Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c4bc705e 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 updates from Miklos Szeredi:
 "The biggest part of this pull request is a patch series from Maxim
  Patlasov to optimize scatter-gather direct IO.  There's also the
  addition of a "readdirplus" API, poll events and various fixes and
  cleanups.

  There's a one line change outside of fuse to mm/filemap.c which makes
  the argument of iov_iter_single_seg_count() const, required by Maxim's
  patches."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse: (22 commits)
  fuse: allow control of adaptive readdirplus use
  Synchronize fuse header with one used in library
  fuse: send poll events
  fuse: don't WARN when nlink is zero
  fuse: avoid out-of-scope stack access
  fuse: bump version for READDIRPLUS
  FUSE: Adapt readdirplus to application usage patterns
  Do not use RCU for current process credentials
  fuse: cleanup fuse_direct_io()
  fuse: optimize __fuse_direct_io()
  fuse: optimize fuse_get_user_pages()
  fuse: pass iov[] to fuse_get_user_pages()
  mm: minor cleanup of iov_iter_single_seg_count()
  fuse: use req->page_descs[] for argpages cases
  fuse: add per-page descriptor <offset, length> to fuse_req
  fuse: rework fuse_do_ioctl()
  fuse: rework fuse_perform_write()
  fuse: rework fuse_readpages()
  fuse: rework fuse_retrieve()
  fuse: categorize fuse_get_req()
  ...
parents 2608e3d0 634734b6

fs/fuse/cuse.c

+7 −3
Original line number Diff line number Diff line
@@ -91,19 +91,22 @@ static ssize_t cuse_read(struct file *file, char __user *buf, size_t count, 
			 loff_t *ppos)

{

	loff_t pos = 0;

	struct iovec iov = { .iov_base = buf, .iov_len = count };



	return fuse_direct_io(file, buf, count, &pos, 0);

	return fuse_direct_io(file, &iov, 1, count, &pos, 0);

}



static ssize_t cuse_write(struct file *file, const char __user *buf,

			  size_t count, loff_t *ppos)

{

	loff_t pos = 0;

	struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = count };



	/*

	 * No locking or generic_write_checks(), the server is

	 * responsible for locking and sanity checks.

	 */

	return fuse_direct_io(file, buf, count, &pos, 1);

	return fuse_direct_io(file, &iov, 1, count, &pos, 1);

}



static int cuse_open(struct inode *inode, struct file *file)
@@ -419,7 +422,7 @@ static int cuse_send_init(struct cuse_conn *cc) 


	BUILD_BUG_ON(CUSE_INIT_INFO_MAX > PAGE_SIZE);



	req = fuse_get_req(fc);

	req = fuse_get_req(fc, 1);

	if (IS_ERR(req)) {

		rc = PTR_ERR(req);

		goto err;
@@ -449,6 +452,7 @@ static int cuse_send_init(struct cuse_conn *cc) 
	req->out.argvar = 1;

	req->out.argpages = 1;

	req->pages[0] = page;

	req->page_descs[0].length = req->out.args[1].size;

	req->num_pages = 1;

	req->end = cuse_process_init_reply;

	fuse_request_send_background(fc, req);

fs/fuse/dev.c

+96 −32
Original line number Diff line number Diff line
@@ -34,34 +34,67 @@ static struct fuse_conn *fuse_get_conn(struct file *file) 
	return file->private_data;

}



static void fuse_request_init(struct fuse_req *req)

static void fuse_request_init(struct fuse_req *req, struct page **pages,

			      struct fuse_page_desc *page_descs,

			      unsigned npages)

{

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

	memset(pages, 0, sizeof(*pages) * npages);

	memset(page_descs, 0, sizeof(*page_descs) * npages);

	INIT_LIST_HEAD(&req->list);

	INIT_LIST_HEAD(&req->intr_entry);

	init_waitqueue_head(&req->waitq);

	atomic_set(&req->count, 1);

	req->pages = pages;

	req->page_descs = page_descs;

	req->max_pages = npages;

}



struct fuse_req *fuse_request_alloc(void)

static struct fuse_req *__fuse_request_alloc(unsigned npages, gfp_t flags)

{

	struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, GFP_KERNEL);

	if (req)

		fuse_request_init(req);

	struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, flags);

	if (req) {

		struct page **pages;

		struct fuse_page_desc *page_descs;



		if (npages <= FUSE_REQ_INLINE_PAGES) {

			pages = req->inline_pages;

			page_descs = req->inline_page_descs;

		} else {

			pages = kmalloc(sizeof(struct page *) * npages, flags);

			page_descs = kmalloc(sizeof(struct fuse_page_desc) *

					     npages, flags);

		}



		if (!pages || !page_descs) {

			kfree(pages);

			kfree(page_descs);

			kmem_cache_free(fuse_req_cachep, req);

			return NULL;

		}



		fuse_request_init(req, pages, page_descs, npages);

	}

	return req;

}



struct fuse_req *fuse_request_alloc(unsigned npages)

{

	return __fuse_request_alloc(npages, GFP_KERNEL);

}

EXPORT_SYMBOL_GPL(fuse_request_alloc);



struct fuse_req *fuse_request_alloc_nofs(void)

struct fuse_req *fuse_request_alloc_nofs(unsigned npages)

{

	struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, GFP_NOFS);

	if (req)

		fuse_request_init(req);

	return req;

	return __fuse_request_alloc(npages, GFP_NOFS);

}



void fuse_request_free(struct fuse_req *req)

{

	if (req->pages != req->inline_pages) {

		kfree(req->pages);

		kfree(req->page_descs);

	}

	kmem_cache_free(fuse_req_cachep, req);

}
@@ -97,7 +130,7 @@ static void fuse_req_init_context(struct fuse_req *req) 
	req->in.h.pid = current->pid;

}



struct fuse_req *fuse_get_req(struct fuse_conn *fc)

struct fuse_req *fuse_get_req(struct fuse_conn *fc, unsigned npages)

{

	struct fuse_req *req;

	sigset_t oldset;
@@ -116,7 +149,7 @@ struct fuse_req *fuse_get_req(struct fuse_conn *fc) 
	if (!fc->connected)

		goto out;



	req = fuse_request_alloc();

	req = fuse_request_alloc(npages);

	err = -ENOMEM;

	if (!req)

		goto out;
@@ -165,7 +198,7 @@ static void put_reserved_req(struct fuse_conn *fc, struct fuse_req *req) 
	struct fuse_file *ff = file->private_data;



	spin_lock(&fc->lock);

	fuse_request_init(req);

	fuse_request_init(req, req->pages, req->page_descs, req->max_pages);

	BUG_ON(ff->reserved_req);

	ff->reserved_req = req;

	wake_up_all(&fc->reserved_req_waitq);
@@ -186,13 +219,14 @@ static void put_reserved_req(struct fuse_conn *fc, struct fuse_req *req) 
 * filesystem should not have it's own file open.  If deadlock is

 * intentional, it can still be broken by "aborting" the filesystem.

 */

struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file)

struct fuse_req *fuse_get_req_nofail_nopages(struct fuse_conn *fc,

					     struct file *file)

{

	struct fuse_req *req;



	atomic_inc(&fc->num_waiting);

	wait_event(fc->blocked_waitq, !fc->blocked);

	req = fuse_request_alloc();

	req = fuse_request_alloc(0);

	if (!req)

		req = get_reserved_req(fc, file);
@@ -406,9 +440,8 @@ __acquires(fc->lock) 
	}

}



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

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

{

	req->isreply = 1;

	spin_lock(&fc->lock);

	if (!fc->connected)

		req->out.h.error = -ENOTCONN;
@@ -425,6 +458,12 @@ void fuse_request_send(struct fuse_conn *fc, struct fuse_req *req) 
	}

	spin_unlock(&fc->lock);

}



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

{

	req->isreply = 1;

	__fuse_request_send(fc, req);

}

EXPORT_SYMBOL_GPL(fuse_request_send);



