mirror of
https://github.com/torvalds/linux.git
synced 2024-12-12 06:02:38 +00:00
3e32715496
All users now just use '->iterate_shared()', which only takes the directory inode lock for reading. Filesystems that never got convered to shared mode now instead use a wrapper that drops the lock, re-takes it in write mode, calls the old function, and then downgrades the lock back to read mode. This way the VFS layer and other callers no longer need to care about filesystems that never got converted to the modern era. The filesystems that use the new wrapper are ceph, coda, exfat, jfs, ntfs, ocfs2, overlayfs, and vboxsf. Honestly, several of them look like they really could just iterate their directories in shared mode and skip the wrapper entirely, but the point of this change is to not change semantics or fix filesystems that haven't been fixed in the last 7+ years, but to finally get rid of the dual iterators. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Christian Brauner <brauner@kernel.org>
487 lines
12 KiB
C
487 lines
12 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;
|
|
}
|
|
|
|
WRAP_DIR_ITER(vboxsf_dir_iterate) // FIXME!
|
|
const struct file_operations vboxsf_dir_fops = {
|
|
.open = vboxsf_dir_open,
|
|
.iterate_shared = shared_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, false);
|
|
}
|
|
|
|
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, false);
|
|
|
|
d_instantiate(dentry, inode);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int vboxsf_dir_create(struct inode *parent, struct dentry *dentry,
|
|
umode_t mode, bool is_dir, bool excl, u64 *handle_ret)
|
|
{
|
|
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_ACCESS_READWRITE;
|
|
if (is_dir)
|
|
params.create_flags |= SHFL_CF_DIRECTORY;
|
|
if (excl)
|
|
params.create_flags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
|
|
|
|
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;
|
|
|
|
err = vboxsf_dir_instantiate(parent, dentry, ¶ms.info);
|
|
if (err)
|
|
goto out;
|
|
|
|
/* parent directory access/change time changed */
|
|
sf_parent_i->force_restat = 1;
|
|
|
|
out:
|
|
if (err == 0 && handle_ret)
|
|
*handle_ret = params.handle;
|
|
else
|
|
vboxsf_close(sbi->root, params.handle);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int vboxsf_dir_mkfile(struct mnt_idmap *idmap,
|
|
struct inode *parent, struct dentry *dentry,
|
|
umode_t mode, bool excl)
|
|
{
|
|
return vboxsf_dir_create(parent, dentry, mode, false, excl, NULL);
|
|
}
|
|
|
|
static int vboxsf_dir_mkdir(struct mnt_idmap *idmap,
|
|
struct inode *parent, struct dentry *dentry,
|
|
umode_t mode)
|
|
{
|
|
return vboxsf_dir_create(parent, dentry, mode, true, true, NULL);
|
|
}
|
|
|
|
static int vboxsf_dir_atomic_open(struct inode *parent, struct dentry *dentry,
|
|
struct file *file, unsigned int flags, umode_t mode)
|
|
{
|
|
struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
|
|
struct vboxsf_handle *sf_handle;
|
|
struct dentry *res = NULL;
|
|
u64 handle;
|
|
int err;
|
|
|
|
if (d_in_lookup(dentry)) {
|
|
res = vboxsf_dir_lookup(parent, dentry, 0);
|
|
if (IS_ERR(res))
|
|
return PTR_ERR(res);
|
|
|
|
if (res)
|
|
dentry = res;
|
|
}
|
|
|
|
/* Only creates */
|
|
if (!(flags & O_CREAT) || d_really_is_positive(dentry))
|
|
return finish_no_open(file, res);
|
|
|
|
err = vboxsf_dir_create(parent, dentry, mode, false, flags & O_EXCL, &handle);
|
|
if (err)
|
|
goto out;
|
|
|
|
sf_handle = vboxsf_create_sf_handle(d_inode(dentry), handle, SHFL_CF_ACCESS_READWRITE);
|
|
if (IS_ERR(sf_handle)) {
|
|
vboxsf_close(sbi->root, handle);
|
|
err = PTR_ERR(sf_handle);
|
|
goto out;
|
|
}
|
|
|
|
err = finish_open(file, dentry, generic_file_open);
|
|
if (err) {
|
|
/* This also closes the handle passed to vboxsf_create_sf_handle() */
|
|
vboxsf_release_sf_handle(d_inode(dentry), sf_handle);
|
|
goto out;
|
|
}
|
|
|
|
file->private_data = sf_handle;
|
|
file->f_mode |= FMODE_CREATED;
|
|
out:
|
|
dput(res);
|
|
return err;
|
|
}
|
|
|
|
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 mnt_idmap *idmap,
|
|
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 mnt_idmap *idmap,
|
|
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,
|
|
.atomic_open = vboxsf_dir_atomic_open,
|
|
.rmdir = vboxsf_dir_unlink,
|
|
.unlink = vboxsf_dir_unlink,
|
|
.rename = vboxsf_dir_rename,
|
|
.symlink = vboxsf_dir_symlink,
|
|
.getattr = vboxsf_getattr,
|
|
.setattr = vboxsf_setattr,
|
|
};
|