block: pass iov_iter to the BLOCK_PC mapping functions

Make use of a new interface provided by iov_iter, backed by
scatter-gather list of iovec, instead of the old interface based on
sg_iovec. Also use iov_iter_advance() instead of manual iteration.

This commit should contain only literal replacements, without
functional changes.

Cc: Christoph Hellwig <hch@infradead.org>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Doug Gilbert <dgilbert@interlog.com>
Cc: "James E.J. Bottomley" <JBottomley@parallels.com>
Signed-off-by: Kent Overstreet <kmo@daterainc.com>
[dpark: add more description in commit message]
Signed-off-by: Dongsu Park <dongsu.park@profitbricks.com>
[hch: fixed to do a deep clone of the iov_iter, and to properly use
      the iov_iter direction]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Ming Lei <tom.leiming@gmail.com>
Signed-off-by: Jens Axboe <axboe@fb.com>

3 files changed, 90 insertions, 111 deletions

diff --git a/block/bio.c b/block/bio.c
index 0895f694f440..7d8c6555e3f3 100644
--- a/block/bio.c
+++ b/block/bio.c
@@ -28,7 +28,6 @@
 #include <linux/mempool.h>
 #include <linux/workqueue.h>
 #include <linux/cgroup.h>
-#include <scsi/sg.h>            /* for struct sg_iovec */
 
 #include <trace/events/block.h>
 
@@ -1022,21 +1021,11 @@ void bio_copy_data(struct bio *dst, struct bio *src)
 EXPORT_SYMBOL(bio_copy_data);
 
 struct bio_map_data {
-        int nr_sgvecs;
         int is_our_pages;
-        struct sg_iovec sgvecs[];
+        struct iov_iter iter;
+        struct iovec iov[];
 };
 
-static void bio_set_map_data(struct bio_map_data *bmd, struct bio *bio,
-                             const struct sg_iovec *iov, int iov_count,
-                             int is_our_pages)
-{
-        memcpy(bmd->sgvecs, iov, sizeof(struct sg_iovec) * iov_count);
-        bmd->nr_sgvecs = iov_count;
-        bmd->is_our_pages = is_our_pages;
-        bio->bi_private = bmd;
-}
-
 static struct bio_map_data *bio_alloc_map_data(unsigned int iov_count,
                                                gfp_t gfp_mask)
 {
@@ -1044,36 +1033,33 @@ static struct bio_map_data *bio_alloc_map_data(unsigned int iov_count,
                 return NULL;
 
         return kmalloc(sizeof(struct bio_map_data) +
-                       sizeof(struct sg_iovec) * iov_count, gfp_mask);
+                       sizeof(struct iovec) * iov_count, gfp_mask);
 }
 
