yeahuh / rpms / qemu-kvm

Forked from rpms/qemu-kvm 2 years ago
Clone
ae23c9
From 63d4efaba799ee14d474e545f5634ee1c4369ef6 Mon Sep 17 00:00:00 2001
ae23c9
From: Kevin Wolf <kwolf@redhat.com>
ae23c9
Date: Tue, 26 Jun 2018 09:48:29 +0200
ae23c9
Subject: [PATCH 121/268] job: Move progress fields to Job
ae23c9
ae23c9
RH-Author: Kevin Wolf <kwolf@redhat.com>
ae23c9
Message-id: <20180626094856.6924-47-kwolf@redhat.com>
ae23c9
Patchwork-id: 81115
ae23c9
O-Subject: [RHV-7.6 qemu-kvm-rhev PATCH v2 46/73] job: Move progress fields to Job
ae23c9
Bugzilla: 1513543
ae23c9
RH-Acked-by: Jeffrey Cody <jcody@redhat.com>
ae23c9
RH-Acked-by: Max Reitz <mreitz@redhat.com>
ae23c9
RH-Acked-by: Fam Zheng <famz@redhat.com>
ae23c9
ae23c9
BlockJob has fields .offset and .len, which are actually misnomers today
ae23c9
because they are no longer tied to block device sizes, but just progress
ae23c9
counters. As such they make a lot of sense in generic Jobs.
ae23c9
ae23c9
This patch moves the fields to Job and renames them to .progress_current
ae23c9
and .progress_total to describe their function better.
ae23c9
ae23c9
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
ae23c9
Reviewed-by: Max Reitz <mreitz@redhat.com>
ae23c9
(cherry picked from commit 30a5c887bf4a7e00d0e0ecbb08509e8ba2902620)
ae23c9
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
ae23c9
Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>
ae23c9
---
ae23c9
 block/backup.c           |  8 ++++----
ae23c9
 block/commit.c           |  4 ++--
ae23c9
 block/mirror.c           |  4 ++--
ae23c9
 block/stream.c           |  4 ++--
ae23c9
 blockjob.c               | 26 ++++++++------------------
ae23c9
 include/block/blockjob.h | 25 -------------------------
ae23c9
 include/qemu/job.h       | 28 ++++++++++++++++++++++++++++
ae23c9
 job.c                    | 10 ++++++++++
ae23c9
 qemu-img.c               |  8 ++++++--
ae23c9
 9 files changed, 62 insertions(+), 55 deletions(-)
ae23c9
ae23c9
diff --git a/block/backup.c b/block/backup.c
ae23c9
index 6f4f3df..4e228e9 100644
ae23c9
--- a/block/backup.c
ae23c9
+++ b/block/backup.c
ae23c9
@@ -160,7 +160,7 @@ static int coroutine_fn backup_do_cow(BackupBlockJob *job,
ae23c9
          * offset field is an opaque progress value, it is not a disk offset.
ae23c9
          */
ae23c9
         job->bytes_read += n;
ae23c9
-        block_job_progress_update(&job->common, n);
ae23c9
+        job_progress_update(&job->common.job, n);
ae23c9
     }
ae23c9
 
ae23c9
 out:
ae23c9
@@ -406,8 +406,8 @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)
ae23c9
         bdrv_set_dirty_iter(dbi, next_cluster * job->cluster_size);
ae23c9
     }
ae23c9
 
