libqtest: Replace qtest_startf() by qtest_initf()

[qemu.git] / blockdev.c

diff --git a/blockdev.c b/blockdev.c
index 1fbfd3a2c40d9d9b495c616c209cfdca2da15031..dcf8c8d2ab95d45aa9efdab63a09308648612adb 100644 (file)
--- a/blockdev.c
+++ b/blockdev.c
@@ -35,6 +35,7 @@
 #include "sysemu/blockdev.h"
 #include "hw/block/block.h"
 #include "block/blockjob.h"
 #include "sysemu/blockdev.h"
 #include "hw/block/block.h"
 #include "block/blockjob.h"

+#include "block/qdict.h"

 #include "block/throttle-groups.h"
 #include "monitor/monitor.h"
 #include "qemu/error-report.h"
 #include "block/throttle-groups.h"
 #include "monitor/monitor.h"
 #include "qemu/error-report.h"


@@ -150,7 +151,7 @@ void blockdev_mark_auto_del(BlockBackend *blk)
         aio_context_acquire(aio_context);
 
         if (bs->job) {
         aio_context_acquire(aio_context);
 
         if (bs->job) {

-            block_job_cancel(bs->job);
+            job_cancel(&bs->job->job, false);

         }
 
         aio_context_release(aio_context);
         }
 
         aio_context_release(aio_context);


@@ -334,7 +335,8 @@ static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals,
 
         case QTYPE_QSTRING: {
             unsigned long long length;
 
         case QTYPE_QSTRING: {
             unsigned long long length;

-            const char *str = qstring_get_str(qobject_to_qstring(entry->value));
+            const char *str = qstring_get_str(qobject_to(QString,
+                                                         entry->value));

             if (parse_uint_full(str, &length, 10) == 0 &&
                 length > 0 && length <= UINT_MAX) {
                 block_acct_add_interval(stats, (unsigned) length);
             if (parse_uint_full(str, &length, 10) == 0 &&
                 length > 0 && length <= UINT_MAX) {
                 block_acct_add_interval(stats, (unsigned) length);


@@ -346,7 +348,7 @@ static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals,
         }
 
         case QTYPE_QNUM: {
         }
 
         case QTYPE_QNUM: {

-            int64_t length = qnum_get_int(qobject_to_qnum(entry->value));
+            int64_t length = qnum_get_int(qobject_to(QNum, entry->value));

 
             if (length > 0 && length <= UINT_MAX) {
                 block_acct_add_interval(stats, (unsigned) length);
 
             if (length > 0 && length <= UINT_MAX) {
                 block_acct_add_interval(stats, (unsigned) length);


@@ -575,7 +577,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
         blk_rs->read_only     = read_only;
         blk_rs->detect_zeroes = detect_zeroes;
 
         blk_rs->read_only     = read_only;
         blk_rs->detect_zeroes = detect_zeroes;
 

-        QDECREF(bs_opts);
+        qobject_unref(bs_opts);

     } else {
         if (file && !*file) {
             file = NULL;
     } else {
         if (file && !*file) {
             file = NULL;


@@ -631,16 +633,16 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
 
 err_no_bs_opts:
     qemu_opts_del(opts);
 
 err_no_bs_opts:
     qemu_opts_del(opts);

-    QDECREF(interval_dict);
-    QDECREF(interval_list);
+    qobject_unref(interval_dict);
+    qobject_unref(interval_list);

     return blk;
 
 early_err:
     qemu_opts_del(opts);
     return blk;
 
 early_err:
     qemu_opts_del(opts);

-    QDECREF(interval_dict);
-    QDECREF(interval_list);
+    qobject_unref(interval_dict);
+    qobject_unref(interval_list);

 err_no_opts:
 err_no_opts:

-    QDECREF(bs_opts);
+    qobject_unref(bs_opts);

     return NULL;
 }
 
     return NULL;
 }
 


@@ -1129,7 +1131,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
 
 fail:
     qemu_opts_del(legacy_opts);
 
 fail:
     qemu_opts_del(legacy_opts);

-    QDECREF(bs_opts);
+    qobject_unref(bs_opts);

     return dinfo;
 }
 
     return dinfo;
 }
 


@@ -1445,7 +1447,7 @@ typedef struct BlkActionOps {
 struct BlkActionState {
     TransactionAction *action;
     const BlkActionOps *ops;
 struct BlkActionState {
     TransactionAction *action;
     const BlkActionOps *ops;

-    BlockJobTxn *block_job_txn;
+    JobTxn *block_job_txn;

     TransactionProperties *txn_props;
     QSIMPLEQ_ENTRY(BlkActionState) entry;
 };
     TransactionProperties *txn_props;
     QSIMPLEQ_ENTRY(BlkActionState) entry;
 };


@@ -1863,7 +1865,7 @@ typedef struct DriveBackupState {
     BlockJob *job;
 } DriveBackupState;
 
     BlockJob *job;
 } DriveBackupState;
 

-static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
+static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,

                             Error **errp);
 
 static void drive_backup_prepare(BlkActionState *common, Error **errp)
                             Error **errp);
 
 static void drive_backup_prepare(BlkActionState *common, Error **errp)


@@ -1909,7 +1911,7 @@ static void drive_backup_commit(BlkActionState *common)
     aio_context_acquire(aio_context);
 
     assert(state->job);
     aio_context_acquire(aio_context);
 
     assert(state->job);

-    block_job_start(state->job);
+    job_start(&state->job->job);

 
     aio_context_release(aio_context);
 }
 
     aio_context_release(aio_context);
 }


@@ -1924,7 +1926,7 @@ static void drive_backup_abort(BlkActionState *common)
         aio_context = bdrv_get_aio_context(state->bs);
         aio_context_acquire(aio_context);
 
         aio_context = bdrv_get_aio_context(state->bs);
         aio_context_acquire(aio_context);
 

-        block_job_cancel_sync(state->job);
+        job_cancel_sync(&state->job->job);

 
         aio_context_release(aio_context);
     }
 
         aio_context_release(aio_context);
     }


@@ -1953,7 +1955,7 @@ typedef struct BlockdevBackupState {
     BlockJob *job;
 } BlockdevBackupState;
 
     BlockJob *job;
 } BlockdevBackupState;
 

-static BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
+static BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,

                                     Error **errp);
 
 static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
                                     Error **errp);
 
 static void blockdev_backup_prepare(BlkActionState *common, Error **errp)


@@ -1967,7 +1969,7 @@ static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
     assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
     backup = common->action->u.blockdev_backup.data;
 
     assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
     backup = common->action->u.blockdev_backup.data;
 

-    bs = qmp_get_root_bs(backup->device, errp);
+    bs = bdrv_lookup_bs(backup->device, backup->device, errp);

     if (!bs) {
         return;
     }
     if (!bs) {
         return;
     }


@@ -2007,7 +2009,7 @@ static void blockdev_backup_commit(BlkActionState *common)
     aio_context_acquire(aio_context);
 
     assert(state->job);
     aio_context_acquire(aio_context);
 
     assert(state->job);

-    block_job_start(state->job);
+    job_start(&state->job->job);

 
     aio_context_release(aio_context);
 }
 
     aio_context_release(aio_context);
 }


@@ -2022,7 +2024,7 @@ static void blockdev_backup_abort(BlkActionState *common)
         aio_context = bdrv_get_aio_context(state->bs);
         aio_context_acquire(aio_context);
 
         aio_context = bdrv_get_aio_context(state->bs);
         aio_context_acquire(aio_context);
 

-        block_job_cancel_sync(state->job);
+        job_cancel_sync(&state->job->job);

 
         aio_context_release(aio_context);
     }
 
         aio_context_release(aio_context);
     }


