savevm: Factorize ram globals reset in its own function

[qemu.git] / blockdev.c

diff --git a/blockdev.c b/blockdev.c
index d82461208984937b3efce5895772b95655126655..99828ad2bdbc7dcbb137f4e719d621cc934c1b24 100644 (file)
--- a/blockdev.c
+++ b/blockdev.c
@@ -9,6 +9,7 @@
 
 #include "blockdev.h"
 #include "hw/block-common.h"
 
 #include "blockdev.h"
 #include "hw/block-common.h"

+#include "blockjob.h"

 #include "monitor.h"
 #include "qerror.h"
 #include "qemu-option.h"
 #include "monitor.h"
 #include "qerror.h"
 #include "qemu-option.h"


@@ -237,16 +238,16 @@ static void drive_put_ref_bh_schedule(DriveInfo *dinfo)
     qemu_bh_schedule(s->bh);
 }
 
     qemu_bh_schedule(s->bh);
 }
 

-static int parse_block_error_action(const char *buf, int is_read)
+static int parse_block_error_action(const char *buf, bool is_read)

 {
     if (!strcmp(buf, "ignore")) {
 {
     if (!strcmp(buf, "ignore")) {

-        return BLOCK_ERR_IGNORE;
+        return BLOCKDEV_ON_ERROR_IGNORE;

     } else if (!is_read && !strcmp(buf, "enospc")) {
     } else if (!is_read && !strcmp(buf, "enospc")) {

-        return BLOCK_ERR_STOP_ENOSPC;
+        return BLOCKDEV_ON_ERROR_ENOSPC;

     } else if (!strcmp(buf, "stop")) {
     } else if (!strcmp(buf, "stop")) {

-        return BLOCK_ERR_STOP_ANY;
+        return BLOCKDEV_ON_ERROR_STOP;

     } else if (!strcmp(buf, "report")) {
     } else if (!strcmp(buf, "report")) {

-        return BLOCK_ERR_REPORT;
+        return BLOCKDEV_ON_ERROR_REPORT;

     } else {
         error_report("'%s' invalid %s error action",
                      buf, is_read ? "read" : "write");
     } else {
         error_report("'%s' invalid %s error action",
                      buf, is_read ? "read" : "write");


@@ -432,7 +433,7 @@ DriveInfo *drive_init(QemuOpts *opts, int default_to_scsi)
         return NULL;
     }
 
         return NULL;
     }
 

-    on_write_error = BLOCK_ERR_STOP_ENOSPC;
+    on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;

     if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
         if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && type != IF_NONE) {
             error_report("werror is not supported by this bus type");
     if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
         if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && type != IF_NONE) {
             error_report("werror is not supported by this bus type");


@@ -445,7 +446,7 @@ DriveInfo *drive_init(QemuOpts *opts, int default_to_scsi)
         }
     }
 
         }
     }
 

-    on_read_error = BLOCK_ERR_REPORT;
+    on_read_error = BLOCKDEV_ON_ERROR_REPORT;

     if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
         if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI && type != IF_NONE) {
             error_report("rerror is not supported by this bus type");
     if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
         if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI && type != IF_NONE) {
             error_report("rerror is not supported by this bus type");


@@ -829,7 +830,6 @@ exit:
     QSIMPLEQ_FOREACH_SAFE(states, &snap_bdrv_states, entry, next) {
         g_free(states);
     }
     QSIMPLEQ_FOREACH_SAFE(states, &snap_bdrv_states, entry, next) {
         g_free(states);
     }

-    return;

 }
 
 
 }
 
 


