cryptospore / rpms / qemu-kvm

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