fs.acl.rework.prep.v6.1
-----BEGIN PGP SIGNATURE-----
iHUEABYKAB0WIQRAhzRXHqcMeLMyaSiRxhvAZXjcogUCYzqi8gAKCRCRxhvAZXjc
orKNAQCGKPJ3Kc3LVVnh8qdjm9npP+j9UQAB7jDZi9q7RijIIAD/VYjj+z5XLg4V
k96ibCyir1+4EOF8ihY0WQi40MSWYws=
=S/Wf
-----END PGP SIGNATURE-----
Merge tag 'fs.acl.rework.prep.v6.1' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/idmapping
Pull vfs acl updates from Christian Brauner:
"These are general fixes and preparatory changes related to the ongoing
posix acl rework. The actual rework where we build a type safe posix
acl api wasn't ready for this merge window but we're hopeful for the
next merge window.
General fixes:
- Some filesystems like 9p and cifs have to implement custom posix
acl handlers because they require access to the dentry in order to
set and get posix acls while the set and get inode operations
currently don't. But the ntfs3 filesystem has no such requirement
and thus implemented custom posix acl xattr handlers when it really
didn't have to. So this pr contains patch that just implements set
and get inode operations for ntfs3 and switches it to rely on the
generic posix acl xattr handlers. (We would've appreciated reviews
from the ntfs3 maintainers but we didn't get any. But hey, if we
really broke it we'll fix it. But fstests for ntfs3 said it's
fine.)
- The posix_acl_fix_xattr_common() helper has been adapted so it can
be used by a few more callers and avoiding open-coding the same
checks over and over.
Other than the two general fixes this series introduces a new helper
vfs_set_acl_prepare(). The reason for this helper is so that we can
mitigate one of the source that change {g,u}id values directly in the
uapi struct. With the vfs_set_acl_prepare() helper we can move the
idmapped mount fixup into the generic posix acl set handler.
The advantage of this is that it allows us to remove the
posix_acl_setxattr_idmapped_mnt() helper which so far we had to call
in vfs_setxattr() to account for idmapped mounts. While semantically
correct the problem with this approach was that we had to keep the
value parameter of the generic vfs_setxattr() call as non-const. This
is rectified in this series.
Ultimately, we will get rid of all the extreme kludges and type
unsafety once we have merged the posix api - hopefully during the next
merge window - built solely around get and set inode operations. Which
incidentally will also improve handling of posix acls in security and
especially in integrity modesl. While this will come with temporarily
having two inode operation for posix acls that is nothing compared to
the problems we have right now and so well worth it. We'll end up with
something that we can actually reason about instead of needing to
write novels to explain what's going on"
* tag 'fs.acl.rework.prep.v6.1' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/idmapping:
xattr: always us is_posix_acl_xattr() helper
acl: fix the comments of posix_acl_xattr_set
xattr: constify value argument in vfs_setxattr()
ovl: use vfs_set_acl_prepare()
acl: move idmapping handling into posix_acl_xattr_set()
acl: add vfs_set_acl_prepare()
acl: return EOPNOTSUPP in posix_acl_fix_xattr_common()
ntfs3: rework xattr handlers and switch to POSIX ACL VFS helpers
This commit is contained in:
Linus Torvalds
Коммит
223b845253
|
|
@ -1927,8 +1927,6 @@ const struct inode_operations ntfs_link_inode_operations = {
|
|||
.setattr = ntfs3_setattr,
|
||||
.listxattr = ntfs_listxattr,
|
||||
.permission = ntfs_permission,
|
||||
.get_acl = ntfs_get_acl,
|
||||
.set_acl = ntfs_set_acl,
|
||||
};
|
||||
|
||||
const struct address_space_operations ntfs_aops = {
|
||||
|
|
|
|||
102
fs/ntfs3/xattr.c
102
fs/ntfs3/xattr.c
|
|
@ -625,67 +625,6 @@ int ntfs_set_acl(struct user_namespace *mnt_userns, struct inode *inode,
|
|||
return ntfs_set_acl_ex(mnt_userns, inode, acl, type, false);
|
||||
}
|
||||
|
||||
static int ntfs_xattr_get_acl(struct user_namespace *mnt_userns,
|
||||
struct inode *inode, int type, void *buffer,
|
||||
size_t size)
|
||||
{
|
||||
struct posix_acl *acl;
|
||||
int err;
|
||||
|
||||
if (!(inode->i_sb->s_flags & SB_POSIXACL)) {
|
||||
ntfs_inode_warn(inode, "add mount option \"acl\" to use acl");
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
acl = ntfs_get_acl(inode, type, false);
|
||||
if (IS_ERR(acl))
|
||||
return PTR_ERR(acl);
|
||||
|
||||
if (!acl)
|
||||
return -ENODATA;
|
||||
|
||||
err = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
|
||||
posix_acl_release(acl);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int ntfs_xattr_set_acl(struct user_namespace *mnt_userns,
|
||||
struct inode *inode, int type, const void *value,
|
||||
size_t size)
|
||||
{
|
||||
struct posix_acl *acl;
|
||||
int err;
|
||||
|
||||
if (!(inode->i_sb->s_flags & SB_POSIXACL)) {
|
||||
ntfs_inode_warn(inode, "add mount option \"acl\" to use acl");
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
if (!inode_owner_or_capable(mnt_userns, inode))
|
||||
return -EPERM;
|
||||
|
||||
if (!value) {
|
||||
acl = NULL;
|
||||
} else {
|
||||
acl = posix_acl_from_xattr(&init_user_ns, value, size);
|
||||
if (IS_ERR(acl))
|
||||
return PTR_ERR(acl);
|
||||
|
||||
if (acl) {
|
||||
err = posix_acl_valid(&init_user_ns, acl);
|
||||
if (err)
|
||||
goto release_and_out;
|
||||
}
|
||||
}
|
||||
|
||||
err = ntfs_set_acl(mnt_userns, inode, acl, type);
|
||||
|
||||
release_and_out:
|
||||
posix_acl_release(acl);
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* ntfs_init_acl - Initialize the ACLs of a new inode.
|
||||
*
|
||||
|
|
@ -852,23 +791,6 @@ static int ntfs_getxattr(const struct xattr_handler *handler, struct dentry *de,
|
|||
goto out;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_NTFS3_FS_POSIX_ACL
|
||||
if ((name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1 &&
|
||||
!memcmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
|
||||
sizeof(XATTR_NAME_POSIX_ACL_ACCESS))) ||
|
||||
(name_len == sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1 &&
|
||||
!memcmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
|
||||
sizeof(XATTR_NAME_POSIX_ACL_DEFAULT)))) {
|
||||
/* TODO: init_user_ns? */
|
||||
err = ntfs_xattr_get_acl(
|
||||
&init_user_ns, inode,
|
||||
name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1
|
||||
? ACL_TYPE_ACCESS
|
||||
: ACL_TYPE_DEFAULT,
|
||||
buffer, size);
|
||||
goto out;
|
||||
}
|
||||
#endif
|
||||
/* Deal with NTFS extended attribute. */
|
||||
err = ntfs_get_ea(inode, name, name_len, buffer, size, NULL);
|
||||
|
||||
|
|
@ -981,22 +903,6 @@ set_new_fa:
|
|||
goto out;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_NTFS3_FS_POSIX_ACL
|
||||
if ((name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1 &&
|
||||
!memcmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
|
||||
sizeof(XATTR_NAME_POSIX_ACL_ACCESS))) ||
|
||||
(name_len == sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1 &&
|
||||
!memcmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
|
||||
sizeof(XATTR_NAME_POSIX_ACL_DEFAULT)))) {
|
||||
err = ntfs_xattr_set_acl(
|
||||
mnt_userns, inode,
|
||||
name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1
|
||||
? ACL_TYPE_ACCESS
|
||||
: ACL_TYPE_DEFAULT,
|
||||
value, size);
|
||||
goto out;
|
||||
}
|
||||
#endif
|
||||
/* Deal with NTFS extended attribute. */
|
||||
err = ntfs_set_ea(inode, name, name_len, value, size, flags, 0);
|
||||
|
||||
|
|
@ -1086,7 +992,7 @@ static bool ntfs_xattr_user_list(struct dentry *dentry)
|
|||
}
|
||||
|
||||
// clang-format off
|
||||
static const struct xattr_handler ntfs_xattr_handler = {
|
||||
static const struct xattr_handler ntfs_other_xattr_handler = {
|
||||
.prefix = "",
|
||||
.get = ntfs_getxattr,
|
||||
.set = ntfs_setxattr,
|
||||
|
|
@ -1094,7 +1000,11 @@ static const struct xattr_handler ntfs_xattr_handler = {
|
|||
};
|
||||
|
||||
const struct xattr_handler *ntfs_xattr_handlers[] = {
|
||||
&ntfs_xattr_handler,
|
||||
#ifdef CONFIG_NTFS3_FS_POSIX_ACL
|
||||
&posix_acl_access_xattr_handler,
|
||||
&posix_acl_default_xattr_handler,
|
||||
#endif
|
||||
&ntfs_other_xattr_handler,
|
||||
NULL,
|
||||
};
|
||||
// clang-format on
|
||||
|
|
|
|||
|
|
@ -250,7 +250,7 @@ static inline int ovl_do_setxattr(struct ovl_fs *ofs, struct dentry *dentry,
|
|||
size_t size, int flags)
|
||||
{
|
||||
int err = vfs_setxattr(ovl_upper_mnt_userns(ofs), dentry, name,
|
||||
(void *)value, size, flags);
|
||||
value, size, flags);
|
||||
|
||||
pr_debug("setxattr(%pd2, \"%s\", \"%*pE\", %zu, %d) = %i\n",
|
||||
dentry, name, min((int)size, 48), value, size, flags, err);
|
||||
|
|
|
|||
|
|
@ -1022,7 +1022,20 @@ ovl_posix_acl_xattr_set(const struct xattr_handler *handler,
|
|||
|
||||
/* Check that everything is OK before copy-up */
|
||||
if (value) {
|
||||
acl = posix_acl_from_xattr(&init_user_ns, value, size);
|
||||
/* The above comment can be understood in two ways:
|
||||
*
|
||||
* 1. We just want to check whether the basic POSIX ACL format
|
||||
* is ok. For example, if the header is correct and the size
|
||||
* is sane.
|
||||
* 2. We want to know whether the ACL_{GROUP,USER} entries can
|
||||
* be mapped according to the underlying filesystem.
|
||||
*
|
||||
* Currently, we only check 1. If we wanted to check 2. we
|
||||
* would need to pass the mnt_userns and the fs_userns of the
|
||||
* underlying filesystem. But frankly, I think checking 1. is
|
||||
* enough to start the copy-up.
|
||||
*/
|
||||
acl = vfs_set_acl_prepare(&init_user_ns, &init_user_ns, value, size);
|
||||
if (IS_ERR(acl))
|
||||
return PTR_ERR(acl);
|
||||
}
|
||||
|
|
|
|||
288
fs/posix_acl.c
288
fs/posix_acl.c
|
|
@ -710,9 +710,9 @@ EXPORT_SYMBOL(posix_acl_update_mode);
|
|||
/*
|
||||
* Fix up the uids and gids in posix acl extended attributes in place.
|
||||
*/
|
||||
static int posix_acl_fix_xattr_common(void *value, size_t size)
|
||||
static int posix_acl_fix_xattr_common(const void *value, size_t size)
|
||||
{
|
||||
struct posix_acl_xattr_header *header = value;
|
||||
const struct posix_acl_xattr_header *header = value;
|
||||
int count;
|
||||
|
||||
if (!header)
|
||||
|
|
@ -720,13 +720,13 @@ static int posix_acl_fix_xattr_common(void *value, size_t size)
|
|||
if (size < sizeof(struct posix_acl_xattr_header))
|
||||
return -EINVAL;
|
||||
if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
|
||||
return -EINVAL;
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
count = posix_acl_xattr_count(size);
|
||||
if (count < 0)
|
||||
return -EINVAL;
|
||||
if (count == 0)
|
||||
return -EINVAL;
|
||||
return 0;
|
||||
|
||||
return count;
|
||||
}
|
||||
|
|
@ -748,7 +748,7 @@ void posix_acl_getxattr_idmapped_mnt(struct user_namespace *mnt_userns,
|
|||
return;
|
||||
|
||||
count = posix_acl_fix_xattr_common(value, size);
|
||||
if (count < 0)
|
||||
if (count <= 0)
|
||||
return;
|
||||
|
||||
for (end = entry + count; entry != end; entry++) {
|
||||
|
|
@ -771,46 +771,6 @@ void posix_acl_getxattr_idmapped_mnt(struct user_namespace *mnt_userns,
|
|||
}
|
||||
}
|
||||
|
||||
void posix_acl_setxattr_idmapped_mnt(struct user_namespace *mnt_userns,
|
||||
const struct inode *inode,
|
||||
void *value, size_t size)
|
||||
{
|
||||
struct posix_acl_xattr_header *header = value;
|
||||
struct posix_acl_xattr_entry *entry = (void *)(header + 1), *end;
|
||||
struct user_namespace *fs_userns = i_user_ns(inode);
|
||||
int count;
|
||||
vfsuid_t vfsuid;
|
||||
vfsgid_t vfsgid;
|
||||
kuid_t uid;
|
||||
kgid_t gid;
|
||||
|
||||
if (no_idmapping(mnt_userns, i_user_ns(inode)))
|
||||
return;
|
||||
|
||||
count = posix_acl_fix_xattr_common(value, size);
|
||||
if (count < 0)
|
||||
return;
|
||||
|
||||
for (end = entry + count; entry != end; entry++) {
|
||||
switch (le16_to_cpu(entry->e_tag)) {
|
||||
case ACL_USER:
|
||||
uid = make_kuid(&init_user_ns, le32_to_cpu(entry->e_id));
|
||||
vfsuid = VFSUIDT_INIT(uid);
|
||||
uid = from_vfsuid(mnt_userns, fs_userns, vfsuid);
|
||||
entry->e_id = cpu_to_le32(from_kuid(&init_user_ns, uid));
|
||||
break;
|
||||
case ACL_GROUP:
|
||||
gid = make_kgid(&init_user_ns, le32_to_cpu(entry->e_id));
|
||||
vfsgid = VFSGIDT_INIT(gid);
|
||||
gid = from_vfsgid(mnt_userns, fs_userns, vfsgid);
|
||||
entry->e_id = cpu_to_le32(from_kgid(&init_user_ns, gid));
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void posix_acl_fix_xattr_userns(
|
||||
struct user_namespace *to, struct user_namespace *from,
|
||||
void *value, size_t size)
|
||||
|
|
@ -822,7 +782,7 @@ static void posix_acl_fix_xattr_userns(
|
|||
kgid_t gid;
|
||||
|
||||
count = posix_acl_fix_xattr_common(value, size);
|
||||
if (count < 0)
|
||||
if (count <= 0)
|
||||
return;
|
||||
|
||||
for (end = entry + count; entry != end; entry++) {
|
||||
|
|
@ -857,12 +817,32 @@ void posix_acl_fix_xattr_to_user(void *value, size_t size)
|
|||
posix_acl_fix_xattr_userns(user_ns, &init_user_ns, value, size);
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert from extended attribute to in-memory representation.
|
||||
/**
|
||||
* make_posix_acl - convert POSIX ACLs from uapi to VFS format using the
|
||||
* provided callbacks to map ACL_{GROUP,USER} entries into the
|
||||
* appropriate format
|
||||
* @mnt_userns: the mount's idmapping
|
||||
* @fs_userns: the filesystem's idmapping
|
||||
* @value: the uapi representation of POSIX ACLs
|
||||
* @size: the size of @void
|
||||
* @uid_cb: callback to use for mapping the uid stored in ACL_USER entries
|
||||
* @gid_cb: callback to use for mapping the gid stored in ACL_GROUP entries
|
||||
*
|
||||
* The make_posix_acl() helper is an abstraction to translate from uapi format
|
||||
* into the VFS format allowing the caller to specific callbacks to map
|
||||
* ACL_{GROUP,USER} entries into the expected format. This is used in
|
||||
* posix_acl_from_xattr() and vfs_set_acl_prepare() and avoids pointless code
|
||||
* duplication.
|
||||
*
|
||||
* Return: Allocated struct posix_acl on success, NULL for a valid header but
|
||||
* without actual POSIX ACL entries, or ERR_PTR() encoded error code.
|
||||
*/
|
||||
struct posix_acl *
|
||||
posix_acl_from_xattr(struct user_namespace *user_ns,
|
||||
const void *value, size_t size)
|
||||
static struct posix_acl *make_posix_acl(struct user_namespace *mnt_userns,
|
||||
struct user_namespace *fs_userns, const void *value, size_t size,
|
||||
kuid_t (*uid_cb)(struct user_namespace *, struct user_namespace *,
|
||||
const struct posix_acl_xattr_entry *),
|
||||
kgid_t (*gid_cb)(struct user_namespace *, struct user_namespace *,
|
||||
const struct posix_acl_xattr_entry *))
|
||||
{
|
||||
const struct posix_acl_xattr_header *header = value;
|
||||
const struct posix_acl_xattr_entry *entry = (const void *)(header + 1), *end;
|
||||
|
|
@ -870,16 +850,9 @@ posix_acl_from_xattr(struct user_namespace *user_ns,
|
|||
struct posix_acl *acl;
|
||||
struct posix_acl_entry *acl_e;
|
||||
|
||||
if (!value)
|
||||
return NULL;
|
||||
if (size < sizeof(struct posix_acl_xattr_header))
|
||||
return ERR_PTR(-EINVAL);
|
||||
if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
|
||||
return ERR_PTR(-EOPNOTSUPP);
|
||||
|
||||
count = posix_acl_xattr_count(size);
|
||||
count = posix_acl_fix_xattr_common(value, size);
|
||||
if (count < 0)
|
||||
return ERR_PTR(-EINVAL);
|
||||
return ERR_PTR(count);
|
||||
if (count == 0)
|
||||
return NULL;
|
||||
|
||||
|
|
@ -900,16 +873,12 @@ posix_acl_from_xattr(struct user_namespace *user_ns,
|
|||
break;
|
||||
|
||||
case ACL_USER:
|
||||
acl_e->e_uid =
|
||||
make_kuid(user_ns,
|
||||
le32_to_cpu(entry->e_id));
|
||||
acl_e->e_uid = uid_cb(mnt_userns, fs_userns, entry);
|
||||
if (!uid_valid(acl_e->e_uid))
|
||||
goto fail;
|
||||
break;
|
||||
case ACL_GROUP:
|
||||
acl_e->e_gid =
|
||||
make_kgid(user_ns,
|
||||
le32_to_cpu(entry->e_id));
|
||||
acl_e->e_gid = gid_cb(mnt_userns, fs_userns, entry);
|
||||
if (!gid_valid(acl_e->e_gid))
|
||||
goto fail;
|
||||
break;
|
||||
|
|
@ -924,6 +893,181 @@ fail:
|
|||
posix_acl_release(acl);
|
||||
return ERR_PTR(-EINVAL);
|
||||
}
|
||||
|
||||
/**
|
||||
* vfs_set_acl_prepare_kuid - map ACL_USER uid according to mount- and
|
||||
* filesystem idmapping
|
||||
* @mnt_userns: the mount's idmapping
|
||||
* @fs_userns: the filesystem's idmapping
|
||||
* @e: a ACL_USER entry in POSIX ACL uapi format
|
||||
*
|
||||
* The uid stored as ACL_USER entry in @e is a kuid_t stored as a raw {g,u}id
|
||||
* value. The vfs_set_acl_prepare_kuid() will recover the kuid_t through
|
||||
* KUIDT_INIT() and then map it according to the idmapped mount. The resulting
|
||||
* kuid_t is the value which the filesystem can map up into a raw backing store
|
||||
* id in the filesystem's idmapping.
|
||||
*
|
||||
* This is used in vfs_set_acl_prepare() to generate the proper VFS
|
||||
* representation of POSIX ACLs with ACL_USER entries during setxattr().
|
||||
*
|
||||
* Return: A kuid in @fs_userns for the uid stored in @e.
|
||||
*/
|
||||
static inline kuid_t
|
||||
vfs_set_acl_prepare_kuid(struct user_namespace *mnt_userns,
|
||||
struct user_namespace *fs_userns,
|
||||
const struct posix_acl_xattr_entry *e)
|
||||
{
|
||||
kuid_t kuid = KUIDT_INIT(le32_to_cpu(e->e_id));
|
||||
return from_vfsuid(mnt_userns, fs_userns, VFSUIDT_INIT(kuid));
|
||||
}
|
||||
|
||||
/**
|
||||
* vfs_set_acl_prepare_kgid - map ACL_GROUP gid according to mount- and
|
||||
* filesystem idmapping
|
||||
* @mnt_userns: the mount's idmapping
|
||||
* @fs_userns: the filesystem's idmapping
|
||||
* @e: a ACL_GROUP entry in POSIX ACL uapi format
|
||||
*
|
||||
* The gid stored as ACL_GROUP entry in @e is a kgid_t stored as a raw {g,u}id
|
||||
* value. The vfs_set_acl_prepare_kgid() will recover the kgid_t through
|
||||
* KGIDT_INIT() and then map it according to the idmapped mount. The resulting
|
||||
* kgid_t is the value which the filesystem can map up into a raw backing store
|
||||
* id in the filesystem's idmapping.
|
||||
*
|
||||
* This is used in vfs_set_acl_prepare() to generate the proper VFS
|
||||
* representation of POSIX ACLs with ACL_GROUP entries during setxattr().
|
||||
*
|
||||
* Return: A kgid in @fs_userns for the gid stored in @e.
|
||||
*/
|
||||
static inline kgid_t
|
||||
vfs_set_acl_prepare_kgid(struct user_namespace *mnt_userns,
|
||||
struct user_namespace *fs_userns,
|
||||
const struct posix_acl_xattr_entry *e)
|
||||
{
|
||||
kgid_t kgid = KGIDT_INIT(le32_to_cpu(e->e_id));
|
||||
return from_vfsgid(mnt_userns, fs_userns, VFSGIDT_INIT(kgid));
|
||||
}
|
||||
|
||||
/**
|
||||
* vfs_set_acl_prepare - convert POSIX ACLs from uapi to VFS format taking
|
||||
* mount and filesystem idmappings into account
|
||||
* @mnt_userns: the mount's idmapping
|
||||
* @fs_userns: the filesystem's idmapping
|
||||
* @value: the uapi representation of POSIX ACLs
|
||||
* @size: the size of @void
|
||||
*
|
||||
* When setting POSIX ACLs with ACL_{GROUP,USER} entries they need to be
|
||||
* mapped according to the relevant mount- and filesystem idmapping. It is
|
||||
* important that the ACL_{GROUP,USER} entries in struct posix_acl will be
|
||||
* mapped into k{g,u}id_t that are supposed to be mapped up in the filesystem
|
||||
* idmapping. This is crucial since the resulting struct posix_acl might be
|
||||
* cached filesystem wide. The vfs_set_acl_prepare() function will take care to
|
||||
* perform all necessary idmappings.
|
||||
*
|
||||
* Note, that since basically forever the {g,u}id values encoded as
|
||||
* ACL_{GROUP,USER} entries in the uapi POSIX ACLs passed via @value contain
|
||||
* values that have been mapped according to the caller's idmapping. In other
|
||||
* words, POSIX ACLs passed in uapi format as @value during setxattr() contain
|
||||
* {g,u}id values in their ACL_{GROUP,USER} entries that should actually have
|
||||
* been stored as k{g,u}id_t.
|
||||
*
|
||||
* This means, vfs_set_acl_prepare() needs to first recover the k{g,u}id_t by
|
||||
* calling K{G,U}IDT_INIT(). Afterwards they can be interpreted as vfs{g,u}id_t
|
||||
* through from_vfs{g,u}id() to account for any idmapped mounts. The
|
||||
* vfs_set_acl_prepare_k{g,u}id() helpers will take care to generate the
|
||||
* correct k{g,u}id_t.
|
||||
*
|
||||
* The filesystem will then receive the POSIX ACLs ready to be cached
|
||||
* filesystem wide and ready to be written to the backing store taking the
|
||||
* filesystem's idmapping into account.
|
||||
*
|
||||
* Return: Allocated struct posix_acl on success, NULL for a valid header but
|
||||
* without actual POSIX ACL entries, or ERR_PTR() encoded error code.
|
||||
*/
|
||||
struct posix_acl *vfs_set_acl_prepare(struct user_namespace *mnt_userns,
|
||||
struct user_namespace *fs_userns,
|
||||
const void *value, size_t size)
|
||||
{
|
||||
return make_posix_acl(mnt_userns, fs_userns, value, size,
|
||||
vfs_set_acl_prepare_kuid,
|
||||
vfs_set_acl_prepare_kgid);
|
||||
}
|
||||
EXPORT_SYMBOL(vfs_set_acl_prepare);
|
||||
|
||||
/**
|
||||
* posix_acl_from_xattr_kuid - map ACL_USER uid into filesystem idmapping
|
||||
* @mnt_userns: unused
|
||||
* @fs_userns: the filesystem's idmapping
|
||||
* @e: a ACL_USER entry in POSIX ACL uapi format
|
||||
*
|
||||
* Map the uid stored as ACL_USER entry in @e into the filesystem's idmapping.
|
||||
* This is used in posix_acl_from_xattr() to generate the proper VFS
|
||||
* representation of POSIX ACLs with ACL_USER entries.
|
||||
*
|
||||
* Return: A kuid in @fs_userns for the uid stored in @e.
|
||||
*/
|
||||
static inline kuid_t
|
||||
posix_acl_from_xattr_kuid(struct user_namespace *mnt_userns,
|
||||
struct user_namespace *fs_userns,
|
||||
const struct posix_acl_xattr_entry *e)
|
||||
{
|
||||
return make_kuid(fs_userns, le32_to_cpu(e->e_id));
|
||||
}
|
||||
|
||||
/**
|
||||
* posix_acl_from_xattr_kgid - map ACL_GROUP gid into filesystem idmapping
|
||||
* @mnt_userns: unused
|
||||
* @fs_userns: the filesystem's idmapping
|
||||
* @e: a ACL_GROUP entry in POSIX ACL uapi format
|
||||
*
|
||||
* Map the gid stored as ACL_GROUP entry in @e into the filesystem's idmapping.
|
||||
* This is used in posix_acl_from_xattr() to generate the proper VFS
|
||||
* representation of POSIX ACLs with ACL_GROUP entries.
|
||||
*
|
||||
* Return: A kgid in @fs_userns for the gid stored in @e.
|
||||
*/
|
||||
static inline kgid_t
|
||||
posix_acl_from_xattr_kgid(struct user_namespace *mnt_userns,
|
||||
struct user_namespace *fs_userns,
|
||||
const struct posix_acl_xattr_entry *e)
|
||||
{
|
||||
return make_kgid(fs_userns, le32_to_cpu(e->e_id));
|
||||
}
|
||||
|
||||
/**
|
||||
* posix_acl_from_xattr - convert POSIX ACLs from backing store to VFS format
|
||||
* @fs_userns: the filesystem's idmapping
|
||||
* @value: the uapi representation of POSIX ACLs
|
||||
* @size: the size of @void
|
||||
*
|
||||
* Filesystems that store POSIX ACLs in the unaltered uapi format should use
|
||||
* posix_acl_from_xattr() when reading them from the backing store and
|
||||
* converting them into the struct posix_acl VFS format. The helper is
|
||||
* specifically intended to be called from the ->get_acl() inode operation.
|
||||
*
|
||||
* The posix_acl_from_xattr() function will map the raw {g,u}id values stored
|
||||
* in ACL_{GROUP,USER} entries into the filesystem idmapping in @fs_userns. The
|
||||
* posix_acl_from_xattr_k{g,u}id() helpers will take care to generate the
|
||||
* correct k{g,u}id_t. The returned struct posix_acl can be cached.
|
||||
*
|
||||
* Note that posix_acl_from_xattr() does not take idmapped mounts into account.
|
||||
* If it did it calling is from the ->get_acl() inode operation would return
|
||||
* POSIX ACLs mapped according to an idmapped mount which would mean that the
|
||||
* value couldn't be cached for the filesystem. Idmapped mounts are taken into
|
||||
* account on the fly during permission checking or right at the VFS -
|
||||
* userspace boundary before reporting them to the user.
|
||||
*
|
||||
* Return: Allocated struct posix_acl on success, NULL for a valid header but
|
||||
* without actual POSIX ACL entries, or ERR_PTR() encoded error code.
|
||||
*/
|
||||
struct posix_acl *
|
||||
posix_acl_from_xattr(struct user_namespace *fs_userns,
|
||||
const void *value, size_t size)
|
||||
{
|
||||
return make_posix_acl(&init_user_ns, fs_userns, value, size,
|
||||
posix_acl_from_xattr_kuid,
|
||||
posix_acl_from_xattr_kgid);
|
||||
}
|
||||
EXPORT_SYMBOL (posix_acl_from_xattr);
|
||||
|
||||
/*
|
||||
|
|
@ -1027,7 +1171,17 @@ posix_acl_xattr_set(const struct xattr_handler *handler,
|
|||
int ret;
|
||||
|
||||
if (value) {
|
||||
acl = posix_acl_from_xattr(&init_user_ns, value, size);
|
||||
/*
|
||||
* By the time we end up here the {g,u}ids stored in
|
||||
* ACL_{GROUP,USER} have already been mapped according to the
|
||||
* caller's idmapping. The vfs_set_acl_prepare() helper will
|
||||
* recover them and take idmapped mounts into account. The
|
||||
* filesystem will receive the POSIX ACLs in the correct
|
||||
* format ready to be cached or written to the backing store
|
||||
* taking the filesystem idmapping into account.
|
||||
*/
|
||||
acl = vfs_set_acl_prepare(mnt_userns, i_user_ns(inode),
|
||||
value, size);
|
||||
if (IS_ERR(acl))
|
||||
return PTR_ERR(acl);
|
||||
}
|
||||
|
|
|
|||
15
fs/xattr.c
15
fs/xattr.c
|
|
@ -290,7 +290,7 @@ static inline bool is_posix_acl_xattr(const char *name)
|
|||
|
||||
int
|
||||
vfs_setxattr(struct user_namespace *mnt_userns, struct dentry *dentry,
|
||||
const char *name, void *value, size_t size, int flags)
|
||||
const char *name, const void *value, size_t size, int flags)
|
||||
{
|
||||
struct inode *inode = dentry->d_inode;
|
||||
struct inode *delegated_inode = NULL;
|
||||
|
|
@ -298,16 +298,12 @@ vfs_setxattr(struct user_namespace *mnt_userns, struct dentry *dentry,
|
|||
int error;
|
||||
|
||||
if (size && strcmp(name, XATTR_NAME_CAPS) == 0) {
|
||||
error = cap_convert_nscap(mnt_userns, dentry,
|
||||
(const void **)&value, size);
|
||||
error = cap_convert_nscap(mnt_userns, dentry, &value, size);
|
||||
if (error < 0)
|
||||
return error;
|
||||
size = error;
|
||||
}
|
||||
|
||||
if (size && is_posix_acl_xattr(name))
|
||||
posix_acl_setxattr_idmapped_mnt(mnt_userns, inode, value, size);
|
||||
|
||||
retry_deleg:
|
||||
inode_lock(inode);
|
||||
error = __vfs_setxattr_locked(mnt_userns, dentry, name, value, size,
|
||||
|
|
@ -587,9 +583,7 @@ int setxattr_copy(const char __user *name, struct xattr_ctx *ctx)
|
|||
static void setxattr_convert(struct user_namespace *mnt_userns,
|
||||
struct dentry *d, struct xattr_ctx *ctx)
|
||||
{
|
||||
if (ctx->size &&
|
||||
((strcmp(ctx->kname->name, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
|
||||
(strcmp(ctx->kname->name, XATTR_NAME_POSIX_ACL_DEFAULT) == 0)))
|
||||
if (ctx->size && is_posix_acl_xattr(ctx->kname->name))
|
||||
posix_acl_fix_xattr_from_user(ctx->kvalue, ctx->size);
|
||||
}
|
||||
|
||||
|
|
@ -705,8 +699,7 @@ do_getxattr(struct user_namespace *mnt_userns, struct dentry *d,
|
|||
|
||||
error = vfs_getxattr(mnt_userns, d, kname, ctx->kvalue, ctx->size);
|
||||
if (error > 0) {
|
||||
if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
|
||||
(strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
|
||||
if (is_posix_acl_xattr(kname))
|
||||
posix_acl_fix_xattr_to_user(ctx->kvalue, error);
|
||||
if (ctx->size && copy_to_user(ctx->value, ctx->kvalue, error))
|
||||
error = -EFAULT;
|
||||
|
|
|
|||
|
|
@ -38,9 +38,6 @@ void posix_acl_fix_xattr_to_user(void *value, size_t size);
|
|||
void posix_acl_getxattr_idmapped_mnt(struct user_namespace *mnt_userns,
|
||||
const struct inode *inode,
|
||||
void *value, size_t size);
|
||||
void posix_acl_setxattr_idmapped_mnt(struct user_namespace *mnt_userns,
|
||||
const struct inode *inode,
|
||||
void *value, size_t size);
|
||||
#else
|
||||
static inline void posix_acl_fix_xattr_from_user(void *value, size_t size)
|
||||
{
|
||||
|
|
@ -54,18 +51,15 @@ posix_acl_getxattr_idmapped_mnt(struct user_namespace *mnt_userns,
|
|||
size_t size)
|
||||
{
|
||||
}
|
||||
static inline void
|
||||
posix_acl_setxattr_idmapped_mnt(struct user_namespace *mnt_userns,
|
||||
const struct inode *inode, void *value,
|
||||
size_t size)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
struct posix_acl *posix_acl_from_xattr(struct user_namespace *user_ns,
|
||||
const void *value, size_t size);
|
||||
int posix_acl_to_xattr(struct user_namespace *user_ns,
|
||||
const struct posix_acl *acl, void *buffer, size_t size);
|
||||
struct posix_acl *vfs_set_acl_prepare(struct user_namespace *mnt_userns,
|
||||
struct user_namespace *fs_userns,
|
||||
const void *value, size_t size);
|
||||
|
||||
extern const struct xattr_handler posix_acl_access_xattr_handler;
|
||||
extern const struct xattr_handler posix_acl_default_xattr_handler;
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ int __vfs_setxattr_locked(struct user_namespace *, struct dentry *,
|
|||
const char *, const void *, size_t, int,
|
||||
struct inode **);
|
||||
int vfs_setxattr(struct user_namespace *, struct dentry *, const char *,
|
||||
void *, size_t, int);
|
||||
const void *, size_t, int);
|
||||
int __vfs_removexattr(struct user_namespace *, struct dentry *, const char *);
|
||||
int __vfs_removexattr_locked(struct user_namespace *, struct dentry *,
|
||||
const char *, struct inode **);
|
||||
|
|
|
|||
|
|
@ -457,10 +457,21 @@ static int evm_xattr_acl_change(struct user_namespace *mnt_userns,
|
|||
int rc;
|
||||
|
||||
/*
|
||||
* user_ns is not relevant here, ACL_USER/ACL_GROUP don't have impact
|
||||
* on the inode mode (see posix_acl_equiv_mode()).
|
||||
* An earlier comment here mentioned that the idmappings for
|
||||
* ACL_{GROUP,USER} don't matter since EVM is only interested in the
|
||||
* mode stored as part of POSIX ACLs. Nonetheless, if it must translate
|
||||
* from the uapi POSIX ACL representation to the VFS internal POSIX ACL
|
||||
* representation it should do so correctly. There's no guarantee that
|
||||
* we won't change POSIX ACLs in a way that ACL_{GROUP,USER} matters
|
||||
* for the mode at some point and it's difficult to keep track of all
|
||||
* the LSM and integrity modules and what they do to POSIX ACLs.
|
||||
*
|
||||
* Frankly, EVM shouldn't try to interpret the uapi struct for POSIX
|
||||
* ACLs it received. It requires knowledge that only the VFS is
|
||||
* guaranteed to have.
|
||||
*/
|
||||
acl = posix_acl_from_xattr(&init_user_ns, xattr_value, xattr_value_len);
|
||||
acl = vfs_set_acl_prepare(mnt_userns, i_user_ns(inode),
|
||||
xattr_value, xattr_value_len);
|
||||
if (IS_ERR_OR_NULL(acl))
|
||||
return 1;
|
||||
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче