ocfs2: Remove xattrs via ocfs2_xa_loc
[linux-2.6.git] / fs / ocfs2 / xattr.c
index 3478ad1..22a60a7 100644 (file)
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/string.h>
+#include <linux/security.h>
 
 #define MLOG_MASK_PREFIX ML_XATTR
 #include <cluster/masklog.h>
 
 #include "ocfs2.h"
 #include "alloc.h"
+#include "blockcheck.h"
 #include "dlmglue.h"
 #include "file.h"
 #include "symlink.h"
@@ -53,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;
@@ -61,11 +64,33 @@ struct ocfs2_xattr_def_value_root {
 };
 
 struct ocfs2_xattr_bucket {
+       /* The inode these xattrs are associated with */
+       struct inode *bu_inode;
+
+       /* The actual buffers that make up the bucket */
        struct buffer_head *bu_bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
+
+       /* How many blocks make up one bucket for this filesystem */
+       int bu_blocks;
+};
+
+struct ocfs2_xattr_set_ctxt {
+       handle_t *handle;
+       struct ocfs2_alloc_context *meta_ac;
+       struct ocfs2_alloc_context *data_ac;
+       struct ocfs2_cached_dealloc_ctxt dealloc;
 };
 
 #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) \
+                                        - 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),
@@ -73,13 +98,21 @@ 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
 };
 
 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,
 };
 
 struct ocfs2_xattr_info {
@@ -97,14 +130,59 @@ struct ocfs2_xattr_search {
         */
        struct buffer_head *xattr_bh;
        struct ocfs2_xattr_header *header;
-       struct ocfs2_xattr_bucket bucket;
+       struct ocfs2_xattr_bucket *bucket;
        void *base;
        void *end;
        struct ocfs2_xattr_entry *here;
        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,
@@ -121,19 +199,53 @@ 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);
 
 static int ocfs2_xattr_create_index_block(struct inode *inode,
-                                         struct ocfs2_xattr_search *xs);
+                                         struct ocfs2_xattr_search *xs,
+                                         struct ocfs2_xattr_set_ctxt *ctxt);
 
 static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
                                             struct ocfs2_xattr_info *xi,
-                                            struct ocfs2_xattr_search *xs);
+                                            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)
 {
@@ -157,17 +269,217 @@ static inline u16 ocfs2_xattr_max_xe_in_bucket(struct super_block *sb)
 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
 
-static void ocfs2_xattr_bucket_relse(struct inode *inode,
-                                    struct ocfs2_xattr_bucket *bucket)
+static struct ocfs2_xattr_bucket *ocfs2_xattr_bucket_new(struct inode *inode)
 {
-       int i, blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+       struct ocfs2_xattr_bucket *bucket;
+       int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+
+       BUG_ON(blks > OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET);
+
+       bucket = kzalloc(sizeof(struct ocfs2_xattr_bucket), GFP_NOFS);
+       if (bucket) {
+               bucket->bu_inode = inode;
+               bucket->bu_blocks = blks;
+       }
+
+       return bucket;
+}
 
-       for (i = 0; i < blks; i++) {
+static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket *bucket)
+{
+       int i;
+
+       for (i = 0; i < bucket->bu_blocks; i++) {
                brelse(bucket->bu_bhs[i]);
                bucket->bu_bhs[i] = NULL;
        }
 }
 
+static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket *bucket)
+{
+       if (bucket) {
+               ocfs2_xattr_bucket_relse(bucket);
+               bucket->bu_inode = NULL;
+               kfree(bucket);
+       }
+}
+
+/*
+ * A bucket that has never been written to disk doesn't need to be
+ * read.  We just need the buffer_heads.  Don't call this for
+ * buckets that are already on disk.  ocfs2_read_xattr_bucket() initializes
+ * them fully.
+ */
+static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
+                                  u64 xb_blkno)
+{
+       int i, rc = 0;
+
+       for (i = 0; i < bucket->bu_blocks; i++) {
+               bucket->bu_bhs[i] = sb_getblk(bucket->bu_inode->i_sb,
+                                             xb_blkno + i);
+               if (!bucket->bu_bhs[i]) {
+                       rc = -EIO;
+                       mlog_errno(rc);
+                       break;
+               }
+
+               if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
+                                          bucket->bu_bhs[i]))
+                       ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
+                                                     bucket->bu_bhs[i]);
+       }
+
+       if (rc)
+               ocfs2_xattr_bucket_relse(bucket);
+       return rc;
+}
+
+/* Read the xattr bucket at xb_blkno */
+static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
+                                  u64 xb_blkno)
+{
+       int rc;
+
+       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;
+}
+
+static int ocfs2_xattr_bucket_journal_access(handle_t *handle,
+                                            struct ocfs2_xattr_bucket *bucket,
+                                            int type)
+{
+       int i, rc = 0;
+
+       for (i = 0; i < bucket->bu_blocks; i++) {
+               rc = ocfs2_journal_access(handle,
+                                         INODE_CACHE(bucket->bu_inode),
+                                         bucket->bu_bhs[i], type);
+               if (rc) {
+                       mlog_errno(rc);
+                       break;
+               }
+       }
+
+       return rc;
+}
+
+static void ocfs2_xattr_bucket_journal_dirty(handle_t *handle,
+                                            struct ocfs2_xattr_bucket *bucket)
+{
+       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]);
+}
+
+static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket *dest,
+                                        struct ocfs2_xattr_bucket *src)
+{
+       int i;
+       int blocksize = src->bu_inode->i_sb->s_blocksize;
+
+       BUG_ON(dest->bu_blocks != src->bu_blocks);
+       BUG_ON(dest->bu_inode != src->bu_inode);
+
+       for (i = 0; i < src->bu_blocks; i++) {
+               memcpy(bucket_block(dest, i), bucket_block(src, i),
+                      blocksize);
+       }
+}
+
+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;
@@ -214,212 +526,254 @@ static void ocfs2_xattr_hash_entry(struct inode *inode,
        return;
 }
 
+static int ocfs2_xattr_entry_real_size(int name_len, size_t value_len)
+{
+       int size = 0;
+
+       if (value_len <= OCFS2_XATTR_INLINE_SIZE)
+               size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(value_len);
+       else
+               size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
+       size += sizeof(struct ocfs2_xattr_entry);
+
+       return size;
+}
+
+int ocfs2_calc_security_init(struct inode *dir,
+                            struct ocfs2_security_xattr_info *si,
+                            int *want_clusters,
+                            int *xattr_credits,
+                            struct ocfs2_alloc_context **xattr_ac)
+{
+       int ret = 0;
+       struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
+       int s_size = ocfs2_xattr_entry_real_size(strlen(si->name),
+                                                si->value_len);
+
+       /*
+        * The max space of security xattr taken inline is
+        * 256(name) + 80(value) + 16(entry) = 352 bytes,
+        * So reserve one metadata block for it is ok.
+        */
+       if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE ||
+           s_size > OCFS2_XATTR_FREE_IN_IBODY) {
+               ret = ocfs2_reserve_new_metadata_blocks(osb, 1, xattr_ac);
+               if (ret) {
+                       mlog_errno(ret);
+                       return ret;
+               }
+               *xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
+       }
+
+       /* reserve clusters for xattr value which will be set in B tree*/
+       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;
-       int restart_func = 0;
-       int credits = 0;
-       handle_t *handle = NULL;
-       struct ocfs2_alloc_context *data_ac = NULL;
-       struct ocfs2_alloc_context *meta_ac = NULL;
+       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);
-
-restart_all:
-
-       status = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0,
-                                      &data_ac, &meta_ac);
-       if (status) {
-               mlog_errno(status);
-               goto leave;
-       }
-
-       credits = ocfs2_calc_extend_credits(osb->sb, et.et_root_el,
-                                           clusters_to_add);
-       handle = ocfs2_start_trans(osb, credits);
-       if (IS_ERR(handle)) {
-               status = PTR_ERR(handle);
-               handle = NULL;
-               mlog_errno(status);
-               goto leave;
-       }
+       ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
 
-restarted_transaction:
-       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,
-                                            data_ac,
-                                            meta_ac,
+                                            ctxt->data_ac,
+                                            ctxt->meta_ac,
                                             &why);
-       if ((status < 0) && (status != -EAGAIN)) {
-               if (status != -ENOSPC)
-                       mlog_errno(status);
+       if (status < 0) {
+               mlog_errno(status);
                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;
 
-       if (why != RESTART_NONE && clusters_to_add) {
-               if (why == RESTART_META) {
-                       mlog(0, "restarting function.\n");
-                       restart_func = 1;
-               } else {
-                       BUG_ON(why != RESTART_TRANS);
-
-                       mlog(0, "restarting transaction.\n");
-                       /* TODO: This can be more intelligent. */
-                       credits = ocfs2_calc_extend_credits(osb->sb,
-                                                           et.et_root_el,
-                                                           clusters_to_add);
-                       status = ocfs2_extend_trans(handle, credits);
-                       if (status < 0) {
-                               /* handle still has to be committed at
-                                * this point. */
-                               status = -ENOMEM;
-                               mlog_errno(status);
-                               goto leave;
-                       }
-                       goto restarted_transaction;
-               }
-       }
+       /*
+        * We should have already allocated enough space before the transaction,
+        * so no need to restart.
+        */
+       BUG_ON(why != RESTART_NONE || clusters_to_add);
 
 leave:
-       if (handle) {
-               ocfs2_commit_trans(osb, handle);
-               handle = NULL;
-       }
-       if (data_ac) {
-               ocfs2_free_alloc_context(data_ac);
-               data_ac = NULL;
-       }
-       if (meta_ac) {
-               ocfs2_free_alloc_context(meta_ac);
-               meta_ac = NULL;
-       }
-       if ((!status) && restart_func) {
-               restart_func = 0;
-               goto restart_all;
-       }
 
        return status;
 }
 
 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,
-                                     struct ocfs2_cached_dealloc_ctxt *dealloc)
+                                     unsigned int ext_flags,
+                                     struct ocfs2_xattr_set_ctxt *ctxt)
 {
        int ret;
        u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-       struct inode *tl_inode = osb->osb_tl_inode;
-       handle_t *handle;
-       struct ocfs2_alloc_context *meta_ac = NULL;
+       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_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
+       ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
+                           OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
-               return ret;
-       }
-
-       mutex_lock(&tl_inode->i_mutex);
-
-       if (ocfs2_truncate_log_needs_flush(osb)) {
-               ret = __ocfs2_flush_truncate_log(osb);
-               if (ret < 0) {
-                       mlog_errno(ret);
-                       goto out;
-               }
-       }
-
-       handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_journal_access(handle, inode, root_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_remove_extent(handle, &et, cpos, len, ctxt->meta_ac,
+                                 &ctxt->dealloc);
        if (ret) {
                mlog_errno(ret);
-               goto out_commit;
-       }
-
-       ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac,
-                                 dealloc);
-       if (ret) {
-               mlog_errno(ret);
-               goto out_commit;
+               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_commit;
+               goto out;
        }
 
-       ret = ocfs2_truncate_log_append(osb, handle, 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);
 
-out_commit:
-       ocfs2_commit_trans(osb, handle);
 out:
-       mutex_unlock(&tl_inode->i_mutex);
-
-       if (meta_ac)
-               ocfs2_free_alloc_context(meta_ac);
-
        return ret;
 }
 
 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;
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-       struct ocfs2_cached_dealloc_ctxt dealloc;
-
-       ocfs2_init_dealloc_ctxt(&dealloc);
 
        if (old_clusters <= new_clusters)
                return 0;
@@ -428,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;
@@ -437,36 +792,33 @@ 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,
-                                                &dealloc);
+                                                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;
        }
 
 out:
