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"
27 #define NAME_HASH_SHIFT 5
28 #define VALUE_HASH_SHIFT 16
31 * ext2_xattr_hash_entry()
33 * Compute the hash of an extended attribute.
35 __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry, void *data)
38 char *name = ((char *) entry) + sizeof(struct ext2_ext_attr_entry);
41 for (n = 0; n < entry->e_name_len; n++) {
42 hash = (hash << NAME_HASH_SHIFT) ^
43 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
47 /* The hash needs to be calculated on the data in little-endian. */
48 if (entry->e_value_block == 0 && entry->e_value_size != 0) {
49 __u32 *value = (__u32 *)data;
50 for (n = (entry->e_value_size + EXT2_EXT_ATTR_ROUND) >>
51 EXT2_EXT_ATTR_PAD_BITS; n; n--) {
52 hash = (hash << VALUE_HASH_SHIFT) ^
53 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
54 ext2fs_le32_to_cpu(*value++);
61 static errcode_t check_ext_attr_header(struct ext2_ext_attr_header *header)
63 if ((header->h_magic != EXT2_EXT_ATTR_MAGIC_v1 &&
64 header->h_magic != EXT2_EXT_ATTR_MAGIC) ||
65 header->h_blocks != 1)
66 return EXT2_ET_BAD_EA_HEADER;
71 #undef NAME_HASH_SHIFT
72 #undef VALUE_HASH_SHIFT
74 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
80 retval = io_channel_read_blk64(fs->io, block, 1, buf);
84 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
85 !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf))
88 #ifdef WORDS_BIGENDIAN
89 ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1);
92 retval = check_ext_attr_header(buf);
93 if (retval == 0 && csum_failed)
94 retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
99 errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf)
101 return ext2fs_read_ext_attr3(fs, block, buf, 0);
104 errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf)
106 return ext2fs_read_ext_attr2(fs, block, buf);
109 errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *inbuf,
115 #ifdef WORDS_BIGENDIAN
116 retval = ext2fs_get_mem(fs->blocksize, &write_buf);
119 ext2fs_swap_ext_attr(write_buf, inbuf, fs->blocksize, 1);
121 write_buf = (char *) inbuf;
124 retval = ext2fs_ext_attr_block_csum_set(fs, inum, block,
125 (struct ext2_ext_attr_header *)write_buf);
129 retval = io_channel_write_blk64(fs->io, block, 1, write_buf);
130 #ifdef WORDS_BIGENDIAN
131 ext2fs_free_mem(&write_buf);
134 ext2fs_mark_changed(fs);
138 errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *inbuf)
140 return ext2fs_write_ext_attr3(fs, block, inbuf, 0);
143 errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf)
145 return ext2fs_write_ext_attr2(fs, block, inbuf);
149 * This function adjusts the reference count of the EA block.
151 errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk,
152 char *block_buf, int adjust,
153 __u32 *newcount, ext2_ino_t inum)
156 struct ext2_ext_attr_header *header;
159 if ((blk >= ext2fs_blocks_count(fs->super)) ||
160 (blk < fs->super->s_first_data_block))
161 return EXT2_ET_BAD_EA_BLOCK_NUM;
164 retval = ext2fs_get_mem(fs->blocksize, &buf);
170 retval = ext2fs_read_ext_attr3(fs, blk, block_buf, inum);
174 header = (struct ext2_ext_attr_header *) block_buf;
175 header->h_refcount += adjust;
177 *newcount = header->h_refcount;
179 retval = ext2fs_write_ext_attr3(fs, blk, block_buf, inum);
185 ext2fs_free_mem(&buf);
189 errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
190 char *block_buf, int adjust,
193 return ext2fs_adjust_ea_refcount3(fs, blk, block_buf, adjust,
197 errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
198 char *block_buf, int adjust,
201 return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust,
205 /* Manipulate the contents of extended attribute regions */
212 struct ext2_xattr_handle {
215 struct ext2_xattr *attrs;
216 size_t length, count;
221 static errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h,
222 unsigned int expandby)
224 struct ext2_xattr *new_attrs;
227 err = ext2fs_get_arrayzero(h->length + expandby,
228 sizeof(struct ext2_xattr), &new_attrs);
232 memcpy(new_attrs, h->attrs, h->length * sizeof(struct ext2_xattr));
233 ext2fs_free_mem(&h->attrs);
234 h->length += expandby;
235 h->attrs = new_attrs;
240 struct ea_name_index {
245 /* Keep these names sorted in order of decreasing specificity. */
246 static struct ea_name_index ea_names[] = {
247 {3, "system.posix_acl_default"},
248 {2, "system.posix_acl_access"},
249 {8, "system.richacl"},
257 /* Push empty attributes to the end and inlinedata to the front. */
258 static int attr_compare(const void *a, const void *b)
260 const struct ext2_xattr *xa = a, *xb = b;
262 if (xa->name == NULL)
264 else if (xb->name == NULL)
266 else if (!strcmp(xa->name, "system.data"))
268 else if (!strcmp(xb->name, "system.data"))
273 static const char *find_ea_prefix(int index)
275 struct ea_name_index *e;
277 for (e = ea_names; e->name; e++)
278 if (e->index == index)
284 static int find_ea_index(const char *fullname, char **name, int *index)
286 struct ea_name_index *e;
288 for (e = ea_names; e->name; e++) {
289 if (memcmp(fullname, e->name, strlen(e->name)) == 0) {
290 *name = (char *)fullname + strlen(e->name);
298 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
299 struct ext2_inode_large *inode)
301 struct ext2_ext_attr_header *header;
302 void *block_buf = NULL;
305 struct ext2_inode_large i;
309 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i,
310 sizeof(struct ext2_inode_large));
316 /* Do we already have an EA block? */
317 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
321 /* Find block, zero it, write back */
322 if ((blk < fs->super->s_first_data_block) ||
323 (blk >= ext2fs_blocks_count(fs->super))) {
324 err = EXT2_ET_BAD_EA_BLOCK_NUM;
328 err = ext2fs_get_mem(fs->blocksize, &block_buf);
332 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
336 /* We only know how to deal with v2 EA blocks */
337 header = (struct ext2_ext_attr_header *) block_buf;
338 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
339 err = EXT2_ET_BAD_EA_HEADER;
343 header->h_refcount--;
344 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
348 /* Erase link to block */
349 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0);
350 if (header->h_refcount == 0)
351 ext2fs_block_alloc_stats2(fs, blk, -1);
352 err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1);
358 err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i,
359 sizeof(struct ext2_inode_large));
365 ext2fs_free_mem(&block_buf);
370 static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino,
371 struct ext2_inode_large *inode)
373 struct ext2_ext_attr_header *header;
374 void *block_buf = NULL;
378 /* Do we already have an EA block? */
379 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
381 if ((blk < fs->super->s_first_data_block) ||
382 (blk >= ext2fs_blocks_count(fs->super))) {
383 err = EXT2_ET_BAD_EA_BLOCK_NUM;
387 err = ext2fs_get_mem(fs->blocksize, &block_buf);
391 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
395 /* We only know how to deal with v2 EA blocks */
396 header = (struct ext2_ext_attr_header *) block_buf;
397 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
398 err = EXT2_ET_BAD_EA_HEADER;
402 /* Single-user block. We're done here. */
403 if (header->h_refcount == 1)
406 /* We need to CoW the block. */
407 header->h_refcount--;
408 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
412 /* No block, we must increment i_blocks */
413 err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode,
419 /* Allocate a block */
420 goal = ext2fs_find_inode_goal(fs, ino, (struct ext2_inode *)inode, 0);
421 err = ext2fs_alloc_block2(fs, goal, NULL, &blk);
424 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk);
427 ext2fs_free_mem(&block_buf);
433 static errcode_t write_xattrs_to_buffer(struct ext2_xattr_handle *handle,
434 struct ext2_xattr **pos,
436 unsigned int storage_size,
437 unsigned int value_offset_correction,
440 struct ext2_xattr *x = *pos;
441 struct ext2_ext_attr_entry *e = entries_start;
442 void *end = entries_start + storage_size;
444 unsigned int entry_size, value_size;
447 memset(entries_start, 0, storage_size);
448 /* For all remaining x... */
449 for (; x < handle->attrs + handle->length; x++) {
453 /* Calculate index and shortname position */
455 ret = find_ea_index(x->name, &shortname, &idx);
457 /* Calculate entry and value size */
458 entry_size = (sizeof(*e) + strlen(shortname) +
459 EXT2_EXT_ATTR_PAD - 1) &
460 ~(EXT2_EXT_ATTR_PAD - 1);
461 value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) /
462 EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD;
465 * Would entry collide with value?
466 * Note that we must leave sufficient room for a (u32)0 to
467 * mark the end of the entries.
469 if ((void *)e + entry_size + sizeof(__u32) > end - value_size)
472 /* Fill out e appropriately */
473 e->e_name_len = strlen(shortname);
474 e->e_name_index = (ret ? idx : 0);
475 e->e_value_offs = end - value_size - (void *)entries_start +
476 value_offset_correction;
477 e->e_value_block = 0;
478 e->e_value_size = x->value_len;
480 /* Store name and value */
482 memcpy((void *)e + sizeof(*e), shortname, e->e_name_len);
483 memcpy(end, x->value, e->e_value_size);
486 e->e_hash = ext2fs_ext_attr_hash_entry(e, end);
490 e = EXT2_EXT_ATTR_NEXT(e);
498 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle)
500 struct ext2_xattr *x;
501 struct ext2_inode_large *inode;
502 void *start, *block_buf = NULL;
503 struct ext2_ext_attr_header *header;
504 __u32 ea_inode_magic;
506 unsigned int storage_size;
510 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
511 i = EXT2_INODE_SIZE(handle->fs->super);
512 if (i < sizeof(*inode))
514 err = ext2fs_get_memzero(i, &inode);
518 err = ext2fs_read_inode_full(handle->fs, handle->ino,
519 (struct ext2_inode *)inode,
520 EXT2_INODE_SIZE(handle->fs->super));
524 /* If extra_isize isn't set, we need to set it now */
525 if (inode->i_extra_isize == 0 &&
526 EXT2_INODE_SIZE(handle->fs->super) > EXT2_GOOD_OLD_INODE_SIZE) {
527 char *p = (char *)inode;
528 size_t extra = handle->fs->super->s_want_extra_isize;
531 extra = sizeof(__u32);
532 memset(p + EXT2_GOOD_OLD_INODE_SIZE, 0, extra);
533 inode->i_extra_isize = extra;
537 * Force the inlinedata attr to the front and the empty entries
541 qsort(x, handle->length, sizeof(struct ext2_xattr), attr_compare);
543 /* Does the inode have space for EA? */
544 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
545 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
546 inode->i_extra_isize +
550 /* Write the inode EA */
551 ea_inode_magic = EXT2_EXT_ATTR_MAGIC;
552 memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
553 inode->i_extra_isize, &ea_inode_magic, sizeof(__u32));
554 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
555 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
557 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
558 inode->i_extra_isize + sizeof(__u32);
560 err = write_xattrs_to_buffer(handle, &x, start, storage_size, 0, 0);
566 if (x >= handle->attrs + handle->count)
569 /* Write the EA block */
570 err = ext2fs_get_memzero(handle->fs->blocksize, &block_buf);
574 storage_size = handle->fs->blocksize -
575 sizeof(struct ext2_ext_attr_header);
576 start = block_buf + sizeof(struct ext2_ext_attr_header);
578 err = write_xattrs_to_buffer(handle, &x, start, storage_size,
579 (void *)start - block_buf, 1);
583 if (x < handle->attrs + handle->length) {
584 err = EXT2_ET_EA_NO_SPACE;
588 /* Write a header on the EA block */
590 header->h_magic = EXT2_EXT_ATTR_MAGIC;
591 header->h_refcount = 1;
592 header->h_blocks = 1;
594 /* Get a new block for writing */
595 err = prep_ea_block_for_write(handle->fs, handle->ino, inode);
599 /* Finally, write the new EA block */
600 blk = ext2fs_file_acl_block(handle->fs,
601 (struct ext2_inode *)inode);
602 err = ext2fs_write_ext_attr3(handle->fs, blk, block_buf,
608 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
609 if (!block_buf && blk) {
610 /* xattrs shrunk, free the block */
611 err = ext2fs_free_ext_attr(handle->fs, handle->ino, inode);
616 /* Write the inode */
617 err = ext2fs_write_inode_full(handle->fs, handle->ino,
618 (struct ext2_inode *)inode,
619 EXT2_INODE_SIZE(handle->fs->super));
624 ext2fs_free_mem(&block_buf);
626 ext2fs_free_mem(&inode);
631 static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle,
632 struct ext2_ext_attr_entry *entries,
633 unsigned int storage_size,
637 struct ext2_xattr *x;
638 struct ext2_ext_attr_entry *entry, *end;
640 unsigned int remain, prefix_len;
642 unsigned int values_size = storage_size +
643 ((char *)entries - (char *)value_start);
651 remain = storage_size;
652 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
653 !EXT2_EXT_IS_LAST_ENTRY(end)) {
655 /* header eats this space */
656 remain -= sizeof(struct ext2_ext_attr_entry);
658 /* is attribute name valid? */
659 if (EXT2_EXT_ATTR_SIZE(end->e_name_len) > remain)
660 return EXT2_ET_EA_BAD_NAME_LEN;
662 /* attribute len eats this space */
663 remain -= EXT2_EXT_ATTR_SIZE(end->e_name_len);
664 end = EXT2_EXT_ATTR_NEXT(end);
668 remain = storage_size;
669 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
670 !EXT2_EXT_IS_LAST_ENTRY(entry)) {
673 /* header eats this space */
674 remain -= sizeof(struct ext2_ext_attr_entry);
676 /* attribute len eats this space */
677 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
679 /* check value size */
680 if (entry->e_value_size > remain)
681 return EXT2_ET_EA_BAD_VALUE_SIZE;
683 if (entry->e_value_offs + entry->e_value_size > values_size)
684 return EXT2_ET_EA_BAD_VALUE_OFFSET;
686 if (entry->e_value_size > 0 &&
687 value_start + entry->e_value_offs <
688 (void *)end + sizeof(__u32))
689 return EXT2_ET_EA_BAD_VALUE_OFFSET;
691 /* e_value_block must be 0 in inode's ea */
692 if (entry->e_value_block != 0)
693 return EXT2_ET_BAD_EA_BLOCK_NUM;
695 hash = ext2fs_ext_attr_hash_entry(entry, value_start +
696 entry->e_value_offs);
698 /* e_hash may be 0 in older inode's ea */
699 if (entry->e_hash != 0 && entry->e_hash != hash)
700 return EXT2_ET_BAD_EA_HASH;
702 remain -= entry->e_value_size;
704 /* Allocate space for more attrs? */
705 if (x == handle->attrs + handle->length) {
706 err = ext2fs_xattrs_expand(handle, 4);
709 x = handle->attrs + handle->length - 4;
712 /* Extract name/value */
713 prefix = find_ea_prefix(entry->e_name_index);
714 prefix_len = (prefix ? strlen(prefix) : 0);
715 err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1,
720 memcpy(x->name, prefix, prefix_len);
721 if (entry->e_name_len)
722 memcpy(x->name + prefix_len,
723 (void *)entry + sizeof(*entry),
726 err = ext2fs_get_mem(entry->e_value_size, &x->value);
729 x->value_len = entry->e_value_size;
730 memcpy(x->value, value_start + entry->e_value_offs,
731 entry->e_value_size);
734 entry = EXT2_EXT_ATTR_NEXT(entry);
740 static void xattrs_free_keys(struct ext2_xattr_handle *h)
742 struct ext2_xattr *a = h->attrs;
745 for (i = 0; i < h->length; i++) {
747 ext2fs_free_mem(&a[i].name);
749 ext2fs_free_mem(&a[i].value);
754 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle)
756 struct ext2_inode_large *inode;
757 struct ext2_ext_attr_header *header;
758 __u32 ea_inode_magic;
759 unsigned int storage_size;
760 void *start, *block_buf = NULL;
765 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
766 i = EXT2_INODE_SIZE(handle->fs->super);
767 if (i < sizeof(*inode))
769 err = ext2fs_get_memzero(i, &inode);
773 err = ext2fs_read_inode_full(handle->fs, handle->ino,
774 (struct ext2_inode *)inode,
775 EXT2_INODE_SIZE(handle->fs->super));
779 xattrs_free_keys(handle);
781 /* Does the inode have space for EA? */
782 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
783 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
784 inode->i_extra_isize +
788 /* Look for EA in the inode */
789 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
790 inode->i_extra_isize, sizeof(__u32));
791 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
792 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
793 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
795 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
796 inode->i_extra_isize + sizeof(__u32);
798 err = read_xattrs_from_buffer(handle, start, storage_size,
799 start, &handle->count);
805 /* Look for EA in a separate EA block */
806 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
808 if ((blk < handle->fs->super->s_first_data_block) ||
809 (blk >= ext2fs_blocks_count(handle->fs->super))) {
810 err = EXT2_ET_BAD_EA_BLOCK_NUM;
814 err = ext2fs_get_mem(handle->fs->blocksize, &block_buf);
818 err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf,
823 /* We only know how to deal with v2 EA blocks */
824 header = (struct ext2_ext_attr_header *) block_buf;
825 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
826 err = EXT2_ET_BAD_EA_HEADER;
831 storage_size = handle->fs->blocksize -
832 sizeof(struct ext2_ext_attr_header);
833 start = block_buf + sizeof(struct ext2_ext_attr_header);
834 err = read_xattrs_from_buffer(handle, start, storage_size,
835 block_buf, &handle->count);
839 ext2fs_free_mem(&block_buf);
842 ext2fs_free_mem(&block_buf);
843 ext2fs_free_mem(&inode);
847 ext2fs_free_mem(&block_buf);
849 ext2fs_free_mem(&inode);
853 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h,
854 int (*func)(char *name, char *value,
855 size_t value_len, void *data),
858 struct ext2_xattr *x;
861 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
862 for (x = h->attrs; x < h->attrs + h->length; x++) {
866 ret = func(x->name, x->value, x->value_len, data);
867 if (ret & XATTR_CHANGED)
869 if (ret & XATTR_ABORT)
876 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key,
877 void **value, size_t *value_len)
879 struct ext2_xattr *x;
883 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
884 for (x = h->attrs; x < h->attrs + h->length; x++) {
888 if (strcmp(x->name, key) == 0) {
889 err = ext2fs_get_mem(x->value_len, &val);
892 memcpy(val, x->value, x->value_len);
894 *value_len = x->value_len;
899 return EXT2_ET_EA_KEY_NOT_FOUND;
902 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino,
905 struct ext2_ext_attr_entry *entry;
906 struct ext2_inode_large *inode;
907 __u32 ea_inode_magic;
913 i = EXT2_INODE_SIZE(fs->super);
914 if (i < sizeof(*inode))
916 err = ext2fs_get_memzero(i, &inode);
920 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)inode,
921 EXT2_INODE_SIZE(fs->super));
925 /* Does the inode have size for EA? */
926 if (EXT2_INODE_SIZE(fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
927 inode->i_extra_isize +
929 err = EXT2_ET_INLINE_DATA_NO_SPACE;
933 minoff = EXT2_INODE_SIZE(fs->super) - sizeof(*inode) - sizeof(__u32);
934 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
935 inode->i_extra_isize, sizeof(__u32));
936 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
937 /* has xattrs. calculate the size */
938 start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
939 inode->i_extra_isize + sizeof(__u32);
941 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
942 if (!entry->e_value_block && entry->e_value_size) {
943 unsigned int offs = entry->e_value_offs;
947 entry = EXT2_EXT_ATTR_NEXT(entry);
949 *size = minoff - ((char *)entry - (char *)start) - sizeof(__u32);
951 /* no xattr. return a maximum size */
952 *size = EXT2_EXT_ATTR_SIZE(minoff -
953 EXT2_EXT_ATTR_LEN(strlen("data")) -
954 EXT2_EXT_ATTR_ROUND - sizeof(__u32));
958 ext2fs_free_mem(&inode);
962 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle,
967 struct ext2_xattr *x, *last_empty;
971 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
973 for (x = handle->attrs; x < handle->attrs + handle->length; x++) {
980 if (strcmp(x->name, key) == 0) {
981 err = ext2fs_get_mem(value_len, &new_value);
984 memcpy(new_value, value, value_len);
985 ext2fs_free_mem(&x->value);
986 x->value = new_value;
987 x->value_len = value_len;
993 /* Add attr to empty slot */
995 err = ext2fs_get_mem(strlen(key) + 1, &last_empty->name);
998 strcpy(last_empty->name, key);
1000 err = ext2fs_get_mem(value_len, &last_empty->value);
1003 memcpy(last_empty->value, value, value_len);
1004 last_empty->value_len = value_len;
1010 /* Expand array, append slot */
1011 err = ext2fs_xattrs_expand(handle, 4);
1015 x = handle->attrs + handle->length - 4;
1016 err = ext2fs_get_mem(strlen(key) + 1, &x->name);
1019 strcpy(x->name, key);
1021 err = ext2fs_get_mem(value_len, &x->value);
1024 memcpy(x->value, value, value_len);
1025 x->value_len = value_len;
1031 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle,
1034 struct ext2_xattr *x;
1036 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1037 for (x = handle->attrs; x < handle->attrs + handle->length; x++) {
1041 if (strcmp(x->name, key) == 0) {
1042 ext2fs_free_mem(&x->name);
1043 ext2fs_free_mem(&x->value);
1051 /* no key found, success! */
1055 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino,
1056 struct ext2_xattr_handle **handle)
1058 struct ext2_xattr_handle *h;
1061 if (!EXT2_HAS_COMPAT_FEATURE(fs->super,
1062 EXT2_FEATURE_COMPAT_EXT_ATTR) &&
1063 !EXT2_HAS_INCOMPAT_FEATURE(fs->super,
1064 EXT4_FEATURE_INCOMPAT_INLINE_DATA))
1065 return EXT2_ET_MISSING_EA_FEATURE;
1067 err = ext2fs_get_memzero(sizeof(*h), &h);
1071 h->magic = EXT2_ET_MAGIC_EA_HANDLE;
1073 err = ext2fs_get_arrayzero(h->length, sizeof(struct ext2_xattr),
1076 ext2fs_free_mem(&h);
1086 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle)
1088 struct ext2_xattr_handle *h = *handle;
1091 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1093 err = ext2fs_xattrs_write(h);
1098 xattrs_free_keys(h);
1099 ext2fs_free_mem(&h->attrs);
1100 ext2fs_free_mem(handle);
1104 errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count)
1106 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1107 *count = handle->count;