target/ppc: Fix TCG temporary leaks in gen_slbia()

[qemu.git] / block / stream.c

diff --git a/block/stream.c b/block/stream.c
index 9264b68a1e89f0aacf9aefda5a7ca1221bd0cd63..aa2e7af98e37747526efbba6ef1120294e6abc55 100644 (file)
--- a/block/stream.c
+++ b/block/stream.c
@@ -22,52 +22,54 @@
 
 enum {
     /*
 
 enum {
     /*

-     * Size of data buffer for populating the image file.  This should be large
-     * enough to process multiple clusters in a single call, so that populating
-     * contiguous regions of the image is efficient.
+     * Maximum chunk size to feed to copy-on-read.  This should be
+     * large enough to process multiple clusters in a single call, so
+     * that populating contiguous regions of the image is efficient.

      */
      */

-    STREAM_BUFFER_SIZE = 512 * 1024, /* in bytes */
+    STREAM_CHUNK = 512 * 1024, /* in bytes */

 };
 
 typedef struct StreamBlockJob {
     BlockJob common;
 };
 
 typedef struct StreamBlockJob {
     BlockJob common;

-    BlockDriverState *base;
+    BlockDriverState *bottom;

     BlockdevOnError on_error;
     char *backing_file_str;
     BlockdevOnError on_error;
     char *backing_file_str;

-    int bs_flags;
+    bool bs_read_only;
+    bool chain_frozen;

 } StreamBlockJob;
 
 static int coroutine_fn stream_populate(BlockBackend *blk,
 } StreamBlockJob;
 
 static int coroutine_fn stream_populate(BlockBackend *blk,

-                                        int64_t offset, uint64_t bytes,
-                                        void *buf)
+                                        int64_t offset, uint64_t bytes)

 {
 {

-    struct iovec iov = {
-        .iov_base = buf,
-        .iov_len  = bytes,
-    };
-    QEMUIOVector qiov;
-

     assert(bytes < SIZE_MAX);
     assert(bytes < SIZE_MAX);

-    qemu_iovec_init_external(&qiov, &iov, 1);

 
 

-    /* Copy-on-read the unallocated clusters */
-    return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ);
+    return blk_co_preadv(blk, offset, bytes, NULL,
+                         BDRV_REQ_COPY_ON_READ | BDRV_REQ_PREFETCH);

 }
 
 }
 

-typedef struct {
-    int ret;
-} StreamCompleteData;
+static void stream_abort(Job *job)
+{
+    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
+
+    if (s->chain_frozen) {
+        BlockJob *bjob = &s->common;
+        bdrv_unfreeze_backing_chain(blk_bs(bjob->blk), s->bottom);
+    }
+}

 
 

-static void stream_complete(Job *job, void *opaque)
+static int stream_prepare(Job *job)

 {
     StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
     BlockJob *bjob = &s->common;
 {
     StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
     BlockJob *bjob = &s->common;

-    StreamCompleteData *data = opaque;

     BlockDriverState *bs = blk_bs(bjob->blk);
     BlockDriverState *bs = blk_bs(bjob->blk);

-    BlockDriverState *base = s->base;
+    BlockDriverState *base = backing_bs(s->bottom);

     Error *local_err = NULL;
     Error *local_err = NULL;

+    int ret = 0;
+
+    bdrv_unfreeze_backing_chain(bs, s->bottom);
+    s->chain_frozen = false;

 
 

-    if (!job_is_cancelled(job) && bs->backing && data->ret == 0) {
+    if (bs->backing) {

         const char *base_id = NULL, *base_fmt = NULL;
         if (base) {
             base_id = s->backing_file_str;
         const char *base_id = NULL, *base_fmt = NULL;
         if (base) {
             base_id = s->backing_file_str;


@@ -75,67 +77,68 @@ static void stream_complete(Job *job, void *opaque)
                 base_fmt = base->drv->format_name;
             }
         }
                 base_fmt = base->drv->format_name;
             }
         }

-        data->ret = bdrv_change_backing_file(bs, base_id, base_fmt);

         bdrv_set_backing_hd(bs, base, &local_err);
         bdrv_set_backing_hd(bs, base, &local_err);

+        ret = bdrv_change_backing_file(bs, base_id, base_fmt);

         if (local_err) {
             error_report_err(local_err);
         if (local_err) {
             error_report_err(local_err);

-            data->ret = -EPERM;
-            goto out;
+            return -EPERM;

         }
     }
 
         }
     }
 

