2 * linux/fs/ext2/xattr.c
4 * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
6 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
7 * Extended attributes for symlinks and special files added per
8 * suggestion of Luka Renko <luka.renko@hermes.si>.
9 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
15 * Extended attributes are stored on disk blocks allocated outside of
16 * any inode. The i_file_acl field is then made to point to this allocated
17 * block. If all extended attributes of an inode are identical, these
18 * inodes may share the same extended attribute block. Such situations
19 * are automatically detected by keeping a cache of recent attribute block
20 * numbers and hashes over the block's contents in memory.
23 * Extended attribute block layout:
25 * +------------------+
28 * | entry 2 | | growing downwards
33 * | value 3 | | growing upwards
35 * +------------------+
37 * The block header is followed by multiple entry descriptors. These entry
38 * descriptors are variable in size, and aligned to EXT2_XATTR_PAD
39 * byte boundaries. The entry descriptors are sorted by attribute name,
40 * so that two extended attribute blocks can be compared efficiently.
42 * Attribute values are aligned to the end of the block, stored in
43 * no specific order. They are also padded to EXT2_XATTR_PAD byte
44 * boundaries. No additional gaps are left between them.
48 * EXT2_I(inode)->i_file_acl is protected by EXT2_I(inode)->xattr_sem.
49 * EA blocks are only changed if they are exclusive to an inode, so
50 * holding xattr_sem also means that nothing but the EA block's reference
51 * count will change. Multiple writers to an EA block are synchronized
52 * by the bh lock. No more than a single bh lock is held at any time
56 #include <linux/buffer_head.h>
57 #include <linux/init.h>
58 #include <linux/slab.h>
59 #include <linux/mbcache.h>
60 #include <linux/quotaops.h>
61 #include <linux/rwsem.h>
62 #include <linux/security.h>
67 #define HDR(bh) ((struct ext2_xattr_header *)((bh)->b_data))
68 #define ENTRY(ptr) ((struct ext2_xattr_entry *)(ptr))
69 #define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
70 #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
72 #ifdef EXT2_XATTR_DEBUG
73 # define ea_idebug(inode, f...) do { \
74 printk(KERN_DEBUG "inode %s:%ld: ", \
75 inode->i_sb->s_id, inode->i_ino); \
79 # define ea_bdebug(bh, f...) do { \
80 printk(KERN_DEBUG "block %pg:%lu: ", \
81 bh->b_bdev, (unsigned long) bh->b_blocknr); \
86 # define ea_idebug(f...)
87 # define ea_bdebug(f...)
90 static int ext2_xattr_set2(struct inode
*, struct buffer_head
*,
91 struct ext2_xattr_header
*);
93 static int ext2_xattr_cache_insert(struct mb_cache
*, struct buffer_head
*);
94 static struct buffer_head
*ext2_xattr_cache_find(struct inode
*,
95 struct ext2_xattr_header
*);
96 static void ext2_xattr_rehash(struct ext2_xattr_header
*,
97 struct ext2_xattr_entry
*);
99 static const struct xattr_handler
*ext2_xattr_handler_map
[] = {
100 [EXT2_XATTR_INDEX_USER
] = &ext2_xattr_user_handler
,
101 #ifdef CONFIG_EXT2_FS_POSIX_ACL
102 [EXT2_XATTR_INDEX_POSIX_ACL_ACCESS
] = &posix_acl_access_xattr_handler
,
103 [EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT
] = &posix_acl_default_xattr_handler
,
105 [EXT2_XATTR_INDEX_TRUSTED
] = &ext2_xattr_trusted_handler
,
106 #ifdef CONFIG_EXT2_FS_SECURITY
107 [EXT2_XATTR_INDEX_SECURITY
] = &ext2_xattr_security_handler
,
111 const struct xattr_handler
*ext2_xattr_handlers
[] = {
112 &ext2_xattr_user_handler
,
113 &ext2_xattr_trusted_handler
,
114 #ifdef CONFIG_EXT2_FS_POSIX_ACL
115 &posix_acl_access_xattr_handler
,
116 &posix_acl_default_xattr_handler
,
118 #ifdef CONFIG_EXT2_FS_SECURITY
119 &ext2_xattr_security_handler
,
124 #define EA_BLOCK_CACHE(inode) (EXT2_SB(inode->i_sb)->s_ea_block_cache)
126 static inline const struct xattr_handler
*
127 ext2_xattr_handler(int name_index
)
129 const struct xattr_handler
*handler
= NULL
;
131 if (name_index
> 0 && name_index
< ARRAY_SIZE(ext2_xattr_handler_map
))
132 handler
= ext2_xattr_handler_map
[name_index
];
139 * Copy an extended attribute into the buffer
140 * provided, or compute the buffer size required.
141 * Buffer is NULL to compute the size of the buffer required.
143 * Returns a negative error number on failure, or the number of bytes
144 * used / required on success.
147 ext2_xattr_get(struct inode
*inode
, int name_index
, const char *name
,
148 void *buffer
, size_t buffer_size
)
150 struct buffer_head
*bh
= NULL
;
151 struct ext2_xattr_entry
*entry
;
152 size_t name_len
, size
;
155 struct mb_cache
*ea_block_cache
= EA_BLOCK_CACHE(inode
);
157 ea_idebug(inode
, "name=%d.%s, buffer=%p, buffer_size=%ld",
158 name_index
, name
, buffer
, (long)buffer_size
);
162 name_len
= strlen(name
);
166 down_read(&EXT2_I(inode
)->xattr_sem
);
168 if (!EXT2_I(inode
)->i_file_acl
)
170 ea_idebug(inode
, "reading block %d", EXT2_I(inode
)->i_file_acl
);
171 bh
= sb_bread(inode
->i_sb
, EXT2_I(inode
)->i_file_acl
);
175 ea_bdebug(bh
, "b_count=%d, refcount=%d",
176 atomic_read(&(bh
->b_count
)), le32_to_cpu(HDR(bh
)->h_refcount
));
177 end
= bh
->b_data
+ bh
->b_size
;
178 if (HDR(bh
)->h_magic
!= cpu_to_le32(EXT2_XATTR_MAGIC
) ||
179 HDR(bh
)->h_blocks
!= cpu_to_le32(1)) {
180 bad_block
: ext2_error(inode
->i_sb
, "ext2_xattr_get",
181 "inode %ld: bad block %d", inode
->i_ino
,
182 EXT2_I(inode
)->i_file_acl
);
187 /* find named attribute */
188 entry
= FIRST_ENTRY(bh
);
189 while (!IS_LAST_ENTRY(entry
)) {
190 struct ext2_xattr_entry
*next
=
191 EXT2_XATTR_NEXT(entry
);
192 if ((char *)next
>= end
)
194 if (name_index
== entry
->e_name_index
&&
195 name_len
== entry
->e_name_len
&&
196 memcmp(name
, entry
->e_name
, name_len
) == 0)
200 if (ext2_xattr_cache_insert(ea_block_cache
, bh
))
201 ea_idebug(inode
, "cache insert failed");
205 /* check the buffer size */
206 if (entry
->e_value_block
!= 0)
208 size
= le32_to_cpu(entry
->e_value_size
);
209 if (size
> inode
->i_sb
->s_blocksize
||
210 le16_to_cpu(entry
->e_value_offs
) + size
> inode
->i_sb
->s_blocksize
)
213 if (ext2_xattr_cache_insert(ea_block_cache
, bh
))
214 ea_idebug(inode
, "cache insert failed");
217 if (size
> buffer_size
)
219 /* return value of attribute */
220 memcpy(buffer
, bh
->b_data
+ le16_to_cpu(entry
->e_value_offs
),
227 up_read(&EXT2_I(inode
)->xattr_sem
);
235 * Copy a list of attribute names into the buffer
236 * provided, or compute the buffer size required.
237 * Buffer is NULL to compute the size of the buffer required.
239 * Returns a negative error number on failure, or the number of bytes
240 * used / required on success.
243 ext2_xattr_list(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
245 struct inode
*inode
= d_inode(dentry
);
246 struct buffer_head
*bh
= NULL
;
247 struct ext2_xattr_entry
*entry
;
249 size_t rest
= buffer_size
;
251 struct mb_cache
*ea_block_cache
= EA_BLOCK_CACHE(inode
);
253 ea_idebug(inode
, "buffer=%p, buffer_size=%ld",
254 buffer
, (long)buffer_size
);
256 down_read(&EXT2_I(inode
)->xattr_sem
);
258 if (!EXT2_I(inode
)->i_file_acl
)
260 ea_idebug(inode
, "reading block %d", EXT2_I(inode
)->i_file_acl
);
261 bh
= sb_bread(inode
->i_sb
, EXT2_I(inode
)->i_file_acl
);
265 ea_bdebug(bh
, "b_count=%d, refcount=%d",
266 atomic_read(&(bh
->b_count
)), le32_to_cpu(HDR(bh
)->h_refcount
));
267 end
= bh
->b_data
+ bh
->b_size
;
268 if (HDR(bh
)->h_magic
!= cpu_to_le32(EXT2_XATTR_MAGIC
) ||
269 HDR(bh
)->h_blocks
!= cpu_to_le32(1)) {
270 bad_block
: ext2_error(inode
->i_sb
, "ext2_xattr_list",
271 "inode %ld: bad block %d", inode
->i_ino
,
272 EXT2_I(inode
)->i_file_acl
);
277 /* check the on-disk data structure */
278 entry
= FIRST_ENTRY(bh
);
279 while (!IS_LAST_ENTRY(entry
)) {
280 struct ext2_xattr_entry
*next
= EXT2_XATTR_NEXT(entry
);
282 if ((char *)next
>= end
)
286 if (ext2_xattr_cache_insert(ea_block_cache
, bh
))
287 ea_idebug(inode
, "cache insert failed");
289 /* list the attribute names */
290 for (entry
= FIRST_ENTRY(bh
); !IS_LAST_ENTRY(entry
);
291 entry
= EXT2_XATTR_NEXT(entry
)) {
292 const struct xattr_handler
*handler
=
293 ext2_xattr_handler(entry
->e_name_index
);
295 if (handler
&& (!handler
->list
|| handler
->list(dentry
))) {
296 const char *prefix
= handler
->prefix
?: handler
->name
;
297 size_t prefix_len
= strlen(prefix
);
298 size_t size
= prefix_len
+ entry
->e_name_len
+ 1;
305 memcpy(buffer
, prefix
, prefix_len
);
306 buffer
+= prefix_len
;
307 memcpy(buffer
, entry
->e_name
, entry
->e_name_len
);
308 buffer
+= entry
->e_name_len
;
314 error
= buffer_size
- rest
; /* total size */
318 up_read(&EXT2_I(inode
)->xattr_sem
);
324 * Inode operation listxattr()
326 * d_inode(dentry)->i_mutex: don't care
329 ext2_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
331 return ext2_xattr_list(dentry
, buffer
, size
);
335 * If the EXT2_FEATURE_COMPAT_EXT_ATTR feature of this file system is
338 static void ext2_xattr_update_super_block(struct super_block
*sb
)
340 if (EXT2_HAS_COMPAT_FEATURE(sb
, EXT2_FEATURE_COMPAT_EXT_ATTR
))
343 spin_lock(&EXT2_SB(sb
)->s_lock
);
344 EXT2_SET_COMPAT_FEATURE(sb
, EXT2_FEATURE_COMPAT_EXT_ATTR
);
345 spin_unlock(&EXT2_SB(sb
)->s_lock
);
346 mark_buffer_dirty(EXT2_SB(sb
)->s_sbh
);
352 * Create, replace or remove an extended attribute for this inode. Value
353 * is NULL to remove an existing extended attribute, and non-NULL to
354 * either replace an existing extended attribute, or create a new extended
355 * attribute. The flags XATTR_REPLACE and XATTR_CREATE
356 * specify that an extended attribute must exist and must not exist
357 * previous to the call, respectively.
359 * Returns 0, or a negative error number on failure.
362 ext2_xattr_set(struct inode
*inode
, int name_index
, const char *name
,
363 const void *value
, size_t value_len
, int flags
)
365 struct super_block
*sb
= inode
->i_sb
;
366 struct buffer_head
*bh
= NULL
;
367 struct ext2_xattr_header
*header
= NULL
;
368 struct ext2_xattr_entry
*here
, *last
;
369 size_t name_len
, free
, min_offs
= sb
->s_blocksize
;
370 int not_found
= 1, error
;
374 * header -- Points either into bh, or to a temporarily
376 * here -- The named entry found, or the place for inserting, within
377 * the block pointed to by header.
378 * last -- Points right after the last named entry within the block
379 * pointed to by header.
380 * min_offs -- The offset of the first value (values are aligned
381 * towards the end of the block).
382 * end -- Points right after the block pointed to by header.
385 ea_idebug(inode
, "name=%d.%s, value=%p, value_len=%ld",
386 name_index
, name
, value
, (long)value_len
);
392 name_len
= strlen(name
);
393 if (name_len
> 255 || value_len
> sb
->s_blocksize
)
395 down_write(&EXT2_I(inode
)->xattr_sem
);
396 if (EXT2_I(inode
)->i_file_acl
) {
397 /* The inode already has an extended attribute block. */
398 bh
= sb_bread(sb
, EXT2_I(inode
)->i_file_acl
);
402 ea_bdebug(bh
, "b_count=%d, refcount=%d",
403 atomic_read(&(bh
->b_count
)),
404 le32_to_cpu(HDR(bh
)->h_refcount
));
406 end
= bh
->b_data
+ bh
->b_size
;
407 if (header
->h_magic
!= cpu_to_le32(EXT2_XATTR_MAGIC
) ||
408 header
->h_blocks
!= cpu_to_le32(1)) {
409 bad_block
: ext2_error(sb
, "ext2_xattr_set",
410 "inode %ld: bad block %d", inode
->i_ino
,
411 EXT2_I(inode
)->i_file_acl
);
415 /* Find the named attribute. */
416 here
= FIRST_ENTRY(bh
);
417 while (!IS_LAST_ENTRY(here
)) {
418 struct ext2_xattr_entry
*next
= EXT2_XATTR_NEXT(here
);
419 if ((char *)next
>= end
)
421 if (!here
->e_value_block
&& here
->e_value_size
) {
422 size_t offs
= le16_to_cpu(here
->e_value_offs
);
426 not_found
= name_index
- here
->e_name_index
;
428 not_found
= name_len
- here
->e_name_len
;
430 not_found
= memcmp(name
, here
->e_name
,name_len
);
436 /* We still need to compute min_offs and last. */
437 while (!IS_LAST_ENTRY(last
)) {
438 struct ext2_xattr_entry
*next
= EXT2_XATTR_NEXT(last
);
439 if ((char *)next
>= end
)
441 if (!last
->e_value_block
&& last
->e_value_size
) {
442 size_t offs
= le16_to_cpu(last
->e_value_offs
);
449 /* Check whether we have enough space left. */
450 free
= min_offs
- ((char*)last
- (char*)header
) - sizeof(__u32
);
452 /* We will use a new extended attribute block. */
453 free
= sb
->s_blocksize
-
454 sizeof(struct ext2_xattr_header
) - sizeof(__u32
);
455 here
= last
= NULL
; /* avoid gcc uninitialized warning. */
459 /* Request to remove a nonexistent attribute? */
461 if (flags
& XATTR_REPLACE
)
467 /* Request to create an existing attribute? */
469 if (flags
& XATTR_CREATE
)
471 if (!here
->e_value_block
&& here
->e_value_size
) {
472 size_t size
= le32_to_cpu(here
->e_value_size
);
474 if (le16_to_cpu(here
->e_value_offs
) + size
>
475 sb
->s_blocksize
|| size
> sb
->s_blocksize
)
477 free
+= EXT2_XATTR_SIZE(size
);
479 free
+= EXT2_XATTR_LEN(name_len
);
482 if (free
< EXT2_XATTR_LEN(name_len
) + EXT2_XATTR_SIZE(value_len
))
485 /* Here we know that we can set the new attribute. */
488 /* assert(header == HDR(bh)); */
490 if (header
->h_refcount
== cpu_to_le32(1)) {
491 __u32 hash
= le32_to_cpu(header
->h_hash
);
493 ea_bdebug(bh
, "modifying in-place");
495 * This must happen under buffer lock for
496 * ext2_xattr_set2() to reliably detect modified block
498 mb_cache_entry_delete(EA_BLOCK_CACHE(inode
), hash
,
501 /* keep the buffer locked while modifying it. */
506 ea_bdebug(bh
, "cloning");
507 header
= kmalloc(bh
->b_size
, GFP_KERNEL
);
511 memcpy(header
, HDR(bh
), bh
->b_size
);
512 header
->h_refcount
= cpu_to_le32(1);
514 offset
= (char *)here
- bh
->b_data
;
515 here
= ENTRY((char *)header
+ offset
);
516 offset
= (char *)last
- bh
->b_data
;
517 last
= ENTRY((char *)header
+ offset
);
520 /* Allocate a buffer where we construct the new block. */
521 header
= kzalloc(sb
->s_blocksize
, GFP_KERNEL
);
525 end
= (char *)header
+ sb
->s_blocksize
;
526 header
->h_magic
= cpu_to_le32(EXT2_XATTR_MAGIC
);
527 header
->h_blocks
= header
->h_refcount
= cpu_to_le32(1);
528 last
= here
= ENTRY(header
+1);
531 /* Iff we are modifying the block in-place, bh is locked here. */
534 /* Insert the new name. */
535 size_t size
= EXT2_XATTR_LEN(name_len
);
536 size_t rest
= (char *)last
- (char *)here
;
537 memmove((char *)here
+ size
, here
, rest
);
538 memset(here
, 0, size
);
539 here
->e_name_index
= name_index
;
540 here
->e_name_len
= name_len
;
541 memcpy(here
->e_name
, name
, name_len
);
543 if (!here
->e_value_block
&& here
->e_value_size
) {
544 char *first_val
= (char *)header
+ min_offs
;
545 size_t offs
= le16_to_cpu(here
->e_value_offs
);
546 char *val
= (char *)header
+ offs
;
547 size_t size
= EXT2_XATTR_SIZE(
548 le32_to_cpu(here
->e_value_size
));
550 if (size
== EXT2_XATTR_SIZE(value_len
)) {
551 /* The old and the new value have the same
552 size. Just replace. */
553 here
->e_value_size
= cpu_to_le32(value_len
);
554 memset(val
+ size
- EXT2_XATTR_PAD
, 0,
555 EXT2_XATTR_PAD
); /* Clear pad bytes. */
556 memcpy(val
, value
, value_len
);
560 /* Remove the old value. */
561 memmove(first_val
+ size
, first_val
, val
- first_val
);
562 memset(first_val
, 0, size
);
563 here
->e_value_offs
= 0;
566 /* Adjust all value offsets. */
567 last
= ENTRY(header
+1);
568 while (!IS_LAST_ENTRY(last
)) {
569 size_t o
= le16_to_cpu(last
->e_value_offs
);
570 if (!last
->e_value_block
&& o
< offs
)
572 cpu_to_le16(o
+ size
);
573 last
= EXT2_XATTR_NEXT(last
);
577 /* Remove the old name. */
578 size_t size
= EXT2_XATTR_LEN(name_len
);
579 last
= ENTRY((char *)last
- size
);
580 memmove(here
, (char*)here
+ size
,
581 (char*)last
- (char*)here
);
582 memset(last
, 0, size
);
587 /* Insert the new value. */
588 here
->e_value_size
= cpu_to_le32(value_len
);
590 size_t size
= EXT2_XATTR_SIZE(value_len
);
591 char *val
= (char *)header
+ min_offs
- size
;
593 cpu_to_le16((char *)val
- (char *)header
);
594 memset(val
+ size
- EXT2_XATTR_PAD
, 0,
595 EXT2_XATTR_PAD
); /* Clear the pad bytes. */
596 memcpy(val
, value
, value_len
);
601 if (IS_LAST_ENTRY(ENTRY(header
+1))) {
602 /* This block is now empty. */
603 if (bh
&& header
== HDR(bh
))
604 unlock_buffer(bh
); /* we were modifying in-place. */
605 error
= ext2_xattr_set2(inode
, bh
, NULL
);
607 ext2_xattr_rehash(header
, here
);
608 if (bh
&& header
== HDR(bh
))
609 unlock_buffer(bh
); /* we were modifying in-place. */
610 error
= ext2_xattr_set2(inode
, bh
, header
);
615 if (!(bh
&& header
== HDR(bh
)))
617 up_write(&EXT2_I(inode
)->xattr_sem
);
623 * Second half of ext2_xattr_set(): Update the file system.
626 ext2_xattr_set2(struct inode
*inode
, struct buffer_head
*old_bh
,
627 struct ext2_xattr_header
*header
)
629 struct super_block
*sb
= inode
->i_sb
;
630 struct buffer_head
*new_bh
= NULL
;
632 struct mb_cache
*ea_block_cache
= EA_BLOCK_CACHE(inode
);
635 new_bh
= ext2_xattr_cache_find(inode
, header
);
637 /* We found an identical block in the cache. */
638 if (new_bh
== old_bh
) {
639 ea_bdebug(new_bh
, "keeping this block");
641 /* The old block is released after updating
643 ea_bdebug(new_bh
, "reusing block");
645 error
= dquot_alloc_block(inode
, 1);
647 unlock_buffer(new_bh
);
650 le32_add_cpu(&HDR(new_bh
)->h_refcount
, 1);
651 ea_bdebug(new_bh
, "refcount now=%d",
652 le32_to_cpu(HDR(new_bh
)->h_refcount
));
654 unlock_buffer(new_bh
);
655 } else if (old_bh
&& header
== HDR(old_bh
)) {
656 /* Keep this block. No need to lock the block as we
657 don't need to change the reference count. */
660 ext2_xattr_cache_insert(ea_block_cache
, new_bh
);
662 /* We need to allocate a new block */
663 ext2_fsblk_t goal
= ext2_group_first_block_no(sb
,
664 EXT2_I(inode
)->i_block_group
);
665 int block
= ext2_new_block(inode
, goal
, &error
);
668 ea_idebug(inode
, "creating block %d", block
);
670 new_bh
= sb_getblk(sb
, block
);
671 if (unlikely(!new_bh
)) {
672 ext2_free_blocks(inode
, block
, 1);
673 mark_inode_dirty(inode
);
678 memcpy(new_bh
->b_data
, header
, new_bh
->b_size
);
679 set_buffer_uptodate(new_bh
);
680 unlock_buffer(new_bh
);
681 ext2_xattr_cache_insert(ea_block_cache
, new_bh
);
683 ext2_xattr_update_super_block(sb
);
685 mark_buffer_dirty(new_bh
);
686 if (IS_SYNC(inode
)) {
687 sync_dirty_buffer(new_bh
);
689 if (buffer_req(new_bh
) && !buffer_uptodate(new_bh
))
694 /* Update the inode. */
695 EXT2_I(inode
)->i_file_acl
= new_bh
? new_bh
->b_blocknr
: 0;
696 inode
->i_ctime
= current_time(inode
);
697 if (IS_SYNC(inode
)) {
698 error
= sync_inode_metadata(inode
, 1);
699 /* In case sync failed due to ENOSPC the inode was actually
700 * written (only some dirty data were not) so we just proceed
701 * as if nothing happened and cleanup the unused block */
702 if (error
&& error
!= -ENOSPC
) {
703 if (new_bh
&& new_bh
!= old_bh
) {
704 dquot_free_block_nodirty(inode
, 1);
705 mark_inode_dirty(inode
);
710 mark_inode_dirty(inode
);
713 if (old_bh
&& old_bh
!= new_bh
) {
715 * If there was an old block and we are no longer using it,
716 * release the old block.
719 if (HDR(old_bh
)->h_refcount
== cpu_to_le32(1)) {
720 __u32 hash
= le32_to_cpu(HDR(old_bh
)->h_hash
);
723 * This must happen under buffer lock for
724 * ext2_xattr_set2() to reliably detect freed block
726 mb_cache_entry_delete(ea_block_cache
, hash
,
728 /* Free the old block. */
729 ea_bdebug(old_bh
, "freeing");
730 ext2_free_blocks(inode
, old_bh
->b_blocknr
, 1);
731 mark_inode_dirty(inode
);
732 /* We let our caller release old_bh, so we
733 * need to duplicate the buffer before. */
737 /* Decrement the refcount only. */
738 le32_add_cpu(&HDR(old_bh
)->h_refcount
, -1);
739 dquot_free_block_nodirty(inode
, 1);
740 mark_inode_dirty(inode
);
741 mark_buffer_dirty(old_bh
);
742 ea_bdebug(old_bh
, "refcount now=%d",
743 le32_to_cpu(HDR(old_bh
)->h_refcount
));
745 unlock_buffer(old_bh
);
755 * ext2_xattr_delete_inode()
757 * Free extended attribute resources associated with this inode. This
758 * is called immediately before an inode is freed.
761 ext2_xattr_delete_inode(struct inode
*inode
)
763 struct buffer_head
*bh
= NULL
;
764 struct ext2_sb_info
*sbi
= EXT2_SB(inode
->i_sb
);
766 down_write(&EXT2_I(inode
)->xattr_sem
);
767 if (!EXT2_I(inode
)->i_file_acl
)
770 if (!ext2_data_block_valid(sbi
, EXT2_I(inode
)->i_file_acl
, 0)) {
771 ext2_error(inode
->i_sb
, "ext2_xattr_delete_inode",
772 "inode %ld: xattr block %d is out of data blocks range",
773 inode
->i_ino
, EXT2_I(inode
)->i_file_acl
);
777 bh
= sb_bread(inode
->i_sb
, EXT2_I(inode
)->i_file_acl
);
779 ext2_error(inode
->i_sb
, "ext2_xattr_delete_inode",
780 "inode %ld: block %d read error", inode
->i_ino
,
781 EXT2_I(inode
)->i_file_acl
);
784 ea_bdebug(bh
, "b_count=%d", atomic_read(&(bh
->b_count
)));
785 if (HDR(bh
)->h_magic
!= cpu_to_le32(EXT2_XATTR_MAGIC
) ||
786 HDR(bh
)->h_blocks
!= cpu_to_le32(1)) {
787 ext2_error(inode
->i_sb
, "ext2_xattr_delete_inode",
788 "inode %ld: bad block %d", inode
->i_ino
,
789 EXT2_I(inode
)->i_file_acl
);
793 if (HDR(bh
)->h_refcount
== cpu_to_le32(1)) {
794 __u32 hash
= le32_to_cpu(HDR(bh
)->h_hash
);
797 * This must happen under buffer lock for ext2_xattr_set2() to
798 * reliably detect freed block
800 mb_cache_entry_delete(EA_BLOCK_CACHE(inode
), hash
,
802 ext2_free_blocks(inode
, EXT2_I(inode
)->i_file_acl
, 1);
807 le32_add_cpu(&HDR(bh
)->h_refcount
, -1);
808 ea_bdebug(bh
, "refcount now=%d",
809 le32_to_cpu(HDR(bh
)->h_refcount
));
811 mark_buffer_dirty(bh
);
813 sync_dirty_buffer(bh
);
814 dquot_free_block_nodirty(inode
, 1);
816 EXT2_I(inode
)->i_file_acl
= 0;
820 up_write(&EXT2_I(inode
)->xattr_sem
);
824 * ext2_xattr_cache_insert()
826 * Create a new entry in the extended attribute cache, and insert
827 * it unless such an entry is already in the cache.
829 * Returns 0, or a negative error number on failure.
832 ext2_xattr_cache_insert(struct mb_cache
*cache
, struct buffer_head
*bh
)
834 __u32 hash
= le32_to_cpu(HDR(bh
)->h_hash
);
837 error
= mb_cache_entry_create(cache
, GFP_NOFS
, hash
, bh
->b_blocknr
, 1);
839 if (error
== -EBUSY
) {
840 ea_bdebug(bh
, "already in cache (%d cache entries)",
841 atomic_read(&ext2_xattr_cache
->c_entry_count
));
845 ea_bdebug(bh
, "inserting [%x]", (int)hash
);
852 * Compare two extended attribute blocks for equality.
854 * Returns 0 if the blocks are equal, 1 if they differ, and
855 * a negative error number on errors.
858 ext2_xattr_cmp(struct ext2_xattr_header
*header1
,
859 struct ext2_xattr_header
*header2
)
861 struct ext2_xattr_entry
*entry1
, *entry2
;
863 entry1
= ENTRY(header1
+1);
864 entry2
= ENTRY(header2
+1);
865 while (!IS_LAST_ENTRY(entry1
)) {
866 if (IS_LAST_ENTRY(entry2
))
868 if (entry1
->e_hash
!= entry2
->e_hash
||
869 entry1
->e_name_index
!= entry2
->e_name_index
||
870 entry1
->e_name_len
!= entry2
->e_name_len
||
871 entry1
->e_value_size
!= entry2
->e_value_size
||
872 memcmp(entry1
->e_name
, entry2
->e_name
, entry1
->e_name_len
))
874 if (entry1
->e_value_block
!= 0 || entry2
->e_value_block
!= 0)
876 if (memcmp((char *)header1
+ le16_to_cpu(entry1
->e_value_offs
),
877 (char *)header2
+ le16_to_cpu(entry2
->e_value_offs
),
878 le32_to_cpu(entry1
->e_value_size
)))
881 entry1
= EXT2_XATTR_NEXT(entry1
);
882 entry2
= EXT2_XATTR_NEXT(entry2
);
884 if (!IS_LAST_ENTRY(entry2
))
890 * ext2_xattr_cache_find()
892 * Find an identical extended attribute block.
894 * Returns a locked buffer head to the block found, or NULL if such
895 * a block was not found or an error occurred.
897 static struct buffer_head
*
898 ext2_xattr_cache_find(struct inode
*inode
, struct ext2_xattr_header
*header
)
900 __u32 hash
= le32_to_cpu(header
->h_hash
);
901 struct mb_cache_entry
*ce
;
902 struct mb_cache
*ea_block_cache
= EA_BLOCK_CACHE(inode
);
905 return NULL
; /* never share */
906 ea_idebug(inode
, "looking for cached blocks [%x]", (int)hash
);
908 ce
= mb_cache_entry_find_first(ea_block_cache
, hash
);
910 struct buffer_head
*bh
;
912 bh
= sb_bread(inode
->i_sb
, ce
->e_value
);
914 ext2_error(inode
->i_sb
, "ext2_xattr_cache_find",
915 "inode %ld: block %ld read error",
916 inode
->i_ino
, (unsigned long) ce
->e_value
);
920 * We have to be careful about races with freeing or
921 * rehashing of xattr block. Once we hold buffer lock
922 * xattr block's state is stable so we can check
923 * whether the block got freed / rehashed or not.
924 * Since we unhash mbcache entry under buffer lock when
925 * freeing / rehashing xattr block, checking whether
926 * entry is still hashed is reliable.
928 if (hlist_bl_unhashed(&ce
->e_hash_list
)) {
929 mb_cache_entry_put(ea_block_cache
, ce
);
933 } else if (le32_to_cpu(HDR(bh
)->h_refcount
) >
934 EXT2_XATTR_REFCOUNT_MAX
) {
935 ea_idebug(inode
, "block %ld refcount %d>%d",
936 (unsigned long) ce
->e_value
,
937 le32_to_cpu(HDR(bh
)->h_refcount
),
938 EXT2_XATTR_REFCOUNT_MAX
);
939 } else if (!ext2_xattr_cmp(header
, HDR(bh
))) {
940 ea_bdebug(bh
, "b_count=%d",
941 atomic_read(&(bh
->b_count
)));
942 mb_cache_entry_touch(ea_block_cache
, ce
);
943 mb_cache_entry_put(ea_block_cache
, ce
);
949 ce
= mb_cache_entry_find_next(ea_block_cache
, ce
);
954 #define NAME_HASH_SHIFT 5
955 #define VALUE_HASH_SHIFT 16
958 * ext2_xattr_hash_entry()
960 * Compute the hash of an extended attribute.
962 static inline void ext2_xattr_hash_entry(struct ext2_xattr_header
*header
,
963 struct ext2_xattr_entry
*entry
)
966 char *name
= entry
->e_name
;
969 for (n
=0; n
< entry
->e_name_len
; n
++) {
970 hash
= (hash
<< NAME_HASH_SHIFT
) ^
971 (hash
>> (8*sizeof(hash
) - NAME_HASH_SHIFT
)) ^
975 if (entry
->e_value_block
== 0 && entry
->e_value_size
!= 0) {
976 __le32
*value
= (__le32
*)((char *)header
+
977 le16_to_cpu(entry
->e_value_offs
));
978 for (n
= (le32_to_cpu(entry
->e_value_size
) +
979 EXT2_XATTR_ROUND
) >> EXT2_XATTR_PAD_BITS
; n
; n
--) {
980 hash
= (hash
<< VALUE_HASH_SHIFT
) ^
981 (hash
>> (8*sizeof(hash
) - VALUE_HASH_SHIFT
)) ^
982 le32_to_cpu(*value
++);
985 entry
->e_hash
= cpu_to_le32(hash
);
988 #undef NAME_HASH_SHIFT
989 #undef VALUE_HASH_SHIFT
991 #define BLOCK_HASH_SHIFT 16
994 * ext2_xattr_rehash()
996 * Re-compute the extended attribute hash value after an entry has changed.
998 static void ext2_xattr_rehash(struct ext2_xattr_header
*header
,
999 struct ext2_xattr_entry
*entry
)
1001 struct ext2_xattr_entry
*here
;
1004 ext2_xattr_hash_entry(header
, entry
);
1005 here
= ENTRY(header
+1);
1006 while (!IS_LAST_ENTRY(here
)) {
1007 if (!here
->e_hash
) {
1008 /* Block is not shared if an entry's hash value == 0 */
1012 hash
= (hash
<< BLOCK_HASH_SHIFT
) ^
1013 (hash
>> (8*sizeof(hash
) - BLOCK_HASH_SHIFT
)) ^
1014 le32_to_cpu(here
->e_hash
);
1015 here
= EXT2_XATTR_NEXT(here
);
1017 header
->h_hash
= cpu_to_le32(hash
);
1020 #undef BLOCK_HASH_SHIFT
1022 #define HASH_BUCKET_BITS 10
1024 struct mb_cache
*ext2_xattr_create_cache(void)
1026 return mb_cache_create(HASH_BUCKET_BITS
);
1029 void ext2_xattr_destroy_cache(struct mb_cache
*cache
)
1032 mb_cache_destroy(cache
);