qmp-commands: move 'human-monitor-command' doc to schema

[qemu.git] / blockjob.c

diff --git a/blockjob.c b/blockjob.c
index 422851fde5da5eb929841e6500957909a4f35e67..513620c199fde95f7448d01e3e3c33fb3724ba21 100644 (file)
--- a/blockjob.c
+++ b/blockjob.c
@@ -27,7 +27,7 @@
 #include "qemu-common.h"
 #include "trace.h"
 #include "block/block.h"
 #include "qemu-common.h"
 #include "trace.h"
 #include "block/block.h"

-#include "block/blockjob.h"
+#include "block/blockjob_int.h"

 #include "block/block_int.h"
 #include "sysemu/block-backend.h"
 #include "qapi/qmp/qerror.h"
 #include "block/block_int.h"
 #include "sysemu/block-backend.h"
 #include "qapi/qmp/qerror.h"


@@ -38,6 +38,9 @@
 #include "qemu/timer.h"
 #include "qapi-event.h"
 
 #include "qemu/timer.h"
 #include "qapi-event.h"
 

+static void block_job_event_cancelled(BlockJob *job);
+static void block_job_event_completed(BlockJob *job, const char *msg);
+

 /* Transactional group of block jobs */
 struct BlockJobTxn {
 
 /* Transactional group of block jobs */
 struct BlockJobTxn {
 


@@ -66,7 +69,7 @@ BlockJob *block_job_get(const char *id)
     BlockJob *job;
 
     QLIST_FOREACH(job, &block_jobs, job_list) {
     BlockJob *job;
 
     QLIST_FOREACH(job, &block_jobs, job_list) {

-        if (!strcmp(id, job->id)) {
+        if (job->id && !strcmp(id, job->id)) {

             return job;
         }
     }
             return job;
         }
     }


@@ -121,19 +124,18 @@ void block_job_add_bdrv(BlockJob *job, BlockDriverState *bs)
 }
 
 void *block_job_create(const char *job_id, const BlockJobDriver *driver,
 }
 
 void *block_job_create(const char *job_id, const BlockJobDriver *driver,

-                       BlockDriverState *bs, int64_t speed,
+                       BlockDriverState *bs, int64_t speed, int flags,

                        BlockCompletionFunc *cb, void *opaque, Error **errp)
 {
     BlockBackend *blk;
     BlockJob *job;
 
                        BlockCompletionFunc *cb, void *opaque, Error **errp)
 {
     BlockBackend *blk;
     BlockJob *job;
 

-    assert(cb);

     if (bs->job) {
         error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
         return NULL;
     }
 
     if (bs->job) {
         error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
         return NULL;
     }
 

-    if (job_id == NULL) {
+    if (job_id == NULL && !(flags & BLOCK_JOB_INTERNAL)) {

         job_id = bdrv_get_device_name(bs);
         if (!*job_id) {
             error_setg(errp, "An explicit job ID is required for this node");
         job_id = bdrv_get_device_name(bs);
         if (!*job_id) {
             error_setg(errp, "An explicit job ID is required for this node");


@@ -141,14 +143,21 @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
         }
     }
 
         }
     }
 

-    if (!id_wellformed(job_id)) {
-        error_setg(errp, "Invalid job ID '%s'", job_id);
-        return NULL;
-    }
+    if (job_id) {
+        if (flags & BLOCK_JOB_INTERNAL) {
+            error_setg(errp, "Cannot specify job ID for internal block job");
+            return NULL;
+        }

 
 

-    if (block_job_get(job_id)) {
-        error_setg(errp, "Job ID '%s' already in use", job_id);
-        return NULL;
+        if (!id_wellformed(job_id)) {
+            error_setg(errp, "Invalid job ID '%s'", job_id);
+            return NULL;
+        }
+
+        if (block_job_get(job_id)) {
+            error_setg(errp, "Job ID '%s' already in use", job_id);
+            return NULL;
+        }

     }
 
     blk = blk_new();
     }
 
     blk = blk_new();


@@ -165,7 +174,9 @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
     job->blk           = blk;
     job->cb            = cb;
     job->opaque        = opaque;
     job->blk           = blk;
     job->cb            = cb;
     job->opaque        = opaque;

-    job->busy          = true;
+    job->busy          = false;
+    job->paused        = true;
+    job->pause_count   = 1;

     job->refcnt        = 1;
     bs->job = job;
 
     job->refcnt        = 1;
     bs->job = job;
 


@@ -188,6 +199,28 @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
     return job;
 }
 
     return job;
 }
 