-       ocfs2_schedule_truncate_log_flush(osb, 1);
-       ocfs2_run_deallocs(osb, &dealloc);
-
        return ret;
 }
 
 static int ocfs2_xattr_value_truncate(struct inode *inode,
-                                     struct buffer_head *root_bh,
-                                     struct ocfs2_xattr_value_root *xv,
-                                     int len)
+                                     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;
@@ -474,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);
+                                                   vb, ctxt);
        else
                ret = ocfs2_xattr_shrink_size(inode,
                                              old_clusters, new_clusters,
-                                             root_bh, xv);
+                                             vb, ctxt);
 
        return ret;
 }
@@ -535,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,
@@ -568,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;
@@ -690,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;
@@ -699,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;
@@ -781,9 +1145,15 @@ 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);
 
-       memset(&xs->bucket, 0, sizeof(xs->bucket));
+       xs->bucket = ocfs2_xattr_bucket_new(inode);
+       if (!xs->bucket) {
+               ret = -ENOMEM;
+               mlog_errno(ret);
+               goto cleanup;
+       }
 
        ret = ocfs2_xattr_block_find(inode, name_index, name, xs);
        if (ret) {
@@ -808,12 +1178,12 @@ 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,
-                                                               bucket_xh(&xs->bucket),
+                       ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
+                                                               bucket_xh(xs->bucket),
                                                                i,
                                                                &block_off,
                                                                &name_offset);
-                       xs->base = bucket_block(&xs->bucket, block_off);
+                       xs->base = bucket_block(xs->bucket, block_off);
                }
                if (ocfs2_xattr_is_local(xs->here)) {
                        memcpy(buffer, (void *)xs->base +
@@ -831,20 +1201,15 @@ static int ocfs2_xattr_block_get(struct inode *inode,
        }
        ret = size;
 cleanup:
-       ocfs2_xattr_bucket_relse(inode, &xs->bucket);
-       memset(&xs->bucket, 0, sizeof(xs->bucket));
+       ocfs2_xattr_bucket_free(xs->bucket);
 
        brelse(xs->xattr_bh);
        xs->xattr_bh = NULL;
        return ret;
 }
 
-/* ocfs2_xattr_get()
- *
- * Copy an extended attribute into the buffer provided.
- * Buffer is NULL to compute the size of buffer required.
- */
-static int ocfs2_xattr_get(struct inode *inode,
+int ocfs2_xattr_get_nolock(struct inode *inode,
+                          struct buffer_head *di_bh,
                           int name_index,
                           const char *name,
                           void *buffer,
@@ -852,7 +1217,6 @@ static int ocfs2_xattr_get(struct inode *inode,
 {
        int ret;
        struct ocfs2_dinode *di = NULL;
-       struct buffer_head *di_bh = NULL;
        struct ocfs2_inode_info *oi = OCFS2_I(inode);
        struct ocfs2_xattr_search xis = {
                .not_found = -ENODATA,
@@ -867,11 +1231,6 @@ static int ocfs2_xattr_get(struct inode *inode,
        if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
                ret = -ENODATA;
 
-       ret = ocfs2_inode_lock(inode, &di_bh, 0);
-       if (ret < 0) {
-               mlog_errno(ret);
-               return ret;
-       }
        xis.inode_bh = xbs.inode_bh = di_bh;
        di = (struct ocfs2_dinode *)di_bh->b_data;
 
@@ -882,6 +1241,32 @@ static int ocfs2_xattr_get(struct inode *inode,
                ret = ocfs2_xattr_block_get(inode, name_index, name, buffer,
                                            buffer_size, &xbs);
        up_read(&oi->ip_xattr_sem);
+
+       return ret;
+}
+
+/* ocfs2_xattr_get()
+ *
+ * Copy an extended attribute into the buffer provided.
+ * Buffer is NULL to compute the size of buffer required.
+ */
+static int ocfs2_xattr_get(struct inode *inode,
+                          int name_index,
+                          const char *name,
+                          void *buffer,
+                          size_t buffer_size)
+{
+       int ret;
+       struct buffer_head *di_bh = NULL;
+
+       ret = ocfs2_inode_lock(inode, &di_bh, 0);
+       if (ret < 0) {
+               mlog_errno(ret);
+               return ret;
+       }
+       ret = ocfs2_xattr_get_nolock(inode, di_bh, name_index,
+                                    name, buffer, buffer_size);
+
        ocfs2_inode_unlock(inode, 0);
 
        brelse(di_bh);
@@ -890,53 +1275,51 @@ static int ocfs2_xattr_get(struct inode *inode,
 }
 
 static int __ocfs2_xattr_set_value_outside(struct inode *inode,
-                                          struct ocfs2_xattr_value_root *xv,
+                                          handle_t *handle,
+                                          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;
-       handle_t *handle;
+       unsigned int ext_flags;
+       struct ocfs2_xattr_value_root *xv = vb->vb_xv;
 
        BUG_ON(clusters > le32_to_cpu(xv->xr_clusters));
 
-       credits = clusters * bpc;
-       handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb), credits);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               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_commit;
+                       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_commit;
+                               goto out;
                        }
 
                        ret = ocfs2_journal_access(handle,
-                                                  inode,
+                                                  INODE_CACHE(inode),
                                                   bh,
                                                   OCFS2_JOURNAL_ACCESS_WRITE);
                        if (ret < 0) {
                                mlog_errno(ret);
-                               goto out_commit;
+                               goto out;
                        }
 
                        cp_len = value_len > blocksize ? blocksize : value_len;
@@ -950,7 +1333,7 @@ static int __ocfs2_xattr_set_value_outside(struct inode *inode,
                        ret = ocfs2_journal_dirty(handle, bh);
                        if (ret < 0) {
                                mlog_errno(ret);
-                               goto out_commit;
+                               goto out;
                        }
                        brelse(bh);
                        bh = NULL;
@@ -964,8 +1347,6 @@ static int __ocfs2_xattr_set_value_outside(struct inode *inode,
                }
                cpos += num_clusters;
        }
-out_commit:
-       ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 out:
        brelse(bh);
 
@@ -973,28 +1354,22 @@ out:
 }
 
 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)
 {
-       handle_t *handle = NULL;
        int ret = 0;
        size_t name_len = strlen(xi->name);
        void *val = xs->base + offs;
        size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
 
-       handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
-                                  OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               mlog_errno(ret);
-               goto out;
-       }
-       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_commit;
+               goto out;
        }
        /* Decrease xattr count */
        le16_add_cpu(&xs->header->xh_count, -1);
@@ -1002,35 +1377,27 @@ 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_commit:
-       ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 out:
        return ret;
 }
 
 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)
 {
-       handle_t *handle = NULL;
-       int ret = 0;
+       int ret;
 
-       handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
-                                  OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               mlog_errno(ret);
-               goto out;
-       }
-       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_commit;
+               goto out;
        }
 
        xs->here->xe_name_offset = cpu_to_le16(offs);
@@ -1041,11 +1408,9 @@ 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_commit:
-       ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 out:
        return ret;
 }
@@ -1058,6 +1423,8 @@ out:
 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);
@@ -1075,20 +1442,20 @@ 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);
+       ret = ocfs2_xattr_value_truncate(inode, vb, xi->value_len, ctxt);
        if (ret < 0) {
                mlog_errno(ret);
                return ret;
        }
-       ret = __ocfs2_xattr_set_value_outside(inode, xv, xi->value,
-                                             xi->value_len);
+       ret = ocfs2_xattr_update_entry(inode, ctxt->handle, xi, xs, vb, offs);
        if (ret < 0) {
                mlog_errno(ret);
                return ret;
        }
-       ret = ocfs2_xattr_update_entry(inode, xi, xs, offs);
+       ret = __ocfs2_xattr_set_value_outside(inode, ctxt->handle, vb,
+                                             xi->value, xi->value_len);
        if (ret < 0)
                mlog_errno(ret);
 
@@ -1096,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.
@@ -1107,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);
@@ -1147,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. */
@@ -1208,6 +1746,7 @@ static void ocfs2_xattr_set_entry_local(struct inode *inode,
 static int ocfs2_xattr_set_entry(struct inode *inode,
                                 struct ocfs2_xattr_info *xi,
                                 struct ocfs2_xattr_search *xs,
+                                struct ocfs2_xattr_set_ctxt *ctxt,
                                 int flag)
 {
        struct ocfs2_xattr_entry *last;
@@ -1215,7 +1754,7 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
        size_t min_offs = xs->end - xs->base, name_len = strlen(xi->name);
        size_t size_l = 0;
-       handle_t *handle = NULL;
+       handle_t *handle = ctxt->handle;
        int free, i, ret;
        struct ocfs2_xattr_info xi_l = {
                .name_index = xi->name_index,
@@ -1223,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;
@@ -1234,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;
 
@@ -1278,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,
-                                                           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) {
                                /*
@@ -1295,27 +1843,30 @@ 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,
-                                                                xi->value_len);
+                                                                &vb,
+                                                                xi->value_len,
+                                                                ctxt);
                                if (ret < 0) {
                                        mlog_errno(ret);
                                        goto out;
                                }
 
-                               ret = __ocfs2_xattr_set_value_outside(inode,
-                                                               xv,
-                                                               xi->value,
-                                                               xi->value_len);
+                               ret = ocfs2_xattr_update_entry(inode,
+                                                              handle,
+                                                              xi,
+                                                              xs,
+                                                              &vb,
+                                                              offs);
                                if (ret < 0) {
                                        mlog_errno(ret);
                                        goto out;
                                }
 
-                               ret = ocfs2_xattr_update_entry(inode,
-                                                              xi,
-                                                              xs,
-                                                              offs);
+                               ret = __ocfs2_xattr_set_value_outside(inode,
+                                                               handle,
+                                                               &vb,
+                                                               xi->value,
+                                                               xi->value_len);
                                if (ret < 0)
                                        mlog_errno(ret);
                                goto out;
@@ -1325,44 +1876,28 @@ 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,
-                                                                0);
+                                                                 &vb,
+                                                                 0,
+                                                                 ctxt);
                                if (ret < 0)
                                        mlog_errno(ret);
                        }
                }
        }
 
-       handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
-                                  OCFS2_INODE_UPDATE_CREDITS);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               mlog_errno(ret);
-               goto out;
-       }
-
-       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_commit;
+               goto out;
        }
 
        if (!(flag & OCFS2_INLINE_XATTR_FL)) {
-               /* set extended attribute in external block. */
-               ret = ocfs2_extend_trans(handle,
-                                        OCFS2_INODE_UPDATE_CREDITS +
-                                        OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
-               if (ret) {
-                       mlog_errno(ret);
-                       goto out_commit;
-               }
-               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_commit;
+                       goto out;
                }
        }
 
@@ -1376,7 +1911,7 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
                ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
                if (ret < 0) {
                        mlog_errno(ret);
-                       goto out_commit;
+                       goto out;
                }
        }
 
@@ -1404,25 +1939,19 @@ 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)
                mlog_errno(ret);
 
-out_commit:
-       ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
-
        if (!ret && xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
                /*
                 * Set value outside in B tree.
                 * 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, offs);
+               ret = ocfs2_xattr_set_value_outside(inode, xi, xs, ctxt,
+                                                   &vb, offs);
                if (ret < 0) {
                        int ret2;
 
@@ -1431,79 +1960,181 @@ out_commit:
                         * If set value outside failed, we have to clean
                         * the junk tree root we have already set in local.
                         */
-                       ret2 = ocfs2_xattr_cleanup(inode, xi, xs, offs);
+                       ret2 = ocfs2_xattr_cleanup(inode, ctxt->handle,
+                                                  xi, xs, &vb, offs);
                        if (ret2 < 0)
                                mlog_errno(ret2);
                }
        }
 out:
        return ret;
+}
+
+/*
+ * 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, meta_add = 0;
+       u32 p_cluster, num_clusters;
+       unsigned int ext_flags;
+
+       *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;
+       }
+
+       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 buffer_head *bh,
-                                     struct ocfs2_xattr_header *header)
+                                     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;
+       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);
-                       if (ret < 0) {
-                               mlog_errno(ret);
-                               return ret;
-                       }
+               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;
                }
        }
 
+       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;
 }
 
 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;
@@ -1515,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);
@@ -1586,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;
 
@@ -1595,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;
@@ -1605,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;
@@ -1619,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;
@@ -1639,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;
 }
 
@@ -1727,7 +2373,8 @@ static int ocfs2_xattr_ibody_find(struct inode *inode,
  */
 static int ocfs2_xattr_ibody_set(struct inode *inode,
                                 struct ocfs2_xattr_info *xi,
-                                struct ocfs2_xattr_search *xs)
+                                struct ocfs2_xattr_search *xs,
+                                struct ocfs2_xattr_set_ctxt *ctxt)
 {
        struct ocfs2_inode_info *oi = OCFS2_I(inode);
        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
@@ -1744,7 +2391,7 @@ static int ocfs2_xattr_ibody_set(struct inode *inode,
                }
        }
 
-       ret = ocfs2_xattr_set_entry(inode, xi, xs,
+       ret = ocfs2_xattr_set_entry(inode, xi, xs, ctxt,
                                (OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL));
 out:
        up_write(&oi->ip_alloc_sem);
@@ -1771,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;
@@ -1809,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()
  *
@@ -1817,110 +2538,569 @@ cleanup:
  */
 static int ocfs2_xattr_block_set(struct inode *inode,
                                 struct ocfs2_xattr_info *xi,
-                                struct ocfs2_xattr_search *xs)
+                                struct ocfs2_xattr_search *xs,
+                                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;
-       struct ocfs2_alloc_context *meta_ac = NULL;
-       handle_t *handle = NULL;
+       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_create_xattr_block(handle, inode, xs->inode_bh,
+                                              ctxt->meta_ac, &new_bh, 0);
+               if (ret) {
+                       mlog_errno(ret);
+                       goto end;
+               }
+
+               xs->xattr_bh = new_bh;
+               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;
+       } else
+               xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
+
+       if (!(le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)) {
+               /* Set extended attribute into external block */
+               ret = ocfs2_xattr_set_entry(inode, xi, xs, ctxt,
+                                           OCFS2_HAS_XATTR_FL);
+               if (!ret || ret != -ENOSPC)
+                       goto end;
+
+               ret = ocfs2_xattr_create_index_block(inode, xs, ctxt);
+               if (ret)
+                       goto end;
+       }
+
+       ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs, ctxt);
+
+end:
+
+       return ret;
+}
+
+/* Check whether the new xattr can be inserted into the inode. */
+static int ocfs2_xattr_can_be_in_inode(struct inode *inode,
+                                      struct ocfs2_xattr_info *xi,
+                                      struct ocfs2_xattr_search *xs)
+{
+       u64 value_size;
+       struct ocfs2_xattr_entry *last;
+       int free, i;
+       size_t min_offs = xs->end - xs->base;
+
+       if (!xs->header)
+               return 0;
+
+       last = xs->header->xh_entries;
+
+       for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
+               size_t offs = le16_to_cpu(last->xe_name_offset);
+               if (offs < min_offs)
+                       min_offs = offs;
+               last += 1;
+       }
+
+       free = min_offs - ((void *)last - xs->base) - OCFS2_XATTR_HEADER_GAP;
+       if (free < 0)
+               return 0;
+
+       BUG_ON(!xs->not_found);
+
+       if (xi->value_len > OCFS2_XATTR_INLINE_SIZE)
+               value_size = OCFS2_XATTR_ROOT_SIZE;
+       else
+               value_size = OCFS2_XATTR_SIZE(xi->value_len);
+
+       if (free >= sizeof(struct ocfs2_xattr_entry) +
+                  OCFS2_XATTR_SIZE(strlen(xi->name)) + value_size)
+               return 1;
+
+       return 0;
+}
+
+static int ocfs2_calc_xattr_set_need(struct inode *inode,
+                                    struct ocfs2_dinode *di,
+                                    struct ocfs2_xattr_info *xi,
+                                    struct ocfs2_xattr_search *xis,
+                                    struct ocfs2_xattr_search *xbs,
+                                    int *clusters_need,
+                                    int *meta_need,
+                                    int *credits_need)
+{
+       int ret = 0, old_in_xb = 0;
+       int clusters_add = 0, meta_add = 0, credits = 0;
+       struct buffer_head *bh = NULL;
+       struct ocfs2_xattr_block *xb = NULL;
+       struct ocfs2_xattr_entry *xe = NULL;
+       struct ocfs2_xattr_value_root *xv = NULL;
+       char *base = NULL;
+       int name_offset, name_len = 0;
+       u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb,
+                                                   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);
+
+               if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
+                       clusters_add += new_clusters;
+                       credits += ocfs2_calc_extend_credits(inode->i_sb,
+                                                       &def_xv.xv.xr_list,
+                                                       new_clusters);
+               }
+
+               goto meta_guess;
+       }
+
+       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;
+               credits += OCFS2_INODE_UPDATE_CREDITS;
+       } 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;
+               old_in_xb = 1;
+
+               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);
+                       base = bucket_block(xbs->bucket, block_off);
+                       credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+               } else {
+                       base = xbs->base;
+                       credits += OCFS2_XATTR_BLOCK_UPDATE_CREDITS;
+               }
+       }
+
+       /*
+        * delete a xattr doesn't need metadata and cluster allocation.
+        * so just calculate the credits and return.
+        *
+        * The credits for removing the value tree will be extended
+        * by ocfs2_remove_extent itself.
+        */
+       if (!xi->value) {
+               if (!ocfs2_xattr_is_local(xe))
+                       credits += ocfs2_remove_extent_credits(inode->i_sb);
+
+               goto out;
+       }
+
+       /* do cluster allocation guess first. */
+       value_size = le64_to_cpu(xe->xe_value_size);
+
+       if (old_in_xb) {
                /*
-                * Alloc one external block for extended attribute
-                * outside of inode.
+                * In xattr set, we always try to set the xe in inode first,
+                * so if it can be inserted into inode successfully, the old
+                * one will be removed from the xattr block, and this xattr
+                * will be inserted into inode as a new xattr in inode.
                 */
-               ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac);
-               if (ret < 0) {
-                       mlog_errno(ret);
+               if (ocfs2_xattr_can_be_in_inode(inode, xi, xis)) {
+                       clusters_add += new_clusters;
+                       credits += ocfs2_remove_extent_credits(inode->i_sb) +
+                                   OCFS2_INODE_UPDATE_CREDITS;
+                       if (!ocfs2_xattr_is_local(xe))
+                               credits += ocfs2_calc_extend_credits(
+                                                       inode->i_sb,
+                                                       &def_xv.xv.xr_list,
+                                                       new_clusters);
                        goto out;
                }
-               handle = ocfs2_start_trans(osb,
-                                          OCFS2_XATTR_BLOCK_CREATE_CREDITS);
-               if (IS_ERR(handle)) {
-                       ret = PTR_ERR(handle);
-                       mlog_errno(ret);
+       }
+
+       if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
+               /* the new values will be stored outside. */
+               u32 old_clusters = 0;
+
+               if (!ocfs2_xattr_is_local(xe)) {
+                       old_clusters =  ocfs2_clusters_for_bytes(inode->i_sb,
+                                                                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(inode->i_sb);
                        goto out;
+               } else {
+                       meta_add += ocfs2_extend_meta_needed(&xv->xr_list);
+                       clusters_add += new_clusters - old_clusters;
+                       credits += ocfs2_calc_extend_credits(inode->i_sb,
+                                                            &xv->xr_list,
+                                                            new_clusters -
+                                                            old_clusters);
+                       if (value_size >= OCFS2_XATTR_ROOT_SIZE)
+                               goto out;
                }
-               ret = ocfs2_journal_access(handle, inode, xs->inode_bh,
-                                          OCFS2_JOURNAL_ACCESS_CREATE);
-               if (ret < 0) {
-                       mlog_errno(ret);
-                       goto out_commit;
+       } else {
+               /*
+                * Now the new value will be stored inside. So if the new
+                * value is smaller than the size of value root or the old
+                * value, we don't need any allocation, otherwise we have
+                * to guess metadata allocation.
+                */
+               if ((ocfs2_xattr_is_local(xe) && value_size >= xi->value_len) ||
+                   (!ocfs2_xattr_is_local(xe) &&
+                    OCFS2_XATTR_ROOT_SIZE >= xi->value_len))
+                       goto out;
+       }
+
+meta_guess:
+       /* calculate metadata allocation. */
+       if (di->i_xattr_loc) {
+               if (!xbs->xattr_bh) {
+                       ret = ocfs2_read_xattr_block(inode,
+                                                    le64_to_cpu(di->i_xattr_loc),
+                                                    &bh);
+                       if (ret) {
+                               mlog_errno(ret);
+                               goto out;
+                       }
+
+                       xb = (struct ocfs2_xattr_block *)bh->b_data;
+               } 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
+                * new xattr block.
+                * If the cluster size is the same as the bucket size, one
+                * more is needed since we may need to extend the bucket
+                * also.
+                */
+               clusters_add += 1;
+               credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+               if (OCFS2_XATTR_BUCKET_SIZE ==
+                       OCFS2_SB(inode->i_sb)->s_clustersize) {
+                       credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+                       clusters_add += 1;
                }
+       } else {
+               meta_add += 1;
+               credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
+       }
+out:
+       if (clusters_need)
+               *clusters_need = clusters_add;
+       if (meta_need)
+               *meta_need = meta_add;
+       if (credits_need)
+               *credits_need = credits;
+       brelse(bh);
+       return ret;
+}
 
-               ret = ocfs2_claim_metadata(osb, handle, meta_ac, 1,
-                                          &suballoc_bit_start, &num_got,
-                                          &first_blkno);
-               if (ret < 0) {
+static int ocfs2_init_xattr_set_ctxt(struct inode *inode,
+                                    struct ocfs2_dinode *di,
+                                    struct ocfs2_xattr_info *xi,
+                                    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;
+       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+
+       memset(ctxt, 0, sizeof(struct ocfs2_xattr_set_ctxt));
+
+       ocfs2_init_dealloc_ctxt(&ctxt->dealloc);
+
+       ret = ocfs2_calc_xattr_set_need(inode, di, xi, xis, xbs,
+                                       &clusters_add, &meta_add, credits);
+       if (ret) {
+               mlog_errno(ret);
+               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);
+
+       if (meta_add) {
+               ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add,
+                                                       &ctxt->meta_ac);
+               if (ret) {
                        mlog_errno(ret);
-                       goto out_commit;
+                       goto out;
                }
+       }
 
-               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) {
+       if (clusters_add) {
+               ret = ocfs2_reserve_clusters(osb, clusters_add, &ctxt->data_ac);
+               if (ret)
                        mlog_errno(ret);
-                       goto out_commit;
+       }
+out:
+       if (ret) {
+               if (ctxt->meta_ac) {
+                       ocfs2_free_alloc_context(ctxt->meta_ac);
+                       ctxt->meta_ac = NULL;
                }
 
-               /* 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);
+               /*
+                * We cannot have an error and a non null ctxt->data_ac.
+                */
+       }
 
-               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;
+       return ret;
+}
 
+static int __ocfs2_xattr_set_handle(struct inode *inode,
+                                   struct ocfs2_dinode *di,
+                                   struct ocfs2_xattr_info *xi,
+                                   struct ocfs2_xattr_search *xis,
+                                   struct ocfs2_xattr_search *xbs,
+                                   struct ocfs2_xattr_set_ctxt *ctxt)
+{
+       int ret = 0, credits, old_found;
 
-               ret = ocfs2_journal_dirty(handle, new_bh);
-               if (ret < 0) {
-                       mlog_errno(ret);
-                       goto out_commit;
+       if (!xi->value) {
+               /* Remove existing extended attribute */
+               if (!xis->not_found)
+                       ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt);
+               else if (!xbs->not_found)
+                       ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
+       } else {
+               /* We always try to set extended attribute into inode first*/
+               ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt);
+               if (!ret && !xbs->not_found) {
+                       /*
+                        * If succeed and that extended attribute existing in
+                        * external block, then we will remove it.
+                        */
+                       xi->value = NULL;
+                       xi->value_len = 0;
+
+                       old_found = xis->not_found;
+                       xis->not_found = -ENODATA;
+                       ret = ocfs2_calc_xattr_set_need(inode,
+                                                       di,
+                                                       xi,
+                                                       xis,
+                                                       xbs,
+                                                       NULL,
+                                                       NULL,
+                                                       &credits);
+                       xis->not_found = old_found;
+                       if (ret) {
+                               mlog_errno(ret);
+                               goto out;
+                       }
+
+                       ret = ocfs2_extend_trans(ctxt->handle, credits +
+                                       ctxt->handle->h_buffer_credits);
+                       if (ret) {
+                               mlog_errno(ret);
+                               goto out;
+                       }
+                       ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
+               } else if (ret == -ENOSPC) {
+                       if (di->i_xattr_loc && !xbs->xattr_bh) {
+                               ret = ocfs2_xattr_block_find(inode,
+                                                            xi->name_index,
+                                                            xi->name, xbs);
+                               if (ret)
+                                       goto out;
+
+                               old_found = xis->not_found;
+                               xis->not_found = -ENODATA;
+                               ret = ocfs2_calc_xattr_set_need(inode,
+                                                               di,
+                                                               xi,
+                                                               xis,
+                                                               xbs,
+                                                               NULL,
+                                                               NULL,
+                                                               &credits);
+                               xis->not_found = old_found;
+                               if (ret) {
+                                       mlog_errno(ret);
+                                       goto out;
+                               }
+
+                               ret = ocfs2_extend_trans(ctxt->handle, credits +
+                                       ctxt->handle->h_buffer_credits);
+                               if (ret) {
+                                       mlog_errno(ret);
+                                       goto out;
+                               }
+                       }
+                       /*
+                        * If no space in inode, we will set extended attribute
+                        * into external block.
+                        */
+                       ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
+                       if (ret)
+                               goto out;
+                       if (!xis->not_found) {
+                               /*
+                                * If succeed and that extended attribute
+                                * existing in inode, we will remove it.
+                                */
+                               xi->value = NULL;
+                               xi->value_len = 0;
+                               xbs->not_found = -ENODATA;
+                               ret = ocfs2_calc_xattr_set_need(inode,
+                                                               di,
+                                                               xi,
+                                                               xis,
+                                                               xbs,
+                                                               NULL,
+                                                               NULL,
+                                                               &credits);
+                               if (ret) {
+                                       mlog_errno(ret);
+                                       goto out;
+                               }
+
+                               ret = ocfs2_extend_trans(ctxt->handle, credits +
+                                               ctxt->handle->h_buffer_credits);
+                               if (ret) {
+                                       mlog_errno(ret);
+                                       goto out;
+                               }
+                               ret = ocfs2_xattr_ibody_set(inode, xi,
+                                                           xis, ctxt);
+                       }
                }
-               di->i_xattr_loc = cpu_to_le64(first_blkno);
-               ret = ocfs2_journal_dirty(handle, xs->inode_bh);
-               if (ret < 0)
+       }
+
+       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);
-out_commit:
-               ocfs2_commit_trans(osb, handle);
+                       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:
-               if (meta_ac)
-                       ocfs2_free_alloc_context(meta_ac);
-               if (ret < 0)
-                       return ret;
-       } else
-               xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
+       return ret;
+}
 
-       if (!(le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)) {
-               /* Set extended attribute into external block */
-               ret = ocfs2_xattr_set_entry(inode, xi, xs, OCFS2_HAS_XATTR_FL);
-               if (!ret || ret != -ENOSPC)
-                       goto end;
+/*
+ * This function only called duing creating inode
+ * for init security/acl xattrs of the new inode.
+ * All transanction credits have been reserved in mknod.
+ */
+int ocfs2_xattr_set_handle(handle_t *handle,
+                          struct inode *inode,
+                          struct buffer_head *di_bh,
+                          int name_index,
+                          const char *name,
+                          const void *value,
+                          size_t value_len,
+                          int flags,
+                          struct ocfs2_alloc_context *meta_ac,
+                          struct ocfs2_alloc_context *data_ac)
+{
+       struct ocfs2_dinode *di;
+       int ret;
+
+       struct ocfs2_xattr_info xi = {
+               .name_index = name_index,
+               .name = name,
+               .value = value,
+               .value_len = value_len,
+       };
 
-               ret = ocfs2_xattr_create_index_block(inode, xs);
+       struct ocfs2_xattr_search xis = {
+               .not_found = -ENODATA,
+       };
+
+       struct ocfs2_xattr_search xbs = {
+               .not_found = -ENODATA,
+       };
+
+       struct ocfs2_xattr_set_ctxt ctxt = {
+               .handle = handle,
+               .meta_ac = meta_ac,
+               .data_ac = data_ac,
+       };
+
+       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;
+
+       down_write(&OCFS2_I(inode)->ip_xattr_sem);
+
+       ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
+       if (ret)
+               goto cleanup;
+       if (xis.not_found) {
+               ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
                if (ret)
-                       goto end;
+                       goto cleanup;
        }
 
-       ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs);
+       ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
 
-end:
+cleanup:
+       up_write(&OCFS2_I(inode)->ip_xattr_sem);
+       brelse(xbs.xattr_bh);
+       ocfs2_xattr_bucket_free(xbs.bucket);
 
        return ret;
 }
