mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Christian Brauner](/assets/img/avatar_default.png)
Extend some inode methods with an additional user namespace argument. A filesystem that is aware of idmapped mounts will receive the user namespace the mount has been marked with. This can be used for additional permission checking and also to enable filesystems to translate between uids and gids if they need to. We have implemented all relevant helpers in earlier patches. As requested we simply extend the exisiting inode method instead of introducing new ones. This is a little more code churn but it's mostly mechanical and doesnt't leave us with additional inode methods. Link: https://lore.kernel.org/r/20210121131959.646623-25-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>
431 lines
10 KiB
C
431 lines
10 KiB
C
// SPDX-License-Identifier: MIT
|
|
/*
|
|
* VirtualBox Guest Shared Folders support: Directory inode and file operations
|
|
*
|
|
* Copyright (C) 2006-2018 Oracle Corporation
|
|
*/
|
|
|
|
#include <linux/namei.h>
|
|
#include <linux/vbox_utils.h>
|
|
#include "vfsmod.h"
|
|
|
|
static int vboxsf_dir_open(struct inode *inode, struct file *file)
|
|
{
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(inode->i_sb);
|
|
struct shfl_createparms params = {};
|
|
struct vboxsf_dir_info *sf_d;
|
|
int err;
|
|
|
|
sf_d = vboxsf_dir_info_alloc();
|
|
if (!sf_d)
|
|
return -ENOMEM;
|
|
|
|
params.handle = SHFL_HANDLE_NIL;
|
|
params.create_flags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS |
|
|
SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
|
|
|
|
err = vboxsf_create_at_dentry(file_dentry(file), ¶ms);
|
|
if (err)
|
|
goto err_free_dir_info;
|
|
|
|
if (params.result != SHFL_FILE_EXISTS) {
|
|
err = -ENOENT;
|
|
goto err_close;
|
|
}
|
|
|
|
err = vboxsf_dir_read_all(sbi, sf_d, params.handle);
|
|
if (err)
|
|
goto err_close;
|
|
|
|
vboxsf_close(sbi->root, params.handle);
|
|
file->private_data = sf_d;
|
|
return 0;
|
|
|
|
err_close:
|
|
vboxsf_close(sbi->root, params.handle);
|
|
err_free_dir_info:
|
|
vboxsf_dir_info_free(sf_d);
|
|
return err;
|
|
}
|
|
|
|
static int vboxsf_dir_release(struct inode *inode, struct file *file)
|
|
{
|
|
if (file->private_data)
|
|
vboxsf_dir_info_free(file->private_data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static unsigned int vboxsf_get_d_type(u32 mode)
|
|
{
|
|
unsigned int d_type;
|
|
|
|
switch (mode & SHFL_TYPE_MASK) {
|
|
case SHFL_TYPE_FIFO:
|
|
d_type = DT_FIFO;
|
|
break;
|
|
case SHFL_TYPE_DEV_CHAR:
|
|
d_type = DT_CHR;
|
|
break;
|
|
case SHFL_TYPE_DIRECTORY:
|
|
d_type = DT_DIR;
|
|
break;
|
|
case SHFL_TYPE_DEV_BLOCK:
|
|
d_type = DT_BLK;
|
|
break;
|
|
case SHFL_TYPE_FILE:
|
|
d_type = DT_REG;
|
|
break;
|
|
case SHFL_TYPE_SYMLINK:
|
|
d_type = DT_LNK;
|
|
break;
|
|
case SHFL_TYPE_SOCKET:
|
|
d_type = DT_SOCK;
|
|
break;
|
|
case SHFL_TYPE_WHITEOUT:
|
|
d_type = DT_WHT;
|
|
break;
|
|
default:
|
|
d_type = DT_UNKNOWN;
|
|
break;
|
|
}
|
|
return d_type;
|
|
}
|
|
|
|
static bool vboxsf_dir_emit(struct file *dir, struct dir_context *ctx)
|
|
{
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(file_inode(dir)->i_sb);
|
|
struct vboxsf_dir_info *sf_d = dir->private_data;
|
|
struct shfl_dirinfo *info;
|
|
struct vboxsf_dir_buf *b;
|
|
unsigned int d_type;
|
|
loff_t i, cur = 0;
|
|
ino_t fake_ino;
|
|
void *end;
|
|
int err;
|
|
|
|
list_for_each_entry(b, &sf_d->info_list, head) {
|
|
try_next_entry:
|
|
if (ctx->pos >= cur + b->entries) {
|
|
cur += b->entries;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Note the vboxsf_dir_info objects we are iterating over here
|
|
* are variable sized, so the info pointer may end up being
|
|
* unaligned. This is how we get the data from the host.
|
|
* Since vboxsf is only supported on x86 machines this is not
|
|
* a problem.
|
|
*/
|
|
for (i = 0, info = b->buf; i < ctx->pos - cur; i++) {
|
|
end = &info->name.string.utf8[info->name.size];
|
|
/* Only happens if the host gives us corrupt data */
|
|
if (WARN_ON(end > (b->buf + b->used)))
|
|
return false;
|
|
info = end;
|
|
}
|
|
|
|
end = &info->name.string.utf8[info->name.size];
|
|
if (WARN_ON(end > (b->buf + b->used)))
|
|
return false;
|
|
|
|
/* Info now points to the right entry, emit it. */
|
|
d_type = vboxsf_get_d_type(info->info.attr.mode);
|
|
|
|
/*
|
|
* On 32-bit systems pos is 64-bit signed, while ino is 32-bit
|
|
* unsigned so fake_ino may overflow, check for this.
|
|
*/
|
|
if ((ino_t)(ctx->pos + 1) != (u64)(ctx->pos + 1)) {
|
|
vbg_err("vboxsf: fake ino overflow, truncating dir\n");
|
|
return false;
|
|
}
|
|
fake_ino = ctx->pos + 1;
|
|
|
|
if (sbi->nls) {
|
|
char d_name[NAME_MAX];
|
|
|
|
err = vboxsf_nlscpy(sbi, d_name, NAME_MAX,
|
|
info->name.string.utf8,
|
|
info->name.length);
|
|
if (err) {
|
|
/* skip erroneous entry and proceed */
|
|
ctx->pos += 1;
|
|
goto try_next_entry;
|
|
}
|
|
|
|
return dir_emit(ctx, d_name, strlen(d_name),
|
|
fake_ino, d_type);
|
|
}
|
|
|
|
return dir_emit(ctx, info->name.string.utf8, info->name.length,
|
|
fake_ino, d_type);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static int vboxsf_dir_iterate(struct file *dir, struct dir_context *ctx)
|
|
{
|
|
bool emitted;
|
|
|
|
do {
|
|
emitted = vboxsf_dir_emit(dir, ctx);
|
|
if (emitted)
|
|
ctx->pos += 1;
|
|
} while (emitted);
|
|
|
|
return 0;
|
|
}
|
|
|
|
const struct file_operations vboxsf_dir_fops = {
|
|
.open = vboxsf_dir_open,
|
|
.iterate = vboxsf_dir_iterate,
|
|
.release = vboxsf_dir_release,
|
|
.read = generic_read_dir,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
|
|
/*
|
|
* This is called during name resolution/lookup to check if the @dentry in
|
|
* the cache is still valid. the job is handled by vboxsf_inode_revalidate.
|
|
*/
|
|
static int vboxsf_dentry_revalidate(struct dentry *dentry, unsigned int flags)
|
|
{
|
|
if (flags & LOOKUP_RCU)
|
|
return -ECHILD;
|
|
|
|
if (d_really_is_positive(dentry))
|
|
return vboxsf_inode_revalidate(dentry) == 0;
|
|
else
|
|
return vboxsf_stat_dentry(dentry, NULL) == -ENOENT;
|
|
}
|
|
|
|
const struct dentry_operations vboxsf_dentry_ops = {
|
|
.d_revalidate = vboxsf_dentry_revalidate
|
|
};
|
|
|
|
/* iops */
|
|
|
|
static struct dentry *vboxsf_dir_lookup(struct inode *parent,
|
|
struct dentry *dentry,
|
|
unsigned int flags)
|
|
{
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
|
|
struct shfl_fsobjinfo fsinfo;
|
|
struct inode *inode;
|
|
int err;
|
|
|
|
dentry->d_time = jiffies;
|
|
|
|
err = vboxsf_stat_dentry(dentry, &fsinfo);
|
|
if (err) {
|
|
inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
|
|
} else {
|
|
inode = vboxsf_new_inode(parent->i_sb);
|
|
if (!IS_ERR(inode))
|
|
vboxsf_init_inode(sbi, inode, &fsinfo);
|
|
}
|
|
|
|
return d_splice_alias(inode, dentry);
|
|
}
|
|
|
|
static int vboxsf_dir_instantiate(struct inode *parent, struct dentry *dentry,
|
|
struct shfl_fsobjinfo *info)
|
|
{
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
|
|
struct vboxsf_inode *sf_i;
|
|
struct inode *inode;
|
|
|
|
inode = vboxsf_new_inode(parent->i_sb);
|
|
if (IS_ERR(inode))
|
|
return PTR_ERR(inode);
|
|
|
|
sf_i = VBOXSF_I(inode);
|
|
/* The host may have given us different attr then requested */
|
|
sf_i->force_restat = 1;
|
|
vboxsf_init_inode(sbi, inode, info);
|
|
|
|
d_instantiate(dentry, inode);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int vboxsf_dir_create(struct inode *parent, struct dentry *dentry,
|
|
umode_t mode, int is_dir)
|
|
{
|
|
struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
|
|
struct shfl_createparms params = {};
|
|
int err;
|
|
|
|
params.handle = SHFL_HANDLE_NIL;
|
|
params.create_flags = SHFL_CF_ACT_CREATE_IF_NEW |
|
|
SHFL_CF_ACT_FAIL_IF_EXISTS |
|
|
SHFL_CF_ACCESS_READWRITE |
|
|
(is_dir ? SHFL_CF_DIRECTORY : 0);
|
|
params.info.attr.mode = (mode & 0777) |
|
|
(is_dir ? SHFL_TYPE_DIRECTORY : SHFL_TYPE_FILE);
|
|
params.info.attr.additional = SHFLFSOBJATTRADD_NOTHING;
|
|
|
|
err = vboxsf_create_at_dentry(dentry, ¶ms);
|
|
if (err)
|
|
return err;
|
|
|
|
if (params.result != SHFL_FILE_CREATED)
|
|
return -EPERM;
|
|
|
|
vboxsf_close(sbi->root, params.handle);
|
|
|
|
err = vboxsf_dir_instantiate(parent, dentry, ¶ms.info);
|
|
if (err)
|
|
return err;
|
|
|
|
/* parent directory access/change time changed */
|
|
sf_parent_i->force_restat = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int vboxsf_dir_mkfile(struct user_namespace *mnt_userns,
|
|
struct inode *parent, struct dentry *dentry,
|
|
umode_t mode, bool excl)
|
|
{
|
|
return vboxsf_dir_create(parent, dentry, mode, 0);
|
|
}
|
|
|
|
static int vboxsf_dir_mkdir(struct user_namespace *mnt_userns,
|
|
struct inode *parent, struct dentry *dentry,
|
|
umode_t mode)
|
|
{
|
|
return vboxsf_dir_create(parent, dentry, mode, 1);
|
|
}
|
|
|
|
static int vboxsf_dir_unlink(struct inode *parent, struct dentry *dentry)
|
|
{
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
|
|
struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
|
|
struct inode *inode = d_inode(dentry);
|
|
struct shfl_string *path;
|
|
u32 flags;
|
|
int err;
|
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
flags = SHFL_REMOVE_DIR;
|
|
else
|
|
flags = SHFL_REMOVE_FILE;
|
|
|
|
if (S_ISLNK(inode->i_mode))
|
|
flags |= SHFL_REMOVE_SYMLINK;
|
|
|
|
path = vboxsf_path_from_dentry(sbi, dentry);
|
|
if (IS_ERR(path))
|
|
return PTR_ERR(path);
|
|
|
|
err = vboxsf_remove(sbi->root, path, flags);
|
|
__putname(path);
|
|
if (err)
|
|
return err;
|
|
|
|
/* parent directory access/change time changed */
|
|
sf_parent_i->force_restat = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int vboxsf_dir_rename(struct user_namespace *mnt_userns,
|
|
struct inode *old_parent,
|
|
struct dentry *old_dentry,
|
|
struct inode *new_parent,
|
|
struct dentry *new_dentry,
|
|
unsigned int flags)
|
|
{
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(old_parent->i_sb);
|
|
struct vboxsf_inode *sf_old_parent_i = VBOXSF_I(old_parent);
|
|
struct vboxsf_inode *sf_new_parent_i = VBOXSF_I(new_parent);
|
|
u32 shfl_flags = SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS;
|
|
struct shfl_string *old_path, *new_path;
|
|
int err;
|
|
|
|
if (flags)
|
|
return -EINVAL;
|
|
|
|
old_path = vboxsf_path_from_dentry(sbi, old_dentry);
|
|
if (IS_ERR(old_path))
|
|
return PTR_ERR(old_path);
|
|
|
|
new_path = vboxsf_path_from_dentry(sbi, new_dentry);
|
|
if (IS_ERR(new_path)) {
|
|
err = PTR_ERR(new_path);
|
|
goto err_put_old_path;
|
|
}
|
|
|
|
if (d_inode(old_dentry)->i_mode & S_IFDIR)
|
|
shfl_flags = 0;
|
|
|
|
err = vboxsf_rename(sbi->root, old_path, new_path, shfl_flags);
|
|
if (err == 0) {
|
|
/* parent directories access/change time changed */
|
|
sf_new_parent_i->force_restat = 1;
|
|
sf_old_parent_i->force_restat = 1;
|
|
}
|
|
|
|
__putname(new_path);
|
|
err_put_old_path:
|
|
__putname(old_path);
|
|
return err;
|
|
}
|
|
|
|
static int vboxsf_dir_symlink(struct user_namespace *mnt_userns,
|
|
struct inode *parent, struct dentry *dentry,
|
|
const char *symname)
|
|
{
|
|
struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
|
|
int symname_size = strlen(symname) + 1;
|
|
struct shfl_string *path, *ssymname;
|
|
struct shfl_fsobjinfo info;
|
|
int err;
|
|
|
|
path = vboxsf_path_from_dentry(sbi, dentry);
|
|
if (IS_ERR(path))
|
|
return PTR_ERR(path);
|
|
|
|
ssymname = kmalloc(SHFLSTRING_HEADER_SIZE + symname_size, GFP_KERNEL);
|
|
if (!ssymname) {
|
|
__putname(path);
|
|
return -ENOMEM;
|
|
}
|
|
ssymname->length = symname_size - 1;
|
|
ssymname->size = symname_size;
|
|
memcpy(ssymname->string.utf8, symname, symname_size);
|
|
|
|
err = vboxsf_symlink(sbi->root, path, ssymname, &info);
|
|
kfree(ssymname);
|
|
__putname(path);
|
|
if (err) {
|
|
/* -EROFS means symlinks are note support -> -EPERM */
|
|
return (err == -EROFS) ? -EPERM : err;
|
|
}
|
|
|
|
err = vboxsf_dir_instantiate(parent, dentry, &info);
|
|
if (err)
|
|
return err;
|
|
|
|
/* parent directory access/change time changed */
|
|
sf_parent_i->force_restat = 1;
|
|
return 0;
|
|
}
|
|
|
|
const struct inode_operations vboxsf_dir_iops = {
|
|
.lookup = vboxsf_dir_lookup,
|
|
.create = vboxsf_dir_mkfile,
|
|
.mkdir = vboxsf_dir_mkdir,
|
|
.rmdir = vboxsf_dir_unlink,
|
|
.unlink = vboxsf_dir_unlink,
|
|
.rename = vboxsf_dir_rename,
|
|
.symlink = vboxsf_dir_symlink,
|
|
.getattr = vboxsf_getattr,
|
|
.setattr = vboxsf_setattr,
|
|
};
|