-out:
+    return ret;
+}
+
+static void stream_clean(Job *job)
+{
+    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
+    BlockJob *bjob = &s->common;
+    BlockDriverState *bs = blk_bs(bjob->blk);
+

     /* Reopen the image back in read-only mode if necessary */
     /* Reopen the image back in read-only mode if necessary */

-    if (s->bs_flags != bdrv_get_flags(bs)) {
+    if (s->bs_read_only) {

         /* Give up write permissions before making it read-only */
         blk_set_perm(bjob->blk, 0, BLK_PERM_ALL, &error_abort);
         /* Give up write permissions before making it read-only */
         blk_set_perm(bjob->blk, 0, BLK_PERM_ALL, &error_abort);

-        bdrv_reopen(bs, s->bs_flags, NULL);
+        bdrv_reopen_set_read_only(bs, true, NULL);

     }
 
     g_free(s->backing_file_str);
     }
 
     g_free(s->backing_file_str);

-    job_completed(job, data->ret, NULL);
-    g_free(data);

 }
 
 }
 

-static void coroutine_fn stream_run(void *opaque)
+static int coroutine_fn stream_run(Job *job, Error **errp)

 {
 {

-    StreamBlockJob *s = opaque;
-    StreamCompleteData *data;
+    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);

     BlockBackend *blk = s->common.blk;
     BlockDriverState *bs = blk_bs(blk);
     BlockBackend *blk = s->common.blk;
     BlockDriverState *bs = blk_bs(blk);

-    BlockDriverState *base = s->base;
+    bool enable_cor = !backing_bs(s->bottom);

     int64_t len;
     int64_t offset = 0;
     uint64_t delay_ns = 0;
     int error = 0;
     int64_t len;
     int64_t offset = 0;
     uint64_t delay_ns = 0;
     int error = 0;

-    int ret = 0;

     int64_t n = 0; /* bytes */
     int64_t n = 0; /* bytes */

-    void *buf;

 
 

-    if (!bs->backing) {
-        goto out;
+    if (bs == s->bottom) {
+        /* Nothing to stream */
+        return 0;

     }
 
     len = bdrv_getlength(bs);
     if (len < 0) {
     }
 
     len = bdrv_getlength(bs);
     if (len < 0) {

-        ret = len;
-        goto out;
+        return len;

     }
     job_progress_set_remaining(&s->common.job, len);
 
     }
     job_progress_set_remaining(&s->common.job, len);
 

-    buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE);
-

     /* Turn on copy-on-read for the whole block device so that guest read
      * requests help us make progress.  Only do this when copying the entire
      * backing chain since the copy-on-read operation does not take base into
      * account.
      */
     /* Turn on copy-on-read for the whole block device so that guest read
      * requests help us make progress.  Only do this when copying the entire
      * backing chain since the copy-on-read operation does not take base into
      * account.
      */