@@ -2051,6 +2053,7 @@ typedef struct BlockDirtyBitmapState {
     BlockDriverState *bs;
     HBitmap *backup;
     bool prepared;
     BlockDriverState *bs;
     HBitmap *backup;
     bool prepared;

+    bool was_enabled;

 } BlockDirtyBitmapState;
 
 static void block_dirty_bitmap_add_prepare(BlkActionState *common,
 } BlockDirtyBitmapState;
 
 static void block_dirty_bitmap_add_prepare(BlkActionState *common,


@@ -2071,6 +2074,7 @@ static void block_dirty_bitmap_add_prepare(BlkActionState *common,
                                action->has_granularity, action->granularity,
                                action->has_persistent, action->persistent,
                                action->has_autoload, action->autoload,
                                action->has_granularity, action->granularity,
                                action->has_persistent, action->persistent,
                                action->has_autoload, action->autoload,

+                               action->has_x_disabled, action->x_disabled,

                                &local_err);
 
     if (!local_err) {
                                &local_err);
 
     if (!local_err) {


@@ -2118,6 +2122,9 @@ static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
     if (bdrv_dirty_bitmap_frozen(state->bitmap)) {
         error_setg(errp, "Cannot modify a frozen bitmap");
         return;
     if (bdrv_dirty_bitmap_frozen(state->bitmap)) {
         error_setg(errp, "Cannot modify a frozen bitmap");
         return;

+    } else if (bdrv_dirty_bitmap_qmp_locked(state->bitmap)) {
+        error_setg(errp, "Cannot modify a locked bitmap");
+        return;

     } else if (!bdrv_dirty_bitmap_enabled(state->bitmap)) {
         error_setg(errp, "Cannot clear a disabled bitmap");
         return;
     } else if (!bdrv_dirty_bitmap_enabled(state->bitmap)) {
         error_setg(errp, "Cannot clear a disabled bitmap");
         return;


@@ -2147,6 +2154,74 @@ static void block_dirty_bitmap_clear_commit(BlkActionState *common)
     hbitmap_free(state->backup);
 }
 
     hbitmap_free(state->backup);
 }
 

+static void block_dirty_bitmap_enable_prepare(BlkActionState *common,
+                                              Error **errp)
+{
+    BlockDirtyBitmap *action;
+    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
+                                             common, common);
+
+    if (action_check_completion_mode(common, errp) < 0) {
+        return;
+    }
+
+    action = common->action->u.x_block_dirty_bitmap_enable.data;
+    state->bitmap = block_dirty_bitmap_lookup(action->node,
+                                              action->name,
+                                              NULL,
+                                              errp);
+    if (!state->bitmap) {
+        return;
+    }
+
+    state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
+    bdrv_enable_dirty_bitmap(state->bitmap);
+}
+
+static void block_dirty_bitmap_enable_abort(BlkActionState *common)
+{
+    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
+                                             common, common);
+
+    if (!state->was_enabled) {
+        bdrv_disable_dirty_bitmap(state->bitmap);
+    }
+}
+
+static void block_dirty_bitmap_disable_prepare(BlkActionState *common,
+                                               Error **errp)
+{
+    BlockDirtyBitmap *action;
+    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
+                                             common, common);
+
+    if (action_check_completion_mode(common, errp) < 0) {
+        return;
+    }
+
+    action = common->action->u.x_block_dirty_bitmap_disable.data;
+    state->bitmap = block_dirty_bitmap_lookup(action->node,
+                                              action->name,
+                                              NULL,
+                                              errp);
+    if (!state->bitmap) {
+        return;
+    }
+
+    state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
+    bdrv_disable_dirty_bitmap(state->bitmap);
+}
+
+static void block_dirty_bitmap_disable_abort(BlkActionState *common)
+{
+    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
+                                             common, common);
+
+    if (state->was_enabled) {
+        bdrv_enable_dirty_bitmap(state->bitmap);
+    }
+}
+

 static void abort_prepare(BlkActionState *common, Error **errp)
 {
     error_setg(errp, "Transaction aborted using Abort action");
 static void abort_prepare(BlkActionState *common, Error **errp)
 {
     error_setg(errp, "Transaction aborted using Abort action");


@@ -2207,7 +2282,17 @@ static const BlkActionOps actions[] = {
         .prepare = block_dirty_bitmap_clear_prepare,
         .commit = block_dirty_bitmap_clear_commit,
         .abort = block_dirty_bitmap_clear_abort,
         .prepare = block_dirty_bitmap_clear_prepare,
         .commit = block_dirty_bitmap_clear_commit,
         .abort = block_dirty_bitmap_clear_abort,

-    }
+    },
+    [TRANSACTION_ACTION_KIND_X_BLOCK_DIRTY_BITMAP_ENABLE] = {
+        .instance_size = sizeof(BlockDirtyBitmapState),
+        .prepare = block_dirty_bitmap_enable_prepare,
+        .abort = block_dirty_bitmap_enable_abort,
+    },
+    [TRANSACTION_ACTION_KIND_X_BLOCK_DIRTY_BITMAP_DISABLE] = {
+        .instance_size = sizeof(BlockDirtyBitmapState),
+        .prepare = block_dirty_bitmap_disable_prepare,
+        .abort = block_dirty_bitmap_disable_abort,
+     }

 };
 
 /**
 };
 
 /**


@@ -2239,7 +2324,7 @@ void qmp_transaction(TransactionActionList *dev_list,
                      Error **errp)
 {
     TransactionActionList *dev_entry = dev_list;
                      Error **errp)
 {
     TransactionActionList *dev_entry = dev_list;

-    BlockJobTxn *block_job_txn = NULL;
+    JobTxn *block_job_txn = NULL;

     BlkActionState *state, *next;
     Error *local_err = NULL;
 
     BlkActionState *state, *next;
     Error *local_err = NULL;
 


@@ -2247,11 +2332,11 @@ void qmp_transaction(TransactionActionList *dev_list,
     QSIMPLEQ_INIT(&snap_bdrv_states);
 
     /* Does this transaction get canceled as a group on failure?
     QSIMPLEQ_INIT(&snap_bdrv_states);
 
     /* Does this transaction get canceled as a group on failure?

-     * If not, we don't really need to make a BlockJobTxn.
+     * If not, we don't really need to make a JobTxn.

      */
     props = get_transaction_properties(props);
     if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
      */
     props = get_transaction_properties(props);
     if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {

-        block_job_txn = block_job_txn_new();
+        block_job_txn = job_txn_new();

     }
 
     /* drain all i/o before any operations */
     }
 
     /* drain all i/o before any operations */


