1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * Copyright (C) 2004, 2008 Oracle. All rights reserved.
9 * Lots of code in this file is copy from linux/fs/ext3/xattr.c.
10 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public
14 * License version 2 as published by the Free Software Foundation.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
22 #include <linux/capability.h>
24 #include <linux/types.h>
25 #include <linux/slab.h>
26 #include <linux/highmem.h>
27 #include <linux/pagemap.h>
28 #include <linux/uio.h>
29 #include <linux/sched.h>
30 #include <linux/splice.h>
31 #include <linux/mount.h>
32 #include <linux/writeback.h>
33 #include <linux/falloc.h>
34 #include <linux/sort.h>
35 #include <linux/init.h>
36 #include <linux/module.h>
37 #include <linux/string.h>
38 #include <linux/security.h>
40 #include <cluster/masklog.h>
44 #include "blockcheck.h"
54 #include "buffer_head_io.h"
57 #include "refcounttree.h"
59 #include "ocfs2_trace.h"
61 struct ocfs2_xattr_def_value_root {
62 struct ocfs2_xattr_value_root xv;
63 struct ocfs2_extent_rec er;
66 struct ocfs2_xattr_bucket {
67 /* The inode these xattrs are associated with */
68 struct inode *bu_inode;
70 /* The actual buffers that make up the bucket */
71 struct buffer_head *bu_bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
73 /* How many blocks make up one bucket for this filesystem */
77 struct ocfs2_xattr_set_ctxt {
79 struct ocfs2_alloc_context *meta_ac;
80 struct ocfs2_alloc_context *data_ac;
81 struct ocfs2_cached_dealloc_ctxt dealloc;
85 #define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root))
86 #define OCFS2_XATTR_INLINE_SIZE 80
87 #define OCFS2_XATTR_HEADER_GAP 4
88 #define OCFS2_XATTR_FREE_IN_IBODY (OCFS2_MIN_XATTR_INLINE_SIZE \
89 - sizeof(struct ocfs2_xattr_header) \
90 - OCFS2_XATTR_HEADER_GAP)
91 #define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \
92 - sizeof(struct ocfs2_xattr_block) \
93 - sizeof(struct ocfs2_xattr_header) \
94 - OCFS2_XATTR_HEADER_GAP)
96 static struct ocfs2_xattr_def_value_root def_xv = {
97 .xv.xr_list.l_count = cpu_to_le16(1),
100 const struct xattr_handler *ocfs2_xattr_handlers[] = {
101 &ocfs2_xattr_user_handler,
102 &posix_acl_access_xattr_handler,
103 &posix_acl_default_xattr_handler,
104 &ocfs2_xattr_trusted_handler,
105 &ocfs2_xattr_security_handler,
109 static const struct xattr_handler *ocfs2_xattr_handler_map[OCFS2_XATTR_MAX] = {
110 [OCFS2_XATTR_INDEX_USER] = &ocfs2_xattr_user_handler,
111 [OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS]
112 = &posix_acl_access_xattr_handler,
113 [OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT]
114 = &posix_acl_default_xattr_handler,
115 [OCFS2_XATTR_INDEX_TRUSTED] = &ocfs2_xattr_trusted_handler,
116 [OCFS2_XATTR_INDEX_SECURITY] = &ocfs2_xattr_security_handler,
119 struct ocfs2_xattr_info {
123 const void *xi_value;
127 struct ocfs2_xattr_search {
128 struct buffer_head *inode_bh;
130 * xattr_bh point to the block buffer head which has extended attribute
131 * when extended attribute in inode, xattr_bh is equal to inode_bh.
133 struct buffer_head *xattr_bh;
134 struct ocfs2_xattr_header *header;
135 struct ocfs2_xattr_bucket *bucket;
138 struct ocfs2_xattr_entry *here;
142 /* Operations on struct ocfs2_xa_entry */
144 struct ocfs2_xa_loc_operations {
148 int (*xlo_journal_access)(handle_t *handle, struct ocfs2_xa_loc *loc,
150 void (*xlo_journal_dirty)(handle_t *handle, struct ocfs2_xa_loc *loc);
153 * Return a pointer to the appropriate buffer in loc->xl_storage
154 * at the given offset from loc->xl_header.
156 void *(*xlo_offset_pointer)(struct ocfs2_xa_loc *loc, int offset);
158 /* Can we reuse the existing entry for the new value? */
159 int (*xlo_can_reuse)(struct ocfs2_xa_loc *loc,
160 struct ocfs2_xattr_info *xi);
162 /* How much space is needed for the new value? */
163 int (*xlo_check_space)(struct ocfs2_xa_loc *loc,
164 struct ocfs2_xattr_info *xi);
167 * Return the offset of the first name+value pair. This is
168 * the start of our downward-filling free space.
170 int (*xlo_get_free_start)(struct ocfs2_xa_loc *loc);
173 * Remove the name+value at this location. Do whatever is
174 * appropriate with the remaining name+value pairs.
176 void (*xlo_wipe_namevalue)(struct ocfs2_xa_loc *loc);
178 /* Fill xl_entry with a new entry */
179 void (*xlo_add_entry)(struct ocfs2_xa_loc *loc, u32 name_hash);
181 /* Add name+value storage to an entry */
182 void (*xlo_add_namevalue)(struct ocfs2_xa_loc *loc, int size);
185 * Initialize the value buf's access and bh fields for this entry.
186 * ocfs2_xa_fill_value_buf() will handle the xv pointer.
188 void (*xlo_fill_value_buf)(struct ocfs2_xa_loc *loc,
189 struct ocfs2_xattr_value_buf *vb);
193 * Describes an xattr entry location. This is a memory structure
194 * tracking the on-disk structure.
196 struct ocfs2_xa_loc {
197 /* This xattr belongs to this inode */
198 struct inode *xl_inode;
200 /* The ocfs2_xattr_header inside the on-disk storage. Not NULL. */
201 struct ocfs2_xattr_header *xl_header;
203 /* Bytes from xl_header to the end of the storage */
207 * The ocfs2_xattr_entry this location describes. If this is
208 * NULL, this location describes the on-disk structure where it
211 struct ocfs2_xattr_entry *xl_entry;
214 * Internal housekeeping
217 /* Buffer(s) containing this entry */
220 /* Operations on the storage backing this location */
221 const struct ocfs2_xa_loc_operations *xl_ops;
225 * Convenience functions to calculate how much space is needed for a
226 * given name+value pair
228 static int namevalue_size(int name_len, uint64_t value_len)
230 if (value_len > OCFS2_XATTR_INLINE_SIZE)
231 return OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
233 return OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(value_len);
236 static int namevalue_size_xi(struct ocfs2_xattr_info *xi)
238 return namevalue_size(xi->xi_name_len, xi->xi_value_len);
241 static int namevalue_size_xe(struct ocfs2_xattr_entry *xe)
243 u64 value_len = le64_to_cpu(xe->xe_value_size);
245 BUG_ON((value_len > OCFS2_XATTR_INLINE_SIZE) &&
246 ocfs2_xattr_is_local(xe));
247 return namevalue_size(xe->xe_name_len, value_len);
251 static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb,
252 struct ocfs2_xattr_header *xh,
257 static int ocfs2_xattr_block_find(struct inode *inode,
260 struct ocfs2_xattr_search *xs);
261 static int ocfs2_xattr_index_block_find(struct inode *inode,
262 struct buffer_head *root_bh,
265 struct ocfs2_xattr_search *xs);
267 static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
268 struct buffer_head *blk_bh,
272 static int ocfs2_xattr_create_index_block(struct inode *inode,
273 struct ocfs2_xattr_search *xs,
274 struct ocfs2_xattr_set_ctxt *ctxt);
276 static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
277 struct ocfs2_xattr_info *xi,
278 struct ocfs2_xattr_search *xs,
279 struct ocfs2_xattr_set_ctxt *ctxt);
281 typedef int (xattr_tree_rec_func)(struct inode *inode,
282 struct buffer_head *root_bh,
283 u64 blkno, u32 cpos, u32 len, void *para);
284 static int ocfs2_iterate_xattr_index_block(struct inode *inode,
285 struct buffer_head *root_bh,
286 xattr_tree_rec_func *rec_func,
288 static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
289 struct ocfs2_xattr_bucket *bucket,
291 static int ocfs2_rm_xattr_cluster(struct inode *inode,
292 struct buffer_head *root_bh,
298 static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle,
299 u64 src_blk, u64 last_blk, u64 to_blk,
300 unsigned int start_bucket,
302 static int ocfs2_prepare_refcount_xattr(struct inode *inode,
303 struct ocfs2_dinode *di,
304 struct ocfs2_xattr_info *xi,
305 struct ocfs2_xattr_search *xis,
306 struct ocfs2_xattr_search *xbs,
307 struct ocfs2_refcount_tree **ref_tree,
310 static int ocfs2_get_xattr_tree_value_root(struct super_block *sb,
311 struct ocfs2_xattr_bucket *bucket,
313 struct ocfs2_xattr_value_root **xv,
314 struct buffer_head **bh);
316 static inline u16 ocfs2_xattr_buckets_per_cluster(struct ocfs2_super *osb)
318 return (1 << osb->s_clustersize_bits) / OCFS2_XATTR_BUCKET_SIZE;
321 static inline u16 ocfs2_blocks_per_xattr_bucket(struct super_block *sb)
323 return OCFS2_XATTR_BUCKET_SIZE / (1 << sb->s_blocksize_bits);
326 #define bucket_blkno(_b) ((_b)->bu_bhs[0]->b_blocknr)
327 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
328 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
330 static struct ocfs2_xattr_bucket *ocfs2_xattr_bucket_new(struct inode *inode)
332 struct ocfs2_xattr_bucket *bucket;
333 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
335 BUG_ON(blks > OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET);
337 bucket = kzalloc(sizeof(struct ocfs2_xattr_bucket), GFP_NOFS);
339 bucket->bu_inode = inode;
340 bucket->bu_blocks = blks;
346 static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket *bucket)
350 for (i = 0; i < bucket->bu_blocks; i++) {
351 brelse(bucket->bu_bhs[i]);
352 bucket->bu_bhs[i] = NULL;
356 static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket *bucket)
359 ocfs2_xattr_bucket_relse(bucket);
360 bucket->bu_inode = NULL;
366 * A bucket that has never been written to disk doesn't need to be
367 * read. We just need the buffer_heads. Don't call this for
368 * buckets that are already on disk. ocfs2_read_xattr_bucket() initializes
371 static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
372 u64 xb_blkno, int new)
376 for (i = 0; i < bucket->bu_blocks; i++) {
377 bucket->bu_bhs[i] = sb_getblk(bucket->bu_inode->i_sb,
379 if (!bucket->bu_bhs[i]) {
385 if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
386 bucket->bu_bhs[i])) {
388 ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
391 set_buffer_uptodate(bucket->bu_bhs[i]);
392 ocfs2_set_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
399 ocfs2_xattr_bucket_relse(bucket);
403 /* Read the xattr bucket at xb_blkno */
404 static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
409 rc = ocfs2_read_blocks(INODE_CACHE(bucket->bu_inode), xb_blkno,
410 bucket->bu_blocks, bucket->bu_bhs, 0,
413 spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
414 rc = ocfs2_validate_meta_ecc_bhs(bucket->bu_inode->i_sb,
417 &bucket_xh(bucket)->xh_check);
418 spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
424 ocfs2_xattr_bucket_relse(bucket);
428 static int ocfs2_xattr_bucket_journal_access(handle_t *handle,
429 struct ocfs2_xattr_bucket *bucket,
434 for (i = 0; i < bucket->bu_blocks; i++) {
435 rc = ocfs2_journal_access(handle,
436 INODE_CACHE(bucket->bu_inode),
437 bucket->bu_bhs[i], type);
447 static void ocfs2_xattr_bucket_journal_dirty(handle_t *handle,
448 struct ocfs2_xattr_bucket *bucket)
452 spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
453 ocfs2_compute_meta_ecc_bhs(bucket->bu_inode->i_sb,
454 bucket->bu_bhs, bucket->bu_blocks,
455 &bucket_xh(bucket)->xh_check);
456 spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
458 for (i = 0; i < bucket->bu_blocks; i++)
459 ocfs2_journal_dirty(handle, bucket->bu_bhs[i]);
462 static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket *dest,
463 struct ocfs2_xattr_bucket *src)
466 int blocksize = src->bu_inode->i_sb->s_blocksize;
468 BUG_ON(dest->bu_blocks != src->bu_blocks);
469 BUG_ON(dest->bu_inode != src->bu_inode);
471 for (i = 0; i < src->bu_blocks; i++) {
472 memcpy(bucket_block(dest, i), bucket_block(src, i),
477 static int ocfs2_validate_xattr_block(struct super_block *sb,
478 struct buffer_head *bh)
481 struct ocfs2_xattr_block *xb =
482 (struct ocfs2_xattr_block *)bh->b_data;
484 trace_ocfs2_validate_xattr_block((unsigned long long)bh->b_blocknr);
486 BUG_ON(!buffer_uptodate(bh));
489 * If the ecc fails, we return the error but otherwise
490 * leave the filesystem running. We know any error is
491 * local to this block.
493 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &xb->xb_check);
498 * Errors after here are fatal
501 if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) {
502 return ocfs2_error(sb,
503 "Extended attribute block #%llu has bad signature %.*s\n",
504 (unsigned long long)bh->b_blocknr, 7,
508 if (le64_to_cpu(xb->xb_blkno) != bh->b_blocknr) {
509 return ocfs2_error(sb,
510 "Extended attribute block #%llu has an invalid xb_blkno of %llu\n",
511 (unsigned long long)bh->b_blocknr,
512 (unsigned long long)le64_to_cpu(xb->xb_blkno));
515 if (le32_to_cpu(xb->xb_fs_generation) != OCFS2_SB(sb)->fs_generation) {
516 return ocfs2_error(sb,
517 "Extended attribute block #%llu has an invalid xb_fs_generation of #%u\n",
518 (unsigned long long)bh->b_blocknr,
519 le32_to_cpu(xb->xb_fs_generation));
525 static int ocfs2_read_xattr_block(struct inode *inode, u64 xb_blkno,
526 struct buffer_head **bh)
529 struct buffer_head *tmp = *bh;
531 rc = ocfs2_read_block(INODE_CACHE(inode), xb_blkno, &tmp,
532 ocfs2_validate_xattr_block);
534 /* If ocfs2_read_block() got us a new bh, pass it up. */
541 static inline const char *ocfs2_xattr_prefix(int name_index)
543 const struct xattr_handler *handler = NULL;
545 if (name_index > 0 && name_index < OCFS2_XATTR_MAX)
546 handler = ocfs2_xattr_handler_map[name_index];
548 return handler ? handler->prefix : NULL;
551 static u32 ocfs2_xattr_name_hash(struct inode *inode,
555 /* Get hash value of uuid from super block */
556 u32 hash = OCFS2_SB(inode->i_sb)->uuid_hash;
559 /* hash extended attribute name */
560 for (i = 0; i < name_len; i++) {
561 hash = (hash << OCFS2_HASH_SHIFT) ^
562 (hash >> (8*sizeof(hash) - OCFS2_HASH_SHIFT)) ^
569 static int ocfs2_xattr_entry_real_size(int name_len, size_t value_len)
571 return namevalue_size(name_len, value_len) +
572 sizeof(struct ocfs2_xattr_entry);
575 static int ocfs2_xi_entry_usage(struct ocfs2_xattr_info *xi)
577 return namevalue_size_xi(xi) +
578 sizeof(struct ocfs2_xattr_entry);
581 static int ocfs2_xe_entry_usage(struct ocfs2_xattr_entry *xe)
583 return namevalue_size_xe(xe) +
584 sizeof(struct ocfs2_xattr_entry);
587 int ocfs2_calc_security_init(struct inode *dir,
588 struct ocfs2_security_xattr_info *si,
591 struct ocfs2_alloc_context **xattr_ac)
594 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
595 int s_size = ocfs2_xattr_entry_real_size(strlen(si->name),
599 * The max space of security xattr taken inline is
600 * 256(name) + 80(value) + 16(entry) = 352 bytes,
601 * So reserve one metadata block for it is ok.
603 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE ||
604 s_size > OCFS2_XATTR_FREE_IN_IBODY) {
605 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, xattr_ac);
610 *xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
613 /* reserve clusters for xattr value which will be set in B tree*/
614 if (si->value_len > OCFS2_XATTR_INLINE_SIZE) {
615 int new_clusters = ocfs2_clusters_for_bytes(dir->i_sb,
618 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
620 *want_clusters += new_clusters;
625 int ocfs2_calc_xattr_init(struct inode *dir,
626 struct buffer_head *dir_bh,
628 struct ocfs2_security_xattr_info *si,
634 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
635 int s_size = 0, a_size = 0, acl_len = 0, new_clusters;
638 s_size = ocfs2_xattr_entry_real_size(strlen(si->name),
641 if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) {
642 down_read(&OCFS2_I(dir)->ip_xattr_sem);
643 acl_len = ocfs2_xattr_get_nolock(dir, dir_bh,
644 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
646 up_read(&OCFS2_I(dir)->ip_xattr_sem);
648 a_size = ocfs2_xattr_entry_real_size(0, acl_len);
651 } else if (acl_len != 0 && acl_len != -ENODATA) {
657 if (!(s_size + a_size))
661 * The max space of security xattr taken inline is
662 * 256(name) + 80(value) + 16(entry) = 352 bytes,
663 * The max space of acl xattr taken inline is
664 * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
665 * when blocksize = 512, may reserve one more cluser for
666 * xattr bucket, otherwise reserve one metadata block
668 * If this is a new directory with inline data,
669 * we choose to reserve the entire inline area for
670 * directory contents and force an external xattr block.
672 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE ||
673 (S_ISDIR(mode) && ocfs2_supports_inline_data(osb)) ||
674 (s_size + a_size) > OCFS2_XATTR_FREE_IN_IBODY) {
675 *want_meta = *want_meta + 1;
676 *xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
679 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE &&
680 (s_size + a_size) > OCFS2_XATTR_FREE_IN_BLOCK(dir)) {
682 *xattr_credits += ocfs2_blocks_per_xattr_bucket(dir->i_sb);
686 * reserve credits and clusters for xattrs which has large value
687 * and have to be set outside
689 if (si->enable && si->value_len > OCFS2_XATTR_INLINE_SIZE) {
690 new_clusters = ocfs2_clusters_for_bytes(dir->i_sb,
692 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
694 *want_clusters += new_clusters;
696 if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL &&
697 acl_len > OCFS2_XATTR_INLINE_SIZE) {
698 /* for directory, it has DEFAULT and ACCESS two types of acls */
699 new_clusters = (S_ISDIR(mode) ? 2 : 1) *
700 ocfs2_clusters_for_bytes(dir->i_sb, acl_len);
701 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
703 *want_clusters += new_clusters;
709 static int ocfs2_xattr_extend_allocation(struct inode *inode,
711 struct ocfs2_xattr_value_buf *vb,
712 struct ocfs2_xattr_set_ctxt *ctxt)
714 int status = 0, credits;
715 handle_t *handle = ctxt->handle;
716 enum ocfs2_alloc_restarted why;
717 u32 prev_clusters, logical_start = le32_to_cpu(vb->vb_xv->xr_clusters);
718 struct ocfs2_extent_tree et;
720 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
722 while (clusters_to_add) {
723 trace_ocfs2_xattr_extend_allocation(clusters_to_add);
725 status = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
726 OCFS2_JOURNAL_ACCESS_WRITE);
732 prev_clusters = le32_to_cpu(vb->vb_xv->xr_clusters);
733 status = ocfs2_add_clusters_in_btree(handle,
741 if ((status < 0) && (status != -EAGAIN)) {
742 if (status != -ENOSPC)
747 ocfs2_journal_dirty(handle, vb->vb_bh);
749 clusters_to_add -= le32_to_cpu(vb->vb_xv->xr_clusters) -
752 if (why != RESTART_NONE && clusters_to_add) {
754 * We can only fail in case the alloc file doesn't give
755 * up enough clusters.
757 BUG_ON(why == RESTART_META);
759 credits = ocfs2_calc_extend_credits(inode->i_sb,
760 &vb->vb_xv->xr_list);
761 status = ocfs2_extend_trans(handle, credits);
773 static int __ocfs2_remove_xattr_range(struct inode *inode,
774 struct ocfs2_xattr_value_buf *vb,
775 u32 cpos, u32 phys_cpos, u32 len,
776 unsigned int ext_flags,
777 struct ocfs2_xattr_set_ctxt *ctxt)
780 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
781 handle_t *handle = ctxt->handle;
782 struct ocfs2_extent_tree et;
784 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
786 ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
787 OCFS2_JOURNAL_ACCESS_WRITE);
793 ret = ocfs2_remove_extent(handle, &et, cpos, len, ctxt->meta_ac,
800 le32_add_cpu(&vb->vb_xv->xr_clusters, -len);
801 ocfs2_journal_dirty(handle, vb->vb_bh);
803 if (ext_flags & OCFS2_EXT_REFCOUNTED)
804 ret = ocfs2_decrease_refcount(inode, handle,
805 ocfs2_blocks_to_clusters(inode->i_sb,
807 len, ctxt->meta_ac, &ctxt->dealloc, 1);
809 ret = ocfs2_cache_cluster_dealloc(&ctxt->dealloc,
818 static int ocfs2_xattr_shrink_size(struct inode *inode,
821 struct ocfs2_xattr_value_buf *vb,
822 struct ocfs2_xattr_set_ctxt *ctxt)
825 unsigned int ext_flags;
826 u32 trunc_len, cpos, phys_cpos, alloc_size;
829 if (old_clusters <= new_clusters)
833 trunc_len = old_clusters - new_clusters;
835 ret = ocfs2_xattr_get_clusters(inode, cpos, &phys_cpos,
837 &vb->vb_xv->xr_list, &ext_flags);
843 if (alloc_size > trunc_len)
844 alloc_size = trunc_len;
846 ret = __ocfs2_remove_xattr_range(inode, vb, cpos,
847 phys_cpos, alloc_size,
854 block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
855 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode),
858 trunc_len -= alloc_size;
865 static int ocfs2_xattr_value_truncate(struct inode *inode,
866 struct ocfs2_xattr_value_buf *vb,
868 struct ocfs2_xattr_set_ctxt *ctxt)
871 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len);
872 u32 old_clusters = le32_to_cpu(vb->vb_xv->xr_clusters);
874 if (new_clusters == old_clusters)
877 if (new_clusters > old_clusters)
878 ret = ocfs2_xattr_extend_allocation(inode,
879 new_clusters - old_clusters,
882 ret = ocfs2_xattr_shrink_size(inode,
883 old_clusters, new_clusters,
889 static int ocfs2_xattr_list_entry(char *buffer, size_t size,
890 size_t *result, const char *prefix,
891 const char *name, int name_len)
893 char *p = buffer + *result;
894 int prefix_len = strlen(prefix);
895 int total_len = prefix_len + name_len + 1;
897 *result += total_len;
899 /* we are just looking for how big our buffer needs to be */
906 memcpy(p, prefix, prefix_len);
907 memcpy(p + prefix_len, name, name_len);
908 p[prefix_len + name_len] = '\0';
913 static int ocfs2_xattr_list_entries(struct inode *inode,
914 struct ocfs2_xattr_header *header,
915 char *buffer, size_t buffer_size)
919 const char *prefix, *name;
921 for (i = 0 ; i < le16_to_cpu(header->xh_count); i++) {
922 struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
923 type = ocfs2_xattr_get_type(entry);
924 prefix = ocfs2_xattr_prefix(type);
927 name = (const char *)header +
928 le16_to_cpu(entry->xe_name_offset);
930 ret = ocfs2_xattr_list_entry(buffer, buffer_size,
931 &result, prefix, name,
941 int ocfs2_has_inline_xattr_value_outside(struct inode *inode,
942 struct ocfs2_dinode *di)
944 struct ocfs2_xattr_header *xh;
947 xh = (struct ocfs2_xattr_header *)
948 ((void *)di + inode->i_sb->s_blocksize -
949 le16_to_cpu(di->i_xattr_inline_size));
951 for (i = 0; i < le16_to_cpu(xh->xh_count); i++)
952 if (!ocfs2_xattr_is_local(&xh->xh_entries[i]))
958 static int ocfs2_xattr_ibody_list(struct inode *inode,
959 struct ocfs2_dinode *di,
963 struct ocfs2_xattr_header *header = NULL;
964 struct ocfs2_inode_info *oi = OCFS2_I(inode);
967 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
970 header = (struct ocfs2_xattr_header *)
971 ((void *)di + inode->i_sb->s_blocksize -
972 le16_to_cpu(di->i_xattr_inline_size));
974 ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size);
979 static int ocfs2_xattr_block_list(struct inode *inode,
980 struct ocfs2_dinode *di,
984 struct buffer_head *blk_bh = NULL;
985 struct ocfs2_xattr_block *xb;
988 if (!di->i_xattr_loc)
991 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
998 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
999 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
1000 struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
1001 ret = ocfs2_xattr_list_entries(inode, header,
1002 buffer, buffer_size);
1004 ret = ocfs2_xattr_tree_list_index_block(inode, blk_bh,
1005 buffer, buffer_size);
1012 ssize_t ocfs2_listxattr(struct dentry *dentry,
1016 int ret = 0, i_ret = 0, b_ret = 0;
1017 struct buffer_head *di_bh = NULL;
1018 struct ocfs2_dinode *di = NULL;
1019 struct ocfs2_inode_info *oi = OCFS2_I(d_inode(dentry));
1021 if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb)))
1024 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
1027 ret = ocfs2_inode_lock(d_inode(dentry), &di_bh, 0);
1033 di = (struct ocfs2_dinode *)di_bh->b_data;
1035 down_read(&oi->ip_xattr_sem);
1036 i_ret = ocfs2_xattr_ibody_list(d_inode(dentry), di, buffer, size);
1044 b_ret = ocfs2_xattr_block_list(d_inode(dentry), di,
1049 up_read(&oi->ip_xattr_sem);
1050 ocfs2_inode_unlock(d_inode(dentry), 0);
1054 return i_ret + b_ret;
1057 static int ocfs2_xattr_find_entry(int name_index,
1059 struct ocfs2_xattr_search *xs)
1061 struct ocfs2_xattr_entry *entry;
1068 name_len = strlen(name);
1070 for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
1071 cmp = name_index - ocfs2_xattr_get_type(entry);
1073 cmp = name_len - entry->xe_name_len;
1075 cmp = memcmp(name, (xs->base +
1076 le16_to_cpu(entry->xe_name_offset)),
1084 return cmp ? -ENODATA : 0;
1087 static int ocfs2_xattr_get_value_outside(struct inode *inode,
1088 struct ocfs2_xattr_value_root *xv,
1092 u32 cpos, p_cluster, num_clusters, bpc, clusters;
1095 size_t cplen, blocksize;
1096 struct buffer_head *bh = NULL;
1097 struct ocfs2_extent_list *el;
1100 clusters = le32_to_cpu(xv->xr_clusters);
1101 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
1102 blocksize = inode->i_sb->s_blocksize;
1105 while (cpos < clusters) {
1106 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
1107 &num_clusters, el, NULL);
1113 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
1114 /* Copy ocfs2_xattr_value */
1115 for (i = 0; i < num_clusters * bpc; i++, blkno++) {
1116 ret = ocfs2_read_block(INODE_CACHE(inode), blkno,
1123 cplen = len >= blocksize ? blocksize : len;
1124 memcpy(buffer, bh->b_data, cplen);
1133 cpos += num_clusters;
1139 static int ocfs2_xattr_ibody_get(struct inode *inode,
1144 struct ocfs2_xattr_search *xs)
1146 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1147 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
1148 struct ocfs2_xattr_value_root *xv;
1152 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
1155 xs->end = (void *)di + inode->i_sb->s_blocksize;
1156 xs->header = (struct ocfs2_xattr_header *)
1157 (xs->end - le16_to_cpu(di->i_xattr_inline_size));
1158 xs->base = (void *)xs->header;
1159 xs->here = xs->header->xh_entries;
1161 ret = ocfs2_xattr_find_entry(name_index, name, xs);
1164 size = le64_to_cpu(xs->here->xe_value_size);
1166 if (size > buffer_size)
1168 if (ocfs2_xattr_is_local(xs->here)) {
1169 memcpy(buffer, (void *)xs->base +
1170 le16_to_cpu(xs->here->xe_name_offset) +
1171 OCFS2_XATTR_SIZE(xs->here->xe_name_len), size);
1173 xv = (struct ocfs2_xattr_value_root *)
1174 (xs->base + le16_to_cpu(
1175 xs->here->xe_name_offset) +
1176 OCFS2_XATTR_SIZE(xs->here->xe_name_len));
1177 ret = ocfs2_xattr_get_value_outside(inode, xv,
1189 static int ocfs2_xattr_block_get(struct inode *inode,
1194 struct ocfs2_xattr_search *xs)
1196 struct ocfs2_xattr_block *xb;
1197 struct ocfs2_xattr_value_root *xv;
1199 int ret = -ENODATA, name_offset, name_len, i;
1200 int uninitialized_var(block_off);
1202 xs->bucket = ocfs2_xattr_bucket_new(inode);
1209 ret = ocfs2_xattr_block_find(inode, name_index, name, xs);
1215 if (xs->not_found) {
1220 xb = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
1221 size = le64_to_cpu(xs->here->xe_value_size);
1224 if (size > buffer_size)
1227 name_offset = le16_to_cpu(xs->here->xe_name_offset);
1228 name_len = OCFS2_XATTR_SIZE(xs->here->xe_name_len);
1229 i = xs->here - xs->header->xh_entries;
1231 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
1232 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
1233 bucket_xh(xs->bucket),
1241 xs->base = bucket_block(xs->bucket, block_off);
1243 if (ocfs2_xattr_is_local(xs->here)) {
1244 memcpy(buffer, (void *)xs->base +
1245 name_offset + name_len, size);
1247 xv = (struct ocfs2_xattr_value_root *)
1248 (xs->base + name_offset + name_len);
1249 ret = ocfs2_xattr_get_value_outside(inode, xv,
1259 ocfs2_xattr_bucket_free(xs->bucket);
1261 brelse(xs->xattr_bh);
1262 xs->xattr_bh = NULL;
1266 int ocfs2_xattr_get_nolock(struct inode *inode,
1267 struct buffer_head *di_bh,
1274 struct ocfs2_dinode *di = NULL;
1275 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1276 struct ocfs2_xattr_search xis = {
1277 .not_found = -ENODATA,
1279 struct ocfs2_xattr_search xbs = {
1280 .not_found = -ENODATA,
1283 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
1286 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
1289 xis.inode_bh = xbs.inode_bh = di_bh;
1290 di = (struct ocfs2_dinode *)di_bh->b_data;
1292 ret = ocfs2_xattr_ibody_get(inode, name_index, name, buffer,
1294 if (ret == -ENODATA && di->i_xattr_loc)
1295 ret = ocfs2_xattr_block_get(inode, name_index, name, buffer,
1301 /* ocfs2_xattr_get()
1303 * Copy an extended attribute into the buffer provided.
1304 * Buffer is NULL to compute the size of buffer required.
1306 static int ocfs2_xattr_get(struct inode *inode,
1313 struct buffer_head *di_bh = NULL;
1315 ret = ocfs2_inode_lock(inode, &di_bh, 0);
1320 down_read(&OCFS2_I(inode)->ip_xattr_sem);
1321 ret = ocfs2_xattr_get_nolock(inode, di_bh, name_index,
1322 name, buffer, buffer_size);
1323 up_read(&OCFS2_I(inode)->ip_xattr_sem);
1325 ocfs2_inode_unlock(inode, 0);
1332 static int __ocfs2_xattr_set_value_outside(struct inode *inode,
1334 struct ocfs2_xattr_value_buf *vb,
1338 int ret = 0, i, cp_len;
1339 u16 blocksize = inode->i_sb->s_blocksize;
1340 u32 p_cluster, num_clusters;
1341 u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
1342 u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len);
1344 struct buffer_head *bh = NULL;
1345 unsigned int ext_flags;
1346 struct ocfs2_xattr_value_root *xv = vb->vb_xv;
1348 BUG_ON(clusters > le32_to_cpu(xv->xr_clusters));
1350 while (cpos < clusters) {
1351 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
1352 &num_clusters, &xv->xr_list,
1359 BUG_ON(ext_flags & OCFS2_EXT_REFCOUNTED);
1361 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
1363 for (i = 0; i < num_clusters * bpc; i++, blkno++) {
1364 ret = ocfs2_read_block(INODE_CACHE(inode), blkno,
1371 ret = ocfs2_journal_access(handle,
1374 OCFS2_JOURNAL_ACCESS_WRITE);
1380 cp_len = value_len > blocksize ? blocksize : value_len;
1381 memcpy(bh->b_data, value, cp_len);
1382 value_len -= cp_len;
1384 if (cp_len < blocksize)
1385 memset(bh->b_data + cp_len, 0,
1386 blocksize - cp_len);
1388 ocfs2_journal_dirty(handle, bh);
1393 * XXX: do we need to empty all the following
1394 * blocks in this cluster?
1399 cpos += num_clusters;
1407 static int ocfs2_xa_check_space_helper(int needed_space, int free_start,
1415 free_space = free_start -
1416 sizeof(struct ocfs2_xattr_header) -
1417 (num_entries * sizeof(struct ocfs2_xattr_entry)) -
1418 OCFS2_XATTR_HEADER_GAP;
1421 if (free_space < needed_space)
1427 static int ocfs2_xa_journal_access(handle_t *handle, struct ocfs2_xa_loc *loc,
1430 return loc->xl_ops->xlo_journal_access(handle, loc, type);
1433 static void ocfs2_xa_journal_dirty(handle_t *handle, struct ocfs2_xa_loc *loc)
1435 loc->xl_ops->xlo_journal_dirty(handle, loc);
1438 /* Give a pointer into the storage for the given offset */
1439 static void *ocfs2_xa_offset_pointer(struct ocfs2_xa_loc *loc, int offset)
1441 BUG_ON(offset >= loc->xl_size);
1442 return loc->xl_ops->xlo_offset_pointer(loc, offset);
1446 * Wipe the name+value pair and allow the storage to reclaim it. This
1447 * must be followed by either removal of the entry or a call to
1448 * ocfs2_xa_add_namevalue().
1450 static void ocfs2_xa_wipe_namevalue(struct ocfs2_xa_loc *loc)
1452 loc->xl_ops->xlo_wipe_namevalue(loc);
1456 * Find lowest offset to a name+value pair. This is the start of our
1457 * downward-growing free space.
1459 static int ocfs2_xa_get_free_start(struct ocfs2_xa_loc *loc)
1461 return loc->xl_ops->xlo_get_free_start(loc);
1464 /* Can we reuse loc->xl_entry for xi? */
1465 static int ocfs2_xa_can_reuse_entry(struct ocfs2_xa_loc *loc,
1466 struct ocfs2_xattr_info *xi)
1468 return loc->xl_ops->xlo_can_reuse(loc, xi);
1471 /* How much free space is needed to set the new value */
1472 static int ocfs2_xa_check_space(struct ocfs2_xa_loc *loc,
1473 struct ocfs2_xattr_info *xi)
1475 return loc->xl_ops->xlo_check_space(loc, xi);
1478 static void ocfs2_xa_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash)
1480 loc->xl_ops->xlo_add_entry(loc, name_hash);
1481 loc->xl_entry->xe_name_hash = cpu_to_le32(name_hash);
1483 * We can't leave the new entry's xe_name_offset at zero or
1484 * add_namevalue() will go nuts. We set it to the size of our
1485 * storage so that it can never be less than any other entry.
1487 loc->xl_entry->xe_name_offset = cpu_to_le16(loc->xl_size);
1490 static void ocfs2_xa_add_namevalue(struct ocfs2_xa_loc *loc,
1491 struct ocfs2_xattr_info *xi)
1493 int size = namevalue_size_xi(xi);
1497 loc->xl_ops->xlo_add_namevalue(loc, size);
1498 loc->xl_entry->xe_value_size = cpu_to_le64(xi->xi_value_len);
1499 loc->xl_entry->xe_name_len = xi->xi_name_len;
1500 ocfs2_xattr_set_type(loc->xl_entry, xi->xi_name_index);
1501 ocfs2_xattr_set_local(loc->xl_entry,
1502 xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE);
1504 nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset);
1505 nameval_buf = ocfs2_xa_offset_pointer(loc, nameval_offset);
1506 memset(nameval_buf, 0, size);
1507 memcpy(nameval_buf, xi->xi_name, xi->xi_name_len);
1510 static void ocfs2_xa_fill_value_buf(struct ocfs2_xa_loc *loc,
1511 struct ocfs2_xattr_value_buf *vb)
1513 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset);
1514 int name_size = OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len);
1516 /* Value bufs are for value trees */
1517 BUG_ON(ocfs2_xattr_is_local(loc->xl_entry));
1518 BUG_ON(namevalue_size_xe(loc->xl_entry) !=
1519 (name_size + OCFS2_XATTR_ROOT_SIZE));
1521 loc->xl_ops->xlo_fill_value_buf(loc, vb);
1523 (struct ocfs2_xattr_value_root *)ocfs2_xa_offset_pointer(loc,
1528 static int ocfs2_xa_block_journal_access(handle_t *handle,
1529 struct ocfs2_xa_loc *loc, int type)
1531 struct buffer_head *bh = loc->xl_storage;
1532 ocfs2_journal_access_func access;
1534 if (loc->xl_size == (bh->b_size -
1535 offsetof(struct ocfs2_xattr_block,
1536 xb_attrs.xb_header)))
1537 access = ocfs2_journal_access_xb;
1539 access = ocfs2_journal_access_di;
1540 return access(handle, INODE_CACHE(loc->xl_inode), bh, type);
1543 static void ocfs2_xa_block_journal_dirty(handle_t *handle,
1544 struct ocfs2_xa_loc *loc)
1546 struct buffer_head *bh = loc->xl_storage;
1548 ocfs2_journal_dirty(handle, bh);
1551 static void *ocfs2_xa_block_offset_pointer(struct ocfs2_xa_loc *loc,
1554 return (char *)loc->xl_header + offset;
1557 static int ocfs2_xa_block_can_reuse(struct ocfs2_xa_loc *loc,
1558 struct ocfs2_xattr_info *xi)
1561 * Block storage is strict. If the sizes aren't exact, we will
1562 * remove the old one and reinsert the new.
1564 return namevalue_size_xe(loc->xl_entry) ==
1565 namevalue_size_xi(xi);
1568 static int ocfs2_xa_block_get_free_start(struct ocfs2_xa_loc *loc)
1570 struct ocfs2_xattr_header *xh = loc->xl_header;
1571 int i, count = le16_to_cpu(xh->xh_count);
1572 int offset, free_start = loc->xl_size;
1574 for (i = 0; i < count; i++) {
1575 offset = le16_to_cpu(xh->xh_entries[i].xe_name_offset);
1576 if (offset < free_start)
1577 free_start = offset;
1583 static int ocfs2_xa_block_check_space(struct ocfs2_xa_loc *loc,
1584 struct ocfs2_xattr_info *xi)
1586 int count = le16_to_cpu(loc->xl_header->xh_count);
1587 int free_start = ocfs2_xa_get_free_start(loc);
1588 int needed_space = ocfs2_xi_entry_usage(xi);
1591 * Block storage will reclaim the original entry before inserting
1592 * the new value, so we only need the difference. If the new
1593 * entry is smaller than the old one, we don't need anything.
1595 if (loc->xl_entry) {
1596 /* Don't need space if we're reusing! */
1597 if (ocfs2_xa_can_reuse_entry(loc, xi))
1600 needed_space -= ocfs2_xe_entry_usage(loc->xl_entry);
1602 if (needed_space < 0)
1604 return ocfs2_xa_check_space_helper(needed_space, free_start, count);
1608 * Block storage for xattrs keeps the name+value pairs compacted. When
1609 * we remove one, we have to shift any that preceded it towards the end.
1611 static void ocfs2_xa_block_wipe_namevalue(struct ocfs2_xa_loc *loc)
1614 int namevalue_offset, first_namevalue_offset, namevalue_size;
1615 struct ocfs2_xattr_entry *entry = loc->xl_entry;
1616 struct ocfs2_xattr_header *xh = loc->xl_header;
1617 int count = le16_to_cpu(xh->xh_count);
1619 namevalue_offset = le16_to_cpu(entry->xe_name_offset);
1620 namevalue_size = namevalue_size_xe(entry);
1621 first_namevalue_offset = ocfs2_xa_get_free_start(loc);
1623 /* Shift the name+value pairs */
1624 memmove((char *)xh + first_namevalue_offset + namevalue_size,
1625 (char *)xh + first_namevalue_offset,
1626 namevalue_offset - first_namevalue_offset);
1627 memset((char *)xh + first_namevalue_offset, 0, namevalue_size);
1629 /* Now tell xh->xh_entries about it */
1630 for (i = 0; i < count; i++) {
1631 offset = le16_to_cpu(xh->xh_entries[i].xe_name_offset);
1632 if (offset <= namevalue_offset)
1633 le16_add_cpu(&xh->xh_entries[i].xe_name_offset,
1638 * Note that we don't update xh_free_start or xh_name_value_len
1639 * because they're not used in block-stored xattrs.
1643 static void ocfs2_xa_block_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash)
1645 int count = le16_to_cpu(loc->xl_header->xh_count);
1646 loc->xl_entry = &(loc->xl_header->xh_entries[count]);
1647 le16_add_cpu(&loc->xl_header->xh_count, 1);
1648 memset(loc->xl_entry, 0, sizeof(struct ocfs2_xattr_entry));
1651 static void ocfs2_xa_block_add_namevalue(struct ocfs2_xa_loc *loc, int size)
1653 int free_start = ocfs2_xa_get_free_start(loc);
1655 loc->xl_entry->xe_name_offset = cpu_to_le16(free_start - size);
1658 static void ocfs2_xa_block_fill_value_buf(struct ocfs2_xa_loc *loc,
1659 struct ocfs2_xattr_value_buf *vb)
1661 struct buffer_head *bh = loc->xl_storage;
1663 if (loc->xl_size == (bh->b_size -
1664 offsetof(struct ocfs2_xattr_block,
1665 xb_attrs.xb_header)))
1666 vb->vb_access = ocfs2_journal_access_xb;
1668 vb->vb_access = ocfs2_journal_access_di;
1673 * Operations for xattrs stored in blocks. This includes inline inode
1674 * storage and unindexed ocfs2_xattr_blocks.
1676 static const struct ocfs2_xa_loc_operations ocfs2_xa_block_loc_ops = {
1677 .xlo_journal_access = ocfs2_xa_block_journal_access,
1678 .xlo_journal_dirty = ocfs2_xa_block_journal_dirty,
1679 .xlo_offset_pointer = ocfs2_xa_block_offset_pointer,
1680 .xlo_check_space = ocfs2_xa_block_check_space,
1681 .xlo_can_reuse = ocfs2_xa_block_can_reuse,
1682 .xlo_get_free_start = ocfs2_xa_block_get_free_start,
1683 .xlo_wipe_namevalue = ocfs2_xa_block_wipe_namevalue,
1684 .xlo_add_entry = ocfs2_xa_block_add_entry,
1685 .xlo_add_namevalue = ocfs2_xa_block_add_namevalue,
1686 .xlo_fill_value_buf = ocfs2_xa_block_fill_value_buf,
1689 static int ocfs2_xa_bucket_journal_access(handle_t *handle,
1690 struct ocfs2_xa_loc *loc, int type)
1692 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1694 return ocfs2_xattr_bucket_journal_access(handle, bucket, type);
1697 static void ocfs2_xa_bucket_journal_dirty(handle_t *handle,
1698 struct ocfs2_xa_loc *loc)
1700 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1702 ocfs2_xattr_bucket_journal_dirty(handle, bucket);
1705 static void *ocfs2_xa_bucket_offset_pointer(struct ocfs2_xa_loc *loc,
1708 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1709 int block, block_offset;
1711 /* The header is at the front of the bucket */
1712 block = offset >> loc->xl_inode->i_sb->s_blocksize_bits;
1713 block_offset = offset % loc->xl_inode->i_sb->s_blocksize;
1715 return bucket_block(bucket, block) + block_offset;
1718 static int ocfs2_xa_bucket_can_reuse(struct ocfs2_xa_loc *loc,
1719 struct ocfs2_xattr_info *xi)
1721 return namevalue_size_xe(loc->xl_entry) >=
1722 namevalue_size_xi(xi);
1725 static int ocfs2_xa_bucket_get_free_start(struct ocfs2_xa_loc *loc)
1727 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1728 return le16_to_cpu(bucket_xh(bucket)->xh_free_start);
1731 static int ocfs2_bucket_align_free_start(struct super_block *sb,
1732 int free_start, int size)
1735 * We need to make sure that the name+value pair fits within
1738 if (((free_start - size) >> sb->s_blocksize_bits) !=
1739 ((free_start - 1) >> sb->s_blocksize_bits))
1740 free_start -= free_start % sb->s_blocksize;
1745 static int ocfs2_xa_bucket_check_space(struct ocfs2_xa_loc *loc,
1746 struct ocfs2_xattr_info *xi)
1749 int count = le16_to_cpu(loc->xl_header->xh_count);
1750 int free_start = ocfs2_xa_get_free_start(loc);
1751 int needed_space = ocfs2_xi_entry_usage(xi);
1752 int size = namevalue_size_xi(xi);
1753 struct super_block *sb = loc->xl_inode->i_sb;
1756 * Bucket storage does not reclaim name+value pairs it cannot
1757 * reuse. They live as holes until the bucket fills, and then
1758 * the bucket is defragmented. However, the bucket can reclaim
1759 * the ocfs2_xattr_entry.
1761 if (loc->xl_entry) {
1762 /* Don't need space if we're reusing! */
1763 if (ocfs2_xa_can_reuse_entry(loc, xi))
1766 needed_space -= sizeof(struct ocfs2_xattr_entry);
1768 BUG_ON(needed_space < 0);
1770 if (free_start < size) {
1775 * First we check if it would fit in the first place.
1776 * Below, we align the free start to a block. This may
1777 * slide us below the minimum gap. By checking unaligned
1778 * first, we avoid that error.
1780 rc = ocfs2_xa_check_space_helper(needed_space, free_start,
1784 free_start = ocfs2_bucket_align_free_start(sb, free_start,
1787 return ocfs2_xa_check_space_helper(needed_space, free_start, count);
1790 static void ocfs2_xa_bucket_wipe_namevalue(struct ocfs2_xa_loc *loc)
1792 le16_add_cpu(&loc->xl_header->xh_name_value_len,
1793 -namevalue_size_xe(loc->xl_entry));
1796 static void ocfs2_xa_bucket_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash)
1798 struct ocfs2_xattr_header *xh = loc->xl_header;
1799 int count = le16_to_cpu(xh->xh_count);
1800 int low = 0, high = count - 1, tmp;
1801 struct ocfs2_xattr_entry *tmp_xe;
1804 * We keep buckets sorted by name_hash, so we need to find
1807 while (low <= high && count) {
1808 tmp = (low + high) / 2;
1809 tmp_xe = &xh->xh_entries[tmp];
1811 if (name_hash > le32_to_cpu(tmp_xe->xe_name_hash))
1813 else if (name_hash < le32_to_cpu(tmp_xe->xe_name_hash))
1822 memmove(&xh->xh_entries[low + 1],
1823 &xh->xh_entries[low],
1824 ((count - low) * sizeof(struct ocfs2_xattr_entry)));
1826 le16_add_cpu(&xh->xh_count, 1);
1827 loc->xl_entry = &xh->xh_entries[low];
1828 memset(loc->xl_entry, 0, sizeof(struct ocfs2_xattr_entry));
1831 static void ocfs2_xa_bucket_add_namevalue(struct ocfs2_xa_loc *loc, int size)
1833 int free_start = ocfs2_xa_get_free_start(loc);
1834 struct ocfs2_xattr_header *xh = loc->xl_header;
1835 struct super_block *sb = loc->xl_inode->i_sb;
1838 free_start = ocfs2_bucket_align_free_start(sb, free_start, size);
1839 nameval_offset = free_start - size;
1840 loc->xl_entry->xe_name_offset = cpu_to_le16(nameval_offset);
1841 xh->xh_free_start = cpu_to_le16(nameval_offset);
1842 le16_add_cpu(&xh->xh_name_value_len, size);
1846 static void ocfs2_xa_bucket_fill_value_buf(struct ocfs2_xa_loc *loc,
1847 struct ocfs2_xattr_value_buf *vb)
1849 struct ocfs2_xattr_bucket *bucket = loc->xl_storage;
1850 struct super_block *sb = loc->xl_inode->i_sb;
1851 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset);
1852 int size = namevalue_size_xe(loc->xl_entry);
1853 int block_offset = nameval_offset >> sb->s_blocksize_bits;
1855 /* Values are not allowed to straddle block boundaries */
1856 BUG_ON(block_offset !=
1857 ((nameval_offset + size - 1) >> sb->s_blocksize_bits));
1858 /* We expect the bucket to be filled in */
1859 BUG_ON(!bucket->bu_bhs[block_offset]);
1861 vb->vb_access = ocfs2_journal_access;
1862 vb->vb_bh = bucket->bu_bhs[block_offset];
1865 /* Operations for xattrs stored in buckets. */
1866 static const struct ocfs2_xa_loc_operations ocfs2_xa_bucket_loc_ops = {
1867 .xlo_journal_access = ocfs2_xa_bucket_journal_access,
1868 .xlo_journal_dirty = ocfs2_xa_bucket_journal_dirty,
1869 .xlo_offset_pointer = ocfs2_xa_bucket_offset_pointer,
1870 .xlo_check_space = ocfs2_xa_bucket_check_space,
1871 .xlo_can_reuse = ocfs2_xa_bucket_can_reuse,
1872 .xlo_get_free_start = ocfs2_xa_bucket_get_free_start,
1873 .xlo_wipe_namevalue = ocfs2_xa_bucket_wipe_namevalue,
1874 .xlo_add_entry = ocfs2_xa_bucket_add_entry,
1875 .xlo_add_namevalue = ocfs2_xa_bucket_add_namevalue,
1876 .xlo_fill_value_buf = ocfs2_xa_bucket_fill_value_buf,
1879 static unsigned int ocfs2_xa_value_clusters(struct ocfs2_xa_loc *loc)
1881 struct ocfs2_xattr_value_buf vb;
1883 if (ocfs2_xattr_is_local(loc->xl_entry))
1886 ocfs2_xa_fill_value_buf(loc, &vb);
1887 return le32_to_cpu(vb.vb_xv->xr_clusters);
1890 static int ocfs2_xa_value_truncate(struct ocfs2_xa_loc *loc, u64 bytes,
1891 struct ocfs2_xattr_set_ctxt *ctxt)
1893 int trunc_rc, access_rc;
1894 struct ocfs2_xattr_value_buf vb;
1896 ocfs2_xa_fill_value_buf(loc, &vb);
1897 trunc_rc = ocfs2_xattr_value_truncate(loc->xl_inode, &vb, bytes,
1901 * The caller of ocfs2_xa_value_truncate() has already called
1902 * ocfs2_xa_journal_access on the loc. However, The truncate code
1903 * calls ocfs2_extend_trans(). This may commit the previous
1904 * transaction and open a new one. If this is a bucket, truncate
1905 * could leave only vb->vb_bh set up for journaling. Meanwhile,
1906 * the caller is expecting to dirty the entire bucket. So we must
1907 * reset the journal work. We do this even if truncate has failed,
1908 * as it could have failed after committing the extend.
1910 access_rc = ocfs2_xa_journal_access(ctxt->handle, loc,
1911 OCFS2_JOURNAL_ACCESS_WRITE);
1913 /* Errors in truncate take precedence */
1914 return trunc_rc ? trunc_rc : access_rc;
1917 static void ocfs2_xa_remove_entry(struct ocfs2_xa_loc *loc)
1920 struct ocfs2_xattr_header *xh = loc->xl_header;
1921 struct ocfs2_xattr_entry *entry = loc->xl_entry;
1923 ocfs2_xa_wipe_namevalue(loc);
1924 loc->xl_entry = NULL;
1926 le16_add_cpu(&xh->xh_count, -1);
1927 count = le16_to_cpu(xh->xh_count);
1930 * Only zero out the entry if there are more remaining. This is
1931 * important for an empty bucket, as it keeps track of the
1932 * bucket's hash value. It doesn't hurt empty block storage.
1935 index = ((char *)entry - (char *)&xh->xh_entries) /
1936 sizeof(struct ocfs2_xattr_entry);
1937 memmove(&xh->xh_entries[index], &xh->xh_entries[index + 1],
1938 (count - index) * sizeof(struct ocfs2_xattr_entry));
1939 memset(&xh->xh_entries[count], 0,
1940 sizeof(struct ocfs2_xattr_entry));
1945 * If we have a problem adjusting the size of an external value during
1946 * ocfs2_xa_prepare_entry() or ocfs2_xa_remove(), we may have an xattr
1947 * in an intermediate state. For example, the value may be partially
1950 * If the value tree hasn't changed, the extend/truncate went nowhere.
1951 * We have nothing to do. The caller can treat it as a straight error.
1953 * If the value tree got partially truncated, we now have a corrupted
1954 * extended attribute. We're going to wipe its entry and leak the
1955 * clusters. Better to leak some storage than leave a corrupt entry.
1957 * If the value tree grew, it obviously didn't grow enough for the
1958 * new entry. We're not going to try and reclaim those clusters either.
1959 * If there was already an external value there (orig_clusters != 0),
1960 * the new clusters are attached safely and we can just leave the old
1961 * value in place. If there was no external value there, we remove
1964 * This way, the xattr block we store in the journal will be consistent.
1965 * If the size change broke because of the journal, no changes will hit
1968 static void ocfs2_xa_cleanup_value_truncate(struct ocfs2_xa_loc *loc,
1970 unsigned int orig_clusters)
1972 unsigned int new_clusters = ocfs2_xa_value_clusters(loc);
1973 char *nameval_buf = ocfs2_xa_offset_pointer(loc,
1974 le16_to_cpu(loc->xl_entry->xe_name_offset));
1976 if (new_clusters < orig_clusters) {
1978 "Partial truncate while %s xattr %.*s. Leaking "
1979 "%u clusters and removing the entry\n",
1980 what, loc->xl_entry->xe_name_len, nameval_buf,
1981 orig_clusters - new_clusters);
1982 ocfs2_xa_remove_entry(loc);
1983 } else if (!orig_clusters) {
1985 "Unable to allocate an external value for xattr "
1986 "%.*s safely. Leaking %u clusters and removing the "
1988 loc->xl_entry->xe_name_len, nameval_buf,
1989 new_clusters - orig_clusters);
1990 ocfs2_xa_remove_entry(loc);
1991 } else if (new_clusters > orig_clusters)
1993 "Unable to grow xattr %.*s safely. %u new clusters "
1994 "have been added, but the value will not be "
1996 loc->xl_entry->xe_name_len, nameval_buf,
1997 new_clusters - orig_clusters);
2000 static int ocfs2_xa_remove(struct ocfs2_xa_loc *loc,
2001 struct ocfs2_xattr_set_ctxt *ctxt)
2004 unsigned int orig_clusters;
2006 if (!ocfs2_xattr_is_local(loc->xl_entry)) {
2007 orig_clusters = ocfs2_xa_value_clusters(loc);
2008 rc = ocfs2_xa_value_truncate(loc, 0, ctxt);
2012 * Since this is remove, we can return 0 if
2013 * ocfs2_xa_cleanup_value_truncate() is going to
2014 * wipe the entry anyway. So we check the
2015 * cluster count as well.
2017 if (orig_clusters != ocfs2_xa_value_clusters(loc))
2019 ocfs2_xa_cleanup_value_truncate(loc, "removing",
2026 ocfs2_xa_remove_entry(loc);
2032 static void ocfs2_xa_install_value_root(struct ocfs2_xa_loc *loc)
2034 int name_size = OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len);
2037 nameval_buf = ocfs2_xa_offset_pointer(loc,
2038 le16_to_cpu(loc->xl_entry->xe_name_offset));
2039 memcpy(nameval_buf + name_size, &def_xv, OCFS2_XATTR_ROOT_SIZE);
2043 * Take an existing entry and make it ready for the new value. This
2044 * won't allocate space, but it may free space. It should be ready for
2045 * ocfs2_xa_prepare_entry() to finish the work.
2047 static int ocfs2_xa_reuse_entry(struct ocfs2_xa_loc *loc,
2048 struct ocfs2_xattr_info *xi,
2049 struct ocfs2_xattr_set_ctxt *ctxt)
2052 int name_size = OCFS2_XATTR_SIZE(xi->xi_name_len);
2053 unsigned int orig_clusters;
2055 int xe_local = ocfs2_xattr_is_local(loc->xl_entry);
2056 int xi_local = xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE;
2058 BUG_ON(OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len) !=
2061 nameval_buf = ocfs2_xa_offset_pointer(loc,
2062 le16_to_cpu(loc->xl_entry->xe_name_offset));
2064 memset(nameval_buf + name_size, 0,
2065 namevalue_size_xe(loc->xl_entry) - name_size);
2067 ocfs2_xa_install_value_root(loc);
2069 orig_clusters = ocfs2_xa_value_clusters(loc);
2071 rc = ocfs2_xa_value_truncate(loc, 0, ctxt);
2075 memset(nameval_buf + name_size, 0,
2076 namevalue_size_xe(loc->xl_entry) -
2078 } else if (le64_to_cpu(loc->xl_entry->xe_value_size) >
2080 rc = ocfs2_xa_value_truncate(loc, xi->xi_value_len,
2087 ocfs2_xa_cleanup_value_truncate(loc, "reusing",
2093 loc->xl_entry->xe_value_size = cpu_to_le64(xi->xi_value_len);
2094 ocfs2_xattr_set_local(loc->xl_entry, xi_local);
2101 * Prepares loc->xl_entry to receive the new xattr. This includes
2102 * properly setting up the name+value pair region. If loc->xl_entry
2103 * already exists, it will take care of modifying it appropriately.
2105 * Note that this modifies the data. You did journal_access already,
2108 static int ocfs2_xa_prepare_entry(struct ocfs2_xa_loc *loc,
2109 struct ocfs2_xattr_info *xi,
2111 struct ocfs2_xattr_set_ctxt *ctxt)
2114 unsigned int orig_clusters;
2115 __le64 orig_value_size = 0;
2117 rc = ocfs2_xa_check_space(loc, xi);
2121 if (loc->xl_entry) {
2122 if (ocfs2_xa_can_reuse_entry(loc, xi)) {
2123 orig_value_size = loc->xl_entry->xe_value_size;
2124 rc = ocfs2_xa_reuse_entry(loc, xi, ctxt);
2130 if (!ocfs2_xattr_is_local(loc->xl_entry)) {
2131 orig_clusters = ocfs2_xa_value_clusters(loc);
2132 rc = ocfs2_xa_value_truncate(loc, 0, ctxt);
2135 ocfs2_xa_cleanup_value_truncate(loc,
2141 ocfs2_xa_wipe_namevalue(loc);
2143 ocfs2_xa_add_entry(loc, name_hash);
2146 * If we get here, we have a blank entry. Fill it. We grow our
2147 * name+value pair back from the end.
2149 ocfs2_xa_add_namevalue(loc, xi);
2150 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE)
2151 ocfs2_xa_install_value_root(loc);
2154 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
2155 orig_clusters = ocfs2_xa_value_clusters(loc);
2156 rc = ocfs2_xa_value_truncate(loc, xi->xi_value_len, ctxt);
2158 ctxt->set_abort = 1;
2159 ocfs2_xa_cleanup_value_truncate(loc, "growing",
2162 * If we were growing an existing value,
2163 * ocfs2_xa_cleanup_value_truncate() won't remove
2164 * the entry. We need to restore the original value
2167 if (loc->xl_entry) {
2168 BUG_ON(!orig_value_size);
2169 loc->xl_entry->xe_value_size = orig_value_size;
2180 * Store the value portion of the name+value pair. This will skip
2181 * values that are stored externally. Their tree roots were set up
2182 * by ocfs2_xa_prepare_entry().
2184 static int ocfs2_xa_store_value(struct ocfs2_xa_loc *loc,
2185 struct ocfs2_xattr_info *xi,
2186 struct ocfs2_xattr_set_ctxt *ctxt)
2189 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset);
2190 int name_size = OCFS2_XATTR_SIZE(xi->xi_name_len);
2192 struct ocfs2_xattr_value_buf vb;
2194 nameval_buf = ocfs2_xa_offset_pointer(loc, nameval_offset);
2195 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
2196 ocfs2_xa_fill_value_buf(loc, &vb);
2197 rc = __ocfs2_xattr_set_value_outside(loc->xl_inode,
2202 memcpy(nameval_buf + name_size, xi->xi_value, xi->xi_value_len);
2207 static int ocfs2_xa_set(struct ocfs2_xa_loc *loc,
2208 struct ocfs2_xattr_info *xi,
2209 struct ocfs2_xattr_set_ctxt *ctxt)
2212 u32 name_hash = ocfs2_xattr_name_hash(loc->xl_inode, xi->xi_name,
2215 ret = ocfs2_xa_journal_access(ctxt->handle, loc,
2216 OCFS2_JOURNAL_ACCESS_WRITE);
2223 * From here on out, everything is going to modify the buffer a
2224 * little. Errors are going to leave the xattr header in a
2225 * sane state. Thus, even with errors we dirty the sucker.
2228 /* Don't worry, we are never called with !xi_value and !xl_entry */
2229 if (!xi->xi_value) {
2230 ret = ocfs2_xa_remove(loc, ctxt);
2234 ret = ocfs2_xa_prepare_entry(loc, xi, name_hash, ctxt);
2241 ret = ocfs2_xa_store_value(loc, xi, ctxt);
2246 ocfs2_xa_journal_dirty(ctxt->handle, loc);
2252 static void ocfs2_init_dinode_xa_loc(struct ocfs2_xa_loc *loc,
2253 struct inode *inode,
2254 struct buffer_head *bh,
2255 struct ocfs2_xattr_entry *entry)
2257 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;
2259 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_XATTR_FL));
2261 loc->xl_inode = inode;
2262 loc->xl_ops = &ocfs2_xa_block_loc_ops;
2263 loc->xl_storage = bh;
2264 loc->xl_entry = entry;
2265 loc->xl_size = le16_to_cpu(di->i_xattr_inline_size);
2267 (struct ocfs2_xattr_header *)(bh->b_data + bh->b_size -
2271 static void ocfs2_init_xattr_block_xa_loc(struct ocfs2_xa_loc *loc,
2272 struct inode *inode,
2273 struct buffer_head *bh,
2274 struct ocfs2_xattr_entry *entry)
2276 struct ocfs2_xattr_block *xb =
2277 (struct ocfs2_xattr_block *)bh->b_data;
2279 BUG_ON(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED);
2281 loc->xl_inode = inode;
2282 loc->xl_ops = &ocfs2_xa_block_loc_ops;
2283 loc->xl_storage = bh;
2284 loc->xl_header = &(xb->xb_attrs.xb_header);
2285 loc->xl_entry = entry;
2286 loc->xl_size = bh->b_size - offsetof(struct ocfs2_xattr_block,
2287 xb_attrs.xb_header);
2290 static void ocfs2_init_xattr_bucket_xa_loc(struct ocfs2_xa_loc *loc,
2291 struct ocfs2_xattr_bucket *bucket,
2292 struct ocfs2_xattr_entry *entry)
2294 loc->xl_inode = bucket->bu_inode;
2295 loc->xl_ops = &ocfs2_xa_bucket_loc_ops;
2296 loc->xl_storage = bucket;
2297 loc->xl_header = bucket_xh(bucket);
2298 loc->xl_entry = entry;
2299 loc->xl_size = OCFS2_XATTR_BUCKET_SIZE;
2303 * In xattr remove, if it is stored outside and refcounted, we may have
2304 * the chance to split the refcount tree. So need the allocators.
2306 static int ocfs2_lock_xattr_remove_allocators(struct inode *inode,
2307 struct ocfs2_xattr_value_root *xv,
2308 struct ocfs2_caching_info *ref_ci,
2309 struct buffer_head *ref_root_bh,
2310 struct ocfs2_alloc_context **meta_ac,
2313 int ret, meta_add = 0;
2314 u32 p_cluster, num_clusters;
2315 unsigned int ext_flags;
2318 ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster,
2327 if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
2330 ret = ocfs2_refcounted_xattr_delete_need(inode, ref_ci,
2332 &meta_add, ref_credits);
2338 ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(inode->i_sb),
2347 static int ocfs2_remove_value_outside(struct inode*inode,
2348 struct ocfs2_xattr_value_buf *vb,
2349 struct ocfs2_xattr_header *header,
2350 struct ocfs2_caching_info *ref_ci,
2351 struct buffer_head *ref_root_bh)
2353 int ret = 0, i, ref_credits;
2354 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2355 struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
2358 ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
2360 for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
2361 struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
2363 if (ocfs2_xattr_is_local(entry))
2366 val = (void *)header +
2367 le16_to_cpu(entry->xe_name_offset);
2368 vb->vb_xv = (struct ocfs2_xattr_value_root *)
2369 (val + OCFS2_XATTR_SIZE(entry->xe_name_len));
2371 ret = ocfs2_lock_xattr_remove_allocators(inode, vb->vb_xv,
2372 ref_ci, ref_root_bh,
2376 ctxt.handle = ocfs2_start_trans(osb, ref_credits +
2377 ocfs2_remove_extent_credits(osb->sb));
2378 if (IS_ERR(ctxt.handle)) {
2379 ret = PTR_ERR(ctxt.handle);
2384 ret = ocfs2_xattr_value_truncate(inode, vb, 0, &ctxt);
2386 ocfs2_commit_trans(osb, ctxt.handle);
2388 ocfs2_free_alloc_context(ctxt.meta_ac);
2389 ctxt.meta_ac = NULL;
2400 ocfs2_free_alloc_context(ctxt.meta_ac);
2401 ocfs2_schedule_truncate_log_flush(osb, 1);
2402 ocfs2_run_deallocs(osb, &ctxt.dealloc);
2406 static int ocfs2_xattr_ibody_remove(struct inode *inode,
2407 struct buffer_head *di_bh,
2408 struct ocfs2_caching_info *ref_ci,
2409 struct buffer_head *ref_root_bh)
2412 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2413 struct ocfs2_xattr_header *header;
2415 struct ocfs2_xattr_value_buf vb = {
2417 .vb_access = ocfs2_journal_access_di,
2420 header = (struct ocfs2_xattr_header *)
2421 ((void *)di + inode->i_sb->s_blocksize -
2422 le16_to_cpu(di->i_xattr_inline_size));
2424 ret = ocfs2_remove_value_outside(inode, &vb, header,
2425 ref_ci, ref_root_bh);
2430 struct ocfs2_rm_xattr_bucket_para {
2431 struct ocfs2_caching_info *ref_ci;
2432 struct buffer_head *ref_root_bh;
2435 static int ocfs2_xattr_block_remove(struct inode *inode,
2436 struct buffer_head *blk_bh,
2437 struct ocfs2_caching_info *ref_ci,
2438 struct buffer_head *ref_root_bh)
2440 struct ocfs2_xattr_block *xb;
2442 struct ocfs2_xattr_value_buf vb = {
2444 .vb_access = ocfs2_journal_access_xb,
2446 struct ocfs2_rm_xattr_bucket_para args = {
2448 .ref_root_bh = ref_root_bh,
2451 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
2452 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
2453 struct ocfs2_xattr_header *header = &(xb->xb_attrs.xb_header);
2454 ret = ocfs2_remove_value_outside(inode, &vb, header,
2455 ref_ci, ref_root_bh);
2457 ret = ocfs2_iterate_xattr_index_block(inode,
2459 ocfs2_rm_xattr_cluster,
2465 static int ocfs2_xattr_free_block(struct inode *inode,
2467 struct ocfs2_caching_info *ref_ci,
2468 struct buffer_head *ref_root_bh)
2470 struct inode *xb_alloc_inode;
2471 struct buffer_head *xb_alloc_bh = NULL;
2472 struct buffer_head *blk_bh = NULL;
2473 struct ocfs2_xattr_block *xb;
2474 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2480 ret = ocfs2_read_xattr_block(inode, block, &blk_bh);
2486 ret = ocfs2_xattr_block_remove(inode, blk_bh, ref_ci, ref_root_bh);
2492 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
2493 blk = le64_to_cpu(xb->xb_blkno);
2494 bit = le16_to_cpu(xb->xb_suballoc_bit);
2495 if (xb->xb_suballoc_loc)
2496 bg_blkno = le64_to_cpu(xb->xb_suballoc_loc);
2498 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
2500 xb_alloc_inode = ocfs2_get_system_file_inode(osb,
2501 EXTENT_ALLOC_SYSTEM_INODE,
2502 le16_to_cpu(xb->xb_suballoc_slot));
2503 if (!xb_alloc_inode) {
2508 mutex_lock(&xb_alloc_inode->i_mutex);
2510 ret = ocfs2_inode_lock(xb_alloc_inode, &xb_alloc_bh, 1);
2516 handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
2517 if (IS_ERR(handle)) {
2518 ret = PTR_ERR(handle);
2523 ret = ocfs2_free_suballoc_bits(handle, xb_alloc_inode, xb_alloc_bh,
2528 ocfs2_commit_trans(osb, handle);
2530 ocfs2_inode_unlock(xb_alloc_inode, 1);
2531 brelse(xb_alloc_bh);
2533 mutex_unlock(&xb_alloc_inode->i_mutex);
2534 iput(xb_alloc_inode);
2541 * ocfs2_xattr_remove()
2543 * Free extended attribute resources associated with this inode.
2545 int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
2547 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2548 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2549 struct ocfs2_refcount_tree *ref_tree = NULL;
2550 struct buffer_head *ref_root_bh = NULL;
2551 struct ocfs2_caching_info *ref_ci = NULL;
2555 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
2558 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
2561 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) {
2562 ret = ocfs2_lock_refcount_tree(OCFS2_SB(inode->i_sb),
2563 le64_to_cpu(di->i_refcount_loc),
2564 1, &ref_tree, &ref_root_bh);
2569 ref_ci = &ref_tree->rf_ci;
2573 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
2574 ret = ocfs2_xattr_ibody_remove(inode, di_bh,
2575 ref_ci, ref_root_bh);
2582 if (di->i_xattr_loc) {
2583 ret = ocfs2_xattr_free_block(inode,
2584 le64_to_cpu(di->i_xattr_loc),
2585 ref_ci, ref_root_bh);
2592 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
2593 OCFS2_INODE_UPDATE_CREDITS);
2594 if (IS_ERR(handle)) {
2595 ret = PTR_ERR(handle);
2599 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
2600 OCFS2_JOURNAL_ACCESS_WRITE);
2606 di->i_xattr_loc = 0;
2608 spin_lock(&oi->ip_lock);
2609 oi->ip_dyn_features &= ~(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL);
2610 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
2611 spin_unlock(&oi->ip_lock);
2612 ocfs2_update_inode_fsync_trans(handle, inode, 0);
2614 ocfs2_journal_dirty(handle, di_bh);
2616 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
2619 ocfs2_unlock_refcount_tree(OCFS2_SB(inode->i_sb), ref_tree, 1);
2620 brelse(ref_root_bh);
2624 static int ocfs2_xattr_has_space_inline(struct inode *inode,
2625 struct ocfs2_dinode *di)
2627 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2628 unsigned int xattrsize = OCFS2_SB(inode->i_sb)->s_xattr_inline_size;
2631 if (xattrsize < OCFS2_MIN_XATTR_INLINE_SIZE)
2634 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
2635 struct ocfs2_inline_data *idata = &di->id2.i_data;
2636 free = le16_to_cpu(idata->id_count) - le64_to_cpu(di->i_size);
2637 } else if (ocfs2_inode_is_fast_symlink(inode)) {
2638 free = ocfs2_fast_symlink_chars(inode->i_sb) -
2639 le64_to_cpu(di->i_size);
2641 struct ocfs2_extent_list *el = &di->id2.i_list;
2642 free = (le16_to_cpu(el->l_count) -
2643 le16_to_cpu(el->l_next_free_rec)) *
2644 sizeof(struct ocfs2_extent_rec);
2646 if (free >= xattrsize)
2653 * ocfs2_xattr_ibody_find()
2655 * Find extended attribute in inode block and
2656 * fill search info into struct ocfs2_xattr_search.
2658 static int ocfs2_xattr_ibody_find(struct inode *inode,
2661 struct ocfs2_xattr_search *xs)
2663 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2664 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
2668 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
2671 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
2672 down_read(&oi->ip_alloc_sem);
2673 has_space = ocfs2_xattr_has_space_inline(inode, di);
2674 up_read(&oi->ip_alloc_sem);
2679 xs->xattr_bh = xs->inode_bh;
2680 xs->end = (void *)di + inode->i_sb->s_blocksize;
2681 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)
2682 xs->header = (struct ocfs2_xattr_header *)
2683 (xs->end - le16_to_cpu(di->i_xattr_inline_size));
2685 xs->header = (struct ocfs2_xattr_header *)
2686 (xs->end - OCFS2_SB(inode->i_sb)->s_xattr_inline_size);
2687 xs->base = (void *)xs->header;
2688 xs->here = xs->header->xh_entries;
2690 /* Find the named attribute. */
2691 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
2692 ret = ocfs2_xattr_find_entry(name_index, name, xs);
2693 if (ret && ret != -ENODATA)
2695 xs->not_found = ret;
2701 static int ocfs2_xattr_ibody_init(struct inode *inode,
2702 struct buffer_head *di_bh,
2703 struct ocfs2_xattr_set_ctxt *ctxt)
2706 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2707 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2708 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2709 unsigned int xattrsize = osb->s_xattr_inline_size;
2711 if (!ocfs2_xattr_has_space_inline(inode, di)) {
2716 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode), di_bh,
2717 OCFS2_JOURNAL_ACCESS_WRITE);
2724 * Adjust extent record count or inline data size
2725 * to reserve space for extended attribute.
2727 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
2728 struct ocfs2_inline_data *idata = &di->id2.i_data;
2729 le16_add_cpu(&idata->id_count, -xattrsize);
2730 } else if (!(ocfs2_inode_is_fast_symlink(inode))) {
2731 struct ocfs2_extent_list *el = &di->id2.i_list;
2732 le16_add_cpu(&el->l_count, -(xattrsize /
2733 sizeof(struct ocfs2_extent_rec)));
2735 di->i_xattr_inline_size = cpu_to_le16(xattrsize);
2737 spin_lock(&oi->ip_lock);
2738 oi->ip_dyn_features |= OCFS2_INLINE_XATTR_FL|OCFS2_HAS_XATTR_FL;
2739 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
2740 spin_unlock(&oi->ip_lock);
2742 ocfs2_journal_dirty(ctxt->handle, di_bh);
2749 * ocfs2_xattr_ibody_set()
2751 * Set, replace or remove an extended attribute into inode block.
2754 static int ocfs2_xattr_ibody_set(struct inode *inode,
2755 struct ocfs2_xattr_info *xi,
2756 struct ocfs2_xattr_search *xs,
2757 struct ocfs2_xattr_set_ctxt *ctxt)
2760 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2761 struct ocfs2_xa_loc loc;
2763 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
2766 down_write(&oi->ip_alloc_sem);
2767 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
2768 ret = ocfs2_xattr_ibody_init(inode, xs->inode_bh, ctxt);
2776 ocfs2_init_dinode_xa_loc(&loc, inode, xs->inode_bh,
2777 xs->not_found ? NULL : xs->here);
2778 ret = ocfs2_xa_set(&loc, xi, ctxt);
2784 xs->here = loc.xl_entry;
2787 up_write(&oi->ip_alloc_sem);
2793 * ocfs2_xattr_block_find()
2795 * Find extended attribute in external block and
2796 * fill search info into struct ocfs2_xattr_search.
2798 static int ocfs2_xattr_block_find(struct inode *inode,
2801 struct ocfs2_xattr_search *xs)
2803 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
2804 struct buffer_head *blk_bh = NULL;
2805 struct ocfs2_xattr_block *xb;
2808 if (!di->i_xattr_loc)
2811 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
2818 xs->xattr_bh = blk_bh;
2819 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
2821 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
2822 xs->header = &xb->xb_attrs.xb_header;
2823 xs->base = (void *)xs->header;
2824 xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size;
2825 xs->here = xs->header->xh_entries;
2827 ret = ocfs2_xattr_find_entry(name_index, name, xs);
2829 ret = ocfs2_xattr_index_block_find(inode, blk_bh,
2833 if (ret && ret != -ENODATA) {
2834 xs->xattr_bh = NULL;
2837 xs->not_found = ret;
2845 static int ocfs2_create_xattr_block(struct inode *inode,
2846 struct buffer_head *inode_bh,
2847 struct ocfs2_xattr_set_ctxt *ctxt,
2849 struct buffer_head **ret_bh)
2852 u16 suballoc_bit_start;
2854 u64 suballoc_loc, first_blkno;
2855 struct ocfs2_dinode *di = (struct ocfs2_dinode *)inode_bh->b_data;
2856 struct buffer_head *new_bh = NULL;
2857 struct ocfs2_xattr_block *xblk;
2859 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode),
2860 inode_bh, OCFS2_JOURNAL_ACCESS_CREATE);
2866 ret = ocfs2_claim_metadata(ctxt->handle, ctxt->meta_ac, 1,
2867 &suballoc_loc, &suballoc_bit_start,
2868 &num_got, &first_blkno);
2874 new_bh = sb_getblk(inode->i_sb, first_blkno);
2881 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), new_bh);
2883 ret = ocfs2_journal_access_xb(ctxt->handle, INODE_CACHE(inode),
2885 OCFS2_JOURNAL_ACCESS_CREATE);
2891 /* Initialize ocfs2_xattr_block */
2892 xblk = (struct ocfs2_xattr_block *)new_bh->b_data;
2893 memset(xblk, 0, inode->i_sb->s_blocksize);
2894 strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE);
2895 xblk->xb_suballoc_slot = cpu_to_le16(ctxt->meta_ac->ac_alloc_slot);
2896 xblk->xb_suballoc_loc = cpu_to_le64(suballoc_loc);
2897 xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start);
2898 xblk->xb_fs_generation =
2899 cpu_to_le32(OCFS2_SB(inode->i_sb)->fs_generation);
2900 xblk->xb_blkno = cpu_to_le64(first_blkno);
2902 struct ocfs2_xattr_tree_root *xr = &xblk->xb_attrs.xb_root;
2903 xr->xt_clusters = cpu_to_le32(1);
2904 xr->xt_last_eb_blk = 0;
2905 xr->xt_list.l_tree_depth = 0;
2906 xr->xt_list.l_count = cpu_to_le16(
2907 ocfs2_xattr_recs_per_xb(inode->i_sb));
2908 xr->xt_list.l_next_free_rec = cpu_to_le16(1);
2909 xblk->xb_flags = cpu_to_le16(OCFS2_XATTR_INDEXED);
2911 ocfs2_journal_dirty(ctxt->handle, new_bh);
2913 /* Add it to the inode */
2914 di->i_xattr_loc = cpu_to_le64(first_blkno);
2916 spin_lock(&OCFS2_I(inode)->ip_lock);
2917 OCFS2_I(inode)->ip_dyn_features |= OCFS2_HAS_XATTR_FL;
2918 di->i_dyn_features = cpu_to_le16(OCFS2_I(inode)->ip_dyn_features);
2919 spin_unlock(&OCFS2_I(inode)->ip_lock);
2921 ocfs2_journal_dirty(ctxt->handle, inode_bh);
2932 * ocfs2_xattr_block_set()
2934 * Set, replace or remove an extended attribute into external block.
2937 static int ocfs2_xattr_block_set(struct inode *inode,
2938 struct ocfs2_xattr_info *xi,
2939 struct ocfs2_xattr_search *xs,
2940 struct ocfs2_xattr_set_ctxt *ctxt)
2942 struct buffer_head *new_bh = NULL;
2943 struct ocfs2_xattr_block *xblk = NULL;
2945 struct ocfs2_xa_loc loc;
2947 if (!xs->xattr_bh) {
2948 ret = ocfs2_create_xattr_block(inode, xs->inode_bh, ctxt,
2955 xs->xattr_bh = new_bh;
2956 xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
2957 xs->header = &xblk->xb_attrs.xb_header;
2958 xs->base = (void *)xs->header;
2959 xs->end = (void *)xblk + inode->i_sb->s_blocksize;
2960 xs->here = xs->header->xh_entries;
2962 xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
2964 if (!(le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)) {
2965 ocfs2_init_xattr_block_xa_loc(&loc, inode, xs->xattr_bh,
2966 xs->not_found ? NULL : xs->here);
2968 ret = ocfs2_xa_set(&loc, xi, ctxt);
2970 xs->here = loc.xl_entry;
2971 else if ((ret != -ENOSPC) || ctxt->set_abort)
2974 ret = ocfs2_xattr_create_index_block(inode, xs, ctxt);
2980 if (le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)
2981 ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs, ctxt);
2987 /* Check whether the new xattr can be inserted into the inode. */
2988 static int ocfs2_xattr_can_be_in_inode(struct inode *inode,
2989 struct ocfs2_xattr_info *xi,
2990 struct ocfs2_xattr_search *xs)
2992 struct ocfs2_xattr_entry *last;
2994 size_t min_offs = xs->end - xs->base;
2999 last = xs->header->xh_entries;
3001 for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
3002 size_t offs = le16_to_cpu(last->xe_name_offset);
3003 if (offs < min_offs)
3008 free = min_offs - ((void *)last - xs->base) - OCFS2_XATTR_HEADER_GAP;
3012 BUG_ON(!xs->not_found);
3014 if (free >= (sizeof(struct ocfs2_xattr_entry) + namevalue_size_xi(xi)))
3020 static int ocfs2_calc_xattr_set_need(struct inode *inode,
3021 struct ocfs2_dinode *di,
3022 struct ocfs2_xattr_info *xi,
3023 struct ocfs2_xattr_search *xis,
3024 struct ocfs2_xattr_search *xbs,
3029 int ret = 0, old_in_xb = 0;
3030 int clusters_add = 0, meta_add = 0, credits = 0;
3031 struct buffer_head *bh = NULL;
3032 struct ocfs2_xattr_block *xb = NULL;
3033 struct ocfs2_xattr_entry *xe = NULL;
3034 struct ocfs2_xattr_value_root *xv = NULL;
3036 int name_offset, name_len = 0;
3037 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb,
3042 * Calculate the clusters we need to write.
3043 * No matter whether we replace an old one or add a new one,
3044 * we need this for writing.
3046 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE)
3047 credits += new_clusters *
3048 ocfs2_clusters_to_blocks(inode->i_sb, 1);
3050 if (xis->not_found && xbs->not_found) {
3051 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3053 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
3054 clusters_add += new_clusters;
3055 credits += ocfs2_calc_extend_credits(inode->i_sb,
3056 &def_xv.xv.xr_list);
3062 if (!xis->not_found) {
3064 name_offset = le16_to_cpu(xe->xe_name_offset);
3065 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
3067 credits += OCFS2_INODE_UPDATE_CREDITS;
3069 int i, block_off = 0;
3070 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
3072 name_offset = le16_to_cpu(xe->xe_name_offset);
3073 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
3074 i = xbs->here - xbs->header->xh_entries;
3077 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
3078 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
3079 bucket_xh(xbs->bucket),
3082 base = bucket_block(xbs->bucket, block_off);
3083 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3086 credits += OCFS2_XATTR_BLOCK_UPDATE_CREDITS;
3091 * delete a xattr doesn't need metadata and cluster allocation.
3092 * so just calculate the credits and return.
3094 * The credits for removing the value tree will be extended
3095 * by ocfs2_remove_extent itself.
3097 if (!xi->xi_value) {
3098 if (!ocfs2_xattr_is_local(xe))
3099 credits += ocfs2_remove_extent_credits(inode->i_sb);
3104 /* do cluster allocation guess first. */
3105 value_size = le64_to_cpu(xe->xe_value_size);
3109 * In xattr set, we always try to set the xe in inode first,
3110 * so if it can be inserted into inode successfully, the old
3111 * one will be removed from the xattr block, and this xattr
3112 * will be inserted into inode as a new xattr in inode.
3114 if (ocfs2_xattr_can_be_in_inode(inode, xi, xis)) {
3115 clusters_add += new_clusters;
3116 credits += ocfs2_remove_extent_credits(inode->i_sb) +
3117 OCFS2_INODE_UPDATE_CREDITS;
3118 if (!ocfs2_xattr_is_local(xe))
3119 credits += ocfs2_calc_extend_credits(
3121 &def_xv.xv.xr_list);
3126 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
3127 /* the new values will be stored outside. */
3128 u32 old_clusters = 0;
3130 if (!ocfs2_xattr_is_local(xe)) {
3131 old_clusters = ocfs2_clusters_for_bytes(inode->i_sb,
3133 xv = (struct ocfs2_xattr_value_root *)
3134 (base + name_offset + name_len);
3135 value_size = OCFS2_XATTR_ROOT_SIZE;
3139 if (old_clusters >= new_clusters) {
3140 credits += ocfs2_remove_extent_credits(inode->i_sb);
3143 meta_add += ocfs2_extend_meta_needed(&xv->xr_list);
3144 clusters_add += new_clusters - old_clusters;
3145 credits += ocfs2_calc_extend_credits(inode->i_sb,
3147 if (value_size >= OCFS2_XATTR_ROOT_SIZE)
3152 * Now the new value will be stored inside. So if the new
3153 * value is smaller than the size of value root or the old
3154 * value, we don't need any allocation, otherwise we have
3155 * to guess metadata allocation.
3157 if ((ocfs2_xattr_is_local(xe) &&
3158 (value_size >= xi->xi_value_len)) ||
3159 (!ocfs2_xattr_is_local(xe) &&
3160 OCFS2_XATTR_ROOT_SIZE >= xi->xi_value_len))
3165 /* calculate metadata allocation. */
3166 if (di->i_xattr_loc) {
3167 if (!xbs->xattr_bh) {
3168 ret = ocfs2_read_xattr_block(inode,
3169 le64_to_cpu(di->i_xattr_loc),
3176 xb = (struct ocfs2_xattr_block *)bh->b_data;
3178 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
3181 * If there is already an xattr tree, good, we can calculate
3182 * like other b-trees. Otherwise we may have the chance of
3183 * create a tree, the credit calculation is borrowed from
3184 * ocfs2_calc_extend_credits with root_el = NULL. And the
3185 * new tree will be cluster based, so no meta is needed.
3187 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
3188 struct ocfs2_extent_list *el =
3189 &xb->xb_attrs.xb_root.xt_list;
3190 meta_add += ocfs2_extend_meta_needed(el);
3191 credits += ocfs2_calc_extend_credits(inode->i_sb,
3194 credits += OCFS2_SUBALLOC_ALLOC + 1;
3197 * This cluster will be used either for new bucket or for
3199 * If the cluster size is the same as the bucket size, one
3200 * more is needed since we may need to extend the bucket
3204 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3205 if (OCFS2_XATTR_BUCKET_SIZE ==
3206 OCFS2_SB(inode->i_sb)->s_clustersize) {
3207 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3211 credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
3212 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) {
3213 struct ocfs2_extent_list *el = &def_xv.xv.xr_list;
3214 meta_add += ocfs2_extend_meta_needed(el);
3215 credits += ocfs2_calc_extend_credits(inode->i_sb,
3223 *clusters_need = clusters_add;
3225 *meta_need = meta_add;
3227 *credits_need = credits;
3232 static int ocfs2_init_xattr_set_ctxt(struct inode *inode,
3233 struct ocfs2_dinode *di,
3234 struct ocfs2_xattr_info *xi,
3235 struct ocfs2_xattr_search *xis,
3236 struct ocfs2_xattr_search *xbs,
3237 struct ocfs2_xattr_set_ctxt *ctxt,
3241 int clusters_add, meta_add, ret;
3242 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3244 memset(ctxt, 0, sizeof(struct ocfs2_xattr_set_ctxt));
3246 ocfs2_init_dealloc_ctxt(&ctxt->dealloc);
3248 ret = ocfs2_calc_xattr_set_need(inode, di, xi, xis, xbs,
3249 &clusters_add, &meta_add, credits);
3255 meta_add += extra_meta;
3256 trace_ocfs2_init_xattr_set_ctxt(xi->xi_name, meta_add,
3257 clusters_add, *credits);
3260 ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add,
3269 ret = ocfs2_reserve_clusters(osb, clusters_add, &ctxt->data_ac);
3275 if (ctxt->meta_ac) {
3276 ocfs2_free_alloc_context(ctxt->meta_ac);
3277 ctxt->meta_ac = NULL;
3281 * We cannot have an error and a non null ctxt->data_ac.
3288 static int __ocfs2_xattr_set_handle(struct inode *inode,
3289 struct ocfs2_dinode *di,
3290 struct ocfs2_xattr_info *xi,
3291 struct ocfs2_xattr_search *xis,
3292 struct ocfs2_xattr_search *xbs,
3293 struct ocfs2_xattr_set_ctxt *ctxt)
3295 int ret = 0, credits, old_found;
3297 if (!xi->xi_value) {
3298 /* Remove existing extended attribute */
3299 if (!xis->not_found)
3300 ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt);
3301 else if (!xbs->not_found)
3302 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
3304 /* We always try to set extended attribute into inode first*/
3305 ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt);
3306 if (!ret && !xbs->not_found) {
3308 * If succeed and that extended attribute existing in
3309 * external block, then we will remove it.
3311 xi->xi_value = NULL;
3312 xi->xi_value_len = 0;
3314 old_found = xis->not_found;
3315 xis->not_found = -ENODATA;
3316 ret = ocfs2_calc_xattr_set_need(inode,
3324 xis->not_found = old_found;
3330 ret = ocfs2_extend_trans(ctxt->handle, credits);
3335 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
3336 } else if ((ret == -ENOSPC) && !ctxt->set_abort) {
3337 if (di->i_xattr_loc && !xbs->xattr_bh) {
3338 ret = ocfs2_xattr_block_find(inode,
3344 old_found = xis->not_found;
3345 xis->not_found = -ENODATA;
3346 ret = ocfs2_calc_xattr_set_need(inode,
3354 xis->not_found = old_found;
3360 ret = ocfs2_extend_trans(ctxt->handle, credits);
3367 * If no space in inode, we will set extended attribute
3368 * into external block.
3370 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
3373 if (!xis->not_found) {
3375 * If succeed and that extended attribute
3376 * existing in inode, we will remove it.
3378 xi->xi_value = NULL;
3379 xi->xi_value_len = 0;
3380 xbs->not_found = -ENODATA;
3381 ret = ocfs2_calc_xattr_set_need(inode,
3394 ret = ocfs2_extend_trans(ctxt->handle, credits);
3399 ret = ocfs2_xattr_ibody_set(inode, xi,
3406 /* Update inode ctime. */
3407 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode),
3409 OCFS2_JOURNAL_ACCESS_WRITE);
3415 inode->i_ctime = CURRENT_TIME;
3416 di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
3417 di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
3418 ocfs2_journal_dirty(ctxt->handle, xis->inode_bh);
3425 * This function only called duing creating inode
3426 * for init security/acl xattrs of the new inode.
3427 * All transanction credits have been reserved in mknod.
3429 int ocfs2_xattr_set_handle(handle_t *handle,
3430 struct inode *inode,
3431 struct buffer_head *di_bh,
3437 struct ocfs2_alloc_context *meta_ac,
3438 struct ocfs2_alloc_context *data_ac)
3440 struct ocfs2_dinode *di;
3443 struct ocfs2_xattr_info xi = {
3444 .xi_name_index = name_index,
3446 .xi_name_len = strlen(name),
3448 .xi_value_len = value_len,
3451 struct ocfs2_xattr_search xis = {
3452 .not_found = -ENODATA,
3455 struct ocfs2_xattr_search xbs = {
3456 .not_found = -ENODATA,
3459 struct ocfs2_xattr_set_ctxt ctxt = {
3465 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
3469 * In extreme situation, may need xattr bucket when
3470 * block size is too small. And we have already reserved
3471 * the credits for bucket in mknod.
3473 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) {
3474 xbs.bucket = ocfs2_xattr_bucket_new(inode);
3476 mlog_errno(-ENOMEM);
3481 xis.inode_bh = xbs.inode_bh = di_bh;
3482 di = (struct ocfs2_dinode *)di_bh->b_data;
3484 down_write(&OCFS2_I(inode)->ip_xattr_sem);
3486 ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
3489 if (xis.not_found) {
3490 ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
3495 ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
3498 up_write(&OCFS2_I(inode)->ip_xattr_sem);
3499 brelse(xbs.xattr_bh);
3500 ocfs2_xattr_bucket_free(xbs.bucket);
3508 * Set, replace or remove an extended attribute for this inode.
3509 * value is NULL to remove an existing extended attribute, else either
3510 * create or replace an extended attribute.
3512 int ocfs2_xattr_set(struct inode *inode,
3519 struct buffer_head *di_bh = NULL;
3520 struct ocfs2_dinode *di;
3521 int ret, credits, ref_meta = 0, ref_credits = 0;
3522 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3523 struct inode *tl_inode = osb->osb_tl_inode;
3524 struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, NULL, };
3525 struct ocfs2_refcount_tree *ref_tree = NULL;
3527 struct ocfs2_xattr_info xi = {
3528 .xi_name_index = name_index,
3530 .xi_name_len = strlen(name),
3532 .xi_value_len = value_len,
3535 struct ocfs2_xattr_search xis = {
3536 .not_found = -ENODATA,
3539 struct ocfs2_xattr_search xbs = {
3540 .not_found = -ENODATA,
3543 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
3547 * Only xbs will be used on indexed trees. xis doesn't need a
3550 xbs.bucket = ocfs2_xattr_bucket_new(inode);
3552 mlog_errno(-ENOMEM);
3556 ret = ocfs2_inode_lock(inode, &di_bh, 1);
3559 goto cleanup_nolock;
3561 xis.inode_bh = xbs.inode_bh = di_bh;
3562 di = (struct ocfs2_dinode *)di_bh->b_data;
3564 down_write(&OCFS2_I(inode)->ip_xattr_sem);
3566 * Scan inode and external block to find the same name
3567 * extended attribute and collect search information.
3569 ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
3572 if (xis.not_found) {
3573 ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
3578 if (xis.not_found && xbs.not_found) {
3580 if (flags & XATTR_REPLACE)
3587 if (flags & XATTR_CREATE)
3591 /* Check whether the value is refcounted and do some preparation. */
3592 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL &&
3593 (!xis.not_found || !xbs.not_found)) {
3594 ret = ocfs2_prepare_refcount_xattr(inode, di, &xi,
3595 &xis, &xbs, &ref_tree,
3596 &ref_meta, &ref_credits);
3603 mutex_lock(&tl_inode->i_mutex);
3605 if (ocfs2_truncate_log_needs_flush(osb)) {
3606 ret = __ocfs2_flush_truncate_log(osb);
3608 mutex_unlock(&tl_inode->i_mutex);
3613 mutex_unlock(&tl_inode->i_mutex);
3615 ret = ocfs2_init_xattr_set_ctxt(inode, di, &xi, &xis,
3616 &xbs, &ctxt, ref_meta, &credits);
3622 /* we need to update inode's ctime field, so add credit for it. */
3623 credits += OCFS2_INODE_UPDATE_CREDITS;
3624 ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits);
3625 if (IS_ERR(ctxt.handle)) {
3626 ret = PTR_ERR(ctxt.handle);
3631 ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
3632 ocfs2_update_inode_fsync_trans(ctxt.handle, inode, 0);
3634 ocfs2_commit_trans(osb, ctxt.handle);
3638 ocfs2_free_alloc_context(ctxt.data_ac);
3640 ocfs2_free_alloc_context(ctxt.meta_ac);
3641 if (ocfs2_dealloc_has_cluster(&ctxt.dealloc))
3642 ocfs2_schedule_truncate_log_flush(osb, 1);
3643 ocfs2_run_deallocs(osb, &ctxt.dealloc);
3647 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
3648 up_write(&OCFS2_I(inode)->ip_xattr_sem);
3649 if (!value && !ret) {
3650 ret = ocfs2_try_remove_refcount_tree(inode, di_bh);
3654 ocfs2_inode_unlock(inode, 1);
3657 brelse(xbs.xattr_bh);
3658 ocfs2_xattr_bucket_free(xbs.bucket);
3664 * Find the xattr extent rec which may contains name_hash.
3665 * e_cpos will be the first name hash of the xattr rec.
3666 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
3668 static int ocfs2_xattr_get_rec(struct inode *inode,
3673 struct ocfs2_extent_list *el)
3676 struct buffer_head *eb_bh = NULL;
3677 struct ocfs2_extent_block *eb;
3678 struct ocfs2_extent_rec *rec = NULL;
3681 if (el->l_tree_depth) {
3682 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, name_hash,
3689 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
3692 if (el->l_tree_depth) {
3693 ret = ocfs2_error(inode->i_sb,
3694 "Inode %lu has non zero tree depth in xattr tree block %llu\n",
3696 (unsigned long long)eb_bh->b_blocknr);
3701 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
3702 rec = &el->l_recs[i];
3704 if (le32_to_cpu(rec->e_cpos) <= name_hash) {
3705 e_blkno = le64_to_cpu(rec->e_blkno);
3711 ret = ocfs2_error(inode->i_sb, "Inode %lu has bad extent record (%u, %u, 0) in xattr\n",
3713 le32_to_cpu(rec->e_cpos),
3714 ocfs2_rec_clusters(el, rec));
3718 *p_blkno = le64_to_cpu(rec->e_blkno);
3719 *num_clusters = le16_to_cpu(rec->e_leaf_clusters);
3721 *e_cpos = le32_to_cpu(rec->e_cpos);
3727 typedef int (xattr_bucket_func)(struct inode *inode,
3728 struct ocfs2_xattr_bucket *bucket,
3731 static int ocfs2_find_xe_in_bucket(struct inode *inode,
3732 struct ocfs2_xattr_bucket *bucket,
3739 int i, ret = 0, cmp = 1, block_off, new_offset;
3740 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
3741 size_t name_len = strlen(name);
3742 struct ocfs2_xattr_entry *xe = NULL;
3746 * We don't use binary search in the bucket because there
3747 * may be multiple entries with the same name hash.
3749 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
3750 xe = &xh->xh_entries[i];
3752 if (name_hash > le32_to_cpu(xe->xe_name_hash))
3754 else if (name_hash < le32_to_cpu(xe->xe_name_hash))
3757 cmp = name_index - ocfs2_xattr_get_type(xe);
3759 cmp = name_len - xe->xe_name_len;
3763 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
3774 xe_name = bucket_block(bucket, block_off) + new_offset;
3775 if (!memcmp(name, xe_name, name_len)) {
3787 * Find the specified xattr entry in a series of buckets.
3788 * This series start from p_blkno and last for num_clusters.
3789 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
3790 * the num of the valid buckets.
3792 * Return the buffer_head this xattr should reside in. And if the xattr's
3793 * hash is in the gap of 2 buckets, return the lower bucket.
3795 static int ocfs2_xattr_bucket_find(struct inode *inode,
3802 struct ocfs2_xattr_search *xs)
3805 struct ocfs2_xattr_header *xh = NULL;
3806 struct ocfs2_xattr_entry *xe = NULL;
3808 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
3809 int low_bucket = 0, bucket, high_bucket;
3810 struct ocfs2_xattr_bucket *search;
3811 u64 blkno, lower_blkno = 0;
3813 search = ocfs2_xattr_bucket_new(inode);
3820 ret = ocfs2_read_xattr_bucket(search, p_blkno);
3826 xh = bucket_xh(search);
3827 high_bucket = le16_to_cpu(xh->xh_num_buckets) - 1;
3828 while (low_bucket <= high_bucket) {
3829 ocfs2_xattr_bucket_relse(search);
3831 bucket = (low_bucket + high_bucket) / 2;
3832 blkno = p_blkno + bucket * blk_per_bucket;
3833 ret = ocfs2_read_xattr_bucket(search, blkno);
3839 xh = bucket_xh(search);
3840 xe = &xh->xh_entries[0];
3841 if (name_hash < le32_to_cpu(xe->xe_name_hash)) {
3842 high_bucket = bucket - 1;
3847 * Check whether the hash of the last entry in our
3848 * bucket is larger than the search one. for an empty
3849 * bucket, the last one is also the first one.
3852 xe = &xh->xh_entries[le16_to_cpu(xh->xh_count) - 1];
3854 /* record lower_blkno which may be the insert place. */
3855 lower_blkno = blkno;
3857 if (name_hash > le32_to_cpu(xe->xe_name_hash)) {
3858 low_bucket = bucket + 1;
3862 /* the searched xattr should reside in this bucket if exists. */
3863 ret = ocfs2_find_xe_in_bucket(inode, search,
3864 name_index, name, name_hash,
3874 * Record the bucket we have found.
3875 * When the xattr's hash value is in the gap of 2 buckets, we will
3876 * always set it to the previous bucket.
3879 lower_blkno = p_blkno;
3881 /* This should be in cache - we just read it during the search */
3882 ret = ocfs2_read_xattr_bucket(xs->bucket, lower_blkno);
3888 xs->header = bucket_xh(xs->bucket);
3889 xs->base = bucket_block(xs->bucket, 0);
3890 xs->end = xs->base + inode->i_sb->s_blocksize;
3893 xs->here = &xs->header->xh_entries[index];
3894 trace_ocfs2_xattr_bucket_find(OCFS2_I(inode)->ip_blkno,
3895 name, name_index, name_hash,
3896 (unsigned long long)bucket_blkno(xs->bucket),
3902 ocfs2_xattr_bucket_free(search);
3906 static int ocfs2_xattr_index_block_find(struct inode *inode,
3907 struct buffer_head *root_bh,
3910 struct ocfs2_xattr_search *xs)
3913 struct ocfs2_xattr_block *xb =
3914 (struct ocfs2_xattr_block *)root_bh->b_data;
3915 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
3916 struct ocfs2_extent_list *el = &xb_root->xt_list;
3918 u32 first_hash, num_clusters = 0;
3919 u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name));
3921 if (le16_to_cpu(el->l_next_free_rec) == 0)
3924 trace_ocfs2_xattr_index_block_find(OCFS2_I(inode)->ip_blkno,
3925 name, name_index, name_hash,
3926 (unsigned long long)root_bh->b_blocknr,
3929 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &first_hash,
3936 BUG_ON(p_blkno == 0 || num_clusters == 0 || first_hash > name_hash);
3938 trace_ocfs2_xattr_index_block_find_rec(OCFS2_I(inode)->ip_blkno,
3939 name, name_index, first_hash,
3940 (unsigned long long)p_blkno,
3943 ret = ocfs2_xattr_bucket_find(inode, name_index, name, name_hash,
3944 p_blkno, first_hash, num_clusters, xs);
3950 static int ocfs2_iterate_xattr_buckets(struct inode *inode,
3953 xattr_bucket_func *func,
3957 u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
3958 u32 num_buckets = clusters * bpc;
3959 struct ocfs2_xattr_bucket *bucket;
3961 bucket = ocfs2_xattr_bucket_new(inode);
3963 mlog_errno(-ENOMEM);
3967 trace_ocfs2_iterate_xattr_buckets(
3968 (unsigned long long)OCFS2_I(inode)->ip_blkno,
3969 (unsigned long long)blkno, clusters);
3971 for (i = 0; i < num_buckets; i++, blkno += bucket->bu_blocks) {
3972 ret = ocfs2_read_xattr_bucket(bucket, blkno);
3979 * The real bucket num in this series of blocks is stored
3980 * in the 1st bucket.
3983 num_buckets = le16_to_cpu(bucket_xh(bucket)->xh_num_buckets);
3985 trace_ocfs2_iterate_xattr_bucket((unsigned long long)blkno,
3986 le32_to_cpu(bucket_xh(bucket)->xh_entries[0].xe_name_hash));
3988 ret = func(inode, bucket, para);
3989 if (ret && ret != -ERANGE)
3991 /* Fall through to bucket_relse() */
3994 ocfs2_xattr_bucket_relse(bucket);
3999 ocfs2_xattr_bucket_free(bucket);
4003 struct ocfs2_xattr_tree_list {
4009 static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb,
4010 struct ocfs2_xattr_header *xh,
4017 if (index < 0 || index >= le16_to_cpu(xh->xh_count))
4020 name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset);
4022 *block_off = name_offset >> sb->s_blocksize_bits;
4023 *new_offset = name_offset % sb->s_blocksize;
4028 static int ocfs2_list_xattr_bucket(struct inode *inode,
4029 struct ocfs2_xattr_bucket *bucket,
4033 struct ocfs2_xattr_tree_list *xl = (struct ocfs2_xattr_tree_list *)para;
4034 int i, block_off, new_offset;
4035 const char *prefix, *name;
4037 for (i = 0 ; i < le16_to_cpu(bucket_xh(bucket)->xh_count); i++) {
4038 struct ocfs2_xattr_entry *entry = &bucket_xh(bucket)->xh_entries[i];
4039 type = ocfs2_xattr_get_type(entry);
4040 prefix = ocfs2_xattr_prefix(type);
4043 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
4051 name = (const char *)bucket_block(bucket, block_off) +
4053 ret = ocfs2_xattr_list_entry(xl->buffer,
4057 entry->xe_name_len);
4066 static int ocfs2_iterate_xattr_index_block(struct inode *inode,
4067 struct buffer_head *blk_bh,
4068 xattr_tree_rec_func *rec_func,
4071 struct ocfs2_xattr_block *xb =
4072 (struct ocfs2_xattr_block *)blk_bh->b_data;
4073 struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list;
4075 u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0;
4078 if (!el->l_next_free_rec || !rec_func)
4081 while (name_hash > 0) {
4082 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
4083 &e_cpos, &num_clusters, el);
4089 ret = rec_func(inode, blk_bh, p_blkno, e_cpos,
4090 num_clusters, para);
4100 name_hash = e_cpos - 1;
4107 static int ocfs2_list_xattr_tree_rec(struct inode *inode,
4108 struct buffer_head *root_bh,
4109 u64 blkno, u32 cpos, u32 len, void *para)
4111 return ocfs2_iterate_xattr_buckets(inode, blkno, len,
4112 ocfs2_list_xattr_bucket, para);
4115 static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
4116 struct buffer_head *blk_bh,
4121 struct ocfs2_xattr_tree_list xl = {
4123 .buffer_size = buffer_size,
4127 ret = ocfs2_iterate_xattr_index_block(inode, blk_bh,
4128 ocfs2_list_xattr_tree_rec, &xl);
4139 static int cmp_xe(const void *a, const void *b)
4141 const struct ocfs2_xattr_entry *l = a, *r = b;
4142 u32 l_hash = le32_to_cpu(l->xe_name_hash);
4143 u32 r_hash = le32_to_cpu(r->xe_name_hash);
4145 if (l_hash > r_hash)
4147 if (l_hash < r_hash)
4152 static void swap_xe(void *a, void *b, int size)
4154 struct ocfs2_xattr_entry *l = a, *r = b, tmp;
4157 memcpy(l, r, sizeof(struct ocfs2_xattr_entry));
4158 memcpy(r, &tmp, sizeof(struct ocfs2_xattr_entry));
4162 * When the ocfs2_xattr_block is filled up, new bucket will be created
4163 * and all the xattr entries will be moved to the new bucket.
4164 * The header goes at the start of the bucket, and the names+values are
4165 * filled from the end. This is why *target starts as the last buffer.
4166 * Note: we need to sort the entries since they are not saved in order
4167 * in the ocfs2_xattr_block.
4169 static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode,
4170 struct buffer_head *xb_bh,
4171 struct ocfs2_xattr_bucket *bucket)
4173 int i, blocksize = inode->i_sb->s_blocksize;
4174 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
4175 u16 offset, size, off_change;
4176 struct ocfs2_xattr_entry *xe;
4177 struct ocfs2_xattr_block *xb =
4178 (struct ocfs2_xattr_block *)xb_bh->b_data;
4179 struct ocfs2_xattr_header *xb_xh = &xb->xb_attrs.xb_header;
4180 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
4181 u16 count = le16_to_cpu(xb_xh->xh_count);
4182 char *src = xb_bh->b_data;
4183 char *target = bucket_block(bucket, blks - 1);
4185 trace_ocfs2_cp_xattr_block_to_bucket_begin(
4186 (unsigned long long)xb_bh->b_blocknr,
4187 (unsigned long long)bucket_blkno(bucket));
4189 for (i = 0; i < blks; i++)
4190 memset(bucket_block(bucket, i), 0, blocksize);
4193 * Since the xe_name_offset is based on ocfs2_xattr_header,
4194 * there is a offset change corresponding to the change of
4195 * ocfs2_xattr_header's position.
4197 off_change = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
4198 xe = &xb_xh->xh_entries[count - 1];
4199 offset = le16_to_cpu(xe->xe_name_offset) + off_change;
4200 size = blocksize - offset;
4202 /* copy all the names and values. */
4203 memcpy(target + offset, src + offset, size);
4205 /* Init new header now. */
4206 xh->xh_count = xb_xh->xh_count;
4207 xh->xh_num_buckets = cpu_to_le16(1);
4208 xh->xh_name_value_len = cpu_to_le16(size);
4209 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE - size);
4211 /* copy all the entries. */
4212 target = bucket_block(bucket, 0);
4213 offset = offsetof(struct ocfs2_xattr_header, xh_entries);
4214 size = count * sizeof(struct ocfs2_xattr_entry);
4215 memcpy(target + offset, (char *)xb_xh + offset, size);
4217 /* Change the xe offset for all the xe because of the move. */
4218 off_change = OCFS2_XATTR_BUCKET_SIZE - blocksize +
4219 offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
4220 for (i = 0; i < count; i++)
4221 le16_add_cpu(&xh->xh_entries[i].xe_name_offset, off_change);
4223 trace_ocfs2_cp_xattr_block_to_bucket_end(offset, size, off_change);
4225 sort(target + offset, count, sizeof(struct ocfs2_xattr_entry),
4230 * After we move xattr from block to index btree, we have to
4231 * update ocfs2_xattr_search to the new xe and base.
4233 * When the entry is in xattr block, xattr_bh indicates the storage place.
4234 * While if the entry is in index b-tree, "bucket" indicates the
4235 * real place of the xattr.
4237 static void ocfs2_xattr_update_xattr_search(struct inode *inode,
4238 struct ocfs2_xattr_search *xs,
4239 struct buffer_head *old_bh)
4241 char *buf = old_bh->b_data;
4242 struct ocfs2_xattr_block *old_xb = (struct ocfs2_xattr_block *)buf;
4243 struct ocfs2_xattr_header *old_xh = &old_xb->xb_attrs.xb_header;
4246 xs->header = bucket_xh(xs->bucket);
4247 xs->base = bucket_block(xs->bucket, 0);
4248 xs->end = xs->base + inode->i_sb->s_blocksize;
4253 i = xs->here - old_xh->xh_entries;
4254 xs->here = &xs->header->xh_entries[i];
4257 static int ocfs2_xattr_create_index_block(struct inode *inode,
4258 struct ocfs2_xattr_search *xs,
4259 struct ocfs2_xattr_set_ctxt *ctxt)
4264 handle_t *handle = ctxt->handle;
4265 struct ocfs2_inode_info *oi = OCFS2_I(inode);
4266 struct buffer_head *xb_bh = xs->xattr_bh;
4267 struct ocfs2_xattr_block *xb =
4268 (struct ocfs2_xattr_block *)xb_bh->b_data;
4269 struct ocfs2_xattr_tree_root *xr;
4270 u16 xb_flags = le16_to_cpu(xb->xb_flags);
4272 trace_ocfs2_xattr_create_index_block_begin(
4273 (unsigned long long)xb_bh->b_blocknr);
4275 BUG_ON(xb_flags & OCFS2_XATTR_INDEXED);
4276 BUG_ON(!xs->bucket);
4280 * We can use this lock for now, and maybe move to a dedicated mutex
4281 * if performance becomes a problem later.
4283 down_write(&oi->ip_alloc_sem);
4285 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), xb_bh,
4286 OCFS2_JOURNAL_ACCESS_WRITE);
4292 ret = __ocfs2_claim_clusters(handle, ctxt->data_ac,
4293 1, 1, &bit_off, &len);
4300 * The bucket may spread in many blocks, and
4301 * we will only touch the 1st block and the last block
4302 * in the whole bucket(one for entry and one for data).
4304 blkno = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
4306 trace_ocfs2_xattr_create_index_block((unsigned long long)blkno);
4308 ret = ocfs2_init_xattr_bucket(xs->bucket, blkno, 1);
4314 ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
4315 OCFS2_JOURNAL_ACCESS_CREATE);
4321 ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xs->bucket);
4322 ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
4324 ocfs2_xattr_update_xattr_search(inode, xs, xb_bh);
4326 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
4327 memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize -
4328 offsetof(struct ocfs2_xattr_block, xb_attrs));
4330 xr = &xb->xb_attrs.xb_root;
4331 xr->xt_clusters = cpu_to_le32(1);
4332 xr->xt_last_eb_blk = 0;
4333 xr->xt_list.l_tree_depth = 0;
4334 xr->xt_list.l_count = cpu_to_le16(ocfs2_xattr_recs_per_xb(inode->i_sb));
4335 xr->xt_list.l_next_free_rec = cpu_to_le16(1);
4337 xr->xt_list.l_recs[0].e_cpos = 0;
4338 xr->xt_list.l_recs[0].e_blkno = cpu_to_le64(blkno);
4339 xr->xt_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1);
4341 xb->xb_flags = cpu_to_le16(xb_flags | OCFS2_XATTR_INDEXED);
4343 ocfs2_journal_dirty(handle, xb_bh);
4346 up_write(&oi->ip_alloc_sem);
4351 static int cmp_xe_offset(const void *a, const void *b)
4353 const struct ocfs2_xattr_entry *l = a, *r = b;
4354 u32 l_name_offset = le16_to_cpu(l->xe_name_offset);
4355 u32 r_name_offset = le16_to_cpu(r->xe_name_offset);
4357 if (l_name_offset < r_name_offset)
4359 if (l_name_offset > r_name_offset)
4365 * defrag a xattr bucket if we find that the bucket has some
4366 * holes beteen name/value pairs.
4367 * We will move all the name/value pairs to the end of the bucket
4368 * so that we can spare some space for insertion.
4370 static int ocfs2_defrag_xattr_bucket(struct inode *inode,
4372 struct ocfs2_xattr_bucket *bucket)
4375 size_t end, offset, len;
4376 struct ocfs2_xattr_header *xh;
4377 char *entries, *buf, *bucket_buf = NULL;
4378 u64 blkno = bucket_blkno(bucket);
4380 size_t blocksize = inode->i_sb->s_blocksize;
4381 struct ocfs2_xattr_entry *xe;
4384 * In order to make the operation more efficient and generic,
4385 * we copy all the blocks into a contiguous memory and do the
4386 * defragment there, so if anything is error, we will not touch
4389 bucket_buf = kmalloc(OCFS2_XATTR_BUCKET_SIZE, GFP_NOFS);
4396 for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)
4397 memcpy(buf, bucket_block(bucket, i), blocksize);
4399 ret = ocfs2_xattr_bucket_journal_access(handle, bucket,
4400 OCFS2_JOURNAL_ACCESS_WRITE);
4406 xh = (struct ocfs2_xattr_header *)bucket_buf;
4407 entries = (char *)xh->xh_entries;
4408 xh_free_start = le16_to_cpu(xh->xh_free_start);
4410 trace_ocfs2_defrag_xattr_bucket(
4411 (unsigned long long)blkno, le16_to_cpu(xh->xh_count),
4412 xh_free_start, le16_to_cpu(xh->xh_name_value_len));
4415 * sort all the entries by their offset.
4416 * the largest will be the first, so that we can
4417 * move them to the end one by one.
4419 sort(entries, le16_to_cpu(xh->xh_count),
4420 sizeof(struct ocfs2_xattr_entry),
4421 cmp_xe_offset, swap_xe);
4423 /* Move all name/values to the end of the bucket. */
4424 xe = xh->xh_entries;
4425 end = OCFS2_XATTR_BUCKET_SIZE;
4426 for (i = 0; i < le16_to_cpu(xh->xh_count); i++, xe++) {
4427 offset = le16_to_cpu(xe->xe_name_offset);
4428 len = namevalue_size_xe(xe);
4431 * We must make sure that the name/value pair
4432 * exist in the same block. So adjust end to
4433 * the previous block end if needed.
4435 if (((end - len) / blocksize !=
4436 (end - 1) / blocksize))
4437 end = end - end % blocksize;
4439 if (end > offset + len) {
4440 memmove(bucket_buf + end - len,
4441 bucket_buf + offset, len);
4442 xe->xe_name_offset = cpu_to_le16(end - len);
4445 mlog_bug_on_msg(end < offset + len, "Defrag check failed for "
4446 "bucket %llu\n", (unsigned long long)blkno);
4451 mlog_bug_on_msg(xh_free_start > end, "Defrag check failed for "
4452 "bucket %llu\n", (unsigned long long)blkno);
4454 if (xh_free_start == end)
4457 memset(bucket_buf + xh_free_start, 0, end - xh_free_start);
4458 xh->xh_free_start = cpu_to_le16(end);
4460 /* sort the entries by their name_hash. */
4461 sort(entries, le16_to_cpu(xh->xh_count),
4462 sizeof(struct ocfs2_xattr_entry),
4466 for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)
4467 memcpy(bucket_block(bucket, i), buf, blocksize);
4468 ocfs2_xattr_bucket_journal_dirty(handle, bucket);
4476 * prev_blkno points to the start of an existing extent. new_blkno
4477 * points to a newly allocated extent. Because we know each of our
4478 * clusters contains more than bucket, we can easily split one cluster
4479 * at a bucket boundary. So we take the last cluster of the existing
4480 * extent and split it down the middle. We move the last half of the
4481 * buckets in the last cluster of the existing extent over to the new
4484 * first_bh is the buffer at prev_blkno so we can update the existing
4485 * extent's bucket count. header_bh is the bucket were we were hoping
4486 * to insert our xattr. If the bucket move places the target in the new
4487 * extent, we'll update first_bh and header_bh after modifying the old
4490 * first_hash will be set as the 1st xe's name_hash in the new extent.
4492 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode *inode,
4494 struct ocfs2_xattr_bucket *first,
4495 struct ocfs2_xattr_bucket *target,
4501 struct super_block *sb = inode->i_sb;
4502 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(sb);
4503 int num_buckets = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb));
4504 int to_move = num_buckets / 2;
4506 u64 last_cluster_blkno = bucket_blkno(first) +
4507 ((num_clusters - 1) * ocfs2_clusters_to_blocks(sb, 1));
4509 BUG_ON(le16_to_cpu(bucket_xh(first)->xh_num_buckets) < num_buckets);
4510 BUG_ON(OCFS2_XATTR_BUCKET_SIZE == OCFS2_SB(sb)->s_clustersize);
4512 trace_ocfs2_mv_xattr_bucket_cross_cluster(
4513 (unsigned long long)last_cluster_blkno,
4514 (unsigned long long)new_blkno);
4516 ret = ocfs2_mv_xattr_buckets(inode, handle, bucket_blkno(first),
4517 last_cluster_blkno, new_blkno,
4518 to_move, first_hash);
4524 /* This is the first bucket that got moved */
4525 src_blkno = last_cluster_blkno + (to_move * blks_per_bucket);
4528 * If the target bucket was part of the moved buckets, we need to
4529 * update first and target.
4531 if (bucket_blkno(target) >= src_blkno) {
4532 /* Find the block for the new target bucket */
4533 src_blkno = new_blkno +
4534 (bucket_blkno(target) - src_blkno);
4536 ocfs2_xattr_bucket_relse(first);
4537 ocfs2_xattr_bucket_relse(target);
4540 * These shouldn't fail - the buffers are in the
4541 * journal from ocfs2_cp_xattr_bucket().
4543 ret = ocfs2_read_xattr_bucket(first, new_blkno);
4548 ret = ocfs2_read_xattr_bucket(target, src_blkno);
4559 * Find the suitable pos when we divide a bucket into 2.
4560 * We have to make sure the xattrs with the same hash value exist
4561 * in the same bucket.
4563 * If this ocfs2_xattr_header covers more than one hash value, find a
4564 * place where the hash value changes. Try to find the most even split.
4565 * The most common case is that all entries have different hash values,
4566 * and the first check we make will find a place to split.
4568 static int ocfs2_xattr_find_divide_pos(struct ocfs2_xattr_header *xh)
4570 struct ocfs2_xattr_entry *entries = xh->xh_entries;
4571 int count = le16_to_cpu(xh->xh_count);
4572 int delta, middle = count / 2;
4575 * We start at the middle. Each step gets farther away in both
4576 * directions. We therefore hit the change in hash value
4577 * nearest to the middle. Note that this loop does not execute for
4580 for (delta = 0; delta < middle; delta++) {
4581 /* Let's check delta earlier than middle */
4582 if (cmp_xe(&entries[middle - delta - 1],
4583 &entries[middle - delta]))
4584 return middle - delta;
4586 /* For even counts, don't walk off the end */
4587 if ((middle + delta + 1) == count)
4590 /* Now try delta past middle */
4591 if (cmp_xe(&entries[middle + delta],
4592 &entries[middle + delta + 1]))
4593 return middle + delta + 1;
4596 /* Every entry had the same hash */
4601 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
4602 * first_hash will record the 1st hash of the new bucket.
4604 * Normally half of the xattrs will be moved. But we have to make
4605 * sure that the xattrs with the same hash value are stored in the
4606 * same bucket. If all the xattrs in this bucket have the same hash
4607 * value, the new bucket will be initialized as an empty one and the
4608 * first_hash will be initialized as (hash_value+1).
4610 static int ocfs2_divide_xattr_bucket(struct inode *inode,
4615 int new_bucket_head)
4618 int count, start, len, name_value_len = 0, name_offset = 0;
4619 struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
4620 struct ocfs2_xattr_header *xh;
4621 struct ocfs2_xattr_entry *xe;
4622 int blocksize = inode->i_sb->s_blocksize;
4624 trace_ocfs2_divide_xattr_bucket_begin((unsigned long long)blk,
4625 (unsigned long long)new_blk);
4627 s_bucket = ocfs2_xattr_bucket_new(inode);
4628 t_bucket = ocfs2_xattr_bucket_new(inode);
4629 if (!s_bucket || !t_bucket) {
4635 ret = ocfs2_read_xattr_bucket(s_bucket, blk);
4641 ret = ocfs2_xattr_bucket_journal_access(handle, s_bucket,
4642 OCFS2_JOURNAL_ACCESS_WRITE);
4649 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
4650 * there's no need to read it.
4652 ret = ocfs2_init_xattr_bucket(t_bucket, new_blk, new_bucket_head);
4659 * Hey, if we're overwriting t_bucket, what difference does
4660 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
4661 * same part of ocfs2_cp_xattr_bucket().
4663 ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
4665 OCFS2_JOURNAL_ACCESS_CREATE :
4666 OCFS2_JOURNAL_ACCESS_WRITE);
4672 xh = bucket_xh(s_bucket);
4673 count = le16_to_cpu(xh->xh_count);
4674 start = ocfs2_xattr_find_divide_pos(xh);
4676 if (start == count) {
4677 xe = &xh->xh_entries[start-1];
4680 * initialized a new empty bucket here.
4681 * The hash value is set as one larger than
4682 * that of the last entry in the previous bucket.
4684 for (i = 0; i < t_bucket->bu_blocks; i++)
4685 memset(bucket_block(t_bucket, i), 0, blocksize);
4687 xh = bucket_xh(t_bucket);
4688 xh->xh_free_start = cpu_to_le16(blocksize);
4689 xh->xh_entries[0].xe_name_hash = xe->xe_name_hash;
4690 le32_add_cpu(&xh->xh_entries[0].xe_name_hash, 1);
4692 goto set_num_buckets;
4695 /* copy the whole bucket to the new first. */
4696 ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
4698 /* update the new bucket. */
4699 xh = bucket_xh(t_bucket);
4702 * Calculate the total name/value len and xh_free_start for
4703 * the old bucket first.
4705 name_offset = OCFS2_XATTR_BUCKET_SIZE;
4707 for (i = 0; i < start; i++) {
4708 xe = &xh->xh_entries[i];
4709 name_value_len += namevalue_size_xe(xe);
4710 if (le16_to_cpu(xe->xe_name_offset) < name_offset)
4711 name_offset = le16_to_cpu(xe->xe_name_offset);
4715 * Now begin the modification to the new bucket.
4717 * In the new bucket, We just move the xattr entry to the beginning
4718 * and don't touch the name/value. So there will be some holes in the
4719 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
4722 xe = &xh->xh_entries[start];
4723 len = sizeof(struct ocfs2_xattr_entry) * (count - start);
4724 trace_ocfs2_divide_xattr_bucket_move(len,
4725 (int)((char *)xe - (char *)xh),
4726 (int)((char *)xh->xh_entries - (char *)xh));
4727 memmove((char *)xh->xh_entries, (char *)xe, len);
4728 xe = &xh->xh_entries[count - start];
4729 len = sizeof(struct ocfs2_xattr_entry) * start;
4730 memset((char *)xe, 0, len);
4732 le16_add_cpu(&xh->xh_count, -start);
4733 le16_add_cpu(&xh->xh_name_value_len, -name_value_len);
4735 /* Calculate xh_free_start for the new bucket. */
4736 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE);
4737 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
4738 xe = &xh->xh_entries[i];
4739 if (le16_to_cpu(xe->xe_name_offset) <
4740 le16_to_cpu(xh->xh_free_start))
4741 xh->xh_free_start = xe->xe_name_offset;
4745 /* set xh->xh_num_buckets for the new xh. */
4746 if (new_bucket_head)
4747 xh->xh_num_buckets = cpu_to_le16(1);
4749 xh->xh_num_buckets = 0;
4751 ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
4753 /* store the first_hash of the new bucket. */
4755 *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash);
4758 * Now only update the 1st block of the old bucket. If we
4759 * just added a new empty bucket, there is no need to modify
4765 xh = bucket_xh(s_bucket);
4766 memset(&xh->xh_entries[start], 0,
4767 sizeof(struct ocfs2_xattr_entry) * (count - start));
4768 xh->xh_count = cpu_to_le16(start);
4769 xh->xh_free_start = cpu_to_le16(name_offset);
4770 xh->xh_name_value_len = cpu_to_le16(name_value_len);
4772 ocfs2_xattr_bucket_journal_dirty(handle, s_bucket);
4775 ocfs2_xattr_bucket_free(s_bucket);
4776 ocfs2_xattr_bucket_free(t_bucket);
4782 * Copy xattr from one bucket to another bucket.
4784 * The caller must make sure that the journal transaction
4785 * has enough space for journaling.
4787 static int ocfs2_cp_xattr_bucket(struct inode *inode,
4794 struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
4796 BUG_ON(s_blkno == t_blkno);
4798 trace_ocfs2_cp_xattr_bucket((unsigned long long)s_blkno,
4799 (unsigned long long)t_blkno,
4802 s_bucket = ocfs2_xattr_bucket_new(inode);
4803 t_bucket = ocfs2_xattr_bucket_new(inode);
4804 if (!s_bucket || !t_bucket) {
4810 ret = ocfs2_read_xattr_bucket(s_bucket, s_blkno);
4815 * Even if !t_is_new, we're overwriting t_bucket. Thus,
4816 * there's no need to read it.
4818 ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno, t_is_new);
4823 * Hey, if we're overwriting t_bucket, what difference does
4824 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
4825 * cluster to fill, we came here from
4826 * ocfs2_mv_xattr_buckets(), and it is really new -
4827 * ACCESS_CREATE is required. But we also might have moved data
4828 * out of t_bucket before extending back into it.
4829 * ocfs2_add_new_xattr_bucket() can do this - its call to
4830 * ocfs2_add_new_xattr_cluster() may have created a new extent
4831 * and copied out the end of the old extent. Then it re-extends
4832 * the old extent back to create space for new xattrs. That's
4833 * how we get here, and the bucket isn't really new.
4835 ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
4837 OCFS2_JOURNAL_ACCESS_CREATE :
4838 OCFS2_JOURNAL_ACCESS_WRITE);
4842 ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
4843 ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
4846 ocfs2_xattr_bucket_free(t_bucket);
4847 ocfs2_xattr_bucket_free(s_bucket);
4853 * src_blk points to the start of an existing extent. last_blk points to
4854 * last cluster in that extent. to_blk points to a newly allocated
4855 * extent. We copy the buckets from the cluster at last_blk to the new
4856 * extent. If start_bucket is non-zero, we skip that many buckets before
4857 * we start copying. The new extent's xh_num_buckets gets set to the
4858 * number of buckets we copied. The old extent's xh_num_buckets shrinks
4859 * by the same amount.
4861 static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle,
4862 u64 src_blk, u64 last_blk, u64 to_blk,
4863 unsigned int start_bucket,
4866 int i, ret, credits;
4867 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
4868 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
4869 int num_buckets = ocfs2_xattr_buckets_per_cluster(osb);
4870 struct ocfs2_xattr_bucket *old_first, *new_first;
4872 trace_ocfs2_mv_xattr_buckets((unsigned long long)last_blk,
4873 (unsigned long long)to_blk);
4875 BUG_ON(start_bucket >= num_buckets);
4877 num_buckets -= start_bucket;
4878 last_blk += (start_bucket * blks_per_bucket);
4881 /* The first bucket of the original extent */
4882 old_first = ocfs2_xattr_bucket_new(inode);
4883 /* The first bucket of the new extent */
4884 new_first = ocfs2_xattr_bucket_new(inode);
4885 if (!old_first || !new_first) {
4891 ret = ocfs2_read_xattr_bucket(old_first, src_blk);
4898 * We need to update the first bucket of the old extent and all
4899 * the buckets going to the new extent.
4901 credits = ((num_buckets + 1) * blks_per_bucket);
4902 ret = ocfs2_extend_trans(handle, credits);
4908 ret = ocfs2_xattr_bucket_journal_access(handle, old_first,
4909 OCFS2_JOURNAL_ACCESS_WRITE);
4915 for (i = 0; i < num_buckets; i++) {
4916 ret = ocfs2_cp_xattr_bucket(inode, handle,
4917 last_blk + (i * blks_per_bucket),
4918 to_blk + (i * blks_per_bucket),
4927 * Get the new bucket ready before we dirty anything
4928 * (This actually shouldn't fail, because we already dirtied
4929 * it once in ocfs2_cp_xattr_bucket()).
4931 ret = ocfs2_read_xattr_bucket(new_first, to_blk);
4936 ret = ocfs2_xattr_bucket_journal_access(handle, new_first,
4937 OCFS2_JOURNAL_ACCESS_WRITE);
4943 /* Now update the headers */
4944 le16_add_cpu(&bucket_xh(old_first)->xh_num_buckets, -num_buckets);
4945 ocfs2_xattr_bucket_journal_dirty(handle, old_first);
4947 bucket_xh(new_first)->xh_num_buckets = cpu_to_le16(num_buckets);
4948 ocfs2_xattr_bucket_journal_dirty(handle, new_first);
4951 *first_hash = le32_to_cpu(bucket_xh(new_first)->xh_entries[0].xe_name_hash);
4954 ocfs2_xattr_bucket_free(new_first);
4955 ocfs2_xattr_bucket_free(old_first);
4960 * Move some xattrs in this cluster to the new cluster.
4961 * This function should only be called when bucket size == cluster size.
4962 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4964 static int ocfs2_divide_xattr_cluster(struct inode *inode,
4970 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
4971 int ret, credits = 2 * blk_per_bucket;
4973 BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize);
4975 ret = ocfs2_extend_trans(handle, credits);
4981 /* Move half of the xattr in start_blk to the next bucket. */
4982 return ocfs2_divide_xattr_bucket(inode, handle, prev_blk,
4983 new_blk, first_hash, 1);
4987 * Move some xattrs from the old cluster to the new one since they are not
4988 * contiguous in ocfs2 xattr tree.
4990 * new_blk starts a new separate cluster, and we will move some xattrs from
4991 * prev_blk to it. v_start will be set as the first name hash value in this
4992 * new cluster so that it can be used as e_cpos during tree insertion and
4993 * don't collide with our original b-tree operations. first_bh and header_bh
4994 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
4995 * to extend the insert bucket.
4997 * The problem is how much xattr should we move to the new one and when should
4998 * we update first_bh and header_bh?
4999 * 1. If cluster size > bucket size, that means the previous cluster has more
5000 * than 1 bucket, so just move half nums of bucket into the new cluster and
5001 * update the first_bh and header_bh if the insert bucket has been moved
5002 * to the new cluster.
5003 * 2. If cluster_size == bucket_size:
5004 * a) If the previous extent rec has more than one cluster and the insert
5005 * place isn't in the last cluster, copy the entire last cluster to the
5006 * new one. This time, we don't need to upate the first_bh and header_bh
5007 * since they will not be moved into the new cluster.
5008 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
5009 * the new one. And we set the extend flag to zero if the insert place is
5010 * moved into the new allocated cluster since no extend is needed.
5012 static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode,
5014 struct ocfs2_xattr_bucket *first,
5015 struct ocfs2_xattr_bucket *target,
5023 trace_ocfs2_adjust_xattr_cross_cluster(
5024 (unsigned long long)bucket_blkno(first),
5025 (unsigned long long)new_blk, prev_clusters);
5027 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1) {
5028 ret = ocfs2_mv_xattr_bucket_cross_cluster(inode,
5037 /* The start of the last cluster in the first extent */
5038 u64 last_blk = bucket_blkno(first) +
5039 ((prev_clusters - 1) *
5040 ocfs2_clusters_to_blocks(inode->i_sb, 1));
5042 if (prev_clusters > 1 && bucket_blkno(target) != last_blk) {
5043 ret = ocfs2_mv_xattr_buckets(inode, handle,
5044 bucket_blkno(first),
5045 last_blk, new_blk, 0,
5050 ret = ocfs2_divide_xattr_cluster(inode, handle,
5056 if ((bucket_blkno(target) == last_blk) && extend)
5065 * Add a new cluster for xattr storage.
5067 * If the new cluster is contiguous with the previous one, it will be
5068 * appended to the same extent record, and num_clusters will be updated.
5069 * If not, we will insert a new extent for it and move some xattrs in
5070 * the last cluster into the new allocated one.
5071 * We also need to limit the maximum size of a btree leaf, otherwise we'll
5072 * lose the benefits of hashing because we'll have to search large leaves.
5073 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
5076 * first_bh is the first block of the previous extent rec and header_bh
5077 * indicates the bucket we will insert the new xattrs. They will be updated
5078 * when the header_bh is moved into the new cluster.
5080 static int ocfs2_add_new_xattr_cluster(struct inode *inode,
5081 struct buffer_head *root_bh,
5082 struct ocfs2_xattr_bucket *first,
5083 struct ocfs2_xattr_bucket *target,
5087 struct ocfs2_xattr_set_ctxt *ctxt)
5090 u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
5091 u32 prev_clusters = *num_clusters;
5092 u32 clusters_to_add = 1, bit_off, num_bits, v_start = 0;
5094 handle_t *handle = ctxt->handle;
5095 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5096 struct ocfs2_extent_tree et;
5098 trace_ocfs2_add_new_xattr_cluster_begin(
5099 (unsigned long long)OCFS2_I(inode)->ip_blkno,
5100 (unsigned long long)bucket_blkno(first),
5101 prev_cpos, prev_clusters);
5103 ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh);
5105 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh,
5106 OCFS2_JOURNAL_ACCESS_WRITE);
5112 ret = __ocfs2_claim_clusters(handle, ctxt->data_ac, 1,
5113 clusters_to_add, &bit_off, &num_bits);
5120 BUG_ON(num_bits > clusters_to_add);
5122 block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
5123 trace_ocfs2_add_new_xattr_cluster((unsigned long long)block, num_bits);
5125 if (bucket_blkno(first) + (prev_clusters * bpc) == block &&
5126 (prev_clusters + num_bits) << osb->s_clustersize_bits <=
5127 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
5129 * If this cluster is contiguous with the old one and
5130 * adding this new cluster, we don't surpass the limit of
5131 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
5132 * initialized and used like other buckets in the previous
5134 * So add it as a contiguous one. The caller will handle
5137 v_start = prev_cpos + prev_clusters;
5138 *num_clusters = prev_clusters + num_bits;
5140 ret = ocfs2_adjust_xattr_cross_cluster(inode,
5154 trace_ocfs2_add_new_xattr_cluster_insert((unsigned long long)block,
5156 ret = ocfs2_insert_extent(handle, &et, v_start, block,
5157 num_bits, 0, ctxt->meta_ac);
5163 ocfs2_journal_dirty(handle, root_bh);
5170 * We are given an extent. 'first' is the bucket at the very front of
5171 * the extent. The extent has space for an additional bucket past
5172 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
5173 * of the target bucket. We wish to shift every bucket past the target
5174 * down one, filling in that additional space. When we get back to the
5175 * target, we split the target between itself and the now-empty bucket
5176 * at target+1 (aka, target_blkno + blks_per_bucket).
5178 static int ocfs2_extend_xattr_bucket(struct inode *inode,
5180 struct ocfs2_xattr_bucket *first,
5185 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5186 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
5188 u16 new_bucket = le16_to_cpu(bucket_xh(first)->xh_num_buckets);
5190 trace_ocfs2_extend_xattr_bucket((unsigned long long)target_blk,
5191 (unsigned long long)bucket_blkno(first),
5192 num_clusters, new_bucket);
5194 /* The extent must have room for an additional bucket */
5195 BUG_ON(new_bucket >=
5196 (num_clusters * ocfs2_xattr_buckets_per_cluster(osb)));
5198 /* end_blk points to the last existing bucket */
5199 end_blk = bucket_blkno(first) + ((new_bucket - 1) * blk_per_bucket);
5202 * end_blk is the start of the last existing bucket.
5203 * Thus, (end_blk - target_blk) covers the target bucket and
5204 * every bucket after it up to, but not including, the last
5205 * existing bucket. Then we add the last existing bucket, the
5206 * new bucket, and the first bucket (3 * blk_per_bucket).
5208 credits = (end_blk - target_blk) + (3 * blk_per_bucket);
5209 ret = ocfs2_extend_trans(handle, credits);
5215 ret = ocfs2_xattr_bucket_journal_access(handle, first,
5216 OCFS2_JOURNAL_ACCESS_WRITE);
5222 while (end_blk != target_blk) {
5223 ret = ocfs2_cp_xattr_bucket(inode, handle, end_blk,
5224 end_blk + blk_per_bucket, 0);
5227 end_blk -= blk_per_bucket;
5230 /* Move half of the xattr in target_blkno to the next bucket. */
5231 ret = ocfs2_divide_xattr_bucket(inode, handle, target_blk,
5232 target_blk + blk_per_bucket, NULL, 0);
5234 le16_add_cpu(&bucket_xh(first)->xh_num_buckets, 1);
5235 ocfs2_xattr_bucket_journal_dirty(handle, first);
5242 * Add new xattr bucket in an extent record and adjust the buckets
5243 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
5244 * bucket we want to insert into.
5246 * In the easy case, we will move all the buckets after target down by
5247 * one. Half of target's xattrs will be moved to the next bucket.
5249 * If current cluster is full, we'll allocate a new one. This may not
5250 * be contiguous. The underlying calls will make sure that there is
5251 * space for the insert, shifting buckets around if necessary.
5252 * 'target' may be moved by those calls.
5254 static int ocfs2_add_new_xattr_bucket(struct inode *inode,
5255 struct buffer_head *xb_bh,
5256 struct ocfs2_xattr_bucket *target,
5257 struct ocfs2_xattr_set_ctxt *ctxt)
5259 struct ocfs2_xattr_block *xb =
5260 (struct ocfs2_xattr_block *)xb_bh->b_data;
5261 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
5262 struct ocfs2_extent_list *el = &xb_root->xt_list;
5264 le32_to_cpu(bucket_xh(target)->xh_entries[0].xe_name_hash);
5265 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5266 int ret, num_buckets, extend = 1;
5268 u32 e_cpos, num_clusters;
5269 /* The bucket at the front of the extent */
5270 struct ocfs2_xattr_bucket *first;
5272 trace_ocfs2_add_new_xattr_bucket(
5273 (unsigned long long)bucket_blkno(target));
5275 /* The first bucket of the original extent */
5276 first = ocfs2_xattr_bucket_new(inode);
5283 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &e_cpos,
5290 ret = ocfs2_read_xattr_bucket(first, p_blkno);
5296 num_buckets = ocfs2_xattr_buckets_per_cluster(osb) * num_clusters;
5297 if (num_buckets == le16_to_cpu(bucket_xh(first)->xh_num_buckets)) {
5299 * This can move first+target if the target bucket moves
5300 * to the new extent.
5302 ret = ocfs2_add_new_xattr_cluster(inode,
5317 ret = ocfs2_extend_xattr_bucket(inode,
5320 bucket_blkno(target),
5327 ocfs2_xattr_bucket_free(first);
5333 * Truncate the specified xe_off entry in xattr bucket.
5334 * bucket is indicated by header_bh and len is the new length.
5335 * Both the ocfs2_xattr_value_root and the entry will be updated here.
5337 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
5339 static int ocfs2_xattr_bucket_value_truncate(struct inode *inode,
5340 struct ocfs2_xattr_bucket *bucket,
5343 struct ocfs2_xattr_set_ctxt *ctxt)
5347 struct ocfs2_xattr_entry *xe;
5348 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
5349 size_t blocksize = inode->i_sb->s_blocksize;
5350 struct ocfs2_xattr_value_buf vb = {
5351 .vb_access = ocfs2_journal_access,
5354 xe = &xh->xh_entries[xe_off];
5356 BUG_ON(!xe || ocfs2_xattr_is_local(xe));
5358 offset = le16_to_cpu(xe->xe_name_offset) +
5359 OCFS2_XATTR_SIZE(xe->xe_name_len);
5361 value_blk = offset / blocksize;
5363 /* We don't allow ocfs2_xattr_value to be stored in different block. */
5364 BUG_ON(value_blk != (offset + OCFS2_XATTR_ROOT_SIZE - 1) / blocksize);
5366 vb.vb_bh = bucket->bu_bhs[value_blk];
5369 vb.vb_xv = (struct ocfs2_xattr_value_root *)
5370 (vb.vb_bh->b_data + offset % blocksize);
5373 * From here on out we have to dirty the bucket. The generic
5374 * value calls only modify one of the bucket's bhs, but we need
5375 * to send the bucket at once. So if they error, they *could* have
5376 * modified something. We have to assume they did, and dirty
5377 * the whole bucket. This leaves us in a consistent state.
5379 trace_ocfs2_xattr_bucket_value_truncate(
5380 (unsigned long long)bucket_blkno(bucket), xe_off, len);
5381 ret = ocfs2_xattr_value_truncate(inode, &vb, len, ctxt);
5387 ret = ocfs2_xattr_bucket_journal_access(ctxt->handle, bucket,
5388 OCFS2_JOURNAL_ACCESS_WRITE);
5394 xe->xe_value_size = cpu_to_le64(len);
5396 ocfs2_xattr_bucket_journal_dirty(ctxt->handle, bucket);
5402 static int ocfs2_rm_xattr_cluster(struct inode *inode,
5403 struct buffer_head *root_bh,
5410 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5411 struct inode *tl_inode = osb->osb_tl_inode;
5413 struct ocfs2_xattr_block *xb =
5414 (struct ocfs2_xattr_block *)root_bh->b_data;
5415 struct ocfs2_alloc_context *meta_ac = NULL;
5416 struct ocfs2_cached_dealloc_ctxt dealloc;
5417 struct ocfs2_extent_tree et;
5419 ret = ocfs2_iterate_xattr_buckets(inode, blkno, len,
5420 ocfs2_delete_xattr_in_bucket, para);
5426 ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh);
5428 ocfs2_init_dealloc_ctxt(&dealloc);
5430 trace_ocfs2_rm_xattr_cluster(
5431 (unsigned long long)OCFS2_I(inode)->ip_blkno,
5432 (unsigned long long)blkno, cpos, len);
5434 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode), blkno,
5437 ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
5443 mutex_lock(&tl_inode->i_mutex);
5445 if (ocfs2_truncate_log_needs_flush(osb)) {
5446 ret = __ocfs2_flush_truncate_log(osb);
5453 handle = ocfs2_start_trans(osb, ocfs2_remove_extent_credits(osb->sb));
5454 if (IS_ERR(handle)) {
5460 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh,
5461 OCFS2_JOURNAL_ACCESS_WRITE);
5467 ret = ocfs2_remove_extent(handle, &et, cpos, len, meta_ac,
5474 le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, -len);
5475 ocfs2_journal_dirty(handle, root_bh);
5477 ret = ocfs2_truncate_log_append(osb, handle, blkno, len);
5480 ocfs2_update_inode_fsync_trans(handle, inode, 0);
5483 ocfs2_commit_trans(osb, handle);
5485 ocfs2_schedule_truncate_log_flush(osb, 1);
5487 mutex_unlock(&tl_inode->i_mutex);
5490 ocfs2_free_alloc_context(meta_ac);
5492 ocfs2_run_deallocs(osb, &dealloc);
5498 * check whether the xattr bucket is filled up with the same hash value.
5499 * If we want to insert the xattr with the same hash, return -ENOSPC.
5500 * If we want to insert a xattr with different hash value, go ahead
5501 * and ocfs2_divide_xattr_bucket will handle this.
5503 static int ocfs2_check_xattr_bucket_collision(struct inode *inode,
5504 struct ocfs2_xattr_bucket *bucket,
5507 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
5508 u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name));
5510 if (name_hash != le32_to_cpu(xh->xh_entries[0].xe_name_hash))
5513 if (xh->xh_entries[le16_to_cpu(xh->xh_count) - 1].xe_name_hash ==
5514 xh->xh_entries[0].xe_name_hash) {
5515 mlog(ML_ERROR, "Too much hash collision in xattr bucket %llu, "
5517 (unsigned long long)bucket_blkno(bucket),
5518 le32_to_cpu(xh->xh_entries[0].xe_name_hash));
5526 * Try to set the entry in the current bucket. If we fail, the caller
5527 * will handle getting us another bucket.
5529 static int ocfs2_xattr_set_entry_bucket(struct inode *inode,
5530 struct ocfs2_xattr_info *xi,
5531 struct ocfs2_xattr_search *xs,
5532 struct ocfs2_xattr_set_ctxt *ctxt)
5535 struct ocfs2_xa_loc loc;
5537 trace_ocfs2_xattr_set_entry_bucket(xi->xi_name);
5539 ocfs2_init_xattr_bucket_xa_loc(&loc, xs->bucket,
5540 xs->not_found ? NULL : xs->here);
5541 ret = ocfs2_xa_set(&loc, xi, ctxt);
5543 xs->here = loc.xl_entry;
5546 if (ret != -ENOSPC) {
5551 /* Ok, we need space. Let's try defragmenting the bucket. */
5552 ret = ocfs2_defrag_xattr_bucket(inode, ctxt->handle,
5559 ret = ocfs2_xa_set(&loc, xi, ctxt);
5561 xs->here = loc.xl_entry;
5572 static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
5573 struct ocfs2_xattr_info *xi,
5574 struct ocfs2_xattr_search *xs,
5575 struct ocfs2_xattr_set_ctxt *ctxt)
5579 trace_ocfs2_xattr_set_entry_index_block(xi->xi_name);
5581 ret = ocfs2_xattr_set_entry_bucket(inode, xi, xs, ctxt);
5584 if (ret != -ENOSPC) {
5589 /* Ack, need more space. Let's try to get another bucket! */
5592 * We do not allow for overlapping ranges between buckets. And
5593 * the maximum number of collisions we will allow for then is
5594 * one bucket's worth, so check it here whether we need to
5595 * add a new bucket for the insert.
5597 ret = ocfs2_check_xattr_bucket_collision(inode,
5605 ret = ocfs2_add_new_xattr_bucket(inode,
5615 * ocfs2_add_new_xattr_bucket() will have updated
5616 * xs->bucket if it moved, but it will not have updated
5617 * any of the other search fields. Thus, we drop it and
5618 * re-search. Everything should be cached, so it'll be
5621 ocfs2_xattr_bucket_relse(xs->bucket);
5622 ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh,
5625 if (ret && ret != -ENODATA)
5627 xs->not_found = ret;
5629 /* Ok, we have a new bucket, let's try again */
5630 ret = ocfs2_xattr_set_entry_bucket(inode, xi, xs, ctxt);
5631 if (ret && (ret != -ENOSPC))
5638 static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
5639 struct ocfs2_xattr_bucket *bucket,
5642 int ret = 0, ref_credits;
5643 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
5645 struct ocfs2_xattr_entry *xe;
5646 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5647 struct ocfs2_xattr_set_ctxt ctxt = {NULL, NULL,};
5648 int credits = ocfs2_remove_extent_credits(osb->sb) +
5649 ocfs2_blocks_per_xattr_bucket(inode->i_sb);
5650 struct ocfs2_xattr_value_root *xv;
5651 struct ocfs2_rm_xattr_bucket_para *args =
5652 (struct ocfs2_rm_xattr_bucket_para *)para;
5654 ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
5656 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
5657 xe = &xh->xh_entries[i];
5658 if (ocfs2_xattr_is_local(xe))
5661 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket,
5668 ret = ocfs2_lock_xattr_remove_allocators(inode, xv,
5674 ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits);
5675 if (IS_ERR(ctxt.handle)) {
5676 ret = PTR_ERR(ctxt.handle);
5681 ret = ocfs2_xattr_bucket_value_truncate(inode, bucket,
5684 ocfs2_commit_trans(osb, ctxt.handle);
5686 ocfs2_free_alloc_context(ctxt.meta_ac);
5687 ctxt.meta_ac = NULL;
5696 ocfs2_free_alloc_context(ctxt.meta_ac);
5697 ocfs2_schedule_truncate_log_flush(osb, 1);
5698 ocfs2_run_deallocs(osb, &ctxt.dealloc);
5703 * Whenever we modify a xattr value root in the bucket(e.g, CoW
5704 * or change the extent record flag), we need to recalculate
5705 * the metaecc for the whole bucket. So it is done here.
5708 * We have to give the extra credits for the caller.
5710 static int ocfs2_xattr_bucket_post_refcount(struct inode *inode,
5715 struct ocfs2_xattr_bucket *bucket =
5716 (struct ocfs2_xattr_bucket *)para;
5718 ret = ocfs2_xattr_bucket_journal_access(handle, bucket,
5719 OCFS2_JOURNAL_ACCESS_WRITE);
5725 ocfs2_xattr_bucket_journal_dirty(handle, bucket);
5731 * Special action we need if the xattr value is refcounted.
5733 * 1. If the xattr is refcounted, lock the tree.
5734 * 2. CoW the xattr if we are setting the new value and the value
5735 * will be stored outside.
5736 * 3. In other case, decrease_refcount will work for us, so just
5737 * lock the refcount tree, calculate the meta and credits is OK.
5739 * We have to do CoW before ocfs2_init_xattr_set_ctxt since
5740 * currently CoW is a completed transaction, while this function
5741 * will also lock the allocators and let us deadlock. So we will
5742 * CoW the whole xattr value.
5744 static int ocfs2_prepare_refcount_xattr(struct inode *inode,
5745 struct ocfs2_dinode *di,
5746 struct ocfs2_xattr_info *xi,
5747 struct ocfs2_xattr_search *xis,
5748 struct ocfs2_xattr_search *xbs,
5749 struct ocfs2_refcount_tree **ref_tree,
5754 struct ocfs2_xattr_block *xb;
5755 struct ocfs2_xattr_entry *xe;
5757 u32 p_cluster, num_clusters;
5758 unsigned int ext_flags;
5759 int name_offset, name_len;
5760 struct ocfs2_xattr_value_buf vb;
5761 struct ocfs2_xattr_bucket *bucket = NULL;
5762 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5763 struct ocfs2_post_refcount refcount;
5764 struct ocfs2_post_refcount *p = NULL;
5765 struct buffer_head *ref_root_bh = NULL;
5767 if (!xis->not_found) {
5769 name_offset = le16_to_cpu(xe->xe_name_offset);
5770 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
5772 vb.vb_bh = xis->inode_bh;
5773 vb.vb_access = ocfs2_journal_access_di;
5775 int i, block_off = 0;
5776 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
5778 name_offset = le16_to_cpu(xe->xe_name_offset);
5779 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
5780 i = xbs->here - xbs->header->xh_entries;
5782 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
5783 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
5784 bucket_xh(xbs->bucket),
5791 base = bucket_block(xbs->bucket, block_off);
5792 vb.vb_bh = xbs->bucket->bu_bhs[block_off];
5793 vb.vb_access = ocfs2_journal_access;
5795 if (ocfs2_meta_ecc(osb)) {
5796 /*create parameters for ocfs2_post_refcount. */
5797 bucket = xbs->bucket;
5798 refcount.credits = bucket->bu_blocks;
5799 refcount.para = bucket;
5801 ocfs2_xattr_bucket_post_refcount;
5806 vb.vb_bh = xbs->xattr_bh;
5807 vb.vb_access = ocfs2_journal_access_xb;
5811 if (ocfs2_xattr_is_local(xe))
5814 vb.vb_xv = (struct ocfs2_xattr_value_root *)
5815 (base + name_offset + name_len);
5817 ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster,
5818 &num_clusters, &vb.vb_xv->xr_list,
5826 * We just need to check the 1st extent record, since we always
5827 * CoW the whole xattr. So there shouldn't be a xattr with
5828 * some REFCOUNT extent recs after the 1st one.
5830 if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
5833 ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
5834 1, ref_tree, &ref_root_bh);
5841 * If we are deleting the xattr or the new size will be stored inside,
5842 * cool, leave it there, the xattr truncate process will remove them
5843 * for us(it still needs the refcount tree lock and the meta, credits).
5844 * And the worse case is that every cluster truncate will split the
5845 * refcount tree, and make the original extent become 3. So we will need
5846 * 2 * cluster more extent recs at most.
5848 if (!xi->xi_value || xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE) {
5850 ret = ocfs2_refcounted_xattr_delete_need(inode,
5851 &(*ref_tree)->rf_ci,
5852 ref_root_bh, vb.vb_xv,
5859 ret = ocfs2_refcount_cow_xattr(inode, di, &vb,
5860 *ref_tree, ref_root_bh, 0,
5861 le32_to_cpu(vb.vb_xv->xr_clusters), p);
5866 brelse(ref_root_bh);
5871 * Add the REFCOUNTED flags for all the extent rec in ocfs2_xattr_value_root.
5872 * The physical clusters will be added to refcount tree.
5874 static int ocfs2_xattr_value_attach_refcount(struct inode *inode,
5875 struct ocfs2_xattr_value_root *xv,
5876 struct ocfs2_extent_tree *value_et,
5877 struct ocfs2_caching_info *ref_ci,
5878 struct buffer_head *ref_root_bh,
5879 struct ocfs2_cached_dealloc_ctxt *dealloc,
5880 struct ocfs2_post_refcount *refcount)
5883 u32 clusters = le32_to_cpu(xv->xr_clusters);
5884 u32 cpos, p_cluster, num_clusters;
5885 struct ocfs2_extent_list *el = &xv->xr_list;
5886 unsigned int ext_flags;
5889 while (cpos < clusters) {
5890 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
5891 &num_clusters, el, &ext_flags);
5897 cpos += num_clusters;
5898 if ((ext_flags & OCFS2_EXT_REFCOUNTED))
5903 ret = ocfs2_add_refcount_flag(inode, value_et,
5904 ref_ci, ref_root_bh,
5905 cpos - num_clusters,
5906 p_cluster, num_clusters,
5918 * Given a normal ocfs2_xattr_header, refcount all the entries which
5919 * have value stored outside.
5920 * Used for xattrs stored in inode and ocfs2_xattr_block.
5922 static int ocfs2_xattr_attach_refcount_normal(struct inode *inode,
5923 struct ocfs2_xattr_value_buf *vb,
5924 struct ocfs2_xattr_header *header,
5925 struct ocfs2_caching_info *ref_ci,
5926 struct buffer_head *ref_root_bh,
5927 struct ocfs2_cached_dealloc_ctxt *dealloc)
5930 struct ocfs2_xattr_entry *xe;
5931 struct ocfs2_xattr_value_root *xv;
5932 struct ocfs2_extent_tree et;
5935 for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
5936 xe = &header->xh_entries[i];
5938 if (ocfs2_xattr_is_local(xe))
5941 xv = (struct ocfs2_xattr_value_root *)((void *)header +
5942 le16_to_cpu(xe->xe_name_offset) +
5943 OCFS2_XATTR_SIZE(xe->xe_name_len));
5946 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
5948 ret = ocfs2_xattr_value_attach_refcount(inode, xv, &et,
5949 ref_ci, ref_root_bh,
5960 static int ocfs2_xattr_inline_attach_refcount(struct inode *inode,
5961 struct buffer_head *fe_bh,
5962 struct ocfs2_caching_info *ref_ci,
5963 struct buffer_head *ref_root_bh,
5964 struct ocfs2_cached_dealloc_ctxt *dealloc)
5966 struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
5967 struct ocfs2_xattr_header *header = (struct ocfs2_xattr_header *)
5968 (fe_bh->b_data + inode->i_sb->s_blocksize -
5969 le16_to_cpu(di->i_xattr_inline_size));
5970 struct ocfs2_xattr_value_buf vb = {
5972 .vb_access = ocfs2_journal_access_di,
5975 return ocfs2_xattr_attach_refcount_normal(inode, &vb, header,
5976 ref_ci, ref_root_bh, dealloc);
5979 struct ocfs2_xattr_tree_value_refcount_para {
5980 struct ocfs2_caching_info *ref_ci;
5981 struct buffer_head *ref_root_bh;
5982 struct ocfs2_cached_dealloc_ctxt *dealloc;
5985 static int ocfs2_get_xattr_tree_value_root(struct super_block *sb,
5986 struct ocfs2_xattr_bucket *bucket,
5988 struct ocfs2_xattr_value_root **xv,
5989 struct buffer_head **bh)
5991 int ret, block_off, name_offset;
5992 struct ocfs2_xattr_header *xh = bucket_xh(bucket);
5993 struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset];
5996 ret = ocfs2_xattr_bucket_get_name_value(sb,
6006 base = bucket_block(bucket, block_off);
6008 *xv = (struct ocfs2_xattr_value_root *)(base + name_offset +
6009 OCFS2_XATTR_SIZE(xe->xe_name_len));
6012 *bh = bucket->bu_bhs[block_off];
6018 * For a given xattr bucket, refcount all the entries which
6019 * have value stored outside.
6021 static int ocfs2_xattr_bucket_value_refcount(struct inode *inode,
6022 struct ocfs2_xattr_bucket *bucket,
6026 struct ocfs2_extent_tree et;
6027 struct ocfs2_xattr_tree_value_refcount_para *ref =
6028 (struct ocfs2_xattr_tree_value_refcount_para *)para;
6029 struct ocfs2_xattr_header *xh =
6030 (struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;
6031 struct ocfs2_xattr_entry *xe;
6032 struct ocfs2_xattr_value_buf vb = {
6033 .vb_access = ocfs2_journal_access,
6035 struct ocfs2_post_refcount refcount = {
6036 .credits = bucket->bu_blocks,
6038 .func = ocfs2_xattr_bucket_post_refcount,
6040 struct ocfs2_post_refcount *p = NULL;
6042 /* We only need post_refcount if we support metaecc. */
6043 if (ocfs2_meta_ecc(OCFS2_SB(inode->i_sb)))
6046 trace_ocfs2_xattr_bucket_value_refcount(
6047 (unsigned long long)bucket_blkno(bucket),
6048 le16_to_cpu(xh->xh_count));
6049 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
6050 xe = &xh->xh_entries[i];
6052 if (ocfs2_xattr_is_local(xe))
6055 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, i,
6056 &vb.vb_xv, &vb.vb_bh);
6062 ocfs2_init_xattr_value_extent_tree(&et,
6063 INODE_CACHE(inode), &vb);
6065 ret = ocfs2_xattr_value_attach_refcount(inode, vb.vb_xv,
6079 static int ocfs2_refcount_xattr_tree_rec(struct inode *inode,
6080 struct buffer_head *root_bh,
6081 u64 blkno, u32 cpos, u32 len, void *para)
6083 return ocfs2_iterate_xattr_buckets(inode, blkno, len,
6084 ocfs2_xattr_bucket_value_refcount,
6088 static int ocfs2_xattr_block_attach_refcount(struct inode *inode,
6089 struct buffer_head *blk_bh,
6090 struct ocfs2_caching_info *ref_ci,
6091 struct buffer_head *ref_root_bh,
6092 struct ocfs2_cached_dealloc_ctxt *dealloc)
6095 struct ocfs2_xattr_block *xb =
6096 (struct ocfs2_xattr_block *)blk_bh->b_data;
6098 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
6099 struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
6100 struct ocfs2_xattr_value_buf vb = {
6102 .vb_access = ocfs2_journal_access_xb,
6105 ret = ocfs2_xattr_attach_refcount_normal(inode, &vb, header,
6106 ref_ci, ref_root_bh,
6109 struct ocfs2_xattr_tree_value_refcount_para para = {
6111 .ref_root_bh = ref_root_bh,
6115 ret = ocfs2_iterate_xattr_index_block(inode, blk_bh,
6116 ocfs2_refcount_xattr_tree_rec,
6123 int ocfs2_xattr_attach_refcount_tree(struct inode *inode,
6124 struct buffer_head *fe_bh,
6125 struct ocfs2_caching_info *ref_ci,
6126 struct buffer_head *ref_root_bh,
6127 struct ocfs2_cached_dealloc_ctxt *dealloc)
6130 struct ocfs2_inode_info *oi = OCFS2_I(inode);
6131 struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
6132 struct buffer_head *blk_bh = NULL;
6134 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
6135 ret = ocfs2_xattr_inline_attach_refcount(inode, fe_bh,
6136 ref_ci, ref_root_bh,
6144 if (!di->i_xattr_loc)
6147 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
6154 ret = ocfs2_xattr_block_attach_refcount(inode, blk_bh, ref_ci,
6155 ref_root_bh, dealloc);
6165 typedef int (should_xattr_reflinked)(struct ocfs2_xattr_entry *xe);
6167 * Store the information we need in xattr reflink.
6168 * old_bh and new_bh are inode bh for the old and new inode.
6170 struct ocfs2_xattr_reflink {
6171 struct inode *old_inode;
6172 struct inode *new_inode;
6173 struct buffer_head *old_bh;
6174 struct buffer_head *new_bh;
6175 struct ocfs2_caching_info *ref_ci;
6176 struct buffer_head *ref_root_bh;
6177 struct ocfs2_cached_dealloc_ctxt *dealloc;
6178 should_xattr_reflinked *xattr_reflinked;
6182 * Given a xattr header and xe offset,
6183 * return the proper xv and the corresponding bh.
6184 * xattr in inode, block and xattr tree have different implementaions.
6186 typedef int (get_xattr_value_root)(struct super_block *sb,
6187 struct buffer_head *bh,
6188 struct ocfs2_xattr_header *xh,
6190 struct ocfs2_xattr_value_root **xv,
6191 struct buffer_head **ret_bh,
6195 * Calculate all the xattr value root metadata stored in this xattr header and
6196 * credits we need if we create them from the scratch.
6197 * We use get_xattr_value_root so that all types of xattr container can use it.
6199 static int ocfs2_value_metas_in_xattr_header(struct super_block *sb,
6200 struct buffer_head *bh,
6201 struct ocfs2_xattr_header *xh,
6202 int *metas, int *credits,
6204 get_xattr_value_root *func,
6208 struct ocfs2_xattr_value_root *xv;
6209 struct ocfs2_xattr_entry *xe;
6211 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
6212 xe = &xh->xh_entries[i];
6213 if (ocfs2_xattr_is_local(xe))
6216 ret = func(sb, bh, xh, i, &xv, NULL, para);
6222 *metas += le16_to_cpu(xv->xr_list.l_tree_depth) *
6223 le16_to_cpu(xv->xr_list.l_next_free_rec);
6225 *credits += ocfs2_calc_extend_credits(sb,
6226 &def_xv.xv.xr_list);
6229 * If the value is a tree with depth > 1, We don't go deep
6230 * to the extent block, so just calculate a maximum record num.
6232 if (!xv->xr_list.l_tree_depth)
6233 *num_recs += le16_to_cpu(xv->xr_list.l_next_free_rec);
6235 *num_recs += ocfs2_clusters_for_bytes(sb,
6242 /* Used by xattr inode and block to return the right xv and buffer_head. */
6243 static int ocfs2_get_xattr_value_root(struct super_block *sb,
6244 struct buffer_head *bh,
6245 struct ocfs2_xattr_header *xh,
6247 struct ocfs2_xattr_value_root **xv,
6248 struct buffer_head **ret_bh,
6251 struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset];
6253 *xv = (struct ocfs2_xattr_value_root *)((void *)xh +
6254 le16_to_cpu(xe->xe_name_offset) +
6255 OCFS2_XATTR_SIZE(xe->xe_name_len));
6264 * Lock the meta_ac and caculate how much credits we need for reflink xattrs.
6265 * It is only used for inline xattr and xattr block.
6267 static int ocfs2_reflink_lock_xattr_allocators(struct ocfs2_super *osb,
6268 struct ocfs2_xattr_header *xh,
6269 struct buffer_head *ref_root_bh,
6271 struct ocfs2_alloc_context **meta_ac)
6273 int ret, meta_add = 0, num_recs = 0;
6274 struct ocfs2_refcount_block *rb =
6275 (struct ocfs2_refcount_block *)ref_root_bh->b_data;
6279 ret = ocfs2_value_metas_in_xattr_header(osb->sb, NULL, xh,
6280 &meta_add, credits, &num_recs,
6281 ocfs2_get_xattr_value_root,
6289 * We need to add/modify num_recs in refcount tree, so just calculate
6290 * an approximate number we need for refcount tree change.
6291 * Sometimes we need to split the tree, and after split, half recs
6292 * will be moved to the new block, and a new block can only provide
6293 * half number of recs. So we multiple new blocks by 2.
6295 num_recs = num_recs / ocfs2_refcount_recs_per_rb(osb->sb) * 2;
6296 meta_add += num_recs;
6297 *credits += num_recs + num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
6298 if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
6299 *credits += le16_to_cpu(rb->rf_list.l_tree_depth) *
6300 le16_to_cpu(rb->rf_list.l_next_free_rec) + 1;
6304 ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add, meta_ac);
6313 * Given a xattr header, reflink all the xattrs in this container.
6314 * It can be used for inode, block and bucket.
6317 * Before we call this function, the caller has memcpy the xattr in
6318 * old_xh to the new_xh.
6320 * If args.xattr_reflinked is set, call it to decide whether the xe should
6321 * be reflinked or not. If not, remove it from the new xattr header.
6323 static int ocfs2_reflink_xattr_header(handle_t *handle,
6324 struct ocfs2_xattr_reflink *args,
6325 struct buffer_head *old_bh,
6326 struct ocfs2_xattr_header *xh,
6327 struct buffer_head *new_bh,
6328 struct ocfs2_xattr_header *new_xh,
6329 struct ocfs2_xattr_value_buf *vb,
6330 struct ocfs2_alloc_context *meta_ac,
6331 get_xattr_value_root *func,
6335 struct super_block *sb = args->old_inode->i_sb;
6336 struct buffer_head *value_bh;
6337 struct ocfs2_xattr_entry *xe, *last;
6338 struct ocfs2_xattr_value_root *xv, *new_xv;
6339 struct ocfs2_extent_tree data_et;
6340 u32 clusters, cpos, p_cluster, num_clusters;
6341 unsigned int ext_flags = 0;
6343 trace_ocfs2_reflink_xattr_header((unsigned long long)old_bh->b_blocknr,
6344 le16_to_cpu(xh->xh_count));
6346 last = &new_xh->xh_entries[le16_to_cpu(new_xh->xh_count)];
6347 for (i = 0, j = 0; i < le16_to_cpu(xh->xh_count); i++, j++) {
6348 xe = &xh->xh_entries[i];
6350 if (args->xattr_reflinked && !args->xattr_reflinked(xe)) {
6351 xe = &new_xh->xh_entries[j];
6353 le16_add_cpu(&new_xh->xh_count, -1);
6354 if (new_xh->xh_count) {
6356 (void *)last - (void *)xe);
6358 sizeof(struct ocfs2_xattr_entry));
6362 * We don't want j to increase in the next round since
6363 * it is already moved ahead.
6369 if (ocfs2_xattr_is_local(xe))
6372 ret = func(sb, old_bh, xh, i, &xv, NULL, para);
6378 ret = func(sb, new_bh, new_xh, j, &new_xv, &value_bh, para);
6385 * For the xattr which has l_tree_depth = 0, all the extent
6386 * recs have already be copied to the new xh with the
6387 * propriate OCFS2_EXT_REFCOUNTED flag we just need to
6388 * increase the refount count int the refcount tree.
6390 * For the xattr which has l_tree_depth > 0, we need
6391 * to initialize it to the empty default value root,
6392 * and then insert the extents one by one.
6394 if (xv->xr_list.l_tree_depth) {
6395 memcpy(new_xv, &def_xv, sizeof(def_xv));
6397 vb->vb_bh = value_bh;
6398 ocfs2_init_xattr_value_extent_tree(&data_et,
6399 INODE_CACHE(args->new_inode), vb);
6402 clusters = le32_to_cpu(xv->xr_clusters);
6404 while (cpos < clusters) {
6405 ret = ocfs2_xattr_get_clusters(args->old_inode,
6418 if (xv->xr_list.l_tree_depth) {
6419 ret = ocfs2_insert_extent(handle,
6421 ocfs2_clusters_to_blocks(
6422 args->old_inode->i_sb,
6424 num_clusters, ext_flags,
6432 ret = ocfs2_increase_refcount(handle, args->ref_ci,
6434 p_cluster, num_clusters,
6435 meta_ac, args->dealloc);
6441 cpos += num_clusters;
6449 static int ocfs2_reflink_xattr_inline(struct ocfs2_xattr_reflink *args)
6451 int ret = 0, credits = 0;
6453 struct ocfs2_super *osb = OCFS2_SB(args->old_inode->i_sb);
6454 struct ocfs2_dinode *di = (struct ocfs2_dinode *)args->old_bh->b_data;
6455 int inline_size = le16_to_cpu(di->i_xattr_inline_size);
6456 int header_off = osb->sb->s_blocksize - inline_size;
6457 struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)
6458 (args->old_bh->b_data + header_off);
6459 struct ocfs2_xattr_header *new_xh = (struct ocfs2_xattr_header *)
6460 (args->new_bh->b_data + header_off);
6461 struct ocfs2_alloc_context *meta_ac = NULL;
6462 struct ocfs2_inode_info *new_oi;
6463 struct ocfs2_dinode *new_di;
6464 struct ocfs2_xattr_value_buf vb = {
6465 .vb_bh = args->new_bh,
6466 .vb_access = ocfs2_journal_access_di,
6469 ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh,
6470 &credits, &meta_ac);
6476 handle = ocfs2_start_trans(osb, credits);
6477 if (IS_ERR(handle)) {
6478 ret = PTR_ERR(handle);
6483 ret = ocfs2_journal_access_di(handle, INODE_CACHE(args->new_inode),
6484 args->new_bh, OCFS2_JOURNAL_ACCESS_WRITE);
6490 memcpy(args->new_bh->b_data + header_off,
6491 args->old_bh->b_data + header_off, inline_size);
6493 new_di = (struct ocfs2_dinode *)args->new_bh->b_data;
6494 new_di->i_xattr_inline_size = cpu_to_le16(inline_size);
6496 ret = ocfs2_reflink_xattr_header(handle, args, args->old_bh, xh,
6497 args->new_bh, new_xh, &vb, meta_ac,
6498 ocfs2_get_xattr_value_root, NULL);
6504 new_oi = OCFS2_I(args->new_inode);
6506 * Adjust extent record count to reserve space for extended attribute.
6507 * Inline data count had been adjusted in ocfs2_duplicate_inline_data().
6509 if (!(new_oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) &&
6510 !(ocfs2_inode_is_fast_symlink(args->new_inode))) {
6511 struct ocfs2_extent_list *el = &new_di->id2.i_list;
6512 le16_add_cpu(&el->l_count, -(inline_size /
6513 sizeof(struct ocfs2_extent_rec)));
6515 spin_lock(&new_oi->ip_lock);
6516 new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL | OCFS2_INLINE_XATTR_FL;
6517 new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features);
6518 spin_unlock(&new_oi->ip_lock);
6520 ocfs2_journal_dirty(handle, args->new_bh);
6523 ocfs2_commit_trans(osb, handle);
6527 ocfs2_free_alloc_context(meta_ac);
6531 static int ocfs2_create_empty_xattr_block(struct inode *inode,
6532 struct buffer_head *fe_bh,
6533 struct buffer_head **ret_bh,
6537 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
6538 struct ocfs2_xattr_set_ctxt ctxt;
6540 memset(&ctxt, 0, sizeof(ctxt));
6541 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &ctxt.meta_ac);
6547 ctxt.handle = ocfs2_start_trans(osb, OCFS2_XATTR_BLOCK_CREATE_CREDITS);
6548 if (IS_ERR(ctxt.handle)) {
6549 ret = PTR_ERR(ctxt.handle);
6554 trace_ocfs2_create_empty_xattr_block(
6555 (unsigned long long)fe_bh->b_blocknr, indexed);
6556 ret = ocfs2_create_xattr_block(inode, fe_bh, &ctxt, indexed,
6561 ocfs2_commit_trans(osb, ctxt.handle);
6563 ocfs2_free_alloc_context(ctxt.meta_ac);
6567 static int ocfs2_reflink_xattr_block(struct ocfs2_xattr_reflink *args,
6568 struct buffer_head *blk_bh,
6569 struct buffer_head *new_blk_bh)
6571 int ret = 0, credits = 0;
6573 struct ocfs2_inode_info *new_oi = OCFS2_I(args->new_inode);
6574 struct ocfs2_dinode *new_di;
6575 struct ocfs2_super *osb = OCFS2_SB(args->new_inode->i_sb);
6576 int header_off = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
6577 struct ocfs2_xattr_block *xb =
6578 (struct ocfs2_xattr_block *)blk_bh->b_data;
6579 struct ocfs2_xattr_header *xh = &xb->xb_attrs.xb_header;
6580 struct ocfs2_xattr_block *new_xb =
6581 (struct ocfs2_xattr_block *)new_blk_bh->b_data;
6582 struct ocfs2_xattr_header *new_xh = &new_xb->xb_attrs.xb_header;
6583 struct ocfs2_alloc_context *meta_ac;
6584 struct ocfs2_xattr_value_buf vb = {
6585 .vb_bh = new_blk_bh,
6586 .vb_access = ocfs2_journal_access_xb,
6589 ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh,
6590 &credits, &meta_ac);
6596 /* One more credits in case we need to add xattr flags in new inode. */
6597 handle = ocfs2_start_trans(osb, credits + 1);
6598 if (IS_ERR(handle)) {
6599 ret = PTR_ERR(handle);
6604 if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) {
6605 ret = ocfs2_journal_access_di(handle,
6606 INODE_CACHE(args->new_inode),
6608 OCFS2_JOURNAL_ACCESS_WRITE);
6615 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(args->new_inode),
6616 new_blk_bh, OCFS2_JOURNAL_ACCESS_WRITE);
6622 memcpy(new_blk_bh->b_data + header_off, blk_bh->b_data + header_off,
6623 osb->sb->s_blocksize - header_off);
6625 ret = ocfs2_reflink_xattr_header(handle, args, blk_bh, xh,
6626 new_blk_bh, new_xh, &vb, meta_ac,
6627 ocfs2_get_xattr_value_root, NULL);
6633 ocfs2_journal_dirty(handle, new_blk_bh);
6635 if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) {
6636 new_di = (struct ocfs2_dinode *)args->new_bh->b_data;
6637 spin_lock(&new_oi->ip_lock);
6638 new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL;
6639 new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features);
6640 spin_unlock(&new_oi->ip_lock);
6642 ocfs2_journal_dirty(handle, args->new_bh);
6646 ocfs2_commit_trans(osb, handle);
6649 ocfs2_free_alloc_context(meta_ac);
6653 struct ocfs2_reflink_xattr_tree_args {
6654 struct ocfs2_xattr_reflink *reflink;
6655 struct buffer_head *old_blk_bh;
6656 struct buffer_head *new_blk_bh;
6657 struct ocfs2_xattr_bucket *old_bucket;
6658 struct ocfs2_xattr_bucket *new_bucket;
6663 * We have to handle the case that both old bucket and new bucket
6664 * will call this function to get the right ret_bh.
6665 * So The caller must give us the right bh.
6667 static int ocfs2_get_reflink_xattr_value_root(struct super_block *sb,
6668 struct buffer_head *bh,
6669 struct ocfs2_xattr_header *xh,
6671 struct ocfs2_xattr_value_root **xv,
6672 struct buffer_head **ret_bh,
6675 struct ocfs2_reflink_xattr_tree_args *args =
6676 (struct ocfs2_reflink_xattr_tree_args *)para;
6677 struct ocfs2_xattr_bucket *bucket;
6679 if (bh == args->old_bucket->bu_bhs[0])
6680 bucket = args->old_bucket;
6682 bucket = args->new_bucket;
6684 return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,
6688 struct ocfs2_value_tree_metas {
6694 static int ocfs2_value_tree_metas_in_bucket(struct super_block *sb,
6695 struct buffer_head *bh,
6696 struct ocfs2_xattr_header *xh,
6698 struct ocfs2_xattr_value_root **xv,
6699 struct buffer_head **ret_bh,
6702 struct ocfs2_xattr_bucket *bucket =
6703 (struct ocfs2_xattr_bucket *)para;
6705 return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,
6709 static int ocfs2_calc_value_tree_metas(struct inode *inode,
6710 struct ocfs2_xattr_bucket *bucket,
6713 struct ocfs2_value_tree_metas *metas =
6714 (struct ocfs2_value_tree_metas *)para;
6715 struct ocfs2_xattr_header *xh =
6716 (struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;
6718 /* Add the credits for this bucket first. */
6719 metas->credits += bucket->bu_blocks;
6720 return ocfs2_value_metas_in_xattr_header(inode->i_sb, bucket->bu_bhs[0],
6721 xh, &metas->num_metas,
6722 &metas->credits, &metas->num_recs,
6723 ocfs2_value_tree_metas_in_bucket,
6728 * Given a xattr extent rec starting from blkno and having len clusters,
6729 * iterate all the buckets calculate how much metadata we need for reflinking
6730 * all the ocfs2_xattr_value_root and lock the allocators accordingly.
6732 static int ocfs2_lock_reflink_xattr_rec_allocators(
6733 struct ocfs2_reflink_xattr_tree_args *args,
6734 struct ocfs2_extent_tree *xt_et,
6735 u64 blkno, u32 len, int *credits,
6736 struct ocfs2_alloc_context **meta_ac,
6737 struct ocfs2_alloc_context **data_ac)
6739 int ret, num_free_extents;
6740 struct ocfs2_value_tree_metas metas;
6741 struct ocfs2_super *osb = OCFS2_SB(args->reflink->old_inode->i_sb);
6742 struct ocfs2_refcount_block *rb;
6744 memset(&metas, 0, sizeof(metas));
6746 ret = ocfs2_iterate_xattr_buckets(args->reflink->old_inode, blkno, len,
6747 ocfs2_calc_value_tree_metas, &metas);
6753 *credits = metas.credits;
6756 * Calculate we need for refcount tree change.
6758 * We need to add/modify num_recs in refcount tree, so just calculate
6759 * an approximate number we need for refcount tree change.
6760 * Sometimes we need to split the tree, and after split, half recs
6761 * will be moved to the new block, and a new block can only provide
6762 * half number of recs. So we multiple new blocks by 2.
6763 * In the end, we have to add credits for modifying the already
6764 * existed refcount block.
6766 rb = (struct ocfs2_refcount_block *)args->reflink->ref_root_bh->b_data;
6768 (metas.num_recs + ocfs2_refcount_recs_per_rb(osb->sb) - 1) /
6769 ocfs2_refcount_recs_per_rb(osb->sb) * 2;
6770 metas.num_metas += metas.num_recs;
6771 *credits += metas.num_recs +
6772 metas.num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
6773 if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
6774 *credits += le16_to_cpu(rb->rf_list.l_tree_depth) *
6775 le16_to_cpu(rb->rf_list.l_next_free_rec) + 1;
6779 /* count in the xattr tree change. */
6780 num_free_extents = ocfs2_num_free_extents(osb, xt_et);
6781 if (num_free_extents < 0) {
6782 ret = num_free_extents;
6787 if (num_free_extents < len)
6788 metas.num_metas += ocfs2_extend_meta_needed(xt_et->et_root_el);
6790 *credits += ocfs2_calc_extend_credits(osb->sb,
6793 if (metas.num_metas) {
6794 ret = ocfs2_reserve_new_metadata_blocks(osb, metas.num_metas,
6803 ret = ocfs2_reserve_clusters(osb, len, data_ac);
6810 ocfs2_free_alloc_context(*meta_ac);
6818 static int ocfs2_reflink_xattr_bucket(handle_t *handle,
6819 u64 blkno, u64 new_blkno, u32 clusters,
6820 u32 *cpos, int num_buckets,
6821 struct ocfs2_alloc_context *meta_ac,
6822 struct ocfs2_alloc_context *data_ac,
6823 struct ocfs2_reflink_xattr_tree_args *args)
6826 struct super_block *sb = args->reflink->old_inode->i_sb;
6827 int bpb = args->old_bucket->bu_blocks;
6828 struct ocfs2_xattr_value_buf vb = {
6829 .vb_access = ocfs2_journal_access,
6832 for (i = 0; i < num_buckets; i++, blkno += bpb, new_blkno += bpb) {
6833 ret = ocfs2_read_xattr_bucket(args->old_bucket, blkno);
6839 ret = ocfs2_init_xattr_bucket(args->new_bucket, new_blkno, 1);
6845 ret = ocfs2_xattr_bucket_journal_access(handle,
6847 OCFS2_JOURNAL_ACCESS_CREATE);
6853 for (j = 0; j < bpb; j++)
6854 memcpy(bucket_block(args->new_bucket, j),
6855 bucket_block(args->old_bucket, j),
6859 * Record the start cpos so that we can use it to initialize
6860 * our xattr tree we also set the xh_num_bucket for the new
6864 *cpos = le32_to_cpu(bucket_xh(args->new_bucket)->
6865 xh_entries[0].xe_name_hash);
6866 bucket_xh(args->new_bucket)->xh_num_buckets =
6867 cpu_to_le16(num_buckets);
6870 ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket);
6872 ret = ocfs2_reflink_xattr_header(handle, args->reflink,
6873 args->old_bucket->bu_bhs[0],
6874 bucket_xh(args->old_bucket),
6875 args->new_bucket->bu_bhs[0],
6876 bucket_xh(args->new_bucket),
6878 ocfs2_get_reflink_xattr_value_root,
6886 * Re-access and dirty the bucket to calculate metaecc.
6887 * Because we may extend the transaction in reflink_xattr_header
6888 * which will let the already accessed block gone.
6890 ret = ocfs2_xattr_bucket_journal_access(handle,
6892 OCFS2_JOURNAL_ACCESS_WRITE);
6898 ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket);
6900 ocfs2_xattr_bucket_relse(args->old_bucket);
6901 ocfs2_xattr_bucket_relse(args->new_bucket);
6904 ocfs2_xattr_bucket_relse(args->old_bucket);
6905 ocfs2_xattr_bucket_relse(args->new_bucket);
6909 static int ocfs2_reflink_xattr_buckets(handle_t *handle,
6910 struct inode *inode,
6911 struct ocfs2_reflink_xattr_tree_args *args,
6912 struct ocfs2_extent_tree *et,
6913 struct ocfs2_alloc_context *meta_ac,
6914 struct ocfs2_alloc_context *data_ac,
6915 u64 blkno, u32 cpos, u32 len)
6917 int ret, first_inserted = 0;
6918 u32 p_cluster, num_clusters, reflink_cpos = 0;
6920 unsigned int num_buckets, reflink_buckets;
6922 ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
6924 ret = ocfs2_read_xattr_bucket(args->old_bucket, blkno);
6929 num_buckets = le16_to_cpu(bucket_xh(args->old_bucket)->xh_num_buckets);
6930 ocfs2_xattr_bucket_relse(args->old_bucket);
6932 while (len && num_buckets) {
6933 ret = ocfs2_claim_clusters(handle, data_ac,
6934 1, &p_cluster, &num_clusters);
6940 new_blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
6941 reflink_buckets = min(num_buckets, bpc * num_clusters);
6943 ret = ocfs2_reflink_xattr_bucket(handle, blkno,
6944 new_blkno, num_clusters,
6945 &reflink_cpos, reflink_buckets,
6946 meta_ac, data_ac, args);
6953 * For the 1st allocated cluster, we make it use the same cpos
6954 * so that the xattr tree looks the same as the original one
6957 if (!first_inserted) {
6958 reflink_cpos = cpos;
6961 ret = ocfs2_insert_extent(handle, et, reflink_cpos, new_blkno,
6962 num_clusters, 0, meta_ac);
6966 trace_ocfs2_reflink_xattr_buckets((unsigned long long)new_blkno,
6967 num_clusters, reflink_cpos);
6969 len -= num_clusters;
6970 blkno += ocfs2_clusters_to_blocks(inode->i_sb, num_clusters);
6971 num_buckets -= reflink_buckets;
6978 * Create the same xattr extent record in the new inode's xattr tree.
6980 static int ocfs2_reflink_xattr_rec(struct inode *inode,
6981 struct buffer_head *root_bh,
6987 int ret, credits = 0;
6989 struct ocfs2_reflink_xattr_tree_args *args =
6990 (struct ocfs2_reflink_xattr_tree_args *)para;
6991 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
6992 struct ocfs2_alloc_context *meta_ac = NULL;
6993 struct ocfs2_alloc_context *data_ac = NULL;
6994 struct ocfs2_extent_tree et;
6996 trace_ocfs2_reflink_xattr_rec((unsigned long long)blkno, len);
6998 ocfs2_init_xattr_tree_extent_tree(&et,
6999 INODE_CACHE(args->reflink->new_inode),
7002 ret = ocfs2_lock_reflink_xattr_rec_allocators(args, &et, blkno,
7004 &meta_ac, &data_ac);
7010 handle = ocfs2_start_trans(osb, credits);
7011 if (IS_ERR(handle)) {
7012 ret = PTR_ERR(handle);
7017 ret = ocfs2_reflink_xattr_buckets(handle, inode, args, &et,
7023 ocfs2_commit_trans(osb, handle);
7027 ocfs2_free_alloc_context(meta_ac);
7029 ocfs2_free_alloc_context(data_ac);
7034 * Create reflinked xattr buckets.
7035 * We will add bucket one by one, and refcount all the xattrs in the bucket
7036 * if they are stored outside.
7038 static int ocfs2_reflink_xattr_tree(struct ocfs2_xattr_reflink *args,
7039 struct buffer_head *blk_bh,
7040 struct buffer_head *new_blk_bh)
7043 struct ocfs2_reflink_xattr_tree_args para;
7045 memset(¶, 0, sizeof(para));
7046 para.reflink = args;
7047 para.old_blk_bh = blk_bh;
7048 para.new_blk_bh = new_blk_bh;
7050 para.old_bucket = ocfs2_xattr_bucket_new(args->old_inode);
7051 if (!para.old_bucket) {
7052 mlog_errno(-ENOMEM);
7056 para.new_bucket = ocfs2_xattr_bucket_new(args->new_inode);
7057 if (!para.new_bucket) {
7063 ret = ocfs2_iterate_xattr_index_block(args->old_inode, blk_bh,
7064 ocfs2_reflink_xattr_rec,
7070 ocfs2_xattr_bucket_free(para.old_bucket);
7071 ocfs2_xattr_bucket_free(para.new_bucket);
7075 static int ocfs2_reflink_xattr_in_block(struct ocfs2_xattr_reflink *args,
7076 struct buffer_head *blk_bh)
7078 int ret, indexed = 0;
7079 struct buffer_head *new_blk_bh = NULL;
7080 struct ocfs2_xattr_block *xb =
7081 (struct ocfs2_xattr_block *)blk_bh->b_data;
7084 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)
7087 ret = ocfs2_create_empty_xattr_block(args->new_inode, args->new_bh,
7088 &new_blk_bh, indexed);
7095 ret = ocfs2_reflink_xattr_block(args, blk_bh, new_blk_bh);
7097 ret = ocfs2_reflink_xattr_tree(args, blk_bh, new_blk_bh);
7106 static int ocfs2_reflink_xattr_no_security(struct ocfs2_xattr_entry *xe)
7108 int type = ocfs2_xattr_get_type(xe);
7110 return type != OCFS2_XATTR_INDEX_SECURITY &&
7111 type != OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS &&
7112 type != OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT;
7115 int ocfs2_reflink_xattrs(struct inode *old_inode,
7116 struct buffer_head *old_bh,
7117 struct inode *new_inode,
7118 struct buffer_head *new_bh,
7119 bool preserve_security)
7122 struct ocfs2_xattr_reflink args;
7123 struct ocfs2_inode_info *oi = OCFS2_I(old_inode);
7124 struct ocfs2_dinode *di = (struct ocfs2_dinode *)old_bh->b_data;
7125 struct buffer_head *blk_bh = NULL;
7126 struct ocfs2_cached_dealloc_ctxt dealloc;
7127 struct ocfs2_refcount_tree *ref_tree;
7128 struct buffer_head *ref_root_bh = NULL;
7130 ret = ocfs2_lock_refcount_tree(OCFS2_SB(old_inode->i_sb),
7131 le64_to_cpu(di->i_refcount_loc),
7132 1, &ref_tree, &ref_root_bh);
7138 ocfs2_init_dealloc_ctxt(&dealloc);
7140 args.old_inode = old_inode;
7141 args.new_inode = new_inode;
7142 args.old_bh = old_bh;
7143 args.new_bh = new_bh;
7144 args.ref_ci = &ref_tree->rf_ci;
7145 args.ref_root_bh = ref_root_bh;
7146 args.dealloc = &dealloc;
7147 if (preserve_security)
7148 args.xattr_reflinked = NULL;
7150 args.xattr_reflinked = ocfs2_reflink_xattr_no_security;
7152 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
7153 ret = ocfs2_reflink_xattr_inline(&args);
7160 if (!di->i_xattr_loc)
7163 ret = ocfs2_read_xattr_block(old_inode, le64_to_cpu(di->i_xattr_loc),
7170 ret = ocfs2_reflink_xattr_in_block(&args, blk_bh);
7177 ocfs2_unlock_refcount_tree(OCFS2_SB(old_inode->i_sb),
7179 brelse(ref_root_bh);
7181 if (ocfs2_dealloc_has_cluster(&dealloc)) {
7182 ocfs2_schedule_truncate_log_flush(OCFS2_SB(old_inode->i_sb), 1);
7183 ocfs2_run_deallocs(OCFS2_SB(old_inode->i_sb), &dealloc);
7191 * Initialize security and acl for a already created inode.
7192 * Used for reflink a non-preserve-security file.
7194 * It uses common api like ocfs2_xattr_set, so the caller
7195 * must not hold any lock expect i_mutex.
7197 int ocfs2_init_security_and_acl(struct inode *dir,
7198 struct inode *inode,
7199 const struct qstr *qstr)
7202 struct buffer_head *dir_bh = NULL;
7204 ret = ocfs2_init_security_get(inode, dir, qstr, NULL);
7210 ret = ocfs2_inode_lock(dir, &dir_bh, 0);
7215 ret = ocfs2_init_acl(NULL, inode, dir, NULL, dir_bh, NULL, NULL);
7219 ocfs2_inode_unlock(dir, 0);
7225 * 'security' attributes support
7227 static size_t ocfs2_xattr_security_list(const struct xattr_handler *handler,
7228 struct dentry *dentry, char *list,
7229 size_t list_size, const char *name,
7232 const size_t prefix_len = XATTR_SECURITY_PREFIX_LEN;
7233 const size_t total_len = prefix_len + name_len + 1;
7235 if (list && total_len <= list_size) {
7236 memcpy(list, XATTR_SECURITY_PREFIX, prefix_len);
7237 memcpy(list + prefix_len, name, name_len);
7238 list[prefix_len + name_len] = '\0';
7243 static int ocfs2_xattr_security_get(const struct xattr_handler *handler,
7244 struct dentry *dentry, const char *name,
7245 void *buffer, size_t size)
7247 if (strcmp(name, "") == 0)
7249 return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY,
7250 name, buffer, size);
7253 static int ocfs2_xattr_security_set(const struct xattr_handler *handler,
7254 struct dentry *dentry, const char *name,
7255 const void *value, size_t size, int flags)
7257 if (strcmp(name, "") == 0)
7260 return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY,
7261 name, value, size, flags);
7264 static int ocfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
7267 const struct xattr *xattr;
7270 for (xattr = xattr_array; xattr->name != NULL; xattr++) {
7271 err = ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY,
7272 xattr->name, xattr->value,
7273 xattr->value_len, XATTR_CREATE);
7280 int ocfs2_init_security_get(struct inode *inode,
7282 const struct qstr *qstr,
7283 struct ocfs2_security_xattr_info *si)
7285 /* check whether ocfs2 support feature xattr */
7286 if (!ocfs2_supports_xattr(OCFS2_SB(dir->i_sb)))
7289 return security_old_inode_init_security(inode, dir, qstr,
7290 &si->name, &si->value,
7293 return security_inode_init_security(inode, dir, qstr,
7294 &ocfs2_initxattrs, NULL);
7297 int ocfs2_init_security_set(handle_t *handle,
7298 struct inode *inode,
7299 struct buffer_head *di_bh,
7300 struct ocfs2_security_xattr_info *si,
7301 struct ocfs2_alloc_context *xattr_ac,
7302 struct ocfs2_alloc_context *data_ac)
7304 return ocfs2_xattr_set_handle(handle, inode, di_bh,
7305 OCFS2_XATTR_INDEX_SECURITY,
7306 si->name, si->value, si->value_len, 0,
7310 const struct xattr_handler ocfs2_xattr_security_handler = {
7311 .prefix = XATTR_SECURITY_PREFIX,
7312 .list = ocfs2_xattr_security_list,
7313 .get = ocfs2_xattr_security_get,
7314 .set = ocfs2_xattr_security_set,
7318 * 'trusted' attributes support
7320 static size_t ocfs2_xattr_trusted_list(const struct xattr_handler *handler,
7321 struct dentry *dentry, char *list,
7322 size_t list_size, const char *name,
7325 const size_t prefix_len = XATTR_TRUSTED_PREFIX_LEN;
7326 const size_t total_len = prefix_len + name_len + 1;
7328 if (!capable(CAP_SYS_ADMIN))
7331 if (list && total_len <= list_size) {
7332 memcpy(list, XATTR_TRUSTED_PREFIX, prefix_len);
7333 memcpy(list + prefix_len, name, name_len);
7334 list[prefix_len + name_len] = '\0';
7339 static int ocfs2_xattr_trusted_get(const struct xattr_handler *handler,
7340 struct dentry *dentry, const char *name,
7341 void *buffer, size_t size)
7343 if (strcmp(name, "") == 0)
7345 return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED,
7346 name, buffer, size);
7349 static int ocfs2_xattr_trusted_set(const struct xattr_handler *handler,
7350 struct dentry *dentry, const char *name,
7351 const void *value, size_t size, int flags)
7353 if (strcmp(name, "") == 0)
7356 return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED,
7357 name, value, size, flags);
7360 const struct xattr_handler ocfs2_xattr_trusted_handler = {
7361 .prefix = XATTR_TRUSTED_PREFIX,
7362 .list = ocfs2_xattr_trusted_list,
7363 .get = ocfs2_xattr_trusted_get,
7364 .set = ocfs2_xattr_trusted_set,
7368 * 'user' attributes support
7370 static size_t ocfs2_xattr_user_list(const struct xattr_handler *handler,
7371 struct dentry *dentry, char *list,
7372 size_t list_size, const char *name,
7375 const size_t prefix_len = XATTR_USER_PREFIX_LEN;
7376 const size_t total_len = prefix_len + name_len + 1;
7377 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
7379 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
7382 if (list && total_len <= list_size) {
7383 memcpy(list, XATTR_USER_PREFIX, prefix_len);
7384 memcpy(list + prefix_len, name, name_len);
7385 list[prefix_len + name_len] = '\0';
7390 static int ocfs2_xattr_user_get(const struct xattr_handler *handler,
7391 struct dentry *dentry, const char *name,
7392 void *buffer, size_t size)
7394 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
7396 if (strcmp(name, "") == 0)
7398 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
7400 return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_USER, name,
7404 static int ocfs2_xattr_user_set(const struct xattr_handler *handler,
7405 struct dentry *dentry, const char *name,
7406 const void *value, size_t size, int flags)
7408 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
7410 if (strcmp(name, "") == 0)
7412 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
7415 return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_USER,
7416 name, value, size, flags);
7419 const struct xattr_handler ocfs2_xattr_user_handler = {
7420 .prefix = XATTR_USER_PREFIX,
7421 .list = ocfs2_xattr_user_list,
7422 .get = ocfs2_xattr_user_get,
7423 .set = ocfs2_xattr_user_set,