-    if (!base) {
+    if (enable_cor) {

         bdrv_enable_copy_on_read(bs);
     }
 
     for ( ; offset < len; offset += n) {
         bool copy;
         bdrv_enable_copy_on_read(bs);
     }
 
     for ( ; offset < len; offset += n) {
         bool copy;

+        int ret;

 
         /* Note that even when no rate limit is applied we need to yield
          * with no pending I/O here so that bdrv_drain_all() returns.
 
         /* Note that even when no rate limit is applied we need to yield
          * with no pending I/O here so that bdrv_drain_all() returns.


@@ -147,15 +150,14 @@ static void coroutine_fn stream_run(void *opaque)
 
         copy = false;
 
 
         copy = false;
 

-        ret = bdrv_is_allocated(bs, offset, STREAM_BUFFER_SIZE, &n);
+        ret = bdrv_is_allocated(bs, offset, STREAM_CHUNK, &n);

         if (ret == 1) {
             /* Allocated in the top, no need to copy.  */
         } else if (ret >= 0) {
             /* Copy if allocated in the intermediate images.  Limit to the
              * known-unallocated area [offset, offset+n*BDRV_SECTOR_SIZE).  */
         if (ret == 1) {
             /* Allocated in the top, no need to copy.  */
         } else if (ret >= 0) {
             /* Copy if allocated in the intermediate images.  Limit to the
              * known-unallocated area [offset, offset+n*BDRV_SECTOR_SIZE).  */

-            ret = bdrv_is_allocated_above(backing_bs(bs), base,
+            ret = bdrv_is_allocated_above(backing_bs(bs), s->bottom, true,

                                           offset, n, &n);
                                           offset, n, &n);

-

             /* Finish early if end of backing file has been reached */
             if (ret == 0 && n == 0) {
                 n = len - offset;
             /* Finish early if end of backing file has been reached */
             if (ret == 0 && n == 0) {
                 n = len - offset;


@@ -165,7 +167,7 @@ static void coroutine_fn stream_run(void *opaque)
         }
         trace_stream_one_iteration(s, offset, n, ret);
         if (copy) {
         }
         trace_stream_one_iteration(s, offset, n, ret);
         if (copy) {

-            ret = stream_populate(blk, offset, n, buf);
+            ret = stream_populate(blk, offset, n);

         }
         if (ret < 0) {
             BlockErrorAction action =
         }
         if (ret < 0) {
             BlockErrorAction action =


@@ -181,7 +183,6 @@ static void coroutine_fn stream_run(void *opaque)
                 break;
             }
         }
                 break;
             }
         }

-        ret = 0;

 
         /* Publish progress */
         job_progress_update(&s->common.job, n);
 
         /* Publish progress */
         job_progress_update(&s->common.job, n);


@@ -192,20 +193,12 @@ static void coroutine_fn stream_run(void *opaque)
         }
     }
 
         }
     }
 

-    if (!base) {
+    if (enable_cor) {

         bdrv_disable_copy_on_read(bs);
     }
 
         bdrv_disable_copy_on_read(bs);
     }
 

