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 int ocfs2_has_inline_xattr_value_outside(struct inode
*inode
,
844 struct ocfs2_dinode
*di
)
846 struct ocfs2_xattr_header
*xh
;
849 xh
= (struct ocfs2_xattr_header
*)
850 ((void *)di
+ inode
->i_sb
->s_blocksize
-
851 le16_to_cpu(di
->i_xattr_inline_size
));
853 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++)
854 if (!ocfs2_xattr_is_local(&xh
->xh_entries
[i
]))
860 static int ocfs2_xattr_ibody_list(struct inode
*inode
,
861 struct ocfs2_dinode
*di
,
865 struct ocfs2_xattr_header
*header
= NULL
;
866 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
869 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
))
872 header
= (struct ocfs2_xattr_header
*)
873 ((void *)di
+ inode
->i_sb
->s_blocksize
-
874 le16_to_cpu(di
->i_xattr_inline_size
));
876 ret
= ocfs2_xattr_list_entries(inode
, header
, buffer
, buffer_size
);
881 static int ocfs2_xattr_block_list(struct inode
*inode
,
882 struct ocfs2_dinode
*di
,
886 struct buffer_head
*blk_bh
= NULL
;
887 struct ocfs2_xattr_block
*xb
;
890 if (!di
->i_xattr_loc
)
893 ret
= ocfs2_read_xattr_block(inode
, le64_to_cpu(di
->i_xattr_loc
),
900 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
901 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
902 struct ocfs2_xattr_header
*header
= &xb
->xb_attrs
.xb_header
;
903 ret
= ocfs2_xattr_list_entries(inode
, header
,
904 buffer
, buffer_size
);
906 ret
= ocfs2_xattr_tree_list_index_block(inode
, blk_bh
,
907 buffer
, buffer_size
);
914 ssize_t
ocfs2_listxattr(struct dentry
*dentry
,
918 int ret
= 0, i_ret
= 0, b_ret
= 0;
919 struct buffer_head
*di_bh
= NULL
;
920 struct ocfs2_dinode
*di
= NULL
;
921 struct ocfs2_inode_info
*oi
= OCFS2_I(dentry
->d_inode
);
923 if (!ocfs2_supports_xattr(OCFS2_SB(dentry
->d_sb
)))
926 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
929 ret
= ocfs2_inode_lock(dentry
->d_inode
, &di_bh
, 0);
935 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
937 down_read(&oi
->ip_xattr_sem
);
938 i_ret
= ocfs2_xattr_ibody_list(dentry
->d_inode
, di
, buffer
, size
);
946 b_ret
= ocfs2_xattr_block_list(dentry
->d_inode
, di
,
951 up_read(&oi
->ip_xattr_sem
);
952 ocfs2_inode_unlock(dentry
->d_inode
, 0);
956 return i_ret
+ b_ret
;
959 static int ocfs2_xattr_find_entry(int name_index
,
961 struct ocfs2_xattr_search
*xs
)
963 struct ocfs2_xattr_entry
*entry
;
970 name_len
= strlen(name
);
972 for (i
= 0; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
973 cmp
= name_index
- ocfs2_xattr_get_type(entry
);
975 cmp
= name_len
- entry
->xe_name_len
;
977 cmp
= memcmp(name
, (xs
->base
+
978 le16_to_cpu(entry
->xe_name_offset
)),
986 return cmp
? -ENODATA
: 0;
989 static int ocfs2_xattr_get_value_outside(struct inode
*inode
,
990 struct ocfs2_xattr_value_root
*xv
,
994 u32 cpos
, p_cluster
, num_clusters
, bpc
, clusters
;
997 size_t cplen
, blocksize
;
998 struct buffer_head
*bh
= NULL
;
999 struct ocfs2_extent_list
*el
;
1002 clusters
= le32_to_cpu(xv
->xr_clusters
);
1003 bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
1004 blocksize
= inode
->i_sb
->s_blocksize
;
1007 while (cpos
< clusters
) {
1008 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &p_cluster
,
1009 &num_clusters
, el
, NULL
);
1015 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, p_cluster
);
1016 /* Copy ocfs2_xattr_value */
1017 for (i
= 0; i
< num_clusters
* bpc
; i
++, blkno
++) {
1018 ret
= ocfs2_read_block(INODE_CACHE(inode
), blkno
,
1025 cplen
= len
>= blocksize
? blocksize
: len
;
1026 memcpy(buffer
, bh
->b_data
, cplen
);
1035 cpos
+= num_clusters
;
1041 static int ocfs2_xattr_ibody_get(struct inode
*inode
,
1046 struct ocfs2_xattr_search
*xs
)
1048 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1049 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
1050 struct ocfs2_xattr_value_root
*xv
;
1054 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
))
1057 xs
->end
= (void *)di
+ inode
->i_sb
->s_blocksize
;
1058 xs
->header
= (struct ocfs2_xattr_header
*)
1059 (xs
->end
- le16_to_cpu(di
->i_xattr_inline_size
));
1060 xs
->base
= (void *)xs
->header
;
1061 xs
->here
= xs
->header
->xh_entries
;
1063 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
1066 size
= le64_to_cpu(xs
->here
->xe_value_size
);
1068 if (size
> buffer_size
)
1070 if (ocfs2_xattr_is_local(xs
->here
)) {
1071 memcpy(buffer
, (void *)xs
->base
+
1072 le16_to_cpu(xs
->here
->xe_name_offset
) +
1073 OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
), size
);
1075 xv
= (struct ocfs2_xattr_value_root
*)
1076 (xs
->base
+ le16_to_cpu(
1077 xs
->here
->xe_name_offset
) +
1078 OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
));
1079 ret
= ocfs2_xattr_get_value_outside(inode
, xv
,
1091 static int ocfs2_xattr_block_get(struct inode
*inode
,
1096 struct ocfs2_xattr_search
*xs
)
1098 struct ocfs2_xattr_block
*xb
;
1099 struct ocfs2_xattr_value_root
*xv
;
1101 int ret
= -ENODATA
, name_offset
, name_len
, i
;
1102 int uninitialized_var(block_off
);
1104 xs
->bucket
= ocfs2_xattr_bucket_new(inode
);
1111 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, xs
);
1117 if (xs
->not_found
) {
1122 xb
= (struct ocfs2_xattr_block
*)xs
->xattr_bh
->b_data
;
1123 size
= le64_to_cpu(xs
->here
->xe_value_size
);
1126 if (size
> buffer_size
)
1129 name_offset
= le16_to_cpu(xs
->here
->xe_name_offset
);
1130 name_len
= OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
);
1131 i
= xs
->here
- xs
->header
->xh_entries
;
1133 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
1134 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
1135 bucket_xh(xs
->bucket
),
1139 xs
->base
= bucket_block(xs
->bucket
, block_off
);
1141 if (ocfs2_xattr_is_local(xs
->here
)) {
1142 memcpy(buffer
, (void *)xs
->base
+
1143 name_offset
+ name_len
, size
);
1145 xv
= (struct ocfs2_xattr_value_root
*)
1146 (xs
->base
+ name_offset
+ name_len
);
1147 ret
= ocfs2_xattr_get_value_outside(inode
, xv
,
1157 ocfs2_xattr_bucket_free(xs
->bucket
);
1159 brelse(xs
->xattr_bh
);
1160 xs
->xattr_bh
= NULL
;
1164 int ocfs2_xattr_get_nolock(struct inode
*inode
,
1165 struct buffer_head
*di_bh
,
1172 struct ocfs2_dinode
*di
= NULL
;
1173 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1174 struct ocfs2_xattr_search xis
= {
1175 .not_found
= -ENODATA
,
1177 struct ocfs2_xattr_search xbs
= {
1178 .not_found
= -ENODATA
,
1181 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
1184 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
1187 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
1188 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1190 down_read(&oi
->ip_xattr_sem
);
1191 ret
= ocfs2_xattr_ibody_get(inode
, name_index
, name
, buffer
,
1193 if (ret
== -ENODATA
&& di
->i_xattr_loc
)
1194 ret
= ocfs2_xattr_block_get(inode
, name_index
, name
, buffer
,
1196 up_read(&oi
->ip_xattr_sem
);
1201 /* ocfs2_xattr_get()
1203 * Copy an extended attribute into the buffer provided.
1204 * Buffer is NULL to compute the size of buffer required.
1206 static int ocfs2_xattr_get(struct inode
*inode
,
1213 struct buffer_head
*di_bh
= NULL
;
1215 ret
= ocfs2_inode_lock(inode
, &di_bh
, 0);
1220 ret
= ocfs2_xattr_get_nolock(inode
, di_bh
, name_index
,
1221 name
, buffer
, buffer_size
);
1223 ocfs2_inode_unlock(inode
, 0);
1230 static int __ocfs2_xattr_set_value_outside(struct inode
*inode
,
1232 struct ocfs2_xattr_value_buf
*vb
,
1236 int ret
= 0, i
, cp_len
;
1237 u16 blocksize
= inode
->i_sb
->s_blocksize
;
1238 u32 p_cluster
, num_clusters
;
1239 u32 cpos
= 0, bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
1240 u32 clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
, value_len
);
1242 struct buffer_head
*bh
= NULL
;
1243 unsigned int ext_flags
;
1244 struct ocfs2_xattr_value_root
*xv
= vb
->vb_xv
;
1246 BUG_ON(clusters
> le32_to_cpu(xv
->xr_clusters
));
1248 while (cpos
< clusters
) {
1249 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &p_cluster
,
1250 &num_clusters
, &xv
->xr_list
,
1257 BUG_ON(ext_flags
& OCFS2_EXT_REFCOUNTED
);
1259 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, p_cluster
);
1261 for (i
= 0; i
< num_clusters
* bpc
; i
++, blkno
++) {
1262 ret
= ocfs2_read_block(INODE_CACHE(inode
), blkno
,
1269 ret
= ocfs2_journal_access(handle
,
1272 OCFS2_JOURNAL_ACCESS_WRITE
);
1278 cp_len
= value_len
> blocksize
? blocksize
: value_len
;
1279 memcpy(bh
->b_data
, value
, cp_len
);
1280 value_len
-= cp_len
;
1282 if (cp_len
< blocksize
)
1283 memset(bh
->b_data
+ cp_len
, 0,
1284 blocksize
- cp_len
);
1286 ret
= ocfs2_journal_dirty(handle
, bh
);
1295 * XXX: do we need to empty all the following
1296 * blocks in this cluster?
1301 cpos
+= num_clusters
;
1309 static int ocfs2_xattr_cleanup(struct inode
*inode
,
1311 struct ocfs2_xattr_info
*xi
,
1312 struct ocfs2_xattr_search
*xs
,
1313 struct ocfs2_xattr_value_buf
*vb
,
1317 size_t name_len
= strlen(xi
->name
);
1318 void *val
= xs
->base
+ offs
;
1319 size_t size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1321 ret
= vb
->vb_access(handle
, INODE_CACHE(inode
), vb
->vb_bh
,
1322 OCFS2_JOURNAL_ACCESS_WRITE
);
1327 /* Decrease xattr count */
1328 le16_add_cpu(&xs
->header
->xh_count
, -1);
1329 /* Remove the xattr entry and tree root which has already be set*/
1330 memset((void *)xs
->here
, 0, sizeof(struct ocfs2_xattr_entry
));
1331 memset(val
, 0, size
);
1333 ret
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
1340 static int ocfs2_xattr_update_entry(struct inode
*inode
,
1342 struct ocfs2_xattr_info
*xi
,
1343 struct ocfs2_xattr_search
*xs
,
1344 struct ocfs2_xattr_value_buf
*vb
,
1349 ret
= vb
->vb_access(handle
, INODE_CACHE(inode
), vb
->vb_bh
,
1350 OCFS2_JOURNAL_ACCESS_WRITE
);
1356 xs
->here
->xe_name_offset
= cpu_to_le16(offs
);
1357 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1358 if (xi
->value_len
<= OCFS2_XATTR_INLINE_SIZE
)
1359 ocfs2_xattr_set_local(xs
->here
, 1);
1361 ocfs2_xattr_set_local(xs
->here
, 0);
1362 ocfs2_xattr_hash_entry(inode
, xs
->header
, xs
->here
);
1364 ret
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
1372 * ocfs2_xattr_set_value_outside()
1374 * Set large size value in B tree.
1376 static int ocfs2_xattr_set_value_outside(struct inode
*inode
,
1377 struct ocfs2_xattr_info
*xi
,
1378 struct ocfs2_xattr_search
*xs
,
1379 struct ocfs2_xattr_set_ctxt
*ctxt
,
1380 struct ocfs2_xattr_value_buf
*vb
,
1383 size_t name_len
= strlen(xi
->name
);
1384 void *val
= xs
->base
+ offs
;
1385 struct ocfs2_xattr_value_root
*xv
= NULL
;
1386 size_t size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1389 memset(val
, 0, size
);
1390 memcpy(val
, xi
->name
, name_len
);
1391 xv
= (struct ocfs2_xattr_value_root
*)
1392 (val
+ OCFS2_XATTR_SIZE(name_len
));
1393 xv
->xr_clusters
= 0;
1394 xv
->xr_last_eb_blk
= 0;
1395 xv
->xr_list
.l_tree_depth
= 0;
1396 xv
->xr_list
.l_count
= cpu_to_le16(1);
1397 xv
->xr_list
.l_next_free_rec
= 0;
1400 ret
= ocfs2_xattr_value_truncate(inode
, vb
, xi
->value_len
, ctxt
);
1405 ret
= ocfs2_xattr_update_entry(inode
, ctxt
->handle
, xi
, xs
, vb
, offs
);
1410 ret
= __ocfs2_xattr_set_value_outside(inode
, ctxt
->handle
, vb
,
1411 xi
->value
, xi
->value_len
);
1419 * ocfs2_xattr_set_entry_local()
1421 * Set, replace or remove extended attribute in local.
1423 static void ocfs2_xattr_set_entry_local(struct inode
*inode
,
1424 struct ocfs2_xattr_info
*xi
,
1425 struct ocfs2_xattr_search
*xs
,
1426 struct ocfs2_xattr_entry
*last
,
1429 size_t name_len
= strlen(xi
->name
);
1432 if (xi
->value
&& xs
->not_found
) {
1433 /* Insert the new xattr entry. */
1434 le16_add_cpu(&xs
->header
->xh_count
, 1);
1435 ocfs2_xattr_set_type(last
, xi
->name_index
);
1436 ocfs2_xattr_set_local(last
, 1);
1437 last
->xe_name_len
= name_len
;
1443 first_val
= xs
->base
+ min_offs
;
1444 offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1445 val
= xs
->base
+ offs
;
1447 if (le64_to_cpu(xs
->here
->xe_value_size
) >
1448 OCFS2_XATTR_INLINE_SIZE
)
1449 size
= OCFS2_XATTR_SIZE(name_len
) +
1450 OCFS2_XATTR_ROOT_SIZE
;
1452 size
= OCFS2_XATTR_SIZE(name_len
) +
1453 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1455 if (xi
->value
&& size
== OCFS2_XATTR_SIZE(name_len
) +
1456 OCFS2_XATTR_SIZE(xi
->value_len
)) {
1457 /* The old and the new value have the
1458 same size. Just replace the value. */
1459 ocfs2_xattr_set_local(xs
->here
, 1);
1460 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1461 /* Clear value bytes. */
1462 memset(val
+ OCFS2_XATTR_SIZE(name_len
),
1464 OCFS2_XATTR_SIZE(xi
->value_len
));
1465 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
1470 /* Remove the old name+value. */
1471 memmove(first_val
+ size
, first_val
, val
- first_val
);
1472 memset(first_val
, 0, size
);
1473 xs
->here
->xe_name_hash
= 0;
1474 xs
->here
->xe_name_offset
= 0;
1475 ocfs2_xattr_set_local(xs
->here
, 1);
1476 xs
->here
->xe_value_size
= 0;
1480 /* Adjust all value offsets. */
1481 last
= xs
->header
->xh_entries
;
1482 for (i
= 0 ; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
1483 size_t o
= le16_to_cpu(last
->xe_name_offset
);
1486 last
->xe_name_offset
= cpu_to_le16(o
+ size
);
1491 /* Remove the old entry. */
1493 memmove(xs
->here
, xs
->here
+ 1,
1494 (void *)last
- (void *)xs
->here
);
1495 memset(last
, 0, sizeof(struct ocfs2_xattr_entry
));
1496 le16_add_cpu(&xs
->header
->xh_count
, -1);
1500 /* Insert the new name+value. */
1501 size_t size
= OCFS2_XATTR_SIZE(name_len
) +
1502 OCFS2_XATTR_SIZE(xi
->value_len
);
1503 void *val
= xs
->base
+ min_offs
- size
;
1505 xs
->here
->xe_name_offset
= cpu_to_le16(min_offs
- size
);
1506 memset(val
, 0, size
);
1507 memcpy(val
, xi
->name
, name_len
);
1508 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
1511 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1512 ocfs2_xattr_set_local(xs
->here
, 1);
1513 ocfs2_xattr_hash_entry(inode
, xs
->header
, xs
->here
);
1520 * ocfs2_xattr_set_entry()
1522 * Set extended attribute entry into inode or block.
1524 * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
1525 * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
1526 * then set value in B tree with set_value_outside().
1528 static int ocfs2_xattr_set_entry(struct inode
*inode
,
1529 struct ocfs2_xattr_info
*xi
,
1530 struct ocfs2_xattr_search
*xs
,
1531 struct ocfs2_xattr_set_ctxt
*ctxt
,
1534 struct ocfs2_xattr_entry
*last
;
1535 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1536 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
1537 size_t min_offs
= xs
->end
- xs
->base
, name_len
= strlen(xi
->name
);
1539 handle_t
*handle
= ctxt
->handle
;
1541 struct ocfs2_xattr_info xi_l
= {
1542 .name_index
= xi
->name_index
,
1545 .value_len
= xi
->value_len
,
1547 struct ocfs2_xattr_value_buf vb
= {
1548 .vb_bh
= xs
->xattr_bh
,
1549 .vb_access
= ocfs2_journal_access_di
,
1552 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1553 BUG_ON(xs
->xattr_bh
== xs
->inode_bh
);
1554 vb
.vb_access
= ocfs2_journal_access_xb
;
1556 BUG_ON(xs
->xattr_bh
!= xs
->inode_bh
);
1558 /* Compute min_offs, last and free space. */
1559 last
= xs
->header
->xh_entries
;
1561 for (i
= 0 ; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
1562 size_t offs
= le16_to_cpu(last
->xe_name_offset
);
1563 if (offs
< min_offs
)
1568 free
= min_offs
- ((void *)last
- xs
->base
) - OCFS2_XATTR_HEADER_GAP
;
1572 if (!xs
->not_found
) {
1574 if (ocfs2_xattr_is_local(xs
->here
))
1575 size
= OCFS2_XATTR_SIZE(name_len
) +
1576 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1578 size
= OCFS2_XATTR_SIZE(name_len
) +
1579 OCFS2_XATTR_ROOT_SIZE
;
1580 free
+= (size
+ sizeof(struct ocfs2_xattr_entry
));
1582 /* Check free space in inode or block */
1583 if (xi
->value
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1584 if (free
< sizeof(struct ocfs2_xattr_entry
) +
1585 OCFS2_XATTR_SIZE(name_len
) +
1586 OCFS2_XATTR_ROOT_SIZE
) {
1590 size_l
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1591 xi_l
.value
= (void *)&def_xv
;
1592 xi_l
.value_len
= OCFS2_XATTR_ROOT_SIZE
;
1593 } else if (xi
->value
) {
1594 if (free
< sizeof(struct ocfs2_xattr_entry
) +
1595 OCFS2_XATTR_SIZE(name_len
) +
1596 OCFS2_XATTR_SIZE(xi
->value_len
)) {
1602 if (!xs
->not_found
) {
1603 /* For existing extended attribute */
1604 size_t size
= OCFS2_XATTR_SIZE(name_len
) +
1605 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1606 size_t offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1607 void *val
= xs
->base
+ offs
;
1609 if (ocfs2_xattr_is_local(xs
->here
) && size
== size_l
) {
1610 /* Replace existing local xattr with tree root */
1611 ret
= ocfs2_xattr_set_value_outside(inode
, xi
, xs
,
1616 } else if (!ocfs2_xattr_is_local(xs
->here
)) {
1617 /* For existing xattr which has value outside */
1618 vb
.vb_xv
= (struct ocfs2_xattr_value_root
*)
1619 (val
+ OCFS2_XATTR_SIZE(name_len
));
1621 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1623 * If new value need set outside also,
1624 * first truncate old value to new value,
1625 * then set new value with set_value_outside().
1627 ret
= ocfs2_xattr_value_truncate(inode
,
1636 ret
= ocfs2_xattr_update_entry(inode
,
1647 ret
= __ocfs2_xattr_set_value_outside(inode
,
1657 * If new value need set in local,
1658 * just trucate old value to zero.
1660 ret
= ocfs2_xattr_value_truncate(inode
,
1670 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), xs
->inode_bh
,
1671 OCFS2_JOURNAL_ACCESS_WRITE
);
1677 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1678 ret
= vb
.vb_access(handle
, INODE_CACHE(inode
), vb
.vb_bh
,
1679 OCFS2_JOURNAL_ACCESS_WRITE
);
1687 * Set value in local, include set tree root in local.
1688 * This is the first step for value size >INLINE_SIZE.
1690 ocfs2_xattr_set_entry_local(inode
, &xi_l
, xs
, last
, min_offs
);
1692 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1693 ret
= ocfs2_journal_dirty(handle
, xs
->xattr_bh
);
1700 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) &&
1701 (flag
& OCFS2_INLINE_XATTR_FL
)) {
1702 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1703 unsigned int xattrsize
= osb
->s_xattr_inline_size
;
1706 * Adjust extent record count or inline data size
1707 * to reserve space for extended attribute.
1709 if (oi
->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
1710 struct ocfs2_inline_data
*idata
= &di
->id2
.i_data
;
1711 le16_add_cpu(&idata
->id_count
, -xattrsize
);
1712 } else if (!(ocfs2_inode_is_fast_symlink(inode
))) {
1713 struct ocfs2_extent_list
*el
= &di
->id2
.i_list
;
1714 le16_add_cpu(&el
->l_count
, -(xattrsize
/
1715 sizeof(struct ocfs2_extent_rec
)));
1717 di
->i_xattr_inline_size
= cpu_to_le16(xattrsize
);
1719 /* Update xattr flag */
1720 spin_lock(&oi
->ip_lock
);
1721 oi
->ip_dyn_features
|= flag
;
1722 di
->i_dyn_features
= cpu_to_le16(oi
->ip_dyn_features
);
1723 spin_unlock(&oi
->ip_lock
);
1725 ret
= ocfs2_journal_dirty(handle
, xs
->inode_bh
);
1729 if (!ret
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1731 * Set value outside in B tree.
1732 * This is the second step for value size > INLINE_SIZE.
1734 size_t offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1735 ret
= ocfs2_xattr_set_value_outside(inode
, xi
, xs
, ctxt
,
1742 * If set value outside failed, we have to clean
1743 * the junk tree root we have already set in local.
1745 ret2
= ocfs2_xattr_cleanup(inode
, ctxt
->handle
,
1755 static int ocfs2_remove_value_outside(struct inode
*inode
,
1756 struct ocfs2_xattr_value_buf
*vb
,
1757 struct ocfs2_xattr_header
*header
)
1760 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1761 struct ocfs2_xattr_set_ctxt ctxt
= { NULL
, NULL
, };
1763 ocfs2_init_dealloc_ctxt(&ctxt
.dealloc
);
1765 ctxt
.handle
= ocfs2_start_trans(osb
,
1766 ocfs2_remove_extent_credits(osb
->sb
));
1767 if (IS_ERR(ctxt
.handle
)) {
1768 ret
= PTR_ERR(ctxt
.handle
);
1773 for (i
= 0; i
< le16_to_cpu(header
->xh_count
); i
++) {
1774 struct ocfs2_xattr_entry
*entry
= &header
->xh_entries
[i
];
1776 if (!ocfs2_xattr_is_local(entry
)) {
1779 val
= (void *)header
+
1780 le16_to_cpu(entry
->xe_name_offset
);
1781 vb
->vb_xv
= (struct ocfs2_xattr_value_root
*)
1782 (val
+ OCFS2_XATTR_SIZE(entry
->xe_name_len
));
1783 ret
= ocfs2_xattr_value_truncate(inode
, vb
, 0, &ctxt
);
1791 ocfs2_commit_trans(osb
, ctxt
.handle
);
1792 ocfs2_schedule_truncate_log_flush(osb
, 1);
1793 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
1798 static int ocfs2_xattr_ibody_remove(struct inode
*inode
,
1799 struct buffer_head
*di_bh
)
1802 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1803 struct ocfs2_xattr_header
*header
;
1805 struct ocfs2_xattr_value_buf vb
= {
1807 .vb_access
= ocfs2_journal_access_di
,
1810 header
= (struct ocfs2_xattr_header
*)
1811 ((void *)di
+ inode
->i_sb
->s_blocksize
-
1812 le16_to_cpu(di
->i_xattr_inline_size
));
1814 ret
= ocfs2_remove_value_outside(inode
, &vb
, header
);
1819 static int ocfs2_xattr_block_remove(struct inode
*inode
,
1820 struct buffer_head
*blk_bh
)
1822 struct ocfs2_xattr_block
*xb
;
1824 struct ocfs2_xattr_value_buf vb
= {
1826 .vb_access
= ocfs2_journal_access_xb
,
1829 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
1830 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
1831 struct ocfs2_xattr_header
*header
= &(xb
->xb_attrs
.xb_header
);
1832 ret
= ocfs2_remove_value_outside(inode
, &vb
, header
);
1834 ret
= ocfs2_iterate_xattr_index_block(inode
,
1836 ocfs2_rm_xattr_cluster
,
1842 static int ocfs2_xattr_free_block(struct inode
*inode
,
1845 struct inode
*xb_alloc_inode
;
1846 struct buffer_head
*xb_alloc_bh
= NULL
;
1847 struct buffer_head
*blk_bh
= NULL
;
1848 struct ocfs2_xattr_block
*xb
;
1849 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1855 ret
= ocfs2_read_xattr_block(inode
, block
, &blk_bh
);
1861 ret
= ocfs2_xattr_block_remove(inode
, blk_bh
);
1867 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
1868 blk
= le64_to_cpu(xb
->xb_blkno
);
1869 bit
= le16_to_cpu(xb
->xb_suballoc_bit
);
1870 bg_blkno
= ocfs2_which_suballoc_group(blk
, bit
);
1872 xb_alloc_inode
= ocfs2_get_system_file_inode(osb
,
1873 EXTENT_ALLOC_SYSTEM_INODE
,
1874 le16_to_cpu(xb
->xb_suballoc_slot
));
1875 if (!xb_alloc_inode
) {
1880 mutex_lock(&xb_alloc_inode
->i_mutex
);
1882 ret
= ocfs2_inode_lock(xb_alloc_inode
, &xb_alloc_bh
, 1);
1888 handle
= ocfs2_start_trans(osb
, OCFS2_SUBALLOC_FREE
);
1889 if (IS_ERR(handle
)) {
1890 ret
= PTR_ERR(handle
);
1895 ret
= ocfs2_free_suballoc_bits(handle
, xb_alloc_inode
, xb_alloc_bh
,
1900 ocfs2_commit_trans(osb
, handle
);
1902 ocfs2_inode_unlock(xb_alloc_inode
, 1);
1903 brelse(xb_alloc_bh
);
1905 mutex_unlock(&xb_alloc_inode
->i_mutex
);
1906 iput(xb_alloc_inode
);
1913 * ocfs2_xattr_remove()
1915 * Free extended attribute resources associated with this inode.
1917 int ocfs2_xattr_remove(struct inode
*inode
, struct buffer_head
*di_bh
)
1919 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1920 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1924 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
1927 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
1930 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) {
1931 ret
= ocfs2_xattr_ibody_remove(inode
, di_bh
);
1938 if (di
->i_xattr_loc
) {
1939 ret
= ocfs2_xattr_free_block(inode
,
1940 le64_to_cpu(di
->i_xattr_loc
));
1947 handle
= ocfs2_start_trans((OCFS2_SB(inode
->i_sb
)),
1948 OCFS2_INODE_UPDATE_CREDITS
);
1949 if (IS_ERR(handle
)) {
1950 ret
= PTR_ERR(handle
);
1954 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), di_bh
,
1955 OCFS2_JOURNAL_ACCESS_WRITE
);
1961 di
->i_xattr_loc
= 0;
1963 spin_lock(&oi
->ip_lock
);
1964 oi
->ip_dyn_features
&= ~(OCFS2_INLINE_XATTR_FL
| OCFS2_HAS_XATTR_FL
);
1965 di
->i_dyn_features
= cpu_to_le16(oi
->ip_dyn_features
);
1966 spin_unlock(&oi
->ip_lock
);
1968 ret
= ocfs2_journal_dirty(handle
, di_bh
);
1972 ocfs2_commit_trans(OCFS2_SB(inode
->i_sb
), handle
);
1977 static int ocfs2_xattr_has_space_inline(struct inode
*inode
,
1978 struct ocfs2_dinode
*di
)
1980 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1981 unsigned int xattrsize
= OCFS2_SB(inode
->i_sb
)->s_xattr_inline_size
;
1984 if (xattrsize
< OCFS2_MIN_XATTR_INLINE_SIZE
)
1987 if (oi
->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
1988 struct ocfs2_inline_data
*idata
= &di
->id2
.i_data
;
1989 free
= le16_to_cpu(idata
->id_count
) - le64_to_cpu(di
->i_size
);
1990 } else if (ocfs2_inode_is_fast_symlink(inode
)) {
1991 free
= ocfs2_fast_symlink_chars(inode
->i_sb
) -
1992 le64_to_cpu(di
->i_size
);
1994 struct ocfs2_extent_list
*el
= &di
->id2
.i_list
;
1995 free
= (le16_to_cpu(el
->l_count
) -
1996 le16_to_cpu(el
->l_next_free_rec
)) *
1997 sizeof(struct ocfs2_extent_rec
);
1999 if (free
>= xattrsize
)
2006 * ocfs2_xattr_ibody_find()
2008 * Find extended attribute in inode block and
2009 * fill search info into struct ocfs2_xattr_search.
2011 static int ocfs2_xattr_ibody_find(struct inode
*inode
,
2014 struct ocfs2_xattr_search
*xs
)
2016 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
2017 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2021 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
)
2024 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)) {
2025 down_read(&oi
->ip_alloc_sem
);
2026 has_space
= ocfs2_xattr_has_space_inline(inode
, di
);
2027 up_read(&oi
->ip_alloc_sem
);
2032 xs
->xattr_bh
= xs
->inode_bh
;
2033 xs
->end
= (void *)di
+ inode
->i_sb
->s_blocksize
;
2034 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)
2035 xs
->header
= (struct ocfs2_xattr_header
*)
2036 (xs
->end
- le16_to_cpu(di
->i_xattr_inline_size
));
2038 xs
->header
= (struct ocfs2_xattr_header
*)
2039 (xs
->end
- OCFS2_SB(inode
->i_sb
)->s_xattr_inline_size
);
2040 xs
->base
= (void *)xs
->header
;
2041 xs
->here
= xs
->header
->xh_entries
;
2043 /* Find the named attribute. */
2044 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) {
2045 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
2046 if (ret
&& ret
!= -ENODATA
)
2048 xs
->not_found
= ret
;
2055 * ocfs2_xattr_ibody_set()
2057 * Set, replace or remove an extended attribute into inode block.
2060 static int ocfs2_xattr_ibody_set(struct inode
*inode
,
2061 struct ocfs2_xattr_info
*xi
,
2062 struct ocfs2_xattr_search
*xs
,
2063 struct ocfs2_xattr_set_ctxt
*ctxt
)
2065 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
2066 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2069 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
)
2072 down_write(&oi
->ip_alloc_sem
);
2073 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)) {
2074 if (!ocfs2_xattr_has_space_inline(inode
, di
)) {
2080 ret
= ocfs2_xattr_set_entry(inode
, xi
, xs
, ctxt
,
2081 (OCFS2_INLINE_XATTR_FL
| OCFS2_HAS_XATTR_FL
));
2083 up_write(&oi
->ip_alloc_sem
);
2089 * ocfs2_xattr_block_find()
2091 * Find extended attribute in external block and
2092 * fill search info into struct ocfs2_xattr_search.
2094 static int ocfs2_xattr_block_find(struct inode
*inode
,
2097 struct ocfs2_xattr_search
*xs
)
2099 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2100 struct buffer_head
*blk_bh
= NULL
;
2101 struct ocfs2_xattr_block
*xb
;
2104 if (!di
->i_xattr_loc
)
2107 ret
= ocfs2_read_xattr_block(inode
, le64_to_cpu(di
->i_xattr_loc
),
2114 xs
->xattr_bh
= blk_bh
;
2115 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
2117 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
2118 xs
->header
= &xb
->xb_attrs
.xb_header
;
2119 xs
->base
= (void *)xs
->header
;
2120 xs
->end
= (void *)(blk_bh
->b_data
) + blk_bh
->b_size
;
2121 xs
->here
= xs
->header
->xh_entries
;
2123 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
2125 ret
= ocfs2_xattr_index_block_find(inode
, blk_bh
,
2129 if (ret
&& ret
!= -ENODATA
) {
2130 xs
->xattr_bh
= NULL
;
2133 xs
->not_found
= ret
;
2141 static int ocfs2_create_xattr_block(handle_t
*handle
,
2142 struct inode
*inode
,
2143 struct buffer_head
*inode_bh
,
2144 struct ocfs2_alloc_context
*meta_ac
,
2145 struct buffer_head
**ret_bh
)
2148 u16 suballoc_bit_start
;
2151 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)inode_bh
->b_data
;
2152 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2153 struct buffer_head
*new_bh
= NULL
;
2154 struct ocfs2_xattr_block
*xblk
;
2156 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), inode_bh
,
2157 OCFS2_JOURNAL_ACCESS_CREATE
);
2163 ret
= ocfs2_claim_metadata(osb
, handle
, meta_ac
, 1,
2164 &suballoc_bit_start
, &num_got
,
2171 new_bh
= sb_getblk(inode
->i_sb
, first_blkno
);
2172 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), new_bh
);
2174 ret
= ocfs2_journal_access_xb(handle
, INODE_CACHE(inode
),
2176 OCFS2_JOURNAL_ACCESS_CREATE
);
2182 /* Initialize ocfs2_xattr_block */
2183 xblk
= (struct ocfs2_xattr_block
*)new_bh
->b_data
;
2184 memset(xblk
, 0, inode
->i_sb
->s_blocksize
);
2185 strcpy((void *)xblk
, OCFS2_XATTR_BLOCK_SIGNATURE
);
2186 xblk
->xb_suballoc_slot
= cpu_to_le16(osb
->slot_num
);
2187 xblk
->xb_suballoc_bit
= cpu_to_le16(suballoc_bit_start
);
2188 xblk
->xb_fs_generation
= cpu_to_le32(osb
->fs_generation
);
2189 xblk
->xb_blkno
= cpu_to_le64(first_blkno
);
2191 ret
= ocfs2_journal_dirty(handle
, new_bh
);
2196 di
->i_xattr_loc
= cpu_to_le64(first_blkno
);
2197 ocfs2_journal_dirty(handle
, inode_bh
);
2208 * ocfs2_xattr_block_set()
2210 * Set, replace or remove an extended attribute into external block.
2213 static int ocfs2_xattr_block_set(struct inode
*inode
,
2214 struct ocfs2_xattr_info
*xi
,
2215 struct ocfs2_xattr_search
*xs
,
2216 struct ocfs2_xattr_set_ctxt
*ctxt
)
2218 struct buffer_head
*new_bh
= NULL
;
2219 handle_t
*handle
= ctxt
->handle
;
2220 struct ocfs2_xattr_block
*xblk
= NULL
;
2223 if (!xs
->xattr_bh
) {
2224 ret
= ocfs2_create_xattr_block(handle
, inode
, xs
->inode_bh
,
2225 ctxt
->meta_ac
, &new_bh
);
2231 xs
->xattr_bh
= new_bh
;
2232 xblk
= (struct ocfs2_xattr_block
*)xs
->xattr_bh
->b_data
;
2233 xs
->header
= &xblk
->xb_attrs
.xb_header
;
2234 xs
->base
= (void *)xs
->header
;
2235 xs
->end
= (void *)xblk
+ inode
->i_sb
->s_blocksize
;
2236 xs
->here
= xs
->header
->xh_entries
;
2238 xblk
= (struct ocfs2_xattr_block
*)xs
->xattr_bh
->b_data
;
2240 if (!(le16_to_cpu(xblk
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
2241 /* Set extended attribute into external block */
2242 ret
= ocfs2_xattr_set_entry(inode
, xi
, xs
, ctxt
,
2243 OCFS2_HAS_XATTR_FL
);
2244 if (!ret
|| ret
!= -ENOSPC
)
2247 ret
= ocfs2_xattr_create_index_block(inode
, xs
, ctxt
);
2252 ret
= ocfs2_xattr_set_entry_index_block(inode
, xi
, xs
, ctxt
);
2259 /* Check whether the new xattr can be inserted into the inode. */
2260 static int ocfs2_xattr_can_be_in_inode(struct inode
*inode
,
2261 struct ocfs2_xattr_info
*xi
,
2262 struct ocfs2_xattr_search
*xs
)
2265 struct ocfs2_xattr_entry
*last
;
2267 size_t min_offs
= xs
->end
- xs
->base
;
2272 last
= xs
->header
->xh_entries
;
2274 for (i
= 0; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
2275 size_t offs
= le16_to_cpu(last
->xe_name_offset
);
2276 if (offs
< min_offs
)
2281 free
= min_offs
- ((void *)last
- xs
->base
) - OCFS2_XATTR_HEADER_GAP
;
2285 BUG_ON(!xs
->not_found
);
2287 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
2288 value_size
= OCFS2_XATTR_ROOT_SIZE
;
2290 value_size
= OCFS2_XATTR_SIZE(xi
->value_len
);
2292 if (free
>= sizeof(struct ocfs2_xattr_entry
) +
2293 OCFS2_XATTR_SIZE(strlen(xi
->name
)) + value_size
)
2299 static int ocfs2_calc_xattr_set_need(struct inode
*inode
,
2300 struct ocfs2_dinode
*di
,
2301 struct ocfs2_xattr_info
*xi
,
2302 struct ocfs2_xattr_search
*xis
,
2303 struct ocfs2_xattr_search
*xbs
,
2308 int ret
= 0, old_in_xb
= 0;
2309 int clusters_add
= 0, meta_add
= 0, credits
= 0;
2310 struct buffer_head
*bh
= NULL
;
2311 struct ocfs2_xattr_block
*xb
= NULL
;
2312 struct ocfs2_xattr_entry
*xe
= NULL
;
2313 struct ocfs2_xattr_value_root
*xv
= NULL
;
2315 int name_offset
, name_len
= 0;
2316 u32 new_clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
,
2321 * Calculate the clusters we need to write.
2322 * No matter whether we replace an old one or add a new one,
2323 * we need this for writing.
2325 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
2326 credits
+= new_clusters
*
2327 ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
2329 if (xis
->not_found
&& xbs
->not_found
) {
2330 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2332 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
2333 clusters_add
+= new_clusters
;
2334 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2342 if (!xis
->not_found
) {
2344 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
2345 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
2347 credits
+= OCFS2_INODE_UPDATE_CREDITS
;
2349 int i
, block_off
= 0;
2350 xb
= (struct ocfs2_xattr_block
*)xbs
->xattr_bh
->b_data
;
2352 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
2353 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
2354 i
= xbs
->here
- xbs
->header
->xh_entries
;
2357 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
2358 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
2359 bucket_xh(xbs
->bucket
),
2362 base
= bucket_block(xbs
->bucket
, block_off
);
2363 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2366 credits
+= OCFS2_XATTR_BLOCK_UPDATE_CREDITS
;
2371 * delete a xattr doesn't need metadata and cluster allocation.
2372 * so just calculate the credits and return.
2374 * The credits for removing the value tree will be extended
2375 * by ocfs2_remove_extent itself.
2378 if (!ocfs2_xattr_is_local(xe
))
2379 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
);
2384 /* do cluster allocation guess first. */
2385 value_size
= le64_to_cpu(xe
->xe_value_size
);
2389 * In xattr set, we always try to set the xe in inode first,
2390 * so if it can be inserted into inode successfully, the old
2391 * one will be removed from the xattr block, and this xattr
2392 * will be inserted into inode as a new xattr in inode.
2394 if (ocfs2_xattr_can_be_in_inode(inode
, xi
, xis
)) {
2395 clusters_add
+= new_clusters
;
2396 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
) +
2397 OCFS2_INODE_UPDATE_CREDITS
;
2398 if (!ocfs2_xattr_is_local(xe
))
2399 credits
+= ocfs2_calc_extend_credits(
2407 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
2408 /* the new values will be stored outside. */
2409 u32 old_clusters
= 0;
2411 if (!ocfs2_xattr_is_local(xe
)) {
2412 old_clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
,
2414 xv
= (struct ocfs2_xattr_value_root
*)
2415 (base
+ name_offset
+ name_len
);
2416 value_size
= OCFS2_XATTR_ROOT_SIZE
;
2420 if (old_clusters
>= new_clusters
) {
2421 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
);
2424 meta_add
+= ocfs2_extend_meta_needed(&xv
->xr_list
);
2425 clusters_add
+= new_clusters
- old_clusters
;
2426 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2430 if (value_size
>= OCFS2_XATTR_ROOT_SIZE
)
2435 * Now the new value will be stored inside. So if the new
2436 * value is smaller than the size of value root or the old
2437 * value, we don't need any allocation, otherwise we have
2438 * to guess metadata allocation.
2440 if ((ocfs2_xattr_is_local(xe
) && value_size
>= xi
->value_len
) ||
2441 (!ocfs2_xattr_is_local(xe
) &&
2442 OCFS2_XATTR_ROOT_SIZE
>= xi
->value_len
))
2447 /* calculate metadata allocation. */
2448 if (di
->i_xattr_loc
) {
2449 if (!xbs
->xattr_bh
) {
2450 ret
= ocfs2_read_xattr_block(inode
,
2451 le64_to_cpu(di
->i_xattr_loc
),
2458 xb
= (struct ocfs2_xattr_block
*)bh
->b_data
;
2460 xb
= (struct ocfs2_xattr_block
*)xbs
->xattr_bh
->b_data
;
2463 * If there is already an xattr tree, good, we can calculate
2464 * like other b-trees. Otherwise we may have the chance of
2465 * create a tree, the credit calculation is borrowed from
2466 * ocfs2_calc_extend_credits with root_el = NULL. And the
2467 * new tree will be cluster based, so no meta is needed.
2469 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
2470 struct ocfs2_extent_list
*el
=
2471 &xb
->xb_attrs
.xb_root
.xt_list
;
2472 meta_add
+= ocfs2_extend_meta_needed(el
);
2473 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2476 credits
+= OCFS2_SUBALLOC_ALLOC
+ 1;
2479 * This cluster will be used either for new bucket or for
2481 * If the cluster size is the same as the bucket size, one
2482 * more is needed since we may need to extend the bucket
2486 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2487 if (OCFS2_XATTR_BUCKET_SIZE
==
2488 OCFS2_SB(inode
->i_sb
)->s_clustersize
) {
2489 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2494 credits
+= OCFS2_XATTR_BLOCK_CREATE_CREDITS
;
2498 *clusters_need
= clusters_add
;
2500 *meta_need
= meta_add
;
2502 *credits_need
= credits
;
2507 static int ocfs2_init_xattr_set_ctxt(struct inode
*inode
,
2508 struct ocfs2_dinode
*di
,
2509 struct ocfs2_xattr_info
*xi
,
2510 struct ocfs2_xattr_search
*xis
,
2511 struct ocfs2_xattr_search
*xbs
,
2512 struct ocfs2_xattr_set_ctxt
*ctxt
,
2516 int clusters_add
, meta_add
, ret
;
2517 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2519 memset(ctxt
, 0, sizeof(struct ocfs2_xattr_set_ctxt
));
2521 ocfs2_init_dealloc_ctxt(&ctxt
->dealloc
);
2523 ret
= ocfs2_calc_xattr_set_need(inode
, di
, xi
, xis
, xbs
,
2524 &clusters_add
, &meta_add
, credits
);
2530 meta_add
+= extra_meta
;
2531 mlog(0, "Set xattr %s, reserve meta blocks = %d, clusters = %d, "
2532 "credits = %d\n", xi
->name
, meta_add
, clusters_add
, *credits
);
2535 ret
= ocfs2_reserve_new_metadata_blocks(osb
, meta_add
,
2544 ret
= ocfs2_reserve_clusters(osb
, clusters_add
, &ctxt
->data_ac
);
2550 if (ctxt
->meta_ac
) {
2551 ocfs2_free_alloc_context(ctxt
->meta_ac
);
2552 ctxt
->meta_ac
= NULL
;
2556 * We cannot have an error and a non null ctxt->data_ac.
2563 static int __ocfs2_xattr_set_handle(struct inode
*inode
,
2564 struct ocfs2_dinode
*di
,
2565 struct ocfs2_xattr_info
*xi
,
2566 struct ocfs2_xattr_search
*xis
,
2567 struct ocfs2_xattr_search
*xbs
,
2568 struct ocfs2_xattr_set_ctxt
*ctxt
)
2570 int ret
= 0, credits
, old_found
;
2573 /* Remove existing extended attribute */
2574 if (!xis
->not_found
)
2575 ret
= ocfs2_xattr_ibody_set(inode
, xi
, xis
, ctxt
);
2576 else if (!xbs
->not_found
)
2577 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2579 /* We always try to set extended attribute into inode first*/
2580 ret
= ocfs2_xattr_ibody_set(inode
, xi
, xis
, ctxt
);
2581 if (!ret
&& !xbs
->not_found
) {
2583 * If succeed and that extended attribute existing in
2584 * external block, then we will remove it.
2589 old_found
= xis
->not_found
;
2590 xis
->not_found
= -ENODATA
;
2591 ret
= ocfs2_calc_xattr_set_need(inode
,
2599 xis
->not_found
= old_found
;
2605 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2606 ctxt
->handle
->h_buffer_credits
);
2611 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2612 } else if (ret
== -ENOSPC
) {
2613 if (di
->i_xattr_loc
&& !xbs
->xattr_bh
) {
2614 ret
= ocfs2_xattr_block_find(inode
,
2620 old_found
= xis
->not_found
;
2621 xis
->not_found
= -ENODATA
;
2622 ret
= ocfs2_calc_xattr_set_need(inode
,
2630 xis
->not_found
= old_found
;
2636 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2637 ctxt
->handle
->h_buffer_credits
);
2644 * If no space in inode, we will set extended attribute
2645 * into external block.
2647 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2650 if (!xis
->not_found
) {
2652 * If succeed and that extended attribute
2653 * existing in inode, we will remove it.
2657 xbs
->not_found
= -ENODATA
;
2658 ret
= ocfs2_calc_xattr_set_need(inode
,
2671 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2672 ctxt
->handle
->h_buffer_credits
);
2677 ret
= ocfs2_xattr_ibody_set(inode
, xi
,
2684 /* Update inode ctime. */
2685 ret
= ocfs2_journal_access_di(ctxt
->handle
, INODE_CACHE(inode
),
2687 OCFS2_JOURNAL_ACCESS_WRITE
);
2693 inode
->i_ctime
= CURRENT_TIME
;
2694 di
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
2695 di
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
2696 ocfs2_journal_dirty(ctxt
->handle
, xis
->inode_bh
);
2703 * This function only called duing creating inode
2704 * for init security/acl xattrs of the new inode.
2705 * All transanction credits have been reserved in mknod.
2707 int ocfs2_xattr_set_handle(handle_t
*handle
,
2708 struct inode
*inode
,
2709 struct buffer_head
*di_bh
,
2715 struct ocfs2_alloc_context
*meta_ac
,
2716 struct ocfs2_alloc_context
*data_ac
)
2718 struct ocfs2_dinode
*di
;
2721 struct ocfs2_xattr_info xi
= {
2722 .name_index
= name_index
,
2725 .value_len
= value_len
,
2728 struct ocfs2_xattr_search xis
= {
2729 .not_found
= -ENODATA
,
2732 struct ocfs2_xattr_search xbs
= {
2733 .not_found
= -ENODATA
,
2736 struct ocfs2_xattr_set_ctxt ctxt
= {
2742 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
2746 * In extreme situation, may need xattr bucket when
2747 * block size is too small. And we have already reserved
2748 * the credits for bucket in mknod.
2750 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
) {
2751 xbs
.bucket
= ocfs2_xattr_bucket_new(inode
);
2753 mlog_errno(-ENOMEM
);
2758 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
2759 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2761 down_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2763 ret
= ocfs2_xattr_ibody_find(inode
, name_index
, name
, &xis
);
2766 if (xis
.not_found
) {
2767 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, &xbs
);
2772 ret
= __ocfs2_xattr_set_handle(inode
, di
, &xi
, &xis
, &xbs
, &ctxt
);
2775 up_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2776 brelse(xbs
.xattr_bh
);
2777 ocfs2_xattr_bucket_free(xbs
.bucket
);
2785 * Set, replace or remove an extended attribute for this inode.
2786 * value is NULL to remove an existing extended attribute, else either
2787 * create or replace an extended attribute.
2789 int ocfs2_xattr_set(struct inode
*inode
,
2796 struct buffer_head
*di_bh
= NULL
;
2797 struct ocfs2_dinode
*di
;
2798 int ret
, credits
, ref_meta
= 0, ref_credits
= 0;
2799 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2800 struct inode
*tl_inode
= osb
->osb_tl_inode
;
2801 struct ocfs2_xattr_set_ctxt ctxt
= { NULL
, NULL
, };
2802 struct ocfs2_refcount_tree
*ref_tree
= NULL
;
2804 struct ocfs2_xattr_info xi
= {
2805 .name_index
= name_index
,
2808 .value_len
= value_len
,
2811 struct ocfs2_xattr_search xis
= {
2812 .not_found
= -ENODATA
,
2815 struct ocfs2_xattr_search xbs
= {
2816 .not_found
= -ENODATA
,
2819 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
2823 * Only xbs will be used on indexed trees. xis doesn't need a
2826 xbs
.bucket
= ocfs2_xattr_bucket_new(inode
);
2828 mlog_errno(-ENOMEM
);
2832 ret
= ocfs2_inode_lock(inode
, &di_bh
, 1);
2835 goto cleanup_nolock
;
2837 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
2838 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2840 down_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2842 * Scan inode and external block to find the same name
2843 * extended attribute and collect search infomation.
2845 ret
= ocfs2_xattr_ibody_find(inode
, name_index
, name
, &xis
);
2848 if (xis
.not_found
) {
2849 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, &xbs
);
2854 if (xis
.not_found
&& xbs
.not_found
) {
2856 if (flags
& XATTR_REPLACE
)
2863 if (flags
& XATTR_CREATE
)
2867 /* Check whether the value is refcounted and do some prepartion. */
2868 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_HAS_REFCOUNT_FL
&&
2869 (!xis
.not_found
|| !xbs
.not_found
)) {
2870 ret
= ocfs2_prepare_refcount_xattr(inode
, di
, &xi
,
2871 &xis
, &xbs
, &ref_tree
,
2872 &ref_meta
, &ref_credits
);
2879 mutex_lock(&tl_inode
->i_mutex
);
2881 if (ocfs2_truncate_log_needs_flush(osb
)) {
2882 ret
= __ocfs2_flush_truncate_log(osb
);
2884 mutex_unlock(&tl_inode
->i_mutex
);
2889 mutex_unlock(&tl_inode
->i_mutex
);
2891 ret
= ocfs2_init_xattr_set_ctxt(inode
, di
, &xi
, &xis
,
2892 &xbs
, &ctxt
, ref_meta
, &credits
);
2898 /* we need to update inode's ctime field, so add credit for it. */
2899 credits
+= OCFS2_INODE_UPDATE_CREDITS
;
2900 ctxt
.handle
= ocfs2_start_trans(osb
, credits
+ ref_credits
);
2901 if (IS_ERR(ctxt
.handle
)) {
2902 ret
= PTR_ERR(ctxt
.handle
);
2907 ret
= __ocfs2_xattr_set_handle(inode
, di
, &xi
, &xis
, &xbs
, &ctxt
);
2909 ocfs2_commit_trans(osb
, ctxt
.handle
);
2912 ocfs2_free_alloc_context(ctxt
.data_ac
);
2914 ocfs2_free_alloc_context(ctxt
.meta_ac
);
2915 if (ocfs2_dealloc_has_cluster(&ctxt
.dealloc
))
2916 ocfs2_schedule_truncate_log_flush(osb
, 1);
2917 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
2921 ocfs2_unlock_refcount_tree(osb
, ref_tree
, 1);
2922 up_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2923 if (!value
&& !ret
) {
2924 ret
= ocfs2_try_remove_refcount_tree(inode
, di_bh
);
2928 ocfs2_inode_unlock(inode
, 1);
2931 brelse(xbs
.xattr_bh
);
2932 ocfs2_xattr_bucket_free(xbs
.bucket
);
2938 * Find the xattr extent rec which may contains name_hash.
2939 * e_cpos will be the first name hash of the xattr rec.
2940 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
2942 static int ocfs2_xattr_get_rec(struct inode
*inode
,
2947 struct ocfs2_extent_list
*el
)
2950 struct buffer_head
*eb_bh
= NULL
;
2951 struct ocfs2_extent_block
*eb
;
2952 struct ocfs2_extent_rec
*rec
= NULL
;
2955 if (el
->l_tree_depth
) {
2956 ret
= ocfs2_find_leaf(INODE_CACHE(inode
), el
, name_hash
,
2963 eb
= (struct ocfs2_extent_block
*) eb_bh
->b_data
;
2966 if (el
->l_tree_depth
) {
2967 ocfs2_error(inode
->i_sb
,
2968 "Inode %lu has non zero tree depth in "
2969 "xattr tree block %llu\n", inode
->i_ino
,
2970 (unsigned long long)eb_bh
->b_blocknr
);
2976 for (i
= le16_to_cpu(el
->l_next_free_rec
) - 1; i
>= 0; i
--) {
2977 rec
= &el
->l_recs
[i
];
2979 if (le32_to_cpu(rec
->e_cpos
) <= name_hash
) {
2980 e_blkno
= le64_to_cpu(rec
->e_blkno
);
2986 ocfs2_error(inode
->i_sb
, "Inode %lu has bad extent "
2987 "record (%u, %u, 0) in xattr", inode
->i_ino
,
2988 le32_to_cpu(rec
->e_cpos
),
2989 ocfs2_rec_clusters(el
, rec
));
2994 *p_blkno
= le64_to_cpu(rec
->e_blkno
);
2995 *num_clusters
= le16_to_cpu(rec
->e_leaf_clusters
);
2997 *e_cpos
= le32_to_cpu(rec
->e_cpos
);
3003 typedef int (xattr_bucket_func
)(struct inode
*inode
,
3004 struct ocfs2_xattr_bucket
*bucket
,
3007 static int ocfs2_find_xe_in_bucket(struct inode
*inode
,
3008 struct ocfs2_xattr_bucket
*bucket
,
3015 int i
, ret
= 0, cmp
= 1, block_off
, new_offset
;
3016 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
3017 size_t name_len
= strlen(name
);
3018 struct ocfs2_xattr_entry
*xe
= NULL
;
3022 * We don't use binary search in the bucket because there
3023 * may be multiple entries with the same name hash.
3025 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
3026 xe
= &xh
->xh_entries
[i
];
3028 if (name_hash
> le32_to_cpu(xe
->xe_name_hash
))
3030 else if (name_hash
< le32_to_cpu(xe
->xe_name_hash
))
3033 cmp
= name_index
- ocfs2_xattr_get_type(xe
);
3035 cmp
= name_len
- xe
->xe_name_len
;
3039 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
3050 xe_name
= bucket_block(bucket
, block_off
) + new_offset
;
3051 if (!memcmp(name
, xe_name
, name_len
)) {
3063 * Find the specified xattr entry in a series of buckets.
3064 * This series start from p_blkno and last for num_clusters.
3065 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
3066 * the num of the valid buckets.
3068 * Return the buffer_head this xattr should reside in. And if the xattr's
3069 * hash is in the gap of 2 buckets, return the lower bucket.
3071 static int ocfs2_xattr_bucket_find(struct inode
*inode
,
3078 struct ocfs2_xattr_search
*xs
)
3081 struct ocfs2_xattr_header
*xh
= NULL
;
3082 struct ocfs2_xattr_entry
*xe
= NULL
;
3084 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
3085 int low_bucket
= 0, bucket
, high_bucket
;
3086 struct ocfs2_xattr_bucket
*search
;
3088 u64 blkno
, lower_blkno
= 0;
3090 search
= ocfs2_xattr_bucket_new(inode
);
3097 ret
= ocfs2_read_xattr_bucket(search
, p_blkno
);
3103 xh
= bucket_xh(search
);
3104 high_bucket
= le16_to_cpu(xh
->xh_num_buckets
) - 1;
3105 while (low_bucket
<= high_bucket
) {
3106 ocfs2_xattr_bucket_relse(search
);
3108 bucket
= (low_bucket
+ high_bucket
) / 2;
3109 blkno
= p_blkno
+ bucket
* blk_per_bucket
;
3110 ret
= ocfs2_read_xattr_bucket(search
, blkno
);
3116 xh
= bucket_xh(search
);
3117 xe
= &xh
->xh_entries
[0];
3118 if (name_hash
< le32_to_cpu(xe
->xe_name_hash
)) {
3119 high_bucket
= bucket
- 1;
3124 * Check whether the hash of the last entry in our
3125 * bucket is larger than the search one. for an empty
3126 * bucket, the last one is also the first one.
3129 xe
= &xh
->xh_entries
[le16_to_cpu(xh
->xh_count
) - 1];
3131 last_hash
= le32_to_cpu(xe
->xe_name_hash
);
3133 /* record lower_blkno which may be the insert place. */
3134 lower_blkno
= blkno
;
3136 if (name_hash
> le32_to_cpu(xe
->xe_name_hash
)) {
3137 low_bucket
= bucket
+ 1;
3141 /* the searched xattr should reside in this bucket if exists. */
3142 ret
= ocfs2_find_xe_in_bucket(inode
, search
,
3143 name_index
, name
, name_hash
,
3153 * Record the bucket we have found.
3154 * When the xattr's hash value is in the gap of 2 buckets, we will
3155 * always set it to the previous bucket.
3158 lower_blkno
= p_blkno
;
3160 /* This should be in cache - we just read it during the search */
3161 ret
= ocfs2_read_xattr_bucket(xs
->bucket
, lower_blkno
);
3167 xs
->header
= bucket_xh(xs
->bucket
);
3168 xs
->base
= bucket_block(xs
->bucket
, 0);
3169 xs
->end
= xs
->base
+ inode
->i_sb
->s_blocksize
;
3172 xs
->here
= &xs
->header
->xh_entries
[index
];
3173 mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name
,
3174 (unsigned long long)bucket_blkno(xs
->bucket
), index
);
3179 ocfs2_xattr_bucket_free(search
);
3183 static int ocfs2_xattr_index_block_find(struct inode
*inode
,
3184 struct buffer_head
*root_bh
,
3187 struct ocfs2_xattr_search
*xs
)
3190 struct ocfs2_xattr_block
*xb
=
3191 (struct ocfs2_xattr_block
*)root_bh
->b_data
;
3192 struct ocfs2_xattr_tree_root
*xb_root
= &xb
->xb_attrs
.xb_root
;
3193 struct ocfs2_extent_list
*el
= &xb_root
->xt_list
;
3195 u32 first_hash
, num_clusters
= 0;
3196 u32 name_hash
= ocfs2_xattr_name_hash(inode
, name
, strlen(name
));
3198 if (le16_to_cpu(el
->l_next_free_rec
) == 0)
3201 mlog(0, "find xattr %s, hash = %u, index = %d in xattr tree\n",
3202 name
, name_hash
, name_index
);
3204 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
, &first_hash
,
3211 BUG_ON(p_blkno
== 0 || num_clusters
== 0 || first_hash
> name_hash
);
3213 mlog(0, "find xattr extent rec %u clusters from %llu, the first hash "
3214 "in the rec is %u\n", num_clusters
, (unsigned long long)p_blkno
,
3217 ret
= ocfs2_xattr_bucket_find(inode
, name_index
, name
, name_hash
,
3218 p_blkno
, first_hash
, num_clusters
, xs
);
3224 static int ocfs2_iterate_xattr_buckets(struct inode
*inode
,
3227 xattr_bucket_func
*func
,
3231 u32 bpc
= ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode
->i_sb
));
3232 u32 num_buckets
= clusters
* bpc
;
3233 struct ocfs2_xattr_bucket
*bucket
;
3235 bucket
= ocfs2_xattr_bucket_new(inode
);
3237 mlog_errno(-ENOMEM
);
3241 mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
3242 clusters
, (unsigned long long)blkno
);
3244 for (i
= 0; i
< num_buckets
; i
++, blkno
+= bucket
->bu_blocks
) {
3245 ret
= ocfs2_read_xattr_bucket(bucket
, blkno
);
3252 * The real bucket num in this series of blocks is stored
3253 * in the 1st bucket.
3256 num_buckets
= le16_to_cpu(bucket_xh(bucket
)->xh_num_buckets
);
3258 mlog(0, "iterating xattr bucket %llu, first hash %u\n",
3259 (unsigned long long)blkno
,
3260 le32_to_cpu(bucket_xh(bucket
)->xh_entries
[0].xe_name_hash
));
3262 ret
= func(inode
, bucket
, para
);
3263 if (ret
&& ret
!= -ERANGE
)
3265 /* Fall through to bucket_relse() */
3268 ocfs2_xattr_bucket_relse(bucket
);
3273 ocfs2_xattr_bucket_free(bucket
);
3277 struct ocfs2_xattr_tree_list
{
3283 static int ocfs2_xattr_bucket_get_name_value(struct super_block
*sb
,
3284 struct ocfs2_xattr_header
*xh
,
3291 if (index
< 0 || index
>= le16_to_cpu(xh
->xh_count
))
3294 name_offset
= le16_to_cpu(xh
->xh_entries
[index
].xe_name_offset
);
3296 *block_off
= name_offset
>> sb
->s_blocksize_bits
;
3297 *new_offset
= name_offset
% sb
->s_blocksize
;
3302 static int ocfs2_list_xattr_bucket(struct inode
*inode
,
3303 struct ocfs2_xattr_bucket
*bucket
,
3307 struct ocfs2_xattr_tree_list
*xl
= (struct ocfs2_xattr_tree_list
*)para
;
3308 int i
, block_off
, new_offset
;
3309 const char *prefix
, *name
;
3311 for (i
= 0 ; i
< le16_to_cpu(bucket_xh(bucket
)->xh_count
); i
++) {
3312 struct ocfs2_xattr_entry
*entry
= &bucket_xh(bucket
)->xh_entries
[i
];
3313 type
= ocfs2_xattr_get_type(entry
);
3314 prefix
= ocfs2_xattr_prefix(type
);
3317 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
3325 name
= (const char *)bucket_block(bucket
, block_off
) +
3327 ret
= ocfs2_xattr_list_entry(xl
->buffer
,
3331 entry
->xe_name_len
);
3340 static int ocfs2_iterate_xattr_index_block(struct inode
*inode
,
3341 struct buffer_head
*blk_bh
,
3342 xattr_tree_rec_func
*rec_func
,
3345 struct ocfs2_xattr_block
*xb
=
3346 (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
3347 struct ocfs2_extent_list
*el
= &xb
->xb_attrs
.xb_root
.xt_list
;
3349 u32 name_hash
= UINT_MAX
, e_cpos
= 0, num_clusters
= 0;
3352 if (!el
->l_next_free_rec
|| !rec_func
)
3355 while (name_hash
> 0) {
3356 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
,
3357 &e_cpos
, &num_clusters
, el
);
3363 ret
= rec_func(inode
, blk_bh
, p_blkno
, e_cpos
,
3364 num_clusters
, para
);
3374 name_hash
= e_cpos
- 1;
3381 static int ocfs2_list_xattr_tree_rec(struct inode
*inode
,
3382 struct buffer_head
*root_bh
,
3383 u64 blkno
, u32 cpos
, u32 len
, void *para
)
3385 return ocfs2_iterate_xattr_buckets(inode
, blkno
, len
,
3386 ocfs2_list_xattr_bucket
, para
);
3389 static int ocfs2_xattr_tree_list_index_block(struct inode
*inode
,
3390 struct buffer_head
*blk_bh
,
3395 struct ocfs2_xattr_tree_list xl
= {
3397 .buffer_size
= buffer_size
,
3401 ret
= ocfs2_iterate_xattr_index_block(inode
, blk_bh
,
3402 ocfs2_list_xattr_tree_rec
, &xl
);
3413 static int cmp_xe(const void *a
, const void *b
)
3415 const struct ocfs2_xattr_entry
*l
= a
, *r
= b
;
3416 u32 l_hash
= le32_to_cpu(l
->xe_name_hash
);
3417 u32 r_hash
= le32_to_cpu(r
->xe_name_hash
);
3419 if (l_hash
> r_hash
)
3421 if (l_hash
< r_hash
)
3426 static void swap_xe(void *a
, void *b
, int size
)
3428 struct ocfs2_xattr_entry
*l
= a
, *r
= b
, tmp
;
3431 memcpy(l
, r
, sizeof(struct ocfs2_xattr_entry
));
3432 memcpy(r
, &tmp
, sizeof(struct ocfs2_xattr_entry
));
3436 * When the ocfs2_xattr_block is filled up, new bucket will be created
3437 * and all the xattr entries will be moved to the new bucket.
3438 * The header goes at the start of the bucket, and the names+values are
3439 * filled from the end. This is why *target starts as the last buffer.
3440 * Note: we need to sort the entries since they are not saved in order
3441 * in the ocfs2_xattr_block.
3443 static void ocfs2_cp_xattr_block_to_bucket(struct inode
*inode
,
3444 struct buffer_head
*xb_bh
,
3445 struct ocfs2_xattr_bucket
*bucket
)
3447 int i
, blocksize
= inode
->i_sb
->s_blocksize
;
3448 int blks
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
3449 u16 offset
, size
, off_change
;
3450 struct ocfs2_xattr_entry
*xe
;
3451 struct ocfs2_xattr_block
*xb
=
3452 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
3453 struct ocfs2_xattr_header
*xb_xh
= &xb
->xb_attrs
.xb_header
;
3454 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
3455 u16 count
= le16_to_cpu(xb_xh
->xh_count
);
3456 char *src
= xb_bh
->b_data
;
3457 char *target
= bucket_block(bucket
, blks
- 1);
3459 mlog(0, "cp xattr from block %llu to bucket %llu\n",
3460 (unsigned long long)xb_bh
->b_blocknr
,
3461 (unsigned long long)bucket_blkno(bucket
));
3463 for (i
= 0; i
< blks
; i
++)
3464 memset(bucket_block(bucket
, i
), 0, blocksize
);
3467 * Since the xe_name_offset is based on ocfs2_xattr_header,
3468 * there is a offset change corresponding to the change of
3469 * ocfs2_xattr_header's position.
3471 off_change
= offsetof(struct ocfs2_xattr_block
, xb_attrs
.xb_header
);
3472 xe
= &xb_xh
->xh_entries
[count
- 1];
3473 offset
= le16_to_cpu(xe
->xe_name_offset
) + off_change
;
3474 size
= blocksize
- offset
;
3476 /* copy all the names and values. */
3477 memcpy(target
+ offset
, src
+ offset
, size
);
3479 /* Init new header now. */
3480 xh
->xh_count
= xb_xh
->xh_count
;
3481 xh
->xh_num_buckets
= cpu_to_le16(1);
3482 xh
->xh_name_value_len
= cpu_to_le16(size
);
3483 xh
->xh_free_start
= cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
- size
);
3485 /* copy all the entries. */
3486 target
= bucket_block(bucket
, 0);
3487 offset
= offsetof(struct ocfs2_xattr_header
, xh_entries
);
3488 size
= count
* sizeof(struct ocfs2_xattr_entry
);
3489 memcpy(target
+ offset
, (char *)xb_xh
+ offset
, size
);
3491 /* Change the xe offset for all the xe because of the move. */
3492 off_change
= OCFS2_XATTR_BUCKET_SIZE
- blocksize
+
3493 offsetof(struct ocfs2_xattr_block
, xb_attrs
.xb_header
);
3494 for (i
= 0; i
< count
; i
++)
3495 le16_add_cpu(&xh
->xh_entries
[i
].xe_name_offset
, off_change
);
3497 mlog(0, "copy entry: start = %u, size = %u, offset_change = %u\n",
3498 offset
, size
, off_change
);
3500 sort(target
+ offset
, count
, sizeof(struct ocfs2_xattr_entry
),
3505 * After we move xattr from block to index btree, we have to
3506 * update ocfs2_xattr_search to the new xe and base.
3508 * When the entry is in xattr block, xattr_bh indicates the storage place.
3509 * While if the entry is in index b-tree, "bucket" indicates the
3510 * real place of the xattr.
3512 static void ocfs2_xattr_update_xattr_search(struct inode
*inode
,
3513 struct ocfs2_xattr_search
*xs
,
3514 struct buffer_head
*old_bh
)
3516 char *buf
= old_bh
->b_data
;
3517 struct ocfs2_xattr_block
*old_xb
= (struct ocfs2_xattr_block
*)buf
;
3518 struct ocfs2_xattr_header
*old_xh
= &old_xb
->xb_attrs
.xb_header
;
3521 xs
->header
= bucket_xh(xs
->bucket
);
3522 xs
->base
= bucket_block(xs
->bucket
, 0);
3523 xs
->end
= xs
->base
+ inode
->i_sb
->s_blocksize
;
3528 i
= xs
->here
- old_xh
->xh_entries
;
3529 xs
->here
= &xs
->header
->xh_entries
[i
];
3532 static int ocfs2_xattr_create_index_block(struct inode
*inode
,
3533 struct ocfs2_xattr_search
*xs
,
3534 struct ocfs2_xattr_set_ctxt
*ctxt
)
3539 handle_t
*handle
= ctxt
->handle
;
3540 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
3541 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
3542 struct buffer_head
*xb_bh
= xs
->xattr_bh
;
3543 struct ocfs2_xattr_block
*xb
=
3544 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
3545 struct ocfs2_xattr_tree_root
*xr
;
3546 u16 xb_flags
= le16_to_cpu(xb
->xb_flags
);
3548 mlog(0, "create xattr index block for %llu\n",
3549 (unsigned long long)xb_bh
->b_blocknr
);
3551 BUG_ON(xb_flags
& OCFS2_XATTR_INDEXED
);
3552 BUG_ON(!xs
->bucket
);
3556 * We can use this lock for now, and maybe move to a dedicated mutex
3557 * if performance becomes a problem later.
3559 down_write(&oi
->ip_alloc_sem
);
3561 ret
= ocfs2_journal_access_xb(handle
, INODE_CACHE(inode
), xb_bh
,
3562 OCFS2_JOURNAL_ACCESS_WRITE
);
3568 ret
= __ocfs2_claim_clusters(osb
, handle
, ctxt
->data_ac
,
3569 1, 1, &bit_off
, &len
);
3576 * The bucket may spread in many blocks, and
3577 * we will only touch the 1st block and the last block
3578 * in the whole bucket(one for entry and one for data).
3580 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, bit_off
);
3582 mlog(0, "allocate 1 cluster from %llu to xattr block\n",
3583 (unsigned long long)blkno
);
3585 ret
= ocfs2_init_xattr_bucket(xs
->bucket
, blkno
);
3591 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
3592 OCFS2_JOURNAL_ACCESS_CREATE
);
3598 ocfs2_cp_xattr_block_to_bucket(inode
, xb_bh
, xs
->bucket
);
3599 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
3601 ocfs2_xattr_update_xattr_search(inode
, xs
, xb_bh
);
3603 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
3604 memset(&xb
->xb_attrs
, 0, inode
->i_sb
->s_blocksize
-
3605 offsetof(struct ocfs2_xattr_block
, xb_attrs
));
3607 xr
= &xb
->xb_attrs
.xb_root
;
3608 xr
->xt_clusters
= cpu_to_le32(1);
3609 xr
->xt_last_eb_blk
= 0;
3610 xr
->xt_list
.l_tree_depth
= 0;
3611 xr
->xt_list
.l_count
= cpu_to_le16(ocfs2_xattr_recs_per_xb(inode
->i_sb
));
3612 xr
->xt_list
.l_next_free_rec
= cpu_to_le16(1);
3614 xr
->xt_list
.l_recs
[0].e_cpos
= 0;
3615 xr
->xt_list
.l_recs
[0].e_blkno
= cpu_to_le64(blkno
);
3616 xr
->xt_list
.l_recs
[0].e_leaf_clusters
= cpu_to_le16(1);
3618 xb
->xb_flags
= cpu_to_le16(xb_flags
| OCFS2_XATTR_INDEXED
);
3620 ocfs2_journal_dirty(handle
, xb_bh
);
3623 up_write(&oi
->ip_alloc_sem
);
3628 static int cmp_xe_offset(const void *a
, const void *b
)
3630 const struct ocfs2_xattr_entry
*l
= a
, *r
= b
;
3631 u32 l_name_offset
= le16_to_cpu(l
->xe_name_offset
);
3632 u32 r_name_offset
= le16_to_cpu(r
->xe_name_offset
);
3634 if (l_name_offset
< r_name_offset
)
3636 if (l_name_offset
> r_name_offset
)
3642 * defrag a xattr bucket if we find that the bucket has some
3643 * holes beteen name/value pairs.
3644 * We will move all the name/value pairs to the end of the bucket
3645 * so that we can spare some space for insertion.
3647 static int ocfs2_defrag_xattr_bucket(struct inode
*inode
,
3649 struct ocfs2_xattr_bucket
*bucket
)
3652 size_t end
, offset
, len
, value_len
;
3653 struct ocfs2_xattr_header
*xh
;
3654 char *entries
, *buf
, *bucket_buf
= NULL
;
3655 u64 blkno
= bucket_blkno(bucket
);
3657 size_t blocksize
= inode
->i_sb
->s_blocksize
;
3658 struct ocfs2_xattr_entry
*xe
;
3661 * In order to make the operation more efficient and generic,
3662 * we copy all the blocks into a contiguous memory and do the
3663 * defragment there, so if anything is error, we will not touch
3666 bucket_buf
= kmalloc(OCFS2_XATTR_BUCKET_SIZE
, GFP_NOFS
);
3673 for (i
= 0; i
< bucket
->bu_blocks
; i
++, buf
+= blocksize
)
3674 memcpy(buf
, bucket_block(bucket
, i
), blocksize
);
3676 ret
= ocfs2_xattr_bucket_journal_access(handle
, bucket
,
3677 OCFS2_JOURNAL_ACCESS_WRITE
);
3683 xh
= (struct ocfs2_xattr_header
*)bucket_buf
;
3684 entries
= (char *)xh
->xh_entries
;
3685 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
3687 mlog(0, "adjust xattr bucket in %llu, count = %u, "
3688 "xh_free_start = %u, xh_name_value_len = %u.\n",
3689 (unsigned long long)blkno
, le16_to_cpu(xh
->xh_count
),
3690 xh_free_start
, le16_to_cpu(xh
->xh_name_value_len
));
3693 * sort all the entries by their offset.
3694 * the largest will be the first, so that we can
3695 * move them to the end one by one.
3697 sort(entries
, le16_to_cpu(xh
->xh_count
),
3698 sizeof(struct ocfs2_xattr_entry
),
3699 cmp_xe_offset
, swap_xe
);
3701 /* Move all name/values to the end of the bucket. */
3702 xe
= xh
->xh_entries
;
3703 end
= OCFS2_XATTR_BUCKET_SIZE
;
3704 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++, xe
++) {
3705 offset
= le16_to_cpu(xe
->xe_name_offset
);
3706 if (ocfs2_xattr_is_local(xe
))
3707 value_len
= OCFS2_XATTR_SIZE(
3708 le64_to_cpu(xe
->xe_value_size
));
3710 value_len
= OCFS2_XATTR_ROOT_SIZE
;
3711 len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
) + value_len
;
3714 * We must make sure that the name/value pair
3715 * exist in the same block. So adjust end to
3716 * the previous block end if needed.
3718 if (((end
- len
) / blocksize
!=
3719 (end
- 1) / blocksize
))
3720 end
= end
- end
% blocksize
;
3722 if (end
> offset
+ len
) {
3723 memmove(bucket_buf
+ end
- len
,
3724 bucket_buf
+ offset
, len
);
3725 xe
->xe_name_offset
= cpu_to_le16(end
- len
);
3728 mlog_bug_on_msg(end
< offset
+ len
, "Defrag check failed for "
3729 "bucket %llu\n", (unsigned long long)blkno
);
3734 mlog_bug_on_msg(xh_free_start
> end
, "Defrag check failed for "
3735 "bucket %llu\n", (unsigned long long)blkno
);
3737 if (xh_free_start
== end
)
3740 memset(bucket_buf
+ xh_free_start
, 0, end
- xh_free_start
);
3741 xh
->xh_free_start
= cpu_to_le16(end
);
3743 /* sort the entries by their name_hash. */
3744 sort(entries
, le16_to_cpu(xh
->xh_count
),
3745 sizeof(struct ocfs2_xattr_entry
),
3749 for (i
= 0; i
< bucket
->bu_blocks
; i
++, buf
+= blocksize
)
3750 memcpy(bucket_block(bucket
, i
), buf
, blocksize
);
3751 ocfs2_xattr_bucket_journal_dirty(handle
, bucket
);
3759 * prev_blkno points to the start of an existing extent. new_blkno
3760 * points to a newly allocated extent. Because we know each of our
3761 * clusters contains more than bucket, we can easily split one cluster
3762 * at a bucket boundary. So we take the last cluster of the existing
3763 * extent and split it down the middle. We move the last half of the
3764 * buckets in the last cluster of the existing extent over to the new
3767 * first_bh is the buffer at prev_blkno so we can update the existing
3768 * extent's bucket count. header_bh is the bucket were we were hoping
3769 * to insert our xattr. If the bucket move places the target in the new
3770 * extent, we'll update first_bh and header_bh after modifying the old
3773 * first_hash will be set as the 1st xe's name_hash in the new extent.
3775 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode
*inode
,
3777 struct ocfs2_xattr_bucket
*first
,
3778 struct ocfs2_xattr_bucket
*target
,
3784 struct super_block
*sb
= inode
->i_sb
;
3785 int blks_per_bucket
= ocfs2_blocks_per_xattr_bucket(sb
);
3786 int num_buckets
= ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb
));
3787 int to_move
= num_buckets
/ 2;
3789 u64 last_cluster_blkno
= bucket_blkno(first
) +
3790 ((num_clusters
- 1) * ocfs2_clusters_to_blocks(sb
, 1));
3792 BUG_ON(le16_to_cpu(bucket_xh(first
)->xh_num_buckets
) < num_buckets
);
3793 BUG_ON(OCFS2_XATTR_BUCKET_SIZE
== OCFS2_SB(sb
)->s_clustersize
);
3795 mlog(0, "move half of xattrs in cluster %llu to %llu\n",
3796 (unsigned long long)last_cluster_blkno
, (unsigned long long)new_blkno
);
3798 ret
= ocfs2_mv_xattr_buckets(inode
, handle
, bucket_blkno(first
),
3799 last_cluster_blkno
, new_blkno
,
3800 to_move
, first_hash
);
3806 /* This is the first bucket that got moved */
3807 src_blkno
= last_cluster_blkno
+ (to_move
* blks_per_bucket
);
3810 * If the target bucket was part of the moved buckets, we need to
3811 * update first and target.
3813 if (bucket_blkno(target
) >= src_blkno
) {
3814 /* Find the block for the new target bucket */
3815 src_blkno
= new_blkno
+
3816 (bucket_blkno(target
) - src_blkno
);
3818 ocfs2_xattr_bucket_relse(first
);
3819 ocfs2_xattr_bucket_relse(target
);
3822 * These shouldn't fail - the buffers are in the
3823 * journal from ocfs2_cp_xattr_bucket().
3825 ret
= ocfs2_read_xattr_bucket(first
, new_blkno
);
3830 ret
= ocfs2_read_xattr_bucket(target
, src_blkno
);
3841 * Find the suitable pos when we divide a bucket into 2.
3842 * We have to make sure the xattrs with the same hash value exist
3843 * in the same bucket.
3845 * If this ocfs2_xattr_header covers more than one hash value, find a
3846 * place where the hash value changes. Try to find the most even split.
3847 * The most common case is that all entries have different hash values,
3848 * and the first check we make will find a place to split.
3850 static int ocfs2_xattr_find_divide_pos(struct ocfs2_xattr_header
*xh
)
3852 struct ocfs2_xattr_entry
*entries
= xh
->xh_entries
;
3853 int count
= le16_to_cpu(xh
->xh_count
);
3854 int delta
, middle
= count
/ 2;
3857 * We start at the middle. Each step gets farther away in both
3858 * directions. We therefore hit the change in hash value
3859 * nearest to the middle. Note that this loop does not execute for
3862 for (delta
= 0; delta
< middle
; delta
++) {
3863 /* Let's check delta earlier than middle */
3864 if (cmp_xe(&entries
[middle
- delta
- 1],
3865 &entries
[middle
- delta
]))
3866 return middle
- delta
;
3868 /* For even counts, don't walk off the end */
3869 if ((middle
+ delta
+ 1) == count
)
3872 /* Now try delta past middle */
3873 if (cmp_xe(&entries
[middle
+ delta
],
3874 &entries
[middle
+ delta
+ 1]))
3875 return middle
+ delta
+ 1;
3878 /* Every entry had the same hash */
3883 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
3884 * first_hash will record the 1st hash of the new bucket.
3886 * Normally half of the xattrs will be moved. But we have to make
3887 * sure that the xattrs with the same hash value are stored in the
3888 * same bucket. If all the xattrs in this bucket have the same hash
3889 * value, the new bucket will be initialized as an empty one and the
3890 * first_hash will be initialized as (hash_value+1).
3892 static int ocfs2_divide_xattr_bucket(struct inode
*inode
,
3897 int new_bucket_head
)
3900 int count
, start
, len
, name_value_len
= 0, xe_len
, name_offset
= 0;
3901 struct ocfs2_xattr_bucket
*s_bucket
= NULL
, *t_bucket
= NULL
;
3902 struct ocfs2_xattr_header
*xh
;
3903 struct ocfs2_xattr_entry
*xe
;
3904 int blocksize
= inode
->i_sb
->s_blocksize
;
3906 mlog(0, "move some of xattrs from bucket %llu to %llu\n",
3907 (unsigned long long)blk
, (unsigned long long)new_blk
);
3909 s_bucket
= ocfs2_xattr_bucket_new(inode
);
3910 t_bucket
= ocfs2_xattr_bucket_new(inode
);
3911 if (!s_bucket
|| !t_bucket
) {
3917 ret
= ocfs2_read_xattr_bucket(s_bucket
, blk
);
3923 ret
= ocfs2_xattr_bucket_journal_access(handle
, s_bucket
,
3924 OCFS2_JOURNAL_ACCESS_WRITE
);
3931 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
3932 * there's no need to read it.
3934 ret
= ocfs2_init_xattr_bucket(t_bucket
, new_blk
);
3941 * Hey, if we're overwriting t_bucket, what difference does
3942 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
3943 * same part of ocfs2_cp_xattr_bucket().
3945 ret
= ocfs2_xattr_bucket_journal_access(handle
, t_bucket
,
3947 OCFS2_JOURNAL_ACCESS_CREATE
:
3948 OCFS2_JOURNAL_ACCESS_WRITE
);
3954 xh
= bucket_xh(s_bucket
);
3955 count
= le16_to_cpu(xh
->xh_count
);
3956 start
= ocfs2_xattr_find_divide_pos(xh
);
3958 if (start
== count
) {
3959 xe
= &xh
->xh_entries
[start
-1];
3962 * initialized a new empty bucket here.
3963 * The hash value is set as one larger than
3964 * that of the last entry in the previous bucket.
3966 for (i
= 0; i
< t_bucket
->bu_blocks
; i
++)
3967 memset(bucket_block(t_bucket
, i
), 0, blocksize
);
3969 xh
= bucket_xh(t_bucket
);
3970 xh
->xh_free_start
= cpu_to_le16(blocksize
);
3971 xh
->xh_entries
[0].xe_name_hash
= xe
->xe_name_hash
;
3972 le32_add_cpu(&xh
->xh_entries
[0].xe_name_hash
, 1);
3974 goto set_num_buckets
;
3977 /* copy the whole bucket to the new first. */
3978 ocfs2_xattr_bucket_copy_data(t_bucket
, s_bucket
);
3980 /* update the new bucket. */
3981 xh
= bucket_xh(t_bucket
);
3984 * Calculate the total name/value len and xh_free_start for
3985 * the old bucket first.
3987 name_offset
= OCFS2_XATTR_BUCKET_SIZE
;
3989 for (i
= 0; i
< start
; i
++) {
3990 xe
= &xh
->xh_entries
[i
];
3991 xe_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
3992 if (ocfs2_xattr_is_local(xe
))
3994 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
3996 xe_len
+= OCFS2_XATTR_ROOT_SIZE
;
3997 name_value_len
+= xe_len
;
3998 if (le16_to_cpu(xe
->xe_name_offset
) < name_offset
)
3999 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
4003 * Now begin the modification to the new bucket.
4005 * In the new bucket, We just move the xattr entry to the beginning
4006 * and don't touch the name/value. So there will be some holes in the
4007 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
4010 xe
= &xh
->xh_entries
[start
];
4011 len
= sizeof(struct ocfs2_xattr_entry
) * (count
- start
);
4012 mlog(0, "mv xattr entry len %d from %d to %d\n", len
,
4013 (int)((char *)xe
- (char *)xh
),
4014 (int)((char *)xh
->xh_entries
- (char *)xh
));
4015 memmove((char *)xh
->xh_entries
, (char *)xe
, len
);
4016 xe
= &xh
->xh_entries
[count
- start
];
4017 len
= sizeof(struct ocfs2_xattr_entry
) * start
;
4018 memset((char *)xe
, 0, len
);
4020 le16_add_cpu(&xh
->xh_count
, -start
);
4021 le16_add_cpu(&xh
->xh_name_value_len
, -name_value_len
);
4023 /* Calculate xh_free_start for the new bucket. */
4024 xh
->xh_free_start
= cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
);
4025 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
4026 xe
= &xh
->xh_entries
[i
];
4027 xe_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
4028 if (ocfs2_xattr_is_local(xe
))
4030 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
4032 xe_len
+= OCFS2_XATTR_ROOT_SIZE
;
4033 if (le16_to_cpu(xe
->xe_name_offset
) <
4034 le16_to_cpu(xh
->xh_free_start
))
4035 xh
->xh_free_start
= xe
->xe_name_offset
;
4039 /* set xh->xh_num_buckets for the new xh. */
4040 if (new_bucket_head
)
4041 xh
->xh_num_buckets
= cpu_to_le16(1);
4043 xh
->xh_num_buckets
= 0;
4045 ocfs2_xattr_bucket_journal_dirty(handle
, t_bucket
);
4047 /* store the first_hash of the new bucket. */
4049 *first_hash
= le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
);
4052 * Now only update the 1st block of the old bucket. If we
4053 * just added a new empty bucket, there is no need to modify
4059 xh
= bucket_xh(s_bucket
);
4060 memset(&xh
->xh_entries
[start
], 0,
4061 sizeof(struct ocfs2_xattr_entry
) * (count
- start
));
4062 xh
->xh_count
= cpu_to_le16(start
);
4063 xh
->xh_free_start
= cpu_to_le16(name_offset
);
4064 xh
->xh_name_value_len
= cpu_to_le16(name_value_len
);
4066 ocfs2_xattr_bucket_journal_dirty(handle
, s_bucket
);
4069 ocfs2_xattr_bucket_free(s_bucket
);
4070 ocfs2_xattr_bucket_free(t_bucket
);
4076 * Copy xattr from one bucket to another bucket.
4078 * The caller must make sure that the journal transaction
4079 * has enough space for journaling.
4081 static int ocfs2_cp_xattr_bucket(struct inode
*inode
,
4088 struct ocfs2_xattr_bucket
*s_bucket
= NULL
, *t_bucket
= NULL
;
4090 BUG_ON(s_blkno
== t_blkno
);
4092 mlog(0, "cp bucket %llu to %llu, target is %d\n",
4093 (unsigned long long)s_blkno
, (unsigned long long)t_blkno
,
4096 s_bucket
= ocfs2_xattr_bucket_new(inode
);
4097 t_bucket
= ocfs2_xattr_bucket_new(inode
);
4098 if (!s_bucket
|| !t_bucket
) {
4104 ret
= ocfs2_read_xattr_bucket(s_bucket
, s_blkno
);
4109 * Even if !t_is_new, we're overwriting t_bucket. Thus,
4110 * there's no need to read it.
4112 ret
= ocfs2_init_xattr_bucket(t_bucket
, t_blkno
);
4117 * Hey, if we're overwriting t_bucket, what difference does
4118 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
4119 * cluster to fill, we came here from
4120 * ocfs2_mv_xattr_buckets(), and it is really new -
4121 * ACCESS_CREATE is required. But we also might have moved data
4122 * out of t_bucket before extending back into it.
4123 * ocfs2_add_new_xattr_bucket() can do this - its call to
4124 * ocfs2_add_new_xattr_cluster() may have created a new extent
4125 * and copied out the end of the old extent. Then it re-extends
4126 * the old extent back to create space for new xattrs. That's
4127 * how we get here, and the bucket isn't really new.
4129 ret
= ocfs2_xattr_bucket_journal_access(handle
, t_bucket
,
4131 OCFS2_JOURNAL_ACCESS_CREATE
:
4132 OCFS2_JOURNAL_ACCESS_WRITE
);
4136 ocfs2_xattr_bucket_copy_data(t_bucket
, s_bucket
);
4137 ocfs2_xattr_bucket_journal_dirty(handle
, t_bucket
);
4140 ocfs2_xattr_bucket_free(t_bucket
);
4141 ocfs2_xattr_bucket_free(s_bucket
);
4147 * src_blk points to the start of an existing extent. last_blk points to
4148 * last cluster in that extent. to_blk points to a newly allocated
4149 * extent. We copy the buckets from the cluster at last_blk to the new
4150 * extent. If start_bucket is non-zero, we skip that many buckets before
4151 * we start copying. The new extent's xh_num_buckets gets set to the
4152 * number of buckets we copied. The old extent's xh_num_buckets shrinks
4153 * by the same amount.
4155 static int ocfs2_mv_xattr_buckets(struct inode
*inode
, handle_t
*handle
,
4156 u64 src_blk
, u64 last_blk
, u64 to_blk
,
4157 unsigned int start_bucket
,
4160 int i
, ret
, credits
;
4161 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4162 int blks_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4163 int num_buckets
= ocfs2_xattr_buckets_per_cluster(osb
);
4164 struct ocfs2_xattr_bucket
*old_first
, *new_first
;
4166 mlog(0, "mv xattrs from cluster %llu to %llu\n",
4167 (unsigned long long)last_blk
, (unsigned long long)to_blk
);
4169 BUG_ON(start_bucket
>= num_buckets
);
4171 num_buckets
-= start_bucket
;
4172 last_blk
+= (start_bucket
* blks_per_bucket
);
4175 /* The first bucket of the original extent */
4176 old_first
= ocfs2_xattr_bucket_new(inode
);
4177 /* The first bucket of the new extent */
4178 new_first
= ocfs2_xattr_bucket_new(inode
);
4179 if (!old_first
|| !new_first
) {
4185 ret
= ocfs2_read_xattr_bucket(old_first
, src_blk
);
4192 * We need to update the first bucket of the old extent and all
4193 * the buckets going to the new extent.
4195 credits
= ((num_buckets
+ 1) * blks_per_bucket
) +
4196 handle
->h_buffer_credits
;
4197 ret
= ocfs2_extend_trans(handle
, credits
);
4203 ret
= ocfs2_xattr_bucket_journal_access(handle
, old_first
,
4204 OCFS2_JOURNAL_ACCESS_WRITE
);
4210 for (i
= 0; i
< num_buckets
; i
++) {
4211 ret
= ocfs2_cp_xattr_bucket(inode
, handle
,
4212 last_blk
+ (i
* blks_per_bucket
),
4213 to_blk
+ (i
* blks_per_bucket
),
4222 * Get the new bucket ready before we dirty anything
4223 * (This actually shouldn't fail, because we already dirtied
4224 * it once in ocfs2_cp_xattr_bucket()).
4226 ret
= ocfs2_read_xattr_bucket(new_first
, to_blk
);
4231 ret
= ocfs2_xattr_bucket_journal_access(handle
, new_first
,
4232 OCFS2_JOURNAL_ACCESS_WRITE
);
4238 /* Now update the headers */
4239 le16_add_cpu(&bucket_xh(old_first
)->xh_num_buckets
, -num_buckets
);
4240 ocfs2_xattr_bucket_journal_dirty(handle
, old_first
);
4242 bucket_xh(new_first
)->xh_num_buckets
= cpu_to_le16(num_buckets
);
4243 ocfs2_xattr_bucket_journal_dirty(handle
, new_first
);
4246 *first_hash
= le32_to_cpu(bucket_xh(new_first
)->xh_entries
[0].xe_name_hash
);
4249 ocfs2_xattr_bucket_free(new_first
);
4250 ocfs2_xattr_bucket_free(old_first
);
4255 * Move some xattrs in this cluster to the new cluster.
4256 * This function should only be called when bucket size == cluster size.
4257 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4259 static int ocfs2_divide_xattr_cluster(struct inode
*inode
,
4265 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4266 int ret
, credits
= 2 * blk_per_bucket
+ handle
->h_buffer_credits
;
4268 BUG_ON(OCFS2_XATTR_BUCKET_SIZE
< OCFS2_SB(inode
->i_sb
)->s_clustersize
);
4270 ret
= ocfs2_extend_trans(handle
, credits
);
4276 /* Move half of the xattr in start_blk to the next bucket. */
4277 return ocfs2_divide_xattr_bucket(inode
, handle
, prev_blk
,
4278 new_blk
, first_hash
, 1);
4282 * Move some xattrs from the old cluster to the new one since they are not
4283 * contiguous in ocfs2 xattr tree.
4285 * new_blk starts a new separate cluster, and we will move some xattrs from
4286 * prev_blk to it. v_start will be set as the first name hash value in this
4287 * new cluster so that it can be used as e_cpos during tree insertion and
4288 * don't collide with our original b-tree operations. first_bh and header_bh
4289 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
4290 * to extend the insert bucket.
4292 * The problem is how much xattr should we move to the new one and when should
4293 * we update first_bh and header_bh?
4294 * 1. If cluster size > bucket size, that means the previous cluster has more
4295 * than 1 bucket, so just move half nums of bucket into the new cluster and
4296 * update the first_bh and header_bh if the insert bucket has been moved
4297 * to the new cluster.
4298 * 2. If cluster_size == bucket_size:
4299 * a) If the previous extent rec has more than one cluster and the insert
4300 * place isn't in the last cluster, copy the entire last cluster to the
4301 * new one. This time, we don't need to upate the first_bh and header_bh
4302 * since they will not be moved into the new cluster.
4303 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
4304 * the new one. And we set the extend flag to zero if the insert place is
4305 * moved into the new allocated cluster since no extend is needed.
4307 static int ocfs2_adjust_xattr_cross_cluster(struct inode
*inode
,
4309 struct ocfs2_xattr_bucket
*first
,
4310 struct ocfs2_xattr_bucket
*target
,
4318 mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n",
4319 (unsigned long long)bucket_blkno(first
), prev_clusters
,
4320 (unsigned long long)new_blk
);
4322 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode
->i_sb
)) > 1) {
4323 ret
= ocfs2_mv_xattr_bucket_cross_cluster(inode
,
4332 /* The start of the last cluster in the first extent */
4333 u64 last_blk
= bucket_blkno(first
) +
4334 ((prev_clusters
- 1) *
4335 ocfs2_clusters_to_blocks(inode
->i_sb
, 1));
4337 if (prev_clusters
> 1 && bucket_blkno(target
) != last_blk
) {
4338 ret
= ocfs2_mv_xattr_buckets(inode
, handle
,
4339 bucket_blkno(first
),
4340 last_blk
, new_blk
, 0,
4345 ret
= ocfs2_divide_xattr_cluster(inode
, handle
,
4351 if ((bucket_blkno(target
) == last_blk
) && extend
)
4360 * Add a new cluster for xattr storage.
4362 * If the new cluster is contiguous with the previous one, it will be
4363 * appended to the same extent record, and num_clusters will be updated.
4364 * If not, we will insert a new extent for it and move some xattrs in
4365 * the last cluster into the new allocated one.
4366 * We also need to limit the maximum size of a btree leaf, otherwise we'll
4367 * lose the benefits of hashing because we'll have to search large leaves.
4368 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
4371 * first_bh is the first block of the previous extent rec and header_bh
4372 * indicates the bucket we will insert the new xattrs. They will be updated
4373 * when the header_bh is moved into the new cluster.
4375 static int ocfs2_add_new_xattr_cluster(struct inode
*inode
,
4376 struct buffer_head
*root_bh
,
4377 struct ocfs2_xattr_bucket
*first
,
4378 struct ocfs2_xattr_bucket
*target
,
4382 struct ocfs2_xattr_set_ctxt
*ctxt
)
4385 u16 bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
4386 u32 prev_clusters
= *num_clusters
;
4387 u32 clusters_to_add
= 1, bit_off
, num_bits
, v_start
= 0;
4389 handle_t
*handle
= ctxt
->handle
;
4390 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4391 struct ocfs2_extent_tree et
;
4393 mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, "
4394 "previous xattr blkno = %llu\n",
4395 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
4396 prev_cpos
, (unsigned long long)bucket_blkno(first
));
4398 ocfs2_init_xattr_tree_extent_tree(&et
, INODE_CACHE(inode
), root_bh
);
4400 ret
= ocfs2_journal_access_xb(handle
, INODE_CACHE(inode
), root_bh
,
4401 OCFS2_JOURNAL_ACCESS_WRITE
);
4407 ret
= __ocfs2_claim_clusters(osb
, handle
, ctxt
->data_ac
, 1,
4408 clusters_to_add
, &bit_off
, &num_bits
);
4415 BUG_ON(num_bits
> clusters_to_add
);
4417 block
= ocfs2_clusters_to_blocks(osb
->sb
, bit_off
);
4418 mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n",
4419 num_bits
, bit_off
, (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
4421 if (bucket_blkno(first
) + (prev_clusters
* bpc
) == block
&&
4422 (prev_clusters
+ num_bits
) << osb
->s_clustersize_bits
<=
4423 OCFS2_MAX_XATTR_TREE_LEAF_SIZE
) {
4425 * If this cluster is contiguous with the old one and
4426 * adding this new cluster, we don't surpass the limit of
4427 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
4428 * initialized and used like other buckets in the previous
4430 * So add it as a contiguous one. The caller will handle
4433 v_start
= prev_cpos
+ prev_clusters
;
4434 *num_clusters
= prev_clusters
+ num_bits
;
4435 mlog(0, "Add contiguous %u clusters to previous extent rec.\n",
4438 ret
= ocfs2_adjust_xattr_cross_cluster(inode
,
4452 mlog(0, "Insert %u clusters at block %llu for xattr at %u\n",
4453 num_bits
, (unsigned long long)block
, v_start
);
4454 ret
= ocfs2_insert_extent(handle
, &et
, v_start
, block
,
4455 num_bits
, 0, ctxt
->meta_ac
);
4461 ret
= ocfs2_journal_dirty(handle
, root_bh
);
4470 * We are given an extent. 'first' is the bucket at the very front of
4471 * the extent. The extent has space for an additional bucket past
4472 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
4473 * of the target bucket. We wish to shift every bucket past the target
4474 * down one, filling in that additional space. When we get back to the
4475 * target, we split the target between itself and the now-empty bucket
4476 * at target+1 (aka, target_blkno + blks_per_bucket).
4478 static int ocfs2_extend_xattr_bucket(struct inode
*inode
,
4480 struct ocfs2_xattr_bucket
*first
,
4485 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4486 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4488 u16 new_bucket
= le16_to_cpu(bucket_xh(first
)->xh_num_buckets
);
4490 mlog(0, "extend xattr bucket in %llu, xattr extend rec starting "
4491 "from %llu, len = %u\n", (unsigned long long)target_blk
,
4492 (unsigned long long)bucket_blkno(first
), num_clusters
);
4494 /* The extent must have room for an additional bucket */
4495 BUG_ON(new_bucket
>=
4496 (num_clusters
* ocfs2_xattr_buckets_per_cluster(osb
)));
4498 /* end_blk points to the last existing bucket */
4499 end_blk
= bucket_blkno(first
) + ((new_bucket
- 1) * blk_per_bucket
);
4502 * end_blk is the start of the last existing bucket.
4503 * Thus, (end_blk - target_blk) covers the target bucket and
4504 * every bucket after it up to, but not including, the last
4505 * existing bucket. Then we add the last existing bucket, the
4506 * new bucket, and the first bucket (3 * blk_per_bucket).
4508 credits
= (end_blk
- target_blk
) + (3 * blk_per_bucket
) +
4509 handle
->h_buffer_credits
;
4510 ret
= ocfs2_extend_trans(handle
, credits
);
4516 ret
= ocfs2_xattr_bucket_journal_access(handle
, first
,
4517 OCFS2_JOURNAL_ACCESS_WRITE
);
4523 while (end_blk
!= target_blk
) {
4524 ret
= ocfs2_cp_xattr_bucket(inode
, handle
, end_blk
,
4525 end_blk
+ blk_per_bucket
, 0);
4528 end_blk
-= blk_per_bucket
;
4531 /* Move half of the xattr in target_blkno to the next bucket. */
4532 ret
= ocfs2_divide_xattr_bucket(inode
, handle
, target_blk
,
4533 target_blk
+ blk_per_bucket
, NULL
, 0);
4535 le16_add_cpu(&bucket_xh(first
)->xh_num_buckets
, 1);
4536 ocfs2_xattr_bucket_journal_dirty(handle
, first
);
4543 * Add new xattr bucket in an extent record and adjust the buckets
4544 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
4545 * bucket we want to insert into.
4547 * In the easy case, we will move all the buckets after target down by
4548 * one. Half of target's xattrs will be moved to the next bucket.
4550 * If current cluster is full, we'll allocate a new one. This may not
4551 * be contiguous. The underlying calls will make sure that there is
4552 * space for the insert, shifting buckets around if necessary.
4553 * 'target' may be moved by those calls.
4555 static int ocfs2_add_new_xattr_bucket(struct inode
*inode
,
4556 struct buffer_head
*xb_bh
,
4557 struct ocfs2_xattr_bucket
*target
,
4558 struct ocfs2_xattr_set_ctxt
*ctxt
)
4560 struct ocfs2_xattr_block
*xb
=
4561 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
4562 struct ocfs2_xattr_tree_root
*xb_root
= &xb
->xb_attrs
.xb_root
;
4563 struct ocfs2_extent_list
*el
= &xb_root
->xt_list
;
4565 le32_to_cpu(bucket_xh(target
)->xh_entries
[0].xe_name_hash
);
4566 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4567 int ret
, num_buckets
, extend
= 1;
4569 u32 e_cpos
, num_clusters
;
4570 /* The bucket at the front of the extent */
4571 struct ocfs2_xattr_bucket
*first
;
4573 mlog(0, "Add new xattr bucket starting from %llu\n",
4574 (unsigned long long)bucket_blkno(target
));
4576 /* The first bucket of the original extent */
4577 first
= ocfs2_xattr_bucket_new(inode
);
4584 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
, &e_cpos
,
4591 ret
= ocfs2_read_xattr_bucket(first
, p_blkno
);
4597 num_buckets
= ocfs2_xattr_buckets_per_cluster(osb
) * num_clusters
;
4598 if (num_buckets
== le16_to_cpu(bucket_xh(first
)->xh_num_buckets
)) {
4600 * This can move first+target if the target bucket moves
4601 * to the new extent.
4603 ret
= ocfs2_add_new_xattr_cluster(inode
,
4618 ret
= ocfs2_extend_xattr_bucket(inode
,
4621 bucket_blkno(target
),
4628 ocfs2_xattr_bucket_free(first
);
4633 static inline char *ocfs2_xattr_bucket_get_val(struct inode
*inode
,
4634 struct ocfs2_xattr_bucket
*bucket
,
4637 int block_off
= offs
>> inode
->i_sb
->s_blocksize_bits
;
4639 offs
= offs
% inode
->i_sb
->s_blocksize
;
4640 return bucket_block(bucket
, block_off
) + offs
;
4644 * Handle the normal xattr set, including replace, delete and new.
4646 * Note: "local" indicates the real data's locality. So we can't
4647 * just its bucket locality by its length.
4649 static void ocfs2_xattr_set_entry_normal(struct inode
*inode
,
4650 struct ocfs2_xattr_info
*xi
,
4651 struct ocfs2_xattr_search
*xs
,
4655 struct ocfs2_xattr_entry
*last
, *xe
;
4656 int name_len
= strlen(xi
->name
);
4657 struct ocfs2_xattr_header
*xh
= xs
->header
;
4658 u16 count
= le16_to_cpu(xh
->xh_count
), start
;
4659 size_t blocksize
= inode
->i_sb
->s_blocksize
;
4661 size_t offs
, size
, new_size
;
4663 last
= &xh
->xh_entries
[count
];
4664 if (!xs
->not_found
) {
4666 offs
= le16_to_cpu(xe
->xe_name_offset
);
4667 if (ocfs2_xattr_is_local(xe
))
4668 size
= OCFS2_XATTR_SIZE(name_len
) +
4669 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
4671 size
= OCFS2_XATTR_SIZE(name_len
) +
4672 OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE
);
4675 * If the new value will be stored outside, xi->value has been
4676 * initalized as an empty ocfs2_xattr_value_root, and the same
4677 * goes with xi->value_len, so we can set new_size safely here.
4678 * See ocfs2_xattr_set_in_bucket.
4680 new_size
= OCFS2_XATTR_SIZE(name_len
) +
4681 OCFS2_XATTR_SIZE(xi
->value_len
);
4683 le16_add_cpu(&xh
->xh_name_value_len
, -size
);
4685 if (new_size
> size
)
4686 goto set_new_name_value
;
4688 /* Now replace the old value with new one. */
4690 xe
->xe_value_size
= cpu_to_le64(xi
->value_len
);
4692 xe
->xe_value_size
= 0;
4694 val
= ocfs2_xattr_bucket_get_val(inode
,
4696 memset(val
+ OCFS2_XATTR_SIZE(name_len
), 0,
4697 size
- OCFS2_XATTR_SIZE(name_len
));
4698 if (OCFS2_XATTR_SIZE(xi
->value_len
) > 0)
4699 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
4700 xi
->value
, xi
->value_len
);
4702 le16_add_cpu(&xh
->xh_name_value_len
, new_size
);
4703 ocfs2_xattr_set_local(xe
, local
);
4707 * Remove the old entry if there is more than one.
4708 * We don't remove the last entry so that we can
4709 * use it to indicate the hash value of the empty
4713 le16_add_cpu(&xh
->xh_count
, -1);
4716 (void *)last
- (void *)xe
);
4718 sizeof(struct ocfs2_xattr_entry
));
4721 cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
);
4726 /* find a new entry for insert. */
4727 int low
= 0, high
= count
- 1, tmp
;
4728 struct ocfs2_xattr_entry
*tmp_xe
;
4730 while (low
<= high
&& count
) {
4731 tmp
= (low
+ high
) / 2;
4732 tmp_xe
= &xh
->xh_entries
[tmp
];
4734 if (name_hash
> le32_to_cpu(tmp_xe
->xe_name_hash
))
4736 else if (name_hash
<
4737 le32_to_cpu(tmp_xe
->xe_name_hash
))
4745 xe
= &xh
->xh_entries
[low
];
4747 memmove(xe
+ 1, xe
, (void *)last
- (void *)xe
);
4749 le16_add_cpu(&xh
->xh_count
, 1);
4750 memset(xe
, 0, sizeof(struct ocfs2_xattr_entry
));
4751 xe
->xe_name_hash
= cpu_to_le32(name_hash
);
4752 xe
->xe_name_len
= name_len
;
4753 ocfs2_xattr_set_type(xe
, xi
->name_index
);
4757 /* Insert the new name+value. */
4758 size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_SIZE(xi
->value_len
);
4761 * We must make sure that the name/value pair
4762 * exists in the same block.
4764 offs
= le16_to_cpu(xh
->xh_free_start
);
4765 start
= offs
- size
;
4767 if (start
>> inode
->i_sb
->s_blocksize_bits
!=
4768 (offs
- 1) >> inode
->i_sb
->s_blocksize_bits
) {
4769 offs
= offs
- offs
% blocksize
;
4770 xh
->xh_free_start
= cpu_to_le16(offs
);
4773 val
= ocfs2_xattr_bucket_get_val(inode
, xs
->bucket
, offs
- size
);
4774 xe
->xe_name_offset
= cpu_to_le16(offs
- size
);
4776 memset(val
, 0, size
);
4777 memcpy(val
, xi
->name
, name_len
);
4778 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
), xi
->value
, xi
->value_len
);
4780 xe
->xe_value_size
= cpu_to_le64(xi
->value_len
);
4781 ocfs2_xattr_set_local(xe
, local
);
4783 le16_add_cpu(&xh
->xh_free_start
, -size
);
4784 le16_add_cpu(&xh
->xh_name_value_len
, size
);
4790 * Set the xattr entry in the specified bucket.
4791 * The bucket is indicated by xs->bucket and it should have the enough
4792 * space for the xattr insertion.
4794 static int ocfs2_xattr_set_entry_in_bucket(struct inode
*inode
,
4796 struct ocfs2_xattr_info
*xi
,
4797 struct ocfs2_xattr_search
*xs
,
4804 mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n",
4805 (unsigned long)xi
->value_len
, xi
->name_index
,
4806 (unsigned long long)bucket_blkno(xs
->bucket
));
4808 if (!xs
->bucket
->bu_bhs
[1]) {
4809 blkno
= bucket_blkno(xs
->bucket
);
4810 ocfs2_xattr_bucket_relse(xs
->bucket
);
4811 ret
= ocfs2_read_xattr_bucket(xs
->bucket
, blkno
);
4818 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
4819 OCFS2_JOURNAL_ACCESS_WRITE
);
4825 ocfs2_xattr_set_entry_normal(inode
, xi
, xs
, name_hash
, local
);
4826 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
4833 * Truncate the specified xe_off entry in xattr bucket.
4834 * bucket is indicated by header_bh and len is the new length.
4835 * Both the ocfs2_xattr_value_root and the entry will be updated here.
4837 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
4839 static int ocfs2_xattr_bucket_value_truncate(struct inode
*inode
,
4840 struct ocfs2_xattr_bucket
*bucket
,
4843 struct ocfs2_xattr_set_ctxt
*ctxt
)
4847 struct ocfs2_xattr_entry
*xe
;
4848 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
4849 size_t blocksize
= inode
->i_sb
->s_blocksize
;
4850 struct ocfs2_xattr_value_buf vb
= {
4851 .vb_access
= ocfs2_journal_access
,
4854 xe
= &xh
->xh_entries
[xe_off
];
4856 BUG_ON(!xe
|| ocfs2_xattr_is_local(xe
));
4858 offset
= le16_to_cpu(xe
->xe_name_offset
) +
4859 OCFS2_XATTR_SIZE(xe
->xe_name_len
);
4861 value_blk
= offset
/ blocksize
;
4863 /* We don't allow ocfs2_xattr_value to be stored in different block. */
4864 BUG_ON(value_blk
!= (offset
+ OCFS2_XATTR_ROOT_SIZE
- 1) / blocksize
);
4866 vb
.vb_bh
= bucket
->bu_bhs
[value_blk
];
4869 vb
.vb_xv
= (struct ocfs2_xattr_value_root
*)
4870 (vb
.vb_bh
->b_data
+ offset
% blocksize
);
4873 * From here on out we have to dirty the bucket. The generic
4874 * value calls only modify one of the bucket's bhs, but we need
4875 * to send the bucket at once. So if they error, they *could* have
4876 * modified something. We have to assume they did, and dirty
4877 * the whole bucket. This leaves us in a consistent state.
4879 mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n",
4880 xe_off
, (unsigned long long)bucket_blkno(bucket
), len
);
4881 ret
= ocfs2_xattr_value_truncate(inode
, &vb
, len
, ctxt
);
4887 ret
= ocfs2_xattr_bucket_journal_access(ctxt
->handle
, bucket
,
4888 OCFS2_JOURNAL_ACCESS_WRITE
);
4894 xe
->xe_value_size
= cpu_to_le64(len
);
4896 ocfs2_xattr_bucket_journal_dirty(ctxt
->handle
, bucket
);
4902 static int ocfs2_xattr_bucket_value_truncate_xs(struct inode
*inode
,
4903 struct ocfs2_xattr_search
*xs
,
4905 struct ocfs2_xattr_set_ctxt
*ctxt
)
4908 struct ocfs2_xattr_entry
*xe
= xs
->here
;
4909 struct ocfs2_xattr_header
*xh
= (struct ocfs2_xattr_header
*)xs
->base
;
4911 BUG_ON(!xs
->bucket
->bu_bhs
[0] || !xe
|| ocfs2_xattr_is_local(xe
));
4913 offset
= xe
- xh
->xh_entries
;
4914 ret
= ocfs2_xattr_bucket_value_truncate(inode
, xs
->bucket
,
4922 static int ocfs2_xattr_bucket_set_value_outside(struct inode
*inode
,
4924 struct ocfs2_xattr_search
*xs
,
4928 int ret
, offset
, block_off
;
4929 struct ocfs2_xattr_value_root
*xv
;
4930 struct ocfs2_xattr_entry
*xe
= xs
->here
;
4931 struct ocfs2_xattr_header
*xh
= bucket_xh(xs
->bucket
);
4933 struct ocfs2_xattr_value_buf vb
= {
4934 .vb_access
= ocfs2_journal_access
,
4937 BUG_ON(!xs
->base
|| !xe
|| ocfs2_xattr_is_local(xe
));
4939 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
, xh
,
4940 xe
- xh
->xh_entries
,
4948 base
= bucket_block(xs
->bucket
, block_off
);
4949 xv
= (struct ocfs2_xattr_value_root
*)(base
+ offset
+
4950 OCFS2_XATTR_SIZE(xe
->xe_name_len
));
4953 vb
.vb_bh
= xs
->bucket
->bu_bhs
[block_off
];
4954 ret
= __ocfs2_xattr_set_value_outside(inode
, handle
,
4955 &vb
, val
, value_len
);
4962 static int ocfs2_rm_xattr_cluster(struct inode
*inode
,
4963 struct buffer_head
*root_bh
,
4970 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4971 struct inode
*tl_inode
= osb
->osb_tl_inode
;
4973 struct ocfs2_xattr_block
*xb
=
4974 (struct ocfs2_xattr_block
*)root_bh
->b_data
;
4975 struct ocfs2_alloc_context
*meta_ac
= NULL
;
4976 struct ocfs2_cached_dealloc_ctxt dealloc
;
4977 struct ocfs2_extent_tree et
;
4979 ret
= ocfs2_iterate_xattr_buckets(inode
, blkno
, len
,
4980 ocfs2_delete_xattr_in_bucket
, NULL
);
4986 ocfs2_init_xattr_tree_extent_tree(&et
, INODE_CACHE(inode
), root_bh
);
4988 ocfs2_init_dealloc_ctxt(&dealloc
);
4990 mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n",
4991 cpos
, len
, (unsigned long long)blkno
);
4993 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode
), blkno
,
4996 ret
= ocfs2_lock_allocators(inode
, &et
, 0, 1, NULL
, &meta_ac
);
5002 mutex_lock(&tl_inode
->i_mutex
);
5004 if (ocfs2_truncate_log_needs_flush(osb
)) {
5005 ret
= __ocfs2_flush_truncate_log(osb
);
5012 handle
= ocfs2_start_trans(osb
, ocfs2_remove_extent_credits(osb
->sb
));
5013 if (IS_ERR(handle
)) {
5019 ret
= ocfs2_journal_access_xb(handle
, INODE_CACHE(inode
), root_bh
,
5020 OCFS2_JOURNAL_ACCESS_WRITE
);
5026 ret
= ocfs2_remove_extent(handle
, &et
, cpos
, len
, meta_ac
,
5033 le32_add_cpu(&xb
->xb_attrs
.xb_root
.xt_clusters
, -len
);
5035 ret
= ocfs2_journal_dirty(handle
, root_bh
);
5041 ret
= ocfs2_truncate_log_append(osb
, handle
, blkno
, len
);
5046 ocfs2_commit_trans(osb
, handle
);
5048 ocfs2_schedule_truncate_log_flush(osb
, 1);
5050 mutex_unlock(&tl_inode
->i_mutex
);
5053 ocfs2_free_alloc_context(meta_ac
);
5055 ocfs2_run_deallocs(osb
, &dealloc
);
5060 static void ocfs2_xattr_bucket_remove_xs(struct inode
*inode
,
5062 struct ocfs2_xattr_search
*xs
)
5064 struct ocfs2_xattr_header
*xh
= bucket_xh(xs
->bucket
);
5065 struct ocfs2_xattr_entry
*last
= &xh
->xh_entries
[
5066 le16_to_cpu(xh
->xh_count
) - 1];
5069 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
5070 OCFS2_JOURNAL_ACCESS_WRITE
);
5076 /* Remove the old entry. */
5077 memmove(xs
->here
, xs
->here
+ 1,
5078 (void *)last
- (void *)xs
->here
);
5079 memset(last
, 0, sizeof(struct ocfs2_xattr_entry
));
5080 le16_add_cpu(&xh
->xh_count
, -1);
5082 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
5086 * Set the xattr name/value in the bucket specified in xs.
5088 * As the new value in xi may be stored in the bucket or in an outside cluster,
5089 * we divide the whole process into 3 steps:
5090 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
5091 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
5092 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
5093 * 4. If the clusters for the new outside value can't be allocated, we need
5094 * to free the xattr we allocated in set.
5096 static int ocfs2_xattr_set_in_bucket(struct inode
*inode
,
5097 struct ocfs2_xattr_info
*xi
,
5098 struct ocfs2_xattr_search
*xs
,
5099 struct ocfs2_xattr_set_ctxt
*ctxt
)
5103 char *val
= (char *)xi
->value
;
5104 struct ocfs2_xattr_entry
*xe
= xs
->here
;
5105 u32 name_hash
= ocfs2_xattr_name_hash(inode
, xi
->name
,
5108 if (!xs
->not_found
&& !ocfs2_xattr_is_local(xe
)) {
5110 * We need to truncate the xattr storage first.
5112 * If both the old and new value are stored to
5113 * outside block, we only need to truncate
5114 * the storage and then set the value outside.
5116 * If the new value should be stored within block,
5117 * we should free all the outside block first and
5118 * the modification to the xattr block will be done
5119 * by following steps.
5121 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
5122 value_len
= xi
->value_len
;
5126 ret
= ocfs2_xattr_bucket_value_truncate_xs(inode
, xs
,
5133 goto set_value_outside
;
5136 value_len
= xi
->value_len
;
5137 /* So we have to handle the inside block change now. */
5138 if (value_len
> OCFS2_XATTR_INLINE_SIZE
) {
5140 * If the new value will be stored outside of block,
5141 * initalize a new empty value root and insert it first.
5144 xi
->value
= &def_xv
;
5145 xi
->value_len
= OCFS2_XATTR_ROOT_SIZE
;
5148 ret
= ocfs2_xattr_set_entry_in_bucket(inode
, ctxt
->handle
, xi
, xs
,
5155 if (value_len
<= OCFS2_XATTR_INLINE_SIZE
)
5158 /* allocate the space now for the outside block storage. */
5159 ret
= ocfs2_xattr_bucket_value_truncate_xs(inode
, xs
,
5164 if (xs
->not_found
) {
5166 * We can't allocate enough clusters for outside
5167 * storage and we have allocated xattr already,
5168 * so need to remove it.
5170 ocfs2_xattr_bucket_remove_xs(inode
, ctxt
->handle
, xs
);
5176 ret
= ocfs2_xattr_bucket_set_value_outside(inode
, ctxt
->handle
,
5177 xs
, val
, value_len
);
5183 * check whether the xattr bucket is filled up with the same hash value.
5184 * If we want to insert the xattr with the same hash, return -ENOSPC.
5185 * If we want to insert a xattr with different hash value, go ahead
5186 * and ocfs2_divide_xattr_bucket will handle this.
5188 static int ocfs2_check_xattr_bucket_collision(struct inode
*inode
,
5189 struct ocfs2_xattr_bucket
*bucket
,
5192 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
5193 u32 name_hash
= ocfs2_xattr_name_hash(inode
, name
, strlen(name
));
5195 if (name_hash
!= le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
))
5198 if (xh
->xh_entries
[le16_to_cpu(xh
->xh_count
) - 1].xe_name_hash
==
5199 xh
->xh_entries
[0].xe_name_hash
) {
5200 mlog(ML_ERROR
, "Too much hash collision in xattr bucket %llu, "
5202 (unsigned long long)bucket_blkno(bucket
),
5203 le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
));
5210 static int ocfs2_xattr_set_entry_index_block(struct inode
*inode
,
5211 struct ocfs2_xattr_info
*xi
,
5212 struct ocfs2_xattr_search
*xs
,
5213 struct ocfs2_xattr_set_ctxt
*ctxt
)
5215 struct ocfs2_xattr_header
*xh
;
5216 struct ocfs2_xattr_entry
*xe
;
5217 u16 count
, header_size
, xh_free_start
;
5218 int free
, max_free
, need
, old
;
5219 size_t value_size
= 0, name_len
= strlen(xi
->name
);
5220 size_t blocksize
= inode
->i_sb
->s_blocksize
;
5221 int ret
, allocation
= 0;
5223 mlog_entry("Set xattr %s in xattr index block\n", xi
->name
);
5227 count
= le16_to_cpu(xh
->xh_count
);
5228 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
5229 header_size
= sizeof(struct ocfs2_xattr_header
) +
5230 count
* sizeof(struct ocfs2_xattr_entry
);
5231 max_free
= OCFS2_XATTR_BUCKET_SIZE
- header_size
-
5232 le16_to_cpu(xh
->xh_name_value_len
) - OCFS2_XATTR_HEADER_GAP
;
5234 mlog_bug_on_msg(header_size
> blocksize
, "bucket %llu has header size "
5235 "of %u which exceed block size\n",
5236 (unsigned long long)bucket_blkno(xs
->bucket
),
5239 if (xi
->value
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
5240 value_size
= OCFS2_XATTR_ROOT_SIZE
;
5242 value_size
= OCFS2_XATTR_SIZE(xi
->value_len
);
5245 need
= sizeof(struct ocfs2_xattr_entry
) +
5246 OCFS2_XATTR_SIZE(name_len
) + value_size
;
5248 need
= value_size
+ OCFS2_XATTR_SIZE(name_len
);
5251 * We only replace the old value if the new length is smaller
5252 * than the old one. Otherwise we will allocate new space in the
5253 * bucket to store it.
5256 if (ocfs2_xattr_is_local(xe
))
5257 old
= OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
5259 old
= OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE
);
5261 if (old
>= value_size
)
5265 free
= xh_free_start
- header_size
- OCFS2_XATTR_HEADER_GAP
;
5267 * We need to make sure the new name/value pair
5268 * can exist in the same block.
5270 if (xh_free_start
% blocksize
< need
)
5271 free
-= xh_free_start
% blocksize
;
5273 mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, "
5274 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
5275 " %u\n", xs
->not_found
,
5276 (unsigned long long)bucket_blkno(xs
->bucket
),
5277 free
, need
, max_free
, le16_to_cpu(xh
->xh_free_start
),
5278 le16_to_cpu(xh
->xh_name_value_len
));
5282 count
== ocfs2_xattr_max_xe_in_bucket(inode
->i_sb
))) {
5283 if (need
<= max_free
&&
5284 count
< ocfs2_xattr_max_xe_in_bucket(inode
->i_sb
)) {
5286 * We can create the space by defragment. Since only the
5287 * name/value will be moved, the xe shouldn't be changed
5290 ret
= ocfs2_defrag_xattr_bucket(inode
, ctxt
->handle
,
5297 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
5298 free
= xh_free_start
- header_size
5299 - OCFS2_XATTR_HEADER_GAP
;
5300 if (xh_free_start
% blocksize
< need
)
5301 free
-= xh_free_start
% blocksize
;
5306 mlog(0, "Can't get enough space for xattr insert by "
5307 "defragment. Need %u bytes, but we have %d, so "
5308 "allocate new bucket for it.\n", need
, free
);
5312 * We have to add new buckets or clusters and one
5313 * allocation should leave us enough space for insert.
5318 * We do not allow for overlapping ranges between buckets. And
5319 * the maximum number of collisions we will allow for then is
5320 * one bucket's worth, so check it here whether we need to
5321 * add a new bucket for the insert.
5323 ret
= ocfs2_check_xattr_bucket_collision(inode
,
5331 ret
= ocfs2_add_new_xattr_bucket(inode
,
5341 * ocfs2_add_new_xattr_bucket() will have updated
5342 * xs->bucket if it moved, but it will not have updated
5343 * any of the other search fields. Thus, we drop it and
5344 * re-search. Everything should be cached, so it'll be
5347 ocfs2_xattr_bucket_relse(xs
->bucket
);
5348 ret
= ocfs2_xattr_index_block_find(inode
, xs
->xattr_bh
,
5351 if (ret
&& ret
!= -ENODATA
)
5353 xs
->not_found
= ret
;
5359 ret
= ocfs2_xattr_set_in_bucket(inode
, xi
, xs
, ctxt
);
5365 static int ocfs2_delete_xattr_in_bucket(struct inode
*inode
,
5366 struct ocfs2_xattr_bucket
*bucket
,
5370 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
5372 struct ocfs2_xattr_entry
*xe
;
5373 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5374 struct ocfs2_xattr_set_ctxt ctxt
= {NULL
, NULL
,};
5375 int credits
= ocfs2_remove_extent_credits(osb
->sb
) +
5376 ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
5379 ocfs2_init_dealloc_ctxt(&ctxt
.dealloc
);
5381 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
5382 xe
= &xh
->xh_entries
[i
];
5383 if (ocfs2_xattr_is_local(xe
))
5386 ctxt
.handle
= ocfs2_start_trans(osb
, credits
);
5387 if (IS_ERR(ctxt
.handle
)) {
5388 ret
= PTR_ERR(ctxt
.handle
);
5393 ret
= ocfs2_xattr_bucket_value_truncate(inode
, bucket
,
5396 ocfs2_commit_trans(osb
, ctxt
.handle
);
5403 ocfs2_schedule_truncate_log_flush(osb
, 1);
5404 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
5409 * Whenever we modify a xattr value root in the bucket(e.g, CoW
5410 * or change the extent record flag), we need to recalculate
5411 * the metaecc for the whole bucket. So it is done here.
5414 * We have to give the extra credits for the caller.
5416 static int ocfs2_xattr_bucket_post_refcount(struct inode
*inode
,
5421 struct ocfs2_xattr_bucket
*bucket
=
5422 (struct ocfs2_xattr_bucket
*)para
;
5424 ret
= ocfs2_xattr_bucket_journal_access(handle
, bucket
,
5425 OCFS2_JOURNAL_ACCESS_WRITE
);
5431 ocfs2_xattr_bucket_journal_dirty(handle
, bucket
);
5437 * Special action we need if the xattr value is refcounted.
5439 * 1. If the xattr is refcounted, lock the tree.
5440 * 2. CoW the xattr if we are setting the new value and the value
5441 * will be stored outside.
5442 * 3. In other case, decrease_refcount will work for us, so just
5443 * lock the refcount tree, calculate the meta and credits is OK.
5445 * We have to do CoW before ocfs2_init_xattr_set_ctxt since
5446 * currently CoW is a completed transaction, while this function
5447 * will also lock the allocators and let us deadlock. So we will
5448 * CoW the whole xattr value.
5450 static int ocfs2_prepare_refcount_xattr(struct inode
*inode
,
5451 struct ocfs2_dinode
*di
,
5452 struct ocfs2_xattr_info
*xi
,
5453 struct ocfs2_xattr_search
*xis
,
5454 struct ocfs2_xattr_search
*xbs
,
5455 struct ocfs2_refcount_tree
**ref_tree
,
5460 struct ocfs2_xattr_block
*xb
;
5461 struct ocfs2_xattr_entry
*xe
;
5463 u32 p_cluster
, num_clusters
;
5464 unsigned int ext_flags
;
5465 int name_offset
, name_len
;
5466 struct ocfs2_xattr_value_buf vb
;
5467 struct ocfs2_xattr_bucket
*bucket
= NULL
;
5468 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5469 struct ocfs2_post_refcount refcount
;
5470 struct ocfs2_post_refcount
*p
= NULL
;
5471 struct buffer_head
*ref_root_bh
= NULL
;
5473 if (!xis
->not_found
) {
5475 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
5476 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
5478 vb
.vb_bh
= xis
->inode_bh
;
5479 vb
.vb_access
= ocfs2_journal_access_di
;
5481 int i
, block_off
= 0;
5482 xb
= (struct ocfs2_xattr_block
*)xbs
->xattr_bh
->b_data
;
5484 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
5485 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
5486 i
= xbs
->here
- xbs
->header
->xh_entries
;
5488 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
5489 ret
= ocfs2_xattr_bucket_get_name_value(inode
->i_sb
,
5490 bucket_xh(xbs
->bucket
),
5497 base
= bucket_block(xbs
->bucket
, block_off
);
5498 vb
.vb_bh
= xbs
->bucket
->bu_bhs
[block_off
];
5499 vb
.vb_access
= ocfs2_journal_access
;
5501 if (ocfs2_meta_ecc(osb
)) {
5502 /*create parameters for ocfs2_post_refcount. */
5503 bucket
= xbs
->bucket
;
5504 refcount
.credits
= bucket
->bu_blocks
;
5505 refcount
.para
= bucket
;
5507 ocfs2_xattr_bucket_post_refcount
;
5512 vb
.vb_bh
= xbs
->xattr_bh
;
5513 vb
.vb_access
= ocfs2_journal_access_xb
;
5517 if (ocfs2_xattr_is_local(xe
))
5520 vb
.vb_xv
= (struct ocfs2_xattr_value_root
*)
5521 (base
+ name_offset
+ name_len
);
5523 ret
= ocfs2_xattr_get_clusters(inode
, 0, &p_cluster
,
5524 &num_clusters
, &vb
.vb_xv
->xr_list
,
5532 * We just need to check the 1st extent record, since we always
5533 * CoW the whole xattr. So there shouldn't be a xattr with
5534 * some REFCOUNT extent recs after the 1st one.
5536 if (!(ext_flags
& OCFS2_EXT_REFCOUNTED
))
5539 ret
= ocfs2_lock_refcount_tree(osb
, le64_to_cpu(di
->i_refcount_loc
),
5540 1, ref_tree
, &ref_root_bh
);
5547 * If we are deleting the xattr or the new size will be stored inside,
5548 * cool, leave it there, the xattr truncate process will remove them
5549 * for us(it still needs the refcount tree lock and the meta, credits).
5550 * And the worse case is that every cluster truncate will split the
5551 * refcount tree, and make the original extent become 3. So we will need
5552 * 2 * cluster more extent recs at most.
5554 if (!xi
->value
|| xi
->value_len
<= OCFS2_XATTR_INLINE_SIZE
) {
5556 ret
= ocfs2_refcounted_xattr_delete_need(inode
,
5557 &(*ref_tree
)->rf_ci
,
5558 ref_root_bh
, vb
.vb_xv
,
5565 ret
= ocfs2_refcount_cow_xattr(inode
, di
, &vb
,
5566 *ref_tree
, ref_root_bh
, 0,
5567 le32_to_cpu(vb
.vb_xv
->xr_clusters
), p
);
5572 brelse(ref_root_bh
);
5577 * Add the REFCOUNTED flags for all the extent rec in ocfs2_xattr_value_root.
5578 * The physical clusters will be added to refcount tree.
5580 static int ocfs2_xattr_value_attach_refcount(struct inode
*inode
,
5581 struct ocfs2_xattr_value_root
*xv
,
5582 struct ocfs2_extent_tree
*value_et
,
5583 struct ocfs2_caching_info
*ref_ci
,
5584 struct buffer_head
*ref_root_bh
,
5585 struct ocfs2_cached_dealloc_ctxt
*dealloc
,
5586 struct ocfs2_post_refcount
*refcount
)
5589 u32 clusters
= le32_to_cpu(xv
->xr_clusters
);
5590 u32 cpos
, p_cluster
, num_clusters
;
5591 struct ocfs2_extent_list
*el
= &xv
->xr_list
;
5592 unsigned int ext_flags
;
5595 while (cpos
< clusters
) {
5596 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &p_cluster
,
5597 &num_clusters
, el
, &ext_flags
);
5599 cpos
+= num_clusters
;
5600 if ((ext_flags
& OCFS2_EXT_REFCOUNTED
))
5605 ret
= ocfs2_add_refcount_flag(inode
, value_et
,
5606 ref_ci
, ref_root_bh
,
5607 cpos
- num_clusters
,
5608 p_cluster
, num_clusters
,
5620 * Given a normal ocfs2_xattr_header, refcount all the entries which
5621 * have value stored outside.
5622 * Used for xattrs stored in inode and ocfs2_xattr_block.
5624 static int ocfs2_xattr_attach_refcount_normal(struct inode
*inode
,
5625 struct ocfs2_xattr_value_buf
*vb
,
5626 struct ocfs2_xattr_header
*header
,
5627 struct ocfs2_caching_info
*ref_ci
,
5628 struct buffer_head
*ref_root_bh
,
5629 struct ocfs2_cached_dealloc_ctxt
*dealloc
)
5632 struct ocfs2_xattr_entry
*xe
;
5633 struct ocfs2_xattr_value_root
*xv
;
5634 struct ocfs2_extent_tree et
;
5637 for (i
= 0; i
< le16_to_cpu(header
->xh_count
); i
++) {
5638 xe
= &header
->xh_entries
[i
];
5640 if (ocfs2_xattr_is_local(xe
))
5643 xv
= (struct ocfs2_xattr_value_root
*)((void *)header
+
5644 le16_to_cpu(xe
->xe_name_offset
) +
5645 OCFS2_XATTR_SIZE(xe
->xe_name_len
));
5648 ocfs2_init_xattr_value_extent_tree(&et
, INODE_CACHE(inode
), vb
);
5650 ret
= ocfs2_xattr_value_attach_refcount(inode
, xv
, &et
,
5651 ref_ci
, ref_root_bh
,
5662 static int ocfs2_xattr_inline_attach_refcount(struct inode
*inode
,
5663 struct buffer_head
*fe_bh
,
5664 struct ocfs2_caching_info
*ref_ci
,
5665 struct buffer_head
*ref_root_bh
,
5666 struct ocfs2_cached_dealloc_ctxt
*dealloc
)
5668 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)fe_bh
->b_data
;
5669 struct ocfs2_xattr_header
*header
= (struct ocfs2_xattr_header
*)
5670 (fe_bh
->b_data
+ inode
->i_sb
->s_blocksize
-
5671 le16_to_cpu(di
->i_xattr_inline_size
));
5672 struct ocfs2_xattr_value_buf vb
= {
5674 .vb_access
= ocfs2_journal_access_di
,
5677 return ocfs2_xattr_attach_refcount_normal(inode
, &vb
, header
,
5678 ref_ci
, ref_root_bh
, dealloc
);
5681 struct ocfs2_xattr_tree_value_refcount_para
{
5682 struct ocfs2_caching_info
*ref_ci
;
5683 struct buffer_head
*ref_root_bh
;
5684 struct ocfs2_cached_dealloc_ctxt
*dealloc
;
5687 static int ocfs2_get_xattr_tree_value_root(struct super_block
*sb
,
5688 struct ocfs2_xattr_bucket
*bucket
,
5690 struct ocfs2_xattr_value_root
**xv
,
5691 struct buffer_head
**bh
)
5693 int ret
, block_off
, name_offset
;
5694 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
5695 struct ocfs2_xattr_entry
*xe
= &xh
->xh_entries
[offset
];
5698 ret
= ocfs2_xattr_bucket_get_name_value(sb
,
5708 base
= bucket_block(bucket
, block_off
);
5710 *xv
= (struct ocfs2_xattr_value_root
*)(base
+ name_offset
+
5711 OCFS2_XATTR_SIZE(xe
->xe_name_len
));
5714 *bh
= bucket
->bu_bhs
[block_off
];
5720 * For a given xattr bucket, refcount all the entries which
5721 * have value stored outside.
5723 static int ocfs2_xattr_bucket_value_refcount(struct inode
*inode
,
5724 struct ocfs2_xattr_bucket
*bucket
,
5728 struct ocfs2_extent_tree et
;
5729 struct ocfs2_xattr_tree_value_refcount_para
*ref
=
5730 (struct ocfs2_xattr_tree_value_refcount_para
*)para
;
5731 struct ocfs2_xattr_header
*xh
=
5732 (struct ocfs2_xattr_header
*)bucket
->bu_bhs
[0]->b_data
;
5733 struct ocfs2_xattr_entry
*xe
;
5734 struct ocfs2_xattr_value_buf vb
= {
5735 .vb_access
= ocfs2_journal_access
,
5737 struct ocfs2_post_refcount refcount
= {
5738 .credits
= bucket
->bu_blocks
,
5740 .func
= ocfs2_xattr_bucket_post_refcount
,
5742 struct ocfs2_post_refcount
*p
= NULL
;
5744 /* We only need post_refcount if we support metaecc. */
5745 if (ocfs2_meta_ecc(OCFS2_SB(inode
->i_sb
)))
5748 mlog(0, "refcount bucket %llu, count = %u\n",
5749 (unsigned long long)bucket_blkno(bucket
),
5750 le16_to_cpu(xh
->xh_count
));
5751 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
5752 xe
= &xh
->xh_entries
[i
];
5754 if (ocfs2_xattr_is_local(xe
))
5757 ret
= ocfs2_get_xattr_tree_value_root(inode
->i_sb
, bucket
, i
,
5758 &vb
.vb_xv
, &vb
.vb_bh
);
5764 ocfs2_init_xattr_value_extent_tree(&et
,
5765 INODE_CACHE(inode
), &vb
);
5767 ret
= ocfs2_xattr_value_attach_refcount(inode
, vb
.vb_xv
,
5781 static int ocfs2_refcount_xattr_tree_rec(struct inode
*inode
,
5782 struct buffer_head
*root_bh
,
5783 u64 blkno
, u32 cpos
, u32 len
, void *para
)
5785 return ocfs2_iterate_xattr_buckets(inode
, blkno
, len
,
5786 ocfs2_xattr_bucket_value_refcount
,
5790 static int ocfs2_xattr_block_attach_refcount(struct inode
*inode
,
5791 struct buffer_head
*blk_bh
,
5792 struct ocfs2_caching_info
*ref_ci
,
5793 struct buffer_head
*ref_root_bh
,
5794 struct ocfs2_cached_dealloc_ctxt
*dealloc
)
5797 struct ocfs2_xattr_block
*xb
=
5798 (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
5800 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
5801 struct ocfs2_xattr_header
*header
= &xb
->xb_attrs
.xb_header
;
5802 struct ocfs2_xattr_value_buf vb
= {
5804 .vb_access
= ocfs2_journal_access_xb
,
5807 ret
= ocfs2_xattr_attach_refcount_normal(inode
, &vb
, header
,
5808 ref_ci
, ref_root_bh
,
5811 struct ocfs2_xattr_tree_value_refcount_para para
= {
5813 .ref_root_bh
= ref_root_bh
,
5817 ret
= ocfs2_iterate_xattr_index_block(inode
, blk_bh
,
5818 ocfs2_refcount_xattr_tree_rec
,
5825 int ocfs2_xattr_attach_refcount_tree(struct inode
*inode
,
5826 struct buffer_head
*fe_bh
,
5827 struct ocfs2_caching_info
*ref_ci
,
5828 struct buffer_head
*ref_root_bh
,
5829 struct ocfs2_cached_dealloc_ctxt
*dealloc
)
5832 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
5833 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)fe_bh
->b_data
;
5834 struct buffer_head
*blk_bh
= NULL
;
5836 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) {
5837 ret
= ocfs2_xattr_inline_attach_refcount(inode
, fe_bh
,
5838 ref_ci
, ref_root_bh
,
5846 if (!di
->i_xattr_loc
)
5849 ret
= ocfs2_read_xattr_block(inode
, le64_to_cpu(di
->i_xattr_loc
),
5856 ret
= ocfs2_xattr_block_attach_refcount(inode
, blk_bh
, ref_ci
,
5857 ref_root_bh
, dealloc
);
5868 * 'security' attributes support
5870 static size_t ocfs2_xattr_security_list(struct inode
*inode
, char *list
,
5871 size_t list_size
, const char *name
,
5874 const size_t prefix_len
= XATTR_SECURITY_PREFIX_LEN
;
5875 const size_t total_len
= prefix_len
+ name_len
+ 1;
5877 if (list
&& total_len
<= list_size
) {
5878 memcpy(list
, XATTR_SECURITY_PREFIX
, prefix_len
);
5879 memcpy(list
+ prefix_len
, name
, name_len
);
5880 list
[prefix_len
+ name_len
] = '\0';
5885 static int ocfs2_xattr_security_get(struct inode
*inode
, const char *name
,
5886 void *buffer
, size_t size
)
5888 if (strcmp(name
, "") == 0)
5890 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_SECURITY
, name
,
5894 static int ocfs2_xattr_security_set(struct inode
*inode
, const char *name
,
5895 const void *value
, size_t size
, int flags
)
5897 if (strcmp(name
, "") == 0)
5900 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_SECURITY
, name
, value
,
5904 int ocfs2_init_security_get(struct inode
*inode
,
5906 struct ocfs2_security_xattr_info
*si
)
5908 /* check whether ocfs2 support feature xattr */
5909 if (!ocfs2_supports_xattr(OCFS2_SB(dir
->i_sb
)))
5911 return security_inode_init_security(inode
, dir
, &si
->name
, &si
->value
,
5915 int ocfs2_init_security_set(handle_t
*handle
,
5916 struct inode
*inode
,
5917 struct buffer_head
*di_bh
,
5918 struct ocfs2_security_xattr_info
*si
,
5919 struct ocfs2_alloc_context
*xattr_ac
,
5920 struct ocfs2_alloc_context
*data_ac
)
5922 return ocfs2_xattr_set_handle(handle
, inode
, di_bh
,
5923 OCFS2_XATTR_INDEX_SECURITY
,
5924 si
->name
, si
->value
, si
->value_len
, 0,
5928 struct xattr_handler ocfs2_xattr_security_handler
= {
5929 .prefix
= XATTR_SECURITY_PREFIX
,
5930 .list
= ocfs2_xattr_security_list
,
5931 .get
= ocfs2_xattr_security_get
,
5932 .set
= ocfs2_xattr_security_set
,
5936 * 'trusted' attributes support
5938 static size_t ocfs2_xattr_trusted_list(struct inode
*inode
, char *list
,
5939 size_t list_size
, const char *name
,
5942 const size_t prefix_len
= XATTR_TRUSTED_PREFIX_LEN
;
5943 const size_t total_len
= prefix_len
+ name_len
+ 1;
5945 if (list
&& total_len
<= list_size
) {
5946 memcpy(list
, XATTR_TRUSTED_PREFIX
, prefix_len
);
5947 memcpy(list
+ prefix_len
, name
, name_len
);
5948 list
[prefix_len
+ name_len
] = '\0';
5953 static int ocfs2_xattr_trusted_get(struct inode
*inode
, const char *name
,
5954 void *buffer
, size_t size
)
5956 if (strcmp(name
, "") == 0)
5958 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_TRUSTED
, name
,
5962 static int ocfs2_xattr_trusted_set(struct inode
*inode
, const char *name
,
5963 const void *value
, size_t size
, int flags
)
5965 if (strcmp(name
, "") == 0)
5968 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_TRUSTED
, name
, value
,
5972 struct xattr_handler ocfs2_xattr_trusted_handler
= {
5973 .prefix
= XATTR_TRUSTED_PREFIX
,
5974 .list
= ocfs2_xattr_trusted_list
,
5975 .get
= ocfs2_xattr_trusted_get
,
5976 .set
= ocfs2_xattr_trusted_set
,
5980 * 'user' attributes support
5982 static size_t ocfs2_xattr_user_list(struct inode
*inode
, char *list
,
5983 size_t list_size
, const char *name
,
5986 const size_t prefix_len
= XATTR_USER_PREFIX_LEN
;
5987 const size_t total_len
= prefix_len
+ name_len
+ 1;
5988 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5990 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
5993 if (list
&& total_len
<= list_size
) {
5994 memcpy(list
, XATTR_USER_PREFIX
, prefix_len
);
5995 memcpy(list
+ prefix_len
, name
, name_len
);
5996 list
[prefix_len
+ name_len
] = '\0';
6001 static int ocfs2_xattr_user_get(struct inode
*inode
, const char *name
,
6002 void *buffer
, size_t size
)
6004 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
6006 if (strcmp(name
, "") == 0)
6008 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
6010 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_USER
, name
,
6014 static int ocfs2_xattr_user_set(struct inode
*inode
, const char *name
,
6015 const void *value
, size_t size
, int flags
)
6017 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
6019 if (strcmp(name
, "") == 0)
6021 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
6024 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_USER
, name
, value
,
6028 struct xattr_handler ocfs2_xattr_user_handler
= {
6029 .prefix
= XATTR_USER_PREFIX
,
6030 .list
= ocfs2_xattr_user_list
,
6031 .get
= ocfs2_xattr_user_get
,
6032 .set
= ocfs2_xattr_user_set
,