Merge remote-tracking branch 'linus/master' into testing

20 files changed, 189 insertions, 277 deletions

diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index b8a9d87231b1..17e6bdde96c5 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -5655,7 +5655,7 @@ int ocfs2_remove_btree_range(struct inode *inode,
                                                &ref_tree, NULL);
                 if (ret) {
                         mlog_errno(ret);
-                        goto out;
+                        goto bail;
                 }
 
                 ret = ocfs2_prepare_refcount_change_for_del(inode,
@@ -5666,7 +5666,7 @@ int ocfs2_remove_btree_range(struct inode *inode,
                                                             &extra_blocks);
                 if (ret < 0) {
                         mlog_errno(ret);
-                        goto out;
+                        goto bail;
                 }
         }
 
@@ -5674,7 +5674,7 @@ int ocfs2_remove_btree_range(struct inode *inode,
                                                  extra_blocks);
         if (ret) {
                 mlog_errno(ret);
-                return ret;
+                goto bail;
         }
 
         mutex_lock(&tl_inode->i_mutex);
@@ -5734,7 +5734,7 @@ out_commit:
         ocfs2_commit_trans(osb, handle);
 out:
         mutex_unlock(&tl_inode->i_mutex);
-
+bail:
         if (meta_ac)
                 ocfs2_free_alloc_context(meta_ac);
 
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 20dfec72e903..2abf97b2a592 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -603,11 +603,12 @@ static void ocfs2_dio_end_io(struct kiocb *iocb,
  * from ext3.  PageChecked() bits have been removed as OCFS2 does not
  * do journalled data.
  */
-static void ocfs2_invalidatepage(struct page *page, unsigned long offset)
+static void ocfs2_invalidatepage(struct page *page, unsigned int offset,
+                                 unsigned int length)
 {
         journal_t *journal = OCFS2_SB(page->mapping->host->i_sb)->journal->j_journal;
 
-        jbd2_journal_invalidatepage(journal, page, offset);
+        jbd2_journal_invalidatepage(journal, page, offset, length);
 }
 
 static int ocfs2_releasepage(struct page *page, gfp_t wait)
@@ -1756,7 +1757,7 @@ try_again:
                 goto out;
         } else if (ret == 1) {
                 clusters_need = wc->w_clen;
-                ret = ocfs2_refcount_cow(inode, filp, di_bh,
+                ret = ocfs2_refcount_cow(inode, di_bh,
                                          wc->w_cpos, wc->w_clen, UINT_MAX);
                 if (ret) {
                         mlog_errno(ret);
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 42252bf64b51..5c1c864e81cc 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -176,7 +176,7 @@ static void o2hb_dead_threshold_set(unsigned int threshold)
         }
 }
 
-static int o2hb_global_hearbeat_mode_set(unsigned int hb_mode)
+static int o2hb_global_heartbeat_mode_set(unsigned int hb_mode)
 {
         int ret = -1;
 
@@ -500,7 +500,7 @@ static int o2hb_issue_node_write(struct o2hb_region *reg,
         }
 
         atomic_inc(&write_wc->wc_num_reqs);
-        submit_bio(WRITE, bio);
+        submit_bio(WRITE_SYNC, bio);
 
         status = 0;
 bail:
@@ -2271,7 +2271,7 @@ ssize_t o2hb_heartbeat_group_mode_store(struct o2hb_heartbeat_group *group,
                 if (strnicmp(page, o2hb_heartbeat_mode_desc[i], len))
                         continue;
 
-                ret = o2hb_global_hearbeat_mode_set(i);
+                ret = o2hb_global_heartbeat_mode_set(i);
                 if (!ret)
                         printk(KERN_NOTICE "o2hb: Heartbeat mode set to %s\n",
                                o2hb_heartbeat_mode_desc[i]);
@@ -2304,7 +2304,7 @@ static struct configfs_attribute *o2hb_heartbeat_group_attrs[] = {
         NULL,
 };
 
-static struct configfs_item_operations o2hb_hearbeat_group_item_ops = {
+static struct configfs_item_operations o2hb_heartbeat_group_item_ops = {
         .show_attribute         = o2hb_heartbeat_group_show,
         .store_attribute        = o2hb_heartbeat_group_store,
 };
@@ -2316,7 +2316,7 @@ static struct configfs_group_operations o2hb_heartbeat_group_group_ops = {
 
 static struct config_item_type o2hb_heartbeat_group_type = {
         .ct_group_ops   = &o2hb_heartbeat_group_group_ops,
-        .ct_item_ops    = &o2hb_hearbeat_group_item_ops,
+        .ct_item_ops    = &o2hb_heartbeat_group_item_ops,
         .ct_attrs       = o2hb_heartbeat_group_attrs,
         .ct_owner       = THIS_MODULE,
 };
@@ -2389,6 +2389,9 @@ static int o2hb_region_pin(const char *region_uuid)
         assert_spin_locked(&o2hb_live_lock);
 
         list_for_each_entry(reg, &o2hb_all_regions, hr_all_item) {
+                if (reg->hr_item_dropped)
+                        continue;
+
                 uuid = config_item_name(&reg->hr_item);
 
                 /* local heartbeat */
@@ -2439,6 +2442,9 @@ static void o2hb_region_unpin(const char *region_uuid)
         assert_spin_locked(&o2hb_live_lock);
 
         list_for_each_entry(reg, &o2hb_all_regions, hr_all_item) {
+                if (reg->hr_item_dropped)
+                        continue;
+
                 uuid = config_item_name(&reg->hr_item);
                 if (region_uuid) {
                         if (strcmp(region_uuid, uuid))
@@ -2654,6 +2660,9 @@ int o2hb_get_all_regions(char *region_uuids, u8 max_regions)
 
         p = region_uuids;
         list_for_each_entry(reg, &o2hb_all_regions, hr_all_item) {
+                if (reg->hr_item_dropped)
+                        continue;
+
                 mlog(0, "Region: %s\n", config_item_name(&reg->hr_item));
                 if (numregs < max_regions) {
                         memcpy(p, config_item_name(&reg->hr_item),
diff --git a/fs/ocfs2/cluster/quorum.c b/fs/ocfs2/cluster/quorum.c
index c19897d0fe14..1ec141e758d7 100644
--- a/fs/ocfs2/cluster/quorum.c
+++ b/fs/ocfs2/cluster/quorum.c
@@ -264,7 +264,7 @@ void o2quo_hb_still_up(u8 node)
 /* This is analogous to hb_up.  as a node's connection comes up we delay the
  * quorum decision until we see it heartbeating.  the hold will be droped in
  * hb_up or hb_down.  it might be perpetuated by con_err until hb_down.  if
- * it's already heartbeating we we might be dropping a hold that conn_up got.
+ * it's already heartbeating we might be dropping a hold that conn_up got.
  * */
 void o2quo_conn_up(u8 node)
 {
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index aa88bd8bcedc..d644dc611425 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -406,6 +406,9 @@ static void sc_kref_release(struct kref *kref)
         sc->sc_node = NULL;
 
         o2net_debug_del_sc(sc);
+
+        if (sc->sc_page)
+                __free_page(sc->sc_page);
         kfree(sc);
 }
 
@@ -630,19 +633,19 @@ static void o2net_state_change(struct sock *sk)
         state_change = sc->sc_state_change;
 
         switch(sk->sk_state) {
-                /* ignore connecting sockets as they make progress */
-                case TCP_SYN_SENT:
-                case TCP_SYN_RECV:
-                        break;
-                case TCP_ESTABLISHED:
-                        o2net_sc_queue_work(sc, &sc->sc_connect_work);
-                        break;
-                default:
-                        printk(KERN_INFO "o2net: Connection to " SC_NODEF_FMT
-                              " shutdown, state %d\n",
-                              SC_NODEF_ARGS(sc), sk->sk_state);
-                        o2net_sc_queue_work(sc, &sc->sc_shutdown_work);
-                        break;
+        /* ignore connecting sockets as they make progress */
+        case TCP_SYN_SENT:
+        case TCP_SYN_RECV:
+                break;
+        case TCP_ESTABLISHED:
+                o2net_sc_queue_work(sc, &sc->sc_connect_work);
+                break;
+        default:
+                printk(KERN_INFO "o2net: Connection to " SC_NODEF_FMT
+                        " shutdown, state %d\n",
+                        SC_NODEF_ARGS(sc), sk->sk_state);
+                o2net_sc_queue_work(sc, &sc->sc_shutdown_work);
+                break;
         }
 out:
         read_unlock(&sk->sk_callback_lock);
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index f1e1aed8f638..30544ce8e9f7 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -1761,11 +1761,10 @@ bail:
 
 static int ocfs2_dir_foreach_blk_id(struct inode *inode,
                                     u64 *f_version,
-                                    loff_t *f_pos, void *priv,
-                                    filldir_t filldir, int *filldir_err)
+                                    struct dir_context *ctx)
 {
-        int ret, i, filldir_ret;
-        unsigned long offset = *f_pos;
+        int ret, i;
+        unsigned long offset = ctx->pos;
         struct buffer_head *di_bh = NULL;
         struct ocfs2_dinode *di;
         struct ocfs2_inline_data *data;
@@ -1781,8 +1780,7 @@ static int ocfs2_dir_foreach_blk_id(struct inode *inode,
         di = (struct ocfs2_dinode *)di_bh->b_data;
         data = &di->id2.i_data;
 
-        while (*f_pos < i_size_read(inode)) {
-revalidate:
+        while (ctx->pos < i_size_read(inode)) {
                 /* If the dir block has changed since the last call to
                  * readdir(2), then we might be pointing to an invalid
                  * dirent right now.  Scan from the start of the block
@@ -1802,50 +1800,31 @@ revalidate:
                                         break;
                                 i += le16_to_cpu(de->rec_len);
                         }
-                        *f_pos = offset = i;
+                        ctx->pos = offset = i;
                         *f_version = inode->i_version;
                 }
 
-                de = (struct ocfs2_dir_entry *) (data->id_data + *f_pos);
-                if (!ocfs2_check_dir_entry(inode, de, di_bh, *f_pos)) {
+                de = (struct ocfs2_dir_entry *) (data->id_data + ctx->pos);
+                if (!ocfs2_check_dir_entry(inode, de, di_bh, ctx->pos)) {
                         /* On error, skip the f_pos to the end. */
-                        *f_pos = i_size_read(inode);
-                        goto out;
+                        ctx->pos = i_size_read(inode);
+                        break;
                 }
                 offset += le16_to_cpu(de->rec_len);
                 if (le64_to_cpu(de->inode)) {
-                        /* We might block in the next section
-                         * if the data destination is
-                         * currently swapped out.  So, use a
-                         * version stamp to detect whether or
-                         * not the directory has been modified
-                         * during the copy operation.
-                         */
-                        u64 version = *f_version;
                         unsigned char d_type = DT_UNKNOWN;
 
                         if (de->file_type < OCFS2_FT_MAX)
                                 d_type = ocfs2_filetype_table[de->file_type];
 
-                        filldir_ret = filldir(priv, de->name,
-                                              de->name_len,
-                                              *f_pos,
-                                              le64_to_cpu(de->inode),
-                                              d_type);
-                        if (filldir_ret) {
-                                if (filldir_err)
-                                        *filldir_err = filldir_ret;
-                                break;
-                        }
-                        if (version != *f_version)
-                                goto revalidate;
+                        if (!dir_emit(ctx, de->name, de->name_len,
+                                      le64_to_cpu(de->inode), d_type))
+                                goto out;
                 }
-                *f_pos += le16_to_cpu(de->rec_len);
+                ctx->pos += le16_to_cpu(de->rec_len);
         }
-
 out:
         brelse(di_bh);
-
         return 0;
 }
 
@@ -1855,27 +1834,26 @@ out:
  */
 static int ocfs2_dir_foreach_blk_el(struct inode *inode,
                                     u64 *f_version,
-                                    loff_t *f_pos, void *priv,
-                                    filldir_t filldir, int *filldir_err)
+                                    struct dir_context *ctx,
+                                    bool persist)
 {
-        int error = 0;
         unsigned long offset, blk, last_ra_blk = 0;
-        int i, stored;
+        int i;
         struct buffer_head * bh, * tmp;
         struct ocfs2_dir_entry * de;
         struct super_block * sb = inode->i_sb;
         unsigned int ra_sectors = 16;
+        int stored = 0;
 
-        stored = 0;
         bh = NULL;
 
-        offset = (*f_pos) & (sb->s_blocksize - 1);
+        offset = ctx->pos & (sb->s_blocksize - 1);
 
-        while (!error && !stored && *f_pos < i_size_read(inode)) {
-                blk = (*f_pos) >> sb->s_blocksize_bits;
+        while (ctx->pos < i_size_read(inode)) {
+                blk = ctx->pos >> sb->s_blocksize_bits;
                 if (ocfs2_read_dir_block(inode, blk, &bh, 0)) {
                         /* Skip the corrupt dirblock and keep trying */
-                        *f_pos += sb->s_blocksize - offset;
+                        ctx->pos += sb->s_blocksize - offset;
                         continue;
                 }
 
@@ -1897,7 +1875,6 @@ static int ocfs2_dir_foreach_blk_el(struct inode *inode,
                         ra_sectors = 8;
                 }
 
-revalidate:
                 /* If the dir block has changed since the last call to
                  * readdir(2), then we might be pointing to an invalid
                  * dirent right now.  Scan from the start of the block
@@ -1917,93 +1894,64 @@ revalidate:
                                 i += le16_to_cpu(de->rec_len);
                         }
                         offset = i;
-                        *f_pos = ((*f_pos) & ~(sb->s_blocksize - 1))
+                        ctx->pos = (ctx->pos & ~(sb->s_blocksize - 1))
                                 | offset;
                         *f_version = inode->i_version;
                 }
 
-                while (!error && *f_pos < i_size_read(inode)
+                while (ctx->pos < i_size_read(inode)
                        && offset < sb->s_blocksize) {
                         de = (struct ocfs2_dir_entry *) (bh->b_data + offset);
                         if (!ocfs2_check_dir_entry(inode, de, bh, offset)) {
                                 /* On error, skip the f_pos to the
                                    next block. */
-                                *f_pos = ((*f_pos) | (sb->s_blocksize - 1)) + 1;
+                                ctx->pos = (ctx->pos | (sb->s_blocksize - 1)) + 1;
                                 brelse(bh);
-                                goto out;
+                                continue;
                         }
-                        offset += le16_to_cpu(de->rec_len);
                         if (le64_to_cpu(de->inode)) {
-                                /* We might block in the next section
-                                 * if the data destination is
-                                 * currently swapped out.  So, use a
-                                 * version stamp to detect whether or
-                                 * not the directory has been modified
-                                 * during the copy operation.
-                                 */
-                                unsigned long version = *f_version;
                                 unsigned char d_type = DT_UNKNOWN;
 
                                 if (de->file_type < OCFS2_FT_MAX)
                                         d_type = ocfs2_filetype_table[de->file_type];
-                                error = filldir(priv, de->name,
+                                if (!dir_emit(ctx, de->name,
                                                 de->name_len,
-                                                *f_pos,
                                                 le64_to_cpu(de->inode),
-                                                d_type);
-                                if (error) {
-                                        if (filldir_err)
-                                                *filldir_err = error;
-                                        break;
+                                                d_type)) {
+                                        brelse(bh);
+                                        return 0;
                                 }
-                                if (version != *f_version)
-                                        goto revalidate;
-                                stored ++;
+                                stored++;
                         }
-                        *f_pos += le16_to_cpu(de->rec_len);
+                        offset += le16_to_cpu(de->rec_len);
+                        ctx->pos += le16_to_cpu(de->rec_len);
                 }
                 offset = 0;
                 brelse(bh);
                 bh = NULL;
+                if (!persist && stored)
+                        break;
         }
-
-        stored = 0;
-out:
-        return stored;
+        return 0;
 }
 
 static int ocfs2_dir_foreach_blk(struct inode *inode, u64 *f_version,
-                                 loff_t *f_pos, void *priv, filldir_t filldir,
-                                 int *filldir_err)
+                                 struct dir_context *ctx,
+                                 bool persist)
 {
         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
-                return ocfs2_dir_foreach_blk_id(inode, f_version, f_pos, priv,
-                                                filldir, filldir_err);
-
-        return ocfs2_dir_foreach_blk_el(inode, f_version, f_pos, priv, filldir,
-                                        filldir_err);
+                return ocfs2_dir_foreach_blk_id(inode, f_version, ctx);
+        return ocfs2_dir_foreach_blk_el(inode, f_version, ctx, persist);
 }
 
 /*
  * This is intended to be called from inside other kernel functions,
  * so we fake some arguments.
  */
-int ocfs2_dir_foreach(struct inode *inode, loff_t *f_pos, void *priv,
-                      filldir_t filldir)
+int ocfs2_dir_foreach(struct inode *inode, struct dir_context *ctx)
 {
-        int ret = 0, filldir_err = 0;
         u64 version = inode->i_version;
-
-        while (*f_pos < i_size_read(inode)) {
-                ret = ocfs2_dir_foreach_blk(inode, &version, f_pos, priv,
-                                            filldir, &filldir_err);
-                if (ret || filldir_err)
-                        break;
-        }
-
-        if (ret > 0)
-                ret = -EIO;
-
+        ocfs2_dir_foreach_blk(inode, &version, ctx, true);
         return 0;
 }
 
@@ -2011,15 +1959,15 @@ int ocfs2_dir_foreach(struct inode *inode, loff_t *f_pos, void *priv,
  * ocfs2_readdir()
  *
  */
-int ocfs2_readdir(struct file * filp, void * dirent, filldir_t filldir)
+int ocfs2_readdir(struct file *file, struct dir_context *ctx)
 {
         int error = 0;
-        struct inode *inode = file_inode(filp);
+        struct inode *inode = file_inode(file);
         int lock_level = 0;
 
         trace_ocfs2_readdir((unsigned long long)OCFS2_I(inode)->ip_blkno);
 
-        error = ocfs2_inode_lock_atime(inode, filp->f_path.mnt, &lock_level);
+        error = ocfs2_inode_lock_atime(inode, file->f_path.mnt, &lock_level);
         if (lock_level && error >= 0) {
                 /* We release EX lock which used to update atime
                  * and get PR lock again to reduce contention
@@ -2035,8 +1983,7 @@ int ocfs2_readdir(struct file * filp, void * dirent, filldir_t filldir)
                 goto bail_nolock;
         }
 
-        error = ocfs2_dir_foreach_blk(inode, &filp->f_version, &filp->f_pos,
-                                      dirent, filldir, NULL);
+        error = ocfs2_dir_foreach_blk(inode, &file->f_version, ctx, false);
 
         ocfs2_inode_unlock(inode, lock_level);
         if (error)
@@ -2120,6 +2067,7 @@ bail:
 }
 
 struct ocfs2_empty_dir_priv {
+        struct dir_context ctx;
         unsigned seen_dot;
         unsigned seen_dot_dot;
         unsigned seen_other;
@@ -2204,10 +2152,9 @@ out:
 int ocfs2_empty_dir(struct inode *inode)
 {
         int ret;
-        loff_t start = 0;
-        struct ocfs2_empty_dir_priv priv;
-
-        memset(&priv, 0, sizeof(priv));
+        struct ocfs2_empty_dir_priv priv = {
+                .ctx.actor = ocfs2_empty_dir_filldir,
+        };
 
         if (ocfs2_dir_indexed(inode)) {
                 ret = ocfs2_empty_dir_dx(inode, &priv);
@@ -2219,7 +2166,7 @@ int ocfs2_empty_dir(struct inode *inode)
                  */
         }
 
-        ret = ocfs2_dir_foreach(inode, &start, &priv, ocfs2_empty_dir_filldir);
+        ret = ocfs2_dir_foreach(inode, &priv.ctx);
         if (ret)
                 mlog_errno(ret);
 
diff --git a/fs/ocfs2/dir.h b/fs/ocfs2/dir.h
index e683f3deb645..f0344b75b14d 100644
--- a/fs/ocfs2/dir.h
+++ b/fs/ocfs2/dir.h
@@ -92,9 +92,8 @@ int ocfs2_find_files_on_disk(const char *name,
                              struct ocfs2_dir_lookup_result *res);
 int ocfs2_lookup_ino_from_name(struct inode *dir, const char *name,
                                int namelen, u64 *blkno);
-int ocfs2_readdir(struct file *filp, void *dirent, filldir_t filldir);
-int ocfs2_dir_foreach(struct inode *inode, loff_t *f_pos, void *priv,
-                      filldir_t filldir);
+int ocfs2_readdir(struct file *file, struct dir_context *ctx);
+int ocfs2_dir_foreach(struct inode *inode, struct dir_context *ctx);
 int ocfs2_prepare_dir_for_insert(struct ocfs2_super *osb,
                                  struct inode *dir,
                                  struct buffer_head *parent_fe_bh,
diff --git a/fs/ocfs2/dlm/dlmlock.c b/fs/ocfs2/dlm/dlmlock.c
index 975810b98492..47e67c2d228f 100644
--- a/fs/ocfs2/dlm/dlmlock.c
+++ b/fs/ocfs2/dlm/dlmlock.c
@@ -178,6 +178,7 @@ static enum dlm_status dlmlock_master(struct dlm_ctxt *dlm,
                                      lock->ml.node);
                         }
                 } else {
+                        status = DLM_NORMAL;
                         dlm_lock_get(lock);
                         list_add_tail(&lock->list, &res->blocked);
                         kick_thread = 1;
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index e68588e6b1e8..773bd32bfd8c 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -55,9 +55,6 @@
 static void dlm_do_local_recovery_cleanup(struct dlm_ctxt *dlm, u8 dead_node);
 
 static int dlm_recovery_thread(void *data);
-void dlm_complete_recovery_thread(struct dlm_ctxt *dlm);
-int dlm_launch_recovery_thread(struct dlm_ctxt *dlm);
-void dlm_kick_recovery_thread(struct dlm_ctxt *dlm);
 static int dlm_do_recovery(struct dlm_ctxt *dlm);
 
 static int dlm_pick_recovery_master(struct dlm_ctxt *dlm);
@@ -789,7 +786,7 @@ static int dlm_request_all_locks(struct dlm_ctxt *dlm, u8 request_from,
                                  u8 dead_node)
 {
         struct dlm_lock_request lr;
-        enum dlm_status ret;
+        int ret;
 
         mlog(0, "\n");
 
@@ -802,7 +799,6 @@ static int dlm_request_all_locks(struct dlm_ctxt *dlm, u8 request_from,
         lr.dead_node = dead_node;
 
         // send message
-        ret = DLM_NOLOCKMGR;
         ret = o2net_send_message(DLM_LOCK_REQUEST_MSG, dlm->key,
                                  &lr, sizeof(lr), request_from, NULL);
 
@@ -2696,6 +2692,7 @@ int dlm_begin_reco_handler(struct o2net_msg *msg, u32 len, void *data,
                      dlm->name, br->node_idx, br->dead_node,
                      dlm->reco.dead_node, dlm->reco.new_master);
                 spin_unlock(&dlm->spinlock);
+                dlm_put(dlm);
                 return -EAGAIN;
         }
         spin_unlock(&dlm->spinlock);
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index ff54014a24ec..3261d71319ee 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -370,7 +370,7 @@ static int ocfs2_cow_file_pos(struct inode *inode,
         if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
                 goto out;
 
-        return ocfs2_refcount_cow(inode, NULL, fe_bh, cpos, 1, cpos+1);
+        return ocfs2_refcount_cow(inode, fe_bh, cpos, 1, cpos+1);
 
 out:
         return status;
@@ -899,7 +899,7 @@ static int ocfs2_zero_extend_get_range(struct inode *inode,
                 zero_clusters = last_cpos - zero_cpos;
 
         if (needs_cow) {
-                rc = ocfs2_refcount_cow(inode, NULL, di_bh, zero_cpos,
+                rc = ocfs2_refcount_cow(inode, di_bh, zero_cpos,
                                         zero_clusters, UINT_MAX);
                 if (rc) {
                         mlog_errno(rc);
@@ -2078,7 +2078,7 @@ static int ocfs2_prepare_inode_for_refcount(struct inode *inode,
 
         *meta_level = 1;
 
-        ret = ocfs2_refcount_cow(inode, file, di_bh, cpos, clusters, UINT_MAX);
+        ret = ocfs2_refcount_cow(inode, di_bh, cpos, clusters, UINT_MAX);
         if (ret)
                 mlog_errno(ret);
 out:
@@ -2646,17 +2646,7 @@ static loff_t ocfs2_file_llseek(struct file *file, loff_t offset, int whence)
                 goto out;
         }
 
-        if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
-                ret = -EINVAL;
-        if (!ret && offset > inode->i_sb->s_maxbytes)
-                ret = -EINVAL;
-        if (ret)
-                goto out;
-
-        if (offset != file->f_pos) {
-                file->f_pos = offset;
-                file->f_version = 0;
-        }
+        offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
 
 out:
         mutex_unlock(&inode->i_mutex);
@@ -2712,7 +2702,7 @@ const struct file_operations ocfs2_fops = {
 const struct file_operations ocfs2_dops = {
         .llseek         = generic_file_llseek,
         .read           = generic_read_dir,
-        .readdir        = ocfs2_readdir,
+        .iterate        = ocfs2_readdir,
         .fsync          = ocfs2_sync_file,
         .release        = ocfs2_dir_release,
         .open           = ocfs2_dir_open,
@@ -2759,7 +2749,7 @@ const struct file_operations ocfs2_fops_no_plocks = {
 const struct file_operations ocfs2_dops_no_plocks = {
         .llseek         = generic_file_llseek,
         .read           = generic_read_dir,
-        .readdir        = ocfs2_readdir,
+        .iterate        = ocfs2_readdir,
         .fsync          = ocfs2_sync_file,
         .release        = ocfs2_dir_release,
         .open           = ocfs2_dir_open,
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index 8eccfabcd12e..242170d83971 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -1941,6 +1941,7 @@ void ocfs2_orphan_scan_start(struct ocfs2_super *osb)
 }
 
 struct ocfs2_orphan_filldir_priv {
+        struct dir_context      ctx;
         struct inode            *head;
         struct ocfs2_super      *osb;
 };
@@ -1977,11 +1978,11 @@ static int ocfs2_queue_orphans(struct ocfs2_super *osb,
 {
         int status;
         struct inode *orphan_dir_inode = NULL;
-        struct ocfs2_orphan_filldir_priv priv;
-        loff_t pos = 0;
-
-        priv.osb = osb;
-        priv.head = *head;
+        struct ocfs2_orphan_filldir_priv priv = {
+                .ctx.actor = ocfs2_orphan_filldir,
+                .osb = osb,
+                .head = *head
+        };
 
         orphan_dir_inode = ocfs2_get_system_file_inode(osb,
                                                        ORPHAN_DIR_SYSTEM_INODE,
@@ -1999,8 +2000,7 @@ static int ocfs2_queue_orphans(struct ocfs2_super *osb,
                 goto out;
         }
 
-        status = ocfs2_dir_foreach(orphan_dir_inode, &pos, &priv,
-                                   ocfs2_orphan_filldir);
+        status = ocfs2_dir_foreach(orphan_dir_inode, &priv.ctx);
         if (status) {
                 mlog_errno(status);
                 goto out_cluster;
diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
index a3385b63ff5e..0a992737dcaf 100644
--- a/fs/ocfs2/journal.h
+++ b/fs/ocfs2/journal.h
@@ -200,7 +200,6 @@ void ocfs2_complete_quota_recovery(struct ocfs2_super *osb);
 
 static inline void ocfs2_start_checkpoint(struct ocfs2_super *osb)
 {
-        atomic_set(&osb->needs_checkpoint, 1);
         wake_up(&osb->checkpoint_event);
 }
 
diff --git a/fs/ocfs2/move_extents.c b/fs/ocfs2/move_extents.c
index f1fc172175b6..452068b45749 100644
--- a/fs/ocfs2/move_extents.c
+++ b/fs/ocfs2/move_extents.c
@@ -69,7 +69,7 @@ static int __ocfs2_move_extent(handle_t *handle,
         u64 ino = ocfs2_metadata_cache_owner(context->et.et_ci);
         u64 old_blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cpos);
 
-        ret = ocfs2_duplicate_clusters_by_page(handle, context->file, cpos,
+        ret = ocfs2_duplicate_clusters_by_page(handle, inode, cpos,
                                                p_cpos, new_p_cpos, len);
         if (ret) {
                 mlog_errno(ret);
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index b4a5cdf9dbc5..be3f8676a438 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -522,7 +522,7 @@ static int __ocfs2_mknod_locked(struct inode *dir,
 
         fe->i_last_eb_blk = 0;
         strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
-        le32_add_cpu(&fe->i_flags, OCFS2_VALID_FL);
+        fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL);
         fe->i_atime = fe->i_ctime = fe->i_mtime =
                 cpu_to_le64(CURRENT_TIME.tv_sec);
         fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
@@ -773,7 +773,7 @@ static int ocfs2_remote_dentry_delete(struct dentry *dentry)
         return ret;
 }
 
-static inline int inode_is_unlinkable(struct inode *inode)
+static inline int ocfs2_inode_is_unlinkable(struct inode *inode)
 {
         if (S_ISDIR(inode->i_mode)) {
                 if (inode->i_nlink == 2)
@@ -791,6 +791,7 @@ static int ocfs2_unlink(struct inode *dir,
 {
         int status;
         int child_locked = 0;
+        bool is_unlinkable = false;
         struct inode *inode = dentry->d_inode;
         struct inode *orphan_dir = NULL;
         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
@@ -865,7 +866,7 @@ static int ocfs2_unlink(struct inode *dir,
                 goto leave;
         }
 
-        if (inode_is_unlinkable(inode)) {
+        if (ocfs2_inode_is_unlinkable(inode)) {
                 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
                                                   OCFS2_I(inode)->ip_blkno,
                                                   orphan_name, &orphan_insert);
@@ -873,6 +874,7 @@ static int ocfs2_unlink(struct inode *dir,
                         mlog_errno(status);
                         goto leave;
                 }
+                is_unlinkable = true;
         }
 
         handle = ocfs2_start_trans(osb, ocfs2_unlink_credits(osb->sb));
@@ -892,15 +894,6 @@ static int ocfs2_unlink(struct inode *dir,
 
         fe = (struct ocfs2_dinode *) fe_bh->b_data;
 
-        if (inode_is_unlinkable(inode)) {
-                status = ocfs2_orphan_add(osb, handle, inode, fe_bh, orphan_name,
-                                          &orphan_insert, orphan_dir);
-                if (status < 0) {
-                        mlog_errno(status);
-                        goto leave;
-                }
-        }
-
         /* delete the name from the parent dir */
         status = ocfs2_delete_entry(handle, dir, &lookup);
         if (status < 0) {
@@ -923,6 +916,14 @@ static int ocfs2_unlink(struct inode *dir,
                 mlog_errno(status);
                 if (S_ISDIR(inode->i_mode))
                         inc_nlink(dir);
+                goto leave;
+        }
+
+        if (is_unlinkable) {
+                status = ocfs2_orphan_add(osb, handle, inode, fe_bh,
+                                orphan_name, &orphan_insert, orphan_dir);
+                if (status < 0)
+                        mlog_errno(status);
         }
 
 leave:
@@ -2012,6 +2013,21 @@ static int ocfs2_orphan_add(struct ocfs2_super *osb,
                 goto leave;
         }
 
+        /*
+         * We're going to journal the change of i_flags and i_orphaned_slot.
+         * It's safe anyway, though some callers may duplicate the journaling.
+         * Journaling within the func just make the logic look more
+         * straightforward.
+         */
+        status = ocfs2_journal_access_di(handle,
+                                         INODE_CACHE(inode),
+                                         fe_bh,
+                                         OCFS2_JOURNAL_ACCESS_WRITE);
+        if (status < 0) {
+                mlog_errno(status);
+                goto leave;
+        }
+
         /* we're a cluster, and nlink can change on disk from
          * underneath us... */
         orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
@@ -2026,25 +2042,10 @@ static int ocfs2_orphan_add(struct ocfs2_super *osb,
                                    orphan_dir_bh, lookup);
         if (status < 0) {
                 mlog_errno(status);
-                goto leave;
-        }
-
-        /*
-         * We're going to journal the change of i_flags and i_orphaned_slot.
-         * It's safe anyway, though some callers may duplicate the journaling.
-         * Journaling within the func just make the logic look more
-         * straightforward.
-         */
-        status = ocfs2_journal_access_di(handle,
-                                         INODE_CACHE(inode),
-                                         fe_bh,
-                                         OCFS2_JOURNAL_ACCESS_WRITE);
-        if (status < 0) {
-                mlog_errno(status);
-                goto leave;
+                goto rollback;
         }
 
-        le32_add_cpu(&fe->i_flags, OCFS2_ORPHANED_FL);
+        fe->i_flags |= cpu_to_le32(OCFS2_ORPHANED_FL);
         OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR;
 
         /* Record which orphan dir our inode now resides
@@ -2057,11 +2058,16 @@ static int ocfs2_orphan_add(struct ocfs2_super *osb,
         trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
                                    osb->slot_num);
 
+rollback:
+        if (status < 0) {
+                if (S_ISDIR(inode->i_mode))
+                        ocfs2_add_links_count(orphan_fe, -1);
+                set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
+        }
+
 leave:
         brelse(orphan_dir_bh);
 
-        if (status)
-                mlog_errno(status);
         return status;
 }
 
@@ -2434,7 +2440,7 @@ int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
         }
 
         di = (struct ocfs2_dinode *)di_bh->b_data;
-        le32_add_cpu(&di->i_flags, -OCFS2_ORPHANED_FL);
+        di->i_flags &= ~cpu_to_le32(OCFS2_ORPHANED_FL);
         di->i_orphaned_slot = 0;
         set_nlink(inode, 1);
         ocfs2_set_links_count(di, inode->i_nlink);
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h
index d355e6e36b36..3a903470c794 100644
--- a/fs/ocfs2/ocfs2.h
+++ b/fs/ocfs2/ocfs2.h
@@ -347,7 +347,6 @@ struct ocfs2_super
         struct task_struct *recovery_thread_task;
         int disable_recovery;
         wait_queue_head_t checkpoint_event;
-        atomic_t needs_checkpoint;
         struct ocfs2_journal *journal;
         unsigned long osb_commit_interval;
 
diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c
index 998b17eda09d..a70d604593b6 100644
--- a/fs/ocfs2/refcounttree.c
+++ b/fs/ocfs2/refcounttree.c
@@ -49,7 +49,6 @@
 
 struct ocfs2_cow_context {
         struct inode *inode;
-        struct file *file;
         u32 cow_start;
         u32 cow_len;
         struct ocfs2_extent_tree data_et;
@@ -66,7 +65,7 @@ struct ocfs2_cow_context {
                             u32 *num_clusters,
                             unsigned int *extent_flags);
         int (*cow_duplicate_clusters)(handle_t *handle,
-                                      struct file *file,
+                                      struct inode *inode,
                                       u32 cpos, u32 old_cluster,
                                       u32 new_cluster, u32 new_len);
 };
@@ -2922,14 +2921,12 @@ static int ocfs2_clear_cow_buffer(handle_t *handle, struct buffer_head *bh)
 }
 
 int ocfs2_duplicate_clusters_by_page(handle_t *handle,
-                                     struct file *file,
+                                     struct inode *inode,
                                      u32 cpos, u32 old_cluster,
                                      u32 new_cluster, u32 new_len)
 {
         int ret = 0, partial;
-        struct inode *inode = file_inode(file);
-        struct ocfs2_caching_info *ci = INODE_CACHE(inode);
-        struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
+        struct super_block *sb = inode->i_sb;
         u64 new_block = ocfs2_clusters_to_blocks(sb, new_cluster);
         struct page *page;
         pgoff_t page_index;
@@ -2965,6 +2962,11 @@ int ocfs2_duplicate_clusters_by_page(handle_t *handle,
                         to = map_end & (PAGE_CACHE_SIZE - 1);
 
                 page = find_or_create_page(mapping, page_index, GFP_NOFS);
+                if (!page) {
+                        ret = -ENOMEM;
+                        mlog_errno(ret);
+                        break;
+                }
 
                 /*
                  * In case PAGE_CACHE_SIZE <= CLUSTER_SIZE, This page
@@ -2973,13 +2975,6 @@ int ocfs2_duplicate_clusters_by_page(handle_t *handle,
                 if (PAGE_CACHE_SIZE <= OCFS2_SB(sb)->s_clustersize)
                         BUG_ON(PageDirty(page));
 
-                if (PageReadahead(page)) {
-                        page_cache_async_readahead(mapping,
-                                                   &file->f_ra, file,
-                                                   page, page_index,
-                                                   readahead_pages);
-                }
-
                 if (!PageUptodate(page)) {
                         ret = block_read_full_page(page, ocfs2_get_block);
                         if (ret) {
@@ -2999,7 +2994,8 @@ int ocfs2_duplicate_clusters_by_page(handle_t *handle,
                         }
                 }
 
-                ocfs2_map_and_dirty_page(inode, handle, from, to,
+                ocfs2_map_and_dirty_page(inode,
+                                         handle, from, to,
                                          page, 0, &new_block);
                 mark_page_accessed(page);
 unlock:
@@ -3015,12 +3011,11 @@ unlock:
 }
 
 int ocfs2_duplicate_clusters_by_jbd(handle_t *handle,
-                                    struct file *file,
+                                    struct inode *inode,
                                     u32 cpos, u32 old_cluster,
                                     u32 new_cluster, u32 new_len)
 {
         int ret = 0;
-        struct inode *inode = file_inode(file);
         struct super_block *sb = inode->i_sb;
         struct ocfs2_caching_info *ci = INODE_CACHE(inode);
         int i, blocks = ocfs2_clusters_to_blocks(sb, new_len);
@@ -3145,7 +3140,7 @@ static int ocfs2_replace_clusters(handle_t *handle,
 
         /*If the old clusters is unwritten, no need to duplicate. */
         if (!(ext_flags & OCFS2_EXT_UNWRITTEN)) {
-                ret = context->cow_duplicate_clusters(handle, context->file,
+                ret = context->cow_duplicate_clusters(handle, context->inode,
                                                       cpos, old, new, len);
                 if (ret) {
                         mlog_errno(ret);
@@ -3423,35 +3418,12 @@ static int ocfs2_replace_cow(struct ocfs2_cow_context *context)
         return ret;
 }
 
-static void ocfs2_readahead_for_cow(struct inode *inode,
-                                    struct file *file,
-                                    u32 start, u32 len)
-{
-        struct address_space *mapping;
-        pgoff_t index;
-        unsigned long num_pages;
-        int cs_bits = OCFS2_SB(inode->i_sb)->s_clustersize_bits;
-
-        if (!file)
-                return;
-
-        mapping = file->f_mapping;
-        num_pages = (len << cs_bits) >> PAGE_CACHE_SHIFT;
-        if (!num_pages)
-                num_pages = 1;
-
-        index = ((loff_t)start << cs_bits) >> PAGE_CACHE_SHIFT;
-        page_cache_sync_readahead(mapping, &file->f_ra, file,
-                                  index, num_pages);
-}
-
 /*
  * Starting at cpos, try to CoW write_len clusters.  Don't CoW
  * past max_cpos.  This will stop when it runs into a hole or an
  * unrefcounted extent.
  */
 static int ocfs2_refcount_cow_hunk(struct inode *inode,
-                                   struct file *file,
                                    struct buffer_head *di_bh,
                                    u32 cpos, u32 write_len, u32 max_cpos)
 {
@@ -3480,8 +3452,6 @@ static int ocfs2_refcount_cow_hunk(struct inode *inode,
 
         BUG_ON(cow_len == 0);
 
-        ocfs2_readahead_for_cow(inode, file, cow_start, cow_len);
-
         context = kzalloc(sizeof(struct ocfs2_cow_context), GFP_NOFS);
         if (!context) {
                 ret = -ENOMEM;
@@ -3503,7 +3473,6 @@ static int ocfs2_refcount_cow_hunk(struct inode *inode,
         context->ref_root_bh = ref_root_bh;
         context->cow_duplicate_clusters = ocfs2_duplicate_clusters_by_page;
         context->get_clusters = ocfs2_di_get_clusters;
-        context->file = file;
 
         ocfs2_init_dinode_extent_tree(&context->data_et,
                                       INODE_CACHE(inode), di_bh);
@@ -3532,7 +3501,6 @@ out:
  * clusters between cpos and cpos+write_len are safe to modify.
  */
 int ocfs2_refcount_cow(struct inode *inode,
-                       struct file *file,
                        struct buffer_head *di_bh,
                        u32 cpos, u32 write_len, u32 max_cpos)
 {
@@ -3552,7 +3520,7 @@ int ocfs2_refcount_cow(struct inode *inode,
                         num_clusters = write_len;
 
                 if (ext_flags & OCFS2_EXT_REFCOUNTED) {
-                        ret = ocfs2_refcount_cow_hunk(inode, file, di_bh, cpos,
+                        ret = ocfs2_refcount_cow_hunk(inode, di_bh, cpos,
                                                       num_clusters, max_cpos);
                         if (ret) {
                                 mlog_errno(ret);
diff --git a/fs/ocfs2/refcounttree.h b/fs/ocfs2/refcounttree.h
index 7754608c83a4..6422bbcdb525 100644
--- a/fs/ocfs2/refcounttree.h
+++ b/fs/ocfs2/refcounttree.h
@@ -53,7 +53,7 @@ int ocfs2_prepare_refcount_change_for_del(struct inode *inode,
                                           int *credits,
                                           int *ref_blocks);
 int ocfs2_refcount_cow(struct inode *inode,
-                       struct file *filep, struct buffer_head *di_bh,
+                       struct buffer_head *di_bh,
                        u32 cpos, u32 write_len, u32 max_cpos);
 
 typedef int (ocfs2_post_refcount_func)(struct inode *inode,
@@ -85,11 +85,11 @@ int ocfs2_refcount_cow_xattr(struct inode *inode,
                              u32 cpos, u32 write_len,
                              struct ocfs2_post_refcount *post);
 int ocfs2_duplicate_clusters_by_page(handle_t *handle,
-                                     struct file *file,
+                                     struct inode *inode,
                                      u32 cpos, u32 old_cluster,
                                      u32 new_cluster, u32 new_len);
 int ocfs2_duplicate_clusters_by_jbd(handle_t *handle,
-                                    struct file *file,
+                                    struct inode *inode,
                                     u32 cpos, u32 old_cluster,
                                     u32 new_cluster, u32 new_len);
 int ocfs2_cow_sync_writeback(struct super_block *sb,
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index b7e74b580c0f..5397c07ce608 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -1422,7 +1422,7 @@ static int ocfs2_relink_block_group(handle_t *handle,
         int status;
         /* there is a really tiny chance the journal calls could fail,
          * but we wouldn't want inconsistent blocks in *any* case. */
-        u64 fe_ptr, bg_ptr, prev_bg_ptr;
+        u64 bg_ptr, prev_bg_ptr;
         struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
         struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
         struct ocfs2_group_desc *prev_bg = (struct ocfs2_group_desc *) prev_bg_bh->b_data;
@@ -1437,51 +1437,44 @@ static int ocfs2_relink_block_group(handle_t *handle,
                 (unsigned long long)le64_to_cpu(bg->bg_blkno),
                 (unsigned long long)le64_to_cpu(prev_bg->bg_blkno));
 
-        fe_ptr = le64_to_cpu(fe->id2.i_chain.cl_recs[chain].c_blkno);
         bg_ptr = le64_to_cpu(bg->bg_next_group);
         prev_bg_ptr = le64_to_cpu(prev_bg->bg_next_group);
 
         status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode),
                                          prev_bg_bh,
                                          OCFS2_JOURNAL_ACCESS_WRITE);
-        if (status < 0) {
-                mlog_errno(status);
-                goto out_rollback;
-        }
+        if (status < 0)
+                goto out;
 
         prev_bg->bg_next_group = bg->bg_next_group;
         ocfs2_journal_dirty(handle, prev_bg_bh);
 
         status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode),
                                          bg_bh, OCFS2_JOURNAL_ACCESS_WRITE);
-        if (status < 0) {
-                mlog_errno(status);
-                goto out_rollback;
-        }
+        if (status < 0)
+                goto out_rollback_prev_bg;
 
         bg->bg_next_group = fe->id2.i_chain.cl_recs[chain].c_blkno;
         ocfs2_journal_dirty(handle, bg_bh);
 
         status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode),
                                          fe_bh, OCFS2_JOURNAL_ACCESS_WRITE);
-        if (status < 0) {
-                mlog_errno(status);
-                goto out_rollback;
-        }
+        if (status < 0)
+                goto out_rollback_bg;
 
         fe->id2.i_chain.cl_recs[chain].c_blkno = bg->bg_blkno;
         ocfs2_journal_dirty(handle, fe_bh);
 
-out_rollback:
-        if (status < 0) {
-                fe->id2.i_chain.cl_recs[chain].c_blkno = cpu_to_le64(fe_ptr);
-                bg->bg_next_group = cpu_to_le64(bg_ptr);
-                prev_bg->bg_next_group = cpu_to_le64(prev_bg_ptr);
-        }
-
-        if (status)
+out:
+        if (status < 0)
                 mlog_errno(status);
         return status;
+
+out_rollback_bg:
+        bg->bg_next_group = cpu_to_le64(bg_ptr);
+out_rollback_prev_bg:
+        prev_bg->bg_next_group = cpu_to_le64(prev_bg_ptr);
+        goto out;
 }
 
 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg,
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 01b85165552b..854d80955bf8 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -286,10 +286,9 @@ static int ocfs2_osb_dump(struct ocfs2_super *osb, char *buf, int len)
         spin_unlock(&osb->osb_lock);
 
         out += snprintf(buf + out, len - out,
-                        "%10s => Pid: %d  Interval: %lu  Needs: %d\n", "Commit",
+                        "%10s => Pid: %d  Interval: %lu\n", "Commit",
                         (osb->commit_task ? task_pid_nr(osb->commit_task) : -1),
-                        osb->osb_commit_interval,
-                        atomic_read(&osb->needs_checkpoint));
+                        osb->osb_commit_interval);
 
         out += snprintf(buf + out, len - out,
                         "%10s => State: %d  TxnId: %lu  NumTxns: %d\n",
@@ -2154,7 +2153,6 @@ static int ocfs2_initialize_super(struct super_block *sb,
         }
 
         init_waitqueue_head(&osb->checkpoint_event);
-        atomic_set(&osb->needs_checkpoint, 0);
 
         osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
 
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index 2e3ea308c144..317ef0abccbb 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -2751,7 +2751,6 @@ static int ocfs2_xattr_ibody_set(struct inode *inode,
 {
         int ret;
         struct ocfs2_inode_info *oi = OCFS2_I(inode);
-        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
         struct ocfs2_xa_loc loc;
 
         if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
@@ -2759,13 +2758,6 @@ static int ocfs2_xattr_ibody_set(struct inode *inode,
 
         down_write(&oi->ip_alloc_sem);
         if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
-                if (!ocfs2_xattr_has_space_inline(inode, di)) {
-                        ret = -ENOSPC;
-                        goto out;
-                }
-        }
-
-        if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
                 ret = ocfs2_xattr_ibody_init(inode, xs->inode_bh, ctxt);
                 if (ret) {
                         if (ret != -ENOSPC)
@@ -6499,6 +6491,16 @@ static int ocfs2_reflink_xattr_inline(struct ocfs2_xattr_reflink *args)
         }
 
         new_oi = OCFS2_I(args->new_inode);
+        /*
+         * Adjust extent record count to reserve space for extended attribute.
+         * Inline data count had been adjusted in ocfs2_duplicate_inline_data().
+         */
+        if (!(new_oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) &&
+            !(ocfs2_inode_is_fast_symlink(args->new_inode))) {
+                struct ocfs2_extent_list *el = &new_di->id2.i_list;
+                le16_add_cpu(&el->l_count, -(inline_size /
+                                        sizeof(struct ocfs2_extent_rec)));
+        }
         spin_lock(&new_oi->ip_lock);
         new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL | OCFS2_INLINE_XATTR_FL;
         new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features);