Commit c103b21c authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse 

Pull fuse update from Miklos Szeredi:
 "The first part makes sure we don't hold up umount with pending async
  requests.  In addition to being a cleanup, this is a small behavioral
  change (for the better) and unlikely to break anything.

  The second part prepares for a cleanup of the fuse device I/O code by
  adding a helper for simple request submission, with some savings in
  line numbers already realized"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse:
  fuse: use file_inode() in fuse_file_fallocate()
  fuse: introduce fuse_simple_request() helper
  fuse: reduce max out args
  fuse: hold inode instead of path after release
  fuse: flush requests on umount
  fuse: don't wake up reserved req in fuse_conn_kill()
parents 603ba7e4 1c68271c

fs/fuse/cuse.c

+1 −1
Original line number Diff line number Diff line
@@ -415,7 +415,7 @@ err_unlock: 
err_region:

	unregister_chrdev_region(devt, 1);

err:

	fuse_conn_kill(fc);

	fuse_abort_conn(fc);

	goto out;

}

fs/fuse/dev.c

+29 −0
Original line number Diff line number Diff line
@@ -511,6 +511,35 @@ void fuse_request_send(struct fuse_conn *fc, struct fuse_req *req) 
}

EXPORT_SYMBOL_GPL(fuse_request_send);



ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args)

{

	struct fuse_req *req;

	ssize_t ret;



	req = fuse_get_req(fc, 0);

	if (IS_ERR(req))

		return PTR_ERR(req);



	req->in.h.opcode = args->in.h.opcode;

	req->in.h.nodeid = args->in.h.nodeid;

	req->in.numargs = args->in.numargs;

	memcpy(req->in.args, args->in.args,

	       args->in.numargs * sizeof(struct fuse_in_arg));

	req->out.argvar = args->out.argvar;

	req->out.numargs = args->out.numargs;

	memcpy(req->out.args, args->out.args,

	       args->out.numargs * sizeof(struct fuse_arg));

	fuse_request_send(fc, req);

	ret = req->out.h.error;

	if (!ret && args->out.argvar) {

		BUG_ON(args->out.numargs != 1);

		ret = req->out.args[0].size;

	}

	fuse_put_request(fc, req);



	return ret;

}



static void fuse_request_send_nowait_locked(struct fuse_conn *fc,

					    struct fuse_req *req)

{

fs/fuse/dir.c

+215 −323

File changed.

Preview size limit exceeded, changes collapsed.

fs/fuse/file.c

+78 −152
Original line number Diff line number Diff line
@@ -24,30 +24,22 @@ static int fuse_send_open(struct fuse_conn *fc, u64 nodeid, struct file *file, 
			  int opcode, struct fuse_open_out *outargp)

{

	struct fuse_open_in inarg;

	struct fuse_req *req;

	int err;



	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);

	FUSE_ARGS(args);



	memset(&inarg, 0, sizeof(inarg));

	inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY);

	if (!fc->atomic_o_trunc)

		inarg.flags &= ~O_TRUNC;

	req->in.h.opcode = opcode;

	req->in.h.nodeid = nodeid;

	req->in.numargs = 1;

	req->in.args[0].size = sizeof(inarg);

	req->in.args[0].value = &inarg;

	req->out.numargs = 1;

	req->out.args[0].size = sizeof(*outargp);

	req->out.args[0].value = outargp;

	fuse_request_send(fc, req);

	err = req->out.h.error;

	fuse_put_request(fc, req);

	args.in.h.opcode = opcode;

	args.in.h.nodeid = nodeid;

	args.in.numargs = 1;

	args.in.args[0].size = sizeof(inarg);

	args.in.args[0].value = &inarg;

	args.out.numargs = 1;

	args.out.args[0].size = sizeof(*outargp);

	args.out.args[0].value = outargp;



	return err;

	return fuse_simple_request(fc, &args);

}



struct fuse_file *fuse_file_alloc(struct fuse_conn *fc)
@@ -89,37 +81,9 @@ struct fuse_file *fuse_file_get(struct fuse_file *ff) 
	return ff;

}



static void fuse_release_async(struct work_struct *work)

{

	struct fuse_req *req;

	struct fuse_conn *fc;

	struct path path;



	req = container_of(work, struct fuse_req, misc.release.work);

	path = req->misc.release.path;

	fc = get_fuse_conn(path.dentry->d_inode);



	fuse_put_request(fc, req);

	path_put(&path);

}



static void fuse_release_end(struct fuse_conn *fc, struct fuse_req *req)

