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

Merge tag 'fuse-update-5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse 

Pull fuse updates from Miklos Szeredi:
 "Scalability and performance improvements, as well as minor bug fixes
  and cleanups"

* tag 'fuse-update-5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse: (25 commits)
  fuse: cache readdir calls if filesystem opts out of opendir
  fuse: support clients that don't implement 'opendir'
  fuse: lift bad inode checks into callers
  fuse: multiplex cached/direct_io file operations
  fuse add copy_file_range to direct io fops
  fuse: use iov_iter based generic splice helpers
  fuse: Switch to using async direct IO for FOPEN_DIRECT_IO
  fuse: use atomic64_t for khctr
  fuse: clean up aborted
  fuse: Protect ff->reserved_req via corresponding fi->lock
  fuse: Protect fi->nlookup with fi->lock
  fuse: Introduce fi->lock to protect write related fields
  fuse: Convert fc->attr_version into atomic64_t
  fuse: Add fuse_inode argument to fuse_prepare_release()
  fuse: Verify userspace asks to requeue interrupt that we really sent
  fuse: Do some refactoring in fuse_dev_do_write()
  fuse: Wake up req->waitq of only if not background
  fuse: Optimize request_end() by not taking fiq->waitq.lock
  fuse: Kill fasync only if interrupt is queued in queue_interrupt()
  fuse: Remove stale comment in end_requests()
  ...
parents 7b47a9e7 fabf7e02

fs/fuse/control.c