@@ -2310,7 +2395,7 @@ exit:
     if (!has_props) {
         qapi_free_TransactionProperties(props);
     }
     if (!has_props) {
         qapi_free_TransactionProperties(props);
     }

-    block_job_txn_unref(block_job_txn);
+    job_txn_unref(block_job_txn);

 }
 
 void qmp_eject(bool has_device, const char *device,
 }
 
 void qmp_eject(bool has_device, const char *device,


@@ -2797,6 +2882,7 @@ void qmp_block_dirty_bitmap_add(const char *node, const char *name,
                                 bool has_granularity, uint32_t granularity,
                                 bool has_persistent, bool persistent,
                                 bool has_autoload, bool autoload,
                                 bool has_granularity, uint32_t granularity,
                                 bool has_persistent, bool persistent,
                                 bool has_autoload, bool autoload,

+                                bool has_disabled, bool disabled,

                                 Error **errp)
 {
     BlockDriverState *bs;
                                 Error **errp)
 {
     BlockDriverState *bs;


@@ -2831,6 +2917,10 @@ void qmp_block_dirty_bitmap_add(const char *node, const char *name,
         warn_report("Autoload option is deprecated and its value is ignored");
     }
 
         warn_report("Autoload option is deprecated and its value is ignored");
     }
 

+    if (!has_disabled) {
+        disabled = false;
+    }
+

     if (persistent &&
         !bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp))
     {
     if (persistent &&
         !bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp))
     {


@@ -2842,6 +2932,10 @@ void qmp_block_dirty_bitmap_add(const char *node, const char *name,
         return;
     }
 
         return;
     }
 

+    if (disabled) {
+        bdrv_disable_dirty_bitmap(bitmap);
+    }
+

     bdrv_dirty_bitmap_set_persistance(bitmap, persistent);
 }
 
     bdrv_dirty_bitmap_set_persistance(bitmap, persistent);
 }
 


@@ -2862,6 +2956,11 @@ void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
                    "Bitmap '%s' is currently frozen and cannot be removed",
                    name);
         return;
                    "Bitmap '%s' is currently frozen and cannot be removed",
                    name);
         return;

+    } else if (bdrv_dirty_bitmap_qmp_locked(bitmap)) {
+        error_setg(errp,
+                   "Bitmap '%s' is currently locked and cannot be removed",
+                   name);
+        return;

     }
 
     if (bdrv_dirty_bitmap_get_persistance(bitmap)) {
     }
 
     if (bdrv_dirty_bitmap_get_persistance(bitmap)) {


@@ -2872,7 +2971,6 @@ void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
         }
     }
 
         }
     }
 

-    bdrv_dirty_bitmap_make_anon(bitmap);

     bdrv_release_dirty_bitmap(bs, bitmap);
 }
 
     bdrv_release_dirty_bitmap(bs, bitmap);
 }
 


@@ -2896,6 +2994,11 @@ void qmp_block_dirty_bitmap_clear(const char *node, const char *name,
                    "Bitmap '%s' is currently frozen and cannot be modified",
                    name);
         return;
                    "Bitmap '%s' is currently frozen and cannot be modified",
                    name);
         return;

+    } else if (bdrv_dirty_bitmap_qmp_locked(bitmap)) {
+        error_setg(errp,
+                   "Bitmap '%s' is currently locked and cannot be modified",
+                   name);
+        return;

     } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
         error_setg(errp,
                    "Bitmap '%s' is currently disabled and cannot be cleared",
     } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
         error_setg(errp,
                    "Bitmap '%s' is currently disabled and cannot be cleared",


@@ -2909,6 +3012,78 @@ void qmp_block_dirty_bitmap_clear(const char *node, const char *name,
     bdrv_clear_dirty_bitmap(bitmap, NULL);
 }
 
     bdrv_clear_dirty_bitmap(bitmap, NULL);
 }
 

