ocfs2: Remove xattrs via ocfs2_xa_loc
[linux-2.6.git] / fs / ocfs2 / xattr.c
index ba9b870..22a60a7 100644 (file)
@@ -42,6 +42,7 @@
 
 #include "ocfs2.h"
 #include "alloc.h"
+#include "blockcheck.h"
 #include "dlmglue.h"
 #include "file.h"
 #include "symlink.h"
@@ -54,7 +55,8 @@
 #include "buffer_head_io.h"
 #include "super.h"
 #include "xattr.h"
-
+#include "refcounttree.h"
+#include "acl.h"
 
 struct ocfs2_xattr_def_value_root {
        struct ocfs2_xattr_value_root   xv;
@@ -81,9 +83,14 @@ struct ocfs2_xattr_set_ctxt {
 
 #define OCFS2_XATTR_ROOT_SIZE  (sizeof(struct ocfs2_xattr_def_value_root))
 #define OCFS2_XATTR_INLINE_SIZE        80
+#define OCFS2_XATTR_HEADER_GAP 4
 #define OCFS2_XATTR_FREE_IN_IBODY      (OCFS2_MIN_XATTR_INLINE_SIZE \
                                         - sizeof(struct ocfs2_xattr_header) \
-                                        - sizeof(__u32))
+                                        - OCFS2_XATTR_HEADER_GAP)
+#define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \
+                                        - sizeof(struct ocfs2_xattr_block) \
+                                        - sizeof(struct ocfs2_xattr_header) \
+                                        - OCFS2_XATTR_HEADER_GAP)
 
 static struct ocfs2_xattr_def_value_root def_xv = {
        .xv.xr_list.l_count = cpu_to_le16(1),
@@ -91,6 +98,8 @@ static struct ocfs2_xattr_def_value_root def_xv = {
 
 struct xattr_handler *ocfs2_xattr_handlers[] = {
        &ocfs2_xattr_user_handler,
+       &ocfs2_xattr_acl_access_handler,
+       &ocfs2_xattr_acl_default_handler,
        &ocfs2_xattr_trusted_handler,
        &ocfs2_xattr_security_handler,
        NULL
@@ -98,6 +107,10 @@ struct xattr_handler *ocfs2_xattr_handlers[] = {
 
 static struct xattr_handler *ocfs2_xattr_handler_map[OCFS2_XATTR_MAX] = {
        [OCFS2_XATTR_INDEX_USER]        = &ocfs2_xattr_user_handler,
+       [OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS]
+                                       = &ocfs2_xattr_acl_access_handler,
+       [OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT]
+                                       = &ocfs2_xattr_acl_default_handler,
        [OCFS2_XATTR_INDEX_TRUSTED]     = &ocfs2_xattr_trusted_handler,
        [OCFS2_XATTR_INDEX_SECURITY]    = &ocfs2_xattr_security_handler,
 };
@@ -124,7 +137,52 @@ struct ocfs2_xattr_search {
        int not_found;
 };
 
-static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
+/* Operations on struct ocfs2_xa_entry */
+struct ocfs2_xa_loc;
+struct ocfs2_xa_loc_operations {
+       /*
+        * Return a pointer to the appropriate buffer in loc->xl_storage
+        * at the given offset from loc->xl_header.
+        */
+       void *(*xlo_offset_pointer)(struct ocfs2_xa_loc *loc, int offset);
+
+       /*
+        * Remove the name+value at this location.  Do whatever is
+        * appropriate with the remaining name+value pairs.
+        */
+       void (*xlo_wipe_namevalue)(struct ocfs2_xa_loc *loc);
+};
+
+/*
+ * Describes an xattr entry location.  This is a memory structure
+ * tracking the on-disk structure.
+ */
+struct ocfs2_xa_loc {
+       /* The ocfs2_xattr_header inside the on-disk storage. Not NULL. */
+       struct ocfs2_xattr_header *xl_header;
+
+       /* Bytes from xl_header to the end of the storage */
+       int xl_size;
+
+       /*
+        * The ocfs2_xattr_entry this location describes.  If this is
+        * NULL, this location describes the on-disk structure where it
+        * would have been.
+        */
+       struct ocfs2_xattr_entry *xl_entry;
+
+       /*
+        * Internal housekeeping
+        */
+
+       /* Buffer(s) containing this entry */
+       void *xl_storage;
+
+       /* Operations on the storage backing this location */
+       const struct ocfs2_xa_loc_operations *xl_ops;
+};
+
+static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb,
                                             struct ocfs2_xattr_header *xh,
                                             int index,
                                             int *block_off,
@@ -141,7 +199,7 @@ static int ocfs2_xattr_index_block_find(struct inode *inode,
                                        struct ocfs2_xattr_search *xs);
 
 static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
-                                       struct ocfs2_xattr_tree_root *xt,
+                                       struct buffer_head *blk_bh,
                                        char *buffer,
                                        size_t buffer_size);
 
@@ -154,8 +212,40 @@ static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
                                             struct ocfs2_xattr_search *xs,
                                             struct ocfs2_xattr_set_ctxt *ctxt);
 
-static int ocfs2_delete_xattr_index_block(struct inode *inode,
-                                         struct buffer_head *xb_bh);
+typedef int (xattr_tree_rec_func)(struct inode *inode,
+                                 struct buffer_head *root_bh,
+                                 u64 blkno, u32 cpos, u32 len, void *para);
+static int ocfs2_iterate_xattr_index_block(struct inode *inode,
+                                          struct buffer_head *root_bh,
+                                          xattr_tree_rec_func *rec_func,
+                                          void *para);
+static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
+                                       struct ocfs2_xattr_bucket *bucket,
+                                       void *para);
+static int ocfs2_rm_xattr_cluster(struct inode *inode,
+                                 struct buffer_head *root_bh,
+                                 u64 blkno,
+                                 u32 cpos,
+                                 u32 len,
+                                 void *para);
+
+static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle,
+                                 u64 src_blk, u64 last_blk, u64 to_blk,
+                                 unsigned int start_bucket,
+                                 u32 *first_hash);
+static int ocfs2_prepare_refcount_xattr(struct inode *inode,
+                                       struct ocfs2_dinode *di,
+                                       struct ocfs2_xattr_info *xi,
+                                       struct ocfs2_xattr_search *xis,
+                                       struct ocfs2_xattr_search *xbs,
+                                       struct ocfs2_refcount_tree **ref_tree,
+                                       int *meta_need,
+                                       int *credits);
+static int ocfs2_get_xattr_tree_value_root(struct super_block *sb,
+                                          struct ocfs2_xattr_bucket *bucket,
+                                          int offset,
+                                          struct ocfs2_xattr_value_root **xv,
+                                          struct buffer_head **bh);
 
 static inline u16 ocfs2_xattr_buckets_per_cluster(struct ocfs2_super *osb)
 {
@@ -234,9 +324,9 @@ static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
                        break;
                }
 
-               if (!ocfs2_buffer_uptodate(bucket->bu_inode,
+               if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
                                           bucket->bu_bhs[i]))
-                       ocfs2_set_new_buffer_uptodate(bucket->bu_inode,
+                       ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
                                                      bucket->bu_bhs[i]);
        }
 
@@ -251,8 +341,20 @@ static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
 {
        int rc;
 
-       rc = ocfs2_read_blocks(bucket->bu_inode, xb_blkno,
-                              bucket->bu_blocks, bucket->bu_bhs, 0);
+       rc = ocfs2_read_blocks(INODE_CACHE(bucket->bu_inode), xb_blkno,
+                              bucket->bu_blocks, bucket->bu_bhs, 0,
+                              NULL);
+       if (!rc) {
+               spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
+               rc = ocfs2_validate_meta_ecc_bhs(bucket->bu_inode->i_sb,
+                                                bucket->bu_bhs,
+                                                bucket->bu_blocks,
+                                                &bucket_xh(bucket)->xh_check);
+               spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
+               if (rc)
+                       mlog_errno(rc);
+       }
+
        if (rc)
                ocfs2_xattr_bucket_relse(bucket);
        return rc;
@@ -265,7 +367,8 @@ static int ocfs2_xattr_bucket_journal_access(handle_t *handle,
        int i, rc = 0;
 
        for (i = 0; i < bucket->bu_blocks; i++) {
-               rc = ocfs2_journal_access(handle, bucket->bu_inode,
+               rc = ocfs2_journal_access(handle,
+                                         INODE_CACHE(bucket->bu_inode),
                                          bucket->bu_bhs[i], type);
                if (rc) {
                        mlog_errno(rc);
@@ -281,6 +384,12 @@ static void ocfs2_xattr_bucket_journal_dirty(handle_t *handle,
 {
        int i;
 
+       spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
+       ocfs2_compute_meta_ecc_bhs(bucket->bu_inode->i_sb,
+                                  bucket->bu_bhs, bucket->bu_blocks,
+                                  &bucket_xh(bucket)->xh_check);
+       spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
+
        for (i = 0; i < bucket->bu_blocks; i++)
                ocfs2_journal_dirty(handle, bucket->bu_bhs[i]);
 }
@@ -300,6 +409,77 @@ static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket *dest,
        }
 }
 
+static int ocfs2_validate_xattr_block(struct super_block *sb,
+                                     struct buffer_head *bh)
+{
+       int rc;
+       struct ocfs2_xattr_block *xb =
+               (struct ocfs2_xattr_block *)bh->b_data;
+
+       mlog(0, "Validating xattr block %llu\n",
+            (unsigned long long)bh->b_blocknr);
+
+       BUG_ON(!buffer_uptodate(bh));
+
+       /*
+        * If the ecc fails, we return the error but otherwise
+        * leave the filesystem running.  We know any error is
+        * local to this block.
+        */
+       rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &xb->xb_check);
+       if (rc)
+               return rc;
+
+       /*
+        * Errors after here are fatal
+        */
+
+       if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) {
+               ocfs2_error(sb,
+                           "Extended attribute block #%llu has bad "
+                           "signature %.*s",
+                           (unsigned long long)bh->b_blocknr, 7,
+                           xb->xb_signature);
+               return -EINVAL;
+       }
+
+       if (le64_to_cpu(xb->xb_blkno) != bh->b_blocknr) {
+               ocfs2_error(sb,
+                           "Extended attribute block #%llu has an "
+                           "invalid xb_blkno of %llu",
+                           (unsigned long long)bh->b_blocknr,
+                           (unsigned long long)le64_to_cpu(xb->xb_blkno));
+               return -EINVAL;
+       }
+
+       if (le32_to_cpu(xb->xb_fs_generation) != OCFS2_SB(sb)->fs_generation) {
+               ocfs2_error(sb,
+                           "Extended attribute block #%llu has an invalid "
+                           "xb_fs_generation of #%u",
+                           (unsigned long long)bh->b_blocknr,
+                           le32_to_cpu(xb->xb_fs_generation));
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static int ocfs2_read_xattr_block(struct inode *inode, u64 xb_blkno,
+                                 struct buffer_head **bh)
+{
+       int rc;
+       struct buffer_head *tmp = *bh;
+
+       rc = ocfs2_read_block(INODE_CACHE(inode), xb_blkno, &tmp,
+                             ocfs2_validate_xattr_block);
+
+       /* If ocfs2_read_block() got us a new bh, pass it up. */
+       if (!rc && !*bh)
+               *bh = tmp;
+
+       return rc;
+}
+
 static inline const char *ocfs2_xattr_prefix(int name_index)
 {
        struct xattr_handler *handler = NULL;
@@ -386,44 +566,127 @@ int ocfs2_calc_security_init(struct inode *dir,
        }
 
        /* reserve clusters for xattr value which will be set in B tree*/
-       if (si->value_len > OCFS2_XATTR_INLINE_SIZE)
-               *want_clusters += ocfs2_clusters_for_bytes(dir->i_sb,
-                                                          si->value_len);
+       if (si->value_len > OCFS2_XATTR_INLINE_SIZE) {
+               int new_clusters = ocfs2_clusters_for_bytes(dir->i_sb,
+                                                           si->value_len);
+
+               *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
+                                                          new_clusters);
+               *want_clusters += new_clusters;
+       }
+       return ret;
+}
+
+int ocfs2_calc_xattr_init(struct inode *dir,
+                         struct buffer_head *dir_bh,
+                         int mode,
+                         struct ocfs2_security_xattr_info *si,
+                         int *want_clusters,
+                         int *xattr_credits,
+                         int *want_meta)
+{
+       int ret = 0;
+       struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
+       int s_size = 0, a_size = 0, acl_len = 0, new_clusters;
+
+       if (si->enable)
+               s_size = ocfs2_xattr_entry_real_size(strlen(si->name),
+                                                    si->value_len);
+
+       if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) {
+               acl_len = ocfs2_xattr_get_nolock(dir, dir_bh,
+                                       OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
+                                       "", NULL, 0);
+               if (acl_len > 0) {
+                       a_size = ocfs2_xattr_entry_real_size(0, acl_len);
+                       if (S_ISDIR(mode))
+                               a_size <<= 1;
+               } else if (acl_len != 0 && acl_len != -ENODATA) {
+                       mlog_errno(ret);
+                       return ret;
+               }
+       }
+
+       if (!(s_size + a_size))
+               return ret;
+
+       /*
+        * The max space of security xattr taken inline is
+        * 256(name) + 80(value) + 16(entry) = 352 bytes,
+        * The max space of acl xattr taken inline is
+        * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
+        * when blocksize = 512, may reserve one more cluser for
+        * xattr bucket, otherwise reserve one metadata block
+        * for them is ok.
+        * If this is a new directory with inline data,
+        * we choose to reserve the entire inline area for
+        * directory contents and force an external xattr block.
+        */
+       if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE ||
+           (S_ISDIR(mode) && ocfs2_supports_inline_data(osb)) ||
+           (s_size + a_size) > OCFS2_XATTR_FREE_IN_IBODY) {
+               *want_meta = *want_meta + 1;
+               *xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
+       }
+
+       if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE &&
+           (s_size + a_size) > OCFS2_XATTR_FREE_IN_BLOCK(dir)) {
+               *want_clusters += 1;
+               *xattr_credits += ocfs2_blocks_per_xattr_bucket(dir->i_sb);
+       }
+
+       /*
+        * reserve credits and clusters for xattrs which has large value
+        * and have to be set outside
+        */
+       if (si->enable && si->value_len > OCFS2_XATTR_INLINE_SIZE) {
+               new_clusters = ocfs2_clusters_for_bytes(dir->i_sb,
+                                                       si->value_len);
+               *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
+                                                          new_clusters);
+               *want_clusters += new_clusters;
+       }
+       if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL &&
+           acl_len > OCFS2_XATTR_INLINE_SIZE) {
+               /* for directory, it has DEFAULT and ACCESS two types of acls */
+               new_clusters = (S_ISDIR(mode) ? 2 : 1) *
+                               ocfs2_clusters_for_bytes(dir->i_sb, acl_len);
+               *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
+                                                          new_clusters);
+               *want_clusters += new_clusters;
+       }
+
        return ret;
 }
 
 static int ocfs2_xattr_extend_allocation(struct inode *inode,
                                         u32 clusters_to_add,
-                                        struct buffer_head *xattr_bh,
-                                        struct ocfs2_xattr_value_root *xv,
+                                        struct ocfs2_xattr_value_buf *vb,
                                         struct ocfs2_xattr_set_ctxt *ctxt)
 {
        int status = 0;
        handle_t *handle = ctxt->handle;
        enum ocfs2_alloc_restarted why;
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-       u32 prev_clusters, logical_start = le32_to_cpu(xv->xr_clusters);
+       u32 prev_clusters, logical_start = le32_to_cpu(vb->vb_xv->xr_clusters);
        struct ocfs2_extent_tree et;
 
        mlog(0, "(clusters_to_add for xattr= %u)\n", clusters_to_add);
 
-       ocfs2_init_xattr_value_extent_tree(&et, inode, xattr_bh, xv);
+       ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
 
-       status = ocfs2_journal_access(handle, inode, xattr_bh,
-                                     OCFS2_JOURNAL_ACCESS_WRITE);
+       status = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
+                             OCFS2_JOURNAL_ACCESS_WRITE);
        if (status < 0) {
                mlog_errno(status);
                goto leave;
        }
 
