--- /dev/null
+From: Tao Ma <tao.ma@oracle.com>
+Date: Wed, 12 Nov 2008 08:27:00 +0800
+Subject: ocfs2/xattr: Reserve meta/data at the beginning of ocfs2_xattr_set.
+Patch-mainline: 2.6.29
+
+In ocfs2 xattr set, we reserve metadata and clusters in any place
+they are needed. It is time-consuming and ineffective, so this
+patch try to reserve metadata and clusters at the beginning of
+ocfs2_xattr_set.
+
+Signed-off-by: Tao Ma <tao.ma@oracle.com>
+Signed-off-by: Mark Fasheh <mfasheh@suse.com>
+---
+ fs/ocfs2/alloc.h | 4 +
+ fs/ocfs2/xattr.c | 483 ++++++++++++++++++++++++++++++++++++++++--------------
+ 2 files changed, 361 insertions(+), 126 deletions(-)
+
+diff --git a/fs/ocfs2/alloc.h b/fs/ocfs2/alloc.h
+index c301cf2..3eb735e 100644
+--- a/fs/ocfs2/alloc.h
++++ b/fs/ocfs2/alloc.h
+@@ -176,6 +176,10 @@ static inline void ocfs2_init_dealloc_ctxt(struct ocfs2_cached_dealloc_ctxt *c)
+ }
+ int ocfs2_cache_cluster_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
+ u64 blkno, unsigned int bit);
++static inline int ocfs2_dealloc_has_cluster(struct ocfs2_cached_dealloc_ctxt *c)
++{
++ return c->c_global_allocator != NULL;
++}
+ int ocfs2_run_deallocs(struct ocfs2_super *osb,
+ struct ocfs2_cached_dealloc_ctxt *ctxt);
+
+diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
+index f1da381..4fd201a 100644
+--- a/fs/ocfs2/xattr.c
++++ b/fs/ocfs2/xattr.c
+@@ -71,6 +71,12 @@ struct ocfs2_xattr_bucket {
+ int bu_blocks;
+ };
+
++struct ocfs2_xattr_set_ctxt {
++ 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
+
+@@ -133,11 +139,13 @@ static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
+ 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);
+@@ -334,14 +342,13 @@ static void ocfs2_xattr_hash_entry(struct inode *inode,
+ 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_root *xv,
++ 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;
+ 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);
+@@ -353,13 +360,6 @@ static int ocfs2_xattr_extend_allocation(struct inode *inode,
+
+ 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);
+@@ -386,8 +386,8 @@ restarted_transaction:
+ 0,
+ &et,
+ handle,
+- data_ac,
+- meta_ac,
++ ctxt->data_ac,
++ ctxt->meta_ac,
+ &why);
+ if ((status < 0) && (status != -EAGAIN)) {
+ if (status != -ENOSPC)
+@@ -432,14 +432,6 @@ leave:
+ 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;
+@@ -452,23 +444,16 @@ static int __ocfs2_remove_xattr_range(struct inode *inode,
+ struct buffer_head *root_bh,
+ struct ocfs2_xattr_value_root *xv,
+ u32 cpos, u32 phys_cpos, u32 len,
+- struct ocfs2_cached_dealloc_ctxt *dealloc)
++ 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);
+ handle_t *handle;
+- struct ocfs2_alloc_context *meta_ac = NULL;
+ struct ocfs2_extent_tree et;
+
+ ocfs2_init_xattr_value_extent_tree(&et, inode, root_bh, xv);
+
+- ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
+- if (ret) {
+- mlog_errno(ret);
+- return ret;
+- }
+-
+ handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
+ if (IS_ERR(handle)) {
+ ret = PTR_ERR(handle);
+@@ -483,8 +468,8 @@ static int __ocfs2_remove_xattr_range(struct inode *inode,
+ goto out_commit;
+ }
+
+- ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac,
+- dealloc);
++ ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, ctxt->meta_ac,
++ &ctxt->dealloc);
+ if (ret) {
+ mlog_errno(ret);
+ goto out_commit;
+@@ -498,17 +483,13 @@ static int __ocfs2_remove_xattr_range(struct inode *inode,
+ goto out_commit;
+ }
+
+- ret = ocfs2_cache_cluster_dealloc(dealloc, phys_blkno, len);
++ ret = ocfs2_cache_cluster_dealloc(&ctxt->dealloc, phys_blkno, len);
+ if (ret)
+ mlog_errno(ret);
+
+ out_commit:
+ ocfs2_commit_trans(osb, handle);
+ out:
+-
+- if (meta_ac)
+- ocfs2_free_alloc_context(meta_ac);
+-
+ return ret;
+ }
+
+@@ -516,15 +497,12 @@ 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_root *xv,
++ struct ocfs2_xattr_set_ctxt *ctxt)
+ {
+ int ret = 0;
+ 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;
+@@ -544,7 +522,7 @@ static int ocfs2_xattr_shrink_size(struct inode *inode,
+
+ ret = __ocfs2_remove_xattr_range(inode, root_bh, xv, cpos,
+ phys_cpos, alloc_size,
+- &dealloc);
++ ctxt);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+@@ -558,16 +536,14 @@ static int ocfs2_xattr_shrink_size(struct inode *inode,
+ }
+
+ 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)
++ int len,
++ struct ocfs2_xattr_set_ctxt *ctxt)
+ {
+ int ret;
+ u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len);
+@@ -579,11 +555,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);
++ root_bh, xv, ctxt);
+ else
+ ret = ocfs2_xattr_shrink_size(inode,
+ old_clusters, new_clusters,
+- root_bh, xv);
++ root_bh, xv, ctxt);
+
+ return ret;
+ }
+@@ -1167,6 +1143,7 @@ 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,
+ size_t offs)
+ {
+ size_t name_len = strlen(xi->name);
+@@ -1186,7 +1163,7 @@ static int ocfs2_xattr_set_value_outside(struct inode *inode,
+ xv->xr_list.l_next_free_rec = 0;
+
+ ret = ocfs2_xattr_value_truncate(inode, xs->xattr_bh, xv,
+- xi->value_len);
++ xi->value_len, ctxt);
+ if (ret < 0) {
+ mlog_errno(ret);
+ return ret;
+@@ -1317,6 +1294,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;
+@@ -1387,7 +1365,7 @@ 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, offs);
+ if (ret < 0)
+ mlog_errno(ret);
+ goto out;
+@@ -1406,7 +1384,8 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
+ ret = ocfs2_xattr_value_truncate(inode,
+ xs->xattr_bh,
+ xv,
+- xi->value_len);
++ xi->value_len,
++ ctxt);
+ if (ret < 0) {
+ mlog_errno(ret);
+ goto out;
+@@ -1436,7 +1415,8 @@ static int ocfs2_xattr_set_entry(struct inode *inode,
+ ret = ocfs2_xattr_value_truncate(inode,
+ xs->xattr_bh,
+ xv,
+- 0);
++ 0,
++ ctxt);
+ if (ret < 0)
+ mlog_errno(ret);
+ }
+@@ -1531,7 +1511,7 @@ out_commit:
+ * 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, offs);
+ if (ret < 0) {
+ int ret2;
+
+@@ -1555,6 +1535,10 @@ static int ocfs2_remove_value_outside(struct inode*inode,
+ struct ocfs2_xattr_header *header)
+ {
+ int ret = 0, i;
++ struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
++ struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
++
++ 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];
+@@ -1567,14 +1551,17 @@ static int ocfs2_remove_value_outside(struct inode*inode,
+ 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);
++ ret = ocfs2_xattr_value_truncate(inode, bh, xv,
++ 0, &ctxt);
+ if (ret < 0) {
+ mlog_errno(ret);
+- return ret;
++ break;
+ }
+ }
+ }
+
++ ocfs2_schedule_truncate_log_flush(osb, 1);
++ ocfs2_run_deallocs(osb, &ctxt.dealloc);
+ return ret;
+ }
+
+@@ -1836,7 +1823,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;
+@@ -1853,7 +1841,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);
+@@ -1926,12 +1914,12 @@ 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;
+ struct ocfs2_xattr_block *xblk = NULL;
+ u16 suballoc_bit_start;
+@@ -1940,15 +1928,6 @@ static int ocfs2_xattr_block_set(struct inode *inode,
+ int ret;
+
+ if (!xs->xattr_bh) {
+- /*
+- * Alloc one external block for extended attribute
+- * outside of inode.
+- */
+- ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac);
+- if (ret < 0) {
+- mlog_errno(ret);
+- goto out;
+- }
+ handle = ocfs2_start_trans(osb,
+ OCFS2_XATTR_BLOCK_CREATE_CREDITS);
+ if (IS_ERR(handle)) {
+@@ -1963,7 +1942,7 @@ static int ocfs2_xattr_block_set(struct inode *inode,
+ goto out_commit;
+ }
+
+- ret = ocfs2_claim_metadata(osb, handle, meta_ac, 1,
++ ret = ocfs2_claim_metadata(osb, handle, ctxt->meta_ac, 1,
+ &suballoc_bit_start, &num_got,
+ &first_blkno);
+ if (ret < 0) {
+@@ -1996,7 +1975,6 @@ static int ocfs2_xattr_block_set(struct inode *inode,
+ xs->end = (void *)xblk + inode->i_sb->s_blocksize;
+ xs->here = xs->header->xh_entries;
+
+-
+ ret = ocfs2_journal_dirty(handle, new_bh);
+ if (ret < 0) {
+ mlog_errno(ret);
+@@ -2009,8 +1987,6 @@ static int ocfs2_xattr_block_set(struct inode *inode,
+ out_commit:
+ ocfs2_commit_trans(osb, handle);
+ out:
+- if (meta_ac)
+- ocfs2_free_alloc_context(meta_ac);
+ if (ret < 0)
+ return ret;
+ } else
+@@ -2018,22 +1994,266 @@ out:
+
+ 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);
++ 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);
++ ret = ocfs2_xattr_create_index_block(inode, xs, ctxt);
+ if (ret)
+ goto end;
+ }
+
+- ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs);
++ 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) - sizeof(__u32);
++ 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 ret = 0, old_in_xb = 0;
++ int clusters_add = 0, meta_add = 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;
++
++ /*
++ * delete a xattr doesn't need metadata and cluster allocation.
++ * so return.
++ */
++ if (!xi->value)
++ goto out;
++
++ if (xis->not_found && xbs->not_found) {
++ if (xi->value_len > OCFS2_XATTR_INLINE_SIZE)
++ clusters_add += 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;
++ } else {
++ int i, block_off;
++ 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,
++ bucket_xh(xbs->bucket),
++ i, &block_off,
++ &name_offset);
++ base = bucket_block(xbs->bucket, block_off);
++ } else
++ base = xbs->base;
++ }
++
++ /* do cluster allocation guess first. */
++ value_size = le64_to_cpu(xe->xe_value_size);
++
++ if (old_in_xb) {
++ /*
++ * 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.
++ */
++ if (ocfs2_xattr_can_be_in_inode(inode, xi, xis)) {
++ clusters_add += new_clusters;
++ goto out;
++ }
++ }
++
++ 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);
++ } else
++ xv = &def_xv.xv;
++
++ if (old_clusters >= new_clusters)
++ goto out;
++ else {
++ meta_add += ocfs2_extend_meta_needed(&xv->xr_list);
++ clusters_add += new_clusters - old_clusters;
++ goto out;
++ }
++ } 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_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 (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);
++ }
++
++ /*
++ * 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;
++ if (OCFS2_XATTR_BUCKET_SIZE ==
++ OCFS2_SB(inode->i_sb)->s_clustersize)
++ clusters_add += 1;
++ } else
++ meta_add += 1;
++out:
++ if (clusters_need)
++ *clusters_need = clusters_add;
++ if (meta_need)
++ *meta_need = meta_add;
++ brelse(bh);
++ return ret;
++}
++
++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 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);
++ if (ret) {
++ mlog_errno(ret);
++ return ret;
++ }
++
++ mlog(0, "Set xattr %s, reserve meta blocks = %d, clusters = %d\n",
++ xi->name, meta_add, clusters_add);
++
++ if (meta_add) {
++ ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add,
++ &ctxt->meta_ac);
++ if (ret) {
++ mlog_errno(ret);
++ goto out;
++ }
++ }
++
++ if (clusters_add) {
++ ret = ocfs2_reserve_clusters(osb, clusters_add, &ctxt->data_ac);
++ if (ret)
++ mlog_errno(ret);
++ }
++out:
++ if (ret) {
++ if (ctxt->meta_ac) {
++ ocfs2_free_alloc_context(ctxt->meta_ac);
++ ctxt->meta_ac = NULL;
++ }
++
++ /*
++ * We cannot have an error and a non null ctxt->data_ac.
++ */
++ }
++
++ return ret;
++}
++
+ /*
+ * ocfs2_xattr_set()
+ *
+@@ -2051,6 +2271,8 @@ int ocfs2_xattr_set(struct inode *inode,
+ struct buffer_head *di_bh = NULL;
+ struct ocfs2_dinode *di;
+ int ret;
++ struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
++ struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
+
+ struct ocfs2_xattr_info xi = {
+ .name_index = name_index,
+@@ -2115,15 +2337,21 @@ int ocfs2_xattr_set(struct inode *inode,
+ goto cleanup;
+ }
+
++ ret = ocfs2_init_xattr_set_ctxt(inode, di, &xi, &xis, &xbs, &ctxt);
++ if (ret) {
++ mlog_errno(ret);
++ goto cleanup;
++ }
++
+ if (!value) {
+ /* Remove existing extended attribute */
+ if (!xis.not_found)
+- ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
++ ret = ocfs2_xattr_ibody_set(inode, &xi, &xis, &ctxt);
+ else if (!xbs.not_found)
+- ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
++ 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);
++ ret = ocfs2_xattr_ibody_set(inode, &xi, &xis, &ctxt);
+ if (!ret && !xbs.not_found) {
+ /*
+ * If succeed and that extended attribute existing in
+@@ -2131,7 +2359,7 @@ int ocfs2_xattr_set(struct inode *inode,
+ */
+ xi.value = NULL;
+ xi.value_len = 0;
+- ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
++ 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, name_index,
+@@ -2143,9 +2371,9 @@ int ocfs2_xattr_set(struct inode *inode,
+ * If no space in inode, we will set extended attribute
+ * into external block.
+ */
+- ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
++ ret = ocfs2_xattr_block_set(inode, &xi, &xbs, &ctxt);
+ if (ret)
+- goto cleanup;
++ goto free;
+ if (!xis.not_found) {
+ /*
+ * If succeed and that extended attribute
+@@ -2153,10 +2381,19 @@ int ocfs2_xattr_set(struct inode *inode,
+ */
+ xi.value = NULL;
+ xi.value_len = 0;
+- ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
++ ret = ocfs2_xattr_ibody_set(inode, &xi,
++ &xis, &ctxt);
+ }
+ }
+ }
++free:
++ 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:
+ up_write(&OCFS2_I(inode)->ip_xattr_sem);
+ ocfs2_inode_unlock(inode, 1);
+@@ -2734,7 +2971,8 @@ static void ocfs2_xattr_update_xattr_search(struct inode *inode,
+ }
+
+ 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;
+ u32 bit_off, len;
+@@ -2742,7 +2980,6 @@ static int ocfs2_xattr_create_index_block(struct inode *inode,
+ handle_t *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 *xb_bh = xs->xattr_bh;
+ struct ocfs2_xattr_block *xb =
+ (struct ocfs2_xattr_block *)xb_bh->b_data;
+@@ -2755,12 +2992,6 @@ static int ocfs2_xattr_create_index_block(struct inode *inode,
+ BUG_ON(xb_flags & OCFS2_XATTR_INDEXED);
+ BUG_ON(!xs->bucket);
+
+- ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
+- if (ret) {
+- mlog_errno(ret);
+- goto out;
+- }
+-
+ /*
+ * XXX:
+ * We can use this lock for now, and maybe move to a dedicated mutex
+@@ -2787,7 +3018,8 @@ static int ocfs2_xattr_create_index_block(struct inode *inode,
+ goto out_commit;
+ }
+
+- 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;
+@@ -2850,10 +3082,6 @@ out_commit:
+ out_sem:
+ up_write(&oi->ip_alloc_sem);
+
+-out:
+- if (data_ac)
+- ocfs2_free_alloc_context(data_ac);
+-
+ return ret;
+ }
+
+@@ -3614,7 +3842,8 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
+ u32 *num_clusters,
+ u32 prev_cpos,
+ u64 prev_blkno,
+- int *extend)
++ int *extend,
++ struct ocfs2_xattr_set_ctxt *ctxt)
+ {
+ int ret, credits;
+ u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+@@ -3622,8 +3851,6 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
+ 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;
+ struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+ struct ocfs2_extent_tree et;
+
+@@ -3634,13 +3861,6 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
+
+ ocfs2_init_xattr_tree_extent_tree(&et, 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);
+@@ -3658,7 +3878,7 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
+ 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)
+@@ -3719,7 +3939,7 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
+ mlog(0, "Insert %u clusters at block %llu for xattr at %u\n",
+ num_bits, (unsigned long long)block, v_start);
+ ret = ocfs2_insert_extent(osb, handle, inode, &et, v_start, block,
+- num_bits, 0, meta_ac);
++ num_bits, 0, ctxt->meta_ac);
+ if (ret < 0) {
+ mlog_errno(ret);
+ goto leave;
+@@ -3734,10 +3954,6 @@ static int ocfs2_add_new_xattr_cluster(struct inode *inode,
+ 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;
+ }
+@@ -3821,7 +4037,8 @@ out:
+ */
+ static int ocfs2_add_new_xattr_bucket(struct inode *inode,
+ struct buffer_head *xb_bh,
+- struct buffer_head *header_bh)
++ struct buffer_head *header_bh,
++ struct ocfs2_xattr_set_ctxt *ctxt)
+ {
+ struct ocfs2_xattr_header *first_xh = NULL;
+ struct buffer_head *first_bh = NULL;
+@@ -3872,7 +4089,8 @@ static int ocfs2_add_new_xattr_bucket(struct inode *inode,
+ &num_clusters,
+ e_cpos,
+ p_blkno,
+- &extend);
++ &extend,
++ ctxt);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+@@ -4147,7 +4365,8 @@ out:
+ static int ocfs2_xattr_bucket_value_truncate(struct inode *inode,
+ struct buffer_head *header_bh,
+ int xe_off,
+- int len)
++ int len,
++ struct ocfs2_xattr_set_ctxt *ctxt)
+ {
+ int ret, offset;
+ u64 value_blk;
+@@ -4182,7 +4401,7 @@ static int ocfs2_xattr_bucket_value_truncate(struct inode *inode,
+
+ 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);
++ ret = ocfs2_xattr_value_truncate(inode, value_bh, xv, len, ctxt);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+@@ -4200,8 +4419,9 @@ out:
+ }
+
+ 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;
+@@ -4211,7 +4431,7 @@ static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode,
+
+ offset = xe - xh->xh_entries;
+ ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket->bu_bhs[0],
+- offset, len);
++ offset, len, ctxt);
+ if (ret)
+ mlog_errno(ret);
+
+@@ -4375,7 +4595,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;
+@@ -4403,7 +4624,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;
+
+@@ -4434,7 +4656,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);
+
+@@ -4485,7 +4707,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;
+@@ -4603,7 +4826,8 @@ try_again:
+
+ ret = ocfs2_add_new_xattr_bucket(inode,
+ xs->xattr_bh,
+- xs->bucket->bu_bhs[0]);
++ xs->bucket->bu_bhs[0],
++ ctxt);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+@@ -4622,7 +4846,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;
+@@ -4636,6 +4860,10 @@ static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
+ 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,};
++
++ ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
+
+ for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
+ xe = &xh->xh_entries[i];
+@@ -4644,13 +4872,16 @@ static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
+
+ ret = ocfs2_xattr_bucket_value_truncate(inode,
+ bucket->bu_bhs[0],
+- i, 0);
++ i, 0, &ctxt);
+ if (ret) {
+ mlog_errno(ret);
+ break;
+ }
+ }
+
++ ocfs2_schedule_truncate_log_flush(osb, 1);
++ ocfs2_run_deallocs(osb, &ctxt.dealloc);
++
+ return ret;
+ }
+
+--
+1.5.6
+
projects / people / pmueller / ipfire-2.x.git / blobdiff