+bool block_job_is_internal(BlockJob *job)
+{
+    return (job->id == NULL);
+}
+
+static bool block_job_started(BlockJob *job)
+{
+    return job->co;
+}
+
+void block_job_start(BlockJob *job)
+{
+    assert(job && !block_job_started(job) && job->paused &&
+           !job->busy && job->driver->start);
+    job->co = qemu_coroutine_create(job->driver->start, job);
+    if (--job->pause_count == 0) {
+        job->paused = false;
+        job->busy = true;
+        qemu_coroutine_enter(job->co);
+    }
+}
+

 void block_job_ref(BlockJob *job)
 {
     ++job->refcnt;
 void block_job_ref(BlockJob *job)
 {
     ++job->refcnt;


@@ -227,8 +260,29 @@ static void block_job_completed_single(BlockJob *job)
             job->driver->abort(job);
         }
     }
             job->driver->abort(job);
         }
     }

-    job->cb(job->opaque, job->ret);
+    if (job->driver->clean) {
+        job->driver->clean(job);
+    }
+
+    if (job->cb) {
+        job->cb(job->opaque, job->ret);
+    }
+
+    /* Emit events only if we actually started */
+    if (block_job_started(job)) {
+        if (block_job_is_cancelled(job)) {
+            block_job_event_cancelled(job);
+        } else {
+            const char *msg = NULL;
+            if (job->ret < 0) {
+                msg = strerror(-job->ret);
+            }
+            block_job_event_completed(job, msg);
+        }
+    }
+

     if (job->txn) {
     if (job->txn) {

+        QLIST_REMOVE(job, txn_list);

         block_job_txn_unref(job->txn);
     }
     block_job_unref(job);
         block_job_txn_unref(job->txn);
     }
     block_job_unref(job);