{

	if (fc->destroy_req) {

		/*

		 * If this is a fuseblk mount, then it's possible that

		 * releasing the path will result in releasing the

		 * super block and sending the DESTROY request.  If

		 * the server is single threaded, this would hang.

		 * For this reason do the path_put() in a separate

		 * thread.

		 */

		atomic_inc(&req->count);

		INIT_WORK(&req->misc.release.work, fuse_release_async);

		schedule_work(&req->misc.release.work);

	} else {

		path_put(&req->misc.release.path);

	}

	iput(req->misc.release.inode);

}



static void fuse_file_put(struct fuse_file *ff, bool sync)
@@ -133,12 +97,12 @@ static void fuse_file_put(struct fuse_file *ff, bool sync) 
			 * implement 'open'

			 */

			req->background = 0;

			path_put(&req->misc.release.path);

			iput(req->misc.release.inode);

			fuse_put_request(ff->fc, req);

		} else if (sync) {

			req->background = 0;

			fuse_request_send(ff->fc, req);

			path_put(&req->misc.release.path);

			iput(req->misc.release.inode);

			fuse_put_request(ff->fc, req);

		} else {

			req->end = fuse_release_end;
@@ -297,9 +261,8 @@ void fuse_release_common(struct file *file, int opcode) 
		inarg->lock_owner = fuse_lock_owner_id(ff->fc,

						       (fl_owner_t) file);

	}

	/* Hold vfsmount and dentry until release is finished */

	path_get(&file->f_path);

	req->misc.release.path = file->f_path;

	/* Hold inode until release is finished */

	req->misc.release.inode = igrab(file_inode(file));



	/*

	 * Normally this will send the RELEASE request, however if
@@ -480,7 +443,7 @@ int fuse_fsync_common(struct file *file, loff_t start, loff_t end, 
	struct inode *inode = file->f_mapping->host;

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_file *ff = file->private_data;

	struct fuse_req *req;

	FUSE_ARGS(args);

	struct fuse_fsync_in inarg;

	int err;
@@ -506,23 +469,15 @@ int fuse_fsync_common(struct file *file, loff_t start, loff_t end, 
	if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir))

		goto out;



	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req)) {

		err = PTR_ERR(req);

		goto out;

	}



	memset(&inarg, 0, sizeof(inarg));

	inarg.fh = ff->fh;

	inarg.fsync_flags = datasync ? 1 : 0;

	req->in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC;

	req->in.h.nodeid = get_node_id(inode);

	req->in.numargs = 1;

	req->in.args[0].size = sizeof(inarg);

	req->in.args[0].value = &inarg;

	fuse_request_send(fc, req);

	err = req->out.h.error;

	fuse_put_request(fc, req);

	args.in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC;

	args.in.h.nodeid = get_node_id(inode);

	args.in.numargs = 1;

	args.in.args[0].size = sizeof(inarg);

	args.in.args[0].value = &inarg;

	err = fuse_simple_request(fc, &args);

	if (err == -ENOSYS) {

		if (isdir)

			fc->no_fsyncdir = 1;
@@ -2156,49 +2111,44 @@ static int convert_fuse_file_lock(const struct fuse_file_lock *ffl, 
	return 0;

}



static void fuse_lk_fill(struct fuse_req *req, struct file *file,

static void fuse_lk_fill(struct fuse_args *args, struct file *file,

			 const struct file_lock *fl, int opcode, pid_t pid,

			 int flock)

			 int flock, struct fuse_lk_in *inarg)

{

	struct inode *inode = file_inode(file);

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_file *ff = file->private_data;

	struct fuse_lk_in *arg = &req->misc.lk_in;



	arg->fh = ff->fh;

	arg->owner = fuse_lock_owner_id(fc, fl->fl_owner);

	arg->lk.start = fl->fl_start;

	arg->lk.end = fl->fl_end;

	arg->lk.type = fl->fl_type;

	arg->lk.pid = pid;



	memset(inarg, 0, sizeof(*inarg));

	inarg->fh = ff->fh;

	inarg->owner = fuse_lock_owner_id(fc, fl->fl_owner);

	inarg->lk.start = fl->fl_start;

	inarg->lk.end = fl->fl_end;

	inarg->lk.type = fl->fl_type;

	inarg->lk.pid = pid;

	if (flock)

		arg->lk_flags |= FUSE_LK_FLOCK;

	req->in.h.opcode = opcode;

	req->in.h.nodeid = get_node_id(inode);

	req->in.numargs = 1;

	req->in.args[0].size = sizeof(*arg);

	req->in.args[0].value = arg;

		inarg->lk_flags |= FUSE_LK_FLOCK;

	args->in.h.opcode = opcode;

	args->in.h.nodeid = get_node_id(inode);

	args->in.numargs = 1;

	args->in.args[0].size = sizeof(*inarg);

	args->in.args[0].value = inarg;

}



static int fuse_getlk(struct file *file, struct file_lock *fl)

{

	struct inode *inode = file_inode(file);

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_req *req;

	FUSE_ARGS(args);

	struct fuse_lk_in inarg;

	struct fuse_lk_out outarg;

	int err;



	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);



	fuse_lk_fill(req, file, fl, FUSE_GETLK, 0, 0);

	req->out.numargs = 1;

	req->out.args[0].size = sizeof(outarg);

	req->out.args[0].value = &outarg;

	fuse_request_send(fc, req);

	err = req->out.h.error;

	fuse_put_request(fc, req);

	fuse_lk_fill(&args, file, fl, FUSE_GETLK, 0, 0, &inarg);

	args.out.numargs = 1;

	args.out.args[0].size = sizeof(outarg);

	args.out.args[0].value = &outarg;

	err = fuse_simple_request(fc, &args);

	if (!err)

		err = convert_fuse_file_lock(&outarg.lk, fl);
@@ -2209,7 +2159,8 @@ static int fuse_setlk(struct file *file, struct file_lock *fl, int flock) 
{

	struct inode *inode = file_inode(file);

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_req *req;

	FUSE_ARGS(args);

	struct fuse_lk_in inarg;

	int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK;

	pid_t pid = fl->fl_type != F_UNLCK ? current->tgid : 0;

	int err;
@@ -2223,17 +2174,13 @@ static int fuse_setlk(struct file *file, struct file_lock *fl, int flock) 
	if (fl->fl_flags & FL_CLOSE)

		return 0;



	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);

	fuse_lk_fill(&args, file, fl, opcode, pid, flock, &inarg);

	err = fuse_simple_request(fc, &args);



	fuse_lk_fill(req, file, fl, opcode, pid, flock);

	fuse_request_send(fc, req);

	err = req->out.h.error;

	/* locking is restartable */

	if (err == -EINTR)

		err = -ERESTARTSYS;

	fuse_put_request(fc, req);



	return err;

}
@@ -2283,7 +2230,7 @@ static sector_t fuse_bmap(struct address_space *mapping, sector_t block) 
{

	struct inode *inode = mapping->host;

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_req *req;

	FUSE_ARGS(args);

	struct fuse_bmap_in inarg;

	struct fuse_bmap_out outarg;

	int err;
@@ -2291,24 +2238,18 @@ static sector_t fuse_bmap(struct address_space *mapping, sector_t block) 
	if (!inode->i_sb->s_bdev || fc->no_bmap)

		return 0;



	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return 0;



	memset(&inarg, 0, sizeof(inarg));

	inarg.block = block;

	inarg.blocksize = inode->i_sb->s_blocksize;

	req->in.h.opcode = FUSE_BMAP;

	req->in.h.nodeid = get_node_id(inode);

	req->in.numargs = 1;

	req->in.args[0].size = sizeof(inarg);

	req->in.args[0].value = &inarg;

	req->out.numargs = 1;

	req->out.args[0].size = sizeof(outarg);

	req->out.args[0].value = &outarg;

	fuse_request_send(fc, req);

	err = req->out.h.error;

	fuse_put_request(fc, req);

	args.in.h.opcode = FUSE_BMAP;

	args.in.h.nodeid = get_node_id(inode);

	args.in.numargs = 1;

	args.in.args[0].size = sizeof(inarg);

	args.in.args[0].value = &inarg;

	args.out.numargs = 1;

	args.out.args[0].size = sizeof(outarg);

	args.out.args[0].value = &outarg;

	err = fuse_simple_request(fc, &args);

	if (err == -ENOSYS)

		fc->no_bmap = 1;
@@ -2776,7 +2717,7 @@ unsigned fuse_file_poll(struct file *file, poll_table *wait) 
	struct fuse_conn *fc = ff->fc;

	struct fuse_poll_in inarg = { .fh = ff->fh, .kh = ff->kh };

	struct fuse_poll_out outarg;

	struct fuse_req *req;

	FUSE_ARGS(args);

	int err;



	if (fc->no_poll)
@@ -2794,21 +2735,15 @@ unsigned fuse_file_poll(struct file *file, poll_table *wait) 
		fuse_register_polled_file(fc, ff);

	}



	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return POLLERR;



	req->in.h.opcode = FUSE_POLL;

	req->in.h.nodeid = ff->nodeid;

	req->in.numargs = 1;

	req->in.args[0].size = sizeof(inarg);

	req->in.args[0].value = &inarg;

	req->out.numargs = 1;

	req->out.args[0].size = sizeof(outarg);

	req->out.args[0].value = &outarg;

	fuse_request_send(fc, req);

	err = req->out.h.error;

	fuse_put_request(fc, req);

	args.in.h.opcode = FUSE_POLL;

	args.in.h.nodeid = ff->nodeid;

	args.in.numargs = 1;

	args.in.args[0].size = sizeof(inarg);

	args.in.args[0].value = &inarg;

	args.out.numargs = 1;

	args.out.args[0].size = sizeof(outarg);

	args.out.args[0].value = &outarg;

	err = fuse_simple_request(fc, &args);



	if (!err)

		return outarg.revents;
