From d432da3600bfb48139ee10373122c250a9f5a003 Mon Sep 17 00:00:00 2001

From: Fam Zheng <famz@redhat.com>

Date: Fri, 17 Jan 2014 03:07:59 +0100

Subject: [PATCH 16/34] block: Add commit_active_start()

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

Message-id: <1389928083-8921-15-git-send-email-famz@redhat.com>

Patchwork-id: 56776

O-Subject: [RHEL-7 qemu-kvm PATCH 14/18] block: Add commit_active_start()

Bugzilla: 1041301

RH-Acked-by: Jeffrey Cody <jcody@redhat.com>

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

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

commit_active_start is implemented in block/mirror.c, It will create a

job with "commit" type and designated base in block-commit command. This

will be used for committing active layer of device.

Sync mode is removed from MirrorBlockJob because there's no proper type

for commit. The used information is is_none_mode.

The common part of mirror_start and commit_active_start is moved to

mirror_start_job().

Fix the comment wording for commit_start.

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

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

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

(cherry picked from commit 03544a6e9ecc1be115e8a29bd929f83b467d4816)

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

---

 block/mirror.c            | 66 +++++++++++++++++++++++++++++++++++------------

 include/block/block_int.h | 22 +++++++++++++---

 2 files changed, 69 insertions(+), 19 deletions(-)

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

---

 block/mirror.c            |   66 ++++++++++++++++++++++++++++++++++-----------

 include/block/block_int.h |   22 +++++++++++++--

 2 files changed, 69 insertions(+), 19 deletions(-)

diff --git a/block/mirror.c b/block/mirror.c

index 8ccde2f..01fe379 100644

--- a/block/mirror.c

+++ b/block/mirror.c

@@ -32,7 +32,7 @@ typedef struct MirrorBlockJob {

     RateLimit limit;

     BlockDriverState *target;

     BlockDriverState *base;

-    MirrorSyncMode mode;

+    bool is_none_mode;

     BlockdevOnError on_source_error, on_target_error;

     bool synced;

     bool should_complete;

@@ -333,7 +333,7 @@ static void coroutine_fn mirror_run(void *opaque)

     sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;

     mirror_free_init(s);

-    if (s->mode != MIRROR_SYNC_MODE_NONE) {

+    if (!s->is_none_mode) {

         /* First part, loop on the sectors and initialize the dirty bitmap.  */

         BlockDriverState *base = s->base;

         for (sector_num = 0; sector_num < end; ) {

@@ -532,15 +532,26 @@ static const BlockJobDriver mirror_job_driver = {

     .complete      = mirror_complete,

 };

-void mirror_start(BlockDriverState *bs, BlockDriverState *target,

-                  int64_t speed, int64_t granularity, int64_t buf_size,

-                  MirrorSyncMode mode, BlockdevOnError on_source_error,

-                  BlockdevOnError on_target_error,

-                  BlockDriverCompletionFunc *cb,

-                  void *opaque, Error **errp)

+static const BlockJobDriver commit_active_job_driver = {

+    .instance_size = sizeof(MirrorBlockJob),

+    .job_type      = BLOCK_JOB_TYPE_COMMIT,

+    .set_speed     = mirror_set_speed,

+    .iostatus_reset

+                   = mirror_iostatus_reset,

+    .complete      = mirror_complete,

+};

+

+static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target,

+                            int64_t speed, int64_t granularity,

+                            int64_t buf_size,

+                            BlockdevOnError on_source_error,

+                            BlockdevOnError on_target_error,

+                            BlockDriverCompletionFunc *cb,

+                            void *opaque, Error **errp,

+                            const BlockJobDriver *driver,

+                            bool is_none_mode, BlockDriverState *base)

 {

     MirrorBlockJob *s;

-    BlockDriverState *base = NULL;

     if (granularity == 0) {

         /* Choose the default granularity based on the target file's cluster

@@ -563,13 +574,8 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target,

         return;

     }

-    if (mode == MIRROR_SYNC_MODE_TOP) {

-        base = bs->backing_hd;

-    } else {

-        base = NULL;

-    }

-    s = block_job_create(&mirror_job_driver, bs, speed, cb, opaque, errp);

+    s = block_job_create(driver, bs, speed, cb, opaque, errp);

     if (!s) {

         return;

     }

@@ -577,7 +583,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target,

     s->on_source_error = on_source_error;

     s->on_target_error = on_target_error;

     s->target = target;

-    s->mode = mode;

+    s->is_none_mode = is_none_mode;

     s->base = base;

     s->granularity = granularity;

     s->buf_size = MAX(buf_size, granularity);

@@ -590,3 +596,31 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target,

     trace_mirror_start(bs, s, s->common.co, opaque);

     qemu_coroutine_enter(s->common.co, s);

 }

+

+void mirror_start(BlockDriverState *bs, BlockDriverState *target,

+                  int64_t speed, int64_t granularity, int64_t buf_size,

+                  MirrorSyncMode mode, BlockdevOnError on_source_error,

+                  BlockdevOnError on_target_error,

+                  BlockDriverCompletionFunc *cb,

+                  void *opaque, Error **errp)

+{

+    bool is_none_mode;

+    BlockDriverState *base;

+

+    is_none_mode = mode == MIRROR_SYNC_MODE_NONE;

+    base = mode == MIRROR_SYNC_MODE_TOP ? bs->backing_hd : NULL;

+    mirror_start_job(bs, target, speed, granularity, buf_size,

+                     on_source_error, on_target_error, cb, opaque, errp,

+                     &mirror_job_driver, is_none_mode, base);

+}

+

+void commit_active_start(BlockDriverState *bs, BlockDriverState *base,

+                         int64_t speed,

+                         BlockdevOnError on_error,

+                         BlockDriverCompletionFunc *cb,

+                         void *opaque, Error **errp)

+{

+    mirror_start_job(bs, base, speed, 0, 0,

+                     on_error, on_error, cb, opaque, errp,

+                     &commit_active_job_driver, false, base);

+}

diff --git a/include/block/block_int.h b/include/block/block_int.h

index fbfdab7..c8f30fd 100644

--- a/include/block/block_int.h

+++ b/include/block/block_int.h

@@ -374,8 +374,9 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base,

 /**

  * commit_start:

- * @bs: Top Block device

- * @base: Block device that will be written into, and become the new top

+ * @bs: Active block device.

+ * @top: Top block device to be committed.

+ * @base: Block device that will be written into, and become the new top.

  * @speed: The maximum speed, in bytes per second, or 0 for unlimited.

  * @on_error: The action to take upon error.

  * @cb: Completion function for the job.

@@ -387,7 +388,22 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base,

                  BlockDriverState *top, int64_t speed,

                  BlockdevOnError on_error, BlockDriverCompletionFunc *cb,

                  void *opaque, Error **errp);

-

+/**

+ * commit_active_start:

+ * @bs: Active block device to be committed.

+ * @base: Block device that will be written into, and become the new top.

+ * @speed: The maximum speed, in bytes per second, or 0 for unlimited.

+ * @on_error: The action to take upon error.

+ * @cb: Completion function for the job.

+ * @opaque: Opaque pointer value passed to @cb.

+ * @errp: Error object.

+ *

+ */

+void commit_active_start(BlockDriverState *bs, BlockDriverState *base,

+                         int64_t speed,

+                         BlockdevOnError on_error,

+                         BlockDriverCompletionFunc *cb,

+                         void *opaque, Error **errp);

 /*

  * mirror_start:

  * @bs: Block device to operate on.

-- 

1.7.1