]> git.ipfire.org Git - people/ms/linux.git/blob - fs/ocfs2/xattr.c
projects / people / ms / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag '5.18-smb3-fixes-part2' of git://git.samba.org/sfrench/cifs-2.6
[people/ms/linux.git] / fs / ocfs2 / xattr.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * xattr.c
4 *
5 * Copyright (C) 2004, 2008 Oracle. All rights reserved.
6 *
7 * CREDITS:
8 * Lots of code in this file is copy from linux/fs/ext3/xattr.c.
9 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
10 */
11
12 #include <linux/capability.h>
13 #include <linux/fs.h>
14 #include <linux/types.h>
15 #include <linux/slab.h>
16 #include <linux/highmem.h>
17 #include <linux/pagemap.h>
18 #include <linux/uio.h>
19 #include <linux/sched.h>
20 #include <linux/splice.h>
21 #include <linux/mount.h>
22 #include <linux/writeback.h>
23 #include <linux/falloc.h>
24 #include <linux/sort.h>
25 #include <linux/init.h>
26 #include <linux/module.h>
27 #include <linux/string.h>
28 #include <linux/security.h>
29
30 #include <cluster/masklog.h>
31
32 #include "ocfs2.h"
33 #include "alloc.h"
34 #include "blockcheck.h"
35 #include "dlmglue.h"
36 #include "file.h"
37 #include "symlink.h"
38 #include "sysfile.h"
39 #include "inode.h"
40 #include "journal.h"
41 #include "ocfs2_fs.h"
42 #include "suballoc.h"
43 #include "uptodate.h"
44 #include "buffer_head_io.h"
45 #include "super.h"
46 #include "xattr.h"
47 #include "refcounttree.h"
48 #include "acl.h"
49 #include "ocfs2_trace.h"
50
51 struct ocfs2_xattr_def_value_root {
52 struct ocfs2_xattr_value_root xv;
53 struct ocfs2_extent_rec er;
54 };
55
56 struct ocfs2_xattr_bucket {
57 /* The inode these xattrs are associated with */
58 struct inode *bu_inode;
59
60 /* The actual buffers that make up the bucket */
61 struct buffer_head *bu_bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
62
63 /* How many blocks make up one bucket for this filesystem */
64 int bu_blocks;
65 };
66
67 struct ocfs2_xattr_set_ctxt {
68 handle_t *handle;
69 struct ocfs2_alloc_context *meta_ac;
70 struct ocfs2_alloc_context *data_ac;
71 struct ocfs2_cached_dealloc_ctxt dealloc;
72 int set_abort;
73 };
74
75 #define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root))
76 #define OCFS2_XATTR_INLINE_SIZE 80
77 #define OCFS2_XATTR_HEADER_GAP 4
78 #define OCFS2_XATTR_FREE_IN_IBODY (OCFS2_MIN_XATTR_INLINE_SIZE \
79 - sizeof(struct ocfs2_xattr_header) \
80 - OCFS2_XATTR_HEADER_GAP)
81 #define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \
82 - sizeof(struct ocfs2_xattr_block) \
83 - sizeof(struct ocfs2_xattr_header) \
84 - OCFS2_XATTR_HEADER_GAP)
85
86 static struct ocfs2_xattr_def_value_root def_xv = {
87 .xv.xr_list.l_count = cpu_to_le16(1),
88 };
89
90 const struct xattr_handler *ocfs2_xattr_handlers[] = {
91 &ocfs2_xattr_user_handler,
92 &posix_acl_access_xattr_handler,
93 &posix_acl_default_xattr_handler,
94 &ocfs2_xattr_trusted_handler,
95 &ocfs2_xattr_security_handler,
96 NULL
97 };
98
99 static const struct xattr_handler *ocfs2_xattr_handler_map[OCFS2_XATTR_MAX] = {
100 [OCFS2_XATTR_INDEX_USER] = &ocfs2_xattr_user_handler,
101 [OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS]
102 = &posix_acl_access_xattr_handler,
103 [OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT]
104 = &posix_acl_default_xattr_handler,
105 [OCFS2_XATTR_INDEX_TRUSTED] = &ocfs2_xattr_trusted_handler,
106 [OCFS2_XATTR_INDEX_SECURITY] = &ocfs2_xattr_security_handler,
107 };
108
109 struct ocfs2_xattr_info {
110 int xi_name_index;
111 const char *xi_name;
112 int xi_name_len;
113 const void *xi_value;
114 size_t xi_value_len;
115 };
116
117 struct ocfs2_xattr_search {
118 struct buffer_head *inode_bh;
119 /*
120 * xattr_bh point to the block buffer head which has extended attribute
121 * when extended attribute in inode, xattr_bh is equal to inode_bh.
122 */
123 struct buffer_head *xattr_bh;
124 struct ocfs2_xattr_header *header;
125 struct ocfs2_xattr_bucket *bucket;
126 void *base;
127 void *end;
128 struct ocfs2_xattr_entry *here;
129 int not_found;
130 };
131
132 /* Operations on struct ocfs2_xa_entry */
133 struct ocfs2_xa_loc;
134 struct ocfs2_xa_loc_operations {
135 /*
136 * Journal functions
137 */
138 int (*xlo_journal_access)(handle_t *handle, struct ocfs2_xa_loc *loc,
139 int type);
140 void (*xlo_journal_dirty)(handle_t *handle, struct ocfs2_xa_loc *loc);
141
142 /*
143 * Return a pointer to the appropriate buffer in loc->xl_storage
144 * at the given offset from loc->xl_header.
145 */
146 void *(*xlo_offset_pointer)(struct ocfs2_xa_loc *loc, int offset);
147
148 /* Can we reuse the existing entry for the new value? */
149 int (*xlo_can_reuse)(struct ocfs2_xa_loc *loc,
150 struct ocfs2_xattr_info *xi);
151
152 /* How much space is needed for the new value? */
153 int (*xlo_check_space)(struct ocfs2_xa_loc *loc,
154 struct ocfs2_xattr_info *xi);
155
156 /*
157 * Return the offset of the first name+value pair. This is
158 * the start of our downward-filling free space.
159 */
160 int (*xlo_get_free_start)(struct ocfs2_xa_loc *loc);
161
162 /*
163 * Remove the name+value at this location. Do whatever is
164 * appropriate with the remaining name+value pairs.
165 */
166 void (*xlo_wipe_namevalue)(struct ocfs2_xa_loc *loc);
167
168 /* Fill xl_entry with a new entry */
169 void (*xlo_add_entry)(struct ocfs2_xa_loc *loc, u32 name_hash);
170
171 /* Add name+value storage to an entry */
172 void (*xlo_add_namevalue)(struct ocfs2_xa_loc *loc, int size);
173
174 /*
175 * Initialize the value buf's access and bh fields for this entry.
176 * ocfs2_xa_fill_value_buf() will handle the xv pointer.
177 */
178 void (*xlo_fill_value_buf)(struct ocfs2_xa_loc *loc,
179 struct ocfs2_xattr_value_buf *vb);
180 };
181
182 /*
183 * Describes an xattr entry location. This is a memory structure
184 * tracking the on-disk structure.
185 */
186 struct ocfs2_xa_loc {
187 /* This xattr belongs to this inode */
188 struct inode *xl_inode;
189
190 /* The ocfs2_xattr_header inside the on-disk storage. Not NULL. */
191 struct ocfs2_xattr_header *xl_header;
192
193 /* Bytes from xl_header to the end of the storage */
194 int xl_size;
195
196 /*
197 * The ocfs2_xattr_entry this location describes. If this is
198 * NULL, this location describes the on-disk structure where it
199 * would have been.
200 */
201 struct ocfs2_xattr_entry *xl_entry;
202
203 /*
204 * Internal housekeeping
205 */
206
207 /* Buffer(s) containing this entry */
208 void *xl_storage;
209
210 /* Operations on the storage backing this location */
211 const struct ocfs2_xa_loc_operations *xl_ops;
212 };
213
214 /*
215 * Convenience functions to calculate how much space is needed for a
216 * given name+value pair
217 */
218 static int namevalue_size(int name_len, uint64_t value_len)
219 {
220 if (value_len > OCFS2_XATTR_INLINE_SIZE)
221 return OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
222 else
223 return OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(value_len);
224 }
225
226 static int namevalue_size_xi(struct ocfs2_xattr_info *xi)
227 {
228 return namevalue_size(xi->xi_name_len, xi->xi_value_len);
229 }
230
231 static int namevalue_size_xe(struct ocfs2_xattr_entry *xe)
232 {
233 u64 value_len = le64_to_cpu(xe->xe_value_size);
234
235 BUG_ON((value_len > OCFS2_XATTR_INLINE_SIZE) &&
236 ocfs2_xattr_is_local(xe));
237 return namevalue_size(xe->xe_name_len, value_len);
238 }
239
240
241 static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb,
242 struct ocfs2_xattr_header *xh,
243 int index,
244 int *block_off,
245 int *new_offset);
246
247 static int ocfs2_xattr_block_find(struct inode *inode,
248 int name_index,
249 const char *name,
250 struct ocfs2_xattr_search *xs);
251 static int ocfs2_xattr_index_block_find(struct inode *inode,
252 struct buffer_head *root_bh,
253 int name_index,
254 const char *name,
255 struct ocfs2_xattr_search *xs);
256
257 static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
258 struct buffer_head *blk_bh,
259 char *buffer,
260 size_t buffer_size);
261
262 static int ocfs2_xattr_create_index_block(struct inode *inode,
263 struct ocfs2_xattr_search *xs,
264 struct ocfs2_xattr_set_ctxt *ctxt);
265
266 static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
267 struct ocfs2_xattr_info *xi,
268 struct ocfs2_xattr_search *xs,
269 struct ocfs2_xattr_set_ctxt *ctxt);
270
271 typedef int (xattr_tree_rec_func)(struct inode *inode,
272 struct buffer_head *root_bh,
273 u64 blkno, u32 cpos, u32 len, void *para);
274 static int ocfs2_iterate_xattr_index_block(struct inode *inode,
275 struct buffer_head *root_bh,
276 xattr_tree_rec_func *rec_func,
277 void *para);
278 static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
279 struct ocfs2_xattr_bucket *bucket,
280 void *para);
281 static int ocfs2_rm_xattr_cluster(struct inode *inode,
282 struct buffer_head *root_bh,
283 u64 blkno,
284 u32 cpos,
285 u32 len,
286 void *para);
287
288 static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle,
289 u64 src_blk, u64 last_blk, u64 to_blk,
290 unsigned int start_bucket,
291 u32 *first_hash);
292 static int ocfs2_prepare_refcount_xattr(struct inode *inode,
293 struct ocfs2_dinode *di,
294 struct ocfs2_xattr_info *xi,
295 struct ocfs2_xattr_search *xis,
296 struct ocfs2_xattr_search *xbs,
297 struct ocfs2_refcount_tree **ref_tree,
298 int *meta_need,
299 int *credits);
300 static int ocfs2_get_xattr_tree_value_root(struct super_block *sb,
301 struct ocfs2_xattr_bucket *bucket,
302 int offset,
303 struct ocfs2_xattr_value_root **xv,
304 struct buffer_head **bh);
305
306 static inline u16 ocfs2_xattr_buckets_per_cluster(struct ocfs2_super *osb)
307 {
308 return (1 << osb->s_clustersize_bits) / OCFS2_XATTR_BUCKET_SIZE;
309 }
310
311 static inline u16 ocfs2_blocks_per_xattr_bucket(struct super_block *sb)
312 {
313 return OCFS2_XATTR_BUCKET_SIZE / (1 << sb->s_blocksize_bits);
314 }
315
316 #define bucket_blkno(_b) ((_b)->bu_bhs[0]->b_blocknr)
317 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
318 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
319
320 static struct ocfs2_xattr_bucket *ocfs2_xattr_bucket_new(struct inode *inode)
321 {
322 struct ocfs2_xattr_bucket *bucket;
323 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
324
325 BUG_ON(blks > OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET);
326
327 bucket = kzalloc(sizeof(struct ocfs2_xattr_bucket), GFP_NOFS);
328 if (bucket) {
329 bucket->bu_inode = inode;
330 bucket->bu_blocks = blks;
331 }
332
333 return bucket;
334 }
335
336 static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket *bucket)
337 {
338 int i;
339
340 for (i = 0; i < bucket->bu_blocks; i++) {
341 brelse(bucket->bu_bhs[i]);
342 bucket->bu_bhs[i] = NULL;
343 }
344 }
345
346 static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket *bucket)
347 {
348 if (bucket) {
349 ocfs2_xattr_bucket_relse(bucket);
350 bucket->bu_inode = NULL;
351 kfree(bucket);
352 }
353 }
354
355 /*
356 * A bucket that has never been written to disk doesn't need to be
357 * read. We just need the buffer_heads. Don't call this for
358 * buckets that are already on disk. ocfs2_read_xattr_bucket() initializes
359 * them fully.
360 */
361 static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
362 u64 xb_blkno, int new)
363 {
364 int i, rc = 0;
365
366 for (i = 0; i < bucket->bu_blocks; i++) {
367 bucket->bu_bhs[i] = sb_getblk(bucket->bu_inode->i_sb,
368 xb_blkno + i);
369 if (!bucket->bu_bhs[i]) {
370 rc = -ENOMEM;
371 mlog_errno(rc);
372 break;
373 }
374
375 if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
376 bucket->bu_bhs[i])) {
377 if (new)
378 ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
379 bucket->bu_bhs[i]);
380 else {
381 set_buffer_uptodate(bucket->bu_bhs[i]);
382 ocfs2_set_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
383 bucket->bu_bhs[i]);
384 }
385 }
386 }
387
388 if (rc)
389 ocfs2_xattr_bucket_relse(bucket);
390 return rc;
391 }
392
393 /* Read the xattr bucket at xb_blkno */
394 static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
395 u64 xb_blkno)
396 {
397 int rc;
398
399 rc = ocfs2_read_blocks(INODE_CACHE(bucket->bu_inode), xb_blkno,
400 bucket->bu_blocks, bucket->bu_bhs, 0,
401 NULL);
402 if (!rc) {
403 spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
404 rc = ocfs2_validate_meta_ecc_bhs(bucket->bu_inode->i_sb,
405 bucket->bu_bhs,
406 bucket->bu_blocks,
407 &bucket_xh(bucket)->xh_check);
408 spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
409 if (rc)
410 mlog_errno(rc);
411 }
412
413 if (rc)
414 ocfs2_xattr_bucket_relse(bucket);
415 return rc;
416 }
417
418 static int ocfs2_xattr_bucket_journal_access(handle_t *handle,
419 struct ocfs2_xattr_bucket *bucket,
420 int type)
421 {
422 int i, rc = 0;
423
424 for (i = 0; i < bucket->bu_blocks; i++) {
425 rc = ocfs2_journal_access(handle,
426 INODE_CACHE(bucket->bu_inode),
427 bucket->bu_bhs[i], type);
428 if (rc) {
429 mlog_errno(rc);
430 break;
431 }
432 }
433
434 return rc;
435 }
436
437 static void ocfs2_xattr_bucket_journal_dirty(handle_t *handle,
438 struct ocfs2_xattr_bucket *bucket)
439 {
440 int i;
441
442 spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
443 ocfs2_compute_meta_ecc_bhs(bucket->bu_inode->i_sb,
444 bucket->bu_bhs, bucket->bu_blocks,
445 &bucket_xh(bucket)->xh_check);
446 spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
447
448 for (i = 0; i < bucket->bu_blocks; i++)
449 ocfs2_journal_dirty(handle, bucket->bu_bhs[i]);
450 }
451
452 static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket *dest,
453 struct ocfs2_xattr_bucket *src)
454 {
455 int i;
456 int blocksize = src->bu_inode->i_sb->s_blocksize;
457
458 BUG_ON(dest->bu_blocks != src->bu_blocks);
459 BUG_ON(dest->bu_inode != src->bu_inode);
460
461 for (i = 0; i < src->bu_blocks; i++) {
462 memcpy(bucket_block(dest, i), bucket_block(src, i),
463 blocksize);
464 }
465 }
466
467 static int ocfs2_validate_xattr_block(struct super_block *sb,
468 struct buffer_head *bh)
469 {
470 int rc;
471 struct ocfs2_xattr_block *xb =
472 (struct ocfs2_xattr_block *)bh->b_data;
473
474 trace_ocfs2_validate_xattr_block((unsigned long long)bh->b_blocknr);
475
476 BUG_ON(!buffer_uptodate(bh));
477
478 /*
479 * If the ecc fails, we return the error but otherwise
480 * leave the filesystem running. We know any error is
481 * local to this block.
482 */
483 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &xb->xb_check);
484 if (rc)
485 return rc;
486
487 /*
488 * Errors after here are fatal
489 */
490
491 if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) {
492 return ocfs2_error(sb,
493 "Extended attribute block #%llu has bad signature %.*s\n",
494 (unsigned long long)bh->b_blocknr, 7,
495 xb->xb_signature);
496 }
497
498 if (le64_to_cpu(xb->xb_blkno) != bh->b_blocknr) {
499 return ocfs2_error(sb,
500 "Extended attribute block #%llu has an invalid xb_blkno of %llu\n",
501 (unsigned long long)bh->b_blocknr,
502 (unsigned long long)le64_to_cpu(xb->xb_blkno));
503 }
504
505 if (le32_to_cpu(xb->xb_fs_generation) != OCFS2_SB(sb)->fs_generation) {
506 return ocfs2_error(sb,
507 "Extended attribute block #%llu has an invalid xb_fs_generation of #%u\n",
508 (unsigned long long)bh->b_blocknr,
509 le32_to_cpu(xb->xb_fs_generation));
510 }
511
512 return 0;
513 }
514
515 static int ocfs2_read_xattr_block(struct inode *inode, u64 xb_blkno,
516 struct buffer_head **bh)
517 {
518 int rc;
519 struct buffer_head *tmp = *bh;
520
521 rc = ocfs2_read_block(INODE_CACHE(inode), xb_blkno, &tmp,
522 ocfs2_validate_xattr_block);
523
524 /* If ocfs2_read_block() got us a new bh, pass it up. */
525 if (!rc && !*bh)
526 *bh = tmp;
527
528 return rc;
529 }
530
531 static inline const char *ocfs2_xattr_prefix(int name_index)
532 {
533 const struct xattr_handler *handler = NULL;
534
535 if (name_index > 0 && name_index < OCFS2_XATTR_MAX)
536 handler = ocfs2_xattr_handler_map[name_index];
537 return handler ? xattr_prefix(handler) : NULL;
538 }
539
540 static u32 ocfs2_xattr_name_hash(struct inode *inode,
541 const char *name,
542 int name_len)
543 {
544 /* Get hash value of uuid from super block */
545 u32 hash = OCFS2_SB(inode->i_sb)->uuid_hash;
546 int i;
547
548 /* hash extended attribute name */
549 for (i = 0; i < name_len; i++) {
550 hash = (hash << OCFS2_HASH_SHIFT) ^
551 (hash >> (8*sizeof(hash) - OCFS2_HASH_SHIFT)) ^
552 *name++;
553 }
554
555 return hash;
556 }
557
558 static int ocfs2_xattr_entry_real_size(int name_len, size_t value_len)
559 {
560 return namevalue_size(name_len, value_len) +
561 sizeof(struct ocfs2_xattr_entry);
562 }
563
564 static int ocfs2_xi_entry_usage(struct ocfs2_xattr_info *xi)
565 {
566 return namevalue_size_xi(xi) +
567 sizeof(struct ocfs2_xattr_entry);
568 }
569
570 static int ocfs2_xe_entry_usage(struct ocfs2_xattr_entry *xe)
571 {
572 return namevalue_size_xe(xe) +
573 sizeof(struct ocfs2_xattr_entry);
574 }
575
576 int ocfs2_calc_security_init(struct inode *dir,
577 struct ocfs2_security_xattr_info *si,
578 int *want_clusters,
579 int *xattr_credits,
580 struct ocfs2_alloc_context **xattr_ac)
581 {
582 int ret = 0;
583 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
584 int s_size = ocfs2_xattr_entry_real_size(strlen(si->name),
585 si->value_len);
586
587 /*
588 * The max space of security xattr taken inline is
589 * 256(name) + 80(value) + 16(entry) = 352 bytes,
590 * So reserve one metadata block for it is ok.
591 */
592 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE ||
593 s_size > OCFS2_XATTR_FREE_IN_IBODY) {
594 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, xattr_ac);
595 if (ret) {
596 mlog_errno(ret);
597 return ret;
598 }
599 *xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
600 }
601
602 /* reserve clusters for xattr value which will be set in B tree*/
603 if (si->value_len > OCFS2_XATTR_INLINE_SIZE) {
604 int new_clusters = ocfs2_clusters_for_bytes(dir->i_sb,
605 si->value_len);
606
607 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
608 new_clusters);
609 *want_clusters += new_clusters;
610 }
611 return ret;
612 }
613
614 int ocfs2_calc_xattr_init(struct inode *dir,
615 struct buffer_head *dir_bh,
616 umode_t mode,
617 struct ocfs2_security_xattr_info *si,
618 int *want_clusters,
619 int *xattr_credits,
620 int *want_meta)
621 {
622 int ret = 0;
623 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
624 int s_size = 0, a_size = 0, acl_len = 0, new_clusters;
625
626 if (si->enable)
627 s_size = ocfs2_xattr_entry_real_size(strlen(si->name),
628 si->value_len);
629
630 if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) {
631 down_read(&OCFS2_I(dir)->ip_xattr_sem);
632 acl_len = ocfs2_xattr_get_nolock(dir, dir_bh,
633 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
634 "", NULL, 0);
635 up_read(&OCFS2_I(dir)->ip_xattr_sem);
636 if (acl_len > 0) {
637 a_size = ocfs2_xattr_entry_real_size(0, acl_len);
638 if (S_ISDIR(mode))
639 a_size <<= 1;
640 } else if (acl_len != 0 && acl_len != -ENODATA) {
641 ret = acl_len;
642 mlog_errno(ret);
643 return ret;
644 }
645 }
646
647 if (!(s_size + a_size))
648 return ret;
649
650 /*
651 * The max space of security xattr taken inline is
652 * 256(name) + 80(value) + 16(entry) = 352 bytes,
653 * The max space of acl xattr taken inline is
654 * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
655 * when blocksize = 512, may reserve one more cluser for
656 * xattr bucket, otherwise reserve one metadata block
657 * for them is ok.
658 * If this is a new directory with inline data,
659 * we choose to reserve the entire inline area for
660 * directory contents and force an external xattr block.
661 */
662 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE ||
663 (S_ISDIR(mode) && ocfs2_supports_inline_data(osb)) ||
664 (s_size + a_size) > OCFS2_XATTR_FREE_IN_IBODY) {
665 *want_meta = *want_meta + 1;
666 *xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
667 }
668
669 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE &&
670 (s_size + a_size) > OCFS2_XATTR_FREE_IN_BLOCK(dir)) {
671 *want_clusters += 1;
672 *xattr_credits += ocfs2_blocks_per_xattr_bucket(dir->i_sb);
673 }
674
675 /*
676 * reserve credits and clusters for xattrs which has large value
677 * and have to be set outside
678 */
679 if (si->enable && si->value_len > OCFS2_XATTR_INLINE_SIZE) {
680 new_clusters = ocfs2_clusters_for_bytes(dir->i_sb,
681 si->value_len);
682 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
683 new_clusters);
684 *want_clusters += new_clusters;
685 }
686 if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL &&
687 acl_len > OCFS2_XATTR_INLINE_SIZE) {
688 /* for directory, it has DEFAULT and ACCESS two types of acls */
689 new_clusters = (S_ISDIR(mode) ? 2 : 1) *
690 ocfs2_clusters_for_bytes(dir->i_sb, acl_len);
691 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
692 new_clusters);
693 *want_clusters += new_clusters;
694 }
695
696 return ret;
697 }
698
699 static int ocfs2_xattr_extend_allocation(struct inode *inode,
700 u32 clusters_to_add,
701 struct ocfs2_xattr_value_buf *vb,
702 struct ocfs2_xattr_set_ctxt *ctxt)
703 {
704 int status = 0, credits;
705 handle_t *handle = ctxt->handle;
706 enum ocfs2_alloc_restarted why;
707 u32 prev_clusters, logical_start = le32_to_cpu(vb->vb_xv->xr_clusters);
708 struct ocfs2_extent_tree et;
709
710 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
711
712 while (clusters_to_add) {
713 trace_ocfs2_xattr_extend_allocation(clusters_to_add);
714
715 status = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
716 OCFS2_JOURNAL_ACCESS_WRITE);
717 if (status < 0) {
718 mlog_errno(status);
719 break;
720 }
721
722 prev_clusters = le32_to_cpu(vb->vb_xv->xr_clusters);
723 status = ocfs2_add_clusters_in_btree(handle,
724 &et,
725 &logical_start,
726 clusters_to_add,
727 0,
728 ctxt->data_ac,
729 ctxt->meta_ac,
730 &why);
731 if ((status < 0) && (status != -EAGAIN)) {
732 if (status != -ENOSPC)
733 mlog_errno(status);
734 break;
735 }
736
737 ocfs2_journal_dirty(handle, vb->vb_bh);
738
739 clusters_to_add -= le32_to_cpu(vb->vb_xv->xr_clusters) -
740 prev_clusters;
741
742 if (why != RESTART_NONE && clusters_to_add) {
743 /*
744 * We can only fail in case the alloc file doesn't give
745 * up enough clusters.
746 */
747 BUG_ON(why == RESTART_META);
748
749 credits = ocfs2_calc_extend_credits(inode->i_sb,
750 &vb->vb_xv->xr_list);
751 status = ocfs2_extend_trans(handle, credits);
752 if (status < 0) {
753 status = -ENOMEM;
754 mlog_errno(status);
755 break;
756 }
757 }
758 }
759
760 return status;
761 }
762
763 static int __ocfs2_remove_xattr_range(struct inode *inode,
764 struct ocfs2_xattr_value_buf *vb,
765 u32 cpos, u32 phys_cpos, u32 len,
766 unsigned int ext_flags,
767 struct ocfs2_xattr_set_ctxt *ctxt)
768 {
769 int ret;
770 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
771 handle_t *handle = ctxt->handle;
772 struct ocfs2_extent_tree et;
773
774 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
775
776 ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
777 OCFS2_JOURNAL_ACCESS_WRITE);
778 if (ret) {
779 mlog_errno(ret);
780 goto out;
781 }
782
783 ret = ocfs2_remove_extent(handle, &et, cpos, len, ctxt->meta_ac,
784 &ctxt->dealloc);
785 if (ret) {
786 mlog_errno(ret);
787 goto out;
788 }
789
790 le32_add_cpu(&vb->vb_xv->xr_clusters, -len);
791 ocfs2_journal_dirty(handle, vb->vb_bh);
792
793 if (ext_flags & OCFS2_EXT_REFCOUNTED)
794 ret = ocfs2_decrease_refcount(inode, handle,
795 ocfs2_blocks_to_clusters(inode->i_sb,
796 phys_blkno),
797 len, ctxt->meta_ac, &ctxt->dealloc, 1);
798 else
799 ret = ocfs2_cache_cluster_dealloc(&ctxt->dealloc,
800 phys_blkno, len);
801 if (ret)
802 mlog_errno(ret);
803
804 out:
805 return ret;
806 }
807
808 static int ocfs2_xattr_shrink_size(struct inode *inode,
809 u32 old_clusters,
810 u32 new_clusters,
811 struct ocfs2_xattr_value_buf *vb,
812 struct ocfs2_xattr_set_ctxt *ctxt)
813 {
814 int ret = 0;
815 unsigned int ext_flags;
816 u32 trunc_len, cpos, phys_cpos, alloc_size;
817 u64 block;
818
819 if (old_clusters <= new_clusters)
820 return 0;
821
822 cpos = new_clusters;
823 trunc_len = old_clusters - new_clusters;
824 while (trunc_len) {
825 ret = ocfs2_xattr_get_clusters(inode, cpos, &phys_cpos,
826 &alloc_size,
827 &vb->vb_xv->xr_list, &ext_flags);
828 if (ret) {
829 mlog_errno(ret);
830 goto out;
831 }
832
833 if (alloc_size > trunc_len)
834 alloc_size = trunc_len;
835
836 ret = __ocfs2_remove_xattr_range(inode, vb, cpos,
837 phys_cpos, alloc_size,
838 ext_flags, ctxt);
839 if (ret) {
840 mlog_errno(ret);
841 goto out;
842 }
843
844 block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
845 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode),
846 block, alloc_size);
847 cpos += alloc_size;
848 trunc_len -= alloc_size;
849 }
850
851 out:
852 return ret;
853 }
854
855 static int ocfs2_xattr_value_truncate(struct inode *inode,
856 struct ocfs2_xattr_value_buf *vb,
857 int len,
858 struct ocfs2_xattr_set_ctxt *ctxt)
859 {
860 int ret;
861 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len);
862 u32 old_clusters = le32_to_cpu(vb->vb_xv->xr_clusters);
863
864 if (new_clusters == old_clusters)
865 return 0;
866
867 if (new_clusters > old_clusters)
868 ret = ocfs2_xattr_extend_allocation(inode,
869 new_clusters - old_clusters,
870 vb, ctxt);
871 else
872 ret = ocfs2_xattr_shrink_size(inode,
873 old_clusters, new_clusters,
874 vb, ctxt);
875
876 return ret;
877 }
878
879 static int ocfs2_xattr_list_entry(struct super_block *sb,
880 char *buffer, size_t size,
881 size_t *result, int type,
882 const char *name, int name_len)
883 {
884 char *p = buffer + *result;
885 const char *prefix;
886 int prefix_len;
887 int total_len;
888
889 switch(type) {
890 case OCFS2_XATTR_INDEX_USER:
891 if (OCFS2_SB(sb)->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
892 return 0;
893 break;
894
895 case OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS:
896 case OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT:
897 if (!(sb->s_flags & SB_POSIXACL))
898 return 0;
899 break;
900
901 case OCFS2_XATTR_INDEX_TRUSTED:
902 if (!capable(CAP_SYS_ADMIN))
903 return 0;
904 break;
905 }
906
907 prefix = ocfs2_xattr_prefix(type);
908 if (!prefix)
909 return 0;
910 prefix_len = strlen(prefix);
911 total_len = prefix_len + name_len + 1;
912 *result += total_len;
913
914 /* we are just looking for how big our buffer needs to be */
915 if (!size)
916 return 0;
917
918 if (*result > size)
919 return -ERANGE;
920
921 memcpy(p, prefix, prefix_len);
922 memcpy(p + prefix_len, name, name_len);
923 p[prefix_len + name_len] = '\0';
924
925 return 0;
926 }
927
928 static int ocfs2_xattr_list_entries(struct inode *inode,
929 struct ocfs2_xattr_header *header,
930 char *buffer, size_t buffer_size)
931 {
932 size_t result = 0;
933 int i, type, ret;
934 const char *name;
935
936 for (i = 0 ; i < le16_to_cpu(header->xh_count); i++) {
937 struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
938 type = ocfs2_xattr_get_type(entry);
939 name = (const char *)header +
940 le16_to_cpu(entry->xe_name_offset);
941
942 ret = ocfs2_xattr_list_entry(inode->i_sb,
943 buffer, buffer_size,
944 &result, type, name,
945 entry->xe_name_len);
946 if (ret)
947 return ret;
948 }
949
950 return result;
951 }
952
953 int ocfs2_has_inline_xattr_value_outside(struct inode *inode,
954 struct ocfs2_dinode *di)
955 {
956 struct ocfs2_xattr_header *xh;
957 int i;
958
959 xh = (struct ocfs2_xattr_header *)
960 ((void *)di + inode->i_sb->s_blocksize -
961 le16_to_cpu(di->i_xattr_inline_size));
962
963 for (i = 0; i < le16_to_cpu(xh->xh_count); i++)
964 if (!ocfs2_xattr_is_local(&xh->xh_entries[i]))
965 return 1;
966
967 return 0;
968 }
969
970 static int ocfs2_xattr_ibody_list(struct inode *inode,
971 struct ocfs2_dinode *di,
972 char *buffer,
973 size_t buffer_size)
974 {
975 struct ocfs2_xattr_header *header = NULL;
976 struct ocfs2_inode_info *oi = OCFS2_I(inode);
977 int ret = 0;
978
979 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
980 return ret;
981
982 header = (struct ocfs2_xattr_header *)
983 ((void *)di + inode->i_sb->s_blocksize -
984 le16_to_cpu(di->i_xattr_inline_size));
985
986 ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size);
987
988 return ret;
989 }
990
991 static int ocfs2_xattr_block_list(struct inode *inode,
992 struct ocfs2_dinode *di,
993 char *buffer,
994 size_t buffer_size)
995 {
996 struct buffer_head *blk_bh = NULL;
997 struct ocfs2_xattr_block *xb;
998 int ret = 0;
999
1000 if (!di->i_xattr_loc)
1001 return ret;
1002
1003 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
1004 &blk_bh);
1005 if (ret < 0) {
1006 mlog_errno(ret);
1007 return ret;
1008 }
1009
1010 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
1011 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
1012 struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
1013 ret = ocfs2_xattr_list_entries(inode, header,
1014 buffer, buffer_size);
1015 } else
1016 ret = ocfs2_xattr_tree_list_index_block(inode, blk_bh,
1017 buffer, buffer_size);
1018
1019 brelse(blk_bh);
1020
1021 return ret;
1022 }
1023
1024 ssize_t ocfs2_listxattr(struct dentry *dentry,
1025 char *buffer,
1026 size_t size)
1027 {
1028 int ret = 0, i_ret = 0, b_ret = 0;
1029 struct buffer_head *di_bh = NULL;
1030 struct ocfs2_dinode *di = NULL;
1031 struct ocfs2_inode_info *oi = OCFS2_I(d_inode(dentry));
1032
1033 if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb)))
1034 return -EOPNOTSUPP;
1035
1036 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
1037 return ret;
1038
1039 ret = ocfs2_inode_lock(d_inode(dentry), &di_bh, 0);
1040 if (ret < 0) {
1041 mlog_errno(ret);
1042 return ret;
1043 }
1044
1045 di = (struct ocfs2_dinode *)di_bh->b_data;
1046
1047 down_read(&oi->ip_xattr_sem);
1048 i_ret = ocfs2_xattr_ibody_list(d_inode(dentry), di, buffer, size);
1049 if (i_ret < 0)
1050 b_ret = 0;
1051 else {
1052 if (buffer) {
1053 buffer += i_ret;
1054 size -= i_ret;
1055 }
1056 b_ret = ocfs2_xattr_block_list(d_inode(dentry), di,
1057 buffer, size);
1058 if (b_ret < 0)
1059 i_ret = 0;
1060 }
1061 up_read(&oi->ip_xattr_sem);
1062 ocfs2_inode_unlock(d_inode(dentry), 0);
1063
1064 brelse(di_bh);
1065
1066 return i_ret + b_ret;
1067 }
1068
1069 static int ocfs2_xattr_find_entry(int name_index,
1070 const char *name,
1071 struct ocfs2_xattr_search *xs)
1072 {
1073 struct ocfs2_xattr_entry *entry;
1074 size_t name_len;
1075 int i, cmp = 1;
1076
1077 if (name == NULL)
1078 return -EINVAL;
1079
1080 name_len = strlen(name);
1081 entry = xs->here;
1082 for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
1083 cmp = name_index - ocfs2_xattr_get_type(entry);
1084 if (!cmp)
1085 cmp = name_len - entry->xe_name_len;
1086 if (!cmp)
1087 cmp = memcmp(name, (xs->base +
1088 le16_to_cpu(entry->xe_name_offset)),
1089 name_len);
1090 if (cmp == 0)
1091 break;
1092 entry += 1;
1093 }
1094 xs->here = entry;
1095
1096 return cmp ? -ENODATA : 0;
1097 }
1098
1099 static int ocfs2_xattr_get_value_outside(struct inode *inode,
1100 struct ocfs2_xattr_value_root *xv,
1101 void *buffer,
1102 size_t len)
1103 {
1104 u32 cpos, p_cluster, num_clusters, bpc, clusters;
1105 u64 blkno;
1106 int i, ret = 0;
1107 size_t cplen, blocksize;
1108 struct buffer_head *bh = NULL;
1109 struct ocfs2_extent_list *el;
1110
1111 el = &xv->xr_list;
1112 clusters = le32_to_cpu(xv->xr_clusters);
1113 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
1114 blocksize = inode->i_sb->s_blocksize;
1115
1116 cpos = 0;
1117 while (cpos < clusters) {
1118 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
1119 &num_clusters, el, NULL);
1120 if (ret) {
1121 mlog_errno(ret);
1122 goto out;
1123 }
1124
1125 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
1126 /* Copy ocfs2_xattr_value */
1127 for (i = 0; i < num_clusters * bpc; i++, blkno++) {
1128 ret = ocfs2_read_block(INODE_CACHE(inode), blkno,
1129 &bh, NULL);
1130 if (ret) {
1131 mlog_errno(ret);
1132 goto out;
1133 }
1134
1135 cplen = len >= blocksize ? blocksize : len;
1136 memcpy(buffer, bh->b_data, cplen);
1137 len -= cplen;
1138 buffer += cplen;
1139
1140 brelse(bh);
1141 bh = NULL;
1142 if (len == 0)
1143 break;
1144 }
1145 cpos += num_clusters;
1146 }
1147 out:
1148 return ret;
1149 }
1150
1151 static int ocfs2_xattr_ibody_get(struct inode *inode,
1152 int name_index,
1153 const char *name,
1154 void *buffer,
1155 size_t buffer_size,
1156 struct ocfs2_xattr_search *xs)
1157 {
1158 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1159 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
1160 struct ocfs2_xattr_value_root *xv;
1161 size_t size;
1162 int ret = 0;
1163
1164 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
1165 return -ENODATA;
1166
1167 xs->end = (void *)di + inode->i_sb->s_blocksize;
1168 xs->header = (struct ocfs2_xattr_header *)
1169 (xs->end - le16_to_cpu(di->i_xattr_inline_size));
1170 xs->base = (void *)xs->header;
1171 xs->here = xs->header->xh_entries;
1172
1173 ret = ocfs2_xattr_find_entry(name_index, name, xs);
1174 if (ret)
1175 return ret;
1176 size = le64_to_cpu(xs->here->xe_value_size);
1177 if (buffer) {
1178 if (size > buffer_size)
1179 return -ERANGE;
1180 if (ocfs2_xattr_is_local(xs->here)) {
1181 memcpy(buffer, (void *)xs->base +
1182 le16_to_cpu(xs->here->xe_name_offset) +
1183 OCFS2_XATTR_SIZE(xs->here->xe_name_len), size);
1184 } else {
1185 xv = (struct ocfs2_xattr_value_root *)
1186 (xs->base + le16_to_cpu(
1187 xs->here->xe_name_offset) +
1188 OCFS2_XATTR_SIZE(xs->here->xe_name_len));
1189 ret = ocfs2_xattr_get_value_outside(inode, xv,
1190 buffer, size);
1191 if (ret < 0) {
1192 mlog_errno(ret);
1193 return ret;
1194 }
1195 }
1196 }
1197
1198 return size;
1199 }
1200
1201 static int ocfs2_xattr_block_get(struct inode *inode,
1202 int name_index,
1203 const char *name,
1204 void *buffer,
1205 size_t buffer_size,
1206 struct ocfs2_xattr_search *xs)
1207 {
1208 struct ocfs2_xattr_block *xb;
1209 struct ocfs2_xattr_value_root *xv;
1210 size_t size;
1211 int ret = -ENODATA, name_offset, name_len, i;
1212 int block_off;
1213
1214 xs->bucket = ocfs2_xattr_bucket_new(inode);
1215 if (!xs->bucket) {
1216 ret = -ENOMEM;
1217 mlog_errno(ret);
1218 goto cleanup;
1219 }
1220
1221 ret = ocfs2_xattr_block_find(inode, name_index, name, xs);
1222 if (ret) {
1223 mlog_errno(ret);
1224 goto cleanup;
1225 }
1226
1227 if (xs->not_found) {
1228 ret = -ENODATA;
1229 goto cleanup;
1230 }
1231
1232 xb = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
1233 size = le64_to_cpu(xs->here->xe_value_size);
1234 if (buffer) {
1235 ret = -ERANGE;
1236 if (size > buffer_size)
1237 goto cleanup;
1238
1239 name_offset = le16_to_cpu(xs->here->xe_name_offset);
1240 name_len = OCFS2_XATTR_SIZE(xs->here->xe_name_len);
1241 i = xs->here - xs->header->xh_entries;
1242
1243 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
1244 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
1245 bucket_xh(xs->bucket),
1246 i,
1247 &block_off,
1248 &name_offset);
1249 if (ret) {
1250 mlog_errno(ret);
1251 goto cleanup;
1252 }
1253 xs->base = bucket_block(xs->bucket, block_off);
1254 }
1255 if (ocfs2_xattr_is_local(xs->here)) {
1256 memcpy(buffer, (void *)xs->base +
1257 name_offset + name_len, size);
1258 } else {
1259 xv = (struct ocfs2_xattr_value_root *)
1260 (xs->base + name_offset + name_len);
1261 ret = ocfs2_xattr_get_value_outside(inode, xv,
1262 buffer, size);
1263 if (ret < 0) {
1264 mlog_errno(ret);
1265 goto cleanup;
1266 }
1267 }
1268 }
1269 ret = size;
1270 cleanup:
1271 ocfs2_xattr_bucket_free(xs->bucket);
1272
1273 brelse(xs->xattr_bh);
1274 xs->xattr_bh = NULL;
1275 return ret;
1276 }
1277
1278 int ocfs2_xattr_get_nolock(struct inode *inode,
1279 struct buffer_head *di_bh,
1280 int name_index,
1281 const char *name,
1282 void *buffer,
1283 size_t buffer_size)
1284 {
1285 int ret;
1286 struct ocfs2_dinode *di = NULL;
1287 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1288 struct ocfs2_xattr_search xis = {
1289 .not_found = -ENODATA,
1290 };
1291 struct ocfs2_xattr_search xbs = {
1292 .not_found = -ENODATA,
1293 };
1294
1295 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
1296 return -EOPNOTSUPP;
1297
1298 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
1299 return -ENODATA;
1300
1301 xis.inode_bh = xbs.inode_bh = di_bh;
1302 di = (struct ocfs2_dinode *)di_bh->b_data;
1303
1304 ret = ocfs2_xattr_ibody_get(inode, name_index, name, buffer,
1305 buffer_size, &xis);
1306 if (ret == -ENODATA && di->i_xattr_loc)
1307 ret = ocfs2_xattr_block_get(inode, name_index, name, buffer,
1308 buffer_size, &xbs);
1309
1310 return ret;
1311 }
1312
1313 /* ocfs2_xattr_get()
1314 *
1315 * Copy an extended attribute into the buffer provided.
1316 * Buffer is NULL to compute the size of buffer required.
1317 */
1318 static int ocfs2_xattr_get(struct inode *inode,
1319 int name_index,
1320 const char *name,
1321 void *buffer,
1322 size_t buffer_size)
1323 {
1324 int ret, had_lock;
1325 struct buffer_head *di_bh = NULL;
1326 struct ocfs2_lock_holder oh;
1327
1328 had_lock = ocfs2_inode_lock_tracker(inode, &di_bh, 0, &oh);
1329 if (had_lock < 0) {
1330 mlog_errno(had_lock);
1331 return had_lock;
1332 }
1333 down_read(&OCFS2_I(inode)->ip_xattr_sem);
1334 ret = ocfs2_xattr_get_nolock(inode, di_bh, name_index,
1335 name, buffer, buffer_size);
1336 up_read(&OCFS2_I(inode)->ip_xattr_sem);
1337
1338 ocfs2_inode_unlock_tracker(inode, 0, &oh, had_lock);
1339
1340 brelse(di_bh);
1341
1342 return ret;
1343 }
1344
1345 static int __ocfs2_xattr_set_value_outside(struct inode *inode,
1346 handle_t *handle,
1347 struct ocfs2_xattr_value_buf *vb,
1348 const void *value,
1349 int value_len)
1350 {
1351 int ret = 0, i, cp_len;
1352 u16 blocksize = inode->i_sb->s_blocksize;
1353 u32 p_cluster, num_clusters;
1354 u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
1355 u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len);
1356 u64 blkno;
1357 struct buffer_head *bh = NULL;
1358 unsigned int ext_flags;
1359 struct ocfs2_xattr_value_root *xv = vb->vb_xv;
1360
1361 BUG_ON(clusters > le32_to_cpu(xv->xr_clusters));
1362
1363 while (cpos < clusters) {
1364 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
1365 &num_clusters, &xv->xr_list,
1366 &ext_flags);
1367 if (ret) {
1368 mlog_errno(ret);
1369 goto out;
1370 }
1371
1372 BUG_ON(ext_flags & OCFS2_EXT_REFCOUNTED);
1373
1374 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
1375
1376 for (i = 0; i < num_clusters * bpc; i++, blkno++) {
1377 ret = ocfs2_read_block(INODE_CACHE(inode), blkno,
1378 &bh, NULL);
1379 if (ret) {
1380 mlog_errno(ret);
1381 goto out;
1382 }
1383
1384 ret = ocfs2_journal_access(handle,
1385 INODE_CACHE(inode),
1386 bh,
1387 OCFS2_JOURNAL_ACCESS_WRITE);
1388 if (ret < 0) {
1389 mlog_errno(ret);
1390 goto out;
1391 }
1392
1393 cp_len = value_len > blocksize ? blocksize : value_len;
1394 memcpy(bh->b_data, value, cp_len);
1395 value_len -= cp_len;
1396 value += cp_len;
1397 if (cp_len < blocksize)
1398 memset(bh->b_data + cp_len, 0,
1399 blocksize - cp_len);
1400
1401 ocfs2_journal_dirty(handle, bh);
1402 brelse(bh);
1403 bh = NULL;
1404
1405 /*
1406 * XXX: do we need to empty all the following
1407 * blocks in this cluster?
1408 */
1409 if (!value_len)
1410 break;
1411 }
1412 cpos += num_clusters;
1413 }
1414 out:
1415 brelse(bh);
1416
1417 return ret;
1418 }
1419
1420 static int ocfs2_xa_check_space_helper(int needed_space, int free_start,
1421 int num_entries)
1422 {
1423 int free_space;
1424
1425 if (!needed_space)
1426 return 0;
1427
1428 free_space = free_start -
1429 sizeof(struct ocfs2_xattr_header) -
1430 (num_entries * sizeof(struct ocfs2_xattr_entry)) -
1431 OCFS2_XATTR_HEADER_GAP;
1432 if (free_space < 0)
1433 return -EIO;
1434 if (free_space < needed_space)
1435 return -ENOSPC;
1436
1437 return 0;
1438 }
1439
1440 static int ocfs2_xa_journal_access(handle_t *handle, struct ocfs2_xa_loc *loc,
1441 int type)
1442 {
1443 return loc->xl_ops->xlo_journal_access(handle, loc, type);
1444 }
1445
1446 static void ocfs2_xa_journal_dirty(handle_t *handle, struct ocfs2_xa_loc *loc)
1447 {
1448 loc->xl_ops->xlo_journal_dirty(handle, loc);
1449 }
1450
1451 /* Give a pointer into the storage for the given offset */
1452 static void *ocfs2_xa_offset_pointer(struct ocfs2_xa_loc *loc, int offset)
1453 {
1454 BUG_ON(offset >= loc->xl_size);
1455 return loc->xl_ops->xlo_offset_pointer(loc, offset);
1456 }
1457
1458 /*
1459 * Wipe the name+value pair and allow the storage to reclaim it. This
1460 * must be followed by either removal of the entry or a call to
1461 * ocfs2_xa_add_namevalue().
1462 */
1463 static void ocfs2_xa_wipe_namevalue(struct ocfs2_xa_loc *loc)
1464 {
1465 loc->xl_ops->xlo_wipe_namevalue(loc);
1466 }
1467
1468 /*
1469 * Find lowest offset to a name+value pair. This is the start of our
1470 * downward-growing free space.
1471 */
1472 static int ocfs2_xa_get_free_start(struct ocfs2_xa_loc *loc)
1473 {
1474 return loc->xl_ops->xlo_get_free_start(loc);
1475 }
1476
1477 /* Can we reuse loc->xl_entry for xi? */
1478 static int ocfs2_xa_can_reuse_entry(struct ocfs2_xa_loc *loc,
1479 struct ocfs2_xattr_info *xi)
1480 {
1481 return loc->xl_ops->xlo_can_reuse(loc, xi);
1482 }
1483
1484 /* How much free space is needed to set the new value */
1485 static int ocfs2_xa_check_space(struct ocfs2_xa_loc *loc,
1486 struct ocfs2_xattr_info *xi)
1487 {
1488 return loc->xl_ops->xlo_check_space(loc, xi);
1489 }
1490
1491 static void ocfs2_xa_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash)
1492 {
1493 loc->xl_ops->xlo_add_entry(loc, name_hash);
1494 loc->xl_entry->xe_name_hash = cpu_to_le32(name_hash);
1495 /*
1496 * We can't leave the new entry's xe_name_offset at zero or
1497 * add_namevalue() will go nuts. We set it to the size of our
1498 * storage so that it can never be less than any other entry.
1499 */
1500 loc->xl_entry->xe_name_offset = cpu_to_le16(loc->xl_size);
1501 }
1502
1503 static void ocfs2_xa_add_namevalue(struct ocfs2_xa_loc *loc,
1504 struct ocfs2_xattr_info *xi)
1505 {
1506 int size = namevalue_size_xi(xi);
1507 int nameval_offset;
1508 char *nameval_buf;
1509
1510 loc->xl_ops->xlo_add_namevalue(loc, size);
1511 loc->xl_entry->xe_value_size = cpu_to_le64(xi->xi_value_len);
1512 loc->xl_entry->xe_name_len = xi->xi_name_len;
1513 ocfs2_xattr_set_type(loc->xl_entry, xi->xi_name_index);
1514 ocfs2_xattr_set_local(loc->xl_entry,
1515 xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE);
1516
1517 nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset);
1518 nameval_buf = ocfs2_xa_offset_pointer(loc, nameval_offset);
1519 memset(nameval_buf, 0, size);
1520 memcpy(nameval_buf, xi->xi_name, xi->xi_name_len);
1521 }
1522
1523 static void ocfs2_xa_fill_value_buf(struct ocfs2_xa_loc *loc,
1524 struct ocfs2_xattr_value_buf *vb)
1525 {
1526 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset);
1527 int name_size = OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len);
1528
1529 /* Value bufs are for value trees */
1530 BUG_ON(ocfs2_xattr_is_local(loc->xl_entry));
1531 BUG_ON(namevalue_size_xe(loc->xl_entry) !=
1532 (name_size + OCFS2_XATTR_ROOT_SIZE));
1533
1534 loc->xl_ops->xlo_fill_value_buf(loc, vb);
1535 vb->vb_xv =
1536 (struct ocfs2_xattr_value_root *)ocfs2_xa_offset_pointer(loc,
1537 nameval_offset +
1538 name_size);
1539 }
1540
1541 static int ocfs2_xa_block_journal_access(handle_t *handle,
1542 struct ocfs2_xa_loc *loc, int type)
1543 {
1544 struct buffer_head *bh = loc->xl_storage;
1545 ocfs2_journal_access_func access;
1546
1547 if (loc->xl_size == (bh->b_size -
1548 offsetof(struct ocfs2_xattr_block,
1549 xb_attrs.xb_header)))
1550 access = ocfs2_journal_access_xb;
1551 else
1552 access = ocfs2_journal_access_di;
1553 return access(handle, INODE_CACHE(loc->xl_inode), bh, type);
1554 }
1555
1556 static void ocfs2_xa_block_journal_dirty(handle_t *handle,
1557 struct ocfs2_xa_loc *loc)
1558 {
1559 struct buffer_head *bh = loc->xl_storage;
1560
1561 ocfs2_journal_dirty(handle, bh);
1562 }
1563
1564 static void *ocfs2_xa_block_offset_pointer(struct ocfs2_xa_loc *loc,
1565 int offset)
1566 {
1567 return (char *)loc->xl_header + offset;
1568 }
1569
1570 static int ocfs2_xa_block_can_reuse(struct ocfs2_xa_loc *loc,
1571 struct ocfs2_xattr_info *xi)
1572 {
1573 /*
1574 * Block storage is strict. If the sizes aren't exact, we will
1575 * remove the old one and reinsert the new.
1576 */
1577 return namevalue_size_xe(loc->xl_entry) ==
1578 namevalue_size_xi(xi);
1579 }
1580
1581 static int ocfs2_xa_block_get_free_start(struct ocfs2_xa_loc *loc)
1582 {
1583 struct ocfs2_xattr_header *xh = loc->xl_header;
1584 int i, count = le16_to_cpu(xh->xh_count);
1585 int offset, free_start = loc->xl_size;
1586
1587 for (i = 0; i < count; i++) {
1588 offset = le16_to_cpu(xh->xh_entries[i].xe_name_offset);
1589 if (offset < free_start)
1590 free_start = offset;
1591 }
1592
1593 return free_start;
1594 }
1595
1596 static int ocfs2_xa_block_check_space(struct ocfs2_xa_loc *loc,
1597 struct ocfs2_xattr_info *xi)
1598 {
1599 int count = le16_to_cpu(loc->xl_header->xh_count);
1600 int free_start = ocfs2_xa_get_free_start(loc);
1601 int needed_space = ocfs2_xi_entry_usage(xi);
1602
1603 /*
1604 * Block storage will reclaim the original entry before inserting
1605 * the new value, so we only need the difference. If the new
1606 * entry is smaller than the old one, we don't need anything.
1607 */
1608 if (loc->xl_entry) {
1609 /* Don't need space if we're reusing! */
1610 if (ocfs2_xa_can_reuse_entry(loc, xi))
1611 needed_space = 0;
1612 else
1613 needed_space -= ocfs2_xe_entry_usage(loc->xl_entry);
1614 }
1615 if (needed_space < 0)
1616 needed_space = 0;
1617 return ocfs2_xa_check_space_helper(needed_space, free_start, count);
1618 }
1619
1620 /*
1621 * Block storage for xattrs keeps the name+value pairs compacted. When
1622 * we remove one, we have to shift any that preceded it towards the end.
1623 */
1624 static void ocfs2_xa_block_wipe_namevalue(struct ocfs2_xa_loc *loc)
1625 {
1626 int i, offset;
1627 int namevalue_offset, first_namevalue_offset, namevalue_size;
1628 struct ocfs2_xattr_entry *entry = loc->xl_entry;
1629 struct ocfs2_xattr_header *xh = loc->xl_header;
1630 int count = le16_to_cpu(xh->xh_count);
1631
1632 namevalue_offset = le16_to_cpu(entry->xe_name_offset);
1633 namevalue_size = namevalue_size_xe(entry);
1634 first_namevalue_offset = ocfs2_xa_get_free_start(loc);
1635
1636 /* Shift the name+value pairs */
1637 memmove((char *)xh + first_namevalue_offset + namevalue_size,
1638 (char *)xh + first_namevalue_offset,
1639 namevalue_offset - first_namevalue_offset);
1640 memset((char *)xh + first_namevalue_offset, 0, namevalue_size);
1641
1642 /* Now tell xh->xh_entries about it */
1643 for (i = 0; i < count; i++) {
1644 offset = le16_to_cpu(xh->xh_entries[i].xe_name_offset);
1645 if (offset <= namevalue_offset)
1646 le16_add_cpu(&xh->xh_entries[i].xe_name_offset,
1647 namevalue_size);
1648 }
1649
1650 /*
1651 * Note that we don't update xh_free_start or xh_name_value_len
1652 * because they're not used in block-stored xattrs.
1653 */
1654 }
1655
1656 static void ocfs2_xa_block_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash)
1657 {
1658 int count = le16_to_cpu(loc->xl_header->xh_count);
1659 loc->xl_entry = &(loc->xl_header->xh_entries[count]);
1660 le16_add_cpu(&loc->xl_header->xh_count, 1);
1661 memset(loc->xl_entry, 0, sizeof(struct ocfs2_xattr_entry));
1662 }
1663
1664 static void ocfs2_xa_block_add_namevalue(struct ocfs2_xa_loc *loc, int size)
1665 {
1666 int free_start = ocfs2_xa_get_free_start(loc);
1667
1668 loc->xl_entry->xe_name_offset = cpu_to_le16(free_start - size);
1669 }
1670
1671 static void ocfs2_xa_block_fill_value_buf(struct ocfs2_xa_loc *loc,
1672 struct ocfs2_xattr_value_buf *vb)
1673 {
1674 struct buffer_head *bh = loc->xl_storage;
1675
1676 if (loc->xl_size == (bh->b_size -
1677 offsetof(struct ocfs2_xattr_block,
1678 xb_attrs.xb_header)))
1679 vb->vb_access = ocfs2_journal_access_xb;
1680 else
1681 vb->vb_access = ocfs2_journal_access_di;
1682 vb->vb_bh = bh;
1683 }
1684
1685 /*
1686 * Operations for xattrs stored in blocks. This includes inline inode
1687 * storage and unindexed ocfs2_xattr_blocks.
1688 */
1689 static const struct ocfs2_xa_loc_operations ocfs2_xa_block_loc_ops = {
1690 .xlo_journal_access = ocfs2_xa_block_journal_access,
1691 .xlo_journal_dirty = ocfs2_xa_block_journal_dirty,
1692 .xlo_offset_pointer = ocfs2_xa_block_offset_pointer,
1693 .xlo_check_space = ocfs2_xa_block_check_space,
1694 .xlo_can_reuse = ocfs2_xa_block_can_reuse,
1695 .xlo_get_free_start = ocfs2_xa_block_get_free_start,
1696 .xlo_wipe_namevalue = ocfs2_xa_block_wipe_namevalue,
1697 .xlo_add_entry = ocfs2_xa_block_add_entry,
1698 .xlo_add_namevalue = ocfs2_xa_block_add_namevalue,
1699 .xlo_fill_value_buf = ocfs2_xa_block_fill_value_buf,
1700 };
1701
1702 static int ocfs2_xa_bucket_journal_access(handle_t *handle,
1703 struct ocfs2_xa_loc *loc, int type)
1704 {
1705 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1706
1707 return ocfs2_xattr_bucket_journal_access(handle, bucket, type);
1708 }
1709
1710 static void ocfs2_xa_bucket_journal_dirty(handle_t *handle,
1711 struct ocfs2_xa_loc *loc)
1712 {
1713 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1714
1715 ocfs2_xattr_bucket_journal_dirty(handle, bucket);
1716 }
1717
1718 static void *ocfs2_xa_bucket_offset_pointer(struct ocfs2_xa_loc *loc,
1719 int offset)
1720 {
1721 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1722 int block, block_offset;
1723
1724 /* The header is at the front of the bucket */
1725 block = offset >> loc->xl_inode->i_sb->s_blocksize_bits;
1726 block_offset = offset % loc->xl_inode->i_sb->s_blocksize;
1727
1728 return bucket_block(bucket, block) + block_offset;
1729 }
1730
1731 static int ocfs2_xa_bucket_can_reuse(struct ocfs2_xa_loc *loc,
1732 struct ocfs2_xattr_info *xi)
1733 {
1734 return namevalue_size_xe(loc->xl_entry) >=
1735 namevalue_size_xi(xi);
1736 }
1737
1738 static int ocfs2_xa_bucket_get_free_start(struct ocfs2_xa_loc *loc)
1739 {
1740 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1741 return le16_to_cpu(bucket_xh(bucket)->xh_free_start);
1742 }
1743
1744 static int ocfs2_bucket_align_free_start(struct super_block *sb,
1745 int free_start, int size)
1746 {
1747 /*
1748 * We need to make sure that the name+value pair fits within
1749 * one block.
1750 */
1751 if (((free_start - size) >> sb->s_blocksize_bits) !=
1752 ((free_start - 1) >> sb->s_blocksize_bits))
1753 free_start -= free_start % sb->s_blocksize;
1754
1755 return free_start;
1756 }
1757
1758 static int ocfs2_xa_bucket_check_space(struct ocfs2_xa_loc *loc,
1759 struct ocfs2_xattr_info *xi)
1760 {
1761 int rc;
1762 int count = le16_to_cpu(loc->xl_header->xh_count);
1763 int free_start = ocfs2_xa_get_free_start(loc);
1764 int needed_space = ocfs2_xi_entry_usage(xi);
1765 int size = namevalue_size_xi(xi);
1766 struct super_block *sb = loc->xl_inode->i_sb;
1767
1768 /*
1769 * Bucket storage does not reclaim name+value pairs it cannot
1770 * reuse. They live as holes until the bucket fills, and then
1771 * the bucket is defragmented. However, the bucket can reclaim
1772 * the ocfs2_xattr_entry.
1773 */
1774 if (loc->xl_entry) {
1775 /* Don't need space if we're reusing! */
1776 if (ocfs2_xa_can_reuse_entry(loc, xi))
1777 needed_space = 0;
1778 else
1779 needed_space -= sizeof(struct ocfs2_xattr_entry);
1780 }
1781 BUG_ON(needed_space < 0);
1782
1783 if (free_start < size) {
1784 if (needed_space)
1785 return -ENOSPC;
1786 } else {
1787 /*
1788 * First we check if it would fit in the first place.
1789 * Below, we align the free start to a block. This may
1790 * slide us below the minimum gap. By checking unaligned
1791 * first, we avoid that error.
1792 */
1793 rc = ocfs2_xa_check_space_helper(needed_space, free_start,
1794 count);
1795 if (rc)
1796 return rc;
1797 free_start = ocfs2_bucket_align_free_start(sb, free_start,
1798 size);
1799 }
1800 return ocfs2_xa_check_space_helper(needed_space, free_start, count);
1801 }
1802
1803 static void ocfs2_xa_bucket_wipe_namevalue(struct ocfs2_xa_loc *loc)
1804 {
1805 le16_add_cpu(&loc->xl_header->xh_name_value_len,
1806 -namevalue_size_xe(loc->xl_entry));
1807 }
1808
1809 static void ocfs2_xa_bucket_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash)
1810 {
1811 struct ocfs2_xattr_header *xh = loc->xl_header;
1812 int count = le16_to_cpu(xh->xh_count);
1813 int low = 0, high = count - 1, tmp;
1814 struct ocfs2_xattr_entry *tmp_xe;
1815
1816 /*
1817 * We keep buckets sorted by name_hash, so we need to find
1818 * our insert place.
1819 */
1820 while (low <= high && count) {
1821 tmp = (low + high) / 2;
1822 tmp_xe = &xh->xh_entries[tmp];
1823
1824 if (name_hash > le32_to_cpu(tmp_xe->xe_name_hash))
1825 low = tmp + 1;
1826 else if (name_hash < le32_to_cpu(tmp_xe->xe_name_hash))
1827 high = tmp - 1;
1828 else {
1829 low = tmp;
1830 break;
1831 }
1832 }
1833
1834 if (low != count)
1835 memmove(&xh->xh_entries[low + 1],
1836 &xh->xh_entries[low],
1837 ((count - low) * sizeof(struct ocfs2_xattr_entry)));
1838
1839 le16_add_cpu(&xh->xh_count, 1);
1840 loc->xl_entry = &xh->xh_entries[low];
1841 memset(loc->xl_entry, 0, sizeof(struct ocfs2_xattr_entry));
1842 }
1843
1844 static void ocfs2_xa_bucket_add_namevalue(struct ocfs2_xa_loc *loc, int size)
1845 {
1846 int free_start = ocfs2_xa_get_free_start(loc);
1847 struct ocfs2_xattr_header *xh = loc->xl_header;
1848 struct super_block *sb = loc->xl_inode->i_sb;
1849 int nameval_offset;
1850
1851 free_start = ocfs2_bucket_align_free_start(sb, free_start, size);
1852 nameval_offset = free_start - size;
1853 loc->xl_entry->xe_name_offset = cpu_to_le16(nameval_offset);
1854 xh->xh_free_start = cpu_to_le16(nameval_offset);
1855 le16_add_cpu(&xh->xh_name_value_len, size);
1856
1857 }
1858
1859 static void ocfs2_xa_bucket_fill_value_buf(struct ocfs2_xa_loc *loc,
1860 struct ocfs2_xattr_value_buf *vb)
1861 {
1862 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1863 struct super_block *sb = loc->xl_inode->i_sb;
1864 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset);
1865 int size = namevalue_size_xe(loc->xl_entry);
1866 int block_offset = nameval_offset >> sb->s_blocksize_bits;
1867
1868 /* Values are not allowed to straddle block boundaries */
1869 BUG_ON(block_offset !=
1870 ((nameval_offset + size - 1) >> sb->s_blocksize_bits));
1871 /* We expect the bucket to be filled in */
1872 BUG_ON(!bucket->bu_bhs[block_offset]);
1873
1874 vb->vb_access = ocfs2_journal_access;
1875 vb->vb_bh = bucket->bu_bhs[block_offset];
1876 }
1877
1878 /* Operations for xattrs stored in buckets. */
1879 static const struct ocfs2_xa_loc_operations ocfs2_xa_bucket_loc_ops = {
1880 .xlo_journal_access = ocfs2_xa_bucket_journal_access,
1881 .xlo_journal_dirty = ocfs2_xa_bucket_journal_dirty,
1882 .xlo_offset_pointer = ocfs2_xa_bucket_offset_pointer,
1883 .xlo_check_space = ocfs2_xa_bucket_check_space,
1884 .xlo_can_reuse = ocfs2_xa_bucket_can_reuse,
1885 .xlo_get_free_start = ocfs2_xa_bucket_get_free_start,
1886 .xlo_wipe_namevalue = ocfs2_xa_bucket_wipe_namevalue,
1887 .xlo_add_entry = ocfs2_xa_bucket_add_entry,
1888 .xlo_add_namevalue = ocfs2_xa_bucket_add_namevalue,
1889 .xlo_fill_value_buf = ocfs2_xa_bucket_fill_value_buf,
1890 };
1891
1892 static unsigned int ocfs2_xa_value_clusters(struct ocfs2_xa_loc *loc)
1893 {
1894 struct ocfs2_xattr_value_buf vb;
1895
1896 if (ocfs2_xattr_is_local(loc->xl_entry))
1897 return 0;
1898
1899 ocfs2_xa_fill_value_buf(loc, &vb);
1900 return le32_to_cpu(vb.vb_xv->xr_clusters);
1901 }
1902
1903 static int ocfs2_xa_value_truncate(struct ocfs2_xa_loc *loc, u64 bytes,
1904 struct ocfs2_xattr_set_ctxt *ctxt)
1905 {
1906 int trunc_rc, access_rc;
1907 struct ocfs2_xattr_value_buf vb;
1908
1909 ocfs2_xa_fill_value_buf(loc, &vb);
1910 trunc_rc = ocfs2_xattr_value_truncate(loc->xl_inode, &vb, bytes,
1911 ctxt);
1912
1913 /*
1914 * The caller of ocfs2_xa_value_truncate() has already called
1915 * ocfs2_xa_journal_access on the loc. However, The truncate code
1916 * calls ocfs2_extend_trans(). This may commit the previous
1917 * transaction and open a new one. If this is a bucket, truncate
1918 * could leave only vb->vb_bh set up for journaling. Meanwhile,
1919 * the caller is expecting to dirty the entire bucket. So we must
1920 * reset the journal work. We do this even if truncate has failed,
1921 * as it could have failed after committing the extend.
1922 */
1923 access_rc = ocfs2_xa_journal_access(ctxt->handle, loc,
1924 OCFS2_JOURNAL_ACCESS_WRITE);
1925
1926 /* Errors in truncate take precedence */
1927 return trunc_rc ? trunc_rc : access_rc;
1928 }
1929
1930 static void ocfs2_xa_remove_entry(struct ocfs2_xa_loc *loc)
1931 {
1932 int index, count;
1933 struct ocfs2_xattr_header *xh = loc->xl_header;
1934 struct ocfs2_xattr_entry *entry = loc->xl_entry;
1935
1936 ocfs2_xa_wipe_namevalue(loc);
1937 loc->xl_entry = NULL;
1938
1939 le16_add_cpu(&xh->xh_count, -1);
1940 count = le16_to_cpu(xh->xh_count);
1941
1942 /*
1943 * Only zero out the entry if there are more remaining. This is
1944 * important for an empty bucket, as it keeps track of the
1945 * bucket's hash value. It doesn't hurt empty block storage.
1946 */
1947 if (count) {
1948 index = ((char *)entry - (char *)&xh->xh_entries) /
1949 sizeof(struct ocfs2_xattr_entry);
1950 memmove(&xh->xh_entries[index], &xh->xh_entries[index + 1],
1951 (count - index) * sizeof(struct ocfs2_xattr_entry));
1952 memset(&xh->xh_entries[count], 0,
1953 sizeof(struct ocfs2_xattr_entry));
1954 }
1955 }
1956
1957 /*
1958 * If we have a problem adjusting the size of an external value during
1959 * ocfs2_xa_prepare_entry() or ocfs2_xa_remove(), we may have an xattr
1960 * in an intermediate state. For example, the value may be partially
1961 * truncated.
1962 *
1963 * If the value tree hasn't changed, the extend/truncate went nowhere.
1964 * We have nothing to do. The caller can treat it as a straight error.
1965 *
1966 * If the value tree got partially truncated, we now have a corrupted
1967 * extended attribute. We're going to wipe its entry and leak the
1968 * clusters. Better to leak some storage than leave a corrupt entry.
1969 *
1970 * If the value tree grew, it obviously didn't grow enough for the
1971 * new entry. We're not going to try and reclaim those clusters either.
1972 * If there was already an external value there (orig_clusters != 0),
1973 * the new clusters are attached safely and we can just leave the old
1974 * value in place. If there was no external value there, we remove
1975 * the entry.
1976 *
1977 * This way, the xattr block we store in the journal will be consistent.
1978 * If the size change broke because of the journal, no changes will hit
1979 * disk anyway.
1980 */
1981 static void ocfs2_xa_cleanup_value_truncate(struct ocfs2_xa_loc *loc,
1982 const char *what,
1983 unsigned int orig_clusters)
1984 {
1985 unsigned int new_clusters = ocfs2_xa_value_clusters(loc);
1986 char *nameval_buf = ocfs2_xa_offset_pointer(loc,
1987 le16_to_cpu(loc->xl_entry->xe_name_offset));
1988
1989 if (new_clusters < orig_clusters) {
1990 mlog(ML_ERROR,
1991 "Partial truncate while %s xattr %.*s. Leaking "
1992 "%u clusters and removing the entry\n",
1993 what, loc->xl_entry->xe_name_len, nameval_buf,
1994 orig_clusters - new_clusters);
1995 ocfs2_xa_remove_entry(loc);
1996 } else if (!orig_clusters) {
1997 mlog(ML_ERROR,
1998 "Unable to allocate an external value for xattr "
1999 "%.*s safely. Leaking %u clusters and removing the "
2000 "entry\n",
2001 loc->xl_entry->xe_name_len, nameval_buf,
2002 new_clusters - orig_clusters);
2003 ocfs2_xa_remove_entry(loc);
2004 } else if (new_clusters > orig_clusters)
2005 mlog(ML_ERROR,
2006 "Unable to grow xattr %.*s safely. %u new clusters "
2007 "have been added, but the value will not be "
2008 "modified\n",
2009 loc->xl_entry->xe_name_len, nameval_buf,
2010 new_clusters - orig_clusters);
2011 }
2012
2013 static int ocfs2_xa_remove(struct ocfs2_xa_loc *loc,
2014 struct ocfs2_xattr_set_ctxt *ctxt)
2015 {
2016 int rc = 0;
2017 unsigned int orig_clusters;
2018
2019 if (!ocfs2_xattr_is_local(loc->xl_entry)) {
2020 orig_clusters = ocfs2_xa_value_clusters(loc);
2021 rc = ocfs2_xa_value_truncate(loc, 0, ctxt);
2022 if (rc) {
2023 mlog_errno(rc);
2024 /*
2025 * Since this is remove, we can return 0 if
2026 * ocfs2_xa_cleanup_value_truncate() is going to
2027 * wipe the entry anyway. So we check the
2028 * cluster count as well.
2029 */
2030 if (orig_clusters != ocfs2_xa_value_clusters(loc))
2031 rc = 0;
2032 ocfs2_xa_cleanup_value_truncate(loc, "removing",
2033 orig_clusters);
2034 if (rc)
2035 goto out;
2036 }
2037 }
2038
2039 ocfs2_xa_remove_entry(loc);
2040
2041 out:
2042 return rc;
2043 }
2044
2045 static void ocfs2_xa_install_value_root(struct ocfs2_xa_loc *loc)
2046 {
2047 int name_size = OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len);
2048 char *nameval_buf;
2049
2050 nameval_buf = ocfs2_xa_offset_pointer(loc,
2051 le16_to_cpu(loc->xl_entry->xe_name_offset));
2052 memcpy(nameval_buf + name_size, &def_xv, OCFS2_XATTR_ROOT_SIZE);
2053 }
2054
2055 /*
2056 * Take an existing entry and make it ready for the new value. This
2057 * won't allocate space, but it may free space. It should be ready for
2058 * ocfs2_xa_prepare_entry() to finish the work.
2059 */
2060 static int ocfs2_xa_reuse_entry(struct ocfs2_xa_loc *loc,
2061 struct ocfs2_xattr_info *xi,
2062 struct ocfs2_xattr_set_ctxt *ctxt)
2063 {
2064 int rc = 0;
2065 int name_size = OCFS2_XATTR_SIZE(xi->xi_name_len);
2066 unsigned int orig_clusters;
2067 char *nameval_buf;
2068 int xe_local = ocfs2_xattr_is_local(loc->xl_entry);
2069 int xi_local = xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE;
2070
2071 BUG_ON(OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len) !=
2072 name_size);
2073
2074 nameval_buf = ocfs2_xa_offset_pointer(loc,
2075 le16_to_cpu(loc->xl_entry->xe_name_offset));
2076 if (xe_local) {
2077 memset(nameval_buf + name_size, 0,
2078 namevalue_size_xe(loc->xl_entry) - name_size);
2079 if (!xi_local)
2080 ocfs2_xa_install_value_root(loc);
2081 } else {
2082 orig_clusters = ocfs2_xa_value_clusters(loc);
2083 if (xi_local) {
2084 rc = ocfs2_xa_value_truncate(loc, 0, ctxt);
2085 if (rc < 0)
2086 mlog_errno(rc);
2087 else
2088 memset(nameval_buf + name_size, 0,
2089 namevalue_size_xe(loc->xl_entry) -
2090 name_size);
2091 } else if (le64_to_cpu(loc->xl_entry->xe_value_size) >
2092 xi->xi_value_len) {
2093 rc = ocfs2_xa_value_truncate(loc, xi->xi_value_len,
2094 ctxt);
2095 if (rc < 0)
2096 mlog_errno(rc);
2097 }
2098
2099 if (rc) {
2100 ocfs2_xa_cleanup_value_truncate(loc, "reusing",
2101 orig_clusters);
2102 goto out;
2103 }
2104 }
2105
2106 loc->xl_entry->xe_value_size = cpu_to_le64(xi->xi_value_len);
2107 ocfs2_xattr_set_local(loc->xl_entry, xi_local);
2108
2109 out:
2110 return rc;
2111 }
2112
2113 /*
2114 * Prepares loc->xl_entry to receive the new xattr. This includes
2115 * properly setting up the name+value pair region. If loc->xl_entry
2116 * already exists, it will take care of modifying it appropriately.
2117 *
2118 * Note that this modifies the data. You did journal_access already,
2119 * right?
2120 */
2121 static int ocfs2_xa_prepare_entry(struct ocfs2_xa_loc *loc,
2122 struct ocfs2_xattr_info *xi,
2123 u32 name_hash,
2124 struct ocfs2_xattr_set_ctxt *ctxt)
2125 {
2126 int rc = 0;
2127 unsigned int orig_clusters;
2128 __le64 orig_value_size = 0;
2129
2130 rc = ocfs2_xa_check_space(loc, xi);
2131 if (rc)
2132 goto out;
2133
2134 if (loc->xl_entry) {
2135 if (ocfs2_xa_can_reuse_entry(loc, xi)) {
2136 orig_value_size = loc->xl_entry->xe_value_size;
2137 rc = ocfs2_xa_reuse_entry(loc, xi, ctxt);
2138 if (rc)
2139 goto out;
2140 goto alloc_value;
2141 }
2142
2143 if (!ocfs2_xattr_is_local(loc->xl_entry)) {
2144 orig_clusters = ocfs2_xa_value_clusters(loc);
2145 rc = ocfs2_xa_value_truncate(loc, 0, ctxt);
2146 if (rc) {
2147 mlog_errno(rc);
2148 ocfs2_xa_cleanup_value_truncate(loc,
2149 "overwriting",
2150 orig_clusters);
2151 goto out;
2152 }
2153 }
2154 ocfs2_xa_wipe_namevalue(loc);
2155 } else
2156 ocfs2_xa_add_entry(loc, name_hash);
2157
2158 /*
2159 * If we get here, we have a blank entry. Fill it. We grow our
2160 * name+value pair back from the end.
2161 */
2162 ocfs2_xa_add_namevalue(loc, xi);
2163 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE)
2164 ocfs2_xa_install_value_root(loc);
2165
2166 alloc_value:
2167 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
2168 orig_clusters = ocfs2_xa_value_clusters(loc);
2169 rc = ocfs2_xa_value_truncate(loc, xi->xi_value_len, ctxt);
2170 if (rc < 0) {
2171 ctxt->set_abort = 1;
2172 ocfs2_xa_cleanup_value_truncate(loc, "growing",
2173 orig_clusters);
2174 /*
2175 * If we were growing an existing value,
2176 * ocfs2_xa_cleanup_value_truncate() won't remove
2177 * the entry. We need to restore the original value
2178 * size.
2179 */
2180 if (loc->xl_entry) {
2181 BUG_ON(!orig_value_size);
2182 loc->xl_entry->xe_value_size = orig_value_size;
2183 }
2184 mlog_errno(rc);
2185 }
2186 }
2187
2188 out:
2189 return rc;
2190 }
2191
2192 /*
2193 * Store the value portion of the name+value pair. This will skip
2194 * values that are stored externally. Their tree roots were set up
2195 * by ocfs2_xa_prepare_entry().
2196 */
2197 static int ocfs2_xa_store_value(struct ocfs2_xa_loc *loc,
2198 struct ocfs2_xattr_info *xi,
2199 struct ocfs2_xattr_set_ctxt *ctxt)
2200 {
2201 int rc = 0;
2202 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset);
2203 int name_size = OCFS2_XATTR_SIZE(xi->xi_name_len);
2204 char *nameval_buf;
2205 struct ocfs2_xattr_value_buf vb;
2206
2207 nameval_buf = ocfs2_xa_offset_pointer(loc, nameval_offset);
2208 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
2209 ocfs2_xa_fill_value_buf(loc, &vb);
2210 rc = __ocfs2_xattr_set_value_outside(loc->xl_inode,
2211 ctxt->handle, &vb,
2212 xi->xi_value,
2213 xi->xi_value_len);
2214 } else
2215 memcpy(nameval_buf + name_size, xi->xi_value, xi->xi_value_len);
2216
2217 return rc;
2218 }
2219
2220 static int ocfs2_xa_set(struct ocfs2_xa_loc *loc,
2221 struct ocfs2_xattr_info *xi,
2222 struct ocfs2_xattr_set_ctxt *ctxt)
2223 {
2224 int ret;
2225 u32 name_hash = ocfs2_xattr_name_hash(loc->xl_inode, xi->xi_name,
2226 xi->xi_name_len);
2227
2228 ret = ocfs2_xa_journal_access(ctxt->handle, loc,
2229 OCFS2_JOURNAL_ACCESS_WRITE);
2230 if (ret) {
2231 mlog_errno(ret);
2232 goto out;
2233 }
2234
2235 /*
2236 * From here on out, everything is going to modify the buffer a
2237 * little. Errors are going to leave the xattr header in a
2238 * sane state. Thus, even with errors we dirty the sucker.
2239 */
2240
2241 /* Don't worry, we are never called with !xi_value and !xl_entry */
2242 if (!xi->xi_value) {
2243 ret = ocfs2_xa_remove(loc, ctxt);
2244 goto out_dirty;
2245 }
2246
2247 ret = ocfs2_xa_prepare_entry(loc, xi, name_hash, ctxt);
2248 if (ret) {
2249 if (ret != -ENOSPC)
2250 mlog_errno(ret);
2251 goto out_dirty;
2252 }
2253
2254 ret = ocfs2_xa_store_value(loc, xi, ctxt);
2255 if (ret)
2256 mlog_errno(ret);
2257
2258 out_dirty:
2259 ocfs2_xa_journal_dirty(ctxt->handle, loc);
2260
2261 out:
2262 return ret;
2263 }
2264
2265 static void ocfs2_init_dinode_xa_loc(struct ocfs2_xa_loc *loc,
2266 struct inode *inode,
2267 struct buffer_head *bh,
2268 struct ocfs2_xattr_entry *entry)
2269 {
2270 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;
2271
2272 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_XATTR_FL));
2273
2274 loc->xl_inode = inode;
2275 loc->xl_ops = &ocfs2_xa_block_loc_ops;
2276 loc->xl_storage = bh;
2277 loc->xl_entry = entry;
2278 loc->xl_size = le16_to_cpu(di->i_xattr_inline_size);
2279 loc->xl_header =
2280 (struct ocfs2_xattr_header *)(bh->b_data + bh->b_size -
2281 loc->xl_size);
2282 }
2283
2284 static void ocfs2_init_xattr_block_xa_loc(struct ocfs2_xa_loc *loc,
2285 struct inode *inode,
2286 struct buffer_head *bh,
2287 struct ocfs2_xattr_entry *entry)
2288 {
2289 struct ocfs2_xattr_block *xb =
2290 (struct ocfs2_xattr_block *)bh->b_data;
2291
2292 BUG_ON(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED);
2293
2294 loc->xl_inode = inode;
2295 loc->xl_ops = &ocfs2_xa_block_loc_ops;
2296 loc->xl_storage = bh;
2297 loc->xl_header = &(xb->xb_attrs.xb_header);
2298 loc->xl_entry = entry;
2299 loc->xl_size = bh->b_size - offsetof(struct ocfs2_xattr_block,
2300 xb_attrs.xb_header);
2301 }
2302
2303 static void ocfs2_init_xattr_bucket_xa_loc(struct ocfs2_xa_loc *loc,
2304 struct ocfs2_xattr_bucket *bucket,
2305 struct ocfs2_xattr_entry *entry)
2306 {
2307 loc->xl_inode = bucket->bu_inode;
2308 loc->xl_ops = &ocfs2_xa_bucket_loc_ops;
2309 loc->xl_storage = bucket;
2310 loc->xl_header = bucket_xh(bucket);
2311 loc->xl_entry = entry;
2312 loc->xl_size = OCFS2_XATTR_BUCKET_SIZE;
2313 }
2314
2315 /*
2316 * In xattr remove, if it is stored outside and refcounted, we may have
2317 * the chance to split the refcount tree. So need the allocators.
2318 */
2319 static int ocfs2_lock_xattr_remove_allocators(struct inode *inode,
2320 struct ocfs2_xattr_value_root *xv,
2321 struct ocfs2_caching_info *ref_ci,
2322 struct buffer_head *ref_root_bh,
2323 struct ocfs2_alloc_context **meta_ac,
2324 int *ref_credits)
2325 {
2326 int ret, meta_add = 0;
2327 u32 p_cluster, num_clusters;
2328 unsigned int ext_flags;
2329
2330 *ref_credits = 0;
2331 ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster,
2332 &num_clusters,
2333 &xv->xr_list,
2334 &ext_flags);
2335 if (ret) {
2336 mlog_errno(ret);
2337 goto out;
2338 }
2339
2340 if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
2341 goto out;
2342
2343 ret = ocfs2_refcounted_xattr_delete_need(inode, ref_ci,
2344 ref_root_bh, xv,
2345 &meta_add, ref_credits);
2346 if (ret) {
2347 mlog_errno(ret);
2348 goto out;
2349 }
2350
2351 ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(inode->i_sb),
2352 meta_add, meta_ac);
2353 if (ret)
2354 mlog_errno(ret);
2355
2356 out:
2357 return ret;
2358 }
2359
2360 static int ocfs2_remove_value_outside(struct inode*inode,
2361 struct ocfs2_xattr_value_buf *vb,
2362 struct ocfs2_xattr_header *header,
2363 struct ocfs2_caching_info *ref_ci,
2364 struct buffer_head *ref_root_bh)
2365 {
2366 int ret = 0, i, ref_credits;
2367 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2368 struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
2369 void *val;
2370
2371 ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
2372
2373 for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
2374 struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
2375
2376 if (ocfs2_xattr_is_local(entry))
2377 continue;
2378
2379 val = (void *)header +
2380 le16_to_cpu(entry->xe_name_offset);
2381 vb->vb_xv = (struct ocfs2_xattr_value_root *)
2382 (val + OCFS2_XATTR_SIZE(entry->xe_name_len));
2383
2384 ret = ocfs2_lock_xattr_remove_allocators(inode, vb->vb_xv,
2385 ref_ci, ref_root_bh,
2386 &ctxt.meta_ac,
2387 &ref_credits);
2388
2389 ctxt.handle = ocfs2_start_trans(osb, ref_credits +
2390 ocfs2_remove_extent_credits(osb->sb));
2391 if (IS_ERR(ctxt.handle)) {
2392 ret = PTR_ERR(ctxt.handle);
2393 mlog_errno(ret);
2394 break;
2395 }
2396
2397 ret = ocfs2_xattr_value_truncate(inode, vb, 0, &ctxt);
2398
2399 ocfs2_commit_trans(osb, ctxt.handle);
2400 if (ctxt.meta_ac) {
2401 ocfs2_free_alloc_context(ctxt.meta_ac);
2402 ctxt.meta_ac = NULL;
2403 }
2404
2405 if (ret < 0) {
2406 mlog_errno(ret);
2407 break;
2408 }
2409
2410 }
2411
2412 if (ctxt.meta_ac)
2413 ocfs2_free_alloc_context(ctxt.meta_ac);
2414 ocfs2_schedule_truncate_log_flush(osb, 1);
2415 ocfs2_run_deallocs(osb, &ctxt.dealloc);
2416 return ret;
2417 }
2418
2419 static int ocfs2_xattr_ibody_remove(struct inode *inode,
2420 struct buffer_head *di_bh,
2421 struct ocfs2_caching_info *ref_ci,
2422 struct buffer_head *ref_root_bh)
2423 {
2424
2425 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2426 struct ocfs2_xattr_header *header;
2427 int ret;
2428 struct ocfs2_xattr_value_buf vb = {
2429 .vb_bh = di_bh,
2430 .vb_access = ocfs2_journal_access_di,
2431 };
2432
2433 header = (struct ocfs2_xattr_header *)
2434 ((void *)di + inode->i_sb->s_blocksize -
2435 le16_to_cpu(di->i_xattr_inline_size));
2436
2437 ret = ocfs2_remove_value_outside(inode, &vb, header,
2438 ref_ci, ref_root_bh);
2439
2440 return ret;
2441 }
2442
2443 struct ocfs2_rm_xattr_bucket_para {
2444 struct ocfs2_caching_info *ref_ci;
2445 struct buffer_head *ref_root_bh;
2446 };
2447
2448 static int ocfs2_xattr_block_remove(struct inode *inode,
2449 struct buffer_head *blk_bh,
2450 struct ocfs2_caching_info *ref_ci,
2451 struct buffer_head *ref_root_bh)
2452 {
2453 struct ocfs2_xattr_block *xb;
2454 int ret = 0;
2455 struct ocfs2_xattr_value_buf vb = {
2456 .vb_bh = blk_bh,
2457 .vb_access = ocfs2_journal_access_xb,
2458 };
2459 struct ocfs2_rm_xattr_bucket_para args = {
2460 .ref_ci = ref_ci,
2461 .ref_root_bh = ref_root_bh,
2462 };
2463
2464 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
2465 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
2466 struct ocfs2_xattr_header *header = &(xb->xb_attrs.xb_header);
2467 ret = ocfs2_remove_value_outside(inode, &vb, header,
2468 ref_ci, ref_root_bh);
2469 } else
2470 ret = ocfs2_iterate_xattr_index_block(inode,
2471 blk_bh,
2472 ocfs2_rm_xattr_cluster,
2473 &args);
2474
2475 return ret;
2476 }
2477
2478 static int ocfs2_xattr_free_block(struct inode *inode,
2479 u64 block,
2480 struct ocfs2_caching_info *ref_ci,
2481 struct buffer_head *ref_root_bh)
2482 {
2483 struct inode *xb_alloc_inode;
2484 struct buffer_head *xb_alloc_bh = NULL;
2485 struct buffer_head *blk_bh = NULL;
2486 struct ocfs2_xattr_block *xb;
2487 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2488 handle_t *handle;
2489 int ret = 0;
2490 u64 blk, bg_blkno;
2491 u16 bit;
2492
2493 ret = ocfs2_read_xattr_block(inode, block, &blk_bh);
2494 if (ret < 0) {
2495 mlog_errno(ret);
2496 goto out;
2497 }
2498
2499 ret = ocfs2_xattr_block_remove(inode, blk_bh, ref_ci, ref_root_bh);
2500 if (ret < 0) {
2501 mlog_errno(ret);
2502 goto out;
2503 }
2504
2505 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
2506 blk = le64_to_cpu(xb->xb_blkno);
2507 bit = le16_to_cpu(xb->xb_suballoc_bit);
2508 if (xb->xb_suballoc_loc)
2509 bg_blkno = le64_to_cpu(xb->xb_suballoc_loc);
2510 else
2511 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
2512
2513 xb_alloc_inode = ocfs2_get_system_file_inode(osb,
2514 EXTENT_ALLOC_SYSTEM_INODE,
2515 le16_to_cpu(xb->xb_suballoc_slot));
2516 if (!xb_alloc_inode) {
2517 ret = -ENOMEM;
2518 mlog_errno(ret);
2519 goto out;
2520 }
2521 inode_lock(xb_alloc_inode);
2522
2523 ret = ocfs2_inode_lock(xb_alloc_inode, &xb_alloc_bh, 1);
2524 if (ret < 0) {
2525 mlog_errno(ret);
2526 goto out_mutex;
2527 }
2528
2529 handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
2530 if (IS_ERR(handle)) {
2531 ret = PTR_ERR(handle);
2532 mlog_errno(ret);
2533 goto out_unlock;
2534 }
2535
2536 ret = ocfs2_free_suballoc_bits(handle, xb_alloc_inode, xb_alloc_bh,
2537 bit, bg_blkno, 1);
2538 if (ret < 0)
2539 mlog_errno(ret);
2540
2541 ocfs2_commit_trans(osb, handle);
2542 out_unlock:
2543 ocfs2_inode_unlock(xb_alloc_inode, 1);
2544 brelse(xb_alloc_bh);
2545 out_mutex:
2546 inode_unlock(xb_alloc_inode);
2547 iput(xb_alloc_inode);
2548 out:
2549 brelse(blk_bh);
2550 return ret;
2551 }
2552
2553 /*
2554 * ocfs2_xattr_remove()
2555 *
2556 * Free extended attribute resources associated with this inode.
2557 */
2558 int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
2559 {
2560 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2561 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2562 struct ocfs2_refcount_tree *ref_tree = NULL;
2563 struct buffer_head *ref_root_bh = NULL;
2564 struct ocfs2_caching_info *ref_ci = NULL;
2565 handle_t *handle;
2566 int ret;
2567
2568 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
2569 return 0;
2570
2571 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
2572 return 0;
2573
2574 if (ocfs2_is_refcount_inode(inode)) {
2575 ret = ocfs2_lock_refcount_tree(OCFS2_SB(inode->i_sb),
2576 le64_to_cpu(di->i_refcount_loc),
2577 1, &ref_tree, &ref_root_bh);
2578 if (ret) {
2579 mlog_errno(ret);
2580 goto out;
2581 }
2582 ref_ci = &ref_tree->rf_ci;
2583
2584 }
2585
2586 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
2587 ret = ocfs2_xattr_ibody_remove(inode, di_bh,
2588 ref_ci, ref_root_bh);
2589 if (ret < 0) {
2590 mlog_errno(ret);
2591 goto out;
2592 }
2593 }
2594
2595 if (di->i_xattr_loc) {
2596 ret = ocfs2_xattr_free_block(inode,
2597 le64_to_cpu(di->i_xattr_loc),
2598 ref_ci, ref_root_bh);
2599 if (ret < 0) {
2600 mlog_errno(ret);
2601 goto out;
2602 }
2603 }
2604
2605 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
2606 OCFS2_INODE_UPDATE_CREDITS);
2607 if (IS_ERR(handle)) {
2608 ret = PTR_ERR(handle);
2609 mlog_errno(ret);
2610 goto out;
2611 }
2612 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
2613 OCFS2_JOURNAL_ACCESS_WRITE);
2614 if (ret) {
2615 mlog_errno(ret);
2616 goto out_commit;
2617 }
2618
2619 di->i_xattr_loc = 0;
2620
2621 spin_lock(&oi->ip_lock);
2622 oi->ip_dyn_features &= ~(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL);
2623 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
2624 spin_unlock(&oi->ip_lock);
2625 ocfs2_update_inode_fsync_trans(handle, inode, 0);
2626
2627 ocfs2_journal_dirty(handle, di_bh);
2628 out_commit:
2629 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
2630 out:
2631 if (ref_tree)
2632 ocfs2_unlock_refcount_tree(OCFS2_SB(inode->i_sb), ref_tree, 1);
2633 brelse(ref_root_bh);
2634 return ret;
2635 }
2636
2637 static int ocfs2_xattr_has_space_inline(struct inode *inode,
2638 struct ocfs2_dinode *di)
2639 {
2640 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2641 unsigned int xattrsize = OCFS2_SB(inode->i_sb)->s_xattr_inline_size;
2642 int free;
2643
2644 if (xattrsize < OCFS2_MIN_XATTR_INLINE_SIZE)
2645 return 0;
2646
2647 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
2648 struct ocfs2_inline_data *idata = &di->id2.i_data;
2649 free = le16_to_cpu(idata->id_count) - le64_to_cpu(di->i_size);
2650 } else if (ocfs2_inode_is_fast_symlink(inode)) {
2651 free = ocfs2_fast_symlink_chars(inode->i_sb) -
2652 le64_to_cpu(di->i_size);
2653 } else {
2654 struct ocfs2_extent_list *el = &di->id2.i_list;
2655 free = (le16_to_cpu(el->l_count) -
2656 le16_to_cpu(el->l_next_free_rec)) *
2657 sizeof(struct ocfs2_extent_rec);
2658 }
2659 if (free >= xattrsize)
2660 return 1;
2661
2662 return 0;
2663 }
2664
2665 /*
2666 * ocfs2_xattr_ibody_find()
2667 *
2668 * Find extended attribute in inode block and
2669 * fill search info into struct ocfs2_xattr_search.
2670 */
2671 static int ocfs2_xattr_ibody_find(struct inode *inode,
2672 int name_index,
2673 const char *name,
2674 struct ocfs2_xattr_search *xs)
2675 {
2676 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2677 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
2678 int ret;
2679 int has_space = 0;
2680
2681 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
2682 return 0;
2683
2684 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
2685 down_read(&oi->ip_alloc_sem);
2686 has_space = ocfs2_xattr_has_space_inline(inode, di);
2687 up_read(&oi->ip_alloc_sem);
2688 if (!has_space)
2689 return 0;
2690 }
2691
2692 xs->xattr_bh = xs->inode_bh;
2693 xs->end = (void *)di + inode->i_sb->s_blocksize;
2694 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)
2695 xs->header = (struct ocfs2_xattr_header *)
2696 (xs->end - le16_to_cpu(di->i_xattr_inline_size));
2697 else
2698 xs->header = (struct ocfs2_xattr_header *)
2699 (xs->end - OCFS2_SB(inode->i_sb)->s_xattr_inline_size);
2700 xs->base = (void *)xs->header;
2701 xs->here = xs->header->xh_entries;
2702
2703 /* Find the named attribute. */
2704 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
2705 ret = ocfs2_xattr_find_entry(name_index, name, xs);
2706 if (ret && ret != -ENODATA)
2707 return ret;
2708 xs->not_found = ret;
2709 }
2710
2711 return 0;
2712 }
2713
2714 static int ocfs2_xattr_ibody_init(struct inode *inode,
2715 struct buffer_head *di_bh,
2716 struct ocfs2_xattr_set_ctxt *ctxt)
2717 {
2718 int ret;
2719 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2720 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2721 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2722 unsigned int xattrsize = osb->s_xattr_inline_size;
2723
2724 if (!ocfs2_xattr_has_space_inline(inode, di)) {
2725 ret = -ENOSPC;
2726 goto out;
2727 }
2728
2729 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode), di_bh,
2730 OCFS2_JOURNAL_ACCESS_WRITE);
2731 if (ret) {
2732 mlog_errno(ret);
2733 goto out;
2734 }
2735
2736 /*
2737 * Adjust extent record count or inline data size
2738 * to reserve space for extended attribute.
2739 */
2740 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
2741 struct ocfs2_inline_data *idata = &di->id2.i_data;
2742 le16_add_cpu(&idata->id_count, -xattrsize);
2743 } else if (!(ocfs2_inode_is_fast_symlink(inode))) {
2744 struct ocfs2_extent_list *el = &di->id2.i_list;
2745 le16_add_cpu(&el->l_count, -(xattrsize /
2746 sizeof(struct ocfs2_extent_rec)));
2747 }
2748 di->i_xattr_inline_size = cpu_to_le16(xattrsize);
2749
2750 spin_lock(&oi->ip_lock);
2751 oi->ip_dyn_features |= OCFS2_INLINE_XATTR_FL|OCFS2_HAS_XATTR_FL;
2752 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
2753 spin_unlock(&oi->ip_lock);
2754
2755 ocfs2_journal_dirty(ctxt->handle, di_bh);
2756
2757 out:
2758 return ret;
2759 }
2760
2761 /*
2762 * ocfs2_xattr_ibody_set()
2763 *
2764 * Set, replace or remove an extended attribute into inode block.
2765 *
2766 */
2767 static int ocfs2_xattr_ibody_set(struct inode *inode,
2768 struct ocfs2_xattr_info *xi,
2769 struct ocfs2_xattr_search *xs,
2770 struct ocfs2_xattr_set_ctxt *ctxt)
2771 {
2772 int ret;
2773 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2774 struct ocfs2_xa_loc loc;
2775
2776 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
2777 return -ENOSPC;
2778
2779 down_write(&oi->ip_alloc_sem);
2780 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
2781 ret = ocfs2_xattr_ibody_init(inode, xs->inode_bh, ctxt);
2782 if (ret) {
2783 if (ret != -ENOSPC)
2784 mlog_errno(ret);
2785 goto out;
2786 }
2787 }
2788
2789 ocfs2_init_dinode_xa_loc(&loc, inode, xs->inode_bh,
2790 xs->not_found ? NULL : xs->here);
2791 ret = ocfs2_xa_set(&loc, xi, ctxt);
2792 if (ret) {
2793 if (ret != -ENOSPC)
2794 mlog_errno(ret);
2795 goto out;
2796 }
2797 xs->here = loc.xl_entry;
2798
2799 out:
2800 up_write(&oi->ip_alloc_sem);
2801
2802 return ret;
2803 }
2804
2805 /*
2806 * ocfs2_xattr_block_find()
2807 *
2808 * Find extended attribute in external block and
2809 * fill search info into struct ocfs2_xattr_search.
2810 */
2811 static int ocfs2_xattr_block_find(struct inode *inode,
2812 int name_index,
2813 const char *name,
2814 struct ocfs2_xattr_search *xs)
2815 {
2816 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
2817 struct buffer_head *blk_bh = NULL;
2818 struct ocfs2_xattr_block *xb;
2819 int ret = 0;
2820
2821 if (!di->i_xattr_loc)
2822 return ret;
2823
2824 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
2825 &blk_bh);
2826 if (ret < 0) {
2827 mlog_errno(ret);
2828 return ret;
2829 }
2830
2831 xs->xattr_bh = blk_bh;
2832 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
2833
2834 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
2835 xs->header = &xb->xb_attrs.xb_header;
2836 xs->base = (void *)xs->header;
2837 xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size;
2838 xs->here = xs->header->xh_entries;
2839
2840 ret = ocfs2_xattr_find_entry(name_index, name, xs);
2841 } else
2842 ret = ocfs2_xattr_index_block_find(inode, blk_bh,
2843 name_index,
2844 name, xs);
2845
2846 if (ret && ret != -ENODATA) {
2847 xs->xattr_bh = NULL;
2848 goto cleanup;
2849 }
2850 xs->not_found = ret;
2851 return 0;
2852 cleanup:
2853 brelse(blk_bh);
2854
2855 return ret;
2856 }
2857
2858 static int ocfs2_create_xattr_block(struct inode *inode,
2859 struct buffer_head *inode_bh,
2860 struct ocfs2_xattr_set_ctxt *ctxt,
2861 int indexed,
2862 struct buffer_head **ret_bh)
2863 {
2864 int ret;
2865 u16 suballoc_bit_start;
2866 u32 num_got;
2867 u64 suballoc_loc, first_blkno;
2868 struct ocfs2_dinode *di = (struct ocfs2_dinode *)inode_bh->b_data;
2869 struct buffer_head *new_bh = NULL;
2870 struct ocfs2_xattr_block *xblk;
2871
2872 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode),
2873 inode_bh, OCFS2_JOURNAL_ACCESS_CREATE);
2874 if (ret < 0) {
2875 mlog_errno(ret);
2876 goto end;
2877 }
2878
2879 ret = ocfs2_claim_metadata(ctxt->handle, ctxt->meta_ac, 1,
2880 &suballoc_loc, &suballoc_bit_start,
2881 &num_got, &first_blkno);
2882 if (ret < 0) {
2883 mlog_errno(ret);
2884 goto end;
2885 }
2886
2887 new_bh = sb_getblk(inode->i_sb, first_blkno);
2888 if (!new_bh) {
2889 ret = -ENOMEM;
2890 mlog_errno(ret);
2891 goto end;
2892 }
2893
2894 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), new_bh);
2895
2896 ret = ocfs2_journal_access_xb(ctxt->handle, INODE_CACHE(inode),
2897 new_bh,
2898 OCFS2_JOURNAL_ACCESS_CREATE);
2899 if (ret < 0) {
2900 mlog_errno(ret);
2901 goto end;
2902 }
2903
2904 /* Initialize ocfs2_xattr_block */
2905 xblk = (struct ocfs2_xattr_block *)new_bh->b_data;
2906 memset(xblk, 0, inode->i_sb->s_blocksize);
2907 strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE);
2908 xblk->xb_suballoc_slot = cpu_to_le16(ctxt->meta_ac->ac_alloc_slot);
2909 xblk->xb_suballoc_loc = cpu_to_le64(suballoc_loc);
2910 xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start);
2911 xblk->xb_fs_generation =
2912 cpu_to_le32(OCFS2_SB(inode->i_sb)->fs_generation);
2913 xblk->xb_blkno = cpu_to_le64(first_blkno);
2914 if (indexed) {
2915 struct ocfs2_xattr_tree_root *xr = &xblk->xb_attrs.xb_root;
2916 xr->xt_clusters = cpu_to_le32(1);
2917 xr->xt_last_eb_blk = 0;
2918 xr->xt_list.l_tree_depth = 0;
2919 xr->xt_list.l_count = cpu_to_le16(
2920 ocfs2_xattr_recs_per_xb(inode->i_sb));
2921 xr->xt_list.l_next_free_rec = cpu_to_le16(1);
2922 xblk->xb_flags = cpu_to_le16(OCFS2_XATTR_INDEXED);
2923 }
2924 ocfs2_journal_dirty(ctxt->handle, new_bh);
2925
2926 /* Add it to the inode */
2927 di->i_xattr_loc = cpu_to_le64(first_blkno);
2928
2929 spin_lock(&OCFS2_I(inode)->ip_lock);
2930 OCFS2_I(inode)->ip_dyn_features |= OCFS2_HAS_XATTR_FL;
2931 di->i_dyn_features = cpu_to_le16(OCFS2_I(inode)->ip_dyn_features);
2932 spin_unlock(&OCFS2_I(inode)->ip_lock);
2933
2934 ocfs2_journal_dirty(ctxt->handle, inode_bh);
2935
2936 *ret_bh = new_bh;
2937 new_bh = NULL;
2938
2939 end:
2940 brelse(new_bh);
2941 return ret;
2942 }
2943
2944 /*
2945 * ocfs2_xattr_block_set()
2946 *
2947 * Set, replace or remove an extended attribute into external block.
2948 *
2949 */
2950 static int ocfs2_xattr_block_set(struct inode *inode,
2951 struct ocfs2_xattr_info *xi,
2952 struct ocfs2_xattr_search *xs,
2953 struct ocfs2_xattr_set_ctxt *ctxt)
2954 {
2955 struct buffer_head *new_bh = NULL;
2956 struct ocfs2_xattr_block *xblk = NULL;
2957 int ret;
2958 struct ocfs2_xa_loc loc;
2959
2960 if (!xs->xattr_bh) {
2961 ret = ocfs2_create_xattr_block(inode, xs->inode_bh, ctxt,
2962 0, &new_bh);
2963 if (ret) {
2964 mlog_errno(ret);
2965 goto end;
2966 }
2967
2968 xs->xattr_bh = new_bh;
2969 xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
2970 xs->header = &xblk->xb_attrs.xb_header;
2971 xs->base = (void *)xs->header;
2972 xs->end = (void *)xblk + inode->i_sb->s_blocksize;
2973 xs->here = xs->header->xh_entries;
2974 } else
2975 xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
2976
2977 if (!(le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)) {
2978 ocfs2_init_xattr_block_xa_loc(&loc, inode, xs->xattr_bh,
2979 xs->not_found ? NULL : xs->here);
2980
2981 ret = ocfs2_xa_set(&loc, xi, ctxt);
2982 if (!ret)
2983 xs->here = loc.xl_entry;
2984 else if ((ret != -ENOSPC) || ctxt->set_abort)
2985 goto end;
2986 else {
2987 ret = ocfs2_xattr_create_index_block(inode, xs, ctxt);
2988 if (ret)
2989 goto end;
2990 }
2991 }
2992
2993 if (le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)
2994 ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs, ctxt);
2995
2996 end:
2997 return ret;
2998 }
2999
3000 /* Check whether the new xattr can be inserted into the inode. */
3001 static int ocfs2_xattr_can_be_in_inode(struct inode *inode,
3002 struct ocfs2_xattr_info *xi,
3003 struct ocfs2_xattr_search *xs)
3004 {
3005 struct ocfs2_xattr_entry *last;
3006 int free, i;
3007 size_t min_offs = xs->end - xs->base;
3008
3009 if (!xs->header)
3010 return 0;
3011
3012 last = xs->header->xh_entries;
3013
3014 for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
3015 size_t offs = le16_to_cpu(last->xe_name_offset);
3016 if (offs < min_offs)
3017 min_offs = offs;
3018 last += 1;
3019 }
3020
3021 free = min_offs - ((void *)last - xs->base) - OCFS2_XATTR_HEADER_GAP;
3022 if (free < 0)
3023 return 0;
3024
3025 BUG_ON(!xs->not_found);
3026
3027 if (free >= (sizeof(struct ocfs2_xattr_entry) + namevalue_size_xi(xi)))
3028 return 1;
3029
3030 return 0;
3031 }
3032
3033 static int ocfs2_calc_xattr_set_need(struct inode *inode,
3034 struct ocfs2_dinode *di,
3035 struct ocfs2_xattr_info *xi,
3036 struct ocfs2_xattr_search *xis,
3037 struct ocfs2_xattr_search *xbs,
3038 int *clusters_need,
3039 int *meta_need,
3040 int *credits_need)
3041 {
3042 int ret = 0, old_in_xb = 0;
3043 int clusters_add = 0, meta_add = 0, credits = 0;
3044 struct buffer_head *bh = NULL;
3045 struct ocfs2_xattr_block *xb = NULL;
3046 struct ocfs2_xattr_entry *xe = NULL;
3047 struct ocfs2_xattr_value_root *xv = NULL;
3048 char *base = NULL;
3049 int name_offset, name_len = 0;
3050 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb,
3051 xi->xi_value_len);
3052 u64 value_size;
3053
3054 /*
3055 * Calculate the clusters we need to write.
3056 * No matter whether we replace an old one or add a new one,
3057 * we need this for writing.
3058 */
3059 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE)
3060 credits += new_clusters *
3061 ocfs2_clusters_to_blocks(inode->i_sb, 1);
3062
3063 if (xis->not_found && xbs->not_found) {
3064 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3065
3066 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
3067 clusters_add += new_clusters;
3068 credits += ocfs2_calc_extend_credits(inode->i_sb,
3069 &def_xv.xv.xr_list);
3070 }
3071
3072 goto meta_guess;
3073 }
3074
3075 if (!xis->not_found) {
3076 xe = xis->here;
3077 name_offset = le16_to_cpu(xe->xe_name_offset);
3078 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
3079 base = xis->base;
3080 credits += OCFS2_INODE_UPDATE_CREDITS;
3081 } else {
3082 int i, block_off = 0;
3083 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
3084 xe = xbs->here;
3085 name_offset = le16_to_cpu(xe->xe_name_offset);
3086 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
3087 i = xbs->here - xbs->header->xh_entries;
3088 old_in_xb = 1;
3089
3090 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
3091 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
3092 bucket_xh(xbs->bucket),
3093 i, &block_off,
3094 &name_offset);
3095 base = bucket_block(xbs->bucket, block_off);
3096 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3097 } else {
3098 base = xbs->base;
3099 credits += OCFS2_XATTR_BLOCK_UPDATE_CREDITS;
3100 }
3101 }
3102
3103 /*
3104 * delete a xattr doesn't need metadata and cluster allocation.
3105 * so just calculate the credits and return.
3106 *
3107 * The credits for removing the value tree will be extended
3108 * by ocfs2_remove_extent itself.
3109 */
3110 if (!xi->xi_value) {
3111 if (!ocfs2_xattr_is_local(xe))
3112 credits += ocfs2_remove_extent_credits(inode->i_sb);
3113
3114 goto out;
3115 }
3116
3117 /* do cluster allocation guess first. */
3118 value_size = le64_to_cpu(xe->xe_value_size);
3119
3120 if (old_in_xb) {
3121 /*
3122 * In xattr set, we always try to set the xe in inode first,
3123 * so if it can be inserted into inode successfully, the old
3124 * one will be removed from the xattr block, and this xattr
3125 * will be inserted into inode as a new xattr in inode.
3126 */
3127 if (ocfs2_xattr_can_be_in_inode(inode, xi, xis)) {
3128 clusters_add += new_clusters;
3129 credits += ocfs2_remove_extent_credits(inode->i_sb) +
3130 OCFS2_INODE_UPDATE_CREDITS;
3131 if (!ocfs2_xattr_is_local(xe))
3132 credits += ocfs2_calc_extend_credits(
3133 inode->i_sb,
3134 &def_xv.xv.xr_list);
3135 goto out;
3136 }
3137 }
3138
3139 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
3140 /* the new values will be stored outside. */
3141 u32 old_clusters = 0;
3142
3143 if (!ocfs2_xattr_is_local(xe)) {
3144 old_clusters = ocfs2_clusters_for_bytes(inode->i_sb,
3145 value_size);
3146 xv = (struct ocfs2_xattr_value_root *)
3147 (base + name_offset + name_len);
3148 value_size = OCFS2_XATTR_ROOT_SIZE;
3149 } else
3150 xv = &def_xv.xv;
3151
3152 if (old_clusters >= new_clusters) {
3153 credits += ocfs2_remove_extent_credits(inode->i_sb);
3154 goto out;
3155 } else {
3156 meta_add += ocfs2_extend_meta_needed(&xv->xr_list);
3157 clusters_add += new_clusters - old_clusters;
3158 credits += ocfs2_calc_extend_credits(inode->i_sb,
3159 &xv->xr_list);
3160 if (value_size >= OCFS2_XATTR_ROOT_SIZE)
3161 goto out;
3162 }
3163 } else {
3164 /*
3165 * Now the new value will be stored inside. So if the new
3166 * value is smaller than the size of value root or the old
3167 * value, we don't need any allocation, otherwise we have
3168 * to guess metadata allocation.
3169 */
3170 if ((ocfs2_xattr_is_local(xe) &&
3171 (value_size >= xi->xi_value_len)) ||
3172 (!ocfs2_xattr_is_local(xe) &&
3173 OCFS2_XATTR_ROOT_SIZE >= xi->xi_value_len))
3174 goto out;
3175 }
3176
3177 meta_guess:
3178 /* calculate metadata allocation. */
3179 if (di->i_xattr_loc) {
3180 if (!xbs->xattr_bh) {
3181 ret = ocfs2_read_xattr_block(inode,
3182 le64_to_cpu(di->i_xattr_loc),
3183 &bh);
3184 if (ret) {
3185 mlog_errno(ret);
3186 goto out;
3187 }
3188
3189 xb = (struct ocfs2_xattr_block *)bh->b_data;
3190 } else
3191 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
3192
3193 /*
3194 * If there is already an xattr tree, good, we can calculate
3195 * like other b-trees. Otherwise we may have the chance of
3196 * create a tree, the credit calculation is borrowed from
3197 * ocfs2_calc_extend_credits with root_el = NULL. And the
3198 * new tree will be cluster based, so no meta is needed.
3199 */
3200 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
3201 struct ocfs2_extent_list *el =
3202 &xb->xb_attrs.xb_root.xt_list;
3203 meta_add += ocfs2_extend_meta_needed(el);
3204 credits += ocfs2_calc_extend_credits(inode->i_sb,
3205 el);
3206 } else
3207 credits += OCFS2_SUBALLOC_ALLOC + 1;
3208
3209 /*
3210 * This cluster will be used either for new bucket or for
3211 * new xattr block.
3212 * If the cluster size is the same as the bucket size, one
3213 * more is needed since we may need to extend the bucket
3214 * also.
3215 */
3216 clusters_add += 1;
3217 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3218 if (OCFS2_XATTR_BUCKET_SIZE ==
3219 OCFS2_SB(inode->i_sb)->s_clustersize) {
3220 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3221 clusters_add += 1;
3222 }
3223 } else {
3224 credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
3225 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
3226 struct ocfs2_extent_list *el = &def_xv.xv.xr_list;
3227 meta_add += ocfs2_extend_meta_needed(el);
3228 credits += ocfs2_calc_extend_credits(inode->i_sb,
3229 el);
3230 } else {
3231 meta_add += 1;
3232 }
3233 }
3234 out:
3235 if (clusters_need)
3236 *clusters_need = clusters_add;
3237 if (meta_need)
3238 *meta_need = meta_add;
3239 if (credits_need)
3240 *credits_need = credits;
3241 brelse(bh);
3242 return ret;
3243 }
3244
3245 static int ocfs2_init_xattr_set_ctxt(struct inode *inode,
3246 struct ocfs2_dinode *di,
3247 struct ocfs2_xattr_info *xi,
3248 struct ocfs2_xattr_search *xis,
3249 struct ocfs2_xattr_search *xbs,
3250 struct ocfs2_xattr_set_ctxt *ctxt,
3251 int extra_meta,
3252 int *credits)
3253 {
3254 int clusters_add, meta_add, ret;
3255 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3256
3257 memset(ctxt, 0, sizeof(struct ocfs2_xattr_set_ctxt));
3258
3259 ocfs2_init_dealloc_ctxt(&ctxt->dealloc);
3260
3261 ret = ocfs2_calc_xattr_set_need(inode, di, xi, xis, xbs,
3262 &clusters_add, &meta_add, credits);
3263 if (ret) {
3264 mlog_errno(ret);
3265 return ret;
3266 }
3267
3268 meta_add += extra_meta;
3269 trace_ocfs2_init_xattr_set_ctxt(xi->xi_name, meta_add,
3270 clusters_add, *credits);
3271
3272 if (meta_add) {
3273 ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add,
3274 &ctxt->meta_ac);
3275 if (ret) {
3276 mlog_errno(ret);
3277 goto out;
3278 }
3279 }
3280
3281 if (clusters_add) {
3282 ret = ocfs2_reserve_clusters(osb, clusters_add, &ctxt->data_ac);
3283 if (ret)
3284 mlog_errno(ret);
3285 }
3286 out:
3287 if (ret) {
3288 if (ctxt->meta_ac) {
3289 ocfs2_free_alloc_context(ctxt->meta_ac);
3290 ctxt->meta_ac = NULL;
3291 }
3292
3293 /*
3294 * We cannot have an error and a non null ctxt->data_ac.
3295 */
3296 }
3297
3298 return ret;
3299 }
3300
3301 static int __ocfs2_xattr_set_handle(struct inode *inode,
3302 struct ocfs2_dinode *di,
3303 struct ocfs2_xattr_info *xi,
3304 struct ocfs2_xattr_search *xis,
3305 struct ocfs2_xattr_search *xbs,
3306 struct ocfs2_xattr_set_ctxt *ctxt)
3307 {
3308 int ret = 0, credits, old_found;
3309
3310 if (!xi->xi_value) {
3311 /* Remove existing extended attribute */
3312 if (!xis->not_found)
3313 ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt);
3314 else if (!xbs->not_found)
3315 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
3316 } else {
3317 /* We always try to set extended attribute into inode first*/
3318 ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt);
3319 if (!ret && !xbs->not_found) {
3320 /*
3321 * If succeed and that extended attribute existing in
3322 * external block, then we will remove it.
3323 */
3324 xi->xi_value = NULL;
3325 xi->xi_value_len = 0;
3326
3327 old_found = xis->not_found;
3328 xis->not_found = -ENODATA;
3329 ret = ocfs2_calc_xattr_set_need(inode,
3330 di,
3331 xi,
3332 xis,
3333 xbs,
3334 NULL,
3335 NULL,
3336 &credits);
3337 xis->not_found = old_found;
3338 if (ret) {
3339 mlog_errno(ret);
3340 goto out;
3341 }
3342
3343 ret = ocfs2_extend_trans(ctxt->handle, credits);
3344 if (ret) {
3345 mlog_errno(ret);
3346 goto out;
3347 }
3348 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
3349 } else if ((ret == -ENOSPC) && !ctxt->set_abort) {
3350 if (di->i_xattr_loc && !xbs->xattr_bh) {
3351 ret = ocfs2_xattr_block_find(inode,
3352 xi->xi_name_index,
3353 xi->xi_name, xbs);
3354 if (ret)
3355 goto out;
3356
3357 old_found = xis->not_found;
3358 xis->not_found = -ENODATA;
3359 ret = ocfs2_calc_xattr_set_need(inode,
3360 di,
3361 xi,
3362 xis,
3363 xbs,
3364 NULL,
3365 NULL,
3366 &credits);
3367 xis->not_found = old_found;
3368 if (ret) {
3369 mlog_errno(ret);
3370 goto out;
3371 }
3372
3373 ret = ocfs2_extend_trans(ctxt->handle, credits);
3374 if (ret) {
3375 mlog_errno(ret);
3376 goto out;
3377 }
3378 }
3379 /*
3380 * If no space in inode, we will set extended attribute
3381 * into external block.
3382 */
3383 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
3384 if (ret)
3385 goto out;
3386 if (!xis->not_found) {
3387 /*
3388 * If succeed and that extended attribute
3389 * existing in inode, we will remove it.
3390 */
3391 xi->xi_value = NULL;
3392 xi->xi_value_len = 0;
3393 xbs->not_found = -ENODATA;
3394 ret = ocfs2_calc_xattr_set_need(inode,
3395 di,
3396 xi,
3397 xis,
3398 xbs,
3399 NULL,
3400 NULL,
3401 &credits);
3402 if (ret) {
3403 mlog_errno(ret);
3404 goto out;
3405 }
3406
3407 ret = ocfs2_extend_trans(ctxt->handle, credits);
3408 if (ret) {
3409 mlog_errno(ret);
3410 goto out;
3411 }
3412 ret = ocfs2_xattr_ibody_set(inode, xi,
3413 xis, ctxt);
3414 }
3415 }
3416 }
3417
3418 if (!ret) {
3419 /* Update inode ctime. */
3420 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode),
3421 xis->inode_bh,
3422 OCFS2_JOURNAL_ACCESS_WRITE);
3423 if (ret) {
3424 mlog_errno(ret);
3425 goto out;
3426 }
3427
3428 inode->i_ctime = current_time(inode);
3429 di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
3430 di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
3431 ocfs2_journal_dirty(ctxt->handle, xis->inode_bh);
3432 }
3433 out:
3434 return ret;
3435 }
3436
3437 /*
3438 * This function only called duing creating inode
3439 * for init security/acl xattrs of the new inode.
3440 * All transanction credits have been reserved in mknod.
3441 */
3442 int ocfs2_xattr_set_handle(handle_t *handle,
3443 struct inode *inode,
3444 struct buffer_head *di_bh,
3445 int name_index,
3446 const char *name,
3447 const void *value,
3448 size_t value_len,
3449 int flags,
3450 struct ocfs2_alloc_context *meta_ac,
3451 struct ocfs2_alloc_context *data_ac)
3452 {
3453 struct ocfs2_dinode *di;
3454 int ret;
3455
3456 struct ocfs2_xattr_info xi = {
3457 .xi_name_index = name_index,
3458 .xi_name = name,
3459 .xi_name_len = strlen(name),
3460 .xi_value = value,
3461 .xi_value_len = value_len,
3462 };
3463
3464 struct ocfs2_xattr_search xis = {
3465 .not_found = -ENODATA,
3466 };
3467
3468 struct ocfs2_xattr_search xbs = {
3469 .not_found = -ENODATA,
3470 };
3471
3472 struct ocfs2_xattr_set_ctxt ctxt = {
3473 .handle = handle,
3474 .meta_ac = meta_ac,
3475 .data_ac = data_ac,
3476 };
3477
3478 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
3479 return -EOPNOTSUPP;
3480
3481 /*
3482 * In extreme situation, may need xattr bucket when
3483 * block size is too small. And we have already reserved
3484 * the credits for bucket in mknod.
3485 */
3486 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) {
3487 xbs.bucket = ocfs2_xattr_bucket_new(inode);
3488 if (!xbs.bucket) {
3489 mlog_errno(-ENOMEM);
3490 return -ENOMEM;
3491 }
3492 }
3493
3494 xis.inode_bh = xbs.inode_bh = di_bh;
3495 di = (struct ocfs2_dinode *)di_bh->b_data;
3496
3497 down_write(&OCFS2_I(inode)->ip_xattr_sem);
3498
3499 ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
3500 if (ret)
3501 goto cleanup;
3502 if (xis.not_found) {
3503 ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
3504 if (ret)
3505 goto cleanup;
3506 }
3507
3508 ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
3509
3510 cleanup:
3511 up_write(&OCFS2_I(inode)->ip_xattr_sem);
3512 brelse(xbs.xattr_bh);
3513 ocfs2_xattr_bucket_free(xbs.bucket);
3514
3515 return ret;
3516 }
3517
3518 /*
3519 * ocfs2_xattr_set()
3520 *
3521 * Set, replace or remove an extended attribute for this inode.
3522 * value is NULL to remove an existing extended attribute, else either
3523 * create or replace an extended attribute.
3524 */
3525 int ocfs2_xattr_set(struct inode *inode,
3526 int name_index,
3527 const char *name,
3528 const void *value,
3529 size_t value_len,
3530 int flags)
3531 {
3532 struct buffer_head *di_bh = NULL;
3533 struct ocfs2_dinode *di;
3534 int ret, credits, had_lock, ref_meta = 0, ref_credits = 0;
3535 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3536 struct inode *tl_inode = osb->osb_tl_inode;
3537 struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, NULL, };
3538 struct ocfs2_refcount_tree *ref_tree = NULL;
3539 struct ocfs2_lock_holder oh;
3540
3541 struct ocfs2_xattr_info xi = {
3542 .xi_name_index = name_index,
3543 .xi_name = name,
3544 .xi_name_len = strlen(name),
3545 .xi_value = value,
3546 .xi_value_len = value_len,
3547 };
3548
3549 struct ocfs2_xattr_search xis = {
3550 .not_found = -ENODATA,
3551 };
3552
3553 struct ocfs2_xattr_search xbs = {
3554 .not_found = -ENODATA,
3555 };
3556
3557 if (!ocfs2_supports_xattr(osb))
3558 return -EOPNOTSUPP;
3559
3560 /*
3561 * Only xbs will be used on indexed trees. xis doesn't need a
3562 * bucket.
3563 */
3564 xbs.bucket = ocfs2_xattr_bucket_new(inode);
3565 if (!xbs.bucket) {
3566 mlog_errno(-ENOMEM);
3567 return -ENOMEM;
3568 }
3569
3570 had_lock = ocfs2_inode_lock_tracker(inode, &di_bh, 1, &oh);
3571 if (had_lock < 0) {
3572 ret = had_lock;
3573 mlog_errno(ret);
3574 goto cleanup_nolock;
3575 }
3576 xis.inode_bh = xbs.inode_bh = di_bh;
3577 di = (struct ocfs2_dinode *)di_bh->b_data;
3578
3579 down_write(&OCFS2_I(inode)->ip_xattr_sem);
3580 /*
3581 * Scan inode and external block to find the same name
3582 * extended attribute and collect search information.
3583 */
3584 ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
3585 if (ret)
3586 goto cleanup;
3587 if (xis.not_found) {
3588 ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
3589 if (ret)
3590 goto cleanup;
3591 }
3592
3593 if (xis.not_found && xbs.not_found) {
3594 ret = -ENODATA;
3595 if (flags & XATTR_REPLACE)
3596 goto cleanup;
3597 ret = 0;
3598 if (!value)
3599 goto cleanup;
3600 } else {
3601 ret = -EEXIST;
3602 if (flags & XATTR_CREATE)
3603 goto cleanup;
3604 }
3605
3606 /* Check whether the value is refcounted and do some preparation. */
3607 if (ocfs2_is_refcount_inode(inode) &&
3608 (!xis.not_found || !xbs.not_found)) {
3609 ret = ocfs2_prepare_refcount_xattr(inode, di, &xi,
3610 &xis, &xbs, &ref_tree,
3611 &ref_meta, &ref_credits);
3612 if (ret) {
3613 mlog_errno(ret);
3614 goto cleanup;
3615 }
3616 }
3617
3618 inode_lock(tl_inode);
3619
3620 if (ocfs2_truncate_log_needs_flush(osb)) {
3621 ret = __ocfs2_flush_truncate_log(osb);
3622 if (ret < 0) {
3623 inode_unlock(tl_inode);
3624 mlog_errno(ret);
3625 goto cleanup;
3626 }
3627 }
3628 inode_unlock(tl_inode);
3629
3630 ret = ocfs2_init_xattr_set_ctxt(inode, di, &xi, &xis,
3631 &xbs, &ctxt, ref_meta, &credits);
3632 if (ret) {
3633 mlog_errno(ret);
3634 goto cleanup;
3635 }
3636
3637 /* we need to update inode's ctime field, so add credit for it. */
3638 credits += OCFS2_INODE_UPDATE_CREDITS;
3639 ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits);
3640 if (IS_ERR(ctxt.handle)) {
3641 ret = PTR_ERR(ctxt.handle);
3642 mlog_errno(ret);
3643 goto out_free_ac;
3644 }
3645
3646 ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
3647 ocfs2_update_inode_fsync_trans(ctxt.handle, inode, 0);
3648
3649 ocfs2_commit_trans(osb, ctxt.handle);
3650
3651 out_free_ac:
3652 if (ctxt.data_ac)
3653 ocfs2_free_alloc_context(ctxt.data_ac);
3654 if (ctxt.meta_ac)
3655 ocfs2_free_alloc_context(ctxt.meta_ac);
3656 if (ocfs2_dealloc_has_cluster(&ctxt.dealloc))
3657 ocfs2_schedule_truncate_log_flush(osb, 1);
3658 ocfs2_run_deallocs(osb, &ctxt.dealloc);
3659
3660 cleanup:
3661 if (ref_tree)
3662 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
3663 up_write(&OCFS2_I(inode)->ip_xattr_sem);
3664 if (!value && !ret) {
3665 ret = ocfs2_try_remove_refcount_tree(inode, di_bh);
3666 if (ret)
3667 mlog_errno(ret);
3668 }
3669 ocfs2_inode_unlock_tracker(inode, 1, &oh, had_lock);
3670 cleanup_nolock:
3671 brelse(di_bh);
3672 brelse(xbs.xattr_bh);
3673 ocfs2_xattr_bucket_free(xbs.bucket);
3674
3675 return ret;
3676 }
3677
3678 /*
3679 * Find the xattr extent rec which may contains name_hash.
3680 * e_cpos will be the first name hash of the xattr rec.
3681 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
3682 */
3683 static int ocfs2_xattr_get_rec(struct inode *inode,
3684 u32 name_hash,
3685 u64 *p_blkno,
3686 u32 *e_cpos,
3687 u32 *num_clusters,
3688 struct ocfs2_extent_list *el)
3689 {
3690 int ret = 0, i;
3691 struct buffer_head *eb_bh = NULL;
3692 struct ocfs2_extent_block *eb;
3693 struct ocfs2_extent_rec *rec = NULL;
3694 u64 e_blkno = 0;
3695
3696 if (el->l_tree_depth) {
3697 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, name_hash,
3698 &eb_bh);
3699 if (ret) {
3700 mlog_errno(ret);
3701 goto out;
3702 }
3703
3704 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
3705 el = &eb->h_list;
3706
3707 if (el->l_tree_depth) {
3708 ret = ocfs2_error(inode->i_sb,
3709 "Inode %lu has non zero tree depth in xattr tree block %llu\n",
3710 inode->i_ino,
3711 (unsigned long long)eb_bh->b_blocknr);
3712 goto out;
3713 }
3714 }
3715
3716 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
3717 rec = &el->l_recs[i];
3718
3719 if (le32_to_cpu(rec->e_cpos) <= name_hash) {
3720 e_blkno = le64_to_cpu(rec->e_blkno);
3721 break;
3722 }
3723 }
3724
3725 if (!e_blkno) {
3726 ret = ocfs2_error(inode->i_sb, "Inode %lu has bad extent record (%u, %u, 0) in xattr\n",
3727 inode->i_ino,
3728 le32_to_cpu(rec->e_cpos),
3729 ocfs2_rec_clusters(el, rec));
3730 goto out;
3731 }
3732
3733 *p_blkno = le64_to_cpu(rec->e_blkno);
3734 *num_clusters = le16_to_cpu(rec->e_leaf_clusters);
3735 if (e_cpos)
3736 *e_cpos = le32_to_cpu(rec->e_cpos);
3737 out:
3738 brelse(eb_bh);
3739 return ret;
3740 }
3741
3742 typedef int (xattr_bucket_func)(struct inode *inode,
3743 struct ocfs2_xattr_bucket *bucket,
3744 void *para);
3745
3746 static int ocfs2_find_xe_in_bucket(struct inode *inode,
3747 struct ocfs2_xattr_bucket *bucket,
3748 int name_index,
3749 const char *name,
3750 u32 name_hash,
3751 u16 *xe_index,
3752 int *found)
3753 {
3754 int i, ret = 0, cmp = 1, block_off, new_offset;
3755 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
3756 size_t name_len = strlen(name);
3757 struct ocfs2_xattr_entry *xe = NULL;
3758 char *xe_name;
3759
3760 /*
3761 * We don't use binary search in the bucket because there
3762 * may be multiple entries with the same name hash.
3763 */
3764 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
3765 xe = &xh->xh_entries[i];
3766
3767 if (name_hash > le32_to_cpu(xe->xe_name_hash))
3768 continue;
3769 else if (name_hash < le32_to_cpu(xe->xe_name_hash))
3770 break;
3771
3772 cmp = name_index - ocfs2_xattr_get_type(xe);
3773 if (!cmp)
3774 cmp = name_len - xe->xe_name_len;
3775 if (cmp)
3776 continue;
3777
3778 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
3779 xh,
3780 i,
3781 &block_off,
3782 &new_offset);
3783 if (ret) {
3784 mlog_errno(ret);
3785 break;
3786 }
3787
3788
3789 xe_name = bucket_block(bucket, block_off) + new_offset;
3790 if (!memcmp(name, xe_name, name_len)) {
3791 *xe_index = i;
3792 *found = 1;
3793 ret = 0;
3794 break;
3795 }
3796 }
3797
3798 return ret;
3799 }
3800
3801 /*
3802 * Find the specified xattr entry in a series of buckets.
3803 * This series start from p_blkno and last for num_clusters.
3804 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
3805 * the num of the valid buckets.
3806 *
3807 * Return the buffer_head this xattr should reside in. And if the xattr's
3808 * hash is in the gap of 2 buckets, return the lower bucket.
3809 */
3810 static int ocfs2_xattr_bucket_find(struct inode *inode,
3811 int name_index,
3812 const char *name,
3813 u32 name_hash,
3814 u64 p_blkno,
3815 u32 first_hash,
3816 u32 num_clusters,
3817 struct ocfs2_xattr_search *xs)
3818 {
3819 int ret, found = 0;
3820 struct ocfs2_xattr_header *xh = NULL;
3821 struct ocfs2_xattr_entry *xe = NULL;
3822 u16 index = 0;
3823 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3824 int low_bucket = 0, bucket, high_bucket;
3825 struct ocfs2_xattr_bucket *search;
3826 u64 blkno, lower_blkno = 0;
3827
3828 search = ocfs2_xattr_bucket_new(inode);
3829 if (!search) {
3830 ret = -ENOMEM;
3831 mlog_errno(ret);
3832 goto out;
3833 }
3834
3835 ret = ocfs2_read_xattr_bucket(search, p_blkno);
3836 if (ret) {
3837 mlog_errno(ret);
3838 goto out;
3839 }
3840
3841 xh = bucket_xh(search);
3842 high_bucket = le16_to_cpu(xh->xh_num_buckets) - 1;
3843 while (low_bucket <= high_bucket) {
3844 ocfs2_xattr_bucket_relse(search);
3845
3846 bucket = (low_bucket + high_bucket) / 2;
3847 blkno = p_blkno + bucket * blk_per_bucket;
3848 ret = ocfs2_read_xattr_bucket(search, blkno);
3849 if (ret) {
3850 mlog_errno(ret);
3851 goto out;
3852 }
3853
3854 xh = bucket_xh(search);
3855 xe = &xh->xh_entries[0];
3856 if (name_hash < le32_to_cpu(xe->xe_name_hash)) {
3857 high_bucket = bucket - 1;
3858 continue;
3859 }
3860
3861 /*
3862 * Check whether the hash of the last entry in our
3863 * bucket is larger than the search one. for an empty
3864 * bucket, the last one is also the first one.
3865 */
3866 if (xh->xh_count)
3867 xe = &xh->xh_entries[le16_to_cpu(xh->xh_count) - 1];
3868
3869 /* record lower_blkno which may be the insert place. */
3870 lower_blkno = blkno;
3871
3872 if (name_hash > le32_to_cpu(xe->xe_name_hash)) {
3873 low_bucket = bucket + 1;
3874 continue;
3875 }
3876
3877 /* the searched xattr should reside in this bucket if exists. */
3878 ret = ocfs2_find_xe_in_bucket(inode, search,
3879 name_index, name, name_hash,
3880 &index, &found);
3881 if (ret) {
3882 mlog_errno(ret);
3883 goto out;
3884 }
3885 break;
3886 }
3887
3888 /*
3889 * Record the bucket we have found.
3890 * When the xattr's hash value is in the gap of 2 buckets, we will
3891 * always set it to the previous bucket.
3892 */
3893 if (!lower_blkno)
3894 lower_blkno = p_blkno;
3895
3896 /* This should be in cache - we just read it during the search */
3897 ret = ocfs2_read_xattr_bucket(xs->bucket, lower_blkno);
3898 if (ret) {
3899 mlog_errno(ret);
3900 goto out;
3901 }
3902
3903 xs->header = bucket_xh(xs->bucket);
3904 xs->base = bucket_block(xs->bucket, 0);
3905 xs->end = xs->base + inode->i_sb->s_blocksize;
3906
3907 if (found) {
3908 xs->here = &xs->header->xh_entries[index];
3909 trace_ocfs2_xattr_bucket_find(OCFS2_I(inode)->ip_blkno,
3910 name, name_index, name_hash,
3911 (unsigned long long)bucket_blkno(xs->bucket),
3912 index);
3913 } else
3914 ret = -ENODATA;
3915
3916 out:
3917 ocfs2_xattr_bucket_free(search);
3918 return ret;
3919 }
3920
3921 static int ocfs2_xattr_index_block_find(struct inode *inode,
3922 struct buffer_head *root_bh,
3923 int name_index,
3924 const char *name,
3925 struct ocfs2_xattr_search *xs)
3926 {
3927 int ret;
3928 struct ocfs2_xattr_block *xb =
3929 (struct ocfs2_xattr_block *)root_bh->b_data;
3930 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
3931 struct ocfs2_extent_list *el = &xb_root->xt_list;
3932 u64 p_blkno = 0;
3933 u32 first_hash, num_clusters = 0;
3934 u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name));
3935
3936 if (le16_to_cpu(el->l_next_free_rec) == 0)
3937 return -ENODATA;
3938
3939 trace_ocfs2_xattr_index_block_find(OCFS2_I(inode)->ip_blkno,
3940 name, name_index, name_hash,
3941 (unsigned long long)root_bh->b_blocknr,
3942 -1);
3943
3944 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &first_hash,
3945 &num_clusters, el);
3946 if (ret) {
3947 mlog_errno(ret);
3948 goto out;
3949 }
3950
3951 BUG_ON(p_blkno == 0 || num_clusters == 0 || first_hash > name_hash);
3952
3953 trace_ocfs2_xattr_index_block_find_rec(OCFS2_I(inode)->ip_blkno,
3954 name, name_index, first_hash,
3955 (unsigned long long)p_blkno,
3956 num_clusters);
3957
3958 ret = ocfs2_xattr_bucket_find(inode, name_index, name, name_hash,
3959 p_blkno, first_hash, num_clusters, xs);
3960
3961 out:
3962 return ret;
3963 }
3964
3965 static int ocfs2_iterate_xattr_buckets(struct inode *inode,
3966 u64 blkno,
3967 u32 clusters,
3968 xattr_bucket_func *func,
3969 void *para)
3970 {
3971 int i, ret = 0;
3972 u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
3973 u32 num_buckets = clusters * bpc;
3974 struct ocfs2_xattr_bucket *bucket;
3975
3976 bucket = ocfs2_xattr_bucket_new(inode);
3977 if (!bucket) {
3978 mlog_errno(-ENOMEM);
3979 return -ENOMEM;
3980 }
3981
3982 trace_ocfs2_iterate_xattr_buckets(
3983 (unsigned long long)OCFS2_I(inode)->ip_blkno,
3984 (unsigned long long)blkno, clusters);
3985
3986 for (i = 0; i < num_buckets; i++, blkno += bucket->bu_blocks) {
3987 ret = ocfs2_read_xattr_bucket(bucket, blkno);
3988 if (ret) {
3989 mlog_errno(ret);
3990 break;
3991 }
3992
3993 /*
3994 * The real bucket num in this series of blocks is stored
3995 * in the 1st bucket.
3996 */
3997 if (i == 0)
3998 num_buckets = le16_to_cpu(bucket_xh(bucket)->xh_num_buckets);
3999
4000 trace_ocfs2_iterate_xattr_bucket((unsigned long long)blkno,
4001 le32_to_cpu(bucket_xh(bucket)->xh_entries[0].xe_name_hash));
4002 if (func) {
4003 ret = func(inode, bucket, para);
4004 if (ret && ret != -ERANGE)
4005 mlog_errno(ret);
4006 /* Fall through to bucket_relse() */
4007 }
4008
4009 ocfs2_xattr_bucket_relse(bucket);
4010 if (ret)
4011 break;
4012 }
4013
4014 ocfs2_xattr_bucket_free(bucket);
4015 return ret;
4016 }
4017
4018 struct ocfs2_xattr_tree_list {
4019 char *buffer;
4020 size_t buffer_size;
4021 size_t result;
4022 };
4023
4024 static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb,
4025 struct ocfs2_xattr_header *xh,
4026 int index,
4027 int *block_off,
4028 int *new_offset)
4029 {
4030 u16 name_offset;
4031
4032 if (index < 0 || index >= le16_to_cpu(xh->xh_count))
4033 return -EINVAL;
4034
4035 name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset);
4036
4037 *block_off = name_offset >> sb->s_blocksize_bits;
4038 *new_offset = name_offset % sb->s_blocksize;
4039
4040 return 0;
4041 }
4042
4043 static int ocfs2_list_xattr_bucket(struct inode *inode,
4044 struct ocfs2_xattr_bucket *bucket,
4045 void *para)
4046 {
4047 int ret = 0, type;
4048 struct ocfs2_xattr_tree_list *xl = (struct ocfs2_xattr_tree_list *)para;
4049 int i, block_off, new_offset;
4050 const char *name;
4051
4052 for (i = 0 ; i < le16_to_cpu(bucket_xh(bucket)->xh_count); i++) {
4053 struct ocfs2_xattr_entry *entry = &bucket_xh(bucket)->xh_entries[i];
4054 type = ocfs2_xattr_get_type(entry);
4055
4056 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
4057 bucket_xh(bucket),
4058 i,
4059 &block_off,
4060 &new_offset);
4061 if (ret)
4062 break;
4063
4064 name = (const char *)bucket_block(bucket, block_off) +
4065 new_offset;
4066 ret = ocfs2_xattr_list_entry(inode->i_sb,
4067 xl->buffer,
4068 xl->buffer_size,
4069 &xl->result,
4070 type, name,
4071 entry->xe_name_len);
4072 if (ret)
4073 break;
4074 }
4075
4076 return ret;
4077 }
4078
4079 static int ocfs2_iterate_xattr_index_block(struct inode *inode,
4080 struct buffer_head *blk_bh,
4081 xattr_tree_rec_func *rec_func,
4082 void *para)
4083 {
4084 struct ocfs2_xattr_block *xb =
4085 (struct ocfs2_xattr_block *)blk_bh->b_data;
4086 struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list;
4087 int ret = 0;
4088 u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0;
4089 u64 p_blkno = 0;
4090
4091 if (!el->l_next_free_rec || !rec_func)
4092 return 0;
4093
4094 while (name_hash > 0) {
4095 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
4096 &e_cpos, &num_clusters, el);
4097 if (ret) {
4098 mlog_errno(ret);
4099 break;
4100 }
4101
4102 ret = rec_func(inode, blk_bh, p_blkno, e_cpos,
4103 num_clusters, para);
4104 if (ret) {
4105 if (ret != -ERANGE)
4106 mlog_errno(ret);
4107 break;
4108 }
4109
4110 if (e_cpos == 0)
4111 break;
4112
4113 name_hash = e_cpos - 1;
4114 }
4115
4116 return ret;
4117
4118 }
4119
4120 static int ocfs2_list_xattr_tree_rec(struct inode *inode,
4121 struct buffer_head *root_bh,
4122 u64 blkno, u32 cpos, u32 len, void *para)
4123 {
4124 return ocfs2_iterate_xattr_buckets(inode, blkno, len,
4125 ocfs2_list_xattr_bucket, para);
4126 }
4127
4128 static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
4129 struct buffer_head *blk_bh,
4130 char *buffer,
4131 size_t buffer_size)
4132 {
4133 int ret;
4134 struct ocfs2_xattr_tree_list xl = {
4135 .buffer = buffer,
4136 .buffer_size = buffer_size,
4137 .result = 0,
4138 };
4139
4140 ret = ocfs2_iterate_xattr_index_block(inode, blk_bh,
4141 ocfs2_list_xattr_tree_rec, &xl);
4142 if (ret) {
4143 mlog_errno(ret);
4144 goto out;
4145 }
4146
4147 ret = xl.result;
4148 out:
4149 return ret;
4150 }
4151
4152 static int cmp_xe(const void *a, const void *b)
4153 {
4154 const struct ocfs2_xattr_entry *l = a, *r = b;
4155 u32 l_hash = le32_to_cpu(l->xe_name_hash);
4156 u32 r_hash = le32_to_cpu(r->xe_name_hash);
4157
4158 if (l_hash > r_hash)
4159 return 1;
4160 if (l_hash < r_hash)
4161 return -1;
4162 return 0;
4163 }
4164
4165 static void swap_xe(void *a, void *b, int size)
4166 {
4167 struct ocfs2_xattr_entry *l = a, *r = b, tmp;
4168
4169 tmp = *l;
4170 memcpy(l, r, sizeof(struct ocfs2_xattr_entry));
4171 memcpy(r, &tmp, sizeof(struct ocfs2_xattr_entry));
4172 }
4173
4174 /*
4175 * When the ocfs2_xattr_block is filled up, new bucket will be created
4176 * and all the xattr entries will be moved to the new bucket.
4177 * The header goes at the start of the bucket, and the names+values are
4178 * filled from the end. This is why *target starts as the last buffer.
4179 * Note: we need to sort the entries since they are not saved in order
4180 * in the ocfs2_xattr_block.
4181 */
4182 static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode,
4183 struct buffer_head *xb_bh,
4184 struct ocfs2_xattr_bucket *bucket)
4185 {
4186 int i, blocksize = inode->i_sb->s_blocksize;
4187 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
4188 u16 offset, size, off_change;
4189 struct ocfs2_xattr_entry *xe;
4190 struct ocfs2_xattr_block *xb =
4191 (struct ocfs2_xattr_block *)xb_bh->b_data;
4192 struct ocfs2_xattr_header *xb_xh = &xb->xb_attrs.xb_header;
4193 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
4194 u16 count = le16_to_cpu(xb_xh->xh_count);
4195 char *src = xb_bh->b_data;
4196 char *target = bucket_block(bucket, blks - 1);
4197
4198 trace_ocfs2_cp_xattr_block_to_bucket_begin(
4199 (unsigned long long)xb_bh->b_blocknr,
4200 (unsigned long long)bucket_blkno(bucket));
4201
4202 for (i = 0; i < blks; i++)
4203 memset(bucket_block(bucket, i), 0, blocksize);
4204
4205 /*
4206 * Since the xe_name_offset is based on ocfs2_xattr_header,
4207 * there is a offset change corresponding to the change of
4208 * ocfs2_xattr_header's position.
4209 */
4210 off_change = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
4211 xe = &xb_xh->xh_entries[count - 1];
4212 offset = le16_to_cpu(xe->xe_name_offset) + off_change;
4213 size = blocksize - offset;
4214
4215 /* copy all the names and values. */
4216 memcpy(target + offset, src + offset, size);
4217
4218 /* Init new header now. */
4219 xh->xh_count = xb_xh->xh_count;
4220 xh->xh_num_buckets = cpu_to_le16(1);
4221 xh->xh_name_value_len = cpu_to_le16(size);
4222 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE - size);
4223
4224 /* copy all the entries. */
4225 target = bucket_block(bucket, 0);
4226 offset = offsetof(struct ocfs2_xattr_header, xh_entries);
4227 size = count * sizeof(struct ocfs2_xattr_entry);
4228 memcpy(target + offset, (char *)xb_xh + offset, size);
4229
4230 /* Change the xe offset for all the xe because of the move. */
4231 off_change = OCFS2_XATTR_BUCKET_SIZE - blocksize +
4232 offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
4233 for (i = 0; i < count; i++)
4234 le16_add_cpu(&xh->xh_entries[i].xe_name_offset, off_change);
4235
4236 trace_ocfs2_cp_xattr_block_to_bucket_end(offset, size, off_change);
4237
4238 sort(target + offset, count, sizeof(struct ocfs2_xattr_entry),
4239 cmp_xe, swap_xe);
4240 }
4241
4242 /*
4243 * After we move xattr from block to index btree, we have to
4244 * update ocfs2_xattr_search to the new xe and base.
4245 *
4246 * When the entry is in xattr block, xattr_bh indicates the storage place.
4247 * While if the entry is in index b-tree, "bucket" indicates the
4248 * real place of the xattr.
4249 */
4250 static void ocfs2_xattr_update_xattr_search(struct inode *inode,
4251 struct ocfs2_xattr_search *xs,
4252 struct buffer_head *old_bh)
4253 {
4254 char *buf = old_bh->b_data;
4255 struct ocfs2_xattr_block *old_xb = (struct ocfs2_xattr_block *)buf;
4256 struct ocfs2_xattr_header *old_xh = &old_xb->xb_attrs.xb_header;
4257 int i;
4258
4259 xs->header = bucket_xh(xs->bucket);
4260 xs->base = bucket_block(xs->bucket, 0);
4261 xs->end = xs->base + inode->i_sb->s_blocksize;
4262
4263 if (xs->not_found)
4264 return;
4265
4266 i = xs->here - old_xh->xh_entries;
4267 xs->here = &xs->header->xh_entries[i];
4268 }
4269
4270 static int ocfs2_xattr_create_index_block(struct inode *inode,
4271 struct ocfs2_xattr_search *xs,
4272 struct ocfs2_xattr_set_ctxt *ctxt)
4273 {
4274 int ret;
4275 u32 bit_off, len;
4276 u64 blkno;
4277 handle_t *handle = ctxt->handle;
4278 struct ocfs2_inode_info *oi = OCFS2_I(inode);
4279 struct buffer_head *xb_bh = xs->xattr_bh;
4280 struct ocfs2_xattr_block *xb =
4281 (struct ocfs2_xattr_block *)xb_bh->b_data;
4282 struct ocfs2_xattr_tree_root *xr;
4283 u16 xb_flags = le16_to_cpu(xb->xb_flags);
4284
4285 trace_ocfs2_xattr_create_index_block_begin(
4286 (unsigned long long)xb_bh->b_blocknr);
4287
4288 BUG_ON(xb_flags & OCFS2_XATTR_INDEXED);
4289 BUG_ON(!xs->bucket);
4290
4291 /*
4292 * XXX:
4293 * We can use this lock for now, and maybe move to a dedicated mutex
4294 * if performance becomes a problem later.
4295 */
4296 down_write(&oi->ip_alloc_sem);
4297
4298 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), xb_bh,
4299 OCFS2_JOURNAL_ACCESS_WRITE);
4300 if (ret) {
4301 mlog_errno(ret);
4302 goto out;
4303 }
4304
4305 ret = __ocfs2_claim_clusters(handle, ctxt->data_ac,
4306 1, 1, &bit_off, &len);
4307 if (ret) {
4308 mlog_errno(ret);
4309 goto out;
4310 }
4311
4312 /*
4313 * The bucket may spread in many blocks, and
4314 * we will only touch the 1st block and the last block
4315 * in the whole bucket(one for entry and one for data).
4316 */
4317 blkno = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
4318
4319 trace_ocfs2_xattr_create_index_block((unsigned long long)blkno);
4320
4321 ret = ocfs2_init_xattr_bucket(xs->bucket, blkno, 1);
4322 if (ret) {
4323 mlog_errno(ret);
4324 goto out;
4325 }
4326
4327 ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
4328 OCFS2_JOURNAL_ACCESS_CREATE);
4329 if (ret) {
4330 mlog_errno(ret);
4331 goto out;
4332 }
4333
4334 ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xs->bucket);
4335 ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
4336
4337 ocfs2_xattr_update_xattr_search(inode, xs, xb_bh);
4338
4339 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
4340 memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize -
4341 offsetof(struct ocfs2_xattr_block, xb_attrs));
4342
4343 xr = &xb->xb_attrs.xb_root;
4344 xr->xt_clusters = cpu_to_le32(1);
4345 xr->xt_last_eb_blk = 0;
4346 xr->xt_list.l_tree_depth = 0;
4347 xr->xt_list.l_count = cpu_to_le16(ocfs2_xattr_recs_per_xb(inode->i_sb));
4348 xr->xt_list.l_next_free_rec = cpu_to_le16(1);
4349
4350 xr->xt_list.l_recs[0].e_cpos = 0;
4351 xr->xt_list.l_recs[0].e_blkno = cpu_to_le64(blkno);
4352 xr->xt_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1);
4353
4354 xb->xb_flags = cpu_to_le16(xb_flags | OCFS2_XATTR_INDEXED);
4355
4356 ocfs2_journal_dirty(handle, xb_bh);
4357
4358 out:
4359 up_write(&oi->ip_alloc_sem);
4360
4361 return ret;
4362 }
4363
4364 static int cmp_xe_offset(const void *a, const void *b)
4365 {
4366 const struct ocfs2_xattr_entry *l = a, *r = b;
4367 u32 l_name_offset = le16_to_cpu(l->xe_name_offset);
4368 u32 r_name_offset = le16_to_cpu(r->xe_name_offset);
4369
4370 if (l_name_offset < r_name_offset)
4371 return 1;
4372 if (l_name_offset > r_name_offset)
4373 return -1;
4374 return 0;
4375 }
4376
4377 /*
4378 * defrag a xattr bucket if we find that the bucket has some
4379 * holes beteen name/value pairs.
4380 * We will move all the name/value pairs to the end of the bucket
4381 * so that we can spare some space for insertion.
4382 */
4383 static int ocfs2_defrag_xattr_bucket(struct inode *inode,
4384 handle_t *handle,
4385 struct ocfs2_xattr_bucket *bucket)
4386 {
4387 int ret, i;
4388 size_t end, offset, len;
4389 struct ocfs2_xattr_header *xh;
4390 char *entries, *buf, *bucket_buf = NULL;
4391 u64 blkno = bucket_blkno(bucket);
4392 u16 xh_free_start;
4393 size_t blocksize = inode->i_sb->s_blocksize;
4394 struct ocfs2_xattr_entry *xe;
4395
4396 /*
4397 * In order to make the operation more efficient and generic,
4398 * we copy all the blocks into a contiguous memory and do the
4399 * defragment there, so if anything is error, we will not touch
4400 * the real block.
4401 */
4402 bucket_buf = kmalloc(OCFS2_XATTR_BUCKET_SIZE, GFP_NOFS);
4403 if (!bucket_buf) {
4404 ret = -EIO;
4405 goto out;
4406 }
4407
4408 buf = bucket_buf;
4409 for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)
4410 memcpy(buf, bucket_block(bucket, i), blocksize);
4411
4412 ret = ocfs2_xattr_bucket_journal_access(handle, bucket,
4413 OCFS2_JOURNAL_ACCESS_WRITE);
4414 if (ret < 0) {
4415 mlog_errno(ret);
4416 goto out;
4417 }
4418
4419 xh = (struct ocfs2_xattr_header *)bucket_buf;
4420 entries = (char *)xh->xh_entries;
4421 xh_free_start = le16_to_cpu(xh->xh_free_start);
4422
4423 trace_ocfs2_defrag_xattr_bucket(
4424 (unsigned long long)blkno, le16_to_cpu(xh->xh_count),
4425 xh_free_start, le16_to_cpu(xh->xh_name_value_len));
4426
4427 /*
4428 * sort all the entries by their offset.
4429 * the largest will be the first, so that we can
4430 * move them to the end one by one.
4431 */
4432 sort(entries, le16_to_cpu(xh->xh_count),
4433 sizeof(struct ocfs2_xattr_entry),
4434 cmp_xe_offset, swap_xe);
4435
4436 /* Move all name/values to the end of the bucket. */
4437 xe = xh->xh_entries;
4438 end = OCFS2_XATTR_BUCKET_SIZE;
4439 for (i = 0; i < le16_to_cpu(xh->xh_count); i++, xe++) {
4440 offset = le16_to_cpu(xe->xe_name_offset);
4441 len = namevalue_size_xe(xe);
4442
4443 /*
4444 * We must make sure that the name/value pair
4445 * exist in the same block. So adjust end to
4446 * the previous block end if needed.
4447 */
4448 if (((end - len) / blocksize !=
4449 (end - 1) / blocksize))
4450 end = end - end % blocksize;
4451
4452 if (end > offset + len) {
4453 memmove(bucket_buf + end - len,
4454 bucket_buf + offset, len);
4455 xe->xe_name_offset = cpu_to_le16(end - len);
4456 }
4457
4458 mlog_bug_on_msg(end < offset + len, "Defrag check failed for "
4459 "bucket %llu\n", (unsigned long long)blkno);
4460
4461 end -= len;
4462 }
4463
4464 mlog_bug_on_msg(xh_free_start > end, "Defrag check failed for "
4465 "bucket %llu\n", (unsigned long long)blkno);
4466
4467 if (xh_free_start == end)
4468 goto out;
4469
4470 memset(bucket_buf + xh_free_start, 0, end - xh_free_start);
4471 xh->xh_free_start = cpu_to_le16(end);
4472
4473 /* sort the entries by their name_hash. */
4474 sort(entries, le16_to_cpu(xh->xh_count),
4475 sizeof(struct ocfs2_xattr_entry),
4476 cmp_xe, swap_xe);
4477
4478 buf = bucket_buf;
4479 for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)
4480 memcpy(bucket_block(bucket, i), buf, blocksize);
4481 ocfs2_xattr_bucket_journal_dirty(handle, bucket);
4482
4483 out:
4484 kfree(bucket_buf);
4485 return ret;
4486 }
4487
4488 /*
4489 * prev_blkno points to the start of an existing extent. new_blkno
4490 * points to a newly allocated extent. Because we know each of our
4491 * clusters contains more than bucket, we can easily split one cluster
4492 * at a bucket boundary. So we take the last cluster of the existing
4493 * extent and split it down the middle. We move the last half of the
4494 * buckets in the last cluster of the existing extent over to the new
4495 * extent.
4496 *
4497 * first_bh is the buffer at prev_blkno so we can update the existing
4498 * extent's bucket count. header_bh is the bucket were we were hoping
4499 * to insert our xattr. If the bucket move places the target in the new
4500 * extent, we'll update first_bh and header_bh after modifying the old
4501 * extent.
4502 *
4503 * first_hash will be set as the 1st xe's name_hash in the new extent.
4504 */
4505 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode *inode,
4506 handle_t *handle,
4507 struct ocfs2_xattr_bucket *first,
4508 struct ocfs2_xattr_bucket *target,
4509 u64 new_blkno,
4510 u32 num_clusters,
4511 u32 *first_hash)
4512 {
4513 int ret;
4514 struct super_block *sb = inode->i_sb;
4515 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(sb);
4516 int num_buckets = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb));
4517 int to_move = num_buckets / 2;
4518 u64 src_blkno;
4519 u64 last_cluster_blkno = bucket_blkno(first) +
4520 ((num_clusters - 1) * ocfs2_clusters_to_blocks(sb, 1));
4521
4522 BUG_ON(le16_to_cpu(bucket_xh(first)->xh_num_buckets) < num_buckets);
4523 BUG_ON(OCFS2_XATTR_BUCKET_SIZE == OCFS2_SB(sb)->s_clustersize);
4524
4525 trace_ocfs2_mv_xattr_bucket_cross_cluster(
4526 (unsigned long long)last_cluster_blkno,
4527 (unsigned long long)new_blkno);
4528
4529 ret = ocfs2_mv_xattr_buckets(inode, handle, bucket_blkno(first),
4530 last_cluster_blkno, new_blkno,
4531 to_move, first_hash);
4532 if (ret) {
4533 mlog_errno(ret);
4534 goto out;
4535 }
4536
4537 /* This is the first bucket that got moved */
4538 src_blkno = last_cluster_blkno + (to_move * blks_per_bucket);
4539
4540 /*
4541 * If the target bucket was part of the moved buckets, we need to
4542 * update first and target.
4543 */
4544 if (bucket_blkno(target) >= src_blkno) {
4545 /* Find the block for the new target bucket */
4546 src_blkno = new_blkno +
4547 (bucket_blkno(target) - src_blkno);
4548
4549 ocfs2_xattr_bucket_relse(first);
4550 ocfs2_xattr_bucket_relse(target);
4551
4552 /*
4553 * These shouldn't fail - the buffers are in the
4554 * journal from ocfs2_cp_xattr_bucket().
4555 */
4556 ret = ocfs2_read_xattr_bucket(first, new_blkno);
4557 if (ret) {
4558 mlog_errno(ret);
4559 goto out;
4560 }
4561 ret = ocfs2_read_xattr_bucket(target, src_blkno);
4562 if (ret)
4563 mlog_errno(ret);
4564
4565 }
4566
4567 out:
4568 return ret;
4569 }
4570
4571 /*
4572 * Find the suitable pos when we divide a bucket into 2.
4573 * We have to make sure the xattrs with the same hash value exist
4574 * in the same bucket.
4575 *
4576 * If this ocfs2_xattr_header covers more than one hash value, find a
4577 * place where the hash value changes. Try to find the most even split.
4578 * The most common case is that all entries have different hash values,
4579 * and the first check we make will find a place to split.
4580 */
4581 static int ocfs2_xattr_find_divide_pos(struct ocfs2_xattr_header *xh)
4582 {
4583 struct ocfs2_xattr_entry *entries = xh->xh_entries;
4584 int count = le16_to_cpu(xh->xh_count);
4585 int delta, middle = count / 2;
4586
4587 /*
4588 * We start at the middle. Each step gets farther away in both
4589 * directions. We therefore hit the change in hash value
4590 * nearest to the middle. Note that this loop does not execute for
4591 * count < 2.
4592 */
4593 for (delta = 0; delta < middle; delta++) {
4594 /* Let's check delta earlier than middle */
4595 if (cmp_xe(&entries[middle - delta - 1],
4596 &entries[middle - delta]))
4597 return middle - delta;
4598
4599 /* For even counts, don't walk off the end */
4600 if ((middle + delta + 1) == count)
4601 continue;
4602
4603 /* Now try delta past middle */
4604 if (cmp_xe(&entries[middle + delta],
4605 &entries[middle + delta + 1]))
4606 return middle + delta + 1;
4607 }
4608
4609 /* Every entry had the same hash */
4610 return count;
4611 }
4612
4613 /*
4614 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
4615 * first_hash will record the 1st hash of the new bucket.
4616 *
4617 * Normally half of the xattrs will be moved. But we have to make
4618 * sure that the xattrs with the same hash value are stored in the
4619 * same bucket. If all the xattrs in this bucket have the same hash
4620 * value, the new bucket will be initialized as an empty one and the
4621 * first_hash will be initialized as (hash_value+1).
4622 */
4623 static int ocfs2_divide_xattr_bucket(struct inode *inode,
4624 handle_t *handle,
4625 u64 blk,
4626 u64 new_blk,
4627 u32 *first_hash,
4628 int new_bucket_head)
4629 {
4630 int ret, i;
4631 int count, start, len, name_value_len = 0, name_offset = 0;
4632 struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
4633 struct ocfs2_xattr_header *xh;
4634 struct ocfs2_xattr_entry *xe;
4635 int blocksize = inode->i_sb->s_blocksize;
4636
4637 trace_ocfs2_divide_xattr_bucket_begin((unsigned long long)blk,
4638 (unsigned long long)new_blk);
4639
4640 s_bucket = ocfs2_xattr_bucket_new(inode);
4641 t_bucket = ocfs2_xattr_bucket_new(inode);
4642 if (!s_bucket || !t_bucket) {
4643 ret = -ENOMEM;
4644 mlog_errno(ret);
4645 goto out;
4646 }
4647
4648 ret = ocfs2_read_xattr_bucket(s_bucket, blk);
4649 if (ret) {
4650 mlog_errno(ret);
4651 goto out;
4652 }
4653
4654 ret = ocfs2_xattr_bucket_journal_access(handle, s_bucket,
4655 OCFS2_JOURNAL_ACCESS_WRITE);
4656 if (ret) {
4657 mlog_errno(ret);
4658 goto out;
4659 }
4660
4661 /*
4662 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
4663 * there's no need to read it.
4664 */
4665 ret = ocfs2_init_xattr_bucket(t_bucket, new_blk, new_bucket_head);
4666 if (ret) {
4667 mlog_errno(ret);
4668 goto out;
4669 }
4670
4671 /*
4672 * Hey, if we're overwriting t_bucket, what difference does
4673 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
4674 * same part of ocfs2_cp_xattr_bucket().
4675 */
4676 ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
4677 new_bucket_head ?
4678 OCFS2_JOURNAL_ACCESS_CREATE :
4679 OCFS2_JOURNAL_ACCESS_WRITE);
4680 if (ret) {
4681 mlog_errno(ret);
4682 goto out;
4683 }
4684
4685 xh = bucket_xh(s_bucket);
4686 count = le16_to_cpu(xh->xh_count);
4687 start = ocfs2_xattr_find_divide_pos(xh);
4688
4689 if (start == count) {
4690 xe = &xh->xh_entries[start-1];
4691
4692 /*
4693 * initialized a new empty bucket here.
4694 * The hash value is set as one larger than
4695 * that of the last entry in the previous bucket.
4696 */
4697 for (i = 0; i < t_bucket->bu_blocks; i++)
4698 memset(bucket_block(t_bucket, i), 0, blocksize);
4699
4700 xh = bucket_xh(t_bucket);
4701 xh->xh_free_start = cpu_to_le16(blocksize);
4702 xh->xh_entries[0].xe_name_hash = xe->xe_name_hash;
4703 le32_add_cpu(&xh->xh_entries[0].xe_name_hash, 1);
4704
4705 goto set_num_buckets;
4706 }
4707
4708 /* copy the whole bucket to the new first. */
4709 ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
4710
4711 /* update the new bucket. */
4712 xh = bucket_xh(t_bucket);
4713
4714 /*
4715 * Calculate the total name/value len and xh_free_start for
4716 * the old bucket first.
4717 */
4718 name_offset = OCFS2_XATTR_BUCKET_SIZE;
4719 name_value_len = 0;
4720 for (i = 0; i < start; i++) {
4721 xe = &xh->xh_entries[i];
4722 name_value_len += namevalue_size_xe(xe);
4723 if (le16_to_cpu(xe->xe_name_offset) < name_offset)
4724 name_offset = le16_to_cpu(xe->xe_name_offset);
4725 }
4726
4727 /*
4728 * Now begin the modification to the new bucket.
4729 *
4730 * In the new bucket, We just move the xattr entry to the beginning
4731 * and don't touch the name/value. So there will be some holes in the
4732 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
4733 * called.
4734 */
4735 xe = &xh->xh_entries[start];
4736 len = sizeof(struct ocfs2_xattr_entry) * (count - start);
4737 trace_ocfs2_divide_xattr_bucket_move(len,
4738 (int)((char *)xe - (char *)xh),
4739 (int)((char *)xh->xh_entries - (char *)xh));
4740 memmove((char *)xh->xh_entries, (char *)xe, len);
4741 xe = &xh->xh_entries[count - start];
4742 len = sizeof(struct ocfs2_xattr_entry) * start;
4743 memset((char *)xe, 0, len);
4744
4745 le16_add_cpu(&xh->xh_count, -start);
4746 le16_add_cpu(&xh->xh_name_value_len, -name_value_len);
4747
4748 /* Calculate xh_free_start for the new bucket. */
4749 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE);
4750 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
4751 xe = &xh->xh_entries[i];
4752 if (le16_to_cpu(xe->xe_name_offset) <
4753 le16_to_cpu(xh->xh_free_start))
4754 xh->xh_free_start = xe->xe_name_offset;
4755 }
4756
4757 set_num_buckets:
4758 /* set xh->xh_num_buckets for the new xh. */
4759 if (new_bucket_head)
4760 xh->xh_num_buckets = cpu_to_le16(1);
4761 else
4762 xh->xh_num_buckets = 0;
4763
4764 ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
4765
4766 /* store the first_hash of the new bucket. */
4767 if (first_hash)
4768 *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash);
4769
4770 /*
4771 * Now only update the 1st block of the old bucket. If we
4772 * just added a new empty bucket, there is no need to modify
4773 * it.
4774 */
4775 if (start == count)
4776 goto out;
4777
4778 xh = bucket_xh(s_bucket);
4779 memset(&xh->xh_entries[start], 0,
4780 sizeof(struct ocfs2_xattr_entry) * (count - start));
4781 xh->xh_count = cpu_to_le16(start);
4782 xh->xh_free_start = cpu_to_le16(name_offset);
4783 xh->xh_name_value_len = cpu_to_le16(name_value_len);
4784
4785 ocfs2_xattr_bucket_journal_dirty(handle, s_bucket);
4786
4787 out:
4788 ocfs2_xattr_bucket_free(s_bucket);
4789 ocfs2_xattr_bucket_free(t_bucket);
4790
4791 return ret;
4792 }
4793
4794 /*
4795 * Copy xattr from one bucket to another bucket.
4796 *
4797 * The caller must make sure that the journal transaction
4798 * has enough space for journaling.
4799 */
4800 static int ocfs2_cp_xattr_bucket(struct inode *inode,
4801 handle_t *handle,
4802 u64 s_blkno,
4803 u64 t_blkno,
4804 int t_is_new)
4805 {
4806 int ret;
4807 struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
4808
4809 BUG_ON(s_blkno == t_blkno);
4810
4811 trace_ocfs2_cp_xattr_bucket((unsigned long long)s_blkno,
4812 (unsigned long long)t_blkno,
4813 t_is_new);
4814
4815 s_bucket = ocfs2_xattr_bucket_new(inode);
4816 t_bucket = ocfs2_xattr_bucket_new(inode);
4817 if (!s_bucket || !t_bucket) {
4818 ret = -ENOMEM;
4819 mlog_errno(ret);
4820 goto out;
4821 }
4822
4823 ret = ocfs2_read_xattr_bucket(s_bucket, s_blkno);
4824 if (ret)
4825 goto out;
4826
4827 /*
4828 * Even if !t_is_new, we're overwriting t_bucket. Thus,
4829 * there's no need to read it.
4830 */
4831 ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno, t_is_new);
4832 if (ret)
4833 goto out;
4834
4835 /*
4836 * Hey, if we're overwriting t_bucket, what difference does
4837 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
4838 * cluster to fill, we came here from
4839 * ocfs2_mv_xattr_buckets(), and it is really new -
4840 * ACCESS_CREATE is required. But we also might have moved data
4841 * out of t_bucket before extending back into it.
4842 * ocfs2_add_new_xattr_bucket() can do this - its call to
4843 * ocfs2_add_new_xattr_cluster() may have created a new extent
4844 * and copied out the end of the old extent. Then it re-extends
4845 * the old extent back to create space for new xattrs. That's
4846 * how we get here, and the bucket isn't really new.
4847 */
4848 ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
4849 t_is_new ?
4850 OCFS2_JOURNAL_ACCESS_CREATE :
4851 OCFS2_JOURNAL_ACCESS_WRITE);
4852 if (ret)
4853 goto out;
4854
4855 ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
4856 ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
4857
4858 out:
4859 ocfs2_xattr_bucket_free(t_bucket);
4860 ocfs2_xattr_bucket_free(s_bucket);
4861
4862 return ret;
4863 }
4864
4865 /*
4866 * src_blk points to the start of an existing extent. last_blk points to
4867 * last cluster in that extent. to_blk points to a newly allocated
4868 * extent. We copy the buckets from the cluster at last_blk to the new
4869 * extent. If start_bucket is non-zero, we skip that many buckets before
4870 * we start copying. The new extent's xh_num_buckets gets set to the
4871 * number of buckets we copied. The old extent's xh_num_buckets shrinks
4872 * by the same amount.
4873 */
4874 static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle,
4875 u64 src_blk, u64 last_blk, u64 to_blk,
4876 unsigned int start_bucket,
4877 u32 *first_hash)
4878 {
4879 int i, ret, credits;
4880 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
4881 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
4882 int num_buckets = ocfs2_xattr_buckets_per_cluster(osb);
4883 struct ocfs2_xattr_bucket *old_first, *new_first;
4884
4885 trace_ocfs2_mv_xattr_buckets((unsigned long long)last_blk,
4886 (unsigned long long)to_blk);
4887
4888 BUG_ON(start_bucket >= num_buckets);
4889 if (start_bucket) {
4890 num_buckets -= start_bucket;
4891 last_blk += (start_bucket * blks_per_bucket);
4892 }
4893
4894 /* The first bucket of the original extent */
4895 old_first = ocfs2_xattr_bucket_new(inode);
4896 /* The first bucket of the new extent */
4897 new_first = ocfs2_xattr_bucket_new(inode);
4898 if (!old_first || !new_first) {
4899 ret = -ENOMEM;
4900 mlog_errno(ret);
4901 goto out;
4902 }
4903
4904 ret = ocfs2_read_xattr_bucket(old_first, src_blk);
4905 if (ret) {
4906 mlog_errno(ret);
4907 goto out;
4908 }
4909
4910 /*
4911 * We need to update the first bucket of the old extent and all
4912 * the buckets going to the new extent.
4913 */
4914 credits = ((num_buckets + 1) * blks_per_bucket);
4915 ret = ocfs2_extend_trans(handle, credits);
4916 if (ret) {
4917 mlog_errno(ret);
4918 goto out;
4919 }
4920
4921 ret = ocfs2_xattr_bucket_journal_access(handle, old_first,
4922 OCFS2_JOURNAL_ACCESS_WRITE);
4923 if (ret) {
4924 mlog_errno(ret);
4925 goto out;
4926 }
4927
4928 for (i = 0; i < num_buckets; i++) {
4929 ret = ocfs2_cp_xattr_bucket(inode, handle,
4930 last_blk + (i * blks_per_bucket),
4931 to_blk + (i * blks_per_bucket),
4932 1);
4933 if (ret) {
4934 mlog_errno(ret);
4935 goto out;
4936 }
4937 }
4938
4939 /*
4940 * Get the new bucket ready before we dirty anything
4941 * (This actually shouldn't fail, because we already dirtied
4942 * it once in ocfs2_cp_xattr_bucket()).
4943 */
4944 ret = ocfs2_read_xattr_bucket(new_first, to_blk);
4945 if (ret) {
4946 mlog_errno(ret);
4947 goto out;
4948 }
4949 ret = ocfs2_xattr_bucket_journal_access(handle, new_first,
4950 OCFS2_JOURNAL_ACCESS_WRITE);
4951 if (ret) {
4952 mlog_errno(ret);
4953 goto out;
4954 }
4955
4956 /* Now update the headers */
4957 le16_add_cpu(&bucket_xh(old_first)->xh_num_buckets, -num_buckets);
4958 ocfs2_xattr_bucket_journal_dirty(handle, old_first);
4959
4960 bucket_xh(new_first)->xh_num_buckets = cpu_to_le16(num_buckets);
4961 ocfs2_xattr_bucket_journal_dirty(handle, new_first);
4962
4963 if (first_hash)
4964 *first_hash = le32_to_cpu(bucket_xh(new_first)->xh_entries[0].xe_name_hash);
4965
4966 out:
4967 ocfs2_xattr_bucket_free(new_first);
4968 ocfs2_xattr_bucket_free(old_first);
4969 return ret;
4970 }
4971
4972 /*
4973 * Move some xattrs in this cluster to the new cluster.
4974 * This function should only be called when bucket size == cluster size.
4975 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4976 */
4977 static int ocfs2_divide_xattr_cluster(struct inode *inode,
4978 handle_t *handle,
4979 u64 prev_blk,
4980 u64 new_blk,
4981 u32 *first_hash)
4982 {
4983 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
4984 int ret, credits = 2 * blk_per_bucket;
4985
4986 BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize);
4987
4988 ret = ocfs2_extend_trans(handle, credits);
4989 if (ret) {
4990 mlog_errno(ret);
4991 return ret;
4992 }
4993
4994 /* Move half of the xattr in start_blk to the next bucket. */
4995 return ocfs2_divide_xattr_bucket(inode, handle, prev_blk,
4996 new_blk, first_hash, 1);
4997 }
4998
4999 /*
5000 * Move some xattrs from the old cluster to the new one since they are not
5001 * contiguous in ocfs2 xattr tree.
5002 *
5003 * new_blk starts a new separate cluster, and we will move some xattrs from
5004 * prev_blk to it. v_start will be set as the first name hash value in this
5005 * new cluster so that it can be used as e_cpos during tree insertion and
5006 * don't collide with our original b-tree operations. first_bh and header_bh
5007 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
5008 * to extend the insert bucket.
5009 *
5010 * The problem is how much xattr should we move to the new one and when should
5011 * we update first_bh and header_bh?
5012 * 1. If cluster size > bucket size, that means the previous cluster has more
5013 * than 1 bucket, so just move half nums of bucket into the new cluster and
5014 * update the first_bh and header_bh if the insert bucket has been moved
5015 * to the new cluster.
5016 * 2. If cluster_size == bucket_size:
5017 * a) If the previous extent rec has more than one cluster and the insert
5018 * place isn't in the last cluster, copy the entire last cluster to the
5019 * new one. This time, we don't need to upate the first_bh and header_bh
5020 * since they will not be moved into the new cluster.
5021 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
5022 * the new one. And we set the extend flag to zero if the insert place is
5023 * moved into the new allocated cluster since no extend is needed.
5024 */
5025 static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode,
5026 handle_t *handle,
5027 struct ocfs2_xattr_bucket *first,
5028 struct ocfs2_xattr_bucket *target,
5029 u64 new_blk,
5030 u32 prev_clusters,
5031 u32 *v_start,
5032 int *extend)
5033 {
5034 int ret;
5035
5036 trace_ocfs2_adjust_xattr_cross_cluster(
5037 (unsigned long long)bucket_blkno(first),
5038 (unsigned long long)new_blk, prev_clusters);
5039
5040 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1) {
5041 ret = ocfs2_mv_xattr_bucket_cross_cluster(inode,
5042 handle,
5043 first, target,
5044 new_blk,
5045 prev_clusters,
5046 v_start);
5047 if (ret)
5048 mlog_errno(ret);
5049 } else {
5050 /* The start of the last cluster in the first extent */
5051 u64 last_blk = bucket_blkno(first) +
5052 ((prev_clusters - 1) *
5053 ocfs2_clusters_to_blocks(inode->i_sb, 1));
5054
5055 if (prev_clusters > 1 && bucket_blkno(target) != last_blk) {
5056 ret = ocfs2_mv_xattr_buckets(inode, handle,
5057 bucket_blkno(first),
5058 last_blk, new_blk, 0,
5059 v_start);
5060 if (ret)
5061 mlog_errno(ret);
5062 } else {
5063 ret = ocfs2_divide_xattr_cluster(inode, handle,
5064 last_blk, new_blk,
5065 v_start);
5066 if (ret)
5067 mlog_errno(ret);
5068
5069 if ((bucket_blkno(target) == last_blk) && extend)
5070 *extend = 0;
5071 }
5072 }
5073
5074 return ret;
5075 }
5076
5077 /*
5078 * Add a new cluster for xattr storage.
5079 *
5080 * If the new cluster is contiguous with the previous one, it will be
5081 * appended to the same extent record, and num_clusters will be updated.
5082 * If not, we will insert a new extent for it and move some xattrs in
5083 * the last cluster into the new allocated one.
5084 * We also need to limit the maximum size of a btree leaf, otherwise we'll
5085 * lose the benefits of hashing because we'll have to search large leaves.
5086 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
5087 * if it's bigger).
5088 *
5089 * first_bh is the first block of the previous extent rec and header_bh
5090 * indicates the bucket we will insert the new xattrs. They will be updated
5091 * when the header_bh is moved into the new cluster.
5092 */
5093 static int ocfs2_add_new_xattr_cluster(struct inode *inode,
5094 struct buffer_head *root_bh,
5095 struct ocfs2_xattr_bucket *first,
5096 struct ocfs2_xattr_bucket *target,
5097 u32 *num_clusters,
5098 u32 prev_cpos,
5099 int *extend,
5100 struct ocfs2_xattr_set_ctxt *ctxt)
5101 {
5102 int ret;
5103 u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
5104 u32 prev_clusters = *num_clusters;
5105 u32 clusters_to_add = 1, bit_off, num_bits, v_start = 0;
5106 u64 block;
5107 handle_t *handle = ctxt->handle;
5108 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5109 struct ocfs2_extent_tree et;
5110
5111 trace_ocfs2_add_new_xattr_cluster_begin(
5112 (unsigned long long)OCFS2_I(inode)->ip_blkno,
5113 (unsigned long long)bucket_blkno(first),
5114 prev_cpos, prev_clusters);
5115
5116 ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh);
5117
5118 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh,
5119 OCFS2_JOURNAL_ACCESS_WRITE);
5120 if (ret < 0) {
5121 mlog_errno(ret);
5122 goto leave;
5123 }
5124
5125 ret = __ocfs2_claim_clusters(handle, ctxt->data_ac, 1,
5126 clusters_to_add, &bit_off, &num_bits);
5127 if (ret < 0) {
5128 if (ret != -ENOSPC)
5129 mlog_errno(ret);
5130 goto leave;
5131 }
5132
5133 BUG_ON(num_bits > clusters_to_add);
5134
5135 block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
5136 trace_ocfs2_add_new_xattr_cluster((unsigned long long)block, num_bits);
5137
5138 if (bucket_blkno(first) + (prev_clusters * bpc) == block &&
5139 (prev_clusters + num_bits) << osb->s_clustersize_bits <=
5140 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
5141 /*
5142 * If this cluster is contiguous with the old one and
5143 * adding this new cluster, we don't surpass the limit of
5144 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
5145 * initialized and used like other buckets in the previous
5146 * cluster.
5147 * So add it as a contiguous one. The caller will handle
5148 * its init process.
5149 */
5150 v_start = prev_cpos + prev_clusters;
5151 *num_clusters = prev_clusters + num_bits;
5152 } else {
5153 ret = ocfs2_adjust_xattr_cross_cluster(inode,
5154 handle,
5155 first,
5156 target,
5157 block,
5158 prev_clusters,
5159 &v_start,
5160 extend);
5161 if (ret) {
5162 mlog_errno(ret);
5163 goto leave;
5164 }
5165 }
5166
5167 trace_ocfs2_add_new_xattr_cluster_insert((unsigned long long)block,
5168 v_start, num_bits);
5169 ret = ocfs2_insert_extent(handle, &et, v_start, block,
5170 num_bits, 0, ctxt->meta_ac);
5171 if (ret < 0) {
5172 mlog_errno(ret);
5173 goto leave;
5174 }
5175
5176 ocfs2_journal_dirty(handle, root_bh);
5177
5178 leave:
5179 return ret;
5180 }
5181
5182 /*
5183 * We are given an extent. 'first' is the bucket at the very front of
5184 * the extent. The extent has space for an additional bucket past
5185 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
5186 * of the target bucket. We wish to shift every bucket past the target
5187 * down one, filling in that additional space. When we get back to the
5188 * target, we split the target between itself and the now-empty bucket
5189 * at target+1 (aka, target_blkno + blks_per_bucket).
5190 */
5191 static int ocfs2_extend_xattr_bucket(struct inode *inode,
5192 handle_t *handle,
5193 struct ocfs2_xattr_bucket *first,
5194 u64 target_blk,
5195 u32 num_clusters)
5196 {
5197 int ret, credits;
5198 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5199 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
5200 u64 end_blk;
5201 u16 new_bucket = le16_to_cpu(bucket_xh(first)->xh_num_buckets);
5202
5203 trace_ocfs2_extend_xattr_bucket((unsigned long long)target_blk,
5204 (unsigned long long)bucket_blkno(first),
5205 num_clusters, new_bucket);
5206
5207 /* The extent must have room for an additional bucket */
5208 BUG_ON(new_bucket >=
5209 (num_clusters * ocfs2_xattr_buckets_per_cluster(osb)));
5210
5211 /* end_blk points to the last existing bucket */
5212 end_blk = bucket_blkno(first) + ((new_bucket - 1) * blk_per_bucket);
5213
5214 /*
5215 * end_blk is the start of the last existing bucket.
5216 * Thus, (end_blk - target_blk) covers the target bucket and
5217 * every bucket after it up to, but not including, the last
5218 * existing bucket. Then we add the last existing bucket, the
5219 * new bucket, and the first bucket (3 * blk_per_bucket).
5220 */
5221 credits = (end_blk - target_blk) + (3 * blk_per_bucket);
5222 ret = ocfs2_extend_trans(handle, credits);
5223 if (ret) {
5224 mlog_errno(ret);
5225 goto out;
5226 }
5227
5228 ret = ocfs2_xattr_bucket_journal_access(handle, first,
5229 OCFS2_JOURNAL_ACCESS_WRITE);
5230 if (ret) {
5231 mlog_errno(ret);
5232 goto out;
5233 }
5234
5235 while (end_blk != target_blk) {
5236 ret = ocfs2_cp_xattr_bucket(inode, handle, end_blk,
5237 end_blk + blk_per_bucket, 0);
5238 if (ret)
5239 goto out;
5240 end_blk -= blk_per_bucket;
5241 }
5242
5243 /* Move half of the xattr in target_blkno to the next bucket. */
5244 ret = ocfs2_divide_xattr_bucket(inode, handle, target_blk,
5245 target_blk + blk_per_bucket, NULL, 0);
5246
5247 le16_add_cpu(&bucket_xh(first)->xh_num_buckets, 1);
5248 ocfs2_xattr_bucket_journal_dirty(handle, first);
5249
5250 out:
5251 return ret;
5252 }
5253
5254 /*
5255 * Add new xattr bucket in an extent record and adjust the buckets
5256 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
5257 * bucket we want to insert into.
5258 *
5259 * In the easy case, we will move all the buckets after target down by
5260 * one. Half of target's xattrs will be moved to the next bucket.
5261 *
5262 * If current cluster is full, we'll allocate a new one. This may not
5263 * be contiguous. The underlying calls will make sure that there is
5264 * space for the insert, shifting buckets around if necessary.
5265 * 'target' may be moved by those calls.
5266 */
5267 static int ocfs2_add_new_xattr_bucket(struct inode *inode,
5268 struct buffer_head *xb_bh,
5269 struct ocfs2_xattr_bucket *target,
5270 struct ocfs2_xattr_set_ctxt *ctxt)
5271 {
5272 struct ocfs2_xattr_block *xb =
5273 (struct ocfs2_xattr_block *)xb_bh->b_data;
5274 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
5275 struct ocfs2_extent_list *el = &xb_root->xt_list;
5276 u32 name_hash =
5277 le32_to_cpu(bucket_xh(target)->xh_entries[0].xe_name_hash);
5278 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5279 int ret, num_buckets, extend = 1;
5280 u64 p_blkno;
5281 u32 e_cpos, num_clusters;
5282 /* The bucket at the front of the extent */
5283 struct ocfs2_xattr_bucket *first;
5284
5285 trace_ocfs2_add_new_xattr_bucket(
5286 (unsigned long long)bucket_blkno(target));
5287
5288 /* The first bucket of the original extent */
5289 first = ocfs2_xattr_bucket_new(inode);
5290 if (!first) {
5291 ret = -ENOMEM;
5292 mlog_errno(ret);
5293 goto out;
5294 }
5295
5296 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &e_cpos,
5297 &num_clusters, el);
5298 if (ret) {
5299 mlog_errno(ret);
5300 goto out;
5301 }
5302
5303 ret = ocfs2_read_xattr_bucket(first, p_blkno);
5304 if (ret) {
5305 mlog_errno(ret);
5306 goto out;
5307 }
5308
5309 num_buckets = ocfs2_xattr_buckets_per_cluster(osb) * num_clusters;
5310 if (num_buckets == le16_to_cpu(bucket_xh(first)->xh_num_buckets)) {
5311 /*
5312 * This can move first+target if the target bucket moves
5313 * to the new extent.
5314 */
5315 ret = ocfs2_add_new_xattr_cluster(inode,
5316 xb_bh,
5317 first,
5318 target,
5319 &num_clusters,
5320 e_cpos,
5321 &extend,
5322 ctxt);
5323 if (ret) {
5324 mlog_errno(ret);
5325 goto out;
5326 }
5327 }
5328
5329 if (extend) {
5330 ret = ocfs2_extend_xattr_bucket(inode,
5331 ctxt->handle,
5332 first,
5333 bucket_blkno(target),
5334 num_clusters);
5335 if (ret)
5336 mlog_errno(ret);
5337 }
5338
5339 out:
5340 ocfs2_xattr_bucket_free(first);
5341
5342 return ret;
5343 }
5344
5345 /*
5346 * Truncate the specified xe_off entry in xattr bucket.
5347 * bucket is indicated by header_bh and len is the new length.
5348 * Both the ocfs2_xattr_value_root and the entry will be updated here.
5349 *
5350 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
5351 */
5352 static int ocfs2_xattr_bucket_value_truncate(struct inode *inode,
5353 struct ocfs2_xattr_bucket *bucket,
5354 int xe_off,
5355 int len,
5356 struct ocfs2_xattr_set_ctxt *ctxt)
5357 {
5358 int ret, offset;
5359 u64 value_blk;
5360 struct ocfs2_xattr_entry *xe;
5361 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
5362 size_t blocksize = inode->i_sb->s_blocksize;
5363 struct ocfs2_xattr_value_buf vb = {
5364 .vb_access = ocfs2_journal_access,
5365 };
5366
5367 xe = &xh->xh_entries[xe_off];
5368
5369 BUG_ON(!xe || ocfs2_xattr_is_local(xe));
5370
5371 offset = le16_to_cpu(xe->xe_name_offset) +
5372 OCFS2_XATTR_SIZE(xe->xe_name_len);
5373
5374 value_blk = offset / blocksize;
5375
5376 /* We don't allow ocfs2_xattr_value to be stored in different block. */
5377 BUG_ON(value_blk != (offset + OCFS2_XATTR_ROOT_SIZE - 1) / blocksize);
5378
5379 vb.vb_bh = bucket->bu_bhs[value_blk];
5380 BUG_ON(!vb.vb_bh);
5381
5382 vb.vb_xv = (struct ocfs2_xattr_value_root *)
5383 (vb.vb_bh->b_data + offset % blocksize);
5384
5385 /*
5386 * From here on out we have to dirty the bucket. The generic
5387 * value calls only modify one of the bucket's bhs, but we need
5388 * to send the bucket at once. So if they error, they *could* have
5389 * modified something. We have to assume they did, and dirty
5390 * the whole bucket. This leaves us in a consistent state.
5391 */
5392 trace_ocfs2_xattr_bucket_value_truncate(
5393 (unsigned long long)bucket_blkno(bucket), xe_off, len);
5394 ret = ocfs2_xattr_value_truncate(inode, &vb, len, ctxt);
5395 if (ret) {
5396 mlog_errno(ret);
5397 goto out;
5398 }
5399
5400 ret = ocfs2_xattr_bucket_journal_access(ctxt->handle, bucket,
5401 OCFS2_JOURNAL_ACCESS_WRITE);
5402 if (ret) {
5403 mlog_errno(ret);
5404 goto out;
5405 }
5406
5407 xe->xe_value_size = cpu_to_le64(len);
5408
5409 ocfs2_xattr_bucket_journal_dirty(ctxt->handle, bucket);
5410
5411 out:
5412 return ret;
5413 }
5414
5415 static int ocfs2_rm_xattr_cluster(struct inode *inode,
5416 struct buffer_head *root_bh,
5417 u64 blkno,
5418 u32 cpos,
5419 u32 len,
5420 void *para)
5421 {
5422 int ret;
5423 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5424 struct inode *tl_inode = osb->osb_tl_inode;
5425 handle_t *handle;
5426 struct ocfs2_xattr_block *xb =
5427 (struct ocfs2_xattr_block *)root_bh->b_data;
5428 struct ocfs2_alloc_context *meta_ac = NULL;
5429 struct ocfs2_cached_dealloc_ctxt dealloc;
5430 struct ocfs2_extent_tree et;
5431
5432 ret = ocfs2_iterate_xattr_buckets(inode, blkno, len,
5433 ocfs2_delete_xattr_in_bucket, para);
5434 if (ret) {
5435 mlog_errno(ret);
5436 return ret;
5437 }
5438
5439 ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh);
5440
5441 ocfs2_init_dealloc_ctxt(&dealloc);
5442
5443 trace_ocfs2_rm_xattr_cluster(
5444 (unsigned long long)OCFS2_I(inode)->ip_blkno,
5445 (unsigned long long)blkno, cpos, len);
5446
5447 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode), blkno,
5448 len);
5449
5450 ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
5451 if (ret) {
5452 mlog_errno(ret);
5453 return ret;
5454 }
5455
5456 inode_lock(tl_inode);
5457
5458 if (ocfs2_truncate_log_needs_flush(osb)) {
5459 ret = __ocfs2_flush_truncate_log(osb);
5460 if (ret < 0) {
5461 mlog_errno(ret);
5462 goto out;
5463 }
5464 }
5465
5466 handle = ocfs2_start_trans(osb, ocfs2_remove_extent_credits(osb->sb));
5467 if (IS_ERR(handle)) {
5468 ret = -ENOMEM;
5469 mlog_errno(ret);
5470 goto out;
5471 }
5472
5473 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh,
5474 OCFS2_JOURNAL_ACCESS_WRITE);
5475 if (ret) {
5476 mlog_errno(ret);
5477 goto out_commit;
5478 }
5479
5480 ret = ocfs2_remove_extent(handle, &et, cpos, len, meta_ac,
5481 &dealloc);
5482 if (ret) {
5483 mlog_errno(ret);
5484 goto out_commit;
5485 }
5486
5487 le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, -len);
5488 ocfs2_journal_dirty(handle, root_bh);
5489
5490 ret = ocfs2_truncate_log_append(osb, handle, blkno, len);
5491 if (ret)
5492 mlog_errno(ret);
5493 ocfs2_update_inode_fsync_trans(handle, inode, 0);
5494
5495 out_commit:
5496 ocfs2_commit_trans(osb, handle);
5497 out:
5498 ocfs2_schedule_truncate_log_flush(osb, 1);
5499
5500 inode_unlock(tl_inode);
5501
5502 if (meta_ac)
5503 ocfs2_free_alloc_context(meta_ac);
5504
5505 ocfs2_run_deallocs(osb, &dealloc);
5506
5507 return ret;
5508 }
5509
5510 /*
5511 * check whether the xattr bucket is filled up with the same hash value.
5512 * If we want to insert the xattr with the same hash, return -ENOSPC.
5513 * If we want to insert a xattr with different hash value, go ahead
5514 * and ocfs2_divide_xattr_bucket will handle this.
5515 */
5516 static int ocfs2_check_xattr_bucket_collision(struct inode *inode,
5517 struct ocfs2_xattr_bucket *bucket,
5518 const char *name)
5519 {
5520 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
5521 u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name));
5522
5523 if (name_hash != le32_to_cpu(xh->xh_entries[0].xe_name_hash))
5524 return 0;
5525
5526 if (xh->xh_entries[le16_to_cpu(xh->xh_count) - 1].xe_name_hash ==
5527 xh->xh_entries[0].xe_name_hash) {
5528 mlog(ML_ERROR, "Too much hash collision in xattr bucket %llu, "
5529 "hash = %u\n",
5530 (unsigned long long)bucket_blkno(bucket),
5531 le32_to_cpu(xh->xh_entries[0].xe_name_hash));
5532 return -ENOSPC;
5533 }
5534
5535 return 0;
5536 }
5537
5538 /*
5539 * Try to set the entry in the current bucket. If we fail, the caller
5540 * will handle getting us another bucket.
5541 */
5542 static int ocfs2_xattr_set_entry_bucket(struct inode *inode,
5543 struct ocfs2_xattr_info *xi,
5544 struct ocfs2_xattr_search *xs,
5545 struct ocfs2_xattr_set_ctxt *ctxt)
5546 {
5547 int ret;
5548 struct ocfs2_xa_loc loc;
5549
5550 trace_ocfs2_xattr_set_entry_bucket(xi->xi_name);
5551
5552 ocfs2_init_xattr_bucket_xa_loc(&loc, xs->bucket,
5553 xs->not_found ? NULL : xs->here);
5554 ret = ocfs2_xa_set(&loc, xi, ctxt);
5555 if (!ret) {
5556 xs->here = loc.xl_entry;
5557 goto out;
5558 }
5559 if (ret != -ENOSPC) {
5560 mlog_errno(ret);
5561 goto out;
5562 }
5563
5564 /* Ok, we need space. Let's try defragmenting the bucket. */
5565 ret = ocfs2_defrag_xattr_bucket(inode, ctxt->handle,
5566 xs->bucket);
5567 if (ret) {
5568 mlog_errno(ret);
5569 goto out;
5570 }
5571
5572 ret = ocfs2_xa_set(&loc, xi, ctxt);
5573 if (!ret) {
5574 xs->here = loc.xl_entry;
5575 goto out;
5576 }
5577 if (ret != -ENOSPC)
5578 mlog_errno(ret);
5579
5580
5581 out:
5582 return ret;
5583 }
5584
5585 static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
5586 struct ocfs2_xattr_info *xi,
5587 struct ocfs2_xattr_search *xs,
5588 struct ocfs2_xattr_set_ctxt *ctxt)
5589 {
5590 int ret;
5591
5592 trace_ocfs2_xattr_set_entry_index_block(xi->xi_name);
5593
5594 ret = ocfs2_xattr_set_entry_bucket(inode, xi, xs, ctxt);
5595 if (!ret)
5596 goto out;
5597 if (ret != -ENOSPC) {
5598 mlog_errno(ret);
5599 goto out;
5600 }
5601
5602 /* Ack, need more space. Let's try to get another bucket! */
5603
5604 /*
5605 * We do not allow for overlapping ranges between buckets. And
5606 * the maximum number of collisions we will allow for then is
5607 * one bucket's worth, so check it here whether we need to
5608 * add a new bucket for the insert.
5609 */
5610 ret = ocfs2_check_xattr_bucket_collision(inode,
5611 xs->bucket,
5612 xi->xi_name);
5613 if (ret) {
5614 mlog_errno(ret);
5615 goto out;
5616 }
5617
5618 ret = ocfs2_add_new_xattr_bucket(inode,
5619 xs->xattr_bh,
5620 xs->bucket,
5621 ctxt);
5622 if (ret) {
5623 mlog_errno(ret);
5624 goto out;
5625 }
5626
5627 /*
5628 * ocfs2_add_new_xattr_bucket() will have updated
5629 * xs->bucket if it moved, but it will not have updated
5630 * any of the other search fields. Thus, we drop it and
5631 * re-search. Everything should be cached, so it'll be
5632 * quick.
5633 */
5634 ocfs2_xattr_bucket_relse(xs->bucket);
5635 ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh,
5636 xi->xi_name_index,
5637 xi->xi_name, xs);
5638 if (ret && ret != -ENODATA)
5639 goto out;
5640 xs->not_found = ret;
5641
5642 /* Ok, we have a new bucket, let's try again */
5643 ret = ocfs2_xattr_set_entry_bucket(inode, xi, xs, ctxt);
5644 if (ret && (ret != -ENOSPC))
5645 mlog_errno(ret);
5646
5647 out:
5648 return ret;
5649 }
5650
5651 static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
5652 struct ocfs2_xattr_bucket *bucket,
5653 void *para)
5654 {
5655 int ret = 0, ref_credits;
5656 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
5657 u16 i;
5658 struct ocfs2_xattr_entry *xe;
5659 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5660 struct ocfs2_xattr_set_ctxt ctxt = {NULL, NULL,};
5661 int credits = ocfs2_remove_extent_credits(osb->sb) +
5662 ocfs2_blocks_per_xattr_bucket(inode->i_sb);
5663 struct ocfs2_xattr_value_root *xv;
5664 struct ocfs2_rm_xattr_bucket_para *args =
5665 (struct ocfs2_rm_xattr_bucket_para *)para;
5666
5667 ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
5668
5669 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
5670 xe = &xh->xh_entries[i];
5671 if (ocfs2_xattr_is_local(xe))
5672 continue;
5673
5674 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket,
5675 i, &xv, NULL);
5676 if (ret) {
5677 mlog_errno(ret);
5678 break;
5679 }
5680
5681 ret = ocfs2_lock_xattr_remove_allocators(inode, xv,
5682 args->ref_ci,
5683 args->ref_root_bh,
5684 &ctxt.meta_ac,
5685 &ref_credits);
5686
5687 ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits);
5688 if (IS_ERR(ctxt.handle)) {
5689 ret = PTR_ERR(ctxt.handle);
5690 mlog_errno(ret);
5691 break;
5692 }
5693
5694 ret = ocfs2_xattr_bucket_value_truncate(inode, bucket,
5695 i, 0, &ctxt);
5696
5697 ocfs2_commit_trans(osb, ctxt.handle);
5698 if (ctxt.meta_ac) {
5699 ocfs2_free_alloc_context(ctxt.meta_ac);
5700 ctxt.meta_ac = NULL;
5701 }
5702 if (ret) {
5703 mlog_errno(ret);
5704 break;
5705 }
5706 }
5707
5708 if (ctxt.meta_ac)
5709 ocfs2_free_alloc_context(ctxt.meta_ac);
5710 ocfs2_schedule_truncate_log_flush(osb, 1);
5711 ocfs2_run_deallocs(osb, &ctxt.dealloc);
5712 return ret;
5713 }
5714
5715 /*
5716 * Whenever we modify a xattr value root in the bucket(e.g, CoW
5717 * or change the extent record flag), we need to recalculate
5718 * the metaecc for the whole bucket. So it is done here.
5719 *
5720 * Note:
5721 * We have to give the extra credits for the caller.
5722 */
5723 static int ocfs2_xattr_bucket_post_refcount(struct inode *inode,
5724 handle_t *handle,
5725 void *para)
5726 {
5727 int ret;
5728 struct ocfs2_xattr_bucket *bucket =
5729 (struct ocfs2_xattr_bucket *)para;
5730
5731 ret = ocfs2_xattr_bucket_journal_access(handle, bucket,
5732 OCFS2_JOURNAL_ACCESS_WRITE);
5733 if (ret) {
5734 mlog_errno(ret);
5735 return ret;
5736 }
5737
5738 ocfs2_xattr_bucket_journal_dirty(handle, bucket);
5739
5740 return 0;
5741 }
5742
5743 /*
5744 * Special action we need if the xattr value is refcounted.
5745 *
5746 * 1. If the xattr is refcounted, lock the tree.
5747 * 2. CoW the xattr if we are setting the new value and the value
5748 * will be stored outside.
5749 * 3. In other case, decrease_refcount will work for us, so just
5750 * lock the refcount tree, calculate the meta and credits is OK.
5751 *
5752 * We have to do CoW before ocfs2_init_xattr_set_ctxt since
5753 * currently CoW is a completed transaction, while this function
5754 * will also lock the allocators and let us deadlock. So we will
5755 * CoW the whole xattr value.
5756 */
5757 static int ocfs2_prepare_refcount_xattr(struct inode *inode,
5758 struct ocfs2_dinode *di,
5759 struct ocfs2_xattr_info *xi,
5760 struct ocfs2_xattr_search *xis,
5761 struct ocfs2_xattr_search *xbs,
5762 struct ocfs2_refcount_tree **ref_tree,
5763 int *meta_add,
5764 int *credits)
5765 {
5766 int ret = 0;
5767 struct ocfs2_xattr_block *xb;
5768 struct ocfs2_xattr_entry *xe;
5769 char *base;
5770 u32 p_cluster, num_clusters;
5771 unsigned int ext_flags;
5772 int name_offset, name_len;
5773 struct ocfs2_xattr_value_buf vb;
5774 struct ocfs2_xattr_bucket *bucket = NULL;
5775 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5776 struct ocfs2_post_refcount refcount;
5777 struct ocfs2_post_refcount *p = NULL;
5778 struct buffer_head *ref_root_bh = NULL;
5779
5780 if (!xis->not_found) {
5781 xe = xis->here;
5782 name_offset = le16_to_cpu(xe->xe_name_offset);
5783 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
5784 base = xis->base;
5785 vb.vb_bh = xis->inode_bh;
5786 vb.vb_access = ocfs2_journal_access_di;
5787 } else {
5788 int i, block_off = 0;
5789 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
5790 xe = xbs->here;
5791 name_offset = le16_to_cpu(xe->xe_name_offset);
5792 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
5793 i = xbs->here - xbs->header->xh_entries;
5794
5795 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
5796 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
5797 bucket_xh(xbs->bucket),
5798 i, &block_off,
5799 &name_offset);
5800 if (ret) {
5801 mlog_errno(ret);
5802 goto out;
5803 }
5804 base = bucket_block(xbs->bucket, block_off);
5805 vb.vb_bh = xbs->bucket->bu_bhs[block_off];
5806 vb.vb_access = ocfs2_journal_access;
5807
5808 if (ocfs2_meta_ecc(osb)) {
5809 /*create parameters for ocfs2_post_refcount. */
5810 bucket = xbs->bucket;
5811 refcount.credits = bucket->bu_blocks;
5812 refcount.para = bucket;
5813 refcount.func =
5814 ocfs2_xattr_bucket_post_refcount;
5815 p = &refcount;
5816 }
5817 } else {
5818 base = xbs->base;
5819 vb.vb_bh = xbs->xattr_bh;
5820 vb.vb_access = ocfs2_journal_access_xb;
5821 }
5822 }
5823
5824 if (ocfs2_xattr_is_local(xe))
5825 goto out;
5826
5827 vb.vb_xv = (struct ocfs2_xattr_value_root *)
5828 (base + name_offset + name_len);
5829
5830 ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster,
5831 &num_clusters, &vb.vb_xv->xr_list,
5832 &ext_flags);
5833 if (ret) {
5834 mlog_errno(ret);
5835 goto out;
5836 }
5837
5838 /*
5839 * We just need to check the 1st extent record, since we always
5840 * CoW the whole xattr. So there shouldn't be a xattr with
5841 * some REFCOUNT extent recs after the 1st one.
5842 */
5843 if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
5844 goto out;
5845
5846 ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
5847 1, ref_tree, &ref_root_bh);
5848 if (ret) {
5849 mlog_errno(ret);
5850 goto out;
5851 }
5852
5853 /*
5854 * If we are deleting the xattr or the new size will be stored inside,
5855 * cool, leave it there, the xattr truncate process will remove them
5856 * for us(it still needs the refcount tree lock and the meta, credits).
5857 * And the worse case is that every cluster truncate will split the
5858 * refcount tree, and make the original extent become 3. So we will need
5859 * 2 * cluster more extent recs at most.
5860 */
5861 if (!xi->xi_value || xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE) {
5862
5863 ret = ocfs2_refcounted_xattr_delete_need(inode,
5864 &(*ref_tree)->rf_ci,
5865 ref_root_bh, vb.vb_xv,
5866 meta_add, credits);
5867 if (ret)
5868 mlog_errno(ret);
5869 goto out;
5870 }
5871
5872 ret = ocfs2_refcount_cow_xattr(inode, di, &vb,
5873 *ref_tree, ref_root_bh, 0,
5874 le32_to_cpu(vb.vb_xv->xr_clusters), p);
5875 if (ret)
5876 mlog_errno(ret);
5877
5878 out:
5879 brelse(ref_root_bh);
5880 return ret;
5881 }
5882
5883 /*
5884 * Add the REFCOUNTED flags for all the extent rec in ocfs2_xattr_value_root.
5885 * The physical clusters will be added to refcount tree.
5886 */
5887 static int ocfs2_xattr_value_attach_refcount(struct inode *inode,
5888 struct ocfs2_xattr_value_root *xv,
5889 struct ocfs2_extent_tree *value_et,
5890 struct ocfs2_caching_info *ref_ci,
5891 struct buffer_head *ref_root_bh,
5892 struct ocfs2_cached_dealloc_ctxt *dealloc,
5893 struct ocfs2_post_refcount *refcount)
5894 {
5895 int ret = 0;
5896 u32 clusters = le32_to_cpu(xv->xr_clusters);
5897 u32 cpos, p_cluster, num_clusters;
5898 struct ocfs2_extent_list *el = &xv->xr_list;
5899 unsigned int ext_flags;
5900
5901 cpos = 0;
5902 while (cpos < clusters) {
5903 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
5904 &num_clusters, el, &ext_flags);
5905 if (ret) {
5906 mlog_errno(ret);
5907 break;
5908 }
5909
5910 cpos += num_clusters;
5911 if ((ext_flags & OCFS2_EXT_REFCOUNTED))
5912 continue;
5913
5914 BUG_ON(!p_cluster);
5915
5916 ret = ocfs2_add_refcount_flag(inode, value_et,
5917 ref_ci, ref_root_bh,
5918 cpos - num_clusters,
5919 p_cluster, num_clusters,
5920 dealloc, refcount);
5921 if (ret) {
5922 mlog_errno(ret);
5923 break;
5924 }
5925 }
5926
5927 return ret;
5928 }
5929
5930 /*
5931 * Given a normal ocfs2_xattr_header, refcount all the entries which
5932 * have value stored outside.
5933 * Used for xattrs stored in inode and ocfs2_xattr_block.
5934 */
5935 static int ocfs2_xattr_attach_refcount_normal(struct inode *inode,
5936 struct ocfs2_xattr_value_buf *vb,
5937 struct ocfs2_xattr_header *header,
5938 struct ocfs2_caching_info *ref_ci,
5939 struct buffer_head *ref_root_bh,
5940 struct ocfs2_cached_dealloc_ctxt *dealloc)
5941 {
5942
5943 struct ocfs2_xattr_entry *xe;
5944 struct ocfs2_xattr_value_root *xv;
5945 struct ocfs2_extent_tree et;
5946 int i, ret = 0;
5947
5948 for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
5949 xe = &header->xh_entries[i];
5950
5951 if (ocfs2_xattr_is_local(xe))
5952 continue;
5953
5954 xv = (struct ocfs2_xattr_value_root *)((void *)header +
5955 le16_to_cpu(xe->xe_name_offset) +
5956 OCFS2_XATTR_SIZE(xe->xe_name_len));
5957
5958 vb->vb_xv = xv;
5959 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
5960
5961 ret = ocfs2_xattr_value_attach_refcount(inode, xv, &et,
5962 ref_ci, ref_root_bh,
5963 dealloc, NULL);
5964 if (ret) {
5965 mlog_errno(ret);
5966 break;
5967 }
5968 }
5969
5970 return ret;
5971 }
5972
5973 static int ocfs2_xattr_inline_attach_refcount(struct inode *inode,
5974 struct buffer_head *fe_bh,
5975 struct ocfs2_caching_info *ref_ci,
5976 struct buffer_head *ref_root_bh,
5977 struct ocfs2_cached_dealloc_ctxt *dealloc)
5978 {
5979 struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
5980 struct ocfs2_xattr_header *header = (struct ocfs2_xattr_header *)
5981 (fe_bh->b_data + inode->i_sb->s_blocksize -
5982 le16_to_cpu(di->i_xattr_inline_size));
5983 struct ocfs2_xattr_value_buf vb = {
5984 .vb_bh = fe_bh,
5985 .vb_access = ocfs2_journal_access_di,
5986 };
5987
5988 return ocfs2_xattr_attach_refcount_normal(inode, &vb, header,
5989 ref_ci, ref_root_bh, dealloc);
5990 }
5991
5992 struct ocfs2_xattr_tree_value_refcount_para {
5993 struct ocfs2_caching_info *ref_ci;
5994 struct buffer_head *ref_root_bh;
5995 struct ocfs2_cached_dealloc_ctxt *dealloc;
5996 };
5997
5998 static int ocfs2_get_xattr_tree_value_root(struct super_block *sb,
5999 struct ocfs2_xattr_bucket *bucket,
6000 int offset,
6001 struct ocfs2_xattr_value_root **xv,
6002 struct buffer_head **bh)
6003 {
6004 int ret, block_off, name_offset;
6005 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
6006 struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset];
6007 void *base;
6008
6009 ret = ocfs2_xattr_bucket_get_name_value(sb,
6010 bucket_xh(bucket),
6011 offset,
6012 &block_off,
6013 &name_offset);
6014 if (ret) {
6015 mlog_errno(ret);
6016 goto out;
6017 }
6018
6019 base = bucket_block(bucket, block_off);
6020
6021 *xv = (struct ocfs2_xattr_value_root *)(base + name_offset +
6022 OCFS2_XATTR_SIZE(xe->xe_name_len));
6023
6024 if (bh)
6025 *bh = bucket->bu_bhs[block_off];
6026 out:
6027 return ret;
6028 }
6029
6030 /*
6031 * For a given xattr bucket, refcount all the entries which
6032 * have value stored outside.
6033 */
6034 static int ocfs2_xattr_bucket_value_refcount(struct inode *inode,
6035 struct ocfs2_xattr_bucket *bucket,
6036 void *para)
6037 {
6038 int i, ret = 0;
6039 struct ocfs2_extent_tree et;
6040 struct ocfs2_xattr_tree_value_refcount_para *ref =
6041 (struct ocfs2_xattr_tree_value_refcount_para *)para;
6042 struct ocfs2_xattr_header *xh =
6043 (struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;
6044 struct ocfs2_xattr_entry *xe;
6045 struct ocfs2_xattr_value_buf vb = {
6046 .vb_access = ocfs2_journal_access,
6047 };
6048 struct ocfs2_post_refcount refcount = {
6049 .credits = bucket->bu_blocks,
6050 .para = bucket,
6051 .func = ocfs2_xattr_bucket_post_refcount,
6052 };
6053 struct ocfs2_post_refcount *p = NULL;
6054
6055 /* We only need post_refcount if we support metaecc. */
6056 if (ocfs2_meta_ecc(OCFS2_SB(inode->i_sb)))
6057 p = &refcount;
6058
6059 trace_ocfs2_xattr_bucket_value_refcount(
6060 (unsigned long long)bucket_blkno(bucket),
6061 le16_to_cpu(xh->xh_count));
6062 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
6063 xe = &xh->xh_entries[i];
6064
6065 if (ocfs2_xattr_is_local(xe))
6066 continue;
6067
6068 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, i,
6069 &vb.vb_xv, &vb.vb_bh);
6070 if (ret) {
6071 mlog_errno(ret);
6072 break;
6073 }
6074
6075 ocfs2_init_xattr_value_extent_tree(&et,
6076 INODE_CACHE(inode), &vb);
6077
6078 ret = ocfs2_xattr_value_attach_refcount(inode, vb.vb_xv,
6079 &et, ref->ref_ci,
6080 ref->ref_root_bh,
6081 ref->dealloc, p);
6082 if (ret) {
6083 mlog_errno(ret);
6084 break;
6085 }
6086 }
6087
6088 return ret;
6089
6090 }
6091
6092 static int ocfs2_refcount_xattr_tree_rec(struct inode *inode,
6093 struct buffer_head *root_bh,
6094 u64 blkno, u32 cpos, u32 len, void *para)
6095 {
6096 return ocfs2_iterate_xattr_buckets(inode, blkno, len,
6097 ocfs2_xattr_bucket_value_refcount,
6098 para);
6099 }
6100
6101 static int ocfs2_xattr_block_attach_refcount(struct inode *inode,
6102 struct buffer_head *blk_bh,
6103 struct ocfs2_caching_info *ref_ci,
6104 struct buffer_head *ref_root_bh,
6105 struct ocfs2_cached_dealloc_ctxt *dealloc)
6106 {
6107 int ret = 0;
6108 struct ocfs2_xattr_block *xb =
6109 (struct ocfs2_xattr_block *)blk_bh->b_data;
6110
6111 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
6112 struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
6113 struct ocfs2_xattr_value_buf vb = {
6114 .vb_bh = blk_bh,
6115 .vb_access = ocfs2_journal_access_xb,
6116 };
6117
6118 ret = ocfs2_xattr_attach_refcount_normal(inode, &vb, header,
6119 ref_ci, ref_root_bh,
6120 dealloc);
6121 } else {
6122 struct ocfs2_xattr_tree_value_refcount_para para = {
6123 .ref_ci = ref_ci,
6124 .ref_root_bh = ref_root_bh,
6125 .dealloc = dealloc,
6126 };
6127
6128 ret = ocfs2_iterate_xattr_index_block(inode, blk_bh,
6129 ocfs2_refcount_xattr_tree_rec,
6130 &para);
6131 }
6132
6133 return ret;
6134 }
6135
6136 int ocfs2_xattr_attach_refcount_tree(struct inode *inode,
6137 struct buffer_head *fe_bh,
6138 struct ocfs2_caching_info *ref_ci,
6139 struct buffer_head *ref_root_bh,
6140 struct ocfs2_cached_dealloc_ctxt *dealloc)
6141 {
6142 int ret = 0;
6143 struct ocfs2_inode_info *oi = OCFS2_I(inode);
6144 struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
6145 struct buffer_head *blk_bh = NULL;
6146
6147 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
6148 ret = ocfs2_xattr_inline_attach_refcount(inode, fe_bh,
6149 ref_ci, ref_root_bh,
6150 dealloc);
6151 if (ret) {
6152 mlog_errno(ret);
6153 goto out;
6154 }
6155 }
6156
6157 if (!di->i_xattr_loc)
6158 goto out;
6159
6160 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
6161 &blk_bh);
6162 if (ret < 0) {
6163 mlog_errno(ret);
6164 goto out;
6165 }
6166
6167 ret = ocfs2_xattr_block_attach_refcount(inode, blk_bh, ref_ci,
6168 ref_root_bh, dealloc);
6169 if (ret)
6170 mlog_errno(ret);
6171
6172 brelse(blk_bh);
6173 out:
6174
6175 return ret;
6176 }
6177
6178 typedef int (should_xattr_reflinked)(struct ocfs2_xattr_entry *xe);
6179 /*
6180 * Store the information we need in xattr reflink.
6181 * old_bh and new_bh are inode bh for the old and new inode.
6182 */
6183 struct ocfs2_xattr_reflink {
6184 struct inode *old_inode;
6185 struct inode *new_inode;
6186 struct buffer_head *old_bh;
6187 struct buffer_head *new_bh;
6188 struct ocfs2_caching_info *ref_ci;
6189 struct buffer_head *ref_root_bh;
6190 struct ocfs2_cached_dealloc_ctxt *dealloc;
6191 should_xattr_reflinked *xattr_reflinked;
6192 };
6193
6194 /*
6195 * Given a xattr header and xe offset,
6196 * return the proper xv and the corresponding bh.
6197 * xattr in inode, block and xattr tree have different implementaions.
6198 */
6199 typedef int (get_xattr_value_root)(struct super_block *sb,
6200 struct buffer_head *bh,
6201 struct ocfs2_xattr_header *xh,
6202 int offset,
6203 struct ocfs2_xattr_value_root **xv,
6204 struct buffer_head **ret_bh,
6205 void *para);
6206
6207 /*
6208 * Calculate all the xattr value root metadata stored in this xattr header and
6209 * credits we need if we create them from the scratch.
6210 * We use get_xattr_value_root so that all types of xattr container can use it.
6211 */
6212 static int ocfs2_value_metas_in_xattr_header(struct super_block *sb,
6213 struct buffer_head *bh,
6214 struct ocfs2_xattr_header *xh,
6215 int *metas, int *credits,
6216 int *num_recs,
6217 get_xattr_value_root *func,
6218 void *para)
6219 {
6220 int i, ret = 0;
6221 struct ocfs2_xattr_value_root *xv;
6222 struct ocfs2_xattr_entry *xe;
6223
6224 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
6225 xe = &xh->xh_entries[i];
6226 if (ocfs2_xattr_is_local(xe))
6227 continue;
6228
6229 ret = func(sb, bh, xh, i, &xv, NULL, para);
6230 if (ret) {
6231 mlog_errno(ret);
6232 break;
6233 }
6234
6235 *metas += le16_to_cpu(xv->xr_list.l_tree_depth) *
6236 le16_to_cpu(xv->xr_list.l_next_free_rec);
6237
6238 *credits += ocfs2_calc_extend_credits(sb,
6239 &def_xv.xv.xr_list);
6240
6241 /*
6242 * If the value is a tree with depth > 1, We don't go deep
6243 * to the extent block, so just calculate a maximum record num.
6244 */
6245 if (!xv->xr_list.l_tree_depth)
6246 *num_recs += le16_to_cpu(xv->xr_list.l_next_free_rec);
6247 else
6248 *num_recs += ocfs2_clusters_for_bytes(sb,
6249 XATTR_SIZE_MAX);
6250 }
6251
6252 return ret;
6253 }
6254
6255 /* Used by xattr inode and block to return the right xv and buffer_head. */
6256 static int ocfs2_get_xattr_value_root(struct super_block *sb,
6257 struct buffer_head *bh,
6258 struct ocfs2_xattr_header *xh,
6259 int offset,
6260 struct ocfs2_xattr_value_root **xv,
6261 struct buffer_head **ret_bh,
6262 void *para)
6263 {
6264 struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset];
6265
6266 *xv = (struct ocfs2_xattr_value_root *)((void *)xh +
6267 le16_to_cpu(xe->xe_name_offset) +
6268 OCFS2_XATTR_SIZE(xe->xe_name_len));
6269
6270 if (ret_bh)
6271 *ret_bh = bh;
6272
6273 return 0;
6274 }
6275
6276 /*
6277 * Lock the meta_ac and caculate how much credits we need for reflink xattrs.
6278 * It is only used for inline xattr and xattr block.
6279 */
6280 static int ocfs2_reflink_lock_xattr_allocators(struct ocfs2_super *osb,
6281 struct ocfs2_xattr_header *xh,
6282 struct buffer_head *ref_root_bh,
6283 int *credits,
6284 struct ocfs2_alloc_context **meta_ac)
6285 {
6286 int ret, meta_add = 0, num_recs = 0;
6287 struct ocfs2_refcount_block *rb =
6288 (struct ocfs2_refcount_block *)ref_root_bh->b_data;
6289
6290 *credits = 0;
6291
6292 ret = ocfs2_value_metas_in_xattr_header(osb->sb, NULL, xh,
6293 &meta_add, credits, &num_recs,
6294 ocfs2_get_xattr_value_root,
6295 NULL);
6296 if (ret) {
6297 mlog_errno(ret);
6298 goto out;
6299 }
6300
6301 /*
6302 * We need to add/modify num_recs in refcount tree, so just calculate
6303 * an approximate number we need for refcount tree change.
6304 * Sometimes we need to split the tree, and after split, half recs
6305 * will be moved to the new block, and a new block can only provide
6306 * half number of recs. So we multiple new blocks by 2.
6307 */
6308 num_recs = num_recs / ocfs2_refcount_recs_per_rb(osb->sb) * 2;
6309 meta_add += num_recs;
6310 *credits += num_recs + num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
6311 if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
6312 *credits += le16_to_cpu(rb->rf_list.l_tree_depth) *
6313 le16_to_cpu(rb->rf_list.l_next_free_rec) + 1;
6314 else
6315 *credits += 1;
6316
6317 ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add, meta_ac);
6318 if (ret)
6319 mlog_errno(ret);
6320
6321 out:
6322 return ret;
6323 }
6324
6325 /*
6326 * Given a xattr header, reflink all the xattrs in this container.
6327 * It can be used for inode, block and bucket.
6328 *
6329 * NOTE:
6330 * Before we call this function, the caller has memcpy the xattr in
6331 * old_xh to the new_xh.
6332 *
6333 * If args.xattr_reflinked is set, call it to decide whether the xe should
6334 * be reflinked or not. If not, remove it from the new xattr header.
6335 */
6336 static int ocfs2_reflink_xattr_header(handle_t *handle,
6337 struct ocfs2_xattr_reflink *args,
6338 struct buffer_head *old_bh,
6339 struct ocfs2_xattr_header *xh,
6340 struct buffer_head *new_bh,
6341 struct ocfs2_xattr_header *new_xh,
6342 struct ocfs2_xattr_value_buf *vb,
6343 struct ocfs2_alloc_context *meta_ac,
6344 get_xattr_value_root *func,
6345 void *para)
6346 {
6347 int ret = 0, i, j;
6348 struct super_block *sb = args->old_inode->i_sb;
6349 struct buffer_head *value_bh;
6350 struct ocfs2_xattr_entry *xe, *last;
6351 struct ocfs2_xattr_value_root *xv, *new_xv;
6352 struct ocfs2_extent_tree data_et;
6353 u32 clusters, cpos, p_cluster, num_clusters;
6354 unsigned int ext_flags = 0;
6355
6356 trace_ocfs2_reflink_xattr_header((unsigned long long)old_bh->b_blocknr,
6357 le16_to_cpu(xh->xh_count));
6358
6359 last = &new_xh->xh_entries[le16_to_cpu(new_xh->xh_count)];
6360 for (i = 0, j = 0; i < le16_to_cpu(xh->xh_count); i++, j++) {
6361 xe = &xh->xh_entries[i];
6362
6363 if (args->xattr_reflinked && !args->xattr_reflinked(xe)) {
6364 xe = &new_xh->xh_entries[j];
6365
6366 le16_add_cpu(&new_xh->xh_count, -1);
6367 if (new_xh->xh_count) {
6368 memmove(xe, xe + 1,
6369 (void *)last - (void *)xe);
6370 memset(last, 0,
6371 sizeof(struct ocfs2_xattr_entry));
6372 }
6373
6374 /*
6375 * We don't want j to increase in the next round since
6376 * it is already moved ahead.
6377 */
6378 j--;
6379 continue;
6380 }
6381
6382 if (ocfs2_xattr_is_local(xe))
6383 continue;
6384
6385 ret = func(sb, old_bh, xh, i, &xv, NULL, para);
6386 if (ret) {
6387 mlog_errno(ret);
6388 break;
6389 }
6390
6391 ret = func(sb, new_bh, new_xh, j, &new_xv, &value_bh, para);
6392 if (ret) {
6393 mlog_errno(ret);
6394 break;
6395 }
6396
6397 /*
6398 * For the xattr which has l_tree_depth = 0, all the extent
6399 * recs have already be copied to the new xh with the
6400 * propriate OCFS2_EXT_REFCOUNTED flag we just need to
6401 * increase the refount count int the refcount tree.
6402 *
6403 * For the xattr which has l_tree_depth > 0, we need
6404 * to initialize it to the empty default value root,
6405 * and then insert the extents one by one.
6406 */
6407 if (xv->xr_list.l_tree_depth) {
6408 memcpy(new_xv, &def_xv, OCFS2_XATTR_ROOT_SIZE);
6409 vb->vb_xv = new_xv;
6410 vb->vb_bh = value_bh;
6411 ocfs2_init_xattr_value_extent_tree(&data_et,
6412 INODE_CACHE(args->new_inode), vb);
6413 }
6414
6415 clusters = le32_to_cpu(xv->xr_clusters);
6416 cpos = 0;
6417 while (cpos < clusters) {
6418 ret = ocfs2_xattr_get_clusters(args->old_inode,
6419 cpos,
6420 &p_cluster,
6421 &num_clusters,
6422 &xv->xr_list,
6423 &ext_flags);
6424 if (ret) {
6425 mlog_errno(ret);
6426 goto out;
6427 }
6428
6429 BUG_ON(!p_cluster);
6430
6431 if (xv->xr_list.l_tree_depth) {
6432 ret = ocfs2_insert_extent(handle,
6433 &data_et, cpos,
6434 ocfs2_clusters_to_blocks(
6435 args->old_inode->i_sb,
6436 p_cluster),
6437 num_clusters, ext_flags,
6438 meta_ac);
6439 if (ret) {
6440 mlog_errno(ret);
6441 goto out;
6442 }
6443 }
6444
6445 ret = ocfs2_increase_refcount(handle, args->ref_ci,
6446 args->ref_root_bh,
6447 p_cluster, num_clusters,
6448 meta_ac, args->dealloc);
6449 if (ret) {
6450 mlog_errno(ret);
6451 goto out;
6452 }
6453
6454 cpos += num_clusters;
6455 }
6456 }
6457
6458 out:
6459 return ret;
6460 }
6461
6462 static int ocfs2_reflink_xattr_inline(struct ocfs2_xattr_reflink *args)
6463 {
6464 int ret = 0, credits = 0;
6465 handle_t *handle;
6466 struct ocfs2_super *osb = OCFS2_SB(args->old_inode->i_sb);
6467 struct ocfs2_dinode *di = (struct ocfs2_dinode *)args->old_bh->b_data;
6468 int inline_size = le16_to_cpu(di->i_xattr_inline_size);
6469 int header_off = osb->sb->s_blocksize - inline_size;
6470 struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)
6471 (args->old_bh->b_data + header_off);
6472 struct ocfs2_xattr_header *new_xh = (struct ocfs2_xattr_header *)
6473 (args->new_bh->b_data + header_off);
6474 struct ocfs2_alloc_context *meta_ac = NULL;
6475 struct ocfs2_inode_info *new_oi;
6476 struct ocfs2_dinode *new_di;
6477 struct ocfs2_xattr_value_buf vb = {
6478 .vb_bh = args->new_bh,
6479 .vb_access = ocfs2_journal_access_di,
6480 };
6481
6482 ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh,
6483 &credits, &meta_ac);
6484 if (ret) {
6485 mlog_errno(ret);
6486 goto out;
6487 }
6488
6489 handle = ocfs2_start_trans(osb, credits);
6490 if (IS_ERR(handle)) {
6491 ret = PTR_ERR(handle);
6492 mlog_errno(ret);
6493 goto out;
6494 }
6495
6496 ret = ocfs2_journal_access_di(handle, INODE_CACHE(args->new_inode),
6497 args->new_bh, OCFS2_JOURNAL_ACCESS_WRITE);
6498 if (ret) {
6499 mlog_errno(ret);
6500 goto out_commit;
6501 }
6502
6503 memcpy(args->new_bh->b_data + header_off,
6504 args->old_bh->b_data + header_off, inline_size);
6505
6506 new_di = (struct ocfs2_dinode *)args->new_bh->b_data;
6507 new_di->i_xattr_inline_size = cpu_to_le16(inline_size);
6508
6509 ret = ocfs2_reflink_xattr_header(handle, args, args->old_bh, xh,
6510 args->new_bh, new_xh, &vb, meta_ac,
6511 ocfs2_get_xattr_value_root, NULL);
6512 if (ret) {
6513 mlog_errno(ret);
6514 goto out_commit;
6515 }
6516
6517 new_oi = OCFS2_I(args->new_inode);
6518 /*
6519 * Adjust extent record count to reserve space for extended attribute.
6520 * Inline data count had been adjusted in ocfs2_duplicate_inline_data().
6521 */
6522 if (!(new_oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) &&
6523 !(ocfs2_inode_is_fast_symlink(args->new_inode))) {
6524 struct ocfs2_extent_list *el = &new_di->id2.i_list;
6525 le16_add_cpu(&el->l_count, -(inline_size /
6526 sizeof(struct ocfs2_extent_rec)));
6527 }
6528 spin_lock(&new_oi->ip_lock);
6529 new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL | OCFS2_INLINE_XATTR_FL;
6530 new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features);
6531 spin_unlock(&new_oi->ip_lock);
6532
6533 ocfs2_journal_dirty(handle, args->new_bh);
6534
6535 out_commit:
6536 ocfs2_commit_trans(osb, handle);
6537
6538 out:
6539 if (meta_ac)
6540 ocfs2_free_alloc_context(meta_ac);
6541 return ret;
6542 }
6543
6544 static int ocfs2_create_empty_xattr_block(struct inode *inode,
6545 struct buffer_head *fe_bh,
6546 struct buffer_head **ret_bh,
6547 int indexed)
6548 {
6549 int ret;
6550 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
6551 struct ocfs2_xattr_set_ctxt ctxt;
6552
6553 memset(&ctxt, 0, sizeof(ctxt));
6554 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &ctxt.meta_ac);
6555 if (ret < 0) {
6556 mlog_errno(ret);
6557 return ret;
6558 }
6559
6560 ctxt.handle = ocfs2_start_trans(osb, OCFS2_XATTR_BLOCK_CREATE_CREDITS);
6561 if (IS_ERR(ctxt.handle)) {
6562 ret = PTR_ERR(ctxt.handle);
6563 mlog_errno(ret);
6564 goto out;
6565 }
6566
6567 trace_ocfs2_create_empty_xattr_block(
6568 (unsigned long long)fe_bh->b_blocknr, indexed);
6569 ret = ocfs2_create_xattr_block(inode, fe_bh, &ctxt, indexed,
6570 ret_bh);
6571 if (ret)
6572 mlog_errno(ret);
6573
6574 ocfs2_commit_trans(osb, ctxt.handle);
6575 out:
6576 ocfs2_free_alloc_context(ctxt.meta_ac);
6577 return ret;
6578 }
6579
6580 static int ocfs2_reflink_xattr_block(struct ocfs2_xattr_reflink *args,
6581 struct buffer_head *blk_bh,
6582 struct buffer_head *new_blk_bh)
6583 {
6584 int ret = 0, credits = 0;
6585 handle_t *handle;
6586 struct ocfs2_inode_info *new_oi = OCFS2_I(args->new_inode);
6587 struct ocfs2_dinode *new_di;
6588 struct ocfs2_super *osb = OCFS2_SB(args->new_inode->i_sb);
6589 int header_off = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
6590 struct ocfs2_xattr_block *xb =
6591 (struct ocfs2_xattr_block *)blk_bh->b_data;
6592 struct ocfs2_xattr_header *xh = &xb->xb_attrs.xb_header;
6593 struct ocfs2_xattr_block *new_xb =
6594 (struct ocfs2_xattr_block *)new_blk_bh->b_data;
6595 struct ocfs2_xattr_header *new_xh = &new_xb->xb_attrs.xb_header;
6596 struct ocfs2_alloc_context *meta_ac;
6597 struct ocfs2_xattr_value_buf vb = {
6598 .vb_bh = new_blk_bh,
6599 .vb_access = ocfs2_journal_access_xb,
6600 };
6601
6602 ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh,
6603 &credits, &meta_ac);
6604 if (ret) {
6605 mlog_errno(ret);
6606 return ret;
6607 }
6608
6609 /* One more credits in case we need to add xattr flags in new inode. */
6610 handle = ocfs2_start_trans(osb, credits + 1);
6611 if (IS_ERR(handle)) {
6612 ret = PTR_ERR(handle);
6613 mlog_errno(ret);
6614 goto out;
6615 }
6616
6617 if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) {
6618 ret = ocfs2_journal_access_di(handle,
6619 INODE_CACHE(args->new_inode),
6620 args->new_bh,
6621 OCFS2_JOURNAL_ACCESS_WRITE);
6622 if (ret) {
6623 mlog_errno(ret);
6624 goto out_commit;
6625 }
6626 }
6627
6628 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(args->new_inode),
6629 new_blk_bh, OCFS2_JOURNAL_ACCESS_WRITE);
6630 if (ret) {
6631 mlog_errno(ret);
6632 goto out_commit;
6633 }
6634
6635 memcpy(new_blk_bh->b_data + header_off, blk_bh->b_data + header_off,
6636 osb->sb->s_blocksize - header_off);
6637
6638 ret = ocfs2_reflink_xattr_header(handle, args, blk_bh, xh,
6639 new_blk_bh, new_xh, &vb, meta_ac,
6640 ocfs2_get_xattr_value_root, NULL);
6641 if (ret) {
6642 mlog_errno(ret);
6643 goto out_commit;
6644 }
6645
6646 ocfs2_journal_dirty(handle, new_blk_bh);
6647
6648 if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) {
6649 new_di = (struct ocfs2_dinode *)args->new_bh->b_data;
6650 spin_lock(&new_oi->ip_lock);
6651 new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL;
6652 new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features);
6653 spin_unlock(&new_oi->ip_lock);
6654
6655 ocfs2_journal_dirty(handle, args->new_bh);
6656 }
6657
6658 out_commit:
6659 ocfs2_commit_trans(osb, handle);
6660
6661 out:
6662 ocfs2_free_alloc_context(meta_ac);
6663 return ret;
6664 }
6665
6666 struct ocfs2_reflink_xattr_tree_args {
6667 struct ocfs2_xattr_reflink *reflink;
6668 struct buffer_head *old_blk_bh;
6669 struct buffer_head *new_blk_bh;
6670 struct ocfs2_xattr_bucket *old_bucket;
6671 struct ocfs2_xattr_bucket *new_bucket;
6672 };
6673
6674 /*
6675 * NOTE:
6676 * We have to handle the case that both old bucket and new bucket
6677 * will call this function to get the right ret_bh.
6678 * So The caller must give us the right bh.
6679 */
6680 static int ocfs2_get_reflink_xattr_value_root(struct super_block *sb,
6681 struct buffer_head *bh,
6682 struct ocfs2_xattr_header *xh,
6683 int offset,
6684 struct ocfs2_xattr_value_root **xv,
6685 struct buffer_head **ret_bh,
6686 void *para)
6687 {
6688 struct ocfs2_reflink_xattr_tree_args *args =
6689 (struct ocfs2_reflink_xattr_tree_args *)para;
6690 struct ocfs2_xattr_bucket *bucket;
6691
6692 if (bh == args->old_bucket->bu_bhs[0])
6693 bucket = args->old_bucket;
6694 else
6695 bucket = args->new_bucket;
6696
6697 return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,
6698 xv, ret_bh);
6699 }
6700
6701 struct ocfs2_value_tree_metas {
6702 int num_metas;
6703 int credits;
6704 int num_recs;
6705 };
6706
6707 static int ocfs2_value_tree_metas_in_bucket(struct super_block *sb,
6708 struct buffer_head *bh,
6709 struct ocfs2_xattr_header *xh,
6710 int offset,
6711 struct ocfs2_xattr_value_root **xv,
6712 struct buffer_head **ret_bh,
6713 void *para)
6714 {
6715 struct ocfs2_xattr_bucket *bucket =
6716 (struct ocfs2_xattr_bucket *)para;
6717
6718 return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,
6719 xv, ret_bh);
6720 }
6721
6722 static int ocfs2_calc_value_tree_metas(struct inode *inode,
6723 struct ocfs2_xattr_bucket *bucket,
6724 void *para)
6725 {
6726 struct ocfs2_value_tree_metas *metas =
6727 (struct ocfs2_value_tree_metas *)para;
6728 struct ocfs2_xattr_header *xh =
6729 (struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;
6730
6731 /* Add the credits for this bucket first. */
6732 metas->credits += bucket->bu_blocks;
6733 return ocfs2_value_metas_in_xattr_header(inode->i_sb, bucket->bu_bhs[0],
6734 xh, &metas->num_metas,
6735 &metas->credits, &metas->num_recs,
6736 ocfs2_value_tree_metas_in_bucket,
6737 bucket);
6738 }
6739
6740 /*
6741 * Given a xattr extent rec starting from blkno and having len clusters,
6742 * iterate all the buckets calculate how much metadata we need for reflinking
6743 * all the ocfs2_xattr_value_root and lock the allocators accordingly.
6744 */
6745 static int ocfs2_lock_reflink_xattr_rec_allocators(
6746 struct ocfs2_reflink_xattr_tree_args *args,
6747 struct ocfs2_extent_tree *xt_et,
6748 u64 blkno, u32 len, int *credits,
6749 struct ocfs2_alloc_context **meta_ac,
6750 struct ocfs2_alloc_context **data_ac)
6751 {
6752 int ret, num_free_extents;
6753 struct ocfs2_value_tree_metas metas;
6754 struct ocfs2_super *osb = OCFS2_SB(args->reflink->old_inode->i_sb);
6755 struct ocfs2_refcount_block *rb;
6756
6757 memset(&metas, 0, sizeof(metas));
6758
6759 ret = ocfs2_iterate_xattr_buckets(args->reflink->old_inode, blkno, len,
6760 ocfs2_calc_value_tree_metas, &metas);
6761 if (ret) {
6762 mlog_errno(ret);
6763 goto out;
6764 }
6765
6766 *credits = metas.credits;
6767
6768 /*
6769 * Calculate we need for refcount tree change.
6770 *
6771 * We need to add/modify num_recs in refcount tree, so just calculate
6772 * an approximate number we need for refcount tree change.
6773 * Sometimes we need to split the tree, and after split, half recs
6774 * will be moved to the new block, and a new block can only provide
6775 * half number of recs. So we multiple new blocks by 2.
6776 * In the end, we have to add credits for modifying the already
6777 * existed refcount block.
6778 */
6779 rb = (struct ocfs2_refcount_block *)args->reflink->ref_root_bh->b_data;
6780 metas.num_recs =
6781 (metas.num_recs + ocfs2_refcount_recs_per_rb(osb->sb) - 1) /
6782 ocfs2_refcount_recs_per_rb(osb->sb) * 2;
6783 metas.num_metas += metas.num_recs;
6784 *credits += metas.num_recs +
6785 metas.num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
6786 if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
6787 *credits += le16_to_cpu(rb->rf_list.l_tree_depth) *
6788 le16_to_cpu(rb->rf_list.l_next_free_rec) + 1;
6789 else
6790 *credits += 1;
6791
6792 /* count in the xattr tree change. */
6793 num_free_extents = ocfs2_num_free_extents(xt_et);
6794 if (num_free_extents < 0) {
6795 ret = num_free_extents;
6796 mlog_errno(ret);
6797 goto out;
6798 }
6799
6800 if (num_free_extents < len)
6801 metas.num_metas += ocfs2_extend_meta_needed(xt_et->et_root_el);
6802
6803 *credits += ocfs2_calc_extend_credits(osb->sb,
6804 xt_et->et_root_el);
6805
6806 if (metas.num_metas) {
6807 ret = ocfs2_reserve_new_metadata_blocks(osb, metas.num_metas,
6808 meta_ac);
6809 if (ret) {
6810 mlog_errno(ret);
6811 goto out;
6812 }
6813 }
6814
6815 if (len) {
6816 ret = ocfs2_reserve_clusters(osb, len, data_ac);
6817 if (ret)
6818 mlog_errno(ret);
6819 }
6820 out:
6821 if (ret) {
6822 if (*meta_ac) {
6823 ocfs2_free_alloc_context(*meta_ac);
6824 *meta_ac = NULL;
6825 }
6826 }
6827
6828 return ret;
6829 }
6830
6831 static int ocfs2_reflink_xattr_bucket(handle_t *handle,
6832 u64 blkno, u64 new_blkno, u32 clusters,
6833 u32 *cpos, int num_buckets,
6834 struct ocfs2_alloc_context *meta_ac,
6835 struct ocfs2_alloc_context *data_ac,
6836 struct ocfs2_reflink_xattr_tree_args *args)
6837 {
6838 int i, j, ret = 0;
6839 struct super_block *sb = args->reflink->old_inode->i_sb;
6840 int bpb = args->old_bucket->bu_blocks;
6841 struct ocfs2_xattr_value_buf vb = {
6842 .vb_access = ocfs2_journal_access,
6843 };
6844
6845 for (i = 0; i < num_buckets; i++, blkno += bpb, new_blkno += bpb) {
6846 ret = ocfs2_read_xattr_bucket(args->old_bucket, blkno);
6847 if (ret) {
6848 mlog_errno(ret);
6849 break;
6850 }
6851
6852 ret = ocfs2_init_xattr_bucket(args->new_bucket, new_blkno, 1);
6853 if (ret) {
6854 mlog_errno(ret);
6855 break;
6856 }
6857
6858 ret = ocfs2_xattr_bucket_journal_access(handle,
6859 args->new_bucket,
6860 OCFS2_JOURNAL_ACCESS_CREATE);
6861 if (ret) {
6862 mlog_errno(ret);
6863 break;
6864 }
6865
6866 for (j = 0; j < bpb; j++)
6867 memcpy(bucket_block(args->new_bucket, j),
6868 bucket_block(args->old_bucket, j),
6869 sb->s_blocksize);
6870
6871 /*
6872 * Record the start cpos so that we can use it to initialize
6873 * our xattr tree we also set the xh_num_bucket for the new
6874 * bucket.
6875 */
6876 if (i == 0) {
6877 *cpos = le32_to_cpu(bucket_xh(args->new_bucket)->
6878 xh_entries[0].xe_name_hash);
6879 bucket_xh(args->new_bucket)->xh_num_buckets =
6880 cpu_to_le16(num_buckets);
6881 }
6882
6883 ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket);
6884
6885 ret = ocfs2_reflink_xattr_header(handle, args->reflink,
6886 args->old_bucket->bu_bhs[0],
6887 bucket_xh(args->old_bucket),
6888 args->new_bucket->bu_bhs[0],
6889 bucket_xh(args->new_bucket),
6890 &vb, meta_ac,
6891 ocfs2_get_reflink_xattr_value_root,
6892 args);
6893 if (ret) {
6894 mlog_errno(ret);
6895 break;
6896 }
6897
6898 /*
6899 * Re-access and dirty the bucket to calculate metaecc.
6900 * Because we may extend the transaction in reflink_xattr_header
6901 * which will let the already accessed block gone.
6902 */
6903 ret = ocfs2_xattr_bucket_journal_access(handle,
6904 args->new_bucket,
6905 OCFS2_JOURNAL_ACCESS_WRITE);
6906 if (ret) {
6907 mlog_errno(ret);
6908 break;
6909 }
6910
6911 ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket);
6912
6913 ocfs2_xattr_bucket_relse(args->old_bucket);
6914 ocfs2_xattr_bucket_relse(args->new_bucket);
6915 }
6916
6917 ocfs2_xattr_bucket_relse(args->old_bucket);
6918 ocfs2_xattr_bucket_relse(args->new_bucket);
6919 return ret;
6920 }
6921
6922 static int ocfs2_reflink_xattr_buckets(handle_t *handle,
6923 struct inode *inode,
6924 struct ocfs2_reflink_xattr_tree_args *args,
6925 struct ocfs2_extent_tree *et,
6926 struct ocfs2_alloc_context *meta_ac,
6927 struct ocfs2_alloc_context *data_ac,
6928 u64 blkno, u32 cpos, u32 len)
6929 {
6930 int ret, first_inserted = 0;
6931 u32 p_cluster, num_clusters, reflink_cpos = 0;
6932 u64 new_blkno;
6933 unsigned int num_buckets, reflink_buckets;
6934 unsigned int bpc =
6935 ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
6936
6937 ret = ocfs2_read_xattr_bucket(args->old_bucket, blkno);
6938 if (ret) {
6939 mlog_errno(ret);
6940 goto out;
6941 }
6942 num_buckets = le16_to_cpu(bucket_xh(args->old_bucket)->xh_num_buckets);
6943 ocfs2_xattr_bucket_relse(args->old_bucket);
6944
6945 while (len && num_buckets) {
6946 ret = ocfs2_claim_clusters(handle, data_ac,
6947 1, &p_cluster, &num_clusters);
6948 if (ret) {
6949 mlog_errno(ret);
6950 goto out;
6951 }
6952
6953 new_blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
6954 reflink_buckets = min(num_buckets, bpc * num_clusters);
6955
6956 ret = ocfs2_reflink_xattr_bucket(handle, blkno,
6957 new_blkno, num_clusters,
6958 &reflink_cpos, reflink_buckets,
6959 meta_ac, data_ac, args);
6960 if (ret) {
6961 mlog_errno(ret);
6962 goto out;
6963 }
6964
6965 /*
6966 * For the 1st allocated cluster, we make it use the same cpos
6967 * so that the xattr tree looks the same as the original one
6968 * in the most case.
6969 */
6970 if (!first_inserted) {
6971 reflink_cpos = cpos;
6972 first_inserted = 1;
6973 }
6974 ret = ocfs2_insert_extent(handle, et, reflink_cpos, new_blkno,
6975 num_clusters, 0, meta_ac);
6976 if (ret)
6977 mlog_errno(ret);
6978
6979 trace_ocfs2_reflink_xattr_buckets((unsigned long long)new_blkno,
6980 num_clusters, reflink_cpos);
6981
6982 len -= num_clusters;
6983 blkno += ocfs2_clusters_to_blocks(inode->i_sb, num_clusters);
6984 num_buckets -= reflink_buckets;
6985 }
6986 out:
6987 return ret;
6988 }
6989
6990 /*
6991 * Create the same xattr extent record in the new inode's xattr tree.
6992 */
6993 static int ocfs2_reflink_xattr_rec(struct inode *inode,
6994 struct buffer_head *root_bh,
6995 u64 blkno,
6996 u32 cpos,
6997 u32 len,
6998 void *para)
6999 {
7000 int ret, credits = 0;
7001 handle_t *handle;
7002 struct ocfs2_reflink_xattr_tree_args *args =
7003 (struct ocfs2_reflink_xattr_tree_args *)para;
7004 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7005 struct ocfs2_alloc_context *meta_ac = NULL;
7006 struct ocfs2_alloc_context *data_ac = NULL;
7007 struct ocfs2_extent_tree et;
7008
7009 trace_ocfs2_reflink_xattr_rec((unsigned long long)blkno, len);
7010
7011 ocfs2_init_xattr_tree_extent_tree(&et,
7012 INODE_CACHE(args->reflink->new_inode),
7013 args->new_blk_bh);
7014
7015 ret = ocfs2_lock_reflink_xattr_rec_allocators(args, &et, blkno,
7016 len, &credits,
7017 &meta_ac, &data_ac);
7018 if (ret) {
7019 mlog_errno(ret);
7020 goto out;
7021 }
7022
7023 handle = ocfs2_start_trans(osb, credits);
7024 if (IS_ERR(handle)) {
7025 ret = PTR_ERR(handle);
7026 mlog_errno(ret);
7027 goto out;
7028 }
7029
7030 ret = ocfs2_reflink_xattr_buckets(handle, inode, args, &et,
7031 meta_ac, data_ac,
7032 blkno, cpos, len);
7033 if (ret)
7034 mlog_errno(ret);
7035
7036 ocfs2_commit_trans(osb, handle);
7037
7038 out:
7039 if (meta_ac)
7040 ocfs2_free_alloc_context(meta_ac);
7041 if (data_ac)
7042 ocfs2_free_alloc_context(data_ac);
7043 return ret;
7044 }
7045
7046 /*
7047 * Create reflinked xattr buckets.
7048 * We will add bucket one by one, and refcount all the xattrs in the bucket
7049 * if they are stored outside.
7050 */
7051 static int ocfs2_reflink_xattr_tree(struct ocfs2_xattr_reflink *args,
7052 struct buffer_head *blk_bh,
7053 struct buffer_head *new_blk_bh)
7054 {
7055 int ret;
7056 struct ocfs2_reflink_xattr_tree_args para;
7057
7058 memset(&para, 0, sizeof(para));
7059 para.reflink = args;
7060 para.old_blk_bh = blk_bh;
7061 para.new_blk_bh = new_blk_bh;
7062
7063 para.old_bucket = ocfs2_xattr_bucket_new(args->old_inode);
7064 if (!para.old_bucket) {
7065 mlog_errno(-ENOMEM);
7066 return -ENOMEM;
7067 }
7068
7069 para.new_bucket = ocfs2_xattr_bucket_new(args->new_inode);
7070 if (!para.new_bucket) {
7071 ret = -ENOMEM;
7072 mlog_errno(ret);
7073 goto out;
7074 }
7075
7076 ret = ocfs2_iterate_xattr_index_block(args->old_inode, blk_bh,
7077 ocfs2_reflink_xattr_rec,
7078 &para);
7079 if (ret)
7080 mlog_errno(ret);
7081
7082 out:
7083 ocfs2_xattr_bucket_free(para.old_bucket);
7084 ocfs2_xattr_bucket_free(para.new_bucket);
7085 return ret;
7086 }
7087
7088 static int ocfs2_reflink_xattr_in_block(struct ocfs2_xattr_reflink *args,
7089 struct buffer_head *blk_bh)
7090 {
7091 int ret, indexed = 0;
7092 struct buffer_head *new_blk_bh = NULL;
7093 struct ocfs2_xattr_block *xb =
7094 (struct ocfs2_xattr_block *)blk_bh->b_data;
7095
7096
7097 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)
7098 indexed = 1;
7099
7100 ret = ocfs2_create_empty_xattr_block(args->new_inode, args->new_bh,
7101 &new_blk_bh, indexed);
7102 if (ret) {
7103 mlog_errno(ret);
7104 goto out;
7105 }
7106
7107 if (!indexed)
7108 ret = ocfs2_reflink_xattr_block(args, blk_bh, new_blk_bh);
7109 else
7110 ret = ocfs2_reflink_xattr_tree(args, blk_bh, new_blk_bh);
7111 if (ret)
7112 mlog_errno(ret);
7113
7114 out:
7115 brelse(new_blk_bh);
7116 return ret;
7117 }
7118
7119 static int ocfs2_reflink_xattr_no_security(struct ocfs2_xattr_entry *xe)
7120 {
7121 int type = ocfs2_xattr_get_type(xe);
7122
7123 return type != OCFS2_XATTR_INDEX_SECURITY &&
7124 type != OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS &&
7125 type != OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT;
7126 }
7127
7128 int ocfs2_reflink_xattrs(struct inode *old_inode,
7129 struct buffer_head *old_bh,
7130 struct inode *new_inode,
7131 struct buffer_head *new_bh,
7132 bool preserve_security)
7133 {
7134 int ret;
7135 struct ocfs2_xattr_reflink args;
7136 struct ocfs2_inode_info *oi = OCFS2_I(old_inode);
7137 struct ocfs2_dinode *di = (struct ocfs2_dinode *)old_bh->b_data;
7138 struct buffer_head *blk_bh = NULL;
7139 struct ocfs2_cached_dealloc_ctxt dealloc;
7140 struct ocfs2_refcount_tree *ref_tree;
7141 struct buffer_head *ref_root_bh = NULL;
7142
7143 ret = ocfs2_lock_refcount_tree(OCFS2_SB(old_inode->i_sb),
7144 le64_to_cpu(di->i_refcount_loc),
7145 1, &ref_tree, &ref_root_bh);
7146 if (ret) {
7147 mlog_errno(ret);
7148 goto out;
7149 }
7150
7151 ocfs2_init_dealloc_ctxt(&dealloc);
7152
7153 args.old_inode = old_inode;
7154 args.new_inode = new_inode;
7155 args.old_bh = old_bh;
7156 args.new_bh = new_bh;
7157 args.ref_ci = &ref_tree->rf_ci;
7158 args.ref_root_bh = ref_root_bh;
7159 args.dealloc = &dealloc;
7160 if (preserve_security)
7161 args.xattr_reflinked = NULL;
7162 else
7163 args.xattr_reflinked = ocfs2_reflink_xattr_no_security;
7164
7165 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
7166 ret = ocfs2_reflink_xattr_inline(&args);
7167 if (ret) {
7168 mlog_errno(ret);
7169 goto out_unlock;
7170 }
7171 }
7172
7173 if (!di->i_xattr_loc)
7174 goto out_unlock;
7175
7176 ret = ocfs2_read_xattr_block(old_inode, le64_to_cpu(di->i_xattr_loc),
7177 &blk_bh);
7178 if (ret < 0) {
7179 mlog_errno(ret);
7180 goto out_unlock;
7181 }
7182
7183 ret = ocfs2_reflink_xattr_in_block(&args, blk_bh);
7184 if (ret)
7185 mlog_errno(ret);
7186
7187 brelse(blk_bh);
7188
7189 out_unlock:
7190 ocfs2_unlock_refcount_tree(OCFS2_SB(old_inode->i_sb),
7191 ref_tree, 1);
7192 brelse(ref_root_bh);
7193
7194 if (ocfs2_dealloc_has_cluster(&dealloc)) {
7195 ocfs2_schedule_truncate_log_flush(OCFS2_SB(old_inode->i_sb), 1);
7196 ocfs2_run_deallocs(OCFS2_SB(old_inode->i_sb), &dealloc);
7197 }
7198
7199 out:
7200 return ret;
7201 }
7202
7203 /*
7204 * Initialize security and acl for a already created inode.
7205 * Used for reflink a non-preserve-security file.
7206 *
7207 * It uses common api like ocfs2_xattr_set, so the caller
7208 * must not hold any lock expect i_rwsem.
7209 */
7210 int ocfs2_init_security_and_acl(struct inode *dir,
7211 struct inode *inode,
7212 const struct qstr *qstr)
7213 {
7214 int ret = 0;
7215 struct buffer_head *dir_bh = NULL;
7216
7217 ret = ocfs2_init_security_get(inode, dir, qstr, NULL);
7218 if (ret) {
7219 mlog_errno(ret);
7220 goto leave;
7221 }
7222
7223 ret = ocfs2_inode_lock(dir, &dir_bh, 0);
7224 if (ret) {
7225 mlog_errno(ret);
7226 goto leave;
7227 }
7228 ret = ocfs2_init_acl(NULL, inode, dir, NULL, dir_bh, NULL, NULL);
7229 if (ret)
7230 mlog_errno(ret);
7231
7232 ocfs2_inode_unlock(dir, 0);
7233 brelse(dir_bh);
7234 leave:
7235 return ret;
7236 }
7237
7238 /*
7239 * 'security' attributes support
7240 */
7241 static int ocfs2_xattr_security_get(const struct xattr_handler *handler,
7242 struct dentry *unused, struct inode *inode,
7243 const char *name, void *buffer, size_t size)
7244 {
7245 return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_SECURITY,
7246 name, buffer, size);
7247 }
7248
7249 static int ocfs2_xattr_security_set(const struct xattr_handler *handler,
7250 struct user_namespace *mnt_userns,
7251 struct dentry *unused, struct inode *inode,
7252 const char *name, const void *value,
7253 size_t size, int flags)
7254 {
7255 return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY,
7256 name, value, size, flags);
7257 }
7258
7259 static int ocfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
7260 void *fs_info)
7261 {
7262 const struct xattr *xattr;
7263 int err = 0;
7264
7265 for (xattr = xattr_array; xattr->name != NULL; xattr++) {
7266 err = ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY,
7267 xattr->name, xattr->value,
7268 xattr->value_len, XATTR_CREATE);
7269 if (err)
7270 break;
7271 }
7272 return err;
7273 }
7274
7275 int ocfs2_init_security_get(struct inode *inode,
7276 struct inode *dir,
7277 const struct qstr *qstr,
7278 struct ocfs2_security_xattr_info *si)
7279 {
7280 /* check whether ocfs2 support feature xattr */
7281 if (!ocfs2_supports_xattr(OCFS2_SB(dir->i_sb)))
7282 return -EOPNOTSUPP;
7283 if (si)
7284 return security_old_inode_init_security(inode, dir, qstr,
7285 &si->name, &si->value,
7286 &si->value_len);
7287
7288 return security_inode_init_security(inode, dir, qstr,
7289 &ocfs2_initxattrs, NULL);
7290 }
7291
7292 int ocfs2_init_security_set(handle_t *handle,
7293 struct inode *inode,
7294 struct buffer_head *di_bh,
7295 struct ocfs2_security_xattr_info *si,
7296 struct ocfs2_alloc_context *xattr_ac,
7297 struct ocfs2_alloc_context *data_ac)
7298 {
7299 return ocfs2_xattr_set_handle(handle, inode, di_bh,
7300 OCFS2_XATTR_INDEX_SECURITY,
7301 si->name, si->value, si->value_len, 0,
7302 xattr_ac, data_ac);
7303 }
7304
7305 const struct xattr_handler ocfs2_xattr_security_handler = {
7306 .prefix = XATTR_SECURITY_PREFIX,
7307 .get = ocfs2_xattr_security_get,
7308 .set = ocfs2_xattr_security_set,
7309 };
7310
7311 /*
7312 * 'trusted' attributes support
7313 */
7314 static int ocfs2_xattr_trusted_get(const struct xattr_handler *handler,
7315 struct dentry *unused, struct inode *inode,
7316 const char *name, void *buffer, size_t size)
7317 {
7318 return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_TRUSTED,
7319 name, buffer, size);
7320 }
7321
7322 static int ocfs2_xattr_trusted_set(const struct xattr_handler *handler,
7323 struct user_namespace *mnt_userns,
7324 struct dentry *unused, struct inode *inode,
7325 const char *name, const void *value,
7326 size_t size, int flags)
7327 {
7328 return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_TRUSTED,
7329 name, value, size, flags);
7330 }
7331
7332 const struct xattr_handler ocfs2_xattr_trusted_handler = {
7333 .prefix = XATTR_TRUSTED_PREFIX,
7334 .get = ocfs2_xattr_trusted_get,
7335 .set = ocfs2_xattr_trusted_set,
7336 };
7337
7338 /*
7339 * 'user' attributes support
7340 */
7341 static int ocfs2_xattr_user_get(const struct xattr_handler *handler,
7342 struct dentry *unused, struct inode *inode,
7343 const char *name, void *buffer, size_t size)
7344 {
7345 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7346
7347 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
7348 return -EOPNOTSUPP;
7349 return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_USER, name,
7350 buffer, size);
7351 }
7352
7353 static int ocfs2_xattr_user_set(const struct xattr_handler *handler,
7354 struct user_namespace *mnt_userns,
7355 struct dentry *unused, struct inode *inode,
7356 const char *name, const void *value,
7357 size_t size, int flags)
7358 {
7359 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7360
7361 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
7362 return -EOPNOTSUPP;
7363
7364 return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_USER,
7365 name, value, size, flags);
7366 }
7367
7368 const struct xattr_handler ocfs2_xattr_user_handler = {
7369 .prefix = XATTR_USER_PREFIX,
7370 .get = ocfs2_xattr_user_get,
7371 .set = ocfs2_xattr_user_set,
7372 };
Michael's Linux tree.