qcow2: Rename BDRVQcowState to BDRVQcow2State

[qemu.git] / block / stream.c

diff --git a/block/stream.c b/block/stream.c
index 694fd42e41a855489fe7460c694df521bbbd773d..ab0bd057f7533f5f5eb5dcfa0ef56b18e1dcf323 100644 (file)
--- a/block/stream.c
+++ b/block/stream.c
@@ -14,6 +14,7 @@
 #include "trace.h"
 #include "block/block_int.h"
 #include "block/blockjob.h"
 #include "trace.h"
 #include "block/block_int.h"
 #include "block/blockjob.h"

+#include "qapi/qmp/qerror.h"

 #include "qemu/ratelimit.h"
 
 enum {
 #include "qemu/ratelimit.h"
 
 enum {


@@ -32,7 +33,7 @@ typedef struct StreamBlockJob {
     RateLimit limit;
     BlockDriverState *base;
     BlockdevOnError on_error;
     RateLimit limit;
     BlockDriverState *base;
     BlockdevOnError on_error;

-    char backing_file_id[1024];
+    char *backing_file_str;

 } StreamBlockJob;
 
 static int coroutine_fn stream_populate(BlockDriverState *bs,
 } StreamBlockJob;
 
 static int coroutine_fn stream_populate(BlockDriverState *bs,


@@ -60,7 +61,7 @@ static void close_unused_images(BlockDriverState *top, BlockDriverState *base,
     /* Must assign before bdrv_delete() to prevent traversing dangling pointer
      * while we delete backing image instances.
      */
     /* Must assign before bdrv_delete() to prevent traversing dangling pointer
      * while we delete backing image instances.
      */

-    top->backing_hd = base;
+    bdrv_set_backing_hd(top, base);

 
     while (intermediate) {
         BlockDriverState *unused;
 
     while (intermediate) {
         BlockDriverState *unused;


@@ -72,14 +73,46 @@ static void close_unused_images(BlockDriverState *top, BlockDriverState *base,
 
         unused = intermediate;
         intermediate = intermediate->backing_hd;
 
         unused = intermediate;
         intermediate = intermediate->backing_hd;

-        unused->backing_hd = NULL;
+        bdrv_set_backing_hd(unused, NULL);

         bdrv_unref(unused);
     }
         bdrv_unref(unused);
     }

+
+    bdrv_refresh_limits(top, NULL);
+}
+
+typedef struct {
+    int ret;
+    bool reached_end;
+} StreamCompleteData;
+
+static void stream_complete(BlockJob *job, void *opaque)
+{
+    StreamBlockJob *s = container_of(job, StreamBlockJob, common);
+    StreamCompleteData *data = opaque;
+    BlockDriverState *base = s->base;
+
+    if (!block_job_is_cancelled(&s->common) && data->reached_end &&
+        data->ret == 0) {
+        const char *base_id = NULL, *base_fmt = NULL;
+        if (base) {
+            base_id = s->backing_file_str;
+            if (base->drv) {
+                base_fmt = base->drv->format_name;
+            }
+        }
+        data->ret = bdrv_change_backing_file(job->bs, base_id, base_fmt);
+        close_unused_images(job->bs, base, base_id);
+    }
+
+    g_free(s->backing_file_str);
+    block_job_completed(&s->common, data->ret);
+    g_free(data);

 }
 
 static void coroutine_fn stream_run(void *opaque)
 {
     StreamBlockJob *s = opaque;
 }
 
 static void coroutine_fn stream_run(void *opaque)
 {
     StreamBlockJob *s = opaque;

+    StreamCompleteData *data;

     BlockDriverState *bs = s->common.bs;
     BlockDriverState *base = s->base;
     int64_t sector_num, end;
     BlockDriverState *bs = s->common.bs;
     BlockDriverState *base = s->base;
     int64_t sector_num, end;


@@ -88,6 +121,11 @@ static void coroutine_fn stream_run(void *opaque)
     int n = 0;
     void *buf;
 
     int n = 0;
     void *buf;
 

+    if (!bs->backing_hd) {
+        block_job_completed(&s->common, 0);
+        return;
+    }
+

     s->common.len = bdrv_getlength(bs);
     if (s->common.len < 0) {
         block_job_completed(&s->common, s->common.len);
     s->common.len = bdrv_getlength(bs);
     if (s->common.len < 0) {
         block_job_completed(&s->common, s->common.len);


@@ -152,14 +190,14 @@ wait:
             BlockErrorAction action =
                 block_job_error_action(&s->common, s->common.bs, s->on_error,
                                        true, -ret);
             BlockErrorAction action =
                 block_job_error_action(&s->common, s->common.bs, s->on_error,
                                        true, -ret);

-            if (action == BDRV_ACTION_STOP) {
+            if (action == BLOCK_ERROR_ACTION_STOP) {

                 n = 0;
                 continue;
             }
             if (error == 0) {
                 error = ret;
             }
                 n = 0;
                 continue;
             }
             if (error == 0) {
                 error = ret;
             }

-            if (action == BDRV_ACTION_REPORT) {
+            if (action == BLOCK_ERROR_ACTION_REPORT) {

                 break;
             }
         }
                 break;
             }
         }


@@ -176,20 +214,13 @@ wait:
     /* Do not remove the backing file if an error was there but ignored.  */
     ret = error;
 
     /* Do not remove the backing file if an error was there but ignored.  */
     ret = error;
 

-    if (!block_job_is_cancelled(&s->common) && sector_num == end && ret == 0) {
-        const char *base_id = NULL, *base_fmt = NULL;
-        if (base) {
-            base_id = s->backing_file_id;
-            if (base->drv) {
-                base_fmt = base->drv->format_name;
-            }
-        }
-        ret = bdrv_change_backing_file(bs, base_id, base_fmt);
-        close_unused_images(bs, base, base_id);
-    }
-

     qemu_vfree(buf);
     qemu_vfree(buf);

-    block_job_completed(&s->common, ret);
+
+    /* Modify backing chain and close BDSes in main loop */
+    data = g_malloc(sizeof(*data));
+    data->ret = ret;
+    data->reached_end = sector_num == end;
+    block_job_defer_to_main_loop(&s->common, stream_complete, data);

 }
 
 static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp)
 }
 
 static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp)


@@ -197,7 +228,7 @@ static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp)
     StreamBlockJob *s = container_of(job, StreamBlockJob, common);
 
     if (speed < 0) {
     StreamBlockJob *s = container_of(job, StreamBlockJob, common);
 
     if (speed < 0) {

-        error_set(errp, QERR_INVALID_PARAMETER, "speed");
+        error_setg(errp, QERR_INVALID_PARAMETER, "speed");

         return;
     }
     ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);
         return;
     }
     ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);