@@ -1941,7 +3121,11 @@ int ocfs2_xattr_set(struct inode *inode,
 {
        struct buffer_head *di_bh = NULL;
        struct ocfs2_dinode *di;
-       int ret;
+       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,
@@ -1961,10 +3145,20 @@ int ocfs2_xattr_set(struct inode *inode,
        if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
                return -EOPNOTSUPP;
 
+       /*
+        * Only xbs will be used on indexed trees.  xis doesn't need a
+        * bucket.
+        */
+       xbs.bucket = ocfs2_xattr_bucket_new(inode);
+       if (!xbs.bucket) {
+               mlog_errno(-ENOMEM);
+               return -ENOMEM;
+       }
+
        ret = ocfs2_inode_lock(inode, &di_bh, 1);
        if (ret < 0) {
                mlog_errno(ret);
-               return ret;
+               goto cleanup_nolock;
        }
        xis.inode_bh = xbs.inode_bh = di_bh;
        di = (struct ocfs2_dinode *)di_bh->b_data;
@@ -1996,54 +3190,72 @@ int ocfs2_xattr_set(struct inode *inode,
                        goto cleanup;
        }
 
-       if (!value) {
-               /* Remove existing extended attribute */
-               if (!xis.not_found)
-                       ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
-               else if (!xbs.not_found)
-                       ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
-       } else {
-               /* We always try to set extended attribute into inode first*/
-               ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
-               if (!ret && !xbs.not_found) {
-                       /*
-                        * If succeed and that extended attribute existing in
-                        * external block, then we will remove it.
-                        */
-                       xi.value = NULL;
-                       xi.value_len = 0;
-                       ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
-               } else if (ret == -ENOSPC) {
-                       if (di->i_xattr_loc && !xbs.xattr_bh) {
-                               ret = ocfs2_xattr_block_find(inode, name_index,
-                                                            name, &xbs);
-                               if (ret)
-                                       goto cleanup;
-                       }
-                       /*
-                        * If no space in inode, we will set extended attribute
-                        * into external block.
-                        */
-                       ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
-                       if (ret)
-                               goto cleanup;
-                       if (!xis.not_found) {
-                               /*
-                                * If succeed and that extended attribute
-                                * existing in inode, we will remove it.
-                                */
-                               xi.value = NULL;
-                               xi.value_len = 0;
-                               ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
-                       }
+       /* 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);
+
+       if (ocfs2_truncate_log_needs_flush(osb)) {
+               ret = __ocfs2_flush_truncate_log(osb);
+               if (ret < 0) {
+                       mutex_unlock(&tl_inode->i_mutex);
+                       mlog_errno(ret);
+                       goto cleanup;
+               }
+       }
+       mutex_unlock(&tl_inode->i_mutex);
+
+       ret = ocfs2_init_xattr_set_ctxt(inode, di, &xi, &xis,
+                                       &xbs, &ctxt, ref_meta, &credits);
+       if (ret) {
+               mlog_errno(ret);
+               goto cleanup;
+       }
+
+       /* 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);
+               goto cleanup;
+       }
+
+       ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
+
+       ocfs2_commit_trans(osb, ctxt.handle);
+
+       if (ctxt.data_ac)
+               ocfs2_free_alloc_context(ctxt.data_ac);
+       if (ctxt.meta_ac)
+               ocfs2_free_alloc_context(ctxt.meta_ac);
+       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);
        brelse(xbs.xattr_bh);
-       ocfs2_xattr_bucket_relse(inode, &xbs.bucket);
+       ocfs2_xattr_bucket_free(xbs.bucket);
 
        return ret;
 }
@@ -2067,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;
@@ -2118,7 +3331,7 @@ typedef int (xattr_bucket_func)(struct inode *inode,
                                void *para);
 
 static int ocfs2_find_xe_in_bucket(struct inode *inode,
-                                  struct buffer_head *header_bh,
+                                  struct ocfs2_xattr_bucket *bucket,
                                   int name_index,
                                   const char *name,
                                   u32 name_hash,
@@ -2126,11 +3339,9 @@ static int ocfs2_find_xe_in_bucket(struct inode *inode,
                                   int *found)
 {
        int i, ret = 0, cmp = 1, block_off, new_offset;
-       struct ocfs2_xattr_header *xh =
-                       (struct ocfs2_xattr_header *)header_bh->b_data;
+       struct ocfs2_xattr_header *xh = bucket_xh(bucket);
        size_t name_len = strlen(name);
        struct ocfs2_xattr_entry *xe = NULL;
-       struct buffer_head *name_bh = NULL;
        char *xe_name;
 
        /*
@@ -2151,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,
@@ -2161,19 +3372,9 @@ static int ocfs2_find_xe_in_bucket(struct inode *inode,
                        break;
                }
 
-               ret = ocfs2_read_block(inode, header_bh->b_blocknr + block_off,
-                                      &name_bh);
-               if (ret) {
-                       mlog_errno(ret);
-                       break;
-               }
-               xe_name = name_bh->b_data + new_offset;
-
-               cmp = memcmp(name, xe_name, name_len);
-               brelse(name_bh);
-               name_bh = NULL;
 
-               if (cmp == 0) {
+               xe_name = bucket_block(bucket, block_off) + new_offset;
+               if (!memcmp(name, xe_name, name_len)) {
                        *xe_index = i;
                        *found = 1;
                        ret = 0;
@@ -2203,39 +3404,42 @@ static int ocfs2_xattr_bucket_find(struct inode *inode,
                                   struct ocfs2_xattr_search *xs)
 {
        int ret, found = 0;
-       struct buffer_head *bh = NULL;
-       struct buffer_head *lower_bh = NULL;
        struct ocfs2_xattr_header *xh = NULL;
        struct ocfs2_xattr_entry *xe = NULL;
        u16 index = 0;
        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
        int low_bucket = 0, bucket, high_bucket;
+       struct ocfs2_xattr_bucket *search;
        u32 last_hash;
-       u64 blkno;
+       u64 blkno, lower_blkno = 0;
 
-       ret = ocfs2_read_block(inode, p_blkno, &bh);
+       search = ocfs2_xattr_bucket_new(inode);
+       if (!search) {
+               ret = -ENOMEM;
+               mlog_errno(ret);
+               goto out;
+       }
+
+       ret = ocfs2_read_xattr_bucket(search, p_blkno);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       xh = (struct ocfs2_xattr_header *)bh->b_data;
+       xh = bucket_xh(search);
        high_bucket = le16_to_cpu(xh->xh_num_buckets) - 1;
-
        while (low_bucket <= high_bucket) {
-               brelse(bh);
-               bh = NULL;
-               bucket = (low_bucket + high_bucket) / 2;
+               ocfs2_xattr_bucket_relse(search);
 
+               bucket = (low_bucket + high_bucket) / 2;
                blkno = p_blkno + bucket * blk_per_bucket;
-
-               ret = ocfs2_read_block(inode, blkno, &bh);
+               ret = ocfs2_read_xattr_bucket(search, blkno);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
 
-               xh = (struct ocfs2_xattr_header *)bh->b_data;
+               xh = bucket_xh(search);
                xe = &xh->xh_entries[0];
                if (name_hash < le32_to_cpu(xe->xe_name_hash)) {
                        high_bucket = bucket - 1;
@@ -2252,10 +3456,8 @@ static int ocfs2_xattr_bucket_find(struct inode *inode,
 
                last_hash = le32_to_cpu(xe->xe_name_hash);
 
-               /* record lower_bh which may be the insert place. */
-               brelse(lower_bh);
-               lower_bh = bh;
-               bh = NULL;
+               /* record lower_blkno which may be the insert place. */
+               lower_blkno = blkno;
 
                if (name_hash > le32_to_cpu(xe->xe_name_hash)) {
                        low_bucket = bucket + 1;
@@ -2263,7 +3465,7 @@ static int ocfs2_xattr_bucket_find(struct inode *inode,
                }
 
                /* the searched xattr should reside in this bucket if exists. */
-               ret = ocfs2_find_xe_in_bucket(inode, lower_bh,
+               ret = ocfs2_find_xe_in_bucket(inode, search,
                                              name_index, name, name_hash,
                                              &index, &found);
                if (ret) {
@@ -2278,44 +3480,29 @@ static int ocfs2_xattr_bucket_find(struct inode *inode,
         * When the xattr's hash value is in the gap of 2 buckets, we will
         * always set it to the previous bucket.
         */
-       if (!lower_bh) {
-               /*
-                * We can't find any bucket whose first name_hash is less
-                * than the find name_hash.
-                */
-               BUG_ON(bh->b_blocknr != p_blkno);
-               lower_bh = bh;
-               bh = NULL;
+       if (!lower_blkno)
+               lower_blkno = p_blkno;
+
+       /* This should be in cache - we just read it during the search */
+       ret = ocfs2_read_xattr_bucket(xs->bucket, lower_blkno);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
        }
-       xs->bucket.bu_bhs[0] = lower_bh;
-       lower_bh = NULL;
 
-       xs->header = bucket_xh(&xs->bucket);
-       xs->base = bucket_block(&xs->bucket, 0);
+       xs->header = bucket_xh(xs->bucket);
+       xs->base = bucket_block(xs->bucket, 0);
        xs->end = xs->base + inode->i_sb->s_blocksize;
 
        if (found) {
-               /*
-                * If we have found the xattr enty, read all the blocks in
-                * this bucket.
-                */
-               ret = ocfs2_read_blocks(inode, bucket_blkno(&xs->bucket) + 1,
-                                       blk_per_bucket - 1, &xs->bucket.bu_bhs[1],
-                                       0);
-               if (ret) {
-                       mlog_errno(ret);
-                       goto out;
-               }
-
                xs->here = &xs->header->xh_entries[index];
                mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name,
-                    (unsigned long long)bucket_blkno(&xs->bucket), index);
+                    (unsigned long long)bucket_blkno(xs->bucket), index);
        } else
                ret = -ENODATA;
 
 out:
-       brelse(bh);
-       brelse(lower_bh);
+       ocfs2_xattr_bucket_free(search);
        return ret;
 }
 
@@ -2367,22 +3554,24 @@ static int ocfs2_iterate_xattr_buckets(struct inode *inode,
                                       void *para)
 {
        int i, ret = 0;
-       int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
        u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
        u32 num_buckets = clusters * bpc;
-       struct ocfs2_xattr_bucket bucket;
+       struct ocfs2_xattr_bucket *bucket;
 
-       memset(&bucket, 0, sizeof(bucket));
+       bucket = ocfs2_xattr_bucket_new(inode);
+       if (!bucket) {
+               mlog_errno(-ENOMEM);
+               return -ENOMEM;
+       }
 
        mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
             clusters, (unsigned long long)blkno);
 
-       for (i = 0; i < num_buckets; i++, blkno += blk_per_bucket) {
-               ret = ocfs2_read_blocks(inode, blkno, blk_per_bucket,
-                                       bucket.bu_bhs, 0);
+       for (i = 0; i < num_buckets; i++, blkno += bucket->bu_blocks) {
+               ret = ocfs2_read_xattr_bucket(bucket, blkno);
                if (ret) {
                        mlog_errno(ret);
-                       goto out;
+                       break;
                }
 
                /*
@@ -2390,26 +3579,24 @@ static int ocfs2_iterate_xattr_buckets(struct inode *inode,
                 * in the 1st bucket.
                 */
                if (i == 0)
-                       num_buckets = le16_to_cpu(bucket_xh(&bucket)->xh_num_buckets);
+                       num_buckets = le16_to_cpu(bucket_xh(bucket)->xh_num_buckets);
 
                mlog(0, "iterating xattr bucket %llu, first hash %u\n",
                     (unsigned long long)blkno,
-                    le32_to_cpu(bucket_xh(&bucket)->xh_entries[0].xe_name_hash));
+                    le32_to_cpu(bucket_xh(bucket)->xh_entries[0].xe_name_hash));
                if (func) {
-                       ret = func(inode, &bucket, para);
-                       if (ret) {
+                       ret = func(inode, bucket, para);
+                       if (ret && ret != -ERANGE)
                                mlog_errno(ret);
-                               break;
-                       }
+                       /* Fall through to bucket_relse() */
                }
 
-               ocfs2_xattr_bucket_relse(inode, &bucket);
-               memset(&bucket, 0, sizeof(bucket));
+               ocfs2_xattr_bucket_relse(bucket);
+               if (ret)
+                       break;
        }
 
-out:
-       ocfs2_xattr_bucket_relse(inode, &bucket);
-
+       ocfs2_xattr_bucket_free(bucket);
        return ret;
 }
 
@@ -2419,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,
@@ -2432,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;
 }
@@ -2453,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,
@@ -2476,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) {
@@ -2499,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)
@@ -2516,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;
@@ -2546,32 +3761,34 @@ static void swap_xe(void *a, void *b, int size)
 /*
  * When the ocfs2_xattr_block is filled up, new bucket will be created
  * and all the xattr entries will be moved to the new bucket.
+ * The header goes at the start of the bucket, and the names+values are
+ * filled from the end.  This is why *target starts as the last buffer.
  * Note: we need to sort the entries since they are not saved in order
  * in the ocfs2_xattr_block.
  */
 static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode,
                                           struct buffer_head *xb_bh,
-                                          struct buffer_head *xh_bh,
-                                          struct buffer_head *data_bh)
+                                          struct ocfs2_xattr_bucket *bucket)
 {
        int i, blocksize = inode->i_sb->s_blocksize;
+       int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
        u16 offset, size, off_change;
        struct ocfs2_xattr_entry *xe;
        struct ocfs2_xattr_block *xb =
                                (struct ocfs2_xattr_block *)xb_bh->b_data;
        struct ocfs2_xattr_header *xb_xh = &xb->xb_attrs.xb_header;
-       struct ocfs2_xattr_header *xh =
-                               (struct ocfs2_xattr_header *)xh_bh->b_data;
+       struct ocfs2_xattr_header *xh = bucket_xh(bucket);
        u16 count = le16_to_cpu(xb_xh->xh_count);
-       char *target = xh_bh->b_data, *src = xb_bh->b_data;
+       char *src = xb_bh->b_data;
+       char *target = bucket_block(bucket, blks - 1);
 
        mlog(0, "cp xattr from block %llu to bucket %llu\n",
             (unsigned long long)xb_bh->b_blocknr,
-            (unsigned long long)xh_bh->b_blocknr);
+            (unsigned long long)bucket_blkno(bucket));
+
+       for (i = 0; i < blks; i++)
+               memset(bucket_block(bucket, i), 0, blocksize);
 
-       memset(xh_bh->b_data, 0, blocksize);
-       if (data_bh)
-               memset(data_bh->b_data, 0, blocksize);
        /*
         * Since the xe_name_offset is based on ocfs2_xattr_header,
         * there is a offset change corresponding to the change of
@@ -2583,8 +3800,6 @@ static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode,
        size = blocksize - offset;
 
        /* copy all the names and values. */
-       if (data_bh)
-               target = data_bh->b_data;
        memcpy(target + offset, src + offset, size);
 
        /* Init new header now. */
@@ -2594,7 +3809,7 @@ static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode,
        xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE - size);
 
        /* copy all the entries. */
-       target = xh_bh->b_data;
+       target = bucket_block(bucket, 0);
        offset = offsetof(struct ocfs2_xattr_header, xh_entries);
        size = count * sizeof(struct ocfs2_xattr_entry);
        memcpy(target + offset, (char *)xb_xh + offset, size);
@@ -2620,72 +3835,47 @@ static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode,
  * While if the entry is in index b-tree, "bucket" indicates the
  * real place of the xattr.
  */
-static int ocfs2_xattr_update_xattr_search(struct inode *inode,
-                                          struct ocfs2_xattr_search *xs,
-                                          struct buffer_head *old_bh,
-                                          struct buffer_head *new_bh)
+static void ocfs2_xattr_update_xattr_search(struct inode *inode,
+                                           struct ocfs2_xattr_search *xs,
+                                           struct buffer_head *old_bh)
 {
-       int ret = 0;
        char *buf = old_bh->b_data;
        struct ocfs2_xattr_block *old_xb = (struct ocfs2_xattr_block *)buf;
        struct ocfs2_xattr_header *old_xh = &old_xb->xb_attrs.xb_header;
-       int i, blocksize = inode->i_sb->s_blocksize;
-       u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
-
-       xs->bucket.bu_bhs[0] = new_bh;
-       get_bh(new_bh);
-       xs->header = bucket_xh(&xs->bucket);
+       int i;
 
-       xs->base = new_bh->b_data;
+       xs->header = bucket_xh(xs->bucket);
+       xs->base = bucket_block(xs->bucket, 0);
        xs->end = xs->base + inode->i_sb->s_blocksize;
 
-       if (!xs->not_found) {
-               if (OCFS2_XATTR_BUCKET_SIZE != blocksize) {
-                       ret = ocfs2_read_blocks(inode,
-                                       bucket_blkno(&xs->bucket) + 1,
-                                       blk_per_bucket - 1, &xs->bucket.bu_bhs[1],
-                                       0);
-                       if (ret) {
-                               mlog_errno(ret);
-                               return ret;
-                       }
-
-               }
-               i = xs->here - old_xh->xh_entries;
-               xs->here = &xs->header->xh_entries[i];
-       }
+       if (xs->not_found)
+               return;
 
-       return ret;
+       i = xs->here - old_xh->xh_entries;
+       xs->here = &xs->header->xh_entries[i];
 }
 
 static int ocfs2_xattr_create_index_block(struct inode *inode,
-                                         struct ocfs2_xattr_search *xs)
+                                         struct ocfs2_xattr_search *xs,
+                                         struct ocfs2_xattr_set_ctxt *ctxt)
 {
-       int ret, credits = OCFS2_SUBALLOC_ALLOC;
+       int ret;
        u32 bit_off, len;
        u64 blkno;
-       handle_t *handle;
+       handle_t *handle = ctxt->handle;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        struct ocfs2_inode_info *oi = OCFS2_I(inode);
-       struct ocfs2_alloc_context *data_ac;
-       struct buffer_head *xh_bh = NULL, *data_bh = NULL;
        struct buffer_head *xb_bh = xs->xattr_bh;
        struct ocfs2_xattr_block *xb =
                        (struct ocfs2_xattr_block *)xb_bh->b_data;
        struct ocfs2_xattr_tree_root *xr;
        u16 xb_flags = le16_to_cpu(xb->xb_flags);
-       u16 bpb = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
 
        mlog(0, "create xattr index block for %llu\n",
             (unsigned long long)xb_bh->b_blocknr);
 
        BUG_ON(xb_flags & OCFS2_XATTR_INDEXED);
-
-       ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
-       if (ret) {
-               mlog_errno(ret);
-               goto out;
-       }
+       BUG_ON(!xs->bucket);
 
        /*
         * XXX:
@@ -2694,29 +3884,18 @@ static int ocfs2_xattr_create_index_block(struct inode *inode,
         */
        down_write(&oi->ip_alloc_sem);
 
-       /*
-        * 3 more credits, one for xattr block update, one for the 1st block
-        * of the new xattr bucket and one for the value/data.
-        */
-       credits += 3;
-       handle = ocfs2_start_trans(osb, credits);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               mlog_errno(ret);
-               goto out_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_commit;
+               goto out;
        }
 