-       prev_clusters = le32_to_cpu(xv->xr_clusters);
-       status = ocfs2_add_clusters_in_btree(osb,
-                                            inode,
+       prev_clusters = le32_to_cpu(vb->vb_xv->xr_clusters);
+       status = ocfs2_add_clusters_in_btree(handle,
+                                            &et,
                                             &logical_start,
                                             clusters_to_add,
                                             0,
-                                            &et,
-                                            handle,
                                             ctxt->data_ac,
                                             ctxt->meta_ac,
                                             &why);
@@ -432,13 +695,13 @@ static int ocfs2_xattr_extend_allocation(struct inode *inode,
                goto leave;
        }
 
-       status = ocfs2_journal_dirty(handle, xattr_bh);
+       status = ocfs2_journal_dirty(handle, vb->vb_bh);
        if (status < 0) {
                mlog_errno(status);
                goto leave;
        }
 
-       clusters_to_add -= le32_to_cpu(xv->xr_clusters) - prev_clusters;
+       clusters_to_add -= le32_to_cpu(vb->vb_xv->xr_clusters) - prev_clusters;
 
        /*
         * We should have already allocated enough space before the transaction,
@@ -452,9 +715,9 @@ leave:
 }
 
 static int __ocfs2_remove_xattr_range(struct inode *inode,
-                                     struct buffer_head *root_bh,
-                                     struct ocfs2_xattr_value_root *xv,
+                                     struct ocfs2_xattr_value_buf *vb,
                                      u32 cpos, u32 phys_cpos, u32 len,
+                                     unsigned int ext_flags,
                                      struct ocfs2_xattr_set_ctxt *ctxt)
 {
        int ret;
@@ -462,31 +725,38 @@ static int __ocfs2_remove_xattr_range(struct inode *inode,
        handle_t *handle = ctxt->handle;
        struct ocfs2_extent_tree et;
 
-       ocfs2_init_xattr_value_extent_tree(&et, inode, root_bh, xv);
+       ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
 
-       ret = ocfs2_journal_access(handle, inode, root_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
+                           OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, ctxt->meta_ac,
+       ret = ocfs2_remove_extent(handle, &et, cpos, len, ctxt->meta_ac,
                                  &ctxt->dealloc);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       le32_add_cpu(&xv->xr_clusters, -len);
+       le32_add_cpu(&vb->vb_xv->xr_clusters, -len);
 
-       ret = ocfs2_journal_dirty(handle, root_bh);
+       ret = ocfs2_journal_dirty(handle, vb->vb_bh);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_cache_cluster_dealloc(&ctxt->dealloc, phys_blkno, len);
+       if (ext_flags & OCFS2_EXT_REFCOUNTED)
+               ret = ocfs2_decrease_refcount(inode, handle,
+                                       ocfs2_blocks_to_clusters(inode->i_sb,
+                                                                phys_blkno),
+                                       len, ctxt->meta_ac, &ctxt->dealloc, 1);
+       else
+               ret = ocfs2_cache_cluster_dealloc(&ctxt->dealloc,
+                                                 phys_blkno, len);
        if (ret)
                mlog_errno(ret);
 
@@ -497,11 +767,11 @@ out:
 static int ocfs2_xattr_shrink_size(struct inode *inode,
                                   u32 old_clusters,
                                   u32 new_clusters,
-                                  struct buffer_head *root_bh,
-                                  struct ocfs2_xattr_value_root *xv,
+                                  struct ocfs2_xattr_value_buf *vb,
                                   struct ocfs2_xattr_set_ctxt *ctxt)
 {
        int ret = 0;
+       unsigned int ext_flags;
        u32 trunc_len, cpos, phys_cpos, alloc_size;
        u64 block;
 
@@ -512,7 +782,8 @@ static int ocfs2_xattr_shrink_size(struct inode *inode,
        trunc_len = old_clusters - new_clusters;
        while (trunc_len) {
                ret = ocfs2_xattr_get_clusters(inode, cpos, &phys_cpos,
-                                              &alloc_size, &xv->xr_list);
+                                              &alloc_size,
+                                              &vb->vb_xv->xr_list, &ext_flags);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -521,17 +792,17 @@ static int ocfs2_xattr_shrink_size(struct inode *inode,
                if (alloc_size > trunc_len)
                        alloc_size = trunc_len;
 
-               ret = __ocfs2_remove_xattr_range(inode, root_bh, xv, cpos,
+               ret = __ocfs2_remove_xattr_range(inode, vb, cpos,
                                                 phys_cpos, alloc_size,
-                                                ctxt);
+                                                ext_flags, ctxt);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
 
                block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
-               ocfs2_remove_xattr_clusters_from_cache(inode, block,
-                                                      alloc_size);
+               ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode),
+                                                      block, alloc_size);
                cpos += alloc_size;
                trunc_len -= alloc_size;
        }
@@ -541,14 +812,13 @@ out:
 }
 
 static int ocfs2_xattr_value_truncate(struct inode *inode,
-                                     struct buffer_head *root_bh,
-                                     struct ocfs2_xattr_value_root *xv,
+                                     struct ocfs2_xattr_value_buf *vb,
                                      int len,
                                      struct ocfs2_xattr_set_ctxt *ctxt)
 {
        int ret;
        u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len);
-       u32 old_clusters = le32_to_cpu(xv->xr_clusters);
+       u32 old_clusters = le32_to_cpu(vb->vb_xv->xr_clusters);
 
        if (new_clusters == old_clusters)
                return 0;
@@ -556,11 +826,11 @@ static int ocfs2_xattr_value_truncate(struct inode *inode,
        if (new_clusters > old_clusters)
                ret = ocfs2_xattr_extend_allocation(inode,
                                                    new_clusters - old_clusters,
-                                                   root_bh, xv, ctxt);
+                                                   vb, ctxt);
        else
                ret = ocfs2_xattr_shrink_size(inode,
                                              old_clusters, new_clusters,
-                                             root_bh, xv, ctxt);
+                                             vb, ctxt);
 
        return ret;
 }
@@ -617,6 +887,23 @@ static int ocfs2_xattr_list_entries(struct inode *inode,
        return result;
 }
 
+int ocfs2_has_inline_xattr_value_outside(struct inode *inode,
+                                        struct ocfs2_dinode *di)
+{
+       struct ocfs2_xattr_header *xh;
+       int i;
+
+       xh = (struct ocfs2_xattr_header *)
+                ((void *)di + inode->i_sb->s_blocksize -
+                le16_to_cpu(di->i_xattr_inline_size));
+
+       for (i = 0; i < le16_to_cpu(xh->xh_count); i++)
+               if (!ocfs2_xattr_is_local(&xh->xh_entries[i]))
+                       return 1;
+
+       return 0;
+}
+
 static int ocfs2_xattr_ibody_list(struct inode *inode,
                                  struct ocfs2_dinode *di,
                                  char *buffer,
@@ -650,28 +937,22 @@ static int ocfs2_xattr_block_list(struct inode *inode,
        if (!di->i_xattr_loc)
                return ret;
 
-       ret = ocfs2_read_block(inode, le64_to_cpu(di->i_xattr_loc), &blk_bh);
+       ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
+                                    &blk_bh);
        if (ret < 0) {
                mlog_errno(ret);
                return ret;
        }
 
        xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
-       if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) {
-               ret = -EIO;
-               goto cleanup;
-       }
-
        if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
                struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
                ret = ocfs2_xattr_list_entries(inode, header,
                                               buffer, buffer_size);
-       } else {
-               struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
-               ret = ocfs2_xattr_tree_list_index_block(inode, xt,
+       } else
+               ret = ocfs2_xattr_tree_list_index_block(inode, blk_bh,
                                                   buffer, buffer_size);
-       }
-cleanup:
+
        brelse(blk_bh);
 
        return ret;
@@ -772,7 +1053,7 @@ static int ocfs2_xattr_get_value_outside(struct inode *inode,
        cpos = 0;
        while (cpos < clusters) {
                ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
-                                              &num_clusters, el);
+                                              &num_clusters, el, NULL);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -781,7 +1062,8 @@ static int ocfs2_xattr_get_value_outside(struct inode *inode,
                blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
                /* Copy ocfs2_xattr_value */
                for (i = 0; i < num_clusters * bpc; i++, blkno++) {
-                       ret = ocfs2_read_block(inode, blkno, &bh);
+                       ret = ocfs2_read_block(INODE_CACHE(inode), blkno,
+                                              &bh, NULL);
                        if (ret) {
                                mlog_errno(ret);
                                goto out;
@@ -863,7 +1145,8 @@ static int ocfs2_xattr_block_get(struct inode *inode,
        struct ocfs2_xattr_block *xb;
        struct ocfs2_xattr_value_root *xv;
        size_t size;
-       int ret = -ENODATA, name_offset, name_len, block_off, i;
+       int ret = -ENODATA, name_offset, name_len, i;
+       int uninitialized_var(block_off);
 
        xs->bucket = ocfs2_xattr_bucket_new(inode);
        if (!xs->bucket) {
@@ -895,7 +1178,7 @@ static int ocfs2_xattr_block_get(struct inode *inode,
                i = xs->here - xs->header->xh_entries;
 
                if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
-                       ret = ocfs2_xattr_bucket_get_name_value(inode,
+                       ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
                                                                bucket_xh(xs->bucket),
                                                                i,
                                                                &block_off,
@@ -993,51 +1276,45 @@ static int ocfs2_xattr_get(struct inode *inode,
 
 static int __ocfs2_xattr_set_value_outside(struct inode *inode,
                                           handle_t *handle,
-                                          struct ocfs2_xattr_value_root *xv,
+                                          struct ocfs2_xattr_value_buf *vb,
                                           const void *value,
                                           int value_len)
 {
-       int ret = 0, i, cp_len, credits;
+       int ret = 0, i, cp_len;
        u16 blocksize = inode->i_sb->s_blocksize;
        u32 p_cluster, num_clusters;
        u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
        u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len);
        u64 blkno;
        struct buffer_head *bh = NULL;
+       unsigned int ext_flags;
+       struct ocfs2_xattr_value_root *xv = vb->vb_xv;
 
        BUG_ON(clusters > le32_to_cpu(xv->xr_clusters));
 
-       /*
-        * In __ocfs2_xattr_set_value_outside has already been dirtied,
-        * so we don't need to worry about whether ocfs2_extend_trans
-        * will create a new transactio for us or not.
-        */
-       credits = clusters * bpc;
-       ret = ocfs2_extend_trans(handle, credits);
-       if (ret) {
-               mlog_errno(ret);
-               goto out;
-       }
-
        while (cpos < clusters) {
                ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
-                                              &num_clusters, &xv->xr_list);
+                                              &num_clusters, &xv->xr_list,
+                                              &ext_flags);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
 
+               BUG_ON(ext_flags & OCFS2_EXT_REFCOUNTED);
+
                blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
 
                for (i = 0; i < num_clusters * bpc; i++, blkno++) {
-                       ret = ocfs2_read_block(inode, blkno, &bh);
+                       ret = ocfs2_read_block(INODE_CACHE(inode), blkno,
+                                              &bh, NULL);
                        if (ret) {
                                mlog_errno(ret);
                                goto out;
                        }
 
                        ret = ocfs2_journal_access(handle,
-                                                  inode,
+                                                  INODE_CACHE(inode),
                                                   bh,
                                                   OCFS2_JOURNAL_ACCESS_WRITE);
                        if (ret < 0) {
@@ -1080,6 +1357,7 @@ static int ocfs2_xattr_cleanup(struct inode *inode,
                               handle_t *handle,
                               struct ocfs2_xattr_info *xi,
                               struct ocfs2_xattr_search *xs,
+                              struct ocfs2_xattr_value_buf *vb,
                               size_t offs)
 {
        int ret = 0;
@@ -1087,8 +1365,8 @@ static int ocfs2_xattr_cleanup(struct inode *inode,
        void *val = xs->base + offs;
        size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
 
-       ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
+                           OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -1099,7 +1377,7 @@ static int ocfs2_xattr_cleanup(struct inode *inode,
        memset((void *)xs->here, 0, sizeof(struct ocfs2_xattr_entry));
        memset(val, 0, size);
 
-       ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
+       ret = ocfs2_journal_dirty(handle, vb->vb_bh);
        if (ret < 0)
                mlog_errno(ret);
 out:
@@ -1110,12 +1388,13 @@ static int ocfs2_xattr_update_entry(struct inode *inode,
                                    handle_t *handle,
                                    struct ocfs2_xattr_info *xi,
                                    struct ocfs2_xattr_search *xs,
+                                   struct ocfs2_xattr_value_buf *vb,
                                    size_t offs)
 {
        int ret;
 
-       ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
+                           OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -1129,7 +1408,7 @@ static int ocfs2_xattr_update_entry(struct inode *inode,
                ocfs2_xattr_set_local(xs->here, 0);
        ocfs2_xattr_hash_entry(inode, xs->header, xs->here);
 
-       ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
+       ret = ocfs2_journal_dirty(handle, vb->vb_bh);
        if (ret < 0)
                mlog_errno(ret);
 out:
@@ -1145,6 +1424,7 @@ static int ocfs2_xattr_set_value_outside(struct inode *inode,
                                         struct ocfs2_xattr_info *xi,
                                         struct ocfs2_xattr_search *xs,
                                         struct ocfs2_xattr_set_ctxt *ctxt,
+                                        struct ocfs2_xattr_value_buf *vb,
                                         size_t offs)
 {
        size_t name_len = strlen(xi->name);
@@ -1162,19 +1442,19 @@ static int ocfs2_xattr_set_value_outside(struct inode *inode,
        xv->xr_list.l_tree_depth = 0;
        xv->xr_list.l_count = cpu_to_le16(1);
        xv->xr_list.l_next_free_rec = 0;
+       vb->vb_xv = xv;
 
-       ret = ocfs2_xattr_value_truncate(inode, xs->xattr_bh, xv,
-                                        xi->value_len, ctxt);
+       ret = ocfs2_xattr_value_truncate(inode, vb, xi->value_len, ctxt);
        if (ret < 0) {
                mlog_errno(ret);
                return ret;
        }
-       ret = ocfs2_xattr_update_entry(inode, ctxt->handle, xi, xs, offs);
+       ret = ocfs2_xattr_update_entry(inode, ctxt->handle, xi, xs, vb, offs);
        if (ret < 0) {
                mlog_errno(ret);
                return ret;
        }
-       ret = __ocfs2_xattr_set_value_outside(inode, ctxt->handle, xv,
+       ret = __ocfs2_xattr_set_value_outside(inode, ctxt->handle, vb,
                                              xi->value, xi->value_len);
        if (ret < 0)
                mlog_errno(ret);
@@ -1183,6 +1463,192 @@ static int ocfs2_xattr_set_value_outside(struct inode *inode,
 }
 
 /*
+ * Wipe the name+value pair and allow the storage to reclaim it.  This
+ * must be followed by either removal of the entry or a call to
+ * ocfs2_xa_add_namevalue().
+ */
+static void ocfs2_xa_wipe_namevalue(struct ocfs2_xa_loc *loc)
+{
+       loc->xl_ops->xlo_wipe_namevalue(loc);
+}
+
+static void *ocfs2_xa_block_offset_pointer(struct ocfs2_xa_loc *loc,
+                                          int offset)
+{
+       BUG_ON(offset >= loc->xl_size);
+       return (char *)loc->xl_header + offset;
+}
+
+/*
+ * Block storage for xattrs keeps the name+value pairs compacted.  When
+ * we remove one, we have to shift any that preceded it towards the end.
+ */
+static void ocfs2_xa_block_wipe_namevalue(struct ocfs2_xa_loc *loc)
+{
+       int i, offset;
+       int namevalue_offset, first_namevalue_offset, namevalue_size;
+       struct ocfs2_xattr_entry *entry = loc->xl_entry;
+       struct ocfs2_xattr_header *xh = loc->xl_header;
+       u64 value_size = le64_to_cpu(entry->xe_value_size);
+       int count = le16_to_cpu(xh->xh_count);
+
+       namevalue_offset = le16_to_cpu(entry->xe_name_offset);
+       namevalue_size = OCFS2_XATTR_SIZE(entry->xe_name_len);
+       if (value_size > OCFS2_XATTR_INLINE_SIZE)
+               namevalue_size += OCFS2_XATTR_ROOT_SIZE;
+       else
+               namevalue_size += OCFS2_XATTR_SIZE(value_size);
+
+       for (i = 0, first_namevalue_offset = loc->xl_size;
+            i < count; i++) {
+               offset = le16_to_cpu(xh->xh_entries[i].xe_name_offset);
+               if (offset < first_namevalue_offset)
+                       first_namevalue_offset = offset;
+       }
+
+       /* Shift the name+value pairs */
+       memmove((char *)xh + first_namevalue_offset + namevalue_size,
+               (char *)xh + first_namevalue_offset,
+               namevalue_offset - first_namevalue_offset);
+       memset((char *)xh + first_namevalue_offset, 0, namevalue_size);
+
+       /* Now tell xh->xh_entries about it */
+       for (i = 0; i < count; i++) {
+               offset = le16_to_cpu(xh->xh_entries[i].xe_name_offset);
+               if (offset < namevalue_offset)
+                       le16_add_cpu(&xh->xh_entries[i].xe_name_offset,
+                                    namevalue_size);
+       }
+
+       /*
+        * Note that we don't update xh_free_start or xh_name_value_len
+        * because they're not used in block-stored xattrs.
+        */
+}
+
+/*
+ * Operations for xattrs stored in blocks.  This includes inline inode
+ * storage and unindexed ocfs2_xattr_blocks.
+ */
+static const struct ocfs2_xa_loc_operations ocfs2_xa_block_loc_ops = {
+       .xlo_offset_pointer     = ocfs2_xa_block_offset_pointer,
+       .xlo_wipe_namevalue     = ocfs2_xa_block_wipe_namevalue,
+};
+
+static void *ocfs2_xa_bucket_offset_pointer(struct ocfs2_xa_loc *loc,
+                                           int offset)
+{
+       struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
+       int block, block_offset;
+
+       BUG_ON(offset >= OCFS2_XATTR_BUCKET_SIZE);
+
+       /* The header is at the front of the bucket */
+       block = offset >> bucket->bu_inode->i_sb->s_blocksize_bits;
+       block_offset = offset % bucket->bu_inode->i_sb->s_blocksize;
+
+       return bucket_block(bucket, block) + block_offset;
+}
+
+static void ocfs2_xa_bucket_wipe_namevalue(struct ocfs2_xa_loc *loc)
+{
+       int namevalue_size;
+       struct ocfs2_xattr_entry *entry = loc->xl_entry;
+       u64 value_size = le64_to_cpu(entry->xe_value_size);
+
+       namevalue_size = OCFS2_XATTR_SIZE(entry->xe_name_len);
+       if (value_size > OCFS2_XATTR_INLINE_SIZE)
+               namevalue_size += OCFS2_XATTR_ROOT_SIZE;
+       else
+               namevalue_size += OCFS2_XATTR_SIZE(value_size);
+
+       le16_add_cpu(&loc->xl_header->xh_name_value_len, -namevalue_size);
+}
+
+/* Operations for xattrs stored in buckets. */
+static const struct ocfs2_xa_loc_operations ocfs2_xa_bucket_loc_ops = {
+       .xlo_offset_pointer     = ocfs2_xa_bucket_offset_pointer,
+       .xlo_wipe_namevalue     = ocfs2_xa_bucket_wipe_namevalue,
+};
+
+static void ocfs2_xa_remove_entry(struct ocfs2_xa_loc *loc)
+{
+       int index, count;
+       struct ocfs2_xattr_header *xh = loc->xl_header;
+       struct ocfs2_xattr_entry *entry = loc->xl_entry;
+
+       ocfs2_xa_wipe_namevalue(loc);
+       loc->xl_entry = NULL;
+
+       le16_add_cpu(&xh->xh_count, -1);
+       count = le16_to_cpu(xh->xh_count);
+
+       /*
+        * Only zero out the entry if there are more remaining.  This is
+        * important for an empty bucket, as it keeps track of the
+        * bucket's hash value.  It doesn't hurt empty block storage.
+        */
+       if (count) {
+               index = ((char *)entry - (char *)&xh->xh_entries) /
+                       sizeof(struct ocfs2_xattr_entry);
+               memmove(&xh->xh_entries[index], &xh->xh_entries[index + 1],
+                       (count - index) * sizeof(struct ocfs2_xattr_entry));
+               memset(&xh->xh_entries[count], 0,
+                      sizeof(struct ocfs2_xattr_entry));
+       }
+}
+
+static void ocfs2_init_dinode_xa_loc(struct ocfs2_xa_loc *loc,
+                                    struct inode *inode,
+                                    struct buffer_head *bh,
+                                    struct ocfs2_xattr_entry *entry)
+{
+       struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;
+
+       loc->xl_ops = &ocfs2_xa_block_loc_ops;
+       loc->xl_storage = bh;
+       loc->xl_entry = entry;
+
+       if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_XATTR_FL)
+               loc->xl_size = le16_to_cpu(di->i_xattr_inline_size);
+       else {
+               BUG_ON(entry);
+               loc->xl_size = OCFS2_SB(inode->i_sb)->s_xattr_inline_size;
+       }
+       loc->xl_header =
+               (struct ocfs2_xattr_header *)(bh->b_data + bh->b_size -
+                                             loc->xl_size);
+}
+
+static void ocfs2_init_xattr_block_xa_loc(struct ocfs2_xa_loc *loc,
+                                         struct buffer_head *bh,
+                                         struct ocfs2_xattr_entry *entry)
+{
+       struct ocfs2_xattr_block *xb =
+               (struct ocfs2_xattr_block *)bh->b_data;
+
+       BUG_ON(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED);
+
+       loc->xl_ops = &ocfs2_xa_block_loc_ops;
+       loc->xl_storage = bh;
+       loc->xl_header = &(xb->xb_attrs.xb_header);
+       loc->xl_entry = entry;
+       loc->xl_size = bh->b_size - offsetof(struct ocfs2_xattr_block,
+                                            xb_attrs.xb_header);
+}
+
+static void ocfs2_init_xattr_bucket_xa_loc(struct ocfs2_xa_loc *loc,
+                                          struct ocfs2_xattr_bucket *bucket,
+                                          struct ocfs2_xattr_entry *entry)
+{
+       loc->xl_ops = &ocfs2_xa_bucket_loc_ops;
+       loc->xl_storage = bucket;
+       loc->xl_header = bucket_xh(bucket);
+       loc->xl_entry = entry;
+       loc->xl_size = OCFS2_XATTR_BUCKET_SIZE;
+}
+
+/*
  * ocfs2_xattr_set_entry_local()
  *
  * Set, replace or remove extended attribute in local.
@@ -1194,8 +1660,14 @@ static void ocfs2_xattr_set_entry_local(struct inode *inode,
                                        size_t min_offs)
 {
        size_t name_len = strlen(xi->name);
-       int i;
+       struct ocfs2_xa_loc loc;
 
+       if (xs->xattr_bh == xs->inode_bh)
+               ocfs2_init_dinode_xa_loc(&loc, inode, xs->inode_bh,
+                                        xs->not_found ? NULL : xs->here);
+       else
+               ocfs2_init_xattr_block_xa_loc(&loc, xs->xattr_bh,
+                                             xs->not_found ? NULL : xs->here);
        if (xi->value && xs->not_found) {
                /* Insert the new xattr entry. */
                le16_add_cpu(&xs->header->xh_count, 1);
@@ -1234,34 +1706,13 @@ static void ocfs2_xattr_set_entry_local(struct inode *inode,
                               xi->value_len);
                        return;
                }
-               /* Remove the old name+value. */
-               memmove(first_val + size, first_val, val - first_val);
-               memset(first_val, 0, size);
-               xs->here->xe_name_hash = 0;
-               xs->here->xe_name_offset = 0;
-               ocfs2_xattr_set_local(xs->here, 1);
-               xs->here->xe_value_size = 0;
 
-               min_offs += size;
-
-               /* Adjust all value offsets. */
-               last = xs->header->xh_entries;
-               for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) {
-                       size_t o = le16_to_cpu(last->xe_name_offset);
-
-                       if (o < offs)
-                               last->xe_name_offset = cpu_to_le16(o + size);
-                       last += 1;
-               }
+               if (!xi->value)
+                       ocfs2_xa_remove_entry(&loc);
+               else
+                       ocfs2_xa_wipe_namevalue(&loc);
 
-               if (!xi->value) {
-                       /* Remove the old entry. */
-                       last -= 1;
-                       memmove(xs->here, xs->here + 1,
-                               (void *)last - (void *)xs->here);
-                       memset(last, 0, sizeof(struct ocfs2_xattr_entry));
-                       le16_add_cpu(&xs->header->xh_count, -1);
-               }
+               min_offs += size;
        }
        if (xi->value) {
                /* Insert the new name+value. */
@@ -1311,6 +1762,16 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                .value = xi->value,
                .value_len = xi->value_len,
        };
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_bh = xs->xattr_bh,
+               .vb_access = ocfs2_journal_access_di,
+       };
+
+       if (!(flag & OCFS2_INLINE_XATTR_FL)) {
+               BUG_ON(xs->xattr_bh == xs->inode_bh);
+               vb.vb_access = ocfs2_journal_access_xb;
+       } else
+               BUG_ON(xs->xattr_bh != xs->inode_bh);
 
        /* Compute min_offs, last and free space. */
        last = xs->header->xh_entries;
@@ -1322,7 +1783,7 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                last += 1;
        }
 
-       free = min_offs - ((void *)last - xs->base) - sizeof(__u32);
+       free = min_offs - ((void *)last - xs->base) - OCFS2_XATTR_HEADER_GAP;
        if (free < 0)
                return -EIO;
 
@@ -1366,15 +1827,14 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                if (ocfs2_xattr_is_local(xs->here) && size == size_l) {
                        /* Replace existing local xattr with tree root */
                        ret = ocfs2_xattr_set_value_outside(inode, xi, xs,
-                                                           ctxt, offs);
+                                                           ctxt, &vb, offs);
                        if (ret < 0)
                                mlog_errno(ret);
                        goto out;
                } else if (!ocfs2_xattr_is_local(xs->here)) {
                        /* For existing xattr which has value outside */
-                       struct ocfs2_xattr_value_root *xv = NULL;
-                       xv = (struct ocfs2_xattr_value_root *)(val +
-                               OCFS2_XATTR_SIZE(name_len));
+                       vb.vb_xv = (struct ocfs2_xattr_value_root *)
+                               (val + OCFS2_XATTR_SIZE(name_len));
 
                        if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
                                /*
@@ -1383,8 +1843,7 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                                 * then set new value with set_value_outside().
                                 */
                                ret = ocfs2_xattr_value_truncate(inode,
-                                                                xs->xattr_bh,
-                                                                xv,
+                                                                &vb,
                                                                 xi->value_len,
                                                                 ctxt);
                                if (ret < 0) {
@@ -1396,6 +1855,7 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                                                               handle,
                                                               xi,
                                                               xs,
+                                                              &vb,
                                                               offs);
                                if (ret < 0) {
                                        mlog_errno(ret);
@@ -1404,7 +1864,7 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
 
                                ret = __ocfs2_xattr_set_value_outside(inode,
                                                                handle,
-                                                               xv,
+                                                               &vb,
                                                                xi->value,
                                                                xi->value_len);
                                if (ret < 0)
@@ -1416,8 +1876,7 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                                 * just trucate old value to zero.
                                 */
                                 ret = ocfs2_xattr_value_truncate(inode,
-                                                                 xs->xattr_bh,
-                                                                 xv,
+                                                                 &vb,
                                                                  0,
                                                                  ctxt);
                                if (ret < 0)
@@ -1426,16 +1885,16 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                }
        }
 
-       ret = ocfs2_journal_access(handle, inode, xs->inode_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), xs->inode_bh,
+                                     OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
        if (!(flag & OCFS2_INLINE_XATTR_FL)) {
-               ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
-                                          OCFS2_JOURNAL_ACCESS_WRITE);
+               ret = vb.vb_access(handle, INODE_CACHE(inode), vb.vb_bh,
+                                  OCFS2_JOURNAL_ACCESS_WRITE);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -1480,10 +1939,6 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
        oi->ip_dyn_features |= flag;
        di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
        spin_unlock(&oi->ip_lock);
-       /* Update inode ctime */
-       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);
 
        ret = ocfs2_journal_dirty(handle, xs->inode_bh);
        if (ret < 0)
@@ -1495,7 +1950,8 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                 * This is the second step for value size > INLINE_SIZE.
                 */
                size_t offs = le16_to_cpu(xs->here->xe_name_offset);
-               ret = ocfs2_xattr_set_value_outside(inode, xi, xs, ctxt, offs);
+               ret = ocfs2_xattr_set_value_outside(inode, xi, xs, ctxt,
+                                                   &vb, offs);
                if (ret < 0) {
                        int ret2;
 
@@ -1505,7 +1961,7 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                         * the junk tree root we have already set in local.
                         */
                        ret2 = ocfs2_xattr_cleanup(inode, ctxt->handle,
-                                                  xi, xs, offs);
+                                                  xi, xs, &vb, offs);
                        if (ret2 < 0)
                                mlog_errno(ret2);
                }
@@ -1514,85 +1970,171 @@ out:
        return ret;
 }
 
-static int ocfs2_remove_value_outside(struct inode*inode,
-                                     struct buffer_head *bh,
-                                     struct ocfs2_xattr_header *header)
+/*
+ * In xattr remove, if it is stored outside and refcounted, we may have
+ * the chance to split the refcount tree. So need the allocators.
+ */
+static int ocfs2_lock_xattr_remove_allocators(struct inode *inode,
+                                       struct ocfs2_xattr_value_root *xv,
+                                       struct ocfs2_caching_info *ref_ci,
+                                       struct buffer_head *ref_root_bh,
+                                       struct ocfs2_alloc_context **meta_ac,
+                                       int *ref_credits)
 {
-       int ret = 0, i;
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-       struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
+       int ret, meta_add = 0;
+       u32 p_cluster, num_clusters;
+       unsigned int ext_flags;
 
-       ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
+       *ref_credits = 0;
+       ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster,
+                                      &num_clusters,
+                                      &xv->xr_list,
+                                      &ext_flags);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
 
-       ctxt.handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
-       if (IS_ERR(ctxt.handle)) {
-               ret = PTR_ERR(ctxt.handle);
+       if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
+               goto out;
+
+       ret = ocfs2_refcounted_xattr_delete_need(inode, ref_ci,
+                                                ref_root_bh, xv,
+                                                &meta_add, ref_credits);
+       if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
+       ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(inode->i_sb),
+                                               meta_add, meta_ac);
+       if (ret)
+               mlog_errno(ret);
+
+out:
+       return ret;
+}
+
+static int ocfs2_remove_value_outside(struct inode*inode,
+                                     struct ocfs2_xattr_value_buf *vb,
+                                     struct ocfs2_xattr_header *header,
+                                     struct ocfs2_caching_info *ref_ci,
+                                     struct buffer_head *ref_root_bh)
+{
+       int ret = 0, i, ref_credits;
+       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
+       void *val;
+
+       ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
+
        for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
                struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
 
-               if (!ocfs2_xattr_is_local(entry)) {
-                       struct ocfs2_xattr_value_root *xv;
-                       void *val;
+               if (ocfs2_xattr_is_local(entry))
+                       continue;
 
-                       val = (void *)header +
-                               le16_to_cpu(entry->xe_name_offset);
-                       xv = (struct ocfs2_xattr_value_root *)
-                               (val + OCFS2_XATTR_SIZE(entry->xe_name_len));
-                       ret = ocfs2_xattr_value_truncate(inode, bh, xv,
-                                                        0, &ctxt);
-                       if (ret < 0) {
-                               mlog_errno(ret);
-                               break;
-                       }
+               val = (void *)header +
+                       le16_to_cpu(entry->xe_name_offset);
+               vb->vb_xv = (struct ocfs2_xattr_value_root *)
+                       (val + OCFS2_XATTR_SIZE(entry->xe_name_len));
+
+               ret = ocfs2_lock_xattr_remove_allocators(inode, vb->vb_xv,
+                                                        ref_ci, ref_root_bh,
+                                                        &ctxt.meta_ac,
+                                                        &ref_credits);
+
+               ctxt.handle = ocfs2_start_trans(osb, ref_credits +
+                                       ocfs2_remove_extent_credits(osb->sb));
+               if (IS_ERR(ctxt.handle)) {
+                       ret = PTR_ERR(ctxt.handle);
+                       mlog_errno(ret);
+                       break;
+               }
+
+               ret = ocfs2_xattr_value_truncate(inode, vb, 0, &ctxt);
+               if (ret < 0) {
+                       mlog_errno(ret);
+                       break;
+               }
+
+               ocfs2_commit_trans(osb, ctxt.handle);
+               if (ctxt.meta_ac) {
+                       ocfs2_free_alloc_context(ctxt.meta_ac);
+                       ctxt.meta_ac = NULL;
                }
        }
 
-       ocfs2_commit_trans(osb, ctxt.handle);
+       if (ctxt.meta_ac)
+               ocfs2_free_alloc_context(ctxt.meta_ac);
        ocfs2_schedule_truncate_log_flush(osb, 1);
        ocfs2_run_deallocs(osb, &ctxt.dealloc);
-out:
        return ret;
 }
 
 static int ocfs2_xattr_ibody_remove(struct inode *inode,
-                                   struct buffer_head *di_bh)
+                                   struct buffer_head *di_bh,
+                                   struct ocfs2_caching_info *ref_ci,
+                                   struct buffer_head *ref_root_bh)
 {
 
        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
        struct ocfs2_xattr_header *header;
        int ret;
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_bh = di_bh,
+               .vb_access = ocfs2_journal_access_di,
+       };
 
        header = (struct ocfs2_xattr_header *)
                 ((void *)di + inode->i_sb->s_blocksize -
                 le16_to_cpu(di->i_xattr_inline_size));
 
-       ret = ocfs2_remove_value_outside(inode, di_bh, header);
+       ret = ocfs2_remove_value_outside(inode, &vb, header,
+                                        ref_ci, ref_root_bh);
 
        return ret;
 }
 
+struct ocfs2_rm_xattr_bucket_para {
+       struct ocfs2_caching_info *ref_ci;
+       struct buffer_head *ref_root_bh;
+};
+
 static int ocfs2_xattr_block_remove(struct inode *inode,
-                                   struct buffer_head *blk_bh)
+                                   struct buffer_head *blk_bh,
+                                   struct ocfs2_caching_info *ref_ci,
+                                   struct buffer_head *ref_root_bh)
 {
        struct ocfs2_xattr_block *xb;
        int ret = 0;
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_bh = blk_bh,
+               .vb_access = ocfs2_journal_access_xb,
+       };
+       struct ocfs2_rm_xattr_bucket_para args = {
+               .ref_ci = ref_ci,
+               .ref_root_bh = ref_root_bh,
+       };
 
        xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
        if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
                struct ocfs2_xattr_header *header = &(xb->xb_attrs.xb_header);
-               ret = ocfs2_remove_value_outside(inode, blk_bh, header);
+               ret = ocfs2_remove_value_outside(inode, &vb, header,
+                                                ref_ci, ref_root_bh);
        } else
-               ret = ocfs2_delete_xattr_index_block(inode, blk_bh);
+               ret = ocfs2_iterate_xattr_index_block(inode,
+                                               blk_bh,
+                                               ocfs2_rm_xattr_cluster,
+                                               &args);
 
        return ret;
 }
 
 static int ocfs2_xattr_free_block(struct inode *inode,
-                                 u64 block)
+                                 u64 block,
+                                 struct ocfs2_caching_info *ref_ci,
+                                 struct buffer_head *ref_root_bh)
 {
        struct inode *xb_alloc_inode;
        struct buffer_head *xb_alloc_bh = NULL;
@@ -1604,24 +2146,19 @@ static int ocfs2_xattr_free_block(struct inode *inode,
        u64 blk, bg_blkno;
        u16 bit;
 
-       ret = ocfs2_read_block(inode, block, &blk_bh);
+       ret = ocfs2_read_xattr_block(inode, block, &blk_bh);
        if (ret < 0) {
                mlog_errno(ret);
                goto out;
        }
 
-       xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
-       if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) {
-               ret = -EIO;
-               goto out;
-       }
-
-       ret = ocfs2_xattr_block_remove(inode, blk_bh);
+       ret = ocfs2_xattr_block_remove(inode, blk_bh, ref_ci, ref_root_bh);
        if (ret < 0) {
                mlog_errno(ret);
                goto out;
        }
 
+       xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
        blk = le64_to_cpu(xb->xb_blkno);
        bit = le16_to_cpu(xb->xb_suballoc_bit);
        bg_blkno = ocfs2_which_suballoc_group(blk, bit);
@@ -1675,6 +2212,9 @@ int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
 {
        struct ocfs2_inode_info *oi = OCFS2_I(inode);
        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+       struct ocfs2_refcount_tree *ref_tree = NULL;
+       struct buffer_head *ref_root_bh = NULL;
+       struct ocfs2_caching_info *ref_ci = NULL;
        handle_t *handle;
        int ret;
 
@@ -1684,8 +2224,21 @@ int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
        if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
                return 0;
 
+       if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) {
+               ret = ocfs2_lock_refcount_tree(OCFS2_SB(inode->i_sb),
+                                              le64_to_cpu(di->i_refcount_loc),
+                                              1, &ref_tree, &ref_root_bh);
+               if (ret) {
+                       mlog_errno(ret);
+                       goto out;
+               }
+               ref_ci = &ref_tree->rf_ci;
+
+       }
+
        if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
-               ret = ocfs2_xattr_ibody_remove(inode, di_bh);
+               ret = ocfs2_xattr_ibody_remove(inode, di_bh,
+                                              ref_ci, ref_root_bh);
                if (ret < 0) {
                        mlog_errno(ret);
                        goto out;
@@ -1694,7 +2247,8 @@ int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
 
        if (di->i_xattr_loc) {
                ret = ocfs2_xattr_free_block(inode,
-                                            le64_to_cpu(di->i_xattr_loc));
+                                            le64_to_cpu(di->i_xattr_loc),
+                                            ref_ci, ref_root_bh);
                if (ret < 0) {
                        mlog_errno(ret);
                        goto out;
@@ -1708,8 +2262,8 @@ int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
                mlog_errno(ret);
                goto out;
        }
-       ret = ocfs2_journal_access(handle, inode, di_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
+                                     OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out_commit;
@@ -1728,6 +2282,9 @@ int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
 out_commit:
        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 out:
+       if (ref_tree)
+               ocfs2_unlock_refcount_tree(OCFS2_SB(inode->i_sb), ref_tree, 1);
+       brelse(ref_root_bh);
        return ret;
 }
 
@@ -1861,19 +2418,15 @@ static int ocfs2_xattr_block_find(struct inode *inode,
        if (!di->i_xattr_loc)
                return ret;
 
-       ret = ocfs2_read_block(inode, le64_to_cpu(di->i_xattr_loc), &blk_bh);
+       ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
+                                    &blk_bh);
        if (ret < 0) {
                mlog_errno(ret);
                return ret;
        }
 
-       xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
-       if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) {
-               ret = -EIO;
-               goto cleanup;
-       }
-
        xs->xattr_bh = blk_bh;
+       xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
 
        if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
                xs->header = &xb->xb_attrs.xb_header;
@@ -1899,6 +2452,84 @@ cleanup:
        return ret;
 }
 