@@ -2949,10 +2884,10 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset, 
				loff_t length)

{

	struct fuse_file *ff = file->private_data;

	struct inode *inode = file->f_inode;

	struct inode *inode = file_inode(file);

	struct fuse_inode *fi = get_fuse_inode(inode);

	struct fuse_conn *fc = ff->fc;

	struct fuse_req *req;

	FUSE_ARGS(args);

	struct fuse_fallocate_in inarg = {

		.fh = ff->fh,

		.offset = offset,
@@ -2985,25 +2920,16 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset, 
	if (!(mode & FALLOC_FL_KEEP_SIZE))

		set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);



	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req)) {

		err = PTR_ERR(req);

		goto out;

	}



	req->in.h.opcode = FUSE_FALLOCATE;

	req->in.h.nodeid = ff->nodeid;

	req->in.numargs = 1;

	req->in.args[0].size = sizeof(inarg);

	req->in.args[0].value = &inarg;

	fuse_request_send(fc, req);

	err = req->out.h.error;

	args.in.h.opcode = FUSE_FALLOCATE;

	args.in.h.nodeid = ff->nodeid;

	args.in.numargs = 1;

	args.in.args[0].size = sizeof(inarg);

	args.in.args[0].value = &inarg;

	err = fuse_simple_request(fc, &args);

	if (err == -ENOSYS) {

		fc->no_fallocate = 1;

		err = -EOPNOTSUPP;

	}

	fuse_put_request(fc, req);



	if (err)

		goto out;