+void qmp_x_block_dirty_bitmap_enable(const char *node, const char *name,
+                                   Error **errp)
+{
+    BlockDriverState *bs;
+    BdrvDirtyBitmap *bitmap;
+
+    bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
+    if (!bitmap) {
+        return;
+    }
+
+    if (bdrv_dirty_bitmap_frozen(bitmap)) {
+        error_setg(errp,
+                   "Bitmap '%s' is currently frozen and cannot be enabled",
+                   name);
+        return;
+    }
+
+    bdrv_enable_dirty_bitmap(bitmap);
+}
+
+void qmp_x_block_dirty_bitmap_disable(const char *node, const char *name,
+                                    Error **errp)
+{
+    BlockDriverState *bs;
+    BdrvDirtyBitmap *bitmap;
+
+    bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
+    if (!bitmap) {
+        return;
+    }
+
+    if (bdrv_dirty_bitmap_frozen(bitmap)) {
+        error_setg(errp,
+                   "Bitmap '%s' is currently frozen and cannot be disabled",
+                   name);
+        return;
+    }
+
+    bdrv_disable_dirty_bitmap(bitmap);
+}
+
+void qmp_x_block_dirty_bitmap_merge(const char *node, const char *dst_name,
+                                    const char *src_name, Error **errp)
+{
+    BlockDriverState *bs;
+    BdrvDirtyBitmap *dst, *src;
+
+    dst = block_dirty_bitmap_lookup(node, dst_name, &bs, errp);
+    if (!dst) {
+        return;
+    }
+
+    if (bdrv_dirty_bitmap_frozen(dst)) {
+        error_setg(errp, "Bitmap '%s' is frozen and cannot be modified",
+                   dst_name);
+        return;
+    } else if (bdrv_dirty_bitmap_readonly(dst)) {
+        error_setg(errp, "Bitmap '%s' is readonly and cannot be modified",
+                   dst_name);
+        return;
+    }
+
+    src = bdrv_find_dirty_bitmap(bs, src_name);
+    if (!src) {
+        error_setg(errp, "Dirty bitmap '%s' not found", src_name);
+        return;
+    }
+
+    bdrv_merge_dirty_bitmap(dst, src, errp);
+}
+

 BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node,
                                                               const char *name,
                                                               Error **errp)
 BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node,
                                                               const char *name,
                                                               Error **errp)


@@ -3230,7 +3405,7 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
             goto out;
         }
         commit_active_start(has_job_id ? job_id : NULL, bs, base_bs,
             goto out;
         }
         commit_active_start(has_job_id ? job_id : NULL, bs, base_bs,

-                            BLOCK_JOB_DEFAULT, speed, on_error,
+                            JOB_DEFAULT, speed, on_error,

                             filter_node_name, NULL, NULL, false, &local_err);
     } else {
         BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);
                             filter_node_name, NULL, NULL, false, &local_err);
     } else {
         BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);


@@ -3250,7 +3425,7 @@ out:
     aio_context_release(aio_context);
 }
 
     aio_context_release(aio_context);
 }
 

-static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
+static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,

                                  Error **errp)
 {
     BlockDriverState *bs;
                                  Error **errp)
 {
     BlockDriverState *bs;


@@ -3261,7 +3436,7 @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
     AioContext *aio_context;
     QDict *options = NULL;
     Error *local_err = NULL;
     AioContext *aio_context;
     QDict *options = NULL;
     Error *local_err = NULL;

-    int flags;
+    int flags, job_flags = JOB_DEFAULT;

     int64_t size;
     bool set_backing_hd = false;
 
     int64_t size;
     bool set_backing_hd = false;
 


@@ -3280,6 +3455,12 @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
     if (!backup->has_job_id) {
         backup->job_id = NULL;
     }
     if (!backup->has_job_id) {
         backup->job_id = NULL;
     }

+    if (!backup->has_auto_finalize) {
+        backup->auto_finalize = true;
+    }
+    if (!backup->has_auto_dismiss) {
+        backup->auto_dismiss = true;
+    }

     if (!backup->has_compress) {
         backup->compress = false;
     }
     if (!backup->has_compress) {
         backup->compress = false;
     }


@@ -3370,12 +3551,24 @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
             bdrv_unref(target_bs);
             goto out;
         }
             bdrv_unref(target_bs);
             goto out;
         }

+        if (bdrv_dirty_bitmap_qmp_locked(bmap)) {
+            error_setg(errp,
+                       "Bitmap '%s' is currently locked and cannot be used for "
+                       "backup", backup->bitmap);
+            goto out;
+        }
+    }
+    if (!backup->auto_finalize) {
+        job_flags |= JOB_MANUAL_FINALIZE;
+    }
+    if (!backup->auto_dismiss) {
+        job_flags |= JOB_MANUAL_DISMISS;

     }
 
     job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
                             backup->sync, bmap, backup->compress,
                             backup->on_source_error, backup->on_target_error,
     }
 
     job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
                             backup->sync, bmap, backup->compress,
                             backup->on_source_error, backup->on_target_error,

