block: loop: switch to VFS ITER_BVEC

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 120 insertions, 174 deletions

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index c4fd1e45ce1e..ae3fcb4199e9 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -88,28 +88,6 @@ static int part_shift;
 
 static struct workqueue_struct *loop_wq;
 
-/*
- * Transfer functions
- */
-static int transfer_none(struct loop_device *lo, int cmd,
-                         struct page *raw_page, unsigned raw_off,
-                         struct page *loop_page, unsigned loop_off,
-                         int size, sector_t real_block)
-{
-        char *raw_buf = kmap_atomic(raw_page) + raw_off;
-        char *loop_buf = kmap_atomic(loop_page) + loop_off;
-
-        if (cmd == READ)
-                memcpy(loop_buf, raw_buf, size);
-        else
-                memcpy(raw_buf, loop_buf, size);
-
-        kunmap_atomic(loop_buf);
-        kunmap_atomic(raw_buf);
-        cond_resched();
-        return 0;
-}
-
 static int transfer_xor(struct loop_device *lo, int cmd,
                         struct page *raw_page, unsigned raw_off,
                         struct page *loop_page, unsigned loop_off,
@@ -148,14 +126,13 @@ static int xor_init(struct loop_device *lo, const struct loop_info64 *info)
 
 static struct loop_func_table none_funcs = {
         .number = LO_CRYPT_NONE,
-        .transfer = transfer_none,
-};      
+}; 
 
 static struct loop_func_table xor_funcs = {
         .number = LO_CRYPT_XOR,
         .transfer = transfer_xor,
         .init = xor_init
-};      
+}; 
 
 /* xfer_funcs[0] is special - its release function is never called */
 static struct loop_func_table *xfer_funcs[MAX_LO_CRYPT] = {
@@ -215,207 +192,169 @@ lo_do_transfer(struct loop_device *lo, int cmd,
                struct page *lpage, unsigned loffs,
                int size, sector_t rblock)
 {
-        if (unlikely(!lo->transfer))
+        int ret;
+
+        ret = lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock);
+        if (likely(!ret))
                 return 0;
 
-        return lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock);
+        printk_ratelimited(KERN_ERR
+                "loop: Transfer error at byte offset %llu, length %i.\n",
+                (unsigned long long)rblock << 9, size);
+        return ret;
 }
 
-/**
- * __do_lo_send_write - helper for writing data to a loop device
- *
- * This helper just factors out common code between do_lo_send_direct_write()
- * and do_lo_send_write().
- */
-static int __do_lo_send_write(struct file *file,
-                u8 *buf, const int len, loff_t pos)
+static int lo_write_bvec(struct file *file, struct bio_vec *bvec, loff_t *ppos)
 {
-        struct kvec kvec = {.iov_base = buf, .iov_len = len};
-        struct iov_iter from;
+        struct iov_iter i;
         ssize_t bw;
 
-        iov_iter_kvec(&from, ITER_KVEC | WRITE, &kvec, 1, len);
+        iov_iter_bvec(&i, ITER_BVEC, bvec, 1, bvec->bv_len);
 
         file_start_write(file);
-        bw = vfs_iter_write(file, &from, &pos);
+        bw = vfs_iter_write(file, &i, ppos);
         file_end_write(file);
-        if (likely(bw == len))
+
+        if (likely(bw ==  bvec->bv_len))
                 return 0;
-        printk_ratelimited(KERN_ERR "loop: Write error at byte offset %llu, length %i.\n",
-                        (unsigned long long)pos, len);
+
+        printk_ratelimited(KERN_ERR
+                "loop: Write error at byte offset %llu, length %i.\n",
+                (unsigned long long)*ppos, bvec->bv_len);
         if (bw >= 0)
                 bw = -EIO;
         return bw;
 }
 
-/**
- * do_lo_send_direct_write - helper for writing data to a loop device
- *
- * This is the fast, non-transforming version that does not need double
- * buffering.
- */
-static int do_lo_send_direct_write(struct loop_device *lo,
-                struct bio_vec *bvec, loff_t pos, struct page *page)
+static int lo_write_simple(struct loop_device *lo, struct request *rq,
+                loff_t pos)
 {
-        ssize_t bw = __do_lo_send_write(lo->lo_backing_file,
-                        kmap(bvec->bv_page) + bvec->bv_offset,
-                        bvec->bv_len, pos);
-        kunmap(bvec->bv_page);
-        cond_resched();
-        return bw;
+        struct bio_vec bvec;
+        struct req_iterator iter;
+        int ret = 0;
+
+        rq_for_each_segment(bvec, rq, iter) {
+                ret = lo_write_bvec(lo->lo_backing_file, &bvec, &pos);
+                if (ret < 0)
+                        break;
+                cond_resched();
+        }
+
+        return ret;
 }
 
-/**
- * do_lo_send_write - helper for writing data to a loop device
- *
+/*
  * This is the slow, transforming version that needs to double buffer the
  * data as it cannot do the transformations in place without having direct
  * access to the destination pages of the backing file.
  */
-static int do_lo_send_write(struct loop_device *lo, struct bio_vec *bvec,
-                loff_t pos, struct page *page)
+static int lo_write_transfer(struct loop_device *lo, struct request *rq,
+                loff_t pos)
 {
-        int ret = lo_do_transfer(lo, WRITE, page, 0, bvec->bv_page,
-                        bvec->bv_offset, bvec->bv_len, pos >> 9);
-        if (likely(!ret))
-                return __do_lo_send_write(lo->lo_backing_file,
-                                page_address(page), bvec->bv_len,
-                                pos);
-        printk_ratelimited(KERN_ERR "loop: Transfer error at byte offset %llu, "
-                        "length %i.\n", (unsigned long long)pos, bvec->bv_len);
-        if (ret > 0)
-                ret = -EIO;
-        return ret;
-}
-
-static int lo_send(struct loop_device *lo, struct request *rq, loff_t pos)
-{
-        int (*do_lo_send)(struct loop_device *, struct bio_vec *, loff_t,
-                        struct page *page);
-        struct bio_vec bvec;
+        struct bio_vec bvec, b;
         struct req_iterator iter;
-        struct page *page = NULL;
+        struct page *page;
         int ret = 0;
 
-        if (lo->transfer != transfer_none) {
-                page = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
-                if (unlikely(!page))
-                        goto fail;
-                kmap(page);
-                do_lo_send = do_lo_send_write;
-        } else {
-                do_lo_send = do_lo_send_direct_write;
-        }
+        page = alloc_page(GFP_NOIO);
+        if (unlikely(!page))
+                return -ENOMEM;
 
         rq_for_each_segment(bvec, rq, iter) {
-                ret = do_lo_send(lo, &bvec, pos, page);
+                ret = lo_do_transfer(lo, WRITE, page, 0, bvec.bv_page,