static void fuse_request_send_nowait_locked(struct fuse_conn *fc,
@@ -491,6 +530,27 @@ void fuse_request_send_background_locked(struct fuse_conn *fc, 
	fuse_request_send_nowait_locked(fc, req);

}



void fuse_force_forget(struct file *file, u64 nodeid)

{

	struct inode *inode = file->f_path.dentry->d_inode;

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_req *req;

	struct fuse_forget_in inarg;



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

	inarg.nlookup = 1;

	req = fuse_get_req_nofail_nopages(fc, file);

	req->in.h.opcode = FUSE_FORGET;

	req->in.h.nodeid = nodeid;

	req->in.numargs = 1;

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

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

	req->isreply = 0;

	__fuse_request_send(fc, req);

	/* ignore errors */

	fuse_put_request(fc, req);

}



/*

 * Lock the request.  Up to the next unlock_request() there mustn't be

 * anything that could cause a page-fault.  If the request was already
@@ -850,11 +910,11 @@ static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes, 
{

	unsigned i;

	struct fuse_req *req = cs->req;

	unsigned offset = req->page_offset;

	unsigned count = min(nbytes, (unsigned) PAGE_SIZE - offset);



	for (i = 0; i < req->num_pages && (nbytes || zeroing); i++) {

		int err;

		unsigned offset = req->page_descs[i].offset;

		unsigned count = min(nbytes, req->page_descs[i].length);



		err = fuse_copy_page(cs, &req->pages[i], offset, count,

				     zeroing);
@@ -862,8 +922,6 @@ static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes, 
			return err;



		nbytes -= count;

		count = min(nbytes, (unsigned) PAGE_SIZE);

		offset = 0;

	}

	return 0;

}
@@ -1536,29 +1594,34 @@ static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode, 
	unsigned int num;

	unsigned int offset;

	size_t total_len = 0;

	int num_pages;



	offset = outarg->offset & ~PAGE_CACHE_MASK;

	file_size = i_size_read(inode);



	num = outarg->size;

	if (outarg->offset > file_size)

		num = 0;

	else if (outarg->offset + num > file_size)

		num = file_size - outarg->offset;



	req = fuse_get_req(fc);

	num_pages = (num + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;

	num_pages = min(num_pages, FUSE_MAX_PAGES_PER_REQ);



	req = fuse_get_req(fc, num_pages);

	if (IS_ERR(req))

		return PTR_ERR(req);



	offset = outarg->offset & ~PAGE_CACHE_MASK;



	req->in.h.opcode = FUSE_NOTIFY_REPLY;

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

	req->in.numargs = 2;

	req->in.argpages = 1;

	req->page_offset = offset;

	req->page_descs[0].offset = offset;

	req->end = fuse_retrieve_end;



	index = outarg->offset >> PAGE_CACHE_SHIFT;

	file_size = i_size_read(inode);

	num = outarg->size;

	if (outarg->offset > file_size)

		num = 0;

	else if (outarg->offset + num > file_size)

		num = file_size - outarg->offset;



	while (num && req->num_pages < FUSE_MAX_PAGES_PER_REQ) {

	while (num && req->num_pages < num_pages) {

		struct page *page;

		unsigned int this_num;
@@ -1568,6 +1631,7 @@ static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode, 


		this_num = min_t(unsigned, num, PAGE_CACHE_SIZE - offset);

		req->pages[req->num_pages] = page;

		req->page_descs[req->num_pages].length = this_num;

		req->num_pages++;



		offset = 0;

fs/fuse/dir.c

+221 −38
Original line number Diff line number Diff line
@@ -14,6 +14,29 @@ 
#include <linux/namei.h>

#include <linux/slab.h>



static bool fuse_use_readdirplus(struct inode *dir, struct file *filp)

{

	struct fuse_conn *fc = get_fuse_conn(dir);

	struct fuse_inode *fi = get_fuse_inode(dir);



	if (!fc->do_readdirplus)

		return false;

	if (!fc->readdirplus_auto)

		return true;

	if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))

		return true;

	if (filp->f_pos == 0)

		return true;

	return false;

}



static void fuse_advise_use_readdirplus(struct inode *dir)

{

	struct fuse_inode *fi = get_fuse_inode(dir);



	set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);

}



#if BITS_PER_LONG >= 64

static inline void fuse_dentry_settime(struct dentry *entry, u64 time)

{
@@ -178,7 +201,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags) 
			return -ECHILD;



		fc = get_fuse_conn(inode);

		req = fuse_get_req(fc);

		req = fuse_get_req_nopages(fc);

		if (IS_ERR(req))

			return 0;
@@ -219,6 +242,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags) 
				       attr_version);

		fuse_change_entry_timeout(entry, &outarg);

	}

	fuse_advise_use_readdirplus(inode);

	return 1;

}
@@ -271,7 +295,7 @@ int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name, 
	if (name->len > FUSE_NAME_MAX)

		goto out;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	err = PTR_ERR(req);

	if (IS_ERR(req))

		goto out;
@@ -355,6 +379,7 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry, 
	else

		fuse_invalidate_entry_cache(entry);



	fuse_advise_use_readdirplus(dir);

	return newent;



 out_iput:
@@ -391,7 +416,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, 
	if (!forget)

		goto out_err;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	err = PTR_ERR(req);

	if (IS_ERR(req))

		goto out_put_forget_req;
@@ -592,7 +617,7 @@ static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode, 
{

	struct fuse_mknod_in inarg;

	struct fuse_conn *fc = get_fuse_conn(dir);

	struct fuse_req *req = fuse_get_req(fc);

	struct fuse_req *req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -623,7 +648,7 @@ static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode) 
{

	struct fuse_mkdir_in inarg;

	struct fuse_conn *fc = get_fuse_conn(dir);

	struct fuse_req *req = fuse_get_req(fc);

	struct fuse_req *req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -647,7 +672,7 @@ static int fuse_symlink(struct inode *dir, struct dentry *entry, 
{

	struct fuse_conn *fc = get_fuse_conn(dir);

	unsigned len = strlen(link) + 1;

	struct fuse_req *req = fuse_get_req(fc);

	struct fuse_req *req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -664,7 +689,7 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry) 
{

	int err;

	struct fuse_conn *fc = get_fuse_conn(dir);

	struct fuse_req *req = fuse_get_req(fc);

	struct fuse_req *req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -682,6 +707,13 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry) 


		spin_lock(&fc->lock);

		fi->attr_version = ++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

		 * difficult to enforce correct nlink usage so just ignore this

		 * condition here

		 */

		if (inode->i_nlink > 0)

			drop_nlink(inode);

		spin_unlock(&fc->lock);

		fuse_invalidate_attr(inode);
@@ -696,7 +728,7 @@ static int fuse_rmdir(struct inode *dir, struct dentry *entry) 
{

	int err;

	struct fuse_conn *fc = get_fuse_conn(dir);

	struct fuse_req *req = fuse_get_req(fc);

	struct fuse_req *req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -723,7 +755,7 @@ static int fuse_rename(struct inode *olddir, struct dentry *oldent, 
	int err;

	struct fuse_rename_in inarg;

	struct fuse_conn *fc = get_fuse_conn(olddir);

	struct fuse_req *req = fuse_get_req(fc);

	struct fuse_req *req = fuse_get_req_nopages(fc);



	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -776,7 +808,7 @@ static int fuse_link(struct dentry *entry, struct inode *newdir, 
	struct fuse_link_in inarg;

	struct inode *inode = entry->d_inode;

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_req *req = fuse_get_req(fc);

	struct fuse_req *req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -848,7 +880,7 @@ static int fuse_do_getattr(struct inode *inode, struct kstat *stat, 
	struct fuse_req *req;

	u64 attr_version;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -985,7 +1017,7 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid, 


/*

 * Calling into a user-controlled filesystem gives the filesystem

 * daemon ptrace-like capabilities over the requester process.  This

 * daemon ptrace-like capabilities over the current process.  This

 * means, that the filesystem daemon is able to record the exact

 * filesystem operations performed, and can also control the behavior

 * of the requester process in otherwise impossible ways.  For example
@@ -996,27 +1028,23 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid, 
 * for which the owner of the mount has ptrace privilege.  This

 * excludes processes started by other users, suid or sgid processes.

 */

int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)

int fuse_allow_current_process(struct fuse_conn *fc)

{

	const struct cred *cred;

	int ret;



	if (fc->flags & FUSE_ALLOW_OTHER)

		return 1;



	rcu_read_lock();

	ret = 0;

	cred = __task_cred(task);

	cred = current_cred();

	if (uid_eq(cred->euid, fc->user_id) &&

	    uid_eq(cred->suid, fc->user_id) &&

	    uid_eq(cred->uid,  fc->user_id) &&

	    gid_eq(cred->egid, fc->group_id) &&

	    gid_eq(cred->sgid, fc->group_id) &&

	    gid_eq(cred->gid,  fc->group_id))

		ret = 1;

	rcu_read_unlock();

		return 1;



	return ret;

	return 0;

}



static int fuse_access(struct inode *inode, int mask)
@@ -1029,7 +1057,7 @@ static int fuse_access(struct inode *inode, int mask) 
	if (fc->no_access)

		return 0;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -1077,7 +1105,7 @@ static int fuse_permission(struct inode *inode, int mask) 
	bool refreshed = false;

	int err = 0;



	if (!fuse_allow_task(fc, current))

	if (!fuse_allow_current_process(fc))

		return -EACCES;



	/*
@@ -1155,19 +1183,157 @@ static int parse_dirfile(char *buf, size_t nbytes, struct file *file, 
	return 0;

}



static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)

static int fuse_direntplus_link(struct file *file,

				struct fuse_direntplus *direntplus,

				u64 attr_version)

{

	int err;

	struct fuse_entry_out *o = &direntplus->entry_out;

	struct fuse_dirent *dirent = &direntplus->dirent;

	struct dentry *parent = file->f_path.dentry;

	struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);

	struct dentry *dentry;

	struct dentry *alias;

	struct inode *dir = parent->d_inode;

	struct fuse_conn *fc;

	struct inode *inode;



	if (!o->nodeid) {

		/*

		 * Unlike in the case of fuse_lookup, zero nodeid does not mean

		 * ENOENT. Instead, it only means the userspace filesystem did

		 * not want to return attributes/handle for this entry.

		 *

		 * So do nothing.

		 */

		return 0;

	}



	if (name.name[0] == '.') {

		/*

		 * We could potentially refresh the attributes of the directory

		 * and its parent?

		 */

		if (name.len == 1)

			return 0;

		if (name.name[1] == '.' && name.len == 2)

			return 0;

	}

	fc = get_fuse_conn(dir);



	name.hash = full_name_hash(name.name, name.len);

	dentry = d_lookup(parent, &name);

	if (dentry && dentry->d_inode) {

		inode = dentry->d_inode;

		if (get_node_id(inode) == o->nodeid) {

			struct fuse_inode *fi;

			fi = get_fuse_inode(inode);

			spin_lock(&fc->lock);

			fi->nlookup++;

			spin_unlock(&fc->lock);



			/*

			 * The other branch to 'found' comes via fuse_iget()

			 * which bumps nlookup inside

			 */

			goto found;

		}

		err = d_invalidate(dentry);

		if (err)

			goto out;

		dput(dentry);

		dentry = NULL;

	}



	dentry = d_alloc(parent, &name);

	err = -ENOMEM;

	if (!dentry)

		goto out;



	inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,

			  &o->attr, entry_attr_timeout(o), attr_version);

	if (!inode)

		goto out;



	alias = d_materialise_unique(dentry, inode);

	err = PTR_ERR(alias);

	if (IS_ERR(alias))

		goto out;

	if (alias) {

		dput(dentry);

		dentry = alias;

	}



found:

	fuse_change_attributes(inode, &o->attr, entry_attr_timeout(o),

			       attr_version);



	fuse_change_entry_timeout(dentry, o);



	err = 0;

out:

	if (dentry)

		dput(dentry);

	return err;

}



static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,

			     void *dstbuf, filldir_t filldir, u64 attr_version)

{

	struct fuse_direntplus *direntplus;

	struct fuse_dirent *dirent;

	size_t reclen;

	int over = 0;

	int ret;



	while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {

		direntplus = (struct fuse_direntplus *) buf;

		dirent = &direntplus->dirent;

		reclen = FUSE_DIRENTPLUS_SIZE(direntplus);



		if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)

			return -EIO;

		if (reclen > nbytes)

			break;



		if (!over) {

			/* We fill entries into dstbuf only as much as

			   it can hold. But we still continue iterating

			   over remaining entries to link them. If not,

			   we need to send a FORGET for each of those

			   which we did not link.

			*/

			over = filldir(dstbuf, dirent->name, dirent->namelen,

				       file->f_pos, dirent->ino,

				       dirent->type);

			file->f_pos = dirent->off;

		}



		buf += reclen;

		nbytes -= reclen;



		ret = fuse_direntplus_link(file, direntplus, attr_version);

		if (ret)

			fuse_force_forget(file, direntplus->entry_out.nodeid);

	}



	return 0;

}



static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)

{

	int plus, err;

	size_t nbytes;

	struct page *page;

	struct inode *inode = file->f_path.dentry->d_inode;

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_req *req;

	u64 attr_version = 0;



	if (is_bad_inode(inode))

		return -EIO;



	req = fuse_get_req(fc);

	req = fuse_get_req(fc, 1);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -1176,17 +1342,34 @@ static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir) 
		fuse_put_request(fc, req);

		return -ENOMEM;

	}



	plus = fuse_use_readdirplus(inode, file);

	req->out.argpages = 1;

	req->num_pages = 1;

	req->pages[0] = page;

	fuse_read_fill(req, file, file->f_pos, PAGE_SIZE, FUSE_READDIR);

	req->page_descs[0].length = PAGE_SIZE;

	if (plus) {

		attr_version = fuse_get_attr_version(fc);

		fuse_read_fill(req, file, file->f_pos, PAGE_SIZE,

			       FUSE_READDIRPLUS);

	} else {

		fuse_read_fill(req, file, file->f_pos, PAGE_SIZE,

			       FUSE_READDIR);

	}

	fuse_request_send(fc, req);

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

	err = req->out.h.error;

	fuse_put_request(fc, req);

	if (!err)

		err = parse_dirfile(page_address(page), nbytes, file, dstbuf,

				    filldir);

	if (!err) {

		if (plus) {

			err = parse_dirplusfile(page_address(page), nbytes,

						file, dstbuf, filldir,

						attr_version);

		} else {

			err = parse_dirfile(page_address(page), nbytes, file,

					    dstbuf, filldir);

		}

	}



	__free_page(page);

	fuse_invalidate_attr(inode); /* atime changed */
@@ -1197,7 +1380,7 @@ static char *read_link(struct dentry *dentry) 
{

	struct inode *inode = dentry->d_inode;

	struct fuse_conn *fc = get_fuse_conn(inode);

	struct fuse_req *req = fuse_get_req(fc);

	struct fuse_req *req = fuse_get_req_nopages(fc);

	char *link;



	if (IS_ERR(req))
@@ -1391,7 +1574,7 @@ static int fuse_do_setattr(struct dentry *entry, struct iattr *attr, 
	loff_t oldsize;

	int err;



	if (!fuse_allow_task(fc, current))

	if (!fuse_allow_current_process(fc))

		return -EACCES;



	if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
@@ -1410,7 +1593,7 @@ static int fuse_do_setattr(struct dentry *entry, struct iattr *attr, 
	if (attr->ia_valid & ATTR_SIZE)

		is_truncate = true;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -1500,7 +1683,7 @@ static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry, 
	struct inode *inode = entry->d_inode;

	struct fuse_conn *fc = get_fuse_conn(inode);



	if (!fuse_allow_task(fc, current))

	if (!fuse_allow_current_process(fc))

		return -EACCES;



	return fuse_update_attributes(inode, stat, NULL, NULL);
@@ -1518,7 +1701,7 @@ static int fuse_setxattr(struct dentry *entry, const char *name, 
	if (fc->no_setxattr)

		return -EOPNOTSUPP;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -1557,7 +1740,7 @@ static ssize_t fuse_getxattr(struct dentry *entry, const char *name, 
	if (fc->no_getxattr)

		return -EOPNOTSUPP;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -1603,13 +1786,13 @@ static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size) 
	struct fuse_getxattr_out outarg;

	ssize_t ret;



	if (!fuse_allow_task(fc, current))

	if (!fuse_allow_current_process(fc))

		return -EACCES;



	if (fc->no_listxattr)

		return -EOPNOTSUPP;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -1654,7 +1837,7 @@ static int fuse_removexattr(struct dentry *entry, const char *name) 
	if (fc->no_removexattr)

		return -EOPNOTSUPP;



	req = fuse_get_req(fc);

	req = fuse_get_req_nopages(fc);

	if (IS_ERR(req))

		return PTR_ERR(req);

fs/fuse/file.c

+154 −84

File changed.

Preview size limit exceeded, changes collapsed.

fs/fuse/fuse_i.h

+61 −13
Original line number Diff line number Diff line
@@ -44,6 +44,9 @@ 
    doing the mount will be allowed to access the filesystem */

#define FUSE_ALLOW_OTHER         (1 << 1)



/** Number of page pointers embedded in fuse_req */

#define FUSE_REQ_INLINE_PAGES 1



/** List of active connections */

extern struct list_head fuse_conn_list;
@@ -103,6 +106,15 @@ struct fuse_inode { 


	/** List of writepage requestst (pending or sent) */

	struct list_head writepages;



	/** Miscellaneous bits describing inode state */

	unsigned long state;

};



/** FUSE inode state bits */

enum {

	/** Advise readdirplus  */

	FUSE_I_ADVISE_RDPLUS,

};



struct fuse_conn;
@@ -200,6 +212,12 @@ struct fuse_out { 
	struct fuse_arg args[3];

};



/** FUSE page descriptor */

struct fuse_page_desc {

	unsigned int length;

	unsigned int offset;

};



/** The request state */

enum fuse_req_state {

	FUSE_REQ_INIT = 0,
@@ -291,14 +309,23 @@ struct fuse_req { 
	} misc;



	/** page vector */

	struct page *pages[FUSE_MAX_PAGES_PER_REQ];

	struct page **pages;



	/** page-descriptor vector */

	struct fuse_page_desc *page_descs;



	/** size of the 'pages' array */

	unsigned max_pages;



	/** inline page vector */

	struct page *inline_pages[FUSE_REQ_INLINE_PAGES];



	/** inline page-descriptor vector */

	struct fuse_page_desc inline_page_descs[FUSE_REQ_INLINE_PAGES];



	/** number of pages in vector */

	unsigned num_pages;



	/** offset of data on first page */

	unsigned page_offset;



	/** File used in the request (or NULL) */

	struct fuse_file *ff;
@@ -487,6 +514,12 @@ struct fuse_conn { 
	/** Use enhanced/automatic page cache invalidation. */

	unsigned auto_inval_data:1;



	/** Does the filesystem support readdirplus? */

	unsigned do_readdirplus:1;



	/** Does the filesystem want adaptive readdirplus? */

	unsigned readdirplus_auto:1;



	/** The number of requests waiting for completion */

	atomic_t num_waiting;
@@ -578,6 +611,9 @@ void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget, 


struct fuse_forget_link *fuse_alloc_forget(void);



/* Used by READDIRPLUS */

void fuse_force_forget(struct file *file, u64 nodeid);



/**

 * Initialize READ or READDIR request

 */
@@ -658,9 +694,9 @@ void fuse_ctl_cleanup(void); 
/**

 * Allocate a request

 */

struct fuse_req *fuse_request_alloc(void);

struct fuse_req *fuse_request_alloc(unsigned npages);



struct fuse_req *fuse_request_alloc_nofs(void);

struct fuse_req *fuse_request_alloc_nofs(unsigned npages);



/**

 * Free a request
@@ -668,14 +704,25 @@ struct fuse_req *fuse_request_alloc_nofs(void); 
void fuse_request_free(struct fuse_req *req);



/**

 * Get a request, may fail with -ENOMEM

 * Get a request, may fail with -ENOMEM,

 * caller should specify # elements in req->pages[] explicitly

 */

struct fuse_req *fuse_get_req(struct fuse_conn *fc);

struct fuse_req *fuse_get_req(struct fuse_conn *fc, unsigned npages);



/**

 * 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

 */

struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file);

struct fuse_req *fuse_get_req_nofail_nopages(struct fuse_conn *fc,

					     struct file *file);



/**

 * Decrement reference count of a request.  If count goes to zero free
@@ -739,9 +786,9 @@ void fuse_ctl_remove_conn(struct fuse_conn *fc); 
int fuse_valid_type(int m);



/**

 * Is task allowed to perform filesystem operation?

 * Is current process allowed to perform filesystem operation?

 */

int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task);

int fuse_allow_current_process(struct fuse_conn *fc);



u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id);
@@ -776,8 +823,9 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid, 


int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file,

		 bool isdir);

ssize_t fuse_direct_io(struct file *file, const char __user *buf,

		       size_t count, loff_t *ppos, int write);

ssize_t fuse_direct_io(struct file *file, const struct iovec *iov,

		       unsigned long nr_segs, size_t count, loff_t *ppos,

		       int write);

long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,

		   unsigned int flags);

long fuse_ioctl_common(struct file *file, unsigned int cmd,