@@ -330,7 +384,10 @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
 
 void block_job_complete(BlockJob *job, Error **errp)
 {
 
 void block_job_complete(BlockJob *job, Error **errp)
 {

-    if (job->pause_count || job->cancelled || !job->driver->complete) {
+    /* Should not be reachable via external interface for internal jobs */
+    assert(job->id);
+    if (job->pause_count || job->cancelled ||
+        !block_job_started(job) || !job->driver->complete) {

         error_setg(errp, "The active block job '%s' cannot be completed",
                    job->id);
         return;
         error_setg(errp, "The active block job '%s' cannot be completed",
                    job->id);
         return;


@@ -344,13 +401,26 @@ void block_job_pause(BlockJob *job)
     job->pause_count++;
 }
 
     job->pause_count++;
 }
 

+void block_job_user_pause(BlockJob *job)
+{
+    job->user_paused = true;
+    block_job_pause(job);
+}
+

 static bool block_job_should_pause(BlockJob *job)
 {
     return job->pause_count > 0;
 }
 
 static bool block_job_should_pause(BlockJob *job)
 {
     return job->pause_count > 0;
 }
 

+bool block_job_user_paused(BlockJob *job)
+{
+    return job ? job->user_paused : 0;
+}
+

 void coroutine_fn block_job_pause_point(BlockJob *job)
 {
 void coroutine_fn block_job_pause_point(BlockJob *job)
 {

+    assert(job && block_job_started(job));
+

     if (!block_job_should_pause(job)) {
         return;
     }
     if (!block_job_should_pause(job)) {
         return;
     }


@@ -385,6 +455,14 @@ void block_job_resume(BlockJob *job)
     block_job_enter(job);
 }
 
     block_job_enter(job);
 }
 

+void block_job_user_resume(BlockJob *job)
+{
+    if (job && job->user_paused && job->pause_count > 0) {
+        job->user_paused = false;
+        block_job_resume(job);
+    }
+}
+

 void block_job_enter(BlockJob *job)
 {
     if (job->co && !job->busy) {
 void block_job_enter(BlockJob *job)
 {
     if (job->co && !job->busy) {


@@ -394,9 +472,13 @@ void block_job_enter(BlockJob *job)
 
 void block_job_cancel(BlockJob *job)
 {
 
 void block_job_cancel(BlockJob *job)
 {

-    job->cancelled = true;
-    block_job_iostatus_reset(job);
-    block_job_enter(job);
+    if (block_job_started(job)) {
+        job->cancelled = true;
+        block_job_iostatus_reset(job);
+        block_job_enter(job);
+    } else {
+        block_job_completed(job, -ECANCELED);
+    }

 }
 
 bool block_job_is_cancelled(BlockJob *job)
 }
 
 bool block_job_is_cancelled(BlockJob *job)


@@ -510,9 +592,15 @@ void block_job_yield(BlockJob *job)
     block_job_pause_point(job);
 }
 
     block_job_pause_point(job);
 }
 

-BlockJobInfo *block_job_query(BlockJob *job)
+BlockJobInfo *block_job_query(BlockJob *job, Error **errp)

 {
 {

-    BlockJobInfo *info = g_new0(BlockJobInfo, 1);
+    BlockJobInfo *info;
+
+    if (block_job_is_internal(job)) {
+        error_setg(errp, "Cannot query QEMU internal jobs");
+        return NULL;
+    }
+    info = g_new0(BlockJobInfo, 1);

     info->type      = g_strdup(BlockJobType_lookup[job->driver->job_type]);
     info->device    = g_strdup(job->id);
     info->len       = job->len;
     info->type      = g_strdup(BlockJobType_lookup[job->driver->job_type]);
     info->device    = g_strdup(job->id);
     info->len       = job->len;


@@ -533,8 +621,12 @@ static void block_job_iostatus_set_err(BlockJob *job, int error)
     }
 }
 
     }
 }
 

-void block_job_event_cancelled(BlockJob *job)
+static void block_job_event_cancelled(BlockJob *job)

 {
 {

+    if (block_job_is_internal(job)) {
+        return;
+    }
+

     qapi_event_send_block_job_cancelled(job->driver->job_type,
                                         job->id,
                                         job->len,
     qapi_event_send_block_job_cancelled(job->driver->job_type,
                                         job->id,
                                         job->len,


@@ -543,8 +635,12 @@ void block_job_event_cancelled(BlockJob *job)
                                         &error_abort);
 }
 
                                         &error_abort);
 }
 

-void block_job_event_completed(BlockJob *job, const char *msg)
+static void block_job_event_completed(BlockJob *job, const char *msg)

 {
 {

+    if (block_job_is_internal(job)) {
+        return;
+    }
+

     qapi_event_send_block_job_completed(job->driver->job_type,
                                         job->id,
                                         job->len,
     qapi_event_send_block_job_completed(job->driver->job_type,
                                         job->id,
                                         job->len,


@@ -559,6 +655,10 @@ void block_job_event_ready(BlockJob *job)
 {
     job->ready = true;
 
 {
     job->ready = true;
 

+    if (block_job_is_internal(job)) {
+        return;
+    }
+

     qapi_event_send_block_job_ready(job->driver->job_type,
                                     job->id,
                                     job->len,
     qapi_event_send_block_job_ready(job->driver->job_type,
                                     job->id,
                                     job->len,


@@ -589,14 +689,15 @@ BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
     default:
         abort();
     }
     default:
         abort();
     }

-    qapi_event_send_block_job_error(job->id,
-                                    is_read ? IO_OPERATION_TYPE_READ :
-                                    IO_OPERATION_TYPE_WRITE,
-                                    action, &error_abort);
+    if (!block_job_is_internal(job)) {
+        qapi_event_send_block_job_error(job->id,
+                                        is_read ? IO_OPERATION_TYPE_READ :
+                                        IO_OPERATION_TYPE_WRITE,
+                                        action, &error_abort);
+    }

     if (action == BLOCK_ERROR_ACTION_STOP) {
         /* make the pause user visible, which will be resumed from QMP. */
     if (action == BLOCK_ERROR_ACTION_STOP) {
         /* make the pause user visible, which will be resumed from QMP. */

-        job->user_paused = true;
-        block_job_pause(job);
+        block_job_user_pause(job);

         block_job_iostatus_set_err(job, error);
     }
     return action;
         block_job_iostatus_set_err(job, error);
     }
     return action;