+static int ocfs2_create_xattr_block(handle_t *handle,
+                                   struct inode *inode,
+                                   struct buffer_head *inode_bh,
+                                   struct ocfs2_alloc_context *meta_ac,
+                                   struct buffer_head **ret_bh,
+                                   int indexed)
+{
+       int ret;
+       u16 suballoc_bit_start;
+       u32 num_got;
+       u64 first_blkno;
+       struct ocfs2_dinode *di =  (struct ocfs2_dinode *)inode_bh->b_data;
+       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       struct buffer_head *new_bh = NULL;
+       struct ocfs2_xattr_block *xblk;
+
+       ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), inode_bh,
+                                     OCFS2_JOURNAL_ACCESS_CREATE);
+       if (ret < 0) {
+               mlog_errno(ret);
+               goto end;
+       }
+
+       ret = ocfs2_claim_metadata(osb, handle, meta_ac, 1,
+                                  &suballoc_bit_start, &num_got,
+                                  &first_blkno);
+       if (ret < 0) {
+               mlog_errno(ret);
+               goto end;
+       }
+
+       new_bh = sb_getblk(inode->i_sb, first_blkno);
+       ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), new_bh);
+
+       ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode),
+                                     new_bh,
+                                     OCFS2_JOURNAL_ACCESS_CREATE);
+       if (ret < 0) {
+               mlog_errno(ret);
+               goto end;
+       }
+
+       /* Initialize ocfs2_xattr_block */
+       xblk = (struct ocfs2_xattr_block *)new_bh->b_data;
+       memset(xblk, 0, inode->i_sb->s_blocksize);
+       strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE);
+       xblk->xb_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);
+       xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start);
+       xblk->xb_fs_generation = cpu_to_le32(osb->fs_generation);
+       xblk->xb_blkno = cpu_to_le64(first_blkno);
+
+       if (indexed) {
+               struct ocfs2_xattr_tree_root *xr = &xblk->xb_attrs.xb_root;
+               xr->xt_clusters = cpu_to_le32(1);
+               xr->xt_last_eb_blk = 0;
+               xr->xt_list.l_tree_depth = 0;
+               xr->xt_list.l_count = cpu_to_le16(
+                                       ocfs2_xattr_recs_per_xb(inode->i_sb));
+               xr->xt_list.l_next_free_rec = cpu_to_le16(1);
+               xblk->xb_flags = cpu_to_le16(OCFS2_XATTR_INDEXED);
+       }
+
+       ret = ocfs2_journal_dirty(handle, new_bh);
+       if (ret < 0) {
+               mlog_errno(ret);
+               goto end;
+       }
+       di->i_xattr_loc = cpu_to_le64(first_blkno);
+       ocfs2_journal_dirty(handle, inode_bh);
+
+       *ret_bh = new_bh;
+       new_bh = NULL;
+
+end:
+       brelse(new_bh);
+       return ret;
+}
+
 /*
  * ocfs2_xattr_block_set()
  *
@@ -1911,63 +2542,24 @@ static int ocfs2_xattr_block_set(struct inode *inode,
                                 struct ocfs2_xattr_set_ctxt *ctxt)
 {
        struct buffer_head *new_bh = NULL;
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-       struct ocfs2_dinode *di =  (struct ocfs2_dinode *)xs->inode_bh->b_data;
        handle_t *handle = ctxt->handle;
        struct ocfs2_xattr_block *xblk = NULL;
-       u16 suballoc_bit_start;
-       u32 num_got;
-       u64 first_blkno;
        int ret;
 
        if (!xs->xattr_bh) {
-               ret = ocfs2_journal_access(handle, inode, xs->inode_bh,
-                                          OCFS2_JOURNAL_ACCESS_CREATE);
-               if (ret < 0) {
-                       mlog_errno(ret);
-                       goto end;
-               }
-
-               ret = ocfs2_claim_metadata(osb, handle, ctxt->meta_ac, 1,
-                                          &suballoc_bit_start, &num_got,
-                                          &first_blkno);
-               if (ret < 0) {
-                       mlog_errno(ret);
-                       goto end;
-               }
-
-               new_bh = sb_getblk(inode->i_sb, first_blkno);
-               ocfs2_set_new_buffer_uptodate(inode, new_bh);
-
-               ret = ocfs2_journal_access(handle, inode, new_bh,
-                                          OCFS2_JOURNAL_ACCESS_CREATE);
-               if (ret < 0) {
+               ret = ocfs2_create_xattr_block(handle, inode, xs->inode_bh,
+                                              ctxt->meta_ac, &new_bh, 0);
+               if (ret) {
                        mlog_errno(ret);
                        goto end;
                }
 
-               /* Initialize ocfs2_xattr_block */
                xs->xattr_bh = new_bh;
-               xblk = (struct ocfs2_xattr_block *)new_bh->b_data;
-               memset(xblk, 0, inode->i_sb->s_blocksize);
-               strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE);
-               xblk->xb_suballoc_slot = cpu_to_le16(osb->slot_num);
-               xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start);
-               xblk->xb_fs_generation = cpu_to_le32(osb->fs_generation);
-               xblk->xb_blkno = cpu_to_le64(first_blkno);
-
+               xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
                xs->header = &xblk->xb_attrs.xb_header;
                xs->base = (void *)xs->header;
                xs->end = (void *)xblk + inode->i_sb->s_blocksize;
                xs->here = xs->header->xh_entries;
-
-               ret = ocfs2_journal_dirty(handle, new_bh);
-               if (ret < 0) {
-                       mlog_errno(ret);
-                       goto end;
-               }
-               di->i_xattr_loc = cpu_to_le64(first_blkno);
-               ocfs2_journal_dirty(handle, xs->inode_bh);
        } else
                xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
 
@@ -2012,7 +2604,7 @@ static int ocfs2_xattr_can_be_in_inode(struct inode *inode,
                last += 1;
        }
 
-       free = min_offs - ((void *)last - xs->base) - sizeof(__u32);
+       free = min_offs - ((void *)last - xs->base) - OCFS2_XATTR_HEADER_GAP;
        if (free < 0)
                return 0;
 
@@ -2051,6 +2643,15 @@ static int ocfs2_calc_xattr_set_need(struct inode *inode,
                                                    xi->value_len);
        u64 value_size;
 
