Page MenuHomeFreeBSD
Differential D10807 Diff 28771 sys/fs/ext2fs/ext2_extattr.c

Changeset View

Standalone View

View Options

sys/fs/ext2fs/ext2_extattr.c

Context not available.
#include <fs/ext2fs/ext2_extattr.h> #include <fs/ext2fs/ext2_extattr.h>
#include <fs/ext2fs/ext2_extern.h> #include <fs/ext2fs/ext2_extern.h>
static int static int
ext2_extattr_index_to_bsd(int index) ext2_extattr_attrnamespace_to_bsd(int attrnamespace)
{ {
switch (index) {
case EXT4_XATTR_INDEX_SYSTEM:
return (EXTATTR_NAMESPACE_SYSTEM);
case EXT4_XATTR_INDEX_USER: switch (attrnamespace) {
return (EXTATTR_NAMESPACE_USER); case EXT4_XATTR_INDEX_SYSTEM:
return (EXTATTR_NAMESPACE_SYSTEM);
case EXT4_XATTR_INDEX_USER:
return (EXTATTR_NAMESPACE_USER);
case EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT:
return (POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE);
case EXT4_XATTR_INDEX_POSIX_ACL_ACCESS:
return (POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE);
} }
return (EXTATTR_NAMESPACE_EMPTY); return (EXTATTR_NAMESPACE_EMPTY);
} }
static const char *
ext2_extattr_name_to_bsd(int attrnamespace, const char *name, int* name_len)
{
if (attrnamespace == EXT4_XATTR_INDEX_SYSTEM)
return (name);
else if (attrnamespace == EXT4_XATTR_INDEX_USER)
return (name);
else if (attrnamespace == EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT) {
*name_len = strlen(POSIX1E_ACL_DEFAULT_EXTATTR_NAME);
return (POSIX1E_ACL_DEFAULT_EXTATTR_NAME);
} else if (attrnamespace == EXT4_XATTR_INDEX_POSIX_ACL_ACCESS) {
*name_len = strlen(POSIX1E_ACL_ACCESS_EXTATTR_NAME);
return (POSIX1E_ACL_ACCESS_EXTATTR_NAME);
}
/*
* Not all linux namespaces are mapped to bsd for now,
* return NULL, which will be converted to ENOTSUP on upper layer
pfgUnsubmitted
Not Done
Inline Actions

Minor style: Finish the sentence with a period, You can also use XXX to highlight this is missing in the implementation.

pfg: Minor style: Finish the sentence with a period, You can also use XXX to highlight this is…
*/
#ifdef DEBUG
printf("can not convert ext2fs name to bsd: namespace=%d\n", attrnamespace);
#endif /* DEBUG */
return (NULL);
}
static int static int
ext2_extattr_index_to_linux(int index) ext2_extattr_attrnamespace_to_linux(int attrnamespace, const char *name)
{ {
switch (index) {
case EXTATTR_NAMESPACE_SYSTEM:
return (EXT4_XATTR_INDEX_SYSTEM);
case EXTATTR_NAMESPACE_USER: if (attrnamespace == POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE &&
return (EXT4_XATTR_INDEX_USER); !strcmp(name, POSIX1E_ACL_DEFAULT_EXTATTR_NAME))
return (EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT);
if (attrnamespace == POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE &&
!strcmp(name, POSIX1E_ACL_ACCESS_EXTATTR_NAME))
return (EXT4_XATTR_INDEX_POSIX_ACL_ACCESS);
switch (attrnamespace) {
case EXTATTR_NAMESPACE_SYSTEM:
return (EXT4_XATTR_INDEX_SYSTEM);
case EXTATTR_NAMESPACE_USER:
return (EXT4_XATTR_INDEX_USER);
} }
/*
* In this case namespace conversion should be unique,
* so this point is unreachable.
*/
pfgUnsubmitted
Not Done
Inline Actions

s/fail/failure/ Not sure if a panic is appropriate here.

pfg: s/fail/failure/ Not sure if a panic is appropriate here.
return (-1); return (-1);
} }
static const char *
ext2_extattr_name_to_linux(int attrnamespace, const char *name)
{
if (attrnamespace == POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE ||
attrnamespace == POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE)
return ("");
else
return (name);
}
int int
ext2_extattr_valid_attrname(int attrnamespace, const char *attrname) ext2_extattr_valid_attrname(int attrnamespace, const char *attrname)
{ {
Context not available.
struct buf *bp; struct buf *bp;
struct ext2fs_extattr_dinode_header *header; struct ext2fs_extattr_dinode_header *header;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
const char *attr_name;
int name_len;
int error; int error;
fs = ip->i_e2fs; fs = ip->i_e2fs;
Context not available.
for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); 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) if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) !=
attrnamespace)
continue; continue;
name_len = entry->e_name_len;
attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (uio == NULL) if (uio == NULL)
*size += entry->e_name_len + 1; *size += name_len + 1;
else { else {
char *attr_name = malloc(entry->e_name_len + 1, M_TEMP, M_WAITOK); char *name = malloc(name_len + 1, M_TEMP, M_WAITOK);
attr_name[0] = entry->e_name_len; name[0] = name_len;
memcpy(&attr_name[1], entry->e_name, entry->e_name_len); memcpy(&name[1], attr_name, name_len);
error = uiomove(attr_name, entry->e_name_len + 1, uio); error = uiomove(name, name_len + 1, uio);
free(attr_name, M_TEMP); free(name, M_TEMP);
if (error) if (error)
break; break;
} }
Context not available.
struct buf *bp; struct buf *bp;
struct ext2fs_extattr_header *header; struct ext2fs_extattr_header *header;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
const char *attr_name;
int name_len;
int error; int error;
fs = ip->i_e2fs; fs = ip->i_e2fs;
Context not available.
for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); for (entry = EXT2_FIRST_ENTRY(bp); !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) if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) !=
attrnamespace)
continue; continue;
name_len = entry->e_name_len;
attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (uio == NULL) if (uio == NULL)
*size += entry->e_name_len + 1; *size += name_len + 1;
else { else {
char *attr_name = malloc(entry->e_name_len + 1, M_TEMP, M_WAITOK); char *name = malloc(name_len + 1, M_TEMP, M_WAITOK);
attr_name[0] = entry->e_name_len; name[0] = name_len;
memcpy(&attr_name[1], entry->e_name, entry->e_name_len); memcpy(&name[1], attr_name, name_len);
error = uiomove(attr_name, entry->e_name_len + 1, uio); error = uiomove(name, name_len + 1, uio);
free(attr_name, M_TEMP); free(name, M_TEMP);
if (error) if (error)
break; break;
} }
Context not available.
struct buf *bp; struct buf *bp;
struct ext2fs_extattr_dinode_header *header; struct ext2fs_extattr_dinode_header *header;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
const char *attr_name;
int name_len;
int error; int error;
fs = ip->i_e2fs; fs = ip->i_e2fs;
Context not available.
for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); 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) if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) !=
attrnamespace)
continue; continue;
if (strlen(name) == entry->e_name_len && name_len = entry->e_name_len;
0 == strncmp(entry->e_name, name, entry->e_name_len)) { attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len)) {
pfgUnsubmitted
Not Done
Inline Actions

The 0 == looks better at the end of the comparison, but perhpas just IMO.

pfg: The `0 ==` looks better at the end of the comparison, but perhpas just IMO.
if (uio == NULL) if (uio == NULL)
*size += entry->e_value_size; *size += entry->e_value_size;
else { else {
Context not available.
struct buf *bp; struct buf *bp;
struct ext2fs_extattr_header *header; struct ext2fs_extattr_header *header;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
const char *attr_name;
int name_len;
int error; int error;
fs = ip->i_e2fs; fs = ip->i_e2fs;
Context not available.
for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); for (entry = EXT2_FIRST_ENTRY(bp); !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) if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) !=
attrnamespace)
continue; continue;
if (strlen(name) == entry->e_name_len && name_len = entry->e_name_len;
0 == strncmp(entry->e_name, name, entry->e_name_len)) { attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len)) {
if (uio == NULL) if (uio == NULL)
*size += entry->e_value_size; *size += entry->e_value_size;
else { else {
Context not available.
struct buf *bp; struct buf *bp;
struct ext2fs_extattr_dinode_header *header; struct ext2fs_extattr_dinode_header *header;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
const char *attr_name;
int name_len;
int error; int error;
fs = ip->i_e2fs; fs = ip->i_e2fs;
Context not available.
/* If I am last entry, just make magic zero */ /* If I am last entry, just make magic zero */
entry = EXT2_IFIRST(header); entry = EXT2_IFIRST(header);
if (EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry))) { if ((EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry))) &&
if (strlen(name) == entry->e_name_len && (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) ==
0 == strncmp(entry->e_name, name, entry->e_name_len)) { attrnamespace)) {
name_len = entry->e_name_len;
attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len)) {
memset(header, 0, sizeof(struct ext2fs_extattr_dinode_header)); memset(header, 0, sizeof(struct ext2fs_extattr_dinode_header));
return (bwrite(bp)); return (bwrite(bp));
Context not available.
for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); 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) if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) !=
attrnamespace)
continue; continue;
if (strlen(name) == entry->e_name_len && name_len = entry->e_name_len;
0 == strncmp(entry->e_name, name, entry->e_name_len)) { attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len)) {
ext2_extattr_delete_entry((char *)EXT2_IFIRST(header), ext2_extattr_delete_entry((char *)EXT2_IFIRST(header),
EXT2_IFIRST(header), entry, EXT2_IFIRST(header), entry,
(char *)dinode + EXT2_INODE_SIZE(fs)); (char *)dinode + EXT2_INODE_SIZE(fs));
Context not available.
struct buf *bp; struct buf *bp;
struct ext2fs_extattr_header *header; struct ext2fs_extattr_header *header;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
const char *attr_name;
int name_len;
int error; int error;
fs = ip->i_e2fs; fs = ip->i_e2fs;
Context not available.
/* If I am last entry, clean me and free the block */ /* If I am last entry, clean me and free the block */
entry = EXT2_FIRST_ENTRY(bp); entry = EXT2_FIRST_ENTRY(bp);
if (EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry))) { if (EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry)) &&
if (strlen(name) == entry->e_name_len && (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) ==
0 == strncmp(entry->e_name, name, entry->e_name_len)) { attrnamespace)) {
name_len = entry->e_name_len;
attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len)) {
ip->i_blocks -= btodb(fs->e2fs_bsize); ip->i_blocks -= btodb(fs->e2fs_bsize);
ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize); ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize);
ip->i_facl = 0; ip->i_facl = 0;
Context not available.
for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); for (entry = EXT2_FIRST_ENTRY(bp); !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) if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) !=
attrnamespace)
continue; continue;
if (strlen(name) == entry->e_name_len && name_len = entry->e_name_len;
0 == strncmp(entry->e_name, name, entry->e_name_len)) { attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len)) {
ext2_extattr_delete_entry(bp->b_data, ext2_extattr_delete_entry(bp->b_data,
EXT2_FIRST_ENTRY(bp), entry, EXT2_FIRST_ENTRY(bp), entry,
bp->b_data + bp->b_bufsize); bp->b_data + bp->b_bufsize);
Context not available.
allocate_entry(const char *name, int attrnamespace, uint16_t offs, allocate_entry(const char *name, int attrnamespace, uint16_t offs,
uint32_t size, uint32_t hash) uint32_t size, uint32_t hash)
{ {
size_t name_len; const char *attr_name;
int name_len;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
name_len = strlen(name); attr_name = ext2_extattr_name_to_linux(attrnamespace, name);
name_len = strlen(attr_name);
entry = malloc(sizeof(struct ext2fs_extattr_entry) + name_len, entry = malloc(sizeof(struct ext2fs_extattr_entry) + name_len,
M_TEMP, M_WAITOK); M_TEMP, M_WAITOK);
entry->e_name_len = name_len; entry->e_name_len = name_len;
entry->e_name_index = ext2_extattr_index_to_linux(attrnamespace); entry->e_name_index = ext2_extattr_attrnamespace_to_linux(attrnamespace, name);
entry->e_value_offs = offs; entry->e_value_offs = offs;
entry->e_value_block = 0; entry->e_value_block = 0;
entry->e_value_size = size; entry->e_value_size = size;
Context not available.
struct buf *bp; struct buf *bp;
struct ext2fs_extattr_dinode_header *header; struct ext2fs_extattr_dinode_header *header;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
const char *attr_name;
int name_len;
size_t size = 0, max_size; size_t size = 0, max_size;
int error; int error;
Context not available.
/* Find if entry exist */ /* Find if entry exist */
for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); 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) if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) !=
attrnamespace)
continue; continue;
if (strlen(name) == entry->e_name_len && name_len = entry->e_name_len;
0 == strncmp(entry->e_name, name, entry->e_name_len)) attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len))
break; break;
} }
Context not available.
struct buf *bp; struct buf *bp;
struct ext2fs_extattr_header *header; struct ext2fs_extattr_header *header;
struct ext2fs_extattr_entry *entry; struct ext2fs_extattr_entry *entry;
const char *attr_name;
int name_len;
size_t size; size_t size;
int error; int error;
Context not available.
/* Find if entry exist */ /* Find if entry exist */
for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); for (entry = EXT2_FIRST_ENTRY(bp); !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) if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) !=
attrnamespace)
continue; continue;
if (strlen(name) == entry->e_name_len && name_len = entry->e_name_len;
0 == strncmp(entry->e_name, name, entry->e_name_len)) attr_name = ext2_extattr_name_to_bsd(entry->e_name_index,
entry->e_name, &name_len);
if (!attr_name) {
brelse(bp);
return (ENOTSUP);
}
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len))
break; break;
} }
Context not available.
} }
size = ext2_extattr_get_size(NULL, NULL, size = ext2_extattr_get_size(NULL, NULL,
sizeof(struct ext2fs_extattr_header), strlen(name), uio->uio_resid); sizeof(struct ext2fs_extattr_header),
strlen(ext2_extattr_name_to_linux(attrnamespace, name)), uio->uio_resid);
if (size > fs->e2fs_bsize) if (size > fs->e2fs_bsize)
return (ENOSPC); return (ENOSPC);
Context not available.