@@ -210,9 +241,9 @@ static const BlockJobDriver stream_job_driver = {
 };
 
 void stream_start(BlockDriverState *bs, BlockDriverState *base,
 };
 
 void stream_start(BlockDriverState *bs, BlockDriverState *base,

-                  const char *base_id, int64_t speed,
+                  const char *backing_file_str, int64_t speed,

                   BlockdevOnError on_error,
                   BlockdevOnError on_error,

-                  BlockDriverCompletionFunc *cb,
+                  BlockCompletionFunc *cb,

                   void *opaque, Error **errp)
 {
     StreamBlockJob *s;
                   void *opaque, Error **errp)
 {
     StreamBlockJob *s;


@@ -220,7 +251,7 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base,
     if ((on_error == BLOCKDEV_ON_ERROR_STOP ||
          on_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
         !bdrv_iostatus_is_enabled(bs)) {
     if ((on_error == BLOCKDEV_ON_ERROR_STOP ||
          on_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
         !bdrv_iostatus_is_enabled(bs)) {

-        error_set(errp, QERR_INVALID_PARAMETER, "on-error");
+        error_setg(errp, QERR_INVALID_PARAMETER, "on-error");

         return;
     }
 
         return;
     }
 


@@ -230,9 +261,7 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base,
     }
 
     s->base = base;
     }
 
     s->base = base;

-    if (base_id) {
-        pstrcpy(s->backing_file_id, sizeof(s->backing_file_id), base_id);
-    }
+    s->backing_file_str = g_strdup(backing_file_str);

 
     s->on_error = on_error;
     s->common.co = qemu_coroutine_create(stream_run);
 
     s->on_error = on_error;
     s->common.co = qemu_coroutine_create(stream_run);