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 #undef NAME_HASH_SHIFT
62 #undef VALUE_HASH_SHIFT
64 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
69 retval = io_channel_read_blk64(fs->io, block, 1, buf);
73 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
74 !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf))
75 retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
77 #ifdef WORDS_BIGENDIAN
78 ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1);
84 errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf)
86 return ext2fs_read_ext_attr3(fs, block, buf, 0);
89 errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf)
91 return ext2fs_read_ext_attr2(fs, block, buf);
94 errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *inbuf,
100 #ifdef WORDS_BIGENDIAN
101 retval = ext2fs_get_mem(fs->blocksize, &write_buf);
104 ext2fs_swap_ext_attr(write_buf, inbuf, fs->blocksize, 1);
106 write_buf = (char *) inbuf;
109 retval = ext2fs_ext_attr_block_csum_set(fs, inum, block,
110 (struct ext2_ext_attr_header *)write_buf);
114 retval = io_channel_write_blk64(fs->io, block, 1, write_buf);
115 #ifdef WORDS_BIGENDIAN
116 ext2fs_free_mem(&write_buf);
119 ext2fs_mark_changed(fs);
123 errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *inbuf)
125 return ext2fs_write_ext_attr3(fs, block, inbuf, 0);
128 errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf)
130 return ext2fs_write_ext_attr2(fs, block, inbuf);
134 * This function adjusts the reference count of the EA block.
136 errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk,
137 char *block_buf, int adjust,
138 __u32 *newcount, ext2_ino_t inum)
141 struct ext2_ext_attr_header *header;
144 if ((blk >= ext2fs_blocks_count(fs->super)) ||
145 (blk < fs->super->s_first_data_block))
146 return EXT2_ET_BAD_EA_BLOCK_NUM;
149 retval = ext2fs_get_mem(fs->blocksize, &buf);
155 retval = ext2fs_read_ext_attr3(fs, blk, block_buf, inum);
159 header = (struct ext2_ext_attr_header *) block_buf;
160 header->h_refcount += adjust;
162 *newcount = header->h_refcount;
164 retval = ext2fs_write_ext_attr3(fs, blk, block_buf, inum);
170 ext2fs_free_mem(&buf);
174 errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
175 char *block_buf, int adjust,
178 return ext2fs_adjust_ea_refcount3(fs, blk, block_buf, adjust,
182 errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
183 char *block_buf, int adjust,
186 return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust,
190 /* Manipulate the contents of extended attribute regions */
197 struct ext2_xattr_handle {
199 struct ext2_xattr *attrs;
200 size_t length, count;
205 static errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h,
206 unsigned int expandby)
208 struct ext2_xattr *new_attrs;
211 err = ext2fs_get_arrayzero(h->length + expandby,
212 sizeof(struct ext2_xattr), &new_attrs);
216 memcpy(new_attrs, h->attrs, h->length * sizeof(struct ext2_xattr));
217 ext2fs_free_mem(&h->attrs);
218 h->length += expandby;
219 h->attrs = new_attrs;
224 struct ea_name_index {
229 /* Keep these names sorted in order of decreasing specificity. */
230 static struct ea_name_index ea_names[] = {
231 {3, "system.posix_acl_default"},
232 {2, "system.posix_acl_access"},
233 {8, "system.richacl"},
241 static const char *find_ea_prefix(int index)
243 struct ea_name_index *e;
245 for (e = ea_names; e->name; e++)
246 if (e->index == index)
252 static int find_ea_index(const char *fullname, char **name, int *index)
254 struct ea_name_index *e;
256 for (e = ea_names; e->name; e++) {
257 if (memcmp(fullname, e->name, strlen(e->name)) == 0) {
258 *name = (char *)fullname + strlen(e->name);
266 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
267 struct ext2_inode_large *inode)
269 struct ext2_ext_attr_header *header;
270 void *block_buf = NULL;
274 struct ext2_inode_large i;
278 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i,
279 sizeof(struct ext2_inode_large));
285 /* Do we already have an EA block? */
286 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
290 /* Find block, zero it, write back */
291 if ((blk < fs->super->s_first_data_block) ||
292 (blk >= ext2fs_blocks_count(fs->super))) {
293 err = EXT2_ET_BAD_EA_BLOCK_NUM;
297 err = ext2fs_get_mem(fs->blocksize, &block_buf);
301 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
305 header = (struct ext2_ext_attr_header *) block_buf;
306 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
307 err = EXT2_ET_BAD_EA_HEADER;
311 header->h_refcount--;
312 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
316 /* Erase link to block */
317 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0);
318 if (header->h_refcount == 0)
319 ext2fs_block_alloc_stats2(fs, blk, -1);
320 err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1);
326 err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i,
327 sizeof(struct ext2_inode_large));
333 ext2fs_free_mem(&block_buf);
338 static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino,
339 struct ext2_inode_large *inode)
341 struct ext2_ext_attr_header *header;
342 void *block_buf = NULL;
347 /* Do we already have an EA block? */
348 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
350 if ((blk < fs->super->s_first_data_block) ||
351 (blk >= ext2fs_blocks_count(fs->super))) {
352 err = EXT2_ET_BAD_EA_BLOCK_NUM;
356 err = ext2fs_get_mem(fs->blocksize, &block_buf);
360 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
364 header = (struct ext2_ext_attr_header *) block_buf;
365 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
366 err = EXT2_ET_BAD_EA_HEADER;
370 /* Single-user block. We're done here. */
371 if (header->h_refcount == 1)
374 /* We need to CoW the block. */
375 header->h_refcount--;
376 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
380 /* No block, we must increment i_blocks */
381 err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode,
387 /* Allocate a block */
388 grp = ext2fs_group_of_ino(fs, ino);
389 goal = ext2fs_inode_table_loc(fs, grp);
390 err = ext2fs_alloc_block2(fs, goal, NULL, &blk);
393 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk);
396 ext2fs_free_mem(&block_buf);
402 static errcode_t write_xattrs_to_buffer(struct ext2_xattr_handle *handle,
403 struct ext2_xattr **pos,
405 unsigned int storage_size,
406 unsigned int value_offset_correction)
408 struct ext2_xattr *x = *pos;
409 struct ext2_ext_attr_entry *e = entries_start;
410 void *end = entries_start + storage_size;
412 unsigned int entry_size, value_size;
415 /* For all remaining x... */
416 for (; x < handle->attrs + handle->length; x++) {
420 /* Calculate index and shortname position */
422 ret = find_ea_index(x->name, &shortname, &idx);
424 /* Calculate entry and value size */
425 entry_size = (sizeof(*e) + strlen(shortname) +
426 EXT2_EXT_ATTR_PAD - 1) &
427 ~(EXT2_EXT_ATTR_PAD - 1);
428 value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) /
429 EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD;
432 * Would entry collide with value?
433 * Note that we must leave sufficient room for a (u32)0 to
434 * mark the end of the entries.
436 if ((void *)e + entry_size + sizeof(__u32) > end - value_size)
439 /* Fill out e appropriately */
440 e->e_name_len = strlen(shortname);
441 e->e_name_index = (ret ? idx : 0);
442 e->e_value_offs = end - value_size - (void *)entries_start +
443 value_offset_correction;
444 e->e_value_block = 0;
445 e->e_value_size = x->value_len;
447 /* Store name and value */
449 memcpy((void *)e + sizeof(*e), shortname, e->e_name_len);
450 memcpy(end, x->value, e->e_value_size);
452 e->e_hash = ext2fs_ext_attr_hash_entry(e, end);
454 e = EXT2_EXT_ATTR_NEXT(e);
462 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle)
464 struct ext2_xattr *x;
465 struct ext2_inode_large *inode;
466 void *start, *block_buf = NULL;
467 struct ext2_ext_attr_header *header;
468 __u32 ea_inode_magic;
470 unsigned int storage_size;
474 i = EXT2_INODE_SIZE(handle->fs->super);
475 if (i < sizeof(*inode))
477 err = ext2fs_get_memzero(i, &inode);
481 err = ext2fs_read_inode_full(handle->fs, handle->ino,
482 (struct ext2_inode *)inode,
483 EXT2_INODE_SIZE(handle->fs->super));
488 /* Does the inode have size for EA? */
489 if (EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
490 inode->i_extra_isize +
494 /* Write the inode EA */
495 ea_inode_magic = EXT2_EXT_ATTR_MAGIC;
496 memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
497 inode->i_extra_isize, &ea_inode_magic, sizeof(__u32));
498 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
499 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
501 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
502 inode->i_extra_isize + sizeof(__u32);
504 err = write_xattrs_to_buffer(handle, &x, start, storage_size, 0);
509 if (x == handle->attrs + handle->length)
513 /* Write the EA block */
514 err = ext2fs_get_memzero(handle->fs->blocksize, &block_buf);
518 storage_size = handle->fs->blocksize -
519 sizeof(struct ext2_ext_attr_header);
520 start = block_buf + sizeof(struct ext2_ext_attr_header);
522 err = write_xattrs_to_buffer(handle, &x, start, storage_size,
523 (void *)start - block_buf);
527 if (x < handle->attrs + handle->length) {
528 err = EXT2_ET_EA_NO_SPACE;
532 /* Write a header on the EA block */
534 header->h_magic = EXT2_EXT_ATTR_MAGIC;
535 header->h_refcount = 1;
536 header->h_blocks = 1;
538 /* Get a new block for writing */
539 err = prep_ea_block_for_write(handle->fs, handle->ino, inode);
543 /* Finally, write the new EA block */
544 blk = ext2fs_file_acl_block(handle->fs,
545 (struct ext2_inode *)inode);
546 err = ext2fs_write_ext_attr3(handle->fs, blk, block_buf,
552 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
553 if (!block_buf && blk) {
554 /* xattrs shrunk, free the block */
555 err = ext2fs_free_ext_attr(handle->fs, handle->ino, inode);
560 /* Write the inode */
561 err = ext2fs_write_inode_full(handle->fs, handle->ino,
562 (struct ext2_inode *)inode,
563 EXT2_INODE_SIZE(handle->fs->super));
568 ext2fs_free_mem(&block_buf);
570 ext2fs_free_mem(&inode);
575 static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle,
576 struct ext2_ext_attr_entry *entries,
577 unsigned int storage_size,
581 struct ext2_xattr *x;
582 struct ext2_ext_attr_entry *entry;
585 unsigned int remain, prefix_len;
593 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
596 /* header eats this space */
597 remain -= sizeof(struct ext2_ext_attr_entry);
599 /* is attribute name valid? */
600 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain)
601 return EXT2_ET_EA_BAD_NAME_LEN;
603 /* attribute len eats this space */
604 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
606 /* check value size */
607 if (entry->e_value_size > remain)
608 return EXT2_ET_EA_BAD_VALUE_SIZE;
610 /* e_value_block must be 0 in inode's ea */
611 if (entry->e_value_block != 0)
612 return EXT2_ET_BAD_EA_BLOCK_NUM;
614 hash = ext2fs_ext_attr_hash_entry(entry, value_start +
615 entry->e_value_offs);
617 /* e_hash may be 0 in older inode's ea */
618 if (entry->e_hash != 0 && entry->e_hash != hash)
619 return EXT2_ET_BAD_EA_HASH;
621 remain -= entry->e_value_size;
623 /* Allocate space for more attrs? */
624 if (x == handle->attrs + handle->length) {
625 err = ext2fs_xattrs_expand(handle, 4);
628 x = handle->attrs + handle->length - 4;
631 /* Extract name/value */
632 prefix = find_ea_prefix(entry->e_name_index);
633 prefix_len = (prefix ? strlen(prefix) : 0);
634 err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1,
639 memcpy(x->name, prefix, prefix_len);
640 if (entry->e_name_len)
641 memcpy(x->name + prefix_len,
642 (void *)entry + sizeof(*entry),
645 err = ext2fs_get_mem(entry->e_value_size, &x->value);
648 x->value_len = entry->e_value_size;
649 memcpy(x->value, value_start + entry->e_value_offs,
650 entry->e_value_size);
653 entry = EXT2_EXT_ATTR_NEXT(entry);
659 static void xattrs_free_keys(struct ext2_xattr_handle *h)
661 struct ext2_xattr *a = h->attrs;
664 for (i = 0; i < h->length; i++) {
666 ext2fs_free_mem(&a[i].name);
668 ext2fs_free_mem(&a[i].value);
673 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle)
675 struct ext2_xattr *attrs = NULL, *x;
676 struct ext2_inode_large *inode;
677 struct ext2_ext_attr_header *header;
678 __u32 ea_inode_magic;
679 unsigned int storage_size;
680 void *start, *block_buf = NULL;
685 i = EXT2_INODE_SIZE(handle->fs->super);
686 if (i < sizeof(*inode))
688 err = ext2fs_get_memzero(i, &inode);
692 err = ext2fs_read_inode_full(handle->fs, handle->ino,
693 (struct ext2_inode *)inode,
694 EXT2_INODE_SIZE(handle->fs->super));
698 xattrs_free_keys(handle);
700 /* Does the inode have size for EA? */
701 if (EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
702 inode->i_extra_isize +
706 /* Look for EA in the inode */
707 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
708 inode->i_extra_isize, sizeof(__u32));
709 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
710 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
711 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
713 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
714 inode->i_extra_isize + sizeof(__u32);
716 err = read_xattrs_from_buffer(handle, start, storage_size,
717 start, &handle->count);
723 /* Look for EA in a separate EA block */
724 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
726 if ((blk < handle->fs->super->s_first_data_block) ||
727 (blk >= ext2fs_blocks_count(handle->fs->super))) {
728 err = EXT2_ET_BAD_EA_BLOCK_NUM;
732 err = ext2fs_get_mem(handle->fs->blocksize, &block_buf);
736 err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf,
741 header = (struct ext2_ext_attr_header *) block_buf;
742 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
743 err = EXT2_ET_BAD_EA_HEADER;
747 if (header->h_blocks != 1) {
748 err = EXT2_ET_BAD_EA_HEADER;
753 storage_size = handle->fs->blocksize -
754 sizeof(struct ext2_ext_attr_header);
755 start = block_buf + sizeof(struct ext2_ext_attr_header);
756 err = read_xattrs_from_buffer(handle, start, storage_size,
757 block_buf, &handle->count);
761 ext2fs_free_mem(&block_buf);
764 ext2fs_free_mem(&block_buf);
765 ext2fs_free_mem(&inode);
769 ext2fs_free_mem(&block_buf);
771 ext2fs_free_mem(&inode);
775 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h,
776 int (*func)(char *name, char *value,
777 size_t value_len, void *data),
780 struct ext2_xattr *x;
784 for (x = h->attrs; x < h->attrs + h->length; x++) {
788 ret = func(x->name, x->value, x->value_len, data);
789 if (ret & XATTR_CHANGED)
791 if (ret & XATTR_ABORT)
798 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key,
799 void **value, size_t *value_len)
801 struct ext2_xattr *x;
805 for (x = h->attrs; x < h->attrs + h->length; x++) {
809 if (strcmp(x->name, key) == 0) {
810 err = ext2fs_get_mem(x->value_len, &val);
813 memcpy(val, x->value, x->value_len);
815 *value_len = x->value_len;
820 return EXT2_ET_EA_KEY_NOT_FOUND;
823 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino,
826 struct ext2_ext_attr_header *header;
827 struct ext2_ext_attr_entry *entry;
828 struct ext2_inode_large *inode;
829 __u32 ea_inode_magic;
830 unsigned int storage_size, freesize, minoff;
835 i = EXT2_INODE_SIZE(fs->super);
836 if (i < sizeof(*inode))
838 err = ext2fs_get_memzero(i, &inode);
842 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)inode,
843 EXT2_INODE_SIZE(fs->super));
847 /* Does the inode have size for EA? */
848 if (EXT2_INODE_SIZE(fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
849 inode->i_extra_isize +
851 err = EXT2_ET_INLINE_DATA_NO_SPACE;
855 minoff = EXT2_INODE_SIZE(fs->super) - sizeof(*inode) - sizeof(__u32);
856 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
857 inode->i_extra_isize, sizeof(__u32));
858 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
859 /* has xattrs. calculate the size */
860 storage_size = EXT2_INODE_SIZE(fs->super) -
861 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
863 start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
864 inode->i_extra_isize + sizeof(__u32);
866 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
867 if (!entry->e_value_block && entry->e_value_size) {
868 unsigned int offs = entry->e_value_offs;
872 entry = EXT2_EXT_ATTR_NEXT(entry);
874 *size = minoff - ((char *)entry - (char *)start) - sizeof(__u32);
876 /* no xattr. return a maximum size */
877 *size = EXT2_EXT_ATTR_SIZE(minoff -
878 EXT2_EXT_ATTR_LEN(strlen("data")) -
879 EXT2_EXT_ATTR_ROUND - sizeof(__u32));
883 ext2fs_free_mem(&inode);
887 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle,
892 struct ext2_xattr *x, *last_empty;
897 for (x = handle->attrs; x < handle->attrs + handle->length; x++) {
904 if (strcmp(x->name, key) == 0) {
905 err = ext2fs_get_mem(value_len, &new_value);
908 memcpy(new_value, value, value_len);
909 ext2fs_free_mem(&x->value);
910 x->value = new_value;
911 x->value_len = value_len;
917 /* Add attr to empty slot */
919 err = ext2fs_get_mem(strlen(key) + 1, &last_empty->name);
922 strcpy(last_empty->name, key);
924 err = ext2fs_get_mem(value_len, &last_empty->value);
927 memcpy(last_empty->value, value, value_len);
928 last_empty->value_len = value_len;
934 /* Expand array, append slot */
935 err = ext2fs_xattrs_expand(handle, 4);
939 x = handle->attrs + handle->length - 4;
940 err = ext2fs_get_mem(strlen(key) + 1, &x->name);
943 strcpy(x->name, key);
945 err = ext2fs_get_mem(value_len, &x->value);
948 memcpy(x->value, value, value_len);
949 x->value_len = value_len;
955 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle,
958 struct ext2_xattr *x;
961 for (x = handle->attrs; x < handle->attrs + handle->length; x++) {
965 if (strcmp(x->name, key) == 0) {
966 ext2fs_free_mem(&x->name);
967 ext2fs_free_mem(&x->value);
975 return EXT2_ET_EA_KEY_NOT_FOUND;
978 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino,
979 struct ext2_xattr_handle **handle)
981 struct ext2_xattr_handle *h;
984 if (!EXT2_HAS_COMPAT_FEATURE(fs->super,
985 EXT2_FEATURE_COMPAT_EXT_ATTR) &&
986 !EXT2_HAS_INCOMPAT_FEATURE(fs->super,
987 EXT4_FEATURE_INCOMPAT_INLINE_DATA))
988 return EXT2_ET_MISSING_EA_FEATURE;
990 err = ext2fs_get_memzero(sizeof(*h), &h);
995 err = ext2fs_get_arrayzero(h->length, sizeof(struct ext2_xattr),
1008 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle)
1010 struct ext2_xattr_handle *h = *handle;
1014 err = ext2fs_xattrs_write(h);
1019 xattrs_free_keys(h);
1020 ext2fs_free_mem(&h->attrs);
1021 ext2fs_free_mem(handle);
1025 size_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle)
1027 return handle->count;