a7y18lte-ubports/android_kernel_samsung_universal7885
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

loop: convert to using splice_direct_to_actor() instead of sendfile()

Browse Source 
This gets rid of the dependency on ->sendfile() for receiving data
and converts loop to ->splice_read() instead.

Also includes an IV offset fix from Hugh Dickins.

Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
This commit is contained in:
Jens Axboe 2007-06-12 21:20:37 +02:00
parent 130610d6f6
commit fd5821404e
1 changed files with 44 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
drivers/block/loop.c
View File

@ -74,6 +74,7 @@
#include <linux/highmem.h> #include <linux/highmem.h>
#include <linux/gfp.h> #include <linux/gfp.h>
#include <linux/kthread.h> #include <linux/kthread.h>
#include <linux/pipe_fs_i.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -401,50 +402,73 @@ struct lo_read_data {
}; };
static int static int
lo_read_actor(read_descriptor_t *desc, struct page *page, lo_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
unsigned long offset, unsigned long size) struct splice_desc *sd)
{ {
unsigned long count = desc->count; struct lo_read_data *p = sd->u.data;
struct lo_read_data *p = desc->arg.data;
struct loop_device *lo = p->lo; struct loop_device *lo = p->lo;
struct page *page = buf->page;
sector_t IV; sector_t IV;
size_t size;
int ret;
IV = ((sector_t) page->index << (PAGE_CACHE_SHIFT - 9))+(offset >> 9); ret = buf->ops->pin(pipe, buf);
if (unlikely(ret))
return ret;
if (size > count) IV = ((sector_t) page->index << (PAGE_CACHE_SHIFT - 9)) +
size = count; (buf->offset >> 9);
size = sd->len;
if (size > p->bsize)
size = p->bsize;
if (lo_do_transfer(lo, READ, page, offset, p->page, p->offset, size, IV)) { if (lo_do_transfer(lo, READ, page, buf->offset, p->page, p->offset, size, IV)) {
size = 0;
printk(KERN_ERR "loop: transfer error block %ld\n", printk(KERN_ERR "loop: transfer error block %ld\n",
page->index); page->index);
desc->error = -EINVAL; size = -EINVAL;
} }
flush_dcache_page(p->page); flush_dcache_page(p->page);
desc->count = count - size; if (size > 0)
desc->written += size; p->offset += size;
p->offset += size;
return size; return size;
} }
static int
lo_direct_splice_actor(struct pipe_inode_info *pipe, struct splice_desc *sd)
{
return __splice_from_pipe(pipe, sd, lo_splice_actor);
}
static int static int
do_lo_receive(struct loop_device *lo, do_lo_receive(struct loop_device *lo,
struct bio_vec *bvec, int bsize, loff_t pos) struct bio_vec *bvec, int bsize, loff_t pos)
{ {
struct lo_read_data cookie; struct lo_read_data cookie;
struct splice_desc sd;
struct file *file; struct file *file;
int retval; long retval;
cookie.lo = lo; cookie.lo = lo;
cookie.page = bvec->bv_page; cookie.page = bvec->bv_page;
cookie.offset = bvec->bv_offset; cookie.offset = bvec->bv_offset;
cookie.bsize = bsize; cookie.bsize = bsize;
sd.len = 0;
sd.total_len = bvec->bv_len;
sd.flags = 0;
sd.pos = pos;
sd.u.data = &cookie;
file = lo->lo_backing_file; file = lo->lo_backing_file;
retval = file->f_op->sendfile(file, &pos, bvec->bv_len, retval = splice_direct_to_actor(file, &sd, lo_direct_splice_actor);
lo_read_actor, &cookie);
return (retval < 0)? retval: 0; if (retval < 0)
return retval;
return 0;
} }
static int static int
@ -679,8 +703,8 @@ static int loop_change_fd(struct loop_device *lo, struct file *lo_file,
if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode)) if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
goto out_putf; goto out_putf;
/* new backing store needs to support loop (eg sendfile) */ /* new backing store needs to support loop (eg splice_read) */
if (!inode->i_fop->sendfile) if (!inode->i_fop->splice_read)
goto out_putf; goto out_putf;
/* size of the new backing store needs to be the same */ /* size of the new backing store needs to be the same */
@ -760,7 +784,7 @@ static int loop_set_fd(struct loop_device *lo, struct file *lo_file,
* If we can't read - sorry. If we only can't write - well, * If we can't read - sorry. If we only can't write - well,
* it's going to be read-only. * it's going to be read-only.
*/ */
if (!file->f_op->sendfile) if (!file->f_op->splice_read)
goto out_putf; goto out_putf;
if (aops->prepare_write && aops->commit_write) if (aops->prepare_write && aops->commit_write)
lo_flags |= LO_FLAGS_USE_AOPS; lo_flags |= LO_FLAGS_USE_AOPS;