+3 −1
Original line number Diff line number Diff line
@@ -35,7 +35,9 @@ static ssize_t fuse_conn_abort_write(struct file *file, const char __user *buf, 
{

	struct fuse_conn *fc = fuse_ctl_file_conn_get(file);

	if (fc) {

		fuse_abort_conn(fc, true);

		if (fc->abort_err)

			fc->aborted = true;

		fuse_abort_conn(fc);

		fuse_conn_put(fc);

	}

	return count;

fs/fuse/cuse.c

+4 −3
Original line number Diff line number Diff line
@@ -141,10 +141,11 @@ static int cuse_open(struct inode *inode, struct file *file) 


static int cuse_release(struct inode *inode, struct file *file)

{

	struct fuse_inode *fi = get_fuse_inode(inode);

	struct fuse_file *ff = file->private_data;

	struct fuse_conn *fc = ff->fc;



	fuse_sync_release(ff, file->f_flags);

	fuse_sync_release(fi, ff, file->f_flags);

	fuse_conn_put(fc);



	return 0;
@@ -407,7 +408,7 @@ err_unlock: 
err_region:

	unregister_chrdev_region(devt, 1);

err:

	fuse_abort_conn(fc, false);

	fuse_abort_conn(fc);

	goto out;

}
@@ -586,7 +587,7 @@ static ssize_t cuse_class_abort_store(struct device *dev, 
{

	struct cuse_conn *cc = dev_get_drvdata(dev);



	fuse_abort_conn(&cc->fc, false);

	fuse_abort_conn(&cc->fc);

	return count;

}

static DEVICE_ATTR(abort, 0200, NULL, cuse_class_abort_store);

fs/fuse/dev.c

+66 −49
Original line number Diff line number Diff line
@@ -251,17 +251,18 @@ static struct fuse_req *get_reserved_req(struct fuse_conn *fc, 
					 struct file *file)

{

	struct fuse_req *req = NULL;

	struct fuse_inode *fi = get_fuse_inode(file_inode(file));

	struct fuse_file *ff = file->private_data;



	do {

		wait_event(fc->reserved_req_waitq, ff->reserved_req);

		spin_lock(&fc->lock);

		spin_lock(&fi->lock);

		if (ff->reserved_req) {

			req = ff->reserved_req;

			ff->reserved_req = NULL;

			req->stolen_file = get_file(file);

		}

		spin_unlock(&fc->lock);

		spin_unlock(&fi->lock);

	} while (!req);



	return req;
@@ -273,16 +274,17 @@ static struct fuse_req *get_reserved_req(struct fuse_conn *fc, 
static void put_reserved_req(struct fuse_conn *fc, struct fuse_req *req)

{

	struct file *file = req->stolen_file;

	struct fuse_inode *fi = get_fuse_inode(file_inode(file));

	struct fuse_file *ff = file->private_data;



	WARN_ON(req->max_pages);

	spin_lock(&fc->lock);

	spin_lock(&fi->lock);

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

	fuse_request_init(req, NULL, NULL, 0);

	BUG_ON(ff->reserved_req);

	ff->reserved_req = req;

	wake_up_all(&fc->reserved_req_waitq);

	spin_unlock(&fc->lock);

	spin_unlock(&fi->lock);

	fput(file);

}
@@ -431,10 +433,16 @@ static void request_end(struct fuse_conn *fc, struct fuse_req *req) 


	if (test_and_set_bit(FR_FINISHED, &req->flags))

		goto put_request;



	/*

	 * test_and_set_bit() implies smp_mb() between bit

	 * changing and below intr_entry check. Pairs with

	 * smp_mb() from queue_interrupt().

	 */

	if (!list_empty(&req->intr_entry)) {

		spin_lock(&fiq->waitq.lock);

		list_del_init(&req->intr_entry);

		spin_unlock(&fiq->waitq.lock);

	}

	WARN_ON(test_bit(FR_PENDING, &req->flags));

	WARN_ON(test_bit(FR_SENT, &req->flags));

	if (test_bit(FR_BACKGROUND, &req->flags)) {
@@ -462,27 +470,43 @@ static void request_end(struct fuse_conn *fc, struct fuse_req *req) 
		fc->active_background--;

		flush_bg_queue(fc);

		spin_unlock(&fc->bg_lock);

	}

	} else {

		/* Wake up waiter sleeping in request_wait_answer() */

		wake_up(&req->waitq);

	}



	if (req->end)

		req->end(fc, req);

put_request:

	fuse_put_request(fc, req);

}



static void queue_interrupt(struct fuse_iqueue *fiq, struct fuse_req *req)

static int queue_interrupt(struct fuse_iqueue *fiq, struct fuse_req *req)

{

	spin_lock(&fiq->waitq.lock);

	if (test_bit(FR_FINISHED, &req->flags)) {

	/* Check for we've sent request to interrupt this req */

	if (unlikely(!test_bit(FR_INTERRUPTED, &req->flags))) {

		spin_unlock(&fiq->waitq.lock);

		return;

		return -EINVAL;

	}



	if (list_empty(&req->intr_entry)) {

		list_add_tail(&req->intr_entry, &fiq->interrupts);

		/*

		 * Pairs with smp_mb() implied by test_and_set_bit()

		 * from request_end().

		 */

		smp_mb();

		if (test_bit(FR_FINISHED, &req->flags)) {

			list_del_init(&req->intr_entry);

			spin_unlock(&fiq->waitq.lock);

			return 0;

		}

		wake_up_locked(&fiq->waitq);

		kill_fasync(&fiq->fasync, SIGIO, POLL_IN);

	}

	spin_unlock(&fiq->waitq.lock);

	kill_fasync(&fiq->fasync, SIGIO, POLL_IN);

	return 0;

}



static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
@@ -1306,7 +1330,7 @@ static ssize_t fuse_dev_do_read(struct fuse_dev *fud, struct file *file, 
		goto err_unlock;



	if (!fiq->connected) {

		err = (fc->aborted && fc->abort_err) ? -ECONNABORTED : -ENODEV;

		err = fc->aborted ? -ECONNABORTED : -ENODEV;

		goto err_unlock;

	}
@@ -1353,7 +1377,7 @@ static ssize_t fuse_dev_do_read(struct fuse_dev *fud, struct file *file, 
	spin_lock(&fpq->lock);

	clear_bit(FR_LOCKED, &req->flags);

	if (!fpq->connected) {

		err = (fc->aborted && fc->abort_err) ? -ECONNABORTED : -ENODEV;

		err = fc->aborted ? -ECONNABORTED : -ENODEV;

		goto out_end;

	}

	if (err) {
@@ -1900,16 +1924,17 @@ static ssize_t fuse_dev_do_write(struct fuse_dev *fud, 
	struct fuse_req *req;

	struct fuse_out_header oh;



	err = -EINVAL;

	if (nbytes < sizeof(struct fuse_out_header))

		return -EINVAL;

		goto out;



	err = fuse_copy_one(cs, &oh, sizeof(oh));

	if (err)

		goto err_finish;

		goto copy_finish;



	err = -EINVAL;

	if (oh.len != nbytes)

		goto err_finish;

		goto copy_finish;



	/*

	 * Zero oh.unique indicates unsolicited notification message
@@ -1917,41 +1942,40 @@ static ssize_t fuse_dev_do_write(struct fuse_dev *fud, 
	 */

	if (!oh.unique) {

		err = fuse_notify(fc, oh.error, nbytes - sizeof(oh), cs);

		return err ? err : nbytes;

		goto out;

	}



	err = -EINVAL;

	if (oh.error <= -1000 || oh.error > 0)

		goto err_finish;

		goto copy_finish;



	spin_lock(&fpq->lock);

	err = -ENOENT;

	if (!fpq->connected)

		goto err_unlock_pq;



	req = NULL;

	if (fpq->connected)

		req = request_find(fpq, oh.unique & ~FUSE_INT_REQ_BIT);

	if (!req)

		goto err_unlock_pq;



	err = -ENOENT;

	if (!req) {

		spin_unlock(&fpq->lock);

		goto copy_finish;

	}



	/* Is it an interrupt reply ID? */

	if (oh.unique & FUSE_INT_REQ_BIT) {

		__fuse_get_request(req);

		spin_unlock(&fpq->lock);



		err = 0;

		if (nbytes != sizeof(struct fuse_out_header))

			err = -EINVAL;

		if (nbytes != sizeof(struct fuse_out_header)) {

			fuse_put_request(fc, req);

			goto err_finish;

		}



		if (oh.error == -ENOSYS)

		else if (oh.error == -ENOSYS)

			fc->no_interrupt = 1;

		else if (oh.error == -EAGAIN)

			queue_interrupt(&fc->iq, req);

			err = queue_interrupt(&fc->iq, req);



		fuse_put_request(fc, req);



		fuse_copy_finish(cs);

		return nbytes;

		goto copy_finish;

	}



	clear_bit(FR_SENT, &req->flags);
@@ -1977,14 +2001,12 @@ static ssize_t fuse_dev_do_write(struct fuse_dev *fud, 
	spin_unlock(&fpq->lock);



	request_end(fc, req);



out:

	return err ? err : nbytes;



 err_unlock_pq:

	spin_unlock(&fpq->lock);

 err_finish:

copy_finish:

	fuse_copy_finish(cs);

	return err;

	goto out;

}



static ssize_t fuse_dev_write(struct kiocb *iocb, struct iov_iter *from)
@@ -2109,11 +2131,7 @@ static __poll_t fuse_dev_poll(struct file *file, poll_table *wait) 
	return mask;

}



/*

 * Abort all requests on the given list (pending or processing)

 *

 * This function releases and reacquires fc->lock

 */

/* Abort all requests on the given list (pending or processing) */

static void end_requests(struct fuse_conn *fc, struct list_head *head)

{

	while (!list_empty(head)) {
@@ -2159,7 +2177,7 @@ static void end_polls(struct fuse_conn *fc) 
 * is OK, the request will in that case be removed from the list before we touch

 * it.

 */

void fuse_abort_conn(struct fuse_conn *fc, bool is_abort)

void fuse_abort_conn(struct fuse_conn *fc)

{

	struct fuse_iqueue *fiq = &fc->iq;
@@ -2175,7 +2193,6 @@ void fuse_abort_conn(struct fuse_conn *fc, bool is_abort) 
		fc->connected = 0;

		spin_unlock(&fc->bg_lock);



		fc->aborted = is_abort;

		fuse_set_initialized(fc);

		list_for_each_entry(fud, &fc->devices, entry) {

			struct fuse_pqueue *fpq = &fud->pq;
@@ -2253,7 +2270,7 @@ int fuse_dev_release(struct inode *inode, struct file *file) 
		/* Are we the last open device? */

		if (atomic_dec_and_test(&fc->dev_count)) {

			WARN_ON(fc->iq.fasync != NULL);

			fuse_abort_conn(fc, false);

			fuse_abort_conn(fc);

		}

		fuse_dev_free(fud);

	}

fs/fuse/dir.c

+20 −34
Original line number Diff line number Diff line
@@ -149,21 +149,6 @@ static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_args *args, 
	args->out.args[0].value = outarg;

}



u64 fuse_get_attr_version(struct fuse_conn *fc)

{

	u64 curr_version;



	/*

	 * The spin lock isn't actually needed on 64bit archs, but we

	 * don't yet care too much about such optimizations.

	 */

	spin_lock(&fc->lock);

	curr_version = fc->attr_version;

	spin_unlock(&fc->lock);



	return curr_version;

}



/*

 * Check whether the dentry is still valid

 *
@@ -222,9 +207,9 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags) 
				fuse_queue_forget(fc, forget, outarg.nodeid, 1);

				goto invalid;

			}

			spin_lock(&fc->lock);

			spin_lock(&fi->lock);

			fi->nlookup++;

			spin_unlock(&fc->lock);

			spin_unlock(&fi->lock);

		}

		kfree(forget);

		if (ret == -ENOMEM)
@@ -400,6 +385,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, 
	struct fuse_create_in inarg;

	struct fuse_open_out outopen;

	struct fuse_entry_out outentry;

	struct fuse_inode *fi;

	struct fuse_file *ff;



	/* Userspace expects S_IFREG in create mode */
@@ -451,7 +437,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, 
			  &outentry.attr, entry_attr_timeout(&outentry), 0);

	if (!inode) {

		flags &= ~(O_CREAT | O_EXCL | O_TRUNC);

		fuse_sync_release(ff, flags);

		fuse_sync_release(NULL, ff, flags);

		fuse_queue_forget(fc, forget, outentry.nodeid, 1);

		err = -ENOMEM;

		goto out_err;
@@ -462,7 +448,8 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, 
	fuse_dir_changed(dir);

	err = finish_open(file, entry, generic_file_open);

	if (err) {

		fuse_sync_release(ff, flags);

		fi = get_fuse_inode(inode);

		fuse_sync_release(fi, ff, flags);

	} else {

		file->private_data = ff;

		fuse_finish_open(inode, file);
@@ -671,8 +658,8 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry) 
		struct inode *inode = d_inode(entry);

		struct fuse_inode *fi = get_fuse_inode(inode);



		spin_lock(&fc->lock);

		fi->attr_version = ++fc->attr_version;

		spin_lock(&fi->lock);

		fi->attr_version = atomic64_inc_return(&fc->attr_version);

		/*

		 * If i_nlink == 0 then unlink doesn't make sense, yet this can

		 * happen if userspace filesystem is careless.  It would be
@@ -681,7 +668,7 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry) 
		 */

		if (inode->i_nlink > 0)

			drop_nlink(inode);

		spin_unlock(&fc->lock);

		spin_unlock(&fi->lock);

		fuse_invalidate_attr(inode);

		fuse_dir_changed(dir);

		fuse_invalidate_entry_cache(entry);
@@ -825,10 +812,10 @@ static int fuse_link(struct dentry *entry, struct inode *newdir, 
	if (!err) {

		struct fuse_inode *fi = get_fuse_inode(inode);



		spin_lock(&fc->lock);

		fi->attr_version = ++fc->attr_version;

		spin_lock(&fi->lock);

		fi->attr_version = atomic64_inc_return(&fc->attr_version);

		inc_nlink(inode);

		spin_unlock(&fc->lock);

		spin_unlock(&fi->lock);

		fuse_invalidate_attr(inode);

		fuse_update_ctime(inode);

	} else if (err == -EINTR) {
@@ -1356,15 +1343,14 @@ static void iattr_to_fattr(struct fuse_conn *fc, struct iattr *iattr, 
 */

void fuse_set_nowrite(struct inode *inode)

{

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_inode *fi = get_fuse_inode(inode);



	BUG_ON(!inode_is_locked(inode));



	spin_lock(&fc->lock);

	spin_lock(&fi->lock);

	BUG_ON(fi->writectr < 0);

	fi->writectr += FUSE_NOWRITE;

	spin_unlock(&fc->lock);

	spin_unlock(&fi->lock);

	wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);

}
@@ -1385,11 +1371,11 @@ static void __fuse_release_nowrite(struct inode *inode) 


void fuse_release_nowrite(struct inode *inode)

{

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_inode *fi = get_fuse_inode(inode);



	spin_lock(&fc->lock);

	spin_lock(&fi->lock);

	__fuse_release_nowrite(inode);

	spin_unlock(&fc->lock);

	spin_unlock(&fi->lock);

}



static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_args *args,
@@ -1524,7 +1510,7 @@ int fuse_do_setattr(struct dentry *dentry, struct iattr *attr, 
		goto error;

	}



	spin_lock(&fc->lock);

	spin_lock(&fi->lock);

	/* the kernel maintains i_mtime locally */

	if (trust_local_cmtime) {

		if (attr->ia_valid & ATTR_MTIME)
@@ -1542,10 +1528,10 @@ int fuse_do_setattr(struct dentry *dentry, struct iattr *attr, 
		i_size_write(inode, outarg.attr.size);



	if (is_truncate) {

		/* NOTE: this may release/reacquire fc->lock */

		/* NOTE: this may release/reacquire fi->lock */

		__fuse_release_nowrite(inode);

	}

	spin_unlock(&fc->lock);

	spin_unlock(&fi->lock);



	/*

	 * Only call invalidate_inode_pages2() after removing

CRA Git | Maintained and supported by SUSTech CRA and CCSE