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 static errcode_t check_ext_attr_header(struct ext2_ext_attr_header *header)
144 if ((header->h_magic != EXT2_EXT_ATTR_MAGIC_v1 &&
145 header->h_magic != EXT2_EXT_ATTR_MAGIC) ||
146 header->h_blocks != 1)
147 return EXT2_ET_BAD_EA_HEADER;
152 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
158 retval = io_channel_read_blk64(fs->io, block, 1, buf);
162 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
163 !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf))
166 #ifdef WORDS_BIGENDIAN
167 ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1);
170 retval = check_ext_attr_header(buf);
171 if (retval == 0 && csum_failed)
172 retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
177 errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf)
179 return ext2fs_read_ext_attr3(fs, block, buf, 0);
182 errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf)
184 return ext2fs_read_ext_attr2(fs, block, buf);
187 errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *inbuf,
193 #ifdef WORDS_BIGENDIAN
194 retval = ext2fs_get_mem(fs->blocksize, &write_buf);
197 ext2fs_swap_ext_attr(write_buf, inbuf, fs->blocksize, 1);
199 write_buf = (char *) inbuf;
202 retval = ext2fs_ext_attr_block_csum_set(fs, inum, block,
203 (struct ext2_ext_attr_header *)write_buf);
207 retval = io_channel_write_blk64(fs->io, block, 1, write_buf);
208 #ifdef WORDS_BIGENDIAN
209 ext2fs_free_mem(&write_buf);
212 ext2fs_mark_changed(fs);
216 errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *inbuf)
218 return ext2fs_write_ext_attr3(fs, block, inbuf, 0);
221 errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf)
223 return ext2fs_write_ext_attr2(fs, block, inbuf);
227 * This function adjusts the reference count of the EA block.
229 errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk,
230 char *block_buf, int adjust,
231 __u32 *newcount, ext2_ino_t inum)
234 struct ext2_ext_attr_header *header;
237 if ((blk >= ext2fs_blocks_count(fs->super)) ||
238 (blk < fs->super->s_first_data_block))
239 return EXT2_ET_BAD_EA_BLOCK_NUM;
242 retval = ext2fs_get_mem(fs->blocksize, &buf);
248 retval = ext2fs_read_ext_attr3(fs, blk, block_buf, inum);
252 header = (struct ext2_ext_attr_header *) block_buf;
253 header->h_refcount += adjust;
255 *newcount = header->h_refcount;
257 retval = ext2fs_write_ext_attr3(fs, blk, block_buf, inum);
263 ext2fs_free_mem(&buf);
267 errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
268 char *block_buf, int adjust,
271 return ext2fs_adjust_ea_refcount3(fs, blk, block_buf, adjust,
275 errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
276 char *block_buf, int adjust,
279 return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust,
283 /* Manipulate the contents of extended attribute regions */
290 struct ext2_xattr_handle {
293 struct ext2_xattr *attrs;
294 size_t capacity, count;
300 static errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h,
301 unsigned int expandby)
303 struct ext2_xattr *new_attrs;
306 err = ext2fs_get_arrayzero(h->capacity + expandby,
307 sizeof(struct ext2_xattr), &new_attrs);
311 memcpy(new_attrs, h->attrs, h->capacity * sizeof(struct ext2_xattr));
312 ext2fs_free_mem(&h->attrs);
313 h->capacity += expandby;
314 h->attrs = new_attrs;
319 struct ea_name_index {
324 /* Keep these names sorted in order of decreasing specificity. */
325 static struct ea_name_index ea_names[] = {
326 {3, "system.posix_acl_default"},
327 {2, "system.posix_acl_access"},
328 {8, "system.richacl"},
336 static int find_ea_index(char *fullname, char **name, int *index);
338 /* Pull inlinedata to the front. */
339 static int attr_compare(const void *a, const void *b)
341 const struct ext2_xattr *xa = a, *xb = b;
342 char *xa_suffix, *xb_suffix;
346 if (!strcmp(xa->name, "system.data"))
348 else if (!strcmp(xb->name, "system.data"))
352 * Duplicate the kernel's sorting algorithm because xattr blocks
353 * require sorted keys.
355 xa_suffix = xa->name;
356 xb_suffix = xb->name;
358 find_ea_index(xa->name, &xa_suffix, &xa_idx);
359 find_ea_index(xb->name, &xb_suffix, &xb_idx);
360 cmp = xa_idx - xb_idx;
363 cmp = strlen(xa_suffix) - strlen(xb_suffix);
366 cmp = strcmp(xa_suffix, xb_suffix);
370 static const char *find_ea_prefix(int index)
372 struct ea_name_index *e;
374 for (e = ea_names; e->name; e++)
375 if (e->index == index)
381 static int find_ea_index(char *fullname, char **name, int *index)
383 struct ea_name_index *e;
385 for (e = ea_names; e->name; e++) {
386 if (strncmp(fullname, e->name, strlen(e->name)) == 0) {
387 *name = (char *)fullname + strlen(e->name);
395 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
396 struct ext2_inode_large *inode)
398 struct ext2_ext_attr_header *header;
399 void *block_buf = NULL;
402 struct ext2_inode_large i;
406 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i,
407 sizeof(struct ext2_inode_large));
413 /* Do we already have an EA block? */
414 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
418 /* Find block, zero it, write back */
419 if ((blk < fs->super->s_first_data_block) ||
420 (blk >= ext2fs_blocks_count(fs->super))) {
421 err = EXT2_ET_BAD_EA_BLOCK_NUM;
425 err = ext2fs_get_mem(fs->blocksize, &block_buf);
429 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
433 /* We only know how to deal with v2 EA blocks */
434 header = (struct ext2_ext_attr_header *) block_buf;
435 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
436 err = EXT2_ET_BAD_EA_HEADER;
440 header->h_refcount--;
441 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
445 /* Erase link to block */
446 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0);
447 if (header->h_refcount == 0)
448 ext2fs_block_alloc_stats2(fs, blk, -1);
449 err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1);
455 err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i,
456 sizeof(struct ext2_inode_large));
462 ext2fs_free_mem(&block_buf);
467 static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino,
468 struct ext2_inode_large *inode)
470 struct ext2_ext_attr_header *header;
471 void *block_buf = NULL;
475 /* Do we already have an EA block? */
476 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
478 if ((blk < fs->super->s_first_data_block) ||
479 (blk >= ext2fs_blocks_count(fs->super))) {
480 err = EXT2_ET_BAD_EA_BLOCK_NUM;
484 err = ext2fs_get_mem(fs->blocksize, &block_buf);
488 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
492 /* We only know how to deal with v2 EA blocks */
493 header = (struct ext2_ext_attr_header *) block_buf;
494 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
495 err = EXT2_ET_BAD_EA_HEADER;
499 /* Single-user block. We're done here. */
500 if (header->h_refcount == 1)
503 /* We need to CoW the block. */
504 header->h_refcount--;
505 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
509 /* No block, we must increment i_blocks */
510 err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode,
516 /* Allocate a block */
517 goal = ext2fs_find_inode_goal(fs, ino, (struct ext2_inode *)inode, 0);
518 err = ext2fs_alloc_block2(fs, goal, NULL, &blk);
521 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk);
524 ext2fs_free_mem(&block_buf);
531 posix_acl_xattr_count(size_t size)
533 if (size < sizeof(posix_acl_xattr_header))
535 size -= sizeof(posix_acl_xattr_header);
536 if (size % sizeof(posix_acl_xattr_entry))
538 return size / sizeof(posix_acl_xattr_entry);
542 * The lgetxattr function returns data formatted in the POSIX extended
543 * attribute format. The on-disk format uses a more compact encoding.
544 * See the ext4_acl_to_disk in fs/ext4/acl.c.
546 static errcode_t convert_posix_acl_to_disk_buffer(const void *value, size_t size,
547 void *out_buf, size_t *size_out)
549 posix_acl_xattr_header *header = (posix_acl_xattr_header*) value;
550 posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
551 ext4_acl_header *ext_acl;
559 if (size < sizeof(posix_acl_xattr_header))
561 if (header->a_version != ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION))
564 count = posix_acl_xattr_count(size);
566 ext_acl->a_version = ext2fs_cpu_to_le32(EXT4_ACL_VERSION);
571 e = (char *) out_buf + sizeof(ext4_acl_header);
572 s = sizeof(ext4_acl_header);
573 for (end = entry + count; entry != end;entry++) {
574 ext4_acl_entry *disk_entry = (ext4_acl_entry*) e;
575 disk_entry->e_tag = ext2fs_cpu_to_le16(entry->e_tag);
576 disk_entry->e_perm = ext2fs_cpu_to_le16(entry->e_perm);
578 switch(entry->e_tag) {
583 e += sizeof(ext4_acl_entry_short);
584 s += sizeof(ext4_acl_entry_short);
588 disk_entry->e_id = ext2fs_cpu_to_le32(entry->e_id);
589 e += sizeof(ext4_acl_entry);
590 s += sizeof(ext4_acl_entry);
598 static errcode_t convert_disk_buffer_to_posix_acl(const void *value, size_t size,
599 void **out_buf, size_t *size_out)
601 posix_acl_xattr_header *header;
602 posix_acl_xattr_entry *entry;
603 ext4_acl_header *ext_acl = (ext4_acl_header *) value;
609 (size < sizeof(ext4_acl_header)) ||
610 (ext_acl->a_version != ext2fs_cpu_to_le32(EXT4_ACL_VERSION)))
613 err = ext2fs_get_mem(size * 2, &out);
617 header = (posix_acl_xattr_header *) out;
618 header->a_version = ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION);
619 entry = (posix_acl_xattr_entry *) (out + sizeof(posix_acl_xattr_header));
621 cp = value + sizeof(ext4_acl_header);
622 size -= sizeof(ext4_acl_header);
625 const ext4_acl_entry *disk_entry = (const ext4_acl_entry *) cp;
627 entry->e_tag = ext2fs_le16_to_cpu(disk_entry->e_tag);
628 entry->e_perm = ext2fs_le16_to_cpu(disk_entry->e_perm);
630 switch(entry->e_tag) {
636 cp += sizeof(ext4_acl_entry_short);
637 size -= sizeof(ext4_acl_entry_short);
641 entry->e_id = ext2fs_le32_to_cpu(disk_entry->e_id);
642 cp += sizeof(ext4_acl_entry);
643 size -= sizeof(ext4_acl_entry);
646 ext2fs_free_mem(&out);
653 *size_out = ((char *) entry - out);
658 static errcode_t write_xattrs_to_buffer(struct ext2_xattr_handle *handle,
659 struct ext2_xattr **pos,
661 unsigned int storage_size,
662 unsigned int value_offset_correction,
665 struct ext2_xattr *x = *pos;
666 struct ext2_ext_attr_entry *e = entries_start;
667 char *end = (char *) entries_start + storage_size;
669 unsigned int entry_size, value_size;
672 memset(entries_start, 0, storage_size);
673 /* For all remaining x... */
674 for (; x < handle->attrs + handle->count; x++) {
675 /* Calculate index and shortname position */
677 ret = find_ea_index(x->name, &shortname, &idx);
679 /* Calculate entry and value size */
680 entry_size = (sizeof(*e) + strlen(shortname) +
681 EXT2_EXT_ATTR_PAD - 1) &
682 ~(EXT2_EXT_ATTR_PAD - 1);
683 value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) /
684 EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD;
687 * Would entry collide with value?
688 * Note that we must leave sufficient room for a (u32)0 to
689 * mark the end of the entries.
691 if ((char *)e + entry_size + sizeof(__u32) > end - value_size)
694 /* Fill out e appropriately */
695 e->e_name_len = strlen(shortname);
696 e->e_name_index = (ret ? idx : 0);
697 e->e_value_offs = end - value_size - (char *)entries_start +
698 value_offset_correction;
700 e->e_value_size = x->value_len;
702 /* Store name and value */
704 memcpy((char *)e + sizeof(*e), shortname, e->e_name_len);
705 memcpy(end, x->value, e->e_value_size);
708 e->e_hash = ext2fs_ext_attr_hash_entry(e, end);
712 e = EXT2_EXT_ATTR_NEXT(e);
720 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle)
722 struct ext2_xattr *x;
723 struct ext2_inode_large *inode;
724 char *start, *block_buf = NULL;
725 struct ext2_ext_attr_header *header;
726 __u32 ea_inode_magic;
728 unsigned int storage_size;
732 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
733 i = EXT2_INODE_SIZE(handle->fs->super);
734 if (i < sizeof(*inode))
736 err = ext2fs_get_memzero(i, &inode);
740 err = ext2fs_read_inode_full(handle->fs, handle->ino,
741 (struct ext2_inode *)inode,
742 EXT2_INODE_SIZE(handle->fs->super));
746 /* If extra_isize isn't set, we need to set it now */
747 if (inode->i_extra_isize == 0 &&
748 EXT2_INODE_SIZE(handle->fs->super) > EXT2_GOOD_OLD_INODE_SIZE) {
749 char *p = (char *)inode;
750 size_t extra = handle->fs->super->s_want_extra_isize;
753 extra = sizeof(__u32);
754 memset(p + EXT2_GOOD_OLD_INODE_SIZE, 0, extra);
755 inode->i_extra_isize = extra;
757 if (inode->i_extra_isize & 3) {
758 err = EXT2_ET_INODE_CORRUPTED;
762 /* Force the inlinedata attr to the front. */
764 qsort(x, handle->count, sizeof(struct ext2_xattr), attr_compare);
766 /* Does the inode have space for EA? */
767 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
768 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
769 inode->i_extra_isize +
773 /* Write the inode EA */
774 ea_inode_magic = EXT2_EXT_ATTR_MAGIC;
775 memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
776 inode->i_extra_isize, &ea_inode_magic, sizeof(__u32));
777 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
778 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
780 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
781 inode->i_extra_isize + sizeof(__u32);
783 err = write_xattrs_to_buffer(handle, &x, start, storage_size, 0, 0);
789 if (x >= handle->attrs + handle->count)
792 /* Write the EA block */
793 err = ext2fs_get_memzero(handle->fs->blocksize, &block_buf);
797 storage_size = handle->fs->blocksize -
798 sizeof(struct ext2_ext_attr_header);
799 start = block_buf + sizeof(struct ext2_ext_attr_header);
801 err = write_xattrs_to_buffer(handle, &x, start, storage_size,
802 start - block_buf, 1);
806 if (x < handle->attrs + handle->count) {
807 err = EXT2_ET_EA_NO_SPACE;
811 /* Write a header on the EA block */
812 header = (struct ext2_ext_attr_header *) block_buf;
813 header->h_magic = EXT2_EXT_ATTR_MAGIC;
814 header->h_refcount = 1;
815 header->h_blocks = 1;
817 /* Get a new block for writing */
818 err = prep_ea_block_for_write(handle->fs, handle->ino, inode);
822 /* Finally, write the new EA block */
823 blk = ext2fs_file_acl_block(handle->fs,
824 (struct ext2_inode *)inode);
825 err = ext2fs_write_ext_attr3(handle->fs, blk, block_buf,
831 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
832 if (!block_buf && blk) {
833 /* xattrs shrunk, free the block */
834 err = ext2fs_free_ext_attr(handle->fs, handle->ino, inode);
839 /* Write the inode */
840 err = ext2fs_write_inode_full(handle->fs, handle->ino,
841 (struct ext2_inode *)inode,
842 EXT2_INODE_SIZE(handle->fs->super));
847 ext2fs_free_mem(&block_buf);
849 ext2fs_free_mem(&inode);
854 static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle,
855 struct ext2_inode_large *inode,
856 struct ext2_ext_attr_entry *entries,
857 unsigned int storage_size,
860 struct ext2_xattr *x;
861 struct ext2_ext_attr_entry *entry, *end;
863 unsigned int remain, prefix_len;
865 unsigned int values_size = storage_size +
866 ((char *)entries - value_start);
870 remain = storage_size;
871 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
872 !EXT2_EXT_IS_LAST_ENTRY(end)) {
874 /* header eats this space */
875 remain -= sizeof(struct ext2_ext_attr_entry);
877 /* is attribute name valid? */
878 if (EXT2_EXT_ATTR_SIZE(end->e_name_len) > remain)
879 return EXT2_ET_EA_BAD_NAME_LEN;
881 /* attribute len eats this space */
882 remain -= EXT2_EXT_ATTR_SIZE(end->e_name_len);
883 end = EXT2_EXT_ATTR_NEXT(end);
887 remain = storage_size;
888 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
889 !EXT2_EXT_IS_LAST_ENTRY(entry)) {
891 /* Allocate space for more attrs? */
892 if (handle->count == handle->capacity) {
893 err = ext2fs_xattrs_expand(handle, 4);
898 x = handle->attrs + handle->count;
900 /* header eats this space */
901 remain -= sizeof(struct ext2_ext_attr_entry);
903 /* attribute len eats this space */
904 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
907 prefix = find_ea_prefix(entry->e_name_index);
908 prefix_len = (prefix ? strlen(prefix) : 0);
909 err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1,
914 memcpy(x->name, prefix, prefix_len);
915 if (entry->e_name_len)
916 memcpy(x->name + prefix_len,
917 (char *)entry + sizeof(*entry),
920 /* Check & copy value */
921 if (!ext2fs_has_feature_ea_inode(handle->fs->super) &&
922 entry->e_value_inum != 0)
923 return EXT2_ET_BAD_EA_BLOCK_NUM;
925 if (entry->e_value_inum == 0) {
926 if (entry->e_value_size > remain)
927 return EXT2_ET_EA_BAD_VALUE_SIZE;
929 if (entry->e_value_offs + entry->e_value_size > values_size)
930 return EXT2_ET_EA_BAD_VALUE_OFFSET;
932 if (entry->e_value_size > 0 &&
933 value_start + entry->e_value_offs <
934 (char *)end + sizeof(__u32))
935 return EXT2_ET_EA_BAD_VALUE_OFFSET;
937 remain -= entry->e_value_size;
939 err = ext2fs_get_mem(entry->e_value_size, &x->value);
942 memcpy(x->value, value_start + entry->e_value_offs,
943 entry->e_value_size);
947 if (entry->e_value_offs != 0)
948 return EXT2_ET_EA_BAD_VALUE_OFFSET;
950 if (entry->e_value_size > (64 * 1024))
951 return EXT2_ET_EA_BAD_VALUE_SIZE;
953 err = ext2fs_get_mem(entry->e_value_size, &x->value);
957 err = ext2fs_file_open(handle->fs, entry->e_value_inum,
962 if (ext2fs_file_get_size(ea_file) !=
964 err = EXT2_ET_EA_BAD_VALUE_SIZE;
966 err = ext2fs_file_read(ea_file, x->value,
967 entry->e_value_size, 0);
968 ext2fs_file_close(ea_file);
973 x->value_len = entry->e_value_size;
975 /* e_hash may be 0 in older inode's ea */
976 if (entry->e_hash != 0) {
978 void *data = (entry->e_value_inum != 0) ?
979 0 : value_start + entry->e_value_offs;
981 err = ext2fs_ext_attr_hash_entry2(handle->fs, entry,
985 if (entry->e_hash != hash) {
986 struct ext2_inode child;
988 /* Check whether this is an old Lustre-style
989 * ea_inode reference.
991 err = ext2fs_read_inode(handle->fs,
996 if (child.i_mtime != handle->ino ||
997 child.i_generation != inode->i_generation)
998 return EXT2_ET_BAD_EA_HASH;
1003 entry = EXT2_EXT_ATTR_NEXT(entry);
1009 static void xattrs_free_keys(struct ext2_xattr_handle *h)
1011 struct ext2_xattr *a = h->attrs;
1014 for (i = 0; i < h->capacity; i++) {
1016 ext2fs_free_mem(&a[i].name);
1018 ext2fs_free_mem(&a[i].value);
1023 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle)
1025 struct ext2_inode_large *inode;
1026 struct ext2_ext_attr_header *header;
1027 __u32 ea_inode_magic;
1028 unsigned int storage_size;
1029 char *start, *block_buf = NULL;
1034 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1035 i = EXT2_INODE_SIZE(handle->fs->super);
1036 if (i < sizeof(*inode))
1038 err = ext2fs_get_memzero(i, &inode);
1042 err = ext2fs_read_inode_full(handle->fs, handle->ino,
1043 (struct ext2_inode *)inode,
1044 EXT2_INODE_SIZE(handle->fs->super));
1048 xattrs_free_keys(handle);
1050 /* Does the inode have space for EA? */
1051 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
1052 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1053 inode->i_extra_isize +
1056 if (inode->i_extra_isize & 3) {
1057 err = EXT2_ET_INODE_CORRUPTED;
1061 /* Look for EA in the inode */
1062 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1063 inode->i_extra_isize, sizeof(__u32));
1064 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1065 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
1066 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
1068 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1069 inode->i_extra_isize + sizeof(__u32);
1071 err = read_xattrs_from_buffer(handle, inode,
1072 (struct ext2_ext_attr_entry *) start,
1073 storage_size, start);
1079 /* Look for EA in a separate EA block */
1080 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
1082 if ((blk < handle->fs->super->s_first_data_block) ||
1083 (blk >= ext2fs_blocks_count(handle->fs->super))) {
1084 err = EXT2_ET_BAD_EA_BLOCK_NUM;
1088 err = ext2fs_get_mem(handle->fs->blocksize, &block_buf);
1092 err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf,
1097 /* We only know how to deal with v2 EA blocks */
1098 header = (struct ext2_ext_attr_header *) block_buf;
1099 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
1100 err = EXT2_ET_BAD_EA_HEADER;
1105 storage_size = handle->fs->blocksize -
1106 sizeof(struct ext2_ext_attr_header);
1107 start = block_buf + sizeof(struct ext2_ext_attr_header);
1108 err = read_xattrs_from_buffer(handle, inode,
1109 (struct ext2_ext_attr_entry *) start,
1110 storage_size, block_buf);
1114 ext2fs_free_mem(&block_buf);
1117 ext2fs_free_mem(&block_buf);
1118 ext2fs_free_mem(&inode);
1122 ext2fs_free_mem(&block_buf);
1124 ext2fs_free_mem(&inode);
1128 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h,
1129 int (*func)(char *name, char *value,
1130 size_t value_len, void *data),
1133 struct ext2_xattr *x;
1136 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1137 for (x = h->attrs; x < h->attrs + h->count; x++) {
1138 ret = func(x->name, x->value, x->value_len, data);
1139 if (ret & XATTR_CHANGED)
1141 if (ret & XATTR_ABORT)
1148 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key,
1149 void **value, size_t *value_len)
1151 struct ext2_xattr *x;
1155 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1156 for (x = h->attrs; x < h->attrs + h->count; x++) {
1157 if (strcmp(x->name, key))
1160 if (!(h->flags & XATTR_HANDLE_FLAG_RAW) &&
1161 ((strcmp(key, "system.posix_acl_default") == 0) ||
1162 (strcmp(key, "system.posix_acl_access") == 0))) {
1163 err = convert_disk_buffer_to_posix_acl(x->value, x->value_len,
1167 err = ext2fs_get_mem(x->value_len, &val);
1170 memcpy(val, x->value, x->value_len);
1172 *value_len = x->value_len;
1177 return EXT2_ET_EA_KEY_NOT_FOUND;
1180 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino,
1183 struct ext2_ext_attr_entry *entry;
1184 struct ext2_inode_large *inode;
1185 __u32 ea_inode_magic;
1186 unsigned int minoff;
1191 i = EXT2_INODE_SIZE(fs->super);
1192 if (i < sizeof(*inode))
1194 err = ext2fs_get_memzero(i, &inode);
1198 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)inode,
1199 EXT2_INODE_SIZE(fs->super));
1203 /* Does the inode have size for EA? */
1204 if (EXT2_INODE_SIZE(fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1205 inode->i_extra_isize +
1207 err = EXT2_ET_INLINE_DATA_NO_SPACE;
1211 minoff = EXT2_INODE_SIZE(fs->super) - sizeof(*inode) - sizeof(__u32);
1212 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1213 inode->i_extra_isize, sizeof(__u32));
1214 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1215 /* has xattrs. calculate the size */
1216 start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1217 inode->i_extra_isize + sizeof(__u32);
1218 entry = (struct ext2_ext_attr_entry *) start;
1219 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
1220 if (!entry->e_value_inum && entry->e_value_size) {
1221 unsigned int offs = entry->e_value_offs;
1225 entry = EXT2_EXT_ATTR_NEXT(entry);
1227 *size = minoff - ((char *)entry - (char *)start) - sizeof(__u32);
1229 /* no xattr. return a maximum size */
1230 *size = EXT2_EXT_ATTR_SIZE(minoff -
1231 EXT2_EXT_ATTR_LEN(strlen("data")) -
1232 EXT2_EXT_ATTR_ROUND - sizeof(__u32));
1236 ext2fs_free_mem(&inode);
1240 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle,
1245 struct ext2_xattr *x;
1249 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1251 err = ext2fs_get_mem(value_len, &new_value);
1254 if (!(handle->flags & XATTR_HANDLE_FLAG_RAW) &&
1255 ((strcmp(key, "system.posix_acl_default") == 0) ||
1256 (strcmp(key, "system.posix_acl_access") == 0))) {
1257 err = convert_posix_acl_to_disk_buffer(value, value_len,
1258 new_value, &value_len);
1262 memcpy(new_value, value, value_len);
1264 for (x = handle->attrs; x < handle->attrs + handle->count; x++) {
1266 if (strcmp(x->name, key) == 0) {
1267 ext2fs_free_mem(&x->value);
1268 x->value = new_value;
1269 x->value_len = value_len;
1275 if (handle->count == handle->capacity) {
1276 /* Expand array, append slot */
1277 err = ext2fs_xattrs_expand(handle, 4);
1281 x = handle->attrs + handle->capacity - 4;
1284 err = ext2fs_get_mem(strlen(key) + 1, &x->name);
1287 strcpy(x->name, key);
1289 err = ext2fs_get_mem(value_len, &x->value);
1292 memcpy(x->value, value, value_len);
1293 x->value_len = value_len;
1298 ext2fs_free_mem(&new_value);
1302 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle,
1305 struct ext2_xattr *x;
1306 struct ext2_xattr *end = handle->attrs + handle->count;
1308 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1309 for (x = handle->attrs; x < end; x++) {
1310 if (strcmp(x->name, key) == 0) {
1311 ext2fs_free_mem(&x->name);
1312 ext2fs_free_mem(&x->value);
1313 memmove(x, x + 1, (char *)end - (char *)(x + 1));
1314 memset(end, 0, sizeof(*end));
1321 /* no key found, success! */
1325 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino,
1326 struct ext2_xattr_handle **handle)
1328 struct ext2_xattr_handle *h;
1331 if (!ext2fs_has_feature_xattr(fs->super) &&
1332 !ext2fs_has_feature_inline_data(fs->super))
1333 return EXT2_ET_MISSING_EA_FEATURE;
1335 err = ext2fs_get_memzero(sizeof(*h), &h);
1339 h->magic = EXT2_ET_MAGIC_EA_HANDLE;
1341 err = ext2fs_get_arrayzero(h->capacity, sizeof(struct ext2_xattr),
1344 ext2fs_free_mem(&h);
1354 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle)
1356 struct ext2_xattr_handle *h = *handle;
1359 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1361 err = ext2fs_xattrs_write(h);
1366 xattrs_free_keys(h);
1367 ext2fs_free_mem(&h->attrs);
1368 ext2fs_free_mem(handle);
1372 errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count)
1374 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1375 *count = handle->count;
1379 errcode_t ext2fs_xattrs_flags(struct ext2_xattr_handle *handle,
1380 unsigned int *new_flags, unsigned int *old_flags)
1382 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1384 *old_flags = handle->flags;
1386 handle->flags = *new_flags;