+       /*
+        * Calculate the clusters we need to write.
+        * No matter whether we replace an old one or add a new one,
+        * we need this for writing.
+        */
+       if (xi->value_len > OCFS2_XATTR_INLINE_SIZE)
+               credits += new_clusters *
+                          ocfs2_clusters_to_blocks(inode->i_sb, 1);
+
        if (xis->not_found && xbs->not_found) {
                credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
 
@@ -2071,7 +2672,7 @@ static int ocfs2_calc_xattr_set_need(struct inode *inode,
                base = xis->base;
                credits += OCFS2_INODE_UPDATE_CREDITS;
        } else {
-               int i, block_off;
+               int i, block_off = 0;
                xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
                xe = xbs->here;
                name_offset = le16_to_cpu(xe->xe_name_offset);
@@ -2080,7 +2681,7 @@ static int ocfs2_calc_xattr_set_need(struct inode *inode,
                old_in_xb = 1;
 
                if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
-                       ret = ocfs2_xattr_bucket_get_name_value(inode,
+                       ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
                                                        bucket_xh(xbs->bucket),
                                                        i, &block_off,
                                                        &name_offset);
@@ -2101,7 +2702,7 @@ static int ocfs2_calc_xattr_set_need(struct inode *inode,
         */
        if (!xi->value) {
                if (!ocfs2_xattr_is_local(xe))
-                       credits += OCFS2_REMOVE_EXTENT_CREDITS;
+                       credits += ocfs2_remove_extent_credits(inode->i_sb);
 
                goto out;
        }
@@ -2118,7 +2719,7 @@ static int ocfs2_calc_xattr_set_need(struct inode *inode,
                 */
                if (ocfs2_xattr_can_be_in_inode(inode, xi, xis)) {
                        clusters_add += new_clusters;
-                       credits += OCFS2_REMOVE_EXTENT_CREDITS +
+                       credits += ocfs2_remove_extent_credits(inode->i_sb) +
                                    OCFS2_INODE_UPDATE_CREDITS;
                        if (!ocfs2_xattr_is_local(xe))
                                credits += ocfs2_calc_extend_credits(
@@ -2138,11 +2739,12 @@ static int ocfs2_calc_xattr_set_need(struct inode *inode,
                                                                 value_size);
                        xv = (struct ocfs2_xattr_value_root *)
                             (base + name_offset + name_len);
+                       value_size = OCFS2_XATTR_ROOT_SIZE;
                } else
                        xv = &def_xv.xv;
 
                if (old_clusters >= new_clusters) {
-                       credits += OCFS2_REMOVE_EXTENT_CREDITS;
+                       credits += ocfs2_remove_extent_credits(inode->i_sb);
                        goto out;
                } else {
                        meta_add += ocfs2_extend_meta_needed(&xv->xr_list);
@@ -2151,7 +2753,8 @@ static int ocfs2_calc_xattr_set_need(struct inode *inode,
                                                             &xv->xr_list,
                                                             new_clusters -
                                                             old_clusters);
-                       goto out;
+                       if (value_size >= OCFS2_XATTR_ROOT_SIZE)
+                               goto out;
                }
        } else {
                /*
@@ -2170,9 +2773,9 @@ meta_guess:
        /* calculate metadata allocation. */
        if (di->i_xattr_loc) {
                if (!xbs->xattr_bh) {
-                       ret = ocfs2_read_block(inode,
-                                              le64_to_cpu(di->i_xattr_loc),
-                                              &bh);
+                       ret = ocfs2_read_xattr_block(inode,
+                                                    le64_to_cpu(di->i_xattr_loc),
+                                                    &bh);
                        if (ret) {
                                mlog_errno(ret);
                                goto out;
@@ -2182,13 +2785,21 @@ meta_guess:
                } else
                        xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
 
+               /*
+                * If there is already an xattr tree, good, we can calculate
+                * like other b-trees. Otherwise we may have the chance of
+                * create a tree, the credit calculation is borrowed from
+                * ocfs2_calc_extend_credits with root_el = NULL. And the
+                * new tree will be cluster based, so no meta is needed.
+                */
                if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
                        struct ocfs2_extent_list *el =
                                 &xb->xb_attrs.xb_root.xt_list;
                        meta_add += ocfs2_extend_meta_needed(el);
                        credits += ocfs2_calc_extend_credits(inode->i_sb,
                                                             el, 1);
-               }
+               } else
+                       credits += OCFS2_SUBALLOC_ALLOC + 1;
 
                /*
                 * This cluster will be used either for new bucket or for
@@ -2225,6 +2836,7 @@ static int ocfs2_init_xattr_set_ctxt(struct inode *inode,
                                     struct ocfs2_xattr_search *xis,
                                     struct ocfs2_xattr_search *xbs,
                                     struct ocfs2_xattr_set_ctxt *ctxt,
+                                    int extra_meta,
                                     int *credits)
 {
        int clusters_add, meta_add, ret;
@@ -2241,6 +2853,7 @@ static int ocfs2_init_xattr_set_ctxt(struct inode *inode,
                return ret;
        }
 
+       meta_add += extra_meta;
        mlog(0, "Set xattr %s, reserve meta blocks = %d, clusters = %d, "
             "credits = %d\n", xi->name, meta_add, clusters_add, *credits);
 
@@ -2280,7 +2893,7 @@ static int __ocfs2_xattr_set_handle(struct inode *inode,
                                    struct ocfs2_xattr_search *xbs,
                                    struct ocfs2_xattr_set_ctxt *ctxt)
 {
-       int ret = 0, credits;
+       int ret = 0, credits, old_found;
 
        if (!xi->value) {
                /* Remove existing extended attribute */
@@ -2299,6 +2912,7 @@ static int __ocfs2_xattr_set_handle(struct inode *inode,
                        xi->value = NULL;
                        xi->value_len = 0;
 
+                       old_found = xis->not_found;
                        xis->not_found = -ENODATA;
                        ret = ocfs2_calc_xattr_set_need(inode,
                                                        di,
@@ -2308,6 +2922,7 @@ static int __ocfs2_xattr_set_handle(struct inode *inode,
                                                        NULL,
                                                        NULL,
                                                        &credits);
+                       xis->not_found = old_found;
                        if (ret) {
                                mlog_errno(ret);
                                goto out;
@@ -2328,6 +2943,7 @@ static int __ocfs2_xattr_set_handle(struct inode *inode,
                                if (ret)
                                        goto out;
 
+                               old_found = xis->not_found;
                                xis->not_found = -ENODATA;
                                ret = ocfs2_calc_xattr_set_need(inode,
                                                                di,
@@ -2337,6 +2953,7 @@ static int __ocfs2_xattr_set_handle(struct inode *inode,
                                                                NULL,
                                                                NULL,
                                                                &credits);
+                               xis->not_found = old_found;
                                if (ret) {
                                        mlog_errno(ret);
                                        goto out;
@@ -2389,6 +3006,21 @@ static int __ocfs2_xattr_set_handle(struct inode *inode,
                }
        }
 
+       if (!ret) {
+               /* Update inode ctime. */
+               ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode),
+                                             xis->inode_bh,
+                                             OCFS2_JOURNAL_ACCESS_WRITE);
+               if (ret) {
+                       mlog_errno(ret);
+                       goto out;
+               }
+
+               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_journal_dirty(ctxt->handle, xis->inode_bh);
+       }
 out:
        return ret;
 }
@@ -2396,9 +3028,7 @@ out:
 /*
  * This function only called duing creating inode
  * for init security/acl xattrs of the new inode.
- * The xattrs could be put into ibody or extent block,
- * xattr bucket would not be use in this case.
- * transanction credits also be reserved in here.
+ * All transanction credits have been reserved in mknod.
  */
 int ocfs2_xattr_set_handle(handle_t *handle,
                           struct inode *inode,
@@ -2438,6 +3068,19 @@ int ocfs2_xattr_set_handle(handle_t *handle,
        if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
                return -EOPNOTSUPP;
 
+       /*
+        * In extreme situation, may need xattr bucket when
+        * block size is too small. And we have already reserved
+        * the credits for bucket in mknod.
+        */
+       if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) {
+               xbs.bucket = ocfs2_xattr_bucket_new(inode);
+               if (!xbs.bucket) {
+                       mlog_errno(-ENOMEM);
+                       return -ENOMEM;
+               }
+       }
+
        xis.inode_bh = xbs.inode_bh = di_bh;
        di = (struct ocfs2_dinode *)di_bh->b_data;
 
@@ -2457,6 +3100,7 @@ int ocfs2_xattr_set_handle(handle_t *handle,
 cleanup:
        up_write(&OCFS2_I(inode)->ip_xattr_sem);
        brelse(xbs.xattr_bh);
+       ocfs2_xattr_bucket_free(xbs.bucket);
 
        return ret;
 }
@@ -2477,10 +3121,11 @@ int ocfs2_xattr_set(struct inode *inode,
 {
        struct buffer_head *di_bh = NULL;
        struct ocfs2_dinode *di;
-       int ret, credits;
+       int ret, credits, ref_meta = 0, ref_credits = 0;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        struct inode *tl_inode = osb->osb_tl_inode;
        struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
+       struct ocfs2_refcount_tree *ref_tree = NULL;
 
        struct ocfs2_xattr_info xi = {
                .name_index = name_index,
@@ -2545,6 +3190,17 @@ int ocfs2_xattr_set(struct inode *inode,
                        goto cleanup;
        }
 
+       /* Check whether the value is refcounted and do some prepartion. */
+       if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL &&
+           (!xis.not_found || !xbs.not_found)) {
+               ret = ocfs2_prepare_refcount_xattr(inode, di, &xi,
+                                                  &xis, &xbs, &ref_tree,
+                                                  &ref_meta, &ref_credits);
+               if (ret) {
+                       mlog_errno(ret);
+                       goto cleanup;
+               }
+       }
 
        mutex_lock(&tl_inode->i_mutex);
 
@@ -2559,13 +3215,15 @@ int ocfs2_xattr_set(struct inode *inode,
        mutex_unlock(&tl_inode->i_mutex);
 
        ret = ocfs2_init_xattr_set_ctxt(inode, di, &xi, &xis,
-                                       &xbs, &ctxt, &credits);
+                                       &xbs, &ctxt, ref_meta, &credits);
        if (ret) {
                mlog_errno(ret);
                goto cleanup;
        }
 
-       ctxt.handle = ocfs2_start_trans(osb, credits);
+       /* we need to update inode's ctime field, so add credit for it. */
+       credits += OCFS2_INODE_UPDATE_CREDITS;
+       ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits);
        if (IS_ERR(ctxt.handle)) {
                ret = PTR_ERR(ctxt.handle);
                mlog_errno(ret);
@@ -2583,8 +3241,16 @@ int ocfs2_xattr_set(struct inode *inode,
        if (ocfs2_dealloc_has_cluster(&ctxt.dealloc))
                ocfs2_schedule_truncate_log_flush(osb, 1);
        ocfs2_run_deallocs(osb, &ctxt.dealloc);
+
 cleanup:
+       if (ref_tree)
+               ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
        up_write(&OCFS2_I(inode)->ip_xattr_sem);
+       if (!value && !ret) {
+               ret = ocfs2_try_remove_refcount_tree(inode, di_bh);
+               if (ret)
+                       mlog_errno(ret);
+       }
        ocfs2_inode_unlock(inode, 1);
 cleanup_nolock:
        brelse(di_bh);
@@ -2613,7 +3279,8 @@ static int ocfs2_xattr_get_rec(struct inode *inode,
        u64 e_blkno = 0;
 
        if (el->l_tree_depth) {
-               ret = ocfs2_find_leaf(inode, el, name_hash, &eb_bh);
+               ret = ocfs2_find_leaf(INODE_CACHE(inode), el, name_hash,
+                                     &eb_bh);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -2695,7 +3362,7 @@ static int ocfs2_find_xe_in_bucket(struct inode *inode,
                if (cmp)
                        continue;
 
-               ret = ocfs2_xattr_bucket_get_name_value(inode,
+               ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
                                                        xh,
                                                        i,
                                                        &block_off,
@@ -2705,6 +3372,7 @@ static int ocfs2_find_xe_in_bucket(struct inode *inode,
                        break;
                }
 
+
                xe_name = bucket_block(bucket, block_off) + new_offset;
                if (!memcmp(name, xe_name, name_len)) {
                        *xe_index = i;
@@ -2918,7 +3586,7 @@ static int ocfs2_iterate_xattr_buckets(struct inode *inode,
                     le32_to_cpu(bucket_xh(bucket)->xh_entries[0].xe_name_hash));
                if (func) {
                        ret = func(inode, bucket, para);
-                       if (ret)
+                       if (ret && ret != -ERANGE)
                                mlog_errno(ret);
                        /* Fall through to bucket_relse() */
                }
@@ -2938,7 +3606,7 @@ struct ocfs2_xattr_tree_list {
        size_t result;
 };
 
-static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
+static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb,
                                             struct ocfs2_xattr_header *xh,
                                             int index,
                                             int *block_off,
@@ -2951,8 +3619,8 @@ static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
 
        name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset);
 
-       *block_off = name_offset >> inode->i_sb->s_blocksize_bits;
-       *new_offset = name_offset % inode->i_sb->s_blocksize;
+       *block_off = name_offset >> sb->s_blocksize_bits;
+       *new_offset = name_offset % sb->s_blocksize;
 
        return 0;
 }
@@ -2972,7 +3640,7 @@ static int ocfs2_list_xattr_bucket(struct inode *inode,
                prefix = ocfs2_xattr_prefix(type);
 
                if (prefix) {
-                       ret = ocfs2_xattr_bucket_get_name_value(inode,
+                       ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
                                                                bucket_xh(bucket),
                                                                i,
                                                                &block_off,
@@ -2995,22 +3663,19 @@ static int ocfs2_list_xattr_bucket(struct inode *inode,
        return ret;
 }
 
-static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
-                                            struct ocfs2_xattr_tree_root *xt,
-                                            char *buffer,
-                                            size_t buffer_size)
+static int ocfs2_iterate_xattr_index_block(struct inode *inode,
+                                          struct buffer_head *blk_bh,
+                                          xattr_tree_rec_func *rec_func,
+                                          void *para)
 {
-       struct ocfs2_extent_list *el = &xt->xt_list;
+       struct ocfs2_xattr_block *xb =
+                       (struct ocfs2_xattr_block *)blk_bh->b_data;
+       struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list;
        int ret = 0;
        u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0;
        u64 p_blkno = 0;
-       struct ocfs2_xattr_tree_list xl = {
-               .buffer = buffer,
-               .buffer_size = buffer_size,
-               .result = 0,
-       };
 
-       if (le16_to_cpu(el->l_next_free_rec) == 0)
+       if (!el->l_next_free_rec || !rec_func)
                return 0;
 
        while (name_hash > 0) {
@@ -3018,15 +3683,15 @@ static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
                                          &e_cpos, &num_clusters, el);
                if (ret) {
                        mlog_errno(ret);
-                       goto out;
+                       break;
                }
 
-               ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters,
-                                                 ocfs2_list_xattr_bucket,
-                                                 &xl);
+               ret = rec_func(inode, blk_bh, p_blkno, e_cpos,
+                              num_clusters, para);
                if (ret) {
-                       mlog_errno(ret);
-                       goto out;
+                       if (ret != -ERANGE)
+                               mlog_errno(ret);
+                       break;
                }
 
                if (e_cpos == 0)
@@ -3035,6 +3700,37 @@ static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
                name_hash = e_cpos - 1;
        }
 
+       return ret;
+
+}
+
+static int ocfs2_list_xattr_tree_rec(struct inode *inode,
+                                    struct buffer_head *root_bh,
+                                    u64 blkno, u32 cpos, u32 len, void *para)
+{
+       return ocfs2_iterate_xattr_buckets(inode, blkno, len,
+                                          ocfs2_list_xattr_bucket, para);
+}
+
+static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
+                                            struct buffer_head *blk_bh,
+                                            char *buffer,
+                                            size_t buffer_size)
+{
+       int ret;
+       struct ocfs2_xattr_tree_list xl = {
+               .buffer = buffer,
+               .buffer_size = buffer_size,
+               .result = 0,
+       };
+
+       ret = ocfs2_iterate_xattr_index_block(inode, blk_bh,
+                                             ocfs2_list_xattr_tree_rec, &xl);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
        ret = xl.result;
 out:
        return ret;
@@ -3188,8 +3884,8 @@ static int ocfs2_xattr_create_index_block(struct inode *inode,
         */
        down_write(&oi->ip_alloc_sem);
 
-       ret = ocfs2_journal_access(handle, inode, xb_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), xb_bh,
+                                     OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -3386,124 +4082,84 @@ out:
 }
 
 /*
- * Move half nums of the xattr bucket in the previous cluster to this new
- * cluster. We only touch the last cluster of the previous extend record.
+ * prev_blkno points to the start of an existing extent.  new_blkno
+ * points to a newly allocated extent.  Because we know each of our
+ * clusters contains more than bucket, we can easily split one cluster
+ * at a bucket boundary.  So we take the last cluster of the existing
+ * extent and split it down the middle.  We move the last half of the
+ * buckets in the last cluster of the existing extent over to the new
+ * extent.
+ *
+ * first_bh is the buffer at prev_blkno so we can update the existing
+ * extent's bucket count.  header_bh is the bucket were we were hoping
+ * to insert our xattr.  If the bucket move places the target in the new
+ * extent, we'll update first_bh and header_bh after modifying the old
+ * extent.
  *
- * first_bh is the first buffer_head of a series of bucket in the same
- * extent rec and header_bh is the header of one bucket in this cluster.
- * They will be updated if we move the data header_bh contains to the new
- * cluster. first_hash will be set as the 1st xe's name_hash of the new cluster.
+ * first_hash will be set as the 1st xe's name_hash in the new extent.
  */
 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode *inode,
                                               handle_t *handle,
-                                              struct buffer_head **first_bh,
-                                              struct buffer_head **header_bh,
+                                              struct ocfs2_xattr_bucket *first,
+                                              struct ocfs2_xattr_bucket *target,
                                               u64 new_blkno,
-                                              u64 prev_blkno,
                                               u32 num_clusters,
                                               u32 *first_hash)
 {
-       int i, ret, credits;
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-       int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
-       int num_buckets = ocfs2_xattr_buckets_per_cluster(osb);
-       int blocksize = inode->i_sb->s_blocksize;
-       struct buffer_head *old_bh, *new_bh, *prev_bh, *new_first_bh = NULL;
-       struct ocfs2_xattr_header *new_xh;
-       struct ocfs2_xattr_header *xh =
-                       (struct ocfs2_xattr_header *)((*first_bh)->b_data);
-
-       BUG_ON(le16_to_cpu(xh->xh_num_buckets) < num_buckets);
-       BUG_ON(OCFS2_XATTR_BUCKET_SIZE == osb->s_clustersize);
-
-       prev_bh = *first_bh;
-       get_bh(prev_bh);
-       xh = (struct ocfs2_xattr_header *)prev_bh->b_data;
+       int ret;
+       struct super_block *sb = inode->i_sb;
+       int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(sb);
+       int num_buckets = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb));
+       int to_move = num_buckets / 2;
+       u64 src_blkno;
+       u64 last_cluster_blkno = bucket_blkno(first) +
+               ((num_clusters - 1) * ocfs2_clusters_to_blocks(sb, 1));
 
-       prev_blkno += (num_clusters - 1) * bpc + bpc / 2;
+       BUG_ON(le16_to_cpu(bucket_xh(first)->xh_num_buckets) < num_buckets);
+       BUG_ON(OCFS2_XATTR_BUCKET_SIZE == OCFS2_SB(sb)->s_clustersize);
 
        mlog(0, "move half of xattrs in cluster %llu to %llu\n",
-            (unsigned long long)prev_blkno, (unsigned long long)new_blkno);
+            (unsigned long long)last_cluster_blkno, (unsigned long long)new_blkno);
 
-       /*
-        * We need to update the 1st half of the new cluster and
-        * 1 more for the update of the 1st bucket of the previous
-        * extent record.
-        */
-       credits = bpc / 2 + 1 + handle->h_buffer_credits;
-       ret = ocfs2_extend_trans(handle, credits);
+       ret = ocfs2_mv_xattr_buckets(inode, handle, bucket_blkno(first),
+                                    last_cluster_blkno, new_blkno,
+                                    to_move, first_hash);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_journal_access(handle, inode, prev_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
-       if (ret) {
-               mlog_errno(ret);
-               goto out;
-       }
+       /* This is the first bucket that got moved */
+       src_blkno = last_cluster_blkno + (to_move * blks_per_bucket);
 
-       for (i = 0; i < bpc / 2; i++, prev_blkno++, new_blkno++) {
-               old_bh = new_bh = NULL;
-               new_bh = sb_getblk(inode->i_sb, new_blkno);
-               if (!new_bh) {
-                       ret = -EIO;
-                       mlog_errno(ret);
-                       goto out;
-               }
+       /*
+        * If the target bucket was part of the moved buckets, we need to
+        * update first and target.
+        */
+       if (bucket_blkno(target) >= src_blkno) {
+               /* Find the block for the new target bucket */
+               src_blkno = new_blkno +
+                       (bucket_blkno(target) - src_blkno);
 
-               ocfs2_set_new_buffer_uptodate(inode, new_bh);
+               ocfs2_xattr_bucket_relse(first);
+               ocfs2_xattr_bucket_relse(target);
 
-               ret = ocfs2_journal_access(handle, inode, new_bh,
-                                          OCFS2_JOURNAL_ACCESS_CREATE);
-               if (ret < 0) {
+               /*
+                * These shouldn't fail - the buffers are in the
+                * journal from ocfs2_cp_xattr_bucket().
+                */
+               ret = ocfs2_read_xattr_bucket(first, new_blkno);
+               if (ret) {
                        mlog_errno(ret);
-                       brelse(new_bh);
                        goto out;
                }
-
-               ret = ocfs2_read_block(inode, prev_blkno, &old_bh);
-               if (ret < 0) {
+               ret = ocfs2_read_xattr_bucket(target, src_blkno);
+               if (ret)
                        mlog_errno(ret);
-                       brelse(new_bh);
-                       goto out;
-               }
 
-               memcpy(new_bh->b_data, old_bh->b_data, blocksize);
-
-               if (i == 0) {
-                       new_xh = (struct ocfs2_xattr_header *)new_bh->b_data;
-                       new_xh->xh_num_buckets = cpu_to_le16(num_buckets / 2);
-
-                       if (first_hash)
-                               *first_hash = le32_to_cpu(
-                                       new_xh->xh_entries[0].xe_name_hash);
-                       new_first_bh = new_bh;
-                       get_bh(new_first_bh);
-               }
-
-               ocfs2_journal_dirty(handle, new_bh);
-
-               if (*header_bh == old_bh) {
-                       brelse(*header_bh);
-                       *header_bh = new_bh;
-                       get_bh(*header_bh);
-
-                       brelse(*first_bh);
-                       *first_bh = new_first_bh;
-                       get_bh(*first_bh);
-               }
-               brelse(new_bh);
-               brelse(old_bh);
        }
 
-       le16_add_cpu(&xh->xh_num_buckets, -(num_buckets / 2));
-
-       ocfs2_journal_dirty(handle, prev_bh);
 out:
-       brelse(prev_bh);
-       brelse(new_first_bh);
        return ret;
 }
 
@@ -3607,6 +4263,11 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
                goto out;
        }
 
+       /*
+        * Hey, if we're overwriting t_bucket, what difference does
+        * ACCESS_CREATE vs ACCESS_WRITE make?  See the comment in the
+        * same part of ocfs2_cp_xattr_bucket().
+        */
        ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
                                                new_bucket_head ?
                                                OCFS2_JOURNAL_ACCESS_CREATE :
@@ -3765,7 +4426,7 @@ static int ocfs2_cp_xattr_bucket(struct inode *inode,
                mlog_errno(ret);
                goto out;
        }
-  
+
        ret = ocfs2_read_xattr_bucket(s_bucket, s_blkno);
        if (ret)
                goto out;
@@ -3778,6 +4439,19 @@ static int ocfs2_cp_xattr_bucket(struct inode *inode,
        if (ret)
                goto out;
 
+       /*
+        * Hey, if we're overwriting t_bucket, what difference does
+        * ACCESS_CREATE vs ACCESS_WRITE make?  Well, if we allocated a new
+        * cluster to fill, we came here from
+        * ocfs2_mv_xattr_buckets(), and it is really new -
+        * ACCESS_CREATE is required.  But we also might have moved data
+        * out of t_bucket before extending back into it.
+        * ocfs2_add_new_xattr_bucket() can do this - its call to
+        * ocfs2_add_new_xattr_cluster() may have created a new extent
+        * and copied out the end of the old extent.  Then it re-extends
+        * the old extent back to create space for new xattrs.  That's
+        * how we get here, and the bucket isn't really new.
+        */
        ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
                                                t_is_new ?
                                                OCFS2_JOURNAL_ACCESS_CREATE :
@@ -3796,41 +4470,64 @@ out:
 }
 
 /*
- * Copy one xattr cluster from src_blk to to_blk.
- * The to_blk will become the first bucket header of the cluster, so its
- * xh_num_buckets will be initialized as the bucket num in the cluster.
+ * src_blk points to the start of an existing extent.  last_blk points to
+ * last cluster in that extent.  to_blk points to a newly allocated
+ * extent.  We copy the buckets from the cluster at last_blk to the new
+ * extent.  If start_bucket is non-zero, we skip that many buckets before
+ * we start copying.  The new extent's xh_num_buckets gets set to the
+ * number of buckets we copied.  The old extent's xh_num_buckets shrinks
+ * by the same amount.
  */
-static int ocfs2_cp_xattr_cluster(struct inode *inode,
-                                 handle_t *handle,
-                                 struct buffer_head *first_bh,
-                                 u64 src_blk,
-                                 u64 to_blk,
+static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle,
+                                 u64 src_blk, u64 last_blk, u64 to_blk,
+                                 unsigned int start_bucket,
                                  u32 *first_hash)
 {
        int i, ret, credits;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-       int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+       int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
        int num_buckets = ocfs2_xattr_buckets_per_cluster(osb);
-       struct buffer_head *bh = NULL;
-       struct ocfs2_xattr_header *xh;
-       u64 to_blk_start = to_blk;
+       struct ocfs2_xattr_bucket *old_first, *new_first;
+
+       mlog(0, "mv xattrs from cluster %llu to %llu\n",
+            (unsigned long long)last_blk, (unsigned long long)to_blk);
+
+       BUG_ON(start_bucket >= num_buckets);
+       if (start_bucket) {
+               num_buckets -= start_bucket;
+               last_blk += (start_bucket * blks_per_bucket);
+       }
 
-       mlog(0, "cp xattrs from cluster %llu to %llu\n",
-            (unsigned long long)src_blk, (unsigned long long)to_blk);
+       /* The first bucket of the original extent */
+       old_first = ocfs2_xattr_bucket_new(inode);
+       /* The first bucket of the new extent */
+       new_first = ocfs2_xattr_bucket_new(inode);
+       if (!old_first || !new_first) {
+               ret = -ENOMEM;
+               mlog_errno(ret);
+               goto out;
+       }
+
+       ret = ocfs2_read_xattr_bucket(old_first, src_blk);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
 
        /*
-        * We need to update the new cluster and 1 more for the update of
-        * the 1st bucket of the previous extent rec.
+        * We need to update the first bucket of the old extent and all
+        * the buckets going to the new extent.
         */
-       credits = bpc + 1 + handle->h_buffer_credits;
+       credits = ((num_buckets + 1) * blks_per_bucket) +
+               handle->h_buffer_credits;
        ret = ocfs2_extend_trans(handle, credits);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_journal_access(handle, inode, first_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_xattr_bucket_journal_access(handle, old_first,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -3838,45 +4535,45 @@ static int ocfs2_cp_xattr_cluster(struct inode *inode,
 
        for (i = 0; i < num_buckets; i++) {
                ret = ocfs2_cp_xattr_bucket(inode, handle,
-                                           src_blk, to_blk, 1);
+                                           last_blk + (i * blks_per_bucket),
+                                           to_blk + (i * blks_per_bucket),
+                                           1);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
-
-               src_blk += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
-               to_blk += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
        }
 
-       /* update the old bucket header. */
-       xh = (struct ocfs2_xattr_header *)first_bh->b_data;
-       le16_add_cpu(&xh->xh_num_buckets, -num_buckets);
-
-       ocfs2_journal_dirty(handle, first_bh);
-
-       /* update the new bucket header. */
-       ret = ocfs2_read_block(inode, to_blk_start, &bh);
-       if (ret < 0) {
+       /*
+        * Get the new bucket ready before we dirty anything
+        * (This actually shouldn't fail, because we already dirtied
+        * it once in ocfs2_cp_xattr_bucket()).
+        */
+       ret = ocfs2_read_xattr_bucket(new_first, to_blk);
+       if (ret) {
                mlog_errno(ret);
                goto out;
        }
-
-       ret = ocfs2_journal_access(handle, inode, bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_xattr_bucket_journal_access(handle, new_first,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       xh = (struct ocfs2_xattr_header *)bh->b_data;
-       xh->xh_num_buckets = cpu_to_le16(num_buckets);
+       /* Now update the headers */
+       le16_add_cpu(&bucket_xh(old_first)->xh_num_buckets, -num_buckets);
+       ocfs2_xattr_bucket_journal_dirty(handle, old_first);
 
-       ocfs2_journal_dirty(handle, bh);
+       bucket_xh(new_first)->xh_num_buckets = cpu_to_le16(num_buckets);
+       ocfs2_xattr_bucket_journal_dirty(handle, new_first);
 
        if (first_hash)
-               *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash);
+               *first_hash = le32_to_cpu(bucket_xh(new_first)->xh_entries[0].xe_name_hash);
+
 out:
-       brelse(bh);
+       ocfs2_xattr_bucket_free(new_first);
+       ocfs2_xattr_bucket_free(old_first);
        return ret;
 }
 
@@ -3935,43 +4632,49 @@ static int ocfs2_divide_xattr_cluster(struct inode *inode,
  */
 static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode,
                                            handle_t *handle,
-                                           struct buffer_head **first_bh,
-                                           struct buffer_head **header_bh,
+                                           struct ocfs2_xattr_bucket *first,
+                                           struct ocfs2_xattr_bucket *target,
                                            u64 new_blk,
-                                           u64 prev_blk,
                                            u32 prev_clusters,
                                            u32 *v_start,
                                            int *extend)
 {
-       int ret = 0;
-       int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+       int ret;
 
        mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n",
-            (unsigned long long)prev_blk, prev_clusters,
+            (unsigned long long)bucket_blkno(first), prev_clusters,
             (unsigned long long)new_blk);
 
-       if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1)
+       if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1) {
                ret = ocfs2_mv_xattr_bucket_cross_cluster(inode,
                                                          handle,
-                                                         first_bh,
-                                                         header_bh,
+                                                         first, target,
                                                          new_blk,
-                                                         prev_blk,
                                                          prev_clusters,
                                                          v_start);
-       else {
-               u64 last_blk = prev_blk + bpc * (prev_clusters - 1);
-
-               if (prev_clusters > 1 && (*header_bh)->b_blocknr != last_blk)
-                       ret = ocfs2_cp_xattr_cluster(inode, handle, *first_bh,
-                                                    last_blk, new_blk,
+               if (ret)
+                       mlog_errno(ret);
+       } else {
+               /* The start of the last cluster in the first extent */
+               u64 last_blk = bucket_blkno(first) +
+                       ((prev_clusters - 1) *
+                        ocfs2_clusters_to_blocks(inode->i_sb, 1));
+
+               if (prev_clusters > 1 && bucket_blkno(target) != last_blk) {
+                       ret = ocfs2_mv_xattr_buckets(inode, handle,
+                                                    bucket_blkno(first),
+                                                    last_blk, new_blk, 0,
                                                     v_start);
-               else {
+                       if (ret)
+                               mlog_errno(ret);
+               } else {
                        ret = ocfs2_divide_xattr_cluster(inode, handle,
                                                         last_blk, new_blk,
                                                         v_start);
+                       if (ret)
+                               mlog_errno(ret);
 
-                       if ((*header_bh)->b_blocknr == last_blk && extend)
+                       if ((bucket_blkno(target) == last_blk) && extend)
                                *extend = 0;
                }
        }
@@ -3997,11 +4700,10 @@ static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode,
  */
 static int ocfs2_add_new_xattr_cluster(struct inode *inode,
                                       struct buffer_head *root_bh,
-                                      struct buffer_head **first_bh,
-                                      struct buffer_head **header_bh,
+                                      struct ocfs2_xattr_bucket *first,
+                                      struct ocfs2_xattr_bucket *target,
                                       u32 *num_clusters,
                                       u32 prev_cpos,
-                                      u64 prev_blkno,
                                       int *extend,
                                       struct ocfs2_xattr_set_ctxt *ctxt)
 {
@@ -4017,12 +4719,12 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
        mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, "
             "previous xattr blkno = %llu\n",
             (unsigned long long)OCFS2_I(inode)->ip_blkno,
-            prev_cpos, (unsigned long long)prev_blkno);
+            prev_cpos, (unsigned long long)bucket_blkno(first));
 
-       ocfs2_init_xattr_tree_extent_tree(&et, inode, root_bh);
+       ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh);
 
-       ret = ocfs2_journal_access(handle, inode, root_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh,
+                                     OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret < 0) {
                mlog_errno(ret);
                goto leave;
@@ -4042,7 +4744,7 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
        mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n",
             num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
 
-       if (prev_blkno + prev_clusters * bpc == block &&
+       if (bucket_blkno(first) + (prev_clusters * bpc) == block &&
            (prev_clusters + num_bits) << osb->s_clustersize_bits <=
             OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
                /*
@@ -4061,10 +4763,9 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
        } else {
                ret = ocfs2_adjust_xattr_cross_cluster(inode,
                                                       handle,
-                                                      first_bh,
-                                                      header_bh,
+                                                      first,
+                                                      target,
                                                       block,
-                                                      prev_blkno,
                                                       prev_clusters,
                                                       &v_start,
                                                       extend);
@@ -4076,7 +4777,7 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
 
        mlog(0, "Insert %u clusters at block %llu for xattr at %u\n",
             num_bits, (unsigned long long)block, v_start);
-       ret = ocfs2_insert_extent(osb, handle, inode, &et, v_start, block,
+       ret = ocfs2_insert_extent(handle, &et, v_start, block,
                                  num_bits, 0, ctxt->meta_ac);
        if (ret < 0) {
                mlog_errno(ret);
@@ -4092,37 +4793,45 @@ leave:
 }
 
 /*
- * Extend a new xattr bucket and move xattrs to the end one by one until
- * We meet with start_bh. Only move half of the xattrs to the bucket after it.
+ * We are given an extent.  'first' is the bucket at the very front of
+ * the extent.  The extent has space for an additional bucket past
+ * bucket_xh(first)->xh_num_buckets.  'target_blkno' is the block number
+ * of the target bucket.  We wish to shift every bucket past the target
+ * down one, filling in that additional space.  When we get back to the
+ * target, we split the target between itself and the now-empty bucket
+ * at target+1 (aka, target_blkno + blks_per_bucket).
  */
 static int ocfs2_extend_xattr_bucket(struct inode *inode,
                                     handle_t *handle,
-                                    struct buffer_head *first_bh,
-                                    struct buffer_head *start_bh,
+                                    struct ocfs2_xattr_bucket *first,
+                                    u64 target_blk,
                                     u32 num_clusters)
 {
        int ret, credits;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
-       u64 start_blk = start_bh->b_blocknr, end_blk;
-       u32 num_buckets = num_clusters * ocfs2_xattr_buckets_per_cluster(osb);
-       struct ocfs2_xattr_header *first_xh =
-                               (struct ocfs2_xattr_header *)first_bh->b_data;
-       u16 bucket = le16_to_cpu(first_xh->xh_num_buckets);
+       u64 end_blk;
+       u16 new_bucket = le16_to_cpu(bucket_xh(first)->xh_num_buckets);
 
        mlog(0, "extend xattr bucket in %llu, xattr extend rec starting "
-            "from %llu, len = %u\n", (unsigned long long)start_blk,
-            (unsigned long long)first_bh->b_blocknr, num_clusters);
+            "from %llu, len = %u\n", (unsigned long long)target_blk,
+            (unsigned long long)bucket_blkno(first), num_clusters);
 
-       BUG_ON(bucket >= num_buckets);
+       /* The extent must have room for an additional bucket */
+       BUG_ON(new_bucket >=
+              (num_clusters * ocfs2_xattr_buckets_per_cluster(osb)));
 
-       end_blk = first_bh->b_blocknr + (bucket - 1) * blk_per_bucket;
+       /* end_blk points to the last existing bucket */
+       end_blk = bucket_blkno(first) + ((new_bucket - 1) * blk_per_bucket);
 
        /*
-        * We will touch all the buckets after the start_bh(include it).
-        * Then we add one more bucket.
+        * end_blk is the start of the last existing bucket.
+        * Thus, (end_blk - target_blk) covers the target bucket and
+        * every bucket after it up to, but not including, the last
+        * existing bucket.  Then we add the last existing bucket, the
+        * new bucket, and the first bucket (3 * blk_per_bucket).
         */
-       credits = end_blk - start_blk + 3 * blk_per_bucket + 1 +
+       credits = (end_blk - target_blk) + (3 * blk_per_bucket) +
                  handle->h_buffer_credits;
        ret = ocfs2_extend_trans(handle, credits);
        if (ret) {
@@ -4130,14 +4839,14 @@ static int ocfs2_extend_xattr_bucket(struct inode *inode,
                goto out;
        }
 
-       ret = ocfs2_journal_access(handle, inode, first_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_xattr_bucket_journal_access(handle, first,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       while (end_blk != start_blk) {
+       while (end_blk != target_blk) {
                ret = ocfs2_cp_xattr_bucket(inode, handle, end_blk,
                                            end_blk + blk_per_bucket, 0);
                if (ret)
@@ -4145,55 +4854,58 @@ static int ocfs2_extend_xattr_bucket(struct inode *inode,
                end_blk -= blk_per_bucket;
        }
 
-       /* Move half of the xattr in start_blk to the next bucket. */
-       ret = ocfs2_divide_xattr_bucket(inode, handle, start_blk,
-                                       start_blk + blk_per_bucket, NULL, 0);
+       /* Move half of the xattr in target_blkno to the next bucket. */
+       ret = ocfs2_divide_xattr_bucket(inode, handle, target_blk,
+                                       target_blk + blk_per_bucket, NULL, 0);
 
-       le16_add_cpu(&first_xh->xh_num_buckets, 1);
-       ocfs2_journal_dirty(handle, first_bh);
+       le16_add_cpu(&bucket_xh(first)->xh_num_buckets, 1);
+       ocfs2_xattr_bucket_journal_dirty(handle, first);
 
 out:
        return ret;
 }
 
 /*
- * Add new xattr bucket in an extent record and adjust the buckets accordingly.
- * xb_bh is the ocfs2_xattr_block.
- * We will move all the buckets starting from header_bh to the next place. As
- * for this one, half num of its xattrs will be moved to the next one.
+ * Add new xattr bucket in an extent record and adjust the buckets
+ * accordingly.  xb_bh is the ocfs2_xattr_block, and target is the
+ * bucket we want to insert into.
+ *
+ * In the easy case, we will move all the buckets after target down by
+ * one. Half of target's xattrs will be moved to the next bucket.
  *
- * We will allocate a new cluster if current cluster is full and adjust
- * header_bh and first_bh if the insert place is moved to the new cluster.
+ * If current cluster is full, we'll allocate a new one.  This may not
+ * be contiguous.  The underlying calls will make sure that there is
+ * space for the insert, shifting buckets around if necessary.
+ * 'target' may be moved by those calls.
  */
 static int ocfs2_add_new_xattr_bucket(struct inode *inode,
                                      struct buffer_head *xb_bh,
-                                     struct buffer_head *header_bh,
+                                     struct ocfs2_xattr_bucket *target,
                                      struct ocfs2_xattr_set_ctxt *ctxt)
 {
-       struct ocfs2_xattr_header *first_xh = NULL;
-       struct buffer_head *first_bh = NULL;
        struct ocfs2_xattr_block *xb =
                        (struct ocfs2_xattr_block *)xb_bh->b_data;
        struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
        struct ocfs2_extent_list *el = &xb_root->xt_list;
-       struct ocfs2_xattr_header *xh =
-                       (struct ocfs2_xattr_header *)header_bh->b_data;
-       u32 name_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash);
-       struct super_block *sb = inode->i_sb;
-       struct ocfs2_super *osb = OCFS2_SB(sb);
+       u32 name_hash =
+               le32_to_cpu(bucket_xh(target)->xh_entries[0].xe_name_hash);
+       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        int ret, num_buckets, extend = 1;
        u64 p_blkno;
        u32 e_cpos, num_clusters;
+       /* The bucket at the front of the extent */
+       struct ocfs2_xattr_bucket *first;
 
-       mlog(0, "Add new xattr bucket starting form %llu\n",
-            (unsigned long long)header_bh->b_blocknr);
+       mlog(0, "Add new xattr bucket starting from %llu\n",
+            (unsigned long long)bucket_blkno(target));
 
-       /*
-        * Add refrence for header_bh here because it may be
-        * changed in ocfs2_add_new_xattr_cluster and we need
-        * to free it in the end.
-        */
-       get_bh(header_bh);
+       /* The first bucket of the original extent */
+       first = ocfs2_xattr_bucket_new(inode);
+       if (!first) {
+               ret = -ENOMEM;
+               mlog_errno(ret);
+               goto out;
+       }
 
        ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &e_cpos,
                                  &num_clusters, el);
@@ -4202,23 +4914,24 @@ static int ocfs2_add_new_xattr_bucket(struct inode *inode,
                goto out;
        }
 
-       ret = ocfs2_read_block(inode, p_blkno, &first_bh);
+       ret = ocfs2_read_xattr_bucket(first, p_blkno);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
        num_buckets = ocfs2_xattr_buckets_per_cluster(osb) * num_clusters;
-       first_xh = (struct ocfs2_xattr_header *)first_bh->b_data;
-
-       if (num_buckets == le16_to_cpu(first_xh->xh_num_buckets)) {
+       if (num_buckets == le16_to_cpu(bucket_xh(first)->xh_num_buckets)) {
+               /*
+                * This can move first+target if the target bucket moves
+                * to the new extent.
+                */
                ret = ocfs2_add_new_xattr_cluster(inode,
                                                  xb_bh,
-                                                 &first_bh,
-                                                 &header_bh,
+                                                 first,
+                                                 target,
                                                  &num_clusters,
                                                  e_cpos,
-                                                 p_blkno,
                                                  &extend,
                                                  ctxt);
                if (ret) {
@@ -4227,17 +4940,19 @@ static int ocfs2_add_new_xattr_bucket(struct inode *inode,
                }
        }
 
-       if (extend)
+       if (extend) {
                ret = ocfs2_extend_xattr_bucket(inode,
                                                ctxt->handle,
-                                               first_bh,
-                                               header_bh,
+                                               first,
+                                               bucket_blkno(target),
                                                num_clusters);
-       if (ret)
-               mlog_errno(ret);
+               if (ret)
+                       mlog_errno(ret);
+       }
+
 out:
-       brelse(first_bh);
-       brelse(header_bh);
+       ocfs2_xattr_bucket_free(first);
+
        return ret;
 }
 
@@ -4270,7 +4985,10 @@ static void ocfs2_xattr_set_entry_normal(struct inode *inode,
        size_t blocksize = inode->i_sb->s_blocksize;
        char *val;
        size_t offs, size, new_size;
+       struct ocfs2_xa_loc loc;
 
+       ocfs2_init_xattr_bucket_xa_loc(&loc, xs->bucket,
+                                      xs->not_found ? NULL : xs->here);
        last = &xh->xh_entries[count];
        if (!xs->not_found) {
                xe = xs->here;
@@ -4291,8 +5009,8 @@ static void ocfs2_xattr_set_entry_normal(struct inode *inode,
                new_size = OCFS2_XATTR_SIZE(name_len) +
                           OCFS2_XATTR_SIZE(xi->value_len);
 
-               le16_add_cpu(&xh->xh_name_value_len, -size);
                if (xi->value) {
+                       ocfs2_xa_wipe_namevalue(&loc);
                        if (new_size > size)
                                goto set_new_name_value;
 
@@ -4314,20 +5032,8 @@ static void ocfs2_xattr_set_entry_normal(struct inode *inode,
                        ocfs2_xattr_set_local(xe, local);
                        return;
                } else {
-                       /*
-                        * Remove the old entry if there is more than one.
-                        * We don't remove the last entry so that we can
-                        * use it to indicate the hash value of the empty
-                        * bucket.
-                        */
-                       last -= 1;
-                       le16_add_cpu(&xh->xh_count, -1);
-                       if (xh->xh_count) {
-                               memmove(xe, xe + 1,
-                                       (void *)last - (void *)xe);
-                               memset(last, 0,
-                                      sizeof(struct ocfs2_xattr_entry));
-                       } else
+                       ocfs2_xa_remove_entry(&loc);
+                       if (!xh->xh_count)
                                xh->xh_free_start =
                                        cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE);
 
@@ -4440,31 +5146,6 @@ out:
        return ret;
 }
 
-static int ocfs2_xattr_value_update_size(struct inode *inode,
-                                        handle_t *handle,
-                                        struct buffer_head *xe_bh,
-                                        struct ocfs2_xattr_entry *xe,
-                                        u64 new_size)
-{
-       int ret;
-
-       ret = ocfs2_journal_access(handle, inode, xe_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
-       if (ret < 0) {
-               mlog_errno(ret);
-               goto out;
-       }
-
-       xe->xe_value_size = cpu_to_le64(new_size);
-
-       ret = ocfs2_journal_dirty(handle, xe_bh);
-       if (ret < 0)
-               mlog_errno(ret);
-
-out:
-       return ret;
-}
-
 /*
  * Truncate the specified xe_off entry in xattr bucket.
  * bucket is indicated by header_bh and len is the new length.
@@ -4473,19 +5154,19 @@ out:
  * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
  */
 static int ocfs2_xattr_bucket_value_truncate(struct inode *inode,
-                                            struct buffer_head *header_bh,
+                                            struct ocfs2_xattr_bucket *bucket,
                                             int xe_off,
                                             int len,
                                             struct ocfs2_xattr_set_ctxt *ctxt)
 {
        int ret, offset;
        u64 value_blk;
-       struct buffer_head *value_bh = NULL;
-       struct ocfs2_xattr_value_root *xv;
        struct ocfs2_xattr_entry *xe;
-       struct ocfs2_xattr_header *xh =
-                       (struct ocfs2_xattr_header *)header_bh->b_data;
+       struct ocfs2_xattr_header *xh = bucket_xh(bucket);
        size_t blocksize = inode->i_sb->s_blocksize;
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_access = ocfs2_journal_access,
+       };
 
        xe = &xh->xh_entries[xe_off];
 
@@ -4498,34 +5179,40 @@ static int ocfs2_xattr_bucket_value_truncate(struct inode *inode,
 
        /* We don't allow ocfs2_xattr_value to be stored in different block. */
        BUG_ON(value_blk != (offset + OCFS2_XATTR_ROOT_SIZE - 1) / blocksize);
-       value_blk += header_bh->b_blocknr;
 
-       ret = ocfs2_read_block(inode, value_blk, &value_bh);
-       if (ret) {
-               mlog_errno(ret);
-               goto out;
-       }
+       vb.vb_bh = bucket->bu_bhs[value_blk];
+       BUG_ON(!vb.vb_bh);
 
-       xv = (struct ocfs2_xattr_value_root *)
-               (value_bh->b_data + offset % blocksize);
+       vb.vb_xv = (struct ocfs2_xattr_value_root *)
+               (vb.vb_bh->b_data + offset % blocksize);
 
+       /*
+        * From here on out we have to dirty the bucket.  The generic
+        * value calls only modify one of the bucket's bhs, but we need
+        * to send the bucket at once.  So if they error, they *could* have
+        * modified something.  We have to assume they did, and dirty
+        * the whole bucket.  This leaves us in a consistent state.
+        */
        mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n",
-            xe_off, (unsigned long long)header_bh->b_blocknr, len);
-       ret = ocfs2_xattr_value_truncate(inode, value_bh, xv, len, ctxt);
+            xe_off, (unsigned long long)bucket_blkno(bucket), len);
+       ret = ocfs2_xattr_value_truncate(inode, &vb, len, ctxt);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_xattr_value_update_size(inode, ctxt->handle,
-                                           header_bh, xe, len);
+       ret = ocfs2_xattr_bucket_journal_access(ctxt->handle, bucket,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
+       xe->xe_value_size = cpu_to_le64(len);
+
+       ocfs2_xattr_bucket_journal_dirty(ctxt->handle, bucket);
+
 out:
-       brelse(value_bh);
        return ret;
 }
 
@@ -4541,7 +5228,7 @@ static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode,
        BUG_ON(!xs->bucket->bu_bhs[0] || !xe || ocfs2_xattr_is_local(xe));
 
        offset = xe - xh->xh_entries;
-       ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket->bu_bhs[0],
+       ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket,
                                                offset, len, ctxt);
        if (ret)
                mlog_errno(ret);
@@ -4555,26 +5242,46 @@ static int ocfs2_xattr_bucket_set_value_outside(struct inode *inode,
                                                char *val,
                                                int value_len)
 {
-       int offset;
+       int ret, offset, block_off;
        struct ocfs2_xattr_value_root *xv;
        struct ocfs2_xattr_entry *xe = xs->here;
+       struct ocfs2_xattr_header *xh = bucket_xh(xs->bucket);
+       void *base;
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_access = ocfs2_journal_access,
+       };
 
        BUG_ON(!xs->base || !xe || ocfs2_xattr_is_local(xe));
 
-       offset = le16_to_cpu(xe->xe_name_offset) +
-                OCFS2_XATTR_SIZE(xe->xe_name_len);
+       ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, xh,
+                                               xe - xh->xh_entries,
+                                               &block_off,
+                                               &offset);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
 
-       xv = (struct ocfs2_xattr_value_root *)(xs->base + offset);
+       base = bucket_block(xs->bucket, block_off);
+       xv = (struct ocfs2_xattr_value_root *)(base + offset +
+                OCFS2_XATTR_SIZE(xe->xe_name_len));
 
-       return __ocfs2_xattr_set_value_outside(inode, handle,
-                                              xv, val, value_len);
+       vb.vb_xv = xv;
+       vb.vb_bh = xs->bucket->bu_bhs[block_off];
+       ret = __ocfs2_xattr_set_value_outside(inode, handle,
+                                             &vb, val, value_len);
+       if (ret)
+               mlog_errno(ret);
+out:
+       return ret;
 }
 
 static int ocfs2_rm_xattr_cluster(struct inode *inode,
                                  struct buffer_head *root_bh,
                                  u64 blkno,
                                  u32 cpos,
-                                 u32 len)
+                                 u32 len,
+                                 void *para)
 {
        int ret;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
@@ -4586,14 +5293,22 @@ static int ocfs2_rm_xattr_cluster(struct inode *inode,
        struct ocfs2_cached_dealloc_ctxt dealloc;
        struct ocfs2_extent_tree et;
 
-       ocfs2_init_xattr_tree_extent_tree(&et, inode, root_bh);
+       ret = ocfs2_iterate_xattr_buckets(inode, blkno, len,
+                                         ocfs2_delete_xattr_in_bucket, para);
+       if (ret) {
+               mlog_errno(ret);
+               return ret;
+       }
+
+       ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh);
 
        ocfs2_init_dealloc_ctxt(&dealloc);
 
        mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n",
             cpos, len, (unsigned long long)blkno);
 
-       ocfs2_remove_xattr_clusters_from_cache(inode, blkno, len);
+       ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode), blkno,
+                                              len);
 
        ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
        if (ret) {
@@ -4611,21 +5326,21 @@ static int ocfs2_rm_xattr_cluster(struct inode *inode,
                }
        }
 
-       handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
+       handle = ocfs2_start_trans(osb, ocfs2_remove_extent_credits(osb->sb));
        if (IS_ERR(handle)) {
                ret = -ENOMEM;
                mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_journal_access(handle, inode, root_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh,
+                                     OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
                goto out_commit;
        }
 
-       ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac,
+       ret = ocfs2_remove_extent(handle, &et, cpos, len, meta_ac,
                                  &dealloc);
        if (ret) {
                mlog_errno(ret);
@@ -4830,8 +5545,8 @@ try_again:
        xh_free_start = le16_to_cpu(xh->xh_free_start);
        header_size = sizeof(struct ocfs2_xattr_header) +
                        count * sizeof(struct ocfs2_xattr_entry);
-       max_free = OCFS2_XATTR_BUCKET_SIZE -
-               le16_to_cpu(xh->xh_name_value_len) - header_size;
+       max_free = OCFS2_XATTR_BUCKET_SIZE - header_size -
+               le16_to_cpu(xh->xh_name_value_len) - OCFS2_XATTR_HEADER_GAP;
 
        mlog_bug_on_msg(header_size > blocksize, "bucket %llu has header size "
                        "of %u which exceed block size\n",
@@ -4864,7 +5579,7 @@ try_again:
                        need = 0;
        }
 
-       free = xh_free_start - header_size;
+       free = xh_free_start - header_size - OCFS2_XATTR_HEADER_GAP;
        /*
         * We need to make sure the new name/value pair
         * can exist in the same block.
@@ -4897,7 +5612,8 @@ try_again:
                        }
 
                        xh_free_start = le16_to_cpu(xh->xh_free_start);
-                       free = xh_free_start - header_size;
+                       free = xh_free_start - header_size
+                               - OCFS2_XATTR_HEADER_GAP;
                        if (xh_free_start % blocksize < need)
                                free -= xh_free_start % blocksize;
 
@@ -4931,15 +5647,21 @@ try_again:
 
                ret = ocfs2_add_new_xattr_bucket(inode,
                                                 xs->xattr_bh,
-                                                xs->bucket->bu_bhs[0],
+                                                xs->bucket,
                                                 ctxt);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
 
+               /*
+                * ocfs2_add_new_xattr_bucket() will have updated
+                * xs->bucket if it moved, but it will not have updated
+                * any of the other search fields.  Thus, we drop it and
+                * re-search.  Everything should be cached, so it'll be
+                * quick.
+                */
                ocfs2_xattr_bucket_relse(xs->bucket);
-
                ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh,
                                                   xi->name_index,
                                                   xi->name, xs);
@@ -4961,83 +5683,1478 @@ static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
                                        struct ocfs2_xattr_bucket *bucket,
                                        void *para)
 {
-       int ret = 0;
+       int ret = 0, ref_credits;
        struct ocfs2_xattr_header *xh = bucket_xh(bucket);
        u16 i;
        struct ocfs2_xattr_entry *xe;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        struct ocfs2_xattr_set_ctxt ctxt = {NULL, NULL,};
+       int credits = ocfs2_remove_extent_credits(osb->sb) +
+               ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+       struct ocfs2_xattr_value_root *xv;
+       struct ocfs2_rm_xattr_bucket_para *args =
+                       (struct ocfs2_rm_xattr_bucket_para *)para;
 
        ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
 
-       ctxt.handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
-       if (IS_ERR(ctxt.handle)) {
-               ret = PTR_ERR(ctxt.handle);
-               mlog_errno(ret);
-               goto out;
-       }
-
        for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
                xe = &xh->xh_entries[i];
                if (ocfs2_xattr_is_local(xe))
                        continue;
 
-               ret = ocfs2_xattr_bucket_value_truncate(inode,
-                                                       bucket->bu_bhs[0],
+               ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket,
+                                                     i, &xv, NULL);
+
+               ret = ocfs2_lock_xattr_remove_allocators(inode, xv,
+                                                        args->ref_ci,
+                                                        args->ref_root_bh,
+                                                        &ctxt.meta_ac,
+                                                        &ref_credits);
+
+               ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits);
+               if (IS_ERR(ctxt.handle)) {
+                       ret = PTR_ERR(ctxt.handle);
+                       mlog_errno(ret);
+                       break;
+               }
+
+               ret = ocfs2_xattr_bucket_value_truncate(inode, bucket,
                                                        i, 0, &ctxt);
+
+               ocfs2_commit_trans(osb, ctxt.handle);
+               if (ctxt.meta_ac) {
+                       ocfs2_free_alloc_context(ctxt.meta_ac);
+                       ctxt.meta_ac = NULL;
+               }
                if (ret) {
                        mlog_errno(ret);
                        break;
                }
        }
 
-       ret = ocfs2_commit_trans(osb, ctxt.handle);
+       if (ctxt.meta_ac)
+               ocfs2_free_alloc_context(ctxt.meta_ac);
        ocfs2_schedule_truncate_log_flush(osb, 1);
        ocfs2_run_deallocs(osb, &ctxt.dealloc);
+       return ret;
+}
+
+/*
+ * Whenever we modify a xattr value root in the bucket(e.g, CoW
+ * or change the extent record flag), we need to recalculate
+ * the metaecc for the whole bucket. So it is done here.
+ *
+ * Note:
+ * We have to give the extra credits for the caller.
+ */
+static int ocfs2_xattr_bucket_post_refcount(struct inode *inode,
+                                           handle_t *handle,
+                                           void *para)
+{
+       int ret;
+       struct ocfs2_xattr_bucket *bucket =
+                       (struct ocfs2_xattr_bucket *)para;
+
+       ret = ocfs2_xattr_bucket_journal_access(handle, bucket,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
+       if (ret) {
+               mlog_errno(ret);
+               return ret;
+       }
+
+       ocfs2_xattr_bucket_journal_dirty(handle, bucket);
+
+       return 0;
+}
+
+/*
+ * Special action we need if the xattr value is refcounted.
+ *
+ * 1. If the xattr is refcounted, lock the tree.
+ * 2. CoW the xattr if we are setting the new value and the value
+ *    will be stored outside.
+ * 3. In other case, decrease_refcount will work for us, so just
+ *    lock the refcount tree, calculate the meta and credits is OK.
+ *
+ * We have to do CoW before ocfs2_init_xattr_set_ctxt since
+ * currently CoW is a completed transaction, while this function
+ * will also lock the allocators and let us deadlock. So we will
+ * CoW the whole xattr value.
+ */
+static int ocfs2_prepare_refcount_xattr(struct inode *inode,
+                                       struct ocfs2_dinode *di,
+                                       struct ocfs2_xattr_info *xi,
+                                       struct ocfs2_xattr_search *xis,
+                                       struct ocfs2_xattr_search *xbs,
+                                       struct ocfs2_refcount_tree **ref_tree,
+                                       int *meta_add,
+                                       int *credits)
+{
+       int ret = 0;
+       struct ocfs2_xattr_block *xb;
+       struct ocfs2_xattr_entry *xe;
+       char *base;
+       u32 p_cluster, num_clusters;
+       unsigned int ext_flags;
+       int name_offset, name_len;
+       struct ocfs2_xattr_value_buf vb;
+       struct ocfs2_xattr_bucket *bucket = NULL;
+       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       struct ocfs2_post_refcount refcount;
+       struct ocfs2_post_refcount *p = NULL;
+       struct buffer_head *ref_root_bh = NULL;
+
+       if (!xis->not_found) {
+               xe = xis->here;
+               name_offset = le16_to_cpu(xe->xe_name_offset);
+               name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
+               base = xis->base;
+               vb.vb_bh = xis->inode_bh;
+               vb.vb_access = ocfs2_journal_access_di;
+       } else {
+               int i, block_off = 0;
+               xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
+               xe = xbs->here;
+               name_offset = le16_to_cpu(xe->xe_name_offset);
+               name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
+               i = xbs->here - xbs->header->xh_entries;
+
+               if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
+                       ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
+                                                       bucket_xh(xbs->bucket),
+                                                       i, &block_off,
+                                                       &name_offset);
+                       if (ret) {
+                               mlog_errno(ret);
+                               goto out;
+                       }
+                       base = bucket_block(xbs->bucket, block_off);
+                       vb.vb_bh = xbs->bucket->bu_bhs[block_off];
+                       vb.vb_access = ocfs2_journal_access;
+
+                       if (ocfs2_meta_ecc(osb)) {
+                               /*create parameters for ocfs2_post_refcount. */
+                               bucket = xbs->bucket;
+                               refcount.credits = bucket->bu_blocks;
+                               refcount.para = bucket;
+                               refcount.func =
+                                       ocfs2_xattr_bucket_post_refcount;
+                               p = &refcount;
+                       }
+               } else {
+                       base = xbs->base;
+                       vb.vb_bh = xbs->xattr_bh;
+                       vb.vb_access = ocfs2_journal_access_xb;
+               }
+       }
+
+       if (ocfs2_xattr_is_local(xe))
+               goto out;
+
+       vb.vb_xv = (struct ocfs2_xattr_value_root *)
+                               (base + name_offset + name_len);
+
+       ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster,
+                                      &num_clusters, &vb.vb_xv->xr_list,
+                                      &ext_flags);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       /*
+        * We just need to check the 1st extent record, since we always
+        * CoW the whole xattr. So there shouldn't be a xattr with
+        * some REFCOUNT extent recs after the 1st one.
+        */
+       if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
+               goto out;
+
+       ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
+                                      1, ref_tree, &ref_root_bh);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       /*
+        * If we are deleting the xattr or the new size will be stored inside,
+        * cool, leave it there, the xattr truncate process will remove them
+        * for us(it still needs the refcount tree lock and the meta, credits).
+        * And the worse case is that every cluster truncate will split the
+        * refcount tree, and make the original extent become 3. So we will need
+        * 2 * cluster more extent recs at most.
+        */
+       if (!xi->value || xi->value_len <= OCFS2_XATTR_INLINE_SIZE) {
+
+               ret = ocfs2_refcounted_xattr_delete_need(inode,
+                                                        &(*ref_tree)->rf_ci,
+                                                        ref_root_bh, vb.vb_xv,
+                                                        meta_add, credits);
+               if (ret)
+                       mlog_errno(ret);
+               goto out;
+       }
+
+       ret = ocfs2_refcount_cow_xattr(inode, di, &vb,
+                                      *ref_tree, ref_root_bh, 0,
+                                      le32_to_cpu(vb.vb_xv->xr_clusters), p);
+       if (ret)
+               mlog_errno(ret);
+
 out:
+       brelse(ref_root_bh);
        return ret;
 }
 
-static int ocfs2_delete_xattr_index_block(struct inode *inode,
-                                         struct buffer_head *xb_bh)
+/*
+ * Add the REFCOUNTED flags for all the extent rec in ocfs2_xattr_value_root.
+ * The physical clusters will be added to refcount tree.
+ */
+static int ocfs2_xattr_value_attach_refcount(struct inode *inode,
+                               struct ocfs2_xattr_value_root *xv,
+                               struct ocfs2_extent_tree *value_et,
+                               struct ocfs2_caching_info *ref_ci,
+                               struct buffer_head *ref_root_bh,
+                               struct ocfs2_cached_dealloc_ctxt *dealloc,
+                               struct ocfs2_post_refcount *refcount)
 {
-       struct ocfs2_xattr_block *xb =
-                       (struct ocfs2_xattr_block *)xb_bh->b_data;
-       struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list;
        int ret = 0;
-       u32 name_hash = UINT_MAX, e_cpos, num_clusters;
-       u64 p_blkno;
+       u32 clusters = le32_to_cpu(xv->xr_clusters);
+       u32 cpos, p_cluster, num_clusters;
+       struct ocfs2_extent_list *el = &xv->xr_list;
+       unsigned int ext_flags;
 
-       if (le16_to_cpu(el->l_next_free_rec) == 0)
-               return 0;
+       cpos = 0;
+       while (cpos < clusters) {
+               ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
+                                              &num_clusters, el, &ext_flags);
 
-       while (name_hash > 0) {
-               ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
-                                         &e_cpos, &num_clusters, el);
+               cpos += num_clusters;
+               if ((ext_flags & OCFS2_EXT_REFCOUNTED))
+                       continue;
+
+               BUG_ON(!p_cluster);
+
+               ret = ocfs2_add_refcount_flag(inode, value_et,
+                                             ref_ci, ref_root_bh,
+                                             cpos - num_clusters,
+                                             p_cluster, num_clusters,
+                                             dealloc, refcount);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+       }
+
+       return ret;
+}
+
+/*
+ * Given a normal ocfs2_xattr_header, refcount all the entries which
+ * have value stored outside.
+ * Used for xattrs stored in inode and ocfs2_xattr_block.
+ */
+static int ocfs2_xattr_attach_refcount_normal(struct inode *inode,
+                               struct ocfs2_xattr_value_buf *vb,
+                               struct ocfs2_xattr_header *header,
+                               struct ocfs2_caching_info *ref_ci,
+                               struct buffer_head *ref_root_bh,
+                               struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+
+       struct ocfs2_xattr_entry *xe;
+       struct ocfs2_xattr_value_root *xv;
+       struct ocfs2_extent_tree et;
+       int i, ret = 0;
+
+       for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
+               xe = &header->xh_entries[i];
+
+               if (ocfs2_xattr_is_local(xe))
+                       continue;
+
+               xv = (struct ocfs2_xattr_value_root *)((void *)header +
+                       le16_to_cpu(xe->xe_name_offset) +
+                       OCFS2_XATTR_SIZE(xe->xe_name_len));
+
+               vb->vb_xv = xv;
+               ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
+
+               ret = ocfs2_xattr_value_attach_refcount(inode, xv, &et,
+                                                       ref_ci, ref_root_bh,
+                                                       dealloc, NULL);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+       }
+
+       return ret;
+}
+
+static int ocfs2_xattr_inline_attach_refcount(struct inode *inode,
+                               struct buffer_head *fe_bh,
+                               struct ocfs2_caching_info *ref_ci,
+                               struct buffer_head *ref_root_bh,
+                               struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+       struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
+       struct ocfs2_xattr_header *header = (struct ocfs2_xattr_header *)
+                               (fe_bh->b_data + inode->i_sb->s_blocksize -
+                               le16_to_cpu(di->i_xattr_inline_size));
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_bh = fe_bh,
+               .vb_access = ocfs2_journal_access_di,
+       };
+
+       return ocfs2_xattr_attach_refcount_normal(inode, &vb, header,
+                                                 ref_ci, ref_root_bh, dealloc);
+}
+
+struct ocfs2_xattr_tree_value_refcount_para {
+       struct ocfs2_caching_info *ref_ci;
+       struct buffer_head *ref_root_bh;
+       struct ocfs2_cached_dealloc_ctxt *dealloc;
+};
+
+static int ocfs2_get_xattr_tree_value_root(struct super_block *sb,
+                                          struct ocfs2_xattr_bucket *bucket,
+                                          int offset,
+                                          struct ocfs2_xattr_value_root **xv,
+                                          struct buffer_head **bh)
+{
+       int ret, block_off, name_offset;
+       struct ocfs2_xattr_header *xh = bucket_xh(bucket);
+       struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset];
+       void *base;
+
+       ret = ocfs2_xattr_bucket_get_name_value(sb,
+                                               bucket_xh(bucket),
+                                               offset,
+                                               &block_off,
+                                               &name_offset);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       base = bucket_block(bucket, block_off);
+
+       *xv = (struct ocfs2_xattr_value_root *)(base + name_offset +
+                        OCFS2_XATTR_SIZE(xe->xe_name_len));
+
+       if (bh)
+               *bh = bucket->bu_bhs[block_off];
+out:
+       return ret;
+}
+
+/*
+ * For a given xattr bucket, refcount all the entries which
+ * have value stored outside.
+ */
+static int ocfs2_xattr_bucket_value_refcount(struct inode *inode,
+                                            struct ocfs2_xattr_bucket *bucket,
+                                            void *para)
+{
+       int i, ret = 0;
+       struct ocfs2_extent_tree et;
+       struct ocfs2_xattr_tree_value_refcount_para *ref =
+                       (struct ocfs2_xattr_tree_value_refcount_para *)para;
+       struct ocfs2_xattr_header *xh =
+                       (struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;
+       struct ocfs2_xattr_entry *xe;
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_access = ocfs2_journal_access,
+       };
+       struct ocfs2_post_refcount refcount = {
+               .credits = bucket->bu_blocks,
+               .para = bucket,
+               .func = ocfs2_xattr_bucket_post_refcount,
+       };
+       struct ocfs2_post_refcount *p = NULL;
+
+       /* We only need post_refcount if we support metaecc. */
+       if (ocfs2_meta_ecc(OCFS2_SB(inode->i_sb)))
+               p = &refcount;
+
+       mlog(0, "refcount bucket %llu, count = %u\n",
+            (unsigned long long)bucket_blkno(bucket),
+            le16_to_cpu(xh->xh_count));
+       for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
+               xe = &xh->xh_entries[i];
+
+               if (ocfs2_xattr_is_local(xe))
+                       continue;
+
+               ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, i,
+                                                     &vb.vb_xv, &vb.vb_bh);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+
+               ocfs2_init_xattr_value_extent_tree(&et,
+                                                  INODE_CACHE(inode), &vb);
+
+               ret = ocfs2_xattr_value_attach_refcount(inode, vb.vb_xv,
+                                                       &et, ref->ref_ci,
+                                                       ref->ref_root_bh,
+                                                       ref->dealloc, p);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+       }
+
+       return ret;
+
+}
+
+static int ocfs2_refcount_xattr_tree_rec(struct inode *inode,
+                                    struct buffer_head *root_bh,
+                                    u64 blkno, u32 cpos, u32 len, void *para)
+{
+       return ocfs2_iterate_xattr_buckets(inode, blkno, len,
+                                          ocfs2_xattr_bucket_value_refcount,
+                                          para);
+}
+
+static int ocfs2_xattr_block_attach_refcount(struct inode *inode,
+                               struct buffer_head *blk_bh,
+                               struct ocfs2_caching_info *ref_ci,
+                               struct buffer_head *ref_root_bh,
+                               struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+       int ret = 0;
+       struct ocfs2_xattr_block *xb =
+                               (struct ocfs2_xattr_block *)blk_bh->b_data;
+
+       if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
+               struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
+               struct ocfs2_xattr_value_buf vb = {
+                       .vb_bh = blk_bh,
+                       .vb_access = ocfs2_journal_access_xb,
+               };
+
+               ret = ocfs2_xattr_attach_refcount_normal(inode, &vb, header,
+                                                        ref_ci, ref_root_bh,
+                                                        dealloc);
+       } else {
+               struct ocfs2_xattr_tree_value_refcount_para para = {
+                       .ref_ci = ref_ci,
+                       .ref_root_bh = ref_root_bh,
+                       .dealloc = dealloc,
+               };
+
+               ret = ocfs2_iterate_xattr_index_block(inode, blk_bh,
+                                               ocfs2_refcount_xattr_tree_rec,
+                                               &para);
+       }
+
+       return ret;
+}
+
+int ocfs2_xattr_attach_refcount_tree(struct inode *inode,
+                                    struct buffer_head *fe_bh,
+                                    struct ocfs2_caching_info *ref_ci,
+                                    struct buffer_head *ref_root_bh,
+                                    struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+       int ret = 0;
+       struct ocfs2_inode_info *oi = OCFS2_I(inode);
+       struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
+       struct buffer_head *blk_bh = NULL;
+
+       if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
+               ret = ocfs2_xattr_inline_attach_refcount(inode, fe_bh,
+                                                        ref_ci, ref_root_bh,
+                                                        dealloc);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
+       }
+
+       if (!di->i_xattr_loc)
+               goto out;
+
+       ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
+                                    &blk_bh);
+       if (ret < 0) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       ret = ocfs2_xattr_block_attach_refcount(inode, blk_bh, ref_ci,
+                                               ref_root_bh, dealloc);
+       if (ret)
+               mlog_errno(ret);
+
+       brelse(blk_bh);
+out:
+
+       return ret;
+}
+
+typedef int (should_xattr_reflinked)(struct ocfs2_xattr_entry *xe);
+/*
+ * Store the information we need in xattr reflink.
+ * old_bh and new_bh are inode bh for the old and new inode.
+ */
+struct ocfs2_xattr_reflink {
+       struct inode *old_inode;
+       struct inode *new_inode;
+       struct buffer_head *old_bh;
+       struct buffer_head *new_bh;
+       struct ocfs2_caching_info *ref_ci;
+       struct buffer_head *ref_root_bh;
+       struct ocfs2_cached_dealloc_ctxt *dealloc;
+       should_xattr_reflinked *xattr_reflinked;
+};
+
+/*
+ * Given a xattr header and xe offset,
+ * return the proper xv and the corresponding bh.
+ * xattr in inode, block and xattr tree have different implementaions.
+ */
+typedef int (get_xattr_value_root)(struct super_block *sb,
+                                  struct buffer_head *bh,
+                                  struct ocfs2_xattr_header *xh,
+                                  int offset,
+                                  struct ocfs2_xattr_value_root **xv,
+                                  struct buffer_head **ret_bh,
+                                  void *para);
+
+/*
+ * Calculate all the xattr value root metadata stored in this xattr header and
+ * credits we need if we create them from the scratch.
+ * We use get_xattr_value_root so that all types of xattr container can use it.
+ */
+static int ocfs2_value_metas_in_xattr_header(struct super_block *sb,
+                                            struct buffer_head *bh,
+                                            struct ocfs2_xattr_header *xh,
+                                            int *metas, int *credits,
+                                            int *num_recs,
+                                            get_xattr_value_root *func,
+                                            void *para)
+{
+       int i, ret = 0;
+       struct ocfs2_xattr_value_root *xv;
+       struct ocfs2_xattr_entry *xe;
+
+       for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
+               xe = &xh->xh_entries[i];
+               if (ocfs2_xattr_is_local(xe))
+                       continue;
+
+               ret = func(sb, bh, xh, i, &xv, NULL, para);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+
+               *metas += le16_to_cpu(xv->xr_list.l_tree_depth) *
+                         le16_to_cpu(xv->xr_list.l_next_free_rec);
+
+               *credits += ocfs2_calc_extend_credits(sb,
+                                               &def_xv.xv.xr_list,
+                                               le32_to_cpu(xv->xr_clusters));
+
+               /*
+                * If the value is a tree with depth > 1, We don't go deep
+                * to the extent block, so just calculate a maximum record num.
+                */
+               if (!xv->xr_list.l_tree_depth)
+                       *num_recs += le16_to_cpu(xv->xr_list.l_next_free_rec);
+               else
+                       *num_recs += ocfs2_clusters_for_bytes(sb,
+                                                             XATTR_SIZE_MAX);
+       }
+
+       return ret;
+}
+
+/* Used by xattr inode and block to return the right xv and buffer_head. */
+static int ocfs2_get_xattr_value_root(struct super_block *sb,
+                                     struct buffer_head *bh,
+                                     struct ocfs2_xattr_header *xh,
+                                     int offset,
+                                     struct ocfs2_xattr_value_root **xv,
+                                     struct buffer_head **ret_bh,
+                                     void *para)
+{
+       struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset];
+
+       *xv = (struct ocfs2_xattr_value_root *)((void *)xh +
+               le16_to_cpu(xe->xe_name_offset) +
+               OCFS2_XATTR_SIZE(xe->xe_name_len));
+
+       if (ret_bh)
+               *ret_bh = bh;
+
+       return 0;
+}
+
+/*
+ * Lock the meta_ac and caculate how much credits we need for reflink xattrs.
+ * It is only used for inline xattr and xattr block.
+ */
+static int ocfs2_reflink_lock_xattr_allocators(struct ocfs2_super *osb,
+                                       struct ocfs2_xattr_header *xh,
+                                       struct buffer_head *ref_root_bh,
+                                       int *credits,
+                                       struct ocfs2_alloc_context **meta_ac)
+{
+       int ret, meta_add = 0, num_recs = 0;
+       struct ocfs2_refcount_block *rb =
+                       (struct ocfs2_refcount_block *)ref_root_bh->b_data;
+
+       *credits = 0;
+
+       ret = ocfs2_value_metas_in_xattr_header(osb->sb, NULL, xh,
+                                               &meta_add, credits, &num_recs,
+                                               ocfs2_get_xattr_value_root,
+                                               NULL);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       /*
+        * We need to add/modify num_recs in refcount tree, so just calculate
+        * an approximate number we need for refcount tree change.
+        * Sometimes we need to split the tree, and after split,  half recs
+        * will be moved to the new block, and a new block can only provide
+        * half number of recs. So we multiple new blocks by 2.
+        */
+       num_recs = num_recs / ocfs2_refcount_recs_per_rb(osb->sb) * 2;
+       meta_add += num_recs;
+       *credits += num_recs + num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
+       if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
+               *credits += le16_to_cpu(rb->rf_list.l_tree_depth) *
+                           le16_to_cpu(rb->rf_list.l_next_free_rec) + 1;
+       else
+               *credits += 1;
+
+       ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add, meta_ac);
+       if (ret)
+               mlog_errno(ret);
+
+out:
+       return ret;
+}
+
+/*
+ * Given a xattr header, reflink all the xattrs in this container.
+ * It can be used for inode, block and bucket.
+ *
+ * NOTE:
+ * Before we call this function, the caller has memcpy the xattr in
+ * old_xh to the new_xh.
+ *
+ * If args.xattr_reflinked is set, call it to decide whether the xe should
+ * be reflinked or not. If not, remove it from the new xattr header.
+ */
+static int ocfs2_reflink_xattr_header(handle_t *handle,
+                                     struct ocfs2_xattr_reflink *args,
+                                     struct buffer_head *old_bh,
+                                     struct ocfs2_xattr_header *xh,
+                                     struct buffer_head *new_bh,
+                                     struct ocfs2_xattr_header *new_xh,
+                                     struct ocfs2_xattr_value_buf *vb,
+                                     struct ocfs2_alloc_context *meta_ac,
+                                     get_xattr_value_root *func,
+                                     void *para)
+{
+       int ret = 0, i, j;
+       struct super_block *sb = args->old_inode->i_sb;
+       struct buffer_head *value_bh;
+       struct ocfs2_xattr_entry *xe, *last;
+       struct ocfs2_xattr_value_root *xv, *new_xv;
+       struct ocfs2_extent_tree data_et;
+       u32 clusters, cpos, p_cluster, num_clusters;
+       unsigned int ext_flags = 0;
+
+       mlog(0, "reflink xattr in container %llu, count = %u\n",
+            (unsigned long long)old_bh->b_blocknr, le16_to_cpu(xh->xh_count));
+
+       last = &new_xh->xh_entries[le16_to_cpu(new_xh->xh_count)];
+       for (i = 0, j = 0; i < le16_to_cpu(xh->xh_count); i++, j++) {
+               xe = &xh->xh_entries[i];
+
+               if (args->xattr_reflinked && !args->xattr_reflinked(xe)) {
+                       xe = &new_xh->xh_entries[j];
+
+                       le16_add_cpu(&new_xh->xh_count, -1);
+                       if (new_xh->xh_count) {
+                               memmove(xe, xe + 1,
+                                       (void *)last - (void *)xe);
+                               memset(last, 0,
+                                      sizeof(struct ocfs2_xattr_entry));
+                       }
+
+                       /*
+                        * We don't want j to increase in the next round since
+                        * it is already moved ahead.
+                        */
+                       j--;
+                       continue;
+               }
+
+               if (ocfs2_xattr_is_local(xe))
+                       continue;
+
+               ret = func(sb, old_bh, xh, i, &xv, NULL, para);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+
+               ret = func(sb, new_bh, new_xh, j, &new_xv, &value_bh, para);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+
+               /*
+                * For the xattr which has l_tree_depth = 0, all the extent
+                * recs have already be copied to the new xh with the
+                * propriate OCFS2_EXT_REFCOUNTED flag we just need to
+                * increase the refount count int the refcount tree.
+                *
+                * For the xattr which has l_tree_depth > 0, we need
+                * to initialize it to the empty default value root,
+                * and then insert the extents one by one.
+                */
+               if (xv->xr_list.l_tree_depth) {
+                       memcpy(new_xv, &def_xv, sizeof(def_xv));
+                       vb->vb_xv = new_xv;
+                       vb->vb_bh = value_bh;
+                       ocfs2_init_xattr_value_extent_tree(&data_et,
+                                       INODE_CACHE(args->new_inode), vb);
+               }
+
+               clusters = le32_to_cpu(xv->xr_clusters);
+               cpos = 0;
+               while (cpos < clusters) {
+                       ret = ocfs2_xattr_get_clusters(args->old_inode,
+                                                      cpos,
+                                                      &p_cluster,
+                                                      &num_clusters,
+                                                      &xv->xr_list,
+                                                      &ext_flags);
+                       if (ret) {
+                               mlog_errno(ret);
+                               goto out;
+                       }
+
+                       BUG_ON(!p_cluster);
+
+                       if (xv->xr_list.l_tree_depth) {
+                               ret = ocfs2_insert_extent(handle,
+                                               &data_et, cpos,
+                                               ocfs2_clusters_to_blocks(
+                                                       args->old_inode->i_sb,
+                                                       p_cluster),
+                                               num_clusters, ext_flags,
+                                               meta_ac);
+                               if (ret) {
+                                       mlog_errno(ret);
+                                       goto out;
+                               }
+                       }
+
+                       ret = ocfs2_increase_refcount(handle, args->ref_ci,
+                                                     args->ref_root_bh,
+                                                     p_cluster, num_clusters,
+                                                     meta_ac, args->dealloc);
+                       if (ret) {
+                               mlog_errno(ret);
+                               goto out;
+                       }
+
+                       cpos += num_clusters;
+               }
+       }
+
+out:
+       return ret;
+}
+
+static int ocfs2_reflink_xattr_inline(struct ocfs2_xattr_reflink *args)
+{
+       int ret = 0, credits = 0;
+       handle_t *handle;
+       struct ocfs2_super *osb = OCFS2_SB(args->old_inode->i_sb);
+       struct ocfs2_dinode *di = (struct ocfs2_dinode *)args->old_bh->b_data;
+       int inline_size = le16_to_cpu(di->i_xattr_inline_size);
+       int header_off = osb->sb->s_blocksize - inline_size;
+       struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)
+                                       (args->old_bh->b_data + header_off);
+       struct ocfs2_xattr_header *new_xh = (struct ocfs2_xattr_header *)
+                                       (args->new_bh->b_data + header_off);
+       struct ocfs2_alloc_context *meta_ac = NULL;
+       struct ocfs2_inode_info *new_oi;
+       struct ocfs2_dinode *new_di;
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_bh = args->new_bh,
+               .vb_access = ocfs2_journal_access_di,
+       };
+
+       ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh,
+                                                 &credits, &meta_ac);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       handle = ocfs2_start_trans(osb, credits);
+       if (IS_ERR(handle)) {
+               ret = PTR_ERR(handle);
+               mlog_errno(ret);
+               goto out;
+       }
+
+       ret = ocfs2_journal_access_di(handle, INODE_CACHE(args->new_inode),
+                                     args->new_bh, OCFS2_JOURNAL_ACCESS_WRITE);
+       if (ret) {
+               mlog_errno(ret);
+               goto out_commit;
+       }
+
+       memcpy(args->new_bh->b_data + header_off,
+              args->old_bh->b_data + header_off, inline_size);
+
+       new_di = (struct ocfs2_dinode *)args->new_bh->b_data;
+       new_di->i_xattr_inline_size = cpu_to_le16(inline_size);
+
+       ret = ocfs2_reflink_xattr_header(handle, args, args->old_bh, xh,
+                                        args->new_bh, new_xh, &vb, meta_ac,
+                                        ocfs2_get_xattr_value_root, NULL);
+       if (ret) {
+               mlog_errno(ret);
+               goto out_commit;
+       }
+
+       new_oi = OCFS2_I(args->new_inode);
+       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);
+       spin_unlock(&new_oi->ip_lock);
+
+       ocfs2_journal_dirty(handle, args->new_bh);
+
+out_commit:
+       ocfs2_commit_trans(osb, handle);
+
+out:
+       if (meta_ac)
+               ocfs2_free_alloc_context(meta_ac);
+       return ret;
+}
+
+static int ocfs2_create_empty_xattr_block(struct inode *inode,
+                                         struct buffer_head *fe_bh,
+                                         struct buffer_head **ret_bh,
+                                         int indexed)
+{
+       int ret;
+       handle_t *handle;
+       struct ocfs2_alloc_context *meta_ac;
+       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+
+       ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac);
+       if (ret < 0) {
+               mlog_errno(ret);
+               return ret;
+       }
+
+       handle = ocfs2_start_trans(osb, OCFS2_XATTR_BLOCK_CREATE_CREDITS);
+       if (IS_ERR(handle)) {
+               ret = PTR_ERR(handle);
+               mlog_errno(ret);
+               goto out;
+       }
+
+       mlog(0, "create new xattr block for inode %llu, index = %d\n",
+            (unsigned long long)fe_bh->b_blocknr, indexed);
+       ret = ocfs2_create_xattr_block(handle, inode, fe_bh,
+                                      meta_ac, ret_bh, indexed);
+       if (ret)
+               mlog_errno(ret);
+
+       ocfs2_commit_trans(osb, handle);
+out:
+       ocfs2_free_alloc_context(meta_ac);
+       return ret;
+}
+
+static int ocfs2_reflink_xattr_block(struct ocfs2_xattr_reflink *args,
+                                    struct buffer_head *blk_bh,
+                                    struct buffer_head *new_blk_bh)
+{
+       int ret = 0, credits = 0;
+       handle_t *handle;
+       struct ocfs2_inode_info *new_oi = OCFS2_I(args->new_inode);
+       struct ocfs2_dinode *new_di;
+       struct ocfs2_super *osb = OCFS2_SB(args->new_inode->i_sb);
+       int header_off = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
+       struct ocfs2_xattr_block *xb =
+                       (struct ocfs2_xattr_block *)blk_bh->b_data;
+       struct ocfs2_xattr_header *xh = &xb->xb_attrs.xb_header;
+       struct ocfs2_xattr_block *new_xb =
+                       (struct ocfs2_xattr_block *)new_blk_bh->b_data;
+       struct ocfs2_xattr_header *new_xh = &new_xb->xb_attrs.xb_header;
+       struct ocfs2_alloc_context *meta_ac;
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_bh = new_blk_bh,
+               .vb_access = ocfs2_journal_access_xb,
+       };
+
+       ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh,
+                                                 &credits, &meta_ac);
+       if (ret) {
+               mlog_errno(ret);
+               return ret;
+       }
+
+       /* One more credits in case we need to add xattr flags in new inode. */
+       handle = ocfs2_start_trans(osb, credits + 1);
+       if (IS_ERR(handle)) {
+               ret = PTR_ERR(handle);
+               mlog_errno(ret);
+               goto out;
+       }
+
+       if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) {
+               ret = ocfs2_journal_access_di(handle,
+                                             INODE_CACHE(args->new_inode),
+                                             args->new_bh,
+                                             OCFS2_JOURNAL_ACCESS_WRITE);
+               if (ret) {
+                       mlog_errno(ret);
+                       goto out_commit;
+               }
+       }
+
+       ret = ocfs2_journal_access_xb(handle, INODE_CACHE(args->new_inode),
+                                     new_blk_bh, OCFS2_JOURNAL_ACCESS_WRITE);
+       if (ret) {
+               mlog_errno(ret);
+               goto out_commit;
+       }
+
+       memcpy(new_blk_bh->b_data + header_off, blk_bh->b_data + header_off,
+              osb->sb->s_blocksize - header_off);
+
+       ret = ocfs2_reflink_xattr_header(handle, args, blk_bh, xh,
+                                        new_blk_bh, new_xh, &vb, meta_ac,
+                                        ocfs2_get_xattr_value_root, NULL);
+       if (ret) {
+               mlog_errno(ret);
+               goto out_commit;
+       }
+
+       ocfs2_journal_dirty(handle, new_blk_bh);
+
+       if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) {
+               new_di = (struct ocfs2_dinode *)args->new_bh->b_data;
+               spin_lock(&new_oi->ip_lock);
+               new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL;
+               new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features);
+               spin_unlock(&new_oi->ip_lock);
+
+               ocfs2_journal_dirty(handle, args->new_bh);
+       }
+
+out_commit:
+       ocfs2_commit_trans(osb, handle);
+
+out:
+       ocfs2_free_alloc_context(meta_ac);
+       return ret;
+}
 