-                            BLOCK_JOB_DEFAULT, NULL, NULL, txn, &local_err);
+                            job_flags, NULL, NULL, txn, &local_err);

     bdrv_unref(target_bs);
     if (local_err != NULL) {
         error_propagate(errp, local_err);
     bdrv_unref(target_bs);
     if (local_err != NULL) {
         error_propagate(errp, local_err);


@@ -3393,7 +3586,7 @@ void qmp_drive_backup(DriveBackup *arg, Error **errp)
     BlockJob *job;
     job = do_drive_backup(arg, NULL, errp);
     if (job) {
     BlockJob *job;
     job = do_drive_backup(arg, NULL, errp);
     if (job) {

-        block_job_start(job);
+        job_start(&job->job);

     }
 }
 
     }
 }
 


@@ -3402,7 +3595,7 @@ BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
     return bdrv_named_nodes_list(errp);
 }
 
     return bdrv_named_nodes_list(errp);
 }
 

-BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
+BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,

                              Error **errp)
 {
     BlockDriverState *bs;
                              Error **errp)
 {
     BlockDriverState *bs;


@@ -3410,6 +3603,7 @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
     Error *local_err = NULL;
     AioContext *aio_context;
     BlockJob *job = NULL;
     Error *local_err = NULL;
     AioContext *aio_context;
     BlockJob *job = NULL;

+    int job_flags = JOB_DEFAULT;

 
     if (!backup->has_speed) {
         backup->speed = 0;
 
     if (!backup->has_speed) {
         backup->speed = 0;


@@ -3423,11 +3617,17 @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
     if (!backup->has_job_id) {
         backup->job_id = NULL;
     }
     if (!backup->has_job_id) {
         backup->job_id = NULL;
     }

+    if (!backup->has_auto_finalize) {
+        backup->auto_finalize = true;
+    }
+    if (!backup->has_auto_dismiss) {
+        backup->auto_dismiss = true;
+    }

     if (!backup->has_compress) {
         backup->compress = false;
     }
 
     if (!backup->has_compress) {
         backup->compress = false;
     }
 

-    bs = qmp_get_root_bs(backup->device, errp);
+    bs = bdrv_lookup_bs(backup->device, backup->device, errp);

     if (!bs) {
         return NULL;
     }
     if (!bs) {
         return NULL;
     }


@@ -3451,10 +3651,16 @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn,
             goto out;
         }
     }
             goto out;
         }
     }

+    if (!backup->auto_finalize) {
+        job_flags |= JOB_MANUAL_FINALIZE;
+    }
+    if (!backup->auto_dismiss) {
+        job_flags |= JOB_MANUAL_DISMISS;
+    }

     job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
                             backup->sync, NULL, backup->compress,
                             backup->on_source_error, backup->on_target_error,
     job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
                             backup->sync, NULL, backup->compress,
                             backup->on_source_error, backup->on_target_error,

-                            BLOCK_JOB_DEFAULT, NULL, NULL, txn, &local_err);
+                            job_flags, NULL, NULL, txn, &local_err);

     if (local_err != NULL) {
         error_propagate(errp, local_err);
     }
     if (local_err != NULL) {
         error_propagate(errp, local_err);
     }


@@ -3468,7 +3674,7 @@ void qmp_blockdev_backup(BlockdevBackup *arg, Error **errp)
     BlockJob *job;
     job = do_blockdev_backup(arg, NULL, errp);
     if (job) {
     BlockJob *job;
     job = do_blockdev_backup(arg, NULL, errp);
     if (job) {

-        block_job_start(job);
+        job_start(&job->job);

     }
 }
 
     }
 }
 


@@ -3490,6 +3696,7 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
                                    bool has_unmap, bool unmap,
                                    bool has_filter_node_name,
                                    const char *filter_node_name,
                                    bool has_unmap, bool unmap,
                                    bool has_filter_node_name,
                                    const char *filter_node_name,

+                                   bool has_copy_mode, MirrorCopyMode copy_mode,

                                    Error **errp)
 {
 
                                    Error **errp)
 {
 


@@ -3514,6 +3721,9 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
     if (!has_filter_node_name) {
         filter_node_name = NULL;
     }
     if (!has_filter_node_name) {
         filter_node_name = NULL;
     }

+    if (!has_copy_mode) {
+        copy_mode = MIRROR_COPY_MODE_BACKGROUND;
+    }

 
     if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) {
         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
 
     if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) {
         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",


@@ -3544,7 +3754,7 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
                  has_replaces ? replaces : NULL,
                  speed, granularity, buf_size, sync, backing_mode,
                  on_source_error, on_target_error, unmap, filter_node_name,
                  has_replaces ? replaces : NULL,
                  speed, granularity, buf_size, sync, backing_mode,
                  on_source_error, on_target_error, unmap, filter_node_name,

-                 errp);
+                 copy_mode, errp);

 }
 
 void qmp_drive_mirror(DriveMirror *arg, Error **errp)
 }
 
 void qmp_drive_mirror(DriveMirror *arg, Error **errp)


