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 #define MLOG_MASK_PREFIX ML_XATTR
41 #include <cluster/masklog.h>
45 #include "blockcheck.h"
55 #include "buffer_head_io.h"
58 #include "refcounttree.h"
60 struct ocfs2_xattr_def_value_root
{
61 struct ocfs2_xattr_value_root xv
;
62 struct ocfs2_extent_rec er
;
65 struct ocfs2_xattr_bucket
{
66 /* The inode these xattrs are associated with */
67 struct inode
*bu_inode
;
69 /* The actual buffers that make up the bucket */
70 struct buffer_head
*bu_bhs
[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET
];
72 /* How many blocks make up one bucket for this filesystem */
76 struct ocfs2_xattr_set_ctxt
{
78 struct ocfs2_alloc_context
*meta_ac
;
79 struct ocfs2_alloc_context
*data_ac
;
80 struct ocfs2_cached_dealloc_ctxt dealloc
;
83 #define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root))
84 #define OCFS2_XATTR_INLINE_SIZE 80
85 #define OCFS2_XATTR_HEADER_GAP 4
86 #define OCFS2_XATTR_FREE_IN_IBODY (OCFS2_MIN_XATTR_INLINE_SIZE \
87 - sizeof(struct ocfs2_xattr_header) \
88 - OCFS2_XATTR_HEADER_GAP)
89 #define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \
90 - sizeof(struct ocfs2_xattr_block) \
91 - sizeof(struct ocfs2_xattr_header) \
92 - OCFS2_XATTR_HEADER_GAP)
94 static struct ocfs2_xattr_def_value_root def_xv
= {
95 .xv
.xr_list
.l_count
= cpu_to_le16(1),
98 struct xattr_handler
*ocfs2_xattr_handlers
[] = {
99 &ocfs2_xattr_user_handler
,
100 #ifdef CONFIG_OCFS2_FS_POSIX_ACL
101 &ocfs2_xattr_acl_access_handler
,
102 &ocfs2_xattr_acl_default_handler
,
104 &ocfs2_xattr_trusted_handler
,
105 &ocfs2_xattr_security_handler
,
109 static struct xattr_handler
*ocfs2_xattr_handler_map
[OCFS2_XATTR_MAX
] = {
110 [OCFS2_XATTR_INDEX_USER
] = &ocfs2_xattr_user_handler
,
111 #ifdef CONFIG_OCFS2_FS_POSIX_ACL
112 [OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS
]
113 = &ocfs2_xattr_acl_access_handler
,
114 [OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT
]
115 = &ocfs2_xattr_acl_default_handler
,
117 [OCFS2_XATTR_INDEX_TRUSTED
] = &ocfs2_xattr_trusted_handler
,
118 [OCFS2_XATTR_INDEX_SECURITY
] = &ocfs2_xattr_security_handler
,
121 struct ocfs2_xattr_info
{
128 struct ocfs2_xattr_search
{
129 struct buffer_head
*inode_bh
;
131 * xattr_bh point to the block buffer head which has extended attribute
132 * when extended attribute in inode, xattr_bh is equal to inode_bh.
134 struct buffer_head
*xattr_bh
;
135 struct ocfs2_xattr_header
*header
;
136 struct ocfs2_xattr_bucket
*bucket
;
139 struct ocfs2_xattr_entry
*here
;
143 static int ocfs2_xattr_bucket_get_name_value(struct super_block
*sb
,
144 struct ocfs2_xattr_header
*xh
,
149 static int ocfs2_xattr_block_find(struct inode
*inode
,
152 struct ocfs2_xattr_search
*xs
);
153 static int ocfs2_xattr_index_block_find(struct inode
*inode
,
154 struct buffer_head
*root_bh
,
157 struct ocfs2_xattr_search
*xs
);
159 static int ocfs2_xattr_tree_list_index_block(struct inode
*inode
,
160 struct buffer_head
*blk_bh
,
164 static int ocfs2_xattr_create_index_block(struct inode
*inode
,
165 struct ocfs2_xattr_search
*xs
,
166 struct ocfs2_xattr_set_ctxt
*ctxt
);
168 static int ocfs2_xattr_set_entry_index_block(struct inode
*inode
,
169 struct ocfs2_xattr_info
*xi
,
170 struct ocfs2_xattr_search
*xs
,
171 struct ocfs2_xattr_set_ctxt
*ctxt
);
173 typedef int (xattr_tree_rec_func
)(struct inode
*inode
,
174 struct buffer_head
*root_bh
,
175 u64 blkno
, u32 cpos
, u32 len
, void *para
);
176 static int ocfs2_iterate_xattr_index_block(struct inode
*inode
,
177 struct buffer_head
*root_bh
,
178 xattr_tree_rec_func
*rec_func
,
180 static int ocfs2_delete_xattr_in_bucket(struct inode
*inode
,
181 struct ocfs2_xattr_bucket
*bucket
,
183 static int ocfs2_rm_xattr_cluster(struct inode
*inode
,
184 struct buffer_head
*root_bh
,
190 static int ocfs2_mv_xattr_buckets(struct inode
*inode
, handle_t
*handle
,
191 u64 src_blk
, u64 last_blk
, u64 to_blk
,
192 unsigned int start_bucket
,
194 static int ocfs2_prepare_refcount_xattr(struct inode
*inode
,
195 struct ocfs2_dinode
*di
,
196 struct ocfs2_xattr_info
*xi
,
197 struct ocfs2_xattr_search
*xis
,
198 struct ocfs2_xattr_search
*xbs
,
199 struct ocfs2_refcount_tree
**ref_tree
,
203 static inline u16
ocfs2_xattr_buckets_per_cluster(struct ocfs2_super
*osb
)
205 return (1 << osb
->s_clustersize_bits
) / OCFS2_XATTR_BUCKET_SIZE
;
208 static inline u16
ocfs2_blocks_per_xattr_bucket(struct super_block
*sb
)
210 return OCFS2_XATTR_BUCKET_SIZE
/ (1 << sb
->s_blocksize_bits
);
213 static inline u16
ocfs2_xattr_max_xe_in_bucket(struct super_block
*sb
)
215 u16 len
= sb
->s_blocksize
-
216 offsetof(struct ocfs2_xattr_header
, xh_entries
);
218 return len
/ sizeof(struct ocfs2_xattr_entry
);
221 #define bucket_blkno(_b) ((_b)->bu_bhs[0]->b_blocknr)
222 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
223 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
225 static struct ocfs2_xattr_bucket
*ocfs2_xattr_bucket_new(struct inode
*inode
)
227 struct ocfs2_xattr_bucket
*bucket
;
228 int blks
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
230 BUG_ON(blks
> OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET
);
232 bucket
= kzalloc(sizeof(struct ocfs2_xattr_bucket
), GFP_NOFS
);
234 bucket
->bu_inode
= inode
;
235 bucket
->bu_blocks
= blks
;
241 static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket
*bucket
)
245 for (i
= 0; i
< bucket
->bu_blocks
; i
++) {
246 brelse(bucket
->bu_bhs
[i
]);
247 bucket
->bu_bhs
[i
] = NULL
;
251 static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket
*bucket
)
254 ocfs2_xattr_bucket_relse(bucket
);
255 bucket
->bu_inode
= NULL
;
261 * A bucket that has never been written to disk doesn't need to be
262 * read. We just need the buffer_heads. Don't call this for
263 * buckets that are already on disk. ocfs2_read_xattr_bucket() initializes
266 static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket
*bucket
,
271 for (i
= 0; i
< bucket
->bu_blocks
; i
++) {
272 bucket
->bu_bhs
[i
] = sb_getblk(bucket
->bu_inode
->i_sb
,
274 if (!bucket
->bu_bhs
[i
]) {
280 if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket
->bu_inode
),
282 ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket
->bu_inode
),
287 ocfs2_xattr_bucket_relse(bucket
);
291 /* Read the xattr bucket at xb_blkno */
292 static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket
*bucket
,
297 rc
= ocfs2_read_blocks(INODE_CACHE(bucket
->bu_inode
), xb_blkno
,
298 bucket
->bu_blocks
, bucket
->bu_bhs
, 0,
301 spin_lock(&OCFS2_SB(bucket
->bu_inode
->i_sb
)->osb_xattr_lock
);
302 rc
= ocfs2_validate_meta_ecc_bhs(bucket
->bu_inode
->i_sb
,
305 &bucket_xh(bucket
)->xh_check
);
306 spin_unlock(&OCFS2_SB(bucket
->bu_inode
->i_sb
)->osb_xattr_lock
);
312 ocfs2_xattr_bucket_relse(bucket
);
316 static int ocfs2_xattr_bucket_journal_access(handle_t
*handle
,
317 struct ocfs2_xattr_bucket
*bucket
,
322 for (i
= 0; i
< bucket
->bu_blocks
; i
++) {
323 rc
= ocfs2_journal_access(handle
,
324 INODE_CACHE(bucket
->bu_inode
),
325 bucket
->bu_bhs
[i
], type
);
335 static void ocfs2_xattr_bucket_journal_dirty(handle_t
*handle
,
336 struct ocfs2_xattr_bucket
*bucket
)
340 spin_lock(&OCFS2_SB(bucket
->bu_inode
->i_sb
)->osb_xattr_lock
);
341 ocfs2_compute_meta_ecc_bhs(bucket
->bu_inode
->i_sb
,
342 bucket
->bu_bhs
, bucket
->bu_blocks
,
343 &bucket_xh(bucket
)->xh_check
);
344 spin_unlock(&OCFS2_SB(bucket
->bu_inode
->i_sb
)->osb_xattr_lock
);
346 for (i
= 0; i
< bucket
->bu_blocks
; i
++)
347 ocfs2_journal_dirty(handle
, bucket
->bu_bhs
[i
]);
350 static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket
*dest
,
351 struct ocfs2_xattr_bucket
*src
)
354 int blocksize
= src
->bu_inode
->i_sb
->s_blocksize
;
356 BUG_ON(dest
->bu_blocks
!= src
->bu_blocks
);
357 BUG_ON(dest
->bu_inode
!= src
->bu_inode
);
359 for (i
= 0; i
< src
->bu_blocks
; i
++) {
360 memcpy(bucket_block(dest
, i
), bucket_block(src
, i
),
365 static int ocfs2_validate_xattr_block(struct super_block
*sb
,
366 struct buffer_head
*bh
)
369 struct ocfs2_xattr_block
*xb
=
370 (struct ocfs2_xattr_block
*)bh
->b_data
;
372 mlog(0, "Validating xattr block %llu\n",
373 (unsigned long long)bh
->b_blocknr
);
375 BUG_ON(!buffer_uptodate(bh
));
378 * If the ecc fails, we return the error but otherwise
379 * leave the filesystem running. We know any error is
380 * local to this block.
382 rc
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &xb
->xb_check
);
387 * Errors after here are fatal
390 if (!OCFS2_IS_VALID_XATTR_BLOCK(xb
)) {
392 "Extended attribute block #%llu has bad "
394 (unsigned long long)bh
->b_blocknr
, 7,
399 if (le64_to_cpu(xb
->xb_blkno
) != bh
->b_blocknr
) {
401 "Extended attribute block #%llu has an "
402 "invalid xb_blkno of %llu",
403 (unsigned long long)bh
->b_blocknr
,
404 (unsigned long long)le64_to_cpu(xb
->xb_blkno
));
408 if (le32_to_cpu(xb
->xb_fs_generation
) != OCFS2_SB(sb
)->fs_generation
) {
410 "Extended attribute block #%llu has an invalid "
411 "xb_fs_generation of #%u",
412 (unsigned long long)bh
->b_blocknr
,
413 le32_to_cpu(xb
->xb_fs_generation
));
420 static int ocfs2_read_xattr_block(struct inode
*inode
, u64 xb_blkno
,
421 struct buffer_head
**bh
)
424 struct buffer_head
*tmp
= *bh
;
426 rc
= ocfs2_read_block(INODE_CACHE(inode
), xb_blkno
, &tmp
,
427 ocfs2_validate_xattr_block
);
429 /* If ocfs2_read_block() got us a new bh, pass it up. */
436 static inline const char *ocfs2_xattr_prefix(int name_index
)
438 struct xattr_handler
*handler
= NULL
;
440 if (name_index
> 0 && name_index
< OCFS2_XATTR_MAX
)
441 handler
= ocfs2_xattr_handler_map
[name_index
];
443 return handler
? handler
->prefix
: NULL
;
446 static u32
ocfs2_xattr_name_hash(struct inode
*inode
,
450 /* Get hash value of uuid from super block */
451 u32 hash
= OCFS2_SB(inode
->i_sb
)->uuid_hash
;
454 /* hash extended attribute name */
455 for (i
= 0; i
< name_len
; i
++) {
456 hash
= (hash
<< OCFS2_HASH_SHIFT
) ^
457 (hash
>> (8*sizeof(hash
) - OCFS2_HASH_SHIFT
)) ^
465 * ocfs2_xattr_hash_entry()
467 * Compute the hash of an extended attribute.
469 static void ocfs2_xattr_hash_entry(struct inode
*inode
,
470 struct ocfs2_xattr_header
*header
,
471 struct ocfs2_xattr_entry
*entry
)
474 char *name
= (char *)header
+ le16_to_cpu(entry
->xe_name_offset
);
476 hash
= ocfs2_xattr_name_hash(inode
, name
, entry
->xe_name_len
);
477 entry
->xe_name_hash
= cpu_to_le32(hash
);
482 static int ocfs2_xattr_entry_real_size(int name_len
, size_t value_len
)
486 if (value_len
<= OCFS2_XATTR_INLINE_SIZE
)
487 size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_SIZE(value_len
);
489 size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
490 size
+= sizeof(struct ocfs2_xattr_entry
);
495 int ocfs2_calc_security_init(struct inode
*dir
,
496 struct ocfs2_security_xattr_info
*si
,
499 struct ocfs2_alloc_context
**xattr_ac
)
502 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
503 int s_size
= ocfs2_xattr_entry_real_size(strlen(si
->name
),
507 * The max space of security xattr taken inline is
508 * 256(name) + 80(value) + 16(entry) = 352 bytes,
509 * So reserve one metadata block for it is ok.
511 if (dir
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
||
512 s_size
> OCFS2_XATTR_FREE_IN_IBODY
) {
513 ret
= ocfs2_reserve_new_metadata_blocks(osb
, 1, xattr_ac
);
518 *xattr_credits
+= OCFS2_XATTR_BLOCK_CREATE_CREDITS
;
521 /* reserve clusters for xattr value which will be set in B tree*/
522 if (si
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
523 int new_clusters
= ocfs2_clusters_for_bytes(dir
->i_sb
,
526 *xattr_credits
+= ocfs2_clusters_to_blocks(dir
->i_sb
,
528 *want_clusters
+= new_clusters
;
533 int ocfs2_calc_xattr_init(struct inode
*dir
,
534 struct buffer_head
*dir_bh
,
536 struct ocfs2_security_xattr_info
*si
,
542 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
543 int s_size
= 0, a_size
= 0, acl_len
= 0, new_clusters
;
546 s_size
= ocfs2_xattr_entry_real_size(strlen(si
->name
),
549 if (osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
) {
550 acl_len
= ocfs2_xattr_get_nolock(dir
, dir_bh
,
551 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT
,
554 a_size
= ocfs2_xattr_entry_real_size(0, acl_len
);
557 } else if (acl_len
!= 0 && acl_len
!= -ENODATA
) {
563 if (!(s_size
+ a_size
))
567 * The max space of security xattr taken inline is
568 * 256(name) + 80(value) + 16(entry) = 352 bytes,
569 * The max space of acl xattr taken inline is
570 * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
571 * when blocksize = 512, may reserve one more cluser for
572 * xattr bucket, otherwise reserve one metadata block
574 * If this is a new directory with inline data,
575 * we choose to reserve the entire inline area for
576 * directory contents and force an external xattr block.
578 if (dir
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
||
579 (S_ISDIR(mode
) && ocfs2_supports_inline_data(osb
)) ||
580 (s_size
+ a_size
) > OCFS2_XATTR_FREE_IN_IBODY
) {
581 *want_meta
= *want_meta
+ 1;
582 *xattr_credits
+= OCFS2_XATTR_BLOCK_CREATE_CREDITS
;
585 if (dir
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
&&
586 (s_size
+ a_size
) > OCFS2_XATTR_FREE_IN_BLOCK(dir
)) {
588 *xattr_credits
+= ocfs2_blocks_per_xattr_bucket(dir
->i_sb
);
592 * reserve credits and clusters for xattrs which has large value
593 * and have to be set outside
595 if (si
->enable
&& si
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
596 new_clusters
= ocfs2_clusters_for_bytes(dir
->i_sb
,
598 *xattr_credits
+= ocfs2_clusters_to_blocks(dir
->i_sb
,
600 *want_clusters
+= new_clusters
;
602 if (osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
&&
603 acl_len
> OCFS2_XATTR_INLINE_SIZE
) {
604 /* for directory, it has DEFAULT and ACCESS two types of acls */
605 new_clusters
= (S_ISDIR(mode
) ? 2 : 1) *
606 ocfs2_clusters_for_bytes(dir
->i_sb
, acl_len
);
607 *xattr_credits
+= ocfs2_clusters_to_blocks(dir
->i_sb
,
609 *want_clusters
+= new_clusters
;
615 static int ocfs2_xattr_extend_allocation(struct inode
*inode
,
617 struct ocfs2_xattr_value_buf
*vb
,
618 struct ocfs2_xattr_set_ctxt
*ctxt
)
621 handle_t
*handle
= ctxt
->handle
;
622 enum ocfs2_alloc_restarted why
;
623 u32 prev_clusters
, logical_start
= le32_to_cpu(vb
->vb_xv
->xr_clusters
);
624 struct ocfs2_extent_tree et
;
626 mlog(0, "(clusters_to_add for xattr= %u)\n", clusters_to_add
);
628 ocfs2_init_xattr_value_extent_tree(&et
, INODE_CACHE(inode
), vb
);
630 status
= vb
->vb_access(handle
, INODE_CACHE(inode
), vb
->vb_bh
,
631 OCFS2_JOURNAL_ACCESS_WRITE
);
637 prev_clusters
= le32_to_cpu(vb
->vb_xv
->xr_clusters
);
638 status
= ocfs2_add_clusters_in_btree(handle
,
651 status
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
657 clusters_to_add
-= le32_to_cpu(vb
->vb_xv
->xr_clusters
) - prev_clusters
;
660 * We should have already allocated enough space before the transaction,
661 * so no need to restart.
663 BUG_ON(why
!= RESTART_NONE
|| clusters_to_add
);
670 static int __ocfs2_remove_xattr_range(struct inode
*inode
,
671 struct ocfs2_xattr_value_buf
*vb
,
672 u32 cpos
, u32 phys_cpos
, u32 len
,
673 unsigned int ext_flags
,
674 struct ocfs2_xattr_set_ctxt
*ctxt
)
677 u64 phys_blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, phys_cpos
);
678 handle_t
*handle
= ctxt
->handle
;
679 struct ocfs2_extent_tree et
;
681 ocfs2_init_xattr_value_extent_tree(&et
, INODE_CACHE(inode
), vb
);
683 ret
= vb
->vb_access(handle
, INODE_CACHE(inode
), vb
->vb_bh
,
684 OCFS2_JOURNAL_ACCESS_WRITE
);
690 ret
= ocfs2_remove_extent(handle
, &et
, cpos
, len
, ctxt
->meta_ac
,
697 le32_add_cpu(&vb
->vb_xv
->xr_clusters
, -len
);
699 ret
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
705 if (ext_flags
& OCFS2_EXT_REFCOUNTED
)
706 ret
= ocfs2_decrease_refcount(inode
, handle
,
707 ocfs2_blocks_to_clusters(inode
->i_sb
,
709 len
, ctxt
->meta_ac
, &ctxt
->dealloc
, 1);
711 ret
= ocfs2_cache_cluster_dealloc(&ctxt
->dealloc
,
720 static int ocfs2_xattr_shrink_size(struct inode
*inode
,
723 struct ocfs2_xattr_value_buf
*vb
,
724 struct ocfs2_xattr_set_ctxt
*ctxt
)
727 unsigned int ext_flags
;
728 u32 trunc_len
, cpos
, phys_cpos
, alloc_size
;
731 if (old_clusters
<= new_clusters
)
735 trunc_len
= old_clusters
- new_clusters
;
737 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &phys_cpos
,
739 &vb
->vb_xv
->xr_list
, &ext_flags
);
745 if (alloc_size
> trunc_len
)
746 alloc_size
= trunc_len
;
748 ret
= __ocfs2_remove_xattr_range(inode
, vb
, cpos
,
749 phys_cpos
, alloc_size
,
756 block
= ocfs2_clusters_to_blocks(inode
->i_sb
, phys_cpos
);
757 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode
),
760 trunc_len
-= alloc_size
;
767 static int ocfs2_xattr_value_truncate(struct inode
*inode
,
768 struct ocfs2_xattr_value_buf
*vb
,
770 struct ocfs2_xattr_set_ctxt
*ctxt
)
773 u32 new_clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
, len
);
774 u32 old_clusters
= le32_to_cpu(vb
->vb_xv
->xr_clusters
);
776 if (new_clusters
== old_clusters
)
779 if (new_clusters
> old_clusters
)
780 ret
= ocfs2_xattr_extend_allocation(inode
,
781 new_clusters
- old_clusters
,
784 ret
= ocfs2_xattr_shrink_size(inode
,
785 old_clusters
, new_clusters
,
791 static int ocfs2_xattr_list_entry(char *buffer
, size_t size
,
792 size_t *result
, const char *prefix
,
793 const char *name
, int name_len
)
795 char *p
= buffer
+ *result
;
796 int prefix_len
= strlen(prefix
);
797 int total_len
= prefix_len
+ name_len
+ 1;
799 *result
+= total_len
;
801 /* we are just looking for how big our buffer needs to be */
808 memcpy(p
, prefix
, prefix_len
);
809 memcpy(p
+ prefix_len
, name
, name_len
);
810 p
[prefix_len
+ name_len
] = '\0';
815 static int ocfs2_xattr_list_entries(struct inode
*inode
,
816 struct ocfs2_xattr_header
*header
,
817 char *buffer
, size_t buffer_size
)
821 const char *prefix
, *name
;
823 for (i
= 0 ; i
< le16_to_cpu(header
->xh_count
); i
++) {
824 struct ocfs2_xattr_entry
*entry
= &header
->xh_entries
[i
];
825 type
= ocfs2_xattr_get_type(entry
);
826 prefix
= ocfs2_xattr_prefix(type
);
829 name
= (const char *)header
+
830 le16_to_cpu(entry
->xe_name_offset
);
832 ret
= ocfs2_xattr_list_entry(buffer
, buffer_size
,
833 &result
, prefix
, name
,
843 static int ocfs2_xattr_ibody_list(struct inode
*inode
,
844 struct ocfs2_dinode
*di
,
848 struct ocfs2_xattr_header
*header
= NULL
;
849 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
852 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
))
855 header
= (struct ocfs2_xattr_header
*)
856 ((void *)di
+ inode
->i_sb
->s_blocksize
-
857 le16_to_cpu(di
->i_xattr_inline_size
));
859 ret
= ocfs2_xattr_list_entries(inode
, header
, buffer
, buffer_size
);
864 static int ocfs2_xattr_block_list(struct inode
*inode
,
865 struct ocfs2_dinode
*di
,
869 struct buffer_head
*blk_bh
= NULL
;
870 struct ocfs2_xattr_block
*xb
;
873 if (!di
->i_xattr_loc
)
876 ret
= ocfs2_read_xattr_block(inode
, le64_to_cpu(di
->i_xattr_loc
),
883 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
884 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
885 struct ocfs2_xattr_header
*header
= &xb
->xb_attrs
.xb_header
;
886 ret
= ocfs2_xattr_list_entries(inode
, header
,
887 buffer
, buffer_size
);
889 ret
= ocfs2_xattr_tree_list_index_block(inode
, blk_bh
,
890 buffer
, buffer_size
);
897 ssize_t
ocfs2_listxattr(struct dentry
*dentry
,
901 int ret
= 0, i_ret
= 0, b_ret
= 0;
902 struct buffer_head
*di_bh
= NULL
;
903 struct ocfs2_dinode
*di
= NULL
;
904 struct ocfs2_inode_info
*oi
= OCFS2_I(dentry
->d_inode
);
906 if (!ocfs2_supports_xattr(OCFS2_SB(dentry
->d_sb
)))
909 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
912 ret
= ocfs2_inode_lock(dentry
->d_inode
, &di_bh
, 0);
918 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
920 down_read(&oi
->ip_xattr_sem
);
921 i_ret
= ocfs2_xattr_ibody_list(dentry
->d_inode
, di
, buffer
, size
);
929 b_ret
= ocfs2_xattr_block_list(dentry
->d_inode
, di
,
934 up_read(&oi
->ip_xattr_sem
);
935 ocfs2_inode_unlock(dentry
->d_inode
, 0);
939 return i_ret
+ b_ret
;
942 static int ocfs2_xattr_find_entry(int name_index
,
944 struct ocfs2_xattr_search
*xs
)
946 struct ocfs2_xattr_entry
*entry
;
953 name_len
= strlen(name
);
955 for (i
= 0; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
956 cmp
= name_index
- ocfs2_xattr_get_type(entry
);
958 cmp
= name_len
- entry
->xe_name_len
;
960 cmp
= memcmp(name
, (xs
->base
+
961 le16_to_cpu(entry
->xe_name_offset
)),
969 return cmp
? -ENODATA
: 0;
972 static int ocfs2_xattr_get_value_outside(struct inode
*inode
,
973 struct ocfs2_xattr_value_root
*xv
,
977 u32 cpos
, p_cluster
, num_clusters
, bpc
, clusters
;
980 size_t cplen
, blocksize
;
981 struct buffer_head
*bh
= NULL
;
982 struct ocfs2_extent_list
*el
;
985 clusters
= le32_to_cpu(xv
->xr_clusters
);
986 bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
987 blocksize
= inode
->i_sb
->s_blocksize
;
990 while (cpos
< clusters
) {
991 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &p_cluster
,
992 &num_clusters
, el
, NULL
);
998 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, p_cluster
);
999 /* Copy ocfs2_xattr_value */
1000 for (i
= 0; i
< num_clusters
* bpc
; i
++, blkno
++) {
1001 ret
= ocfs2_read_block(INODE_CACHE(inode
), blkno
,
1008 cplen
= len
>= blocksize
? blocksize
: len
;
1009 memcpy(buffer
, bh
->b_data
, cplen
);
1018 cpos
+= num_clusters
;
1024 static int ocfs2_xattr_ibody_get(struct inode
*inode
,
1029 struct ocfs2_xattr_search
*xs
)
1031 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1032 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
1033 struct ocfs2_xattr_value_root
*xv
;
1037 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
))
1040 xs
->end
= (void *)di
+ inode
->i_sb
->s_blocksize
;
1041 xs
->header
= (struct ocfs2_xattr_header
*)
1042 (xs
->end
- le16_to_cpu(di
->i_xattr_inline_size
));
1043 xs
->base
= (void *)xs
->header
;
1044 xs
->here
= xs
->header
->xh_entries
;
1046 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
1049 size
= le64_to_cpu(xs
->here
->xe_value_size
);
1051 if (size
> buffer_size
)
1053 if (ocfs2_xattr_is_local(xs
->here
)) {
1054 memcpy(buffer
, (void *)xs
->base
+
1055 le16_to_cpu(xs
->here
->xe_name_offset
) +
1056 OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
), size
);
1058 xv
= (struct ocfs2_xattr_value_root
*)
1059 (xs
->base
+ le16_to_cpu(
1060 xs
->here
->xe_name_offset
) +
1061 OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
));
1062 ret
= ocfs2_xattr_get_value_outside(inode
, xv
,
1074 static int ocfs2_xattr_block_get(struct inode
*inode
,
1079 struct ocfs2_xattr_search
*xs
)
1081 struct ocfs2_xattr_block
*xb
;
1082 struct ocfs2_xattr_value_root
*xv
;
1084 int ret
= -ENODATA
, name_offset
, name_len
, i
;
1085 int uninitialized_var(block_off
);
1087 xs
->bucket
= ocfs2_xattr_bucket_new(inode
);
1094 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, xs
);
1100 if (xs
->not_found
) {
1105 xb
= (struct ocfs2_xattr_block
*)xs
->xattr_bh
->b_data
;
1106 size
= le64_to_cpu(xs
->here
->xe_value_size
);
1109 if (size
> buffer_size
)
1112 name_offset
= le16_to_cpu(xs
->here
->xe_name_offset
);
1113 name_len
= OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
);
1114 i
= xs
->here
- xs
->header
->xh_entries
;
1116 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
1117 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
1118 bucket_xh(xs
->bucket
),
1122 xs
->base
= bucket_block(xs
->bucket
, block_off
);
1124 if (ocfs2_xattr_is_local(xs
->here
)) {
1125 memcpy(buffer
, (void *)xs
->base
+
1126 name_offset
+ name_len
, size
);
1128 xv
= (struct ocfs2_xattr_value_root
*)
1129 (xs
->base
+ name_offset
+ name_len
);
1130 ret
= ocfs2_xattr_get_value_outside(inode
, xv
,
1140 ocfs2_xattr_bucket_free(xs
->bucket
);
1142 brelse(xs
->xattr_bh
);
1143 xs
->xattr_bh
= NULL
;
1147 int ocfs2_xattr_get_nolock(struct inode
*inode
,
1148 struct buffer_head
*di_bh
,
1155 struct ocfs2_dinode
*di
= NULL
;
1156 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1157 struct ocfs2_xattr_search xis
= {
1158 .not_found
= -ENODATA
,
1160 struct ocfs2_xattr_search xbs
= {
1161 .not_found
= -ENODATA
,
1164 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
1167 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
1170 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
1171 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1173 down_read(&oi
->ip_xattr_sem
);
1174 ret
= ocfs2_xattr_ibody_get(inode
, name_index
, name
, buffer
,
1176 if (ret
== -ENODATA
&& di
->i_xattr_loc
)
1177 ret
= ocfs2_xattr_block_get(inode
, name_index
, name
, buffer
,
1179 up_read(&oi
->ip_xattr_sem
);
1184 /* ocfs2_xattr_get()
1186 * Copy an extended attribute into the buffer provided.
1187 * Buffer is NULL to compute the size of buffer required.
1189 static int ocfs2_xattr_get(struct inode
*inode
,
1196 struct buffer_head
*di_bh
= NULL
;
1198 ret
= ocfs2_inode_lock(inode
, &di_bh
, 0);
1203 ret
= ocfs2_xattr_get_nolock(inode
, di_bh
, name_index
,
1204 name
, buffer
, buffer_size
);
1206 ocfs2_inode_unlock(inode
, 0);
1213 static int __ocfs2_xattr_set_value_outside(struct inode
*inode
,
1215 struct ocfs2_xattr_value_buf
*vb
,
1219 int ret
= 0, i
, cp_len
;
1220 u16 blocksize
= inode
->i_sb
->s_blocksize
;
1221 u32 p_cluster
, num_clusters
;
1222 u32 cpos
= 0, bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
1223 u32 clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
, value_len
);
1225 struct buffer_head
*bh
= NULL
;
1226 unsigned int ext_flags
;
1227 struct ocfs2_xattr_value_root
*xv
= vb
->vb_xv
;
1229 BUG_ON(clusters
> le32_to_cpu(xv
->xr_clusters
));
1231 while (cpos
< clusters
) {
1232 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &p_cluster
,
1233 &num_clusters
, &xv
->xr_list
,
1240 BUG_ON(ext_flags
& OCFS2_EXT_REFCOUNTED
);
1242 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, p_cluster
);
1244 for (i
= 0; i
< num_clusters
* bpc
; i
++, blkno
++) {
1245 ret
= ocfs2_read_block(INODE_CACHE(inode
), blkno
,
1252 ret
= ocfs2_journal_access(handle
,
1255 OCFS2_JOURNAL_ACCESS_WRITE
);
1261 cp_len
= value_len
> blocksize
? blocksize
: value_len
;
1262 memcpy(bh
->b_data
, value
, cp_len
);
1263 value_len
-= cp_len
;
1265 if (cp_len
< blocksize
)
1266 memset(bh
->b_data
+ cp_len
, 0,
1267 blocksize
- cp_len
);
1269 ret
= ocfs2_journal_dirty(handle
, bh
);
1278 * XXX: do we need to empty all the following
1279 * blocks in this cluster?
1284 cpos
+= num_clusters
;
1292 static int ocfs2_xattr_cleanup(struct inode
*inode
,
1294 struct ocfs2_xattr_info
*xi
,
1295 struct ocfs2_xattr_search
*xs
,
1296 struct ocfs2_xattr_value_buf
*vb
,
1300 size_t name_len
= strlen(xi
->name
);
1301 void *val
= xs
->base
+ offs
;
1302 size_t size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1304 ret
= vb
->vb_access(handle
, INODE_CACHE(inode
), vb
->vb_bh
,
1305 OCFS2_JOURNAL_ACCESS_WRITE
);
1310 /* Decrease xattr count */
1311 le16_add_cpu(&xs
->header
->xh_count
, -1);
1312 /* Remove the xattr entry and tree root which has already be set*/
1313 memset((void *)xs
->here
, 0, sizeof(struct ocfs2_xattr_entry
));
1314 memset(val
, 0, size
);
1316 ret
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
1323 static int ocfs2_xattr_update_entry(struct inode
*inode
,
1325 struct ocfs2_xattr_info
*xi
,
1326 struct ocfs2_xattr_search
*xs
,
1327 struct ocfs2_xattr_value_buf
*vb
,
1332 ret
= vb
->vb_access(handle
, INODE_CACHE(inode
), vb
->vb_bh
,
1333 OCFS2_JOURNAL_ACCESS_WRITE
);
1339 xs
->here
->xe_name_offset
= cpu_to_le16(offs
);
1340 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1341 if (xi
->value_len
<= OCFS2_XATTR_INLINE_SIZE
)
1342 ocfs2_xattr_set_local(xs
->here
, 1);
1344 ocfs2_xattr_set_local(xs
->here
, 0);
1345 ocfs2_xattr_hash_entry(inode
, xs
->header
, xs
->here
);
1347 ret
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
1355 * ocfs2_xattr_set_value_outside()
1357 * Set large size value in B tree.
1359 static int ocfs2_xattr_set_value_outside(struct inode
*inode
,
1360 struct ocfs2_xattr_info
*xi
,
1361 struct ocfs2_xattr_search
*xs
,
1362 struct ocfs2_xattr_set_ctxt
*ctxt
,
1363 struct ocfs2_xattr_value_buf
*vb
,
1366 size_t name_len
= strlen(xi
->name
);
1367 void *val
= xs
->base
+ offs
;
1368 struct ocfs2_xattr_value_root
*xv
= NULL
;
1369 size_t size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1372 memset(val
, 0, size
);
1373 memcpy(val
, xi
->name
, name_len
);
1374 xv
= (struct ocfs2_xattr_value_root
*)
1375 (val
+ OCFS2_XATTR_SIZE(name_len
));
1376 xv
->xr_clusters
= 0;
1377 xv
->xr_last_eb_blk
= 0;
1378 xv
->xr_list
.l_tree_depth
= 0;
1379 xv
->xr_list
.l_count
= cpu_to_le16(1);
1380 xv
->xr_list
.l_next_free_rec
= 0;
1383 ret
= ocfs2_xattr_value_truncate(inode
, vb
, xi
->value_len
, ctxt
);
1388 ret
= ocfs2_xattr_update_entry(inode
, ctxt
->handle
, xi
, xs
, vb
, offs
);
1393 ret
= __ocfs2_xattr_set_value_outside(inode
, ctxt
->handle
, vb
,
1394 xi
->value
, xi
->value_len
);
1402 * ocfs2_xattr_set_entry_local()
1404 * Set, replace or remove extended attribute in local.
1406 static void ocfs2_xattr_set_entry_local(struct inode
*inode
,
1407 struct ocfs2_xattr_info
*xi
,
1408 struct ocfs2_xattr_search
*xs
,
1409 struct ocfs2_xattr_entry
*last
,
1412 size_t name_len
= strlen(xi
->name
);
1415 if (xi
->value
&& xs
->not_found
) {
1416 /* Insert the new xattr entry. */
1417 le16_add_cpu(&xs
->header
->xh_count
, 1);
1418 ocfs2_xattr_set_type(last
, xi
->name_index
);
1419 ocfs2_xattr_set_local(last
, 1);
1420 last
->xe_name_len
= name_len
;
1426 first_val
= xs
->base
+ min_offs
;
1427 offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1428 val
= xs
->base
+ offs
;
1430 if (le64_to_cpu(xs
->here
->xe_value_size
) >
1431 OCFS2_XATTR_INLINE_SIZE
)
1432 size
= OCFS2_XATTR_SIZE(name_len
) +
1433 OCFS2_XATTR_ROOT_SIZE
;
1435 size
= OCFS2_XATTR_SIZE(name_len
) +
1436 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1438 if (xi
->value
&& size
== OCFS2_XATTR_SIZE(name_len
) +
1439 OCFS2_XATTR_SIZE(xi
->value_len
)) {
1440 /* The old and the new value have the
1441 same size. Just replace the value. */
1442 ocfs2_xattr_set_local(xs
->here
, 1);
1443 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1444 /* Clear value bytes. */
1445 memset(val
+ OCFS2_XATTR_SIZE(name_len
),
1447 OCFS2_XATTR_SIZE(xi
->value_len
));
1448 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
1453 /* Remove the old name+value. */
1454 memmove(first_val
+ size
, first_val
, val
- first_val
);
1455 memset(first_val
, 0, size
);
1456 xs
->here
->xe_name_hash
= 0;
1457 xs
->here
->xe_name_offset
= 0;
1458 ocfs2_xattr_set_local(xs
->here
, 1);
1459 xs
->here
->xe_value_size
= 0;
1463 /* Adjust all value offsets. */
1464 last
= xs
->header
->xh_entries
;
1465 for (i
= 0 ; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
1466 size_t o
= le16_to_cpu(last
->xe_name_offset
);
1469 last
->xe_name_offset
= cpu_to_le16(o
+ size
);
1474 /* Remove the old entry. */
1476 memmove(xs
->here
, xs
->here
+ 1,
1477 (void *)last
- (void *)xs
->here
);
1478 memset(last
, 0, sizeof(struct ocfs2_xattr_entry
));
1479 le16_add_cpu(&xs
->header
->xh_count
, -1);
1483 /* Insert the new name+value. */
1484 size_t size
= OCFS2_XATTR_SIZE(name_len
) +
1485 OCFS2_XATTR_SIZE(xi
->value_len
);
1486 void *val
= xs
->base
+ min_offs
- size
;
1488 xs
->here
->xe_name_offset
= cpu_to_le16(min_offs
- size
);
1489 memset(val
, 0, size
);
1490 memcpy(val
, xi
->name
, name_len
);
1491 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
1494 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1495 ocfs2_xattr_set_local(xs
->here
, 1);
1496 ocfs2_xattr_hash_entry(inode
, xs
->header
, xs
->here
);
1503 * ocfs2_xattr_set_entry()
1505 * Set extended attribute entry into inode or block.
1507 * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
1508 * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
1509 * then set value in B tree with set_value_outside().
1511 static int ocfs2_xattr_set_entry(struct inode
*inode
,
1512 struct ocfs2_xattr_info
*xi
,
1513 struct ocfs2_xattr_search
*xs
,
1514 struct ocfs2_xattr_set_ctxt
*ctxt
,
1517 struct ocfs2_xattr_entry
*last
;
1518 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1519 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
1520 size_t min_offs
= xs
->end
- xs
->base
, name_len
= strlen(xi
->name
);
1522 handle_t
*handle
= ctxt
->handle
;
1524 struct ocfs2_xattr_info xi_l
= {
1525 .name_index
= xi
->name_index
,
1528 .value_len
= xi
->value_len
,
1530 struct ocfs2_xattr_value_buf vb
= {
1531 .vb_bh
= xs
->xattr_bh
,
1532 .vb_access
= ocfs2_journal_access_di
,
1535 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1536 BUG_ON(xs
->xattr_bh
== xs
->inode_bh
);
1537 vb
.vb_access
= ocfs2_journal_access_xb
;
1539 BUG_ON(xs
->xattr_bh
!= xs
->inode_bh
);
1541 /* Compute min_offs, last and free space. */
1542 last
= xs
->header
->xh_entries
;
1544 for (i
= 0 ; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
1545 size_t offs
= le16_to_cpu(last
->xe_name_offset
);
1546 if (offs
< min_offs
)
1551 free
= min_offs
- ((void *)last
- xs
->base
) - OCFS2_XATTR_HEADER_GAP
;
1555 if (!xs
->not_found
) {
1557 if (ocfs2_xattr_is_local(xs
->here
))
1558 size
= OCFS2_XATTR_SIZE(name_len
) +
1559 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1561 size
= OCFS2_XATTR_SIZE(name_len
) +
1562 OCFS2_XATTR_ROOT_SIZE
;
1563 free
+= (size
+ sizeof(struct ocfs2_xattr_entry
));
1565 /* Check free space in inode or block */
1566 if (xi
->value
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1567 if (free
< sizeof(struct ocfs2_xattr_entry
) +
1568 OCFS2_XATTR_SIZE(name_len
) +
1569 OCFS2_XATTR_ROOT_SIZE
) {
1573 size_l
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1574 xi_l
.value
= (void *)&def_xv
;
1575 xi_l
.value_len
= OCFS2_XATTR_ROOT_SIZE
;
1576 } else if (xi
->value
) {
1577 if (free
< sizeof(struct ocfs2_xattr_entry
) +
1578 OCFS2_XATTR_SIZE(name_len
) +
1579 OCFS2_XATTR_SIZE(xi
->value_len
)) {
1585 if (!xs
->not_found
) {
1586 /* For existing extended attribute */
1587 size_t size
= OCFS2_XATTR_SIZE(name_len
) +
1588 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1589 size_t offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1590 void *val
= xs
->base
+ offs
;
1592 if (ocfs2_xattr_is_local(xs
->here
) && size
== size_l
) {
1593 /* Replace existing local xattr with tree root */
1594 ret
= ocfs2_xattr_set_value_outside(inode
, xi
, xs
,
1599 } else if (!ocfs2_xattr_is_local(xs
->here
)) {
1600 /* For existing xattr which has value outside */
1601 vb
.vb_xv
= (struct ocfs2_xattr_value_root
*)
1602 (val
+ OCFS2_XATTR_SIZE(name_len
));
1604 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1606 * If new value need set outside also,
1607 * first truncate old value to new value,
1608 * then set new value with set_value_outside().
1610 ret
= ocfs2_xattr_value_truncate(inode
,
1619 ret
= ocfs2_xattr_update_entry(inode
,
1630 ret
= __ocfs2_xattr_set_value_outside(inode
,
1640 * If new value need set in local,
1641 * just trucate old value to zero.
1643 ret
= ocfs2_xattr_value_truncate(inode
,
1653 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), xs
->inode_bh
,
1654 OCFS2_JOURNAL_ACCESS_WRITE
);
1660 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1661 ret
= vb
.vb_access(handle
, INODE_CACHE(inode
), vb
.vb_bh
,
1662 OCFS2_JOURNAL_ACCESS_WRITE
);
1670 * Set value in local, include set tree root in local.
1671 * This is the first step for value size >INLINE_SIZE.
1673 ocfs2_xattr_set_entry_local(inode
, &xi_l
, xs
, last
, min_offs
);
1675 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1676 ret
= ocfs2_journal_dirty(handle
, xs
->xattr_bh
);
1683 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) &&
1684 (flag
& OCFS2_INLINE_XATTR_FL
)) {
1685 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1686 unsigned int xattrsize
= osb
->s_xattr_inline_size
;
1689 * Adjust extent record count or inline data size
1690 * to reserve space for extended attribute.
1692 if (oi
->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
1693 struct ocfs2_inline_data
*idata
= &di
->id2
.i_data
;
1694 le16_add_cpu(&idata
->id_count
, -xattrsize
);
1695 } else if (!(ocfs2_inode_is_fast_symlink(inode
))) {
1696 struct ocfs2_extent_list
*el
= &di
->id2
.i_list
;
1697 le16_add_cpu(&el
->l_count
, -(xattrsize
/
1698 sizeof(struct ocfs2_extent_rec
)));
1700 di
->i_xattr_inline_size
= cpu_to_le16(xattrsize
);
1702 /* Update xattr flag */
1703 spin_lock(&oi
->ip_lock
);
1704 oi
->ip_dyn_features
|= flag
;
1705 di
->i_dyn_features
= cpu_to_le16(oi
->ip_dyn_features
);
1706 spin_unlock(&oi
->ip_lock
);
1708 ret
= ocfs2_journal_dirty(handle
, xs
->inode_bh
);
1712 if (!ret
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1714 * Set value outside in B tree.
1715 * This is the second step for value size > INLINE_SIZE.
1717 size_t offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1718 ret
= ocfs2_xattr_set_value_outside(inode
, xi
, xs
, ctxt
,
1725 * If set value outside failed, we have to clean
1726 * the junk tree root we have already set in local.
1728 ret2
= ocfs2_xattr_cleanup(inode
, ctxt
->handle
,
1738 static int ocfs2_remove_value_outside(struct inode
*inode
,
1739 struct ocfs2_xattr_value_buf
*vb
,
1740 struct ocfs2_xattr_header
*header
)
1743 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1744 struct ocfs2_xattr_set_ctxt ctxt
= { NULL
, NULL
, };
1746 ocfs2_init_dealloc_ctxt(&ctxt
.dealloc
);
1748 ctxt
.handle
= ocfs2_start_trans(osb
,
1749 ocfs2_remove_extent_credits(osb
->sb
));
1750 if (IS_ERR(ctxt
.handle
)) {
1751 ret
= PTR_ERR(ctxt
.handle
);
1756 for (i
= 0; i
< le16_to_cpu(header
->xh_count
); i
++) {
1757 struct ocfs2_xattr_entry
*entry
= &header
->xh_entries
[i
];
1759 if (!ocfs2_xattr_is_local(entry
)) {
1762 val
= (void *)header
+
1763 le16_to_cpu(entry
->xe_name_offset
);
1764 vb
->vb_xv
= (struct ocfs2_xattr_value_root
*)
1765 (val
+ OCFS2_XATTR_SIZE(entry
->xe_name_len
));
1766 ret
= ocfs2_xattr_value_truncate(inode
, vb
, 0, &ctxt
);
1774 ocfs2_commit_trans(osb
, ctxt
.handle
);
1775 ocfs2_schedule_truncate_log_flush(osb
, 1);
1776 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
1781 static int ocfs2_xattr_ibody_remove(struct inode
*inode
,
1782 struct buffer_head
*di_bh
)
1785 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1786 struct ocfs2_xattr_header
*header
;
1788 struct ocfs2_xattr_value_buf vb
= {
1790 .vb_access
= ocfs2_journal_access_di
,
1793 header
= (struct ocfs2_xattr_header
*)
1794 ((void *)di
+ inode
->i_sb
->s_blocksize
-
1795 le16_to_cpu(di
->i_xattr_inline_size
));
1797 ret
= ocfs2_remove_value_outside(inode
, &vb
, header
);
1802 static int ocfs2_xattr_block_remove(struct inode
*inode
,
1803 struct buffer_head
*blk_bh
)
1805 struct ocfs2_xattr_block
*xb
;
1807 struct ocfs2_xattr_value_buf vb
= {
1809 .vb_access
= ocfs2_journal_access_xb
,
1812 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
1813 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
1814 struct ocfs2_xattr_header
*header
= &(xb
->xb_attrs
.xb_header
);
1815 ret
= ocfs2_remove_value_outside(inode
, &vb
, header
);
1817 ret
= ocfs2_iterate_xattr_index_block(inode
,
1819 ocfs2_rm_xattr_cluster
,
1825 static int ocfs2_xattr_free_block(struct inode
*inode
,
1828 struct inode
*xb_alloc_inode
;
1829 struct buffer_head
*xb_alloc_bh
= NULL
;
1830 struct buffer_head
*blk_bh
= NULL
;
1831 struct ocfs2_xattr_block
*xb
;
1832 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1838 ret
= ocfs2_read_xattr_block(inode
, block
, &blk_bh
);
1844 ret
= ocfs2_xattr_block_remove(inode
, blk_bh
);
1850 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
1851 blk
= le64_to_cpu(xb
->xb_blkno
);
1852 bit
= le16_to_cpu(xb
->xb_suballoc_bit
);
1853 bg_blkno
= ocfs2_which_suballoc_group(blk
, bit
);
1855 xb_alloc_inode
= ocfs2_get_system_file_inode(osb
,
1856 EXTENT_ALLOC_SYSTEM_INODE
,
1857 le16_to_cpu(xb
->xb_suballoc_slot
));
1858 if (!xb_alloc_inode
) {
1863 mutex_lock(&xb_alloc_inode
->i_mutex
);
1865 ret
= ocfs2_inode_lock(xb_alloc_inode
, &xb_alloc_bh
, 1);
1871 handle
= ocfs2_start_trans(osb
, OCFS2_SUBALLOC_FREE
);
1872 if (IS_ERR(handle
)) {
1873 ret
= PTR_ERR(handle
);
1878 ret
= ocfs2_free_suballoc_bits(handle
, xb_alloc_inode
, xb_alloc_bh
,
1883 ocfs2_commit_trans(osb
, handle
);
1885 ocfs2_inode_unlock(xb_alloc_inode
, 1);
1886 brelse(xb_alloc_bh
);
1888 mutex_unlock(&xb_alloc_inode
->i_mutex
);
1889 iput(xb_alloc_inode
);
1896 * ocfs2_xattr_remove()
1898 * Free extended attribute resources associated with this inode.
1900 int ocfs2_xattr_remove(struct inode
*inode
, struct buffer_head
*di_bh
)
1902 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1903 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1907 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
1910 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
1913 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) {
1914 ret
= ocfs2_xattr_ibody_remove(inode
, di_bh
);
1921 if (di
->i_xattr_loc
) {
1922 ret
= ocfs2_xattr_free_block(inode
,
1923 le64_to_cpu(di
->i_xattr_loc
));
1930 handle
= ocfs2_start_trans((OCFS2_SB(inode
->i_sb
)),
1931 OCFS2_INODE_UPDATE_CREDITS
);
1932 if (IS_ERR(handle
)) {
1933 ret
= PTR_ERR(handle
);
1937 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), di_bh
,
1938 OCFS2_JOURNAL_ACCESS_WRITE
);
1944 di
->i_xattr_loc
= 0;
1946 spin_lock(&oi
->ip_lock
);
1947 oi
->ip_dyn_features
&= ~(OCFS2_INLINE_XATTR_FL
| OCFS2_HAS_XATTR_FL
);
1948 di
->i_dyn_features
= cpu_to_le16(oi
->ip_dyn_features
);
1949 spin_unlock(&oi
->ip_lock
);
1951 ret
= ocfs2_journal_dirty(handle
, di_bh
);
1955 ocfs2_commit_trans(OCFS2_SB(inode
->i_sb
), handle
);
1960 static int ocfs2_xattr_has_space_inline(struct inode
*inode
,
1961 struct ocfs2_dinode
*di
)
1963 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1964 unsigned int xattrsize
= OCFS2_SB(inode
->i_sb
)->s_xattr_inline_size
;
1967 if (xattrsize
< OCFS2_MIN_XATTR_INLINE_SIZE
)
1970 if (oi
->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
1971 struct ocfs2_inline_data
*idata
= &di
->id2
.i_data
;
1972 free
= le16_to_cpu(idata
->id_count
) - le64_to_cpu(di
->i_size
);
1973 } else if (ocfs2_inode_is_fast_symlink(inode
)) {
1974 free
= ocfs2_fast_symlink_chars(inode
->i_sb
) -
1975 le64_to_cpu(di
->i_size
);
1977 struct ocfs2_extent_list
*el
= &di
->id2
.i_list
;
1978 free
= (le16_to_cpu(el
->l_count
) -
1979 le16_to_cpu(el
->l_next_free_rec
)) *
1980 sizeof(struct ocfs2_extent_rec
);
1982 if (free
>= xattrsize
)
1989 * ocfs2_xattr_ibody_find()
1991 * Find extended attribute in inode block and
1992 * fill search info into struct ocfs2_xattr_search.
1994 static int ocfs2_xattr_ibody_find(struct inode
*inode
,
1997 struct ocfs2_xattr_search
*xs
)
1999 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
2000 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2004 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
)
2007 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)) {
2008 down_read(&oi
->ip_alloc_sem
);
2009 has_space
= ocfs2_xattr_has_space_inline(inode
, di
);
2010 up_read(&oi
->ip_alloc_sem
);
2015 xs
->xattr_bh
= xs
->inode_bh
;
2016 xs
->end
= (void *)di
+ inode
->i_sb
->s_blocksize
;
2017 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)
2018 xs
->header
= (struct ocfs2_xattr_header
*)
2019 (xs
->end
- le16_to_cpu(di
->i_xattr_inline_size
));
2021 xs
->header
= (struct ocfs2_xattr_header
*)
2022 (xs
->end
- OCFS2_SB(inode
->i_sb
)->s_xattr_inline_size
);
2023 xs
->base
= (void *)xs
->header
;
2024 xs
->here
= xs
->header
->xh_entries
;
2026 /* Find the named attribute. */
2027 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) {
2028 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
2029 if (ret
&& ret
!= -ENODATA
)
2031 xs
->not_found
= ret
;
2038 * ocfs2_xattr_ibody_set()
2040 * Set, replace or remove an extended attribute into inode block.
2043 static int ocfs2_xattr_ibody_set(struct inode
*inode
,
2044 struct ocfs2_xattr_info
*xi
,
2045 struct ocfs2_xattr_search
*xs
,
2046 struct ocfs2_xattr_set_ctxt
*ctxt
)
2048 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
2049 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2052 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
)
2055 down_write(&oi
->ip_alloc_sem
);
2056 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)) {
2057 if (!ocfs2_xattr_has_space_inline(inode
, di
)) {
2063 ret
= ocfs2_xattr_set_entry(inode
, xi
, xs
, ctxt
,
2064 (OCFS2_INLINE_XATTR_FL
| OCFS2_HAS_XATTR_FL
));
2066 up_write(&oi
->ip_alloc_sem
);
2072 * ocfs2_xattr_block_find()
2074 * Find extended attribute in external block and
2075 * fill search info into struct ocfs2_xattr_search.
2077 static int ocfs2_xattr_block_find(struct inode
*inode
,
2080 struct ocfs2_xattr_search
*xs
)
2082 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2083 struct buffer_head
*blk_bh
= NULL
;
2084 struct ocfs2_xattr_block
*xb
;
2087 if (!di
->i_xattr_loc
)
2090 ret
= ocfs2_read_xattr_block(inode
, le64_to_cpu(di
->i_xattr_loc
),
2097 xs
->xattr_bh
= blk_bh
;
2098 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
2100 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
2101 xs
->header
= &xb
->xb_attrs
.xb_header
;
2102 xs
->base
= (void *)xs
->header
;
2103 xs
->end
= (void *)(blk_bh
->b_data
) + blk_bh
->b_size
;
2104 xs
->here
= xs
->header
->xh_entries
;
2106 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
2108 ret
= ocfs2_xattr_index_block_find(inode
, blk_bh
,
2112 if (ret
&& ret
!= -ENODATA
) {
2113 xs
->xattr_bh
= NULL
;
2116 xs
->not_found
= ret
;
2124 static int ocfs2_create_xattr_block(handle_t
*handle
,
2125 struct inode
*inode
,
2126 struct buffer_head
*inode_bh
,
2127 struct ocfs2_alloc_context
*meta_ac
,
2128 struct buffer_head
**ret_bh
)
2131 u16 suballoc_bit_start
;
2134 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)inode_bh
->b_data
;
2135 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2136 struct buffer_head
*new_bh
= NULL
;
2137 struct ocfs2_xattr_block
*xblk
;
2139 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), inode_bh
,
2140 OCFS2_JOURNAL_ACCESS_CREATE
);
2146 ret
= ocfs2_claim_metadata(osb
, handle
, meta_ac
, 1,
2147 &suballoc_bit_start
, &num_got
,
2154 new_bh
= sb_getblk(inode
->i_sb
, first_blkno
);
2155 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), new_bh
);
2157 ret
= ocfs2_journal_access_xb(handle
, INODE_CACHE(inode
),
2159 OCFS2_JOURNAL_ACCESS_CREATE
);
2165 /* Initialize ocfs2_xattr_block */
2166 xblk
= (struct ocfs2_xattr_block
*)new_bh
->b_data
;
2167 memset(xblk
, 0, inode
->i_sb
->s_blocksize
);
2168 strcpy((void *)xblk
, OCFS2_XATTR_BLOCK_SIGNATURE
);
2169 xblk
->xb_suballoc_slot
= cpu_to_le16(osb
->slot_num
);
2170 xblk
->xb_suballoc_bit
= cpu_to_le16(suballoc_bit_start
);
2171 xblk
->xb_fs_generation
= cpu_to_le32(osb
->fs_generation
);
2172 xblk
->xb_blkno
= cpu_to_le64(first_blkno
);
2174 ret
= ocfs2_journal_dirty(handle
, new_bh
);
2179 di
->i_xattr_loc
= cpu_to_le64(first_blkno
);
2180 ocfs2_journal_dirty(handle
, inode_bh
);
2191 * ocfs2_xattr_block_set()
2193 * Set, replace or remove an extended attribute into external block.
2196 static int ocfs2_xattr_block_set(struct inode
*inode
,
2197 struct ocfs2_xattr_info
*xi
,
2198 struct ocfs2_xattr_search
*xs
,
2199 struct ocfs2_xattr_set_ctxt
*ctxt
)
2201 struct buffer_head
*new_bh
= NULL
;
2202 handle_t
*handle
= ctxt
->handle
;
2203 struct ocfs2_xattr_block
*xblk
= NULL
;
2206 if (!xs
->xattr_bh
) {
2207 ret
= ocfs2_create_xattr_block(handle
, inode
, xs
->inode_bh
,
2208 ctxt
->meta_ac
, &new_bh
);
2214 xs
->xattr_bh
= new_bh
;
2215 xblk
= (struct ocfs2_xattr_block
*)xs
->xattr_bh
->b_data
;
2216 xs
->header
= &xblk
->xb_attrs
.xb_header
;
2217 xs
->base
= (void *)xs
->header
;
2218 xs
->end
= (void *)xblk
+ inode
->i_sb
->s_blocksize
;
2219 xs
->here
= xs
->header
->xh_entries
;
2221 xblk
= (struct ocfs2_xattr_block
*)xs
->xattr_bh
->b_data
;
2223 if (!(le16_to_cpu(xblk
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
2224 /* Set extended attribute into external block */
2225 ret
= ocfs2_xattr_set_entry(inode
, xi
, xs
, ctxt
,
2226 OCFS2_HAS_XATTR_FL
);
2227 if (!ret
|| ret
!= -ENOSPC
)
2230 ret
= ocfs2_xattr_create_index_block(inode
, xs
, ctxt
);
2235 ret
= ocfs2_xattr_set_entry_index_block(inode
, xi
, xs
, ctxt
);
2242 /* Check whether the new xattr can be inserted into the inode. */
2243 static int ocfs2_xattr_can_be_in_inode(struct inode
*inode
,
2244 struct ocfs2_xattr_info
*xi
,
2245 struct ocfs2_xattr_search
*xs
)
2248 struct ocfs2_xattr_entry
*last
;
2250 size_t min_offs
= xs
->end
- xs
->base
;
2255 last
= xs
->header
->xh_entries
;
2257 for (i
= 0; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
2258 size_t offs
= le16_to_cpu(last
->xe_name_offset
);
2259 if (offs
< min_offs
)
2264 free
= min_offs
- ((void *)last
- xs
->base
) - OCFS2_XATTR_HEADER_GAP
;
2268 BUG_ON(!xs
->not_found
);
2270 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
2271 value_size
= OCFS2_XATTR_ROOT_SIZE
;
2273 value_size
= OCFS2_XATTR_SIZE(xi
->value_len
);
2275 if (free
>= sizeof(struct ocfs2_xattr_entry
) +
2276 OCFS2_XATTR_SIZE(strlen(xi
->name
)) + value_size
)
2282 static int ocfs2_calc_xattr_set_need(struct inode
*inode
,
2283 struct ocfs2_dinode
*di
,
2284 struct ocfs2_xattr_info
*xi
,
2285 struct ocfs2_xattr_search
*xis
,
2286 struct ocfs2_xattr_search
*xbs
,
2291 int ret
= 0, old_in_xb
= 0;
2292 int clusters_add
= 0, meta_add
= 0, credits
= 0;
2293 struct buffer_head
*bh
= NULL
;
2294 struct ocfs2_xattr_block
*xb
= NULL
;
2295 struct ocfs2_xattr_entry
*xe
= NULL
;
2296 struct ocfs2_xattr_value_root
*xv
= NULL
;
2298 int name_offset
, name_len
= 0;
2299 u32 new_clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
,
2304 * Calculate the clusters we need to write.
2305 * No matter whether we replace an old one or add a new one,
2306 * we need this for writing.
2308 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
2309 credits
+= new_clusters
*
2310 ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
2312 if (xis
->not_found
&& xbs
->not_found
) {
2313 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2315 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
2316 clusters_add
+= new_clusters
;
2317 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2325 if (!xis
->not_found
) {
2327 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
2328 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
2330 credits
+= OCFS2_INODE_UPDATE_CREDITS
;
2332 int i
, block_off
= 0;
2333 xb
= (struct ocfs2_xattr_block
*)xbs
->xattr_bh
->b_data
;
2335 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
2336 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
2337 i
= xbs
->here
- xbs
->header
->xh_entries
;
2340 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
2341 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
2342 bucket_xh(xbs
->bucket
),
2345 base
= bucket_block(xbs
->bucket
, block_off
);
2346 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2349 credits
+= OCFS2_XATTR_BLOCK_UPDATE_CREDITS
;
2354 * delete a xattr doesn't need metadata and cluster allocation.
2355 * so just calculate the credits and return.
2357 * The credits for removing the value tree will be extended
2358 * by ocfs2_remove_extent itself.
2361 if (!ocfs2_xattr_is_local(xe
))
2362 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
);
2367 /* do cluster allocation guess first. */
2368 value_size
= le64_to_cpu(xe
->xe_value_size
);
2372 * In xattr set, we always try to set the xe in inode first,
2373 * so if it can be inserted into inode successfully, the old
2374 * one will be removed from the xattr block, and this xattr
2375 * will be inserted into inode as a new xattr in inode.
2377 if (ocfs2_xattr_can_be_in_inode(inode
, xi
, xis
)) {
2378 clusters_add
+= new_clusters
;
2379 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
) +
2380 OCFS2_INODE_UPDATE_CREDITS
;
2381 if (!ocfs2_xattr_is_local(xe
))
2382 credits
+= ocfs2_calc_extend_credits(
2390 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
2391 /* the new values will be stored outside. */
2392 u32 old_clusters
= 0;
2394 if (!ocfs2_xattr_is_local(xe
)) {
2395 old_clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
,
2397 xv
= (struct ocfs2_xattr_value_root
*)
2398 (base
+ name_offset
+ name_len
);
2399 value_size
= OCFS2_XATTR_ROOT_SIZE
;
2403 if (old_clusters
>= new_clusters
) {
2404 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
);
2407 meta_add
+= ocfs2_extend_meta_needed(&xv
->xr_list
);
2408 clusters_add
+= new_clusters
- old_clusters
;
2409 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2413 if (value_size
>= OCFS2_XATTR_ROOT_SIZE
)
2418 * Now the new value will be stored inside. So if the new
2419 * value is smaller than the size of value root or the old
2420 * value, we don't need any allocation, otherwise we have
2421 * to guess metadata allocation.
2423 if ((ocfs2_xattr_is_local(xe
) && value_size
>= xi
->value_len
) ||
2424 (!ocfs2_xattr_is_local(xe
) &&
2425 OCFS2_XATTR_ROOT_SIZE
>= xi
->value_len
))
2430 /* calculate metadata allocation. */
2431 if (di
->i_xattr_loc
) {
2432 if (!xbs
->xattr_bh
) {
2433 ret
= ocfs2_read_xattr_block(inode
,
2434 le64_to_cpu(di
->i_xattr_loc
),
2441 xb
= (struct ocfs2_xattr_block
*)bh
->b_data
;
2443 xb
= (struct ocfs2_xattr_block
*)xbs
->xattr_bh
->b_data
;
2446 * If there is already an xattr tree, good, we can calculate
2447 * like other b-trees. Otherwise we may have the chance of
2448 * create a tree, the credit calculation is borrowed from
2449 * ocfs2_calc_extend_credits with root_el = NULL. And the
2450 * new tree will be cluster based, so no meta is needed.
2452 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
2453 struct ocfs2_extent_list
*el
=
2454 &xb
->xb_attrs
.xb_root
.xt_list
;
2455 meta_add
+= ocfs2_extend_meta_needed(el
);
2456 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2459 credits
+= OCFS2_SUBALLOC_ALLOC
+ 1;
2462 * This cluster will be used either for new bucket or for
2464 * If the cluster size is the same as the bucket size, one
2465 * more is needed since we may need to extend the bucket
2469 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2470 if (OCFS2_XATTR_BUCKET_SIZE
==
2471 OCFS2_SB(inode
->i_sb
)->s_clustersize
) {
2472 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2477 credits
+= OCFS2_XATTR_BLOCK_CREATE_CREDITS
;
2481 *clusters_need
= clusters_add
;
2483 *meta_need
= meta_add
;
2485 *credits_need
= credits
;
2490 static int ocfs2_init_xattr_set_ctxt(struct inode
*inode
,
2491 struct ocfs2_dinode
*di
,
2492 struct ocfs2_xattr_info
*xi
,
2493 struct ocfs2_xattr_search
*xis
,
2494 struct ocfs2_xattr_search
*xbs
,
2495 struct ocfs2_xattr_set_ctxt
*ctxt
,
2499 int clusters_add
, meta_add
, ret
;
2500 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2502 memset(ctxt
, 0, sizeof(struct ocfs2_xattr_set_ctxt
));
2504 ocfs2_init_dealloc_ctxt(&ctxt
->dealloc
);
2506 ret
= ocfs2_calc_xattr_set_need(inode
, di
, xi
, xis
, xbs
,
2507 &clusters_add
, &meta_add
, credits
);
2513 meta_add
+= extra_meta
;
2514 mlog(0, "Set xattr %s, reserve meta blocks = %d, clusters = %d, "
2515 "credits = %d\n", xi
->name
, meta_add
, clusters_add
, *credits
);
2518 ret
= ocfs2_reserve_new_metadata_blocks(osb
, meta_add
,
2527 ret
= ocfs2_reserve_clusters(osb
, clusters_add
, &ctxt
->data_ac
);
2533 if (ctxt
->meta_ac
) {
2534 ocfs2_free_alloc_context(ctxt
->meta_ac
);
2535 ctxt
->meta_ac
= NULL
;
2539 * We cannot have an error and a non null ctxt->data_ac.
2546 static int __ocfs2_xattr_set_handle(struct inode
*inode
,
2547 struct ocfs2_dinode
*di
,
2548 struct ocfs2_xattr_info
*xi
,
2549 struct ocfs2_xattr_search
*xis
,
2550 struct ocfs2_xattr_search
*xbs
,
2551 struct ocfs2_xattr_set_ctxt
*ctxt
)
2553 int ret
= 0, credits
, old_found
;
2556 /* Remove existing extended attribute */
2557 if (!xis
->not_found
)
2558 ret
= ocfs2_xattr_ibody_set(inode
, xi
, xis
, ctxt
);
2559 else if (!xbs
->not_found
)
2560 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2562 /* We always try to set extended attribute into inode first*/
2563 ret
= ocfs2_xattr_ibody_set(inode
, xi
, xis
, ctxt
);
2564 if (!ret
&& !xbs
->not_found
) {
2566 * If succeed and that extended attribute existing in
2567 * external block, then we will remove it.
2572 old_found
= xis
->not_found
;
2573 xis
->not_found
= -ENODATA
;
2574 ret
= ocfs2_calc_xattr_set_need(inode
,
2582 xis
->not_found
= old_found
;
2588 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2589 ctxt
->handle
->h_buffer_credits
);
2594 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2595 } else if (ret
== -ENOSPC
) {
2596 if (di
->i_xattr_loc
&& !xbs
->xattr_bh
) {
2597 ret
= ocfs2_xattr_block_find(inode
,
2603 old_found
= xis
->not_found
;
2604 xis
->not_found
= -ENODATA
;
2605 ret
= ocfs2_calc_xattr_set_need(inode
,
2613 xis
->not_found
= old_found
;
2619 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2620 ctxt
->handle
->h_buffer_credits
);
2627 * If no space in inode, we will set extended attribute
2628 * into external block.
2630 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2633 if (!xis
->not_found
) {
2635 * If succeed and that extended attribute
2636 * existing in inode, we will remove it.
2640 xbs
->not_found
= -ENODATA
;
2641 ret
= ocfs2_calc_xattr_set_need(inode
,
2654 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2655 ctxt
->handle
->h_buffer_credits
);
2660 ret
= ocfs2_xattr_ibody_set(inode
, xi
,
2667 /* Update inode ctime. */
2668 ret
= ocfs2_journal_access_di(ctxt
->handle
, INODE_CACHE(inode
),
2670 OCFS2_JOURNAL_ACCESS_WRITE
);
2676 inode
->i_ctime
= CURRENT_TIME
;
2677 di
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
2678 di
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
2679 ocfs2_journal_dirty(ctxt
->handle
, xis
->inode_bh
);
2686 * This function only called duing creating inode
2687 * for init security/acl xattrs of the new inode.
2688 * All transanction credits have been reserved in mknod.
2690 int ocfs2_xattr_set_handle(handle_t
*handle
,
2691 struct inode
*inode
,
2692 struct buffer_head
*di_bh
,
2698 struct ocfs2_alloc_context
*meta_ac
,
2699 struct ocfs2_alloc_context
*data_ac
)
2701 struct ocfs2_dinode
*di
;
2704 struct ocfs2_xattr_info xi
= {
2705 .name_index
= name_index
,
2708 .value_len
= value_len
,
2711 struct ocfs2_xattr_search xis
= {
2712 .not_found
= -ENODATA
,
2715 struct ocfs2_xattr_search xbs
= {
2716 .not_found
= -ENODATA
,
2719 struct ocfs2_xattr_set_ctxt ctxt
= {
2725 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
2729 * In extreme situation, may need xattr bucket when
2730 * block size is too small. And we have already reserved
2731 * the credits for bucket in mknod.
2733 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
) {
2734 xbs
.bucket
= ocfs2_xattr_bucket_new(inode
);
2736 mlog_errno(-ENOMEM
);
2741 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
2742 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2744 down_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2746 ret
= ocfs2_xattr_ibody_find(inode
, name_index
, name
, &xis
);
2749 if (xis
.not_found
) {
2750 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, &xbs
);
2755 ret
= __ocfs2_xattr_set_handle(inode
, di
, &xi
, &xis
, &xbs
, &ctxt
);
2758 up_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2759 brelse(xbs
.xattr_bh
);
2760 ocfs2_xattr_bucket_free(xbs
.bucket
);
2768 * Set, replace or remove an extended attribute for this inode.
2769 * value is NULL to remove an existing extended attribute, else either
2770 * create or replace an extended attribute.
2772 int ocfs2_xattr_set(struct inode
*inode
,
2779 struct buffer_head
*di_bh
= NULL
;
2780 struct ocfs2_dinode
*di
;
2781 int ret
, credits
, ref_meta
= 0, ref_credits
= 0;
2782 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2783 struct inode
*tl_inode
= osb
->osb_tl_inode
;
2784 struct ocfs2_xattr_set_ctxt ctxt
= { NULL
, NULL
, };
2785 struct ocfs2_refcount_tree
*ref_tree
= NULL
;
2787 struct ocfs2_xattr_info xi
= {
2788 .name_index
= name_index
,
2791 .value_len
= value_len
,
2794 struct ocfs2_xattr_search xis
= {
2795 .not_found
= -ENODATA
,
2798 struct ocfs2_xattr_search xbs
= {
2799 .not_found
= -ENODATA
,
2802 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
2806 * Only xbs will be used on indexed trees. xis doesn't need a
2809 xbs
.bucket
= ocfs2_xattr_bucket_new(inode
);
2811 mlog_errno(-ENOMEM
);
2815 ret
= ocfs2_inode_lock(inode
, &di_bh
, 1);
2818 goto cleanup_nolock
;
2820 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
2821 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2823 down_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2825 * Scan inode and external block to find the same name
2826 * extended attribute and collect search infomation.
2828 ret
= ocfs2_xattr_ibody_find(inode
, name_index
, name
, &xis
);
2831 if (xis
.not_found
) {
2832 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, &xbs
);
2837 if (xis
.not_found
&& xbs
.not_found
) {
2839 if (flags
& XATTR_REPLACE
)
2846 if (flags
& XATTR_CREATE
)
2850 /* Check whether the value is refcounted and do some prepartion. */
2851 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_HAS_REFCOUNT_FL
&&
2852 (!xis
.not_found
|| !xbs
.not_found
)) {
2853 ret
= ocfs2_prepare_refcount_xattr(inode
, di
, &xi
,
2854 &xis
, &xbs
, &ref_tree
,
2855 &ref_meta
, &ref_credits
);
2862 mutex_lock(&tl_inode
->i_mutex
);
2864 if (ocfs2_truncate_log_needs_flush(osb
)) {
2865 ret
= __ocfs2_flush_truncate_log(osb
);
2867 mutex_unlock(&tl_inode
->i_mutex
);
2872 mutex_unlock(&tl_inode
->i_mutex
);
2874 ret
= ocfs2_init_xattr_set_ctxt(inode
, di
, &xi
, &xis
,
2875 &xbs
, &ctxt
, ref_meta
, &credits
);
2881 /* we need to update inode's ctime field, so add credit for it. */
2882 credits
+= OCFS2_INODE_UPDATE_CREDITS
;
2883 ctxt
.handle
= ocfs2_start_trans(osb
, credits
+ ref_credits
);
2884 if (IS_ERR(ctxt
.handle
)) {
2885 ret
= PTR_ERR(ctxt
.handle
);
2890 ret
= __ocfs2_xattr_set_handle(inode
, di
, &xi
, &xis
, &xbs
, &ctxt
);
2892 ocfs2_commit_trans(osb
, ctxt
.handle
);
2895 ocfs2_free_alloc_context(ctxt
.data_ac
);
2897 ocfs2_free_alloc_context(ctxt
.meta_ac
);
2898 if (ocfs2_dealloc_has_cluster(&ctxt
.dealloc
))
2899 ocfs2_schedule_truncate_log_flush(osb
, 1);
2900 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
2903 ocfs2_unlock_refcount_tree(osb
, ref_tree
, 1);
2904 up_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2905 ocfs2_inode_unlock(inode
, 1);
2908 brelse(xbs
.xattr_bh
);
2909 ocfs2_xattr_bucket_free(xbs
.bucket
);
2915 * Find the xattr extent rec which may contains name_hash.
2916 * e_cpos will be the first name hash of the xattr rec.
2917 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
2919 static int ocfs2_xattr_get_rec(struct inode
*inode
,
2924 struct ocfs2_extent_list
*el
)
2927 struct buffer_head
*eb_bh
= NULL
;
2928 struct ocfs2_extent_block
*eb
;
2929 struct ocfs2_extent_rec
*rec
= NULL
;
2932 if (el
->l_tree_depth
) {
2933 ret
= ocfs2_find_leaf(INODE_CACHE(inode
), el
, name_hash
,
2940 eb
= (struct ocfs2_extent_block
*) eb_bh
->b_data
;
2943 if (el
->l_tree_depth
) {
2944 ocfs2_error(inode
->i_sb
,
2945 "Inode %lu has non zero tree depth in "
2946 "xattr tree block %llu\n", inode
->i_ino
,
2947 (unsigned long long)eb_bh
->b_blocknr
);
2953 for (i
= le16_to_cpu(el
->l_next_free_rec
) - 1; i
>= 0; i
--) {
2954 rec
= &el
->l_recs
[i
];
2956 if (le32_to_cpu(rec
->e_cpos
) <= name_hash
) {
2957 e_blkno
= le64_to_cpu(rec
->e_blkno
);
2963 ocfs2_error(inode
->i_sb
, "Inode %lu has bad extent "
2964 "record (%u, %u, 0) in xattr", inode
->i_ino
,
2965 le32_to_cpu(rec
->e_cpos
),
2966 ocfs2_rec_clusters(el
, rec
));
2971 *p_blkno
= le64_to_cpu(rec
->e_blkno
);
2972 *num_clusters
= le16_to_cpu(rec
->e_leaf_clusters
);
2974 *e_cpos
= le32_to_cpu(rec
->e_cpos
);
2980 typedef int (xattr_bucket_func
)(struct inode
*inode
,
2981 struct ocfs2_xattr_bucket
*bucket
,
2984 static int ocfs2_find_xe_in_bucket(struct inode
*inode
,
2985 struct ocfs2_xattr_bucket
*bucket
,
2992 int i
, ret
= 0, cmp
= 1, block_off
, new_offset
;
2993 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
2994 size_t name_len
= strlen(name
);
2995 struct ocfs2_xattr_entry
*xe
= NULL
;
2999 * We don't use binary search in the bucket because there
3000 * may be multiple entries with the same name hash.
3002 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
3003 xe
= &xh
->xh_entries
[i
];
3005 if (name_hash
> le32_to_cpu(xe
->xe_name_hash
))
3007 else if (name_hash
< le32_to_cpu(xe
->xe_name_hash
))
3010 cmp
= name_index
- ocfs2_xattr_get_type(xe
);
3012 cmp
= name_len
- xe
->xe_name_len
;
3016 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
3027 xe_name
= bucket_block(bucket
, block_off
) + new_offset
;
3028 if (!memcmp(name
, xe_name
, name_len
)) {
3040 * Find the specified xattr entry in a series of buckets.
3041 * This series start from p_blkno and last for num_clusters.
3042 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
3043 * the num of the valid buckets.
3045 * Return the buffer_head this xattr should reside in. And if the xattr's
3046 * hash is in the gap of 2 buckets, return the lower bucket.
3048 static int ocfs2_xattr_bucket_find(struct inode
*inode
,
3055 struct ocfs2_xattr_search
*xs
)
3058 struct ocfs2_xattr_header
*xh
= NULL
;
3059 struct ocfs2_xattr_entry
*xe
= NULL
;
3061 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
3062 int low_bucket
= 0, bucket
, high_bucket
;
3063 struct ocfs2_xattr_bucket
*search
;
3065 u64 blkno
, lower_blkno
= 0;
3067 search
= ocfs2_xattr_bucket_new(inode
);
3074 ret
= ocfs2_read_xattr_bucket(search
, p_blkno
);
3080 xh
= bucket_xh(search
);
3081 high_bucket
= le16_to_cpu(xh
->xh_num_buckets
) - 1;
3082 while (low_bucket
<= high_bucket
) {
3083 ocfs2_xattr_bucket_relse(search
);
3085 bucket
= (low_bucket
+ high_bucket
) / 2;
3086 blkno
= p_blkno
+ bucket
* blk_per_bucket
;
3087 ret
= ocfs2_read_xattr_bucket(search
, blkno
);
3093 xh
= bucket_xh(search
);
3094 xe
= &xh
->xh_entries
[0];
3095 if (name_hash
< le32_to_cpu(xe
->xe_name_hash
)) {
3096 high_bucket
= bucket
- 1;
3101 * Check whether the hash of the last entry in our
3102 * bucket is larger than the search one. for an empty
3103 * bucket, the last one is also the first one.
3106 xe
= &xh
->xh_entries
[le16_to_cpu(xh
->xh_count
) - 1];
3108 last_hash
= le32_to_cpu(xe
->xe_name_hash
);
3110 /* record lower_blkno which may be the insert place. */
3111 lower_blkno
= blkno
;
3113 if (name_hash
> le32_to_cpu(xe
->xe_name_hash
)) {
3114 low_bucket
= bucket
+ 1;
3118 /* the searched xattr should reside in this bucket if exists. */
3119 ret
= ocfs2_find_xe_in_bucket(inode
, search
,
3120 name_index
, name
, name_hash
,
3130 * Record the bucket we have found.
3131 * When the xattr's hash value is in the gap of 2 buckets, we will
3132 * always set it to the previous bucket.
3135 lower_blkno
= p_blkno
;
3137 /* This should be in cache - we just read it during the search */
3138 ret
= ocfs2_read_xattr_bucket(xs
->bucket
, lower_blkno
);
3144 xs
->header
= bucket_xh(xs
->bucket
);
3145 xs
->base
= bucket_block(xs
->bucket
, 0);
3146 xs
->end
= xs
->base
+ inode
->i_sb
->s_blocksize
;
3149 xs
->here
= &xs
->header
->xh_entries
[index
];
3150 mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name
,
3151 (unsigned long long)bucket_blkno(xs
->bucket
), index
);
3156 ocfs2_xattr_bucket_free(search
);
3160 static int ocfs2_xattr_index_block_find(struct inode
*inode
,
3161 struct buffer_head
*root_bh
,
3164 struct ocfs2_xattr_search
*xs
)
3167 struct ocfs2_xattr_block
*xb
=
3168 (struct ocfs2_xattr_block
*)root_bh
->b_data
;
3169 struct ocfs2_xattr_tree_root
*xb_root
= &xb
->xb_attrs
.xb_root
;
3170 struct ocfs2_extent_list
*el
= &xb_root
->xt_list
;
3172 u32 first_hash
, num_clusters
= 0;
3173 u32 name_hash
= ocfs2_xattr_name_hash(inode
, name
, strlen(name
));
3175 if (le16_to_cpu(el
->l_next_free_rec
) == 0)
3178 mlog(0, "find xattr %s, hash = %u, index = %d in xattr tree\n",
3179 name
, name_hash
, name_index
);
3181 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
, &first_hash
,
3188 BUG_ON(p_blkno
== 0 || num_clusters
== 0 || first_hash
> name_hash
);
3190 mlog(0, "find xattr extent rec %u clusters from %llu, the first hash "
3191 "in the rec is %u\n", num_clusters
, (unsigned long long)p_blkno
,
3194 ret
= ocfs2_xattr_bucket_find(inode
, name_index
, name
, name_hash
,
3195 p_blkno
, first_hash
, num_clusters
, xs
);
3201 static int ocfs2_iterate_xattr_buckets(struct inode
*inode
,
3204 xattr_bucket_func
*func
,
3208 u32 bpc
= ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode
->i_sb
));
3209 u32 num_buckets
= clusters
* bpc
;
3210 struct ocfs2_xattr_bucket
*bucket
;
3212 bucket
= ocfs2_xattr_bucket_new(inode
);
3214 mlog_errno(-ENOMEM
);
3218 mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
3219 clusters
, (unsigned long long)blkno
);
3221 for (i
= 0; i
< num_buckets
; i
++, blkno
+= bucket
->bu_blocks
) {
3222 ret
= ocfs2_read_xattr_bucket(bucket
, blkno
);
3229 * The real bucket num in this series of blocks is stored
3230 * in the 1st bucket.
3233 num_buckets
= le16_to_cpu(bucket_xh(bucket
)->xh_num_buckets
);
3235 mlog(0, "iterating xattr bucket %llu, first hash %u\n",
3236 (unsigned long long)blkno
,
3237 le32_to_cpu(bucket_xh(bucket
)->xh_entries
[0].xe_name_hash
));
3239 ret
= func(inode
, bucket
, para
);
3240 if (ret
&& ret
!= -ERANGE
)
3242 /* Fall through to bucket_relse() */
3245 ocfs2_xattr_bucket_relse(bucket
);
3250 ocfs2_xattr_bucket_free(bucket
);
3254 struct ocfs2_xattr_tree_list
{
3260 static int ocfs2_xattr_bucket_get_name_value(struct super_block
*sb
,
3261 struct ocfs2_xattr_header
*xh
,
3268 if (index
< 0 || index
>= le16_to_cpu(xh
->xh_count
))
3271 name_offset
= le16_to_cpu(xh
->xh_entries
[index
].xe_name_offset
);
3273 *block_off
= name_offset
>> sb
->s_blocksize_bits
;
3274 *new_offset
= name_offset
% sb
->s_blocksize
;
3279 static int ocfs2_list_xattr_bucket(struct inode
*inode
,
3280 struct ocfs2_xattr_bucket
*bucket
,
3284 struct ocfs2_xattr_tree_list
*xl
= (struct ocfs2_xattr_tree_list
*)para
;
3285 int i
, block_off
, new_offset
;
3286 const char *prefix
, *name
;
3288 for (i
= 0 ; i
< le16_to_cpu(bucket_xh(bucket
)->xh_count
); i
++) {
3289 struct ocfs2_xattr_entry
*entry
= &bucket_xh(bucket
)->xh_entries
[i
];
3290 type
= ocfs2_xattr_get_type(entry
);
3291 prefix
= ocfs2_xattr_prefix(type
);
3294 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
3302 name
= (const char *)bucket_block(bucket
, block_off
) +
3304 ret
= ocfs2_xattr_list_entry(xl
->buffer
,
3308 entry
->xe_name_len
);
3317 static int ocfs2_iterate_xattr_index_block(struct inode
*inode
,
3318 struct buffer_head
*blk_bh
,
3319 xattr_tree_rec_func
*rec_func
,
3322 struct ocfs2_xattr_block
*xb
=
3323 (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
3324 struct ocfs2_extent_list
*el
= &xb
->xb_attrs
.xb_root
.xt_list
;
3326 u32 name_hash
= UINT_MAX
, e_cpos
= 0, num_clusters
= 0;
3329 if (!el
->l_next_free_rec
|| !rec_func
)
3332 while (name_hash
> 0) {
3333 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
,
3334 &e_cpos
, &num_clusters
, el
);
3340 ret
= rec_func(inode
, blk_bh
, p_blkno
, e_cpos
,
3341 num_clusters
, para
);
3351 name_hash
= e_cpos
- 1;
3358 static int ocfs2_list_xattr_tree_rec(struct inode
*inode
,
3359 struct buffer_head
*root_bh
,
3360 u64 blkno
, u32 cpos
, u32 len
, void *para
)
3362 return ocfs2_iterate_xattr_buckets(inode
, blkno
, len
,
3363 ocfs2_list_xattr_bucket
, para
);
3366 static int ocfs2_xattr_tree_list_index_block(struct inode
*inode
,
3367 struct buffer_head
*blk_bh
,
3372 struct ocfs2_xattr_tree_list xl
= {
3374 .buffer_size
= buffer_size
,
3378 ret
= ocfs2_iterate_xattr_index_block(inode
, blk_bh
,
3379 ocfs2_list_xattr_tree_rec
, &xl
);
3390 static int cmp_xe(const void *a
, const void *b
)
3392 const struct ocfs2_xattr_entry
*l
= a
, *r
= b
;
3393 u32 l_hash
= le32_to_cpu(l
->xe_name_hash
);
3394 u32 r_hash
= le32_to_cpu(r
->xe_name_hash
);
3396 if (l_hash
> r_hash
)
3398 if (l_hash
< r_hash
)
3403 static void swap_xe(void *a
, void *b
, int size
)
3405 struct ocfs2_xattr_entry
*l
= a
, *r
= b
, tmp
;
3408 memcpy(l
, r
, sizeof(struct ocfs2_xattr_entry
));
3409 memcpy(r
, &tmp
, sizeof(struct ocfs2_xattr_entry
));
3413 * When the ocfs2_xattr_block is filled up, new bucket will be created
3414 * and all the xattr entries will be moved to the new bucket.
3415 * The header goes at the start of the bucket, and the names+values are
3416 * filled from the end. This is why *target starts as the last buffer.
3417 * Note: we need to sort the entries since they are not saved in order
3418 * in the ocfs2_xattr_block.
3420 static void ocfs2_cp_xattr_block_to_bucket(struct inode
*inode
,
3421 struct buffer_head
*xb_bh
,
3422 struct ocfs2_xattr_bucket
*bucket
)
3424 int i
, blocksize
= inode
->i_sb
->s_blocksize
;
3425 int blks
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
3426 u16 offset
, size
, off_change
;
3427 struct ocfs2_xattr_entry
*xe
;
3428 struct ocfs2_xattr_block
*xb
=
3429 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
3430 struct ocfs2_xattr_header
*xb_xh
= &xb
->xb_attrs
.xb_header
;
3431 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
3432 u16 count
= le16_to_cpu(xb_xh
->xh_count
);
3433 char *src
= xb_bh
->b_data
;
3434 char *target
= bucket_block(bucket
, blks
- 1);
3436 mlog(0, "cp xattr from block %llu to bucket %llu\n",
3437 (unsigned long long)xb_bh
->b_blocknr
,
3438 (unsigned long long)bucket_blkno(bucket
));
3440 for (i
= 0; i
< blks
; i
++)
3441 memset(bucket_block(bucket
, i
), 0, blocksize
);
3444 * Since the xe_name_offset is based on ocfs2_xattr_header,
3445 * there is a offset change corresponding to the change of
3446 * ocfs2_xattr_header's position.
3448 off_change
= offsetof(struct ocfs2_xattr_block
, xb_attrs
.xb_header
);
3449 xe
= &xb_xh
->xh_entries
[count
- 1];
3450 offset
= le16_to_cpu(xe
->xe_name_offset
) + off_change
;
3451 size
= blocksize
- offset
;
3453 /* copy all the names and values. */
3454 memcpy(target
+ offset
, src
+ offset
, size
);
3456 /* Init new header now. */
3457 xh
->xh_count
= xb_xh
->xh_count
;
3458 xh
->xh_num_buckets
= cpu_to_le16(1);
3459 xh
->xh_name_value_len
= cpu_to_le16(size
);
3460 xh
->xh_free_start
= cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
- size
);
3462 /* copy all the entries. */
3463 target
= bucket_block(bucket
, 0);
3464 offset
= offsetof(struct ocfs2_xattr_header
, xh_entries
);
3465 size
= count
* sizeof(struct ocfs2_xattr_entry
);
3466 memcpy(target
+ offset
, (char *)xb_xh
+ offset
, size
);
3468 /* Change the xe offset for all the xe because of the move. */
3469 off_change
= OCFS2_XATTR_BUCKET_SIZE
- blocksize
+
3470 offsetof(struct ocfs2_xattr_block
, xb_attrs
.xb_header
);
3471 for (i
= 0; i
< count
; i
++)
3472 le16_add_cpu(&xh
->xh_entries
[i
].xe_name_offset
, off_change
);
3474 mlog(0, "copy entry: start = %u, size = %u, offset_change = %u\n",
3475 offset
, size
, off_change
);
3477 sort(target
+ offset
, count
, sizeof(struct ocfs2_xattr_entry
),
3482 * After we move xattr from block to index btree, we have to
3483 * update ocfs2_xattr_search to the new xe and base.
3485 * When the entry is in xattr block, xattr_bh indicates the storage place.
3486 * While if the entry is in index b-tree, "bucket" indicates the
3487 * real place of the xattr.
3489 static void ocfs2_xattr_update_xattr_search(struct inode
*inode
,
3490 struct ocfs2_xattr_search
*xs
,
3491 struct buffer_head
*old_bh
)
3493 char *buf
= old_bh
->b_data
;
3494 struct ocfs2_xattr_block
*old_xb
= (struct ocfs2_xattr_block
*)buf
;
3495 struct ocfs2_xattr_header
*old_xh
= &old_xb
->xb_attrs
.xb_header
;
3498 xs
->header
= bucket_xh(xs
->bucket
);
3499 xs
->base
= bucket_block(xs
->bucket
, 0);
3500 xs
->end
= xs
->base
+ inode
->i_sb
->s_blocksize
;
3505 i
= xs
->here
- old_xh
->xh_entries
;
3506 xs
->here
= &xs
->header
->xh_entries
[i
];
3509 static int ocfs2_xattr_create_index_block(struct inode
*inode
,
3510 struct ocfs2_xattr_search
*xs
,
3511 struct ocfs2_xattr_set_ctxt
*ctxt
)
3516 handle_t
*handle
= ctxt
->handle
;
3517 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
3518 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
3519 struct buffer_head
*xb_bh
= xs
->xattr_bh
;
3520 struct ocfs2_xattr_block
*xb
=
3521 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
3522 struct ocfs2_xattr_tree_root
*xr
;
3523 u16 xb_flags
= le16_to_cpu(xb
->xb_flags
);
3525 mlog(0, "create xattr index block for %llu\n",
3526 (unsigned long long)xb_bh
->b_blocknr
);
3528 BUG_ON(xb_flags
& OCFS2_XATTR_INDEXED
);
3529 BUG_ON(!xs
->bucket
);
3533 * We can use this lock for now, and maybe move to a dedicated mutex
3534 * if performance becomes a problem later.
3536 down_write(&oi
->ip_alloc_sem
);
3538 ret
= ocfs2_journal_access_xb(handle
, INODE_CACHE(inode
), xb_bh
,
3539 OCFS2_JOURNAL_ACCESS_WRITE
);
3545 ret
= __ocfs2_claim_clusters(osb
, handle
, ctxt
->data_ac
,
3546 1, 1, &bit_off
, &len
);
3553 * The bucket may spread in many blocks, and
3554 * we will only touch the 1st block and the last block
3555 * in the whole bucket(one for entry and one for data).
3557 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, bit_off
);
3559 mlog(0, "allocate 1 cluster from %llu to xattr block\n",
3560 (unsigned long long)blkno
);
3562 ret
= ocfs2_init_xattr_bucket(xs
->bucket
, blkno
);
3568 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
3569 OCFS2_JOURNAL_ACCESS_CREATE
);
3575 ocfs2_cp_xattr_block_to_bucket(inode
, xb_bh
, xs
->bucket
);
3576 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
3578 ocfs2_xattr_update_xattr_search(inode
, xs
, xb_bh
);
3580 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
3581 memset(&xb
->xb_attrs
, 0, inode
->i_sb
->s_blocksize
-
3582 offsetof(struct ocfs2_xattr_block
, xb_attrs
));
3584 xr
= &xb
->xb_attrs
.xb_root
;
3585 xr
->xt_clusters
= cpu_to_le32(1);
3586 xr
->xt_last_eb_blk
= 0;
3587 xr
->xt_list
.l_tree_depth
= 0;
3588 xr
->xt_list
.l_count
= cpu_to_le16(ocfs2_xattr_recs_per_xb(inode
->i_sb
));
3589 xr
->xt_list
.l_next_free_rec
= cpu_to_le16(1);
3591 xr
->xt_list
.l_recs
[0].e_cpos
= 0;
3592 xr
->xt_list
.l_recs
[0].e_blkno
= cpu_to_le64(blkno
);
3593 xr
->xt_list
.l_recs
[0].e_leaf_clusters
= cpu_to_le16(1);
3595 xb
->xb_flags
= cpu_to_le16(xb_flags
| OCFS2_XATTR_INDEXED
);
3597 ocfs2_journal_dirty(handle
, xb_bh
);
3600 up_write(&oi
->ip_alloc_sem
);
3605 static int cmp_xe_offset(const void *a
, const void *b
)
3607 const struct ocfs2_xattr_entry
*l
= a
, *r
= b
;
3608 u32 l_name_offset
= le16_to_cpu(l
->xe_name_offset
);
3609 u32 r_name_offset
= le16_to_cpu(r
->xe_name_offset
);
3611 if (l_name_offset
< r_name_offset
)
3613 if (l_name_offset
> r_name_offset
)
3619 * defrag a xattr bucket if we find that the bucket has some
3620 * holes beteen name/value pairs.
3621 * We will move all the name/value pairs to the end of the bucket
3622 * so that we can spare some space for insertion.
3624 static int ocfs2_defrag_xattr_bucket(struct inode
*inode
,
3626 struct ocfs2_xattr_bucket
*bucket
)
3629 size_t end
, offset
, len
, value_len
;
3630 struct ocfs2_xattr_header
*xh
;
3631 char *entries
, *buf
, *bucket_buf
= NULL
;
3632 u64 blkno
= bucket_blkno(bucket
);
3634 size_t blocksize
= inode
->i_sb
->s_blocksize
;
3635 struct ocfs2_xattr_entry
*xe
;
3638 * In order to make the operation more efficient and generic,
3639 * we copy all the blocks into a contiguous memory and do the
3640 * defragment there, so if anything is error, we will not touch
3643 bucket_buf
= kmalloc(OCFS2_XATTR_BUCKET_SIZE
, GFP_NOFS
);
3650 for (i
= 0; i
< bucket
->bu_blocks
; i
++, buf
+= blocksize
)
3651 memcpy(buf
, bucket_block(bucket
, i
), blocksize
);
3653 ret
= ocfs2_xattr_bucket_journal_access(handle
, bucket
,
3654 OCFS2_JOURNAL_ACCESS_WRITE
);
3660 xh
= (struct ocfs2_xattr_header
*)bucket_buf
;
3661 entries
= (char *)xh
->xh_entries
;
3662 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
3664 mlog(0, "adjust xattr bucket in %llu, count = %u, "
3665 "xh_free_start = %u, xh_name_value_len = %u.\n",
3666 (unsigned long long)blkno
, le16_to_cpu(xh
->xh_count
),
3667 xh_free_start
, le16_to_cpu(xh
->xh_name_value_len
));
3670 * sort all the entries by their offset.
3671 * the largest will be the first, so that we can
3672 * move them to the end one by one.
3674 sort(entries
, le16_to_cpu(xh
->xh_count
),
3675 sizeof(struct ocfs2_xattr_entry
),
3676 cmp_xe_offset
, swap_xe
);
3678 /* Move all name/values to the end of the bucket. */
3679 xe
= xh
->xh_entries
;
3680 end
= OCFS2_XATTR_BUCKET_SIZE
;
3681 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++, xe
++) {
3682 offset
= le16_to_cpu(xe
->xe_name_offset
);
3683 if (ocfs2_xattr_is_local(xe
))
3684 value_len
= OCFS2_XATTR_SIZE(
3685 le64_to_cpu(xe
->xe_value_size
));
3687 value_len
= OCFS2_XATTR_ROOT_SIZE
;
3688 len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
) + value_len
;
3691 * We must make sure that the name/value pair
3692 * exist in the same block. So adjust end to
3693 * the previous block end if needed.
3695 if (((end
- len
) / blocksize
!=
3696 (end
- 1) / blocksize
))
3697 end
= end
- end
% blocksize
;
3699 if (end
> offset
+ len
) {
3700 memmove(bucket_buf
+ end
- len
,
3701 bucket_buf
+ offset
, len
);
3702 xe
->xe_name_offset
= cpu_to_le16(end
- len
);
3705 mlog_bug_on_msg(end
< offset
+ len
, "Defrag check failed for "
3706 "bucket %llu\n", (unsigned long long)blkno
);
3711 mlog_bug_on_msg(xh_free_start
> end
, "Defrag check failed for "
3712 "bucket %llu\n", (unsigned long long)blkno
);
3714 if (xh_free_start
== end
)
3717 memset(bucket_buf
+ xh_free_start
, 0, end
- xh_free_start
);
3718 xh
->xh_free_start
= cpu_to_le16(end
);
3720 /* sort the entries by their name_hash. */
3721 sort(entries
, le16_to_cpu(xh
->xh_count
),
3722 sizeof(struct ocfs2_xattr_entry
),
3726 for (i
= 0; i
< bucket
->bu_blocks
; i
++, buf
+= blocksize
)
3727 memcpy(bucket_block(bucket
, i
), buf
, blocksize
);
3728 ocfs2_xattr_bucket_journal_dirty(handle
, bucket
);
3736 * prev_blkno points to the start of an existing extent. new_blkno
3737 * points to a newly allocated extent. Because we know each of our
3738 * clusters contains more than bucket, we can easily split one cluster
3739 * at a bucket boundary. So we take the last cluster of the existing
3740 * extent and split it down the middle. We move the last half of the
3741 * buckets in the last cluster of the existing extent over to the new
3744 * first_bh is the buffer at prev_blkno so we can update the existing
3745 * extent's bucket count. header_bh is the bucket were we were hoping
3746 * to insert our xattr. If the bucket move places the target in the new
3747 * extent, we'll update first_bh and header_bh after modifying the old
3750 * first_hash will be set as the 1st xe's name_hash in the new extent.
3752 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode
*inode
,
3754 struct ocfs2_xattr_bucket
*first
,
3755 struct ocfs2_xattr_bucket
*target
,
3761 struct super_block
*sb
= inode
->i_sb
;
3762 int blks_per_bucket
= ocfs2_blocks_per_xattr_bucket(sb
);
3763 int num_buckets
= ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb
));
3764 int to_move
= num_buckets
/ 2;
3766 u64 last_cluster_blkno
= bucket_blkno(first
) +
3767 ((num_clusters
- 1) * ocfs2_clusters_to_blocks(sb
, 1));
3769 BUG_ON(le16_to_cpu(bucket_xh(first
)->xh_num_buckets
) < num_buckets
);
3770 BUG_ON(OCFS2_XATTR_BUCKET_SIZE
== OCFS2_SB(sb
)->s_clustersize
);
3772 mlog(0, "move half of xattrs in cluster %llu to %llu\n",
3773 (unsigned long long)last_cluster_blkno
, (unsigned long long)new_blkno
);
3775 ret
= ocfs2_mv_xattr_buckets(inode
, handle
, bucket_blkno(first
),
3776 last_cluster_blkno
, new_blkno
,
3777 to_move
, first_hash
);
3783 /* This is the first bucket that got moved */
3784 src_blkno
= last_cluster_blkno
+ (to_move
* blks_per_bucket
);
3787 * If the target bucket was part of the moved buckets, we need to
3788 * update first and target.
3790 if (bucket_blkno(target
) >= src_blkno
) {
3791 /* Find the block for the new target bucket */
3792 src_blkno
= new_blkno
+
3793 (bucket_blkno(target
) - src_blkno
);
3795 ocfs2_xattr_bucket_relse(first
);
3796 ocfs2_xattr_bucket_relse(target
);
3799 * These shouldn't fail - the buffers are in the
3800 * journal from ocfs2_cp_xattr_bucket().
3802 ret
= ocfs2_read_xattr_bucket(first
, new_blkno
);
3807 ret
= ocfs2_read_xattr_bucket(target
, src_blkno
);
3818 * Find the suitable pos when we divide a bucket into 2.
3819 * We have to make sure the xattrs with the same hash value exist
3820 * in the same bucket.
3822 * If this ocfs2_xattr_header covers more than one hash value, find a
3823 * place where the hash value changes. Try to find the most even split.
3824 * The most common case is that all entries have different hash values,
3825 * and the first check we make will find a place to split.
3827 static int ocfs2_xattr_find_divide_pos(struct ocfs2_xattr_header
*xh
)
3829 struct ocfs2_xattr_entry
*entries
= xh
->xh_entries
;
3830 int count
= le16_to_cpu(xh
->xh_count
);
3831 int delta
, middle
= count
/ 2;
3834 * We start at the middle. Each step gets farther away in both
3835 * directions. We therefore hit the change in hash value
3836 * nearest to the middle. Note that this loop does not execute for
3839 for (delta
= 0; delta
< middle
; delta
++) {
3840 /* Let's check delta earlier than middle */
3841 if (cmp_xe(&entries
[middle
- delta
- 1],
3842 &entries
[middle
- delta
]))
3843 return middle
- delta
;
3845 /* For even counts, don't walk off the end */
3846 if ((middle
+ delta
+ 1) == count
)
3849 /* Now try delta past middle */
3850 if (cmp_xe(&entries
[middle
+ delta
],
3851 &entries
[middle
+ delta
+ 1]))
3852 return middle
+ delta
+ 1;
3855 /* Every entry had the same hash */
3860 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
3861 * first_hash will record the 1st hash of the new bucket.
3863 * Normally half of the xattrs will be moved. But we have to make
3864 * sure that the xattrs with the same hash value are stored in the
3865 * same bucket. If all the xattrs in this bucket have the same hash
3866 * value, the new bucket will be initialized as an empty one and the
3867 * first_hash will be initialized as (hash_value+1).
3869 static int ocfs2_divide_xattr_bucket(struct inode
*inode
,
3874 int new_bucket_head
)
3877 int count
, start
, len
, name_value_len
= 0, xe_len
, name_offset
= 0;
3878 struct ocfs2_xattr_bucket
*s_bucket
= NULL
, *t_bucket
= NULL
;
3879 struct ocfs2_xattr_header
*xh
;
3880 struct ocfs2_xattr_entry
*xe
;
3881 int blocksize
= inode
->i_sb
->s_blocksize
;
3883 mlog(0, "move some of xattrs from bucket %llu to %llu\n",
3884 (unsigned long long)blk
, (unsigned long long)new_blk
);
3886 s_bucket
= ocfs2_xattr_bucket_new(inode
);
3887 t_bucket
= ocfs2_xattr_bucket_new(inode
);
3888 if (!s_bucket
|| !t_bucket
) {
3894 ret
= ocfs2_read_xattr_bucket(s_bucket
, blk
);
3900 ret
= ocfs2_xattr_bucket_journal_access(handle
, s_bucket
,
3901 OCFS2_JOURNAL_ACCESS_WRITE
);
3908 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
3909 * there's no need to read it.
3911 ret
= ocfs2_init_xattr_bucket(t_bucket
, new_blk
);
3918 * Hey, if we're overwriting t_bucket, what difference does
3919 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
3920 * same part of ocfs2_cp_xattr_bucket().
3922 ret
= ocfs2_xattr_bucket_journal_access(handle
, t_bucket
,
3924 OCFS2_JOURNAL_ACCESS_CREATE
:
3925 OCFS2_JOURNAL_ACCESS_WRITE
);
3931 xh
= bucket_xh(s_bucket
);
3932 count
= le16_to_cpu(xh
->xh_count
);
3933 start
= ocfs2_xattr_find_divide_pos(xh
);
3935 if (start
== count
) {
3936 xe
= &xh
->xh_entries
[start
-1];
3939 * initialized a new empty bucket here.
3940 * The hash value is set as one larger than
3941 * that of the last entry in the previous bucket.
3943 for (i
= 0; i
< t_bucket
->bu_blocks
; i
++)
3944 memset(bucket_block(t_bucket
, i
), 0, blocksize
);
3946 xh
= bucket_xh(t_bucket
);
3947 xh
->xh_free_start
= cpu_to_le16(blocksize
);
3948 xh
->xh_entries
[0].xe_name_hash
= xe
->xe_name_hash
;
3949 le32_add_cpu(&xh
->xh_entries
[0].xe_name_hash
, 1);
3951 goto set_num_buckets
;
3954 /* copy the whole bucket to the new first. */
3955 ocfs2_xattr_bucket_copy_data(t_bucket
, s_bucket
);
3957 /* update the new bucket. */
3958 xh
= bucket_xh(t_bucket
);
3961 * Calculate the total name/value len and xh_free_start for
3962 * the old bucket first.
3964 name_offset
= OCFS2_XATTR_BUCKET_SIZE
;
3966 for (i
= 0; i
< start
; i
++) {
3967 xe
= &xh
->xh_entries
[i
];
3968 xe_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
3969 if (ocfs2_xattr_is_local(xe
))
3971 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
3973 xe_len
+= OCFS2_XATTR_ROOT_SIZE
;
3974 name_value_len
+= xe_len
;
3975 if (le16_to_cpu(xe
->xe_name_offset
) < name_offset
)
3976 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
3980 * Now begin the modification to the new bucket.
3982 * In the new bucket, We just move the xattr entry to the beginning
3983 * and don't touch the name/value. So there will be some holes in the
3984 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
3987 xe
= &xh
->xh_entries
[start
];
3988 len
= sizeof(struct ocfs2_xattr_entry
) * (count
- start
);
3989 mlog(0, "mv xattr entry len %d from %d to %d\n", len
,
3990 (int)((char *)xe
- (char *)xh
),
3991 (int)((char *)xh
->xh_entries
- (char *)xh
));
3992 memmove((char *)xh
->xh_entries
, (char *)xe
, len
);
3993 xe
= &xh
->xh_entries
[count
- start
];
3994 len
= sizeof(struct ocfs2_xattr_entry
) * start
;
3995 memset((char *)xe
, 0, len
);
3997 le16_add_cpu(&xh
->xh_count
, -start
);
3998 le16_add_cpu(&xh
->xh_name_value_len
, -name_value_len
);
4000 /* Calculate xh_free_start for the new bucket. */
4001 xh
->xh_free_start
= cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
);
4002 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
4003 xe
= &xh
->xh_entries
[i
];
4004 xe_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
4005 if (ocfs2_xattr_is_local(xe
))
4007 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
4009 xe_len
+= OCFS2_XATTR_ROOT_SIZE
;
4010 if (le16_to_cpu(xe
->xe_name_offset
) <
4011 le16_to_cpu(xh
->xh_free_start
))
4012 xh
->xh_free_start
= xe
->xe_name_offset
;
4016 /* set xh->xh_num_buckets for the new xh. */
4017 if (new_bucket_head
)
4018 xh
->xh_num_buckets
= cpu_to_le16(1);
4020 xh
->xh_num_buckets
= 0;
4022 ocfs2_xattr_bucket_journal_dirty(handle
, t_bucket
);
4024 /* store the first_hash of the new bucket. */
4026 *first_hash
= le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
);
4029 * Now only update the 1st block of the old bucket. If we
4030 * just added a new empty bucket, there is no need to modify
4036 xh
= bucket_xh(s_bucket
);
4037 memset(&xh
->xh_entries
[start
], 0,
4038 sizeof(struct ocfs2_xattr_entry
) * (count
- start
));
4039 xh
->xh_count
= cpu_to_le16(start
);
4040 xh
->xh_free_start
= cpu_to_le16(name_offset
);
4041 xh
->xh_name_value_len
= cpu_to_le16(name_value_len
);
4043 ocfs2_xattr_bucket_journal_dirty(handle
, s_bucket
);
4046 ocfs2_xattr_bucket_free(s_bucket
);
4047 ocfs2_xattr_bucket_free(t_bucket
);
4053 * Copy xattr from one bucket to another bucket.
4055 * The caller must make sure that the journal transaction
4056 * has enough space for journaling.
4058 static int ocfs2_cp_xattr_bucket(struct inode
*inode
,
4065 struct ocfs2_xattr_bucket
*s_bucket
= NULL
, *t_bucket
= NULL
;
4067 BUG_ON(s_blkno
== t_blkno
);
4069 mlog(0, "cp bucket %llu to %llu, target is %d\n",
4070 (unsigned long long)s_blkno
, (unsigned long long)t_blkno
,
4073 s_bucket
= ocfs2_xattr_bucket_new(inode
);
4074 t_bucket
= ocfs2_xattr_bucket_new(inode
);
4075 if (!s_bucket
|| !t_bucket
) {
4081 ret
= ocfs2_read_xattr_bucket(s_bucket
, s_blkno
);
4086 * Even if !t_is_new, we're overwriting t_bucket. Thus,
4087 * there's no need to read it.
4089 ret
= ocfs2_init_xattr_bucket(t_bucket
, t_blkno
);
4094 * Hey, if we're overwriting t_bucket, what difference does
4095 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
4096 * cluster to fill, we came here from
4097 * ocfs2_mv_xattr_buckets(), and it is really new -
4098 * ACCESS_CREATE is required. But we also might have moved data
4099 * out of t_bucket before extending back into it.
4100 * ocfs2_add_new_xattr_bucket() can do this - its call to
4101 * ocfs2_add_new_xattr_cluster() may have created a new extent
4102 * and copied out the end of the old extent. Then it re-extends
4103 * the old extent back to create space for new xattrs. That's
4104 * how we get here, and the bucket isn't really new.
4106 ret
= ocfs2_xattr_bucket_journal_access(handle
, t_bucket
,
4108 OCFS2_JOURNAL_ACCESS_CREATE
:
4109 OCFS2_JOURNAL_ACCESS_WRITE
);
4113 ocfs2_xattr_bucket_copy_data(t_bucket
, s_bucket
);
4114 ocfs2_xattr_bucket_journal_dirty(handle
, t_bucket
);
4117 ocfs2_xattr_bucket_free(t_bucket
);
4118 ocfs2_xattr_bucket_free(s_bucket
);
4124 * src_blk points to the start of an existing extent. last_blk points to
4125 * last cluster in that extent. to_blk points to a newly allocated
4126 * extent. We copy the buckets from the cluster at last_blk to the new
4127 * extent. If start_bucket is non-zero, we skip that many buckets before
4128 * we start copying. The new extent's xh_num_buckets gets set to the
4129 * number of buckets we copied. The old extent's xh_num_buckets shrinks
4130 * by the same amount.
4132 static int ocfs2_mv_xattr_buckets(struct inode
*inode
, handle_t
*handle
,
4133 u64 src_blk
, u64 last_blk
, u64 to_blk
,
4134 unsigned int start_bucket
,
4137 int i
, ret
, credits
;
4138 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4139 int blks_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4140 int num_buckets
= ocfs2_xattr_buckets_per_cluster(osb
);
4141 struct ocfs2_xattr_bucket
*old_first
, *new_first
;
4143 mlog(0, "mv xattrs from cluster %llu to %llu\n",
4144 (unsigned long long)last_blk
, (unsigned long long)to_blk
);
4146 BUG_ON(start_bucket
>= num_buckets
);
4148 num_buckets
-= start_bucket
;
4149 last_blk
+= (start_bucket
* blks_per_bucket
);
4152 /* The first bucket of the original extent */
4153 old_first
= ocfs2_xattr_bucket_new(inode
);
4154 /* The first bucket of the new extent */
4155 new_first
= ocfs2_xattr_bucket_new(inode
);
4156 if (!old_first
|| !new_first
) {
4162 ret
= ocfs2_read_xattr_bucket(old_first
, src_blk
);
4169 * We need to update the first bucket of the old extent and all
4170 * the buckets going to the new extent.
4172 credits
= ((num_buckets
+ 1) * blks_per_bucket
) +
4173 handle
->h_buffer_credits
;
4174 ret
= ocfs2_extend_trans(handle
, credits
);
4180 ret
= ocfs2_xattr_bucket_journal_access(handle
, old_first
,
4181 OCFS2_JOURNAL_ACCESS_WRITE
);
4187 for (i
= 0; i
< num_buckets
; i
++) {
4188 ret
= ocfs2_cp_xattr_bucket(inode
, handle
,
4189 last_blk
+ (i
* blks_per_bucket
),
4190 to_blk
+ (i
* blks_per_bucket
),
4199 * Get the new bucket ready before we dirty anything
4200 * (This actually shouldn't fail, because we already dirtied
4201 * it once in ocfs2_cp_xattr_bucket()).
4203 ret
= ocfs2_read_xattr_bucket(new_first
, to_blk
);
4208 ret
= ocfs2_xattr_bucket_journal_access(handle
, new_first
,
4209 OCFS2_JOURNAL_ACCESS_WRITE
);
4215 /* Now update the headers */
4216 le16_add_cpu(&bucket_xh(old_first
)->xh_num_buckets
, -num_buckets
);
4217 ocfs2_xattr_bucket_journal_dirty(handle
, old_first
);
4219 bucket_xh(new_first
)->xh_num_buckets
= cpu_to_le16(num_buckets
);
4220 ocfs2_xattr_bucket_journal_dirty(handle
, new_first
);
4223 *first_hash
= le32_to_cpu(bucket_xh(new_first
)->xh_entries
[0].xe_name_hash
);
4226 ocfs2_xattr_bucket_free(new_first
);
4227 ocfs2_xattr_bucket_free(old_first
);
4232 * Move some xattrs in this cluster to the new cluster.
4233 * This function should only be called when bucket size == cluster size.
4234 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4236 static int ocfs2_divide_xattr_cluster(struct inode
*inode
,
4242 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4243 int ret
, credits
= 2 * blk_per_bucket
+ handle
->h_buffer_credits
;
4245 BUG_ON(OCFS2_XATTR_BUCKET_SIZE
< OCFS2_SB(inode
->i_sb
)->s_clustersize
);
4247 ret
= ocfs2_extend_trans(handle
, credits
);
4253 /* Move half of the xattr in start_blk to the next bucket. */
4254 return ocfs2_divide_xattr_bucket(inode
, handle
, prev_blk
,
4255 new_blk
, first_hash
, 1);
4259 * Move some xattrs from the old cluster to the new one since they are not
4260 * contiguous in ocfs2 xattr tree.
4262 * new_blk starts a new separate cluster, and we will move some xattrs from
4263 * prev_blk to it. v_start will be set as the first name hash value in this
4264 * new cluster so that it can be used as e_cpos during tree insertion and
4265 * don't collide with our original b-tree operations. first_bh and header_bh
4266 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
4267 * to extend the insert bucket.
4269 * The problem is how much xattr should we move to the new one and when should
4270 * we update first_bh and header_bh?
4271 * 1. If cluster size > bucket size, that means the previous cluster has more
4272 * than 1 bucket, so just move half nums of bucket into the new cluster and
4273 * update the first_bh and header_bh if the insert bucket has been moved
4274 * to the new cluster.
4275 * 2. If cluster_size == bucket_size:
4276 * a) If the previous extent rec has more than one cluster and the insert
4277 * place isn't in the last cluster, copy the entire last cluster to the
4278 * new one. This time, we don't need to upate the first_bh and header_bh
4279 * since they will not be moved into the new cluster.
4280 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
4281 * the new one. And we set the extend flag to zero if the insert place is
4282 * moved into the new allocated cluster since no extend is needed.
4284 static int ocfs2_adjust_xattr_cross_cluster(struct inode
*inode
,
4286 struct ocfs2_xattr_bucket
*first
,
4287 struct ocfs2_xattr_bucket
*target
,
4295 mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n",
4296 (unsigned long long)bucket_blkno(first
), prev_clusters
,
4297 (unsigned long long)new_blk
);
4299 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode
->i_sb
)) > 1) {
4300 ret
= ocfs2_mv_xattr_bucket_cross_cluster(inode
,
4309 /* The start of the last cluster in the first extent */
4310 u64 last_blk
= bucket_blkno(first
) +
4311 ((prev_clusters
- 1) *
4312 ocfs2_clusters_to_blocks(inode
->i_sb
, 1));
4314 if (prev_clusters
> 1 && bucket_blkno(target
) != last_blk
) {
4315 ret
= ocfs2_mv_xattr_buckets(inode
, handle
,
4316 bucket_blkno(first
),
4317 last_blk
, new_blk
, 0,
4322 ret
= ocfs2_divide_xattr_cluster(inode
, handle
,
4328 if ((bucket_blkno(target
) == last_blk
) && extend
)
4337 * Add a new cluster for xattr storage.
4339 * If the new cluster is contiguous with the previous one, it will be
4340 * appended to the same extent record, and num_clusters will be updated.
4341 * If not, we will insert a new extent for it and move some xattrs in
4342 * the last cluster into the new allocated one.
4343 * We also need to limit the maximum size of a btree leaf, otherwise we'll
4344 * lose the benefits of hashing because we'll have to search large leaves.
4345 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
4348 * first_bh is the first block of the previous extent rec and header_bh
4349 * indicates the bucket we will insert the new xattrs. They will be updated
4350 * when the header_bh is moved into the new cluster.
4352 static int ocfs2_add_new_xattr_cluster(struct inode
*inode
,
4353 struct buffer_head
*root_bh
,
4354 struct ocfs2_xattr_bucket
*first
,
4355 struct ocfs2_xattr_bucket
*target
,
4359 struct ocfs2_xattr_set_ctxt
*ctxt
)
4362 u16 bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
4363 u32 prev_clusters
= *num_clusters
;
4364 u32 clusters_to_add
= 1, bit_off
, num_bits
, v_start
= 0;
4366 handle_t
*handle
= ctxt
->handle
;
4367 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4368 struct ocfs2_extent_tree et
;
4370 mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, "
4371 "previous xattr blkno = %llu\n",
4372 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
4373 prev_cpos
, (unsigned long long)bucket_blkno(first
));
4375 ocfs2_init_xattr_tree_extent_tree(&et
, INODE_CACHE(inode
), root_bh
);
4377 ret
= ocfs2_journal_access_xb(handle
, INODE_CACHE(inode
), root_bh
,
4378 OCFS2_JOURNAL_ACCESS_WRITE
);
4384 ret
= __ocfs2_claim_clusters(osb
, handle
, ctxt
->data_ac
, 1,
4385 clusters_to_add
, &bit_off
, &num_bits
);
4392 BUG_ON(num_bits
> clusters_to_add
);
4394 block
= ocfs2_clusters_to_blocks(osb
->sb
, bit_off
);
4395 mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n",
4396 num_bits
, bit_off
, (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
4398 if (bucket_blkno(first
) + (prev_clusters
* bpc
) == block
&&
4399 (prev_clusters
+ num_bits
) << osb
->s_clustersize_bits
<=
4400 OCFS2_MAX_XATTR_TREE_LEAF_SIZE
) {
4402 * If this cluster is contiguous with the old one and
4403 * adding this new cluster, we don't surpass the limit of
4404 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
4405 * initialized and used like other buckets in the previous
4407 * So add it as a contiguous one. The caller will handle
4410 v_start
= prev_cpos
+ prev_clusters
;
4411 *num_clusters
= prev_clusters
+ num_bits
;
4412 mlog(0, "Add contiguous %u clusters to previous extent rec.\n",
4415 ret
= ocfs2_adjust_xattr_cross_cluster(inode
,
4429 mlog(0, "Insert %u clusters at block %llu for xattr at %u\n",
4430 num_bits
, (unsigned long long)block
, v_start
);
4431 ret
= ocfs2_insert_extent(handle
, &et
, v_start
, block
,
4432 num_bits
, 0, ctxt
->meta_ac
);
4438 ret
= ocfs2_journal_dirty(handle
, root_bh
);
4447 * We are given an extent. 'first' is the bucket at the very front of
4448 * the extent. The extent has space for an additional bucket past
4449 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
4450 * of the target bucket. We wish to shift every bucket past the target
4451 * down one, filling in that additional space. When we get back to the
4452 * target, we split the target between itself and the now-empty bucket
4453 * at target+1 (aka, target_blkno + blks_per_bucket).
4455 static int ocfs2_extend_xattr_bucket(struct inode
*inode
,
4457 struct ocfs2_xattr_bucket
*first
,
4462 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4463 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4465 u16 new_bucket
= le16_to_cpu(bucket_xh(first
)->xh_num_buckets
);
4467 mlog(0, "extend xattr bucket in %llu, xattr extend rec starting "
4468 "from %llu, len = %u\n", (unsigned long long)target_blk
,
4469 (unsigned long long)bucket_blkno(first
), num_clusters
);
4471 /* The extent must have room for an additional bucket */
4472 BUG_ON(new_bucket
>=
4473 (num_clusters
* ocfs2_xattr_buckets_per_cluster(osb
)));
4475 /* end_blk points to the last existing bucket */
4476 end_blk
= bucket_blkno(first
) + ((new_bucket
- 1) * blk_per_bucket
);
4479 * end_blk is the start of the last existing bucket.
4480 * Thus, (end_blk - target_blk) covers the target bucket and
4481 * every bucket after it up to, but not including, the last
4482 * existing bucket. Then we add the last existing bucket, the
4483 * new bucket, and the first bucket (3 * blk_per_bucket).
4485 credits
= (end_blk
- target_blk
) + (3 * blk_per_bucket
) +
4486 handle
->h_buffer_credits
;
4487 ret
= ocfs2_extend_trans(handle
, credits
);
4493 ret
= ocfs2_xattr_bucket_journal_access(handle
, first
,
4494 OCFS2_JOURNAL_ACCESS_WRITE
);
4500 while (end_blk
!= target_blk
) {
4501 ret
= ocfs2_cp_xattr_bucket(inode
, handle
, end_blk
,
4502 end_blk
+ blk_per_bucket
, 0);
4505 end_blk
-= blk_per_bucket
;
4508 /* Move half of the xattr in target_blkno to the next bucket. */
4509 ret
= ocfs2_divide_xattr_bucket(inode
, handle
, target_blk
,
4510 target_blk
+ blk_per_bucket
, NULL
, 0);
4512 le16_add_cpu(&bucket_xh(first
)->xh_num_buckets
, 1);
4513 ocfs2_xattr_bucket_journal_dirty(handle
, first
);
4520 * Add new xattr bucket in an extent record and adjust the buckets
4521 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
4522 * bucket we want to insert into.
4524 * In the easy case, we will move all the buckets after target down by
4525 * one. Half of target's xattrs will be moved to the next bucket.
4527 * If current cluster is full, we'll allocate a new one. This may not
4528 * be contiguous. The underlying calls will make sure that there is
4529 * space for the insert, shifting buckets around if necessary.
4530 * 'target' may be moved by those calls.
4532 static int ocfs2_add_new_xattr_bucket(struct inode
*inode
,
4533 struct buffer_head
*xb_bh
,
4534 struct ocfs2_xattr_bucket
*target
,
4535 struct ocfs2_xattr_set_ctxt
*ctxt
)
4537 struct ocfs2_xattr_block
*xb
=
4538 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
4539 struct ocfs2_xattr_tree_root
*xb_root
= &xb
->xb_attrs
.xb_root
;
4540 struct ocfs2_extent_list
*el
= &xb_root
->xt_list
;
4542 le32_to_cpu(bucket_xh(target
)->xh_entries
[0].xe_name_hash
);
4543 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4544 int ret
, num_buckets
, extend
= 1;
4546 u32 e_cpos
, num_clusters
;
4547 /* The bucket at the front of the extent */
4548 struct ocfs2_xattr_bucket
*first
;
4550 mlog(0, "Add new xattr bucket starting from %llu\n",
4551 (unsigned long long)bucket_blkno(target
));
4553 /* The first bucket of the original extent */
4554 first
= ocfs2_xattr_bucket_new(inode
);
4561 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
, &e_cpos
,
4568 ret
= ocfs2_read_xattr_bucket(first
, p_blkno
);
4574 num_buckets
= ocfs2_xattr_buckets_per_cluster(osb
) * num_clusters
;
4575 if (num_buckets
== le16_to_cpu(bucket_xh(first
)->xh_num_buckets
)) {
4577 * This can move first+target if the target bucket moves
4578 * to the new extent.
4580 ret
= ocfs2_add_new_xattr_cluster(inode
,
4595 ret
= ocfs2_extend_xattr_bucket(inode
,
4598 bucket_blkno(target
),
4605 ocfs2_xattr_bucket_free(first
);
4610 static inline char *ocfs2_xattr_bucket_get_val(struct inode
*inode
,
4611 struct ocfs2_xattr_bucket
*bucket
,
4614 int block_off
= offs
>> inode
->i_sb
->s_blocksize_bits
;
4616 offs
= offs
% inode
->i_sb
->s_blocksize
;
4617 return bucket_block(bucket
, block_off
) + offs
;
4621 * Handle the normal xattr set, including replace, delete and new.
4623 * Note: "local" indicates the real data's locality. So we can't
4624 * just its bucket locality by its length.
4626 static void ocfs2_xattr_set_entry_normal(struct inode
*inode
,
4627 struct ocfs2_xattr_info
*xi
,
4628 struct ocfs2_xattr_search
*xs
,
4632 struct ocfs2_xattr_entry
*last
, *xe
;
4633 int name_len
= strlen(xi
->name
);
4634 struct ocfs2_xattr_header
*xh
= xs
->header
;
4635 u16 count
= le16_to_cpu(xh
->xh_count
), start
;
4636 size_t blocksize
= inode
->i_sb
->s_blocksize
;
4638 size_t offs
, size
, new_size
;
4640 last
= &xh
->xh_entries
[count
];
4641 if (!xs
->not_found
) {
4643 offs
= le16_to_cpu(xe
->xe_name_offset
);
4644 if (ocfs2_xattr_is_local(xe
))
4645 size
= OCFS2_XATTR_SIZE(name_len
) +
4646 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
4648 size
= OCFS2_XATTR_SIZE(name_len
) +
4649 OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE
);
4652 * If the new value will be stored outside, xi->value has been
4653 * initalized as an empty ocfs2_xattr_value_root, and the same
4654 * goes with xi->value_len, so we can set new_size safely here.
4655 * See ocfs2_xattr_set_in_bucket.
4657 new_size
= OCFS2_XATTR_SIZE(name_len
) +
4658 OCFS2_XATTR_SIZE(xi
->value_len
);
4660 le16_add_cpu(&xh
->xh_name_value_len
, -size
);
4662 if (new_size
> size
)
4663 goto set_new_name_value
;
4665 /* Now replace the old value with new one. */
4667 xe
->xe_value_size
= cpu_to_le64(xi
->value_len
);
4669 xe
->xe_value_size
= 0;
4671 val
= ocfs2_xattr_bucket_get_val(inode
,
4673 memset(val
+ OCFS2_XATTR_SIZE(name_len
), 0,
4674 size
- OCFS2_XATTR_SIZE(name_len
));
4675 if (OCFS2_XATTR_SIZE(xi
->value_len
) > 0)
4676 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
4677 xi
->value
, xi
->value_len
);
4679 le16_add_cpu(&xh
->xh_name_value_len
, new_size
);
4680 ocfs2_xattr_set_local(xe
, local
);
4684 * Remove the old entry if there is more than one.
4685 * We don't remove the last entry so that we can
4686 * use it to indicate the hash value of the empty
4690 le16_add_cpu(&xh
->xh_count
, -1);
4693 (void *)last
- (void *)xe
);
4695 sizeof(struct ocfs2_xattr_entry
));
4698 cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
);
4703 /* find a new entry for insert. */
4704 int low
= 0, high
= count
- 1, tmp
;
4705 struct ocfs2_xattr_entry
*tmp_xe
;
4707 while (low
<= high
&& count
) {
4708 tmp
= (low
+ high
) / 2;
4709 tmp_xe
= &xh
->xh_entries
[tmp
];
4711 if (name_hash
> le32_to_cpu(tmp_xe
->xe_name_hash
))
4713 else if (name_hash
<
4714 le32_to_cpu(tmp_xe
->xe_name_hash
))
4722 xe
= &xh
->xh_entries
[low
];
4724 memmove(xe
+ 1, xe
, (void *)last
- (void *)xe
);
4726 le16_add_cpu(&xh
->xh_count
, 1);
4727 memset(xe
, 0, sizeof(struct ocfs2_xattr_entry
));
4728 xe
->xe_name_hash
= cpu_to_le32(name_hash
);
4729 xe
->xe_name_len
= name_len
;
4730 ocfs2_xattr_set_type(xe
, xi
->name_index
);
4734 /* Insert the new name+value. */
4735 size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_SIZE(xi
->value_len
);
4738 * We must make sure that the name/value pair
4739 * exists in the same block.
4741 offs
= le16_to_cpu(xh
->xh_free_start
);
4742 start
= offs
- size
;
4744 if (start
>> inode
->i_sb
->s_blocksize_bits
!=
4745 (offs
- 1) >> inode
->i_sb
->s_blocksize_bits
) {
4746 offs
= offs
- offs
% blocksize
;
4747 xh
->xh_free_start
= cpu_to_le16(offs
);
4750 val
= ocfs2_xattr_bucket_get_val(inode
, xs
->bucket
, offs
- size
);
4751 xe
->xe_name_offset
= cpu_to_le16(offs
- size
);
4753 memset(val
, 0, size
);
4754 memcpy(val
, xi
->name
, name_len
);
4755 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
), xi
->value
, xi
->value_len
);
4757 xe
->xe_value_size
= cpu_to_le64(xi
->value_len
);
4758 ocfs2_xattr_set_local(xe
, local
);
4760 le16_add_cpu(&xh
->xh_free_start
, -size
);
4761 le16_add_cpu(&xh
->xh_name_value_len
, size
);
4767 * Set the xattr entry in the specified bucket.
4768 * The bucket is indicated by xs->bucket and it should have the enough
4769 * space for the xattr insertion.
4771 static int ocfs2_xattr_set_entry_in_bucket(struct inode
*inode
,
4773 struct ocfs2_xattr_info
*xi
,
4774 struct ocfs2_xattr_search
*xs
,
4781 mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n",
4782 (unsigned long)xi
->value_len
, xi
->name_index
,
4783 (unsigned long long)bucket_blkno(xs
->bucket
));
4785 if (!xs
->bucket
->bu_bhs
[1]) {
4786 blkno
= bucket_blkno(xs
->bucket
);
4787 ocfs2_xattr_bucket_relse(xs
->bucket
);
4788 ret
= ocfs2_read_xattr_bucket(xs
->bucket
, blkno
);
4795 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
4796 OCFS2_JOURNAL_ACCESS_WRITE
);
4802 ocfs2_xattr_set_entry_normal(inode
, xi
, xs
, name_hash
, local
);
4803 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
4810 * Truncate the specified xe_off entry in xattr bucket.
4811 * bucket is indicated by header_bh and len is the new length.
4812 * Both the ocfs2_xattr_value_root and the entry will be updated here.
4814 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
4816 static int ocfs2_xattr_bucket_value_truncate(struct inode
*inode
,
4817 struct ocfs2_xattr_bucket
*bucket
,
4820 struct ocfs2_xattr_set_ctxt
*ctxt
)
4824 struct ocfs2_xattr_entry
*xe
;
4825 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
4826 size_t blocksize
= inode
->i_sb
->s_blocksize
;
4827 struct ocfs2_xattr_value_buf vb
= {
4828 .vb_access
= ocfs2_journal_access
,
4831 xe
= &xh
->xh_entries
[xe_off
];
4833 BUG_ON(!xe
|| ocfs2_xattr_is_local(xe
));
4835 offset
= le16_to_cpu(xe
->xe_name_offset
) +
4836 OCFS2_XATTR_SIZE(xe
->xe_name_len
);
4838 value_blk
= offset
/ blocksize
;
4840 /* We don't allow ocfs2_xattr_value to be stored in different block. */
4841 BUG_ON(value_blk
!= (offset
+ OCFS2_XATTR_ROOT_SIZE
- 1) / blocksize
);
4843 vb
.vb_bh
= bucket
->bu_bhs
[value_blk
];
4846 vb
.vb_xv
= (struct ocfs2_xattr_value_root
*)
4847 (vb
.vb_bh
->b_data
+ offset
% blocksize
);
4850 * From here on out we have to dirty the bucket. The generic
4851 * value calls only modify one of the bucket's bhs, but we need
4852 * to send the bucket at once. So if they error, they *could* have
4853 * modified something. We have to assume they did, and dirty
4854 * the whole bucket. This leaves us in a consistent state.
4856 mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n",
4857 xe_off
, (unsigned long long)bucket_blkno(bucket
), len
);
4858 ret
= ocfs2_xattr_value_truncate(inode
, &vb
, len
, ctxt
);
4864 ret
= ocfs2_xattr_bucket_journal_access(ctxt
->handle
, bucket
,
4865 OCFS2_JOURNAL_ACCESS_WRITE
);
4871 xe
->xe_value_size
= cpu_to_le64(len
);
4873 ocfs2_xattr_bucket_journal_dirty(ctxt
->handle
, bucket
);
4879 static int ocfs2_xattr_bucket_value_truncate_xs(struct inode
*inode
,
4880 struct ocfs2_xattr_search
*xs
,
4882 struct ocfs2_xattr_set_ctxt
*ctxt
)
4885 struct ocfs2_xattr_entry
*xe
= xs
->here
;
4886 struct ocfs2_xattr_header
*xh
= (struct ocfs2_xattr_header
*)xs
->base
;
4888 BUG_ON(!xs
->bucket
->bu_bhs
[0] || !xe
|| ocfs2_xattr_is_local(xe
));
4890 offset
= xe
- xh
->xh_entries
;
4891 ret
= ocfs2_xattr_bucket_value_truncate(inode
, xs
->bucket
,
4899 static int ocfs2_xattr_bucket_set_value_outside(struct inode
*inode
,
4901 struct ocfs2_xattr_search
*xs
,
4905 int ret
, offset
, block_off
;
4906 struct ocfs2_xattr_value_root
*xv
;
4907 struct ocfs2_xattr_entry
*xe
= xs
->here
;
4908 struct ocfs2_xattr_header
*xh
= bucket_xh(xs
->bucket
);
4910 struct ocfs2_xattr_value_buf vb
= {
4911 .vb_access
= ocfs2_journal_access
,
4914 BUG_ON(!xs
->base
|| !xe
|| ocfs2_xattr_is_local(xe
));
4916 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
, xh
,
4917 xe
- xh
->xh_entries
,
4925 base
= bucket_block(xs
->bucket
, block_off
);
4926 xv
= (struct ocfs2_xattr_value_root
*)(base
+ offset
+
4927 OCFS2_XATTR_SIZE(xe
->xe_name_len
));
4930 vb
.vb_bh
= xs
->bucket
->bu_bhs
[block_off
];
4931 ret
= __ocfs2_xattr_set_value_outside(inode
, handle
,
4932 &vb
, val
, value_len
);
4939 static int ocfs2_rm_xattr_cluster(struct inode
*inode
,
4940 struct buffer_head
*root_bh
,
4947 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4948 struct inode
*tl_inode
= osb
->osb_tl_inode
;
4950 struct ocfs2_xattr_block
*xb
=
4951 (struct ocfs2_xattr_block
*)root_bh
->b_data
;
4952 struct ocfs2_alloc_context
*meta_ac
= NULL
;
4953 struct ocfs2_cached_dealloc_ctxt dealloc
;
4954 struct ocfs2_extent_tree et
;
4956 ret
= ocfs2_iterate_xattr_buckets(inode
, blkno
, len
,
4957 ocfs2_delete_xattr_in_bucket
, NULL
);
4963 ocfs2_init_xattr_tree_extent_tree(&et
, INODE_CACHE(inode
), root_bh
);
4965 ocfs2_init_dealloc_ctxt(&dealloc
);
4967 mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n",
4968 cpos
, len
, (unsigned long long)blkno
);
4970 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode
), blkno
,
4973 ret
= ocfs2_lock_allocators(inode
, &et
, 0, 1, NULL
, &meta_ac
);
4979 mutex_lock(&tl_inode
->i_mutex
);
4981 if (ocfs2_truncate_log_needs_flush(osb
)) {
4982 ret
= __ocfs2_flush_truncate_log(osb
);
4989 handle
= ocfs2_start_trans(osb
, ocfs2_remove_extent_credits(osb
->sb
));
4990 if (IS_ERR(handle
)) {
4996 ret
= ocfs2_journal_access_xb(handle
, INODE_CACHE(inode
), root_bh
,
4997 OCFS2_JOURNAL_ACCESS_WRITE
);
5003 ret
= ocfs2_remove_extent(handle
, &et
, cpos
, len
, meta_ac
,
5010 le32_add_cpu(&xb
->xb_attrs
.xb_root
.xt_clusters
, -len
);
5012 ret
= ocfs2_journal_dirty(handle
, root_bh
);
5018 ret
= ocfs2_truncate_log_append(osb
, handle
, blkno
, len
);
5023 ocfs2_commit_trans(osb
, handle
);
5025 ocfs2_schedule_truncate_log_flush(osb
, 1);
5027 mutex_unlock(&tl_inode
->i_mutex
);
5030 ocfs2_free_alloc_context(meta_ac
);
5032 ocfs2_run_deallocs(osb
, &dealloc
);
5037 static void ocfs2_xattr_bucket_remove_xs(struct inode
*inode
,
5039 struct ocfs2_xattr_search
*xs
)
5041 struct ocfs2_xattr_header
*xh
= bucket_xh(xs
->bucket
);
5042 struct ocfs2_xattr_entry
*last
= &xh
->xh_entries
[
5043 le16_to_cpu(xh
->xh_count
) - 1];
5046 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
5047 OCFS2_JOURNAL_ACCESS_WRITE
);
5053 /* Remove the old entry. */
5054 memmove(xs
->here
, xs
->here
+ 1,
5055 (void *)last
- (void *)xs
->here
);
5056 memset(last
, 0, sizeof(struct ocfs2_xattr_entry
));
5057 le16_add_cpu(&xh
->xh_count
, -1);
5059 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
5063 * Set the xattr name/value in the bucket specified in xs.
5065 * As the new value in xi may be stored in the bucket or in an outside cluster,
5066 * we divide the whole process into 3 steps:
5067 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
5068 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
5069 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
5070 * 4. If the clusters for the new outside value can't be allocated, we need
5071 * to free the xattr we allocated in set.
5073 static int ocfs2_xattr_set_in_bucket(struct inode
*inode
,
5074 struct ocfs2_xattr_info
*xi
,
5075 struct ocfs2_xattr_search
*xs
,
5076 struct ocfs2_xattr_set_ctxt
*ctxt
)
5080 char *val
= (char *)xi
->value
;
5081 struct ocfs2_xattr_entry
*xe
= xs
->here
;
5082 u32 name_hash
= ocfs2_xattr_name_hash(inode
, xi
->name
,
5085 if (!xs
->not_found
&& !ocfs2_xattr_is_local(xe
)) {
5087 * We need to truncate the xattr storage first.
5089 * If both the old and new value are stored to
5090 * outside block, we only need to truncate
5091 * the storage and then set the value outside.
5093 * If the new value should be stored within block,
5094 * we should free all the outside block first and
5095 * the modification to the xattr block will be done
5096 * by following steps.
5098 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
5099 value_len
= xi
->value_len
;
5103 ret
= ocfs2_xattr_bucket_value_truncate_xs(inode
, xs
,
5110 goto set_value_outside
;
5113 value_len
= xi
->value_len
;
5114 /* So we have to handle the inside block change now. */
5115 if (value_len
> OCFS2_XATTR_INLINE_SIZE
) {
5117 * If the new value will be stored outside of block,
5118 * initalize a new empty value root and insert it first.
5121 xi
->value
= &def_xv
;
5122 xi
->value_len
= OCFS2_XATTR_ROOT_SIZE
;
5125 ret
= ocfs2_xattr_set_entry_in_bucket(inode
, ctxt
->handle
, xi
, xs
,
5132 if (value_len
<= OCFS2_XATTR_INLINE_SIZE
)
5135 /* allocate the space now for the outside block storage. */
5136 ret
= ocfs2_xattr_bucket_value_truncate_xs(inode
, xs
,
5141 if (xs
->not_found
) {
5143 * We can't allocate enough clusters for outside
5144 * storage and we have allocated xattr already,
5145 * so need to remove it.
5147 ocfs2_xattr_bucket_remove_xs(inode
, ctxt
->handle
, xs
);
5153 ret
= ocfs2_xattr_bucket_set_value_outside(inode
, ctxt
->handle
,
5154 xs
, val
, value_len
);
5160 * check whether the xattr bucket is filled up with the same hash value.
5161 * If we want to insert the xattr with the same hash, return -ENOSPC.
5162 * If we want to insert a xattr with different hash value, go ahead
5163 * and ocfs2_divide_xattr_bucket will handle this.
5165 static int ocfs2_check_xattr_bucket_collision(struct inode
*inode
,
5166 struct ocfs2_xattr_bucket
*bucket
,
5169 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
5170 u32 name_hash
= ocfs2_xattr_name_hash(inode
, name
, strlen(name
));
5172 if (name_hash
!= le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
))
5175 if (xh
->xh_entries
[le16_to_cpu(xh
->xh_count
) - 1].xe_name_hash
==
5176 xh
->xh_entries
[0].xe_name_hash
) {
5177 mlog(ML_ERROR
, "Too much hash collision in xattr bucket %llu, "
5179 (unsigned long long)bucket_blkno(bucket
),
5180 le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
));
5187 static int ocfs2_xattr_set_entry_index_block(struct inode
*inode
,
5188 struct ocfs2_xattr_info
*xi
,
5189 struct ocfs2_xattr_search
*xs
,
5190 struct ocfs2_xattr_set_ctxt
*ctxt
)
5192 struct ocfs2_xattr_header
*xh
;
5193 struct ocfs2_xattr_entry
*xe
;
5194 u16 count
, header_size
, xh_free_start
;
5195 int free
, max_free
, need
, old
;
5196 size_t value_size
= 0, name_len
= strlen(xi
->name
);
5197 size_t blocksize
= inode
->i_sb
->s_blocksize
;
5198 int ret
, allocation
= 0;
5200 mlog_entry("Set xattr %s in xattr index block\n", xi
->name
);
5204 count
= le16_to_cpu(xh
->xh_count
);
5205 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
5206 header_size
= sizeof(struct ocfs2_xattr_header
) +
5207 count
* sizeof(struct ocfs2_xattr_entry
);
5208 max_free
= OCFS2_XATTR_BUCKET_SIZE
- header_size
-
5209 le16_to_cpu(xh
->xh_name_value_len
) - OCFS2_XATTR_HEADER_GAP
;
5211 mlog_bug_on_msg(header_size
> blocksize
, "bucket %llu has header size "
5212 "of %u which exceed block size\n",
5213 (unsigned long long)bucket_blkno(xs
->bucket
),
5216 if (xi
->value
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
5217 value_size
= OCFS2_XATTR_ROOT_SIZE
;
5219 value_size
= OCFS2_XATTR_SIZE(xi
->value_len
);
5222 need
= sizeof(struct ocfs2_xattr_entry
) +
5223 OCFS2_XATTR_SIZE(name_len
) + value_size
;
5225 need
= value_size
+ OCFS2_XATTR_SIZE(name_len
);
5228 * We only replace the old value if the new length is smaller
5229 * than the old one. Otherwise we will allocate new space in the
5230 * bucket to store it.
5233 if (ocfs2_xattr_is_local(xe
))
5234 old
= OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
5236 old
= OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE
);
5238 if (old
>= value_size
)
5242 free
= xh_free_start
- header_size
- OCFS2_XATTR_HEADER_GAP
;
5244 * We need to make sure the new name/value pair
5245 * can exist in the same block.
5247 if (xh_free_start
% blocksize
< need
)
5248 free
-= xh_free_start
% blocksize
;
5250 mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, "
5251 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
5252 " %u\n", xs
->not_found
,
5253 (unsigned long long)bucket_blkno(xs
->bucket
),
5254 free
, need
, max_free
, le16_to_cpu(xh
->xh_free_start
),
5255 le16_to_cpu(xh
->xh_name_value_len
));
5259 count
== ocfs2_xattr_max_xe_in_bucket(inode
->i_sb
))) {
5260 if (need
<= max_free
&&
5261 count
< ocfs2_xattr_max_xe_in_bucket(inode
->i_sb
)) {
5263 * We can create the space by defragment. Since only the
5264 * name/value will be moved, the xe shouldn't be changed
5267 ret
= ocfs2_defrag_xattr_bucket(inode
, ctxt
->handle
,
5274 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
5275 free
= xh_free_start
- header_size
5276 - OCFS2_XATTR_HEADER_GAP
;
5277 if (xh_free_start
% blocksize
< need
)
5278 free
-= xh_free_start
% blocksize
;
5283 mlog(0, "Can't get enough space for xattr insert by "
5284 "defragment. Need %u bytes, but we have %d, so "
5285 "allocate new bucket for it.\n", need
, free
);
5289 * We have to add new buckets or clusters and one
5290 * allocation should leave us enough space for insert.
5295 * We do not allow for overlapping ranges between buckets. And
5296 * the maximum number of collisions we will allow for then is
5297 * one bucket's worth, so check it here whether we need to
5298 * add a new bucket for the insert.
5300 ret
= ocfs2_check_xattr_bucket_collision(inode
,
5308 ret
= ocfs2_add_new_xattr_bucket(inode
,
5318 * ocfs2_add_new_xattr_bucket() will have updated
5319 * xs->bucket if it moved, but it will not have updated
5320 * any of the other search fields. Thus, we drop it and
5321 * re-search. Everything should be cached, so it'll be
5324 ocfs2_xattr_bucket_relse(xs
->bucket
);
5325 ret
= ocfs2_xattr_index_block_find(inode
, xs
->xattr_bh
,
5328 if (ret
&& ret
!= -ENODATA
)
5330 xs
->not_found
= ret
;
5336 ret
= ocfs2_xattr_set_in_bucket(inode
, xi
, xs
, ctxt
);
5342 static int ocfs2_delete_xattr_in_bucket(struct inode
*inode
,
5343 struct ocfs2_xattr_bucket
*bucket
,
5347 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
5349 struct ocfs2_xattr_entry
*xe
;
5350 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5351 struct ocfs2_xattr_set_ctxt ctxt
= {NULL
, NULL
,};
5352 int credits
= ocfs2_remove_extent_credits(osb
->sb
) +
5353 ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
5356 ocfs2_init_dealloc_ctxt(&ctxt
.dealloc
);
5358 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
5359 xe
= &xh
->xh_entries
[i
];
5360 if (ocfs2_xattr_is_local(xe
))
5363 ctxt
.handle
= ocfs2_start_trans(osb
, credits
);
5364 if (IS_ERR(ctxt
.handle
)) {
5365 ret
= PTR_ERR(ctxt
.handle
);
5370 ret
= ocfs2_xattr_bucket_value_truncate(inode
, bucket
,
5373 ocfs2_commit_trans(osb
, ctxt
.handle
);
5380 ocfs2_schedule_truncate_log_flush(osb
, 1);
5381 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
5386 * Whenever we modify a xattr value root in the bucket(e.g, CoW
5387 * or change the extent record flag), we need to recalculate
5388 * the metaecc for the whole bucket. So it is done here.
5391 * We have to give the extra credits for the caller.
5393 static int ocfs2_xattr_bucket_post_refcount(struct inode
*inode
,
5398 struct ocfs2_xattr_bucket
*bucket
=
5399 (struct ocfs2_xattr_bucket
*)para
;
5401 ret
= ocfs2_xattr_bucket_journal_access(handle
, bucket
,
5402 OCFS2_JOURNAL_ACCESS_WRITE
);
5408 ocfs2_xattr_bucket_journal_dirty(handle
, bucket
);
5414 * Special action we need if the xattr value is refcounted.
5416 * 1. If the xattr is refcounted, lock the tree.
5417 * 2. CoW the xattr if we are setting the new value and the value
5418 * will be stored outside.
5419 * 3. In other case, decrease_refcount will work for us, so just
5420 * lock the refcount tree, calculate the meta and credits is OK.
5422 * We have to do CoW before ocfs2_init_xattr_set_ctxt since
5423 * currently CoW is a completed transaction, while this function
5424 * will also lock the allocators and let us deadlock. So we will
5425 * CoW the whole xattr value.
5427 static int ocfs2_prepare_refcount_xattr(struct inode
*inode
,
5428 struct ocfs2_dinode
*di
,
5429 struct ocfs2_xattr_info
*xi
,
5430 struct ocfs2_xattr_search
*xis
,
5431 struct ocfs2_xattr_search
*xbs
,
5432 struct ocfs2_refcount_tree
**ref_tree
,
5437 struct ocfs2_xattr_block
*xb
;
5438 struct ocfs2_xattr_entry
*xe
;
5440 u32 p_cluster
, num_clusters
;
5441 unsigned int ext_flags
;
5442 int name_offset
, name_len
;
5443 struct ocfs2_xattr_value_buf vb
;
5444 struct ocfs2_xattr_bucket
*bucket
= NULL
;
5445 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5446 struct ocfs2_post_refcount refcount
;
5447 struct ocfs2_post_refcount
*p
= NULL
;
5448 struct buffer_head
*ref_root_bh
= NULL
;
5450 if (!xis
->not_found
) {
5452 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
5453 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
5455 vb
.vb_bh
= xis
->inode_bh
;
5456 vb
.vb_access
= ocfs2_journal_access_di
;
5458 int i
, block_off
= 0;
5459 xb
= (struct ocfs2_xattr_block
*)xbs
->xattr_bh
->b_data
;
5461 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
5462 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
5463 i
= xbs
->here
- xbs
->header
->xh_entries
;
5465 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
5466 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
5467 bucket_xh(xbs
->bucket
),
5474 base
= bucket_block(xbs
->bucket
, block_off
);
5475 vb
.vb_bh
= xbs
->bucket
->bu_bhs
[block_off
];
5476 vb
.vb_access
= ocfs2_journal_access
;
5478 if (ocfs2_meta_ecc(osb
)) {
5479 /*create parameters for ocfs2_post_refcount. */
5480 bucket
= xbs
->bucket
;
5481 refcount
.credits
= bucket
->bu_blocks
;
5482 refcount
.para
= bucket
;
5484 ocfs2_xattr_bucket_post_refcount
;
5489 vb
.vb_bh
= xbs
->xattr_bh
;
5490 vb
.vb_access
= ocfs2_journal_access_xb
;
5494 if (ocfs2_xattr_is_local(xe
))
5497 vb
.vb_xv
= (struct ocfs2_xattr_value_root
*)
5498 (base
+ name_offset
+ name_len
);
5500 ret
= ocfs2_xattr_get_clusters(inode
, 0, &p_cluster
,
5501 &num_clusters
, &vb
.vb_xv
->xr_list
,
5509 * We just need to check the 1st extent record, since we always
5510 * CoW the whole xattr. So there shouldn't be a xattr with
5511 * some REFCOUNT extent recs after the 1st one.
5513 if (!(ext_flags
& OCFS2_EXT_REFCOUNTED
))
5516 ret
= ocfs2_lock_refcount_tree(osb
, le64_to_cpu(di
->i_refcount_loc
),
5517 1, ref_tree
, &ref_root_bh
);
5524 * If we are deleting the xattr or the new size will be stored inside,
5525 * cool, leave it there, the xattr truncate process will remove them
5526 * for us(it still needs the refcount tree lock and the meta, credits).
5527 * And the worse case is that every cluster truncate will split the
5528 * refcount tree, and make the original extent become 3. So we will need
5529 * 2 * cluster more extent recs at most.
5531 if (!xi
->value
|| xi
->value_len
<= OCFS2_XATTR_INLINE_SIZE
) {
5533 ret
= ocfs2_refcounted_xattr_delete_need(inode
,
5534 &(*ref_tree
)->rf_ci
,
5535 ref_root_bh
, vb
.vb_xv
,
5542 ret
= ocfs2_refcount_cow_xattr(inode
, di
, &vb
,
5543 *ref_tree
, ref_root_bh
, 0,
5544 le32_to_cpu(vb
.vb_xv
->xr_clusters
), p
);
5549 brelse(ref_root_bh
);
5554 * Add the REFCOUNTED flags for all the extent rec in ocfs2_xattr_value_root.
5555 * The physical clusters will be added to refcount tree.
5557 static int ocfs2_xattr_value_attach_refcount(struct inode
*inode
,
5558 struct ocfs2_xattr_value_root
*xv
,
5559 struct ocfs2_extent_tree
*value_et
,
5560 struct ocfs2_caching_info
*ref_ci
,
5561 struct buffer_head
*ref_root_bh
,
5562 struct ocfs2_cached_dealloc_ctxt
*dealloc
,
5563 struct ocfs2_post_refcount
*refcount
)
5566 u32 clusters
= le32_to_cpu(xv
->xr_clusters
);
5567 u32 cpos
, p_cluster
, num_clusters
;
5568 struct ocfs2_extent_list
*el
= &xv
->xr_list
;
5569 unsigned int ext_flags
;
5572 while (cpos
< clusters
) {
5573 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &p_cluster
,
5574 &num_clusters
, el
, &ext_flags
);
5576 cpos
+= num_clusters
;
5577 if ((ext_flags
& OCFS2_EXT_REFCOUNTED
))
5582 ret
= ocfs2_add_refcount_flag(inode
, value_et
,
5583 ref_ci
, ref_root_bh
,
5584 cpos
- num_clusters
,
5585 p_cluster
, num_clusters
,
5597 * Given a normal ocfs2_xattr_header, refcount all the entries which
5598 * have value stored outside.
5599 * Used for xattrs stored in inode and ocfs2_xattr_block.
5601 static int ocfs2_xattr_attach_refcount_normal(struct inode
*inode
,
5602 struct ocfs2_xattr_value_buf
*vb
,
5603 struct ocfs2_xattr_header
*header
,
5604 struct ocfs2_caching_info
*ref_ci
,
5605 struct buffer_head
*ref_root_bh
,
5606 struct ocfs2_cached_dealloc_ctxt
*dealloc
)
5609 struct ocfs2_xattr_entry
*xe
;
5610 struct ocfs2_xattr_value_root
*xv
;
5611 struct ocfs2_extent_tree et
;
5614 for (i
= 0; i
< le16_to_cpu(header
->xh_count
); i
++) {
5615 xe
= &header
->xh_entries
[i
];
5617 if (ocfs2_xattr_is_local(xe
))
5620 xv
= (struct ocfs2_xattr_value_root
*)((void *)header
+
5621 le16_to_cpu(xe
->xe_name_offset
) +
5622 OCFS2_XATTR_SIZE(xe
->xe_name_len
));
5625 ocfs2_init_xattr_value_extent_tree(&et
, INODE_CACHE(inode
), vb
);
5627 ret
= ocfs2_xattr_value_attach_refcount(inode
, xv
, &et
,
5628 ref_ci
, ref_root_bh
,
5639 static int ocfs2_xattr_inline_attach_refcount(struct inode
*inode
,
5640 struct buffer_head
*fe_bh
,
5641 struct ocfs2_caching_info
*ref_ci
,
5642 struct buffer_head
*ref_root_bh
,
5643 struct ocfs2_cached_dealloc_ctxt
*dealloc
)
5645 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)fe_bh
->b_data
;
5646 struct ocfs2_xattr_header
*header
= (struct ocfs2_xattr_header
*)
5647 (fe_bh
->b_data
+ inode
->i_sb
->s_blocksize
-
5648 le16_to_cpu(di
->i_xattr_inline_size
));
5649 struct ocfs2_xattr_value_buf vb
= {
5651 .vb_access
= ocfs2_journal_access_di
,
5654 return ocfs2_xattr_attach_refcount_normal(inode
, &vb
, header
,
5655 ref_ci
, ref_root_bh
, dealloc
);
5658 struct ocfs2_xattr_tree_value_refcount_para
{
5659 struct ocfs2_caching_info
*ref_ci
;
5660 struct buffer_head
*ref_root_bh
;
5661 struct ocfs2_cached_dealloc_ctxt
*dealloc
;
5664 static int ocfs2_get_xattr_tree_value_root(struct super_block
*sb
,
5665 struct ocfs2_xattr_bucket
*bucket
,
5667 struct ocfs2_xattr_value_root
**xv
,
5668 struct buffer_head
**bh
)
5670 int ret
, block_off
, name_offset
;
5671 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
5672 struct ocfs2_xattr_entry
*xe
= &xh
->xh_entries
[offset
];
5675 ret
= ocfs2_xattr_bucket_get_name_value(sb
,
5685 base
= bucket_block(bucket
, block_off
);
5687 *xv
= (struct ocfs2_xattr_value_root
*)(base
+ name_offset
+
5688 OCFS2_XATTR_SIZE(xe
->xe_name_len
));
5691 *bh
= bucket
->bu_bhs
[block_off
];
5697 * For a given xattr bucket, refcount all the entries which
5698 * have value stored outside.
5700 static int ocfs2_xattr_bucket_value_refcount(struct inode
*inode
,
5701 struct ocfs2_xattr_bucket
*bucket
,
5705 struct ocfs2_extent_tree et
;
5706 struct ocfs2_xattr_tree_value_refcount_para
*ref
=
5707 (struct ocfs2_xattr_tree_value_refcount_para
*)para
;
5708 struct ocfs2_xattr_header
*xh
=
5709 (struct ocfs2_xattr_header
*)bucket
->bu_bhs
[0]->b_data
;
5710 struct ocfs2_xattr_entry
*xe
;
5711 struct ocfs2_xattr_value_buf vb
= {
5712 .vb_access
= ocfs2_journal_access
,
5714 struct ocfs2_post_refcount refcount
= {
5715 .credits
= bucket
->bu_blocks
,
5717 .func
= ocfs2_xattr_bucket_post_refcount
,
5719 struct ocfs2_post_refcount
*p
= NULL
;
5721 /* We only need post_refcount if we support metaecc. */
5722 if (ocfs2_meta_ecc(OCFS2_SB(inode
->i_sb
)))
5725 mlog(0, "refcount bucket %llu, count = %u\n",
5726 (unsigned long long)bucket_blkno(bucket
),
5727 le16_to_cpu(xh
->xh_count
));
5728 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
5729 xe
= &xh
->xh_entries
[i
];
5731 if (ocfs2_xattr_is_local(xe
))
5734 ret
= ocfs2_get_xattr_tree_value_root(inode
->i_sb
, bucket
, i
,
5735 &vb
.vb_xv
, &vb
.vb_bh
);
5741 ocfs2_init_xattr_value_extent_tree(&et
,
5742 INODE_CACHE(inode
), &vb
);
5744 ret
= ocfs2_xattr_value_attach_refcount(inode
, vb
.vb_xv
,
5758 static int ocfs2_refcount_xattr_tree_rec(struct inode
*inode
,
5759 struct buffer_head
*root_bh
,
5760 u64 blkno
, u32 cpos
, u32 len
, void *para
)
5762 return ocfs2_iterate_xattr_buckets(inode
, blkno
, len
,
5763 ocfs2_xattr_bucket_value_refcount
,
5767 static int ocfs2_xattr_block_attach_refcount(struct inode
*inode
,
5768 struct buffer_head
*blk_bh
,
5769 struct ocfs2_caching_info
*ref_ci
,
5770 struct buffer_head
*ref_root_bh
,
5771 struct ocfs2_cached_dealloc_ctxt
*dealloc
)
5774 struct ocfs2_xattr_block
*xb
=
5775 (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
5777 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
5778 struct ocfs2_xattr_header
*header
= &xb
->xb_attrs
.xb_header
;
5779 struct ocfs2_xattr_value_buf vb
= {
5781 .vb_access
= ocfs2_journal_access_xb
,
5784 ret
= ocfs2_xattr_attach_refcount_normal(inode
, &vb
, header
,
5785 ref_ci
, ref_root_bh
,
5788 struct ocfs2_xattr_tree_value_refcount_para para
= {
5790 .ref_root_bh
= ref_root_bh
,
5794 ret
= ocfs2_iterate_xattr_index_block(inode
, blk_bh
,
5795 ocfs2_refcount_xattr_tree_rec
,
5802 int ocfs2_xattr_attach_refcount_tree(struct inode
*inode
,
5803 struct buffer_head
*fe_bh
,
5804 struct ocfs2_caching_info
*ref_ci
,
5805 struct buffer_head
*ref_root_bh
,
5806 struct ocfs2_cached_dealloc_ctxt
*dealloc
)
5809 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
5810 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)fe_bh
->b_data
;
5811 struct buffer_head
*blk_bh
= NULL
;
5813 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) {
5814 ret
= ocfs2_xattr_inline_attach_refcount(inode
, fe_bh
,
5815 ref_ci
, ref_root_bh
,
5823 if (!di
->i_xattr_loc
)
5826 ret
= ocfs2_read_xattr_block(inode
, le64_to_cpu(di
->i_xattr_loc
),
5833 ret
= ocfs2_xattr_block_attach_refcount(inode
, blk_bh
, ref_ci
,
5834 ref_root_bh
, dealloc
);
5845 * 'security' attributes support
5847 static size_t ocfs2_xattr_security_list(struct inode
*inode
, char *list
,
5848 size_t list_size
, const char *name
,
5851 const size_t prefix_len
= XATTR_SECURITY_PREFIX_LEN
;
5852 const size_t total_len
= prefix_len
+ name_len
+ 1;
5854 if (list
&& total_len
<= list_size
) {
5855 memcpy(list
, XATTR_SECURITY_PREFIX
, prefix_len
);
5856 memcpy(list
+ prefix_len
, name
, name_len
);
5857 list
[prefix_len
+ name_len
] = '\0';
5862 static int ocfs2_xattr_security_get(struct inode
*inode
, const char *name
,
5863 void *buffer
, size_t size
)
5865 if (strcmp(name
, "") == 0)
5867 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_SECURITY
, name
,
5871 static int ocfs2_xattr_security_set(struct inode
*inode
, const char *name
,
5872 const void *value
, size_t size
, int flags
)
5874 if (strcmp(name
, "") == 0)
5877 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_SECURITY
, name
, value
,
5881 int ocfs2_init_security_get(struct inode
*inode
,
5883 struct ocfs2_security_xattr_info
*si
)
5885 /* check whether ocfs2 support feature xattr */
5886 if (!ocfs2_supports_xattr(OCFS2_SB(dir
->i_sb
)))
5888 return security_inode_init_security(inode
, dir
, &si
->name
, &si
->value
,
5892 int ocfs2_init_security_set(handle_t
*handle
,
5893 struct inode
*inode
,
5894 struct buffer_head
*di_bh
,
5895 struct ocfs2_security_xattr_info
*si
,
5896 struct ocfs2_alloc_context
*xattr_ac
,
5897 struct ocfs2_alloc_context
*data_ac
)
5899 return ocfs2_xattr_set_handle(handle
, inode
, di_bh
,
5900 OCFS2_XATTR_INDEX_SECURITY
,
5901 si
->name
, si
->value
, si
->value_len
, 0,
5905 struct xattr_handler ocfs2_xattr_security_handler
= {
5906 .prefix
= XATTR_SECURITY_PREFIX
,
5907 .list
= ocfs2_xattr_security_list
,
5908 .get
= ocfs2_xattr_security_get
,
5909 .set
= ocfs2_xattr_security_set
,
5913 * 'trusted' attributes support
5915 static size_t ocfs2_xattr_trusted_list(struct inode
*inode
, char *list
,
5916 size_t list_size
, const char *name
,
5919 const size_t prefix_len
= XATTR_TRUSTED_PREFIX_LEN
;
5920 const size_t total_len
= prefix_len
+ name_len
+ 1;
5922 if (list
&& total_len
<= list_size
) {
5923 memcpy(list
, XATTR_TRUSTED_PREFIX
, prefix_len
);
5924 memcpy(list
+ prefix_len
, name
, name_len
);
5925 list
[prefix_len
+ name_len
] = '\0';
5930 static int ocfs2_xattr_trusted_get(struct inode
*inode
, const char *name
,
5931 void *buffer
, size_t size
)
5933 if (strcmp(name
, "") == 0)
5935 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_TRUSTED
, name
,
5939 static int ocfs2_xattr_trusted_set(struct inode
*inode
, const char *name
,
5940 const void *value
, size_t size
, int flags
)
5942 if (strcmp(name
, "") == 0)
5945 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_TRUSTED
, name
, value
,
5949 struct xattr_handler ocfs2_xattr_trusted_handler
= {
5950 .prefix
= XATTR_TRUSTED_PREFIX
,
5951 .list
= ocfs2_xattr_trusted_list
,
5952 .get
= ocfs2_xattr_trusted_get
,
5953 .set
= ocfs2_xattr_trusted_set
,
5957 * 'user' attributes support
5959 static size_t ocfs2_xattr_user_list(struct inode
*inode
, char *list
,
5960 size_t list_size
, const char *name
,
5963 const size_t prefix_len
= XATTR_USER_PREFIX_LEN
;
5964 const size_t total_len
= prefix_len
+ name_len
+ 1;
5965 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5967 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
5970 if (list
&& total_len
<= list_size
) {
5971 memcpy(list
, XATTR_USER_PREFIX
, prefix_len
);
5972 memcpy(list
+ prefix_len
, name
, name_len
);
5973 list
[prefix_len
+ name_len
] = '\0';
5978 static int ocfs2_xattr_user_get(struct inode
*inode
, const char *name
,
5979 void *buffer
, size_t size
)
5981 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5983 if (strcmp(name
, "") == 0)
5985 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
5987 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_USER
, name
,
5991 static int ocfs2_xattr_user_set(struct inode
*inode
, const char *name
,
5992 const void *value
, size_t size
, int flags
)
5994 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5996 if (strcmp(name
, "") == 0)
5998 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
6001 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_USER
, name
, value
,
6005 struct xattr_handler ocfs2_xattr_user_handler
= {
6006 .prefix
= XATTR_USER_PREFIX
,
6007 .list
= ocfs2_xattr_user_list
,
6008 .get
= ocfs2_xattr_user_get
,
6009 .set
= ocfs2_xattr_user_set
,