ae23c9
-    /* TODO block_job_progress_set_remaining() would make more sense */
ae23c9
-    block_job_progress_update(&job->common,
ae23c9
+    /* TODO job_progress_set_remaining() would make more sense */
ae23c9
+    job_progress_update(&job->common.job,
ae23c9
         job->len - hbitmap_count(job->copy_bitmap) * job->cluster_size);
ae23c9
 
ae23c9
     bdrv_dirty_iter_free(dbi);
ae23c9
@@ -425,7 +425,7 @@ static void coroutine_fn backup_run(void *opaque)
ae23c9
     qemu_co_rwlock_init(&job->flush_rwlock);
ae23c9
 
ae23c9
     nb_clusters = DIV_ROUND_UP(job->len, job->cluster_size);
ae23c9
-    block_job_progress_set_remaining(&job->common, job->len);
ae23c9
+    job_progress_set_remaining(&job->common.job, job->len);
ae23c9
 
ae23c9
     job->copy_bitmap = hbitmap_alloc(nb_clusters, 0);
ae23c9
     if (job->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
ae23c9
diff --git a/block/commit.c b/block/commit.c
ae23c9
index b0a847e..6206661 100644
ae23c9
--- a/block/commit.c
ae23c9
+++ b/block/commit.c
ae23c9
@@ -150,7 +150,7 @@ static void coroutine_fn commit_run(void *opaque)
ae23c9
     if (len < 0) {
ae23c9
         goto out;
ae23c9
     }
ae23c9
-    block_job_progress_set_remaining(&s->common, len);
ae23c9
+    job_progress_set_remaining(&s->common.job, len);
ae23c9
 
ae23c9
     ret = base_len = blk_getlength(s->base);
ae23c9
     if (base_len < 0) {
ae23c9
@@ -196,7 +196,7 @@ static void coroutine_fn commit_run(void *opaque)
ae23c9
             }
ae23c9
         }
ae23c9
         /* Publish progress */
ae23c9
-        block_job_progress_update(&s->common, n);
ae23c9
+        job_progress_update(&s->common.job, n);
ae23c9
 
ae23c9
         if (copy) {
ae23c9
             delay_ns = block_job_ratelimit_get_delay(&s->common, n);
ae23c9
diff --git a/block/mirror.c b/block/mirror.c
ae23c9
index bdc1b5b..dcb66ec 100644
ae23c9
--- a/block/mirror.c
ae23c9
+++ b/block/mirror.c
ae23c9
@@ -119,7 +119,7 @@ static void mirror_iteration_done(MirrorOp *op, int ret)
ae23c9
             bitmap_set(s->cow_bitmap, chunk_num, nb_chunks);
ae23c9
         }
ae23c9
         if (!s->initial_zeroing_ongoing) {
ae23c9
-            block_job_progress_update(&s->common, op->bytes);
ae23c9
+            job_progress_update(&s->common.job, op->bytes);
ae23c9
         }
ae23c9
     }
ae23c9
     qemu_iovec_destroy(&op->qiov);
ae23c9
@@ -792,7 +792,7 @@ static void coroutine_fn mirror_run(void *opaque)
ae23c9
         /* cnt is the number of dirty bytes remaining and s->bytes_in_flight is
ae23c9
          * the number of bytes currently being processed; together those are
ae23c9
          * the current remaining operation length */
ae23c9
-        block_job_progress_set_remaining(&s->common, s->bytes_in_flight + cnt);
ae23c9
+        job_progress_set_remaining(&s->common.job, s->bytes_in_flight + cnt);
ae23c9
 
ae23c9
         /* Note that even when no rate limit is applied we need to yield
ae23c9
          * periodically with no pending I/O so that bdrv_drain_all() returns.
ae23c9
diff --git a/block/stream.c b/block/stream.c
ae23c9
index 8546c41..a5d6e0c 100644
ae23c9
--- a/block/stream.c
ae23c9
+++ b/block/stream.c
ae23c9
@@ -121,7 +121,7 @@ static void coroutine_fn stream_run(void *opaque)
ae23c9
         ret = len;
ae23c9
         goto out;
ae23c9
     }
ae23c9
-    block_job_progress_set_remaining(&s->common, len);
ae23c9
+    job_progress_set_remaining(&s->common.job, len);
ae23c9
 
ae23c9
     buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE);
ae23c9
 
ae23c9
@@ -184,7 +184,7 @@ static void coroutine_fn stream_run(void *opaque)
ae23c9
         ret = 0;
ae23c9
 
ae23c9
         /* Publish progress */
ae23c9
-        block_job_progress_update(&s->common, n);
ae23c9
+        job_progress_update(&s->common.job, n);
ae23c9
         if (copy) {
ae23c9
             delay_ns = block_job_ratelimit_get_delay(&s->common, n);
ae23c9
         } else {
ae23c9
diff --git a/blockjob.c b/blockjob.c
ae23c9
index da11b3b..5c8ff6f 100644
ae23c9
--- a/blockjob.c
ae23c9
+++ b/blockjob.c
ae23c9
@@ -242,16 +242,6 @@ int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n)
ae23c9
     return ratelimit_calculate_delay(&job->limit, n);
ae23c9
 }
ae23c9
 
ae23c9
-void block_job_progress_update(BlockJob *job, uint64_t done)
ae23c9
-{
ae23c9
-    job->offset += done;
ae23c9
-}
ae23c9
-
ae23c9
-void block_job_progress_set_remaining(BlockJob *job, uint64_t remaining)
ae23c9
-{
ae23c9
-    job->len = job->offset + remaining;
ae23c9
-}
ae23c9
-
ae23c9
 BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
