1 From: Joel Becker <joel.becker@oracle.com>
2 Date: Fri, 24 Oct 2008 19:13:20 -0700
3 Subject: ocfs2: Take ocfs2_xattr_bucket structures off of the stack.
6 The ocfs2_xattr_bucket structure is a nice abstraction, but it is a bit
7 large to have on the stack. Just like ocfs2_path, let's allocate it
8 with a ocfs2_xattr_bucket_new() function.
10 We can now store the inode on the bucket, cleaning up all the other
11 bucket functions. While we're here, we catch another place or two that
12 wasn't using ocfs2_read_xattr_bucket().
15 - No longer allocating xis.bucket, as it will never be used.
17 Signed-off-by: Joel Becker <joel.becker@oracle.com>
18 Signed-off-by: Mark Fasheh <mfasheh@suse.com>
20 fs/ocfs2/xattr.c | 281 ++++++++++++++++++++++++++++++++----------------------
21 1 files changed, 166 insertions(+), 115 deletions(-)
23 diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
24 index 71d9e7b..766494e 100644
25 --- a/fs/ocfs2/xattr.c
26 +++ b/fs/ocfs2/xattr.c
27 @@ -61,7 +61,14 @@ struct ocfs2_xattr_def_value_root {
30 struct ocfs2_xattr_bucket {
31 + /* The inode these xattrs are associated with */
32 + struct inode *bu_inode;
34 + /* The actual buffers that make up the bucket */
35 struct buffer_head *bu_bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
37 + /* How many blocks make up one bucket for this filesystem */
41 #define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root))
42 @@ -97,7 +104,7 @@ struct ocfs2_xattr_search {
44 struct buffer_head *xattr_bh;
45 struct ocfs2_xattr_header *header;
46 - struct ocfs2_xattr_bucket bucket;
47 + struct ocfs2_xattr_bucket *bucket;
50 struct ocfs2_xattr_entry *here;
51 @@ -157,69 +164,91 @@ static inline u16 ocfs2_xattr_max_xe_in_bucket(struct super_block *sb)
52 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
53 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
55 -static void ocfs2_xattr_bucket_relse(struct inode *inode,
56 - struct ocfs2_xattr_bucket *bucket)
57 +static struct ocfs2_xattr_bucket *ocfs2_xattr_bucket_new(struct inode *inode)
59 - int i, blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
60 + struct ocfs2_xattr_bucket *bucket;
61 + int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
63 - for (i = 0; i < blks; i++) {
64 + BUG_ON(blks > OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET);
66 + bucket = kzalloc(sizeof(struct ocfs2_xattr_bucket), GFP_NOFS);
68 + bucket->bu_inode = inode;
69 + bucket->bu_blocks = blks;
75 +static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket *bucket)
79 + for (i = 0; i < bucket->bu_blocks; i++) {
80 brelse(bucket->bu_bhs[i]);
81 bucket->bu_bhs[i] = NULL;
85 +static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket *bucket)
88 + ocfs2_xattr_bucket_relse(bucket);
89 + bucket->bu_inode = NULL;
95 * A bucket that has never been written to disk doesn't need to be
96 * read. We just need the buffer_heads. Don't call this for
97 * buckets that are already on disk. ocfs2_read_xattr_bucket() initializes
100 -static int ocfs2_init_xattr_bucket(struct inode *inode,
101 - struct ocfs2_xattr_bucket *bucket,
102 +static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
106 - int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
108 - for (i = 0; i < blks; i++) {
109 - bucket->bu_bhs[i] = sb_getblk(inode->i_sb, xb_blkno + i);
110 + for (i = 0; i < bucket->bu_blocks; i++) {
111 + bucket->bu_bhs[i] = sb_getblk(bucket->bu_inode->i_sb,
113 if (!bucket->bu_bhs[i]) {
119 - ocfs2_set_new_buffer_uptodate(inode, bucket->bu_bhs[i]);
120 + ocfs2_set_new_buffer_uptodate(bucket->bu_inode,
121 + bucket->bu_bhs[i]);
125 - ocfs2_xattr_bucket_relse(inode, bucket);
126 + ocfs2_xattr_bucket_relse(bucket);
130 /* Read the xattr bucket at xb_blkno */
131 -static int ocfs2_read_xattr_bucket(struct inode *inode,
132 - struct ocfs2_xattr_bucket *bucket,
133 +static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
136 - int rc, blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
139 - rc = ocfs2_read_blocks(inode, xb_blkno, blks, bucket->bu_bhs, 0);
140 + rc = ocfs2_read_blocks(bucket->bu_inode, xb_blkno,
141 + bucket->bu_blocks, bucket->bu_bhs, 0);
143 - ocfs2_xattr_bucket_relse(inode, bucket);
144 + ocfs2_xattr_bucket_relse(bucket);
148 static int ocfs2_xattr_bucket_journal_access(handle_t *handle,
149 - struct inode *inode,
150 struct ocfs2_xattr_bucket *bucket,
154 - int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
156 - for (i = 0; i < blks; i++) {
157 - rc = ocfs2_journal_access(handle, inode,
158 + for (i = 0; i < bucket->bu_blocks; i++) {
159 + rc = ocfs2_journal_access(handle, bucket->bu_inode,
160 bucket->bu_bhs[i], type);
163 @@ -231,24 +260,24 @@ static int ocfs2_xattr_bucket_journal_access(handle_t *handle,
166 static void ocfs2_xattr_bucket_journal_dirty(handle_t *handle,
167 - struct inode *inode,
168 struct ocfs2_xattr_bucket *bucket)
170 - int i, blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
173 - for (i = 0; i < blks; i++)
174 + for (i = 0; i < bucket->bu_blocks; i++)
175 ocfs2_journal_dirty(handle, bucket->bu_bhs[i]);
178 -static void ocfs2_xattr_bucket_copy_data(struct inode *inode,
179 - struct ocfs2_xattr_bucket *dest,
180 +static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket *dest,
181 struct ocfs2_xattr_bucket *src)
184 - int blocksize = inode->i_sb->s_blocksize;
185 - int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
186 + int blocksize = src->bu_inode->i_sb->s_blocksize;
188 + BUG_ON(dest->bu_blocks != src->bu_blocks);
189 + BUG_ON(dest->bu_inode != src->bu_inode);
191 - for (i = 0; i < blks; i++) {
192 + for (i = 0; i < src->bu_blocks; i++) {
193 memcpy(bucket_block(dest, i), bucket_block(src, i),
196 @@ -869,7 +898,12 @@ static int ocfs2_xattr_block_get(struct inode *inode,
198 int ret = -ENODATA, name_offset, name_len, block_off, i;
200 - memset(&xs->bucket, 0, sizeof(xs->bucket));
201 + xs->bucket = ocfs2_xattr_bucket_new(inode);
208 ret = ocfs2_xattr_block_find(inode, name_index, name, xs);
210 @@ -895,11 +929,11 @@ static int ocfs2_xattr_block_get(struct inode *inode,
212 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
213 ret = ocfs2_xattr_bucket_get_name_value(inode,
214 - bucket_xh(&xs->bucket),
215 + bucket_xh(xs->bucket),
219 - xs->base = bucket_block(&xs->bucket, block_off);
220 + xs->base = bucket_block(xs->bucket, block_off);
222 if (ocfs2_xattr_is_local(xs->here)) {
223 memcpy(buffer, (void *)xs->base +
224 @@ -917,8 +951,7 @@ static int ocfs2_xattr_block_get(struct inode *inode,
228 - ocfs2_xattr_bucket_relse(inode, &xs->bucket);
229 - memset(&xs->bucket, 0, sizeof(xs->bucket));
230 + ocfs2_xattr_bucket_free(xs->bucket);
232 brelse(xs->xattr_bh);
234 @@ -2047,10 +2080,20 @@ int ocfs2_xattr_set(struct inode *inode,
235 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
239 + * Only xbs will be used on indexed trees. xis doesn't need a
242 + xbs.bucket = ocfs2_xattr_bucket_new(inode);
244 + mlog_errno(-ENOMEM);
248 ret = ocfs2_inode_lock(inode, &di_bh, 1);
252 + goto cleanup_nolock;
254 xis.inode_bh = xbs.inode_bh = di_bh;
255 di = (struct ocfs2_dinode *)di_bh->b_data;
256 @@ -2127,9 +2170,10 @@ int ocfs2_xattr_set(struct inode *inode,
258 up_write(&OCFS2_I(inode)->ip_xattr_sem);
259 ocfs2_inode_unlock(inode, 1);
262 brelse(xbs.xattr_bh);
263 - ocfs2_xattr_bucket_relse(inode, &xbs.bucket);
264 + ocfs2_xattr_bucket_free(xbs.bucket);
268 @@ -2373,11 +2417,11 @@ static int ocfs2_xattr_bucket_find(struct inode *inode,
272 - xs->bucket.bu_bhs[0] = lower_bh;
273 + xs->bucket->bu_bhs[0] = lower_bh;
276 - xs->header = bucket_xh(&xs->bucket);
277 - xs->base = bucket_block(&xs->bucket, 0);
278 + xs->header = bucket_xh(xs->bucket);
279 + xs->base = bucket_block(xs->bucket, 0);
280 xs->end = xs->base + inode->i_sb->s_blocksize;
283 @@ -2385,8 +2429,8 @@ static int ocfs2_xattr_bucket_find(struct inode *inode,
284 * If we have found the xattr enty, read all the blocks in
287 - ret = ocfs2_read_blocks(inode, bucket_blkno(&xs->bucket) + 1,
288 - blk_per_bucket - 1, &xs->bucket.bu_bhs[1],
289 + ret = ocfs2_read_blocks(inode, bucket_blkno(xs->bucket) + 1,
290 + blk_per_bucket - 1, &xs->bucket->bu_bhs[1],
294 @@ -2395,7 +2439,7 @@ static int ocfs2_xattr_bucket_find(struct inode *inode,
296 xs->here = &xs->header->xh_entries[index];
297 mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name,
298 - (unsigned long long)bucket_blkno(&xs->bucket), index);
299 + (unsigned long long)bucket_blkno(xs->bucket), index);
303 @@ -2453,22 +2497,24 @@ static int ocfs2_iterate_xattr_buckets(struct inode *inode,
307 - int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
308 u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
309 u32 num_buckets = clusters * bpc;
310 - struct ocfs2_xattr_bucket bucket;
311 + struct ocfs2_xattr_bucket *bucket;
313 - memset(&bucket, 0, sizeof(bucket));
314 + bucket = ocfs2_xattr_bucket_new(inode);
316 + mlog_errno(-ENOMEM);
320 mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
321 clusters, (unsigned long long)blkno);
323 - for (i = 0; i < num_buckets; i++, blkno += blk_per_bucket) {
324 - ret = ocfs2_read_blocks(inode, blkno, blk_per_bucket,
326 + for (i = 0; i < num_buckets; i++, blkno += bucket->bu_blocks) {
327 + ret = ocfs2_read_xattr_bucket(bucket, blkno);
335 @@ -2476,26 +2522,24 @@ static int ocfs2_iterate_xattr_buckets(struct inode *inode,
339 - num_buckets = le16_to_cpu(bucket_xh(&bucket)->xh_num_buckets);
340 + num_buckets = le16_to_cpu(bucket_xh(bucket)->xh_num_buckets);
342 mlog(0, "iterating xattr bucket %llu, first hash %u\n",
343 (unsigned long long)blkno,
344 - le32_to_cpu(bucket_xh(&bucket)->xh_entries[0].xe_name_hash));
345 + le32_to_cpu(bucket_xh(bucket)->xh_entries[0].xe_name_hash));
347 - ret = func(inode, &bucket, para);
349 + ret = func(inode, bucket, para);
354 + /* Fall through to bucket_relse() */
357 - ocfs2_xattr_bucket_relse(inode, &bucket);
358 - memset(&bucket, 0, sizeof(bucket));
359 + ocfs2_xattr_bucket_relse(bucket);
365 - ocfs2_xattr_bucket_relse(inode, &bucket);
367 + ocfs2_xattr_bucket_free(bucket);
371 @@ -2718,9 +2762,9 @@ static int ocfs2_xattr_update_xattr_search(struct inode *inode,
372 int i, blocksize = inode->i_sb->s_blocksize;
373 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
375 - xs->bucket.bu_bhs[0] = new_bh;
376 + xs->bucket->bu_bhs[0] = new_bh;
378 - xs->header = bucket_xh(&xs->bucket);
379 + xs->header = bucket_xh(xs->bucket);
381 xs->base = new_bh->b_data;
382 xs->end = xs->base + inode->i_sb->s_blocksize;
383 @@ -2728,8 +2772,8 @@ static int ocfs2_xattr_update_xattr_search(struct inode *inode,
384 if (!xs->not_found) {
385 if (OCFS2_XATTR_BUCKET_SIZE != blocksize) {
386 ret = ocfs2_read_blocks(inode,
387 - bucket_blkno(&xs->bucket) + 1,
388 - blk_per_bucket - 1, &xs->bucket.bu_bhs[1],
389 + bucket_blkno(xs->bucket) + 1,
390 + blk_per_bucket - 1, &xs->bucket->bu_bhs[1],
394 @@ -3244,8 +3288,7 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
397 int count, start, len, name_value_len = 0, xe_len, name_offset = 0;
398 - u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
399 - struct ocfs2_xattr_bucket s_bucket, t_bucket;
400 + struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
401 struct ocfs2_xattr_header *xh;
402 struct ocfs2_xattr_entry *xe;
403 int blocksize = inode->i_sb->s_blocksize;
404 @@ -3253,16 +3296,21 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
405 mlog(0, "move some of xattrs from bucket %llu to %llu\n",
406 (unsigned long long)blk, (unsigned long long)new_blk);
408 - memset(&s_bucket, 0, sizeof(struct ocfs2_xattr_bucket));
409 - memset(&t_bucket, 0, sizeof(struct ocfs2_xattr_bucket));
410 + s_bucket = ocfs2_xattr_bucket_new(inode);
411 + t_bucket = ocfs2_xattr_bucket_new(inode);
412 + if (!s_bucket || !t_bucket) {
418 - ret = ocfs2_read_xattr_bucket(inode, &s_bucket, blk);
419 + ret = ocfs2_read_xattr_bucket(s_bucket, blk);
425 - ret = ocfs2_xattr_bucket_journal_access(handle, inode, &s_bucket,
426 + ret = ocfs2_xattr_bucket_journal_access(handle, s_bucket,
427 OCFS2_JOURNAL_ACCESS_WRITE);
430 @@ -3273,13 +3321,13 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
431 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
432 * there's no need to read it.
434 - ret = ocfs2_init_xattr_bucket(inode, &t_bucket, new_blk);
435 + ret = ocfs2_init_xattr_bucket(t_bucket, new_blk);
441 - ret = ocfs2_xattr_bucket_journal_access(handle, inode, &t_bucket,
442 + ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
444 OCFS2_JOURNAL_ACCESS_CREATE :
445 OCFS2_JOURNAL_ACCESS_WRITE);
446 @@ -3288,7 +3336,7 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
450 - xh = bucket_xh(&s_bucket);
451 + xh = bucket_xh(s_bucket);
452 count = le16_to_cpu(xh->xh_count);
453 start = ocfs2_xattr_find_divide_pos(xh);
455 @@ -3300,10 +3348,10 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
456 * The hash value is set as one larger than
457 * that of the last entry in the previous bucket.
459 - for (i = 0; i < blk_per_bucket; i++)
460 - memset(bucket_block(&t_bucket, i), 0, blocksize);
461 + for (i = 0; i < t_bucket->bu_blocks; i++)
462 + memset(bucket_block(t_bucket, i), 0, blocksize);
464 - xh = bucket_xh(&t_bucket);
465 + xh = bucket_xh(t_bucket);
466 xh->xh_free_start = cpu_to_le16(blocksize);
467 xh->xh_entries[0].xe_name_hash = xe->xe_name_hash;
468 le32_add_cpu(&xh->xh_entries[0].xe_name_hash, 1);
469 @@ -3312,10 +3360,10 @@ static int ocfs2_divide_xattr_bucket(struct inode *inode,
472 /* copy the whole bucket to the new first. */
473 - ocfs2_xattr_bucket_copy_data(inode, &t_bucket, &s_bucket);
474 + ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
476 /* update the new bucket. */
477 - xh = bucket_xh(&t_bucket);
478 + xh = bucket_xh(t_bucket);
481 * Calculate the total name/value len and xh_free_start for
482 @@ -3379,7 +3427,7 @@ set_num_buckets:
484 xh->xh_num_buckets = 0;
486 - ocfs2_xattr_bucket_journal_dirty(handle, inode, &t_bucket);
487 + ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
489 /* store the first_hash of the new bucket. */
491 @@ -3393,18 +3441,18 @@ set_num_buckets:
495 - xh = bucket_xh(&s_bucket);
496 + xh = bucket_xh(s_bucket);
497 memset(&xh->xh_entries[start], 0,
498 sizeof(struct ocfs2_xattr_entry) * (count - start));
499 xh->xh_count = cpu_to_le16(start);
500 xh->xh_free_start = cpu_to_le16(name_offset);
501 xh->xh_name_value_len = cpu_to_le16(name_value_len);
503 - ocfs2_xattr_bucket_journal_dirty(handle, inode, &s_bucket);
504 + ocfs2_xattr_bucket_journal_dirty(handle, s_bucket);
507 - ocfs2_xattr_bucket_relse(inode, &s_bucket);
508 - ocfs2_xattr_bucket_relse(inode, &t_bucket);
509 + ocfs2_xattr_bucket_free(s_bucket);
510 + ocfs2_xattr_bucket_free(t_bucket);
514 @@ -3422,7 +3470,7 @@ static int ocfs2_cp_xattr_bucket(struct inode *inode,
518 - struct ocfs2_xattr_bucket s_bucket, t_bucket;
519 + struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
521 BUG_ON(s_blkno == t_blkno);
523 @@ -3430,10 +3478,15 @@ static int ocfs2_cp_xattr_bucket(struct inode *inode,
524 (unsigned long long)s_blkno, (unsigned long long)t_blkno,
527 - memset(&s_bucket, 0, sizeof(struct ocfs2_xattr_bucket));
528 - memset(&t_bucket, 0, sizeof(struct ocfs2_xattr_bucket));
530 - ret = ocfs2_read_xattr_bucket(inode, &s_bucket, s_blkno);
531 + s_bucket = ocfs2_xattr_bucket_new(inode);
532 + t_bucket = ocfs2_xattr_bucket_new(inode);
533 + if (!s_bucket || !t_bucket) {
539 + ret = ocfs2_read_xattr_bucket(s_bucket, s_blkno);
543 @@ -3441,23 +3494,23 @@ static int ocfs2_cp_xattr_bucket(struct inode *inode,
544 * Even if !t_is_new, we're overwriting t_bucket. Thus,
545 * there's no need to read it.
547 - ret = ocfs2_init_xattr_bucket(inode, &t_bucket, t_blkno);
548 + ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno);
552 - ret = ocfs2_xattr_bucket_journal_access(handle, inode, &t_bucket,
553 + ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
555 OCFS2_JOURNAL_ACCESS_CREATE :
556 OCFS2_JOURNAL_ACCESS_WRITE);
560 - ocfs2_xattr_bucket_copy_data(inode, &t_bucket, &s_bucket);
561 - ocfs2_xattr_bucket_journal_dirty(handle, inode, &t_bucket);
562 + ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
563 + ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
566 - ocfs2_xattr_bucket_relse(inode, &s_bucket);
567 - ocfs2_xattr_bucket_relse(inode, &t_bucket);
568 + ocfs2_xattr_bucket_free(t_bucket);
569 + ocfs2_xattr_bucket_free(s_bucket);
573 @@ -4009,7 +4062,7 @@ static void ocfs2_xattr_set_entry_normal(struct inode *inode,
574 xe->xe_value_size = 0;
576 val = ocfs2_xattr_bucket_get_val(inode,
577 - &xs->bucket, offs);
579 memset(val + OCFS2_XATTR_SIZE(name_len), 0,
580 size - OCFS2_XATTR_SIZE(name_len));
581 if (OCFS2_XATTR_SIZE(xi->value_len) > 0)
582 @@ -4087,8 +4140,7 @@ set_new_name_value:
583 xh->xh_free_start = cpu_to_le16(offs);
586 - val = ocfs2_xattr_bucket_get_val(inode,
587 - &xs->bucket, offs - size);
588 + val = ocfs2_xattr_bucket_get_val(inode, xs->bucket, offs - size);
589 xe->xe_name_offset = cpu_to_le16(offs - size);
591 memset(val, 0, size);
592 @@ -4122,12 +4174,12 @@ static int ocfs2_xattr_set_entry_in_bucket(struct inode *inode,
594 mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n",
595 (unsigned long)xi->value_len, xi->name_index,
596 - (unsigned long long)bucket_blkno(&xs->bucket));
597 + (unsigned long long)bucket_blkno(xs->bucket));
599 - if (!xs->bucket.bu_bhs[1]) {
600 + if (!xs->bucket->bu_bhs[1]) {
601 ret = ocfs2_read_blocks(inode,
602 - bucket_blkno(&xs->bucket) + 1,
603 - blk_per_bucket - 1, &xs->bucket.bu_bhs[1],
604 + bucket_blkno(xs->bucket) + 1,
605 + blk_per_bucket - 1, &xs->bucket->bu_bhs[1],
609 @@ -4143,7 +4195,7 @@ static int ocfs2_xattr_set_entry_in_bucket(struct inode *inode,
613 - ret = ocfs2_xattr_bucket_journal_access(handle, inode, &xs->bucket,
614 + ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
615 OCFS2_JOURNAL_ACCESS_WRITE);
618 @@ -4151,7 +4203,7 @@ static int ocfs2_xattr_set_entry_in_bucket(struct inode *inode,
621 ocfs2_xattr_set_entry_normal(inode, xi, xs, name_hash, local);
622 - ocfs2_xattr_bucket_journal_dirty(handle, inode, &xs->bucket);
623 + ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
626 ocfs2_commit_trans(osb, handle);
627 @@ -4264,10 +4316,10 @@ static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode,
628 struct ocfs2_xattr_entry *xe = xs->here;
629 struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)xs->base;
631 - BUG_ON(!xs->bucket.bu_bhs[0] || !xe || ocfs2_xattr_is_local(xe));
632 + BUG_ON(!xs->bucket->bu_bhs[0] || !xe || ocfs2_xattr_is_local(xe));
634 offset = xe - xh->xh_entries;
635 - ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket.bu_bhs[0],
636 + ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket->bu_bhs[0],
640 @@ -4387,7 +4439,7 @@ static void ocfs2_xattr_bucket_remove_xs(struct inode *inode,
641 struct ocfs2_xattr_search *xs)
643 handle_t *handle = NULL;
644 - struct ocfs2_xattr_header *xh = bucket_xh(&xs->bucket);
645 + struct ocfs2_xattr_header *xh = bucket_xh(xs->bucket);
646 struct ocfs2_xattr_entry *last = &xh->xh_entries[
647 le16_to_cpu(xh->xh_count) - 1];
649 @@ -4400,7 +4452,7 @@ static void ocfs2_xattr_bucket_remove_xs(struct inode *inode,
653 - ret = ocfs2_xattr_bucket_journal_access(handle, inode, &xs->bucket,
654 + ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
655 OCFS2_JOURNAL_ACCESS_WRITE);
658 @@ -4413,7 +4465,7 @@ static void ocfs2_xattr_bucket_remove_xs(struct inode *inode,
659 memset(last, 0, sizeof(struct ocfs2_xattr_entry));
660 le16_add_cpu(&xh->xh_count, -1);
662 - ocfs2_xattr_bucket_journal_dirty(handle, inode, &xs->bucket);
663 + ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
666 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
667 @@ -4565,7 +4617,7 @@ try_again:
669 mlog_bug_on_msg(header_size > blocksize, "bucket %llu has header size "
670 "of %u which exceed block size\n",
671 - (unsigned long long)bucket_blkno(&xs->bucket),
672 + (unsigned long long)bucket_blkno(xs->bucket),
675 if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE)
676 @@ -4605,7 +4657,7 @@ try_again:
677 mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, "
678 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
679 " %u\n", xs->not_found,
680 - (unsigned long long)bucket_blkno(&xs->bucket),
681 + (unsigned long long)bucket_blkno(xs->bucket),
682 free, need, max_free, le16_to_cpu(xh->xh_free_start),
683 le16_to_cpu(xh->xh_name_value_len));
685 @@ -4617,7 +4669,7 @@ try_again:
686 * name/value will be moved, the xe shouldn't be changed
689 - ret = ocfs2_defrag_xattr_bucket(inode, &xs->bucket);
690 + ret = ocfs2_defrag_xattr_bucket(inode, xs->bucket);
694 @@ -4649,7 +4701,7 @@ try_again:
695 * add a new bucket for the insert.
697 ret = ocfs2_check_xattr_bucket_collision(inode,
703 @@ -4658,14 +4710,13 @@ try_again:
705 ret = ocfs2_add_new_xattr_bucket(inode,
707 - xs->bucket.bu_bhs[0]);
708 + xs->bucket->bu_bhs[0]);
714 - ocfs2_xattr_bucket_relse(inode, &xs->bucket);
715 - memset(&xs->bucket, 0, sizeof(xs->bucket));
716 + ocfs2_xattr_bucket_relse(xs->bucket);
718 ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh,