Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse (003386ff) · Commits · e / devices / android_kernel_teracube_2e

fs/fuse/dev.c

+461 −66

Original line number	Diff line number	Diff line
		@@ -16,6 +16,9 @@
		#include <linux/pagemap.h>
		#include <linux/file.h>
		#include <linux/slab.h>
		#include <linux/pipe_fs_i.h>
		#include <linux/swap.h>
		#include <linux/splice.h>

		MODULE_ALIAS_MISCDEV(FUSE_MINOR);
		MODULE_ALIAS("devname:fuse");
		@@ -499,6 +502,9 @@ struct fuse_copy_state {
		int write;
		struct fuse_req *req;
		const struct iovec *iov;
		struct pipe_buffer *pipebufs;
		struct pipe_buffer *currbuf;
		struct pipe_inode_info *pipe;
		unsigned long nr_segs;
		unsigned long seglen;
		unsigned long addr;
		@@ -506,16 +512,16 @@ struct fuse_copy_state {
		void *mapaddr;
		void *buf;
		unsigned len;
		unsigned move_pages:1;
		};

		static void fuse_copy_init(struct fuse_copy_state cs, struct fuse_conn fc,
		int write, struct fuse_req *req,
		int write,
		const struct iovec *iov, unsigned long nr_segs)
		{
		memset(cs, 0, sizeof(*cs));
		cs->fc = fc;
		cs->write = write;
		cs->req = req;
		cs->iov = iov;
		cs->nr_segs = nr_segs;
		}
		@@ -523,7 +529,18 @@ static void fuse_copy_init(struct fuse_copy_state cs, struct fuse_conn fc,
		/* Unmap and put previous page of userspace buffer */
		static void fuse_copy_finish(struct fuse_copy_state *cs)
		{
		if (cs->mapaddr) {
		if (cs->currbuf) {
		struct pipe_buffer *buf = cs->currbuf;

		if (!cs->write) {
		buf->ops->unmap(cs->pipe, buf, cs->mapaddr);
		} else {
		kunmap_atomic(cs->mapaddr, KM_USER0);
		buf->len = PAGE_SIZE - cs->len;
		}
		cs->currbuf = NULL;
		cs->mapaddr = NULL;
		} else if (cs->mapaddr) {
		kunmap_atomic(cs->mapaddr, KM_USER0);
		if (cs->write) {
		flush_dcache_page(cs->pg);
		@@ -545,6 +562,43 @@ static int fuse_copy_fill(struct fuse_copy_state *cs)

		unlock_request(cs->fc, cs->req);
		fuse_copy_finish(cs);
		if (cs->pipebufs) {
		struct pipe_buffer *buf = cs->pipebufs;

		if (!cs->write) {
		err = buf->ops->confirm(cs->pipe, buf);
		if (err)
		return err;

		BUG_ON(!cs->nr_segs);
		cs->currbuf = buf;
		cs->mapaddr = buf->ops->map(cs->pipe, buf, 1);
		cs->len = buf->len;
		cs->buf = cs->mapaddr + buf->offset;
		cs->pipebufs++;
		cs->nr_segs--;
		} else {
		struct page *page;

		if (cs->nr_segs == cs->pipe->buffers)
		return -EIO;

		page = alloc_page(GFP_HIGHUSER);
		if (!page)
		return -ENOMEM;

		buf->page = page;
		buf->offset = 0;
		buf->len = 0;

		cs->currbuf = buf;
		cs->mapaddr = kmap_atomic(page, KM_USER0);
		cs->buf = cs->mapaddr;
		cs->len = PAGE_SIZE;
		cs->pipebufs++;
		cs->nr_segs++;
		}
		} else {
		if (!cs->seglen) {
		BUG_ON(!cs->nr_segs);
		cs->seglen = cs->iov[0].iov_len;
		@@ -552,10 +606,7 @@ static int fuse_copy_fill(struct fuse_copy_state *cs)
		cs->iov++;
		cs->nr_segs--;
		}
		down_read(&current->mm->mmap_sem);
		err = get_user_pages(current, current->mm, cs->addr, 1, cs->write, 0,
		&cs->pg, NULL);
		up_read(&current->mm->mmap_sem);
		err = get_user_pages_fast(cs->addr, 1, cs->write, &cs->pg);
		if (err < 0)
		return err;
		BUG_ON(err != 1);
		@@ -565,6 +616,7 @@ static int fuse_copy_fill(struct fuse_copy_state *cs)
		cs->len = min(PAGE_SIZE - offset, cs->seglen);
		cs->seglen -= cs->len;
		cs->addr += cs->len;
		}

		return lock_request(cs->fc, cs->req);
		}
		@@ -586,24 +638,179 @@ static int fuse_copy_do(struct fuse_copy_state cs, void val, unsigned size)
		return ncpy;
		}

		static int fuse_check_page(struct page *page)
		{
		if (page_mapcount(page) \|\|
		page->mapping != NULL \|\|
		page_count(page) != 1 \|\|
		(page->flags & PAGE_FLAGS_CHECK_AT_PREP &
		~(1 << PG_locked \|
		1 << PG_referenced \|
		1 << PG_uptodate \|
		1 << PG_lru \|
		1 << PG_active \|
		1 << PG_reclaim))) {
		printk(KERN_WARNING "fuse: trying to steal weird page\n");
		printk(KERN_WARNING " page=%p index=%li flags=%08lx, count=%i, mapcount=%i, mapping=%p\n", page, page->index, page->flags, page_count(page), page_mapcount(page), page->mapping);
		return 1;
		}
		return 0;
		}

		static int fuse_try_move_page(struct fuse_copy_state cs, struct page *pagep)
		{
		int err;
		struct page oldpage = pagep;
		struct page *newpage;
		struct pipe_buffer *buf = cs->pipebufs;
		struct address_space *mapping;
		pgoff_t index;

		unlock_request(cs->fc, cs->req);
		fuse_copy_finish(cs);

		err = buf->ops->confirm(cs->pipe, buf);
		if (err)
		return err;

		BUG_ON(!cs->nr_segs);
		cs->currbuf = buf;
		cs->len = buf->len;
		cs->pipebufs++;
		cs->nr_segs--;

		if (cs->len != PAGE_SIZE)
		goto out_fallback;

		if (buf->ops->steal(cs->pipe, buf) != 0)
		goto out_fallback;

		newpage = buf->page;

		if (WARN_ON(!PageUptodate(newpage)))
		return -EIO;

		ClearPageMappedToDisk(newpage);

		if (fuse_check_page(newpage) != 0)
		goto out_fallback_unlock;

		mapping = oldpage->mapping;
		index = oldpage->index;

		/*
		* This is a new and locked page, it shouldn't be mapped or
		* have any special flags on it
		*/
		if (WARN_ON(page_mapped(oldpage)))
		goto out_fallback_unlock;
		if (WARN_ON(page_has_private(oldpage)))
		goto out_fallback_unlock;
		if (WARN_ON(PageDirty(oldpage) \|\| PageWriteback(oldpage)))
		goto out_fallback_unlock;
		if (WARN_ON(PageMlocked(oldpage)))
		goto out_fallback_unlock;

		remove_from_page_cache(oldpage);
		page_cache_release(oldpage);

		err = add_to_page_cache_locked(newpage, mapping, index, GFP_KERNEL);
		if (err) {
		printk(KERN_WARNING "fuse_try_move_page: failed to add page");
		goto out_fallback_unlock;
		}
		page_cache_get(newpage);

		if (!(buf->flags & PIPE_BUF_FLAG_LRU))
		lru_cache_add_file(newpage);

		err = 0;
		spin_lock(&cs->fc->lock);
		if (cs->req->aborted)
		err = -ENOENT;
		else
		*pagep = newpage;
		spin_unlock(&cs->fc->lock);

		if (err) {
		unlock_page(newpage);
		page_cache_release(newpage);
		return err;
		}

		unlock_page(oldpage);
		page_cache_release(oldpage);
		cs->len = 0;

		return 0;

		out_fallback_unlock:
		unlock_page(newpage);
		out_fallback:
		cs->mapaddr = buf->ops->map(cs->pipe, buf, 1);
		cs->buf = cs->mapaddr + buf->offset;

		err = lock_request(cs->fc, cs->req);
		if (err)
		return err;

		return 1;
		}

		static int fuse_ref_page(struct fuse_copy_state cs, struct page page,
		unsigned offset, unsigned count)
		{
		struct pipe_buffer *buf;

		if (cs->nr_segs == cs->pipe->buffers)
		return -EIO;

		unlock_request(cs->fc, cs->req);
		fuse_copy_finish(cs);

		buf = cs->pipebufs;
		page_cache_get(page);
		buf->page = page;
		buf->offset = offset;
		buf->len = count;

		cs->pipebufs++;
		cs->nr_segs++;
		cs->len = 0;

		return 0;
		}

		/*
		* Copy a page in the request to/from the userspace buffer. Must be
		* done atomically
		*/
		static int fuse_copy_page(struct fuse_copy_state cs, struct page page,
		static int fuse_copy_page(struct fuse_copy_state cs, struct page *pagep,
		unsigned offset, unsigned count, int zeroing)
		{
		int err;
		struct page page = pagep;

		if (page && zeroing && count < PAGE_SIZE) {
		void *mapaddr = kmap_atomic(page, KM_USER1);
		memset(mapaddr, 0, PAGE_SIZE);
		kunmap_atomic(mapaddr, KM_USER1);
		}
		while (count) {
		if (!cs->len) {
		int err = fuse_copy_fill(cs);
		if (cs->write && cs->pipebufs && page) {
		return fuse_ref_page(cs, page, offset, count);
		} else if (!cs->len) {
		if (cs->move_pages && page &&
		offset == 0 && count == PAGE_SIZE) {
		err = fuse_try_move_page(cs, pagep);
		if (err <= 0)
		return err;
		} else {
		err = fuse_copy_fill(cs);
		if (err)
		return err;
		}
		}
		if (page) {
		void *mapaddr = kmap_atomic(page, KM_USER1);
		void *buf = mapaddr + offset;
		@@ -627,8 +834,10 @@ static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes,
		unsigned count = min(nbytes, (unsigned) PAGE_SIZE - offset);

		for (i = 0; i < req->num_pages && (nbytes \|\| zeroing); i++) {
		struct page *page = req->pages[i];
		int err = fuse_copy_page(cs, page, offset, count, zeroing);
		int err;

		err = fuse_copy_page(cs, &req->pages[i], offset, count,
		zeroing);
		if (err)
		return err;

		@@ -705,11 +914,10 @@ __acquires(&fc->lock)
		*
		* Called with fc->lock held, releases it
		*/
		static int fuse_read_interrupt(struct fuse_conn fc, struct fuse_req req,
		const struct iovec *iov, unsigned long nr_segs)
		static int fuse_read_interrupt(struct fuse_conn fc, struct fuse_copy_state cs,
		size_t nbytes, struct fuse_req *req)
		__releases(&fc->lock)
		{
		struct fuse_copy_state cs;
		struct fuse_in_header ih;
		struct fuse_interrupt_in arg;
		unsigned reqsize = sizeof(ih) + sizeof(arg);
		@@ -725,14 +933,13 @@ __releases(&fc->lock)
		arg.unique = req->in.h.unique;

		spin_unlock(&fc->lock);
		if (iov_length(iov, nr_segs) < reqsize)
		if (nbytes < reqsize)
		return -EINVAL;

		fuse_copy_init(&cs, fc, 1, NULL, iov, nr_segs);
		err = fuse_copy_one(&cs, &ih, sizeof(ih));
		err = fuse_copy_one(cs, &ih, sizeof(ih));
		if (!err)
		err = fuse_copy_one(&cs, &arg, sizeof(arg));
		fuse_copy_finish(&cs);
		err = fuse_copy_one(cs, &arg, sizeof(arg));
		fuse_copy_finish(cs);

		return err ? err : reqsize;
		}
		@@ -746,18 +953,13 @@ __releases(&fc->lock)
		* request_end(). Otherwise add it to the processing list, and set
		* the 'sent' flag.
		*/
		static ssize_t fuse_dev_read(struct kiocb iocb, const struct iovec iov,
		unsigned long nr_segs, loff_t pos)
		static ssize_t fuse_dev_do_read(struct fuse_conn fc, struct file file,
		struct fuse_copy_state *cs, size_t nbytes)
		{
		int err;
		struct fuse_req *req;
		struct fuse_in *in;
		struct fuse_copy_state cs;
		unsigned reqsize;
		struct file *file = iocb->ki_filp;
		struct fuse_conn *fc = fuse_get_conn(file);
		if (!fc)
		return -EPERM;

		restart:
		spin_lock(&fc->lock);
		@@ -777,7 +979,7 @@ static ssize_t fuse_dev_read(struct kiocb iocb, const struct iovec iov,
		if (!list_empty(&fc->interrupts)) {
		req = list_entry(fc->interrupts.next, struct fuse_req,
		intr_entry);
		return fuse_read_interrupt(fc, req, iov, nr_segs);
		return fuse_read_interrupt(fc, cs, nbytes, req);
		}

		req = list_entry(fc->pending.next, struct fuse_req, list);
		@@ -787,7 +989,7 @@ static ssize_t fuse_dev_read(struct kiocb iocb, const struct iovec iov,
		in = &req->in;
		reqsize = in->h.len;
		/* If request is too large, reply with an error and restart the read */
		if (iov_length(iov, nr_segs) < reqsize) {
		if (nbytes < reqsize) {
		req->out.h.error = -EIO;
		/* SETXATTR is special, since it may contain too large data */
		if (in->h.opcode == FUSE_SETXATTR)
		@@ -796,12 +998,12 @@ static ssize_t fuse_dev_read(struct kiocb iocb, const struct iovec iov,
		goto restart;
		}
		spin_unlock(&fc->lock);
		fuse_copy_init(&cs, fc, 1, req, iov, nr_segs);
		err = fuse_copy_one(&cs, &in->h, sizeof(in->h));
		cs->req = req;
		err = fuse_copy_one(cs, &in->h, sizeof(in->h));
		if (!err)
		err = fuse_copy_args(&cs, in->numargs, in->argpages,
		err = fuse_copy_args(cs, in->numargs, in->argpages,
		(struct fuse_arg *) in->args, 0);
		fuse_copy_finish(&cs);
		fuse_copy_finish(cs);
		spin_lock(&fc->lock);
		req->locked = 0;
		if (req->aborted) {
		@@ -829,6 +1031,110 @@ static ssize_t fuse_dev_read(struct kiocb iocb, const struct iovec iov,
		return err;
		}

		static ssize_t fuse_dev_read(struct kiocb iocb, const struct iovec iov,
		unsigned long nr_segs, loff_t pos)
		{
		struct fuse_copy_state cs;
		struct file *file = iocb->ki_filp;
		struct fuse_conn *fc = fuse_get_conn(file);
		if (!fc)
		return -EPERM;

		fuse_copy_init(&cs, fc, 1, iov, nr_segs);

		return fuse_dev_do_read(fc, file, &cs, iov_length(iov, nr_segs));
		}

		static int fuse_dev_pipe_buf_steal(struct pipe_inode_info *pipe,
		struct pipe_buffer *buf)
		{
		return 1;
		}

		static const struct pipe_buf_operations fuse_dev_pipe_buf_ops = {
		.can_merge = 0,
		.map = generic_pipe_buf_map,
		.unmap = generic_pipe_buf_unmap,
		.confirm = generic_pipe_buf_confirm,
		.release = generic_pipe_buf_release,
		.steal = fuse_dev_pipe_buf_steal,
		.get = generic_pipe_buf_get,
		};

		static ssize_t fuse_dev_splice_read(struct file in, loff_t ppos,
		struct pipe_inode_info *pipe,
		size_t len, unsigned int flags)
		{
		int ret;
		int page_nr = 0;
		int do_wakeup = 0;
		struct pipe_buffer *bufs;
		struct fuse_copy_state cs;
		struct fuse_conn *fc = fuse_get_conn(in);
		if (!fc)
		return -EPERM;

		bufs = kmalloc(pipe->buffers * sizeof (struct pipe_buffer), GFP_KERNEL);
		if (!bufs)
		return -ENOMEM;

		fuse_copy_init(&cs, fc, 1, NULL, 0);
		cs.pipebufs = bufs;
		cs.pipe = pipe;
		ret = fuse_dev_do_read(fc, in, &cs, len);
		if (ret < 0)
		goto out;

		ret = 0;
		pipe_lock(pipe);

		if (!pipe->readers) {
		send_sig(SIGPIPE, current, 0);
		if (!ret)
		ret = -EPIPE;
		goto out_unlock;
		}

		if (pipe->nrbufs + cs.nr_segs > pipe->buffers) {
		ret = -EIO;
		goto out_unlock;
		}

		while (page_nr < cs.nr_segs) {
		int newbuf = (pipe->curbuf + pipe->nrbufs) & (pipe->buffers - 1);
		struct pipe_buffer *buf = pipe->bufs + newbuf;

		buf->page = bufs[page_nr].page;
		buf->offset = bufs[page_nr].offset;
		buf->len = bufs[page_nr].len;
		buf->ops = &fuse_dev_pipe_buf_ops;

		pipe->nrbufs++;
		page_nr++;
		ret += buf->len;

		if (pipe->inode)
		do_wakeup = 1;
		}

		out_unlock:
		pipe_unlock(pipe);

		if (do_wakeup) {
		smp_mb();
		if (waitqueue_active(&pipe->wait))
		wake_up_interruptible(&pipe->wait);
		kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
		}

		out:
		for (; page_nr < cs.nr_segs; page_nr++)
		page_cache_release(bufs[page_nr].page);

		kfree(bufs);
		return ret;
		}

		static int fuse_notify_poll(struct fuse_conn *fc, unsigned int size,
		struct fuse_copy_state *cs)
		{
		@@ -988,23 +1294,17 @@ static int copy_out_args(struct fuse_copy_state cs, struct fuse_out out,
		* it from the list and copy the rest of the buffer to the request.
		* The request is finished by calling request_end()
		*/
		static ssize_t fuse_dev_write(struct kiocb iocb, const struct iovec iov,
		unsigned long nr_segs, loff_t pos)
		static ssize_t fuse_dev_do_write(struct fuse_conn *fc,
		struct fuse_copy_state *cs, size_t nbytes)
		{
		int err;
		size_t nbytes = iov_length(iov, nr_segs);
		struct fuse_req *req;
		struct fuse_out_header oh;
		struct fuse_copy_state cs;
		struct fuse_conn *fc = fuse_get_conn(iocb->ki_filp);
		if (!fc)
		return -EPERM;

		fuse_copy_init(&cs, fc, 0, NULL, iov, nr_segs);
		if (nbytes < sizeof(struct fuse_out_header))
		return -EINVAL;

		err = fuse_copy_one(&cs, &oh, sizeof(oh));
		err = fuse_copy_one(cs, &oh, sizeof(oh));
		if (err)
		goto err_finish;

		@@ -1017,7 +1317,7 @@ static ssize_t fuse_dev_write(struct kiocb iocb, const struct iovec iov,
		* and error contains notification code.
		*/
		if (!oh.unique) {
		err = fuse_notify(fc, oh.error, nbytes - sizeof(oh), &cs);
		err = fuse_notify(fc, oh.error, nbytes - sizeof(oh), cs);
		return err ? err : nbytes;
		}

		@@ -1036,7 +1336,7 @@ static ssize_t fuse_dev_write(struct kiocb iocb, const struct iovec iov,

		if (req->aborted) {
		spin_unlock(&fc->lock);
		fuse_copy_finish(&cs);
		fuse_copy_finish(cs);
		spin_lock(&fc->lock);
		request_end(fc, req);
		return -ENOENT;
		@@ -1053,7 +1353,7 @@ static ssize_t fuse_dev_write(struct kiocb iocb, const struct iovec iov,
		queue_interrupt(fc, req);

		spin_unlock(&fc->lock);
		fuse_copy_finish(&cs);
		fuse_copy_finish(cs);
		return nbytes;
		}

		@@ -1061,11 +1361,13 @@ static ssize_t fuse_dev_write(struct kiocb iocb, const struct iovec iov,
		list_move(&req->list, &fc->io);
		req->out.h = oh;
		req->locked = 1;
		cs.req = req;
		cs->req = req;
		if (!req->out.page_replace)
		cs->move_pages = 0;
		spin_unlock(&fc->lock);

		err = copy_out_args(&cs, &req->out, nbytes);
		fuse_copy_finish(&cs);
		err = copy_out_args(cs, &req->out, nbytes);
		fuse_copy_finish(cs);

		spin_lock(&fc->lock);
		req->locked = 0;
		@@ -1081,10 +1383,101 @@ static ssize_t fuse_dev_write(struct kiocb iocb, const struct iovec iov,
		err_unlock:
		spin_unlock(&fc->lock);
		err_finish:
		fuse_copy_finish(&cs);
		fuse_copy_finish(cs);
		return err;
		}

		static ssize_t fuse_dev_write(struct kiocb iocb, const struct iovec iov,
		unsigned long nr_segs, loff_t pos)
		{
		struct fuse_copy_state cs;
		struct fuse_conn *fc = fuse_get_conn(iocb->ki_filp);
		if (!fc)
		return -EPERM;

		fuse_copy_init(&cs, fc, 0, iov, nr_segs);

		return fuse_dev_do_write(fc, &cs, iov_length(iov, nr_segs));
		}

		static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe,
		struct file out, loff_t ppos,
		size_t len, unsigned int flags)
		{
		unsigned nbuf;
		unsigned idx;
		struct pipe_buffer *bufs;
		struct fuse_copy_state cs;
		struct fuse_conn *fc;
		size_t rem;
		ssize_t ret;

		fc = fuse_get_conn(out);
		if (!fc)
		return -EPERM;

		bufs = kmalloc(pipe->buffers * sizeof (struct pipe_buffer), GFP_KERNEL);
		if (!bufs)
		return -ENOMEM;

		pipe_lock(pipe);
		nbuf = 0;
		rem = 0;
		for (idx = 0; idx < pipe->nrbufs && rem < len; idx++)
		rem += pipe->bufs[(pipe->curbuf + idx) & (pipe->buffers - 1)].len;

		ret = -EINVAL;
		if (rem < len) {
		pipe_unlock(pipe);
		goto out;
		}

		rem = len;
		while (rem) {
		struct pipe_buffer *ibuf;
		struct pipe_buffer *obuf;

		BUG_ON(nbuf >= pipe->buffers);
		BUG_ON(!pipe->nrbufs);
		ibuf = &pipe->bufs[pipe->curbuf];
		obuf = &bufs[nbuf];

		if (rem >= ibuf->len) {
		obuf = ibuf;
		ibuf->ops = NULL;
		pipe->curbuf = (pipe->curbuf + 1) & (pipe->buffers - 1);
		pipe->nrbufs--;
		} else {
		ibuf->ops->get(pipe, ibuf);
		obuf = ibuf;
		obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
		obuf->len = rem;
		ibuf->offset += obuf->len;
		ibuf->len -= obuf->len;
		}
		nbuf++;
		rem -= obuf->len;
		}
		pipe_unlock(pipe);

		fuse_copy_init(&cs, fc, 0, NULL, nbuf);
		cs.pipebufs = bufs;
		cs.pipe = pipe;

		if (flags & SPLICE_F_MOVE)
		cs.move_pages = 1;

		ret = fuse_dev_do_write(fc, &cs, len);

		for (idx = 0; idx < nbuf; idx++) {
		struct pipe_buffer *buf = &bufs[idx];
		buf->ops->release(pipe, buf);
		}
		out:
		kfree(bufs);
		return ret;
		}

		static unsigned fuse_dev_poll(struct file file, poll_table wait)
		{
		unsigned mask = POLLOUT \| POLLWRNORM;
		@@ -1226,8 +1619,10 @@ const struct file_operations fuse_dev_operations = {
		.llseek = no_llseek,
		.read = do_sync_read,
		.aio_read = fuse_dev_read,
		.splice_read = fuse_dev_splice_read,
		.write = do_sync_write,
		.aio_write = fuse_dev_write,
		.splice_write = fuse_dev_splice_write,
		.poll = fuse_dev_poll,
		.release = fuse_dev_release,
		.fasync = fuse_dev_fasync,

fs/fuse/file.c

+24 −15

Original line number	Diff line number	Diff line
		@@ -516,17 +516,26 @@ static void fuse_readpages_end(struct fuse_conn fc, struct fuse_req req)
		int i;
		size_t count = req->misc.read.in.size;
		size_t num_read = req->out.args[0].size;
		struct inode *inode = req->pages[0]->mapping->host;
		struct address_space *mapping = NULL;

		for (i = 0; mapping == NULL && i < req->num_pages; i++)
		mapping = req->pages[i]->mapping;

		if (mapping) {
		struct inode *inode = mapping->host;

		/*
		* Short read means EOF. If file size is larger, truncate it
		*/
		if (!req->out.h.error && num_read < count) {
		loff_t pos = page_offset(req->pages[0]) + num_read;
		fuse_read_update_size(inode, pos, req->misc.read.attr_ver);
		}
		loff_t pos;

		pos = page_offset(req->pages[0]) + num_read;
		fuse_read_update_size(inode, pos,
		req->misc.read.attr_ver);
		}
		fuse_invalidate_attr(inode); /* atime changed */
		}

		for (i = 0; i < req->num_pages; i++) {
		struct page *page = req->pages[i];
		@@ -535,6 +544,7 @@ static void fuse_readpages_end(struct fuse_conn fc, struct fuse_req req)
		else
		SetPageError(page);
		unlock_page(page);
		page_cache_release(page);
		}
		if (req->ff)
		fuse_file_put(req->ff);
		@@ -549,6 +559,7 @@ static void fuse_send_readpages(struct fuse_req req, struct file file)

		req->out.argpages = 1;
		req->out.page_zeroing = 1;
		req->out.page_replace = 1;
		fuse_read_fill(req, file, pos, count, FUSE_READ);
		req->misc.read.attr_ver = fuse_get_attr_version(fc);
		if (fc->async_read) {
		@@ -588,6 +599,7 @@ static int fuse_readpages_fill(void _data, struct page page)
		return PTR_ERR(req);
		}
		}
		page_cache_get(page);
		req->pages[req->num_pages] = page;
		req->num_pages++;
		return 0;
		@@ -993,10 +1005,7 @@ static int fuse_get_user_pages(struct fuse_req req, const char __user buf,
		nbytes = min_t(size_t, nbytes, FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT);
		npages = (nbytes + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
		npages = clamp(npages, 1, FUSE_MAX_PAGES_PER_REQ);
		down_read(&current->mm->mmap_sem);
		npages = get_user_pages(current, current->mm, user_addr, npages, !write,
		0, req->pages, NULL);
		up_read(&current->mm->mmap_sem);
		npages = get_user_pages_fast(user_addr, npages, !write, req->pages);
		if (npages < 0)
		return npages;

		@@ -1579,9 +1588,9 @@ static int fuse_ioctl_copy_user(struct page *pages, struct iovec iov,
		while (iov_iter_count(&ii)) {
		struct page *page = pages[page_idx++];
		size_t todo = min_t(size_t, PAGE_SIZE, iov_iter_count(&ii));
		void kaddr, map;
		void *kaddr;

		kaddr = map = kmap(page);
		kaddr = kmap(page);

		while (todo) {
		char __user *uaddr = ii.iov->iov_base + ii.iov_offset;

fs/fuse/fuse_i.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -177,6 +177,9 @@ struct fuse_out {
		/** Zero partially or not copied pages */
		unsigned page_zeroing:1;

		/** Pages may be replaced with new ones */
		unsigned page_replace:1;

		/** Number or arguments */
		unsigned numargs;

fs/pipe.c

+6 −0

Original line number	Diff line number	Diff line
		@@ -230,6 +230,7 @@ void generic_pipe_buf_map(struct pipe_inode_info pipe,

		return kmap(buf->page);
		}
		EXPORT_SYMBOL(generic_pipe_buf_map);

		/**
		* generic_pipe_buf_unmap - unmap a previously mapped pipe buffer
		@@ -249,6 +250,7 @@ void generic_pipe_buf_unmap(struct pipe_inode_info *pipe,
		} else
		kunmap(buf->page);
		}
		EXPORT_SYMBOL(generic_pipe_buf_unmap);

		/**
		* generic_pipe_buf_steal - attempt to take ownership of a &pipe_buffer
		@@ -279,6 +281,7 @@ int generic_pipe_buf_steal(struct pipe_inode_info *pipe,

		return 1;
		}
		EXPORT_SYMBOL(generic_pipe_buf_steal);

		/**
		* generic_pipe_buf_get - get a reference to a &struct pipe_buffer
		@@ -294,6 +297,7 @@ void generic_pipe_buf_get(struct pipe_inode_info pipe, struct pipe_buffer buf)
		{
		page_cache_get(buf->page);
		}
		EXPORT_SYMBOL(generic_pipe_buf_get);

		/**
		* generic_pipe_buf_confirm - verify contents of the pipe buffer
		@@ -309,6 +313,7 @@ int generic_pipe_buf_confirm(struct pipe_inode_info *info,
		{
		return 0;
		}
		EXPORT_SYMBOL(generic_pipe_buf_confirm);

		/**
		* generic_pipe_buf_release - put a reference to a &struct pipe_buffer
		@@ -323,6 +328,7 @@ void generic_pipe_buf_release(struct pipe_inode_info *pipe,
		{
		page_cache_release(buf->page);
		}
		EXPORT_SYMBOL(generic_pipe_buf_release);

		static const struct pipe_buf_operations anon_pipe_buf_ops = {
		.can_merge = 1,

include/linux/fuse.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -34,6 +34,9 @@
		* 7.13
		* - make max number of background requests and congestion threshold
		* tunables
		*
		* 7.14
		* - add splice support to fuse device
		*/

		#ifndef _LINUX_FUSE_H
		@@ -65,7 +68,7 @@
		#define FUSE_KERNEL_VERSION 7

		/** Minor version number of this interface */
		#define FUSE_KERNEL_MINOR_VERSION 13
		#define FUSE_KERNEL_MINOR_VERSION 14

		/** The node ID of the root inode */
		#define FUSE_ROOT_ID 1