-       ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off, &len);
+       ret = __ocfs2_claim_clusters(osb, handle, ctxt->data_ac,
+                                    1, 1, &bit_off, &len);
        if (ret) {
                mlog_errno(ret);
-               goto out_commit;
+               goto out;
        }
 
        /*
@@ -2729,51 +3908,23 @@ static int ocfs2_xattr_create_index_block(struct inode *inode,
        mlog(0, "allocate 1 cluster from %llu to xattr block\n",
             (unsigned long long)blkno);
 
-       xh_bh = sb_getblk(inode->i_sb, blkno);
-       if (!xh_bh) {
-               ret = -EIO;
+       ret = ocfs2_init_xattr_bucket(xs->bucket, blkno);
+       if (ret) {
                mlog_errno(ret);
-               goto out_commit;
+               goto out;
        }
 
-       ocfs2_set_new_buffer_uptodate(inode, xh_bh);
-
-       ret = ocfs2_journal_access(handle, inode, xh_bh,
-                                  OCFS2_JOURNAL_ACCESS_CREATE);
+       ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
+                                               OCFS2_JOURNAL_ACCESS_CREATE);
        if (ret) {
                mlog_errno(ret);
-               goto out_commit;
-       }
-
-       if (bpb > 1) {
-               data_bh = sb_getblk(inode->i_sb, blkno + bpb - 1);
-               if (!data_bh) {
-                       ret = -EIO;
-                       mlog_errno(ret);
-                       goto out_commit;
-               }
-
-               ocfs2_set_new_buffer_uptodate(inode, data_bh);
-
-               ret = ocfs2_journal_access(handle, inode, data_bh,
-                                          OCFS2_JOURNAL_ACCESS_CREATE);
-               if (ret) {
-                       mlog_errno(ret);
-                       goto out_commit;
-               }
+               goto out;
        }
 
-       ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xh_bh, data_bh);
+       ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xs->bucket);
+       ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
 
-       ocfs2_journal_dirty(handle, xh_bh);
-       if (data_bh)
-               ocfs2_journal_dirty(handle, data_bh);
-
-       ret = ocfs2_xattr_update_xattr_search(inode, xs, xb_bh, xh_bh);
-       if (ret) {
-               mlog_errno(ret);
-               goto out_commit;
-       }
+       ocfs2_xattr_update_xattr_search(inode, xs, xb_bh);
 
        /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
        memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize -
@@ -2792,24 +3943,10 @@ static int ocfs2_xattr_create_index_block(struct inode *inode,
 
        xb->xb_flags = cpu_to_le16(xb_flags | OCFS2_XATTR_INDEXED);
 
-       ret = ocfs2_journal_dirty(handle, xb_bh);
-       if (ret) {
-               mlog_errno(ret);
-               goto out_commit;
-       }
-
-out_commit:
-       ocfs2_commit_trans(osb, handle);
-
-out_sem:
-       up_write(&oi->ip_alloc_sem);
+       ocfs2_journal_dirty(handle, xb_bh);
 
 out:
-       if (data_ac)
-               ocfs2_free_alloc_context(data_ac);
-
-       brelse(xh_bh);
-       brelse(data_bh);
+       up_write(&oi->ip_alloc_sem);
 
        return ret;
 }
@@ -2834,6 +3971,7 @@ static int cmp_xe_offset(const void *a, const void *b)
  * so that we can spare some space for insertion.
  */
 static int ocfs2_defrag_xattr_bucket(struct inode *inode,
+                                    handle_t *handle,
                                     struct ocfs2_xattr_bucket *bucket)
 {
        int ret, i;
@@ -2841,22 +3979,10 @@ static int ocfs2_defrag_xattr_bucket(struct inode *inode,
        struct ocfs2_xattr_header *xh;
        char *entries, *buf, *bucket_buf = NULL;
        u64 blkno = bucket_blkno(bucket);
-       u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
        u16 xh_free_start;
        size_t blocksize = inode->i_sb->s_blocksize;
-       handle_t *handle;
-       struct buffer_head **bhs;
        struct ocfs2_xattr_entry *xe;
 
-       bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket,
-                       GFP_NOFS);
-       if (!bhs)
-               return -ENOMEM;
-
-       ret = ocfs2_read_blocks(inode, blkno, blk_per_bucket, bhs, 0);
-       if (ret)
-               goto out;
-
        /*
         * In order to make the operation more efficient and generic,
         * we copy all the blocks into a contiguous memory and do the
@@ -2870,26 +3996,16 @@ static int ocfs2_defrag_xattr_bucket(struct inode *inode,
        }
 
        buf = bucket_buf;
-       for (i = 0; i < blk_per_bucket; i++, buf += blocksize)
-               memcpy(buf, bhs[i]->b_data, blocksize);
+       for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)
+               memcpy(buf, bucket_block(bucket, i), blocksize);
 
-       handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), blk_per_bucket);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               handle = NULL;
+       ret = ocfs2_xattr_bucket_journal_access(handle, bucket,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
+       if (ret < 0) {
                mlog_errno(ret);
                goto out;
        }
 
-       for (i = 0; i < blk_per_bucket; i++) {
-               ret = ocfs2_journal_access(handle, inode, bhs[i],
-                                          OCFS2_JOURNAL_ACCESS_WRITE);
-               if (ret < 0) {
-                       mlog_errno(ret);
-                       goto commit;
-               }
-       }
-
        xh = (struct ocfs2_xattr_header *)bucket_buf;
        entries = (char *)xh->xh_entries;
        xh_free_start = le16_to_cpu(xh->xh_free_start);
@@ -2945,7 +4061,7 @@ static int ocfs2_defrag_xattr_bucket(struct inode *inode,
                        "bucket %llu\n", (unsigned long long)blkno);
 
        if (xh_free_start == end)
-               goto commit;
+               goto out;
 
        memset(bucket_buf + xh_free_start, 0, end - xh_free_start);
        xh->xh_free_start = cpu_to_le16(end);
@@ -2956,169 +4072,94 @@ static int ocfs2_defrag_xattr_bucket(struct inode *inode,
             cmp_xe, swap_xe);
 
        buf = bucket_buf;
-       for (i = 0; i < blk_per_bucket; i++, buf += blocksize) {
-               memcpy(bhs[i]->b_data, buf, blocksize);
-               ocfs2_journal_dirty(handle, bhs[i]);
-       }
+       for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)
+               memcpy(bucket_block(bucket, i), buf, blocksize);
+       ocfs2_xattr_bucket_journal_dirty(handle, bucket);
 
-commit:
-       ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 out:
-
-       if (bhs) {
-               for (i = 0; i < blk_per_bucket; i++)
-                       brelse(bhs[i]);
-       }
-       kfree(bhs);
-
        kfree(bucket_buf);
        return ret;
 }
 
 /*
- * 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;
-       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;
-}
-
-static int ocfs2_read_xattr_bucket(struct inode *inode,
-                                  u64 blkno,
-                                  struct buffer_head **bhs,
-                                  int new)
-{
-       int ret = 0;
-       u16 i, blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
-
-       if (!new)
-               return ocfs2_read_blocks(inode, blkno,
-                                        blk_per_bucket, bhs, 0);
-
-       for (i = 0; i < blk_per_bucket; i++) {
-               bhs[i] = sb_getblk(inode->i_sb, blkno + i);
-               if (bhs[i] == NULL) {
-                       ret = -EIO;
-                       mlog_errno(ret);
-                       break;
-               }
-               ocfs2_set_new_buffer_uptodate(inode, bhs[i]);
-       }
-
        return ret;
 }
 
@@ -3183,8 +4224,7 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
 {
        int ret, i;
        int count, start, len, name_value_len = 0, xe_len, name_offset = 0;
-       u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
-       struct buffer_head **s_bhs, **t_bhs = NULL;
+       struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
        struct ocfs2_xattr_header *xh;
        struct ocfs2_xattr_entry *xe;
        int blocksize = inode->i_sb->s_blocksize;
@@ -3192,47 +4232,52 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
        mlog(0, "move some of xattrs from bucket %llu to %llu\n",
             (unsigned long long)blk, (unsigned long long)new_blk);
 
-       s_bhs = kcalloc(blk_per_bucket, sizeof(struct buffer_head *), GFP_NOFS);
-       if (!s_bhs)
-               return -ENOMEM;
-
-       ret = ocfs2_read_xattr_bucket(inode, blk, s_bhs, 0);
-       if (ret) {
+       s_bucket = ocfs2_xattr_bucket_new(inode);
+       t_bucket = ocfs2_xattr_bucket_new(inode);
+       if (!s_bucket || !t_bucket) {
+               ret = -ENOMEM;
                mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_journal_access(handle, inode, s_bhs[0],
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_read_xattr_bucket(s_bucket, blk);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       t_bhs = kcalloc(blk_per_bucket, sizeof(struct buffer_head *), GFP_NOFS);
-       if (!t_bhs) {
-               ret = -ENOMEM;
+       ret = ocfs2_xattr_bucket_journal_access(handle, s_bucket,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
+       if (ret) {
+               mlog_errno(ret);
                goto out;
        }
 
-       ret = ocfs2_read_xattr_bucket(inode, new_blk, t_bhs, new_bucket_head);
+       /*
+        * Even if !new_bucket_head, we're overwriting t_bucket.  Thus,
+        * there's no need to read it.
+        */
+       ret = ocfs2_init_xattr_bucket(t_bucket, new_blk);
        if (ret) {
                mlog_errno(ret);
                goto out;
        }
 
-       for (i = 0; i < blk_per_bucket; i++) {
-               ret = ocfs2_journal_access(handle, inode, t_bhs[i],
-                                          new_bucket_head ?
-                                          OCFS2_JOURNAL_ACCESS_CREATE :
-                                          OCFS2_JOURNAL_ACCESS_WRITE);
-               if (ret) {
-                       mlog_errno(ret);
-                       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 :
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
+       if (ret) {
+               mlog_errno(ret);
+               goto out;
        }
 
-       xh = (struct ocfs2_xattr_header *)s_bhs[0]->b_data;
+       xh = bucket_xh(s_bucket);
        count = le16_to_cpu(xh->xh_count);
        start = ocfs2_xattr_find_divide_pos(xh);
 
@@ -3244,10 +4289,10 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
                 * The hash value is set as one larger than
                 * that of the last entry in the previous bucket.
                 */
-               for (i = 0; i < blk_per_bucket; i++)
-                       memset(t_bhs[i]->b_data, 0, blocksize);
+               for (i = 0; i < t_bucket->bu_blocks; i++)
+                       memset(bucket_block(t_bucket, i), 0, blocksize);
 
-               xh = (struct ocfs2_xattr_header *)t_bhs[0]->b_data;
+               xh = bucket_xh(t_bucket);
                xh->xh_free_start = cpu_to_le16(blocksize);
                xh->xh_entries[0].xe_name_hash = xe->xe_name_hash;
                le32_add_cpu(&xh->xh_entries[0].xe_name_hash, 1);
@@ -3256,11 +4301,10 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
        }
 
        /* copy the whole bucket to the new first. */
-       for (i = 0; i < blk_per_bucket; i++)
-               memcpy(t_bhs[i]->b_data, s_bhs[i]->b_data, blocksize);
+       ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
 
        /* update the new bucket. */
-       xh = (struct ocfs2_xattr_header *)t_bhs[0]->b_data;
+       xh = bucket_xh(t_bucket);
 
        /*
         * Calculate the total name/value len and xh_free_start for
@@ -3324,11 +4368,7 @@ set_num_buckets:
        else
                xh->xh_num_buckets = 0;
 
-       for (i = 0; i < blk_per_bucket; i++) {
-               ocfs2_journal_dirty(handle, t_bhs[i]);
-               if (ret)
-                       mlog_errno(ret);
-       }
+       ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
 
        /* store the first_hash of the new bucket. */
        if (first_hash)
@@ -3342,29 +4382,18 @@ set_num_buckets:
        if (start == count)
                goto out;
 
-       xh = (struct ocfs2_xattr_header *)s_bhs[0]->b_data;
+       xh = bucket_xh(s_bucket);
        memset(&xh->xh_entries[start], 0,
               sizeof(struct ocfs2_xattr_entry) * (count - start));
        xh->xh_count = cpu_to_le16(start);
        xh->xh_free_start = cpu_to_le16(name_offset);
        xh->xh_name_value_len = cpu_to_le16(name_value_len);
 
-       ocfs2_journal_dirty(handle, s_bhs[0]);
-       if (ret)
-               mlog_errno(ret);
+       ocfs2_xattr_bucket_journal_dirty(handle, s_bucket);
 
 out:
-       if (s_bhs) {
-               for (i = 0; i < blk_per_bucket; i++)
-                       brelse(s_bhs[i]);
-       }
-       kfree(s_bhs);
-
-       if (t_bhs) {
-               for (i = 0; i < blk_per_bucket; i++)
-                       brelse(t_bhs[i]);
-       }
-       kfree(t_bhs);
+       ocfs2_xattr_bucket_free(s_bucket);
+       ocfs2_xattr_bucket_free(t_bucket);
 
        return ret;
 }
@@ -3381,10 +4410,8 @@ static int ocfs2_cp_xattr_bucket(struct inode *inode,
                                 u64 t_blkno,
                                 int t_is_new)
 {
-       int ret, i;
-       int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
-       int blocksize = inode->i_sb->s_blocksize;
-       struct buffer_head **s_bhs, **t_bhs = NULL;
+       int ret;
+       struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
 
        BUG_ON(s_blkno == t_blkno);
 
@@ -3392,92 +4419,115 @@ static int ocfs2_cp_xattr_bucket(struct inode *inode,
             (unsigned long long)s_blkno, (unsigned long long)t_blkno,
             t_is_new);
 
-       s_bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket,
-                       GFP_NOFS);
-       if (!s_bhs)
-               return -ENOMEM;
+       s_bucket = ocfs2_xattr_bucket_new(inode);
+       t_bucket = ocfs2_xattr_bucket_new(inode);
+       if (!s_bucket || !t_bucket) {
+               ret = -ENOMEM;
+               mlog_errno(ret);
+               goto out;
+       }
 
-       ret = ocfs2_read_xattr_bucket(inode, s_blkno, s_bhs, 0);
+       ret = ocfs2_read_xattr_bucket(s_bucket, s_blkno);
        if (ret)
                goto out;
 
-       t_bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket,
-                       GFP_NOFS);
-       if (!t_bhs) {
-               ret = -ENOMEM;
+       /*
+        * Even if !t_is_new, we're overwriting t_bucket.  Thus,
+        * there's no need to read it.
+        */
+       ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno);
+       if (ret)
                goto out;
