Merge branch 'sched/urgent' into sched/core, to avoid conflicts

Signed-off-by: Ingo Molnar <mingo@kernel.org>

33 files changed, 394 insertions, 313 deletions

diff --git a/fs/ocfs2/acl.c b/fs/ocfs2/acl.c
index 555f4cddefe3..7e8282dcea2a 100644
--- a/fs/ocfs2/acl.c
+++ b/fs/ocfs2/acl.c
@@ -205,6 +205,7 @@ static int ocfs2_acl_set_mode(struct inode *inode, struct buffer_head *di_bh,
         di->i_mode = cpu_to_le16(inode->i_mode);
         di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
         di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
 
         ocfs2_journal_dirty(handle, di_bh);
 
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index e2edff38be52..b4deb5f750d9 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -5728,6 +5728,7 @@ int ocfs2_remove_btree_range(struct inode *inode,
         }
 
         ocfs2_et_update_clusters(et, -len);
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
 
         ocfs2_journal_dirty(handle, et->et_root_bh);
 
@@ -6932,6 +6933,7 @@ int ocfs2_convert_inline_data_to_extents(struct inode *inode,
         di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
         spin_unlock(&oi->ip_lock);
 
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
         ocfs2_dinode_new_extent_list(inode, di);
 
         ocfs2_journal_dirty(handle, di_bh);
@@ -7208,6 +7210,7 @@ int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
         di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
         di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
 
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
         ocfs2_journal_dirty(handle, di_bh);
 
 out_commit:
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index aeb44e879c51..d310d12a9adc 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -571,7 +571,6 @@ static void ocfs2_dio_end_io(struct kiocb *iocb,
 {
         struct inode *inode = file_inode(iocb->ki_filp);
         int level;
-        wait_queue_head_t *wq = ocfs2_ioend_wq(inode);
 
         /* this io's submitter should not have unlocked this before we could */
         BUG_ON(!ocfs2_iocb_is_rw_locked(iocb));
@@ -582,10 +581,7 @@ static void ocfs2_dio_end_io(struct kiocb *iocb,
         if (ocfs2_iocb_is_unaligned_aio(iocb)) {
                 ocfs2_iocb_clear_unaligned_aio(iocb);
 
-                if (atomic_dec_and_test(&OCFS2_I(inode)->ip_unaligned_aio) &&
-                    waitqueue_active(wq)) {
-                        wake_up_all(wq);
-                }
+                mutex_unlock(&OCFS2_I(inode)->ip_unaligned_aio);
         }
 
         ocfs2_iocb_clear_rw_locked(iocb);
@@ -2043,6 +2039,7 @@ out_write_size:
         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
         di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
         di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
         ocfs2_journal_dirty(handle, wc->w_di_bh);
 
         ocfs2_commit_trans(osb, handle);
diff --git a/fs/ocfs2/aops.h b/fs/ocfs2/aops.h
index f671e49beb34..6cae155d54df 100644
--- a/fs/ocfs2/aops.h
+++ b/fs/ocfs2/aops.h
@@ -102,9 +102,4 @@ enum ocfs2_iocb_lock_bits {
 #define ocfs2_iocb_is_unaligned_aio(iocb) \
         test_bit(OCFS2_IOCB_UNALIGNED_IO, (unsigned long *)&iocb->private)
 
-#define OCFS2_IOEND_WQ_HASH_SZ  37
-#define ocfs2_ioend_wq(v)   (&ocfs2__ioend_wq[((unsigned long)(v)) %\
-                                            OCFS2_IOEND_WQ_HASH_SZ])
-extern wait_queue_head_t ocfs2__ioend_wq[OCFS2_IOEND_WQ_HASH_SZ];
-
 #endif /* OCFS2_FILE_H */
diff --git a/fs/ocfs2/buffer_head_io.c b/fs/ocfs2/buffer_head_io.c
index 5b704c63a103..1edcb141f639 100644
--- a/fs/ocfs2/buffer_head_io.c
+++ b/fs/ocfs2/buffer_head_io.c
@@ -90,7 +90,6 @@ int ocfs2_write_block(struct ocfs2_super *osb, struct buffer_head *bh,
                  * information for this bh as it's not marked locally
                  * uptodate. */
                 ret = -EIO;
-                put_bh(bh);
                 mlog_errno(ret);
         }
 
@@ -420,7 +419,6 @@ int ocfs2_write_super_or_backup(struct ocfs2_super *osb,
 
         if (!buffer_uptodate(bh)) {
                 ret = -EIO;
-                put_bh(bh);
                 mlog_errno(ret);
         }
 
diff --git a/fs/ocfs2/cluster/sys.c b/fs/ocfs2/cluster/sys.c
index a4b07730b2e1..b7f57271d49c 100644
--- a/fs/ocfs2/cluster/sys.c
+++ b/fs/ocfs2/cluster/sys.c
@@ -41,7 +41,7 @@ static ssize_t version_show(struct kobject *kobj, struct kobj_attribute *attr,
         return snprintf(buf, PAGE_SIZE, "%u\n", O2NM_API_VERSION);
 }
 static struct kobj_attribute attr_version =
-        __ATTR(interface_revision, S_IFREG | S_IRUGO, version_show, NULL);
+        __ATTR(interface_revision, S_IRUGO, version_show, NULL);
 
 static struct attribute *o2cb_attrs[] = {
         &attr_version.attr,
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index 2cd2406b4140..c6b90e670389 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -137,7 +137,7 @@ static int o2net_sys_err_translations[O2NET_ERR_MAX] =
 static void o2net_sc_connect_completed(struct work_struct *work);
 static void o2net_rx_until_empty(struct work_struct *work);
 static void o2net_shutdown_sc(struct work_struct *work);
-static void o2net_listen_data_ready(struct sock *sk, int bytes);
+static void o2net_listen_data_ready(struct sock *sk);
 static void o2net_sc_send_keep_req(struct work_struct *work);
 static void o2net_idle_timer(unsigned long data);
 static void o2net_sc_postpone_idle(struct o2net_sock_container *sc);
@@ -262,17 +262,17 @@ static void o2net_update_recv_stats(struct o2net_sock_container *sc)
 
 #endif /* CONFIG_OCFS2_FS_STATS */
 
-static inline int o2net_reconnect_delay(void)
+static inline unsigned int o2net_reconnect_delay(void)
 {
         return o2nm_single_cluster->cl_reconnect_delay_ms;
 }
 
-static inline int o2net_keepalive_delay(void)
+static inline unsigned int o2net_keepalive_delay(void)
 {
         return o2nm_single_cluster->cl_keepalive_delay_ms;
 }
 
-static inline int o2net_idle_timeout(void)
+static inline unsigned int o2net_idle_timeout(void)
 {
         return o2nm_single_cluster->cl_idle_timeout_ms;
 }
@@ -597,9 +597,9 @@ static void o2net_set_nn_state(struct o2net_node *nn,
 }
 
 /* see o2net_register_callbacks() */
-static void o2net_data_ready(struct sock *sk, int bytes)
+static void o2net_data_ready(struct sock *sk)
 {
-        void (*ready)(struct sock *sk, int bytes);
+        void (*ready)(struct sock *sk);
 
         read_lock(&sk->sk_callback_lock);
         if (sk->sk_user_data) {
@@ -613,7 +613,7 @@ static void o2net_data_ready(struct sock *sk, int bytes)
         }
         read_unlock(&sk->sk_callback_lock);
 
-        ready(sk, bytes);
+        ready(sk);
 }
 
 /* see o2net_register_callbacks() */
@@ -916,57 +916,30 @@ static struct o2net_msg_handler *o2net_handler_get(u32 msg_type, u32 key)
 
 static int o2net_recv_tcp_msg(struct socket *sock, void *data, size_t len)
 {
-        int ret;
-        mm_segment_t oldfs;
-        struct kvec vec = {
-                .iov_len = len,
-                .iov_base = data,
-        };
-        struct msghdr msg = {
-                .msg_iovlen = 1,
-                .msg_iov = (struct iovec *)&vec,
-                .msg_flags = MSG_DONTWAIT,
-        };
-
-        oldfs = get_fs();
-        set_fs(get_ds());
-        ret = sock_recvmsg(sock, &msg, len, msg.msg_flags);
-        set_fs(oldfs);
-
-        return ret;
+        struct kvec vec = { .iov_len = len, .iov_base = data, };
+        struct msghdr msg = { .msg_flags = MSG_DONTWAIT, };
+        return kernel_recvmsg(sock, &msg, &vec, 1, len, msg.msg_flags);
 }
 
 static int o2net_send_tcp_msg(struct socket *sock, struct kvec *vec,
                               size_t veclen, size_t total)
 {
         int ret;
-        mm_segment_t oldfs;
-        struct msghdr msg = {
-                .msg_iov = (struct iovec *)vec,
-                .msg_iovlen = veclen,
-        };
+        struct msghdr msg;
 
         if (sock == NULL) {
                 ret = -EINVAL;
                 goto out;
         }
 
-        oldfs = get_fs();
-        set_fs(get_ds());
-        ret = sock_sendmsg(sock, &msg, total);
-        set_fs(oldfs);
-        if (ret != total) {
-                mlog(ML_ERROR, "sendmsg returned %d instead of %zu\n", ret,
-                     total);
-                if (ret >= 0)
-                        ret = -EPIPE; /* should be smarter, I bet */
-                goto out;
-        }
-
-        ret = 0;
+        ret = kernel_sendmsg(sock, &msg, vec, veclen, total);
+        if (likely(ret == total))
+                return 0;
+        mlog(ML_ERROR, "sendmsg returned %d instead of %zu\n", ret, total);
+        if (ret >= 0)
+                ret = -EPIPE; /* should be smarter, I bet */
 out:
-        if (ret < 0)
-                mlog(0, "returning error: %d\n", ret);
+        mlog(0, "returning error: %d\n", ret);
         return ret;
 }
 
@@ -1953,9 +1926,9 @@ static void o2net_accept_many(struct work_struct *work)
                 cond_resched();
 }
 
-static void o2net_listen_data_ready(struct sock *sk, int bytes)
+static void o2net_listen_data_ready(struct sock *sk)
 {
-        void (*ready)(struct sock *sk, int bytes);
+        void (*ready)(struct sock *sk);
 
         read_lock(&sk->sk_callback_lock);
         ready = sk->sk_user_data;
@@ -1964,18 +1937,29 @@ static void o2net_listen_data_ready(struct sock *sk, int bytes)
                 goto out;
         }
 
-        /* ->sk_data_ready is also called for a newly established child socket
-         * before it has been accepted and the acceptor has set up their
-         * data_ready.. we only want to queue listen work for our listening
-         * socket */
+        /* This callback may called twice when a new connection
+         * is  being established as a child socket inherits everything
+         * from a parent LISTEN socket, including the data_ready cb of
+         * the parent. This leads to a hazard. In o2net_accept_one()
+         * we are still initializing the child socket but have not
+         * changed the inherited data_ready callback yet when
+         * data starts arriving.
+         * We avoid this hazard by checking the state.
+         * For the listening socket,  the state will be TCP_LISTEN; for the new
+         * socket, will be  TCP_ESTABLISHED. Also, in this case,
+         * sk->sk_user_data is not a valid function pointer.
+         */
+
         if (sk->sk_state == TCP_LISTEN) {
-                mlog(ML_TCP, "bytes: %d\n", bytes);
                 queue_work(o2net_wq, &o2net_listen_work);
+        } else {
+                ready = NULL;
         }
 
 out:
         read_unlock(&sk->sk_callback_lock);
-        ready(sk, bytes);
+        if (ready != NULL)
+                ready(sk);
 }
 
 static int o2net_open_listening_sock(__be32 addr, __be16 port)
diff --git a/fs/ocfs2/cluster/tcp_internal.h b/fs/ocfs2/cluster/tcp_internal.h
index 4cbcb65784a3..dc024367110a 100644
--- a/fs/ocfs2/cluster/tcp_internal.h
+++ b/fs/ocfs2/cluster/tcp_internal.h
@@ -165,7 +165,7 @@ struct o2net_sock_container {
 
         /* original handlers for the sockets */
         void                    (*sc_state_change)(struct sock *sk);
-        void                    (*sc_data_ready)(struct sock *sk, int bytes);
+        void                    (*sc_data_ready)(struct sock *sk);
 
         u32                     sc_msg_key;
         u16                     sc_msg_type;
diff --git a/fs/ocfs2/dcache.c b/fs/ocfs2/dcache.c
index 0d3a97d2d5f6..e2e05a106beb 100644
--- a/fs/ocfs2/dcache.c
+++ b/fs/ocfs2/dcache.c
@@ -37,7 +37,6 @@
 #include "dlmglue.h"
 #include "file.h"
 #include "inode.h"
-#include "super.h"
 #include "ocfs2_trace.h"
 
 void ocfs2_dentry_attach_gen(struct dentry *dentry)
@@ -346,52 +345,6 @@ out_attach:
         return ret;
 }
 
-DEFINE_SPINLOCK(dentry_list_lock);
-
-/* We limit the number of dentry locks to drop in one go. We have
- * this limit so that we don't starve other users of ocfs2_wq. */
-#define DL_INODE_DROP_COUNT 64
-
-/* Drop inode references from dentry locks */
-static void __ocfs2_drop_dl_inodes(struct ocfs2_super *osb, int drop_count)
-{
-        struct ocfs2_dentry_lock *dl;
-
-        spin_lock(&dentry_list_lock);
-        while (osb->dentry_lock_list && (drop_count < 0 || drop_count--)) {
-                dl = osb->dentry_lock_list;
-                osb->dentry_lock_list = dl->dl_next;
-                spin_unlock(&dentry_list_lock);
-                iput(dl->dl_inode);
-                kfree(dl);
-                spin_lock(&dentry_list_lock);
-        }
-        spin_unlock(&dentry_list_lock);
-}
-
-void ocfs2_drop_dl_inodes(struct work_struct *work)
-{
-        struct ocfs2_super *osb = container_of(work, struct ocfs2_super,
-                                               dentry_lock_work);
-
-        __ocfs2_drop_dl_inodes(osb, DL_INODE_DROP_COUNT);
-        /*
-         * Don't queue dropping if umount is in progress. We flush the
-         * list in ocfs2_dismount_volume
-         */
-        spin_lock(&dentry_list_lock);
-        if (osb->dentry_lock_list &&
-            !ocfs2_test_osb_flag(osb, OCFS2_OSB_DROP_DENTRY_LOCK_IMMED))
-                queue_work(ocfs2_wq, &osb->dentry_lock_work);
-        spin_unlock(&dentry_list_lock);
-}
-
-/* Flush the whole work queue */
-void ocfs2_drop_all_dl_inodes(struct ocfs2_super *osb)
-{
-        __ocfs2_drop_dl_inodes(osb, -1);
-}
-
 /*
  * ocfs2_dentry_iput() and friends.
  *
@@ -416,24 +369,16 @@ void ocfs2_drop_all_dl_inodes(struct ocfs2_super *osb)
 static void ocfs2_drop_dentry_lock(struct ocfs2_super *osb,
                                    struct ocfs2_dentry_lock *dl)
 {
+        iput(dl->dl_inode);
         ocfs2_simple_drop_lockres(osb, &dl->dl_lockres);
         ocfs2_lock_res_free(&dl->dl_lockres);
-
-        /* We leave dropping of inode reference to ocfs2_wq as that can
-         * possibly lead to inode deletion which gets tricky */
-        spin_lock(&dentry_list_lock);
-        if (!osb->dentry_lock_list &&
-            !ocfs2_test_osb_flag(osb, OCFS2_OSB_DROP_DENTRY_LOCK_IMMED))
-                queue_work(ocfs2_wq, &osb->dentry_lock_work);
-        dl->dl_next = osb->dentry_lock_list;
-        osb->dentry_lock_list = dl;
-        spin_unlock(&dentry_list_lock);
+        kfree(dl);
 }
 
 void ocfs2_dentry_lock_put(struct ocfs2_super *osb,
                            struct ocfs2_dentry_lock *dl)
 {
-        int unlock;
+        int unlock = 0;
 
         BUG_ON(dl->dl_count == 0);
 
diff --git a/fs/ocfs2/dcache.h b/fs/ocfs2/dcache.h
index b79eff709958..55f58892b153 100644
--- a/fs/ocfs2/dcache.h
+++ b/fs/ocfs2/dcache.h
@@ -29,13 +29,8 @@
 extern const struct dentry_operations ocfs2_dentry_ops;
 
 struct ocfs2_dentry_lock {
-        /* Use count of dentry lock */
         unsigned int            dl_count;
-        union {
-                /* Linked list of dentry locks to release */
-                struct ocfs2_dentry_lock *dl_next;
-                u64                     dl_parent_blkno;
-        };
+        u64                     dl_parent_blkno;
 
         /*
          * The ocfs2_dentry_lock keeps an inode reference until
@@ -49,14 +44,9 @@ struct ocfs2_dentry_lock {
 int ocfs2_dentry_attach_lock(struct dentry *dentry, struct inode *inode,
                              u64 parent_blkno);
 
-extern spinlock_t dentry_list_lock;
-
 void ocfs2_dentry_lock_put(struct ocfs2_super *osb,
                            struct ocfs2_dentry_lock *dl);
 
-void ocfs2_drop_dl_inodes(struct work_struct *work);
-void ocfs2_drop_all_dl_inodes(struct ocfs2_super *osb);
-
 struct dentry *ocfs2_find_local_alias(struct inode *inode, u64 parent_blkno,
                                       int skip_unhashed);
 
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index 91a7e85ac8fd..0717662b4aef 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -2957,6 +2957,7 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
                 ocfs2_init_dir_trailer(dir, dirdata_bh, i);
         }
 
+        ocfs2_update_inode_fsync_trans(handle, dir, 1);
         ocfs2_journal_dirty(handle, dirdata_bh);
 
         if (ocfs2_supports_indexed_dirs(osb) && !dx_inline) {
@@ -3005,6 +3006,7 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
         di->i_size = cpu_to_le64(sb->s_blocksize);
         di->i_ctime = di->i_mtime = cpu_to_le64(dir->i_ctime.tv_sec);
         di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(dir->i_ctime.tv_nsec);
+        ocfs2_update_inode_fsync_trans(handle, dir, 1);
 
         /*
          * This should never fail as our extent list is empty and all
@@ -3338,6 +3340,7 @@ do_extend:
         } else {
                 de->rec_len = cpu_to_le16(sb->s_blocksize);
         }
+        ocfs2_update_inode_fsync_trans(handle, dir, 1);
         ocfs2_journal_dirty(handle, new_bh);
 
         dir_i_size += dir->i_sb->s_blocksize;
@@ -3896,6 +3899,7 @@ out_commit:
                 dquot_free_space_nodirty(dir,
                                 ocfs2_clusters_to_bytes(dir->i_sb, 1));
 
+        ocfs2_update_inode_fsync_trans(handle, dir, 1);
         ocfs2_commit_trans(osb, handle);
 
 out:
@@ -4134,6 +4138,7 @@ static int ocfs2_expand_inline_dx_root(struct inode *dir,
                 mlog_errno(ret);
         did_quota = 0;
 
+        ocfs2_update_inode_fsync_trans(handle, dir, 1);
         ocfs2_journal_dirty(handle, dx_root_bh);
 
 out_commit:
@@ -4401,6 +4406,7 @@ static int ocfs2_dx_dir_remove_index(struct inode *dir,
         di->i_dyn_features = cpu_to_le16(OCFS2_I(dir)->ip_dyn_features);
         spin_unlock(&OCFS2_I(dir)->ip_lock);
         di->i_dx_root = cpu_to_le64(0ULL);
+        ocfs2_update_inode_fsync_trans(handle, dir, 1);
 
         ocfs2_journal_dirty(handle, di_bh);
 
diff --git a/fs/ocfs2/dlm/dlmdomain.c b/fs/ocfs2/dlm/dlmdomain.c
index 33660a4a52fa..c973690dc0bc 100644
--- a/fs/ocfs2/dlm/dlmdomain.c
+++ b/fs/ocfs2/dlm/dlmdomain.c
@@ -1123,7 +1123,6 @@ static int dlm_query_region_handler(struct o2net_msg *msg, u32 len,
         struct dlm_ctxt *dlm = NULL;
         char *local = NULL;
         int status = 0;
-        int locked = 0;
 
         qr = (struct dlm_query_region *) msg->buf;
 
@@ -1132,10 +1131,8 @@ static int dlm_query_region_handler(struct o2net_msg *msg, u32 len,
 
         /* buffer used in dlm_mast_regions() */
         local = kmalloc(sizeof(qr->qr_regions), GFP_KERNEL);
-        if (!local) {
-                status = -ENOMEM;
-                goto bail;
-        }
+        if (!local)
+                return -ENOMEM;
 
         status = -EINVAL;
 
@@ -1144,16 +1141,15 @@ static int dlm_query_region_handler(struct o2net_msg *msg, u32 len,
         if (!dlm) {
                 mlog(ML_ERROR, "Node %d queried hb regions on domain %s "
                      "before join domain\n", qr->qr_node, qr->qr_domain);
-                goto bail;
+                goto out_domain_lock;
         }
 
         spin_lock(&dlm->spinlock);
-        locked = 1;
         if (dlm->joining_node != qr->qr_node) {
                 mlog(ML_ERROR, "Node %d queried hb regions on domain %s "
                      "but joining node is %d\n", qr->qr_node, qr->qr_domain,
                      dlm->joining_node);
-                goto bail;
+                goto out_dlm_lock;
         }
 
         /* Support for global heartbeat was added in 1.1 */
@@ -1163,14 +1159,15 @@ static int dlm_query_region_handler(struct o2net_msg *msg, u32 len,
                      "but active dlm protocol is %d.%d\n", qr->qr_node,
                      qr->qr_domain, dlm->dlm_locking_proto.pv_major,
                      dlm->dlm_locking_proto.pv_minor);
-                goto bail;
+                goto out_dlm_lock;
         }
 
         status = dlm_match_regions(dlm, qr, local, sizeof(qr->qr_regions));
 
-bail:
-        if (locked)
-                spin_unlock(&dlm->spinlock);
+out_dlm_lock:
+        spin_unlock(&dlm->spinlock);
+
+out_domain_lock:
         spin_unlock(&dlm_domain_lock);
 
         kfree(local);
@@ -1877,19 +1874,19 @@ static int dlm_join_domain(struct dlm_ctxt *dlm)
                 goto bail;
         }
 
-        status = dlm_debug_init(dlm);
+        status = dlm_launch_thread(dlm);
         if (status < 0) {
                 mlog_errno(status);
                 goto bail;
         }
 
-        status = dlm_launch_thread(dlm);
+        status = dlm_launch_recovery_thread(dlm);
         if (status < 0) {
                 mlog_errno(status);
                 goto bail;
         }
 
-        status = dlm_launch_recovery_thread(dlm);
+        status = dlm_debug_init(dlm);
         if (status < 0) {
                 mlog_errno(status);
                 goto bail;
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index 7035af09cc03..fe29f7978f81 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -537,7 +537,10 @@ master_here:
                 /* success!  see if any other nodes need recovery */
                 mlog(0, "DONE mastering recovery of %s:%u here(this=%u)!\n",
                      dlm->name, dlm->reco.dead_node, dlm->node_num);
-                dlm_reset_recovery(dlm);
+                spin_lock(&dlm->spinlock);
+                __dlm_reset_recovery(dlm);
+                dlm->reco.state &= ~DLM_RECO_STATE_FINALIZE;
+                spin_unlock(&dlm->spinlock);
         }
         dlm_end_recovery(dlm);
 
@@ -695,6 +698,14 @@ static int dlm_remaster_locks(struct dlm_ctxt *dlm, u8 dead_node)
                 if (all_nodes_done) {
                         int ret;
 
+                        /* Set this flag on recovery master to avoid
+                         * a new recovery for another dead node start
+                         * before the recovery is not done. That may
+                         * cause recovery hung.*/
+                        spin_lock(&dlm->spinlock);
+                        dlm->reco.state |= DLM_RECO_STATE_FINALIZE;
+                        spin_unlock(&dlm->spinlock);
+
                         /* all nodes are now in DLM_RECO_NODE_DATA_DONE state
                          * just send a finalize message to everyone and
                          * clean up */
@@ -1750,13 +1761,13 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm,
                                      struct dlm_migratable_lockres *mres)
 {
         struct dlm_migratable_lock *ml;
-        struct list_head *queue;
+        struct list_head *queue, *iter;
         struct list_head *tmpq = NULL;
         struct dlm_lock *newlock = NULL;
         struct dlm_lockstatus *lksb = NULL;
         int ret = 0;
         int i, j, bad;
-        struct dlm_lock *lock = NULL;
+        struct dlm_lock *lock;
         u8 from = O2NM_MAX_NODES;
         unsigned int added = 0;
         __be64 c;
@@ -1791,14 +1802,16 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm,
                         /* MIGRATION ONLY! */
                         BUG_ON(!(mres->flags & DLM_MRES_MIGRATION));
 
+                        lock = NULL;
                         spin_lock(&res->spinlock);
                         for (j = DLM_GRANTED_LIST; j <= DLM_BLOCKED_LIST; j++) {
                                 tmpq = dlm_list_idx_to_ptr(res, j);
-                                list_for_each_entry(lock, tmpq, list) {
-                                        if (lock->ml.cookie != ml->cookie)
-                                                lock = NULL;
-                                        else
+                                list_for_each(iter, tmpq) {
+                                        lock = list_entry(iter,
+                                                  struct dlm_lock, list);
+                                        if (lock->ml.cookie == ml->cookie)
                                                 break;
+                                        lock = NULL;
                                 }
                                 if (lock)
                                         break;
@@ -2882,8 +2895,8 @@ int dlm_finalize_reco_handler(struct o2net_msg *msg, u32 len, void *data,
                                 BUG();
                         }
                         dlm->reco.state &= ~DLM_RECO_STATE_FINALIZE;
+                        __dlm_reset_recovery(dlm);
                         spin_unlock(&dlm->spinlock);
-                        dlm_reset_recovery(dlm);
                         dlm_kick_recovery_thread(dlm);
                         break;
                 default:
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 19986959d149..6bd690b5a061 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -3144,22 +3144,60 @@ out:
         return 0;
 }
 
+static void ocfs2_process_blocked_lock(struct ocfs2_super *osb,
+                                       struct ocfs2_lock_res *lockres);
+
 /* Mark the lockres as being dropped. It will no longer be
  * queued if blocking, but we still may have to wait on it
  * being dequeued from the downconvert thread before we can consider
  * it safe to drop.
  *
  * You can *not* attempt to call cluster_lock on this lockres anymore. */
-void ocfs2_mark_lockres_freeing(struct ocfs2_lock_res *lockres)
+void ocfs2_mark_lockres_freeing(struct ocfs2_super *osb,
+                                struct ocfs2_lock_res *lockres)
 {
         int status;
         struct ocfs2_mask_waiter mw;
-        unsigned long flags;
+        unsigned long flags, flags2;
 
         ocfs2_init_mask_waiter(&mw);
 
         spin_lock_irqsave(&lockres->l_lock, flags);
         lockres->l_flags |= OCFS2_LOCK_FREEING;
+        if (lockres->l_flags & OCFS2_LOCK_QUEUED && current == osb->dc_task) {
+                /*
+                 * We know the downconvert is queued but not in progress
+                 * because we are the downconvert thread and processing
+                 * different lock. So we can just remove the lock from the
+                 * queue. This is not only an optimization but also a way
+                 * to avoid the following deadlock:
+                 *   ocfs2_dentry_post_unlock()
+                 *     ocfs2_dentry_lock_put()
+                 *       ocfs2_drop_dentry_lock()
+                 *         iput()
+                 *           ocfs2_evict_inode()
+                 *             ocfs2_clear_inode()
+                 *               ocfs2_mark_lockres_freeing()
+                 *                 ... blocks waiting for OCFS2_LOCK_QUEUED
+                 *                 since we are the downconvert thread which
+                 *                 should clear the flag.
+                 */
+                spin_unlock_irqrestore(&lockres->l_lock, flags);
+                spin_lock_irqsave(&osb->dc_task_lock, flags2);
+                list_del_init(&lockres->l_blocked_list);
+                osb->blocked_lock_count--;
+                spin_unlock_irqrestore(&osb->dc_task_lock, flags2);
+                /*
+                 * Warn if we recurse into another post_unlock call.  Strictly
+                 * speaking it isn't a problem but we need to be careful if
+                 * that happens (stack overflow, deadlocks, ...) so warn if
+                 * ocfs2 grows a path for which this can happen.
+                 */
+                WARN_ON_ONCE(lockres->l_ops->post_unlock);
+                /* Since the lock is freeing we don't do much in the fn below */
+                ocfs2_process_blocked_lock(osb, lockres);
+                return;
+        }
         while (lockres->l_flags & OCFS2_LOCK_QUEUED) {
                 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_QUEUED, 0);
                 spin_unlock_irqrestore(&lockres->l_lock, flags);
@@ -3180,7 +3218,7 @@ void ocfs2_simple_drop_lockres(struct ocfs2_super *osb,
 {
         int ret;
 
-        ocfs2_mark_lockres_freeing(lockres);
+        ocfs2_mark_lockres_freeing(osb, lockres);
         ret = ocfs2_drop_lock(osb, lockres);
         if (ret)
                 mlog_errno(ret);
diff --git a/fs/ocfs2/dlmglue.h b/fs/ocfs2/dlmglue.h
index 1d596d8c4a4a..d293a22c32c5 100644
--- a/fs/ocfs2/dlmglue.h
+++ b/fs/ocfs2/dlmglue.h
@@ -157,7 +157,8 @@ int ocfs2_refcount_lock(struct ocfs2_refcount_tree *ref_tree, int ex);
 void ocfs2_refcount_unlock(struct ocfs2_refcount_tree *ref_tree, int ex);
 
 
-void ocfs2_mark_lockres_freeing(struct ocfs2_lock_res *lockres);
+void ocfs2_mark_lockres_freeing(struct ocfs2_super *osb,
+                                struct ocfs2_lock_res *lockres);
 void ocfs2_simple_drop_lockres(struct ocfs2_super *osb,
                                struct ocfs2_lock_res *lockres);
 
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 51632c40e896..8970dcf74de5 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -175,9 +175,13 @@ static int ocfs2_sync_file(struct file *file, loff_t start, loff_t end,
                            int datasync)
 {
         int err = 0;
-        journal_t *journal;
         struct inode *inode = file->f_mapping->host;
         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        journal_t *journal = osb->journal->j_journal;
+        int ret;
+        tid_t commit_tid;
+        bool needs_barrier = false;
 
         trace_ocfs2_sync_file(inode, file, file->f_path.dentry,
                               OCFS2_I(inode)->ip_blkno,
@@ -192,29 +196,19 @@ static int ocfs2_sync_file(struct file *file, loff_t start, loff_t end,
         if (err)
                 return err;
 
-        /*
-         * Probably don't need the i_mutex at all in here, just putting it here
-         * to be consistent with how fsync used to be called, someone more
-         * familiar with the fs could possibly remove it.
-         */
-        mutex_lock(&inode->i_mutex);
-        if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) {
-                /*
-                 * We still have to flush drive's caches to get data to the
-                 * platter
-                 */
-                if (osb->s_mount_opt & OCFS2_MOUNT_BARRIER)
-                        blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
-                goto bail;
+        commit_tid = datasync ? oi->i_datasync_tid : oi->i_sync_tid;
+        if (journal->j_flags & JBD2_BARRIER &&
+            !jbd2_trans_will_send_data_barrier(journal, commit_tid))
+                needs_barrier = true;
+        err = jbd2_complete_transaction(journal, commit_tid);
+        if (needs_barrier) {
+                ret = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
+                if (!err)
+                        err = ret;
         }
 
-        journal = osb->journal->j_journal;
-        err = jbd2_journal_force_commit(journal);
-
-bail:
         if (err)
                 mlog_errno(err);
-        mutex_unlock(&inode->i_mutex);
 
         return (err < 0) ? -EIO : 0;
 }
@@ -292,6 +286,7 @@ int ocfs2_update_inode_atime(struct inode *inode,
         inode->i_atime = CURRENT_TIME;
         di->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
         di->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
         ocfs2_journal_dirty(handle, bh);
 
 out_commit:
@@ -341,6 +336,7 @@ int ocfs2_simple_size_update(struct inode *inode,
         if (ret < 0)
                 mlog_errno(ret);
 
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
         ocfs2_commit_trans(osb, handle);
 out:
         return ret;
@@ -435,6 +431,7 @@ static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
         di->i_size = cpu_to_le64(new_i_size);
         di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
         di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
 
         ocfs2_journal_dirty(handle, fe_bh);
 
@@ -650,7 +647,7 @@ restarted_transaction:
                         mlog_errno(status);
                 goto leave;
         }
-
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
         ocfs2_journal_dirty(handle, bh);
 
         spin_lock(&OCFS2_I(inode)->ip_lock);
@@ -743,6 +740,7 @@ static handle_t *ocfs2_zero_start_ordered_transaction(struct inode *inode,
                                       OCFS2_JOURNAL_ACCESS_WRITE);
         if (ret)
                 mlog_errno(ret);
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
 
 out:
         if (ret) {
@@ -840,6 +838,7 @@ static int ocfs2_write_zero_page(struct inode *inode, u64 abs_from,
                 di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
                 di->i_mtime_nsec = di->i_ctime_nsec;
                 ocfs2_journal_dirty(handle, di_bh);
+                ocfs2_update_inode_fsync_trans(handle, inode, 1);
                 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
         }
 
@@ -1344,6 +1343,7 @@ static int __ocfs2_write_remove_suid(struct inode *inode,
 
         di = (struct ocfs2_dinode *) bh->b_data;
         di->i_mode = cpu_to_le16(inode->i_mode);
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
 
         ocfs2_journal_dirty(handle, bh);
 
@@ -1576,6 +1576,7 @@ static int ocfs2_zero_partial_clusters(struct inode *inode,
                 if (ret)
                         mlog_errno(ret);
         }
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
 
         ocfs2_commit_trans(osb, handle);
 out:
@@ -2061,13 +2062,6 @@ out:
         return ret;
 }
 
-static void ocfs2_aiodio_wait(struct inode *inode)
-{
-        wait_queue_head_t *wq = ocfs2_ioend_wq(inode);
-
-        wait_event(*wq, (atomic_read(&OCFS2_I(inode)->ip_unaligned_aio) == 0));
-}
-
 static int ocfs2_is_io_unaligned(struct inode *inode, size_t count, loff_t pos)
 {
         int blockmask = inode->i_sb->s_blocksize - 1;
@@ -2345,10 +2339,8 @@ relock:
                  * Wait on previous unaligned aio to complete before
                  * proceeding.
                  */
-                ocfs2_aiodio_wait(inode);
-
-                /* Mark the iocb as needing a decrement in ocfs2_dio_end_io */
-                atomic_inc(&OCFS2_I(inode)->ip_unaligned_aio);
+                mutex_lock(&OCFS2_I(inode)->ip_unaligned_aio);
+                /* Mark the iocb as needing an unlock in ocfs2_dio_end_io */
                 ocfs2_iocb_set_unaligned_aio(iocb);
         }
 
@@ -2375,15 +2367,18 @@ relock:
 
         if (direct_io) {
                 written = generic_file_direct_write(iocb, iov, &nr_segs, *ppos,
-                                                    ppos, count, ocount);
+                                                    count, ocount);
                 if (written < 0) {
                         ret = written;
                         goto out_dio;
                 }
         } else {
+                struct iov_iter from;
+                iov_iter_init(&from, iov, nr_segs, count, 0);
                 current->backing_dev_info = file->f_mapping->backing_dev_info;
-                written = generic_file_buffered_write(iocb, iov, nr_segs, *ppos,
-                                                      ppos, count, 0);
+                written = generic_perform_write(file, &from, *ppos);
+                if (likely(written >= 0))
+                        iocb->ki_pos = *ppos + written;
                 current->backing_dev_info = NULL;
         }
 
@@ -2428,7 +2423,7 @@ out_dio:
 
         if (unaligned_dio) {
                 ocfs2_iocb_clear_unaligned_aio(iocb);
-                atomic_dec(&OCFS2_I(inode)->ip_unaligned_aio);
+                mutex_unlock(&OCFS2_I(inode)->ip_unaligned_aio);
         }
 
 out:
@@ -2645,7 +2640,16 @@ static loff_t ocfs2_file_llseek(struct file *file, loff_t offset, int whence)
         case SEEK_SET:
                 break;
         case SEEK_END:
-                offset += inode->i_size;
+                /* SEEK_END requires the OCFS2 inode lock for the file
+                 * because it references the file's size.
+                 */
+                ret = ocfs2_inode_lock(inode, NULL, 0);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                offset += i_size_read(inode);
+                ocfs2_inode_unlock(inode, 0);
                 break;
         case SEEK_CUR:
                 if (offset == 0) {
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index f29a90fde619..437de7f768c6 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -130,6 +130,7 @@ struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno, unsigned flags,
         struct inode *inode = NULL;
         struct super_block *sb = osb->sb;
         struct ocfs2_find_inode_args args;
+        journal_t *journal = OCFS2_SB(sb)->journal->j_journal;
 
         trace_ocfs2_iget_begin((unsigned long long)blkno, flags,
                                sysfile_type);
@@ -169,6 +170,32 @@ struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno, unsigned flags,
                 goto bail;
         }
 
+        /*
+         * Set transaction id's of transactions that have to be committed
+         * to finish f[data]sync. We set them to currently running transaction
+         * as we cannot be sure that the inode or some of its metadata isn't
+         * part of the transaction - the inode could have been reclaimed and
+         * now it is reread from disk.
+         */
+        if (journal) {
+                transaction_t *transaction;
+                tid_t tid;
+                struct ocfs2_inode_info *oi = OCFS2_I(inode);
+
+                read_lock(&journal->j_state_lock);
+                if (journal->j_running_transaction)
+                        transaction = journal->j_running_transaction;
+                else
+                        transaction = journal->j_committing_transaction;
+                if (transaction)
+                        tid = transaction->t_tid;
+                else
+                        tid = journal->j_commit_sequence;
+                read_unlock(&journal->j_state_lock);
+                oi->i_sync_tid = tid;
+                oi->i_datasync_tid = tid;
+        }
+
 bail:
         if (!IS_ERR(inode)) {
                 trace_ocfs2_iget_end(inode, 
@@ -804,11 +831,13 @@ static int ocfs2_inode_is_valid_to_delete(struct inode *inode)
                 goto bail;
         }
 
-        /* If we're coming from downconvert_thread we can't go into our own
-         * voting [hello, deadlock city!], so unforuntately we just
-         * have to skip deleting this guy. That's OK though because
-         * the node who's doing the actual deleting should handle it
-         * anyway. */
+        /*
+         * If we're coming from downconvert_thread we can't go into our own
+         * voting [hello, deadlock city!] so we cannot delete the inode. But
+         * since we dropped last inode ref when downconverting dentry lock,
+         * we cannot have the file open and thus the node doing unlink will
+         * take care of deleting the inode.
+         */
         if (current == osb->dc_task)
                 goto bail;
 
@@ -822,12 +851,6 @@ static int ocfs2_inode_is_valid_to_delete(struct inode *inode)
                 goto bail_unlock;
         }
 
-        /* If we have allowd wipe of this inode for another node, it
-         * will be marked here so we can safely skip it. Recovery will
-         * cleanup any inodes we might inadvertently skip here. */
-        if (oi->ip_flags & OCFS2_INODE_SKIP_DELETE)
-                goto bail_unlock;
-
         ret = 1;
 bail_unlock:
         spin_unlock(&oi->ip_lock);
@@ -941,7 +964,7 @@ static void ocfs2_cleanup_delete_inode(struct inode *inode,
                 (unsigned long long)OCFS2_I(inode)->ip_blkno, sync_data);
         if (sync_data)
                 filemap_write_and_wait(inode->i_mapping);
-        truncate_inode_pages(&inode->i_data, 0);
+        truncate_inode_pages_final(&inode->i_data);
 }
 
 static void ocfs2_delete_inode(struct inode *inode)
@@ -960,8 +983,6 @@ static void ocfs2_delete_inode(struct inode *inode)
         if (is_bad_inode(inode) || !OCFS2_I(inode)->ip_blkno)
                 goto bail;
 
-        dquot_initialize(inode);
-
         if (!ocfs2_inode_is_valid_to_delete(inode)) {
                 /* It's probably not necessary to truncate_inode_pages
                  * here but we do it for safety anyway (it will most
@@ -970,6 +991,8 @@ static void ocfs2_delete_inode(struct inode *inode)
                 goto bail;
         }
 
+        dquot_initialize(inode);
+
         /* We want to block signals in delete_inode as the lock and
          * messaging paths may return us -ERESTARTSYS. Which would
          * cause us to exit early, resulting in inodes being orphaned
@@ -1057,6 +1080,7 @@ static void ocfs2_clear_inode(struct inode *inode)
 {
         int status;
         struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 
         clear_inode(inode);
         trace_ocfs2_clear_inode((unsigned long long)oi->ip_blkno,
@@ -1073,9 +1097,9 @@ static void ocfs2_clear_inode(struct inode *inode)
 
         /* Do these before all the other work so that we don't bounce
          * the downconvert thread while waiting to destroy the locks. */
-        ocfs2_mark_lockres_freeing(&oi->ip_rw_lockres);
-        ocfs2_mark_lockres_freeing(&oi->ip_inode_lockres);
-        ocfs2_mark_lockres_freeing(&oi->ip_open_lockres);
+        ocfs2_mark_lockres_freeing(osb, &oi->ip_rw_lockres);
+        ocfs2_mark_lockres_freeing(osb, &oi->ip_inode_lockres);
+        ocfs2_mark_lockres_freeing(osb, &oi->ip_open_lockres);
 
         ocfs2_resv_discard(&OCFS2_SB(inode->i_sb)->osb_la_resmap,
                            &oi->ip_la_data_resv);
@@ -1157,7 +1181,7 @@ void ocfs2_evict_inode(struct inode *inode)
             (OCFS2_I(inode)->ip_flags & OCFS2_INODE_MAYBE_ORPHANED)) {
                 ocfs2_delete_inode(inode);
         } else {
-                truncate_inode_pages(&inode->i_data, 0);
+                truncate_inode_pages_final(&inode->i_data);
         }
         ocfs2_clear_inode(inode);
 }
@@ -1260,6 +1284,7 @@ int ocfs2_mark_inode_dirty(handle_t *handle,
         fe->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
 
         ocfs2_journal_dirty(handle, bh);
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
 leave:
         return status;
 }
diff --git a/fs/ocfs2/inode.h b/fs/ocfs2/inode.h
index 621fc73bf23d..a6c991c0fc98 100644
--- a/fs/ocfs2/inode.h
+++ b/fs/ocfs2/inode.h
@@ -44,7 +44,7 @@ struct ocfs2_inode_info
         struct rw_semaphore             ip_xattr_sem;
 
         /* Number of outstanding AIO's which are not page aligned */
-        atomic_t                        ip_unaligned_aio;
+        struct mutex                    ip_unaligned_aio;
 
         /* These fields are protected by ip_lock */
         spinlock_t                      ip_lock;
@@ -73,6 +73,13 @@ struct ocfs2_inode_info
         u32                             ip_dir_lock_gen;
 
         struct ocfs2_alloc_reservation  ip_la_data_resv;
+
+        /*
+         * Transactions that contain inode's metadata needed to complete
+         * fsync and fdatasync, respectively.
+         */
+        tid_t i_sync_tid;
+        tid_t i_datasync_tid;
 };
 
 /*
@@ -84,8 +91,6 @@ struct ocfs2_inode_info
 #define OCFS2_INODE_BITMAP              0x00000004
 /* This inode has been wiped from disk */
 #define OCFS2_INODE_DELETED             0x00000008
-/* Another node is deleting, so our delete is a nop */
-#define OCFS2_INODE_SKIP_DELETE         0x00000010
 /* Has the inode been orphaned on another node?
  *
  * This hints to ocfs2_drop_inode that it should clear i_nlink before
@@ -100,11 +105,11 @@ struct ocfs2_inode_info
  * rely on ocfs2_delete_inode to sort things out under the proper
  * cluster locks.
  */
-#define OCFS2_INODE_MAYBE_ORPHANED      0x00000020
+#define OCFS2_INODE_MAYBE_ORPHANED      0x00000010
 /* Does someone have the file open O_DIRECT */
-#define OCFS2_INODE_OPEN_DIRECT         0x00000040
+#define OCFS2_INODE_OPEN_DIRECT         0x00000020
 /* Tell the inode wipe code it's not in orphan dir */
-#define OCFS2_INODE_SKIP_ORPHAN_DIR     0x00000080
+#define OCFS2_INODE_SKIP_ORPHAN_DIR     0x00000040
 
 static inline struct ocfs2_inode_info *OCFS2_I(struct inode *inode)
 {
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c
index 8ca3c29accbf..490229f43731 100644
--- a/fs/ocfs2/ioctl.c
+++ b/fs/ocfs2/ioctl.c
@@ -413,11 +413,12 @@ int ocfs2_info_handle_freeinode(struct inode *inode,
                 }
 
                 status = ocfs2_info_scan_inode_alloc(osb, inode_alloc, blkno, oifi, i);
-                if (status < 0)
-                        goto bail;
 
                 iput(inode_alloc);
                 inode_alloc = NULL;
+
+                if (status < 0)
+                        goto bail;
         }
 
         o2info_set_request_filled(&oifi->ifi_req);
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index 44fc3e530c3d..03ea9314fecd 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -2132,12 +2132,6 @@ static int ocfs2_recover_orphans(struct ocfs2_super *osb,
                 iter = oi->ip_next_orphan;
 
                 spin_lock(&oi->ip_lock);
-                /* The remote delete code may have set these on the
-                 * assumption that the other node would wipe them
-                 * successfully.  If they are still in the node's
-                 * orphan dir, we need to reset that state. */
-                oi->ip_flags &= ~(OCFS2_INODE_DELETED|OCFS2_INODE_SKIP_DELETE);
-
                 /* Set the proper information to get us going into
                  * ocfs2_delete_inode. */
                 oi->ip_flags |= OCFS2_INODE_MAYBE_ORPHANED;
diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
index 9ff4e8cf9d97..7f8cde94abfe 100644
--- a/fs/ocfs2/journal.h
+++ b/fs/ocfs2/journal.h
@@ -626,4 +626,15 @@ static inline int ocfs2_begin_ordered_truncate(struct inode *inode,
                                 new_size);
 }
 
+static inline void ocfs2_update_inode_fsync_trans(handle_t *handle,
+                                                  struct inode *inode,
+                                                  int datasync)
+{
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+
+        oi->i_sync_tid = handle->h_transaction->t_tid;
+        if (datasync)
+                oi->i_datasync_tid = handle->h_transaction->t_tid;
+}
+
 #endif /* OCFS2_JOURNAL_H */
diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c
index e57c804069ea..6b6d092b0998 100644
--- a/fs/ocfs2/locks.c
+++ b/fs/ocfs2/locks.c
@@ -82,6 +82,8 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode,
         }
 
         ret = flock_lock_file_wait(file, fl);
+        if (ret)
+                ocfs2_file_unlock(file);
 
 out:
         mutex_unlock(&fp->fp_mutex);
diff --git a/fs/ocfs2/move_extents.c b/fs/ocfs2/move_extents.c
index 64c304d668f0..599eb4c4c8be 100644
--- a/fs/ocfs2/move_extents.c
+++ b/fs/ocfs2/move_extents.c
@@ -151,6 +151,7 @@ static int __ocfs2_move_extent(handle_t *handle,
                                                         old_blkno, len);
         }
 
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
 out:
         ocfs2_free_path(path);
         return ret;
@@ -690,8 +691,11 @@ static int ocfs2_move_extent(struct ocfs2_move_extents_context *context,
 
         ret = ocfs2_block_group_set_bits(handle, gb_inode, gd, gd_bh,
                                          goal_bit, len);
-        if (ret)
+        if (ret) {
+                ocfs2_rollback_alloc_dinode_counts(gb_inode, gb_bh, len,
+                                               le16_to_cpu(gd->bg_chain));
                 mlog_errno(ret);
+        }
 
         /*
          * Here we should write the new page out first if we are
@@ -957,6 +961,7 @@ static int ocfs2_move_extents(struct ocfs2_move_extents_context *context)
         inode->i_ctime = CURRENT_TIME;
         di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
         di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
 
         ocfs2_journal_dirty(handle, di_bh);
 
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 3683643f3f0e..2060fc398445 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -450,7 +450,6 @@ leave:
 
         brelse(new_fe_bh);
         brelse(parent_fe_bh);
-        kfree(si.name);
         kfree(si.value);
 
         ocfs2_free_dir_lookup_result(&lookup);
@@ -495,6 +494,7 @@ static int __ocfs2_mknod_locked(struct inode *dir,
         struct ocfs2_dinode *fe = NULL;
         struct ocfs2_extent_list *fel;
         u16 feat;
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
 
         *new_fe_bh = NULL;
 
@@ -576,8 +576,8 @@ static int __ocfs2_mknod_locked(struct inode *dir,
                         mlog_errno(status);
         }
 
-        status = 0; /* error in ocfs2_create_new_inode_locks is not
-                     * critical */
+        oi->i_sync_tid = handle->h_transaction->t_tid;
+        oi->i_datasync_tid = handle->h_transaction->t_tid;
 
 leave:
         if (status < 0) {
@@ -1855,7 +1855,6 @@ bail:
 
         brelse(new_fe_bh);
         brelse(parent_fe_bh);
-        kfree(si.name);
         kfree(si.value);
         ocfs2_free_dir_lookup_result(&lookup);
         if (inode_ac)
@@ -2481,6 +2480,7 @@ int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
         di->i_orphaned_slot = 0;
         set_nlink(inode, 1);
         ocfs2_set_links_count(di, inode->i_nlink);
+        ocfs2_update_inode_fsync_trans(handle, inode, 1);
         ocfs2_journal_dirty(handle, di_bh);
 
         status = ocfs2_add_entry(handle, dentry, inode,
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h
index 553f53cc73ae..8d64a97a9d5e 100644
--- a/fs/ocfs2/ocfs2.h
+++ b/fs/ocfs2/ocfs2.h
@@ -30,6 +30,7 @@
 #include <linux/sched.h>
 #include <linux/wait.h>
 #include <linux/list.h>
+#include <linux/llist.h>
 #include <linux/rbtree.h>
 #include <linux/workqueue.h>
 #include <linux/kref.h>
@@ -274,19 +275,16 @@ enum ocfs2_mount_options
         OCFS2_MOUNT_HB_GLOBAL = 1 << 14, /* Global heartbeat */
 };
 
-#define OCFS2_OSB_SOFT_RO                       0x0001
-#define OCFS2_OSB_HARD_RO                       0x0002
-#define OCFS2_OSB_ERROR_FS                      0x0004
-#define OCFS2_OSB_DROP_DENTRY_LOCK_IMMED        0x0008
-
-#define OCFS2_DEFAULT_ATIME_QUANTUM             60
+#define OCFS2_OSB_SOFT_RO       0x0001
+#define OCFS2_OSB_HARD_RO       0x0002
+#define OCFS2_OSB_ERROR_FS      0x0004
+#define OCFS2_DEFAULT_ATIME_QUANTUM     60
 
 struct ocfs2_journal;
 struct ocfs2_slot_info;
 struct ocfs2_recovery_map;
 struct ocfs2_replay_map;
 struct ocfs2_quota_recovery;
-struct ocfs2_dentry_lock;
 struct ocfs2_super
 {
         struct task_struct *commit_task;
@@ -414,10 +412,9 @@ struct ocfs2_super
         struct list_head blocked_lock_list;
         unsigned long blocked_lock_count;
 
-        /* List of dentry locks to release. Anyone can add locks to
-         * the list, ocfs2_wq processes the list  */
-        struct ocfs2_dentry_lock *dentry_lock_list;
-        struct work_struct dentry_lock_work;
+        /* List of dquot structures to drop last reference to */
+        struct llist_head dquot_drop_list;
+        struct work_struct dquot_drop_work;
 
         wait_queue_head_t               osb_mount_event;
 
@@ -449,6 +446,8 @@ struct ocfs2_super
         /* rb tree root for refcount lock. */
         struct rb_root  osb_rf_lock_tree;
         struct ocfs2_refcount_tree *osb_ref_tree_lru;
+
+        struct mutex system_file_mutex;
 };
 
 #define OCFS2_SB(sb)        ((struct ocfs2_super *)(sb)->s_fs_info)
@@ -579,18 +578,6 @@ static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb,
         spin_unlock(&osb->osb_lock);
 }
 
-
-static inline unsigned long  ocfs2_test_osb_flag(struct ocfs2_super *osb,
-                                                 unsigned long flag)
-{
-        unsigned long ret;
-
-        spin_lock(&osb->osb_lock);
-        ret = osb->osb_flags & flag;
-        spin_unlock(&osb->osb_lock);
-        return ret;
-}
-
 static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb,
                                      int hard)
 {
diff --git a/fs/ocfs2/quota.h b/fs/ocfs2/quota.h
index d5ab56cbe5c5..f266d67df3c6 100644
--- a/fs/ocfs2/quota.h
+++ b/fs/ocfs2/quota.h
@@ -28,6 +28,7 @@ struct ocfs2_dquot {
         unsigned int dq_use_count;      /* Number of nodes having reference to this entry in global quota file */
         s64 dq_origspace;       /* Last globally synced space usage */
         s64 dq_originodes;      /* Last globally synced inode usage */
+        struct llist_node list; /* Member of list of dquots to drop */
 };
 
 /* Description of one chunk to recover in memory */
@@ -110,6 +111,7 @@ int ocfs2_read_quota_phys_block(struct inode *inode, u64 p_block,
 int ocfs2_create_local_dquot(struct dquot *dquot);
 int ocfs2_local_release_dquot(handle_t *handle, struct dquot *dquot);
 int ocfs2_local_write_dquot(struct dquot *dquot);
+void ocfs2_drop_dquot_refs(struct work_struct *work);
 
 extern const struct dquot_operations ocfs2_quota_operations;
 extern struct quota_format_type ocfs2_quota_format;
diff --git a/fs/ocfs2/quota_global.c b/fs/ocfs2/quota_global.c
index d7b5108789e2..b990a62cff50 100644
--- a/fs/ocfs2/quota_global.c
+++ b/fs/ocfs2/quota_global.c
@@ -10,6 +10,7 @@
 #include <linux/jiffies.h>
 #include <linux/writeback.h>
 #include <linux/workqueue.h>
+#include <linux/llist.h>
 
 #include <cluster/masklog.h>
 
@@ -679,6 +680,27 @@ static int ocfs2_calc_qdel_credits(struct super_block *sb, int type)
                OCFS2_INODE_UPDATE_CREDITS;
 }
 
+void ocfs2_drop_dquot_refs(struct work_struct *work)
+{
+        struct ocfs2_super *osb = container_of(work, struct ocfs2_super,
+                                               dquot_drop_work);
+        struct llist_node *list;
+        struct ocfs2_dquot *odquot, *next_odquot;
+
+        list = llist_del_all(&osb->dquot_drop_list);
+        llist_for_each_entry_safe(odquot, next_odquot, list, list) {
+                /* Drop the reference we acquired in ocfs2_dquot_release() */
+                dqput(&odquot->dq_dquot);
+        }
+}
+
+/*
+ * Called when the last reference to dquot is dropped. If we are called from
+ * downconvert thread, we cannot do all the handling here because grabbing
+ * quota lock could deadlock (the node holding the quota lock could need some
+ * other cluster lock to proceed but with blocked downconvert thread we cannot
+ * release any lock).
+ */
 static int ocfs2_release_dquot(struct dquot *dquot)
 {
         handle_t *handle;
@@ -694,6 +716,19 @@ static int ocfs2_release_dquot(struct dquot *dquot)
         /* Check whether we are not racing with some other dqget() */
         if (atomic_read(&dquot->dq_count) > 1)
                 goto out;
+        /* Running from downconvert thread? Postpone quota processing to wq */
+        if (current == osb->dc_task) {
+                /*
+                 * Grab our own reference to dquot and queue it for delayed
+                 * dropping.  Quota code rechecks after calling
+                 * ->release_dquot() and won't free dquot structure.
+                 */
+                dqgrab(dquot);
+                /* First entry on list -> queue work */
+                if (llist_add(&OCFS2_DQUOT(dquot)->list, &osb->dquot_drop_list))
+                        queue_work(ocfs2_wq, &osb->dquot_drop_work);
+                goto out;
+        }
         status = ocfs2_lock_global_qf(oinfo, 1);
         if (status < 0)
                 goto out;
diff --git a/fs/ocfs2/stackglue.c b/fs/ocfs2/stackglue.c
index ca5ce14cbddc..83f1a665ae97 100644
--- a/fs/ocfs2/stackglue.c
+++ b/fs/ocfs2/stackglue.c
@@ -496,7 +496,7 @@ static ssize_t ocfs2_max_locking_protocol_show(struct kobject *kobj,
 }
 
 static struct kobj_attribute ocfs2_attr_max_locking_protocol =
-        __ATTR(max_locking_protocol, S_IFREG | S_IRUGO,
+        __ATTR(max_locking_protocol, S_IRUGO,
                ocfs2_max_locking_protocol_show, NULL);
 
 static ssize_t ocfs2_loaded_cluster_plugins_show(struct kobject *kobj,
@@ -528,7 +528,7 @@ static ssize_t ocfs2_loaded_cluster_plugins_show(struct kobject *kobj,
 }
 
 static struct kobj_attribute ocfs2_attr_loaded_cluster_plugins =
-        __ATTR(loaded_cluster_plugins, S_IFREG | S_IRUGO,
+        __ATTR(loaded_cluster_plugins, S_IRUGO,
                ocfs2_loaded_cluster_plugins_show, NULL);
 
 static ssize_t ocfs2_active_cluster_plugin_show(struct kobject *kobj,
@@ -550,7 +550,7 @@ static ssize_t ocfs2_active_cluster_plugin_show(struct kobject *kobj,
 }
 
 static struct kobj_attribute ocfs2_attr_active_cluster_plugin =
-        __ATTR(active_cluster_plugin, S_IFREG | S_IRUGO,
+        __ATTR(active_cluster_plugin, S_IRUGO,
                ocfs2_active_cluster_plugin_show, NULL);
 
 static ssize_t ocfs2_cluster_stack_show(struct kobject *kobj,
@@ -599,15 +599,29 @@ static ssize_t ocfs2_cluster_stack_store(struct kobject *kobj,
 
 
 static struct kobj_attribute ocfs2_attr_cluster_stack =
-        __ATTR(cluster_stack, S_IFREG | S_IRUGO | S_IWUSR,
+        __ATTR(cluster_stack, S_IRUGO | S_IWUSR,
                ocfs2_cluster_stack_show,
                ocfs2_cluster_stack_store);
 
+
+
+static ssize_t ocfs2_dlm_recover_show(struct kobject *kobj,
+                                        struct kobj_attribute *attr,
+                                        char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "1\n");
+}
+
+static struct kobj_attribute ocfs2_attr_dlm_recover_support =
+        __ATTR(dlm_recover_callback_support, S_IRUGO,
+               ocfs2_dlm_recover_show, NULL);
+
 static struct attribute *ocfs2_attrs[] = {
         &ocfs2_attr_max_locking_protocol.attr,
         &ocfs2_attr_loaded_cluster_plugins.attr,
         &ocfs2_attr_active_cluster_plugin.attr,
         &ocfs2_attr_cluster_stack.attr,
+        &ocfs2_attr_dlm_recover_support.attr,
         NULL,
 };
 
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index 47ae2663a6f5..0cb889a17ae1 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -771,6 +771,7 @@ static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
         spin_unlock(&OCFS2_I(alloc_inode)->ip_lock);
         i_size_write(alloc_inode, le64_to_cpu(fe->i_size));
         alloc_inode->i_blocks = ocfs2_inode_sector_count(alloc_inode);
+        ocfs2_update_inode_fsync_trans(handle, alloc_inode, 0);
 
         status = 0;
 
@@ -1607,6 +1608,21 @@ out:
         return ret;
 }
 
+void ocfs2_rollback_alloc_dinode_counts(struct inode *inode,
+                                       struct buffer_head *di_bh,
+                                       u32 num_bits,
+                                       u16 chain)
+{
+        u32 tmp_used;
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
+        struct ocfs2_chain_list *cl;
+
+        cl = (struct ocfs2_chain_list *)&di->id2.i_chain;
+        tmp_used = le32_to_cpu(di->id1.bitmap1.i_used);
+        di->id1.bitmap1.i_used = cpu_to_le32(tmp_used - num_bits);
+        le32_add_cpu(&cl->cl_recs[chain].c_free, num_bits);
+}
+
 static int ocfs2_bg_discontig_fix_by_rec(struct ocfs2_suballoc_result *res,
                                          struct ocfs2_extent_rec *rec,
                                          struct ocfs2_chain_list *cl)
@@ -1707,8 +1723,12 @@ static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
 
         ret = ocfs2_block_group_set_bits(handle, alloc_inode, gd, group_bh,
                                          res->sr_bit_offset, res->sr_bits);
-        if (ret < 0)
+        if (ret < 0) {
+                ocfs2_rollback_alloc_dinode_counts(alloc_inode, ac->ac_bh,
+                                               res->sr_bits,
+                                               le16_to_cpu(gd->bg_chain));
                 mlog_errno(ret);
+        }
 
 out_loc_only:
         *bits_left = le16_to_cpu(gd->bg_free_bits_count);
@@ -1838,6 +1858,8 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
                                             res->sr_bit_offset,
                                             res->sr_bits);
         if (status < 0) {
+                ocfs2_rollback_alloc_dinode_counts(alloc_inode,
+                                        ac->ac_bh, res->sr_bits, chain);
                 mlog_errno(status);
                 goto bail;
         }
@@ -2091,7 +2113,7 @@ int ocfs2_find_new_inode_loc(struct inode *dir,
 
         ac->ac_find_loc_priv = res;
         *fe_blkno = res->sr_blkno;
-
+        ocfs2_update_inode_fsync_trans(handle, dir, 0);
 out:
         if (handle)
                 ocfs2_commit_trans(OCFS2_SB(dir->i_sb), handle);
@@ -2149,6 +2171,8 @@ int ocfs2_claim_new_inode_at_loc(handle_t *handle,
                                          res->sr_bit_offset,
                                          res->sr_bits);
         if (ret < 0) {
+                ocfs2_rollback_alloc_dinode_counts(ac->ac_inode,
+                                               ac->ac_bh, res->sr_bits, chain);
                 mlog_errno(ret);
                 goto out;
         }
@@ -2870,6 +2894,7 @@ int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res)
         status = ocfs2_inode_lock(inode_alloc_inode, &alloc_bh, 0);
         if (status < 0) {
                 mutex_unlock(&inode_alloc_inode->i_mutex);
+                iput(inode_alloc_inode);
                 mlog(ML_ERROR, "lock on alloc inode on slot %u failed %d\n",
                      (u32)suballoc_slot, status);
                 goto bail;
diff --git a/fs/ocfs2/suballoc.h b/fs/ocfs2/suballoc.h
index 218d8036b3e7..2d2501767c0c 100644
--- a/fs/ocfs2/suballoc.h
+++ b/fs/ocfs2/suballoc.h
@@ -91,6 +91,10 @@ int ocfs2_alloc_dinode_update_counts(struct inode *inode,
                          struct buffer_head *di_bh,
                          u32 num_bits,
                          u16 chain);
+void ocfs2_rollback_alloc_dinode_counts(struct inode *inode,
+                         struct buffer_head *di_bh,
+                         u32 num_bits,
+                         u16 chain);
 int ocfs2_block_group_set_bits(handle_t *handle,
                          struct inode *alloc_inode,
                          struct ocfs2_group_desc *bg,
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 49d84f80f36c..a7cdd56f4c79 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -561,6 +561,9 @@ static struct inode *ocfs2_alloc_inode(struct super_block *sb)
         if (!oi)
                 return NULL;
 
+        oi->i_sync_tid = 0;
+        oi->i_datasync_tid = 0;
+
         jbd2_journal_init_jbd_inode(&oi->ip_jinode, &oi->vfs_inode);
         return &oi->vfs_inode;
 }
@@ -631,6 +634,8 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
         struct ocfs2_super *osb = OCFS2_SB(sb);
         u32 tmp;
 
+        sync_filesystem(sb);
+
         if (!ocfs2_parse_options(sb, data, &parsed_options, 1) ||
             !ocfs2_check_set_options(sb, &parsed_options)) {
                 ret = -EINVAL;
@@ -1238,30 +1243,11 @@ static struct dentry *ocfs2_mount(struct file_system_type *fs_type,
         return mount_bdev(fs_type, flags, dev_name, data, ocfs2_fill_super);
 }
 
-static void ocfs2_kill_sb(struct super_block *sb)
-{
-        struct ocfs2_super *osb = OCFS2_SB(sb);
-
-        /* Failed mount? */
-        if (!osb || atomic_read(&osb->vol_state) == VOLUME_DISABLED)
-                goto out;
-
-        /* Prevent further queueing of inode drop events */
-        spin_lock(&dentry_list_lock);
-        ocfs2_set_osb_flag(osb, OCFS2_OSB_DROP_DENTRY_LOCK_IMMED);
-        spin_unlock(&dentry_list_lock);
-        /* Wait for work to finish and/or remove it */
-        cancel_work_sync(&osb->dentry_lock_work);
-out:
-        kill_block_super(sb);
-}
-
 static struct file_system_type ocfs2_fs_type = {
         .owner          = THIS_MODULE,
         .name           = "ocfs2",
         .mount          = ocfs2_mount,
-        .kill_sb        = ocfs2_kill_sb,
-
+        .kill_sb        = kill_block_super,
         .fs_flags       = FS_REQUIRES_DEV|FS_RENAME_DOES_D_MOVE,
         .next           = NULL
 };
@@ -1612,14 +1598,9 @@ static int ocfs2_show_options(struct seq_file *s, struct dentry *root)
         return 0;
 }
 
-wait_queue_head_t ocfs2__ioend_wq[OCFS2_IOEND_WQ_HASH_SZ];
-
 static int __init ocfs2_init(void)
 {
-        int status, i;
-
-        for (i = 0; i < OCFS2_IOEND_WQ_HASH_SZ; i++)
-                init_waitqueue_head(&ocfs2__ioend_wq[i]);
+        int status;
 
         status = init_ocfs2_uptodate_cache();
         if (status < 0)
@@ -1761,7 +1742,7 @@ static void ocfs2_inode_init_once(void *data)
         ocfs2_extent_map_init(&oi->vfs_inode);
         INIT_LIST_HEAD(&oi->ip_io_markers);
         oi->ip_dir_start_lookup = 0;
-        atomic_set(&oi->ip_unaligned_aio, 0);
+        mutex_init(&oi->ip_unaligned_aio);
         init_rwsem(&oi->ip_alloc_sem);
         init_rwsem(&oi->ip_xattr_sem);
         mutex_init(&oi->ip_io_mutex);
@@ -1932,17 +1913,16 @@ static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err)
 
         debugfs_remove(osb->osb_ctxt);
 
-        /*
-         * Flush inode dropping work queue so that deletes are
-         * performed while the filesystem is still working
-         */
-        ocfs2_drop_all_dl_inodes(osb);
-
         /* Orphan scan should be stopped as early as possible */
         ocfs2_orphan_scan_stop(osb);
 
         ocfs2_disable_quotas(osb);
 
+        /* All dquots should be freed by now */
+        WARN_ON(!llist_empty(&osb->dquot_drop_list));
+        /* Wait for worker to be done with the work structure in osb */
+        cancel_work_sync(&osb->dquot_drop_work);
+
         ocfs2_shutdown_local_alloc(osb);
 
         /* This will disable recovery and flush any recovery work. */
@@ -2077,7 +2057,6 @@ static int ocfs2_initialize_super(struct super_block *sb,
         struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;
         struct inode *inode = NULL;
         struct ocfs2_journal *journal;
-        __le32 uuid_net_key;
         struct ocfs2_super *osb;
         u64 total_blocks;
 
@@ -2123,6 +2102,8 @@ static int ocfs2_initialize_super(struct super_block *sb,
         spin_lock_init(&osb->osb_xattr_lock);
         ocfs2_init_steal_slots(osb);
 
+        mutex_init(&osb->system_file_mutex);
+
         atomic_set(&osb->alloc_stats.moves, 0);
         atomic_set(&osb->alloc_stats.local_data, 0);
         atomic_set(&osb->alloc_stats.bitmap_data, 0);
@@ -2276,8 +2257,8 @@ static int ocfs2_initialize_super(struct super_block *sb,
         INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery);
         journal->j_state = OCFS2_JOURNAL_FREE;
 
-        INIT_WORK(&osb->dentry_lock_work, ocfs2_drop_dl_inodes);
-        osb->dentry_lock_list = NULL;
+        INIT_WORK(&osb->dquot_drop_work, ocfs2_drop_dquot_refs);
+        init_llist_head(&osb->dquot_drop_list);
 
         /* get some pseudo constants for clustersize bits */
         osb->s_clustersize_bits =
@@ -2311,8 +2292,6 @@ static int ocfs2_initialize_super(struct super_block *sb,
                 goto bail;
         }
 
-        memcpy(&uuid_net_key, di->id2.i_super.s_uuid, sizeof(uuid_net_key));
-
         strncpy(osb->vol_label, di->id2.i_super.s_label, 63);
         osb->vol_label[63] = '\0';
         osb->root_blkno = le64_to_cpu(di->id2.i_super.s_root_blkno);
diff --git a/fs/ocfs2/sysfile.c b/fs/ocfs2/sysfile.c
index f053688d22a3..af155c183123 100644
--- a/fs/ocfs2/sysfile.c
+++ b/fs/ocfs2/sysfile.c
@@ -113,9 +113,11 @@ struct inode *ocfs2_get_system_file_inode(struct ocfs2_super *osb,
         } else
                 arr = get_local_system_inode(osb, type, slot);
 
+        mutex_lock(&osb->system_file_mutex);
         if (arr && ((inode = *arr) != NULL)) {
                 /* get a ref in addition to the array ref */
                 inode = igrab(inode);
+                mutex_unlock(&osb->system_file_mutex);
                 BUG_ON(!inode);
 
                 return inode;
@@ -129,6 +131,7 @@ struct inode *ocfs2_get_system_file_inode(struct ocfs2_super *osb,
                 *arr = igrab(inode);
                 BUG_ON(!*arr);
         }
+        mutex_unlock(&osb->system_file_mutex);
         return inode;
 }
 
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index 185fa3b7f962..016f01df3825 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -369,7 +369,7 @@ static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket *bucket)
  * them fully.
  */
 static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
-                                   u64 xb_blkno)
+                                   u64 xb_blkno, int new)
 {
         int i, rc = 0;
 
@@ -383,9 +383,16 @@ static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
                 }
 
                 if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
-                                           bucket->bu_bhs[i]))
-                        ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
-                                                      bucket->bu_bhs[i]);
+                                           bucket->bu_bhs[i])) {
+                        if (new)
+                                ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
+                                                              bucket->bu_bhs[i]);
+                        else {
+                                set_buffer_uptodate(bucket->bu_bhs[i]);
+                                ocfs2_set_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
+                                                          bucket->bu_bhs[i]);
+                        }
+                }
         }
 
         if (rc)
@@ -2602,6 +2609,7 @@ int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
         oi->ip_dyn_features &= ~(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL);
         di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
         spin_unlock(&oi->ip_lock);
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
 
         ocfs2_journal_dirty(handle, di_bh);
 out_commit:
@@ -3200,8 +3208,15 @@ meta_guess:
                         clusters_add += 1;
                 }
         } else {
-                meta_add += 1;
                 credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
+                if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
+                        struct ocfs2_extent_list *el = &def_xv.xv.xr_list;
+                        meta_add += ocfs2_extend_meta_needed(el);
+                        credits += ocfs2_calc_extend_credits(inode->i_sb,
+                                                             el);
+                } else {
+                        meta_add += 1;
+                }
         }
 out:
         if (clusters_need)
@@ -3614,6 +3629,7 @@ int ocfs2_xattr_set(struct inode *inode,
         }
 
         ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
+        ocfs2_update_inode_fsync_trans(ctxt.handle, inode, 0);
 
         ocfs2_commit_trans(osb, ctxt.handle);
 
@@ -4294,7 +4310,7 @@ static int ocfs2_xattr_create_index_block(struct inode *inode,
 
         trace_ocfs2_xattr_create_index_block((unsigned long long)blkno);
 
-        ret = ocfs2_init_xattr_bucket(xs->bucket, blkno);
+        ret = ocfs2_init_xattr_bucket(xs->bucket, blkno, 1);
         if (ret) {
                 mlog_errno(ret);
                 goto out;
@@ -4638,7 +4654,7 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
          * Even if !new_bucket_head, we're overwriting t_bucket.  Thus,
          * there's no need to read it.
          */
-        ret = ocfs2_init_xattr_bucket(t_bucket, new_blk);
+        ret = ocfs2_init_xattr_bucket(t_bucket, new_blk, new_bucket_head);
         if (ret) {
                 mlog_errno(ret);
                 goto out;
@@ -4804,7 +4820,7 @@ static int ocfs2_cp_xattr_bucket(struct inode *inode,
          * Even if !t_is_new, we're overwriting t_bucket.  Thus,
          * there's no need to read it.
          */
-        ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno);
+        ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno, t_is_new);
         if (ret)
                 goto out;
 
@@ -5476,6 +5492,7 @@ static int ocfs2_rm_xattr_cluster(struct inode *inode,
         ret = ocfs2_truncate_log_append(osb, handle, blkno, len);
         if (ret)
                 mlog_errno(ret);
+        ocfs2_update_inode_fsync_trans(handle, inode, 0);
 
 out_commit:
         ocfs2_commit_trans(osb, handle);
@@ -6830,7 +6847,7 @@ static int ocfs2_reflink_xattr_bucket(handle_t *handle,
                         break;
                 }
 
-                ret = ocfs2_init_xattr_bucket(args->new_bucket, new_blkno);
+                ret = ocfs2_init_xattr_bucket(args->new_bucket, new_blkno, 1);
                 if (ret) {
                         mlog_errno(ret);
                         break;