@@ -1095,13 +1095,18 @@ static void block_job_cb(void *opaque, int ret)
 }
 
 void qmp_block_stream(const char *device, bool has_base,
 }
 
 void qmp_block_stream(const char *device, bool has_base,

-                      const char *base, bool has_speed,
-                      int64_t speed, Error **errp)
+                      const char *base, bool has_speed, int64_t speed,
+                      bool has_on_error, BlockdevOnError on_error,
+                      Error **errp)

 {
     BlockDriverState *bs;
     BlockDriverState *base_bs = NULL;
     Error *local_err = NULL;
 
 {
     BlockDriverState *bs;
     BlockDriverState *base_bs = NULL;
     Error *local_err = NULL;
 

+    if (!has_on_error) {
+        on_error = BLOCKDEV_ON_ERROR_REPORT;
+    }
+

     bs = bdrv_find(device);
     if (!bs) {
         error_set(errp, QERR_DEVICE_NOT_FOUND, device);
     bs = bdrv_find(device);
     if (!bs) {
         error_set(errp, QERR_DEVICE_NOT_FOUND, device);


@@ -1117,7 +1122,7 @@ void qmp_block_stream(const char *device, bool has_base,
     }
 
     stream_start(bs, base_bs, base, has_speed ? speed : 0,
     }
 
     stream_start(bs, base_bs, base, has_speed ? speed : 0,

-                 block_job_cb, bs, &local_err);
+                 on_error, block_job_cb, bs, &local_err);

     if (error_is_set(&local_err)) {
         error_propagate(errp, local_err);
         return;
     if (error_is_set(&local_err)) {
         error_propagate(errp, local_err);
         return;


@@ -1142,7 +1147,7 @@ void qmp_block_commit(const char *device,
     /* This will be part of the QMP command, if/when the
      * BlockdevOnError change for blkmirror makes it in
      */
     /* This will be part of the QMP command, if/when the
      * BlockdevOnError change for blkmirror makes it in
      */

-    BlockErrorAction on_error = BLOCK_ERR_REPORT;
+    BlockdevOnError on_error = BLOCKDEV_ON_ERROR_REPORT;

 
     /* drain all i/o before commits */
     bdrv_drain_all();
 
     /* drain all i/o before commits */
     bdrv_drain_all();


@@ -1212,38 +1217,62 @@ void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
     block_job_set_speed(job, speed, errp);
 }
 
     block_job_set_speed(job, speed, errp);
 }
 

-void qmp_block_job_cancel(const char *device, Error **errp)
+void qmp_block_job_cancel(const char *device,
+                          bool has_force, bool force, Error **errp)

 {
     BlockJob *job = find_block_job(device);
 
 {
     BlockJob *job = find_block_job(device);
 

+    if (!has_force) {
+        force = false;
+    }
+

     if (!job) {
         error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
         return;
     }
     if (!job) {
         error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
         return;
     }

+    if (job->paused && !force) {
+        error_set(errp, QERR_BLOCK_JOB_PAUSED, device);
+        return;
+    }

 
     trace_qmp_block_job_cancel(job);
     block_job_cancel(job);
 }
 
 
     trace_qmp_block_job_cancel(job);
     block_job_cancel(job);
 }
 

+void qmp_block_job_pause(const char *device, Error **errp)
+{
+    BlockJob *job = find_block_job(device);
+
+    if (!job) {
+        error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
+        return;
+    }
+
+    trace_qmp_block_job_pause(job);
+    block_job_pause(job);
+}
+
+void qmp_block_job_resume(const char *device, Error **errp)
+{
+    BlockJob *job = find_block_job(device);
+
+    if (!job) {
+        error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
+        return;
+    }
+
+    trace_qmp_block_job_resume(job);
+    block_job_resume(job);
+}
+

 static void do_qmp_query_block_jobs_one(void *opaque, BlockDriverState *bs)
 {
     BlockJobInfoList **prev = opaque;
     BlockJob *job = bs->job;
 
     if (job) {
 static void do_qmp_query_block_jobs_one(void *opaque, BlockDriverState *bs)
 {
     BlockJobInfoList **prev = opaque;
     BlockJob *job = bs->job;
 
     if (job) {

-        BlockJobInfoList *elem;
-        BlockJobInfo *info = g_new(BlockJobInfo, 1);
-        *info = (BlockJobInfo){
-            .type   = g_strdup(job->job_type->job_type),
-            .device = g_strdup(bdrv_get_device_name(bs)),
-            .len    = job->len,
-            .offset = job->offset,
-            .speed  = job->speed,
-        };
-
-        elem = g_new0(BlockJobInfoList, 1);
-        elem->value = info;
-
+        BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1);
+        elem->value = block_job_query(bs->job);

         (*prev)->next = elem;
         *prev = elem;
     }
         (*prev)->next = elem;
         *prev = elem;
     }