Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 178eeac3 authored by Joel Becker's avatar Joel Becker Committed by Mark Fasheh
Browse files

ocfs2: Use buckets in ocfs2_xattr_create_index_block(). 



Use the ocfs2_xattr_bucket abstraction in
ocfs2_xattr_create_index_block() and its helpers.  We get more efficient
reads, a lot less buffer_head munging, and nicer code to boot.  While
we're at it, ocfs2_xattr_update_xattr_search() becomes void.

Signed-off-by: default avatarJoel Becker <joel.becker@oracle.com>
Signed-off-by: default avatarMark Fasheh <mfasheh@suse.com>
parent e2356a3f

fs/ocfs2/xattr.c

+32 −82
Original line number Diff line number Diff line
@@ -2649,32 +2649,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
@@ -2686,8 +2688,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. */
@@ -2697,7 +2697,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);
@@ -2723,44 +2723,26 @@ 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,

static void ocfs2_xattr_update_xattr_search(struct inode *inode,

					    struct ocfs2_xattr_search *xs,

					   struct buffer_head *old_bh,

					   struct buffer_head *new_bh)

					    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);

	int i;



	xs->bucket->bu_bhs[0] = new_bh;

	get_bh(new_bh);

	xs->header = bucket_xh(xs->bucket);



	xs->base = new_bh->b_data;

	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;

			}

	if (xs->not_found)

		return;



		}

	i = xs->here - old_xh->xh_entries;

	xs->here = &xs->header->xh_entries[i];

}



	return ret;

}



static int ocfs2_xattr_create_index_block(struct inode *inode,

					  struct ocfs2_xattr_search *xs)

{
@@ -2771,18 +2753,17 @@ static int ocfs2_xattr_create_index_block(struct inode *inode, 
	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);

	BUG_ON(!xs->bucket);



	ret = ocfs2_reserve_clusters(osb, 1, &data_ac);

	if (ret) {
@@ -2798,10 +2779,10 @@ 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.

	 * We need more credits.  One for the xattr block update and one

	 * for each block of the new xattr bucket.

	 */

	credits += 3;

	credits += 1 + ocfs2_blocks_per_xattr_bucket(inode->i_sb);

	handle = ocfs2_start_trans(osb, credits);

	if (IS_ERR(handle)) {

		ret = PTR_ERR(handle);
@@ -2832,51 +2813,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;

		mlog_errno(ret);

		goto out_commit;

	}



	ocfs2_set_new_buffer_uptodate(inode, xh_bh);



	ret = ocfs2_journal_access(handle, inode, xh_bh,

				   OCFS2_JOURNAL_ACCESS_CREATE);

	ret = ocfs2_init_xattr_bucket(xs->bucket, blkno);

	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,

	ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,

						OCFS2_JOURNAL_ACCESS_CREATE);

	if (ret) {

		mlog_errno(ret);

		goto out_commit;

	}

	}



	ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xh_bh, data_bh);



	ocfs2_journal_dirty(handle, xh_bh);

	if (data_bh)

		ocfs2_journal_dirty(handle, data_bh);

	ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xs->bucket);

	ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);



	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 -
@@ -2911,9 +2864,6 @@ out: 
	if (data_ac)

		ocfs2_free_alloc_context(data_ac);



	brelse(xh_bh);

	brelse(data_bh);



	return ret;

}