-static int __bio_copy_iov(struct bio *bio, const struct sg_iovec *iov, int iov_count,
-                          int to_user, int from_user)
+static int __bio_copy_iov(struct bio *bio, const struct iov_iter *iter,
+                          int to_user, int from_user)
 {
         int ret = 0, i;
         struct bio_vec *bvec;
-        int iov_idx = 0;
-        unsigned int iov_off = 0;
+        struct iov_iter iov_iter = *iter;
 
         bio_for_each_segment_all(bvec, bio, i) {
                 char *bv_addr = page_address(bvec->bv_page);
                 unsigned int bv_len = bvec->bv_len;
 
-                while (bv_len && iov_idx < iov_count) {
-                        unsigned int bytes;
-                        char __user *iov_addr;
-
-                        bytes = min_t(unsigned int,
-                                      iov[iov_idx].iov_len - iov_off, bv_len);
-                        iov_addr = iov[iov_idx].iov_base + iov_off;
+                while (bv_len && iov_iter.count) {
+                        struct iovec iov = iov_iter_iovec(&iov_iter);
+                        unsigned int bytes = min_t(unsigned int, bv_len,
+                                                   iov.iov_len);
 
                         if (!ret) {
                                 if (to_user)
-                                        ret = copy_to_user(iov_addr, bv_addr,
-                                                           bytes);
+                                        ret = copy_to_user(iov.iov_base,
+                                                           bv_addr, bytes);
 
                                 if (from_user)
-                                        ret = copy_from_user(bv_addr, iov_addr,
+                                        ret = copy_from_user(bv_addr,
+                                                             iov.iov_base,
                                                              bytes);
 
                                 if (ret)
@@ -1082,13 +1068,7 @@ static int __bio_copy_iov(struct bio *bio, const struct sg_iovec *iov, int iov_c
 
                         bv_len -= bytes;
                         bv_addr += bytes;
-                        iov_addr += bytes;
-                        iov_off += bytes;
-
-                        if (iov[iov_idx].iov_len == iov_off) {
-                                iov_idx++;
-                                iov_off = 0;
-                        }
+                        iov_iter_advance(&iov_iter, bytes);
                 }
         }
 
@@ -1122,7 +1102,7 @@ int bio_uncopy_user(struct bio *bio)
                  * don't copy into a random user address space, just free.
                  */
                 if (current->mm)
-                        ret = __bio_copy_iov(bio, bmd->sgvecs, bmd->nr_sgvecs,
+                        ret = __bio_copy_iov(bio, &bmd->iter,
                                              bio_data_dir(bio) == READ, 0);
                 if (bmd->is_our_pages)
                         bio_free_pages(bio);
@@ -1135,12 +1115,10 @@ EXPORT_SYMBOL(bio_uncopy_user);
 
 /**
  *      bio_copy_user_iov       -       copy user data to bio
- *      @q: destination block queue
- *      @map_data: pointer to the rq_map_data holding pages (if necessary)
- *      @iov:   the iovec.
- *      @iov_count: number of elements in the iovec
- *      @write_to_vm: bool indicating writing to pages or not
- *      @gfp_mask: memory allocation flags
+ *      @q:             destination block queue
+ *      @map_data:      pointer to the rq_map_data holding pages (if necessary)
+ *      @iter:          iovec iterator
+ *      @gfp_mask:      memory allocation flags
  *
  *      Prepares and returns a bio for indirect user io, bouncing data
  *      to/from kernel pages as necessary. Must be paired with
@@ -1148,24 +1126,25 @@ EXPORT_SYMBOL(bio_uncopy_user);
  */
 struct bio *bio_copy_user_iov(struct request_queue *q,
                               struct rq_map_data *map_data,
-                              const struct sg_iovec *iov, int iov_count,
-                              int write_to_vm, gfp_t gfp_mask)
+                              const struct iov_iter *iter,
+                              gfp_t gfp_mask)
 {
         struct bio_map_data *bmd;
         struct page *page;
         struct bio *bio;
         int i, ret;
         int nr_pages = 0;
-        unsigned int len = 0;
+        unsigned int len = iter->count;
         unsigned int offset = map_data ? map_data->offset & ~PAGE_MASK : 0;
 
-        for (i = 0; i < iov_count; i++) {
+        for (i = 0; i < iter->nr_segs; i++) {
                 unsigned long uaddr;
                 unsigned long end;
                 unsigned long start;
 
-                uaddr = (unsigned long)iov[i].iov_base;
-                end = (uaddr + iov[i].iov_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+                uaddr = (unsigned long) iter->iov[i].iov_base;
+                end = (uaddr + iter->iov[i].iov_len + PAGE_SIZE - 1)
+                        >> PAGE_SHIFT;
                 start = uaddr >> PAGE_SHIFT;
 
                 /*
@@ -1175,22 +1154,31 @@ struct bio *bio_copy_user_iov(struct request_queue *q,
                         return ERR_PTR(-EINVAL);
 
                 nr_pages += end - start;
-                len += iov[i].iov_len;
         }
 
         if (offset)
                 nr_pages++;