-               ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters,
-                                                 ocfs2_delete_xattr_in_bucket,
-                                                 NULL);
+struct ocfs2_reflink_xattr_tree_args {
+       struct ocfs2_xattr_reflink *reflink;
+       struct buffer_head *old_blk_bh;
+       struct buffer_head *new_blk_bh;
+       struct ocfs2_xattr_bucket *old_bucket;
+       struct ocfs2_xattr_bucket *new_bucket;
+};
+
+/*
+ * NOTE:
+ * We have to handle the case that both old bucket and new bucket
+ * will call this function to get the right ret_bh.
+ * So The caller must give us the right bh.
+ */
+static int ocfs2_get_reflink_xattr_value_root(struct super_block *sb,
+                                       struct buffer_head *bh,
+                                       struct ocfs2_xattr_header *xh,
+                                       int offset,
+                                       struct ocfs2_xattr_value_root **xv,
+                                       struct buffer_head **ret_bh,
+                                       void *para)
+{
+       struct ocfs2_reflink_xattr_tree_args *args =
+                       (struct ocfs2_reflink_xattr_tree_args *)para;
+       struct ocfs2_xattr_bucket *bucket;
+
+       if (bh == args->old_bucket->bu_bhs[0])
+               bucket = args->old_bucket;
+       else
+               bucket = args->new_bucket;
+
+       return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,
+                                              xv, ret_bh);
+}
+
+struct ocfs2_value_tree_metas {
+       int num_metas;
+       int credits;
+       int num_recs;
+};
+
+static int ocfs2_value_tree_metas_in_bucket(struct super_block *sb,
+                                       struct buffer_head *bh,
+                                       struct ocfs2_xattr_header *xh,
+                                       int offset,
+                                       struct ocfs2_xattr_value_root **xv,
+                                       struct buffer_head **ret_bh,
+                                       void *para)
+{
+       struct ocfs2_xattr_bucket *bucket =
+                               (struct ocfs2_xattr_bucket *)para;
+
+       return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,
+                                              xv, ret_bh);
+}
+
+static int ocfs2_calc_value_tree_metas(struct inode *inode,
+                                     struct ocfs2_xattr_bucket *bucket,
+                                     void *para)
+{
+       struct ocfs2_value_tree_metas *metas =
+                       (struct ocfs2_value_tree_metas *)para;
+       struct ocfs2_xattr_header *xh =
+                       (struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;
+
+       /* Add the credits for this bucket first. */
+       metas->credits += bucket->bu_blocks;
+       return ocfs2_value_metas_in_xattr_header(inode->i_sb, bucket->bu_bhs[0],
+                                       xh, &metas->num_metas,
+                                       &metas->credits, &metas->num_recs,
+                                       ocfs2_value_tree_metas_in_bucket,
+                                       bucket);
+}
+
+/*
+ * Given a xattr extent rec starting from blkno and having len clusters,
+ * iterate all the buckets calculate how much metadata we need for reflinking
+ * all the ocfs2_xattr_value_root and lock the allocators accordingly.
+ */
+static int ocfs2_lock_reflink_xattr_rec_allocators(
+                               struct ocfs2_reflink_xattr_tree_args *args,
+                               struct ocfs2_extent_tree *xt_et,
+                               u64 blkno, u32 len, int *credits,
+                               struct ocfs2_alloc_context **meta_ac,
+                               struct ocfs2_alloc_context **data_ac)
+{
+       int ret, num_free_extents;
+       struct ocfs2_value_tree_metas metas;
+       struct ocfs2_super *osb = OCFS2_SB(args->reflink->old_inode->i_sb);
+       struct ocfs2_refcount_block *rb;
+
+       memset(&metas, 0, sizeof(metas));
+
+       ret = ocfs2_iterate_xattr_buckets(args->reflink->old_inode, blkno, len,
+                                         ocfs2_calc_value_tree_metas, &metas);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       *credits = metas.credits;
+
+       /*
+        * Calculate we need for refcount tree change.
+        *
+        * We need to add/modify num_recs in refcount tree, so just calculate
+        * an approximate number we need for refcount tree change.
+        * Sometimes we need to split the tree, and after split,  half recs
+        * will be moved to the new block, and a new block can only provide
+        * half number of recs. So we multiple new blocks by 2.
+        * In the end, we have to add credits for modifying the already
+        * existed refcount block.
+        */
+       rb = (struct ocfs2_refcount_block *)args->reflink->ref_root_bh->b_data;
+       metas.num_recs =
+               (metas.num_recs + ocfs2_refcount_recs_per_rb(osb->sb) - 1) /
+                ocfs2_refcount_recs_per_rb(osb->sb) * 2;
+       metas.num_metas += metas.num_recs;
+       *credits += metas.num_recs +
+                   metas.num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
+       if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
+               *credits += le16_to_cpu(rb->rf_list.l_tree_depth) *
+                           le16_to_cpu(rb->rf_list.l_next_free_rec) + 1;
+       else
+               *credits += 1;
+
+       /* count in the xattr tree change. */
+       num_free_extents = ocfs2_num_free_extents(osb, xt_et);
+       if (num_free_extents < 0) {
+               ret = num_free_extents;
+               mlog_errno(ret);
+               goto out;
+       }
+
+       if (num_free_extents < len)
+               metas.num_metas += ocfs2_extend_meta_needed(xt_et->et_root_el);
+
+       *credits += ocfs2_calc_extend_credits(osb->sb,
+                                             xt_et->et_root_el, len);
+
+       if (metas.num_metas) {
+               ret = ocfs2_reserve_new_metadata_blocks(osb, metas.num_metas,
+                                                       meta_ac);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
+       }
 
-               ret = ocfs2_rm_xattr_cluster(inode, xb_bh,
-                                            p_blkno, e_cpos, num_clusters);
+       if (len) {
+               ret = ocfs2_reserve_clusters(osb, len, data_ac);
+               if (ret)
+                       mlog_errno(ret);
+       }
+out:
+       if (ret) {
+               if (*meta_ac) {
+                       ocfs2_free_alloc_context(*meta_ac);
+                       meta_ac = NULL;
+               }
+       }
+
+       return ret;
+}
+
+static int ocfs2_reflink_xattr_buckets(handle_t *handle,
+                               u64 blkno, u64 new_blkno, u32 clusters,
+                               struct ocfs2_alloc_context *meta_ac,
+                               struct ocfs2_alloc_context *data_ac,
+                               struct ocfs2_reflink_xattr_tree_args *args)
+{
+       int i, j, ret = 0;
+       struct super_block *sb = args->reflink->old_inode->i_sb;
+       u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb));
+       u32 num_buckets = clusters * bpc;
+       int bpb = args->old_bucket->bu_blocks;
+       struct ocfs2_xattr_value_buf vb = {
+               .vb_access = ocfs2_journal_access,
+       };
+
+       for (i = 0; i < num_buckets; i++, blkno += bpb, new_blkno += bpb) {
+               ret = ocfs2_read_xattr_bucket(args->old_bucket, blkno);
                if (ret) {
                        mlog_errno(ret);
                        break;
                }
 
-               if (e_cpos == 0)
+               ret = ocfs2_init_xattr_bucket(args->new_bucket, new_blkno);
+               if (ret) {
+                       mlog_errno(ret);
                        break;
+               }
 
-               name_hash = e_cpos - 1;
+               /*
+                * The real bucket num in this series of blocks is stored
+                * in the 1st bucket.
+                */
+               if (i == 0)
+                       num_buckets = le16_to_cpu(
+                               bucket_xh(args->old_bucket)->xh_num_buckets);
+
+               ret = ocfs2_xattr_bucket_journal_access(handle,
+                                               args->new_bucket,
+                                               OCFS2_JOURNAL_ACCESS_CREATE);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+
+               for (j = 0; j < bpb; j++)
+                       memcpy(bucket_block(args->new_bucket, j),
+                              bucket_block(args->old_bucket, j),
+                              sb->s_blocksize);
+
+               ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket);
+
+               ret = ocfs2_reflink_xattr_header(handle, args->reflink,
+                                       args->old_bucket->bu_bhs[0],
+                                       bucket_xh(args->old_bucket),
+                                       args->new_bucket->bu_bhs[0],
+                                       bucket_xh(args->new_bucket),
+                                       &vb, meta_ac,
+                                       ocfs2_get_reflink_xattr_value_root,
+                                       args);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+
+               /*
+                * Re-access and dirty the bucket to calculate metaecc.
+                * Because we may extend the transaction in reflink_xattr_header
+                * which will let the already accessed block gone.
+                */
+               ret = ocfs2_xattr_bucket_journal_access(handle,
+                                               args->new_bucket,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
+               if (ret) {
+                       mlog_errno(ret);
+                       break;
+               }
+
+               ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket);
+               ocfs2_xattr_bucket_relse(args->old_bucket);
+               ocfs2_xattr_bucket_relse(args->new_bucket);
+       }
+
+       ocfs2_xattr_bucket_relse(args->old_bucket);
+       ocfs2_xattr_bucket_relse(args->new_bucket);
+       return ret;
+}
+/*
+ * Create the same xattr extent record in the new inode's xattr tree.
+ */
+static int ocfs2_reflink_xattr_rec(struct inode *inode,
+                                  struct buffer_head *root_bh,
+                                  u64 blkno,
+                                  u32 cpos,
+                                  u32 len,
+                                  void *para)
+{
+       int ret, credits = 0;
+       u32 p_cluster, num_clusters;
+       u64 new_blkno;
+       handle_t *handle;
+       struct ocfs2_reflink_xattr_tree_args *args =
+                       (struct ocfs2_reflink_xattr_tree_args *)para;
+       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       struct ocfs2_alloc_context *meta_ac = NULL;
+       struct ocfs2_alloc_context *data_ac = NULL;
+       struct ocfs2_extent_tree et;
+
+       ocfs2_init_xattr_tree_extent_tree(&et,
+                                         INODE_CACHE(args->reflink->new_inode),
+                                         args->new_blk_bh);
+
+       ret = ocfs2_lock_reflink_xattr_rec_allocators(args, &et, blkno,
+                                                     len, &credits,
+                                                     &meta_ac, &data_ac);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       handle = ocfs2_start_trans(osb, credits);
+       if (IS_ERR(handle)) {
+               ret = PTR_ERR(handle);
+               mlog_errno(ret);
+               goto out;
+       }
+
+       ret = ocfs2_claim_clusters(osb, handle, data_ac,
+                                  len, &p_cluster, &num_clusters);
+       if (ret) {
+               mlog_errno(ret);
+               goto out_commit;
+       }
+
+       new_blkno = ocfs2_clusters_to_blocks(osb->sb, p_cluster);
+
+       mlog(0, "reflink xattr buckets %llu to %llu, len %u\n",
+            (unsigned long long)blkno, (unsigned long long)new_blkno, len);
+       ret = ocfs2_reflink_xattr_buckets(handle, blkno, new_blkno, len,
+                                         meta_ac, data_ac, args);
+       if (ret) {
+               mlog_errno(ret);
+               goto out_commit;
+       }
+
+       mlog(0, "insert new xattr extent rec start %llu len %u to %u\n",
+            (unsigned long long)new_blkno, len, cpos);
+       ret = ocfs2_insert_extent(handle, &et, cpos, new_blkno,
+                                 len, 0, meta_ac);
+       if (ret)
+               mlog_errno(ret);
+
+out_commit:
+       ocfs2_commit_trans(osb, handle);
+
+out:
+       if (meta_ac)
+               ocfs2_free_alloc_context(meta_ac);
+       if (data_ac)
+               ocfs2_free_alloc_context(data_ac);
+       return ret;
+}
+
+/*
+ * Create reflinked xattr buckets.
+ * We will add bucket one by one, and refcount all the xattrs in the bucket
+ * if they are stored outside.
+ */
+static int ocfs2_reflink_xattr_tree(struct ocfs2_xattr_reflink *args,
+                                   struct buffer_head *blk_bh,
+                                   struct buffer_head *new_blk_bh)
+{
+       int ret;
+       struct ocfs2_reflink_xattr_tree_args para;
+
+       memset(&para, 0, sizeof(para));
+       para.reflink = args;
+       para.old_blk_bh = blk_bh;
+       para.new_blk_bh = new_blk_bh;
+
+       para.old_bucket = ocfs2_xattr_bucket_new(args->old_inode);
+       if (!para.old_bucket) {
+               mlog_errno(-ENOMEM);
+               return -ENOMEM;
+       }
+
+       para.new_bucket = ocfs2_xattr_bucket_new(args->new_inode);
+       if (!para.new_bucket) {
+               ret = -ENOMEM;
+               mlog_errno(ret);
+               goto out;
+       }
+
+       ret = ocfs2_iterate_xattr_index_block(args->old_inode, blk_bh,
+                                             ocfs2_reflink_xattr_rec,
+                                             &para);
+       if (ret)
+               mlog_errno(ret);
+
+out:
+       ocfs2_xattr_bucket_free(para.old_bucket);
+       ocfs2_xattr_bucket_free(para.new_bucket);
+       return ret;
+}
+
+static int ocfs2_reflink_xattr_in_block(struct ocfs2_xattr_reflink *args,
+                                       struct buffer_head *blk_bh)
+{
+       int ret, indexed = 0;
+       struct buffer_head *new_blk_bh = NULL;
+       struct ocfs2_xattr_block *xb =
+                       (struct ocfs2_xattr_block *)blk_bh->b_data;
+
+
+       if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)
+               indexed = 1;
+
+       ret = ocfs2_create_empty_xattr_block(args->new_inode, args->new_bh,
+                                            &new_blk_bh, indexed);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED))
+               ret = ocfs2_reflink_xattr_block(args, blk_bh, new_blk_bh);
+       else
+               ret = ocfs2_reflink_xattr_tree(args, blk_bh, new_blk_bh);
+       if (ret)
+               mlog_errno(ret);
+
+out:
+       brelse(new_blk_bh);
+       return ret;
+}
+
+static int ocfs2_reflink_xattr_no_security(struct ocfs2_xattr_entry *xe)
+{
+       int type = ocfs2_xattr_get_type(xe);
+
+       return type != OCFS2_XATTR_INDEX_SECURITY &&
+              type != OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS &&
+              type != OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT;
+}
+
+int ocfs2_reflink_xattrs(struct inode *old_inode,
+                        struct buffer_head *old_bh,
+                        struct inode *new_inode,
+                        struct buffer_head *new_bh,
+                        bool preserve_security)
+{
+       int ret;
+       struct ocfs2_xattr_reflink args;
+       struct ocfs2_inode_info *oi = OCFS2_I(old_inode);
+       struct ocfs2_dinode *di = (struct ocfs2_dinode *)old_bh->b_data;
+       struct buffer_head *blk_bh = NULL;
+       struct ocfs2_cached_dealloc_ctxt dealloc;
+       struct ocfs2_refcount_tree *ref_tree;
+       struct buffer_head *ref_root_bh = NULL;
+
+       ret = ocfs2_lock_refcount_tree(OCFS2_SB(old_inode->i_sb),
+                                      le64_to_cpu(di->i_refcount_loc),
+                                      1, &ref_tree, &ref_root_bh);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
+       }
+
+       ocfs2_init_dealloc_ctxt(&dealloc);
+
+       args.old_inode = old_inode;
+       args.new_inode = new_inode;
+       args.old_bh = old_bh;
+       args.new_bh = new_bh;
+       args.ref_ci = &ref_tree->rf_ci;
+       args.ref_root_bh = ref_root_bh;
+       args.dealloc = &dealloc;
+       if (preserve_security)
+               args.xattr_reflinked = NULL;
+       else
+               args.xattr_reflinked = ocfs2_reflink_xattr_no_security;
+
+       if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
+               ret = ocfs2_reflink_xattr_inline(&args);
+               if (ret) {
+                       mlog_errno(ret);
+                       goto out_unlock;
+               }
+       }
+
+       if (!di->i_xattr_loc)
+               goto out_unlock;
+
+       ret = ocfs2_read_xattr_block(old_inode, le64_to_cpu(di->i_xattr_loc),
+                                    &blk_bh);
+       if (ret < 0) {
+               mlog_errno(ret);
+               goto out_unlock;
+       }
+
+       ret = ocfs2_reflink_xattr_in_block(&args, blk_bh);
+       if (ret)
+               mlog_errno(ret);
+
+       brelse(blk_bh);
+
+out_unlock:
+       ocfs2_unlock_refcount_tree(OCFS2_SB(old_inode->i_sb),
+                                  ref_tree, 1);
+       brelse(ref_root_bh);
+
+       if (ocfs2_dealloc_has_cluster(&dealloc)) {
+               ocfs2_schedule_truncate_log_flush(OCFS2_SB(old_inode->i_sb), 1);
+               ocfs2_run_deallocs(OCFS2_SB(old_inode->i_sb), &dealloc);
        }
 
 out:
