Index: head/sys/fs/ext2fs/ext2_alloc.c =================================================================== --- head/sys/fs/ext2fs/ext2_alloc.c +++ head/sys/fs/ext2fs/ext2_alloc.c @@ -132,6 +132,25 @@ } /* + * Allocate EA's block for inode. + */ +daddr_t +ext2_allocfacl(struct inode *ip) +{ + struct m_ext2fs *fs; + daddr_t facl; + + fs = ip->i_e2fs; + + EXT2_LOCK(ip->i_ump); + facl = ext2_alloccg(ip, ino_to_cg(fs, ip->i_number), 0, fs->e2fs_bsize); + if (0 == facl) + EXT2_UNLOCK(ip->i_ump); + + return (facl); +} + +/* * Reallocate a sequence of blocks into a contiguous sequence of blocks. * * The vnode and an array of buffer pointers for a range of sequential Index: head/sys/fs/ext2fs/ext2_extattr.h =================================================================== --- head/sys/fs/ext2fs/ext2_extattr.h +++ head/sys/fs/ext2fs/ext2_extattr.h @@ -30,25 +30,34 @@ #define _FS_EXT2FS_EXT2_EXTARTTR_H_ /* Linux xattr name indexes */ -#define EXT4_XATTR_INDEX_USER 1 +#define EXT4_XATTR_INDEX_USER 1 #define EXT4_XATTR_INDEX_POSIX_ACL_ACCESS 2 #define EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT 3 -#define EXT4_XATTR_INDEX_TRUSTED 4 -#define EXT4_XATTR_INDEX_LUSTRE 5 -#define EXT4_XATTR_INDEX_SECURITY 6 -#define EXT4_XATTR_INDEX_SYSTEM 7 -#define EXT4_XATTR_INDEX_RICHACL 8 -#define EXT4_XATTR_INDEX_ENCRYPTION 9 +#define EXT4_XATTR_INDEX_TRUSTED 4 +#define EXT4_XATTR_INDEX_LUSTRE 5 +#define EXT4_XATTR_INDEX_SECURITY 6 +#define EXT4_XATTR_INDEX_SYSTEM 7 +#define EXT4_XATTR_INDEX_RICHACL 8 +#define EXT4_XATTR_INDEX_ENCRYPTION 9 /* Magic value in attribute blocks */ #define EXTATTR_MAGIC 0xEA020000 +/* Max EA name length */ +#define EXT2_EXTATTR_NAMELEN_MAX 255 + +/* EA hash constants */ +#define EXT2_EXTATTR_NAME_HASH_SHIFT 5 +#define EXT2_EXTATTR_VALUE_HASH_SHIFT 16 +#define EXT2_EXTATTR_BLOCK_HASH_SHIFT 16 + + struct ext2fs_extattr_header { int32_t h_magic; /* magic number for identification */ int32_t h_refcount; /* reference count */ int32_t h_blocks; /* number of disk blocks used */ int32_t h_hash; /* hash value of all attributes */ - uint32_t h_reserved[4]; /* zero right now */ + uint32_t h_reserved[4]; /* zero right now */ }; struct ext2fs_extattr_dinode_header { @@ -56,21 +65,15 @@ }; struct ext2fs_extattr_entry { - uint8_t e_name_len; /* length of name */ + uint8_t e_name_len; /* length of name */ uint8_t e_name_index; /* attribute name index */ uint16_t e_value_offs; /* offset in disk block of value */ uint32_t e_value_block; /* disk block attribute is stored on (n/i) */ uint32_t e_value_size; /* size of attribute value */ - uint32_t e_hash; /* hash value of name and value */ - char e_name[0]; /* attribute name */ + uint32_t e_hash; /* hash value of name and value */ + char e_name[0]; /* attribute name */ }; -#define EXT2_IHDR(inode, raw_inode) \ - ((struct ext4_xattr_ibody_header *) \ - ((void *)raw_inode + \ - EXT4_GOOD_OLD_INODE_SIZE + \ - EXT4_I(inode)->i_extra_isize)) - #define EXT2_IFIRST(hdr) ((struct ext2fs_extattr_entry *)((hdr)+1)) #define EXT2_HDR(bh) ((struct ext2fs_extattr_header *)((bh)->b_data)) @@ -85,10 +88,20 @@ (((name_len) + EXT2_EXTATTR_ROUND + \ sizeof(struct ext2fs_extattr_entry)) & ~EXT2_EXTATTR_ROUND) +#define EXT2_EXTATTR_SIZE(size) \ + (((size) + EXT2_EXTATTR_ROUND) & ~EXT2_EXTATTR_ROUND) + #define EXT2_EXTATTR_NEXT(entry) \ ( (struct ext2fs_extattr_entry *)( \ (char *)(entry) + EXT2_EXTATTR_LEN((entry)->e_name_len)) ) +int ext2_extattr_inode_delete(struct inode *ip, int attrnamespace, + const char *name); + +int ext2_extattr_block_delete(struct inode *ip, int attrnamespace, + const char *name); + +int ext2_extattr_free(struct inode *ip); int ext2_extattr_inode_list(struct inode *ip, int attrnamespace, struct uio *uio, size_t *size); @@ -101,4 +114,12 @@ int ext2_extattr_block_get(struct inode *ip, int attrnamespace, const char *name, struct uio *uio, size_t *size); +int ext2_extattr_inode_set(struct inode *ip, int attrnamespace, + const char *name, struct uio *uio); + +int ext2_extattr_block_set(struct inode *ip, int attrnamespace, + const char *name, struct uio *uio); + +int ext2_extattr_valid_attrname(int attrnamespace, const char *attrname); + #endif /* !_FS_EXT2FS_EXT2_EXTARTTR_H_ */ Index: head/sys/fs/ext2fs/ext2_extattr.c =================================================================== --- head/sys/fs/ext2fs/ext2_extattr.c +++ head/sys/fs/ext2fs/ext2_extattr.c @@ -44,21 +44,66 @@ #include #include #include +#include static int ext2_extattr_index_to_bsd(int index) { switch (index) { + case EXT4_XATTR_INDEX_SYSTEM: + return (EXTATTR_NAMESPACE_SYSTEM); + case EXT4_XATTR_INDEX_USER: - return EXTATTR_NAMESPACE_USER; + return (EXTATTR_NAMESPACE_USER); + } - case EXT4_XATTR_INDEX_SYSTEM: - return EXTATTR_NAMESPACE_SYSTEM; + return (EXTATTR_NAMESPACE_EMPTY); +} + +static int +ext2_extattr_index_to_linux(int index) +{ + switch (index) { + case EXTATTR_NAMESPACE_SYSTEM: + return (EXT4_XATTR_INDEX_SYSTEM); + + case EXTATTR_NAMESPACE_USER: + return (EXT4_XATTR_INDEX_USER); + } + + return (-1); +} + +int +ext2_extattr_valid_attrname(int attrnamespace, const char *attrname) +{ + if (attrnamespace == EXTATTR_NAMESPACE_EMPTY) + return (EINVAL); + + if (strlen(attrname) == 0) + return (EINVAL); + + if (strlen(attrname) + 1 > EXT2_EXTATTR_NAMELEN_MAX) + return (ENAMETOOLONG); + + return (0); +} + +static int +ext2_extattr_check(struct ext2fs_extattr_entry *entry, char *end) +{ + struct ext2fs_extattr_entry *next; + + while (!EXT2_IS_LAST_ENTRY(entry)) { + next = EXT2_EXTATTR_NEXT(entry); + if ((char *)next >= end) + return (EIO); - default: - return EXTATTR_NAMESPACE_EMPTY; + entry = next; } + + return (0); } int @@ -69,8 +114,6 @@ struct buf *bp; struct ext2fs_extattr_dinode_header *header; struct ext2fs_extattr_entry *entry; - struct ext2fs_extattr_entry *next; - char *end; int error; fs = ip->i_e2fs; @@ -95,21 +138,15 @@ return (0); } - /* Check attributes integrity */ - entry = EXT2_IFIRST(header); - end = (char *)dinode + EXT2_INODE_SIZE(fs); - while (!EXT2_IS_LAST_ENTRY(entry)) { - next = EXT2_EXTATTR_NEXT(entry); - if ((char *)next >= end) { - brelse(bp); - return (EIO); - } - - entry = next; + error = ext2_extattr_check(EXT2_IFIRST(header), + (char *)dinode + EXT2_INODE_SIZE(fs)); + if (error) { + brelse(bp); + return (error); } for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); - entry = EXT2_EXTATTR_NEXT(entry)) { + entry = EXT2_EXTATTR_NEXT(entry)) { if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace) continue; @@ -121,12 +158,14 @@ memcpy(&attr_name[1], entry->e_name, entry->e_name_len); error = uiomove(attr_name, entry->e_name_len + 1, uio); free(attr_name, M_TEMP); + if (error) + break; } } brelse(bp); - return (0); + return (error); } int @@ -137,8 +176,6 @@ struct buf *bp; struct ext2fs_extattr_header *header; struct ext2fs_extattr_entry *entry; - struct ext2fs_extattr_entry *next; - char *end; int error; fs = ip->i_e2fs; @@ -157,17 +194,10 @@ return (EINVAL); } - /* Check attributes integrity */ - end = bp->b_data + bp->b_bufsize; - entry = EXT2_FIRST_ENTRY(bp); - while (!EXT2_IS_LAST_ENTRY(entry)) { - next = EXT2_EXTATTR_NEXT(entry); - if ((char *)next >= end) { - brelse(bp); - return (EIO); - } - - entry = next; + error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); + if (error) { + brelse(bp); + return (error); } for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); @@ -183,12 +213,14 @@ memcpy(&attr_name[1], entry->e_name, entry->e_name_len); error = uiomove(attr_name, entry->e_name_len + 1, uio); free(attr_name, M_TEMP); + if (error) + break; } } brelse(bp); - return (0); + return (error); } int @@ -199,8 +231,6 @@ struct buf *bp; struct ext2fs_extattr_dinode_header *header; struct ext2fs_extattr_entry *entry; - struct ext2fs_extattr_entry *next; - char *end; int error; fs = ip->i_e2fs; @@ -222,20 +252,14 @@ if (header->h_magic != EXTATTR_MAGIC) { brelse(bp); - return (0); + return (ENOATTR); } - /* Check attributes integrity */ - entry = EXT2_IFIRST(header); - end = (char *)dinode + EXT2_INODE_SIZE(fs); - while (!EXT2_IS_LAST_ENTRY(entry)) { - next = EXT2_EXTATTR_NEXT(entry); - if ((char *)next >= end) { - brelse(bp); - return (EIO); - } - - entry = next; + error = ext2_extattr_check(EXT2_IFIRST(header), + (char *)dinode + EXT2_INODE_SIZE(fs)); + if (error) { + brelse(bp); + return (error); } for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); @@ -248,19 +272,18 @@ if (uio == NULL) *size += entry->e_value_size; else { - error = uiomove(((char *)EXT2_IFIRST(header)) + entry->e_value_offs, - entry->e_value_size, uio); - if (error) { - brelse(bp); - return (error); - } + error = uiomove(((char *)EXT2_IFIRST(header)) + + entry->e_value_offs, entry->e_value_size, uio); } + + brelse(bp); + return (error); } } brelse(bp); - return (0); + return (ENOATTR); } int @@ -271,8 +294,6 @@ struct buf *bp; struct ext2fs_extattr_header *header; struct ext2fs_extattr_entry *entry; - struct ext2fs_extattr_entry *next; - char *end; int error; fs = ip->i_e2fs; @@ -291,17 +312,10 @@ return (EINVAL); } - /* Check attributes integrity */ - end = bp->b_data + bp->b_bufsize; - entry = EXT2_FIRST_ENTRY(bp); - while (!EXT2_IS_LAST_ENTRY(entry)) { - next = EXT2_EXTATTR_NEXT(entry); - if ((char *)next >= end) { - brelse(bp); - return (EIO); - } - - entry = next; + error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); + if (error) { + brelse(bp); + return (error); } for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); @@ -316,15 +330,725 @@ else { error = uiomove(bp->b_data + entry->e_value_offs, entry->e_value_size, uio); - if (error) { - brelse(bp); - return (error); - } } + + brelse(bp); + return (error); } } brelse(bp); + return (ENOATTR); +} + +static uint16_t +ext2_extattr_delete_value(char *off, + struct ext2fs_extattr_entry *first_entry, + struct ext2fs_extattr_entry *entry, char *end) +{ + uint16_t min_offs; + struct ext2fs_extattr_entry *next; + + min_offs = end - off; + next = first_entry; + while (!EXT2_IS_LAST_ENTRY(next)) { + if (min_offs > next->e_value_offs && next->e_value_offs > 0) + min_offs = next->e_value_offs; + + next = EXT2_EXTATTR_NEXT(next); + } + + if (entry->e_value_size == 0) + return (min_offs); + + memmove(off + min_offs + EXT2_EXTATTR_SIZE(entry->e_value_size), + off + min_offs, entry->e_value_offs - min_offs); + + /* Adjust all value offsets */ + next = first_entry; + while (!EXT2_IS_LAST_ENTRY(next)) + { + if (next->e_value_offs > 0 && + next->e_value_offs < entry->e_value_offs) + next->e_value_offs += + EXT2_EXTATTR_SIZE(entry->e_value_size); + + next = EXT2_EXTATTR_NEXT(next); + } + + min_offs += EXT2_EXTATTR_SIZE(entry->e_value_size); + + return (min_offs); +} + +static void +ext2_extattr_delete_entry(char *off, + struct ext2fs_extattr_entry *first_entry, + struct ext2fs_extattr_entry *entry, char *end) +{ + char *pad; + struct ext2fs_extattr_entry *next; + + /* Clean entry value */ + ext2_extattr_delete_value(off, first_entry, entry, end); + + /* Clean the entry */ + next = first_entry; + while (!EXT2_IS_LAST_ENTRY(next)) + next = EXT2_EXTATTR_NEXT(next); + + pad = (char*)next + sizeof(uint32_t); + + memmove(entry, (char *)entry + EXT2_EXTATTR_LEN(entry->e_name_len), + pad - ((char *)entry + EXT2_EXTATTR_LEN(entry->e_name_len))); +} + +int +ext2_extattr_inode_delete(struct inode *ip, int attrnamespace, const char *name) +{ + struct m_ext2fs *fs; + struct buf *bp; + struct ext2fs_extattr_dinode_header *header; + struct ext2fs_extattr_entry *entry; + int error; + + fs = ip->i_e2fs; + + if ((error = bread(ip->i_devvp, + fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), + (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) { + brelse(bp); + return (error); + } + + struct ext2fs_dinode *dinode = (struct ext2fs_dinode *) + ((char *)bp->b_data + + EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)); + + /* Check attributes magic value */ + header = (struct ext2fs_extattr_dinode_header *)((char *)dinode + + E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize); + + if (header->h_magic != EXTATTR_MAGIC) { + brelse(bp); + return (ENOATTR); + } + + error = ext2_extattr_check(EXT2_IFIRST(header), + (char *)dinode + EXT2_INODE_SIZE(fs)); + if (error) { + brelse(bp); + return (error); + } + + /* If I am last entry, just make magic zero */ + entry = EXT2_IFIRST(header); + if (EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry))) { + if (strlen(name) == entry->e_name_len && + 0 == strncmp(entry->e_name, name, entry->e_name_len)) { + memset(header, 0, sizeof(struct ext2fs_extattr_dinode_header)); + + return (bwrite(bp)); + } + } + + for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); + entry = EXT2_EXTATTR_NEXT(entry)) { + if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace) + continue; + + if (strlen(name) == entry->e_name_len && + 0 == strncmp(entry->e_name, name, entry->e_name_len)) { + ext2_extattr_delete_entry((char *)EXT2_IFIRST(header), + EXT2_IFIRST(header), entry, + (char *)dinode + EXT2_INODE_SIZE(fs)); + + return (bwrite(bp)); + } + } + + brelse(bp); + + return (ENOATTR); +} + +static int +ext2_extattr_block_clone(struct inode *ip, struct buf **bpp) +{ + struct m_ext2fs *fs; + struct buf *sbp; + struct buf *cbp; + struct ext2fs_extattr_header *header; + uint64_t facl; + + fs = ip->i_e2fs; + sbp = *bpp; + + header = EXT2_HDR(sbp); + if (header->h_magic != EXTATTR_MAGIC || header->h_refcount == 1) + return (EINVAL); + + facl = ext2_allocfacl(ip); + if (!facl) + return (ENOSPC); + + cbp = getblk(ip->i_devvp, fsbtodb(fs, facl), fs->e2fs_bsize, 0, 0, 0); + if (!cbp) { + ext2_blkfree(ip, facl, fs->e2fs_bsize); + return (EIO); + } + + memcpy(cbp->b_data, sbp->b_data, fs->e2fs_bsize); + header->h_refcount--; + bwrite(sbp); + + ip->i_facl = facl; + ext2_update(ip->i_vnode, 1); + + header = EXT2_HDR(cbp); + header->h_refcount = 1; + + *bpp = cbp; + + return (0); +} + +int +ext2_extattr_block_delete(struct inode *ip, int attrnamespace, const char *name) +{ + struct m_ext2fs *fs; + struct buf *bp; + struct ext2fs_extattr_header *header; + struct ext2fs_extattr_entry *entry; + int error; + + fs = ip->i_e2fs; + + error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl), + fs->e2fs_bsize, NOCRED, &bp); + if (error) { + brelse(bp); + return (error); + } + + /* Check attributes magic value */ + header = EXT2_HDR(bp); + if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) { + brelse(bp); + return (EINVAL); + } + + error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); + if (error) { + brelse(bp); + return (error); + } + + if (header->h_refcount > 1) { + error = ext2_extattr_block_clone(ip, &bp); + if (error) { + brelse(bp); + return (error); + } + } + + /* If I am last entry, clean me and free the block */ + entry = EXT2_FIRST_ENTRY(bp); + if (EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry))) { + if (strlen(name) == entry->e_name_len && + 0 == strncmp(entry->e_name, name, entry->e_name_len)) { + ip->i_blocks -= btodb(fs->e2fs_bsize); + ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize); + ip->i_facl = 0; + error = ext2_update(ip->i_vnode, 1); + + brelse(bp); + return (error); + } + } + + for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); + entry = EXT2_EXTATTR_NEXT(entry)) { + if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace) + continue; + + if (strlen(name) == entry->e_name_len && + 0 == strncmp(entry->e_name, name, entry->e_name_len)) { + ext2_extattr_delete_entry(bp->b_data, + EXT2_FIRST_ENTRY(bp), entry, + bp->b_data + bp->b_bufsize); + + return (bwrite(bp)); + } + } + + brelse(bp); + + return (ENOATTR); +} + +static struct ext2fs_extattr_entry * +allocate_entry(const char *name, int attrnamespace, uint16_t offs, + uint32_t size, uint32_t hash) +{ + size_t name_len; + struct ext2fs_extattr_entry *entry; + + name_len = strlen(name); + entry = malloc(sizeof(struct ext2fs_extattr_entry) + name_len, + M_TEMP, M_WAITOK); + + entry->e_name_len = name_len; + entry->e_name_index = ext2_extattr_index_to_linux(attrnamespace); + entry->e_value_offs = offs; + entry->e_value_block = 0; + entry->e_value_size = size; + entry->e_hash = hash; + memcpy(entry->e_name, name, name_len); + + return (entry); +} + +static void +free_entry(struct ext2fs_extattr_entry *entry) +{ + + free(entry, M_TEMP); +} + +static int +ext2_extattr_get_size(struct ext2fs_extattr_entry *first_entry, + struct ext2fs_extattr_entry *exist_entry, int header_size, + int name_len, int new_size) +{ + struct ext2fs_extattr_entry *entry; + int size; + + size = header_size; + size += sizeof(uint32_t); + + if (NULL == exist_entry) { + size += EXT2_EXTATTR_LEN(name_len); + size += EXT2_EXTATTR_SIZE(new_size); + } + + if (first_entry) + for (entry = first_entry; !EXT2_IS_LAST_ENTRY(entry); + entry = EXT2_EXTATTR_NEXT(entry)) { + if (entry != exist_entry) + size += EXT2_EXTATTR_LEN(entry->e_name_len) + + EXT2_EXTATTR_SIZE(entry->e_value_size); + else + size += EXT2_EXTATTR_LEN(entry->e_name_len) + + EXT2_EXTATTR_SIZE(new_size); + } + + return (size); +} + +static void +ext2_extattr_set_exist_entry(char *off, + struct ext2fs_extattr_entry *first_entry, + struct ext2fs_extattr_entry *entry, + char *end, struct uio *uio) +{ + uint16_t min_offs; + + min_offs = ext2_extattr_delete_value(off, first_entry, entry, end); + + entry->e_value_size = uio->uio_resid; + if (entry->e_value_size) + entry->e_value_offs = min_offs - + EXT2_EXTATTR_SIZE(uio->uio_resid); + else + entry->e_value_offs = 0; + + uiomove(off + entry->e_value_offs, entry->e_value_size, uio); +} + +static struct ext2fs_extattr_entry * +ext2_extattr_set_new_entry(char *off, struct ext2fs_extattr_entry *first_entry, + const char *name, int attrnamespace, char *end, struct uio *uio) +{ + int name_len; + char *pad; + uint16_t min_offs; + struct ext2fs_extattr_entry *entry; + struct ext2fs_extattr_entry *new_entry; + + /* Find pad's */ + min_offs = end - off; + entry = first_entry; + while (!EXT2_IS_LAST_ENTRY(entry)) { + if (min_offs > entry->e_value_offs && entry->e_value_offs > 0) + min_offs = entry->e_value_offs; + + entry = EXT2_EXTATTR_NEXT(entry); + } + + pad = (char*)entry + sizeof(uint32_t); + + /* Find entry insert position */ + name_len = strlen(name); + entry = first_entry; + while (!EXT2_IS_LAST_ENTRY(entry)) { + if (!(attrnamespace - entry->e_name_index) && + !(name_len - entry->e_name_len)) + if (memcmp(name, entry->e_name, name_len) <= 0) + break; + + entry = EXT2_EXTATTR_NEXT(entry); + } + + /* Create new entry and insert it */ + new_entry = allocate_entry(name, attrnamespace, 0, uio->uio_resid, 0); + memmove((char *)entry + EXT2_EXTATTR_LEN(new_entry->e_name_len), entry, + pad - (char*)entry); + + memcpy(entry, new_entry, EXT2_EXTATTR_LEN(new_entry->e_name_len)); + free_entry(new_entry); + + new_entry = entry; + if (new_entry->e_value_size > 0) + new_entry->e_value_offs = min_offs - + EXT2_EXTATTR_SIZE(new_entry->e_value_size); + + uiomove(off + new_entry->e_value_offs, new_entry->e_value_size, uio); + + return (new_entry); +} + +int +ext2_extattr_inode_set(struct inode *ip, int attrnamespace, + const char *name, struct uio *uio) +{ + struct m_ext2fs *fs; + struct buf *bp; + struct ext2fs_extattr_dinode_header *header; + struct ext2fs_extattr_entry *entry; + size_t size = 0, max_size; + int error; + + fs = ip->i_e2fs; + + if ((error = bread(ip->i_devvp, + fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), + (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) { + brelse(bp); + return (error); + } + + struct ext2fs_dinode *dinode = (struct ext2fs_dinode *) + ((char *)bp->b_data + + EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)); + + /* Check attributes magic value */ + header = (struct ext2fs_extattr_dinode_header *)((char *)dinode + + E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize); + + if (header->h_magic != EXTATTR_MAGIC) { + brelse(bp); + return (ENOSPC); + } + + error = ext2_extattr_check(EXT2_IFIRST(header), (char *)dinode + + EXT2_INODE_SIZE(fs)); + if (error) { + brelse(bp); + return (error); + } + + /* Find if entry exist */ + for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); + entry = EXT2_EXTATTR_NEXT(entry)) { + if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace) + continue; + + if (strlen(name) == entry->e_name_len && + 0 == strncmp(entry->e_name, name, entry->e_name_len)) + break; + } + + max_size = EXT2_INODE_SIZE(fs) - E2FS_REV0_INODE_SIZE - + dinode->e2di_extra_isize; + + if (!EXT2_IS_LAST_ENTRY(entry)) { + size = ext2_extattr_get_size(EXT2_IFIRST(header), entry, + sizeof(struct ext2fs_extattr_dinode_header), + entry->e_name_len, uio->uio_resid); + if (size > max_size) { + brelse(bp); + return (ENOSPC); + } + + ext2_extattr_set_exist_entry((char *)EXT2_IFIRST(header), + EXT2_IFIRST(header), entry, (char *)header + max_size, uio); + } else { + /* Ensure that the same entry does not exist in the block */ + if (ip->i_facl) { + error = ext2_extattr_block_get(ip, attrnamespace, name, + NULL, &size); + if (error != ENOATTR || size > 0) { + brelse(bp); + if (size > 0) + error = ENOSPC; + + return (error); + } + } + + size = ext2_extattr_get_size(EXT2_IFIRST(header), NULL, + sizeof(struct ext2fs_extattr_dinode_header), + entry->e_name_len, uio->uio_resid); + if (size > max_size) { + brelse(bp); + return (ENOSPC); + } + + ext2_extattr_set_new_entry((char *)EXT2_IFIRST(header), + EXT2_IFIRST(header), name, attrnamespace, + (char *)header + max_size, uio); + } + + return (bwrite(bp)); +} + +static void +ext2_extattr_hash_entry(struct ext2fs_extattr_header *header, + struct ext2fs_extattr_entry *entry) +{ + uint32_t hash = 0; + char *name = entry->e_name; + int n; + + for (n=0; n < entry->e_name_len; n++) { + hash = (hash << EXT2_EXTATTR_NAME_HASH_SHIFT) ^ + (hash >> (8*sizeof(hash) - EXT2_EXTATTR_NAME_HASH_SHIFT)) ^ + (*name++); + } + + if (entry->e_value_block == 0 && entry->e_value_size != 0) { + uint32_t *value = (uint32_t *)((char *)header + entry->e_value_offs); + for (n = (entry->e_value_size + + EXT2_EXTATTR_ROUND) >> EXT2_EXTATTR_PAD_BITS; n; n--) { + hash = (hash << EXT2_EXTATTR_VALUE_HASH_SHIFT) ^ + (hash >> (8*sizeof(hash) - EXT2_EXTATTR_VALUE_HASH_SHIFT)) ^ + (*value++); + } + } + + entry->e_hash = hash; +} + +static void +ext2_extattr_rehash(struct ext2fs_extattr_header *header, + struct ext2fs_extattr_entry *entry) +{ + struct ext2fs_extattr_entry *here; + uint32_t hash = 0; + + ext2_extattr_hash_entry(header, entry); + + here = EXT2_ENTRY(header+1); + while (!EXT2_IS_LAST_ENTRY(here)) { + if (!here->e_hash) { + /* Block is not shared if an entry's hash value == 0 */ + hash = 0; + break; + } + + hash = (hash << EXT2_EXTATTR_BLOCK_HASH_SHIFT) ^ + (hash >> (8*sizeof(hash) - EXT2_EXTATTR_BLOCK_HASH_SHIFT)) ^ + here->e_hash; + + here = EXT2_EXTATTR_NEXT(here); + } + + header->h_hash = hash; +} + +int +ext2_extattr_block_set(struct inode *ip, int attrnamespace, + const char *name, struct uio *uio) +{ + struct m_ext2fs *fs; + struct buf *bp; + struct ext2fs_extattr_header *header; + struct ext2fs_extattr_entry *entry; + size_t size; + int error; + + fs = ip->i_e2fs; + + if (ip->i_facl) { + error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl), + fs->e2fs_bsize, NOCRED, &bp); + if (error) { + brelse(bp); + return (error); + } + + /* Check attributes magic value */ + header = EXT2_HDR(bp); + if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) { + brelse(bp); + return (EINVAL); + } + + error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), + bp->b_data + bp->b_bufsize); + if (error) { + brelse(bp); + return (error); + } + + if (header->h_refcount > 1) { + error = ext2_extattr_block_clone(ip, &bp); + if (error) { + brelse(bp); + return (error); + } + + header = EXT2_HDR(bp); + } + + /* Find if entry exist */ + for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); + entry = EXT2_EXTATTR_NEXT(entry)) { + if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace) + continue; + + if (strlen(name) == entry->e_name_len && + 0 == strncmp(entry->e_name, name, entry->e_name_len)) + break; + } + + if (!EXT2_IS_LAST_ENTRY(entry)) { + size = ext2_extattr_get_size(EXT2_FIRST_ENTRY(bp), entry, + sizeof(struct ext2fs_extattr_header), + entry->e_name_len, uio->uio_resid); + if (size > bp->b_bufsize) { + brelse(bp); + return (ENOSPC); + } + + ext2_extattr_set_exist_entry(bp->b_data, EXT2_FIRST_ENTRY(bp), + entry, bp->b_data + bp->b_bufsize, uio); + } else { + size = ext2_extattr_get_size(EXT2_FIRST_ENTRY(bp), NULL, + sizeof(struct ext2fs_extattr_header), + strlen(name), uio->uio_resid); + if (size > bp->b_bufsize) { + brelse(bp); + return (ENOSPC); + } + + entry = ext2_extattr_set_new_entry(bp->b_data, EXT2_FIRST_ENTRY(bp), + name, attrnamespace, bp->b_data + bp->b_bufsize, uio); + + /* Clean the same entry in the inode */ + error = ext2_extattr_inode_delete(ip, attrnamespace, name); + if (error && error != ENOATTR) { + brelse(bp); + return (error); + } + } + + ext2_extattr_rehash(header, entry); + + return (bwrite(bp)); + } + + size = ext2_extattr_get_size(NULL, NULL, + sizeof(struct ext2fs_extattr_header), strlen(name), uio->uio_resid); + if (size > fs->e2fs_bsize) + return (ENOSPC); + + /* Allocate block, fill EA header and insert entry */ + ip->i_facl = ext2_allocfacl(ip); + if (0 == ip->i_facl) + return (ENOSPC); + + ip->i_blocks += btodb(fs->e2fs_bsize); + ext2_update(ip->i_vnode, 1); + + bp = getblk(ip->i_devvp, fsbtodb(fs, ip->i_facl), fs->e2fs_bsize, 0, 0, 0); + if (!bp) { + ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize); + ip->i_blocks -= btodb(fs->e2fs_bsize); + ip->i_facl = 0; + ext2_update(ip->i_vnode, 1); + return (EIO); + } + + header = EXT2_HDR(bp); + header->h_magic = EXTATTR_MAGIC; + header->h_refcount = 1; + header->h_blocks = 1; + header->h_hash = 0; + memset(header->h_reserved, 0, sizeof(header->h_reserved)); + memcpy(bp->b_data, header, sizeof(struct ext2fs_extattr_header)); + memset(EXT2_FIRST_ENTRY(bp), 0, sizeof(uint32_t)); + + entry = ext2_extattr_set_new_entry(bp->b_data, EXT2_FIRST_ENTRY(bp), + name, attrnamespace, bp->b_data + bp->b_bufsize, uio); + + /* Clean the same entry in the inode */ + error = ext2_extattr_inode_delete(ip, attrnamespace, name); + if (error && error != ENOATTR) { + brelse(bp); + return (error); + } + + ext2_extattr_rehash(header, entry); + + return (bwrite(bp)); +} + +int ext2_extattr_free(struct inode *ip) +{ + struct m_ext2fs *fs; + struct buf *bp; + struct ext2fs_extattr_header *header; + int error; + + fs = ip->i_e2fs; + + if (!ip->i_facl) + return (0); + + error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl), + fs->e2fs_bsize, NOCRED, &bp); + if (error) { + brelse(bp); + return (error); + } + + /* Check attributes magic value */ + header = EXT2_HDR(bp); + if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) { + brelse(bp); + return (EINVAL); + } + + error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); + if (error) { + brelse(bp); + return (error); + } + + if (header->h_refcount > 1) { + header->h_refcount--; + bwrite(bp); + } else { + ext2_blkfree(ip, ip->i_facl, ip->i_e2fs->e2fs_bsize); + brelse(bp); + } + + ip->i_blocks -= btodb(ip->i_e2fs->e2fs_bsize); + ip->i_facl = 0; + ext2_update(ip->i_vnode, 1); + return (0); } Index: head/sys/fs/ext2fs/ext2_extern.h =================================================================== --- head/sys/fs/ext2fs/ext2_extern.h +++ head/sys/fs/ext2fs/ext2_extern.h @@ -51,6 +51,7 @@ int ext2_add_entry(struct vnode *, struct ext2fs_direct_2 *); int ext2_alloc(struct inode *, daddr_t, e4fs_daddr_t, int, struct ucred *, e4fs_daddr_t *); +daddr_t ext2_allocfacl(struct inode *ip); int ext2_balloc(struct inode *, e2fs_lbn_t, int, struct ucred *, struct buf **, int); int ext2_blkatoff(struct vnode *, off_t, char **, struct buf **); Index: head/sys/fs/ext2fs/ext2_inode.c =================================================================== --- head/sys/fs/ext2fs/ext2_inode.c +++ head/sys/fs/ext2fs/ext2_inode.c @@ -53,6 +53,7 @@ #include #include #include +#include static int ext2_indirtrunc(struct inode *, daddr_t, daddr_t, daddr_t, int, e4fs_daddr_t *); @@ -488,6 +489,7 @@ if (ip->i_mode == 0) goto out; if (ip->i_nlink <= 0) { + ext2_extattr_free(ip); error = ext2_truncate(vp, (off_t)0, 0, NOCRED, td); ip->i_rdev = 0; mode = ip->i_mode; Index: head/sys/fs/ext2fs/ext2_inode_cnv.c =================================================================== --- head/sys/fs/ext2fs/ext2_inode_cnv.c +++ head/sys/fs/ext2fs/ext2_inode_cnv.c @@ -51,8 +51,8 @@ printf("Inode: %5ju", (uintmax_t)in->i_number); printf( /* "Inode: %5d" */ - " Type: %10s Mode: 0x%o Flags: 0x%x Version: %d\n", - "n/a", in->i_mode, in->i_flags, in->i_gen); + " Type: %10s Mode: 0x%o Flags: 0x%x Version: %d acl: 0x%llx\n", + "n/a", in->i_mode, in->i_flags, in->i_gen, in->i_facl); printf("User: %5u Group: %5u Size: %ju\n", in->i_uid, in->i_gid, (uintmax_t)in->i_size); printf("Links: %3d Blockcount: %ju\n", @@ -167,6 +167,8 @@ ei->e2di_flags |= (ip->i_flag & IN_E4EXTENTS) ? EXT4_EXTENTS : 0; ei->e2di_nblock = ip->i_blocks & 0xffffffff; ei->e2di_nblock_high = ip->i_blocks >> 32 & 0xffff; + ei->e2di_facl = ip->i_facl & 0xffffffff; + ei->e2di_facl_high = ip->i_facl >> 32 & 0xffff; ei->e2di_gen = ip->i_gen; ei->e2di_uid = ip->i_uid; ei->e2di_gid = ip->i_gid; Index: head/sys/fs/ext2fs/ext2_vnops.c =================================================================== --- head/sys/fs/ext2fs/ext2_vnops.c +++ head/sys/fs/ext2fs/ext2_vnops.c @@ -117,8 +117,10 @@ static vop_strategy_t ext2_strategy; static vop_symlink_t ext2_symlink; static vop_write_t ext2_write; +static vop_deleteextattr_t ext2_deleteextattr; static vop_getextattr_t ext2_getextattr; static vop_listextattr_t ext2_listextattr; +static vop_setextattr_t ext2_setextattr; static vop_vptofh_t ext2_vptofh; static vop_close_t ext2fifo_close; static vop_kqfilter_t ext2fifo_kqfilter; @@ -157,8 +159,10 @@ .vop_strategy = ext2_strategy, .vop_symlink = ext2_symlink, .vop_write = ext2_write, + .vop_deleteextattr = ext2_deleteextattr, .vop_getextattr = ext2_getextattr, .vop_listextattr = ext2_listextattr, + .vop_setextattr = ext2_setextattr, .vop_vptofh = ext2_vptofh, }; @@ -1486,6 +1490,42 @@ } /* + * Vnode operation to remove a named attribute. + */ +static int +ext2_deleteextattr(struct vop_deleteextattr_args *ap) +{ + struct inode *ip; + struct m_ext2fs *fs; + int error; + + ip = VTOI(ap->a_vp); + fs = ip->i_e2fs; + + if (!EXT2_HAS_COMPAT_FEATURE(ip->i_e2fs, EXT2F_COMPAT_EXT_ATTR)) + return (EOPNOTSUPP); + + if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) + return (EOPNOTSUPP); + + error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace, + ap->a_cred, ap->a_td, VWRITE); + if (error) + return (error); + + if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) { + error = ext2_extattr_inode_delete(ip, ap->a_attrnamespace, ap->a_name); + if (error != ENOATTR) + return (error); + } + + if (ip->i_facl) + error = ext2_extattr_block_delete(ip, ap->a_attrnamespace, ap->a_name); + + return (error); +} + +/* * Vnode operation to retrieve a named extended attribute. */ static int @@ -1515,7 +1555,7 @@ if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) { error = ext2_extattr_inode_get(ip, ap->a_attrnamespace, ap->a_name, ap->a_uio, ap->a_size); - if (error) + if (error != ENOATTR) return (error); } @@ -1556,11 +1596,11 @@ if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) { error = ext2_extattr_inode_list(ip, ap->a_attrnamespace, ap->a_uio, ap->a_size); - if(error) + if (error) return (error); } - if(ip->i_facl) + if (ip->i_facl) error = ext2_extattr_block_list(ip, ap->a_attrnamespace, ap->a_uio, ap->a_size); @@ -1568,6 +1608,47 @@ } /* + * Vnode operation to set a named attribute. + */ +static int +ext2_setextattr(struct vop_setextattr_args *ap) +{ + struct inode *ip; + struct m_ext2fs *fs; + int error; + + ip = VTOI(ap->a_vp); + fs = ip->i_e2fs; + + if (!EXT2_HAS_COMPAT_FEATURE(ip->i_e2fs, EXT2F_COMPAT_EXT_ATTR)) + return (EOPNOTSUPP); + + if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) + return (EOPNOTSUPP); + + error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace, + ap->a_cred, ap->a_td, VWRITE); + if (error) + return (error); + + error = ext2_extattr_valid_attrname(ap->a_attrnamespace, ap->a_name); + if (error) + return (error); + + if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) { + error = ext2_extattr_inode_set(ip, ap->a_attrnamespace, + ap->a_name, ap->a_uio); + if (error != ENOSPC) + return (error); + } + + error = ext2_extattr_block_set(ip, ap->a_attrnamespace, + ap->a_name, ap->a_uio); + + return (error); +} + +/* * Vnode pointer to File handle */ /* ARGSUSED */