-       }
 
-       ret = ocfs2_read_xattr_bucket(inode, t_blkno, t_bhs, t_is_new);
+       /*
+        * 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 :
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret)
                goto out;
 
-       for (i = 0; i < blk_per_bucket; i++) {
-               ret = ocfs2_journal_access(handle, inode, t_bhs[i],
-                                          t_is_new ?
-                                          OCFS2_JOURNAL_ACCESS_CREATE :
-                                          OCFS2_JOURNAL_ACCESS_WRITE);
-               if (ret)
-                       goto out;
-       }
-
-       for (i = 0; i < blk_per_bucket; i++) {
-               memcpy(t_bhs[i]->b_data, s_bhs[i]->b_data, blocksize);
-               ocfs2_journal_dirty(handle, t_bhs[i]);
-       }
+       ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
+       ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
 
 out:
-       if (s_bhs) {
-               for (i = 0; i < blk_per_bucket; i++)
-                       brelse(s_bhs[i]);
-       }
-       kfree(s_bhs);
-
-       if (t_bhs) {
-               for (i = 0; i < blk_per_bucket; i++)
-                       brelse(t_bhs[i]);
-       }
-       kfree(t_bhs);
+       ocfs2_xattr_bucket_free(t_bucket);
+       ocfs2_xattr_bucket_free(s_bucket);
 
        return ret;
 }
 
 /*
- * 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);
 
-       mlog(0, "cp xattrs from cluster %llu to %llu\n",
-            (unsigned long long)src_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);
+       }
+
+       /* 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;
+       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;
@@ -3485,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;
 }
 
@@ -3539,7 +4589,7 @@ static int ocfs2_divide_xattr_cluster(struct inode *inode,
                                      u32 *first_hash)
 {
        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
-       int ret, credits = 2 * blk_per_bucket;
+       int ret, credits = 2 * blk_per_bucket + handle->h_buffer_credits;
 
        BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize);
 
@@ -3582,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;
                }
        }
@@ -3644,56 +4700,37 @@ 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)
+                                      int *extend,
+                                      struct ocfs2_xattr_set_ctxt *ctxt)
 {
-       int ret, credits;
+       int ret;
        u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
        u32 prev_clusters = *num_clusters;
        u32 clusters_to_add = 1, bit_off, num_bits, v_start = 0;
        u64 block;
-       handle_t *handle = NULL;
-       struct ocfs2_alloc_context *data_ac = NULL;
-       struct ocfs2_alloc_context *meta_ac = NULL;
+       handle_t *handle = ctxt->handle;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        struct ocfs2_extent_tree et;
 
        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_lock_allocators(inode, &et, clusters_to_add, 0,
-                                   &data_ac, &meta_ac);
-       if (ret) {
-               mlog_errno(ret);
-               goto leave;
-       }
-
-       credits = ocfs2_calc_extend_credits(osb->sb, et.et_root_el,
-                                           clusters_to_add);
-       handle = ocfs2_start_trans(osb, credits);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               handle = NULL;
-               mlog_errno(ret);
-               goto leave;
-       }
-
-       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;
        }
 
-       ret = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
+       ret = __ocfs2_claim_clusters(osb, handle, ctxt->data_ac, 1,
                                     clusters_to_add, &bit_off, &num_bits);
        if (ret < 0) {
                if (ret != -ENOSPC)
@@ -3707,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) {
                /*
@@ -3726,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);
@@ -3739,149 +4775,137 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
                }
        }
 
-       if (handle->h_buffer_credits < credits) {
-               /*
-                * The journal has been restarted before, and don't
-                * have enough space for the insertion, so extend it
-                * here.
-                */
-               ret = ocfs2_extend_trans(handle, credits);
-               if (ret) {
-                       mlog_errno(ret);
-                       goto leave;
-               }
-       }
        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,
-                                 num_bits, 0, meta_ac);
+       ret = ocfs2_insert_extent(handle, &et, v_start, block,
+                                 num_bits, 0, ctxt->meta_ac);
        if (ret < 0) {
                mlog_errno(ret);
                goto leave;
        }
 
        ret = ocfs2_journal_dirty(handle, root_bh);
-       if (ret < 0) {
+       if (ret < 0)
                mlog_errno(ret);
-               goto leave;
-       }
 
 leave:
-       if (handle)
-               ocfs2_commit_trans(osb, handle);
-       if (data_ac)
-               ocfs2_free_alloc_context(data_ac);
-       if (meta_ac)
-               ocfs2_free_alloc_context(meta_ac);
-
        return ret;
 }
 
 /*
- * 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,
-                                    struct buffer_head *first_bh,
-                                    struct buffer_head *start_bh,
+                                    handle_t *handle,
+                                    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);
-       handle_t *handle;
-       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).
-        * Add one more bucket and modify the first_bh.
+        * 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 + 2 * blk_per_bucket + 1;
-       handle = ocfs2_start_trans(osb, credits);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               handle = NULL;
+       credits = (end_blk - target_blk) + (3 * blk_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, first,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
-               goto commit;
+               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)
-                       goto commit;
+                       goto out;
                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);
 
-commit:
-       ocfs2_commit_trans(osb, handle);
 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.
  *
- * 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.
+ * 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.
+ *
+ * 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);
@@ -3890,40 +4914,45 @@ 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);
+                                                 &extend,
+                                                 ctxt);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
        }
 
-       if (extend)
+       if (extend) {
                ret = ocfs2_extend_xattr_bucket(inode,
-                                               first_bh,
-                                               header_bh,
+                                               ctxt->handle,
+                                               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;
 }
 
@@ -3956,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;
@@ -3977,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;
 
@@ -3989,7 +5021,7 @@ static void ocfs2_xattr_set_entry_normal(struct inode *inode,
                                xe->xe_value_size = 0;
 
                        val = ocfs2_xattr_bucket_get_val(inode,
-                                                        &xs->bucket, offs);
+                                                        xs->bucket, offs);
                        memset(val + OCFS2_XATTR_SIZE(name_len), 0,
                               size - OCFS2_XATTR_SIZE(name_len));
                        if (OCFS2_XATTR_SIZE(xi->value_len) > 0)
@@ -4000,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);
 
@@ -4067,8 +5087,7 @@ set_new_name_value:
                xh->xh_free_start = cpu_to_le16(offs);
        }
 
-       val = ocfs2_xattr_bucket_get_val(inode,
-                                        &xs->bucket, offs - size);
+       val = ocfs2_xattr_bucket_get_val(inode, xs->bucket, offs - size);
        xe->xe_name_offset = cpu_to_le16(offs - size);
 
        memset(val, 0, size);
@@ -4084,125 +5103,45 @@ set_new_name_value:
        return;
 }
 
-static int ocfs2_xattr_bucket_handle_journal(struct inode *inode,
-                                            handle_t *handle,
-                                            struct ocfs2_xattr_search *xs,
-                                            struct buffer_head **bhs,
-                                            u16 bh_num)
-{
-       int ret = 0, off, block_off;
-       struct ocfs2_xattr_entry *xe = xs->here;
-
-       /*
-        * First calculate all the blocks we should journal_access
-        * and journal_dirty. The first block should always be touched.
-        */
-       ret = ocfs2_journal_dirty(handle, bhs[0]);
-       if (ret)
-               mlog_errno(ret);
-
-       /* calc the data. */
-       off = le16_to_cpu(xe->xe_name_offset);
-       block_off = off >> inode->i_sb->s_blocksize_bits;
-       ret = ocfs2_journal_dirty(handle, bhs[block_off]);
-       if (ret)
-               mlog_errno(ret);
-
-       return ret;
-}
-
 /*
  * Set the xattr entry in the specified bucket.
  * The bucket is indicated by xs->bucket and it should have the enough
  * space for the xattr insertion.
  */
 static int ocfs2_xattr_set_entry_in_bucket(struct inode *inode,
+                                          handle_t *handle,
                                           struct ocfs2_xattr_info *xi,
                                           struct ocfs2_xattr_search *xs,
                                           u32 name_hash,
                                           int local)
 {
-       int i, ret;
-       handle_t *handle = NULL;
-       u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+       int ret;
+       u64 blkno;
 
        mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n",
             (unsigned long)xi->value_len, xi->name_index,
-            (unsigned long long)bucket_blkno(&xs->bucket));
+            (unsigned long long)bucket_blkno(xs->bucket));
 