@@ -5045,11 +7162,56 @@ out:
 }
 
 /*
+ * Initialize security and acl for a already created inode.
+ * Used for reflink a non-preserve-security file.
+ *
+ * It uses common api like ocfs2_xattr_set, so the caller
+ * must not hold any lock expect i_mutex.
+ */
+int ocfs2_init_security_and_acl(struct inode *dir,
+                               struct inode *inode)
+{
+       int ret = 0;
+       struct buffer_head *dir_bh = NULL;
+       struct ocfs2_security_xattr_info si = {
+               .enable = 1,
+       };
+
+       ret = ocfs2_init_security_get(inode, dir, &si);
+       if (!ret) {
+               ret = ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY,
+                                     si.name, si.value, si.value_len,
+                                     XATTR_CREATE);
+               if (ret) {
+                       mlog_errno(ret);
+                       goto leave;
+               }
+       } else if (ret != -EOPNOTSUPP) {
+               mlog_errno(ret);
+               goto leave;
+       }
+
+       ret = ocfs2_inode_lock(dir, &dir_bh, 0);
+       if (ret) {
+               mlog_errno(ret);
+               goto leave;
+       }
+
+       ret = ocfs2_init_acl(NULL, inode, dir, NULL, dir_bh, NULL, NULL);
+       if (ret)
+               mlog_errno(ret);
+
+       ocfs2_inode_unlock(dir, 0);
+       brelse(dir_bh);
+leave:
+       return ret;
+}
+/*
  * 'security' attributes support
  */
