From 2b47a16d95ebd4d50a0a62d30acd007eb50ce0ea Mon Sep 17 00:00:00 2001

From: Fam Zheng <famz@redhat.com>

Date: Wed, 4 Jul 2018 07:56:31 +0200

Subject: [PATCH 46/57] qemu-img: Convert with copy offloading

RH-Author: Fam Zheng <famz@redhat.com>

Message-id: <20180629061153.12687-11-famz@redhat.com>

Patchwork-id: 81158

O-Subject: [RHEL-7.6 qemu-kvm-rhev PATCH v2 10/13] qemu-img: Convert with copy offloading

Bugzilla: 1482537

RH-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>

RH-Acked-by: Max Reitz <mreitz@redhat.com>

RH-Acked-by: Kevin Wolf <kwolf@redhat.com>

The new blk_co_copy_range interface offers a more efficient way in the

case of network based storage. Make use of it to allow faster convert

operation.

Since copy offloading cannot do zero detection ('-S') and compression

(-c), only try it when these options are not used.

Signed-off-by: Fam Zheng <famz@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-id: 20180601092648.24614-11-famz@redhat.com

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

(cherry picked from commit ee5306d0923377439776e8a30b9fd2de34b5cbfb)

Signed-off-by: Fam Zheng <famz@redhat.com>

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

---

 qemu-img.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++--

 1 file changed, 48 insertions(+), 2 deletions(-)

diff --git a/qemu-img.c b/qemu-img.c

index 9fc8e66..b2ef54e 100644

--- a/qemu-img.c

+++ b/qemu-img.c

@@ -1561,6 +1561,7 @@ typedef struct ImgConvertState {

     bool target_has_backing;

     int64_t target_backing_sectors; /* negative if unknown */

     bool wr_in_order;

+    bool copy_range;

     int min_sparse;

     size_t cluster_sectors;

     size_t buf_sectors;

@@ -1765,6 +1766,37 @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,

     return 0;

 }

+static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num,

+                                              int nb_sectors)

+{

+    int n, ret;

+

+    while (nb_sectors > 0) {

+        BlockBackend *blk;

+        int src_cur;

+        int64_t bs_sectors, src_cur_offset;

+        int64_t offset;

+

+        convert_select_part(s, sector_num, &src_cur, &src_cur_offset);

+        offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;

+        blk = s->src[src_cur];

+        bs_sectors = s->src_sectors[src_cur];

+

+        n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));

+

+        ret = blk_co_copy_range(blk, offset, s->target,

+                                sector_num << BDRV_SECTOR_BITS,

+                                n << BDRV_SECTOR_BITS, 0);

+        if (ret < 0) {

+            return ret;

+        }

+

+        sector_num += n;

+        nb_sectors -= n;

+    }

+    return 0;

+}

+

 static void coroutine_fn convert_co_do_copy(void *opaque)

 {

     ImgConvertState *s = opaque;

@@ -1787,6 +1819,7 @@ static void coroutine_fn convert_co_do_copy(void *opaque)

         int n;

         int64_t sector_num;

         enum ImgConvertBlockStatus status;

+        bool copy_range;

         qemu_co_mutex_lock(&s->lock);

         if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {

@@ -1816,7 +1849,9 @@ static void coroutine_fn convert_co_do_copy(void *opaque)

                                         s->allocated_sectors, 0);

         }

-        if (status == BLK_DATA) {

+retry:

+        copy_range = s->copy_range && s->status == BLK_DATA;

+        if (status == BLK_DATA && !copy_range) {

             ret = convert_co_read(s, sector_num, n, buf);

             if (ret < 0) {

                 error_report("error while reading sector %" PRId64

@@ -1838,7 +1873,15 @@ static void coroutine_fn convert_co_do_copy(void *opaque)

         }

         if (s->ret == -EINPROGRESS) {

-            ret = convert_co_write(s, sector_num, n, buf, status);

+            if (copy_range) {

+                ret = convert_co_copy_range(s, sector_num, n);

+                if (ret) {

+                    s->copy_range = false;

+                    goto retry;

+                }

+            } else {

+                ret = convert_co_write(s, sector_num, n, buf, status);

+            }

             if (ret < 0) {

                 error_report("error while writing sector %" PRId64

                              ": %s", sector_num, strerror(-ret));

@@ -1961,6 +2004,7 @@ static int img_convert(int argc, char **argv)

     ImgConvertState s = (ImgConvertState) {

         /* Need at least 4k of zeros for sparse detection */

         .min_sparse         = 8,

+        .copy_range         = true,

         .buf_sectors        = IO_BUF_SIZE / BDRV_SECTOR_SIZE,

         .wr_in_order        = true,

         .num_coroutines     = 8,

@@ -2001,6 +2045,7 @@ static int img_convert(int argc, char **argv)

             break;

         case 'c':

             s.compressed = true;

+            s.copy_range = false;

             break;

         case 'o':

             if (!is_valid_option_list(optarg)) {

@@ -2042,6 +2087,7 @@ static int img_convert(int argc, char **argv)

             }

             s.min_sparse = sval / BDRV_SECTOR_SIZE;

+            s.copy_range = false;

             break;

         }

         case 'p':

-- 

1.8.3.1