-       if (!xs->bucket.bu_bhs[1]) {
-               ret = ocfs2_read_blocks(inode,
-                                       bucket_blkno(&xs->bucket) + 1,
-                                       blk_per_bucket - 1, &xs->bucket.bu_bhs[1],
-                                       0);
+       if (!xs->bucket->bu_bhs[1]) {
+               blkno = bucket_blkno(xs->bucket);
+               ocfs2_xattr_bucket_relse(xs->bucket);
+               ret = ocfs2_read_xattr_bucket(xs->bucket, blkno);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
        }
 
-       handle = ocfs2_start_trans(osb, blk_per_bucket);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               handle = NULL;
+       ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
+       if (ret < 0) {
                mlog_errno(ret);
                goto out;
        }
 
-       for (i = 0; i < blk_per_bucket; i++) {
-               ret = ocfs2_journal_access(handle, inode, xs->bucket.bu_bhs[i],
-                                          OCFS2_JOURNAL_ACCESS_WRITE);
-               if (ret < 0) {
-                       mlog_errno(ret);
-                       goto out;
-               }
-       }
-
        ocfs2_xattr_set_entry_normal(inode, xi, xs, name_hash, local);
+       ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
 
-       /*Only dirty the blocks we have touched in set xattr. */
-       ret = ocfs2_xattr_bucket_handle_journal(inode, handle, xs,
-                                               xs->bucket.bu_bhs, blk_per_bucket);
-       if (ret)
-               mlog_errno(ret);
-out:
-       ocfs2_commit_trans(osb, handle);
-
-       return ret;
-}
-
-static int ocfs2_xattr_value_update_size(struct inode *inode,
-                                        struct buffer_head *xe_bh,
-                                        struct ocfs2_xattr_entry *xe,
-                                        u64 new_size)
-{
-       int ret;
-       struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-       handle_t *handle = NULL;
-
-       handle = ocfs2_start_trans(osb, 1);
-       if (IS_ERR(handle)) {
-               ret = -ENOMEM;
-               mlog_errno(ret);
-               goto out;
-       }
-
-       ret = ocfs2_journal_access(handle, inode, xe_bh,
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
-       if (ret < 0) {
-               mlog_errno(ret);
-               goto out_commit;
-       }
-
-       xe->xe_value_size = cpu_to_le64(new_size);
-
-       ret = ocfs2_journal_dirty(handle, xe_bh);
-       if (ret < 0)
-               mlog_errno(ret);
-
-out_commit:
-       ocfs2_commit_trans(osb, handle);
 out:
        return ret;
 }
@@ -4215,18 +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)
+                                            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];
 
@@ -4239,49 +5179,57 @@ 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);
+            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, 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;
 }
 
 static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode,
-                                               struct ocfs2_xattr_search *xs,
-                                               int len)
+                                       struct ocfs2_xattr_search *xs,
+                                       int len,
+                                       struct ocfs2_xattr_set_ctxt *ctxt)
 {
        int ret, offset;
        struct ocfs2_xattr_entry *xe = xs->here;
        struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)xs->base;
 
-       BUG_ON(!xs->bucket.bu_bhs[0] || !xe || ocfs2_xattr_is_local(xe));
+       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],
-                                               offset, len);
+       ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket,
+                                               offset, len, ctxt);
        if (ret)
                mlog_errno(ret);
 
@@ -4289,29 +5237,51 @@ static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode,
 }
 
 static int ocfs2_xattr_bucket_set_value_outside(struct inode *inode,
+                                               handle_t *handle,
                                                struct ocfs2_xattr_search *xs,
                                                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, 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);
@@ -4323,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) {
@@ -4348,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);
@@ -4397,26 +5375,19 @@ out:
 }
 
 static void ocfs2_xattr_bucket_remove_xs(struct inode *inode,
+                                        handle_t *handle,
                                         struct ocfs2_xattr_search *xs)
 {
-       handle_t *handle = NULL;
-       struct ocfs2_xattr_header *xh = bucket_xh(&xs->bucket);
+       struct ocfs2_xattr_header *xh = bucket_xh(xs->bucket);
        struct ocfs2_xattr_entry *last = &xh->xh_entries[
                                                le16_to_cpu(xh->xh_count) - 1];
        int ret = 0;
 
-       handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), 1);
-       if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               mlog_errno(ret);
-               return;
-       }
-
-       ret = ocfs2_journal_access(handle, inode, xs->bucket.bu_bhs[0],
-                                  OCFS2_JOURNAL_ACCESS_WRITE);
+       ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
+                                               OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
-               goto out_commit;
+               return;
        }
 
        /* Remove the old entry. */
@@ -4425,11 +5396,7 @@ static void ocfs2_xattr_bucket_remove_xs(struct inode *inode,
        memset(last, 0, sizeof(struct ocfs2_xattr_entry));
        le16_add_cpu(&xh->xh_count, -1);
 
-       ret = ocfs2_journal_dirty(handle, xs->bucket.bu_bhs[0]);
-       if (ret < 0)
-               mlog_errno(ret);
-out_commit:
-       ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+       ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
 }
 
 /*
@@ -4445,7 +5412,8 @@ out_commit:
  */
 static int ocfs2_xattr_set_in_bucket(struct inode *inode,
                                     struct ocfs2_xattr_info *xi,
-                                    struct ocfs2_xattr_search *xs)
+                                    struct ocfs2_xattr_search *xs,
+                                    struct ocfs2_xattr_set_ctxt *ctxt)
 {
        int ret, local = 1;
        size_t value_len;
@@ -4473,7 +5441,8 @@ static int ocfs2_xattr_set_in_bucket(struct inode *inode,
                        value_len = 0;
 
                ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs,
-                                                          value_len);
+                                                          value_len,
+                                                          ctxt);
                if (ret)
                        goto out;
 
@@ -4493,7 +5462,8 @@ static int ocfs2_xattr_set_in_bucket(struct inode *inode,
                xi->value_len = OCFS2_XATTR_ROOT_SIZE;
        }
 
-       ret = ocfs2_xattr_set_entry_in_bucket(inode, xi, xs, name_hash, local);
+       ret = ocfs2_xattr_set_entry_in_bucket(inode, ctxt->handle, xi, xs,
+                                             name_hash, local);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -4504,7 +5474,7 @@ static int ocfs2_xattr_set_in_bucket(struct inode *inode,
 
        /* allocate the space now for the outside block storage. */
        ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs,
-                                                  value_len);
+                                                  value_len, ctxt);
        if (ret) {
                mlog_errno(ret);
 
@@ -4514,13 +5484,14 @@ static int ocfs2_xattr_set_in_bucket(struct inode *inode,
                         * storage and we have allocated xattr already,
                         * so need to remove it.
                         */
-                       ocfs2_xattr_bucket_remove_xs(inode, xs);
+                       ocfs2_xattr_bucket_remove_xs(inode, ctxt->handle, xs);
                }
                goto out;
        }
 
 set_value_outside:
-       ret = ocfs2_xattr_bucket_set_value_outside(inode, xs, val, value_len);
+       ret = ocfs2_xattr_bucket_set_value_outside(inode, ctxt->handle,
+                                                  xs, val, value_len);
 out:
        return ret;
 }
@@ -4555,7 +5526,8 @@ static int ocfs2_check_xattr_bucket_collision(struct inode *inode,
 
 static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
                                             struct ocfs2_xattr_info *xi,
-                                            struct ocfs2_xattr_search *xs)
+                                            struct ocfs2_xattr_search *xs,
+                                            struct ocfs2_xattr_set_ctxt *ctxt)
 {
        struct ocfs2_xattr_header *xh;
        struct ocfs2_xattr_entry *xe;
@@ -4573,12 +5545,12 @@ 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",
-                       (unsigned long long)bucket_blkno(&xs->bucket),
+                       (unsigned long long)bucket_blkno(xs->bucket),
                        header_size);
 
        if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE)
@@ -4607,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.
@@ -4618,11 +5590,13 @@ try_again:
        mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, "
             "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
             " %u\n", xs->not_found,
-            (unsigned long long)bucket_blkno(&xs->bucket),
+            (unsigned long long)bucket_blkno(xs->bucket),
             free, need, max_free, le16_to_cpu(xh->xh_free_start),
             le16_to_cpu(xh->xh_name_value_len));
 
-       if (free < need || count == ocfs2_xattr_max_xe_in_bucket(inode->i_sb)) {
+       if (free < need ||
+           (xs->not_found &&
+            count == ocfs2_xattr_max_xe_in_bucket(inode->i_sb))) {
                if (need <= max_free &&
                    count < ocfs2_xattr_max_xe_in_bucket(inode->i_sb)) {
                        /*
@@ -4630,14 +5604,16 @@ try_again:
                         * name/value will be moved, the xe shouldn't be changed
                         * in xs.
                         */
-                       ret = ocfs2_defrag_xattr_bucket(inode, &xs->bucket);
+                       ret = ocfs2_defrag_xattr_bucket(inode, ctxt->handle,
+                                                       xs->bucket);
                        if (ret) {
                                mlog_errno(ret);
                                goto out;
                        }
 
                        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;
 
@@ -4662,7 +5638,7 @@ try_again:
                 * add a new bucket for the insert.
                 */
                ret = ocfs2_check_xattr_bucket_collision(inode,
-                                                        &xs->bucket,
+                                                        xs->bucket,
                                                         xi->name);
                if (ret) {
                        mlog_errno(ret);
@@ -4671,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_xattr_bucket_relse(inode, &xs->bucket);
-               memset(&xs->bucket, 0, sizeof(xs->bucket));
-
+               /*
+                * 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);
@@ -4691,7 +5673,7 @@ try_again:
        }
 
 xattr_set:
-       ret = ocfs2_xattr_set_in_bucket(inode, xi, xs);
+       ret = ocfs2_xattr_set_in_bucket(inode, xi, xs, ctxt);
 out:
        mlog_exit(ret);
        return ret;
@@ -4701,80 +5683,1603 @@ 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);
 
        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],
-                                                       i, 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;
                }
        }
 
+       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;
 }
 
-static int ocfs2_delete_xattr_index_block(struct inode *inode,
-                                         struct buffer_head *xb_bh)
+/*
+ * 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)
 {
-       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;
+       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(el->l_next_free_rec) == 0)
-               return 0;
+               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;
+               }
+       }
 
-       while (name_hash > 0) {
-               ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
-                                         &e_cpos, &num_clusters, el);
+       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;
+}
+
+/*
+ * 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)
+{
+       int ret = 0;
+       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;
+
+       cpos = 0;
+       while (cpos < clusters) {
+               ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
+                                              &num_clusters, el, &ext_flags);
+
+               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;
+}
+
+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;
 
-               ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters,
-                                                 ocfs2_delete_xattr_in_bucket,
-                                                 NULL);
+       /*
+        * 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;
                }
+       }
+
+       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;
+               }
+       }
 
-               ret = ocfs2_rm_xattr_cluster(inode, xb_bh,
-                                            p_blkno, e_cpos, num_clusters);
+       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,
+                            &nbs