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"
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 inode
*inode
,
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 ocfs2_xattr_tree_root
*xt
,
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 static int ocfs2_delete_xattr_index_block(struct inode
*inode
,
174 struct buffer_head
*xb_bh
);
175 static int ocfs2_mv_xattr_buckets(struct inode
*inode
, handle_t
*handle
,
176 u64 src_blk
, u64 last_blk
, u64 to_blk
,
177 unsigned int start_bucket
,
180 static inline u16
ocfs2_xattr_buckets_per_cluster(struct ocfs2_super
*osb
)
182 return (1 << osb
->s_clustersize_bits
) / OCFS2_XATTR_BUCKET_SIZE
;
185 static inline u16
ocfs2_blocks_per_xattr_bucket(struct super_block
*sb
)
187 return OCFS2_XATTR_BUCKET_SIZE
/ (1 << sb
->s_blocksize_bits
);
190 static inline u16
ocfs2_xattr_max_xe_in_bucket(struct super_block
*sb
)
192 u16 len
= sb
->s_blocksize
-
193 offsetof(struct ocfs2_xattr_header
, xh_entries
);
195 return len
/ sizeof(struct ocfs2_xattr_entry
);
198 #define bucket_blkno(_b) ((_b)->bu_bhs[0]->b_blocknr)
199 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
200 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
202 static struct ocfs2_xattr_bucket
*ocfs2_xattr_bucket_new(struct inode
*inode
)
204 struct ocfs2_xattr_bucket
*bucket
;
205 int blks
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
207 BUG_ON(blks
> OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET
);
209 bucket
= kzalloc(sizeof(struct ocfs2_xattr_bucket
), GFP_NOFS
);
211 bucket
->bu_inode
= inode
;
212 bucket
->bu_blocks
= blks
;
218 static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket
*bucket
)
222 for (i
= 0; i
< bucket
->bu_blocks
; i
++) {
223 brelse(bucket
->bu_bhs
[i
]);
224 bucket
->bu_bhs
[i
] = NULL
;
228 static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket
*bucket
)
231 ocfs2_xattr_bucket_relse(bucket
);
232 bucket
->bu_inode
= NULL
;
238 * A bucket that has never been written to disk doesn't need to be
239 * read. We just need the buffer_heads. Don't call this for
240 * buckets that are already on disk. ocfs2_read_xattr_bucket() initializes
243 static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket
*bucket
,
248 for (i
= 0; i
< bucket
->bu_blocks
; i
++) {
249 bucket
->bu_bhs
[i
] = sb_getblk(bucket
->bu_inode
->i_sb
,
251 if (!bucket
->bu_bhs
[i
]) {
257 if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket
->bu_inode
),
259 ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket
->bu_inode
),
264 ocfs2_xattr_bucket_relse(bucket
);
268 /* Read the xattr bucket at xb_blkno */
269 static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket
*bucket
,
274 rc
= ocfs2_read_blocks(INODE_CACHE(bucket
->bu_inode
), xb_blkno
,
275 bucket
->bu_blocks
, bucket
->bu_bhs
, 0,
278 spin_lock(&OCFS2_SB(bucket
->bu_inode
->i_sb
)->osb_xattr_lock
);
279 rc
= ocfs2_validate_meta_ecc_bhs(bucket
->bu_inode
->i_sb
,
282 &bucket_xh(bucket
)->xh_check
);
283 spin_unlock(&OCFS2_SB(bucket
->bu_inode
->i_sb
)->osb_xattr_lock
);
289 ocfs2_xattr_bucket_relse(bucket
);
293 static int ocfs2_xattr_bucket_journal_access(handle_t
*handle
,
294 struct ocfs2_xattr_bucket
*bucket
,
299 for (i
= 0; i
< bucket
->bu_blocks
; i
++) {
300 rc
= ocfs2_journal_access(handle
, bucket
->bu_inode
,
301 bucket
->bu_bhs
[i
], type
);
311 static void ocfs2_xattr_bucket_journal_dirty(handle_t
*handle
,
312 struct ocfs2_xattr_bucket
*bucket
)
316 spin_lock(&OCFS2_SB(bucket
->bu_inode
->i_sb
)->osb_xattr_lock
);
317 ocfs2_compute_meta_ecc_bhs(bucket
->bu_inode
->i_sb
,
318 bucket
->bu_bhs
, bucket
->bu_blocks
,
319 &bucket_xh(bucket
)->xh_check
);
320 spin_unlock(&OCFS2_SB(bucket
->bu_inode
->i_sb
)->osb_xattr_lock
);
322 for (i
= 0; i
< bucket
->bu_blocks
; i
++)
323 ocfs2_journal_dirty(handle
, bucket
->bu_bhs
[i
]);
326 static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket
*dest
,
327 struct ocfs2_xattr_bucket
*src
)
330 int blocksize
= src
->bu_inode
->i_sb
->s_blocksize
;
332 BUG_ON(dest
->bu_blocks
!= src
->bu_blocks
);
333 BUG_ON(dest
->bu_inode
!= src
->bu_inode
);
335 for (i
= 0; i
< src
->bu_blocks
; i
++) {
336 memcpy(bucket_block(dest
, i
), bucket_block(src
, i
),
341 static int ocfs2_validate_xattr_block(struct super_block
*sb
,
342 struct buffer_head
*bh
)
345 struct ocfs2_xattr_block
*xb
=
346 (struct ocfs2_xattr_block
*)bh
->b_data
;
348 mlog(0, "Validating xattr block %llu\n",
349 (unsigned long long)bh
->b_blocknr
);
351 BUG_ON(!buffer_uptodate(bh
));
354 * If the ecc fails, we return the error but otherwise
355 * leave the filesystem running. We know any error is
356 * local to this block.
358 rc
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &xb
->xb_check
);
363 * Errors after here are fatal
366 if (!OCFS2_IS_VALID_XATTR_BLOCK(xb
)) {
368 "Extended attribute block #%llu has bad "
370 (unsigned long long)bh
->b_blocknr
, 7,
375 if (le64_to_cpu(xb
->xb_blkno
) != bh
->b_blocknr
) {
377 "Extended attribute block #%llu has an "
378 "invalid xb_blkno of %llu",
379 (unsigned long long)bh
->b_blocknr
,
380 (unsigned long long)le64_to_cpu(xb
->xb_blkno
));
384 if (le32_to_cpu(xb
->xb_fs_generation
) != OCFS2_SB(sb
)->fs_generation
) {
386 "Extended attribute block #%llu has an invalid "
387 "xb_fs_generation of #%u",
388 (unsigned long long)bh
->b_blocknr
,
389 le32_to_cpu(xb
->xb_fs_generation
));
396 static int ocfs2_read_xattr_block(struct inode
*inode
, u64 xb_blkno
,
397 struct buffer_head
**bh
)
400 struct buffer_head
*tmp
= *bh
;
402 rc
= ocfs2_read_block(INODE_CACHE(inode
), xb_blkno
, &tmp
,
403 ocfs2_validate_xattr_block
);
405 /* If ocfs2_read_block() got us a new bh, pass it up. */
412 static inline const char *ocfs2_xattr_prefix(int name_index
)
414 struct xattr_handler
*handler
= NULL
;
416 if (name_index
> 0 && name_index
< OCFS2_XATTR_MAX
)
417 handler
= ocfs2_xattr_handler_map
[name_index
];
419 return handler
? handler
->prefix
: NULL
;
422 static u32
ocfs2_xattr_name_hash(struct inode
*inode
,
426 /* Get hash value of uuid from super block */
427 u32 hash
= OCFS2_SB(inode
->i_sb
)->uuid_hash
;
430 /* hash extended attribute name */
431 for (i
= 0; i
< name_len
; i
++) {
432 hash
= (hash
<< OCFS2_HASH_SHIFT
) ^
433 (hash
>> (8*sizeof(hash
) - OCFS2_HASH_SHIFT
)) ^
441 * ocfs2_xattr_hash_entry()
443 * Compute the hash of an extended attribute.
445 static void ocfs2_xattr_hash_entry(struct inode
*inode
,
446 struct ocfs2_xattr_header
*header
,
447 struct ocfs2_xattr_entry
*entry
)
450 char *name
= (char *)header
+ le16_to_cpu(entry
->xe_name_offset
);
452 hash
= ocfs2_xattr_name_hash(inode
, name
, entry
->xe_name_len
);
453 entry
->xe_name_hash
= cpu_to_le32(hash
);
458 static int ocfs2_xattr_entry_real_size(int name_len
, size_t value_len
)
462 if (value_len
<= OCFS2_XATTR_INLINE_SIZE
)
463 size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_SIZE(value_len
);
465 size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
466 size
+= sizeof(struct ocfs2_xattr_entry
);
471 int ocfs2_calc_security_init(struct inode
*dir
,
472 struct ocfs2_security_xattr_info
*si
,
475 struct ocfs2_alloc_context
**xattr_ac
)
478 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
479 int s_size
= ocfs2_xattr_entry_real_size(strlen(si
->name
),
483 * The max space of security xattr taken inline is
484 * 256(name) + 80(value) + 16(entry) = 352 bytes,
485 * So reserve one metadata block for it is ok.
487 if (dir
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
||
488 s_size
> OCFS2_XATTR_FREE_IN_IBODY
) {
489 ret
= ocfs2_reserve_new_metadata_blocks(osb
, 1, xattr_ac
);
494 *xattr_credits
+= OCFS2_XATTR_BLOCK_CREATE_CREDITS
;
497 /* reserve clusters for xattr value which will be set in B tree*/
498 if (si
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
499 int new_clusters
= ocfs2_clusters_for_bytes(dir
->i_sb
,
502 *xattr_credits
+= ocfs2_clusters_to_blocks(dir
->i_sb
,
504 *want_clusters
+= new_clusters
;
509 int ocfs2_calc_xattr_init(struct inode
*dir
,
510 struct buffer_head
*dir_bh
,
512 struct ocfs2_security_xattr_info
*si
,
518 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
519 int s_size
= 0, a_size
= 0, acl_len
= 0, new_clusters
;
522 s_size
= ocfs2_xattr_entry_real_size(strlen(si
->name
),
525 if (osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
) {
526 acl_len
= ocfs2_xattr_get_nolock(dir
, dir_bh
,
527 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT
,
530 a_size
= ocfs2_xattr_entry_real_size(0, acl_len
);
533 } else if (acl_len
!= 0 && acl_len
!= -ENODATA
) {
539 if (!(s_size
+ a_size
))
543 * The max space of security xattr taken inline is
544 * 256(name) + 80(value) + 16(entry) = 352 bytes,
545 * The max space of acl xattr taken inline is
546 * 80(value) + 16(entry) * 2(if directory) = 192 bytes,
547 * when blocksize = 512, may reserve one more cluser for
548 * xattr bucket, otherwise reserve one metadata block
550 * If this is a new directory with inline data,
551 * we choose to reserve the entire inline area for
552 * directory contents and force an external xattr block.
554 if (dir
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
||
555 (S_ISDIR(mode
) && ocfs2_supports_inline_data(osb
)) ||
556 (s_size
+ a_size
) > OCFS2_XATTR_FREE_IN_IBODY
) {
557 *want_meta
= *want_meta
+ 1;
558 *xattr_credits
+= OCFS2_XATTR_BLOCK_CREATE_CREDITS
;
561 if (dir
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
&&
562 (s_size
+ a_size
) > OCFS2_XATTR_FREE_IN_BLOCK(dir
)) {
564 *xattr_credits
+= ocfs2_blocks_per_xattr_bucket(dir
->i_sb
);
568 * reserve credits and clusters for xattrs which has large value
569 * and have to be set outside
571 if (si
->enable
&& si
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
572 new_clusters
= ocfs2_clusters_for_bytes(dir
->i_sb
,
574 *xattr_credits
+= ocfs2_clusters_to_blocks(dir
->i_sb
,
576 *want_clusters
+= new_clusters
;
578 if (osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
&&
579 acl_len
> OCFS2_XATTR_INLINE_SIZE
) {
580 /* for directory, it has DEFAULT and ACCESS two types of acls */
581 new_clusters
= (S_ISDIR(mode
) ? 2 : 1) *
582 ocfs2_clusters_for_bytes(dir
->i_sb
, acl_len
);
583 *xattr_credits
+= ocfs2_clusters_to_blocks(dir
->i_sb
,
585 *want_clusters
+= new_clusters
;
591 static int ocfs2_xattr_extend_allocation(struct inode
*inode
,
593 struct ocfs2_xattr_value_buf
*vb
,
594 struct ocfs2_xattr_set_ctxt
*ctxt
)
597 handle_t
*handle
= ctxt
->handle
;
598 enum ocfs2_alloc_restarted why
;
599 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
600 u32 prev_clusters
, logical_start
= le32_to_cpu(vb
->vb_xv
->xr_clusters
);
601 struct ocfs2_extent_tree et
;
603 mlog(0, "(clusters_to_add for xattr= %u)\n", clusters_to_add
);
605 ocfs2_init_xattr_value_extent_tree(&et
, inode
, vb
);
607 status
= vb
->vb_access(handle
, inode
, vb
->vb_bh
,
608 OCFS2_JOURNAL_ACCESS_WRITE
);
614 prev_clusters
= le32_to_cpu(vb
->vb_xv
->xr_clusters
);
615 status
= ocfs2_add_clusters_in_btree(osb
,
630 status
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
636 clusters_to_add
-= le32_to_cpu(vb
->vb_xv
->xr_clusters
) - prev_clusters
;
639 * We should have already allocated enough space before the transaction,
640 * so no need to restart.
642 BUG_ON(why
!= RESTART_NONE
|| clusters_to_add
);
649 static int __ocfs2_remove_xattr_range(struct inode
*inode
,
650 struct ocfs2_xattr_value_buf
*vb
,
651 u32 cpos
, u32 phys_cpos
, u32 len
,
652 struct ocfs2_xattr_set_ctxt
*ctxt
)
655 u64 phys_blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, phys_cpos
);
656 handle_t
*handle
= ctxt
->handle
;
657 struct ocfs2_extent_tree et
;
659 ocfs2_init_xattr_value_extent_tree(&et
, inode
, vb
);
661 ret
= vb
->vb_access(handle
, inode
, vb
->vb_bh
,
662 OCFS2_JOURNAL_ACCESS_WRITE
);
668 ret
= ocfs2_remove_extent(inode
, &et
, cpos
, len
, handle
, ctxt
->meta_ac
,
675 le32_add_cpu(&vb
->vb_xv
->xr_clusters
, -len
);
677 ret
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
683 ret
= ocfs2_cache_cluster_dealloc(&ctxt
->dealloc
, phys_blkno
, len
);
691 static int ocfs2_xattr_shrink_size(struct inode
*inode
,
694 struct ocfs2_xattr_value_buf
*vb
,
695 struct ocfs2_xattr_set_ctxt
*ctxt
)
698 u32 trunc_len
, cpos
, phys_cpos
, alloc_size
;
701 if (old_clusters
<= new_clusters
)
705 trunc_len
= old_clusters
- new_clusters
;
707 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &phys_cpos
,
709 &vb
->vb_xv
->xr_list
);
715 if (alloc_size
> trunc_len
)
716 alloc_size
= trunc_len
;
718 ret
= __ocfs2_remove_xattr_range(inode
, vb
, cpos
,
719 phys_cpos
, alloc_size
,
726 block
= ocfs2_clusters_to_blocks(inode
->i_sb
, phys_cpos
);
727 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode
),
730 trunc_len
-= alloc_size
;
737 static int ocfs2_xattr_value_truncate(struct inode
*inode
,
738 struct ocfs2_xattr_value_buf
*vb
,
740 struct ocfs2_xattr_set_ctxt
*ctxt
)
743 u32 new_clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
, len
);
744 u32 old_clusters
= le32_to_cpu(vb
->vb_xv
->xr_clusters
);
746 if (new_clusters
== old_clusters
)
749 if (new_clusters
> old_clusters
)
750 ret
= ocfs2_xattr_extend_allocation(inode
,
751 new_clusters
- old_clusters
,
754 ret
= ocfs2_xattr_shrink_size(inode
,
755 old_clusters
, new_clusters
,
761 static int ocfs2_xattr_list_entry(char *buffer
, size_t size
,
762 size_t *result
, const char *prefix
,
763 const char *name
, int name_len
)
765 char *p
= buffer
+ *result
;
766 int prefix_len
= strlen(prefix
);
767 int total_len
= prefix_len
+ name_len
+ 1;
769 *result
+= total_len
;
771 /* we are just looking for how big our buffer needs to be */
778 memcpy(p
, prefix
, prefix_len
);
779 memcpy(p
+ prefix_len
, name
, name_len
);
780 p
[prefix_len
+ name_len
] = '\0';
785 static int ocfs2_xattr_list_entries(struct inode
*inode
,
786 struct ocfs2_xattr_header
*header
,
787 char *buffer
, size_t buffer_size
)
791 const char *prefix
, *name
;
793 for (i
= 0 ; i
< le16_to_cpu(header
->xh_count
); i
++) {
794 struct ocfs2_xattr_entry
*entry
= &header
->xh_entries
[i
];
795 type
= ocfs2_xattr_get_type(entry
);
796 prefix
= ocfs2_xattr_prefix(type
);
799 name
= (const char *)header
+
800 le16_to_cpu(entry
->xe_name_offset
);
802 ret
= ocfs2_xattr_list_entry(buffer
, buffer_size
,
803 &result
, prefix
, name
,
813 static int ocfs2_xattr_ibody_list(struct inode
*inode
,
814 struct ocfs2_dinode
*di
,
818 struct ocfs2_xattr_header
*header
= NULL
;
819 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
822 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
))
825 header
= (struct ocfs2_xattr_header
*)
826 ((void *)di
+ inode
->i_sb
->s_blocksize
-
827 le16_to_cpu(di
->i_xattr_inline_size
));
829 ret
= ocfs2_xattr_list_entries(inode
, header
, buffer
, buffer_size
);
834 static int ocfs2_xattr_block_list(struct inode
*inode
,
835 struct ocfs2_dinode
*di
,
839 struct buffer_head
*blk_bh
= NULL
;
840 struct ocfs2_xattr_block
*xb
;
843 if (!di
->i_xattr_loc
)
846 ret
= ocfs2_read_xattr_block(inode
, le64_to_cpu(di
->i_xattr_loc
),
853 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
854 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
855 struct ocfs2_xattr_header
*header
= &xb
->xb_attrs
.xb_header
;
856 ret
= ocfs2_xattr_list_entries(inode
, header
,
857 buffer
, buffer_size
);
859 struct ocfs2_xattr_tree_root
*xt
= &xb
->xb_attrs
.xb_root
;
860 ret
= ocfs2_xattr_tree_list_index_block(inode
, xt
,
861 buffer
, buffer_size
);
869 ssize_t
ocfs2_listxattr(struct dentry
*dentry
,
873 int ret
= 0, i_ret
= 0, b_ret
= 0;
874 struct buffer_head
*di_bh
= NULL
;
875 struct ocfs2_dinode
*di
= NULL
;
876 struct ocfs2_inode_info
*oi
= OCFS2_I(dentry
->d_inode
);
878 if (!ocfs2_supports_xattr(OCFS2_SB(dentry
->d_sb
)))
881 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
884 ret
= ocfs2_inode_lock(dentry
->d_inode
, &di_bh
, 0);
890 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
892 down_read(&oi
->ip_xattr_sem
);
893 i_ret
= ocfs2_xattr_ibody_list(dentry
->d_inode
, di
, buffer
, size
);
901 b_ret
= ocfs2_xattr_block_list(dentry
->d_inode
, di
,
906 up_read(&oi
->ip_xattr_sem
);
907 ocfs2_inode_unlock(dentry
->d_inode
, 0);
911 return i_ret
+ b_ret
;
914 static int ocfs2_xattr_find_entry(int name_index
,
916 struct ocfs2_xattr_search
*xs
)
918 struct ocfs2_xattr_entry
*entry
;
925 name_len
= strlen(name
);
927 for (i
= 0; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
928 cmp
= name_index
- ocfs2_xattr_get_type(entry
);
930 cmp
= name_len
- entry
->xe_name_len
;
932 cmp
= memcmp(name
, (xs
->base
+
933 le16_to_cpu(entry
->xe_name_offset
)),
941 return cmp
? -ENODATA
: 0;
944 static int ocfs2_xattr_get_value_outside(struct inode
*inode
,
945 struct ocfs2_xattr_value_root
*xv
,
949 u32 cpos
, p_cluster
, num_clusters
, bpc
, clusters
;
952 size_t cplen
, blocksize
;
953 struct buffer_head
*bh
= NULL
;
954 struct ocfs2_extent_list
*el
;
957 clusters
= le32_to_cpu(xv
->xr_clusters
);
958 bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
959 blocksize
= inode
->i_sb
->s_blocksize
;
962 while (cpos
< clusters
) {
963 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &p_cluster
,
970 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, p_cluster
);
971 /* Copy ocfs2_xattr_value */
972 for (i
= 0; i
< num_clusters
* bpc
; i
++, blkno
++) {
973 ret
= ocfs2_read_block(INODE_CACHE(inode
), blkno
,
980 cplen
= len
>= blocksize
? blocksize
: len
;
981 memcpy(buffer
, bh
->b_data
, cplen
);
990 cpos
+= num_clusters
;
996 static int ocfs2_xattr_ibody_get(struct inode
*inode
,
1001 struct ocfs2_xattr_search
*xs
)
1003 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1004 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
1005 struct ocfs2_xattr_value_root
*xv
;
1009 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
))
1012 xs
->end
= (void *)di
+ inode
->i_sb
->s_blocksize
;
1013 xs
->header
= (struct ocfs2_xattr_header
*)
1014 (xs
->end
- le16_to_cpu(di
->i_xattr_inline_size
));
1015 xs
->base
= (void *)xs
->header
;
1016 xs
->here
= xs
->header
->xh_entries
;
1018 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
1021 size
= le64_to_cpu(xs
->here
->xe_value_size
);
1023 if (size
> buffer_size
)
1025 if (ocfs2_xattr_is_local(xs
->here
)) {
1026 memcpy(buffer
, (void *)xs
->base
+
1027 le16_to_cpu(xs
->here
->xe_name_offset
) +
1028 OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
), size
);
1030 xv
= (struct ocfs2_xattr_value_root
*)
1031 (xs
->base
+ le16_to_cpu(
1032 xs
->here
->xe_name_offset
) +
1033 OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
));
1034 ret
= ocfs2_xattr_get_value_outside(inode
, xv
,
1046 static int ocfs2_xattr_block_get(struct inode
*inode
,
1051 struct ocfs2_xattr_search
*xs
)
1053 struct ocfs2_xattr_block
*xb
;
1054 struct ocfs2_xattr_value_root
*xv
;
1056 int ret
= -ENODATA
, name_offset
, name_len
, i
;
1057 int uninitialized_var(block_off
);
1059 xs
->bucket
= ocfs2_xattr_bucket_new(inode
);
1066 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, xs
);
1072 if (xs
->not_found
) {
1077 xb
= (struct ocfs2_xattr_block
*)xs
->xattr_bh
->b_data
;
1078 size
= le64_to_cpu(xs
->here
->xe_value_size
);
1081 if (size
> buffer_size
)
1084 name_offset
= le16_to_cpu(xs
->here
->xe_name_offset
);
1085 name_len
= OCFS2_XATTR_SIZE(xs
->here
->xe_name_len
);
1086 i
= xs
->here
- xs
->header
->xh_entries
;
1088 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
1089 ret
= ocfs2_xattr_bucket_get_name_value(inode
,
1090 bucket_xh(xs
->bucket
),
1094 xs
->base
= bucket_block(xs
->bucket
, block_off
);
1096 if (ocfs2_xattr_is_local(xs
->here
)) {
1097 memcpy(buffer
, (void *)xs
->base
+
1098 name_offset
+ name_len
, size
);
1100 xv
= (struct ocfs2_xattr_value_root
*)
1101 (xs
->base
+ name_offset
+ name_len
);
1102 ret
= ocfs2_xattr_get_value_outside(inode
, xv
,
1112 ocfs2_xattr_bucket_free(xs
->bucket
);
1114 brelse(xs
->xattr_bh
);
1115 xs
->xattr_bh
= NULL
;
1119 int ocfs2_xattr_get_nolock(struct inode
*inode
,
1120 struct buffer_head
*di_bh
,
1127 struct ocfs2_dinode
*di
= NULL
;
1128 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1129 struct ocfs2_xattr_search xis
= {
1130 .not_found
= -ENODATA
,
1132 struct ocfs2_xattr_search xbs
= {
1133 .not_found
= -ENODATA
,
1136 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
1139 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
1142 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
1143 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1145 down_read(&oi
->ip_xattr_sem
);
1146 ret
= ocfs2_xattr_ibody_get(inode
, name_index
, name
, buffer
,
1148 if (ret
== -ENODATA
&& di
->i_xattr_loc
)
1149 ret
= ocfs2_xattr_block_get(inode
, name_index
, name
, buffer
,
1151 up_read(&oi
->ip_xattr_sem
);
1156 /* ocfs2_xattr_get()
1158 * Copy an extended attribute into the buffer provided.
1159 * Buffer is NULL to compute the size of buffer required.
1161 static int ocfs2_xattr_get(struct inode
*inode
,
1168 struct buffer_head
*di_bh
= NULL
;
1170 ret
= ocfs2_inode_lock(inode
, &di_bh
, 0);
1175 ret
= ocfs2_xattr_get_nolock(inode
, di_bh
, name_index
,
1176 name
, buffer
, buffer_size
);
1178 ocfs2_inode_unlock(inode
, 0);
1185 static int __ocfs2_xattr_set_value_outside(struct inode
*inode
,
1187 struct ocfs2_xattr_value_root
*xv
,
1191 int ret
= 0, i
, cp_len
;
1192 u16 blocksize
= inode
->i_sb
->s_blocksize
;
1193 u32 p_cluster
, num_clusters
;
1194 u32 cpos
= 0, bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
1195 u32 clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
, value_len
);
1197 struct buffer_head
*bh
= NULL
;
1199 BUG_ON(clusters
> le32_to_cpu(xv
->xr_clusters
));
1201 while (cpos
< clusters
) {
1202 ret
= ocfs2_xattr_get_clusters(inode
, cpos
, &p_cluster
,
1203 &num_clusters
, &xv
->xr_list
);
1209 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, p_cluster
);
1211 for (i
= 0; i
< num_clusters
* bpc
; i
++, blkno
++) {
1212 ret
= ocfs2_read_block(INODE_CACHE(inode
), blkno
,
1219 ret
= ocfs2_journal_access(handle
,
1222 OCFS2_JOURNAL_ACCESS_WRITE
);
1228 cp_len
= value_len
> blocksize
? blocksize
: value_len
;
1229 memcpy(bh
->b_data
, value
, cp_len
);
1230 value_len
-= cp_len
;
1232 if (cp_len
< blocksize
)
1233 memset(bh
->b_data
+ cp_len
, 0,
1234 blocksize
- cp_len
);
1236 ret
= ocfs2_journal_dirty(handle
, bh
);
1245 * XXX: do we need to empty all the following
1246 * blocks in this cluster?
1251 cpos
+= num_clusters
;
1259 static int ocfs2_xattr_cleanup(struct inode
*inode
,
1261 struct ocfs2_xattr_info
*xi
,
1262 struct ocfs2_xattr_search
*xs
,
1263 struct ocfs2_xattr_value_buf
*vb
,
1267 size_t name_len
= strlen(xi
->name
);
1268 void *val
= xs
->base
+ offs
;
1269 size_t size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1271 ret
= vb
->vb_access(handle
, inode
, vb
->vb_bh
,
1272 OCFS2_JOURNAL_ACCESS_WRITE
);
1277 /* Decrease xattr count */
1278 le16_add_cpu(&xs
->header
->xh_count
, -1);
1279 /* Remove the xattr entry and tree root which has already be set*/
1280 memset((void *)xs
->here
, 0, sizeof(struct ocfs2_xattr_entry
));
1281 memset(val
, 0, size
);
1283 ret
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
1290 static int ocfs2_xattr_update_entry(struct inode
*inode
,
1292 struct ocfs2_xattr_info
*xi
,
1293 struct ocfs2_xattr_search
*xs
,
1294 struct ocfs2_xattr_value_buf
*vb
,
1299 ret
= vb
->vb_access(handle
, inode
, vb
->vb_bh
,
1300 OCFS2_JOURNAL_ACCESS_WRITE
);
1306 xs
->here
->xe_name_offset
= cpu_to_le16(offs
);
1307 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1308 if (xi
->value_len
<= OCFS2_XATTR_INLINE_SIZE
)
1309 ocfs2_xattr_set_local(xs
->here
, 1);
1311 ocfs2_xattr_set_local(xs
->here
, 0);
1312 ocfs2_xattr_hash_entry(inode
, xs
->header
, xs
->here
);
1314 ret
= ocfs2_journal_dirty(handle
, vb
->vb_bh
);
1322 * ocfs2_xattr_set_value_outside()
1324 * Set large size value in B tree.
1326 static int ocfs2_xattr_set_value_outside(struct inode
*inode
,
1327 struct ocfs2_xattr_info
*xi
,
1328 struct ocfs2_xattr_search
*xs
,
1329 struct ocfs2_xattr_set_ctxt
*ctxt
,
1330 struct ocfs2_xattr_value_buf
*vb
,
1333 size_t name_len
= strlen(xi
->name
);
1334 void *val
= xs
->base
+ offs
;
1335 struct ocfs2_xattr_value_root
*xv
= NULL
;
1336 size_t size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1339 memset(val
, 0, size
);
1340 memcpy(val
, xi
->name
, name_len
);
1341 xv
= (struct ocfs2_xattr_value_root
*)
1342 (val
+ OCFS2_XATTR_SIZE(name_len
));
1343 xv
->xr_clusters
= 0;
1344 xv
->xr_last_eb_blk
= 0;
1345 xv
->xr_list
.l_tree_depth
= 0;
1346 xv
->xr_list
.l_count
= cpu_to_le16(1);
1347 xv
->xr_list
.l_next_free_rec
= 0;
1350 ret
= ocfs2_xattr_value_truncate(inode
, vb
, xi
->value_len
, ctxt
);
1355 ret
= ocfs2_xattr_update_entry(inode
, ctxt
->handle
, xi
, xs
, vb
, offs
);
1360 ret
= __ocfs2_xattr_set_value_outside(inode
, ctxt
->handle
, vb
->vb_xv
,
1361 xi
->value
, xi
->value_len
);
1369 * ocfs2_xattr_set_entry_local()
1371 * Set, replace or remove extended attribute in local.
1373 static void ocfs2_xattr_set_entry_local(struct inode
*inode
,
1374 struct ocfs2_xattr_info
*xi
,
1375 struct ocfs2_xattr_search
*xs
,
1376 struct ocfs2_xattr_entry
*last
,
1379 size_t name_len
= strlen(xi
->name
);
1382 if (xi
->value
&& xs
->not_found
) {
1383 /* Insert the new xattr entry. */
1384 le16_add_cpu(&xs
->header
->xh_count
, 1);
1385 ocfs2_xattr_set_type(last
, xi
->name_index
);
1386 ocfs2_xattr_set_local(last
, 1);
1387 last
->xe_name_len
= name_len
;
1393 first_val
= xs
->base
+ min_offs
;
1394 offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1395 val
= xs
->base
+ offs
;
1397 if (le64_to_cpu(xs
->here
->xe_value_size
) >
1398 OCFS2_XATTR_INLINE_SIZE
)
1399 size
= OCFS2_XATTR_SIZE(name_len
) +
1400 OCFS2_XATTR_ROOT_SIZE
;
1402 size
= OCFS2_XATTR_SIZE(name_len
) +
1403 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1405 if (xi
->value
&& size
== OCFS2_XATTR_SIZE(name_len
) +
1406 OCFS2_XATTR_SIZE(xi
->value_len
)) {
1407 /* The old and the new value have the
1408 same size. Just replace the value. */
1409 ocfs2_xattr_set_local(xs
->here
, 1);
1410 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1411 /* Clear value bytes. */
1412 memset(val
+ OCFS2_XATTR_SIZE(name_len
),
1414 OCFS2_XATTR_SIZE(xi
->value_len
));
1415 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
1420 /* Remove the old name+value. */
1421 memmove(first_val
+ size
, first_val
, val
- first_val
);
1422 memset(first_val
, 0, size
);
1423 xs
->here
->xe_name_hash
= 0;
1424 xs
->here
->xe_name_offset
= 0;
1425 ocfs2_xattr_set_local(xs
->here
, 1);
1426 xs
->here
->xe_value_size
= 0;
1430 /* Adjust all value offsets. */
1431 last
= xs
->header
->xh_entries
;
1432 for (i
= 0 ; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
1433 size_t o
= le16_to_cpu(last
->xe_name_offset
);
1436 last
->xe_name_offset
= cpu_to_le16(o
+ size
);
1441 /* Remove the old entry. */
1443 memmove(xs
->here
, xs
->here
+ 1,
1444 (void *)last
- (void *)xs
->here
);
1445 memset(last
, 0, sizeof(struct ocfs2_xattr_entry
));
1446 le16_add_cpu(&xs
->header
->xh_count
, -1);
1450 /* Insert the new name+value. */
1451 size_t size
= OCFS2_XATTR_SIZE(name_len
) +
1452 OCFS2_XATTR_SIZE(xi
->value_len
);
1453 void *val
= xs
->base
+ min_offs
- size
;
1455 xs
->here
->xe_name_offset
= cpu_to_le16(min_offs
- size
);
1456 memset(val
, 0, size
);
1457 memcpy(val
, xi
->name
, name_len
);
1458 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
1461 xs
->here
->xe_value_size
= cpu_to_le64(xi
->value_len
);
1462 ocfs2_xattr_set_local(xs
->here
, 1);
1463 ocfs2_xattr_hash_entry(inode
, xs
->header
, xs
->here
);
1470 * ocfs2_xattr_set_entry()
1472 * Set extended attribute entry into inode or block.
1474 * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
1475 * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
1476 * then set value in B tree with set_value_outside().
1478 static int ocfs2_xattr_set_entry(struct inode
*inode
,
1479 struct ocfs2_xattr_info
*xi
,
1480 struct ocfs2_xattr_search
*xs
,
1481 struct ocfs2_xattr_set_ctxt
*ctxt
,
1484 struct ocfs2_xattr_entry
*last
;
1485 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1486 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
1487 size_t min_offs
= xs
->end
- xs
->base
, name_len
= strlen(xi
->name
);
1489 handle_t
*handle
= ctxt
->handle
;
1491 struct ocfs2_xattr_info xi_l
= {
1492 .name_index
= xi
->name_index
,
1495 .value_len
= xi
->value_len
,
1497 struct ocfs2_xattr_value_buf vb
= {
1498 .vb_bh
= xs
->xattr_bh
,
1499 .vb_access
= ocfs2_journal_access_di
,
1502 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1503 BUG_ON(xs
->xattr_bh
== xs
->inode_bh
);
1504 vb
.vb_access
= ocfs2_journal_access_xb
;
1506 BUG_ON(xs
->xattr_bh
!= xs
->inode_bh
);
1508 /* Compute min_offs, last and free space. */
1509 last
= xs
->header
->xh_entries
;
1511 for (i
= 0 ; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
1512 size_t offs
= le16_to_cpu(last
->xe_name_offset
);
1513 if (offs
< min_offs
)
1518 free
= min_offs
- ((void *)last
- xs
->base
) - OCFS2_XATTR_HEADER_GAP
;
1522 if (!xs
->not_found
) {
1524 if (ocfs2_xattr_is_local(xs
->here
))
1525 size
= OCFS2_XATTR_SIZE(name_len
) +
1526 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1528 size
= OCFS2_XATTR_SIZE(name_len
) +
1529 OCFS2_XATTR_ROOT_SIZE
;
1530 free
+= (size
+ sizeof(struct ocfs2_xattr_entry
));
1532 /* Check free space in inode or block */
1533 if (xi
->value
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1534 if (free
< sizeof(struct ocfs2_xattr_entry
) +
1535 OCFS2_XATTR_SIZE(name_len
) +
1536 OCFS2_XATTR_ROOT_SIZE
) {
1540 size_l
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_ROOT_SIZE
;
1541 xi_l
.value
= (void *)&def_xv
;
1542 xi_l
.value_len
= OCFS2_XATTR_ROOT_SIZE
;
1543 } else if (xi
->value
) {
1544 if (free
< sizeof(struct ocfs2_xattr_entry
) +
1545 OCFS2_XATTR_SIZE(name_len
) +
1546 OCFS2_XATTR_SIZE(xi
->value_len
)) {
1552 if (!xs
->not_found
) {
1553 /* For existing extended attribute */
1554 size_t size
= OCFS2_XATTR_SIZE(name_len
) +
1555 OCFS2_XATTR_SIZE(le64_to_cpu(xs
->here
->xe_value_size
));
1556 size_t offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1557 void *val
= xs
->base
+ offs
;
1559 if (ocfs2_xattr_is_local(xs
->here
) && size
== size_l
) {
1560 /* Replace existing local xattr with tree root */
1561 ret
= ocfs2_xattr_set_value_outside(inode
, xi
, xs
,
1566 } else if (!ocfs2_xattr_is_local(xs
->here
)) {
1567 /* For existing xattr which has value outside */
1568 vb
.vb_xv
= (struct ocfs2_xattr_value_root
*)
1569 (val
+ OCFS2_XATTR_SIZE(name_len
));
1571 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1573 * If new value need set outside also,
1574 * first truncate old value to new value,
1575 * then set new value with set_value_outside().
1577 ret
= ocfs2_xattr_value_truncate(inode
,
1586 ret
= ocfs2_xattr_update_entry(inode
,
1597 ret
= __ocfs2_xattr_set_value_outside(inode
,
1607 * If new value need set in local,
1608 * just trucate old value to zero.
1610 ret
= ocfs2_xattr_value_truncate(inode
,
1620 ret
= ocfs2_journal_access_di(handle
, inode
, xs
->inode_bh
,
1621 OCFS2_JOURNAL_ACCESS_WRITE
);
1627 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1628 ret
= vb
.vb_access(handle
, inode
, vb
.vb_bh
,
1629 OCFS2_JOURNAL_ACCESS_WRITE
);
1637 * Set value in local, include set tree root in local.
1638 * This is the first step for value size >INLINE_SIZE.
1640 ocfs2_xattr_set_entry_local(inode
, &xi_l
, xs
, last
, min_offs
);
1642 if (!(flag
& OCFS2_INLINE_XATTR_FL
)) {
1643 ret
= ocfs2_journal_dirty(handle
, xs
->xattr_bh
);
1650 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) &&
1651 (flag
& OCFS2_INLINE_XATTR_FL
)) {
1652 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1653 unsigned int xattrsize
= osb
->s_xattr_inline_size
;
1656 * Adjust extent record count or inline data size
1657 * to reserve space for extended attribute.
1659 if (oi
->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
1660 struct ocfs2_inline_data
*idata
= &di
->id2
.i_data
;
1661 le16_add_cpu(&idata
->id_count
, -xattrsize
);
1662 } else if (!(ocfs2_inode_is_fast_symlink(inode
))) {
1663 struct ocfs2_extent_list
*el
= &di
->id2
.i_list
;
1664 le16_add_cpu(&el
->l_count
, -(xattrsize
/
1665 sizeof(struct ocfs2_extent_rec
)));
1667 di
->i_xattr_inline_size
= cpu_to_le16(xattrsize
);
1669 /* Update xattr flag */
1670 spin_lock(&oi
->ip_lock
);
1671 oi
->ip_dyn_features
|= flag
;
1672 di
->i_dyn_features
= cpu_to_le16(oi
->ip_dyn_features
);
1673 spin_unlock(&oi
->ip_lock
);
1675 ret
= ocfs2_journal_dirty(handle
, xs
->inode_bh
);
1679 if (!ret
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
1681 * Set value outside in B tree.
1682 * This is the second step for value size > INLINE_SIZE.
1684 size_t offs
= le16_to_cpu(xs
->here
->xe_name_offset
);
1685 ret
= ocfs2_xattr_set_value_outside(inode
, xi
, xs
, ctxt
,
1692 * If set value outside failed, we have to clean
1693 * the junk tree root we have already set in local.
1695 ret2
= ocfs2_xattr_cleanup(inode
, ctxt
->handle
,
1705 static int ocfs2_remove_value_outside(struct inode
*inode
,
1706 struct ocfs2_xattr_value_buf
*vb
,
1707 struct ocfs2_xattr_header
*header
)
1710 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1711 struct ocfs2_xattr_set_ctxt ctxt
= { NULL
, NULL
, };
1713 ocfs2_init_dealloc_ctxt(&ctxt
.dealloc
);
1715 ctxt
.handle
= ocfs2_start_trans(osb
,
1716 ocfs2_remove_extent_credits(osb
->sb
));
1717 if (IS_ERR(ctxt
.handle
)) {
1718 ret
= PTR_ERR(ctxt
.handle
);
1723 for (i
= 0; i
< le16_to_cpu(header
->xh_count
); i
++) {
1724 struct ocfs2_xattr_entry
*entry
= &header
->xh_entries
[i
];
1726 if (!ocfs2_xattr_is_local(entry
)) {
1729 val
= (void *)header
+
1730 le16_to_cpu(entry
->xe_name_offset
);
1731 vb
->vb_xv
= (struct ocfs2_xattr_value_root
*)
1732 (val
+ OCFS2_XATTR_SIZE(entry
->xe_name_len
));
1733 ret
= ocfs2_xattr_value_truncate(inode
, vb
, 0, &ctxt
);
1741 ocfs2_commit_trans(osb
, ctxt
.handle
);
1742 ocfs2_schedule_truncate_log_flush(osb
, 1);
1743 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
1748 static int ocfs2_xattr_ibody_remove(struct inode
*inode
,
1749 struct buffer_head
*di_bh
)
1752 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1753 struct ocfs2_xattr_header
*header
;
1755 struct ocfs2_xattr_value_buf vb
= {
1757 .vb_access
= ocfs2_journal_access_di
,
1760 header
= (struct ocfs2_xattr_header
*)
1761 ((void *)di
+ inode
->i_sb
->s_blocksize
-
1762 le16_to_cpu(di
->i_xattr_inline_size
));
1764 ret
= ocfs2_remove_value_outside(inode
, &vb
, header
);
1769 static int ocfs2_xattr_block_remove(struct inode
*inode
,
1770 struct buffer_head
*blk_bh
)
1772 struct ocfs2_xattr_block
*xb
;
1774 struct ocfs2_xattr_value_buf vb
= {
1776 .vb_access
= ocfs2_journal_access_xb
,
1779 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
1780 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
1781 struct ocfs2_xattr_header
*header
= &(xb
->xb_attrs
.xb_header
);
1782 ret
= ocfs2_remove_value_outside(inode
, &vb
, header
);
1784 ret
= ocfs2_delete_xattr_index_block(inode
, blk_bh
);
1789 static int ocfs2_xattr_free_block(struct inode
*inode
,
1792 struct inode
*xb_alloc_inode
;
1793 struct buffer_head
*xb_alloc_bh
= NULL
;
1794 struct buffer_head
*blk_bh
= NULL
;
1795 struct ocfs2_xattr_block
*xb
;
1796 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1802 ret
= ocfs2_read_xattr_block(inode
, block
, &blk_bh
);
1808 ret
= ocfs2_xattr_block_remove(inode
, blk_bh
);
1814 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
1815 blk
= le64_to_cpu(xb
->xb_blkno
);
1816 bit
= le16_to_cpu(xb
->xb_suballoc_bit
);
1817 bg_blkno
= ocfs2_which_suballoc_group(blk
, bit
);
1819 xb_alloc_inode
= ocfs2_get_system_file_inode(osb
,
1820 EXTENT_ALLOC_SYSTEM_INODE
,
1821 le16_to_cpu(xb
->xb_suballoc_slot
));
1822 if (!xb_alloc_inode
) {
1827 mutex_lock(&xb_alloc_inode
->i_mutex
);
1829 ret
= ocfs2_inode_lock(xb_alloc_inode
, &xb_alloc_bh
, 1);
1835 handle
= ocfs2_start_trans(osb
, OCFS2_SUBALLOC_FREE
);
1836 if (IS_ERR(handle
)) {
1837 ret
= PTR_ERR(handle
);
1842 ret
= ocfs2_free_suballoc_bits(handle
, xb_alloc_inode
, xb_alloc_bh
,
1847 ocfs2_commit_trans(osb
, handle
);
1849 ocfs2_inode_unlock(xb_alloc_inode
, 1);
1850 brelse(xb_alloc_bh
);
1852 mutex_unlock(&xb_alloc_inode
->i_mutex
);
1853 iput(xb_alloc_inode
);
1860 * ocfs2_xattr_remove()
1862 * Free extended attribute resources associated with this inode.
1864 int ocfs2_xattr_remove(struct inode
*inode
, struct buffer_head
*di_bh
)
1866 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1867 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1871 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
1874 if (!(oi
->ip_dyn_features
& OCFS2_HAS_XATTR_FL
))
1877 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) {
1878 ret
= ocfs2_xattr_ibody_remove(inode
, di_bh
);
1885 if (di
->i_xattr_loc
) {
1886 ret
= ocfs2_xattr_free_block(inode
,
1887 le64_to_cpu(di
->i_xattr_loc
));
1894 handle
= ocfs2_start_trans((OCFS2_SB(inode
->i_sb
)),
1895 OCFS2_INODE_UPDATE_CREDITS
);
1896 if (IS_ERR(handle
)) {
1897 ret
= PTR_ERR(handle
);
1901 ret
= ocfs2_journal_access_di(handle
, inode
, di_bh
,
1902 OCFS2_JOURNAL_ACCESS_WRITE
);
1908 di
->i_xattr_loc
= 0;
1910 spin_lock(&oi
->ip_lock
);
1911 oi
->ip_dyn_features
&= ~(OCFS2_INLINE_XATTR_FL
| OCFS2_HAS_XATTR_FL
);
1912 di
->i_dyn_features
= cpu_to_le16(oi
->ip_dyn_features
);
1913 spin_unlock(&oi
->ip_lock
);
1915 ret
= ocfs2_journal_dirty(handle
, di_bh
);
1919 ocfs2_commit_trans(OCFS2_SB(inode
->i_sb
), handle
);
1924 static int ocfs2_xattr_has_space_inline(struct inode
*inode
,
1925 struct ocfs2_dinode
*di
)
1927 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1928 unsigned int xattrsize
= OCFS2_SB(inode
->i_sb
)->s_xattr_inline_size
;
1931 if (xattrsize
< OCFS2_MIN_XATTR_INLINE_SIZE
)
1934 if (oi
->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
1935 struct ocfs2_inline_data
*idata
= &di
->id2
.i_data
;
1936 free
= le16_to_cpu(idata
->id_count
) - le64_to_cpu(di
->i_size
);
1937 } else if (ocfs2_inode_is_fast_symlink(inode
)) {
1938 free
= ocfs2_fast_symlink_chars(inode
->i_sb
) -
1939 le64_to_cpu(di
->i_size
);
1941 struct ocfs2_extent_list
*el
= &di
->id2
.i_list
;
1942 free
= (le16_to_cpu(el
->l_count
) -
1943 le16_to_cpu(el
->l_next_free_rec
)) *
1944 sizeof(struct ocfs2_extent_rec
);
1946 if (free
>= xattrsize
)
1953 * ocfs2_xattr_ibody_find()
1955 * Find extended attribute in inode block and
1956 * fill search info into struct ocfs2_xattr_search.
1958 static int ocfs2_xattr_ibody_find(struct inode
*inode
,
1961 struct ocfs2_xattr_search
*xs
)
1963 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
1964 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
1968 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
)
1971 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)) {
1972 down_read(&oi
->ip_alloc_sem
);
1973 has_space
= ocfs2_xattr_has_space_inline(inode
, di
);
1974 up_read(&oi
->ip_alloc_sem
);
1979 xs
->xattr_bh
= xs
->inode_bh
;
1980 xs
->end
= (void *)di
+ inode
->i_sb
->s_blocksize
;
1981 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)
1982 xs
->header
= (struct ocfs2_xattr_header
*)
1983 (xs
->end
- le16_to_cpu(di
->i_xattr_inline_size
));
1985 xs
->header
= (struct ocfs2_xattr_header
*)
1986 (xs
->end
- OCFS2_SB(inode
->i_sb
)->s_xattr_inline_size
);
1987 xs
->base
= (void *)xs
->header
;
1988 xs
->here
= xs
->header
->xh_entries
;
1990 /* Find the named attribute. */
1991 if (oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
) {
1992 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
1993 if (ret
&& ret
!= -ENODATA
)
1995 xs
->not_found
= ret
;
2002 * ocfs2_xattr_ibody_set()
2004 * Set, replace or remove an extended attribute into inode block.
2007 static int ocfs2_xattr_ibody_set(struct inode
*inode
,
2008 struct ocfs2_xattr_info
*xi
,
2009 struct ocfs2_xattr_search
*xs
,
2010 struct ocfs2_xattr_set_ctxt
*ctxt
)
2012 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
2013 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2016 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
)
2019 down_write(&oi
->ip_alloc_sem
);
2020 if (!(oi
->ip_dyn_features
& OCFS2_INLINE_XATTR_FL
)) {
2021 if (!ocfs2_xattr_has_space_inline(inode
, di
)) {
2027 ret
= ocfs2_xattr_set_entry(inode
, xi
, xs
, ctxt
,
2028 (OCFS2_INLINE_XATTR_FL
| OCFS2_HAS_XATTR_FL
));
2030 up_write(&oi
->ip_alloc_sem
);
2036 * ocfs2_xattr_block_find()
2038 * Find extended attribute in external block and
2039 * fill search info into struct ocfs2_xattr_search.
2041 static int ocfs2_xattr_block_find(struct inode
*inode
,
2044 struct ocfs2_xattr_search
*xs
)
2046 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2047 struct buffer_head
*blk_bh
= NULL
;
2048 struct ocfs2_xattr_block
*xb
;
2051 if (!di
->i_xattr_loc
)
2054 ret
= ocfs2_read_xattr_block(inode
, le64_to_cpu(di
->i_xattr_loc
),
2061 xs
->xattr_bh
= blk_bh
;
2062 xb
= (struct ocfs2_xattr_block
*)blk_bh
->b_data
;
2064 if (!(le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
2065 xs
->header
= &xb
->xb_attrs
.xb_header
;
2066 xs
->base
= (void *)xs
->header
;
2067 xs
->end
= (void *)(blk_bh
->b_data
) + blk_bh
->b_size
;
2068 xs
->here
= xs
->header
->xh_entries
;
2070 ret
= ocfs2_xattr_find_entry(name_index
, name
, xs
);
2072 ret
= ocfs2_xattr_index_block_find(inode
, blk_bh
,
2076 if (ret
&& ret
!= -ENODATA
) {
2077 xs
->xattr_bh
= NULL
;
2080 xs
->not_found
= ret
;
2089 * ocfs2_xattr_block_set()
2091 * Set, replace or remove an extended attribute into external block.
2094 static int ocfs2_xattr_block_set(struct inode
*inode
,
2095 struct ocfs2_xattr_info
*xi
,
2096 struct ocfs2_xattr_search
*xs
,
2097 struct ocfs2_xattr_set_ctxt
*ctxt
)
2099 struct buffer_head
*new_bh
= NULL
;
2100 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2101 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)xs
->inode_bh
->b_data
;
2102 handle_t
*handle
= ctxt
->handle
;
2103 struct ocfs2_xattr_block
*xblk
= NULL
;
2104 u16 suballoc_bit_start
;
2109 if (!xs
->xattr_bh
) {
2110 ret
= ocfs2_journal_access_di(handle
, inode
, xs
->inode_bh
,
2111 OCFS2_JOURNAL_ACCESS_CREATE
);
2117 ret
= ocfs2_claim_metadata(osb
, handle
, ctxt
->meta_ac
, 1,
2118 &suballoc_bit_start
, &num_got
,
2125 new_bh
= sb_getblk(inode
->i_sb
, first_blkno
);
2126 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), new_bh
);
2128 ret
= ocfs2_journal_access_xb(handle
, inode
, new_bh
,
2129 OCFS2_JOURNAL_ACCESS_CREATE
);
2135 /* Initialize ocfs2_xattr_block */
2136 xs
->xattr_bh
= new_bh
;
2137 xblk
= (struct ocfs2_xattr_block
*)new_bh
->b_data
;
2138 memset(xblk
, 0, inode
->i_sb
->s_blocksize
);
2139 strcpy((void *)xblk
, OCFS2_XATTR_BLOCK_SIGNATURE
);
2140 xblk
->xb_suballoc_slot
= cpu_to_le16(osb
->slot_num
);
2141 xblk
->xb_suballoc_bit
= cpu_to_le16(suballoc_bit_start
);
2142 xblk
->xb_fs_generation
= cpu_to_le32(osb
->fs_generation
);
2143 xblk
->xb_blkno
= cpu_to_le64(first_blkno
);
2145 xs
->header
= &xblk
->xb_attrs
.xb_header
;
2146 xs
->base
= (void *)xs
->header
;
2147 xs
->end
= (void *)xblk
+ inode
->i_sb
->s_blocksize
;
2148 xs
->here
= xs
->header
->xh_entries
;
2150 ret
= ocfs2_journal_dirty(handle
, new_bh
);
2155 di
->i_xattr_loc
= cpu_to_le64(first_blkno
);
2156 ocfs2_journal_dirty(handle
, xs
->inode_bh
);
2158 xblk
= (struct ocfs2_xattr_block
*)xs
->xattr_bh
->b_data
;
2160 if (!(le16_to_cpu(xblk
->xb_flags
) & OCFS2_XATTR_INDEXED
)) {
2161 /* Set extended attribute into external block */
2162 ret
= ocfs2_xattr_set_entry(inode
, xi
, xs
, ctxt
,
2163 OCFS2_HAS_XATTR_FL
);
2164 if (!ret
|| ret
!= -ENOSPC
)
2167 ret
= ocfs2_xattr_create_index_block(inode
, xs
, ctxt
);
2172 ret
= ocfs2_xattr_set_entry_index_block(inode
, xi
, xs
, ctxt
);
2179 /* Check whether the new xattr can be inserted into the inode. */
2180 static int ocfs2_xattr_can_be_in_inode(struct inode
*inode
,
2181 struct ocfs2_xattr_info
*xi
,
2182 struct ocfs2_xattr_search
*xs
)
2185 struct ocfs2_xattr_entry
*last
;
2187 size_t min_offs
= xs
->end
- xs
->base
;
2192 last
= xs
->header
->xh_entries
;
2194 for (i
= 0; i
< le16_to_cpu(xs
->header
->xh_count
); i
++) {
2195 size_t offs
= le16_to_cpu(last
->xe_name_offset
);
2196 if (offs
< min_offs
)
2201 free
= min_offs
- ((void *)last
- xs
->base
) - OCFS2_XATTR_HEADER_GAP
;
2205 BUG_ON(!xs
->not_found
);
2207 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
2208 value_size
= OCFS2_XATTR_ROOT_SIZE
;
2210 value_size
= OCFS2_XATTR_SIZE(xi
->value_len
);
2212 if (free
>= sizeof(struct ocfs2_xattr_entry
) +
2213 OCFS2_XATTR_SIZE(strlen(xi
->name
)) + value_size
)
2219 static int ocfs2_calc_xattr_set_need(struct inode
*inode
,
2220 struct ocfs2_dinode
*di
,
2221 struct ocfs2_xattr_info
*xi
,
2222 struct ocfs2_xattr_search
*xis
,
2223 struct ocfs2_xattr_search
*xbs
,
2228 int ret
= 0, old_in_xb
= 0;
2229 int clusters_add
= 0, meta_add
= 0, credits
= 0;
2230 struct buffer_head
*bh
= NULL
;
2231 struct ocfs2_xattr_block
*xb
= NULL
;
2232 struct ocfs2_xattr_entry
*xe
= NULL
;
2233 struct ocfs2_xattr_value_root
*xv
= NULL
;
2235 int name_offset
, name_len
= 0;
2236 u32 new_clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
,
2241 * Calculate the clusters we need to write.
2242 * No matter whether we replace an old one or add a new one,
2243 * we need this for writing.
2245 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
2246 credits
+= new_clusters
*
2247 ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
2249 if (xis
->not_found
&& xbs
->not_found
) {
2250 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2252 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
2253 clusters_add
+= new_clusters
;
2254 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2262 if (!xis
->not_found
) {
2264 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
2265 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
2267 credits
+= OCFS2_INODE_UPDATE_CREDITS
;
2269 int i
, block_off
= 0;
2270 xb
= (struct ocfs2_xattr_block
*)xbs
->xattr_bh
->b_data
;
2272 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
2273 name_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
2274 i
= xbs
->here
- xbs
->header
->xh_entries
;
2277 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
2278 ret
= ocfs2_xattr_bucket_get_name_value(inode
,
2279 bucket_xh(xbs
->bucket
),
2282 base
= bucket_block(xbs
->bucket
, block_off
);
2283 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2286 credits
+= OCFS2_XATTR_BLOCK_UPDATE_CREDITS
;
2291 * delete a xattr doesn't need metadata and cluster allocation.
2292 * so just calculate the credits and return.
2294 * The credits for removing the value tree will be extended
2295 * by ocfs2_remove_extent itself.
2298 if (!ocfs2_xattr_is_local(xe
))
2299 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
);
2304 /* do cluster allocation guess first. */
2305 value_size
= le64_to_cpu(xe
->xe_value_size
);
2309 * In xattr set, we always try to set the xe in inode first,
2310 * so if it can be inserted into inode successfully, the old
2311 * one will be removed from the xattr block, and this xattr
2312 * will be inserted into inode as a new xattr in inode.
2314 if (ocfs2_xattr_can_be_in_inode(inode
, xi
, xis
)) {
2315 clusters_add
+= new_clusters
;
2316 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
) +
2317 OCFS2_INODE_UPDATE_CREDITS
;
2318 if (!ocfs2_xattr_is_local(xe
))
2319 credits
+= ocfs2_calc_extend_credits(
2327 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
) {
2328 /* the new values will be stored outside. */
2329 u32 old_clusters
= 0;
2331 if (!ocfs2_xattr_is_local(xe
)) {
2332 old_clusters
= ocfs2_clusters_for_bytes(inode
->i_sb
,
2334 xv
= (struct ocfs2_xattr_value_root
*)
2335 (base
+ name_offset
+ name_len
);
2336 value_size
= OCFS2_XATTR_ROOT_SIZE
;
2340 if (old_clusters
>= new_clusters
) {
2341 credits
+= ocfs2_remove_extent_credits(inode
->i_sb
);
2344 meta_add
+= ocfs2_extend_meta_needed(&xv
->xr_list
);
2345 clusters_add
+= new_clusters
- old_clusters
;
2346 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2350 if (value_size
>= OCFS2_XATTR_ROOT_SIZE
)
2355 * Now the new value will be stored inside. So if the new
2356 * value is smaller than the size of value root or the old
2357 * value, we don't need any allocation, otherwise we have
2358 * to guess metadata allocation.
2360 if ((ocfs2_xattr_is_local(xe
) && value_size
>= xi
->value_len
) ||
2361 (!ocfs2_xattr_is_local(xe
) &&
2362 OCFS2_XATTR_ROOT_SIZE
>= xi
->value_len
))
2367 /* calculate metadata allocation. */
2368 if (di
->i_xattr_loc
) {
2369 if (!xbs
->xattr_bh
) {
2370 ret
= ocfs2_read_xattr_block(inode
,
2371 le64_to_cpu(di
->i_xattr_loc
),
2378 xb
= (struct ocfs2_xattr_block
*)bh
->b_data
;
2380 xb
= (struct ocfs2_xattr_block
*)xbs
->xattr_bh
->b_data
;
2383 * If there is already an xattr tree, good, we can calculate
2384 * like other b-trees. Otherwise we may have the chance of
2385 * create a tree, the credit calculation is borrowed from
2386 * ocfs2_calc_extend_credits with root_el = NULL. And the
2387 * new tree will be cluster based, so no meta is needed.
2389 if (le16_to_cpu(xb
->xb_flags
) & OCFS2_XATTR_INDEXED
) {
2390 struct ocfs2_extent_list
*el
=
2391 &xb
->xb_attrs
.xb_root
.xt_list
;
2392 meta_add
+= ocfs2_extend_meta_needed(el
);
2393 credits
+= ocfs2_calc_extend_credits(inode
->i_sb
,
2396 credits
+= OCFS2_SUBALLOC_ALLOC
+ 1;
2399 * This cluster will be used either for new bucket or for
2401 * If the cluster size is the same as the bucket size, one
2402 * more is needed since we may need to extend the bucket
2406 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2407 if (OCFS2_XATTR_BUCKET_SIZE
==
2408 OCFS2_SB(inode
->i_sb
)->s_clustersize
) {
2409 credits
+= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2414 credits
+= OCFS2_XATTR_BLOCK_CREATE_CREDITS
;
2418 *clusters_need
= clusters_add
;
2420 *meta_need
= meta_add
;
2422 *credits_need
= credits
;
2427 static int ocfs2_init_xattr_set_ctxt(struct inode
*inode
,
2428 struct ocfs2_dinode
*di
,
2429 struct ocfs2_xattr_info
*xi
,
2430 struct ocfs2_xattr_search
*xis
,
2431 struct ocfs2_xattr_search
*xbs
,
2432 struct ocfs2_xattr_set_ctxt
*ctxt
,
2435 int clusters_add
, meta_add
, ret
;
2436 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2438 memset(ctxt
, 0, sizeof(struct ocfs2_xattr_set_ctxt
));
2440 ocfs2_init_dealloc_ctxt(&ctxt
->dealloc
);
2442 ret
= ocfs2_calc_xattr_set_need(inode
, di
, xi
, xis
, xbs
,
2443 &clusters_add
, &meta_add
, credits
);
2449 mlog(0, "Set xattr %s, reserve meta blocks = %d, clusters = %d, "
2450 "credits = %d\n", xi
->name
, meta_add
, clusters_add
, *credits
);
2453 ret
= ocfs2_reserve_new_metadata_blocks(osb
, meta_add
,
2462 ret
= ocfs2_reserve_clusters(osb
, clusters_add
, &ctxt
->data_ac
);
2468 if (ctxt
->meta_ac
) {
2469 ocfs2_free_alloc_context(ctxt
->meta_ac
);
2470 ctxt
->meta_ac
= NULL
;
2474 * We cannot have an error and a non null ctxt->data_ac.
2481 static int __ocfs2_xattr_set_handle(struct inode
*inode
,
2482 struct ocfs2_dinode
*di
,
2483 struct ocfs2_xattr_info
*xi
,
2484 struct ocfs2_xattr_search
*xis
,
2485 struct ocfs2_xattr_search
*xbs
,
2486 struct ocfs2_xattr_set_ctxt
*ctxt
)
2488 int ret
= 0, credits
, old_found
;
2491 /* Remove existing extended attribute */
2492 if (!xis
->not_found
)
2493 ret
= ocfs2_xattr_ibody_set(inode
, xi
, xis
, ctxt
);
2494 else if (!xbs
->not_found
)
2495 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2497 /* We always try to set extended attribute into inode first*/
2498 ret
= ocfs2_xattr_ibody_set(inode
, xi
, xis
, ctxt
);
2499 if (!ret
&& !xbs
->not_found
) {
2501 * If succeed and that extended attribute existing in
2502 * external block, then we will remove it.
2507 old_found
= xis
->not_found
;
2508 xis
->not_found
= -ENODATA
;
2509 ret
= ocfs2_calc_xattr_set_need(inode
,
2517 xis
->not_found
= old_found
;
2523 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2524 ctxt
->handle
->h_buffer_credits
);
2529 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2530 } else if (ret
== -ENOSPC
) {
2531 if (di
->i_xattr_loc
&& !xbs
->xattr_bh
) {
2532 ret
= ocfs2_xattr_block_find(inode
,
2538 old_found
= xis
->not_found
;
2539 xis
->not_found
= -ENODATA
;
2540 ret
= ocfs2_calc_xattr_set_need(inode
,
2548 xis
->not_found
= old_found
;
2554 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2555 ctxt
->handle
->h_buffer_credits
);
2562 * If no space in inode, we will set extended attribute
2563 * into external block.
2565 ret
= ocfs2_xattr_block_set(inode
, xi
, xbs
, ctxt
);
2568 if (!xis
->not_found
) {
2570 * If succeed and that extended attribute
2571 * existing in inode, we will remove it.
2575 xbs
->not_found
= -ENODATA
;
2576 ret
= ocfs2_calc_xattr_set_need(inode
,
2589 ret
= ocfs2_extend_trans(ctxt
->handle
, credits
+
2590 ctxt
->handle
->h_buffer_credits
);
2595 ret
= ocfs2_xattr_ibody_set(inode
, xi
,
2602 /* Update inode ctime. */
2603 ret
= ocfs2_journal_access_di(ctxt
->handle
, inode
,
2605 OCFS2_JOURNAL_ACCESS_WRITE
);
2611 inode
->i_ctime
= CURRENT_TIME
;
2612 di
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
2613 di
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
2614 ocfs2_journal_dirty(ctxt
->handle
, xis
->inode_bh
);
2621 * This function only called duing creating inode
2622 * for init security/acl xattrs of the new inode.
2623 * All transanction credits have been reserved in mknod.
2625 int ocfs2_xattr_set_handle(handle_t
*handle
,
2626 struct inode
*inode
,
2627 struct buffer_head
*di_bh
,
2633 struct ocfs2_alloc_context
*meta_ac
,
2634 struct ocfs2_alloc_context
*data_ac
)
2636 struct ocfs2_dinode
*di
;
2639 struct ocfs2_xattr_info xi
= {
2640 .name_index
= name_index
,
2643 .value_len
= value_len
,
2646 struct ocfs2_xattr_search xis
= {
2647 .not_found
= -ENODATA
,
2650 struct ocfs2_xattr_search xbs
= {
2651 .not_found
= -ENODATA
,
2654 struct ocfs2_xattr_set_ctxt ctxt
= {
2660 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
2664 * In extreme situation, may need xattr bucket when
2665 * block size is too small. And we have already reserved
2666 * the credits for bucket in mknod.
2668 if (inode
->i_sb
->s_blocksize
== OCFS2_MIN_BLOCKSIZE
) {
2669 xbs
.bucket
= ocfs2_xattr_bucket_new(inode
);
2671 mlog_errno(-ENOMEM
);
2676 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
2677 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2679 down_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2681 ret
= ocfs2_xattr_ibody_find(inode
, name_index
, name
, &xis
);
2684 if (xis
.not_found
) {
2685 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, &xbs
);
2690 ret
= __ocfs2_xattr_set_handle(inode
, di
, &xi
, &xis
, &xbs
, &ctxt
);
2693 up_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2694 brelse(xbs
.xattr_bh
);
2695 ocfs2_xattr_bucket_free(xbs
.bucket
);
2703 * Set, replace or remove an extended attribute for this inode.
2704 * value is NULL to remove an existing extended attribute, else either
2705 * create or replace an extended attribute.
2707 int ocfs2_xattr_set(struct inode
*inode
,
2714 struct buffer_head
*di_bh
= NULL
;
2715 struct ocfs2_dinode
*di
;
2717 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2718 struct inode
*tl_inode
= osb
->osb_tl_inode
;
2719 struct ocfs2_xattr_set_ctxt ctxt
= { NULL
, NULL
, };
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 if (!ocfs2_supports_xattr(OCFS2_SB(inode
->i_sb
)))
2740 * Only xbs will be used on indexed trees. xis doesn't need a
2743 xbs
.bucket
= ocfs2_xattr_bucket_new(inode
);
2745 mlog_errno(-ENOMEM
);
2749 ret
= ocfs2_inode_lock(inode
, &di_bh
, 1);
2752 goto cleanup_nolock
;
2754 xis
.inode_bh
= xbs
.inode_bh
= di_bh
;
2755 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2757 down_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2759 * Scan inode and external block to find the same name
2760 * extended attribute and collect search infomation.
2762 ret
= ocfs2_xattr_ibody_find(inode
, name_index
, name
, &xis
);
2765 if (xis
.not_found
) {
2766 ret
= ocfs2_xattr_block_find(inode
, name_index
, name
, &xbs
);
2771 if (xis
.not_found
&& xbs
.not_found
) {
2773 if (flags
& XATTR_REPLACE
)
2780 if (flags
& XATTR_CREATE
)
2785 mutex_lock(&tl_inode
->i_mutex
);
2787 if (ocfs2_truncate_log_needs_flush(osb
)) {
2788 ret
= __ocfs2_flush_truncate_log(osb
);
2790 mutex_unlock(&tl_inode
->i_mutex
);
2795 mutex_unlock(&tl_inode
->i_mutex
);
2797 ret
= ocfs2_init_xattr_set_ctxt(inode
, di
, &xi
, &xis
,
2798 &xbs
, &ctxt
, &credits
);
2804 /* we need to update inode's ctime field, so add credit for it. */
2805 credits
+= OCFS2_INODE_UPDATE_CREDITS
;
2806 ctxt
.handle
= ocfs2_start_trans(osb
, credits
);
2807 if (IS_ERR(ctxt
.handle
)) {
2808 ret
= PTR_ERR(ctxt
.handle
);
2813 ret
= __ocfs2_xattr_set_handle(inode
, di
, &xi
, &xis
, &xbs
, &ctxt
);
2815 ocfs2_commit_trans(osb
, ctxt
.handle
);
2818 ocfs2_free_alloc_context(ctxt
.data_ac
);
2820 ocfs2_free_alloc_context(ctxt
.meta_ac
);
2821 if (ocfs2_dealloc_has_cluster(&ctxt
.dealloc
))
2822 ocfs2_schedule_truncate_log_flush(osb
, 1);
2823 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
2825 up_write(&OCFS2_I(inode
)->ip_xattr_sem
);
2826 ocfs2_inode_unlock(inode
, 1);
2829 brelse(xbs
.xattr_bh
);
2830 ocfs2_xattr_bucket_free(xbs
.bucket
);
2836 * Find the xattr extent rec which may contains name_hash.
2837 * e_cpos will be the first name hash of the xattr rec.
2838 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
2840 static int ocfs2_xattr_get_rec(struct inode
*inode
,
2845 struct ocfs2_extent_list
*el
)
2848 struct buffer_head
*eb_bh
= NULL
;
2849 struct ocfs2_extent_block
*eb
;
2850 struct ocfs2_extent_rec
*rec
= NULL
;
2853 if (el
->l_tree_depth
) {
2854 ret
= ocfs2_find_leaf(inode
, el
, name_hash
, &eb_bh
);
2860 eb
= (struct ocfs2_extent_block
*) eb_bh
->b_data
;
2863 if (el
->l_tree_depth
) {
2864 ocfs2_error(inode
->i_sb
,
2865 "Inode %lu has non zero tree depth in "
2866 "xattr tree block %llu\n", inode
->i_ino
,
2867 (unsigned long long)eb_bh
->b_blocknr
);
2873 for (i
= le16_to_cpu(el
->l_next_free_rec
) - 1; i
>= 0; i
--) {
2874 rec
= &el
->l_recs
[i
];
2876 if (le32_to_cpu(rec
->e_cpos
) <= name_hash
) {
2877 e_blkno
= le64_to_cpu(rec
->e_blkno
);
2883 ocfs2_error(inode
->i_sb
, "Inode %lu has bad extent "
2884 "record (%u, %u, 0) in xattr", inode
->i_ino
,
2885 le32_to_cpu(rec
->e_cpos
),
2886 ocfs2_rec_clusters(el
, rec
));
2891 *p_blkno
= le64_to_cpu(rec
->e_blkno
);
2892 *num_clusters
= le16_to_cpu(rec
->e_leaf_clusters
);
2894 *e_cpos
= le32_to_cpu(rec
->e_cpos
);
2900 typedef int (xattr_bucket_func
)(struct inode
*inode
,
2901 struct ocfs2_xattr_bucket
*bucket
,
2904 static int ocfs2_find_xe_in_bucket(struct inode
*inode
,
2905 struct ocfs2_xattr_bucket
*bucket
,
2912 int i
, ret
= 0, cmp
= 1, block_off
, new_offset
;
2913 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
2914 size_t name_len
= strlen(name
);
2915 struct ocfs2_xattr_entry
*xe
= NULL
;
2919 * We don't use binary search in the bucket because there
2920 * may be multiple entries with the same name hash.
2922 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
2923 xe
= &xh
->xh_entries
[i
];
2925 if (name_hash
> le32_to_cpu(xe
->xe_name_hash
))
2927 else if (name_hash
< le32_to_cpu(xe
->xe_name_hash
))
2930 cmp
= name_index
- ocfs2_xattr_get_type(xe
);
2932 cmp
= name_len
- xe
->xe_name_len
;
2936 ret
= ocfs2_xattr_bucket_get_name_value(inode
,
2947 xe_name
= bucket_block(bucket
, block_off
) + new_offset
;
2948 if (!memcmp(name
, xe_name
, name_len
)) {
2960 * Find the specified xattr entry in a series of buckets.
2961 * This series start from p_blkno and last for num_clusters.
2962 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
2963 * the num of the valid buckets.
2965 * Return the buffer_head this xattr should reside in. And if the xattr's
2966 * hash is in the gap of 2 buckets, return the lower bucket.
2968 static int ocfs2_xattr_bucket_find(struct inode
*inode
,
2975 struct ocfs2_xattr_search
*xs
)
2978 struct ocfs2_xattr_header
*xh
= NULL
;
2979 struct ocfs2_xattr_entry
*xe
= NULL
;
2981 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
2982 int low_bucket
= 0, bucket
, high_bucket
;
2983 struct ocfs2_xattr_bucket
*search
;
2985 u64 blkno
, lower_blkno
= 0;
2987 search
= ocfs2_xattr_bucket_new(inode
);
2994 ret
= ocfs2_read_xattr_bucket(search
, p_blkno
);
3000 xh
= bucket_xh(search
);
3001 high_bucket
= le16_to_cpu(xh
->xh_num_buckets
) - 1;
3002 while (low_bucket
<= high_bucket
) {
3003 ocfs2_xattr_bucket_relse(search
);
3005 bucket
= (low_bucket
+ high_bucket
) / 2;
3006 blkno
= p_blkno
+ bucket
* blk_per_bucket
;
3007 ret
= ocfs2_read_xattr_bucket(search
, blkno
);
3013 xh
= bucket_xh(search
);
3014 xe
= &xh
->xh_entries
[0];
3015 if (name_hash
< le32_to_cpu(xe
->xe_name_hash
)) {
3016 high_bucket
= bucket
- 1;
3021 * Check whether the hash of the last entry in our
3022 * bucket is larger than the search one. for an empty
3023 * bucket, the last one is also the first one.
3026 xe
= &xh
->xh_entries
[le16_to_cpu(xh
->xh_count
) - 1];
3028 last_hash
= le32_to_cpu(xe
->xe_name_hash
);
3030 /* record lower_blkno which may be the insert place. */
3031 lower_blkno
= blkno
;
3033 if (name_hash
> le32_to_cpu(xe
->xe_name_hash
)) {
3034 low_bucket
= bucket
+ 1;
3038 /* the searched xattr should reside in this bucket if exists. */
3039 ret
= ocfs2_find_xe_in_bucket(inode
, search
,
3040 name_index
, name
, name_hash
,
3050 * Record the bucket we have found.
3051 * When the xattr's hash value is in the gap of 2 buckets, we will
3052 * always set it to the previous bucket.
3055 lower_blkno
= p_blkno
;
3057 /* This should be in cache - we just read it during the search */
3058 ret
= ocfs2_read_xattr_bucket(xs
->bucket
, lower_blkno
);
3064 xs
->header
= bucket_xh(xs
->bucket
);
3065 xs
->base
= bucket_block(xs
->bucket
, 0);
3066 xs
->end
= xs
->base
+ inode
->i_sb
->s_blocksize
;
3069 xs
->here
= &xs
->header
->xh_entries
[index
];
3070 mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name
,
3071 (unsigned long long)bucket_blkno(xs
->bucket
), index
);
3076 ocfs2_xattr_bucket_free(search
);
3080 static int ocfs2_xattr_index_block_find(struct inode
*inode
,
3081 struct buffer_head
*root_bh
,
3084 struct ocfs2_xattr_search
*xs
)
3087 struct ocfs2_xattr_block
*xb
=
3088 (struct ocfs2_xattr_block
*)root_bh
->b_data
;
3089 struct ocfs2_xattr_tree_root
*xb_root
= &xb
->xb_attrs
.xb_root
;
3090 struct ocfs2_extent_list
*el
= &xb_root
->xt_list
;
3092 u32 first_hash
, num_clusters
= 0;
3093 u32 name_hash
= ocfs2_xattr_name_hash(inode
, name
, strlen(name
));
3095 if (le16_to_cpu(el
->l_next_free_rec
) == 0)
3098 mlog(0, "find xattr %s, hash = %u, index = %d in xattr tree\n",
3099 name
, name_hash
, name_index
);
3101 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
, &first_hash
,
3108 BUG_ON(p_blkno
== 0 || num_clusters
== 0 || first_hash
> name_hash
);
3110 mlog(0, "find xattr extent rec %u clusters from %llu, the first hash "
3111 "in the rec is %u\n", num_clusters
, (unsigned long long)p_blkno
,
3114 ret
= ocfs2_xattr_bucket_find(inode
, name_index
, name
, name_hash
,
3115 p_blkno
, first_hash
, num_clusters
, xs
);
3121 static int ocfs2_iterate_xattr_buckets(struct inode
*inode
,
3124 xattr_bucket_func
*func
,
3128 u32 bpc
= ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode
->i_sb
));
3129 u32 num_buckets
= clusters
* bpc
;
3130 struct ocfs2_xattr_bucket
*bucket
;
3132 bucket
= ocfs2_xattr_bucket_new(inode
);
3134 mlog_errno(-ENOMEM
);
3138 mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
3139 clusters
, (unsigned long long)blkno
);
3141 for (i
= 0; i
< num_buckets
; i
++, blkno
+= bucket
->bu_blocks
) {
3142 ret
= ocfs2_read_xattr_bucket(bucket
, blkno
);
3149 * The real bucket num in this series of blocks is stored
3150 * in the 1st bucket.
3153 num_buckets
= le16_to_cpu(bucket_xh(bucket
)->xh_num_buckets
);
3155 mlog(0, "iterating xattr bucket %llu, first hash %u\n",
3156 (unsigned long long)blkno
,
3157 le32_to_cpu(bucket_xh(bucket
)->xh_entries
[0].xe_name_hash
));
3159 ret
= func(inode
, bucket
, para
);
3160 if (ret
&& ret
!= -ERANGE
)
3162 /* Fall through to bucket_relse() */
3165 ocfs2_xattr_bucket_relse(bucket
);
3170 ocfs2_xattr_bucket_free(bucket
);
3174 struct ocfs2_xattr_tree_list
{
3180 static int ocfs2_xattr_bucket_get_name_value(struct inode
*inode
,
3181 struct ocfs2_xattr_header
*xh
,
3188 if (index
< 0 || index
>= le16_to_cpu(xh
->xh_count
))
3191 name_offset
= le16_to_cpu(xh
->xh_entries
[index
].xe_name_offset
);
3193 *block_off
= name_offset
>> inode
->i_sb
->s_blocksize_bits
;
3194 *new_offset
= name_offset
% inode
->i_sb
->s_blocksize
;
3199 static int ocfs2_list_xattr_bucket(struct inode
*inode
,
3200 struct ocfs2_xattr_bucket
*bucket
,
3204 struct ocfs2_xattr_tree_list
*xl
= (struct ocfs2_xattr_tree_list
*)para
;
3205 int i
, block_off
, new_offset
;
3206 const char *prefix
, *name
;
3208 for (i
= 0 ; i
< le16_to_cpu(bucket_xh(bucket
)->xh_count
); i
++) {
3209 struct ocfs2_xattr_entry
*entry
= &bucket_xh(bucket
)->xh_entries
[i
];
3210 type
= ocfs2_xattr_get_type(entry
);
3211 prefix
= ocfs2_xattr_prefix(type
);
3214 ret
= ocfs2_xattr_bucket_get_name_value(inode
,
3222 name
= (const char *)bucket_block(bucket
, block_off
) +
3224 ret
= ocfs2_xattr_list_entry(xl
->buffer
,
3228 entry
->xe_name_len
);
3237 static int ocfs2_xattr_tree_list_index_block(struct inode
*inode
,
3238 struct ocfs2_xattr_tree_root
*xt
,
3242 struct ocfs2_extent_list
*el
= &xt
->xt_list
;
3244 u32 name_hash
= UINT_MAX
, e_cpos
= 0, num_clusters
= 0;
3246 struct ocfs2_xattr_tree_list xl
= {
3248 .buffer_size
= buffer_size
,
3252 if (le16_to_cpu(el
->l_next_free_rec
) == 0)
3255 while (name_hash
> 0) {
3256 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
,
3257 &e_cpos
, &num_clusters
, el
);
3263 ret
= ocfs2_iterate_xattr_buckets(inode
, p_blkno
, num_clusters
,
3264 ocfs2_list_xattr_bucket
,
3275 name_hash
= e_cpos
- 1;
3283 static int cmp_xe(const void *a
, const void *b
)
3285 const struct ocfs2_xattr_entry
*l
= a
, *r
= b
;
3286 u32 l_hash
= le32_to_cpu(l
->xe_name_hash
);
3287 u32 r_hash
= le32_to_cpu(r
->xe_name_hash
);
3289 if (l_hash
> r_hash
)
3291 if (l_hash
< r_hash
)
3296 static void swap_xe(void *a
, void *b
, int size
)
3298 struct ocfs2_xattr_entry
*l
= a
, *r
= b
, tmp
;
3301 memcpy(l
, r
, sizeof(struct ocfs2_xattr_entry
));
3302 memcpy(r
, &tmp
, sizeof(struct ocfs2_xattr_entry
));
3306 * When the ocfs2_xattr_block is filled up, new bucket will be created
3307 * and all the xattr entries will be moved to the new bucket.
3308 * The header goes at the start of the bucket, and the names+values are
3309 * filled from the end. This is why *target starts as the last buffer.
3310 * Note: we need to sort the entries since they are not saved in order
3311 * in the ocfs2_xattr_block.
3313 static void ocfs2_cp_xattr_block_to_bucket(struct inode
*inode
,
3314 struct buffer_head
*xb_bh
,
3315 struct ocfs2_xattr_bucket
*bucket
)
3317 int i
, blocksize
= inode
->i_sb
->s_blocksize
;
3318 int blks
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
3319 u16 offset
, size
, off_change
;
3320 struct ocfs2_xattr_entry
*xe
;
3321 struct ocfs2_xattr_block
*xb
=
3322 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
3323 struct ocfs2_xattr_header
*xb_xh
= &xb
->xb_attrs
.xb_header
;
3324 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
3325 u16 count
= le16_to_cpu(xb_xh
->xh_count
);
3326 char *src
= xb_bh
->b_data
;
3327 char *target
= bucket_block(bucket
, blks
- 1);
3329 mlog(0, "cp xattr from block %llu to bucket %llu\n",
3330 (unsigned long long)xb_bh
->b_blocknr
,
3331 (unsigned long long)bucket_blkno(bucket
));
3333 for (i
= 0; i
< blks
; i
++)
3334 memset(bucket_block(bucket
, i
), 0, blocksize
);
3337 * Since the xe_name_offset is based on ocfs2_xattr_header,
3338 * there is a offset change corresponding to the change of
3339 * ocfs2_xattr_header's position.
3341 off_change
= offsetof(struct ocfs2_xattr_block
, xb_attrs
.xb_header
);
3342 xe
= &xb_xh
->xh_entries
[count
- 1];
3343 offset
= le16_to_cpu(xe
->xe_name_offset
) + off_change
;
3344 size
= blocksize
- offset
;
3346 /* copy all the names and values. */
3347 memcpy(target
+ offset
, src
+ offset
, size
);
3349 /* Init new header now. */
3350 xh
->xh_count
= xb_xh
->xh_count
;
3351 xh
->xh_num_buckets
= cpu_to_le16(1);
3352 xh
->xh_name_value_len
= cpu_to_le16(size
);
3353 xh
->xh_free_start
= cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
- size
);
3355 /* copy all the entries. */
3356 target
= bucket_block(bucket
, 0);
3357 offset
= offsetof(struct ocfs2_xattr_header
, xh_entries
);
3358 size
= count
* sizeof(struct ocfs2_xattr_entry
);
3359 memcpy(target
+ offset
, (char *)xb_xh
+ offset
, size
);
3361 /* Change the xe offset for all the xe because of the move. */
3362 off_change
= OCFS2_XATTR_BUCKET_SIZE
- blocksize
+
3363 offsetof(struct ocfs2_xattr_block
, xb_attrs
.xb_header
);
3364 for (i
= 0; i
< count
; i
++)
3365 le16_add_cpu(&xh
->xh_entries
[i
].xe_name_offset
, off_change
);
3367 mlog(0, "copy entry: start = %u, size = %u, offset_change = %u\n",
3368 offset
, size
, off_change
);
3370 sort(target
+ offset
, count
, sizeof(struct ocfs2_xattr_entry
),
3375 * After we move xattr from block to index btree, we have to
3376 * update ocfs2_xattr_search to the new xe and base.
3378 * When the entry is in xattr block, xattr_bh indicates the storage place.
3379 * While if the entry is in index b-tree, "bucket" indicates the
3380 * real place of the xattr.
3382 static void ocfs2_xattr_update_xattr_search(struct inode
*inode
,
3383 struct ocfs2_xattr_search
*xs
,
3384 struct buffer_head
*old_bh
)
3386 char *buf
= old_bh
->b_data
;
3387 struct ocfs2_xattr_block
*old_xb
= (struct ocfs2_xattr_block
*)buf
;
3388 struct ocfs2_xattr_header
*old_xh
= &old_xb
->xb_attrs
.xb_header
;
3391 xs
->header
= bucket_xh(xs
->bucket
);
3392 xs
->base
= bucket_block(xs
->bucket
, 0);
3393 xs
->end
= xs
->base
+ inode
->i_sb
->s_blocksize
;
3398 i
= xs
->here
- old_xh
->xh_entries
;
3399 xs
->here
= &xs
->header
->xh_entries
[i
];
3402 static int ocfs2_xattr_create_index_block(struct inode
*inode
,
3403 struct ocfs2_xattr_search
*xs
,
3404 struct ocfs2_xattr_set_ctxt
*ctxt
)
3409 handle_t
*handle
= ctxt
->handle
;
3410 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
3411 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
3412 struct buffer_head
*xb_bh
= xs
->xattr_bh
;
3413 struct ocfs2_xattr_block
*xb
=
3414 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
3415 struct ocfs2_xattr_tree_root
*xr
;
3416 u16 xb_flags
= le16_to_cpu(xb
->xb_flags
);
3418 mlog(0, "create xattr index block for %llu\n",
3419 (unsigned long long)xb_bh
->b_blocknr
);
3421 BUG_ON(xb_flags
& OCFS2_XATTR_INDEXED
);
3422 BUG_ON(!xs
->bucket
);
3426 * We can use this lock for now, and maybe move to a dedicated mutex
3427 * if performance becomes a problem later.
3429 down_write(&oi
->ip_alloc_sem
);
3431 ret
= ocfs2_journal_access_xb(handle
, inode
, xb_bh
,
3432 OCFS2_JOURNAL_ACCESS_WRITE
);
3438 ret
= __ocfs2_claim_clusters(osb
, handle
, ctxt
->data_ac
,
3439 1, 1, &bit_off
, &len
);
3446 * The bucket may spread in many blocks, and
3447 * we will only touch the 1st block and the last block
3448 * in the whole bucket(one for entry and one for data).
3450 blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, bit_off
);
3452 mlog(0, "allocate 1 cluster from %llu to xattr block\n",
3453 (unsigned long long)blkno
);
3455 ret
= ocfs2_init_xattr_bucket(xs
->bucket
, blkno
);
3461 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
3462 OCFS2_JOURNAL_ACCESS_CREATE
);
3468 ocfs2_cp_xattr_block_to_bucket(inode
, xb_bh
, xs
->bucket
);
3469 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
3471 ocfs2_xattr_update_xattr_search(inode
, xs
, xb_bh
);
3473 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
3474 memset(&xb
->xb_attrs
, 0, inode
->i_sb
->s_blocksize
-
3475 offsetof(struct ocfs2_xattr_block
, xb_attrs
));
3477 xr
= &xb
->xb_attrs
.xb_root
;
3478 xr
->xt_clusters
= cpu_to_le32(1);
3479 xr
->xt_last_eb_blk
= 0;
3480 xr
->xt_list
.l_tree_depth
= 0;
3481 xr
->xt_list
.l_count
= cpu_to_le16(ocfs2_xattr_recs_per_xb(inode
->i_sb
));
3482 xr
->xt_list
.l_next_free_rec
= cpu_to_le16(1);
3484 xr
->xt_list
.l_recs
[0].e_cpos
= 0;
3485 xr
->xt_list
.l_recs
[0].e_blkno
= cpu_to_le64(blkno
);
3486 xr
->xt_list
.l_recs
[0].e_leaf_clusters
= cpu_to_le16(1);
3488 xb
->xb_flags
= cpu_to_le16(xb_flags
| OCFS2_XATTR_INDEXED
);
3490 ocfs2_journal_dirty(handle
, xb_bh
);
3493 up_write(&oi
->ip_alloc_sem
);
3498 static int cmp_xe_offset(const void *a
, const void *b
)
3500 const struct ocfs2_xattr_entry
*l
= a
, *r
= b
;
3501 u32 l_name_offset
= le16_to_cpu(l
->xe_name_offset
);
3502 u32 r_name_offset
= le16_to_cpu(r
->xe_name_offset
);
3504 if (l_name_offset
< r_name_offset
)
3506 if (l_name_offset
> r_name_offset
)
3512 * defrag a xattr bucket if we find that the bucket has some
3513 * holes beteen name/value pairs.
3514 * We will move all the name/value pairs to the end of the bucket
3515 * so that we can spare some space for insertion.
3517 static int ocfs2_defrag_xattr_bucket(struct inode
*inode
,
3519 struct ocfs2_xattr_bucket
*bucket
)
3522 size_t end
, offset
, len
, value_len
;
3523 struct ocfs2_xattr_header
*xh
;
3524 char *entries
, *buf
, *bucket_buf
= NULL
;
3525 u64 blkno
= bucket_blkno(bucket
);
3527 size_t blocksize
= inode
->i_sb
->s_blocksize
;
3528 struct ocfs2_xattr_entry
*xe
;
3531 * In order to make the operation more efficient and generic,
3532 * we copy all the blocks into a contiguous memory and do the
3533 * defragment there, so if anything is error, we will not touch
3536 bucket_buf
= kmalloc(OCFS2_XATTR_BUCKET_SIZE
, GFP_NOFS
);
3543 for (i
= 0; i
< bucket
->bu_blocks
; i
++, buf
+= blocksize
)
3544 memcpy(buf
, bucket_block(bucket
, i
), blocksize
);
3546 ret
= ocfs2_xattr_bucket_journal_access(handle
, bucket
,
3547 OCFS2_JOURNAL_ACCESS_WRITE
);
3553 xh
= (struct ocfs2_xattr_header
*)bucket_buf
;
3554 entries
= (char *)xh
->xh_entries
;
3555 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
3557 mlog(0, "adjust xattr bucket in %llu, count = %u, "
3558 "xh_free_start = %u, xh_name_value_len = %u.\n",
3559 (unsigned long long)blkno
, le16_to_cpu(xh
->xh_count
),
3560 xh_free_start
, le16_to_cpu(xh
->xh_name_value_len
));
3563 * sort all the entries by their offset.
3564 * the largest will be the first, so that we can
3565 * move them to the end one by one.
3567 sort(entries
, le16_to_cpu(xh
->xh_count
),
3568 sizeof(struct ocfs2_xattr_entry
),
3569 cmp_xe_offset
, swap_xe
);
3571 /* Move all name/values to the end of the bucket. */
3572 xe
= xh
->xh_entries
;
3573 end
= OCFS2_XATTR_BUCKET_SIZE
;
3574 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++, xe
++) {
3575 offset
= le16_to_cpu(xe
->xe_name_offset
);
3576 if (ocfs2_xattr_is_local(xe
))
3577 value_len
= OCFS2_XATTR_SIZE(
3578 le64_to_cpu(xe
->xe_value_size
));
3580 value_len
= OCFS2_XATTR_ROOT_SIZE
;
3581 len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
) + value_len
;
3584 * We must make sure that the name/value pair
3585 * exist in the same block. So adjust end to
3586 * the previous block end if needed.
3588 if (((end
- len
) / blocksize
!=
3589 (end
- 1) / blocksize
))
3590 end
= end
- end
% blocksize
;
3592 if (end
> offset
+ len
) {
3593 memmove(bucket_buf
+ end
- len
,
3594 bucket_buf
+ offset
, len
);
3595 xe
->xe_name_offset
= cpu_to_le16(end
- len
);
3598 mlog_bug_on_msg(end
< offset
+ len
, "Defrag check failed for "
3599 "bucket %llu\n", (unsigned long long)blkno
);
3604 mlog_bug_on_msg(xh_free_start
> end
, "Defrag check failed for "
3605 "bucket %llu\n", (unsigned long long)blkno
);
3607 if (xh_free_start
== end
)
3610 memset(bucket_buf
+ xh_free_start
, 0, end
- xh_free_start
);
3611 xh
->xh_free_start
= cpu_to_le16(end
);
3613 /* sort the entries by their name_hash. */
3614 sort(entries
, le16_to_cpu(xh
->xh_count
),
3615 sizeof(struct ocfs2_xattr_entry
),
3619 for (i
= 0; i
< bucket
->bu_blocks
; i
++, buf
+= blocksize
)
3620 memcpy(bucket_block(bucket
, i
), buf
, blocksize
);
3621 ocfs2_xattr_bucket_journal_dirty(handle
, bucket
);
3629 * prev_blkno points to the start of an existing extent. new_blkno
3630 * points to a newly allocated extent. Because we know each of our
3631 * clusters contains more than bucket, we can easily split one cluster
3632 * at a bucket boundary. So we take the last cluster of the existing
3633 * extent and split it down the middle. We move the last half of the
3634 * buckets in the last cluster of the existing extent over to the new
3637 * first_bh is the buffer at prev_blkno so we can update the existing
3638 * extent's bucket count. header_bh is the bucket were we were hoping
3639 * to insert our xattr. If the bucket move places the target in the new
3640 * extent, we'll update first_bh and header_bh after modifying the old
3643 * first_hash will be set as the 1st xe's name_hash in the new extent.
3645 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode
*inode
,
3647 struct ocfs2_xattr_bucket
*first
,
3648 struct ocfs2_xattr_bucket
*target
,
3654 struct super_block
*sb
= inode
->i_sb
;
3655 int blks_per_bucket
= ocfs2_blocks_per_xattr_bucket(sb
);
3656 int num_buckets
= ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb
));
3657 int to_move
= num_buckets
/ 2;
3659 u64 last_cluster_blkno
= bucket_blkno(first
) +
3660 ((num_clusters
- 1) * ocfs2_clusters_to_blocks(sb
, 1));
3662 BUG_ON(le16_to_cpu(bucket_xh(first
)->xh_num_buckets
) < num_buckets
);
3663 BUG_ON(OCFS2_XATTR_BUCKET_SIZE
== OCFS2_SB(sb
)->s_clustersize
);
3665 mlog(0, "move half of xattrs in cluster %llu to %llu\n",
3666 (unsigned long long)last_cluster_blkno
, (unsigned long long)new_blkno
);
3668 ret
= ocfs2_mv_xattr_buckets(inode
, handle
, bucket_blkno(first
),
3669 last_cluster_blkno
, new_blkno
,
3670 to_move
, first_hash
);
3676 /* This is the first bucket that got moved */
3677 src_blkno
= last_cluster_blkno
+ (to_move
* blks_per_bucket
);
3680 * If the target bucket was part of the moved buckets, we need to
3681 * update first and target.
3683 if (bucket_blkno(target
) >= src_blkno
) {
3684 /* Find the block for the new target bucket */
3685 src_blkno
= new_blkno
+
3686 (bucket_blkno(target
) - src_blkno
);
3688 ocfs2_xattr_bucket_relse(first
);
3689 ocfs2_xattr_bucket_relse(target
);
3692 * These shouldn't fail - the buffers are in the
3693 * journal from ocfs2_cp_xattr_bucket().
3695 ret
= ocfs2_read_xattr_bucket(first
, new_blkno
);
3700 ret
= ocfs2_read_xattr_bucket(target
, src_blkno
);
3711 * Find the suitable pos when we divide a bucket into 2.
3712 * We have to make sure the xattrs with the same hash value exist
3713 * in the same bucket.
3715 * If this ocfs2_xattr_header covers more than one hash value, find a
3716 * place where the hash value changes. Try to find the most even split.
3717 * The most common case is that all entries have different hash values,
3718 * and the first check we make will find a place to split.
3720 static int ocfs2_xattr_find_divide_pos(struct ocfs2_xattr_header
*xh
)
3722 struct ocfs2_xattr_entry
*entries
= xh
->xh_entries
;
3723 int count
= le16_to_cpu(xh
->xh_count
);
3724 int delta
, middle
= count
/ 2;
3727 * We start at the middle. Each step gets farther away in both
3728 * directions. We therefore hit the change in hash value
3729 * nearest to the middle. Note that this loop does not execute for
3732 for (delta
= 0; delta
< middle
; delta
++) {
3733 /* Let's check delta earlier than middle */
3734 if (cmp_xe(&entries
[middle
- delta
- 1],
3735 &entries
[middle
- delta
]))
3736 return middle
- delta
;
3738 /* For even counts, don't walk off the end */
3739 if ((middle
+ delta
+ 1) == count
)
3742 /* Now try delta past middle */
3743 if (cmp_xe(&entries
[middle
+ delta
],
3744 &entries
[middle
+ delta
+ 1]))
3745 return middle
+ delta
+ 1;
3748 /* Every entry had the same hash */
3753 * Move some xattrs in old bucket(blk) to new bucket(new_blk).
3754 * first_hash will record the 1st hash of the new bucket.
3756 * Normally half of the xattrs will be moved. But we have to make
3757 * sure that the xattrs with the same hash value are stored in the
3758 * same bucket. If all the xattrs in this bucket have the same hash
3759 * value, the new bucket will be initialized as an empty one and the
3760 * first_hash will be initialized as (hash_value+1).
3762 static int ocfs2_divide_xattr_bucket(struct inode
*inode
,
3767 int new_bucket_head
)
3770 int count
, start
, len
, name_value_len
= 0, xe_len
, name_offset
= 0;
3771 struct ocfs2_xattr_bucket
*s_bucket
= NULL
, *t_bucket
= NULL
;
3772 struct ocfs2_xattr_header
*xh
;
3773 struct ocfs2_xattr_entry
*xe
;
3774 int blocksize
= inode
->i_sb
->s_blocksize
;
3776 mlog(0, "move some of xattrs from bucket %llu to %llu\n",
3777 (unsigned long long)blk
, (unsigned long long)new_blk
);
3779 s_bucket
= ocfs2_xattr_bucket_new(inode
);
3780 t_bucket
= ocfs2_xattr_bucket_new(inode
);
3781 if (!s_bucket
|| !t_bucket
) {
3787 ret
= ocfs2_read_xattr_bucket(s_bucket
, blk
);
3793 ret
= ocfs2_xattr_bucket_journal_access(handle
, s_bucket
,
3794 OCFS2_JOURNAL_ACCESS_WRITE
);
3801 * Even if !new_bucket_head, we're overwriting t_bucket. Thus,
3802 * there's no need to read it.
3804 ret
= ocfs2_init_xattr_bucket(t_bucket
, new_blk
);
3811 * Hey, if we're overwriting t_bucket, what difference does
3812 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
3813 * same part of ocfs2_cp_xattr_bucket().
3815 ret
= ocfs2_xattr_bucket_journal_access(handle
, t_bucket
,
3817 OCFS2_JOURNAL_ACCESS_CREATE
:
3818 OCFS2_JOURNAL_ACCESS_WRITE
);
3824 xh
= bucket_xh(s_bucket
);
3825 count
= le16_to_cpu(xh
->xh_count
);
3826 start
= ocfs2_xattr_find_divide_pos(xh
);
3828 if (start
== count
) {
3829 xe
= &xh
->xh_entries
[start
-1];
3832 * initialized a new empty bucket here.
3833 * The hash value is set as one larger than
3834 * that of the last entry in the previous bucket.
3836 for (i
= 0; i
< t_bucket
->bu_blocks
; i
++)
3837 memset(bucket_block(t_bucket
, i
), 0, blocksize
);
3839 xh
= bucket_xh(t_bucket
);
3840 xh
->xh_free_start
= cpu_to_le16(blocksize
);
3841 xh
->xh_entries
[0].xe_name_hash
= xe
->xe_name_hash
;
3842 le32_add_cpu(&xh
->xh_entries
[0].xe_name_hash
, 1);
3844 goto set_num_buckets
;
3847 /* copy the whole bucket to the new first. */
3848 ocfs2_xattr_bucket_copy_data(t_bucket
, s_bucket
);
3850 /* update the new bucket. */
3851 xh
= bucket_xh(t_bucket
);
3854 * Calculate the total name/value len and xh_free_start for
3855 * the old bucket first.
3857 name_offset
= OCFS2_XATTR_BUCKET_SIZE
;
3859 for (i
= 0; i
< start
; i
++) {
3860 xe
= &xh
->xh_entries
[i
];
3861 xe_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
3862 if (ocfs2_xattr_is_local(xe
))
3864 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
3866 xe_len
+= OCFS2_XATTR_ROOT_SIZE
;
3867 name_value_len
+= xe_len
;
3868 if (le16_to_cpu(xe
->xe_name_offset
) < name_offset
)
3869 name_offset
= le16_to_cpu(xe
->xe_name_offset
);
3873 * Now begin the modification to the new bucket.
3875 * In the new bucket, We just move the xattr entry to the beginning
3876 * and don't touch the name/value. So there will be some holes in the
3877 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
3880 xe
= &xh
->xh_entries
[start
];
3881 len
= sizeof(struct ocfs2_xattr_entry
) * (count
- start
);
3882 mlog(0, "mv xattr entry len %d from %d to %d\n", len
,
3883 (int)((char *)xe
- (char *)xh
),
3884 (int)((char *)xh
->xh_entries
- (char *)xh
));
3885 memmove((char *)xh
->xh_entries
, (char *)xe
, len
);
3886 xe
= &xh
->xh_entries
[count
- start
];
3887 len
= sizeof(struct ocfs2_xattr_entry
) * start
;
3888 memset((char *)xe
, 0, len
);
3890 le16_add_cpu(&xh
->xh_count
, -start
);
3891 le16_add_cpu(&xh
->xh_name_value_len
, -name_value_len
);
3893 /* Calculate xh_free_start for the new bucket. */
3894 xh
->xh_free_start
= cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
);
3895 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
3896 xe
= &xh
->xh_entries
[i
];
3897 xe_len
= OCFS2_XATTR_SIZE(xe
->xe_name_len
);
3898 if (ocfs2_xattr_is_local(xe
))
3900 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
3902 xe_len
+= OCFS2_XATTR_ROOT_SIZE
;
3903 if (le16_to_cpu(xe
->xe_name_offset
) <
3904 le16_to_cpu(xh
->xh_free_start
))
3905 xh
->xh_free_start
= xe
->xe_name_offset
;
3909 /* set xh->xh_num_buckets for the new xh. */
3910 if (new_bucket_head
)
3911 xh
->xh_num_buckets
= cpu_to_le16(1);
3913 xh
->xh_num_buckets
= 0;
3915 ocfs2_xattr_bucket_journal_dirty(handle
, t_bucket
);
3917 /* store the first_hash of the new bucket. */
3919 *first_hash
= le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
);
3922 * Now only update the 1st block of the old bucket. If we
3923 * just added a new empty bucket, there is no need to modify
3929 xh
= bucket_xh(s_bucket
);
3930 memset(&xh
->xh_entries
[start
], 0,
3931 sizeof(struct ocfs2_xattr_entry
) * (count
- start
));
3932 xh
->xh_count
= cpu_to_le16(start
);
3933 xh
->xh_free_start
= cpu_to_le16(name_offset
);
3934 xh
->xh_name_value_len
= cpu_to_le16(name_value_len
);
3936 ocfs2_xattr_bucket_journal_dirty(handle
, s_bucket
);
3939 ocfs2_xattr_bucket_free(s_bucket
);
3940 ocfs2_xattr_bucket_free(t_bucket
);
3946 * Copy xattr from one bucket to another bucket.
3948 * The caller must make sure that the journal transaction
3949 * has enough space for journaling.
3951 static int ocfs2_cp_xattr_bucket(struct inode
*inode
,
3958 struct ocfs2_xattr_bucket
*s_bucket
= NULL
, *t_bucket
= NULL
;
3960 BUG_ON(s_blkno
== t_blkno
);
3962 mlog(0, "cp bucket %llu to %llu, target is %d\n",
3963 (unsigned long long)s_blkno
, (unsigned long long)t_blkno
,
3966 s_bucket
= ocfs2_xattr_bucket_new(inode
);
3967 t_bucket
= ocfs2_xattr_bucket_new(inode
);
3968 if (!s_bucket
|| !t_bucket
) {
3974 ret
= ocfs2_read_xattr_bucket(s_bucket
, s_blkno
);
3979 * Even if !t_is_new, we're overwriting t_bucket. Thus,
3980 * there's no need to read it.
3982 ret
= ocfs2_init_xattr_bucket(t_bucket
, t_blkno
);
3987 * Hey, if we're overwriting t_bucket, what difference does
3988 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
3989 * cluster to fill, we came here from
3990 * ocfs2_mv_xattr_buckets(), and it is really new -
3991 * ACCESS_CREATE is required. But we also might have moved data
3992 * out of t_bucket before extending back into it.
3993 * ocfs2_add_new_xattr_bucket() can do this - its call to
3994 * ocfs2_add_new_xattr_cluster() may have created a new extent
3995 * and copied out the end of the old extent. Then it re-extends
3996 * the old extent back to create space for new xattrs. That's
3997 * how we get here, and the bucket isn't really new.
3999 ret
= ocfs2_xattr_bucket_journal_access(handle
, t_bucket
,
4001 OCFS2_JOURNAL_ACCESS_CREATE
:
4002 OCFS2_JOURNAL_ACCESS_WRITE
);
4006 ocfs2_xattr_bucket_copy_data(t_bucket
, s_bucket
);
4007 ocfs2_xattr_bucket_journal_dirty(handle
, t_bucket
);
4010 ocfs2_xattr_bucket_free(t_bucket
);
4011 ocfs2_xattr_bucket_free(s_bucket
);
4017 * src_blk points to the start of an existing extent. last_blk points to
4018 * last cluster in that extent. to_blk points to a newly allocated
4019 * extent. We copy the buckets from the cluster at last_blk to the new
4020 * extent. If start_bucket is non-zero, we skip that many buckets before
4021 * we start copying. The new extent's xh_num_buckets gets set to the
4022 * number of buckets we copied. The old extent's xh_num_buckets shrinks
4023 * by the same amount.
4025 static int ocfs2_mv_xattr_buckets(struct inode
*inode
, handle_t
*handle
,
4026 u64 src_blk
, u64 last_blk
, u64 to_blk
,
4027 unsigned int start_bucket
,
4030 int i
, ret
, credits
;
4031 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4032 int blks_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4033 int num_buckets
= ocfs2_xattr_buckets_per_cluster(osb
);
4034 struct ocfs2_xattr_bucket
*old_first
, *new_first
;
4036 mlog(0, "mv xattrs from cluster %llu to %llu\n",
4037 (unsigned long long)last_blk
, (unsigned long long)to_blk
);
4039 BUG_ON(start_bucket
>= num_buckets
);
4041 num_buckets
-= start_bucket
;
4042 last_blk
+= (start_bucket
* blks_per_bucket
);
4045 /* The first bucket of the original extent */
4046 old_first
= ocfs2_xattr_bucket_new(inode
);
4047 /* The first bucket of the new extent */
4048 new_first
= ocfs2_xattr_bucket_new(inode
);
4049 if (!old_first
|| !new_first
) {
4055 ret
= ocfs2_read_xattr_bucket(old_first
, src_blk
);
4062 * We need to update the first bucket of the old extent and all
4063 * the buckets going to the new extent.
4065 credits
= ((num_buckets
+ 1) * blks_per_bucket
) +
4066 handle
->h_buffer_credits
;
4067 ret
= ocfs2_extend_trans(handle
, credits
);
4073 ret
= ocfs2_xattr_bucket_journal_access(handle
, old_first
,
4074 OCFS2_JOURNAL_ACCESS_WRITE
);
4080 for (i
= 0; i
< num_buckets
; i
++) {
4081 ret
= ocfs2_cp_xattr_bucket(inode
, handle
,
4082 last_blk
+ (i
* blks_per_bucket
),
4083 to_blk
+ (i
* blks_per_bucket
),
4092 * Get the new bucket ready before we dirty anything
4093 * (This actually shouldn't fail, because we already dirtied
4094 * it once in ocfs2_cp_xattr_bucket()).
4096 ret
= ocfs2_read_xattr_bucket(new_first
, to_blk
);
4101 ret
= ocfs2_xattr_bucket_journal_access(handle
, new_first
,
4102 OCFS2_JOURNAL_ACCESS_WRITE
);
4108 /* Now update the headers */
4109 le16_add_cpu(&bucket_xh(old_first
)->xh_num_buckets
, -num_buckets
);
4110 ocfs2_xattr_bucket_journal_dirty(handle
, old_first
);
4112 bucket_xh(new_first
)->xh_num_buckets
= cpu_to_le16(num_buckets
);
4113 ocfs2_xattr_bucket_journal_dirty(handle
, new_first
);
4116 *first_hash
= le32_to_cpu(bucket_xh(new_first
)->xh_entries
[0].xe_name_hash
);
4119 ocfs2_xattr_bucket_free(new_first
);
4120 ocfs2_xattr_bucket_free(old_first
);
4125 * Move some xattrs in this cluster to the new cluster.
4126 * This function should only be called when bucket size == cluster size.
4127 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
4129 static int ocfs2_divide_xattr_cluster(struct inode
*inode
,
4135 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4136 int ret
, credits
= 2 * blk_per_bucket
+ handle
->h_buffer_credits
;
4138 BUG_ON(OCFS2_XATTR_BUCKET_SIZE
< OCFS2_SB(inode
->i_sb
)->s_clustersize
);
4140 ret
= ocfs2_extend_trans(handle
, credits
);
4146 /* Move half of the xattr in start_blk to the next bucket. */
4147 return ocfs2_divide_xattr_bucket(inode
, handle
, prev_blk
,
4148 new_blk
, first_hash
, 1);
4152 * Move some xattrs from the old cluster to the new one since they are not
4153 * contiguous in ocfs2 xattr tree.
4155 * new_blk starts a new separate cluster, and we will move some xattrs from
4156 * prev_blk to it. v_start will be set as the first name hash value in this
4157 * new cluster so that it can be used as e_cpos during tree insertion and
4158 * don't collide with our original b-tree operations. first_bh and header_bh
4159 * will also be updated since they will be used in ocfs2_extend_xattr_bucket
4160 * to extend the insert bucket.
4162 * The problem is how much xattr should we move to the new one and when should
4163 * we update first_bh and header_bh?
4164 * 1. If cluster size > bucket size, that means the previous cluster has more
4165 * than 1 bucket, so just move half nums of bucket into the new cluster and
4166 * update the first_bh and header_bh if the insert bucket has been moved
4167 * to the new cluster.
4168 * 2. If cluster_size == bucket_size:
4169 * a) If the previous extent rec has more than one cluster and the insert
4170 * place isn't in the last cluster, copy the entire last cluster to the
4171 * new one. This time, we don't need to upate the first_bh and header_bh
4172 * since they will not be moved into the new cluster.
4173 * b) Otherwise, move the bottom half of the xattrs in the last cluster into
4174 * the new one. And we set the extend flag to zero if the insert place is
4175 * moved into the new allocated cluster since no extend is needed.
4177 static int ocfs2_adjust_xattr_cross_cluster(struct inode
*inode
,
4179 struct ocfs2_xattr_bucket
*first
,
4180 struct ocfs2_xattr_bucket
*target
,
4188 mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n",
4189 (unsigned long long)bucket_blkno(first
), prev_clusters
,
4190 (unsigned long long)new_blk
);
4192 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode
->i_sb
)) > 1) {
4193 ret
= ocfs2_mv_xattr_bucket_cross_cluster(inode
,
4202 /* The start of the last cluster in the first extent */
4203 u64 last_blk
= bucket_blkno(first
) +
4204 ((prev_clusters
- 1) *
4205 ocfs2_clusters_to_blocks(inode
->i_sb
, 1));
4207 if (prev_clusters
> 1 && bucket_blkno(target
) != last_blk
) {
4208 ret
= ocfs2_mv_xattr_buckets(inode
, handle
,
4209 bucket_blkno(first
),
4210 last_blk
, new_blk
, 0,
4215 ret
= ocfs2_divide_xattr_cluster(inode
, handle
,
4221 if ((bucket_blkno(target
) == last_blk
) && extend
)
4230 * Add a new cluster for xattr storage.
4232 * If the new cluster is contiguous with the previous one, it will be
4233 * appended to the same extent record, and num_clusters will be updated.
4234 * If not, we will insert a new extent for it and move some xattrs in
4235 * the last cluster into the new allocated one.
4236 * We also need to limit the maximum size of a btree leaf, otherwise we'll
4237 * lose the benefits of hashing because we'll have to search large leaves.
4238 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
4241 * first_bh is the first block of the previous extent rec and header_bh
4242 * indicates the bucket we will insert the new xattrs. They will be updated
4243 * when the header_bh is moved into the new cluster.
4245 static int ocfs2_add_new_xattr_cluster(struct inode
*inode
,
4246 struct buffer_head
*root_bh
,
4247 struct ocfs2_xattr_bucket
*first
,
4248 struct ocfs2_xattr_bucket
*target
,
4252 struct ocfs2_xattr_set_ctxt
*ctxt
)
4255 u16 bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
4256 u32 prev_clusters
= *num_clusters
;
4257 u32 clusters_to_add
= 1, bit_off
, num_bits
, v_start
= 0;
4259 handle_t
*handle
= ctxt
->handle
;
4260 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4261 struct ocfs2_extent_tree et
;
4263 mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, "
4264 "previous xattr blkno = %llu\n",
4265 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
4266 prev_cpos
, (unsigned long long)bucket_blkno(first
));
4268 ocfs2_init_xattr_tree_extent_tree(&et
, inode
, root_bh
);
4270 ret
= ocfs2_journal_access_xb(handle
, inode
, root_bh
,
4271 OCFS2_JOURNAL_ACCESS_WRITE
);
4277 ret
= __ocfs2_claim_clusters(osb
, handle
, ctxt
->data_ac
, 1,
4278 clusters_to_add
, &bit_off
, &num_bits
);
4285 BUG_ON(num_bits
> clusters_to_add
);
4287 block
= ocfs2_clusters_to_blocks(osb
->sb
, bit_off
);
4288 mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n",
4289 num_bits
, bit_off
, (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
4291 if (bucket_blkno(first
) + (prev_clusters
* bpc
) == block
&&
4292 (prev_clusters
+ num_bits
) << osb
->s_clustersize_bits
<=
4293 OCFS2_MAX_XATTR_TREE_LEAF_SIZE
) {
4295 * If this cluster is contiguous with the old one and
4296 * adding this new cluster, we don't surpass the limit of
4297 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
4298 * initialized and used like other buckets in the previous
4300 * So add it as a contiguous one. The caller will handle
4303 v_start
= prev_cpos
+ prev_clusters
;
4304 *num_clusters
= prev_clusters
+ num_bits
;
4305 mlog(0, "Add contiguous %u clusters to previous extent rec.\n",
4308 ret
= ocfs2_adjust_xattr_cross_cluster(inode
,
4322 mlog(0, "Insert %u clusters at block %llu for xattr at %u\n",
4323 num_bits
, (unsigned long long)block
, v_start
);
4324 ret
= ocfs2_insert_extent(osb
, handle
, inode
, &et
, v_start
, block
,
4325 num_bits
, 0, ctxt
->meta_ac
);
4331 ret
= ocfs2_journal_dirty(handle
, root_bh
);
4340 * We are given an extent. 'first' is the bucket at the very front of
4341 * the extent. The extent has space for an additional bucket past
4342 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
4343 * of the target bucket. We wish to shift every bucket past the target
4344 * down one, filling in that additional space. When we get back to the
4345 * target, we split the target between itself and the now-empty bucket
4346 * at target+1 (aka, target_blkno + blks_per_bucket).
4348 static int ocfs2_extend_xattr_bucket(struct inode
*inode
,
4350 struct ocfs2_xattr_bucket
*first
,
4355 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4356 u16 blk_per_bucket
= ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
4358 u16 new_bucket
= le16_to_cpu(bucket_xh(first
)->xh_num_buckets
);
4360 mlog(0, "extend xattr bucket in %llu, xattr extend rec starting "
4361 "from %llu, len = %u\n", (unsigned long long)target_blk
,
4362 (unsigned long long)bucket_blkno(first
), num_clusters
);
4364 /* The extent must have room for an additional bucket */
4365 BUG_ON(new_bucket
>=
4366 (num_clusters
* ocfs2_xattr_buckets_per_cluster(osb
)));
4368 /* end_blk points to the last existing bucket */
4369 end_blk
= bucket_blkno(first
) + ((new_bucket
- 1) * blk_per_bucket
);
4372 * end_blk is the start of the last existing bucket.
4373 * Thus, (end_blk - target_blk) covers the target bucket and
4374 * every bucket after it up to, but not including, the last
4375 * existing bucket. Then we add the last existing bucket, the
4376 * new bucket, and the first bucket (3 * blk_per_bucket).
4378 credits
= (end_blk
- target_blk
) + (3 * blk_per_bucket
) +
4379 handle
->h_buffer_credits
;
4380 ret
= ocfs2_extend_trans(handle
, credits
);
4386 ret
= ocfs2_xattr_bucket_journal_access(handle
, first
,
4387 OCFS2_JOURNAL_ACCESS_WRITE
);
4393 while (end_blk
!= target_blk
) {
4394 ret
= ocfs2_cp_xattr_bucket(inode
, handle
, end_blk
,
4395 end_blk
+ blk_per_bucket
, 0);
4398 end_blk
-= blk_per_bucket
;
4401 /* Move half of the xattr in target_blkno to the next bucket. */
4402 ret
= ocfs2_divide_xattr_bucket(inode
, handle
, target_blk
,
4403 target_blk
+ blk_per_bucket
, NULL
, 0);
4405 le16_add_cpu(&bucket_xh(first
)->xh_num_buckets
, 1);
4406 ocfs2_xattr_bucket_journal_dirty(handle
, first
);
4413 * Add new xattr bucket in an extent record and adjust the buckets
4414 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the
4415 * bucket we want to insert into.
4417 * In the easy case, we will move all the buckets after target down by
4418 * one. Half of target's xattrs will be moved to the next bucket.
4420 * If current cluster is full, we'll allocate a new one. This may not
4421 * be contiguous. The underlying calls will make sure that there is
4422 * space for the insert, shifting buckets around if necessary.
4423 * 'target' may be moved by those calls.
4425 static int ocfs2_add_new_xattr_bucket(struct inode
*inode
,
4426 struct buffer_head
*xb_bh
,
4427 struct ocfs2_xattr_bucket
*target
,
4428 struct ocfs2_xattr_set_ctxt
*ctxt
)
4430 struct ocfs2_xattr_block
*xb
=
4431 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
4432 struct ocfs2_xattr_tree_root
*xb_root
= &xb
->xb_attrs
.xb_root
;
4433 struct ocfs2_extent_list
*el
= &xb_root
->xt_list
;
4435 le32_to_cpu(bucket_xh(target
)->xh_entries
[0].xe_name_hash
);
4436 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4437 int ret
, num_buckets
, extend
= 1;
4439 u32 e_cpos
, num_clusters
;
4440 /* The bucket at the front of the extent */
4441 struct ocfs2_xattr_bucket
*first
;
4443 mlog(0, "Add new xattr bucket starting from %llu\n",
4444 (unsigned long long)bucket_blkno(target
));
4446 /* The first bucket of the original extent */
4447 first
= ocfs2_xattr_bucket_new(inode
);
4454 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
, &e_cpos
,
4461 ret
= ocfs2_read_xattr_bucket(first
, p_blkno
);
4467 num_buckets
= ocfs2_xattr_buckets_per_cluster(osb
) * num_clusters
;
4468 if (num_buckets
== le16_to_cpu(bucket_xh(first
)->xh_num_buckets
)) {
4470 * This can move first+target if the target bucket moves
4471 * to the new extent.
4473 ret
= ocfs2_add_new_xattr_cluster(inode
,
4488 ret
= ocfs2_extend_xattr_bucket(inode
,
4491 bucket_blkno(target
),
4498 ocfs2_xattr_bucket_free(first
);
4503 static inline char *ocfs2_xattr_bucket_get_val(struct inode
*inode
,
4504 struct ocfs2_xattr_bucket
*bucket
,
4507 int block_off
= offs
>> inode
->i_sb
->s_blocksize_bits
;
4509 offs
= offs
% inode
->i_sb
->s_blocksize
;
4510 return bucket_block(bucket
, block_off
) + offs
;
4514 * Handle the normal xattr set, including replace, delete and new.
4516 * Note: "local" indicates the real data's locality. So we can't
4517 * just its bucket locality by its length.
4519 static void ocfs2_xattr_set_entry_normal(struct inode
*inode
,
4520 struct ocfs2_xattr_info
*xi
,
4521 struct ocfs2_xattr_search
*xs
,
4525 struct ocfs2_xattr_entry
*last
, *xe
;
4526 int name_len
= strlen(xi
->name
);
4527 struct ocfs2_xattr_header
*xh
= xs
->header
;
4528 u16 count
= le16_to_cpu(xh
->xh_count
), start
;
4529 size_t blocksize
= inode
->i_sb
->s_blocksize
;
4531 size_t offs
, size
, new_size
;
4533 last
= &xh
->xh_entries
[count
];
4534 if (!xs
->not_found
) {
4536 offs
= le16_to_cpu(xe
->xe_name_offset
);
4537 if (ocfs2_xattr_is_local(xe
))
4538 size
= OCFS2_XATTR_SIZE(name_len
) +
4539 OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
4541 size
= OCFS2_XATTR_SIZE(name_len
) +
4542 OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE
);
4545 * If the new value will be stored outside, xi->value has been
4546 * initalized as an empty ocfs2_xattr_value_root, and the same
4547 * goes with xi->value_len, so we can set new_size safely here.
4548 * See ocfs2_xattr_set_in_bucket.
4550 new_size
= OCFS2_XATTR_SIZE(name_len
) +
4551 OCFS2_XATTR_SIZE(xi
->value_len
);
4553 le16_add_cpu(&xh
->xh_name_value_len
, -size
);
4555 if (new_size
> size
)
4556 goto set_new_name_value
;
4558 /* Now replace the old value with new one. */
4560 xe
->xe_value_size
= cpu_to_le64(xi
->value_len
);
4562 xe
->xe_value_size
= 0;
4564 val
= ocfs2_xattr_bucket_get_val(inode
,
4566 memset(val
+ OCFS2_XATTR_SIZE(name_len
), 0,
4567 size
- OCFS2_XATTR_SIZE(name_len
));
4568 if (OCFS2_XATTR_SIZE(xi
->value_len
) > 0)
4569 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
),
4570 xi
->value
, xi
->value_len
);
4572 le16_add_cpu(&xh
->xh_name_value_len
, new_size
);
4573 ocfs2_xattr_set_local(xe
, local
);
4577 * Remove the old entry if there is more than one.
4578 * We don't remove the last entry so that we can
4579 * use it to indicate the hash value of the empty
4583 le16_add_cpu(&xh
->xh_count
, -1);
4586 (void *)last
- (void *)xe
);
4588 sizeof(struct ocfs2_xattr_entry
));
4591 cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE
);
4596 /* find a new entry for insert. */
4597 int low
= 0, high
= count
- 1, tmp
;
4598 struct ocfs2_xattr_entry
*tmp_xe
;
4600 while (low
<= high
&& count
) {
4601 tmp
= (low
+ high
) / 2;
4602 tmp_xe
= &xh
->xh_entries
[tmp
];
4604 if (name_hash
> le32_to_cpu(tmp_xe
->xe_name_hash
))
4606 else if (name_hash
<
4607 le32_to_cpu(tmp_xe
->xe_name_hash
))
4615 xe
= &xh
->xh_entries
[low
];
4617 memmove(xe
+ 1, xe
, (void *)last
- (void *)xe
);
4619 le16_add_cpu(&xh
->xh_count
, 1);
4620 memset(xe
, 0, sizeof(struct ocfs2_xattr_entry
));
4621 xe
->xe_name_hash
= cpu_to_le32(name_hash
);
4622 xe
->xe_name_len
= name_len
;
4623 ocfs2_xattr_set_type(xe
, xi
->name_index
);
4627 /* Insert the new name+value. */
4628 size
= OCFS2_XATTR_SIZE(name_len
) + OCFS2_XATTR_SIZE(xi
->value_len
);
4631 * We must make sure that the name/value pair
4632 * exists in the same block.
4634 offs
= le16_to_cpu(xh
->xh_free_start
);
4635 start
= offs
- size
;
4637 if (start
>> inode
->i_sb
->s_blocksize_bits
!=
4638 (offs
- 1) >> inode
->i_sb
->s_blocksize_bits
) {
4639 offs
= offs
- offs
% blocksize
;
4640 xh
->xh_free_start
= cpu_to_le16(offs
);
4643 val
= ocfs2_xattr_bucket_get_val(inode
, xs
->bucket
, offs
- size
);
4644 xe
->xe_name_offset
= cpu_to_le16(offs
- size
);
4646 memset(val
, 0, size
);
4647 memcpy(val
, xi
->name
, name_len
);
4648 memcpy(val
+ OCFS2_XATTR_SIZE(name_len
), xi
->value
, xi
->value_len
);
4650 xe
->xe_value_size
= cpu_to_le64(xi
->value_len
);
4651 ocfs2_xattr_set_local(xe
, local
);
4653 le16_add_cpu(&xh
->xh_free_start
, -size
);
4654 le16_add_cpu(&xh
->xh_name_value_len
, size
);
4660 * Set the xattr entry in the specified bucket.
4661 * The bucket is indicated by xs->bucket and it should have the enough
4662 * space for the xattr insertion.
4664 static int ocfs2_xattr_set_entry_in_bucket(struct inode
*inode
,
4666 struct ocfs2_xattr_info
*xi
,
4667 struct ocfs2_xattr_search
*xs
,
4674 mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n",
4675 (unsigned long)xi
->value_len
, xi
->name_index
,
4676 (unsigned long long)bucket_blkno(xs
->bucket
));
4678 if (!xs
->bucket
->bu_bhs
[1]) {
4679 blkno
= bucket_blkno(xs
->bucket
);
4680 ocfs2_xattr_bucket_relse(xs
->bucket
);
4681 ret
= ocfs2_read_xattr_bucket(xs
->bucket
, blkno
);
4688 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
4689 OCFS2_JOURNAL_ACCESS_WRITE
);
4695 ocfs2_xattr_set_entry_normal(inode
, xi
, xs
, name_hash
, local
);
4696 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
4703 * Truncate the specified xe_off entry in xattr bucket.
4704 * bucket is indicated by header_bh and len is the new length.
4705 * Both the ocfs2_xattr_value_root and the entry will be updated here.
4707 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
4709 static int ocfs2_xattr_bucket_value_truncate(struct inode
*inode
,
4710 struct ocfs2_xattr_bucket
*bucket
,
4713 struct ocfs2_xattr_set_ctxt
*ctxt
)
4717 struct ocfs2_xattr_entry
*xe
;
4718 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
4719 size_t blocksize
= inode
->i_sb
->s_blocksize
;
4720 struct ocfs2_xattr_value_buf vb
= {
4721 .vb_access
= ocfs2_journal_access
,
4724 xe
= &xh
->xh_entries
[xe_off
];
4726 BUG_ON(!xe
|| ocfs2_xattr_is_local(xe
));
4728 offset
= le16_to_cpu(xe
->xe_name_offset
) +
4729 OCFS2_XATTR_SIZE(xe
->xe_name_len
);
4731 value_blk
= offset
/ blocksize
;
4733 /* We don't allow ocfs2_xattr_value to be stored in different block. */
4734 BUG_ON(value_blk
!= (offset
+ OCFS2_XATTR_ROOT_SIZE
- 1) / blocksize
);
4736 vb
.vb_bh
= bucket
->bu_bhs
[value_blk
];
4739 vb
.vb_xv
= (struct ocfs2_xattr_value_root
*)
4740 (vb
.vb_bh
->b_data
+ offset
% blocksize
);
4743 * From here on out we have to dirty the bucket. The generic
4744 * value calls only modify one of the bucket's bhs, but we need
4745 * to send the bucket at once. So if they error, they *could* have
4746 * modified something. We have to assume they did, and dirty
4747 * the whole bucket. This leaves us in a consistent state.
4749 mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n",
4750 xe_off
, (unsigned long long)bucket_blkno(bucket
), len
);
4751 ret
= ocfs2_xattr_value_truncate(inode
, &vb
, len
, ctxt
);
4757 ret
= ocfs2_xattr_bucket_journal_access(ctxt
->handle
, bucket
,
4758 OCFS2_JOURNAL_ACCESS_WRITE
);
4764 xe
->xe_value_size
= cpu_to_le64(len
);
4766 ocfs2_xattr_bucket_journal_dirty(ctxt
->handle
, bucket
);
4772 static int ocfs2_xattr_bucket_value_truncate_xs(struct inode
*inode
,
4773 struct ocfs2_xattr_search
*xs
,
4775 struct ocfs2_xattr_set_ctxt
*ctxt
)
4778 struct ocfs2_xattr_entry
*xe
= xs
->here
;
4779 struct ocfs2_xattr_header
*xh
= (struct ocfs2_xattr_header
*)xs
->base
;
4781 BUG_ON(!xs
->bucket
->bu_bhs
[0] || !xe
|| ocfs2_xattr_is_local(xe
));
4783 offset
= xe
- xh
->xh_entries
;
4784 ret
= ocfs2_xattr_bucket_value_truncate(inode
, xs
->bucket
,
4792 static int ocfs2_xattr_bucket_set_value_outside(struct inode
*inode
,
4794 struct ocfs2_xattr_search
*xs
,
4798 int ret
, offset
, block_off
;
4799 struct ocfs2_xattr_value_root
*xv
;
4800 struct ocfs2_xattr_entry
*xe
= xs
->here
;
4801 struct ocfs2_xattr_header
*xh
= bucket_xh(xs
->bucket
);
4804 BUG_ON(!xs
->base
|| !xe
|| ocfs2_xattr_is_local(xe
));
4806 ret
= ocfs2_xattr_bucket_get_name_value(inode
, xh
,
4807 xe
- xh
->xh_entries
,
4815 base
= bucket_block(xs
->bucket
, block_off
);
4816 xv
= (struct ocfs2_xattr_value_root
*)(base
+ offset
+
4817 OCFS2_XATTR_SIZE(xe
->xe_name_len
));
4819 ret
= __ocfs2_xattr_set_value_outside(inode
, handle
,
4820 xv
, val
, value_len
);
4827 static int ocfs2_rm_xattr_cluster(struct inode
*inode
,
4828 struct buffer_head
*root_bh
,
4834 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
4835 struct inode
*tl_inode
= osb
->osb_tl_inode
;
4837 struct ocfs2_xattr_block
*xb
=
4838 (struct ocfs2_xattr_block
*)root_bh
->b_data
;
4839 struct ocfs2_alloc_context
*meta_ac
= NULL
;
4840 struct ocfs2_cached_dealloc_ctxt dealloc
;
4841 struct ocfs2_extent_tree et
;
4843 ocfs2_init_xattr_tree_extent_tree(&et
, inode
, root_bh
);
4845 ocfs2_init_dealloc_ctxt(&dealloc
);
4847 mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n",
4848 cpos
, len
, (unsigned long long)blkno
);
4850 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode
), blkno
,
4853 ret
= ocfs2_lock_allocators(inode
, &et
, 0, 1, NULL
, &meta_ac
);
4859 mutex_lock(&tl_inode
->i_mutex
);
4861 if (ocfs2_truncate_log_needs_flush(osb
)) {
4862 ret
= __ocfs2_flush_truncate_log(osb
);
4869 handle
= ocfs2_start_trans(osb
, ocfs2_remove_extent_credits(osb
->sb
));
4870 if (IS_ERR(handle
)) {
4876 ret
= ocfs2_journal_access_xb(handle
, inode
, root_bh
,
4877 OCFS2_JOURNAL_ACCESS_WRITE
);
4883 ret
= ocfs2_remove_extent(inode
, &et
, cpos
, len
, handle
, meta_ac
,
4890 le32_add_cpu(&xb
->xb_attrs
.xb_root
.xt_clusters
, -len
);
4892 ret
= ocfs2_journal_dirty(handle
, root_bh
);
4898 ret
= ocfs2_truncate_log_append(osb
, handle
, blkno
, len
);
4903 ocfs2_commit_trans(osb
, handle
);
4905 ocfs2_schedule_truncate_log_flush(osb
, 1);
4907 mutex_unlock(&tl_inode
->i_mutex
);
4910 ocfs2_free_alloc_context(meta_ac
);
4912 ocfs2_run_deallocs(osb
, &dealloc
);
4917 static void ocfs2_xattr_bucket_remove_xs(struct inode
*inode
,
4919 struct ocfs2_xattr_search
*xs
)
4921 struct ocfs2_xattr_header
*xh
= bucket_xh(xs
->bucket
);
4922 struct ocfs2_xattr_entry
*last
= &xh
->xh_entries
[
4923 le16_to_cpu(xh
->xh_count
) - 1];
4926 ret
= ocfs2_xattr_bucket_journal_access(handle
, xs
->bucket
,
4927 OCFS2_JOURNAL_ACCESS_WRITE
);
4933 /* Remove the old entry. */
4934 memmove(xs
->here
, xs
->here
+ 1,
4935 (void *)last
- (void *)xs
->here
);
4936 memset(last
, 0, sizeof(struct ocfs2_xattr_entry
));
4937 le16_add_cpu(&xh
->xh_count
, -1);
4939 ocfs2_xattr_bucket_journal_dirty(handle
, xs
->bucket
);
4943 * Set the xattr name/value in the bucket specified in xs.
4945 * As the new value in xi may be stored in the bucket or in an outside cluster,
4946 * we divide the whole process into 3 steps:
4947 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
4948 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
4949 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
4950 * 4. If the clusters for the new outside value can't be allocated, we need
4951 * to free the xattr we allocated in set.
4953 static int ocfs2_xattr_set_in_bucket(struct inode
*inode
,
4954 struct ocfs2_xattr_info
*xi
,
4955 struct ocfs2_xattr_search
*xs
,
4956 struct ocfs2_xattr_set_ctxt
*ctxt
)
4960 char *val
= (char *)xi
->value
;
4961 struct ocfs2_xattr_entry
*xe
= xs
->here
;
4962 u32 name_hash
= ocfs2_xattr_name_hash(inode
, xi
->name
,
4965 if (!xs
->not_found
&& !ocfs2_xattr_is_local(xe
)) {
4967 * We need to truncate the xattr storage first.
4969 * If both the old and new value are stored to
4970 * outside block, we only need to truncate
4971 * the storage and then set the value outside.
4973 * If the new value should be stored within block,
4974 * we should free all the outside block first and
4975 * the modification to the xattr block will be done
4976 * by following steps.
4978 if (xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
4979 value_len
= xi
->value_len
;
4983 ret
= ocfs2_xattr_bucket_value_truncate_xs(inode
, xs
,
4990 goto set_value_outside
;
4993 value_len
= xi
->value_len
;
4994 /* So we have to handle the inside block change now. */
4995 if (value_len
> OCFS2_XATTR_INLINE_SIZE
) {
4997 * If the new value will be stored outside of block,
4998 * initalize a new empty value root and insert it first.
5001 xi
->value
= &def_xv
;
5002 xi
->value_len
= OCFS2_XATTR_ROOT_SIZE
;
5005 ret
= ocfs2_xattr_set_entry_in_bucket(inode
, ctxt
->handle
, xi
, xs
,
5012 if (value_len
<= OCFS2_XATTR_INLINE_SIZE
)
5015 /* allocate the space now for the outside block storage. */
5016 ret
= ocfs2_xattr_bucket_value_truncate_xs(inode
, xs
,
5021 if (xs
->not_found
) {
5023 * We can't allocate enough clusters for outside
5024 * storage and we have allocated xattr already,
5025 * so need to remove it.
5027 ocfs2_xattr_bucket_remove_xs(inode
, ctxt
->handle
, xs
);
5033 ret
= ocfs2_xattr_bucket_set_value_outside(inode
, ctxt
->handle
,
5034 xs
, val
, value_len
);
5040 * check whether the xattr bucket is filled up with the same hash value.
5041 * If we want to insert the xattr with the same hash, return -ENOSPC.
5042 * If we want to insert a xattr with different hash value, go ahead
5043 * and ocfs2_divide_xattr_bucket will handle this.
5045 static int ocfs2_check_xattr_bucket_collision(struct inode
*inode
,
5046 struct ocfs2_xattr_bucket
*bucket
,
5049 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
5050 u32 name_hash
= ocfs2_xattr_name_hash(inode
, name
, strlen(name
));
5052 if (name_hash
!= le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
))
5055 if (xh
->xh_entries
[le16_to_cpu(xh
->xh_count
) - 1].xe_name_hash
==
5056 xh
->xh_entries
[0].xe_name_hash
) {
5057 mlog(ML_ERROR
, "Too much hash collision in xattr bucket %llu, "
5059 (unsigned long long)bucket_blkno(bucket
),
5060 le32_to_cpu(xh
->xh_entries
[0].xe_name_hash
));
5067 static int ocfs2_xattr_set_entry_index_block(struct inode
*inode
,
5068 struct ocfs2_xattr_info
*xi
,
5069 struct ocfs2_xattr_search
*xs
,
5070 struct ocfs2_xattr_set_ctxt
*ctxt
)
5072 struct ocfs2_xattr_header
*xh
;
5073 struct ocfs2_xattr_entry
*xe
;
5074 u16 count
, header_size
, xh_free_start
;
5075 int free
, max_free
, need
, old
;
5076 size_t value_size
= 0, name_len
= strlen(xi
->name
);
5077 size_t blocksize
= inode
->i_sb
->s_blocksize
;
5078 int ret
, allocation
= 0;
5080 mlog_entry("Set xattr %s in xattr index block\n", xi
->name
);
5084 count
= le16_to_cpu(xh
->xh_count
);
5085 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
5086 header_size
= sizeof(struct ocfs2_xattr_header
) +
5087 count
* sizeof(struct ocfs2_xattr_entry
);
5088 max_free
= OCFS2_XATTR_BUCKET_SIZE
- header_size
-
5089 le16_to_cpu(xh
->xh_name_value_len
) - OCFS2_XATTR_HEADER_GAP
;
5091 mlog_bug_on_msg(header_size
> blocksize
, "bucket %llu has header size "
5092 "of %u which exceed block size\n",
5093 (unsigned long long)bucket_blkno(xs
->bucket
),
5096 if (xi
->value
&& xi
->value_len
> OCFS2_XATTR_INLINE_SIZE
)
5097 value_size
= OCFS2_XATTR_ROOT_SIZE
;
5099 value_size
= OCFS2_XATTR_SIZE(xi
->value_len
);
5102 need
= sizeof(struct ocfs2_xattr_entry
) +
5103 OCFS2_XATTR_SIZE(name_len
) + value_size
;
5105 need
= value_size
+ OCFS2_XATTR_SIZE(name_len
);
5108 * We only replace the old value if the new length is smaller
5109 * than the old one. Otherwise we will allocate new space in the
5110 * bucket to store it.
5113 if (ocfs2_xattr_is_local(xe
))
5114 old
= OCFS2_XATTR_SIZE(le64_to_cpu(xe
->xe_value_size
));
5116 old
= OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE
);
5118 if (old
>= value_size
)
5122 free
= xh_free_start
- header_size
- OCFS2_XATTR_HEADER_GAP
;
5124 * We need to make sure the new name/value pair
5125 * can exist in the same block.
5127 if (xh_free_start
% blocksize
< need
)
5128 free
-= xh_free_start
% blocksize
;
5130 mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, "
5131 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
5132 " %u\n", xs
->not_found
,
5133 (unsigned long long)bucket_blkno(xs
->bucket
),
5134 free
, need
, max_free
, le16_to_cpu(xh
->xh_free_start
),
5135 le16_to_cpu(xh
->xh_name_value_len
));
5139 count
== ocfs2_xattr_max_xe_in_bucket(inode
->i_sb
))) {
5140 if (need
<= max_free
&&
5141 count
< ocfs2_xattr_max_xe_in_bucket(inode
->i_sb
)) {
5143 * We can create the space by defragment. Since only the
5144 * name/value will be moved, the xe shouldn't be changed
5147 ret
= ocfs2_defrag_xattr_bucket(inode
, ctxt
->handle
,
5154 xh_free_start
= le16_to_cpu(xh
->xh_free_start
);
5155 free
= xh_free_start
- header_size
5156 - OCFS2_XATTR_HEADER_GAP
;
5157 if (xh_free_start
% blocksize
< need
)
5158 free
-= xh_free_start
% blocksize
;
5163 mlog(0, "Can't get enough space for xattr insert by "
5164 "defragment. Need %u bytes, but we have %d, so "
5165 "allocate new bucket for it.\n", need
, free
);
5169 * We have to add new buckets or clusters and one
5170 * allocation should leave us enough space for insert.
5175 * We do not allow for overlapping ranges between buckets. And
5176 * the maximum number of collisions we will allow for then is
5177 * one bucket's worth, so check it here whether we need to
5178 * add a new bucket for the insert.
5180 ret
= ocfs2_check_xattr_bucket_collision(inode
,
5188 ret
= ocfs2_add_new_xattr_bucket(inode
,
5198 * ocfs2_add_new_xattr_bucket() will have updated
5199 * xs->bucket if it moved, but it will not have updated
5200 * any of the other search fields. Thus, we drop it and
5201 * re-search. Everything should be cached, so it'll be
5204 ocfs2_xattr_bucket_relse(xs
->bucket
);
5205 ret
= ocfs2_xattr_index_block_find(inode
, xs
->xattr_bh
,
5208 if (ret
&& ret
!= -ENODATA
)
5210 xs
->not_found
= ret
;
5216 ret
= ocfs2_xattr_set_in_bucket(inode
, xi
, xs
, ctxt
);
5222 static int ocfs2_delete_xattr_in_bucket(struct inode
*inode
,
5223 struct ocfs2_xattr_bucket
*bucket
,
5227 struct ocfs2_xattr_header
*xh
= bucket_xh(bucket
);
5229 struct ocfs2_xattr_entry
*xe
;
5230 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5231 struct ocfs2_xattr_set_ctxt ctxt
= {NULL
, NULL
,};
5232 int credits
= ocfs2_remove_extent_credits(osb
->sb
) +
5233 ocfs2_blocks_per_xattr_bucket(inode
->i_sb
);
5236 ocfs2_init_dealloc_ctxt(&ctxt
.dealloc
);
5238 for (i
= 0; i
< le16_to_cpu(xh
->xh_count
); i
++) {
5239 xe
= &xh
->xh_entries
[i
];
5240 if (ocfs2_xattr_is_local(xe
))
5243 ctxt
.handle
= ocfs2_start_trans(osb
, credits
);
5244 if (IS_ERR(ctxt
.handle
)) {
5245 ret
= PTR_ERR(ctxt
.handle
);
5250 ret
= ocfs2_xattr_bucket_value_truncate(inode
, bucket
,
5253 ocfs2_commit_trans(osb
, ctxt
.handle
);
5260 ocfs2_schedule_truncate_log_flush(osb
, 1);
5261 ocfs2_run_deallocs(osb
, &ctxt
.dealloc
);
5265 static int ocfs2_delete_xattr_index_block(struct inode
*inode
,
5266 struct buffer_head
*xb_bh
)
5268 struct ocfs2_xattr_block
*xb
=
5269 (struct ocfs2_xattr_block
*)xb_bh
->b_data
;
5270 struct ocfs2_extent_list
*el
= &xb
->xb_attrs
.xb_root
.xt_list
;
5272 u32 name_hash
= UINT_MAX
, e_cpos
, num_clusters
;
5275 if (le16_to_cpu(el
->l_next_free_rec
) == 0)
5278 while (name_hash
> 0) {
5279 ret
= ocfs2_xattr_get_rec(inode
, name_hash
, &p_blkno
,
5280 &e_cpos
, &num_clusters
, el
);
5286 ret
= ocfs2_iterate_xattr_buckets(inode
, p_blkno
, num_clusters
,
5287 ocfs2_delete_xattr_in_bucket
,
5294 ret
= ocfs2_rm_xattr_cluster(inode
, xb_bh
,
5295 p_blkno
, e_cpos
, num_clusters
);
5304 name_hash
= e_cpos
- 1;
5312 * 'security' attributes support
5314 static size_t ocfs2_xattr_security_list(struct inode
*inode
, char *list
,
5315 size_t list_size
, const char *name
,
5318 const size_t prefix_len
= XATTR_SECURITY_PREFIX_LEN
;
5319 const size_t total_len
= prefix_len
+ name_len
+ 1;
5321 if (list
&& total_len
<= list_size
) {
5322 memcpy(list
, XATTR_SECURITY_PREFIX
, prefix_len
);
5323 memcpy(list
+ prefix_len
, name
, name_len
);
5324 list
[prefix_len
+ name_len
] = '\0';
5329 static int ocfs2_xattr_security_get(struct inode
*inode
, const char *name
,
5330 void *buffer
, size_t size
)
5332 if (strcmp(name
, "") == 0)
5334 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_SECURITY
, name
,
5338 static int ocfs2_xattr_security_set(struct inode
*inode
, const char *name
,
5339 const void *value
, size_t size
, int flags
)
5341 if (strcmp(name
, "") == 0)
5344 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_SECURITY
, name
, value
,
5348 int ocfs2_init_security_get(struct inode
*inode
,
5350 struct ocfs2_security_xattr_info
*si
)
5352 /* check whether ocfs2 support feature xattr */
5353 if (!ocfs2_supports_xattr(OCFS2_SB(dir
->i_sb
)))
5355 return security_inode_init_security(inode
, dir
, &si
->name
, &si
->value
,
5359 int ocfs2_init_security_set(handle_t
*handle
,
5360 struct inode
*inode
,
5361 struct buffer_head
*di_bh
,
5362 struct ocfs2_security_xattr_info
*si
,
5363 struct ocfs2_alloc_context
*xattr_ac
,
5364 struct ocfs2_alloc_context
*data_ac
)
5366 return ocfs2_xattr_set_handle(handle
, inode
, di_bh
,
5367 OCFS2_XATTR_INDEX_SECURITY
,
5368 si
->name
, si
->value
, si
->value_len
, 0,
5372 struct xattr_handler ocfs2_xattr_security_handler
= {
5373 .prefix
= XATTR_SECURITY_PREFIX
,
5374 .list
= ocfs2_xattr_security_list
,
5375 .get
= ocfs2_xattr_security_get
,
5376 .set
= ocfs2_xattr_security_set
,
5380 * 'trusted' attributes support
5382 static size_t ocfs2_xattr_trusted_list(struct inode
*inode
, char *list
,
5383 size_t list_size
, const char *name
,
5386 const size_t prefix_len
= XATTR_TRUSTED_PREFIX_LEN
;
5387 const size_t total_len
= prefix_len
+ name_len
+ 1;
5389 if (list
&& total_len
<= list_size
) {
5390 memcpy(list
, XATTR_TRUSTED_PREFIX
, prefix_len
);
5391 memcpy(list
+ prefix_len
, name
, name_len
);
5392 list
[prefix_len
+ name_len
] = '\0';
5397 static int ocfs2_xattr_trusted_get(struct inode
*inode
, const char *name
,
5398 void *buffer
, size_t size
)
5400 if (strcmp(name
, "") == 0)
5402 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_TRUSTED
, name
,
5406 static int ocfs2_xattr_trusted_set(struct inode
*inode
, const char *name
,
5407 const void *value
, size_t size
, int flags
)
5409 if (strcmp(name
, "") == 0)
5412 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_TRUSTED
, name
, value
,
5416 struct xattr_handler ocfs2_xattr_trusted_handler
= {
5417 .prefix
= XATTR_TRUSTED_PREFIX
,
5418 .list
= ocfs2_xattr_trusted_list
,
5419 .get
= ocfs2_xattr_trusted_get
,
5420 .set
= ocfs2_xattr_trusted_set
,
5424 * 'user' attributes support
5426 static size_t ocfs2_xattr_user_list(struct inode
*inode
, char *list
,
5427 size_t list_size
, const char *name
,
5430 const size_t prefix_len
= XATTR_USER_PREFIX_LEN
;
5431 const size_t total_len
= prefix_len
+ name_len
+ 1;
5432 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5434 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
5437 if (list
&& total_len
<= list_size
) {
5438 memcpy(list
, XATTR_USER_PREFIX
, prefix_len
);
5439 memcpy(list
+ prefix_len
, name
, name_len
);
5440 list
[prefix_len
+ name_len
] = '\0';
5445 static int ocfs2_xattr_user_get(struct inode
*inode
, const char *name
,
5446 void *buffer
, size_t size
)
5448 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5450 if (strcmp(name
, "") == 0)
5452 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
5454 return ocfs2_xattr_get(inode
, OCFS2_XATTR_INDEX_USER
, name
,
5458 static int ocfs2_xattr_user_set(struct inode
*inode
, const char *name
,
5459 const void *value
, size_t size
, int flags
)
5461 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
5463 if (strcmp(name
, "") == 0)
5465 if (osb
->s_mount_opt
& OCFS2_MOUNT_NOUSERXATTR
)
5468 return ocfs2_xattr_set(inode
, OCFS2_XATTR_INDEX_USER
, name
, value
,
5472 struct xattr_handler ocfs2_xattr_user_handler
= {
5473 .prefix
= XATTR_USER_PREFIX
,
5474 .list
= ocfs2_xattr_user_list
,
5475 .get
= ocfs2_xattr_user_get
,
5476 .set
= ocfs2_xattr_user_set
,