mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-30 08:02:30 +00:00
e65ce2a50c
The posix acl permission checking helpers determine whether a caller is privileged over an inode according to the acls associated with the inode. Add helpers that make it possible to handle acls on idmapped mounts. The vfs and the filesystems targeted by this first iteration make use of posix_acl_fix_xattr_from_user() and posix_acl_fix_xattr_to_user() to translate basic posix access and default permissions such as the ACL_USER and ACL_GROUP type according to the initial user namespace (or the superblock's user namespace) to and from the caller's current user namespace. Adapt these two helpers to handle idmapped mounts whereby we either map from or into the mount's user namespace depending on in which direction we're translating. Similarly, cap_convert_nscap() is used by the vfs to translate user namespace and non-user namespace aware filesystem capabilities from the superblock's user namespace to the caller's user namespace. Enable it to handle idmapped mounts by accounting for the mount's user namespace. In addition the fileystems targeted in the first iteration of this patch series make use of the posix_acl_chmod() and, posix_acl_update_mode() helpers. Both helpers perform permission checks on the target inode. Let them handle idmapped mounts. These two helpers are called when posix acls are set by the respective filesystems to handle this case we extend the ->set() method to take an additional user namespace argument to pass the mount's user namespace down. Link: https://lore.kernel.org/r/20210121131959.646623-9-christian.brauner@ubuntu.com Cc: Christoph Hellwig <hch@lst.de> Cc: David Howells <dhowells@redhat.com> Cc: Al Viro <viro@zeniv.linux.org.uk> Cc: linux-fsdevel@vger.kernel.org Reviewed-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
265 lines
6.1 KiB
C
265 lines
6.1 KiB
C
/*
|
|
* FUSE: Filesystem in Userspace
|
|
* Copyright (C) 2001-2016 Miklos Szeredi <miklos@szeredi.hu>
|
|
*
|
|
* This program can be distributed under the terms of the GNU GPL.
|
|
* See the file COPYING.
|
|
*/
|
|
|
|
#include "fuse_i.h"
|
|
|
|
#include <linux/xattr.h>
|
|
#include <linux/posix_acl_xattr.h>
|
|
|
|
int fuse_setxattr(struct inode *inode, const char *name, const void *value,
|
|
size_t size, int flags)
|
|
{
|
|
struct fuse_mount *fm = get_fuse_mount(inode);
|
|
FUSE_ARGS(args);
|
|
struct fuse_setxattr_in inarg;
|
|
int err;
|
|
|
|
if (fm->fc->no_setxattr)
|
|
return -EOPNOTSUPP;
|
|
|
|
memset(&inarg, 0, sizeof(inarg));
|
|
inarg.size = size;
|
|
inarg.flags = flags;
|
|
args.opcode = FUSE_SETXATTR;
|
|
args.nodeid = get_node_id(inode);
|
|
args.in_numargs = 3;
|
|
args.in_args[0].size = sizeof(inarg);
|
|
args.in_args[0].value = &inarg;
|
|
args.in_args[1].size = strlen(name) + 1;
|
|
args.in_args[1].value = name;
|
|
args.in_args[2].size = size;
|
|
args.in_args[2].value = value;
|
|
err = fuse_simple_request(fm, &args);
|
|
if (err == -ENOSYS) {
|
|
fm->fc->no_setxattr = 1;
|
|
err = -EOPNOTSUPP;
|
|
}
|
|
if (!err) {
|
|
fuse_invalidate_attr(inode);
|
|
fuse_update_ctime(inode);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value,
|
|
size_t size)
|
|
{
|
|
struct fuse_mount *fm = get_fuse_mount(inode);
|
|
FUSE_ARGS(args);
|
|
struct fuse_getxattr_in inarg;
|
|
struct fuse_getxattr_out outarg;
|
|
ssize_t ret;
|
|
|
|
if (fm->fc->no_getxattr)
|
|
return -EOPNOTSUPP;
|
|
|
|
memset(&inarg, 0, sizeof(inarg));
|
|
inarg.size = size;
|
|
args.opcode = FUSE_GETXATTR;
|
|
args.nodeid = get_node_id(inode);
|
|
args.in_numargs = 2;
|
|
args.in_args[0].size = sizeof(inarg);
|
|
args.in_args[0].value = &inarg;
|
|
args.in_args[1].size = strlen(name) + 1;
|
|
args.in_args[1].value = name;
|
|
/* This is really two different operations rolled into one */
|
|
args.out_numargs = 1;
|
|
if (size) {
|
|
args.out_argvar = true;
|
|
args.out_args[0].size = size;
|
|
args.out_args[0].value = value;
|
|
} else {
|
|
args.out_args[0].size = sizeof(outarg);
|
|
args.out_args[0].value = &outarg;
|
|
}
|
|
ret = fuse_simple_request(fm, &args);
|
|
if (!ret && !size)
|
|
ret = min_t(ssize_t, outarg.size, XATTR_SIZE_MAX);
|
|
if (ret == -ENOSYS) {
|
|
fm->fc->no_getxattr = 1;
|
|
ret = -EOPNOTSUPP;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int fuse_verify_xattr_list(char *list, size_t size)
|
|
{
|
|
size_t origsize = size;
|
|
|
|
while (size) {
|
|
size_t thislen = strnlen(list, size);
|
|
|
|
if (!thislen || thislen == size)
|
|
return -EIO;
|
|
|
|
size -= thislen + 1;
|
|
list += thislen + 1;
|
|
}
|
|
|
|
return origsize;
|
|
}
|
|
|
|
ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
|
|
{
|
|
struct inode *inode = d_inode(entry);
|
|
struct fuse_mount *fm = get_fuse_mount(inode);
|
|
FUSE_ARGS(args);
|
|
struct fuse_getxattr_in inarg;
|
|
struct fuse_getxattr_out outarg;
|
|
ssize_t ret;
|
|
|
|
if (fuse_is_bad(inode))
|
|
return -EIO;
|
|
|
|
if (!fuse_allow_current_process(fm->fc))
|
|
return -EACCES;
|
|
|
|
if (fm->fc->no_listxattr)
|
|
return -EOPNOTSUPP;
|
|
|
|
memset(&inarg, 0, sizeof(inarg));
|
|
inarg.size = size;
|
|
args.opcode = FUSE_LISTXATTR;
|
|
args.nodeid = get_node_id(inode);
|
|
args.in_numargs = 1;
|
|
args.in_args[0].size = sizeof(inarg);
|
|
args.in_args[0].value = &inarg;
|
|
/* This is really two different operations rolled into one */
|
|
args.out_numargs = 1;
|
|
if (size) {
|
|
args.out_argvar = true;
|
|
args.out_args[0].size = size;
|
|
args.out_args[0].value = list;
|
|
} else {
|
|
args.out_args[0].size = sizeof(outarg);
|
|
args.out_args[0].value = &outarg;
|
|
}
|
|
ret = fuse_simple_request(fm, &args);
|
|
if (!ret && !size)
|
|
ret = min_t(ssize_t, outarg.size, XATTR_LIST_MAX);
|
|
if (ret > 0 && size)
|
|
ret = fuse_verify_xattr_list(list, ret);
|
|
if (ret == -ENOSYS) {
|
|
fm->fc->no_listxattr = 1;
|
|
ret = -EOPNOTSUPP;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int fuse_removexattr(struct inode *inode, const char *name)
|
|
{
|
|
struct fuse_mount *fm = get_fuse_mount(inode);
|
|
FUSE_ARGS(args);
|
|
int err;
|
|
|
|
if (fm->fc->no_removexattr)
|
|
return -EOPNOTSUPP;
|
|
|
|
args.opcode = FUSE_REMOVEXATTR;
|
|
args.nodeid = get_node_id(inode);
|
|
args.in_numargs = 1;
|
|
args.in_args[0].size = strlen(name) + 1;
|
|
args.in_args[0].value = name;
|
|
err = fuse_simple_request(fm, &args);
|
|
if (err == -ENOSYS) {
|
|
fm->fc->no_removexattr = 1;
|
|
err = -EOPNOTSUPP;
|
|
}
|
|
if (!err) {
|
|
fuse_invalidate_attr(inode);
|
|
fuse_update_ctime(inode);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static int fuse_xattr_get(const struct xattr_handler *handler,
|
|
struct dentry *dentry, struct inode *inode,
|
|
const char *name, void *value, size_t size)
|
|
{
|
|
if (fuse_is_bad(inode))
|
|
return -EIO;
|
|
|
|
return fuse_getxattr(inode, name, value, size);
|
|
}
|
|
|
|
static int fuse_xattr_set(const struct xattr_handler *handler,
|
|
struct user_namespace *mnt_userns,
|
|
struct dentry *dentry, struct inode *inode,
|
|
const char *name, const void *value, size_t size,
|
|
int flags)
|
|
{
|
|
if (fuse_is_bad(inode))
|
|
return -EIO;
|
|
|
|
if (!value)
|
|
return fuse_removexattr(inode, name);
|
|
|
|
return fuse_setxattr(inode, name, value, size, flags);
|
|
}
|
|
|
|
static bool no_xattr_list(struct dentry *dentry)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static int no_xattr_get(const struct xattr_handler *handler,
|
|
struct dentry *dentry, struct inode *inode,
|
|
const char *name, void *value, size_t size)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static int no_xattr_set(const struct xattr_handler *handler,
|
|
struct user_namespace *mnt_userns,
|
|
struct dentry *dentry, struct inode *nodee,
|
|
const char *name, const void *value,
|
|
size_t size, int flags)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static const struct xattr_handler fuse_xattr_handler = {
|
|
.prefix = "",
|
|
.get = fuse_xattr_get,
|
|
.set = fuse_xattr_set,
|
|
};
|
|
|
|
const struct xattr_handler *fuse_xattr_handlers[] = {
|
|
&fuse_xattr_handler,
|
|
NULL
|
|
};
|
|
|
|
const struct xattr_handler *fuse_acl_xattr_handlers[] = {
|
|
&posix_acl_access_xattr_handler,
|
|
&posix_acl_default_xattr_handler,
|
|
&fuse_xattr_handler,
|
|
NULL
|
|
};
|
|
|
|
static const struct xattr_handler fuse_no_acl_access_xattr_handler = {
|
|
.name = XATTR_NAME_POSIX_ACL_ACCESS,
|
|
.flags = ACL_TYPE_ACCESS,
|
|
.list = no_xattr_list,
|
|
.get = no_xattr_get,
|
|
.set = no_xattr_set,
|
|
};
|
|
|
|
static const struct xattr_handler fuse_no_acl_default_xattr_handler = {
|
|
.name = XATTR_NAME_POSIX_ACL_DEFAULT,
|
|
.flags = ACL_TYPE_ACCESS,
|
|
.list = no_xattr_list,
|
|
.get = no_xattr_get,
|
|
.set = no_xattr_set,
|
|
};
|
|
|
|
const struct xattr_handler *fuse_no_acl_xattr_handlers[] = {
|
|
&fuse_no_acl_access_xattr_handler,
|
|
&fuse_no_acl_default_xattr_handler,
|
|
&fuse_xattr_handler,
|
|
NULL
|
|
};
|