@@ -3690,6 +3900,7 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
                            arg->has_on_target_error, arg->on_target_error,
                            arg->has_unmap, arg->unmap,
                            false, NULL,
                            arg->has_on_target_error, arg->on_target_error,
                            arg->has_unmap, arg->unmap,
                            false, NULL,

+                           arg->has_copy_mode, arg->copy_mode,

                            &local_err);
     bdrv_unref(target_bs);
     error_propagate(errp, local_err);
                            &local_err);
     bdrv_unref(target_bs);
     error_propagate(errp, local_err);


@@ -3710,6 +3921,7 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
                          BlockdevOnError on_target_error,
                          bool has_filter_node_name,
                          const char *filter_node_name,
                          BlockdevOnError on_target_error,
                          bool has_filter_node_name,
                          const char *filter_node_name,

+                         bool has_copy_mode, MirrorCopyMode copy_mode,

                          Error **errp)
 {
     BlockDriverState *bs;
                          Error **errp)
 {
     BlockDriverState *bs;


@@ -3742,6 +3954,7 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
                            has_on_target_error, on_target_error,
                            true, true,
                            has_filter_node_name, filter_node_name,
                            has_on_target_error, on_target_error,
                            true, true,
                            has_filter_node_name, filter_node_name,

+                           has_copy_mode, copy_mode,

                            &local_err);
     error_propagate(errp, local_err);
 
                            &local_err);
     error_propagate(errp, local_err);
 


@@ -3799,14 +4012,14 @@ void qmp_block_job_cancel(const char *device,
         force = false;
     }
 
         force = false;
     }
 

-    if (block_job_user_paused(job) && !force) {
+    if (job_user_paused(&job->job) && !force) {

         error_setg(errp, "The block job for device '%s' is currently paused",
                    device);
         goto out;
     }
 
     trace_qmp_block_job_cancel(job);
         error_setg(errp, "The block job for device '%s' is currently paused",
                    device);
         goto out;
     }
 
     trace_qmp_block_job_cancel(job);

-    block_job_cancel(job);
+    job_user_cancel(&job->job, force, errp);

 out:
     aio_context_release(aio_context);
 }
 out:
     aio_context_release(aio_context);
 }


@@ -3816,12 +4029,12 @@ void qmp_block_job_pause(const char *device, Error **errp)
     AioContext *aio_context;
     BlockJob *job = find_block_job(device, &aio_context, errp);
 
     AioContext *aio_context;
     BlockJob *job = find_block_job(device, &aio_context, errp);
 

-    if (!job || block_job_user_paused(job)) {
+    if (!job) {

         return;
     }
 
     trace_qmp_block_job_pause(job);
         return;
     }
 
     trace_qmp_block_job_pause(job);

-    block_job_user_pause(job);
+    job_user_pause(&job->job, errp);

     aio_context_release(aio_context);
 }
 
     aio_context_release(aio_context);
 }
 


@@ -3830,12 +4043,12 @@ void qmp_block_job_resume(const char *device, Error **errp)
     AioContext *aio_context;
     BlockJob *job = find_block_job(device, &aio_context, errp);
 
     AioContext *aio_context;
     BlockJob *job = find_block_job(device, &aio_context, errp);
 

-    if (!job || !block_job_user_paused(job)) {
+    if (!job) {

         return;
     }
 
     trace_qmp_block_job_resume(job);
         return;
     }
 
     trace_qmp_block_job_resume(job);

-    block_job_user_resume(job);
+    job_user_resume(&job->job, errp);

     aio_context_release(aio_context);
 }
 
     aio_context_release(aio_context);
 }
 


@@ -3849,7 +4062,37 @@ void qmp_block_job_complete(const char *device, Error **errp)
     }
 
     trace_qmp_block_job_complete(job);
     }
 
     trace_qmp_block_job_complete(job);

-    block_job_complete(job, errp);
+    job_complete(&job->job, errp);
+    aio_context_release(aio_context);
+}
+
+void qmp_block_job_finalize(const char *id, Error **errp)
+{
+    AioContext *aio_context;
+    BlockJob *job = find_block_job(id, &aio_context, errp);
+
+    if (!job) {
+        return;
+    }
+
+    trace_qmp_block_job_finalize(job);
+    job_finalize(&job->job, errp);
+    aio_context_release(aio_context);
+}
+
+void qmp_block_job_dismiss(const char *id, Error **errp)
+{
+    AioContext *aio_context;
+    BlockJob *bjob = find_block_job(id, &aio_context, errp);
+    Job *job;
+
+    if (!bjob) {
+        return;
+    }
+
+    trace_qmp_block_job_dismiss(bjob);
+    job = &bjob->job;
+    job_dismiss(&job, errp);

     aio_context_release(aio_context);
 }
 
     aio_context_release(aio_context);
 }
 