-static size_t ocfs2_xattr_security_list(struct inode *inode, char *list,
+static size_t ocfs2_xattr_security_list(struct dentry *dentry, char *list,
                                        size_t list_size, const char *name,
-                                       size_t name_len)
+                                       size_t name_len, int type)
 {
        const size_t prefix_len = XATTR_SECURITY_PREFIX_LEN;
        const size_t total_len = prefix_len + name_len + 1;
@@ -5062,29 +7224,32 @@ static size_t ocfs2_xattr_security_list(struct inode *inode, char *list,
        return total_len;
 }
 
-static int ocfs2_xattr_security_get(struct inode *inode, const char *name,
-                                   void *buffer, size_t size)
+static int ocfs2_xattr_security_get(struct dentry *dentry, const char *name,
+                                   void *buffer, size_t size, int type)
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_SECURITY, name,
-                              buffer, size);
+       return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY,
+                              name, buffer, size);
 }
 
-static int ocfs2_xattr_security_set(struct inode *inode, const char *name,
-                                   const void *value, size_t size, int flags)
+static int ocfs2_xattr_security_set(struct dentry *dentry, const char *name,
+               const void *value, size_t size, int flags, int type)
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
 
-       return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY, name, value,
-                              size, flags);
+       return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY,
+                              name, value, size, flags);
 }
 
 int ocfs2_init_security_get(struct inode *inode,
                            struct inode *dir,
                            struct ocfs2_security_xattr_info *si)
 {
+       /* check whether ocfs2 support feature xattr */
+       if (!ocfs2_supports_xattr(OCFS2_SB(dir->i_sb)))
+               return -EOPNOTSUPP;
        return security_inode_init_security(inode, dir, &si->name, &si->value,
                                            &si->value_len);
 }
@@ -5112,9 +7277,9 @@ struct xattr_handler ocfs2_xattr_security_handler = {
 /*
  * 'trusted' attributes support
  */
-static size_t ocfs2_xattr_trusted_list(struct inode *inode, char *list,
+static size_t ocfs2_xattr_trusted_list(struct dentry *dentry, char *list,
                                       size_t list_size, const char *name,
-                                      size_t name_len)
+                                      size_t name_len, int type)
 {
        const size_t prefix_len = XATTR_TRUSTED_PREFIX_LEN;
        const size_t total_len = prefix_len + name_len + 1;
@@ -5127,23 +7292,23 @@ static size_t ocfs2_xattr_trusted_list(struct inode *inode, char *list,
        return total_len;
 }
 
-static int ocfs2_xattr_trusted_get(struct inode *inode, const char *name,
-                                  void *buffer, size_t size)
+static int ocfs2_xattr_trusted_get(struct dentry *dentry, const char *name,
+               void *buffer, size_t size, int type)
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_TRUSTED, name,
-                              buffer, size);
+       return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED,
+                              name, buffer, size);
 }
 
-static int ocfs2_xattr_trusted_set(struct inode *inode, const char *name,
-                                  const void *value, size_t size, int flags)
+static int ocfs2_xattr_trusted_set(struct dentry *dentry, const char *name,
+               const void *value, size_t size, int flags, int type)
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
 
-       return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_TRUSTED, name, value,
-                              size, flags);
+       return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED,
+                              name, value, size, flags);
 }
 
 struct xattr_handler ocfs2_xattr_trusted_handler = {
@@ -5156,13 +7321,13 @@ struct xattr_handler ocfs2_xattr_trusted_handler = {
 /*
  * 'user' attributes support
  */
-static size_t ocfs2_xattr_user_list(struct inode *inode, char *list,
+static size_t ocfs2_xattr_user_list(struct dentry *dentry, char *list,
                                    size_t list_size, const char *name,
-                                   size_t name_len)
+                                   size_t name_len, int type)
 {
        const size_t prefix_len = XATTR_USER_PREFIX_LEN;
        const size_t total_len = prefix_len + name_len + 1;
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
 
        if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
                return 0;
@@ -5175,31 +7340,31 @@ static size_t ocfs2_xattr_user_list(struct inode *inode, char *list,
        return total_len;
 }
 
-static int ocfs2_xattr_user_get(struct inode *inode, const char *name,
-                               void *buffer, size_t size)
+static int ocfs2_xattr_user_get(struct dentry *dentry, const char *name,
+               void *buffer, size_t size, int type)
 {
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
 
        if (strcmp(name, "") == 0)
                return -EINVAL;
        if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
                return -EOPNOTSUPP;
-       return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_USER, name,
+       return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_USER, name,
                               buffer, size);
 }
 
-static int ocfs2_xattr_user_set(struct inode *inode, const char *name,
-                               const void *value, size_t size, int flags)
+static int ocfs2_xattr_user_set(struct dentry *dentry, const char *name,
+               const void *value, size_t size, int flags, int type)
 {
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
 
        if (strcmp(name, "") == 0)
                return -EINVAL;
        if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
                return -EOPNOTSUPP;
 
-       return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_USER, name, value,
-                              size, flags);
+       return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_USER,
+                              name, value, size, flags);
 }
 
 struct xattr_handler ocfs2_xattr_user_handler = {