AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-11-24 01:20:52 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

fuse: split fuse_mount off of fuse_conn

Browse Source 
We want to allow submounts for the same fuse_conn, but with different
superblocks so that each of the submounts has its own device ID.  To do
so, we need to split all mount-specific information off of fuse_conn
into a new fuse_mount structure, so that multiple mounts can share a
single fuse_conn.

We need to take care only to perform connection-level actions once (i.e.
when the fuse_conn and thus the first fuse_mount are established, or
when the last fuse_mount and thus the fuse_conn are destroyed).  For
example, fuse_sb_destroy() must invoke fuse_send_destroy() until the
last superblock is released.

To do so, we keep track of which fuse_mount is the root mount and
perform all fuse_conn-level actions only when this fuse_mount is
involved.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
This commit is contained in:
Max Reitz 2020-05-06 17:44:12 +02:00 committed by Miklos Szeredi
parent 8f622e9497
commit fcee216beb
11 changed files with 527 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
fs/fuse/control.c
View File

@ -164,6 +164,7 @@ static ssize_t fuse_conn_congestion_threshold_write(struct file *file,
{ {
unsigned val; unsigned val;
struct fuse_conn *fc; struct fuse_conn *fc;
struct fuse_mount *fm;
ssize_t ret; ssize_t ret;
ret = fuse_conn_limit_write(file, buf, count, ppos, &val, ret = fuse_conn_limit_write(file, buf, count, ppos, &val,
@ -174,18 +175,27 @@ static ssize_t fuse_conn_congestion_threshold_write(struct file *file,
if (!fc) if (!fc)
goto out; goto out;
down_read(&fc->killsb);
spin_lock(&fc->bg_lock); spin_lock(&fc->bg_lock);
fc->congestion_threshold = val; fc->congestion_threshold = val;
if (fc->sb) {
/*
* Get any fuse_mount belonging to this fuse_conn; s_bdi is
* shared between all of them
*/
if (!list_empty(&fc->mounts)) {
fm = list_first_entry(&fc->mounts, struct fuse_mount, fc_entry);
if (fc->num_background < fc->congestion_threshold) { if (fc->num_background < fc->congestion_threshold) {
clear_bdi_congested(fc->sb->s_bdi, BLK_RW_SYNC); clear_bdi_congested(fm->sb->s_bdi, BLK_RW_SYNC);
clear_bdi_congested(fc->sb->s_bdi, BLK_RW_ASYNC); clear_bdi_congested(fm->sb->s_bdi, BLK_RW_ASYNC);
} else { } else {
set_bdi_congested(fc->sb->s_bdi, BLK_RW_SYNC); set_bdi_congested(fm->sb->s_bdi, BLK_RW_SYNC);
set_bdi_congested(fc->sb->s_bdi, BLK_RW_ASYNC); set_bdi_congested(fm->sb->s_bdi, BLK_RW_ASYNC);
} }
} }
spin_unlock(&fc->bg_lock); spin_unlock(&fc->bg_lock);
up_read(&fc->killsb);
fuse_conn_put(fc); fuse_conn_put(fc);
out: out:
return ret; return ret;

21
fs/fuse/cuse.c
View File

@ -57,6 +57,7 @@
struct cuse_conn { struct cuse_conn {
struct list_head list; /* linked on cuse_conntbl */ struct list_head list; /* linked on cuse_conntbl */
struct fuse_mount fm; /* Dummy mount referencing fc */
struct fuse_conn fc; /* fuse connection */ struct fuse_conn fc; /* fuse connection */
struct cdev *cdev; /* associated character device */ struct cdev *cdev; /* associated character device */
struct device *dev; /* device representing @cdev */ struct device *dev; /* device representing @cdev */
@ -134,7 +135,7 @@ static int cuse_open(struct inode *inode, struct file *file)
* Generic permission check is already done against the chrdev * Generic permission check is already done against the chrdev
* file, proceed to open. * file, proceed to open.
*/ */
rc = fuse_do_open(&cc->fc, 0, file, 0); rc = fuse_do_open(&cc->fm, 0, file, 0);
if (rc) if (rc)
fuse_conn_put(&cc->fc); fuse_conn_put(&cc->fc);
return rc; return rc;
@ -143,10 +144,10 @@ static int cuse_open(struct inode *inode, struct file *file)
static int cuse_release(struct inode *inode, struct file *file) static int cuse_release(struct inode *inode, struct file *file)
{ {
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_conn *fc = ff->fc; struct fuse_mount *fm = ff->fm;
fuse_sync_release(NULL, ff, file->f_flags); fuse_sync_release(NULL, ff, file->f_flags);
fuse_conn_put(fc); fuse_conn_put(fm->fc);
return 0; return 0;
} }
@ -155,7 +156,7 @@ static long cuse_file_ioctl(struct file *file, unsigned int cmd,
unsigned long arg) unsigned long arg)
{ {
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct cuse_conn *cc = fc_to_cc(ff->fc); struct cuse_conn *cc = fc_to_cc(ff->fm->fc);
unsigned int flags = 0; unsigned int flags = 0;
if (cc->unrestricted_ioctl) if (cc->unrestricted_ioctl)
@ -168,7 +169,7 @@ static long cuse_file_compat_ioctl(struct file *file, unsigned int cmd,
unsigned long arg) unsigned long arg)
{ {
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct cuse_conn *cc = fc_to_cc(ff->fc); struct cuse_conn *cc = fc_to_cc(ff->fm->fc);
unsigned int flags = FUSE_IOCTL_COMPAT; unsigned int flags = FUSE_IOCTL_COMPAT;
if (cc->unrestricted_ioctl) if (cc->unrestricted_ioctl)
@ -313,9 +314,10 @@ struct cuse_init_args {
* required data structures for it. Please read the comment at the * required data structures for it. Please read the comment at the
* top of this file for high level overview. * top of this file for high level overview.
*/ */
static void cuse_process_init_reply(struct fuse_conn *fc, static void cuse_process_init_reply(struct fuse_mount *fm,
struct fuse_args *args, int error) struct fuse_args *args, int error)
{ {
struct fuse_conn *fc = fm->fc;
struct cuse_init_args *ia = container_of(args, typeof(*ia), ap.args); struct cuse_init_args *ia = container_of(args, typeof(*ia), ap.args);
struct fuse_args_pages *ap = &ia->ap; struct fuse_args_pages *ap = &ia->ap;
struct cuse_conn *cc = fc_to_cc(fc), *pos; struct cuse_conn *cc = fc_to_cc(fc), *pos;
@ -424,7 +426,7 @@ static int cuse_send_init(struct cuse_conn *cc)
{ {
int rc; int rc;
struct page *page; struct page *page;
struct fuse_conn *fc = &cc->fc; struct fuse_mount *fm = &cc->fm;
struct cuse_init_args *ia; struct cuse_init_args *ia;
struct fuse_args_pages *ap; struct fuse_args_pages *ap;
@ -460,7 +462,7 @@ static int cuse_send_init(struct cuse_conn *cc)
ia->desc.length = ap->args.out_args[1].size; ia->desc.length = ap->args.out_args[1].size;
ap->args.end = cuse_process_init_reply; ap->args.end = cuse_process_init_reply;
rc = fuse_simple_background(fc, &ap->args, GFP_KERNEL); rc = fuse_simple_background(fm, &ap->args, GFP_KERNEL);
if (rc) { if (rc) {
kfree(ia); kfree(ia);
err_free_page: err_free_page:
@ -506,7 +508,8 @@ static int cuse_channel_open(struct inode *inode, struct file *file)
* Limit the cuse channel to requests that can * Limit the cuse channel to requests that can
* be represented in file->f_cred->user_ns. * be represented in file->f_cred->user_ns.
*/ */
fuse_conn_init(&cc->fc, file->f_cred->user_ns, &fuse_dev_fiq_ops, NULL); fuse_conn_init(&cc->fc, &cc->fm, file->f_cred->user_ns,
&fuse_dev_fiq_ops, NULL);
fud = fuse_dev_alloc_install(&cc->fc); fud = fuse_dev_alloc_install(&cc->fc);
if (!fud) { if (!fud) {

10
fs/fuse/dax.c
View File

@ -182,8 +182,8 @@ static int fuse_setup_one_mapping(struct inode *inode, unsigned long start_idx,
struct fuse_dax_mapping *dmap, bool writable, struct fuse_dax_mapping *dmap, bool writable,
bool upgrade) bool upgrade)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_conn_dax *fcd = fc->dax; struct fuse_conn_dax *fcd = fm->fc->dax;
struct fuse_inode *fi = get_fuse_inode(inode); struct fuse_inode *fi = get_fuse_inode(inode);
struct fuse_setupmapping_in inarg; struct fuse_setupmapping_in inarg;
loff_t offset = start_idx << FUSE_DAX_SHIFT; loff_t offset = start_idx << FUSE_DAX_SHIFT;
@ -206,7 +206,7 @@ static int fuse_setup_one_mapping(struct inode *inode, unsigned long start_idx,
args.in_numargs = 1; args.in_numargs = 1;
args.in_args[0].size = sizeof(inarg); args.in_args[0].size = sizeof(inarg);
args.in_args[0].value = &inarg; args.in_args[0].value = &inarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err < 0) if (err < 0)
return err; return err;
dmap->writable = writable; dmap->writable = writable;
@ -234,7 +234,7 @@ static int fuse_send_removemapping(struct inode *inode,
struct fuse_removemapping_one *remove_one) struct fuse_removemapping_one *remove_one)
{ {
struct fuse_inode *fi = get_fuse_inode(inode); struct fuse_inode *fi = get_fuse_inode(inode);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
args.opcode = FUSE_REMOVEMAPPING; args.opcode = FUSE_REMOVEMAPPING;
@ -244,7 +244,7 @@ static int fuse_send_removemapping(struct inode *inode,
args.in_args[0].value = inargp; args.in_args[0].value = inargp;
args.in_args[1].size = inargp->count * sizeof(*remove_one); args.in_args[1].size = inargp->count * sizeof(*remove_one);
args.in_args[1].value = remove_one; args.in_args[1].value = remove_one;
return fuse_simple_request(fc, &args); return fuse_simple_request(fm, &args);
} }
static int dmap_removemapping_list(struct inode *inode, unsigned int num, static int dmap_removemapping_list(struct inode *inode, unsigned int num,

106
fs/fuse/dev.c
View File

@ -40,21 +40,21 @@ static struct fuse_dev *fuse_get_dev(struct file *file)
return READ_ONCE(file->private_data); return READ_ONCE(file->private_data);
} }
static void fuse_request_init(struct fuse_conn *fc, struct fuse_req *req) static void fuse_request_init(struct fuse_mount *fm, struct fuse_req *req)
{ {
INIT_LIST_HEAD(&req->list); INIT_LIST_HEAD(&req->list);
INIT_LIST_HEAD(&req->intr_entry); INIT_LIST_HEAD(&req->intr_entry);
init_waitqueue_head(&req->waitq); init_waitqueue_head(&req->waitq);
refcount_set(&req->count, 1); refcount_set(&req->count, 1);
__set_bit(FR_PENDING, &req->flags); __set_bit(FR_PENDING, &req->flags);
req->fc = fc; req->fm = fm;
} }
static struct fuse_req *fuse_request_alloc(struct fuse_conn *fc, gfp_t flags) static struct fuse_req *fuse_request_alloc(struct fuse_mount *fm, gfp_t flags)
{ {
struct fuse_req *req = kmem_cache_zalloc(fuse_req_cachep, flags); struct fuse_req *req = kmem_cache_zalloc(fuse_req_cachep, flags);
if (req) if (req)
fuse_request_init(fc, req); fuse_request_init(fm, req);
return req; return req;
} }
@ -103,8 +103,9 @@ static void fuse_drop_waiting(struct fuse_conn *fc)
static void fuse_put_request(struct fuse_req *req); static void fuse_put_request(struct fuse_req *req);
static struct fuse_req *fuse_get_req(struct fuse_conn *fc, bool for_background) static struct fuse_req *fuse_get_req(struct fuse_mount *fm, bool for_background)
{ {
struct fuse_conn *fc = fm->fc;
struct fuse_req *req; struct fuse_req *req;
int err; int err;
atomic_inc(&fc->num_waiting); atomic_inc(&fc->num_waiting);
@ -126,7 +127,7 @@ static struct fuse_req *fuse_get_req(struct fuse_conn *fc, bool for_background)
if (fc->conn_error) if (fc->conn_error)
goto out; goto out;
req = fuse_request_alloc(fc, GFP_KERNEL); req = fuse_request_alloc(fm, GFP_KERNEL);
err = -ENOMEM; err = -ENOMEM;
if (!req) { if (!req) {
if (for_background) if (for_background)
@ -156,7 +157,7 @@ static struct fuse_req *fuse_get_req(struct fuse_conn *fc, bool for_background)
static void fuse_put_request(struct fuse_req *req) static void fuse_put_request(struct fuse_req *req)
{ {
struct fuse_conn *fc = req->fc; struct fuse_conn *fc = req->fm->fc;
if (refcount_dec_and_test(&req->count)) { if (refcount_dec_and_test(&req->count)) {
if (test_bit(FR_BACKGROUND, &req->flags)) { if (test_bit(FR_BACKGROUND, &req->flags)) {
@ -278,7 +279,8 @@ static void flush_bg_queue(struct fuse_conn *fc)
*/ */
void fuse_request_end(struct fuse_req *req) void fuse_request_end(struct fuse_req *req)
{ {
struct fuse_conn *fc = req->fc; struct fuse_mount *fm = req->fm;
struct fuse_conn *fc = fm->fc;
struct fuse_iqueue *fiq = &fc->iq; struct fuse_iqueue *fiq = &fc->iq;
if (test_and_set_bit(FR_FINISHED, &req->flags)) if (test_and_set_bit(FR_FINISHED, &req->flags))
@ -313,9 +315,9 @@ void fuse_request_end(struct fuse_req *req)
wake_up(&fc->blocked_waitq); wake_up(&fc->blocked_waitq);
} }
if (fc->num_background == fc->congestion_threshold && fc->sb) { if (fc->num_background == fc->congestion_threshold && fm->sb) {
clear_bdi_congested(fc->sb->s_bdi, BLK_RW_SYNC); clear_bdi_congested(fm->sb->s_bdi, BLK_RW_SYNC);
clear_bdi_congested(fc->sb->s_bdi, BLK_RW_ASYNC); clear_bdi_congested(fm->sb->s_bdi, BLK_RW_ASYNC);
} }
fc->num_background--; fc->num_background--;
fc->active_background--; fc->active_background--;
@ -327,7 +329,7 @@ void fuse_request_end(struct fuse_req *req)
} }
if (test_bit(FR_ASYNC, &req->flags)) if (test_bit(FR_ASYNC, &req->flags))
req->args->end(fc, req->args, req->out.h.error); req->args->end(fm, req->args, req->out.h.error);
put_request: put_request:
fuse_put_request(req); fuse_put_request(req);
} }
@ -335,7 +337,7 @@ EXPORT_SYMBOL_GPL(fuse_request_end);
static int queue_interrupt(struct fuse_req *req) static int queue_interrupt(struct fuse_req *req)
{ {
struct fuse_iqueue *fiq = &req->fc->iq; struct fuse_iqueue *fiq = &req->fm->fc->iq;
spin_lock(&fiq->lock); spin_lock(&fiq->lock);
/* Check for we've sent request to interrupt this req */ /* Check for we've sent request to interrupt this req */
@ -365,7 +367,7 @@ static int queue_interrupt(struct fuse_req *req)
static void request_wait_answer(struct fuse_req *req) static void request_wait_answer(struct fuse_req *req)
{ {
struct fuse_conn *fc = req->fc; struct fuse_conn *fc = req->fm->fc;
struct fuse_iqueue *fiq = &fc->iq; struct fuse_iqueue *fiq = &fc->iq;
int err; int err;
@ -411,7 +413,7 @@ static void request_wait_answer(struct fuse_req *req)
static void __fuse_request_send(struct fuse_req *req) static void __fuse_request_send(struct fuse_req *req)
{ {
struct fuse_iqueue *fiq = &req->fc->iq; struct fuse_iqueue *fiq = &req->fm->fc->iq;
BUG_ON(test_bit(FR_BACKGROUND, &req->flags)); BUG_ON(test_bit(FR_BACKGROUND, &req->flags));
spin_lock(&fiq->lock); spin_lock(&fiq->lock);
@ -466,7 +468,7 @@ static void fuse_adjust_compat(struct fuse_conn *fc, struct fuse_args *args)
static void fuse_force_creds(struct fuse_req *req) static void fuse_force_creds(struct fuse_req *req)
{ {
struct fuse_conn *fc = req->fc; struct fuse_conn *fc = req->fm->fc;
req->in.h.uid = from_kuid_munged(fc->user_ns, current_fsuid()); req->in.h.uid = from_kuid_munged(fc->user_ns, current_fsuid());
req->in.h.gid = from_kgid_munged(fc->user_ns, current_fsgid()); req->in.h.gid = from_kgid_munged(fc->user_ns, current_fsgid());
@ -482,14 +484,15 @@ static void fuse_args_to_req(struct fuse_req *req, struct fuse_args *args)
__set_bit(FR_ASYNC, &req->flags); __set_bit(FR_ASYNC, &req->flags);
} }
ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args) ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args)
{ {
struct fuse_conn *fc = fm->fc;
struct fuse_req *req; struct fuse_req *req;
ssize_t ret; ssize_t ret;
if (args->force) { if (args->force) {
atomic_inc(&fc->num_waiting); atomic_inc(&fc->num_waiting);
req = fuse_request_alloc(fc, GFP_KERNEL | __GFP_NOFAIL); req = fuse_request_alloc(fm, GFP_KERNEL | __GFP_NOFAIL);
if (!args->nocreds) if (!args->nocreds)
fuse_force_creds(req); fuse_force_creds(req);
@ -498,7 +501,7 @@ ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args)
__set_bit(FR_FORCE, &req->flags); __set_bit(FR_FORCE, &req->flags);
} else { } else {
WARN_ON(args->nocreds); WARN_ON(args->nocreds);
req = fuse_get_req(fc, false); req = fuse_get_req(fm, false);
if (IS_ERR(req)) if (IS_ERR(req))
return PTR_ERR(req); return PTR_ERR(req);
} }
@ -522,7 +525,8 @@ ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args)
static bool fuse_request_queue_background(struct fuse_req *req) static bool fuse_request_queue_background(struct fuse_req *req)
{ {
struct fuse_conn *fc = req->fc; struct fuse_mount *fm = req->fm;
struct fuse_conn *fc = fm->fc;
bool queued = false; bool queued = false;
WARN_ON(!test_bit(FR_BACKGROUND, &req->flags)); WARN_ON(!test_bit(FR_BACKGROUND, &req->flags));
@ -536,9 +540,9 @@ static bool fuse_request_queue_background(struct fuse_req *req)
fc->num_background++; fc->num_background++;
if (fc->num_background == fc->max_background) if (fc->num_background == fc->max_background)
fc->blocked = 1; fc->blocked = 1;
if (fc->num_background == fc->congestion_threshold && fc->sb) { if (fc->num_background == fc->congestion_threshold && fm->sb) {
set_bdi_congested(fc->sb->s_bdi, BLK_RW_SYNC); set_bdi_congested(fm->sb->s_bdi, BLK_RW_SYNC);
set_bdi_congested(fc->sb->s_bdi, BLK_RW_ASYNC); set_bdi_congested(fm->sb->s_bdi, BLK_RW_ASYNC);
} }
list_add_tail(&req->list, &fc->bg_queue); list_add_tail(&req->list, &fc->bg_queue);
flush_bg_queue(fc); flush_bg_queue(fc);
@ -549,20 +553,20 @@ static bool fuse_request_queue_background(struct fuse_req *req)
return queued; return queued;
} }
int fuse_simple_background(struct fuse_conn *fc, struct fuse_args *args, int fuse_simple_background(struct fuse_mount *fm, struct fuse_args *args,
gfp_t gfp_flags) gfp_t gfp_flags)
{ {
struct fuse_req *req; struct fuse_req *req;
if (args->force) { if (args->force) {
WARN_ON(!args->nocreds); WARN_ON(!args->nocreds);
req = fuse_request_alloc(fc, gfp_flags); req = fuse_request_alloc(fm, gfp_flags);
if (!req) if (!req)
return -ENOMEM; return -ENOMEM;
__set_bit(FR_BACKGROUND, &req->flags); __set_bit(FR_BACKGROUND, &req->flags);
} else { } else {
WARN_ON(args->nocreds); WARN_ON(args->nocreds);
req = fuse_get_req(fc, true); req = fuse_get_req(fm, true);
if (IS_ERR(req)) if (IS_ERR(req))
return PTR_ERR(req); return PTR_ERR(req);
} }
@ -578,14 +582,14 @@ int fuse_simple_background(struct fuse_conn *fc, struct fuse_args *args,
} }
EXPORT_SYMBOL_GPL(fuse_simple_background); EXPORT_SYMBOL_GPL(fuse_simple_background);
static int fuse_simple_notify_reply(struct fuse_conn *fc, static int fuse_simple_notify_reply(struct fuse_mount *fm,
struct fuse_args *args, u64 unique) struct fuse_args *args, u64 unique)
{ {
struct fuse_req *req; struct fuse_req *req;
struct fuse_iqueue *fiq = &fc->iq; struct fuse_iqueue *fiq = &fm->fc->iq;
int err = 0; int err = 0;
req = fuse_get_req(fc, false); req = fuse_get_req(fm, false);
if (IS_ERR(req)) if (IS_ERR(req))
return PTR_ERR(req); return PTR_ERR(req);
@ -1433,11 +1437,8 @@ static int fuse_notify_inval_inode(struct fuse_conn *fc, unsigned int size,
fuse_copy_finish(cs); fuse_copy_finish(cs);
down_read(&fc->killsb); down_read(&fc->killsb);
err = -ENOENT; err = fuse_reverse_inval_inode(fc, outarg.ino,
if (fc->sb) { outarg.off, outarg.len);
err = fuse_reverse_inval_inode(fc->sb, outarg.ino,
outarg.off, outarg.len);
}
up_read(&fc->killsb); up_read(&fc->killsb);
return err; return err;
@ -1483,9 +1484,7 @@ static int fuse_notify_inval_entry(struct fuse_conn *fc, unsigned int size,
buf[outarg.namelen] = 0; buf[outarg.namelen] = 0;
down_read(&fc->killsb); down_read(&fc->killsb);
err = -ENOENT; err = fuse_reverse_inval_entry(fc, outarg.parent, 0, &name);
if (fc->sb)
err = fuse_reverse_inval_entry(fc->sb, outarg.parent, 0, &name);
up_read(&fc->killsb); up_read(&fc->killsb);
kfree(buf); kfree(buf);
return err; return err;
@ -1533,10 +1532,7 @@ static int fuse_notify_delete(struct fuse_conn *fc, unsigned int size,
buf[outarg.namelen] = 0; buf[outarg.namelen] = 0;
down_read(&fc->killsb); down_read(&fc->killsb);
err = -ENOENT; err = fuse_reverse_inval_entry(fc, outarg.parent, outarg.child, &name);
if (fc->sb)
err = fuse_reverse_inval_entry(fc->sb, outarg.parent,
outarg.child, &name);
up_read(&fc->killsb); up_read(&fc->killsb);
kfree(buf); kfree(buf);
return err; return err;
@ -1578,10 +1574,7 @@ static int fuse_notify_store(struct fuse_conn *fc, unsigned int size,
down_read(&fc->killsb); down_read(&fc->killsb);
err = -ENOENT; err = -ENOENT;
if (!fc->sb) inode = fuse_ilookup(fc, nodeid, NULL);
goto out_up_killsb;
inode = ilookup5(fc->sb, nodeid, fuse_inode_eq, &nodeid);
if (!inode) if (!inode)
goto out_up_killsb; goto out_up_killsb;
@ -1638,7 +1631,7 @@ struct fuse_retrieve_args {
struct fuse_notify_retrieve_in inarg; struct fuse_notify_retrieve_in inarg;
}; };
static void fuse_retrieve_end(struct fuse_conn *fc, struct fuse_args *args, static void fuse_retrieve_end(struct fuse_mount *fm, struct fuse_args *args,
int error) int error)
{ {
struct fuse_retrieve_args *ra = struct fuse_retrieve_args *ra =
@ -1648,7 +1641,7 @@ static void fuse_retrieve_end(struct fuse_conn *fc, struct fuse_args *args,
kfree(ra); kfree(ra);
} }
static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode, static int fuse_retrieve(struct fuse_mount *fm, struct inode *inode,
struct fuse_notify_retrieve_out *outarg) struct fuse_notify_retrieve_out *outarg)
{ {
int err; int err;
@ -1659,6 +1652,7 @@ static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode,
unsigned int offset; unsigned int offset;
size_t total_len = 0; size_t total_len = 0;
unsigned int num_pages; unsigned int num_pages;
struct fuse_conn *fc = fm->fc;
struct fuse_retrieve_args *ra; struct fuse_retrieve_args *ra;
size_t args_size = sizeof(*ra); size_t args_size = sizeof(*ra);
struct fuse_args_pages *ap; struct fuse_args_pages *ap;
@ -1720,9 +1714,9 @@ static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode,
args->in_args[0].value = &ra->inarg; args->in_args[0].value = &ra->inarg;
args->in_args[1].size = total_len; args->in_args[1].size = total_len;
err = fuse_simple_notify_reply(fc, args, outarg->notify_unique); err = fuse_simple_notify_reply(fm, args, outarg->notify_unique);
if (err) if (err)
fuse_retrieve_end(fc, args, err); fuse_retrieve_end(fm, args, err);
return err; return err;
} }
@ -1731,7 +1725,9 @@ static int fuse_notify_retrieve(struct fuse_conn *fc, unsigned int size,
struct fuse_copy_state *cs) struct fuse_copy_state *cs)
{ {
struct fuse_notify_retrieve_out outarg; struct fuse_notify_retrieve_out outarg;
struct fuse_mount *fm;
struct inode *inode; struct inode *inode;
u64 nodeid;
int err; int err;
err = -EINVAL; err = -EINVAL;
@ -1746,14 +1742,12 @@ static int fuse_notify_retrieve(struct fuse_conn *fc, unsigned int size,
down_read(&fc->killsb); down_read(&fc->killsb);
err = -ENOENT; err = -ENOENT;
if (fc->sb) { nodeid = outarg.nodeid;
u64 nodeid = outarg.nodeid;
inode = ilookup5(fc->sb, nodeid, fuse_inode_eq, &nodeid); inode = fuse_ilookup(fc, nodeid, &fm);
if (inode) { if (inode) {
err = fuse_retrieve(fc, inode, &outarg); err = fuse_retrieve(fm, inode, &outarg);
iput(inode); iput(inode);
}
} }
up_read(&fc->killsb); up_read(&fc->killsb);

110
fs/fuse/dir.c
View File

@ -196,7 +196,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
{ {
struct inode *inode; struct inode *inode;
struct dentry *parent; struct dentry *parent;
struct fuse_conn *fc; struct fuse_mount *fm;
struct fuse_inode *fi; struct fuse_inode *fi;
int ret; int ret;
@ -218,19 +218,19 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
if (flags & LOOKUP_RCU) if (flags & LOOKUP_RCU)
goto out; goto out;
fc = get_fuse_conn(inode); fm = get_fuse_mount(inode);
forget = fuse_alloc_forget(); forget = fuse_alloc_forget();
ret = -ENOMEM; ret = -ENOMEM;
if (!forget) if (!forget)
goto out; goto out;
attr_version = fuse_get_attr_version(fc); attr_version = fuse_get_attr_version(fm->fc);
parent = dget_parent(entry); parent = dget_parent(entry);
fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)), fuse_lookup_init(fm->fc, &args, get_node_id(d_inode(parent)),
&entry->d_name, &outarg); &entry->d_name, &outarg);
ret = fuse_simple_request(fc, &args); ret = fuse_simple_request(fm, &args);
dput(parent); dput(parent);
/* Zero nodeid is same as -ENOENT */ /* Zero nodeid is same as -ENOENT */
if (!ret && !outarg.nodeid) if (!ret && !outarg.nodeid)
@ -238,7 +238,8 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
if (!ret) { if (!ret) {
fi = get_fuse_inode(inode); fi = get_fuse_inode(inode);
if (outarg.nodeid != get_node_id(inode)) { if (outarg.nodeid != get_node_id(inode)) {
fuse_queue_forget(fc, forget, outarg.nodeid, 1); fuse_queue_forget(fm->fc, forget,
outarg.nodeid, 1);
goto invalid; goto invalid;
} }
spin_lock(&fi->lock); spin_lock(&fi->lock);
@ -329,7 +330,7 @@ bool fuse_invalid_attr(struct fuse_attr *attr)
int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name, int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
struct fuse_entry_out *outarg, struct inode **inode) struct fuse_entry_out *outarg, struct inode **inode)
{ {
struct fuse_conn *fc = get_fuse_conn_super(sb); struct fuse_mount *fm = get_fuse_mount_super(sb);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_forget_link *forget; struct fuse_forget_link *forget;
u64 attr_version; u64 attr_version;
@ -346,10 +347,10 @@ int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name
if (!forget) if (!forget)
goto out; goto out;
attr_version = fuse_get_attr_version(fc); attr_version = fuse_get_attr_version(fm->fc);
fuse_lookup_init(fc, &args, nodeid, name, outarg); fuse_lookup_init(fm->fc, &args, nodeid, name, outarg);
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
/* Zero nodeid is same as -ENOENT, but with valid timeout */ /* Zero nodeid is same as -ENOENT, but with valid timeout */
if (err || !outarg->nodeid) if (err || !outarg->nodeid)
goto out_put_forget; goto out_put_forget;
@ -365,7 +366,7 @@ int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name
attr_version); attr_version);
err = -ENOMEM; err = -ENOMEM;
if (!*inode) { if (!*inode) {
fuse_queue_forget(fc, forget, outarg->nodeid, 1); fuse_queue_forget(fm->fc, forget, outarg->nodeid, 1);
goto out; goto out;
} }
err = 0; err = 0;
@ -434,7 +435,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry,
{ {
int err; int err;
struct inode *inode; struct inode *inode;
struct fuse_conn *fc = get_fuse_conn(dir); struct fuse_mount *fm = get_fuse_mount(dir);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_forget_link *forget; struct fuse_forget_link *forget;
struct fuse_create_in inarg; struct fuse_create_in inarg;
@ -452,11 +453,11 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry,
goto out_err; goto out_err;
err = -ENOMEM; err = -ENOMEM;
ff = fuse_file_alloc(fc); ff = fuse_file_alloc(fm);
if (!ff) if (!ff)
goto out_put_forget_req; goto out_put_forget_req;
if (!fc->dont_mask) if (!fm->fc->dont_mask)
mode &= ~current_umask(); mode &= ~current_umask();
flags &= ~O_NOCTTY; flags &= ~O_NOCTTY;
@ -477,7 +478,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry,
args.out_args[0].value = &outentry; args.out_args[0].value = &outentry;
args.out_args[1].size = sizeof(outopen); args.out_args[1].size = sizeof(outopen);
args.out_args[1].value = &outopen; args.out_args[1].value = &outopen;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err) if (err)
goto out_free_ff; goto out_free_ff;
@ -494,7 +495,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry,
if (!inode) { if (!inode) {
flags &= ~(O_CREAT | O_EXCL | O_TRUNC); flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
fuse_sync_release(NULL, ff, flags); fuse_sync_release(NULL, ff, flags);
fuse_queue_forget(fc, forget, outentry.nodeid, 1); fuse_queue_forget(fm->fc, forget, outentry.nodeid, 1);
err = -ENOMEM; err = -ENOMEM;
goto out_err; goto out_err;
} }
@ -567,7 +568,7 @@ static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
/* /*
* Code shared between mknod, mkdir, symlink and link * Code shared between mknod, mkdir, symlink and link
*/ */
static int create_new_entry(struct fuse_conn *fc, struct fuse_args *args, static int create_new_entry(struct fuse_mount *fm, struct fuse_args *args,
struct inode *dir, struct dentry *entry, struct inode *dir, struct dentry *entry,
umode_t mode) umode_t mode)
{ {
@ -586,7 +587,7 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_args *args,
args->out_numargs = 1; args->out_numargs = 1;
args->out_args[0].size = sizeof(outarg); args->out_args[0].size = sizeof(outarg);
args->out_args[0].value = &outarg; args->out_args[0].value = &outarg;
err = fuse_simple_request(fc, args); err = fuse_simple_request(fm, args);
if (err) if (err)
goto out_put_forget_req; goto out_put_forget_req;
@ -600,7 +601,7 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_args *args,
inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation, inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
&outarg.attr, entry_attr_timeout(&outarg), 0); &outarg.attr, entry_attr_timeout(&outarg), 0);
if (!inode) { if (!inode) {
fuse_queue_forget(fc, forget, outarg.nodeid, 1); fuse_queue_forget(fm->fc, forget, outarg.nodeid, 1);
return -ENOMEM; return -ENOMEM;
} }
kfree(forget); kfree(forget);
@ -628,10 +629,10 @@ static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
dev_t rdev) dev_t rdev)
{ {
struct fuse_mknod_in inarg; struct fuse_mknod_in inarg;
struct fuse_conn *fc = get_fuse_conn(dir); struct fuse_mount *fm = get_fuse_mount(dir);
FUSE_ARGS(args); FUSE_ARGS(args);
if (!fc->dont_mask) if (!fm->fc->dont_mask)
mode &= ~current_umask(); mode &= ~current_umask();
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
@ -644,7 +645,7 @@ static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
args.in_args[0].value = &inarg; args.in_args[0].value = &inarg;
args.in_args[1].size = entry->d_name.len + 1; args.in_args[1].size = entry->d_name.len + 1;
args.in_args[1].value = entry->d_name.name; args.in_args[1].value = entry->d_name.name;
return create_new_entry(fc, &args, dir, entry, mode); return create_new_entry(fm, &args, dir, entry, mode);
} }
static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode, static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
@ -656,10 +657,10 @@ static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode) static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
{ {
struct fuse_mkdir_in inarg; struct fuse_mkdir_in inarg;
struct fuse_conn *fc = get_fuse_conn(dir); struct fuse_mount *fm = get_fuse_mount(dir);
FUSE_ARGS(args); FUSE_ARGS(args);
if (!fc->dont_mask) if (!fm->fc->dont_mask)
mode &= ~current_umask(); mode &= ~current_umask();
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
@ -671,13 +672,13 @@ static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
args.in_args[0].value = &inarg; args.in_args[0].value = &inarg;
args.in_args[1].size = entry->d_name.len + 1; args.in_args[1].size = entry->d_name.len + 1;
args.in_args[1].value = entry->d_name.name; args.in_args[1].value = entry->d_name.name;
return create_new_entry(fc, &args, dir, entry, S_IFDIR); return create_new_entry(fm, &args, dir, entry, S_IFDIR);
} }
static int fuse_symlink(struct inode *dir, struct dentry *entry, static int fuse_symlink(struct inode *dir, struct dentry *entry,
const char *link) const char *link)
{ {
struct fuse_conn *fc = get_fuse_conn(dir); struct fuse_mount *fm = get_fuse_mount(dir);
unsigned len = strlen(link) + 1; unsigned len = strlen(link) + 1;
FUSE_ARGS(args); FUSE_ARGS(args);
@ -687,7 +688,7 @@ static int fuse_symlink(struct inode *dir, struct dentry *entry,
args.in_args[0].value = entry->d_name.name; args.in_args[0].value = entry->d_name.name;
args.in_args[1].size = len; args.in_args[1].size = len;
args.in_args[1].value = link; args.in_args[1].value = link;
return create_new_entry(fc, &args, dir, entry, S_IFLNK); return create_new_entry(fm, &args, dir, entry, S_IFLNK);
} }
void fuse_update_ctime(struct inode *inode) void fuse_update_ctime(struct inode *inode)
@ -701,7 +702,7 @@ void fuse_update_ctime(struct inode *inode)
static int fuse_unlink(struct inode *dir, struct dentry *entry) static int fuse_unlink(struct inode *dir, struct dentry *entry)
{ {
int err; int err;
struct fuse_conn *fc = get_fuse_conn(dir); struct fuse_mount *fm = get_fuse_mount(dir);
FUSE_ARGS(args); FUSE_ARGS(args);
args.opcode = FUSE_UNLINK; args.opcode = FUSE_UNLINK;
@ -709,13 +710,13 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry)
args.in_numargs = 1; args.in_numargs = 1;
args.in_args[0].size = entry->d_name.len + 1; args.in_args[0].size = entry->d_name.len + 1;
args.in_args[0].value = entry->d_name.name; args.in_args[0].value = entry->d_name.name;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (!err) { if (!err) {
struct inode *inode = d_inode(entry); struct inode *inode = d_inode(entry);
struct fuse_inode *fi = get_fuse_inode(inode); struct fuse_inode *fi = get_fuse_inode(inode);
spin_lock(&fi->lock); spin_lock(&fi->lock);
fi->attr_version = atomic64_inc_return(&fc->attr_version); fi->attr_version = atomic64_inc_return(&fm->fc->attr_version);
/* /*
* If i_nlink == 0 then unlink doesn't make sense, yet this can * If i_nlink == 0 then unlink doesn't make sense, yet this can
* happen if userspace filesystem is careless. It would be * happen if userspace filesystem is careless. It would be
@ -737,7 +738,7 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry)
static int fuse_rmdir(struct inode *dir, struct dentry *entry) static int fuse_rmdir(struct inode *dir, struct dentry *entry)
{ {
int err; int err;
struct fuse_conn *fc = get_fuse_conn(dir); struct fuse_mount *fm = get_fuse_mount(dir);
FUSE_ARGS(args); FUSE_ARGS(args);
args.opcode = FUSE_RMDIR; args.opcode = FUSE_RMDIR;
@ -745,7 +746,7 @@ static int fuse_rmdir(struct inode *dir, struct dentry *entry)
args.in_numargs = 1; args.in_numargs = 1;
args.in_args[0].size = entry->d_name.len + 1; args.in_args[0].size = entry->d_name.len + 1;
args.in_args[0].value = entry->d_name.name; args.in_args[0].value = entry->d_name.name;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (!err) { if (!err) {
clear_nlink(d_inode(entry)); clear_nlink(d_inode(entry));
fuse_dir_changed(dir); fuse_dir_changed(dir);
@ -761,7 +762,7 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
{ {
int err; int err;
struct fuse_rename2_in inarg; struct fuse_rename2_in inarg;
struct fuse_conn *fc = get_fuse_conn(olddir); struct fuse_mount *fm = get_fuse_mount(olddir);
FUSE_ARGS(args); FUSE_ARGS(args);
memset(&inarg, 0, argsize); memset(&inarg, 0, argsize);
@ -776,7 +777,7 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
args.in_args[1].value = oldent->d_name.name; args.in_args[1].value = oldent->d_name.name;
args.in_args[2].size = newent->d_name.len + 1; args.in_args[2].size = newent->d_name.len + 1;
args.in_args[2].value = newent->d_name.name; args.in_args[2].value = newent->d_name.name;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (!err) { if (!err) {
/* ctime changes */ /* ctime changes */
fuse_invalidate_attr(d_inode(oldent)); fuse_invalidate_attr(d_inode(oldent));
@ -847,7 +848,7 @@ static int fuse_link(struct dentry *entry, struct inode *newdir,
int err; int err;
struct fuse_link_in inarg; struct fuse_link_in inarg;
struct inode *inode = d_inode(entry); struct inode *inode = d_inode(entry);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
@ -858,7 +859,7 @@ static int fuse_link(struct dentry *entry, struct inode *newdir,
args.in_args[0].value = &inarg; args.in_args[0].value = &inarg;
args.in_args[1].size = newent->d_name.len + 1; args.in_args[1].size = newent->d_name.len + 1;
args.in_args[1].value = newent->d_name.name; args.in_args[1].value = newent->d_name.name;
err = create_new_entry(fc, &args, newdir, newent, inode->i_mode); err = create_new_entry(fm, &args, newdir, newent, inode->i_mode);
/* Contrary to "normal" filesystems it can happen that link /* Contrary to "normal" filesystems it can happen that link
makes two "logical" inodes point to the same "physical" makes two "logical" inodes point to the same "physical"
inode. We invalidate the attributes of the old one, so it inode. We invalidate the attributes of the old one, so it
@ -869,7 +870,7 @@ static int fuse_link(struct dentry *entry, struct inode *newdir,
struct fuse_inode *fi = get_fuse_inode(inode); struct fuse_inode *fi = get_fuse_inode(inode);
spin_lock(&fi->lock); spin_lock(&fi->lock);
fi->attr_version = atomic64_inc_return(&fc->attr_version); fi->attr_version = atomic64_inc_return(&fm->fc->attr_version);
if (likely(inode->i_nlink < UINT_MAX)) if (likely(inode->i_nlink < UINT_MAX))
inc_nlink(inode); inc_nlink(inode);
spin_unlock(&fi->lock); spin_unlock(&fi->lock);
@ -926,11 +927,11 @@ static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
int err; int err;
struct fuse_getattr_in inarg; struct fuse_getattr_in inarg;
struct fuse_attr_out outarg; struct fuse_attr_out outarg;
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
u64 attr_version; u64 attr_version;
attr_version = fuse_get_attr_version(fc); attr_version = fuse_get_attr_version(fm->fc);
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
memset(&outarg, 0, sizeof(outarg)); memset(&outarg, 0, sizeof(outarg));
@ -949,7 +950,7 @@ static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
args.out_numargs = 1; args.out_numargs = 1;
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (!err) { if (!err) {
if (fuse_invalid_attr(&outarg.attr) || if (fuse_invalid_attr(&outarg.attr) ||
(inode->i_mode ^ outarg.attr.mode) & S_IFMT) { (inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
@ -1002,7 +1003,7 @@ int fuse_update_attributes(struct inode *inode, struct file *file)
STATX_BASIC_STATS & ~STATX_ATIME, 0); STATX_BASIC_STATS & ~STATX_ATIME, 0);
} }
int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid, int fuse_reverse_inval_entry(struct fuse_conn *fc, u64 parent_nodeid,
u64 child_nodeid, struct qstr *name) u64 child_nodeid, struct qstr *name)
{ {
int err = -ENOTDIR; int err = -ENOTDIR;
@ -1010,7 +1011,7 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
struct dentry *dir; struct dentry *dir;
struct dentry *entry; struct dentry *entry;
parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid); parent = fuse_ilookup(fc, parent_nodeid, NULL);
if (!parent) if (!parent)
return -ENOENT; return -ENOENT;
@ -1102,14 +1103,14 @@ int fuse_allow_current_process(struct fuse_conn *fc)
static int fuse_access(struct inode *inode, int mask) static int fuse_access(struct inode *inode, int mask)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_access_in inarg; struct fuse_access_in inarg;
int err; int err;
BUG_ON(mask & MAY_NOT_BLOCK); BUG_ON(mask & MAY_NOT_BLOCK);
if (fc->no_access) if (fm->fc->no_access)
return 0; return 0;
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
@ -1119,9 +1120,9 @@ static int fuse_access(struct inode *inode, int mask)
args.in_numargs = 1; args.in_numargs = 1;
args.in_args[0].size = sizeof(inarg); args.in_args[0].size = sizeof(inarg);
args.in_args[0].value = &inarg; args.in_args[0].value = &inarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err == -ENOSYS) { if (err == -ENOSYS) {
fc->no_access = 1; fm->fc->no_access = 1;
err = 0; err = 0;
} }
return err; return err;
@ -1209,7 +1210,7 @@ static int fuse_permission(struct inode *inode, int mask)
static int fuse_readlink_page(struct inode *inode, struct page *page) static int fuse_readlink_page(struct inode *inode, struct page *page)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_page_desc desc = { .length = PAGE_SIZE - 1 }; struct fuse_page_desc desc = { .length = PAGE_SIZE - 1 };
struct fuse_args_pages ap = { struct fuse_args_pages ap = {
.num_pages = 1, .num_pages = 1,
@ -1226,7 +1227,7 @@ static int fuse_readlink_page(struct inode *inode, struct page *page)
ap.args.page_zeroing = true; ap.args.page_zeroing = true;
ap.args.out_numargs = 1; ap.args.out_numargs = 1;
ap.args.out_args[0].size = desc.length; ap.args.out_args[0].size = desc.length;
res = fuse_simple_request(fc, &ap.args); res = fuse_simple_request(fm, &ap.args);
fuse_invalidate_atime(inode); fuse_invalidate_atime(inode);
@ -1454,7 +1455,7 @@ static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_args *args,
*/ */
int fuse_flush_times(struct inode *inode, struct fuse_file *ff) int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_setattr_in inarg; struct fuse_setattr_in inarg;
struct fuse_attr_out outarg; struct fuse_attr_out outarg;
@ -1465,7 +1466,7 @@ int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
inarg.valid = FATTR_MTIME; inarg.valid = FATTR_MTIME;
inarg.mtime = inode->i_mtime.tv_sec; inarg.mtime = inode->i_mtime.tv_sec;
inarg.mtimensec = inode->i_mtime.tv_nsec; inarg.mtimensec = inode->i_mtime.tv_nsec;
if (fc->minor >= 23) { if (fm->fc->minor >= 23) {
inarg.valid |= FATTR_CTIME; inarg.valid |= FATTR_CTIME;
inarg.ctime = inode->i_ctime.tv_sec; inarg.ctime = inode->i_ctime.tv_sec;
inarg.ctimensec = inode->i_ctime.tv_nsec; inarg.ctimensec = inode->i_ctime.tv_nsec;
@ -1474,9 +1475,9 @@ int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
inarg.valid |= FATTR_FH; inarg.valid |= FATTR_FH;
inarg.fh = ff->fh; inarg.fh = ff->fh;
} }
fuse_setattr_fill(fc, &args, inode, &inarg, &outarg); fuse_setattr_fill(fm->fc, &args, inode, &inarg, &outarg);
return fuse_simple_request(fc, &args); return fuse_simple_request(fm, &args);
} }
/* /*
@ -1491,7 +1492,8 @@ int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
struct file *file) struct file *file)
{ {
struct inode *inode = d_inode(dentry); struct inode *inode = d_inode(dentry);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_conn *fc = fm->fc;
struct fuse_inode *fi = get_fuse_inode(inode); struct fuse_inode *fi = get_fuse_inode(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_setattr_in inarg; struct fuse_setattr_in inarg;
@ -1577,7 +1579,7 @@ int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
inarg.lock_owner = fuse_lock_owner_id(fc, current->files); inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
} }
fuse_setattr_fill(fc, &args, inode, &inarg, &outarg); fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err) { if (err) {
if (err == -EINTR) if (err == -EINTR)
fuse_invalidate_attr(inode); fuse_invalidate_attr(inode);

208
fs/fuse/file.c
View File

@ -32,7 +32,7 @@ static struct page **fuse_pages_alloc(unsigned int npages, gfp_t flags,
return pages; return pages;
} }
static int fuse_send_open(struct fuse_conn *fc, u64 nodeid, struct file *file, static int fuse_send_open(struct fuse_mount *fm, u64 nodeid, struct file *file,
int opcode, struct fuse_open_out *outargp) int opcode, struct fuse_open_out *outargp)
{ {
struct fuse_open_in inarg; struct fuse_open_in inarg;
@ -40,7 +40,7 @@ static int fuse_send_open(struct fuse_conn *fc, u64 nodeid, struct file *file,
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY); inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY);
if (!fc->atomic_o_trunc) if (!fm->fc->atomic_o_trunc)
inarg.flags &= ~O_TRUNC; inarg.flags &= ~O_TRUNC;
args.opcode = opcode; args.opcode = opcode;
args.nodeid = nodeid; args.nodeid = nodeid;
@ -51,7 +51,7 @@ static int fuse_send_open(struct fuse_conn *fc, u64 nodeid, struct file *file,
args.out_args[0].size = sizeof(*outargp); args.out_args[0].size = sizeof(*outargp);
args.out_args[0].value = outargp; args.out_args[0].value = outargp;
return fuse_simple_request(fc, &args); return fuse_simple_request(fm, &args);
} }
struct fuse_release_args { struct fuse_release_args {
@ -60,7 +60,7 @@ struct fuse_release_args {
struct inode *inode; struct inode *inode;
}; };
struct fuse_file *fuse_file_alloc(struct fuse_conn *fc) struct fuse_file *fuse_file_alloc(struct fuse_mount *fm)
{ {
struct fuse_file *ff; struct fuse_file *ff;
@ -68,7 +68,7 @@ struct fuse_file *fuse_file_alloc(struct fuse_conn *fc)
if (unlikely(!ff)) if (unlikely(!ff))
return NULL; return NULL;
ff->fc = fc; ff->fm = fm;
ff->release_args = kzalloc(sizeof(*ff->release_args), ff->release_args = kzalloc(sizeof(*ff->release_args),
GFP_KERNEL_ACCOUNT); GFP_KERNEL_ACCOUNT);
if (!ff->release_args) { if (!ff->release_args) {
@ -82,7 +82,7 @@ struct fuse_file *fuse_file_alloc(struct fuse_conn *fc)
RB_CLEAR_NODE(&ff->polled_node); RB_CLEAR_NODE(&ff->polled_node);
init_waitqueue_head(&ff->poll_wait); init_waitqueue_head(&ff->poll_wait);
ff->kh = atomic64_inc_return(&fc->khctr); ff->kh = atomic64_inc_return(&fm->fc->khctr);
return ff; return ff;
} }
@ -100,7 +100,7 @@ static struct fuse_file *fuse_file_get(struct fuse_file *ff)
return ff; return ff;
} }
static void fuse_release_end(struct fuse_conn *fc, struct fuse_args *args, static void fuse_release_end(struct fuse_mount *fm, struct fuse_args *args,
int error) int error)
{ {
struct fuse_release_args *ra = container_of(args, typeof(*ra), args); struct fuse_release_args *ra = container_of(args, typeof(*ra), args);
@ -114,29 +114,30 @@ static void fuse_file_put(struct fuse_file *ff, bool sync, bool isdir)
if (refcount_dec_and_test(&ff->count)) { if (refcount_dec_and_test(&ff->count)) {
struct fuse_args *args = &ff->release_args->args; struct fuse_args *args = &ff->release_args->args;
if (isdir ? ff->fc->no_opendir : ff->fc->no_open) { if (isdir ? ff->fm->fc->no_opendir : ff->fm->fc->no_open) {
/* Do nothing when client does not implement 'open' */ /* Do nothing when client does not implement 'open' */
fuse_release_end(ff->fc, args, 0); fuse_release_end(ff->fm, args, 0);
} else if (sync) { } else if (sync) {
fuse_simple_request(ff->fc, args); fuse_simple_request(ff->fm, args);
fuse_release_end(ff->fc, args, 0); fuse_release_end(ff->fm, args, 0);
} else { } else {
args->end = fuse_release_end; args->end = fuse_release_end;
if (fuse_simple_background(ff->fc, args, if (fuse_simple_background(ff->fm, args,
GFP_KERNEL | __GFP_NOFAIL)) GFP_KERNEL | __GFP_NOFAIL))
fuse_release_end(ff->fc, args, -ENOTCONN); fuse_release_end(ff->fm, args, -ENOTCONN);
} }
kfree(ff); kfree(ff);
} }
} }
int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file, int fuse_do_open(struct fuse_mount *fm, u64 nodeid, struct file *file,
bool isdir) bool isdir)
{ {
struct fuse_conn *fc = fm->fc;
struct fuse_file *ff; struct fuse_file *ff;
int opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN; int opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN;
ff = fuse_file_alloc(fc); ff = fuse_file_alloc(fm);
if (!ff) if (!ff)
return -ENOMEM; return -ENOMEM;
@ -147,7 +148,7 @@ int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file,
struct fuse_open_out outarg; struct fuse_open_out outarg;
int err; int err;
err = fuse_send_open(fc, nodeid, file, opcode, &outarg); err = fuse_send_open(fm, nodeid, file, opcode, &outarg);
if (!err) { if (!err) {
ff->fh = outarg.fh; ff->fh = outarg.fh;
ff->open_flags = outarg.open_flags; ff->open_flags = outarg.open_flags;
@ -216,7 +217,8 @@ void fuse_finish_open(struct inode *inode, struct file *file)
int fuse_open_common(struct inode *inode, struct file *file, bool isdir) int fuse_open_common(struct inode *inode, struct file *file, bool isdir)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_conn *fc = fm->fc;
int err; int err;
bool is_wb_truncate = (file->f_flags & O_TRUNC) && bool is_wb_truncate = (file->f_flags & O_TRUNC) &&
fc->atomic_o_trunc && fc->atomic_o_trunc &&
@ -240,7 +242,7 @@ int fuse_open_common(struct inode *inode, struct file *file, bool isdir)
goto out; goto out;
} }
err = fuse_do_open(fc, get_node_id(inode), file, isdir); err = fuse_do_open(fm, get_node_id(inode), file, isdir);
if (!err) if (!err)
fuse_finish_open(inode, file); fuse_finish_open(inode, file);
@ -259,7 +261,7 @@ int fuse_open_common(struct inode *inode, struct file *file, bool isdir)
static void fuse_prepare_release(struct fuse_inode *fi, struct fuse_file *ff, static void fuse_prepare_release(struct fuse_inode *fi, struct fuse_file *ff,
int flags, int opcode) int flags, int opcode)
{ {
struct fuse_conn *fc = ff->fc; struct fuse_conn *fc = ff->fm->fc;
struct fuse_release_args *ra = ff->release_args; struct fuse_release_args *ra = ff->release_args;
/* Inode is NULL on error path of fuse_create_open() */ /* Inode is NULL on error path of fuse_create_open() */
@ -297,7 +299,7 @@ void fuse_release_common(struct file *file, bool isdir)
if (ff->flock) { if (ff->flock) {
ra->inarg.release_flags |= FUSE_RELEASE_FLOCK_UNLOCK; ra->inarg.release_flags |= FUSE_RELEASE_FLOCK_UNLOCK;
ra->inarg.lock_owner = fuse_lock_owner_id(ff->fc, ra->inarg.lock_owner = fuse_lock_owner_id(ff->fm->fc,
(fl_owner_t) file); (fl_owner_t) file);
} }
/* Hold inode until release is finished */ /* Hold inode until release is finished */
@ -312,7 +314,7 @@ void fuse_release_common(struct file *file, bool isdir)
* synchronous RELEASE is allowed (and desirable) in this case * synchronous RELEASE is allowed (and desirable) in this case
* because the server can be trusted not to screw up. * because the server can be trusted not to screw up.
*/ */
fuse_file_put(ff, ff->fc->destroy, isdir); fuse_file_put(ff, ff->fm->fc->destroy, isdir);
} }
static int fuse_open(struct inode *inode, struct file *file) static int fuse_open(struct inode *inode, struct file *file)
@ -455,7 +457,7 @@ static void fuse_sync_writes(struct inode *inode)
static int fuse_flush(struct file *file, fl_owner_t id) static int fuse_flush(struct file *file, fl_owner_t id)
{ {
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_flush_in inarg; struct fuse_flush_in inarg;
FUSE_ARGS(args); FUSE_ARGS(args);
@ -477,12 +479,12 @@ static int fuse_flush(struct file *file, fl_owner_t id)
return err; return err;
err = 0; err = 0;
if (fc->no_flush) if (fm->fc->no_flush)
goto inval_attr_out; goto inval_attr_out;
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
inarg.fh = ff->fh; inarg.fh = ff->fh;
inarg.lock_owner = fuse_lock_owner_id(fc, id); inarg.lock_owner = fuse_lock_owner_id(fm->fc, id);
args.opcode = FUSE_FLUSH; args.opcode = FUSE_FLUSH;
args.nodeid = get_node_id(inode); args.nodeid = get_node_id(inode);
args.in_numargs = 1; args.in_numargs = 1;
@ -490,9 +492,9 @@ static int fuse_flush(struct file *file, fl_owner_t id)
args.in_args[0].value = &inarg; args.in_args[0].value = &inarg;
args.force = true; args.force = true;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err == -ENOSYS) { if (err == -ENOSYS) {
fc->no_flush = 1; fm->fc->no_flush = 1;
err = 0; err = 0;
} }
@ -501,7 +503,7 @@ static int fuse_flush(struct file *file, fl_owner_t id)
* In memory i_blocks is not maintained by fuse, if writeback cache is * In memory i_blocks is not maintained by fuse, if writeback cache is
* enabled, i_blocks from cached attr may not be accurate. * enabled, i_blocks from cached attr may not be accurate.
*/ */
if (!err && fc->writeback_cache) if (!err && fm->fc->writeback_cache)
fuse_invalidate_attr(inode); fuse_invalidate_attr(inode);
return err; return err;
} }
@ -510,7 +512,7 @@ int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
int datasync, int opcode) int datasync, int opcode)
{ {
struct inode *inode = file->f_mapping->host; struct inode *inode = file->f_mapping->host;
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_fsync_in inarg; struct fuse_fsync_in inarg;
@ -523,7 +525,7 @@ int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
args.in_numargs = 1; args.in_numargs = 1;
args.in_args[0].size = sizeof(inarg); args.in_args[0].size = sizeof(inarg);
args.in_args[0].value = &inarg; args.in_args[0].value = &inarg;
return fuse_simple_request(fc, &args); return fuse_simple_request(fm, &args);
} }
static int fuse_fsync(struct file *file, loff_t start, loff_t end, static int fuse_fsync(struct file *file, loff_t start, loff_t end,
@ -698,7 +700,7 @@ static void fuse_io_free(struct fuse_io_args *ia)
kfree(ia); kfree(ia);
} }
static void fuse_aio_complete_req(struct fuse_conn *fc, struct fuse_args *args, static void fuse_aio_complete_req(struct fuse_mount *fm, struct fuse_args *args,
int err) int err)
{ {
struct fuse_io_args *ia = container_of(args, typeof(*ia), ap.args); struct fuse_io_args *ia = container_of(args, typeof(*ia), ap.args);
@ -727,7 +729,7 @@ static void fuse_aio_complete_req(struct fuse_conn *fc, struct fuse_args *args,
fuse_io_free(ia); fuse_io_free(ia);
} }
static ssize_t fuse_async_req_send(struct fuse_conn *fc, static ssize_t fuse_async_req_send(struct fuse_mount *fm,
struct fuse_io_args *ia, size_t num_bytes) struct fuse_io_args *ia, size_t num_bytes)
{ {
ssize_t err; ssize_t err;
@ -741,9 +743,9 @@ static ssize_t fuse_async_req_send(struct fuse_conn *fc,
ia->ap.args.end = fuse_aio_complete_req; ia->ap.args.end = fuse_aio_complete_req;
ia->ap.args.may_block = io->should_dirty; ia->ap.args.may_block = io->should_dirty;
err = fuse_simple_background(fc, &ia->ap.args, GFP_KERNEL); err = fuse_simple_background(fm, &ia->ap.args, GFP_KERNEL);
if (err) if (err)
fuse_aio_complete_req(fc, &ia->ap.args, err); fuse_aio_complete_req(fm, &ia->ap.args, err);
return num_bytes; return num_bytes;
} }
@ -753,18 +755,18 @@ static ssize_t fuse_send_read(struct fuse_io_args *ia, loff_t pos, size_t count,
{ {
struct file *file = ia->io->iocb->ki_filp; struct file *file = ia->io->iocb->ki_filp;
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_conn *fc = ff->fc; struct fuse_mount *fm = ff->fm;
fuse_read_args_fill(ia, file, pos, count, FUSE_READ); fuse_read_args_fill(ia, file, pos, count, FUSE_READ);
if (owner != NULL) { if (owner != NULL) {
ia->read.in.read_flags |= FUSE_READ_LOCKOWNER; ia->read.in.read_flags |= FUSE_READ_LOCKOWNER;
ia->read.in.lock_owner = fuse_lock_owner_id(fc, owner); ia->read.in.lock_owner = fuse_lock_owner_id(fm->fc, owner);
} }
if (ia->io->async) if (ia->io->async)
return fuse_async_req_send(fc, ia, count); return fuse_async_req_send(fm, ia, count);
return fuse_simple_request(fc, &ia->ap.args); return fuse_simple_request(fm, &ia->ap.args);
} }
static void fuse_read_update_size(struct inode *inode, loff_t size, static void fuse_read_update_size(struct inode *inode, loff_t size,
@ -810,7 +812,7 @@ static void fuse_short_read(struct inode *inode, u64 attr_ver, size_t num_read,
static int fuse_do_readpage(struct file *file, struct page *page) static int fuse_do_readpage(struct file *file, struct page *page)
{ {
struct inode *inode = page->mapping->host; struct inode *inode = page->mapping->host;
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
loff_t pos = page_offset(page); loff_t pos = page_offset(page);
struct fuse_page_desc desc = { .length = PAGE_SIZE }; struct fuse_page_desc desc = { .length = PAGE_SIZE };
struct fuse_io_args ia = { struct fuse_io_args ia = {
@ -830,14 +832,14 @@ static int fuse_do_readpage(struct file *file, struct page *page)
*/ */
fuse_wait_on_page_writeback(inode, page->index); fuse_wait_on_page_writeback(inode, page->index);
attr_ver = fuse_get_attr_version(fc); attr_ver = fuse_get_attr_version(fm->fc);
/* Don't overflow end offset */ /* Don't overflow end offset */
if (pos + (desc.length - 1) == LLONG_MAX) if (pos + (desc.length - 1) == LLONG_MAX)
desc.length--; desc.length--;
fuse_read_args_fill(&ia, file, pos, desc.length, FUSE_READ); fuse_read_args_fill(&ia, file, pos, desc.length, FUSE_READ);
res = fuse_simple_request(fc, &ia.ap.args); res = fuse_simple_request(fm, &ia.ap.args);
if (res < 0) if (res < 0)
return res; return res;
/* /*
@ -867,7 +869,7 @@ static int fuse_readpage(struct file *file, struct page *page)
return err; return err;
} }
static void fuse_readpages_end(struct fuse_conn *fc, struct fuse_args *args, static void fuse_readpages_end(struct fuse_mount *fm, struct fuse_args *args,
int err) int err)
{ {
int i; int i;
@ -911,7 +913,7 @@ static void fuse_readpages_end(struct fuse_conn *fc, struct fuse_args *args,
static void fuse_send_readpages(struct fuse_io_args *ia, struct file *file) static void fuse_send_readpages(struct fuse_io_args *ia, struct file *file)
{ {
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_conn *fc = ff->fc; struct fuse_mount *fm = ff->fm;
struct fuse_args_pages *ap = &ia->ap; struct fuse_args_pages *ap = &ia->ap;
loff_t pos = page_offset(ap->pages[0]); loff_t pos = page_offset(ap->pages[0]);
size_t count = ap->num_pages << PAGE_SHIFT; size_t count = ap->num_pages << PAGE_SHIFT;
@ -930,18 +932,18 @@ static void fuse_send_readpages(struct fuse_io_args *ia, struct file *file)
WARN_ON((loff_t) (pos + count) < 0); WARN_ON((loff_t) (pos + count) < 0);
fuse_read_args_fill(ia, file, pos, count, FUSE_READ); fuse_read_args_fill(ia, file, pos, count, FUSE_READ);
ia->read.attr_ver = fuse_get_attr_version(fc); ia->read.attr_ver = fuse_get_attr_version(fm->fc);
if (fc->async_read) { if (fm->fc->async_read) {
ia->ff = fuse_file_get(ff); ia->ff = fuse_file_get(ff);
ap->args.end = fuse_readpages_end; ap->args.end = fuse_readpages_end;
err = fuse_simple_background(fc, &ap->args, GFP_KERNEL); err = fuse_simple_background(fm, &ap->args, GFP_KERNEL);
if (!err) if (!err)
return; return;
} else { } else {
res = fuse_simple_request(fc, &ap->args); res = fuse_simple_request(fm, &ap->args);
err = res < 0 ? res : 0; err = res < 0 ? res : 0;
} }
fuse_readpages_end(fc, &ap->args, err); fuse_readpages_end(fm, &ap->args, err);
} }
static void fuse_readahead(struct readahead_control *rac) static void fuse_readahead(struct readahead_control *rac)
@ -1012,7 +1014,7 @@ static void fuse_write_args_fill(struct fuse_io_args *ia, struct fuse_file *ff,
args->opcode = FUSE_WRITE; args->opcode = FUSE_WRITE;
args->nodeid = ff->nodeid; args->nodeid = ff->nodeid;
args->in_numargs = 2; args->in_numargs = 2;
if (ff->fc->minor < 9) if (ff->fm->fc->minor < 9)
args->in_args[0].size = FUSE_COMPAT_WRITE_IN_SIZE; args->in_args[0].size = FUSE_COMPAT_WRITE_IN_SIZE;
else else
args->in_args[0].size = sizeof(ia->write.in); args->in_args[0].size = sizeof(ia->write.in);
@ -1041,7 +1043,7 @@ static ssize_t fuse_send_write(struct fuse_io_args *ia, loff_t pos,
struct kiocb *iocb = ia->io->iocb; struct kiocb *iocb = ia->io->iocb;
struct file *file = iocb->ki_filp; struct file *file = iocb->ki_filp;
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_conn *fc = ff->fc; struct fuse_mount *fm = ff->fm;
struct fuse_write_in *inarg = &ia->write.in; struct fuse_write_in *inarg = &ia->write.in;
ssize_t err; ssize_t err;
@ -1049,13 +1051,13 @@ static ssize_t fuse_send_write(struct fuse_io_args *ia, loff_t pos,
inarg->flags = fuse_write_flags(iocb); inarg->flags = fuse_write_flags(iocb);
if (owner != NULL) { if (owner != NULL) {
inarg->write_flags |= FUSE_WRITE_LOCKOWNER; inarg->write_flags |= FUSE_WRITE_LOCKOWNER;
inarg->lock_owner = fuse_lock_owner_id(fc, owner); inarg->lock_owner = fuse_lock_owner_id(fm->fc, owner);
} }
if (ia->io->async) if (ia->io->async)
return fuse_async_req_send(fc, ia, count); return fuse_async_req_send(fm, ia, count);
err = fuse_simple_request(fc, &ia->ap.args); err = fuse_simple_request(fm, &ia->ap.args);
if (!err && ia->write.out.size > count) if (!err && ia->write.out.size > count)
err = -EIO; err = -EIO;
@ -1086,7 +1088,7 @@ static ssize_t fuse_send_write_pages(struct fuse_io_args *ia,
struct fuse_args_pages *ap = &ia->ap; struct fuse_args_pages *ap = &ia->ap;
struct file *file = iocb->ki_filp; struct file *file = iocb->ki_filp;
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_conn *fc = ff->fc; struct fuse_mount *fm = ff->fm;
unsigned int offset, i; unsigned int offset, i;
int err; int err;
@ -1096,7 +1098,7 @@ static ssize_t fuse_send_write_pages(struct fuse_io_args *ia,
fuse_write_args_fill(ia, ff, pos, count); fuse_write_args_fill(ia, ff, pos, count);
ia->write.in.flags = fuse_write_flags(iocb); ia->write.in.flags = fuse_write_flags(iocb);
err = fuse_simple_request(fc, &ap->args); err = fuse_simple_request(fm, &ap->args);
if (!err && ia->write.out.size > count) if (!err && ia->write.out.size > count)
err = -EIO; err = -EIO;
@ -1411,7 +1413,7 @@ ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
struct file *file = io->iocb->ki_filp; struct file *file = io->iocb->ki_filp;
struct inode *inode = file->f_mapping->host; struct inode *inode = file->f_mapping->host;
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_conn *fc = ff->fc; struct fuse_conn *fc = ff->fm->fc;
size_t nmax = write ? fc->max_write : fc->max_read; size_t nmax = write ? fc->max_write : fc->max_read;
loff_t pos = *ppos; loff_t pos = *ppos;
size_t count = iov_iter_count(iter); size_t count = iov_iter_count(iter);
@ -1598,7 +1600,7 @@ static void fuse_writepage_free(struct fuse_writepage_args *wpa)
kfree(wpa); kfree(wpa);
} }
static void fuse_writepage_finish(struct fuse_conn *fc, static void fuse_writepage_finish(struct fuse_mount *fm,
struct fuse_writepage_args *wpa) struct fuse_writepage_args *wpa)
{ {
struct fuse_args_pages *ap = &wpa->ia.ap; struct fuse_args_pages *ap = &wpa->ia.ap;
@ -1616,7 +1618,7 @@ static void fuse_writepage_finish(struct fuse_conn *fc,
} }
/* Called under fi->lock, may release and reacquire it */ /* Called under fi->lock, may release and reacquire it */
static void fuse_send_writepage(struct fuse_conn *fc, static void fuse_send_writepage(struct fuse_mount *fm,
struct fuse_writepage_args *wpa, loff_t size) struct fuse_writepage_args *wpa, loff_t size)
__releases(fi->lock) __releases(fi->lock)
__acquires(fi->lock) __acquires(fi->lock)
@ -1642,10 +1644,10 @@ __acquires(fi->lock)
args->force = true; args->force = true;
args->nocreds = true; args->nocreds = true;
err = fuse_simple_background(fc, args, GFP_ATOMIC); err = fuse_simple_background(fm, args, GFP_ATOMIC);
if (err == -ENOMEM) { if (err == -ENOMEM) {
spin_unlock(&fi->lock); spin_unlock(&fi->lock);
err = fuse_simple_background(fc, args, GFP_NOFS | __GFP_NOFAIL); err = fuse_simple_background(fm, args, GFP_NOFS | __GFP_NOFAIL);
spin_lock(&fi->lock); spin_lock(&fi->lock);
} }
@ -1658,7 +1660,7 @@ __acquires(fi->lock)
out_free: out_free:
fi->writectr--; fi->writectr--;
rb_erase(&wpa->writepages_entry, &fi->writepages); rb_erase(&wpa->writepages_entry, &fi->writepages);
fuse_writepage_finish(fc, wpa); fuse_writepage_finish(fm, wpa);
spin_unlock(&fi->lock); spin_unlock(&fi->lock);
/* After fuse_writepage_finish() aux request list is private */ /* After fuse_writepage_finish() aux request list is private */
@ -1682,7 +1684,7 @@ void fuse_flush_writepages(struct inode *inode)
__releases(fi->lock) __releases(fi->lock)
__acquires(fi->lock) __acquires(fi->lock)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_inode *fi = get_fuse_inode(inode); struct fuse_inode *fi = get_fuse_inode(inode);
loff_t crop = i_size_read(inode); loff_t crop = i_size_read(inode);
struct fuse_writepage_args *wpa; struct fuse_writepage_args *wpa;
@ -1691,7 +1693,7 @@ __acquires(fi->lock)
wpa = list_entry(fi->queued_writes.next, wpa = list_entry(fi->queued_writes.next,
struct fuse_writepage_args, queue_entry); struct fuse_writepage_args, queue_entry);
list_del_init(&wpa->queue_entry); list_del_init(&wpa->queue_entry);
fuse_send_writepage(fc, wpa, crop); fuse_send_writepage(fm, wpa, crop);
} }
} }
@ -1732,7 +1734,7 @@ static void tree_insert(struct rb_root *root, struct fuse_writepage_args *wpa)
WARN_ON(fuse_insert_writeback(root, wpa)); WARN_ON(fuse_insert_writeback(root, wpa));
} }
static void fuse_writepage_end(struct fuse_conn *fc, struct fuse_args *args, static void fuse_writepage_end(struct fuse_mount *fm, struct fuse_args *args,
int error) int error)
{ {
struct fuse_writepage_args *wpa = struct fuse_writepage_args *wpa =
@ -1744,7 +1746,7 @@ static void fuse_writepage_end(struct fuse_conn *fc, struct fuse_args *args,
spin_lock(&fi->lock); spin_lock(&fi->lock);
rb_erase(&wpa->writepages_entry, &fi->writepages); rb_erase(&wpa->writepages_entry, &fi->writepages);
while (wpa->next) { while (wpa->next) {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_write_in *inarg = &wpa->ia.write.in; struct fuse_write_in *inarg = &wpa->ia.write.in;
struct fuse_writepage_args *next = wpa->next; struct fuse_writepage_args *next = wpa->next;
@ -1776,10 +1778,10 @@ static void fuse_writepage_end(struct fuse_conn *fc, struct fuse_args *args,
* no invocations of fuse_writepage_end() while we're in * no invocations of fuse_writepage_end() while we're in
* fuse_set_nowrite..fuse_release_nowrite section. * fuse_set_nowrite..fuse_release_nowrite section.
*/ */
fuse_send_writepage(fc, next, inarg->offset + inarg->size); fuse_send_writepage(fm, next, inarg->offset + inarg->size);
} }
fi->writectr--; fi->writectr--;
fuse_writepage_finish(fc, wpa); fuse_writepage_finish(fm, wpa);
spin_unlock(&fi->lock); spin_unlock(&fi->lock);
fuse_writepage_free(wpa); fuse_writepage_free(wpa);
} }
@ -2419,7 +2421,7 @@ static void fuse_lk_fill(struct fuse_args *args, struct file *file,
static int fuse_getlk(struct file *file, struct file_lock *fl) static int fuse_getlk(struct file *file, struct file_lock *fl)
{ {
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_lk_in inarg; struct fuse_lk_in inarg;
struct fuse_lk_out outarg; struct fuse_lk_out outarg;
@ -2429,9 +2431,9 @@ static int fuse_getlk(struct file *file, struct file_lock *fl)
args.out_numargs = 1; args.out_numargs = 1;
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (!err) if (!err)
err = convert_fuse_file_lock(fc, &outarg.lk, fl); err = convert_fuse_file_lock(fm->fc, &outarg.lk, fl);
return err; return err;
} }
@ -2439,12 +2441,12 @@ static int fuse_getlk(struct file *file, struct file_lock *fl)
static int fuse_setlk(struct file *file, struct file_lock *fl, int flock) static int fuse_setlk(struct file *file, struct file_lock *fl, int flock)
{ {
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_lk_in inarg; struct fuse_lk_in inarg;
int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK; int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK;
struct pid *pid = fl->fl_type != F_UNLCK ? task_tgid(current) : NULL; struct pid *pid = fl->fl_type != F_UNLCK ? task_tgid(current) : NULL;
pid_t pid_nr = pid_nr_ns(pid, fc->pid_ns); pid_t pid_nr = pid_nr_ns(pid, fm->fc->pid_ns);
int err; int err;
if (fl->fl_lmops && fl->fl_lmops->lm_grant) { if (fl->fl_lmops && fl->fl_lmops->lm_grant) {
@ -2457,7 +2459,7 @@ static int fuse_setlk(struct file *file, struct file_lock *fl, int flock)
return 0; return 0;
fuse_lk_fill(&args, file, fl, opcode, pid_nr, flock, &inarg); fuse_lk_fill(&args, file, fl, opcode, pid_nr, flock, &inarg);
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
/* locking is restartable */ /* locking is restartable */
if (err == -EINTR) if (err == -EINTR)
@ -2511,13 +2513,13 @@ static int fuse_file_flock(struct file *file, int cmd, struct file_lock *fl)
static sector_t fuse_bmap(struct address_space *mapping, sector_t block) static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
{ {
struct inode *inode = mapping->host; struct inode *inode = mapping->host;
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_bmap_in inarg; struct fuse_bmap_in inarg;
struct fuse_bmap_out outarg; struct fuse_bmap_out outarg;
int err; int err;
if (!inode->i_sb->s_bdev || fc->no_bmap) if (!inode->i_sb->s_bdev || fm->fc->no_bmap)
return 0; return 0;
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
@ -2531,9 +2533,9 @@ static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
args.out_numargs = 1; args.out_numargs = 1;
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err == -ENOSYS) if (err == -ENOSYS)
fc->no_bmap = 1; fm->fc->no_bmap = 1;
return err ? 0 : outarg.block; return err ? 0 : outarg.block;
} }
@ -2541,7 +2543,7 @@ static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
static loff_t fuse_lseek(struct file *file, loff_t offset, int whence) static loff_t fuse_lseek(struct file *file, loff_t offset, int whence)
{ {
struct inode *inode = file->f_mapping->host; struct inode *inode = file->f_mapping->host;
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_lseek_in inarg = { struct fuse_lseek_in inarg = {
@ -2552,7 +2554,7 @@ static loff_t fuse_lseek(struct file *file, loff_t offset, int whence)
struct fuse_lseek_out outarg; struct fuse_lseek_out outarg;
int err; int err;
if (fc->no_lseek) if (fm->fc->no_lseek)
goto fallback; goto fallback;
args.opcode = FUSE_LSEEK; args.opcode = FUSE_LSEEK;
@ -2563,10 +2565,10 @@ static loff_t fuse_lseek(struct file *file, loff_t offset, int whence)
args.out_numargs = 1; args.out_numargs = 1;
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err) { if (err) {
if (err == -ENOSYS) { if (err == -ENOSYS) {
fc->no_lseek = 1; fm->fc->no_lseek = 1;
goto fallback; goto fallback;
} }
return err; return err;
@ -2752,7 +2754,7 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
unsigned int flags) unsigned int flags)
{ {
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_conn *fc = ff->fc; struct fuse_mount *fm = ff->fm;
struct fuse_ioctl_in inarg = { struct fuse_ioctl_in inarg = {
.fh = ff->fh, .fh = ff->fh,
.cmd = cmd, .cmd = cmd,
@ -2785,12 +2787,12 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
BUILD_BUG_ON(sizeof(struct fuse_ioctl_iovec) * FUSE_IOCTL_MAX_IOV > PAGE_SIZE); BUILD_BUG_ON(sizeof(struct fuse_ioctl_iovec) * FUSE_IOCTL_MAX_IOV > PAGE_SIZE);
err = -ENOMEM; err = -ENOMEM;
ap.pages = fuse_pages_alloc(fc->max_pages, GFP_KERNEL, &ap.descs); ap.pages = fuse_pages_alloc(fm->fc->max_pages, GFP_KERNEL, &ap.descs);
iov_page = (struct iovec *) __get_free_page(GFP_KERNEL); iov_page = (struct iovec *) __get_free_page(GFP_KERNEL);
if (!ap.pages || !iov_page) if (!ap.pages || !iov_page)
goto out; goto out;
fuse_page_descs_length_init(ap.descs, 0, fc->max_pages); fuse_page_descs_length_init(ap.descs, 0, fm->fc->max_pages);
/* /*
* If restricted, initialize IO parameters as encoded in @cmd. * If restricted, initialize IO parameters as encoded in @cmd.
@ -2835,7 +2837,7 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
/* make sure there are enough buffer pages and init request with them */ /* make sure there are enough buffer pages and init request with them */
err = -ENOMEM; err = -ENOMEM;
if (max_pages > fc->max_pages) if (max_pages > fm->fc->max_pages)
goto out; goto out;
while (ap.num_pages < max_pages) { while (ap.num_pages < max_pages) {
ap.pages[ap.num_pages] = alloc_page(GFP_KERNEL | __GFP_HIGHMEM); ap.pages[ap.num_pages] = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
@ -2872,7 +2874,7 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
ap.args.out_pages = true; ap.args.out_pages = true;
ap.args.out_argvar = true; ap.args.out_argvar = true;
transferred = fuse_simple_request(fc, &ap.args); transferred = fuse_simple_request(fm, &ap.args);
err = transferred; err = transferred;
if (transferred < 0) if (transferred < 0)
goto out; goto out;
@ -2900,7 +2902,7 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
goto out; goto out;
vaddr = kmap_atomic(ap.pages[0]); vaddr = kmap_atomic(ap.pages[0]);
err = fuse_copy_ioctl_iovec(fc, iov_page, vaddr, err = fuse_copy_ioctl_iovec(fm->fc, iov_page, vaddr,
transferred, in_iovs + out_iovs, transferred, in_iovs + out_iovs,
(flags & FUSE_IOCTL_COMPAT) != 0); (flags & FUSE_IOCTL_COMPAT) != 0);
kunmap_atomic(vaddr); kunmap_atomic(vaddr);
@ -2910,11 +2912,11 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
in_iov = iov_page; in_iov = iov_page;
out_iov = in_iov + in_iovs; out_iov = in_iov + in_iovs;
err = fuse_verify_ioctl_iov(fc, in_iov, in_iovs); err = fuse_verify_ioctl_iov(fm->fc, in_iov, in_iovs);
if (err) if (err)
goto out; goto out;
err = fuse_verify_ioctl_iov(fc, out_iov, out_iovs); err = fuse_verify_ioctl_iov(fm->fc, out_iov, out_iovs);
if (err) if (err)
goto out; goto out;
@ -3024,13 +3026,13 @@ static void fuse_register_polled_file(struct fuse_conn *fc,
__poll_t fuse_file_poll(struct file *file, poll_table *wait) __poll_t fuse_file_poll(struct file *file, poll_table *wait)
{ {
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct fuse_conn *fc = ff->fc; struct fuse_mount *fm = ff->fm;
struct fuse_poll_in inarg = { .fh = ff->fh, .kh = ff->kh }; struct fuse_poll_in inarg = { .fh = ff->fh, .kh = ff->kh };
struct fuse_poll_out outarg; struct fuse_poll_out outarg;
FUSE_ARGS(args); FUSE_ARGS(args);
int err; int err;
if (fc->no_poll) if (fm->fc->no_poll)
return DEFAULT_POLLMASK; return DEFAULT_POLLMASK;
poll_wait(file, &ff->poll_wait, wait); poll_wait(file, &ff->poll_wait, wait);
@ -3042,7 +3044,7 @@ __poll_t fuse_file_poll(struct file *file, poll_table *wait)
*/ */
if (waitqueue_active(&ff->poll_wait)) { if (waitqueue_active(&ff->poll_wait)) {
inarg.flags |= FUSE_POLL_SCHEDULE_NOTIFY; inarg.flags |= FUSE_POLL_SCHEDULE_NOTIFY;
fuse_register_polled_file(fc, ff); fuse_register_polled_file(fm->fc, ff);
} }
args.opcode = FUSE_POLL; args.opcode = FUSE_POLL;
@ -3053,12 +3055,12 @@ __poll_t fuse_file_poll(struct file *file, poll_table *wait)
args.out_numargs = 1; args.out_numargs = 1;
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (!err) if (!err)
return demangle_poll(outarg.revents); return demangle_poll(outarg.revents);
if (err == -ENOSYS) { if (err == -ENOSYS) {
fc->no_poll = 1; fm->fc->no_poll = 1;
return DEFAULT_POLLMASK; return DEFAULT_POLLMASK;
} }
return EPOLLERR; return EPOLLERR;
@ -3115,7 +3117,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
ssize_t ret = 0; ssize_t ret = 0;
struct file *file = iocb->ki_filp; struct file *file = iocb->ki_filp;
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
bool async_dio = ff->fc->async_dio; bool async_dio = ff->fm->fc->async_dio;
loff_t pos = 0; loff_t pos = 0;
struct inode *inode; struct inode *inode;
loff_t i_size; loff_t i_size;
@ -3134,7 +3136,8 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
if (async_dio && iov_iter_rw(iter) != WRITE && offset + count > i_size) { if (async_dio && iov_iter_rw(iter) != WRITE && offset + count > i_size) {
if (offset >= i_size) if (offset >= i_size)
return 0; return 0;
iov_iter_truncate(iter, fuse_round_up(ff->fc, i_size - offset)); iov_iter_truncate(iter, fuse_round_up(ff->fm->fc,
i_size - offset));
count = iov_iter_count(iter); count = iov_iter_count(iter);
} }
@ -3221,7 +3224,7 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,
struct fuse_file *ff = file->private_data; struct fuse_file *ff = file->private_data;
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct fuse_inode *fi = get_fuse_inode(inode); struct fuse_inode *fi = get_fuse_inode(inode);
struct fuse_conn *fc = ff->fc; struct fuse_mount *fm = ff->fm;
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_fallocate_in inarg = { struct fuse_fallocate_in inarg = {
.fh = ff->fh, .fh = ff->fh,
@ -3238,7 +3241,7 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,
if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE)) if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (fc->no_fallocate) if (fm->fc->no_fallocate)
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (lock_inode) { if (lock_inode) {
@ -3274,9 +3277,9 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,
args.in_numargs = 1; args.in_numargs = 1;
args.in_args[0].size = sizeof(inarg); args.in_args[0].size = sizeof(inarg);
args.in_args[0].value = &inarg; args.in_args[0].value = &inarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err == -ENOSYS) { if (err == -ENOSYS) {
fc->no_fallocate = 1; fm->fc->no_fallocate = 1;
err = -EOPNOTSUPP; err = -EOPNOTSUPP;
} }
if (err) if (err)
@ -3286,7 +3289,7 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,
if (!(mode & FALLOC_FL_KEEP_SIZE)) { if (!(mode & FALLOC_FL_KEEP_SIZE)) {
bool changed = fuse_write_update_size(inode, offset + length); bool changed = fuse_write_update_size(inode, offset + length);
if (changed && fc->writeback_cache) if (changed && fm->fc->writeback_cache)
file_update_time(file); file_update_time(file);
} }
@ -3317,7 +3320,8 @@ static ssize_t __fuse_copy_file_range(struct file *file_in, loff_t pos_in,
struct inode *inode_in = file_inode(file_in); struct inode *inode_in = file_inode(file_in);
struct inode *inode_out = file_inode(file_out); struct inode *inode_out = file_inode(file_out);
struct fuse_inode *fi_out = get_fuse_inode(inode_out); struct fuse_inode *fi_out = get_fuse_inode(inode_out);
struct fuse_conn *fc = ff_in->fc; struct fuse_mount *fm = ff_in->fm;
struct fuse_conn *fc = fm->fc;
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_copy_file_range_in inarg = { struct fuse_copy_file_range_in inarg = {
.fh_in = ff_in->fh, .fh_in = ff_in->fh,
@ -3386,7 +3390,7 @@ static ssize_t __fuse_copy_file_range(struct file *file_in, loff_t pos_in,
args.out_numargs = 1; args.out_numargs = 1;
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err == -ENOSYS) { if (err == -ENOSYS) {
fc->no_copy_file_range = 1; fc->no_copy_file_range = 1;
err = -EOPNOTSUPP; err = -EOPNOTSUPP;

128
fs/fuse/fuse_i.h
View File

@ -175,12 +175,13 @@ enum {
}; };
struct fuse_conn; struct fuse_conn;
struct fuse_mount;
struct fuse_release_args; struct fuse_release_args;
/** FUSE specific file data */ /** FUSE specific file data */
struct fuse_file { struct fuse_file {
/** Fuse connection for this file */ /** Fuse connection for this file */
struct fuse_conn *fc; struct fuse_mount *fm;
/* Argument space reserved for release */ /* Argument space reserved for release */
struct fuse_release_args *release_args; struct fuse_release_args *release_args;
@ -266,7 +267,7 @@ struct fuse_args {
bool may_block:1; bool may_block:1;
struct fuse_in_arg in_args[3]; struct fuse_in_arg in_args[3];
struct fuse_arg out_args[2]; struct fuse_arg out_args[2];
void (*end)(struct fuse_conn *fc, struct fuse_args *args, int error); void (*end)(struct fuse_mount *fm, struct fuse_args *args, int error);
}; };
struct fuse_args_pages { struct fuse_args_pages {
@ -375,8 +376,8 @@ struct fuse_req {
void *argbuf; void *argbuf;
#endif #endif
/** fuse_conn this request belongs to */ /** fuse_mount this request belongs to */
struct fuse_conn *fc; struct fuse_mount *fm;
}; };
struct fuse_iqueue; struct fuse_iqueue;
@ -515,9 +516,9 @@ struct fuse_fs_context {
/** /**
* A Fuse connection. * A Fuse connection.
* *
* This structure is created, when the filesystem is mounted, and is * This structure is created, when the root filesystem is mounted, and
* destroyed, when the client device is closed and the filesystem is * is destroyed, when the client device is closed and the last
* unmounted. * fuse_mount is destroyed.
*/ */
struct fuse_conn { struct fuse_conn {
/** Lock protecting accessess to members of this structure */ /** Lock protecting accessess to members of this structure */
@ -747,10 +748,10 @@ struct fuse_conn {
/** Negotiated minor version */ /** Negotiated minor version */
unsigned minor; unsigned minor;
/** Entry on the fuse_conn_list */ /** Entry on the fuse_mount_list */
struct list_head entry; struct list_head entry;
/** Device ID from super block */ /** Device ID from the root super block */
dev_t dev; dev_t dev;
/** Dentries in the control filesystem */ /** Dentries in the control filesystem */
@ -768,10 +769,10 @@ struct fuse_conn {
/** Called on final put */ /** Called on final put */
void (*release)(struct fuse_conn *); void (*release)(struct fuse_conn *);
/** Super block for this connection. */ /**
struct super_block *sb; * Read/write semaphore to hold when accessing the sb of any
* fuse_mount belonging to this connection
/** Read/write semaphore to hold when accessing sb. */ */
struct rw_semaphore killsb; struct rw_semaphore killsb;
/** List of device instances belonging to this connection */ /** List of device instances belonging to this connection */
@ -781,16 +782,57 @@ struct fuse_conn {
/* Dax specific conn data, non-NULL if DAX is enabled */ /* Dax specific conn data, non-NULL if DAX is enabled */
struct fuse_conn_dax *dax; struct fuse_conn_dax *dax;
#endif #endif
/** List of filesystems using this connection */
struct list_head mounts;
}; };
static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb) /*
* Represents a mounted filesystem, potentially a submount.
*
* This object allows sharing a fuse_conn between separate mounts to
* allow submounts with dedicated superblocks and thus separate device
* IDs.
*/
struct fuse_mount {
/* Underlying (potentially shared) connection to the FUSE server */
struct fuse_conn *fc;
/* Refcount */
refcount_t count;
/*
* Super block for this connection (fc->killsb must be held when
* accessing this).
*/
struct super_block *sb;
/* Entry on fc->mounts */
struct list_head fc_entry;
};
static inline struct fuse_mount *get_fuse_mount_super(struct super_block *sb)
{ {
return sb->s_fs_info; return sb->s_fs_info;
} }
static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
{
struct fuse_mount *fm = get_fuse_mount_super(sb);
return fm ? fm->fc : NULL;
}
static inline struct fuse_mount *get_fuse_mount(struct inode *inode)
{
return get_fuse_mount_super(inode->i_sb);
}
static inline struct fuse_conn *get_fuse_conn(struct inode *inode) static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
{ {
return get_fuse_conn_super(inode->i_sb); struct fuse_mount *fm = get_fuse_mount(inode);
return fm ? fm->fc : NULL;
} }
static inline struct fuse_inode *get_fuse_inode(struct inode *inode) static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
@ -819,11 +861,6 @@ extern const struct file_operations fuse_dev_operations;
extern const struct dentry_operations fuse_dentry_operations; extern const struct dentry_operations fuse_dentry_operations;
extern const struct dentry_operations fuse_root_dentry_operations; extern const struct dentry_operations fuse_root_dentry_operations;
/**
* Inode to nodeid comparison.
*/
int fuse_inode_eq(struct inode *inode, void *_nodeidp);
/** /**
* Get a filled in inode * Get a filled in inode
*/ */
@ -874,7 +911,7 @@ void fuse_read_args_fill(struct fuse_io_args *ia, struct file *file, loff_t pos,
*/ */
int fuse_open_common(struct inode *inode, struct file *file, bool isdir); int fuse_open_common(struct inode *inode, struct file *file, bool isdir);
struct fuse_file *fuse_file_alloc(struct fuse_conn *fc); struct fuse_file *fuse_file_alloc(struct fuse_mount *fm);
void fuse_file_free(struct fuse_file *ff); void fuse_file_free(struct fuse_file *ff);
void fuse_finish_open(struct inode *inode, struct file *file); void fuse_finish_open(struct inode *inode, struct file *file);
@ -942,8 +979,8 @@ void __exit fuse_ctl_cleanup(void);
/** /**
* Simple request sending that does request allocation and freeing * Simple request sending that does request allocation and freeing
*/ */
ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args); ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args);
int fuse_simple_background(struct fuse_conn *fc, struct fuse_args *args, int fuse_simple_background(struct fuse_mount *fm, struct fuse_args *args,
gfp_t gfp_flags); gfp_t gfp_flags);
/** /**
@ -975,7 +1012,8 @@ struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
/** /**
* Initialize fuse_conn * Initialize fuse_conn
*/ */
void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns, void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm,
struct user_namespace *user_ns,
const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv); const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv);
/** /**
@ -983,11 +1021,21 @@ void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns,
*/ */
void fuse_conn_put(struct fuse_conn *fc); void fuse_conn_put(struct fuse_conn *fc);
/**
* Acquire reference to fuse_mount
*/
struct fuse_mount *fuse_mount_get(struct fuse_mount *fm);
/**
* Release reference to fuse_mount
*/
void fuse_mount_put(struct fuse_mount *fm);
struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc); struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc);
struct fuse_dev *fuse_dev_alloc(void); struct fuse_dev *fuse_dev_alloc(void);
void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc); void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc);
void fuse_dev_free(struct fuse_dev *fud); void fuse_dev_free(struct fuse_dev *fud);
void fuse_send_init(struct fuse_conn *fc); void fuse_send_init(struct fuse_mount *fm);
/** /**
* Fill in superblock and initialize fuse connection * Fill in superblock and initialize fuse connection
@ -996,12 +1044,18 @@ void fuse_send_init(struct fuse_conn *fc);
*/ */
int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx); int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx);
/**
* Disassociate fuse connection from superblock and kill the superblock /*
* Remove the mount from the connection
* *
* Calls kill_anon_super(), do not use with bdev mounts. * Returns whether this was the last mount
*/ */
void fuse_kill_sb_anon(struct super_block *sb); bool fuse_mount_remove(struct fuse_mount *fm);
/*
* Shut down the connection (possibly sending DESTROY request).
*/
void fuse_conn_destroy(struct fuse_mount *fm);
/** /**
* Add connection to control filesystem * Add connection to control filesystem
@ -1036,10 +1090,20 @@ void fuse_flush_writepages(struct inode *inode);
void fuse_set_nowrite(struct inode *inode); void fuse_set_nowrite(struct inode *inode);
void fuse_release_nowrite(struct inode *inode); void fuse_release_nowrite(struct inode *inode);
/**
* Scan all fuse_mounts belonging to fc to find the first where
* ilookup5() returns a result. Return that result and the
* respective fuse_mount in *fm (unless fm is NULL).
*
* The caller must hold fc->killsb.
*/
struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid,
struct fuse_mount **fm);
/** /**
* File-system tells the kernel to invalidate cache for the given node id. * File-system tells the kernel to invalidate cache for the given node id.
*/ */
int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid, int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid,
loff_t offset, loff_t len); loff_t offset, loff_t len);
/** /**
@ -1052,10 +1116,10 @@ int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid,
* - is a file or oan empty directory * - is a file or oan empty directory
* then the dentry is unhashed (d_delete()). * then the dentry is unhashed (d_delete()).
*/ */
int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid, int fuse_reverse_inval_entry(struct fuse_conn *fc, u64 parent_nodeid,
u64 child_nodeid, struct qstr *name); u64 child_nodeid, struct qstr *name);
int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file, int fuse_do_open(struct fuse_mount *fm, u64 nodeid, struct file *file,
bool isdir); bool isdir);
/** /**

172
fs/fuse/inode.c
View File

@ -282,7 +282,7 @@ static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
BUG(); BUG();
} }
int fuse_inode_eq(struct inode *inode, void *_nodeidp) static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
{ {
u64 nodeid = *(u64 *) _nodeidp; u64 nodeid = *(u64 *) _nodeidp;
if (get_node_id(inode) == nodeid) if (get_node_id(inode) == nodeid)
@ -334,16 +334,37 @@ struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
return inode; return inode;
} }
int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid, struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid,
struct fuse_mount **fm)
{
struct fuse_mount *fm_iter;
struct inode *inode;
WARN_ON(!rwsem_is_locked(&fc->killsb));
list_for_each_entry(fm_iter, &fc->mounts, fc_entry) {
if (!fm_iter->sb)
continue;
inode = ilookup5(fm_iter->sb, nodeid, fuse_inode_eq, &nodeid);
if (inode) {
if (fm)
*fm = fm_iter;
return inode;
}
}
return NULL;
}
int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid,
loff_t offset, loff_t len) loff_t offset, loff_t len)
{ {
struct fuse_conn *fc = get_fuse_conn_super(sb);
struct fuse_inode *fi; struct fuse_inode *fi;
struct inode *inode; struct inode *inode;
pgoff_t pg_start; pgoff_t pg_start;
pgoff_t pg_end; pgoff_t pg_end;
inode = ilookup5(sb, nodeid, fuse_inode_eq, &nodeid); inode = fuse_ilookup(fc, nodeid, NULL);
if (!inode) if (!inode)
return -ENOENT; return -ENOENT;
@ -393,28 +414,23 @@ static void fuse_umount_begin(struct super_block *sb)
fuse_abort_conn(fc); fuse_abort_conn(fc);
} }
static void fuse_send_destroy(struct fuse_conn *fc) static void fuse_send_destroy(struct fuse_mount *fm)
{ {
if (fc->conn_init) { if (fm->fc->conn_init) {
FUSE_ARGS(args); FUSE_ARGS(args);
args.opcode = FUSE_DESTROY; args.opcode = FUSE_DESTROY;
args.force = true; args.force = true;
args.nocreds = true; args.nocreds = true;
fuse_simple_request(fc, &args); fuse_simple_request(fm, &args);
} }
} }
static void fuse_put_super(struct super_block *sb) static void fuse_put_super(struct super_block *sb)
{ {
struct fuse_conn *fc = get_fuse_conn_super(sb); struct fuse_mount *fm = get_fuse_mount_super(sb);
mutex_lock(&fuse_mutex); fuse_mount_put(fm);
list_del(&fc->entry);
fuse_ctl_remove_conn(fc);
mutex_unlock(&fuse_mutex);
fuse_conn_put(fc);
} }
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr) static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
@ -434,12 +450,12 @@ static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf) static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
{ {
struct super_block *sb = dentry->d_sb; struct super_block *sb = dentry->d_sb;
struct fuse_conn *fc = get_fuse_conn_super(sb); struct fuse_mount *fm = get_fuse_mount_super(sb);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_statfs_out outarg; struct fuse_statfs_out outarg;
int err; int err;
if (!fuse_allow_current_process(fc)) { if (!fuse_allow_current_process(fm->fc)) {
buf->f_type = FUSE_SUPER_MAGIC; buf->f_type = FUSE_SUPER_MAGIC;
return 0; return 0;
} }
@ -451,7 +467,7 @@ static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
args.out_numargs = 1; args.out_numargs = 1;
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (!err) if (!err)
convert_fuse_statfs(buf, &outarg.st); convert_fuse_statfs(buf, &outarg.st);
return err; return err;
@ -635,7 +651,8 @@ static void fuse_pqueue_init(struct fuse_pqueue *fpq)
fpq->connected = 1; fpq->connected = 1;
} }
void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns, void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm,
struct user_namespace *user_ns,
const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv) const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv)
{ {
memset(fc, 0, sizeof(*fc)); memset(fc, 0, sizeof(*fc));
@ -662,6 +679,11 @@ void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns,
fc->pid_ns = get_pid_ns(task_active_pid_ns(current)); fc->pid_ns = get_pid_ns(task_active_pid_ns(current));
fc->user_ns = get_user_ns(user_ns); fc->user_ns = get_user_ns(user_ns);
fc->max_pages = FUSE_DEFAULT_MAX_PAGES_PER_REQ; fc->max_pages = FUSE_DEFAULT_MAX_PAGES_PER_REQ;
INIT_LIST_HEAD(&fc->mounts);
list_add(&fm->fc_entry, &fc->mounts);
fm->fc = fc;
refcount_set(&fm->count, 1);
} }
EXPORT_SYMBOL_GPL(fuse_conn_init); EXPORT_SYMBOL_GPL(fuse_conn_init);
@ -688,6 +710,23 @@ struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
} }
EXPORT_SYMBOL_GPL(fuse_conn_get); EXPORT_SYMBOL_GPL(fuse_conn_get);
void fuse_mount_put(struct fuse_mount *fm)
{
if (refcount_dec_and_test(&fm->count)) {
if (fm->fc)
fuse_conn_put(fm->fc);
kfree(fm);
}
}
EXPORT_SYMBOL_GPL(fuse_mount_put);
struct fuse_mount *fuse_mount_get(struct fuse_mount *fm)
{
refcount_inc(&fm->count);
return fm;
}
EXPORT_SYMBOL_GPL(fuse_mount_get);
static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode) static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
{ {
struct fuse_attr attr; struct fuse_attr attr;
@ -917,9 +956,10 @@ struct fuse_init_args {
struct fuse_init_out out; struct fuse_init_out out;
}; };
static void process_init_reply(struct fuse_conn *fc, struct fuse_args *args, static void process_init_reply(struct fuse_mount *fm, struct fuse_args *args,
int error) int error)
{ {
struct fuse_conn *fc = fm->fc;
struct fuse_init_args *ia = container_of(args, typeof(*ia), args); struct fuse_init_args *ia = container_of(args, typeof(*ia), args);
struct fuse_init_out *arg = &ia->out; struct fuse_init_out *arg = &ia->out;
bool ok = true; bool ok = true;
@ -973,11 +1013,11 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_args *args,
if (arg->flags & FUSE_HANDLE_KILLPRIV) if (arg->flags & FUSE_HANDLE_KILLPRIV)
fc->handle_killpriv = 1; fc->handle_killpriv = 1;
if (arg->time_gran && arg->time_gran <= 1000000000) if (arg->time_gran && arg->time_gran <= 1000000000)
fc->sb->s_time_gran = arg->time_gran; fm->sb->s_time_gran = arg->time_gran;
if ((arg->flags & FUSE_POSIX_ACL)) { if ((arg->flags & FUSE_POSIX_ACL)) {
fc->default_permissions = 1; fc->default_permissions = 1;
fc->posix_acl = 1; fc->posix_acl = 1;
fc->sb->s_xattr = fuse_acl_xattr_handlers; fm->sb->s_xattr = fuse_acl_xattr_handlers;
} }
if (arg->flags & FUSE_CACHE_SYMLINKS) if (arg->flags & FUSE_CACHE_SYMLINKS)
fc->cache_symlinks = 1; fc->cache_symlinks = 1;
@ -999,8 +1039,8 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_args *args,
fc->no_flock = 1; fc->no_flock = 1;
} }
fc->sb->s_bdi->ra_pages = fm->sb->s_bdi->ra_pages =
min(fc->sb->s_bdi->ra_pages, ra_pages); min(fm->sb->s_bdi->ra_pages, ra_pages);
fc->minor = arg->minor; fc->minor = arg->minor;
fc->max_write = arg->minor < 5 ? 4096 : arg->max_write; fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
fc->max_write = max_t(unsigned, 4096, fc->max_write); fc->max_write = max_t(unsigned, 4096, fc->max_write);
@ -1017,7 +1057,7 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_args *args,
wake_up_all(&fc->blocked_waitq); wake_up_all(&fc->blocked_waitq);
} }
void fuse_send_init(struct fuse_conn *fc) void fuse_send_init(struct fuse_mount *fm)
{ {
struct fuse_init_args *ia; struct fuse_init_args *ia;
@ -1025,7 +1065,7 @@ void fuse_send_init(struct fuse_conn *fc)
ia->in.major = FUSE_KERNEL_VERSION; ia->in.major = FUSE_KERNEL_VERSION;
ia->in.minor = FUSE_KERNEL_MINOR_VERSION; ia->in.minor = FUSE_KERNEL_MINOR_VERSION;
ia->in.max_readahead = fc->sb->s_bdi->ra_pages * PAGE_SIZE; ia->in.max_readahead = fm->sb->s_bdi->ra_pages * PAGE_SIZE;
ia->in.flags |= ia->in.flags |=
FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC | FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK | FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
@ -1037,7 +1077,7 @@ void fuse_send_init(struct fuse_conn *fc)
FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS | FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS |
FUSE_NO_OPENDIR_SUPPORT | FUSE_EXPLICIT_INVAL_DATA; FUSE_NO_OPENDIR_SUPPORT | FUSE_EXPLICIT_INVAL_DATA;
#ifdef CONFIG_FUSE_DAX #ifdef CONFIG_FUSE_DAX
if (fc->dax) if (fm->fc->dax)
ia->in.flags |= FUSE_MAP_ALIGNMENT; ia->in.flags |= FUSE_MAP_ALIGNMENT;
#endif #endif
ia->args.opcode = FUSE_INIT; ia->args.opcode = FUSE_INIT;
@ -1055,8 +1095,8 @@ void fuse_send_init(struct fuse_conn *fc)
ia->args.nocreds = true; ia->args.nocreds = true;
ia->args.end = process_init_reply; ia->args.end = process_init_reply;
if (fuse_simple_background(fc, &ia->args, GFP_KERNEL) != 0) if (fuse_simple_background(fm, &ia->args, GFP_KERNEL) != 0)
process_init_reply(fc, &ia->args, -ENOTCONN); process_init_reply(fm, &ia->args, -ENOTCONN);
} }
EXPORT_SYMBOL_GPL(fuse_send_init); EXPORT_SYMBOL_GPL(fuse_send_init);
@ -1170,7 +1210,8 @@ EXPORT_SYMBOL_GPL(fuse_dev_free);
int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx) int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
{ {
struct fuse_dev *fud = NULL; struct fuse_dev *fud = NULL;
struct fuse_conn *fc = get_fuse_conn_super(sb); struct fuse_mount *fm = get_fuse_mount_super(sb);
struct fuse_conn *fc = fm->fc;
struct inode *root; struct inode *root;
struct dentry *root_dentry; struct dentry *root_dentry;
int err; int err;
@ -1225,7 +1266,7 @@ int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
} }
fc->dev = sb->s_dev; fc->dev = sb->s_dev;
fc->sb = sb; fm->sb = sb;
err = fuse_bdi_init(fc, sb); err = fuse_bdi_init(fc, sb);
if (err) if (err)
goto err_dev_free; goto err_dev_free;
@ -1290,6 +1331,7 @@ static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc)
struct file *file; struct file *file;
int err; int err;
struct fuse_conn *fc; struct fuse_conn *fc;
struct fuse_mount *fm;
err = -EINVAL; err = -EINVAL;
file = fget(ctx->fd); file = fget(ctx->fd);
@ -1310,9 +1352,16 @@ static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc)
if (!fc) if (!fc)
goto err_fput; goto err_fput;
fuse_conn_init(fc, sb->s_user_ns, &fuse_dev_fiq_ops, NULL); fm = kzalloc(sizeof(*fm), GFP_KERNEL);
if (!fm) {
kfree(fc);
goto err_fput;
}
fuse_conn_init(fc, fm, sb->s_user_ns, &fuse_dev_fiq_ops, NULL);
fc->release = fuse_free_conn; fc->release = fuse_free_conn;
sb->s_fs_info = fc;
sb->s_fs_info = fm;
err = fuse_fill_super_common(sb, ctx); err = fuse_fill_super_common(sb, ctx);
if (err) if (err)
@ -1323,11 +1372,11 @@ static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc)
* CPUs after this * CPUs after this
*/ */
fput(file); fput(file);
fuse_send_init(get_fuse_conn_super(sb)); fuse_send_init(get_fuse_mount_super(sb));
return 0; return 0;
err_put_conn: err_put_conn:
fuse_conn_put(fc); fuse_mount_put(fm);
sb->s_fs_info = NULL; sb->s_fs_info = NULL;
err_fput: err_fput:
fput(file); fput(file);
@ -1385,29 +1434,45 @@ static int fuse_init_fs_context(struct fs_context *fc)
return 0; return 0;
} }
static void fuse_sb_destroy(struct super_block *sb) bool fuse_mount_remove(struct fuse_mount *fm)
{ {
struct fuse_conn *fc = get_fuse_conn_super(sb); struct fuse_conn *fc = fm->fc;
bool last = false;
if (fc) { down_write(&fc->killsb);
if (fc->destroy) list_del_init(&fm->fc_entry);
fuse_send_destroy(fc); if (list_empty(&fc->mounts))
last = true;
up_write(&fc->killsb);
fuse_abort_conn(fc); return last;
fuse_wait_aborted(fc);
down_write(&fc->killsb);
fc->sb = NULL;
up_write(&fc->killsb);
}
} }
EXPORT_SYMBOL_GPL(fuse_mount_remove);
void fuse_kill_sb_anon(struct super_block *sb) void fuse_conn_destroy(struct fuse_mount *fm)
{ {
fuse_sb_destroy(sb); struct fuse_conn *fc = fm->fc;
if (fc->destroy)
fuse_send_destroy(fm);
fuse_abort_conn(fc);
fuse_wait_aborted(fc);
}
EXPORT_SYMBOL_GPL(fuse_conn_destroy);
static void fuse_kill_sb_anon(struct super_block *sb)
{
struct fuse_mount *fm = get_fuse_mount_super(sb);
bool last;
if (fm) {
last = fuse_mount_remove(fm);
if (last)
fuse_conn_destroy(fm);
}
kill_anon_super(sb); kill_anon_super(sb);
} }
EXPORT_SYMBOL_GPL(fuse_kill_sb_anon);
static struct file_system_type fuse_fs_type = { static struct file_system_type fuse_fs_type = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
@ -1422,7 +1487,14 @@ MODULE_ALIAS_FS("fuse");
#ifdef CONFIG_BLOCK #ifdef CONFIG_BLOCK
static void fuse_kill_sb_blk(struct super_block *sb) static void fuse_kill_sb_blk(struct super_block *sb)
{ {
fuse_sb_destroy(sb); struct fuse_mount *fm = get_fuse_mount_super(sb);
bool last;
if (fm) {
last = fuse_mount_remove(fm);
if (last)
fuse_conn_destroy(fm);
}
kill_block_super(sb); kill_block_super(sb);
} }

10
fs/fuse/readdir.c
View File

@ -252,7 +252,7 @@ static int fuse_direntplus_link(struct file *file,
static void fuse_force_forget(struct file *file, u64 nodeid) static void fuse_force_forget(struct file *file, u64 nodeid)
{ {
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_forget_in inarg; struct fuse_forget_in inarg;
FUSE_ARGS(args); FUSE_ARGS(args);
@ -266,7 +266,7 @@ static void fuse_force_forget(struct file *file, u64 nodeid)
args.force = true; args.force = true;
args.noreply = true; args.noreply = true;
fuse_simple_request(fc, &args); fuse_simple_request(fm, &args);
/* ignore errors */ /* ignore errors */
} }
@ -320,7 +320,7 @@ static int fuse_readdir_uncached(struct file *file, struct dir_context *ctx)
ssize_t res; ssize_t res;
struct page *page; struct page *page;
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
struct fuse_io_args ia = {}; struct fuse_io_args ia = {};
struct fuse_args_pages *ap = &ia.ap; struct fuse_args_pages *ap = &ia.ap;
struct fuse_page_desc desc = { .length = PAGE_SIZE }; struct fuse_page_desc desc = { .length = PAGE_SIZE };
@ -337,7 +337,7 @@ static int fuse_readdir_uncached(struct file *file, struct dir_context *ctx)
ap->pages = &page; ap->pages = &page;
ap->descs = &desc; ap->descs = &desc;
if (plus) { if (plus) {
attr_version = fuse_get_attr_version(fc); attr_version = fuse_get_attr_version(fm->fc);
fuse_read_args_fill(&ia, file, ctx->pos, PAGE_SIZE, fuse_read_args_fill(&ia, file, ctx->pos, PAGE_SIZE,
FUSE_READDIRPLUS); FUSE_READDIRPLUS);
} else { } else {
@ -345,7 +345,7 @@ static int fuse_readdir_uncached(struct file *file, struct dir_context *ctx)
FUSE_READDIR); FUSE_READDIR);
} }
locked = fuse_lock_inode(inode); locked = fuse_lock_inode(inode);
res = fuse_simple_request(fc, &ap->args); res = fuse_simple_request(fm, &ap->args);
fuse_unlock_inode(inode, locked); fuse_unlock_inode(inode, locked);
if (res >= 0) { if (res >= 0) {
if (!res) { if (!res) {

67
fs/fuse/virtio_fs.c
View File

@ -1270,7 +1270,8 @@ static inline void virtio_fs_ctx_set_defaults(struct fuse_fs_context *ctx)
static int virtio_fs_fill_super(struct super_block *sb, struct fs_context *fsc) static int virtio_fs_fill_super(struct super_block *sb, struct fs_context *fsc)
{ {
struct fuse_conn *fc = get_fuse_conn_super(sb); struct fuse_mount *fm = get_fuse_mount_super(sb);
struct fuse_conn *fc = fm->fc;
struct virtio_fs *fs = fc->iq.priv; struct virtio_fs *fs = fc->iq.priv;
struct fuse_fs_context *ctx = fsc->fs_private; struct fuse_fs_context *ctx = fsc->fs_private;
unsigned int i; unsigned int i;
@ -1315,7 +1316,7 @@ static int virtio_fs_fill_super(struct super_block *sb, struct fs_context *fsc)
/* Previous unmount will stop all queues. Start these again */ /* Previous unmount will stop all queues. Start these again */
virtio_fs_start_all_queues(fs); virtio_fs_start_all_queues(fs);
fuse_send_init(fc); fuse_send_init(fm);
mutex_unlock(&virtio_fs_mutex); mutex_unlock(&virtio_fs_mutex);
return 0; return 0;
@ -1326,21 +1327,14 @@ static int virtio_fs_fill_super(struct super_block *sb, struct fs_context *fsc)
return err; return err;
} }
static void virtio_kill_sb(struct super_block *sb) static void virtio_fs_conn_destroy(struct fuse_mount *fm)
{ {
struct fuse_conn *fc = get_fuse_conn_super(sb); struct fuse_conn *fc = fm->fc;
struct virtio_fs *vfs; struct virtio_fs *vfs = fc->iq.priv;
struct virtio_fs_vq *fsvq; struct virtio_fs_vq *fsvq = &vfs->vqs[VQ_HIPRIO];
/* If mount failed, we can still be called without any fc */ /* Stop dax worker. Soon evict_inodes() will be called which
if (!fc) * will free all memory ranges belonging to all inodes.
return fuse_kill_sb_anon(sb);
vfs = fc->iq.priv;
fsvq = &vfs->vqs[VQ_HIPRIO];
/* Stop dax worker. Soon evict_inodes() will be called which will
* free all memory ranges belonging to all inodes.
*/ */
if (IS_ENABLED(CONFIG_FUSE_DAX)) if (IS_ENABLED(CONFIG_FUSE_DAX))
fuse_dax_cancel_work(fc); fuse_dax_cancel_work(fc);
@ -1351,9 +1345,9 @@ static void virtio_kill_sb(struct super_block *sb)
spin_unlock(&fsvq->lock); spin_unlock(&fsvq->lock);
virtio_fs_drain_all_queues(vfs); virtio_fs_drain_all_queues(vfs);
fuse_kill_sb_anon(sb); fuse_conn_destroy(fm);
/* fuse_kill_sb_anon() must have sent destroy. Stop all queues /* fuse_conn_destroy() must have sent destroy. Stop all queues
* and drain one more time and free fuse devices. Freeing fuse * and drain one more time and free fuse devices. Freeing fuse
* devices will drop their reference on fuse_conn and that in * devices will drop their reference on fuse_conn and that in
* turn will drop its reference on virtio_fs object. * turn will drop its reference on virtio_fs object.
@ -1363,12 +1357,27 @@ static void virtio_kill_sb(struct super_block *sb)
virtio_fs_free_devs(vfs); virtio_fs_free_devs(vfs);
} }
static void virtio_kill_sb(struct super_block *sb)
{
struct fuse_mount *fm = get_fuse_mount_super(sb);
bool last;
/* If mount failed, we can still be called without any fc */
if (fm) {
last = fuse_mount_remove(fm);
if (last)
virtio_fs_conn_destroy(fm);
}
kill_anon_super(sb);
}
static int virtio_fs_test_super(struct super_block *sb, static int virtio_fs_test_super(struct super_block *sb,
struct fs_context *fsc) struct fs_context *fsc)
{ {
struct fuse_conn *fc = fsc->s_fs_info; struct fuse_mount *fsc_fm = fsc->s_fs_info;
struct fuse_mount *sb_fm = get_fuse_mount_super(sb);
return fc->iq.priv == get_fuse_conn_super(sb)->iq.priv; return fsc_fm->fc->iq.priv == sb_fm->fc->iq.priv;
} }
static int virtio_fs_set_super(struct super_block *sb, static int virtio_fs_set_super(struct super_block *sb,
@ -1378,7 +1387,7 @@ static int virtio_fs_set_super(struct super_block *sb,
err = get_anon_bdev(&sb->s_dev); err = get_anon_bdev(&sb->s_dev);
if (!err) if (!err)
fuse_conn_get(fsc->s_fs_info); fuse_mount_get(fsc->s_fs_info);
return err; return err;
} }
@ -1388,6 +1397,7 @@ static int virtio_fs_get_tree(struct fs_context *fsc)
struct virtio_fs *fs; struct virtio_fs *fs;
struct super_block *sb; struct super_block *sb;
struct fuse_conn *fc; struct fuse_conn *fc;
struct fuse_mount *fm;
int err; int err;
/* This gets a reference on virtio_fs object. This ptr gets installed /* This gets a reference on virtio_fs object. This ptr gets installed
@ -1408,14 +1418,23 @@ static int virtio_fs_get_tree(struct fs_context *fsc)
return -ENOMEM; return -ENOMEM;
} }
fuse_conn_init(fc, get_user_ns(current_user_ns()), &virtio_fs_fiq_ops, fm = kzalloc(sizeof(struct fuse_mount), GFP_KERNEL);
fs); if (!fm) {
mutex_lock(&virtio_fs_mutex);
virtio_fs_put(fs);
mutex_unlock(&virtio_fs_mutex);
kfree(fc);
return -ENOMEM;
}
fuse_conn_init(fc, fm, get_user_ns(current_user_ns()),
&virtio_fs_fiq_ops, fs);
fc->release = fuse_free_conn; fc->release = fuse_free_conn;
fc->delete_stale = true; fc->delete_stale = true;
fsc->s_fs_info = fc; fsc->s_fs_info = fm;
sb = sget_fc(fsc, virtio_fs_test_super, virtio_fs_set_super); sb = sget_fc(fsc, virtio_fs_test_super, virtio_fs_set_super);
fuse_conn_put(fc); fuse_mount_put(fm);
if (IS_ERR(sb)) if (IS_ERR(sb))
return PTR_ERR(sb); return PTR_ERR(sb);

34
fs/fuse/xattr.c
View File

@ -14,12 +14,12 @@
int fuse_setxattr(struct inode *inode, const char *name, const void *value, int fuse_setxattr(struct inode *inode, const char *name, const void *value,
size_t size, int flags) size_t size, int flags)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_setxattr_in inarg; struct fuse_setxattr_in inarg;
int err; int err;
if (fc->no_setxattr) if (fm->fc->no_setxattr)
return -EOPNOTSUPP; return -EOPNOTSUPP;
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
@ -34,9 +34,9 @@ int fuse_setxattr(struct inode *inode, const char *name, const void *value,
args.in_args[1].value = name; args.in_args[1].value = name;
args.in_args[2].size = size; args.in_args[2].size = size;
args.in_args[2].value = value; args.in_args[2].value = value;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err == -ENOSYS) { if (err == -ENOSYS) {
fc->no_setxattr = 1; fm->fc->no_setxattr = 1;
err = -EOPNOTSUPP; err = -EOPNOTSUPP;
} }
if (!err) { if (!err) {
@ -49,13 +49,13 @@ int fuse_setxattr(struct inode *inode, const char *name, const void *value,
ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value, ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value,
size_t size) size_t size)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_getxattr_in inarg; struct fuse_getxattr_in inarg;
struct fuse_getxattr_out outarg; struct fuse_getxattr_out outarg;
ssize_t ret; ssize_t ret;
if (fc->no_getxattr) if (fm->fc->no_getxattr)
return -EOPNOTSUPP; return -EOPNOTSUPP;
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
@ -77,11 +77,11 @@ ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value,
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
} }
ret = fuse_simple_request(fc, &args); ret = fuse_simple_request(fm, &args);
if (!ret && !size) if (!ret && !size)
ret = min_t(ssize_t, outarg.size, XATTR_SIZE_MAX); ret = min_t(ssize_t, outarg.size, XATTR_SIZE_MAX);
if (ret == -ENOSYS) { if (ret == -ENOSYS) {
fc->no_getxattr = 1; fm->fc->no_getxattr = 1;
ret = -EOPNOTSUPP; ret = -EOPNOTSUPP;
} }
return ret; return ret;
@ -107,16 +107,16 @@ static int fuse_verify_xattr_list(char *list, size_t size)
ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size) ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
{ {
struct inode *inode = d_inode(entry); struct inode *inode = d_inode(entry);
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
struct fuse_getxattr_in inarg; struct fuse_getxattr_in inarg;
struct fuse_getxattr_out outarg; struct fuse_getxattr_out outarg;
ssize_t ret; ssize_t ret;
if (!fuse_allow_current_process(fc)) if (!fuse_allow_current_process(fm->fc))
return -EACCES; return -EACCES;
if (fc->no_listxattr) if (fm->fc->no_listxattr)
return -EOPNOTSUPP; return -EOPNOTSUPP;
memset(&inarg, 0, sizeof(inarg)); memset(&inarg, 0, sizeof(inarg));
@ -136,13 +136,13 @@ ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
args.out_args[0].size = sizeof(outarg); args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg; args.out_args[0].value = &outarg;
} }
ret = fuse_simple_request(fc, &args); ret = fuse_simple_request(fm, &args);
if (!ret && !size) if (!ret && !size)
ret = min_t(ssize_t, outarg.size, XATTR_LIST_MAX); ret = min_t(ssize_t, outarg.size, XATTR_LIST_MAX);
if (ret > 0 && size) if (ret > 0 && size)
ret = fuse_verify_xattr_list(list, ret); ret = fuse_verify_xattr_list(list, ret);
if (ret == -ENOSYS) { if (ret == -ENOSYS) {
fc->no_listxattr = 1; fm->fc->no_listxattr = 1;
ret = -EOPNOTSUPP; ret = -EOPNOTSUPP;
} }
return ret; return ret;
@ -150,11 +150,11 @@ ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
int fuse_removexattr(struct inode *inode, const char *name) int fuse_removexattr(struct inode *inode, const char *name)
{ {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args); FUSE_ARGS(args);
int err; int err;
if (fc->no_removexattr) if (fm->fc->no_removexattr)
return -EOPNOTSUPP; return -EOPNOTSUPP;
args.opcode = FUSE_REMOVEXATTR; args.opcode = FUSE_REMOVEXATTR;
@ -162,9 +162,9 @@ int fuse_removexattr(struct inode *inode, const char *name)
args.in_numargs = 1; args.in_numargs = 1;
args.in_args[0].size = strlen(name) + 1; args.in_args[0].size = strlen(name) + 1;
args.in_args[0].value = name; args.in_args[0].value = name;
err = fuse_simple_request(fc, &args); err = fuse_simple_request(fm, &args);
if (err == -ENOSYS) { if (err == -ENOSYS) {
fc->no_removexattr = 1; fm->fc->no_removexattr = 1;
err = -EOPNOTSUPP; err = -EOPNOTSUPP;
} }
if (!err) { if (!err) {