ae23c9
 {
ae23c9
     BlockJobInfo *info;
ae23c9
@@ -263,10 +253,10 @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
ae23c9
     info = g_new0(BlockJobInfo, 1);
ae23c9
     info->type      = g_strdup(job_type_str(&job->job));
ae23c9
     info->device    = g_strdup(job->job.id);
ae23c9
-    info->len       = job->len;
ae23c9
     info->busy      = atomic_read(&job->job.busy);
ae23c9
     info->paused    = job->job.pause_count > 0;
ae23c9
-    info->offset    = job->offset;
ae23c9
+    info->offset    = job->job.progress_current;
ae23c9
+    info->len       = job->job.progress_total;
ae23c9
     info->speed     = job->speed;
ae23c9
     info->io_status = job->iostatus;
ae23c9
     info->ready     = job_is_ready(&job->job),
ae23c9
@@ -296,8 +286,8 @@ static void block_job_event_cancelled(Notifier *n, void *opaque)
ae23c9
 
ae23c9
     qapi_event_send_block_job_cancelled(job_type(&job->job),
ae23c9
                                         job->job.id,
ae23c9
-                                        job->len,
ae23c9
-                                        job->offset,
ae23c9
+                                        job->job.progress_total,
ae23c9
+                                        job->job.progress_current,
ae23c9
                                         job->speed,
ae23c9
                                         &error_abort);
ae23c9
 }
ae23c9
@@ -317,8 +307,8 @@ static void block_job_event_completed(Notifier *n, void *opaque)
ae23c9
 
ae23c9
     qapi_event_send_block_job_completed(job_type(&job->job),
ae23c9
                                         job->job.id,
ae23c9
-                                        job->len,
ae23c9
-                                        job->offset,
ae23c9
+                                        job->job.progress_total,
ae23c9
+                                        job->job.progress_current,
ae23c9
                                         job->speed,
ae23c9
                                         !!msg,
ae23c9
                                         msg,
ae23c9
@@ -348,8 +338,8 @@ static void block_job_event_ready(Notifier *n, void *opaque)
ae23c9
 
ae23c9
     qapi_event_send_block_job_ready(job_type(&job->job),
ae23c9
                                     job->job.id,
ae23c9
-                                    job->len,
ae23c9
-                                    job->offset,
ae23c9
+                                    job->job.progress_total,
ae23c9
+                                    job->job.progress_current,
ae23c9
                                     job->speed, &error_abort);
ae23c9
 }
ae23c9
 
ae23c9
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
ae23c9
index 4fca45f..3021d11 100644
ae23c9
--- a/include/block/blockjob.h
ae23c9
+++ b/include/block/blockjob.h
ae23c9
@@ -52,12 +52,6 @@ typedef struct BlockJob {
ae23c9
     /** Status that is published by the query-block-jobs QMP API */
ae23c9
     BlockDeviceIoStatus iostatus;
ae23c9
 
ae23c9
-    /** Offset that is published by the query-block-jobs QMP API */
ae23c9
-    int64_t offset;
ae23c9
-
ae23c9
-    /** Length that is published by the query-block-jobs QMP API */
ae23c9
-    int64_t len;
ae23c9
-
ae23c9
     /** Speed that was set with @block_job_set_speed.  */
ae23c9
     int64_t speed;
ae23c9
 
ae23c9
@@ -139,25 +133,6 @@ void block_job_remove_all_bdrv(BlockJob *job);
ae23c9
 void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp);
ae23c9
 
ae23c9
 /**
ae23c9
- * block_job_progress_update:
ae23c9
- * @job: The job that has made progress
ae23c9
- * @done: How much progress the job made
ae23c9
- *
ae23c9
- * Updates the progress counter of the job.
ae23c9
- */
ae23c9
-void block_job_progress_update(BlockJob *job, uint64_t done);
ae23c9
-
ae23c9
-/**
ae23c9
- * block_job_progress_set_remaining:
ae23c9
- * @job: The job whose expected progress end value is set
ae23c9
- * @remaining: Expected end value of the progress counter of the job
ae23c9
- *
ae23c9
- * Sets the expected end value of the progress counter of a job so that a
ae23c9
- * completion percentage can be calculated when the progress is updated.
ae23c9
- */
ae23c9
-void block_job_progress_set_remaining(BlockJob *job, uint64_t remaining);
ae23c9
-
ae23c9
-/**
ae23c9
  * block_job_query:
ae23c9
  * @job: The job to get information about.
ae23c9
  *
ae23c9
diff --git a/include/qemu/job.h b/include/qemu/job.h
ae23c9
index bfc2bc5..92d1d24 100644
ae23c9
--- a/include/qemu/job.h
ae23c9
+++ b/include/qemu/job.h
ae23c9
@@ -114,6 +114,16 @@ typedef struct Job {
ae23c9
     /** True if this job should automatically dismiss itself */