-    /* Do not remove the backing file if an error was there but ignored.  */
-    ret = error;
-
-    qemu_vfree(buf);
-
-out:
-    /* Modify backing chain and close BDSes in main loop */
-    data = g_malloc(sizeof(*data));
-    data->ret = ret;
-    job_defer_to_main_loop(&s->common.job, stream_complete, data);
+    /* Do not remove the backing file if an error was there but ignored. */
+    return error;

 }
 
 static const BlockJobDriver stream_job_driver = {
 }
 
 static const BlockJobDriver stream_job_driver = {


@@ -213,25 +206,35 @@ static const BlockJobDriver stream_job_driver = {
         .instance_size = sizeof(StreamBlockJob),
         .job_type      = JOB_TYPE_STREAM,
         .free          = block_job_free,
         .instance_size = sizeof(StreamBlockJob),
         .job_type      = JOB_TYPE_STREAM,
         .free          = block_job_free,

-        .start         = stream_run,
+        .run           = stream_run,
+        .prepare       = stream_prepare,
+        .abort         = stream_abort,
+        .clean         = stream_clean,

         .user_resume   = block_job_user_resume,
         .user_resume   = block_job_user_resume,

-        .drain         = block_job_drain,

     },
 };
 
 void stream_start(const char *job_id, BlockDriverState *bs,
                   BlockDriverState *base, const char *backing_file_str,
     },
 };
 
 void stream_start(const char *job_id, BlockDriverState *bs,
                   BlockDriverState *base, const char *backing_file_str,

-                  int64_t speed, BlockdevOnError on_error, Error **errp)
+                  int creation_flags, int64_t speed,
+                  BlockdevOnError on_error, Error **errp)

 {
     StreamBlockJob *s;
     BlockDriverState *iter;
 {
     StreamBlockJob *s;
     BlockDriverState *iter;

-    int orig_bs_flags;
+    bool bs_read_only;
+    int basic_flags = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
+    BlockDriverState *bottom = bdrv_find_overlay(bs, base);
+
+    if (bdrv_freeze_backing_chain(bs, bottom, errp) < 0) {
+        return;
+    }

 
     /* Make sure that the image is opened in read-write mode */
 
     /* Make sure that the image is opened in read-write mode */

-    orig_bs_flags = bdrv_get_flags(bs);
-    if (!(orig_bs_flags & BDRV_O_RDWR)) {
-        if (bdrv_reopen(bs, orig_bs_flags | BDRV_O_RDWR, errp) != 0) {
-            return;
+    bs_read_only = bdrv_is_read_only(bs);
+    if (bs_read_only) {
+        if (bdrv_reopen_set_read_only(bs, false, errp) != 0) {
+            bs_read_only = false;
+            goto fail;

         }
     }
 
         }
     }
 


@@ -239,28 +242,30 @@ void stream_start(const char *job_id, BlockDriverState *bs,
      * already have our own plans. Also don't allow resize as the image size is
      * queried only at the job start and then cached. */
     s = block_job_create(job_id, &stream_job_driver, NULL, bs,
      * already have our own plans. Also don't allow resize as the image size is
      * queried only at the job start and then cached. */
     s = block_job_create(job_id, &stream_job_driver, NULL, bs,

-                         BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
-                         BLK_PERM_GRAPH_MOD,
-                         BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
-                         BLK_PERM_WRITE,
-                         speed, JOB_DEFAULT, NULL, NULL, errp);
+                         basic_flags | BLK_PERM_GRAPH_MOD,
+                         basic_flags | BLK_PERM_WRITE,
+                         speed, creation_flags, NULL, NULL, errp);

     if (!s) {
         goto fail;
     }
 
     /* Block all intermediate nodes between bs and base, because they will
      * disappear from the chain after this operation. The streaming job reads
     if (!s) {
         goto fail;
     }
 
     /* Block all intermediate nodes between bs and base, because they will
      * disappear from the chain after this operation. The streaming job reads

-     * every block only once, assuming that it doesn't change, so block writes
-     * and resizes. */
+     * every block only once, assuming that it doesn't change, so forbid writes
+     * and resizes. Reassign the base node pointer because the backing BS of the
+     * bottom node might change after the call to bdrv_reopen_set_read_only()
+     * due to parallel block jobs running.
+     */
+    base = backing_bs(bottom);

     for (iter = backing_bs(bs); iter && iter != base; iter = backing_bs(iter)) {
         block_job_add_bdrv(&s->common, "intermediate node", iter, 0,
     for (iter = backing_bs(bs); iter && iter != base; iter = backing_bs(iter)) {
         block_job_add_bdrv(&s->common, "intermediate node", iter, 0,

-                           BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED,
-                           &error_abort);
+                           basic_flags, &error_abort);

     }
 
     }
 

-    s->base = base;
+    s->bottom = bottom;

     s->backing_file_str = g_strdup(backing_file_str);
     s->backing_file_str = g_strdup(backing_file_str);

-    s->bs_flags = orig_bs_flags;
+    s->bs_read_only = bs_read_only;
+    s->chain_frozen = true;

 
     s->on_error = on_error;
     trace_stream_start(bs, base, s);
 
     s->on_error = on_error;
     trace_stream_start(bs, base, s);


@@ -268,7 +273,8 @@ void stream_start(const char *job_id, BlockDriverState *bs,
     return;
 
 fail:
     return;
 
 fail:

-    if (orig_bs_flags != bdrv_get_flags(bs)) {
-        bdrv_reopen(bs, orig_bs_flags, NULL);
+    if (bs_read_only) {
+        bdrv_reopen_set_read_only(bs, true, NULL);

     }
     }

+    bdrv_unfreeze_backing_chain(bs, bottom);

 }
 }