@@ -3949,7 +4192,7 @@ void hmp_drive_add_node(Monitor *mon, const char *optstr)
     qdict = qemu_opts_to_qdict(opts, NULL);
 
     if (!qdict_get_try_str(qdict, "node-name")) {
     qdict = qemu_opts_to_qdict(opts, NULL);
 
     if (!qdict_get_try_str(qdict, "node-name")) {

-        QDECREF(qdict);
+        qobject_unref(qdict);

         error_report("'node-name' needs to be specified");
         goto out;
     }
         error_report("'node-name' needs to be specified");
         goto out;
     }


@@ -3972,7 +4215,6 @@ void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
     QObject *obj;
     Visitor *v = qobject_output_visitor_new(&obj);
     QDict *qdict;
     QObject *obj;
     Visitor *v = qobject_output_visitor_new(&obj);
     QDict *qdict;

-    const QDictEntry *ent;

     Error *local_err = NULL;
 
     visit_type_BlockdevOptions(v, NULL, &options, &local_err);
     Error *local_err = NULL;
 
     visit_type_BlockdevOptions(v, NULL, &options, &local_err);


@@ -3982,23 +4224,10 @@ void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
     }
 
     visit_complete(v, &obj);
     }
 
     visit_complete(v, &obj);

-    qdict = qobject_to_qdict(obj);
+    qdict = qobject_to(QDict, obj);

 
     qdict_flatten(qdict);
 
 
     qdict_flatten(qdict);
 

-    /*
-     * Rewrite "backing": null to "backing": ""
-     * TODO Rewrite "" to null instead, and perhaps not even here
-     */
-    for (ent = qdict_first(qdict); ent; ent = qdict_next(qdict, ent)) {
-        char *dot = strrchr(ent->key, '.');
-
-        if (!strcmp(dot ? dot + 1 : ent->key, "backing")
-            && qobject_type(ent->value) == QTYPE_QNULL) {
-            qdict_put(qdict, ent->key, qstring_new());
-        }
-    }
-

     if (!qdict_get_try_str(qdict, "node-name")) {
         error_setg(errp, "'node-name' must be specified for the root node");
         goto fail;
     if (!qdict_get_try_str(qdict, "node-name")) {
         error_setg(errp, "'node-name' must be specified for the root node");
         goto fail;


@@ -4180,6 +4409,49 @@ void qmp_x_blockdev_set_iothread(const char *node_name, StrOrNull *iothread,
     aio_context_release(old_context);
 }
 
     aio_context_release(old_context);
 }
 

+void qmp_x_block_latency_histogram_set(
+    const char *device,
+    bool has_boundaries, uint64List *boundaries,
+    bool has_boundaries_read, uint64List *boundaries_read,
+    bool has_boundaries_write, uint64List *boundaries_write,
+    bool has_boundaries_flush, uint64List *boundaries_flush,
+    Error **errp)
+{
+    BlockBackend *blk = blk_by_name(device);
+    BlockAcctStats *stats;
+
+    if (!blk) {
+        error_setg(errp, "Device '%s' not found", device);
+        return;
+    }
+    stats = blk_get_stats(blk);
+
+    if (!has_boundaries && !has_boundaries_read && !has_boundaries_write &&
+        !has_boundaries_flush)
+    {
+        block_latency_histograms_clear(stats);
+        return;
+    }
+
+    if (has_boundaries || has_boundaries_read) {
+        block_latency_histogram_set(
+            stats, BLOCK_ACCT_READ,
+            has_boundaries_read ? boundaries_read : boundaries);
+    }
+
+    if (has_boundaries || has_boundaries_write) {
+        block_latency_histogram_set(
+            stats, BLOCK_ACCT_WRITE,
+            has_boundaries_write ? boundaries_write : boundaries);
+    }
+
+    if (has_boundaries || has_boundaries_flush) {
+        block_latency_histogram_set(
+            stats, BLOCK_ACCT_FLUSH,
+            has_boundaries_flush ? boundaries_flush : boundaries);
+    }
+}
+

 QemuOptsList qemu_common_drive_opts = {
     .name = "drive",
     .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),
 QemuOptsList qemu_common_drive_opts = {
     .name = "drive",
     .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),