2 * ext_attr.c --- extended attribute blocks
4 * Copyright (C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org>
6 * Copyright (C) 2002 Theodore Ts'o.
9 * This file may be redistributed under the terms of the GNU Library
10 * General Public License, version 2.
23 #include "ext2_ext_attr.h"
28 static errcode_t read_ea_inode_hash(ext2_filsys fs, ext2_ino_t ino, __u32 *hash)
30 struct ext2_inode inode;
33 retval = ext2fs_read_inode(fs, ino, &inode);
36 *hash = ext2fs_get_ea_inode_hash(&inode);
40 #define NAME_HASH_SHIFT 5
41 #define VALUE_HASH_SHIFT 16
44 * ext2_xattr_hash_entry()
46 * Compute the hash of an extended attribute.
48 __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry, void *data)
51 char *name = ((char *) entry) + sizeof(struct ext2_ext_attr_entry);
54 for (n = 0; n < entry->e_name_len; n++) {
55 hash = (hash << NAME_HASH_SHIFT) ^
56 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
60 /* The hash needs to be calculated on the data in little-endian. */
61 if (entry->e_value_inum == 0 && entry->e_value_size != 0) {
62 __u32 *value = (__u32 *)data;
63 for (n = (entry->e_value_size + EXT2_EXT_ATTR_ROUND) >>
64 EXT2_EXT_ATTR_PAD_BITS; n; n--) {
65 hash = (hash << VALUE_HASH_SHIFT) ^
66 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
67 ext2fs_le32_to_cpu(*value++);
75 * ext2fs_ext_attr_hash_entry2()
77 * Compute the hash of an extended attribute.
78 * This version of the function supports hashing entries that reference
79 * external inodes (ea_inode feature).
81 errcode_t ext2fs_ext_attr_hash_entry2(ext2_filsys fs,
82 struct ext2_ext_attr_entry *entry,
83 void *data, __u32 *hash)
85 *hash = ext2fs_ext_attr_hash_entry(entry, data);
87 if (entry->e_value_inum) {
91 retval = read_ea_inode_hash(fs, entry->e_value_inum,
96 *hash = (*hash << VALUE_HASH_SHIFT) ^
97 (*hash >> (8*sizeof(*hash) - VALUE_HASH_SHIFT)) ^
103 #undef NAME_HASH_SHIFT
104 #undef VALUE_HASH_SHIFT
106 #define BLOCK_HASH_SHIFT 16
108 /* Mirrors ext4_xattr_rehash() implementation in kernel. */
109 void ext2fs_ext_attr_block_rehash(struct ext2_ext_attr_header *header,
110 struct ext2_ext_attr_entry *end)
112 struct ext2_ext_attr_entry *here;
115 here = (struct ext2_ext_attr_entry *)(header+1);
116 while (here < end && !EXT2_EXT_IS_LAST_ENTRY(here)) {
118 /* Block is not shared if an entry's hash value == 0 */
122 hash = (hash << BLOCK_HASH_SHIFT) ^
123 (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
125 here = EXT2_EXT_ATTR_NEXT(here);
127 header->h_hash = hash;
130 #undef BLOCK_HASH_SHIFT
132 __u32 ext2fs_get_ea_inode_hash(struct ext2_inode *inode)
134 return inode->i_atime;
137 void ext2fs_set_ea_inode_hash(struct ext2_inode *inode, __u32 hash)
139 inode->i_atime = hash;
142 __u64 ext2fs_get_ea_inode_ref(struct ext2_inode *inode)
144 return ((__u64)inode->i_ctime << 32) | inode->osd1.linux1.l_i_version;
147 void ext2fs_set_ea_inode_ref(struct ext2_inode *inode, __u64 ref_count)
149 inode->i_ctime = (__u32)(ref_count >> 32);
150 inode->osd1.linux1.l_i_version = (__u32)ref_count;
153 static errcode_t check_ext_attr_header(struct ext2_ext_attr_header *header)
155 if ((header->h_magic != EXT2_EXT_ATTR_MAGIC_v1 &&
156 header->h_magic != EXT2_EXT_ATTR_MAGIC) ||
157 header->h_blocks != 1)
158 return EXT2_ET_BAD_EA_HEADER;
163 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
169 retval = io_channel_read_blk64(fs->io, block, 1, buf);
173 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
174 !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf))
177 #ifdef WORDS_BIGENDIAN
178 ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1);
181 retval = check_ext_attr_header(buf);
182 if (retval == 0 && csum_failed)
183 retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
188 errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf)
190 return ext2fs_read_ext_attr3(fs, block, buf, 0);
193 errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf)
195 return ext2fs_read_ext_attr2(fs, block, buf);
198 errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *inbuf,
204 #ifdef WORDS_BIGENDIAN
205 retval = ext2fs_get_mem(fs->blocksize, &write_buf);
208 ext2fs_swap_ext_attr(write_buf, inbuf, fs->blocksize, 1);
210 write_buf = (char *) inbuf;
213 retval = ext2fs_ext_attr_block_csum_set(fs, inum, block,
214 (struct ext2_ext_attr_header *)write_buf);
218 retval = io_channel_write_blk64(fs->io, block, 1, write_buf);
219 #ifdef WORDS_BIGENDIAN
220 ext2fs_free_mem(&write_buf);
223 ext2fs_mark_changed(fs);
227 errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *inbuf)
229 return ext2fs_write_ext_attr3(fs, block, inbuf, 0);
232 errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf)
234 return ext2fs_write_ext_attr2(fs, block, inbuf);
238 * This function adjusts the reference count of the EA block.
240 errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk,
241 char *block_buf, int adjust,
242 __u32 *newcount, ext2_ino_t inum)
245 struct ext2_ext_attr_header *header;
248 if ((blk >= ext2fs_blocks_count(fs->super)) ||
249 (blk < fs->super->s_first_data_block))
250 return EXT2_ET_BAD_EA_BLOCK_NUM;
253 retval = ext2fs_get_mem(fs->blocksize, &buf);
259 retval = ext2fs_read_ext_attr3(fs, blk, block_buf, inum);
263 header = (struct ext2_ext_attr_header *) block_buf;
264 header->h_refcount += adjust;
266 *newcount = header->h_refcount;
268 retval = ext2fs_write_ext_attr3(fs, blk, block_buf, inum);
274 ext2fs_free_mem(&buf);
278 errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
279 char *block_buf, int adjust,
282 return ext2fs_adjust_ea_refcount3(fs, blk, block_buf, adjust,
286 errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
287 char *block_buf, int adjust,
290 return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust,
294 /* Manipulate the contents of extended attribute regions */
298 unsigned int value_len;
302 struct ext2_xattr_handle {
305 struct ext2_xattr *attrs;
313 static errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h,
314 unsigned int expandby)
316 struct ext2_xattr *new_attrs;
319 err = ext2fs_get_arrayzero(h->capacity + expandby,
320 sizeof(struct ext2_xattr), &new_attrs);
324 memcpy(new_attrs, h->attrs, h->capacity * sizeof(struct ext2_xattr));
325 ext2fs_free_mem(&h->attrs);
326 h->capacity += expandby;
327 h->attrs = new_attrs;
332 struct ea_name_index {
337 /* Keep these names sorted in order of decreasing specificity. */
338 static struct ea_name_index ea_names[] = {
340 {3, "system.posix_acl_default"},
341 {2, "system.posix_acl_access"},
342 {8, "system.richacl"},
350 static const char *find_ea_prefix(int index)
352 struct ea_name_index *e;
354 for (e = ea_names; e->name; e++)
355 if (e->index == index)
361 static int find_ea_index(const char *fullname, const char **name, int *index)
363 struct ea_name_index *e;
365 for (e = ea_names; e->name; e++) {
366 if (strncmp(fullname, e->name, strlen(e->name)) == 0) {
367 *name = fullname + strlen(e->name);
375 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
376 struct ext2_inode_large *inode)
378 struct ext2_ext_attr_header *header;
379 void *block_buf = NULL;
382 struct ext2_inode_large i;
386 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i,
387 sizeof(struct ext2_inode_large));
393 /* Do we already have an EA block? */
394 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
398 /* Find block, zero it, write back */
399 if ((blk < fs->super->s_first_data_block) ||
400 (blk >= ext2fs_blocks_count(fs->super))) {
401 err = EXT2_ET_BAD_EA_BLOCK_NUM;
405 err = ext2fs_get_mem(fs->blocksize, &block_buf);
409 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
413 /* We only know how to deal with v2 EA blocks */
414 header = (struct ext2_ext_attr_header *) block_buf;
415 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
416 err = EXT2_ET_BAD_EA_HEADER;
420 header->h_refcount--;
421 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
425 /* Erase link to block */
426 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0);
427 if (header->h_refcount == 0)
428 ext2fs_block_alloc_stats2(fs, blk, -1);
429 err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1);
435 err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i,
436 sizeof(struct ext2_inode_large));
442 ext2fs_free_mem(&block_buf);
447 static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino,
448 struct ext2_inode_large *inode)
450 struct ext2_ext_attr_header *header;
451 void *block_buf = NULL;
455 /* Do we already have an EA block? */
456 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
458 if ((blk < fs->super->s_first_data_block) ||
459 (blk >= ext2fs_blocks_count(fs->super))) {
460 err = EXT2_ET_BAD_EA_BLOCK_NUM;
464 err = ext2fs_get_mem(fs->blocksize, &block_buf);
468 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
472 /* We only know how to deal with v2 EA blocks */
473 header = (struct ext2_ext_attr_header *) block_buf;
474 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
475 err = EXT2_ET_BAD_EA_HEADER;
479 /* Single-user block. We're done here. */
480 if (header->h_refcount == 1)
483 /* We need to CoW the block. */
484 header->h_refcount--;
485 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
489 /* No block, we must increment i_blocks */
490 err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode,
496 /* Allocate a block */
497 goal = ext2fs_find_inode_goal(fs, ino, (struct ext2_inode *)inode, 0);
498 err = ext2fs_alloc_block2(fs, goal, NULL, &blk);
501 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk);
504 ext2fs_free_mem(&block_buf);
511 posix_acl_xattr_count(size_t size)
513 if (size < sizeof(posix_acl_xattr_header))
515 size -= sizeof(posix_acl_xattr_header);
516 if (size % sizeof(posix_acl_xattr_entry))
518 return size / sizeof(posix_acl_xattr_entry);
522 * The lgetxattr function returns data formatted in the POSIX extended
523 * attribute format. The on-disk format uses a more compact encoding.
524 * See the ext4_acl_to_disk in fs/ext4/acl.c.
526 static errcode_t convert_posix_acl_to_disk_buffer(const void *value, size_t size,
527 void *out_buf, size_t *size_out)
529 const posix_acl_xattr_header *header =
530 (const posix_acl_xattr_header*) value;
531 const posix_acl_xattr_entry *end, *entry =
532 (const posix_acl_xattr_entry *)(header+1);
533 ext4_acl_header *ext_acl;
541 if (size < sizeof(posix_acl_xattr_header))
543 if (header->a_version != ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION))
546 count = posix_acl_xattr_count(size);
548 ext_acl->a_version = ext2fs_cpu_to_le32(EXT4_ACL_VERSION);
553 e = (char *) out_buf + sizeof(ext4_acl_header);
554 s = sizeof(ext4_acl_header);
555 for (end = entry + count; entry != end;entry++) {
556 ext4_acl_entry *disk_entry = (ext4_acl_entry*) e;
557 disk_entry->e_tag = ext2fs_cpu_to_le16(entry->e_tag);
558 disk_entry->e_perm = ext2fs_cpu_to_le16(entry->e_perm);
560 switch(entry->e_tag) {
565 e += sizeof(ext4_acl_entry_short);
566 s += sizeof(ext4_acl_entry_short);
570 disk_entry->e_id = ext2fs_cpu_to_le32(entry->e_id);
571 e += sizeof(ext4_acl_entry);
572 s += sizeof(ext4_acl_entry);
580 static errcode_t convert_disk_buffer_to_posix_acl(const void *value, size_t size,
581 void **out_buf, size_t *size_out)
583 posix_acl_xattr_header *header;
584 posix_acl_xattr_entry *entry;
585 const ext4_acl_header *ext_acl = (const ext4_acl_header *) value;
591 (size < sizeof(ext4_acl_header)) ||
592 (ext_acl->a_version != ext2fs_cpu_to_le32(EXT4_ACL_VERSION)))
595 err = ext2fs_get_mem(size * 2, &out);
599 header = (posix_acl_xattr_header *) out;
600 header->a_version = ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION);
601 entry = (posix_acl_xattr_entry *) (out + sizeof(posix_acl_xattr_header));
603 cp = (const char *) value + sizeof(ext4_acl_header);
604 size -= sizeof(ext4_acl_header);
607 const ext4_acl_entry *disk_entry = (const ext4_acl_entry *) cp;
609 entry->e_tag = ext2fs_le16_to_cpu(disk_entry->e_tag);
610 entry->e_perm = ext2fs_le16_to_cpu(disk_entry->e_perm);
612 switch(entry->e_tag) {
618 cp += sizeof(ext4_acl_entry_short);
619 size -= sizeof(ext4_acl_entry_short);
623 entry->e_id = ext2fs_le32_to_cpu(disk_entry->e_id);
624 cp += sizeof(ext4_acl_entry);
625 size -= sizeof(ext4_acl_entry);
628 ext2fs_free_mem(&out);
635 *size_out = ((char *) entry - out);
640 write_xattrs_to_buffer(ext2_filsys fs, struct ext2_xattr *attrs, int count,
641 void *entries_start, unsigned int storage_size,
642 unsigned int value_offset_correction, int write_hash)
644 struct ext2_xattr *x;
645 struct ext2_ext_attr_entry *e = entries_start;
646 char *end = (char *) entries_start + storage_size;
647 const char *shortname;
648 unsigned int value_size;
652 memset(entries_start, 0, storage_size);
653 for (x = attrs; x < attrs + count; x++) {
654 /* Calculate index and shortname position */
656 ret = find_ea_index(x->name, &shortname, &idx);
658 value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) /
659 EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD;
661 /* Fill out e appropriately */
662 e->e_name_len = strlen(shortname);
663 e->e_name_index = (ret ? idx : 0);
665 e->e_value_size = x->value_len;
666 e->e_value_inum = x->ea_ino;
669 memcpy((char *)e + sizeof(*e), shortname, e->e_name_len);
674 e->e_value_offs = end - (char *) entries_start +
675 value_offset_correction;
676 memcpy(end, x->value, e->e_value_size);
679 if (write_hash || x->ea_ino) {
680 err = ext2fs_ext_attr_hash_entry2(fs, e,
688 e = EXT2_EXT_ATTR_NEXT(e);
694 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle)
696 ext2_filsys fs = handle->fs;
697 const unsigned int inode_size = EXT2_INODE_SIZE(fs->super);
698 struct ext2_inode_large *inode;
699 char *start, *block_buf = NULL;
700 struct ext2_ext_attr_header *header;
701 __u32 ea_inode_magic;
703 unsigned int storage_size;
707 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
709 if (i < sizeof(*inode))
711 err = ext2fs_get_memzero(i, &inode);
715 err = ext2fs_read_inode_full(fs, handle->ino, EXT2_INODE(inode),
720 /* If extra_isize isn't set, we need to set it now */
721 if (inode->i_extra_isize == 0 &&
722 inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
723 char *p = (char *)inode;
724 size_t extra = fs->super->s_want_extra_isize;
727 extra = sizeof(__u32);
728 memset(p + EXT2_GOOD_OLD_INODE_SIZE, 0, extra);
729 inode->i_extra_isize = extra;
731 if (inode->i_extra_isize & 3) {
732 err = EXT2_ET_INODE_CORRUPTED;
736 /* Does the inode have space for EA? */
737 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
738 inode_size <= EXT2_GOOD_OLD_INODE_SIZE + inode->i_extra_isize +
742 /* Write the inode EA */
743 ea_inode_magic = EXT2_EXT_ATTR_MAGIC;
744 memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
745 inode->i_extra_isize, &ea_inode_magic, sizeof(__u32));
746 storage_size = inode_size - EXT2_GOOD_OLD_INODE_SIZE -
747 inode->i_extra_isize - sizeof(__u32);
748 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
749 inode->i_extra_isize + sizeof(__u32);
751 err = write_xattrs_to_buffer(fs, handle->attrs, handle->ibody_count,
752 start, storage_size, 0, 0);
757 if (handle->ibody_count == handle->count &&
758 !ext2fs_file_acl_block(fs, EXT2_INODE(inode)))
761 /* Write the EA block */
762 err = ext2fs_get_memzero(fs->blocksize, &block_buf);
766 storage_size = fs->blocksize - sizeof(struct ext2_ext_attr_header);
767 start = block_buf + sizeof(struct ext2_ext_attr_header);
769 err = write_xattrs_to_buffer(fs, handle->attrs + handle->ibody_count,
770 handle->count - handle->ibody_count, start,
771 storage_size, start - block_buf, 1);
775 /* Write a header on the EA block */
776 header = (struct ext2_ext_attr_header *) block_buf;
777 header->h_magic = EXT2_EXT_ATTR_MAGIC;
778 header->h_refcount = 1;
779 header->h_blocks = 1;
781 /* Get a new block for writing */
782 err = prep_ea_block_for_write(fs, handle->ino, inode);
786 /* Finally, write the new EA block */
787 blk = ext2fs_file_acl_block(fs, EXT2_INODE(inode));
788 err = ext2fs_write_ext_attr3(fs, blk, block_buf, handle->ino);
793 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
794 if (!block_buf && blk) {
795 /* xattrs shrunk, free the block */
796 err = ext2fs_free_ext_attr(fs, handle->ino, inode);
801 /* Write the inode */
802 err = ext2fs_write_inode_full(fs, handle->ino, EXT2_INODE(inode),
808 ext2fs_free_mem(&block_buf);
810 ext2fs_free_mem(&inode);
814 static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle,
815 struct ext2_inode_large *inode,
816 struct ext2_ext_attr_entry *entries,
817 unsigned int storage_size,
820 struct ext2_xattr *x;
821 struct ext2_ext_attr_entry *entry, *end;
823 unsigned int remain, prefix_len;
825 unsigned int values_size = storage_size +
826 ((char *)entries - value_start);
830 remain = storage_size;
831 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
832 !EXT2_EXT_IS_LAST_ENTRY(end)) {
834 /* header eats this space */
835 remain -= sizeof(struct ext2_ext_attr_entry);
837 /* is attribute name valid? */
838 if (EXT2_EXT_ATTR_SIZE(end->e_name_len) > remain)
839 return EXT2_ET_EA_BAD_NAME_LEN;
841 /* attribute len eats this space */
842 remain -= EXT2_EXT_ATTR_SIZE(end->e_name_len);
843 end = EXT2_EXT_ATTR_NEXT(end);
847 remain = storage_size;
848 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
849 !EXT2_EXT_IS_LAST_ENTRY(entry)) {
851 /* Allocate space for more attrs? */
852 if (handle->count == handle->capacity) {
853 err = ext2fs_xattrs_expand(handle, 4);
858 x = handle->attrs + handle->count;
860 /* header eats this space */
861 remain -= sizeof(struct ext2_ext_attr_entry);
863 /* attribute len eats this space */
864 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
867 prefix = find_ea_prefix(entry->e_name_index);
868 prefix_len = (prefix ? strlen(prefix) : 0);
869 err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1,
874 memcpy(x->name, prefix, prefix_len);
875 if (entry->e_name_len)
876 memcpy(x->name + prefix_len,
877 (char *)entry + sizeof(*entry),
880 /* Check & copy value */
881 if (!ext2fs_has_feature_ea_inode(handle->fs->super) &&
882 entry->e_value_inum != 0)
883 return EXT2_ET_BAD_EA_BLOCK_NUM;
885 if (entry->e_value_inum == 0) {
886 if (entry->e_value_size > remain)
887 return EXT2_ET_EA_BAD_VALUE_SIZE;
889 if (entry->e_value_offs + entry->e_value_size > values_size)
890 return EXT2_ET_EA_BAD_VALUE_OFFSET;
892 if (entry->e_value_size > 0 &&
893 value_start + entry->e_value_offs <
894 (char *)end + sizeof(__u32))
895 return EXT2_ET_EA_BAD_VALUE_OFFSET;
897 remain -= entry->e_value_size;
899 err = ext2fs_get_mem(entry->e_value_size, &x->value);
902 memcpy(x->value, value_start + entry->e_value_offs,
903 entry->e_value_size);
905 struct ext2_inode *ea_inode;
908 if (entry->e_value_offs != 0)
909 return EXT2_ET_EA_BAD_VALUE_OFFSET;
911 if (entry->e_value_size > (64 * 1024))
912 return EXT2_ET_EA_BAD_VALUE_SIZE;
914 err = ext2fs_get_mem(entry->e_value_size, &x->value);
918 err = ext2fs_file_open(handle->fs, entry->e_value_inum,
923 ea_inode = ext2fs_file_get_inode(ea_file);
924 if ((ea_inode->i_flags & EXT4_INLINE_DATA_FL) ||
925 !(ea_inode->i_flags & EXT4_EA_INODE_FL) ||
926 ea_inode->i_links_count == 0)
927 err = EXT2_ET_EA_INODE_CORRUPTED;
928 else if ((__u64) ext2fs_file_get_size(ea_file) !=
930 err = EXT2_ET_EA_BAD_VALUE_SIZE;
932 err = ext2fs_file_read(ea_file, x->value,
933 entry->e_value_size, 0);
934 ext2fs_file_close(ea_file);
939 x->ea_ino = entry->e_value_inum;
940 x->value_len = entry->e_value_size;
942 /* e_hash may be 0 in older inode's ea */
943 if (entry->e_hash != 0) {
945 void *data = (entry->e_value_inum != 0) ?
946 0 : value_start + entry->e_value_offs;
948 err = ext2fs_ext_attr_hash_entry2(handle->fs, entry,
952 if (entry->e_hash != hash) {
953 struct ext2_inode child;
955 /* Check whether this is an old Lustre-style
956 * ea_inode reference.
958 err = ext2fs_read_inode(handle->fs,
963 if (child.i_mtime != handle->ino ||
964 child.i_generation != inode->i_generation)
965 return EXT2_ET_BAD_EA_HASH;
970 entry = EXT2_EXT_ATTR_NEXT(entry);
976 static void xattrs_free_keys(struct ext2_xattr_handle *h)
978 struct ext2_xattr *a = h->attrs;
981 for (i = 0; i < h->capacity; i++) {
983 ext2fs_free_mem(&a[i].name);
985 ext2fs_free_mem(&a[i].value);
991 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle)
993 struct ext2_inode_large *inode;
994 struct ext2_ext_attr_header *header;
995 __u32 ea_inode_magic;
996 unsigned int storage_size;
997 char *start, *block_buf = NULL;
1002 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1003 i = EXT2_INODE_SIZE(handle->fs->super);
1004 if (i < sizeof(*inode))
1006 err = ext2fs_get_memzero(i, &inode);
1010 err = ext2fs_read_inode_full(handle->fs, handle->ino,
1011 (struct ext2_inode *)inode,
1012 EXT2_INODE_SIZE(handle->fs->super));
1016 xattrs_free_keys(handle);
1018 /* Does the inode have space for EA? */
1019 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
1020 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1021 inode->i_extra_isize +
1024 if (inode->i_extra_isize & 3) {
1025 err = EXT2_ET_INODE_CORRUPTED;
1029 /* Look for EA in the inode */
1030 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1031 inode->i_extra_isize, sizeof(__u32));
1032 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1033 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
1034 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
1036 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1037 inode->i_extra_isize + sizeof(__u32);
1039 err = read_xattrs_from_buffer(handle, inode,
1040 (struct ext2_ext_attr_entry *) start,
1041 storage_size, start);
1045 handle->ibody_count = handle->count;
1049 /* Look for EA in a separate EA block */
1050 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
1052 if ((blk < handle->fs->super->s_first_data_block) ||
1053 (blk >= ext2fs_blocks_count(handle->fs->super))) {
1054 err = EXT2_ET_BAD_EA_BLOCK_NUM;
1058 err = ext2fs_get_mem(handle->fs->blocksize, &block_buf);
1062 err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf,
1067 /* We only know how to deal with v2 EA blocks */
1068 header = (struct ext2_ext_attr_header *) block_buf;
1069 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
1070 err = EXT2_ET_BAD_EA_HEADER;
1075 storage_size = handle->fs->blocksize -
1076 sizeof(struct ext2_ext_attr_header);
1077 start = block_buf + sizeof(struct ext2_ext_attr_header);
1078 err = read_xattrs_from_buffer(handle, inode,
1079 (struct ext2_ext_attr_entry *) start,
1080 storage_size, block_buf);
1084 ext2fs_free_mem(&block_buf);
1087 ext2fs_free_mem(&block_buf);
1088 ext2fs_free_mem(&inode);
1092 ext2fs_free_mem(&block_buf);
1094 ext2fs_free_mem(&inode);
1098 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h,
1099 int (*func)(char *name, char *value,
1100 size_t value_len, void *data),
1103 struct ext2_xattr *x;
1107 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1108 for (x = h->attrs; x < h->attrs + h->count; x++) {
1109 ret = func(x->name, x->value, x->value_len, data);
1110 if (ret & XATTR_CHANGED)
1112 if (ret & XATTR_ABORT)
1117 return ext2fs_xattrs_write(h);
1121 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key,
1122 void **value, size_t *value_len)
1124 struct ext2_xattr *x;
1128 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1129 for (x = h->attrs; x < h->attrs + h->count; x++) {
1130 if (strcmp(x->name, key))
1133 if (!(h->flags & XATTR_HANDLE_FLAG_RAW) &&
1134 ((strcmp(key, "system.posix_acl_default") == 0) ||
1135 (strcmp(key, "system.posix_acl_access") == 0))) {
1136 err = convert_disk_buffer_to_posix_acl(x->value, x->value_len,
1140 err = ext2fs_get_mem(x->value_len, &val);
1143 memcpy(val, x->value, x->value_len);
1145 *value_len = x->value_len;
1150 return EXT2_ET_EA_KEY_NOT_FOUND;
1153 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino,
1156 struct ext2_ext_attr_entry *entry;
1157 struct ext2_inode_large *inode;
1158 __u32 ea_inode_magic;
1159 unsigned int minoff;
1164 i = EXT2_INODE_SIZE(fs->super);
1165 if (i < sizeof(*inode))
1167 err = ext2fs_get_memzero(i, &inode);
1171 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)inode,
1172 EXT2_INODE_SIZE(fs->super));
1176 /* Does the inode have size for EA? */
1177 if (EXT2_INODE_SIZE(fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1178 inode->i_extra_isize +
1180 err = EXT2_ET_INLINE_DATA_NO_SPACE;
1184 minoff = EXT2_INODE_SIZE(fs->super) - sizeof(*inode) - sizeof(__u32);
1185 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1186 inode->i_extra_isize, sizeof(__u32));
1187 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1188 /* has xattrs. calculate the size */
1189 start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1190 inode->i_extra_isize + sizeof(__u32);
1191 entry = (struct ext2_ext_attr_entry *) start;
1192 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
1193 if (!entry->e_value_inum && entry->e_value_size) {
1194 unsigned int offs = entry->e_value_offs;
1198 entry = EXT2_EXT_ATTR_NEXT(entry);
1200 *size = minoff - ((char *)entry - (char *)start) - sizeof(__u32);
1202 /* no xattr. return a maximum size */
1203 *size = EXT2_EXT_ATTR_SIZE(minoff -
1204 EXT2_EXT_ATTR_LEN(strlen("data")) -
1205 EXT2_EXT_ATTR_ROUND - sizeof(__u32));
1209 ext2fs_free_mem(&inode);
1213 static errcode_t xattr_create_ea_inode(ext2_filsys fs, const void *value,
1214 size_t value_len, ext2_ino_t *ea_ino)
1216 struct ext2_inode inode;
1222 ret = ext2fs_new_inode(fs, 0, 0, 0, &ino);
1226 memset(&inode, 0, sizeof(inode));
1227 inode.i_flags |= EXT4_EA_INODE_FL;
1228 if (ext2fs_has_feature_extents(fs->super))
1229 inode.i_flags |= EXT4_EXTENTS_FL;
1231 inode.i_mode = LINUX_S_IFREG | 0600;
1232 inode.i_links_count = 1;
1233 ret = ext2fs_write_new_inode(fs, ino, &inode);
1237 * ref_count and hash utilize inode's i_*time fields.
1238 * ext2fs_write_new_inode() call above initializes these fields with
1239 * current time. That's why ref count and hash updates are done
1242 ext2fs_set_ea_inode_ref(&inode, 1);
1243 hash = ext2fs_crc32c_le(fs->csum_seed, value, value_len);
1244 ext2fs_set_ea_inode_hash(&inode, hash);
1246 ret = ext2fs_write_inode(fs, ino, &inode);
1250 ret = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &file);
1253 ret = ext2fs_file_write(file, value, value_len, NULL);
1254 ext2fs_file_close(file);
1258 ext2fs_inode_alloc_stats2(fs, ino, 1 /* inuse */, 0 /* isdir */);
1264 static errcode_t xattr_inode_dec_ref(ext2_filsys fs, ext2_ino_t ino)
1266 struct ext2_inode_large inode;
1270 ret = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode,
1275 ref_count = ext2fs_get_ea_inode_ref(EXT2_INODE(&inode));
1277 ext2fs_set_ea_inode_ref(EXT2_INODE(&inode), ref_count);
1282 inode.i_links_count = 0;
1283 inode.i_dtime = fs->now ? fs->now : time(0);
1285 ret = ext2fs_free_ext_attr(fs, ino, &inode);
1289 if (ext2fs_inode_has_valid_blocks2(fs, (struct ext2_inode *)&inode)) {
1290 ret = ext2fs_punch(fs, ino, (struct ext2_inode *)&inode, NULL,
1296 ext2fs_inode_alloc_stats2(fs, ino, -1 /* inuse */, 0 /* is_dir */);
1299 ret = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode,
1305 static errcode_t xattr_update_entry(ext2_filsys fs, struct ext2_xattr *x,
1306 const char *name, const void *value,
1307 size_t value_len, int in_inode)
1309 ext2_ino_t ea_ino = 0;
1310 void *new_value = NULL;
1311 char *new_name = NULL;
1316 name_len = strlen(name);
1317 ret = ext2fs_get_mem(name_len + 1, &new_name);
1320 memcpy(new_name, name, name_len + 1);
1323 ret = ext2fs_get_mem(value_len, &new_value);
1326 memcpy(new_value, value, value_len);
1329 ret = xattr_create_ea_inode(fs, value, value_len, &ea_ino);
1335 ret = xattr_inode_dec_ref(fs, x->ea_ino);
1344 ext2fs_free_mem(&x->value);
1345 x->value = new_value;
1346 x->value_len = value_len;
1351 ext2fs_free_mem(&new_name);
1353 ext2fs_free_mem(&new_value);
1355 xattr_inode_dec_ref(fs, ea_ino);
1359 static int xattr_find_position(struct ext2_xattr *attrs, int count,
1362 struct ext2_xattr *x;
1364 const char *shortname, *x_shortname;
1365 int name_idx, x_name_idx;
1366 int shortname_len, x_shortname_len;
1368 find_ea_index(name, &shortname, &name_idx);
1369 shortname_len = strlen(shortname);
1371 for (i = 0, x = attrs; i < count; i++, x++) {
1372 find_ea_index(x->name, &x_shortname, &x_name_idx);
1373 if (name_idx < x_name_idx)
1375 if (name_idx > x_name_idx)
1378 x_shortname_len = strlen(x_shortname);
1379 if (shortname_len < x_shortname_len)
1381 if (shortname_len > x_shortname_len)
1384 if (memcmp(shortname, x_shortname, shortname_len) <= 0)
1390 static errcode_t xattr_array_update(struct ext2_xattr_handle *h,
1392 const void *value, size_t value_len,
1393 int ibody_free, int block_free,
1394 int old_idx, int in_inode)
1396 struct ext2_xattr tmp;
1399 int name_len, name_idx;
1400 const char *shortname;
1404 find_ea_index(name, &shortname, &name_idx);
1405 name_len = strlen(shortname);
1407 needed = EXT2_EXT_ATTR_LEN(name_len);
1409 needed += EXT2_EXT_ATTR_SIZE(value_len);
1411 if (old_idx >= 0 && old_idx < h->ibody_count) {
1412 ibody_free += EXT2_EXT_ATTR_LEN(name_len);
1413 if (!h->attrs[old_idx].ea_ino)
1414 ibody_free += EXT2_EXT_ATTR_SIZE(
1415 h->attrs[old_idx].value_len);
1418 if (needed <= ibody_free) {
1420 new_idx = h->ibody_count;
1425 /* Update the existing entry. */
1426 ret = xattr_update_entry(h->fs, &h->attrs[old_idx], name,
1427 value, value_len, in_inode);
1430 if (h->ibody_count <= old_idx) {
1431 /* Move entry from block to the end of ibody. */
1432 tmp = h->attrs[old_idx];
1433 memmove(h->attrs + h->ibody_count + 1,
1434 h->attrs + h->ibody_count,
1435 (old_idx - h->ibody_count) * sizeof(*h->attrs));
1436 h->attrs[h->ibody_count] = tmp;
1442 if (h->ibody_count <= old_idx) {
1443 block_free += EXT2_EXT_ATTR_LEN(name_len);
1444 if (!h->attrs[old_idx].ea_ino)
1446 EXT2_EXT_ATTR_SIZE(h->attrs[old_idx].value_len);
1449 if (needed > block_free)
1450 return EXT2_ET_EA_NO_SPACE;
1453 /* Update the existing entry. */
1454 ret = xattr_update_entry(h->fs, &h->attrs[old_idx], name,
1455 value, value_len, in_inode);
1458 if (old_idx < h->ibody_count) {
1460 * Move entry from ibody to the block. Note that
1461 * entries in the block are sorted.
1463 new_idx = xattr_find_position(h->attrs + h->ibody_count,
1464 h->count - h->ibody_count, name);
1465 new_idx += h->ibody_count - 1;
1466 tmp = h->attrs[old_idx];
1467 memmove(h->attrs + old_idx, h->attrs + old_idx + 1,
1468 (new_idx - old_idx) * sizeof(*h->attrs));
1469 h->attrs[new_idx] = tmp;
1475 new_idx = xattr_find_position(h->attrs + h->ibody_count,
1476 h->count - h->ibody_count, name);
1477 new_idx += h->ibody_count;
1481 if (h->count == h->capacity) {
1482 ret = ext2fs_xattrs_expand(h, 4);
1487 ret = xattr_update_entry(h->fs, &h->attrs[h->count], name, value,
1488 value_len, in_inode);
1492 tmp = h->attrs[h->count];
1493 memmove(h->attrs + new_idx + 1, h->attrs + new_idx,
1494 (h->count - new_idx)*sizeof(*h->attrs));
1495 h->attrs[new_idx] = tmp;
1502 static int space_used(struct ext2_xattr *attrs, int count)
1505 struct ext2_xattr *x;
1506 const char *shortname;
1507 int i, len, name_idx;
1509 for (i = 0, x = attrs; i < count; i++, x++) {
1510 find_ea_index(x->name, &shortname, &name_idx);
1511 len = strlen(shortname);
1512 total += EXT2_EXT_ATTR_LEN(len);
1514 total += EXT2_EXT_ATTR_SIZE(x->value_len);
1520 * The minimum size of EA value when you start storing it in an external inode
1521 * size of block - size of header - size of 1 entry - 4 null bytes
1523 #define EXT4_XATTR_MIN_LARGE_EA_SIZE(b) \
1524 ((b) - EXT2_EXT_ATTR_LEN(3) - sizeof(struct ext2_ext_attr_header) - 4)
1526 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *h,
1531 ext2_filsys fs = h->fs;
1532 const int inode_size = EXT2_INODE_SIZE(fs->super);
1533 struct ext2_inode_large *inode = NULL;
1534 struct ext2_xattr *x;
1536 int ibody_free, block_free;
1542 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1544 ret = ext2fs_get_mem(value_len, &new_value);
1547 if (!(h->flags & XATTR_HANDLE_FLAG_RAW) &&
1548 ((strcmp(name, "system.posix_acl_default") == 0) ||
1549 (strcmp(name, "system.posix_acl_access") == 0))) {
1550 ret = convert_posix_acl_to_disk_buffer(value, value_len,
1551 new_value, &value_len);
1554 } else if (value_len)
1555 memcpy(new_value, value, value_len);
1557 /* Imitate kernel behavior by skipping update if value is the same. */
1558 for (x = h->attrs; x < h->attrs + h->count; x++) {
1559 if (!strcmp(x->name, name)) {
1560 if (!x->ea_ino && x->value_len == value_len &&
1562 !memcmp(x->value, new_value, value_len))) {
1566 old_idx = x - h->attrs;
1571 ret = ext2fs_get_memzero(inode_size, &inode);
1574 ret = ext2fs_read_inode_full(fs, h->ino,
1575 (struct ext2_inode *)inode,
1579 if (inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
1580 extra_isize = inode->i_extra_isize;
1581 if (extra_isize == 0) {
1582 extra_isize = fs->super->s_want_extra_isize;
1583 if (extra_isize == 0)
1584 extra_isize = sizeof(__u32);
1586 ibody_free = inode_size - EXT2_GOOD_OLD_INODE_SIZE;
1587 ibody_free -= extra_isize;
1588 /* Extended attribute magic and final null entry. */
1589 ibody_free -= sizeof(__u32) * 2;
1590 ibody_free -= space_used(h->attrs, h->ibody_count);
1594 /* Inline data can only go to ibody. */
1595 if (strcmp(name, "system.data") == 0) {
1596 if (h->ibody_count <= old_idx) {
1597 ret = EXT2_ET_FILESYSTEM_CORRUPTED;
1600 ret = xattr_array_update(h, name, new_value, value_len,
1602 0 /* block_free */, old_idx,
1609 block_free = fs->blocksize;
1610 block_free -= sizeof(struct ext2_ext_attr_header);
1611 /* Final null entry. */
1612 block_free -= sizeof(__u32);
1613 block_free -= space_used(h->attrs + h->ibody_count,
1614 h->count - h->ibody_count);
1616 if (ext2fs_has_feature_ea_inode(fs->super) &&
1617 value_len > EXT4_XATTR_MIN_LARGE_EA_SIZE(fs->blocksize))
1620 ret = xattr_array_update(h, name, new_value, value_len, ibody_free,
1621 block_free, old_idx, in_inode);
1622 if (ret == EXT2_ET_EA_NO_SPACE && !in_inode &&
1623 ext2fs_has_feature_ea_inode(fs->super))
1624 ret = xattr_array_update(h, name, new_value, value_len,
1625 ibody_free, block_free, old_idx, 1 /* in_inode */);
1630 ret = ext2fs_xattrs_write(h);
1633 ext2fs_free_mem(&inode);
1634 ext2fs_free_mem(&new_value);
1638 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle,
1641 struct ext2_xattr *x;
1642 struct ext2_xattr *end = handle->attrs + handle->count;
1644 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1645 for (x = handle->attrs; x < end; x++) {
1646 if (strcmp(x->name, key) == 0) {
1647 ext2fs_free_mem(&x->name);
1648 ext2fs_free_mem(&x->value);
1650 xattr_inode_dec_ref(handle->fs, x->ea_ino);
1651 memmove(x, x + 1, (end - x - 1)*sizeof(*x));
1652 memset(end - 1, 0, sizeof(*end));
1653 if (x < handle->attrs + handle->ibody_count)
1654 handle->ibody_count--;
1656 return ext2fs_xattrs_write(handle);
1660 /* no key found, success! */
1664 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino,
1665 struct ext2_xattr_handle **handle)
1667 struct ext2_xattr_handle *h;
1670 if (!ext2fs_has_feature_xattr(fs->super) &&
1671 !ext2fs_has_feature_inline_data(fs->super))
1672 return EXT2_ET_MISSING_EA_FEATURE;
1674 err = ext2fs_get_memzero(sizeof(*h), &h);
1678 h->magic = EXT2_ET_MAGIC_EA_HANDLE;
1680 err = ext2fs_get_arrayzero(h->capacity, sizeof(struct ext2_xattr),
1683 ext2fs_free_mem(&h);
1693 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle)
1695 struct ext2_xattr_handle *h = *handle;
1697 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1698 xattrs_free_keys(h);
1699 ext2fs_free_mem(&h->attrs);
1700 ext2fs_free_mem(handle);
1704 errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count)
1706 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1707 *count = handle->count;
1711 errcode_t ext2fs_xattrs_flags(struct ext2_xattr_handle *handle,
1712 unsigned int *new_flags, unsigned int *old_flags)
1714 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1716 *old_flags = handle->flags;
1718 handle->flags = *new_flags;