fs/fuse/fuse_i.h

+27 −18
Original line number Diff line number Diff line
@@ -213,7 +213,7 @@ struct fuse_out { 
	unsigned numargs;



	/** Array of arguments */

	struct fuse_arg args[3];

	struct fuse_arg args[2];

};



/** FUSE page descriptor */
@@ -222,6 +222,25 @@ struct fuse_page_desc { 
	unsigned int offset;

};



struct fuse_args {

	struct {

		struct {

			uint32_t opcode;

			uint64_t nodeid;

		} h;

		unsigned numargs;

		struct fuse_in_arg args[3];



	} in;

	struct {

		unsigned argvar:1;

		unsigned numargs;

		struct fuse_arg args[2];

	} out;

};



#define FUSE_ARGS(args) struct fuse_args args = {}



/** The request state */

enum fuse_req_state {

	FUSE_REQ_INIT = 0,
@@ -305,11 +324,8 @@ struct fuse_req { 
	/** Data for asynchronous requests */

	union {

		struct {

			union {

			struct fuse_release_in in;

				struct work_struct work;

			};

			struct path path;

			struct inode *inode;

		} release;

		struct fuse_init_in init_in;

		struct fuse_init_out init_out;
@@ -324,7 +340,6 @@ struct fuse_req { 
			struct fuse_req *next;

		} write;

		struct fuse_notify_retrieve_in retrieve_in;

		struct fuse_lk_in lk_in;

	} misc;



	/** page vector */
@@ -753,15 +768,6 @@ struct fuse_req *fuse_get_req_for_background(struct fuse_conn *fc, 
 */

void __fuse_get_request(struct fuse_req *req);



/**

 * Get a request, may fail with -ENOMEM,

 * useful for callers who doesn't use req->pages[]

 */

static inline struct fuse_req *fuse_get_req_nopages(struct fuse_conn *fc)

{

	return fuse_get_req(fc, 0);

}



/**

 * Gets a requests for a file operation, always succeeds

 */
@@ -779,6 +785,11 @@ void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req); 
 */

void fuse_request_send(struct fuse_conn *fc, struct fuse_req *req);



/**

 * Simple request sending that does request allocation and freeing

 */

ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args);



/**

 * Send a request in the background

 */
@@ -804,8 +815,6 @@ void fuse_invalidate_atime(struct inode *inode); 
 */

struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);



void fuse_conn_kill(struct fuse_conn *fc);



/**

 * Initialize fuse_conn

 */

CRA Git | Maintained and supported by SUSTech CRA and CCSE