| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * FUSE-BPF: Filesystem in Userspace with BPF |
| * Copyright (c) 2021 Google LLC |
| */ |
| |
| #include "fuse_i.h" |
| |
| #include <linux/fdtable.h> |
| #include <linux/filter.h> |
| #include <linux/fs_stack.h> |
| #include <linux/namei.h> |
| |
| #include "../internal.h" |
| |
| #define FUSE_BPF_IOCB_MASK (IOCB_APPEND | IOCB_DSYNC | IOCB_HIPRI | IOCB_NOWAIT | IOCB_SYNC) |
| |
| struct fuse_bpf_aio_req { |
| struct kiocb iocb; |
| refcount_t ref; |
| struct kiocb *iocb_orig; |
| }; |
| |
| static struct kmem_cache *fuse_bpf_aio_request_cachep; |
| |
| static void fuse_stat_to_attr(struct fuse_conn *fc, struct inode *inode, |
| struct kstat *stat, struct fuse_attr *attr); |
| |
| static void fuse_file_accessed(struct file *dst_file, struct file *src_file) |
| { |
| struct inode *dst_inode; |
| struct inode *src_inode; |
| |
| if (dst_file->f_flags & O_NOATIME) |
| return; |
| |
| dst_inode = file_inode(dst_file); |
| src_inode = file_inode(src_file); |
| |
| if ((!timespec64_equal(&dst_inode->i_mtime, &src_inode->i_mtime) || |
| !timespec64_equal(&dst_inode->i_ctime, &src_inode->i_ctime))) { |
| dst_inode->i_mtime = src_inode->i_mtime; |
| dst_inode->i_ctime = src_inode->i_ctime; |
| } |
| |
| touch_atime(&dst_file->f_path); |
| } |
| |
| int fuse_open_initialize(struct fuse_bpf_args *fa, struct fuse_open_io *foio, |
| struct inode *inode, struct file *file, bool isdir) |
| { |
| foio->foi = (struct fuse_open_in) { |
| .flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY), |
| }; |
| |
| foio->foo = (struct fuse_open_out) {0}; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(inode)->nodeid, |
| .opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN, |
| .in_numargs = 1, |
| .out_numargs = 1, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(foio->foi), |
| .value = &foio->foi, |
| }, |
| .out_args[0] = (struct fuse_bpf_arg) { |
| .size = sizeof(foio->foo), |
| .value = &foio->foo, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_open_backing(struct fuse_bpf_args *fa, |
| struct inode *inode, struct file *file, bool isdir) |
| { |
| struct fuse_mount *fm = get_fuse_mount(inode); |
| const struct fuse_open_in *foi = fa->in_args[0].value; |
| struct fuse_file *ff; |
| int retval; |
| int mask; |
| struct fuse_dentry *fd = get_fuse_dentry(file->f_path.dentry); |
| struct file *backing_file; |
| |
| ff = fuse_file_alloc(fm); |
| if (!ff) |
| return -ENOMEM; |
| file->private_data = ff; |
| |
| switch (foi->flags & O_ACCMODE) { |
| case O_RDONLY: |
| mask = MAY_READ; |
| break; |
| |
| case O_WRONLY: |
| mask = MAY_WRITE; |
| break; |
| |
| case O_RDWR: |
| mask = MAY_READ | MAY_WRITE; |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| |
| retval = inode_permission(&init_user_ns, |
| get_fuse_inode(inode)->backing_inode, mask); |
| if (retval) |
| return retval; |
| |
| backing_file = dentry_open(&fd->backing_path, |
| foi->flags, |
| current_cred()); |
| |
| if (IS_ERR(backing_file)) { |
| fuse_file_free(ff); |
| file->private_data = NULL; |
| return PTR_ERR(backing_file); |
| } |
| ff->backing_file = backing_file; |
| |
| return 0; |
| } |
| |
| void *fuse_open_finalize(struct fuse_bpf_args *fa, |
| struct inode *inode, struct file *file, bool isdir) |
| { |
| struct fuse_file *ff = file->private_data; |
| struct fuse_open_out *foo = fa->out_args[0].value; |
| |
| if (ff) { |
| ff->fh = foo->fh; |
| ff->nodeid = get_fuse_inode(inode)->nodeid; |
| } |
| return 0; |
| } |
| |
| int fuse_create_open_initialize( |
| struct fuse_bpf_args *fa, struct fuse_create_open_io *fcoio, |
| struct inode *dir, struct dentry *entry, |
| struct file *file, unsigned int flags, umode_t mode) |
| { |
| fcoio->fci = (struct fuse_create_in) { |
| .flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY), |
| .mode = mode, |
| }; |
| |
| fcoio->feo = (struct fuse_entry_out) {0}; |
| fcoio->foo = (struct fuse_open_out) {0}; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(dir), |
| .opcode = FUSE_CREATE, |
| .in_numargs = 2, |
| .out_numargs = 2, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(fcoio->fci), |
| .value = &fcoio->fci, |
| }, |
| .in_args[1] = (struct fuse_bpf_in_arg) { |
| .size = entry->d_name.len + 1, |
| .value = entry->d_name.name, |
| }, |
| .out_args[0] = (struct fuse_bpf_arg) { |
| .size = sizeof(fcoio->feo), |
| .value = &fcoio->feo, |
| }, |
| .out_args[1] = (struct fuse_bpf_arg) { |
| .size = sizeof(fcoio->foo), |
| .value = &fcoio->foo, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| static int fuse_open_file_backing(struct inode *inode, struct file *file) |
| { |
| struct fuse_mount *fm = get_fuse_mount(inode); |
| struct dentry *entry = file->f_path.dentry; |
| struct fuse_dentry *fuse_dentry = get_fuse_dentry(entry); |
| struct fuse_file *fuse_file; |
| struct file *backing_file; |
| |
| fuse_file = fuse_file_alloc(fm); |
| if (!fuse_file) |
| return -ENOMEM; |
| file->private_data = fuse_file; |
| |
| backing_file = dentry_open(&fuse_dentry->backing_path, file->f_flags, |
| current_cred()); |
| if (IS_ERR(backing_file)) { |
| fuse_file_free(fuse_file); |
| file->private_data = NULL; |
| return PTR_ERR(backing_file); |
| } |
| fuse_file->backing_file = backing_file; |
| |
| return 0; |
| } |
| |
| int fuse_create_open_backing( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry, |
| struct file *file, unsigned int flags, umode_t mode) |
| { |
| struct fuse_inode *dir_fuse_inode = get_fuse_inode(dir); |
| struct fuse_dentry *dir_fuse_dentry = get_fuse_dentry(entry->d_parent); |
| struct dentry *backing_dentry = NULL; |
| struct inode *inode = NULL; |
| struct dentry *newent; |
| int err = 0; |
| const struct fuse_create_in *fci = fa->in_args[0].value; |
| struct inode *d_inode = entry->d_inode; |
| u64 target_nodeid = 0; |
| |
| if (!dir_fuse_inode || !dir_fuse_dentry) |
| return -EIO; |
| |
| inode_lock_nested(dir_fuse_inode->backing_inode, I_MUTEX_PARENT); |
| backing_dentry = lookup_one_len(fa->in_args[1].value, |
| dir_fuse_dentry->backing_path.dentry, |
| strlen(fa->in_args[1].value)); |
| inode_unlock(dir_fuse_inode->backing_inode); |
| |
| if (IS_ERR(backing_dentry)) |
| return PTR_ERR(backing_dentry); |
| |
| if (d_really_is_positive(backing_dentry)) { |
| err = -EIO; |
| goto out; |
| } |
| |
| err = vfs_create(&init_user_ns, dir_fuse_inode->backing_inode, |
| backing_dentry, fci->mode, true); |
| if (err) |
| goto out; |
| |
| if (get_fuse_dentry(entry)->backing_path.dentry) |
| path_put(&get_fuse_dentry(entry)->backing_path); |
| get_fuse_dentry(entry)->backing_path = (struct path) { |
| .mnt = dir_fuse_dentry->backing_path.mnt, |
| .dentry = backing_dentry, |
| }; |
| path_get(&get_fuse_dentry(entry)->backing_path); |
| |
| if (d_inode) |
| target_nodeid = get_fuse_inode(d_inode)->nodeid; |
| |
| inode = fuse_iget_backing(dir->i_sb, target_nodeid, |
| get_fuse_dentry(entry)->backing_path.dentry->d_inode); |
| if (IS_ERR(inode)) { |
| err = PTR_ERR(inode); |
| goto out; |
| } |
| |
| if (get_fuse_inode(inode)->bpf) |
| bpf_prog_put(get_fuse_inode(inode)->bpf); |
| get_fuse_inode(inode)->bpf = dir_fuse_inode->bpf; |
| if (get_fuse_inode(inode)->bpf) |
| bpf_prog_inc(dir_fuse_inode->bpf); |
| |
| newent = d_splice_alias(inode, entry); |
| if (IS_ERR(newent)) { |
| err = PTR_ERR(newent); |
| goto out; |
| } |
| |
| entry = newent ? newent : entry; |
| err = finish_open(file, entry, fuse_open_file_backing); |
| |
| out: |
| dput(backing_dentry); |
| return err; |
| } |
| |
| void *fuse_create_open_finalize( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry, |
| struct file *file, unsigned int flags, umode_t mode) |
| { |
| struct fuse_file *ff = file->private_data; |
| struct fuse_inode *fi = get_fuse_inode(file->f_inode); |
| struct fuse_entry_out *feo = fa->out_args[0].value; |
| struct fuse_open_out *foo = fa->out_args[1].value; |
| |
| if (fi) |
| fi->nodeid = feo->nodeid; |
| if (ff) |
| ff->fh = foo->fh; |
| return 0; |
| } |
| |
| int fuse_release_initialize(struct fuse_bpf_args *fa, struct fuse_release_in *fri, |
| struct inode *inode, struct file *file) |
| { |
| struct fuse_file *fuse_file = file->private_data; |
| |
| /* Always put backing file whatever bpf/userspace says */ |
| fput(fuse_file->backing_file); |
| |
| *fri = (struct fuse_release_in) { |
| .fh = ((struct fuse_file *)(file->private_data))->fh, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(inode)->nodeid, |
| .opcode = FUSE_RELEASE, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(*fri), |
| .in_args[0].value = fri, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_releasedir_initialize(struct fuse_bpf_args *fa, |
| struct fuse_release_in *fri, |
| struct inode *inode, struct file *file) |
| { |
| struct fuse_file *fuse_file = file->private_data; |
| |
| /* Always put backing file whatever bpf/userspace says */ |
| fput(fuse_file->backing_file); |
| |
| *fri = (struct fuse_release_in) { |
| .fh = ((struct fuse_file *)(file->private_data))->fh, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(inode)->nodeid, |
| .opcode = FUSE_RELEASEDIR, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(*fri), |
| .in_args[0].value = fri, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_release_backing(struct fuse_bpf_args *fa, |
| struct inode *inode, struct file *file) |
| { |
| return 0; |
| } |
| |
| void *fuse_release_finalize(struct fuse_bpf_args *fa, |
| struct inode *inode, struct file *file) |
| { |
| fuse_file_free(file->private_data); |
| return NULL; |
| } |
| |
| int fuse_flush_initialize(struct fuse_bpf_args *fa, struct fuse_flush_in *ffi, |
| struct file *file, fl_owner_t id) |
| { |
| struct fuse_file *fuse_file = file->private_data; |
| |
| *ffi = (struct fuse_flush_in) { |
| .fh = fuse_file->fh, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(file->f_inode), |
| .opcode = FUSE_FLUSH, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(*ffi), |
| .in_args[0].value = ffi, |
| .flags = FUSE_BPF_FORCE, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_flush_backing(struct fuse_bpf_args *fa, struct file *file, fl_owner_t id) |
| { |
| struct fuse_file *fuse_file = file->private_data; |
| struct file *backing_file = fuse_file->backing_file; |
| |
| if (backing_file->f_op->flush) |
| return backing_file->f_op->flush(backing_file, id); |
| return 0; |
| } |
| |
| void *fuse_flush_finalize(struct fuse_bpf_args *fa, struct file *file, fl_owner_t id) |
| { |
| return NULL; |
| } |
| |
| int fuse_lseek_initialize(struct fuse_bpf_args *fa, struct fuse_lseek_io *flio, |
| struct file *file, loff_t offset, int whence) |
| { |
| struct fuse_file *fuse_file = file->private_data; |
| |
| flio->fli = (struct fuse_lseek_in) { |
| .fh = fuse_file->fh, |
| .offset = offset, |
| .whence = whence, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(file->f_inode), |
| .opcode = FUSE_LSEEK, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(flio->fli), |
| .in_args[0].value = &flio->fli, |
| .out_numargs = 1, |
| .out_args[0].size = sizeof(flio->flo), |
| .out_args[0].value = &flio->flo, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_lseek_backing(struct fuse_bpf_args *fa, struct file *file, loff_t offset, int whence) |
| { |
| const struct fuse_lseek_in *fli = fa->in_args[0].value; |
| struct fuse_lseek_out *flo = fa->out_args[0].value; |
| struct fuse_file *fuse_file = file->private_data; |
| struct file *backing_file = fuse_file->backing_file; |
| loff_t ret; |
| |
| /* TODO: Handle changing of the file handle */ |
| if (offset == 0) { |
| if (whence == SEEK_CUR) { |
| flo->offset = file->f_pos; |
| return flo->offset; |
| } |
| |
| if (whence == SEEK_SET) { |
| flo->offset = vfs_setpos(file, 0, 0); |
| return flo->offset; |
| } |
| } |
| |
| inode_lock(file->f_inode); |
| backing_file->f_pos = file->f_pos; |
| ret = vfs_llseek(backing_file, fli->offset, fli->whence); |
| flo->offset = ret; |
| inode_unlock(file->f_inode); |
| return ret; |
| } |
| |
| void *fuse_lseek_finalize(struct fuse_bpf_args *fa, struct file *file, loff_t offset, int whence) |
| { |
| struct fuse_lseek_out *flo = fa->out_args[0].value; |
| |
| if (!fa->error_in) |
| file->f_pos = flo->offset; |
| return ERR_PTR(flo->offset); |
| } |
| |
| int fuse_copy_file_range_initialize(struct fuse_bpf_args *fa, struct fuse_copy_file_range_io *fcf, |
| struct file *file_in, loff_t pos_in, struct file *file_out, |
| loff_t pos_out, size_t len, unsigned int flags) |
| { |
| struct fuse_file *fuse_file_in = file_in->private_data; |
| struct fuse_file *fuse_file_out = file_out->private_data; |
| |
| |
| fcf->fci = (struct fuse_copy_file_range_in) { |
| .fh_in = fuse_file_in->fh, |
| .off_in = pos_in, |
| .nodeid_out = fuse_file_out->nodeid, |
| .fh_out = fuse_file_out->fh, |
| .off_out = pos_out, |
| .len = len, |
| .flags = flags, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(file_in->f_inode), |
| .opcode = FUSE_COPY_FILE_RANGE, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(fcf->fci), |
| .in_args[0].value = &fcf->fci, |
| .out_numargs = 1, |
| .out_args[0].size = sizeof(fcf->fwo), |
| .out_args[0].value = &fcf->fwo, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_copy_file_range_backing(struct fuse_bpf_args *fa, struct file *file_in, loff_t pos_in, |
| struct file *file_out, loff_t pos_out, size_t len, |
| unsigned int flags) |
| { |
| const struct fuse_copy_file_range_in *fci = fa->in_args[0].value; |
| struct fuse_file *fuse_file_in = file_in->private_data; |
| struct file *backing_file_in = fuse_file_in->backing_file; |
| struct fuse_file *fuse_file_out = file_out->private_data; |
| struct file *backing_file_out = fuse_file_out->backing_file; |
| |
| /* TODO: Handle changing of in/out files */ |
| if (backing_file_out) |
| return vfs_copy_file_range(backing_file_in, fci->off_in, backing_file_out, |
| fci->off_out, fci->len, fci->flags); |
| else |
| return generic_copy_file_range(file_in, pos_in, file_out, pos_out, len, |
| flags); |
| } |
| |
| void *fuse_copy_file_range_finalize(struct fuse_bpf_args *fa, struct file *file_in, loff_t pos_in, |
| struct file *file_out, loff_t pos_out, size_t len, |
| unsigned int flags) |
| { |
| return NULL; |
| } |
| |
| int fuse_fsync_initialize(struct fuse_bpf_args *fa, struct fuse_fsync_in *ffi, |
| struct file *file, loff_t start, loff_t end, int datasync) |
| { |
| struct fuse_file *fuse_file = file->private_data; |
| |
| *ffi = (struct fuse_fsync_in) { |
| .fh = fuse_file->fh, |
| .fsync_flags = datasync ? FUSE_FSYNC_FDATASYNC : 0, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(file->f_inode)->nodeid, |
| .opcode = FUSE_FSYNC, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(*ffi), |
| .in_args[0].value = ffi, |
| .flags = FUSE_BPF_FORCE, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_fsync_backing(struct fuse_bpf_args *fa, |
| struct file *file, loff_t start, loff_t end, int datasync) |
| { |
| struct fuse_file *fuse_file = file->private_data; |
| struct file *backing_file = fuse_file->backing_file; |
| const struct fuse_fsync_in *ffi = fa->in_args[0].value; |
| int new_datasync = (ffi->fsync_flags & FUSE_FSYNC_FDATASYNC) ? 1 : 0; |
| |
| return vfs_fsync(backing_file, new_datasync); |
| } |
| |
| void *fuse_fsync_finalize(struct fuse_bpf_args *fa, |
| struct file *file, loff_t start, loff_t end, int datasync) |
| { |
| return NULL; |
| } |
| |
| int fuse_dir_fsync_initialize(struct fuse_bpf_args *fa, struct fuse_fsync_in *ffi, |
| struct file *file, loff_t start, loff_t end, int datasync) |
| { |
| struct fuse_file *fuse_file = file->private_data; |
| |
| *ffi = (struct fuse_fsync_in) { |
| .fh = fuse_file->fh, |
| .fsync_flags = datasync ? FUSE_FSYNC_FDATASYNC : 0, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(file->f_inode)->nodeid, |
| .opcode = FUSE_FSYNCDIR, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(*ffi), |
| .in_args[0].value = ffi, |
| .flags = FUSE_BPF_FORCE, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_getxattr_initialize(struct fuse_bpf_args *fa, |
| struct fuse_getxattr_io *fgio, |
| struct dentry *dentry, const char *name, void *value, |
| size_t size) |
| { |
| *fgio = (struct fuse_getxattr_io) { |
| .fgi.size = size, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(dentry->d_inode)->nodeid, |
| .opcode = FUSE_GETXATTR, |
| .in_numargs = 2, |
| .out_numargs = 1, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(fgio->fgi), |
| .value = &fgio->fgi, |
| }, |
| .in_args[1] = (struct fuse_bpf_in_arg) { |
| .size = strlen(name) + 1, |
| .value = name, |
| }, |
| .flags = size ? FUSE_BPF_OUT_ARGVAR : 0, |
| .out_args[0].size = size ? size : sizeof(fgio->fgo), |
| .out_args[0].value = size ? value : &fgio->fgo, |
| }; |
| return 0; |
| } |
| |
| int fuse_getxattr_backing(struct fuse_bpf_args *fa, |
| struct dentry *dentry, const char *name, void *value, |
| size_t size) |
| { |
| ssize_t ret = vfs_getxattr(&init_user_ns, |
| get_fuse_dentry(dentry)->backing_path.dentry, |
| fa->in_args[1].value, value, size); |
| |
| if (fa->flags & FUSE_BPF_OUT_ARGVAR) |
| fa->out_args[0].size = ret; |
| else |
| ((struct fuse_getxattr_out *)fa->out_args[0].value)->size = ret; |
| |
| return 0; |
| } |
| |
| void *fuse_getxattr_finalize(struct fuse_bpf_args *fa, |
| struct dentry *dentry, const char *name, void *value, |
| size_t size) |
| { |
| struct fuse_getxattr_out *fgo; |
| |
| if (fa->flags & FUSE_BPF_OUT_ARGVAR) |
| return ERR_PTR(fa->out_args[0].size); |
| |
| fgo = fa->out_args[0].value; |
| |
| return ERR_PTR(fgo->size); |
| |
| } |
| |
| int fuse_listxattr_initialize(struct fuse_bpf_args *fa, |
| struct fuse_getxattr_io *fgio, |
| struct dentry *dentry, char *list, size_t size) |
| { |
| *fgio = (struct fuse_getxattr_io){ |
| .fgi.size = size, |
| }; |
| |
| *fa = (struct fuse_bpf_args){ |
| .nodeid = get_fuse_inode(dentry->d_inode)->nodeid, |
| .opcode = FUSE_LISTXATTR, |
| .in_numargs = 1, |
| .out_numargs = 1, |
| .in_args[0] = |
| (struct fuse_bpf_in_arg){ |
| .size = sizeof(fgio->fgi), |
| .value = &fgio->fgi, |
| }, |
| .flags = size ? FUSE_BPF_OUT_ARGVAR : 0, |
| .out_args[0].size = size ? size : sizeof(fgio->fgo), |
| .out_args[0].value = size ? (void *)list : &fgio->fgo, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_listxattr_backing(struct fuse_bpf_args *fa, struct dentry *dentry, |
| char *list, size_t size) |
| { |
| ssize_t ret = |
| vfs_listxattr(get_fuse_dentry(dentry)->backing_path.dentry, |
| list, size); |
| |
| if (ret < 0) |
| return ret; |
| |
| if (fa->flags & FUSE_BPF_OUT_ARGVAR) |
| fa->out_args[0].size = ret; |
| else |
| ((struct fuse_getxattr_out *)fa->out_args[0].value)->size = ret; |
| |
| return ret; |
| } |
| |
| void *fuse_listxattr_finalize(struct fuse_bpf_args *fa, struct dentry *dentry, |
| char *list, size_t size) |
| { |
| struct fuse_getxattr_out *fgo; |
| |
| if (fa->error_in) |
| return NULL; |
| |
| if (fa->flags & FUSE_BPF_OUT_ARGVAR) |
| return ERR_PTR(fa->out_args[0].size); |
| |
| fgo = fa->out_args[0].value; |
| return ERR_PTR(fgo->size); |
| } |
| |
| int fuse_setxattr_initialize(struct fuse_bpf_args *fa, |
| struct fuse_setxattr_in *fsxi, |
| struct dentry *dentry, const char *name, |
| const void *value, size_t size, int flags) |
| { |
| *fsxi = (struct fuse_setxattr_in) { |
| .size = size, |
| .flags = flags, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(dentry->d_inode)->nodeid, |
| .opcode = FUSE_SETXATTR, |
| .in_numargs = 3, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(*fsxi), |
| .value = fsxi, |
| }, |
| .in_args[1] = (struct fuse_bpf_in_arg) { |
| .size = strlen(name) + 1, |
| .value = name, |
| }, |
| .in_args[2] = (struct fuse_bpf_in_arg) { |
| .size = size, |
| .value = value, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_setxattr_backing(struct fuse_bpf_args *fa, struct dentry *dentry, |
| const char *name, const void *value, size_t size, |
| int flags) |
| { |
| return vfs_setxattr(&init_user_ns, |
| get_fuse_dentry(dentry)->backing_path.dentry, name, |
| value, size, flags); |
| } |
| |
| void *fuse_setxattr_finalize(struct fuse_bpf_args *fa, struct dentry *dentry, |
| const char *name, const void *value, size_t size, |
| int flags) |
| { |
| return NULL; |
| } |
| |
| int fuse_removexattr_initialize(struct fuse_bpf_args *fa, |
| struct fuse_dummy_io *unused, |
| struct dentry *dentry, const char *name) |
| { |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(dentry->d_inode)->nodeid, |
| .opcode = FUSE_REMOVEXATTR, |
| .in_numargs = 1, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = strlen(name) + 1, |
| .value = name, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_removexattr_backing(struct fuse_bpf_args *fa, |
| struct dentry *dentry, const char *name) |
| { |
| struct path *backing_path = |
| &get_fuse_dentry(dentry)->backing_path; |
| |
| /* TODO account for changes of the name by prefilter */ |
| return vfs_removexattr(&init_user_ns, backing_path->dentry, name); |
| } |
| |
| void *fuse_removexattr_finalize(struct fuse_bpf_args *fa, |
| struct dentry *dentry, const char *name) |
| { |
| return NULL; |
| } |
| |
| static inline void fuse_bpf_aio_put(struct fuse_bpf_aio_req *aio_req) |
| { |
| if (refcount_dec_and_test(&aio_req->ref)) |
| kmem_cache_free(fuse_bpf_aio_request_cachep, aio_req); |
| } |
| |
| static void fuse_bpf_aio_cleanup_handler(struct fuse_bpf_aio_req *aio_req) |
| { |
| struct kiocb *iocb = &aio_req->iocb; |
| struct kiocb *iocb_orig = aio_req->iocb_orig; |
| |
| if (iocb->ki_flags & IOCB_WRITE) { |
| __sb_writers_acquired(file_inode(iocb->ki_filp)->i_sb, |
| SB_FREEZE_WRITE); |
| file_end_write(iocb->ki_filp); |
| fuse_copyattr(iocb_orig->ki_filp, iocb->ki_filp); |
| } |
| iocb_orig->ki_pos = iocb->ki_pos; |
| fuse_bpf_aio_put(aio_req); |
| } |
| |
| static void fuse_bpf_aio_rw_complete(struct kiocb *iocb, long res, long res2) |
| { |
| struct fuse_bpf_aio_req *aio_req = |
| container_of(iocb, struct fuse_bpf_aio_req, iocb); |
| struct kiocb *iocb_orig = aio_req->iocb_orig; |
| |
| fuse_bpf_aio_cleanup_handler(aio_req); |
| iocb_orig->ki_complete(iocb_orig, res, res2); |
| } |
| |
| |
| int fuse_file_read_iter_initialize( |
| struct fuse_bpf_args *fa, struct fuse_file_read_iter_io *fri, |
| struct kiocb *iocb, struct iov_iter *to) |
| { |
| struct file *file = iocb->ki_filp; |
| struct fuse_file *ff = file->private_data; |
| |
| fri->fri = (struct fuse_read_in) { |
| .fh = ff->fh, |
| .offset = iocb->ki_pos, |
| .size = to->count, |
| }; |
| |
| fri->frio = (struct fuse_read_iter_out) { |
| .ret = fri->fri.size, |
| }; |
| |
| /* TODO we can't assume 'to' is a kvec */ |
| /* TODO we also can't assume the vector has only one component */ |
| *fa = (struct fuse_bpf_args) { |
| .opcode = FUSE_READ, |
| .nodeid = ff->nodeid, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(fri->fri), |
| .in_args[0].value = &fri->fri, |
| .out_numargs = 1, |
| .out_args[0].size = sizeof(fri->frio), |
| .out_args[0].value = &fri->frio, |
| /* |
| * TODO Design this properly. |
| * Possible approach: do not pass buf to bpf |
| * If going to userland, do a deep copy |
| * For extra credit, do that to/from the vector, rather than |
| * making an extra copy in the kernel |
| */ |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_file_read_iter_backing(struct fuse_bpf_args *fa, |
| struct kiocb *iocb, struct iov_iter *to) |
| { |
| struct fuse_read_iter_out *frio = fa->out_args[0].value; |
| struct file *file = iocb->ki_filp; |
| struct fuse_file *ff = file->private_data; |
| ssize_t ret; |
| |
| if (!iov_iter_count(to)) |
| return 0; |
| |
| if ((iocb->ki_flags & IOCB_DIRECT) && |
| (!ff->backing_file->f_mapping->a_ops || |
| !ff->backing_file->f_mapping->a_ops->direct_IO)) |
| return -EINVAL; |
| |
| /* TODO This just plain ignores any change to fuse_read_in */ |
| if (is_sync_kiocb(iocb)) { |
| ret = vfs_iter_read(ff->backing_file, to, &iocb->ki_pos, |
| iocb_to_rw_flags(iocb->ki_flags, FUSE_BPF_IOCB_MASK)); |
| } else { |
| struct fuse_bpf_aio_req *aio_req; |
| |
| ret = -ENOMEM; |
| aio_req = kmem_cache_zalloc(fuse_bpf_aio_request_cachep, GFP_KERNEL); |
| if (!aio_req) |
| goto out; |
| |
| aio_req->iocb_orig = iocb; |
| kiocb_clone(&aio_req->iocb, iocb, ff->backing_file); |
| aio_req->iocb.ki_complete = fuse_bpf_aio_rw_complete; |
| refcount_set(&aio_req->ref, 2); |
| ret = vfs_iocb_iter_read(ff->backing_file, &aio_req->iocb, to); |
| fuse_bpf_aio_put(aio_req); |
| if (ret != -EIOCBQUEUED) |
| fuse_bpf_aio_cleanup_handler(aio_req); |
| } |
| |
| frio->ret = ret; |
| |
| /* TODO Need to point value at the buffer for post-modification */ |
| |
| out: |
| fuse_file_accessed(file, ff->backing_file); |
| |
| return ret; |
| } |
| |
| void *fuse_file_read_iter_finalize(struct fuse_bpf_args *fa, |
| struct kiocb *iocb, struct iov_iter *to) |
| { |
| struct fuse_read_iter_out *frio = fa->out_args[0].value; |
| |
| return ERR_PTR(frio->ret); |
| } |
| |
| int fuse_file_write_iter_initialize( |
| struct fuse_bpf_args *fa, struct fuse_file_write_iter_io *fwio, |
| struct kiocb *iocb, struct iov_iter *from) |
| { |
| struct file *file = iocb->ki_filp; |
| struct fuse_file *ff = file->private_data; |
| |
| *fwio = (struct fuse_file_write_iter_io) { |
| .fwi.fh = ff->fh, |
| .fwi.offset = iocb->ki_pos, |
| .fwi.size = from->count, |
| }; |
| |
| /* TODO we can't assume 'from' is a kvec */ |
| *fa = (struct fuse_bpf_args) { |
| .opcode = FUSE_WRITE, |
| .nodeid = ff->nodeid, |
| .in_numargs = 2, |
| .in_args[0].size = sizeof(fwio->fwi), |
| .in_args[0].value = &fwio->fwi, |
| .in_args[1].size = fwio->fwi.size, |
| .in_args[1].value = from->kvec->iov_base, |
| .out_numargs = 1, |
| .out_args[0].size = sizeof(fwio->fwio), |
| .out_args[0].value = &fwio->fwio, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_file_write_iter_backing(struct fuse_bpf_args *fa, |
| struct kiocb *iocb, struct iov_iter *from) |
| { |
| struct file *file = iocb->ki_filp; |
| struct fuse_file *ff = file->private_data; |
| struct fuse_write_iter_out *fwio = fa->out_args[0].value; |
| ssize_t ret; |
| |
| if (!iov_iter_count(from)) |
| return 0; |
| |
| /* TODO This just plain ignores any change to fuse_write_in */ |
| /* TODO uint32_t seems smaller than ssize_t.... right? */ |
| inode_lock(file_inode(file)); |
| |
| fuse_copyattr(file, ff->backing_file); |
| |
| if (is_sync_kiocb(iocb)) { |
| file_start_write(ff->backing_file); |
| ret = vfs_iter_write(ff->backing_file, from, &iocb->ki_pos, |
| iocb_to_rw_flags(iocb->ki_flags, FUSE_BPF_IOCB_MASK)); |
| file_end_write(ff->backing_file); |
| |
| /* Must reflect change in size of backing file to upper file */ |
| if (ret > 0) |
| fuse_copyattr(file, ff->backing_file); |
| } else { |
| struct fuse_bpf_aio_req *aio_req; |
| |
| ret = -ENOMEM; |
| aio_req = kmem_cache_zalloc(fuse_bpf_aio_request_cachep, GFP_KERNEL); |
| if (!aio_req) |
| goto out; |
| |
| file_start_write(ff->backing_file); |
| __sb_writers_release(file_inode(ff->backing_file)->i_sb, SB_FREEZE_WRITE); |
| aio_req->iocb_orig = iocb; |
| kiocb_clone(&aio_req->iocb, iocb, ff->backing_file); |
| aio_req->iocb.ki_complete = fuse_bpf_aio_rw_complete; |
| refcount_set(&aio_req->ref, 2); |
| ret = vfs_iocb_iter_write(ff->backing_file, &aio_req->iocb, from); |
| fuse_bpf_aio_put(aio_req); |
| if (ret != -EIOCBQUEUED) |
| fuse_bpf_aio_cleanup_handler(aio_req); |
| } |
| |
| out: |
| inode_unlock(file_inode(file)); |
| fwio->ret = ret; |
| if (ret < 0) |
| return ret; |
| return 0; |
| } |
| |
| void *fuse_file_write_iter_finalize(struct fuse_bpf_args *fa, |
| struct kiocb *iocb, struct iov_iter *from) |
| { |
| struct fuse_write_iter_out *fwio = fa->out_args[0].value; |
| |
| return ERR_PTR(fwio->ret); |
| } |
| |
| ssize_t fuse_backing_mmap(struct file *file, struct vm_area_struct *vma) |
| { |
| int ret; |
| struct fuse_file *ff = file->private_data; |
| struct inode *fuse_inode = file_inode(file); |
| struct file *backing_file = ff->backing_file; |
| struct inode *backing_inode = file_inode(backing_file); |
| |
| if (!backing_file->f_op->mmap) |
| return -ENODEV; |
| |
| if (WARN_ON(file != vma->vm_file)) |
| return -EIO; |
| |
| vma->vm_file = get_file(backing_file); |
| |
| ret = call_mmap(vma->vm_file, vma); |
| |
| if (ret) |
| fput(backing_file); |
| else |
| fput(file); |
| |
| if (file->f_flags & O_NOATIME) |
| return ret; |
| |
| if ((!timespec64_equal(&fuse_inode->i_mtime, |
| &backing_inode->i_mtime) || |
| !timespec64_equal(&fuse_inode->i_ctime, |
| &backing_inode->i_ctime))) { |
| fuse_inode->i_mtime = backing_inode->i_mtime; |
| fuse_inode->i_ctime = backing_inode->i_ctime; |
| } |
| touch_atime(&file->f_path); |
| |
| return ret; |
| } |
| |
| int fuse_file_fallocate_initialize(struct fuse_bpf_args *fa, |
| struct fuse_fallocate_in *ffi, |
| struct file *file, int mode, loff_t offset, loff_t length) |
| { |
| struct fuse_file *ff = file->private_data; |
| |
| *ffi = (struct fuse_fallocate_in) { |
| .fh = ff->fh, |
| .offset = offset, |
| .length = length, |
| .mode = mode |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .opcode = FUSE_FALLOCATE, |
| .nodeid = ff->nodeid, |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(*ffi), |
| .in_args[0].value = ffi, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_file_fallocate_backing(struct fuse_bpf_args *fa, |
| struct file *file, int mode, loff_t offset, loff_t length) |
| { |
| const struct fuse_fallocate_in *ffi = fa->in_args[0].value; |
| struct fuse_file *ff = file->private_data; |
| |
| return vfs_fallocate(ff->backing_file, ffi->mode, ffi->offset, |
| ffi->length); |
| } |
| |
| void *fuse_file_fallocate_finalize(struct fuse_bpf_args *fa, |
| struct file *file, int mode, loff_t offset, loff_t length) |
| { |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| * Directory operations after here * |
| ******************************************************************************/ |
| |
| int fuse_lookup_initialize(struct fuse_bpf_args *fa, struct fuse_lookup_io *fli, |
| struct inode *dir, struct dentry *entry, unsigned int flags) |
| { |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_fuse_inode(dir)->nodeid, |
| .opcode = FUSE_LOOKUP, |
| .in_numargs = 1, |
| .out_numargs = 2, |
| .flags = FUSE_BPF_OUT_ARGVAR, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = entry->d_name.len + 1, |
| .value = entry->d_name.name, |
| }, |
| .out_args[0] = (struct fuse_bpf_arg) { |
| .size = sizeof(fli->feo), |
| .value = &fli->feo, |
| }, |
| .out_args[1] = (struct fuse_bpf_arg) { |
| .size = sizeof(fli->feb.out), |
| .value = &fli->feb.out, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_lookup_backing(struct fuse_bpf_args *fa, struct inode *dir, |
| struct dentry *entry, unsigned int flags) |
| { |
| struct fuse_dentry *fuse_entry = get_fuse_dentry(entry); |
| struct fuse_dentry *dir_fuse_entry = get_fuse_dentry(entry->d_parent); |
| struct dentry *dir_backing_entry = dir_fuse_entry->backing_path.dentry; |
| struct inode *dir_backing_inode = dir_backing_entry->d_inode; |
| struct dentry *backing_entry; |
| struct fuse_entry_out *feo = (void *)fa->out_args[0].value; |
| struct kstat stat; |
| int err; |
| |
| /* TODO this will not handle lookups over mount points */ |
| inode_lock_nested(dir_backing_inode, I_MUTEX_PARENT); |
| backing_entry = lookup_one_len(entry->d_name.name, dir_backing_entry, |
| strlen(entry->d_name.name)); |
| inode_unlock(dir_backing_inode); |
| |
| if (IS_ERR(backing_entry)) |
| return PTR_ERR(backing_entry); |
| |
| fuse_entry->backing_path = (struct path) { |
| .dentry = backing_entry, |
| .mnt = mntget(dir_fuse_entry->backing_path.mnt), |
| }; |
| |
| if (d_is_negative(backing_entry)) { |
| fa->error_in = -ENOENT; |
| return 0; |
| } |
| |
| err = vfs_getattr(&fuse_entry->backing_path, &stat, |
| STATX_BASIC_STATS, 0); |
| if (err) { |
| path_put_init(&fuse_entry->backing_path); |
| return err; |
| } |
| |
| fuse_stat_to_attr(get_fuse_conn(dir), |
| backing_entry->d_inode, &stat, &feo->attr); |
| return 0; |
| } |
| |
| int fuse_handle_backing(struct fuse_entry_bpf *feb, struct inode **backing_inode, |
| struct path *backing_path) |
| { |
| switch (feb->out.backing_action) { |
| case FUSE_ACTION_KEEP: |
| /* backing inode/path are added in fuse_lookup_backing */ |
| break; |
| |
| case FUSE_ACTION_REMOVE: |
| iput(*backing_inode); |
| *backing_inode = NULL; |
| path_put_init(backing_path); |
| break; |
| |
| case FUSE_ACTION_REPLACE: { |
| struct file *backing_file = feb->backing_file; |
| |
| if (!backing_file) |
| return -EINVAL; |
| if (IS_ERR(backing_file)) |
| return PTR_ERR(backing_file); |
| |
| if (backing_inode) |
| iput(*backing_inode); |
| *backing_inode = backing_file->f_inode; |
| ihold(*backing_inode); |
| |
| path_put(backing_path); |
| *backing_path = backing_file->f_path; |
| path_get(backing_path); |
| break; |
| } |
| |
| default: |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| int fuse_handle_bpf_prog(struct fuse_entry_bpf *feb, struct inode *parent, |
| struct bpf_prog **bpf) |
| { |
| struct bpf_prog *new_bpf = NULL; |
| |
| switch (feb->out.bpf_action) { |
| case FUSE_ACTION_KEEP: { |
| /* Parent isn't presented, but we want to keep |
| * Don't touch bpf program at all in this case |
| */ |
| if (!parent) |
| return 0; |
| |
| new_bpf = get_fuse_inode(parent)->bpf; |
| if (new_bpf) |
| bpf_prog_inc(new_bpf); |
| break; |
| } |
| |
| case FUSE_ACTION_REMOVE: |
| break; |
| |
| case FUSE_ACTION_REPLACE: { |
| struct file *bpf_file = feb->bpf_file; |
| |
| if (!bpf_file) |
| return -EINVAL; |
| if (IS_ERR(bpf_file)) |
| return PTR_ERR(bpf_file); |
| |
| new_bpf = fuse_get_bpf_prog(bpf_file); |
| if (IS_ERR(new_bpf)) |
| return PTR_ERR(new_bpf); |
| break; |
| } |
| |
| default: |
| return -EINVAL; |
| } |
| |
| /* Cannot change existing program */ |
| if (*bpf && new_bpf) { |
| bpf_prog_put(new_bpf); |
| return new_bpf == *bpf ? 0 : -EINVAL; |
| } |
| |
| if (*bpf) |
| bpf_prog_put(*bpf); |
| |
| *bpf = new_bpf; |
| return 0; |
| } |
| |
| struct dentry *fuse_lookup_finalize(struct fuse_bpf_args *fa, struct inode *dir, |
| struct dentry *entry, unsigned int flags) |
| { |
| struct fuse_dentry *fd; |
| struct dentry *bd; |
| struct inode *inode, *backing_inode; |
| struct inode *d_inode = entry->d_inode; |
| struct fuse_entry_out *feo = fa->out_args[0].value; |
| struct fuse_entry_bpf_out *febo = fa->out_args[1].value; |
| struct fuse_entry_bpf *feb = container_of(febo, struct fuse_entry_bpf, out); |
| int error = -1; |
| u64 target_nodeid = 0; |
| struct dentry *ret; |
| |
| fd = get_fuse_dentry(entry); |
| if (!fd) { |
| ret = ERR_PTR(-EIO); |
| goto out; |
| } |
| |
| bd = fd->backing_path.dentry; |
| if (!bd) { |
| ret = ERR_PTR(-ENOENT); |
| goto out; |
| } |
| |
| backing_inode = bd->d_inode; |
| if (!backing_inode) { |
| ret = 0; |
| goto out; |
| } |
| |
| if (d_inode) |
| target_nodeid = get_fuse_inode(d_inode)->nodeid; |
| |
| inode = fuse_iget_backing(dir->i_sb, target_nodeid, backing_inode); |
| |
| if (IS_ERR(inode)) { |
| ret = ERR_PTR(PTR_ERR(inode)); |
| goto out; |
| } |
| |
| error = fuse_handle_bpf_prog(feb, dir, &get_fuse_inode(inode)->bpf); |
| if (error) { |
| ret = ERR_PTR(error); |
| goto out; |
| } |
| |
| error = fuse_handle_backing(feb, &get_fuse_inode(inode)->backing_inode, &fd->backing_path); |
| if (error) { |
| ret = ERR_PTR(error); |
| goto out; |
| } |
| |
| get_fuse_inode(inode)->nodeid = feo->nodeid; |
| |
| ret = d_splice_alias(inode, entry); |
| out: |
| if (feb->backing_file) |
| fput(feb->backing_file); |
| return ret; |
| } |
| |
| int fuse_revalidate_backing(struct dentry *entry, unsigned int flags) |
| { |
| struct fuse_dentry *fuse_dentry = get_fuse_dentry(entry); |
| struct dentry *backing_entry = fuse_dentry->backing_path.dentry; |
| |
| spin_lock(&backing_entry->d_lock); |
| if (d_unhashed(backing_entry)) { |
| spin_unlock(&backing_entry->d_lock); |
| return 0; |
| } |
| spin_unlock(&backing_entry->d_lock); |
| |
| if (unlikely(backing_entry->d_flags & DCACHE_OP_REVALIDATE)) |
| return backing_entry->d_op->d_revalidate(backing_entry, flags); |
| return 1; |
| } |
| |
| int fuse_canonical_path_initialize(struct fuse_bpf_args *fa, |
| struct fuse_dummy_io *fdi, |
| const struct path *path, |
| struct path *canonical_path) |
| { |
| fa->opcode = FUSE_CANONICAL_PATH; |
| return 0; |
| } |
| |
| int fuse_canonical_path_backing(struct fuse_bpf_args *fa, const struct path *path, |
| struct path *canonical_path) |
| { |
| get_fuse_backing_path(path->dentry, canonical_path); |
| return 0; |
| } |
| |
| void *fuse_canonical_path_finalize(struct fuse_bpf_args *fa, |
| const struct path *path, |
| struct path *canonical_path) |
| { |
| return NULL; |
| } |
| |
| int fuse_mknod_initialize( |
| struct fuse_bpf_args *fa, struct fuse_mknod_in *fmi, |
| struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev) |
| { |
| *fmi = (struct fuse_mknod_in) { |
| .mode = mode, |
| .rdev = new_encode_dev(rdev), |
| .umask = current_umask(), |
| }; |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(dir), |
| .opcode = FUSE_MKNOD, |
| .in_numargs = 2, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(*fmi), |
| .value = fmi, |
| }, |
| .in_args[1] = (struct fuse_bpf_in_arg) { |
| .size = entry->d_name.len + 1, |
| .value = entry->d_name.name, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_mknod_backing( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev) |
| { |
| int err = 0; |
| const struct fuse_mknod_in *fmi = fa->in_args[0].value; |
| struct fuse_inode *fuse_inode = get_fuse_inode(dir); |
| struct inode *backing_inode = fuse_inode->backing_inode; |
| struct path backing_path = {}; |
| struct inode *inode = NULL; |
| |
| //TODO Actually deal with changing the backing entry in mknod |
| get_fuse_backing_path(entry, &backing_path); |
| if (!backing_path.dentry) |
| return -EBADF; |
| |
| inode_lock_nested(backing_inode, I_MUTEX_PARENT); |
| mode = fmi->mode; |
| if (!IS_POSIXACL(backing_inode)) |
| mode &= ~fmi->umask; |
| err = vfs_mknod(&init_user_ns, backing_inode, backing_path.dentry, |
| mode, new_decode_dev(fmi->rdev)); |
| inode_unlock(backing_inode); |
| if (err) |
| goto out; |
| if (d_really_is_negative(backing_path.dentry) || |
| unlikely(d_unhashed(backing_path.dentry))) { |
| err = -EINVAL; |
| /** |
| * TODO: overlayfs responds to this situation with a |
| * lookupOneLen. Should we do that too? |
| */ |
| goto out; |
| } |
| inode = fuse_iget_backing(dir->i_sb, fuse_inode->nodeid, backing_inode); |
| if (IS_ERR(inode)) { |
| err = PTR_ERR(inode); |
| goto out; |
| } |
| d_instantiate(entry, inode); |
| out: |
| path_put(&backing_path); |
| return err; |
| } |
| |
| void *fuse_mknod_finalize( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev) |
| { |
| return NULL; |
| } |
| |
| int fuse_mkdir_initialize( |
| struct fuse_bpf_args *fa, struct fuse_mkdir_in *fmi, |
| struct inode *dir, struct dentry *entry, umode_t mode) |
| { |
| *fmi = (struct fuse_mkdir_in) { |
| .mode = mode, |
| .umask = current_umask(), |
| }; |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(dir), |
| .opcode = FUSE_MKDIR, |
| .in_numargs = 2, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(*fmi), |
| .value = fmi, |
| }, |
| .in_args[1] = (struct fuse_bpf_in_arg) { |
| .size = entry->d_name.len + 1, |
| .value = entry->d_name.name, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_mkdir_backing( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry, umode_t mode) |
| { |
| int err = 0; |
| const struct fuse_mkdir_in *fmi = fa->in_args[0].value; |
| struct fuse_inode *fuse_inode = get_fuse_inode(dir); |
| struct inode *backing_inode = fuse_inode->backing_inode; |
| struct path backing_path = {}; |
| struct inode *inode = NULL; |
| struct dentry *d; |
| |
| //TODO Actually deal with changing the backing entry in mkdir |
| get_fuse_backing_path(entry, &backing_path); |
| if (!backing_path.dentry) |
| return -EBADF; |
| |
| inode_lock_nested(backing_inode, I_MUTEX_PARENT); |
| mode = fmi->mode; |
| if (!IS_POSIXACL(backing_inode)) |
| mode &= ~fmi->umask; |
| err = vfs_mkdir(&init_user_ns, backing_inode, backing_path.dentry, mode); |
| if (err) |
| goto out; |
| if (d_really_is_negative(backing_path.dentry) || |
| unlikely(d_unhashed(backing_path.dentry))) { |
| d = lookup_one_len(entry->d_name.name, backing_path.dentry->d_parent, |
| entry->d_name.len); |
| if (IS_ERR(d)) { |
| err = PTR_ERR(d); |
| goto out; |
| } |
| dput(backing_path.dentry); |
| backing_path.dentry = d; |
| } |
| inode = fuse_iget_backing(dir->i_sb, fuse_inode->nodeid, backing_inode); |
| if (IS_ERR(inode)) { |
| err = PTR_ERR(inode); |
| goto out; |
| } |
| d_instantiate(entry, inode); |
| out: |
| inode_unlock(backing_inode); |
| path_put(&backing_path); |
| return err; |
| } |
| |
| void *fuse_mkdir_finalize( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry, umode_t mode) |
| { |
| return NULL; |
| } |
| |
| int fuse_rmdir_initialize( |
| struct fuse_bpf_args *fa, struct fuse_dummy_io *dummy, |
| struct inode *dir, struct dentry *entry) |
| { |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(dir), |
| .opcode = FUSE_RMDIR, |
| .in_numargs = 1, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = entry->d_name.len + 1, |
| .value = entry->d_name.name, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_rmdir_backing( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry) |
| { |
| int err = 0; |
| struct path backing_path = {}; |
| struct dentry *backing_parent_dentry; |
| struct inode *backing_inode; |
| |
| /* TODO Actually deal with changing the backing entry in rmdir */ |
| get_fuse_backing_path(entry, &backing_path); |
| if (!backing_path.dentry) |
| return -EBADF; |
| |
| /* TODO Not sure if we should reverify like overlayfs, or get inode from d_parent */ |
| backing_parent_dentry = dget_parent(backing_path.dentry); |
| backing_inode = d_inode(backing_parent_dentry); |
| |
| inode_lock_nested(backing_inode, I_MUTEX_PARENT); |
| err = vfs_rmdir(&init_user_ns, backing_inode, backing_path.dentry); |
| inode_unlock(backing_inode); |
| |
| dput(backing_parent_dentry); |
| if (!err) |
| d_drop(entry); |
| path_put(&backing_path); |
| return err; |
| } |
| |
| void *fuse_rmdir_finalize( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry) |
| { |
| return NULL; |
| } |
| |
| static int fuse_rename_backing_common( |
| struct inode *olddir, struct dentry *oldent, |
| struct inode *newdir, struct dentry *newent, |
| unsigned int flags) |
| { |
| int err = 0; |
| struct path old_backing_path; |
| struct path new_backing_path; |
| struct dentry *old_backing_dir_dentry; |
| struct dentry *old_backing_dentry; |
| struct dentry *new_backing_dir_dentry; |
| struct dentry *new_backing_dentry; |
| struct dentry *trap = NULL; |
| struct inode *target_inode; |
| struct renamedata rd; |
| |
| //TODO Actually deal with changing anything that isn't a flag |
| get_fuse_backing_path(oldent, &old_backing_path); |
| if (!old_backing_path.dentry) |
| return -EBADF; |
| get_fuse_backing_path(newent, &new_backing_path); |
| if (!new_backing_path.dentry) { |
| /* |
| * TODO A file being moved from a backing path to another |
| * backing path which is not yet instrumented with FUSE-BPF. |
| * This may be slow and should be substituted with something |
| * more clever. |
| */ |
| err = -EXDEV; |
| goto put_old_path; |
| } |
| if (new_backing_path.mnt != old_backing_path.mnt) { |
| err = -EXDEV; |
| goto put_new_path; |
| } |
| old_backing_dentry = old_backing_path.dentry; |
| new_backing_dentry = new_backing_path.dentry; |
| old_backing_dir_dentry = dget_parent(old_backing_dentry); |
| new_backing_dir_dentry = dget_parent(new_backing_dentry); |
| target_inode = d_inode(newent); |
| |
| trap = lock_rename(old_backing_dir_dentry, new_backing_dir_dentry); |
| if (trap == old_backing_dentry) { |
| err = -EINVAL; |
| goto put_parents; |
| } |
| if (trap == new_backing_dentry) { |
| err = -ENOTEMPTY; |
| goto put_parents; |
| } |
| rd = (struct renamedata) { |
| .old_mnt_userns = &init_user_ns, |
| .old_dir = d_inode(old_backing_dir_dentry), |
| .old_dentry = old_backing_dentry, |
| .new_mnt_userns = &init_user_ns, |
| .new_dir = d_inode(new_backing_dir_dentry), |
| .new_dentry = new_backing_dentry, |
| .flags = flags, |
| }; |
| err = vfs_rename(&rd); |
| if (err) |
| goto unlock; |
| if (target_inode) |
| fsstack_copy_attr_all(target_inode, |
| get_fuse_inode(target_inode)->backing_inode); |
| fsstack_copy_attr_all(d_inode(oldent), d_inode(old_backing_dentry)); |
| unlock: |
| unlock_rename(old_backing_dir_dentry, new_backing_dir_dentry); |
| put_parents: |
| dput(new_backing_dir_dentry); |
| dput(old_backing_dir_dentry); |
| put_new_path: |
| path_put(&new_backing_path); |
| put_old_path: |
| path_put(&old_backing_path); |
| return err; |
| } |
| |
| int fuse_rename2_initialize(struct fuse_bpf_args *fa, struct fuse_rename2_in *fri, |
| struct inode *olddir, struct dentry *oldent, |
| struct inode *newdir, struct dentry *newent, |
| unsigned int flags) |
| { |
| *fri = (struct fuse_rename2_in) { |
| .newdir = get_node_id(newdir), |
| .flags = flags, |
| }; |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(olddir), |
| .opcode = FUSE_RENAME2, |
| .in_numargs = 3, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(*fri), |
| .value = fri, |
| }, |
| .in_args[1] = (struct fuse_bpf_in_arg) { |
| .size = oldent->d_name.len + 1, |
| .value = oldent->d_name.name, |
| }, |
| .in_args[2] = (struct fuse_bpf_in_arg) { |
| .size = newent->d_name.len + 1, |
| .value = newent->d_name.name, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_rename2_backing(struct fuse_bpf_args *fa, |
| struct inode *olddir, struct dentry *oldent, |
| struct inode *newdir, struct dentry *newent, |
| unsigned int flags) |
| { |
| const struct fuse_rename2_in *fri = fa->in_args[0].value; |
| |
| /* TODO: deal with changing dirs/ents */ |
| return fuse_rename_backing_common(olddir, oldent, newdir, newent, fri->flags); |
| } |
| |
| void *fuse_rename2_finalize(struct fuse_bpf_args *fa, |
| struct inode *olddir, struct dentry *oldent, |
| struct inode *newdir, struct dentry *newent, |
| unsigned int flags) |
| { |
| return NULL; |
| } |
| |
| int fuse_rename_initialize(struct fuse_bpf_args *fa, struct fuse_rename_in *fri, |
| struct inode *olddir, struct dentry *oldent, |
| struct inode *newdir, struct dentry *newent) |
| { |
| *fri = (struct fuse_rename_in) { |
| .newdir = get_node_id(newdir), |
| }; |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(olddir), |
| .opcode = FUSE_RENAME, |
| .in_numargs = 3, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(*fri), |
| .value = fri, |
| }, |
| .in_args[1] = (struct fuse_bpf_in_arg) { |
| .size = oldent->d_name.len + 1, |
| .value = oldent->d_name.name, |
| }, |
| .in_args[2] = (struct fuse_bpf_in_arg) { |
| .size = newent->d_name.len + 1, |
| .value = newent->d_name.name, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_rename_backing(struct fuse_bpf_args *fa, |
| struct inode *olddir, struct dentry *oldent, |
| struct inode *newdir, struct dentry *newent) |
| { |
| /* TODO: deal with changing dirs/ents */ |
| return fuse_rename_backing_common(olddir, oldent, newdir, newent, 0); |
| } |
| |
| void *fuse_rename_finalize(struct fuse_bpf_args *fa, |
| struct inode *olddir, struct dentry *oldent, |
| struct inode *newdir, struct dentry *newent) |
| { |
| return NULL; |
| } |
| |
| int fuse_unlink_initialize( |
| struct fuse_bpf_args *fa, struct fuse_dummy_io *dummy, |
| struct inode *dir, struct dentry *entry) |
| { |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(dir), |
| .opcode = FUSE_UNLINK, |
| .in_numargs = 1, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = entry->d_name.len + 1, |
| .value = entry->d_name.name, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_unlink_backing( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry) |
| { |
| int err = 0; |
| struct path backing_path = {}; |
| struct dentry *backing_parent_dentry; |
| struct inode *backing_inode; |
| |
| /* TODO Actually deal with changing the backing entry in unlink */ |
| get_fuse_backing_path(entry, &backing_path); |
| if (!backing_path.dentry) |
| return -EBADF; |
| |
| /* TODO Not sure if we should reverify like overlayfs, or get inode from d_parent */ |
| backing_parent_dentry = dget_parent(backing_path.dentry); |
| backing_inode = d_inode(backing_parent_dentry); |
| |
| inode_lock_nested(backing_inode, I_MUTEX_PARENT); |
| err = vfs_unlink(&init_user_ns, backing_inode, backing_path.dentry, NULL); |
| inode_unlock(backing_inode); |
| |
| dput(backing_parent_dentry); |
| if (!err) |
| d_drop(entry); |
| path_put(&backing_path); |
| return err; |
| } |
| |
| void *fuse_unlink_finalize( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry) |
| { |
| return NULL; |
| } |
| |
| int fuse_link_initialize(struct fuse_bpf_args *fa, struct fuse_link_in *fli, |
| struct dentry *entry, struct inode *dir, |
| struct dentry *newent) |
| { |
| struct inode *src_inode = entry->d_inode; |
| |
| *fli = (struct fuse_link_in){ |
| .oldnodeid = get_node_id(src_inode), |
| }; |
| |
| fa->opcode = FUSE_LINK; |
| fa->in_numargs = 2; |
| fa->in_args[0].size = sizeof(*fli); |
| fa->in_args[0].value = fli; |
| fa->in_args[1].size = newent->d_name.len + 1; |
| fa->in_args[1].value = newent->d_name.name; |
| |
| return 0; |
| } |
| |
| int fuse_link_backing(struct fuse_bpf_args *fa, struct dentry *entry, |
| struct inode *dir, struct dentry *newent) |
| { |
| int err = 0; |
| struct path backing_old_path = {}; |
| struct path backing_new_path = {}; |
| struct dentry *backing_dir_dentry; |
| struct inode *fuse_new_inode = NULL; |
| struct fuse_inode *fuse_dir_inode = get_fuse_inode(dir); |
| struct inode *backing_dir_inode = fuse_dir_inode->backing_inode; |
| |
| get_fuse_backing_path(entry, &backing_old_path); |
| if (!backing_old_path.dentry) |
| return -EBADF; |
| |
| get_fuse_backing_path(newent, &backing_new_path); |
| if (!backing_new_path.dentry) { |
| err = -EBADF; |
| goto err_dst_path; |
| } |
| |
| backing_dir_dentry = dget_parent(backing_new_path.dentry); |
| backing_dir_inode = d_inode(backing_dir_dentry); |
| |
| inode_lock_nested(backing_dir_inode, I_MUTEX_PARENT); |
| err = vfs_link(backing_old_path.dentry, &init_user_ns, |
| backing_dir_inode, backing_new_path.dentry, NULL); |
| inode_unlock(backing_dir_inode); |
| if (err) |
| goto out; |
| |
| if (d_really_is_negative(backing_new_path.dentry) || |
| unlikely(d_unhashed(backing_new_path.dentry))) { |
| err = -EINVAL; |
| /** |
| * TODO: overlayfs responds to this situation with a |
| * lookupOneLen. Should we do that too? |
| */ |
| goto out; |
| } |
| |
| fuse_new_inode = fuse_iget_backing(dir->i_sb, fuse_dir_inode->nodeid, backing_dir_inode); |
| if (IS_ERR(fuse_new_inode)) { |
| err = PTR_ERR(fuse_new_inode); |
| goto out; |
| } |
| d_instantiate(newent, fuse_new_inode); |
| |
| out: |
| dput(backing_dir_dentry); |
| path_put(&backing_new_path); |
| err_dst_path: |
| path_put(&backing_old_path); |
| return err; |
| } |
| |
| void *fuse_link_finalize(struct fuse_bpf_args *fa, struct dentry *entry, |
| struct inode *dir, struct dentry *newent) |
| { |
| return NULL; |
| } |
| |
| int fuse_getattr_initialize(struct fuse_bpf_args *fa, struct fuse_getattr_io *fgio, |
| const struct dentry *entry, struct kstat *stat, |
| u32 request_mask, unsigned int flags) |
| { |
| fgio->fgi = (struct fuse_getattr_in) { |
| .getattr_flags = flags, |
| .fh = -1, /* TODO is this OK? */ |
| }; |
| |
| fgio->fao = (struct fuse_attr_out) {0}; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(entry->d_inode), |
| .opcode = FUSE_GETATTR, |
| .in_numargs = 1, |
| .out_numargs = 1, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(fgio->fgi), |
| .value = &fgio->fgi, |
| }, |
| .out_args[0] = (struct fuse_bpf_arg) { |
| .size = sizeof(fgio->fao), |
| .value = &fgio->fao, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| static void fuse_stat_to_attr(struct fuse_conn *fc, struct inode *inode, |
| struct kstat *stat, struct fuse_attr *attr) |
| { |
| unsigned int blkbits; |
| |
| /* see the comment in fuse_change_attributes() */ |
| if (fc->writeback_cache && S_ISREG(inode->i_mode)) { |
| stat->size = i_size_read(inode); |
| stat->mtime.tv_sec = inode->i_mtime.tv_sec; |
| stat->mtime.tv_nsec = inode->i_mtime.tv_nsec; |
| stat->ctime.tv_sec = inode->i_ctime.tv_sec; |
| stat->ctime.tv_nsec = inode->i_ctime.tv_nsec; |
| } |
| |
| attr->ino = stat->ino; |
| attr->mode = (inode->i_mode & S_IFMT) | (stat->mode & 07777); |
| attr->nlink = stat->nlink; |
| attr->uid = from_kuid(fc->user_ns, stat->uid); |
| attr->gid = from_kgid(fc->user_ns, stat->gid); |
| attr->atime = stat->atime.tv_sec; |
| attr->atimensec = stat->atime.tv_nsec; |
| attr->mtime = stat->mtime.tv_sec; |
| attr->mtimensec = stat->mtime.tv_nsec; |
| attr->ctime = stat->ctime.tv_sec; |
| attr->ctimensec = stat->ctime.tv_nsec; |
| attr->size = stat->size; |
| attr->blocks = stat->blocks; |
| |
| if (stat->blksize != 0) |
| blkbits = ilog2(stat->blksize); |
| else |
| blkbits = inode->i_sb->s_blocksize_bits; |
| |
| attr->blksize = 1 << blkbits; |
| } |
| |
| int fuse_getattr_backing(struct fuse_bpf_args *fa, |
| const struct dentry *entry, struct kstat *stat, |
| u32 request_mask, unsigned int flags) |
| { |
| struct path *backing_path = |
| &get_fuse_dentry(entry)->backing_path; |
| struct inode *backing_inode = backing_path->dentry->d_inode; |
| struct fuse_attr_out *fao = fa->out_args[0].value; |
| struct kstat tmp; |
| int err; |
| |
| if (!stat) |
| stat = &tmp; |
| |
| err = vfs_getattr(backing_path, stat, request_mask, flags); |
| |
| if (!err) |
| fuse_stat_to_attr(get_fuse_conn(entry->d_inode), |
| backing_inode, stat, &fao->attr); |
| |
| return err; |
| } |
| |
| void *fuse_getattr_finalize(struct fuse_bpf_args *fa, |
| const struct dentry *entry, struct kstat *stat, |
| u32 request_mask, unsigned int flags) |
| { |
| struct fuse_attr_out *outarg = fa->out_args[0].value; |
| struct inode *inode = entry->d_inode; |
| u64 attr_version = fuse_get_attr_version(get_fuse_mount(inode)->fc); |
| int err = 0; |
| |
| /* TODO: Ensure this doesn't happen if we had an error getting attrs in |
| * backing. |
| */ |
| err = finalize_attr(inode, outarg, attr_version, stat); |
| return ERR_PTR(err); |
| } |
| |
| static void fattr_to_iattr(struct fuse_conn *fc, |
| const struct fuse_setattr_in *arg, |
| struct iattr *iattr) |
| { |
| unsigned int fvalid = arg->valid; |
| |
| if (fvalid & FATTR_MODE) |
| iattr->ia_valid |= ATTR_MODE, iattr->ia_mode = arg->mode; |
| if (fvalid & FATTR_UID) { |
| iattr->ia_valid |= ATTR_UID; |
| iattr->ia_uid = make_kuid(fc->user_ns, arg->uid); |
| } |
| if (fvalid & FATTR_GID) { |
| iattr->ia_valid |= ATTR_GID; |
| iattr->ia_gid = make_kgid(fc->user_ns, arg->gid); |
| } |
| if (fvalid & FATTR_SIZE) |
| iattr->ia_valid |= ATTR_SIZE, iattr->ia_size = arg->size; |
| if (fvalid & FATTR_ATIME) { |
| iattr->ia_valid |= ATTR_ATIME; |
| iattr->ia_atime.tv_sec = arg->atime; |
| iattr->ia_atime.tv_nsec = arg->atimensec; |
| if (!(fvalid & FATTR_ATIME_NOW)) |
| iattr->ia_valid |= ATTR_ATIME_SET; |
| } |
| if (fvalid & FATTR_MTIME) { |
| iattr->ia_valid |= ATTR_MTIME; |
| iattr->ia_mtime.tv_sec = arg->mtime; |
| iattr->ia_mtime.tv_nsec = arg->mtimensec; |
| if (!(fvalid & FATTR_MTIME_NOW)) |
| iattr->ia_valid |= ATTR_MTIME_SET; |
| } |
| if (fvalid & FATTR_CTIME) { |
| iattr->ia_valid |= ATTR_CTIME; |
| iattr->ia_ctime.tv_sec = arg->ctime; |
| iattr->ia_ctime.tv_nsec = arg->ctimensec; |
| } |
| } |
| |
| int fuse_setattr_initialize(struct fuse_bpf_args *fa, struct fuse_setattr_io *fsio, |
| struct dentry *dentry, struct iattr *attr, struct file *file) |
| { |
| struct fuse_conn *fc = get_fuse_conn(dentry->d_inode); |
| |
| *fsio = (struct fuse_setattr_io) {0}; |
| iattr_to_fattr(fc, attr, &fsio->fsi, true); |
| |
| *fa = (struct fuse_bpf_args) { |
| .opcode = FUSE_SETATTR, |
| .nodeid = get_node_id(dentry->d_inode), |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(fsio->fsi), |
| .in_args[0].value = &fsio->fsi, |
| .out_numargs = 1, |
| .out_args[0].size = sizeof(fsio->fao), |
| .out_args[0].value = &fsio->fao, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_setattr_backing(struct fuse_bpf_args *fa, |
| struct dentry *dentry, struct iattr *attr, struct file *file) |
| { |
| struct fuse_conn *fc = get_fuse_conn(dentry->d_inode); |
| const struct fuse_setattr_in *fsi = fa->in_args[0].value; |
| struct iattr new_attr = {0}; |
| struct path *backing_path = &get_fuse_dentry(dentry)->backing_path; |
| int res; |
| |
| fattr_to_iattr(fc, fsi, &new_attr); |
| /* TODO: Some info doesn't get saved by the attr->fattr->attr transition |
| * When we actually allow the bpf to change these, we may have to consider |
| * the extra flags more, or pass more info into the bpf. Until then we can |
| * keep everything except for ATTR_FILE, since we'd need a file on the |
| * lower fs. For what it's worth, neither f2fs nor ext4 make use of that |
| * even if it is present. |
| */ |
| new_attr.ia_valid = attr->ia_valid & ~ATTR_FILE; |
| inode_lock(d_inode(backing_path->dentry)); |
| res = notify_change(&init_user_ns, backing_path->dentry, &new_attr, |
| NULL); |
| inode_unlock(d_inode(backing_path->dentry)); |
| |
| if (res == 0 && (new_attr.ia_valid & ATTR_SIZE)) |
| i_size_write(dentry->d_inode, new_attr.ia_size); |
| return res; |
| } |
| |
| void *fuse_setattr_finalize(struct fuse_bpf_args *fa, |
| struct dentry *dentry, struct iattr *attr, struct file *file) |
| { |
| return NULL; |
| } |
| |
| int fuse_statfs_initialize( |
| struct fuse_bpf_args *fa, struct fuse_statfs_out *fso, |
| struct dentry *dentry, struct kstatfs *buf) |
| { |
| *fso = (struct fuse_statfs_out) {0}; |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(d_inode(dentry)), |
| .opcode = FUSE_STATFS, |
| .out_numargs = 1, |
| .out_numargs = 1, |
| .out_args[0].size = sizeof(fso), |
| .out_args[0].value = fso, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_statfs_backing( |
| struct fuse_bpf_args *fa, |
| struct dentry *dentry, struct kstatfs *buf) |
| { |
| int err = 0; |
| struct path backing_path; |
| struct fuse_statfs_out *fso = fa->out_args[0].value; |
| |
| get_fuse_backing_path(dentry, &backing_path); |
| if (!backing_path.dentry) |
| return -EBADF; |
| err = vfs_statfs(&backing_path, buf); |
| path_put(&backing_path); |
| buf->f_type = FUSE_SUPER_MAGIC; |
| |
| //TODO Provide postfilter opportunity to modify |
| if (!err) |
| convert_statfs_to_fuse(&fso->st, buf); |
| |
| return err; |
| } |
| |
| void *fuse_statfs_finalize( |
| struct fuse_bpf_args *fa, |
| struct dentry *dentry, struct kstatfs *buf) |
| { |
| struct fuse_statfs_out *fso = fa->out_args[0].value; |
| |
| if (!fa->error_in) |
| convert_fuse_statfs(buf, &fso->st); |
| return NULL; |
| } |
| |
| int fuse_get_link_initialize(struct fuse_bpf_args *fa, struct fuse_dummy_io *unused, |
| struct inode *inode, struct dentry *dentry, |
| struct delayed_call *callback, const char **out) |
| { |
| /* |
| * TODO |
| * If we want to handle changing these things, we'll need to copy |
| * the lower fs's data into our own buffer, and provide our own callback |
| * to free that buffer. |
| * |
| * Pre could change the name we're looking at |
| * postfilter can change the name we return |
| * |
| * We ought to only make that buffer if it's been requested, so leaving |
| * this unimplemented for the moment |
| */ |
| *fa = (struct fuse_bpf_args) { |
| .opcode = FUSE_READLINK, |
| .nodeid = get_node_id(inode), |
| .in_numargs = 1, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = dentry->d_name.len + 1, |
| .value = dentry->d_name.name, |
| }, |
| /* |
| * .out_argvar = 1, |
| * .out_numargs = 1, |
| * .out_args[0].size = , |
| * .out_args[0].value = , |
| */ |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_get_link_backing(struct fuse_bpf_args *fa, |
| struct inode *inode, struct dentry *dentry, |
| struct delayed_call *callback, const char **out) |
| { |
| struct path backing_path; |
| |
| if (!dentry) { |
| *out = ERR_PTR(-ECHILD); |
| return PTR_ERR(*out); |
| } |
| |
| get_fuse_backing_path(dentry, &backing_path); |
| if (!backing_path.dentry) { |
| *out = ERR_PTR(-ECHILD); |
| return PTR_ERR(*out); |
| } |
| |
| /* |
| * TODO: If we want to do our own thing, copy the data and then call the |
| * callback |
| */ |
| *out = vfs_get_link(backing_path.dentry, callback); |
| |
| path_put(&backing_path); |
| return 0; |
| } |
| |
| void *fuse_get_link_finalize(struct fuse_bpf_args *fa, |
| struct inode *inode, struct dentry *dentry, |
| struct delayed_call *callback, const char **out) |
| { |
| return NULL; |
| } |
| |
| int fuse_symlink_initialize( |
| struct fuse_bpf_args *fa, struct fuse_dummy_io *unused, |
| struct inode *dir, struct dentry *entry, const char *link, int len) |
| { |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = get_node_id(dir), |
| .opcode = FUSE_SYMLINK, |
| .in_numargs = 2, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = entry->d_name.len + 1, |
| .value = entry->d_name.name, |
| }, |
| .in_args[1] = (struct fuse_bpf_in_arg) { |
| .size = len, |
| .value = link, |
| }, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_symlink_backing( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry, const char *link, int len) |
| { |
| int err = 0; |
| struct fuse_inode *fuse_inode = get_fuse_inode(dir); |
| struct inode *backing_inode = fuse_inode->backing_inode; |
| struct path backing_path = {}; |
| struct inode *inode = NULL; |
| |
| //TODO Actually deal with changing the backing entry in symlink |
| get_fuse_backing_path(entry, &backing_path); |
| if (!backing_path.dentry) |
| return -EBADF; |
| |
| inode_lock_nested(backing_inode, I_MUTEX_PARENT); |
| err = vfs_symlink(&init_user_ns, backing_inode, backing_path.dentry, |
| link); |
| inode_unlock(backing_inode); |
| if (err) |
| goto out; |
| if (d_really_is_negative(backing_path.dentry) || |
| unlikely(d_unhashed(backing_path.dentry))) { |
| err = -EINVAL; |
| /** |
| * TODO: overlayfs responds to this situation with a |
| * lookupOneLen. Should we do that too? |
| */ |
| goto out; |
| } |
| inode = fuse_iget_backing(dir->i_sb, fuse_inode->nodeid, backing_inode); |
| if (IS_ERR(inode)) { |
| err = PTR_ERR(inode); |
| goto out; |
| } |
| d_instantiate(entry, inode); |
| out: |
| path_put(&backing_path); |
| return err; |
| } |
| |
| void *fuse_symlink_finalize( |
| struct fuse_bpf_args *fa, |
| struct inode *dir, struct dentry *entry, const char *link, int len) |
| { |
| return NULL; |
| } |
| |
| int fuse_readdir_initialize(struct fuse_bpf_args *fa, struct fuse_read_io *frio, |
| struct file *file, struct dir_context *ctx, |
| bool *force_again, bool *allow_force, bool is_continued) |
| { |
| struct fuse_file *ff = file->private_data; |
| u8 *page = (u8 *)__get_free_page(GFP_KERNEL); |
| |
| if (!page) |
| return -ENOMEM; |
| |
| *fa = (struct fuse_bpf_args) { |
| .nodeid = ff->nodeid, |
| .opcode = FUSE_READDIR, |
| .in_numargs = 1, |
| .flags = FUSE_BPF_OUT_ARGVAR, |
| .out_numargs = 2, |
| .in_args[0] = (struct fuse_bpf_in_arg) { |
| .size = sizeof(frio->fri), |
| .value = &frio->fri, |
| }, |
| .out_args[0] = (struct fuse_bpf_arg) { |
| .size = sizeof(frio->fro), |
| .value = &frio->fro, |
| }, |
| .out_args[1] = (struct fuse_bpf_arg) { |
| .size = PAGE_SIZE, |
| .value = page, |
| }, |
| }; |
| |
| frio->fri = (struct fuse_read_in) { |
| .fh = ff->fh, |
| .offset = ctx->pos, |
| .size = PAGE_SIZE, |
| }; |
| frio->fro = (struct fuse_read_out) { |
| .again = 0, |
| .offset = 0, |
| }; |
| *force_again = false; |
| *allow_force = true; |
| return 0; |
| } |
| |
| struct extfuse_ctx { |
| struct dir_context ctx; |
| u8 *addr; |
| size_t offset; |
| }; |
| |
| static int filldir(struct dir_context *ctx, const char *name, int namelen, |
| loff_t offset, u64 ino, unsigned int d_type) |
| { |
| struct extfuse_ctx *ec = container_of(ctx, struct extfuse_ctx, ctx); |
| struct fuse_dirent *fd = (struct fuse_dirent *) (ec->addr + ec->offset); |
| |
| if (ec->offset + sizeof(struct fuse_dirent) + namelen > PAGE_SIZE) |
| return -ENOMEM; |
| |
| *fd = (struct fuse_dirent) { |
| .ino = ino, |
| .off = offset, |
| .namelen = namelen, |
| .type = d_type, |
| }; |
| |
| memcpy(fd->name, name, namelen); |
| ec->offset += FUSE_DIRENT_SIZE(fd); |
| |
| return 0; |
| } |
| |
| static int parse_dirfile(char *buf, size_t nbytes, struct dir_context *ctx) |
| { |
| while (nbytes >= FUSE_NAME_OFFSET) { |
| struct fuse_dirent *dirent = (struct fuse_dirent *) buf; |
| size_t reclen = FUSE_DIRENT_SIZE(dirent); |
| |
| if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX) |
| return -EIO; |
| if (reclen > nbytes) |
| break; |
| if (memchr(dirent->name, '/', dirent->namelen) != NULL) |
| return -EIO; |
| |
| ctx->pos = dirent->off; |
| if (!dir_emit(ctx, dirent->name, dirent->namelen, dirent->ino, |
| dirent->type)) |
| break; |
| |
| buf += reclen; |
| nbytes -= reclen; |
| } |
| |
| return 0; |
| } |
| |
| |
| int fuse_readdir_backing(struct fuse_bpf_args *fa, |
| struct file *file, struct dir_context *ctx, |
| bool *force_again, bool *allow_force, bool is_continued) |
| { |
| struct fuse_file *ff = file->private_data; |
| struct file *backing_dir = ff->backing_file; |
| struct fuse_read_out *fro = fa->out_args[0].value; |
| struct extfuse_ctx ec; |
| int err; |
| |
| ec = (struct extfuse_ctx) { |
| .ctx.actor = filldir, |
| .ctx.pos = ctx->pos, |
| .addr = fa->out_args[1].value, |
| }; |
| |
| if (!ec.addr) |
| return -ENOMEM; |
| |
| if (!is_continued) |
| backing_dir->f_pos = file->f_pos; |
| |
| err = iterate_dir(backing_dir, &ec.ctx); |
| if (ec.offset == 0) |
| *allow_force = false; |
| fa->out_args[1].size = ec.offset; |
| |
| fro->offset = ec.ctx.pos; |
| fro->again = false; |
| return err; |
| } |
| |
| void *fuse_readdir_finalize(struct fuse_bpf_args *fa, |
| struct file *file, struct dir_context *ctx, |
| bool *force_again, bool *allow_force, bool is_continued) |
| { |
| struct fuse_read_out *fro = fa->out_args[0].value; |
| struct fuse_file *ff = file->private_data; |
| struct file *backing_dir = ff->backing_file; |
| int err = 0; |
| |
| err = parse_dirfile(fa->out_args[1].value, fa->out_args[1].size, ctx); |
| *force_again = !!fro->again; |
| if (*force_again && !*allow_force) |
| err = -EINVAL; |
| |
| ctx->pos = fro->offset; |
| backing_dir->f_pos = fro->offset; |
| |
| free_page((unsigned long) fa->out_args[1].value); |
| return ERR_PTR(err); |
| } |
| |
| int fuse_access_initialize(struct fuse_bpf_args *fa, struct fuse_access_in *fai, |
| struct inode *inode, int mask) |
| { |
| *fai = (struct fuse_access_in) { |
| .mask = mask, |
| }; |
| |
| *fa = (struct fuse_bpf_args) { |
| .opcode = FUSE_ACCESS, |
| .nodeid = get_node_id(inode), |
| .in_numargs = 1, |
| .in_args[0].size = sizeof(*fai), |
| .in_args[0].value = fai, |
| }; |
| |
| return 0; |
| } |
| |
| int fuse_access_backing(struct fuse_bpf_args *fa, struct inode *inode, int mask) |
| { |
| struct fuse_inode *fi = get_fuse_inode(inode); |
| const struct fuse_access_in *fai = fa->in_args[0].value; |
| |
| return inode_permission(&init_user_ns, fi->backing_inode, fai->mask); |
| } |
| |
| void *fuse_access_finalize(struct fuse_bpf_args *fa, struct inode *inode, int mask) |
| { |
| return NULL; |
| } |
| |
| int __init fuse_bpf_init(void) |
| { |
| fuse_bpf_aio_request_cachep = kmem_cache_create("fuse_bpf_aio_req", |
| sizeof(struct fuse_bpf_aio_req), |
| 0, SLAB_HWCACHE_ALIGN, NULL); |
| if (!fuse_bpf_aio_request_cachep) |
| return -ENOMEM; |
| |
| return 0; |
| } |
| |
| void __exit fuse_bpf_cleanup(void) |
| { |
| kmem_cache_destroy(fuse_bpf_aio_request_cachep); |
| } |
| |
| ssize_t fuse_bpf_simple_request(struct fuse_mount *fm, struct fuse_bpf_args *bpf_args) |
| { |
| int i; |
| ssize_t res; |
| struct fuse_args args = { |
| .nodeid = bpf_args->nodeid, |
| .opcode = bpf_args->opcode, |
| .error_in = bpf_args->error_in, |
| .in_numargs = bpf_args->in_numargs, |
| .out_numargs = bpf_args->out_numargs, |
| .force = !!(bpf_args->flags & FUSE_BPF_FORCE), |
| .out_argvar = !!(bpf_args->flags & FUSE_BPF_OUT_ARGVAR), |
| }; |
| |
| for (i = 0; i < args.in_numargs; ++i) |
| args.in_args[i] = (struct fuse_in_arg) { |
| .size = bpf_args->in_args[i].size, |
| .value = bpf_args->in_args[i].value, |
| }; |
| for (i = 0; i < args.out_numargs; ++i) |
| args.out_args[i] = (struct fuse_arg) { |
| .size = bpf_args->out_args[i].size, |
| .value = bpf_args->out_args[i].value, |
| }; |
| |
| res = fuse_simple_request(fm, &args); |
| |
| *bpf_args = (struct fuse_bpf_args) { |
| .nodeid = args.nodeid, |
| .opcode = args.opcode, |
| .error_in = args.error_in, |
| .in_numargs = args.in_numargs, |
| .out_numargs = args.out_numargs, |
| }; |
| if (args.force) |
| bpf_args->flags |= FUSE_BPF_FORCE; |
| if (args.out_argvar) |
| bpf_args->flags |= FUSE_BPF_OUT_ARGVAR; |
| for (i = 0; i < args.in_numargs; ++i) |
| bpf_args->in_args[i] = (struct fuse_bpf_in_arg) { |
| .size = args.in_args[i].size, |
| .value = args.in_args[i].value, |
| }; |
| for (i = 0; i < args.out_numargs; ++i) |
| bpf_args->out_args[i] = (struct fuse_bpf_arg) { |
| .size = args.out_args[i].size, |
| .value = args.out_args[i].value, |
| }; |
| return res; |
| } |