ae23c9
     bool auto_dismiss;
ae23c9
 
ae23c9
+    /**
ae23c9
+     * Current progress. The unit is arbitrary as long as the ratio between
ae23c9
+     * progress_current and progress_total represents the estimated percentage
ae23c9
+     * of work already done.
ae23c9
+     */
ae23c9
+    int64_t progress_current;
ae23c9
+
ae23c9
+    /** Estimated progress_current value at the completion of the job */
ae23c9
+    int64_t progress_total;
ae23c9
+
ae23c9
     /** ret code passed to job_completed. */
ae23c9
     int ret;
ae23c9
 
ae23c9
@@ -304,6 +314,24 @@ void job_ref(Job *job);
ae23c9
  */
ae23c9
 void job_unref(Job *job);
ae23c9
 
ae23c9
+/**
ae23c9
+ * @job: The job that has made progress
ae23c9
+ * @done: How much progress the job made since the last call
ae23c9
+ *
ae23c9
+ * Updates the progress counter of the job.
ae23c9
+ */
ae23c9
+void job_progress_update(Job *job, uint64_t done);
ae23c9
+
ae23c9
+/**
ae23c9
+ * @job: The job whose expected progress end value is set
ae23c9
+ * @remaining: Missing progress (on top of the current progress counter value)
ae23c9
+ *             until the new expected end value is reached
ae23c9
+ *
ae23c9
+ * Sets the expected end value of the progress counter of a job so that a
ae23c9
+ * completion percentage can be calculated when the progress is updated.
ae23c9
+ */
ae23c9
+void job_progress_set_remaining(Job *job, uint64_t remaining);
ae23c9
+
ae23c9
 /** To be called when a cancelled job is finalised. */
ae23c9
 void job_event_cancelled(Job *job);
ae23c9
 
ae23c9
diff --git a/job.c b/job.c
ae23c9
index b5bd51b..2046d2f 100644
ae23c9
--- a/job.c
ae23c9
+++ b/job.c
ae23c9
@@ -364,6 +364,16 @@ void job_unref(Job *job)
ae23c9
     }
ae23c9
 }
ae23c9
 
ae23c9
+void job_progress_update(Job *job, uint64_t done)
ae23c9
+{
ae23c9
+    job->progress_current += done;
ae23c9
+}
ae23c9
+
ae23c9
+void job_progress_set_remaining(Job *job, uint64_t remaining)
ae23c9
+{
ae23c9
+    job->progress_total = job->progress_current + remaining;
ae23c9
+}
ae23c9
+
ae23c9
 void job_event_cancelled(Job *job)
ae23c9
 {
ae23c9
     notifier_list_notify(&job->on_finalize_cancelled, job);
ae23c9
diff --git a/qemu-img.c b/qemu-img.c
ae23c9
index 3c449a2..9fc8e66 100644
ae23c9
--- a/qemu-img.c
ae23c9
+++ b/qemu-img.c
ae23c9
@@ -875,9 +875,13 @@ static void run_block_job(BlockJob *job, Error **errp)
ae23c9
     aio_context_acquire(aio_context);
ae23c9
     job_ref(&job->job);
ae23c9
     do {
ae23c9
+        float progress = 0.0f;
ae23c9
         aio_poll(aio_context, true);
ae23c9
-        qemu_progress_print(job->len ?
ae23c9
-                            ((float)job->offset / job->len * 100.f) : 0.0f, 0);
ae23c9
+        if (job->job.progress_total) {
ae23c9
+            progress = (float)job->job.progress_current /
ae23c9
+                       job->job.progress_total * 100.f;
ae23c9
+        }
ae23c9
+        qemu_progress_print(progress, 0);
ae23c9
     } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));
ae23c9
 
ae23c9
     if (!job_is_completed(&job->job)) {
ae23c9
-- 
ae23c9
1.8.3.1
ae23c9