Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse: mm: export generic_pipe_buf_*() to modules fuse: support splice() reading from fuse device fuse: allow splice to move pages mm: export remove_from_page_cache() to modules mm: export lru_cache_add_*() to modules fuse: support splice() writing to fuse device fuse: get page reference for readpages fuse: use get_user_pages_fast() fuse: remove unneeded variable
This commit is contained in:
Linus Torvalds
commit
003386fff3
7 changed files with 500 additions and 82 deletions
527
fs/fuse/dev.c
527
fs/fuse/dev.c
|
|
@ -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,26 +562,61 @@ static int fuse_copy_fill(struct fuse_copy_state *cs)
|
|||
|
||||
unlock_request(cs->fc, cs->req);
|
||||
fuse_copy_finish(cs);
|
||||
if (!cs->seglen) {
|
||||
BUG_ON(!cs->nr_segs);
|
||||
cs->seglen = cs->iov[0].iov_len;
|
||||
cs->addr = (unsigned long) cs->iov[0].iov_base;
|
||||
cs->iov++;
|
||||
cs->nr_segs--;
|
||||
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;
|
||||
cs->addr = (unsigned long) cs->iov[0].iov_base;
|
||||
cs->iov++;
|
||||
cs->nr_segs--;
|
||||
}
|
||||
err = get_user_pages_fast(cs->addr, 1, cs->write, &cs->pg);
|
||||
if (err < 0)
|
||||
return err;
|
||||
BUG_ON(err != 1);
|
||||
offset = cs->addr % PAGE_SIZE;
|
||||
cs->mapaddr = kmap_atomic(cs->pg, KM_USER0);
|
||||
cs->buf = cs->mapaddr + offset;
|
||||
cs->len = min(PAGE_SIZE - offset, cs->seglen);
|
||||
cs->seglen -= cs->len;
|
||||
cs->addr += cs->len;
|
||||
}
|
||||
down_read(¤t->mm->mmap_sem);
|
||||
err = get_user_pages(current, current->mm, cs->addr, 1, cs->write, 0,
|
||||
&cs->pg, NULL);
|
||||
up_read(¤t->mm->mmap_sem);
|
||||
if (err < 0)
|
||||
return err;
|
||||
BUG_ON(err != 1);
|
||||
offset = cs->addr % PAGE_SIZE;
|
||||
cs->mapaddr = kmap_atomic(cs->pg, KM_USER0);
|
||||
cs->buf = cs->mapaddr + offset;
|
||||
cs->len = min(PAGE_SIZE - offset, cs->seglen);
|
||||
cs->seglen -= cs->len;
|
||||
cs->addr += cs->len;
|
||||
|
||||
return lock_request(cs->fc, cs->req);
|
||||
}
|
||||
|
|
@ -586,23 +638,178 @@ 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 (err)
|
||||
return err;
|
||||
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);
|
||||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -516,18 +516,27 @@ 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;
|
||||
|
||||
/*
|
||||
* 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);
|
||||
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;
|
||||
|
||||
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 */
|
||||
}
|
||||
|
||||
fuse_invalidate_attr(inode); /* atime changed */
|
||||
|
||||
for (i = 0; i < req->num_pages; i++) {
|
||||
struct page *page = req->pages[i];
|
||||
if (!req->out.h.error)
|
||||
|
|
@ -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(¤t->mm->mmap_sem);
|
||||
npages = get_user_pages(current, current->mm, user_addr, npages, !write,
|
||||
0, req->pages, NULL);
|
||||
up_read(¤t->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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -151,6 +151,7 @@ void remove_from_page_cache(struct page *page)
|
|||
spin_unlock_irq(&mapping->tree_lock);
|
||||
mem_cgroup_uncharge_cache_page(page);
|
||||
}
|
||||
EXPORT_SYMBOL(remove_from_page_cache);
|
||||
|
||||
static int sync_page(void *word)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -224,6 +224,7 @@ void __lru_cache_add(struct page *page, enum lru_list lru)
|
|||
____pagevec_lru_add(pvec, lru);
|
||||
put_cpu_var(lru_add_pvecs);
|
||||
}
|
||||
EXPORT_SYMBOL(__lru_cache_add);
|
||||
|
||||
/**
|
||||
* lru_cache_add_lru - add a page to a page list
|
||||
|
|
|
|||
Loading…
Reference in a new issue