blockdev.c 132.4 KB
Newer Older
1 2 3 4 5 6 7
/*
 * QEMU host block devices
 *
 * Copyright (c) 2003-2008 Fabrice Bellard
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or
 * later.  See the COPYING file in the top-level directory.
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 * This file incorporates work covered by the following copyright and
 * permission notice:
 *
 * Copyright (c) 2003-2008 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
31 32
 */

P
Peter Maydell 已提交
33
#include "qemu/osdep.h"
34
#include "sysemu/block-backend.h"
35
#include "sysemu/blockdev.h"
36
#include "hw/block/block.h"
37
#include "block/blockjob.h"
38
#include "block/qdict.h"
39
#include "block/throttle-groups.h"
40
#include "monitor/monitor.h"
41
#include "qemu/error-report.h"
42 43
#include "qemu/option.h"
#include "qemu/config-file.h"
44 45 46
#include "qapi/qapi-commands-block.h"
#include "qapi/qapi-commands-transaction.h"
#include "qapi/qapi-visit-block-core.h"
47
#include "qapi/qmp/qdict.h"
48
#include "qapi/qmp/qnum.h"
49
#include "qapi/qmp/qstring.h"
50
#include "qapi/error.h"
51
#include "qapi/qmp/qerror.h"
52
#include "qapi/qmp/qlist.h"
53
#include "qapi/qobject-output-visitor.h"
54
#include "sysemu/sysemu.h"
55
#include "sysemu/iothread.h"
56
#include "block/block_int.h"
57
#include "block/trace.h"
58
#include "sysemu/arch_init.h"
59
#include "sysemu/qtest.h"
60 61
#include "qemu/cutils.h"
#include "qemu/help_option.h"
62
#include "qemu/throttle-options.h"
63

64 65 66
static QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states =
    QTAILQ_HEAD_INITIALIZER(monitor_bdrv_states);

67 68
static int do_open_tray(const char *blk_name, const char *qdev_id,
                        bool force, Error **errp);
69 70 71 72 73
static void blockdev_remove_medium(bool has_device, const char *device,
                                   bool has_id, const char *id, Error **errp);
static void blockdev_insert_medium(bool has_device, const char *device,
                                   bool has_id, const char *id,
                                   const char *node_name, Error **errp);
74

75 76 77 78 79 80 81 82 83 84 85 86
static const char *const if_name[IF_COUNT] = {
    [IF_NONE] = "none",
    [IF_IDE] = "ide",
    [IF_SCSI] = "scsi",
    [IF_FLOPPY] = "floppy",
    [IF_PFLASH] = "pflash",
    [IF_MTD] = "mtd",
    [IF_SD] = "sd",
    [IF_VIRTIO] = "virtio",
    [IF_XEN] = "xen",
};

87
static int if_max_devs[IF_COUNT] = {
88 89 90 91
    /*
     * Do not change these numbers!  They govern how drive option
     * index maps to unit and bus.  That mapping is ABI.
     *
92
     * All controllers used to implement if=T drives need to support
93 94 95 96 97 98 99 100 101 102 103
     * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
     * Otherwise, some index values map to "impossible" bus, unit
     * values.
     *
     * For instance, if you change [IF_SCSI] to 255, -drive
     * if=scsi,index=12 no longer means bus=1,unit=5, but
     * bus=0,unit=12.  With an lsi53c895a controller (7 units max),
     * the drive can't be set up.  Regression.
     */
    [IF_IDE] = 2,
    [IF_SCSI] = 7,
104 105
};

106 107 108 109 110 111
/**
 * Boards may call this to offer board-by-board overrides
 * of the default, global values.
 */
void override_max_devs(BlockInterfaceType type, int max_devs)
{
112
    BlockBackend *blk;
113 114 115 116 117 118
    DriveInfo *dinfo;

    if (max_devs <= 0) {
        return;
    }

119 120
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
        dinfo = blk_legacy_dinfo(blk);
121 122 123 124 125 126 127 128 129 130 131
        if (dinfo->type == type) {
            fprintf(stderr, "Cannot override units-per-bus property of"
                    " the %s interface, because a drive of that type has"
                    " already been added.\n", if_name[type]);
            g_assert_not_reached();
        }
    }

    if_max_devs[type] = max_devs;
}

132 133 134 135 136 137 138
/*
 * We automatically delete the drive when a device using it gets
 * unplugged.  Questionable feature, but we can't just drop it.
 * Device models call blockdev_mark_auto_del() to schedule the
 * automatic deletion, and generic qdev code calls blockdev_auto_del()
 * when deletion is actually safe.
 */
139
void blockdev_mark_auto_del(BlockBackend *blk)
140
{
141
    DriveInfo *dinfo = blk_legacy_dinfo(blk);
142
    BlockDriverState *bs = blk_bs(blk);
143
    AioContext *aio_context;
144

145
    if (!dinfo) {
146 147 148
        return;
    }

M
Max Reitz 已提交
149 150 151
    if (bs) {
        aio_context = bdrv_get_aio_context(bs);
        aio_context_acquire(aio_context);
152

M
Max Reitz 已提交
153
        if (bs->job) {
154
            job_cancel(&bs->job->job, false);
M
Max Reitz 已提交
155
        }
156

M
Max Reitz 已提交
157 158
        aio_context_release(aio_context);
    }
159

160
    dinfo->auto_del = 1;
161 162
}

163
void blockdev_auto_del(BlockBackend *blk)
164
{
165
    DriveInfo *dinfo = blk_legacy_dinfo(blk);
166

167
    if (dinfo && dinfo->auto_del) {
168
        monitor_remove_blk(blk);
169
        blk_unref(blk);
170 171 172
    }
}

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
/**
 * Returns the current mapping of how many units per bus
 * a particular interface can support.
 *
 *  A positive integer indicates n units per bus.
 *  0 implies the mapping has not been established.
 * -1 indicates an invalid BlockInterfaceType was given.
 */
int drive_get_max_devs(BlockInterfaceType type)
{
    if (type >= IF_IDE && type < IF_COUNT) {
        return if_max_devs[type];
    }

    return -1;
}

190 191 192 193 194 195 196 197 198 199 200 201
static int drive_index_to_bus_id(BlockInterfaceType type, int index)
{
    int max_devs = if_max_devs[type];
    return max_devs ? index / max_devs : 0;
}

static int drive_index_to_unit_id(BlockInterfaceType type, int index)
{
    int max_devs = if_max_devs[type];
    return max_devs ? index % max_devs : index;
}

202 203
QemuOpts *drive_def(const char *optstr)
{
204
    return qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr, false);
205 206 207
}

QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
208
                    const char *optstr)
209 210 211
{
    QemuOpts *opts;

212
    opts = drive_def(optstr);
213 214 215
    if (!opts) {
        return NULL;
    }
216
    if (type != IF_DEFAULT) {
217
        qemu_opt_set(opts, "if", if_name[type], &error_abort);
218 219
    }
    if (index >= 0) {
220
        qemu_opt_set_number(opts, "index", index, &error_abort);
221
    }
222
    if (file)
223
        qemu_opt_set(opts, "file", file, &error_abort);
224 225 226 227 228
    return opts;
}

DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
{
229
    BlockBackend *blk;
230 231
    DriveInfo *dinfo;

232 233 234 235
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
        dinfo = blk_legacy_dinfo(blk);
        if (dinfo && dinfo->type == type
            && dinfo->bus == bus && dinfo->unit == unit) {
236
            return dinfo;
237
        }
238 239 240 241 242
    }

    return NULL;
}

243
void drive_check_orphaned(void)
244
{
245
    BlockBackend *blk;
246
    DriveInfo *dinfo;
247
    Location loc;
248
    bool orphans = false;
249

250 251
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
        dinfo = blk_legacy_dinfo(blk);
252
        if (!blk_get_attached_dev(blk) && !dinfo->is_default &&
253
            dinfo->type != IF_NONE) {
254 255
            loc_push_none(&loc);
            qemu_opts_loc_restore(dinfo->opts);
256
            error_report("machine type does not support"
257 258 259
                         " if=%s,bus=%d,unit=%d",
                         if_name[dinfo->type], dinfo->bus, dinfo->unit);
            loc_pop(&loc);
260
            orphans = true;
261 262 263
        }
    }

264 265 266
    if (orphans) {
        exit(1);
    }
267 268
}

269 270 271 272 273 274 275
DriveInfo *drive_get_by_index(BlockInterfaceType type, int index)
{
    return drive_get(type,
                     drive_index_to_bus_id(type, index),
                     drive_index_to_unit_id(type, index));
}

276 277 278
int drive_get_max_bus(BlockInterfaceType type)
{
    int max_bus;
279
    BlockBackend *blk;
280 281 282
    DriveInfo *dinfo;

    max_bus = -1;
283 284 285
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
        dinfo = blk_legacy_dinfo(blk);
        if (dinfo && dinfo->type == type && dinfo->bus > max_bus) {
286
            max_bus = dinfo->bus;
287
        }
288 289 290 291
    }
    return max_bus;
}

292 293 294 295 296 297 298 299 300 301
/* Get a block device.  This should only be used for single-drive devices
   (e.g. SD/Floppy/MTD).  Multi-disk devices (scsi/ide) should use the
   appropriate bus.  */
DriveInfo *drive_get_next(BlockInterfaceType type)
{
    static int next_block_unit[IF_COUNT];

    return drive_get(type, 0, next_block_unit[type]++);
}

302 303
static void bdrv_format_print(void *opaque, const char *name)
{
304
    error_printf(" %s", name);
305 306
}

307 308
typedef struct {
    QEMUBH *bh;
309 310
    BlockDriverState *bs;
} BDRVPutRefBH;
311

312
static int parse_block_error_action(const char *buf, bool is_read, Error **errp)
313 314
{
    if (!strcmp(buf, "ignore")) {
315
        return BLOCKDEV_ON_ERROR_IGNORE;
316
    } else if (!is_read && !strcmp(buf, "enospc")) {
317
        return BLOCKDEV_ON_ERROR_ENOSPC;
318
    } else if (!strcmp(buf, "stop")) {
319
        return BLOCKDEV_ON_ERROR_STOP;
320
    } else if (!strcmp(buf, "report")) {
321
        return BLOCKDEV_ON_ERROR_REPORT;
322
    } else {
323 324
        error_setg(errp, "'%s' invalid %s error action",
                   buf, is_read ? "read" : "write");
325 326 327 328
        return -1;
    }
}

329 330 331 332 333 334 335 336 337
static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals,
                                  Error **errp)
{
    const QListEntry *entry;
    for (entry = qlist_first(intervals); entry; entry = qlist_next(entry)) {
        switch (qobject_type(entry->value)) {

        case QTYPE_QSTRING: {
            unsigned long long length;
338 339
            const char *str = qstring_get_str(qobject_to(QString,
                                                         entry->value));
340 341 342 343 344 345 346 347 348 349
            if (parse_uint_full(str, &length, 10) == 0 &&
                length > 0 && length <= UINT_MAX) {
                block_acct_add_interval(stats, (unsigned) length);
            } else {
                error_setg(errp, "Invalid interval length: %s", str);
                return false;
            }
            break;
        }

350
        case QTYPE_QNUM: {
351
            int64_t length = qnum_get_int(qobject_to(QNum, entry->value));
352

353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
            if (length > 0 && length <= UINT_MAX) {
                block_acct_add_interval(stats, (unsigned) length);
            } else {
                error_setg(errp, "Invalid interval length: %" PRId64, length);
                return false;
            }
            break;
        }

        default:
            error_setg(errp, "The specification of stats-intervals is invalid");
            return false;
        }
    }
    return true;
}

370 371
typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType;

372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
/* All parameters but @opts are optional and may be set to NULL. */
static void extract_common_blockdev_options(QemuOpts *opts, int *bdrv_flags,
    const char **throttling_group, ThrottleConfig *throttle_cfg,
    BlockdevDetectZeroesOptions *detect_zeroes, Error **errp)
{
    Error *local_error = NULL;
    const char *aio;

    if (bdrv_flags) {
        if (qemu_opt_get_bool(opts, "copy-on-read", false)) {
            *bdrv_flags |= BDRV_O_COPY_ON_READ;
        }

        if ((aio = qemu_opt_get(opts, "aio")) != NULL) {
            if (!strcmp(aio, "native")) {
                *bdrv_flags |= BDRV_O_NATIVE_AIO;
            } else if (!strcmp(aio, "threads")) {
                /* this is the default */
            } else {
               error_setg(errp, "invalid aio option");
               return;
            }
        }
    }

    /* disk I/O throttling */
    if (throttling_group) {
        *throttling_group = qemu_opt_get(opts, "throttling.group");
    }

    if (throttle_cfg) {
403
        throttle_config_init(throttle_cfg);
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
        throttle_cfg->buckets[THROTTLE_BPS_TOTAL].avg =
            qemu_opt_get_number(opts, "throttling.bps-total", 0);
        throttle_cfg->buckets[THROTTLE_BPS_READ].avg  =
            qemu_opt_get_number(opts, "throttling.bps-read", 0);
        throttle_cfg->buckets[THROTTLE_BPS_WRITE].avg =
            qemu_opt_get_number(opts, "throttling.bps-write", 0);
        throttle_cfg->buckets[THROTTLE_OPS_TOTAL].avg =
            qemu_opt_get_number(opts, "throttling.iops-total", 0);
        throttle_cfg->buckets[THROTTLE_OPS_READ].avg =
            qemu_opt_get_number(opts, "throttling.iops-read", 0);
        throttle_cfg->buckets[THROTTLE_OPS_WRITE].avg =
            qemu_opt_get_number(opts, "throttling.iops-write", 0);

        throttle_cfg->buckets[THROTTLE_BPS_TOTAL].max =
            qemu_opt_get_number(opts, "throttling.bps-total-max", 0);
        throttle_cfg->buckets[THROTTLE_BPS_READ].max  =
            qemu_opt_get_number(opts, "throttling.bps-read-max", 0);
        throttle_cfg->buckets[THROTTLE_BPS_WRITE].max =
            qemu_opt_get_number(opts, "throttling.bps-write-max", 0);
        throttle_cfg->buckets[THROTTLE_OPS_TOTAL].max =
            qemu_opt_get_number(opts, "throttling.iops-total-max", 0);
        throttle_cfg->buckets[THROTTLE_OPS_READ].max =
            qemu_opt_get_number(opts, "throttling.iops-read-max", 0);
        throttle_cfg->buckets[THROTTLE_OPS_WRITE].max =
            qemu_opt_get_number(opts, "throttling.iops-write-max", 0);

430 431 432 433 434 435 436 437 438 439 440 441 442
        throttle_cfg->buckets[THROTTLE_BPS_TOTAL].burst_length =
            qemu_opt_get_number(opts, "throttling.bps-total-max-length", 1);
        throttle_cfg->buckets[THROTTLE_BPS_READ].burst_length  =
            qemu_opt_get_number(opts, "throttling.bps-read-max-length", 1);
        throttle_cfg->buckets[THROTTLE_BPS_WRITE].burst_length =
            qemu_opt_get_number(opts, "throttling.bps-write-max-length", 1);
        throttle_cfg->buckets[THROTTLE_OPS_TOTAL].burst_length =
            qemu_opt_get_number(opts, "throttling.iops-total-max-length", 1);
        throttle_cfg->buckets[THROTTLE_OPS_READ].burst_length =
            qemu_opt_get_number(opts, "throttling.iops-read-max-length", 1);
        throttle_cfg->buckets[THROTTLE_OPS_WRITE].burst_length =
            qemu_opt_get_number(opts, "throttling.iops-write-max-length", 1);

443 444 445
        throttle_cfg->op_size =
            qemu_opt_get_number(opts, "throttling.iops-size", 0);

446
        if (!throttle_is_valid(throttle_cfg, errp)) {
447 448 449 450 451 452
            return;
        }
    }

    if (detect_zeroes) {
        *detect_zeroes =
453
            qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup,
454 455 456 457 458 459 460 461 462 463
                            qemu_opt_get(opts, "detect-zeroes"),
                            BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
                            &local_error);
        if (local_error) {
            error_propagate(errp, local_error);
            return;
        }
    }
}

464
/* Takes the ownership of bs_opts */
465 466
static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
                                   Error **errp)
467 468 469 470
{
    const char *buf;
    int bdrv_flags = 0;
    int on_read_error, on_write_error;
471
    bool account_invalid, account_failed;
472
    bool writethrough, read_only;
473
    BlockBackend *blk;
474
    BlockDriverState *bs;
475
    ThrottleConfig cfg;
476
    int snapshot = 0;
477
    Error *error = NULL;
478
    QemuOpts *opts;
479 480
    QDict *interval_dict = NULL;
    QList *interval_list = NULL;
481
    const char *id;
482 483 484
    BlockdevDetectZeroesOptions detect_zeroes =
        BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
    const char *throttling_group = NULL;
485

486 487 488
    /* Check common options by copying from bs_opts to opts, all other options
     * stay in bs_opts for processing by bdrv_open(). */
    id = qdict_get_try_str(bs_opts, "id");
489
    opts = qemu_opts_create(&qemu_common_drive_opts, id, 1, &error);
490
    if (error) {
491
        error_propagate(errp, error);
492
        goto err_no_opts;
493 494 495
    }

    qemu_opts_absorb_qdict(opts, bs_opts, &error);
496
    if (error) {
497
        error_propagate(errp, error);
498
        goto early_err;
499 500 501 502 503 504
    }

    if (id) {
        qdict_del(bs_opts, "id");
    }

505 506 507
    /* extract parameters */
    snapshot = qemu_opt_get_bool(opts, "snapshot", 0);

508 509 510
    account_invalid = qemu_opt_get_bool(opts, "stats-account-invalid", true);
    account_failed = qemu_opt_get_bool(opts, "stats-account-failed", true);

511 512
    writethrough = !qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, true);

513 514
    id = qemu_opts_id(opts);

515 516 517 518 519 520 521 522
    qdict_extract_subqdict(bs_opts, &interval_dict, "stats-intervals.");
    qdict_array_split(interval_dict, &interval_list);

    if (qdict_size(interval_dict) != 0) {
        error_setg(errp, "Invalid option stats-intervals.%s",
                   qdict_first(interval_dict)->key);
        goto early_err;
    }
523

524 525 526 527 528
    extract_common_blockdev_options(opts, &bdrv_flags, &throttling_group, &cfg,
                                    &detect_zeroes, &error);
    if (error) {
        error_propagate(errp, error);
        goto early_err;
529 530 531
    }

    if ((buf = qemu_opt_get(opts, "format")) != NULL) {
532 533 534 535
        if (is_help_option(buf)) {
            error_printf("Supported formats:");
            bdrv_iterate_format(bdrv_format_print, NULL);
            error_printf("\n");
536
            goto early_err;
537
        }
538

539 540
        if (qdict_haskey(bs_opts, "driver")) {
            error_setg(errp, "Cannot specify both 'driver' and 'format'");
541
            goto early_err;
542
        }
543
        qdict_put_str(bs_opts, "driver", buf);
544 545
    }

546
    on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
547
    if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
548
        on_write_error = parse_block_error_action(buf, 0, &error);
549
        if (error) {
550
            error_propagate(errp, error);
551
            goto early_err;
552 553 554
        }
    }

555
    on_read_error = BLOCKDEV_ON_ERROR_REPORT;
556
    if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
557
        on_read_error = parse_block_error_action(buf, 1, &error);
558
        if (error) {
559
            error_propagate(errp, error);
560
            goto early_err;
561 562 563
        }
    }

564
    if (snapshot) {
565
        bdrv_flags |= BDRV_O_SNAPSHOT;
566 567
    }

568 569
    read_only = qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false);

570
    /* init */
571
    if ((!file || !*file) && !qdict_size(bs_opts)) {
572 573
        BlockBackendRootState *blk_rs;

574
        blk = blk_new(0, BLK_PERM_ALL);
575 576
        blk_rs = blk_get_root_state(blk);
        blk_rs->open_flags    = bdrv_flags;
577
        blk_rs->read_only     = read_only;
578 579
        blk_rs->detect_zeroes = detect_zeroes;

580
        qobject_unref(bs_opts);
581 582
    } else {
        if (file && !*file) {
583 584
            file = NULL;
        }
585

586 587 588 589 590
        /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
         * with other callers) rather than what we want as the real defaults.
         * Apply the defaults here instead. */
        qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off");
        qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
591 592
        qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY,
                              read_only ? "on" : "off");
593
        assert((bdrv_flags & BDRV_O_CACHE_MASK) == 0);
594

595 596 597 598
        if (runstate_check(RUN_STATE_INMIGRATE)) {
            bdrv_flags |= BDRV_O_INACTIVE;
        }

599
        blk = blk_new_open(file, NULL, bs_opts, bdrv_flags, errp);
600 601 602 603
        if (!blk) {
            goto err_no_bs_opts;
        }
        bs = blk_bs(blk);
604

605
        bs->detect_zeroes = detect_zeroes;
606

607
        block_acct_setup(blk_get_stats(blk), account_invalid, account_failed);
608

609 610 611 612
        if (!parse_stats_intervals(blk_get_stats(blk), interval_list, errp)) {
            blk_unref(blk);
            blk = NULL;
            goto err_no_bs_opts;
613
        }
614 615
    }

616 617 618
    /* disk I/O throttling */
    if (throttle_enabled(&cfg)) {
        if (!throttling_group) {
619
            throttling_group = id;
620 621 622 623 624
        }
        blk_io_limits_enable(blk, throttling_group);
        blk_set_io_limits(blk, &cfg);
    }

625
    blk_set_enable_write_cache(blk, !writethrough);
626
    blk_set_on_error(blk, on_read_error, on_write_error);
627

628
    if (!monitor_add_blk(blk, id, errp)) {
629 630 631 632 633
        blk_unref(blk);
        blk = NULL;
        goto err_no_bs_opts;
    }

634
err_no_bs_opts:
635
    qemu_opts_del(opts);
636 637
    qobject_unref(interval_dict);
    qobject_unref(interval_list);
638
    return blk;
639

640 641
early_err:
    qemu_opts_del(opts);
642 643
    qobject_unref(interval_dict);
    qobject_unref(interval_list);
644
err_no_opts:
645
    qobject_unref(bs_opts);
646
    return NULL;
647 648
}

649 650 651 652 653
/* Takes the ownership of bs_opts */
static BlockDriverState *bds_tree_init(QDict *bs_opts, Error **errp)
{
    int bdrv_flags = 0;

654 655 656 657 658
    /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
     * with other callers) rather than what we want as the real defaults.
     * Apply the defaults here instead. */
    qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off");
    qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
659
    qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY, "off");
660

661 662 663 664
    if (runstate_check(RUN_STATE_INMIGRATE)) {
        bdrv_flags |= BDRV_O_INACTIVE;
    }

665
    return bdrv_open(NULL, NULL, bs_opts, bdrv_flags, errp);
666 667
}

668 669 670 671 672 673 674 675 676 677 678 679 680
void blockdev_close_all_bdrv_states(void)
{
    BlockDriverState *bs, *next_bs;

    QTAILQ_FOREACH_SAFE(bs, &monitor_bdrv_states, monitor_list, next_bs) {
        AioContext *ctx = bdrv_get_aio_context(bs);

        aio_context_acquire(ctx);
        bdrv_unref(bs);
        aio_context_release(ctx);
    }
}

681 682 683 684 685 686 687
/* Iterates over the list of monitor-owned BlockDriverStates */
BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs)
{
    return bs ? QTAILQ_NEXT(bs, monitor_list)
              : QTAILQ_FIRST(&monitor_bdrv_states);
}

688 689
static void qemu_opt_rename(QemuOpts *opts, const char *from, const char *to,
                            Error **errp)
690 691 692 693 694
{
    const char *value;

    value = qemu_opt_get(opts, from);
    if (value) {
695 696 697 698 699
        if (qemu_opt_find(opts, to)) {
            error_setg(errp, "'%s' and its alias '%s' can't be used at the "
                       "same time", to, from);
            return;
        }
700 701 702 703
    }

    /* rename all items in opts */
    while ((value = qemu_opt_get(opts, from))) {
704
        qemu_opt_set(opts, to, value, &error_abort);
705 706 707 708
        qemu_opt_unset(opts, from);
    }
}

709 710 711 712 713
QemuOptsList qemu_legacy_drive_opts = {
    .name = "drive",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts.head),
    .desc = {
        {
714 715 716 717 718 719 720 721 722 723 724 725
            .name = "bus",
            .type = QEMU_OPT_NUMBER,
            .help = "bus number",
        },{
            .name = "unit",
            .type = QEMU_OPT_NUMBER,
            .help = "unit number (i.e. lun for scsi)",
        },{
            .name = "index",
            .type = QEMU_OPT_NUMBER,
            .help = "index number",
        },{
726 727 728
            .name = "media",
            .type = QEMU_OPT_STRING,
            .help = "media type (disk, cdrom)",
729 730 731 732
        },{
            .name = "if",
            .type = QEMU_OPT_STRING,
            .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
733 734 735 736
        },{
            .name = "file",
            .type = QEMU_OPT_STRING,
            .help = "file name",
737
        },
738 739 740

        /* Options that are passed on, but have special semantics with -drive */
        {
741
            .name = BDRV_OPT_READ_ONLY,
742 743
            .type = QEMU_OPT_BOOL,
            .help = "open drive file as read-only",
744 745 746 747 748 749 750 751
        },{
            .name = "rerror",
            .type = QEMU_OPT_STRING,
            .help = "read error action",
        },{
            .name = "werror",
            .type = QEMU_OPT_STRING,
            .help = "write error action",
752 753 754 755 756 757
        },{
            .name = "copy-on-read",
            .type = QEMU_OPT_BOOL,
            .help = "copy read data from backing file into image file",
        },

758 759 760 761
        { /* end of list */ }
    },
};

762 763
DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type,
                     Error **errp)
764
{
765
    const char *value;
766
    BlockBackend *blk;
767
    DriveInfo *dinfo = NULL;
768
    QDict *bs_opts;
769 770
    QemuOpts *legacy_opts;
    DriveMediaType media = MEDIA_DISK;
771
    BlockInterfaceType type;
772
    int max_devs, bus_id, unit_id, index;
773
    const char *werror, *rerror;
774 775
    bool read_only = false;
    bool copy_on_read;
776
    const char *filename;
777
    Error *local_err = NULL;
778
    int i;
779

780
    /* Change legacy command line options into QMP ones */
781 782 783 784 785 786 787
    static const struct {
        const char *from;
        const char *to;
    } opt_renames[] = {
        { "iops",           "throttling.iops-total" },
        { "iops_rd",        "throttling.iops-read" },
        { "iops_wr",        "throttling.iops-write" },
788

789 790 791
        { "bps",            "throttling.bps-total" },
        { "bps_rd",         "throttling.bps-read" },
        { "bps_wr",         "throttling.bps-write" },
792

793 794 795
        { "iops_max",       "throttling.iops-total-max" },
        { "iops_rd_max",    "throttling.iops-read-max" },
        { "iops_wr_max",    "throttling.iops-write-max" },
796

797 798 799
        { "bps_max",        "throttling.bps-total-max" },
        { "bps_rd_max",     "throttling.bps-read-max" },
        { "bps_wr_max",     "throttling.bps-write-max" },
800

801
        { "iops_size",      "throttling.iops-size" },
802

803 804
        { "group",          "throttling.group" },

805
        { "readonly",       BDRV_OPT_READ_ONLY },
806 807 808
    };

    for (i = 0; i < ARRAY_SIZE(opt_renames); i++) {
809 810 811
        qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to,
                        &local_err);
        if (local_err) {
812
            error_propagate(errp, local_err);
813 814
            return NULL;
        }
815
    }
816

817 818 819
    value = qemu_opt_get(all_opts, "cache");
    if (value) {
        int flags = 0;
820
        bool writethrough;
821

822
        if (bdrv_parse_cache_mode(value, &flags, &writethrough) != 0) {
823
            error_setg(errp, "invalid cache option");
824 825 826 827
            return NULL;
        }

        /* Specific options take precedence */
828 829
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_WB)) {
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_WB,
830
                              !writethrough, &error_abort);
831
        }
832 833
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_DIRECT)) {
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_DIRECT,
834
                              !!(flags & BDRV_O_NOCACHE), &error_abort);
835
        }
836 837
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_NO_FLUSH)) {
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_NO_FLUSH,
838
                              !!(flags & BDRV_O_NO_FLUSH), &error_abort);
839 840 841 842
        }
        qemu_opt_unset(all_opts, "cache");
    }

843 844 845 846
    /* Get a QDict for processing the options */
    bs_opts = qdict_new();
    qemu_opts_to_qdict(all_opts, bs_opts);

847 848
    legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0,
                                   &error_abort);
849
    qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err);
850
    if (local_err) {
851
        error_propagate(errp, local_err);
852 853 854 855 856 857 858 859 860 861
        goto fail;
    }

    /* Media type */
    value = qemu_opt_get(legacy_opts, "media");
    if (value) {
        if (!strcmp(value, "disk")) {
            media = MEDIA_DISK;
        } else if (!strcmp(value, "cdrom")) {
            media = MEDIA_CDROM;
862
            read_only = true;
863
        } else {
864
            error_setg(errp, "'%s' invalid media", value);
865 866 867 868
            goto fail;
        }
    }

869
    /* copy-on-read is disabled with a warning for read-only devices */
870
    read_only |= qemu_opt_get_bool(legacy_opts, BDRV_OPT_READ_ONLY, false);
871 872 873
    copy_on_read = qemu_opt_get_bool(legacy_opts, "copy-on-read", false);

    if (read_only && copy_on_read) {
874
        warn_report("disabling copy-on-read on read-only drive");
875 876 877
        copy_on_read = false;
    }

878 879
    qdict_put_str(bs_opts, BDRV_OPT_READ_ONLY, read_only ? "on" : "off");
    qdict_put_str(bs_opts, "copy-on-read", copy_on_read ? "on" : "off");
880

881 882 883 884 885 886 887 888
    /* Controller type */
    value = qemu_opt_get(legacy_opts, "if");
    if (value) {
        for (type = 0;
             type < IF_COUNT && strcmp(value, if_name[type]);
             type++) {
        }
        if (type == IF_COUNT) {
889
            error_setg(errp, "unsupported bus type '%s'", value);
890 891 892 893 894 895
            goto fail;
        }
    } else {
        type = block_default_type;
    }

896 897 898 899 900 901 902 903 904 905
    /* Device address specified by bus/unit or index.
     * If none was specified, try to find the first free one. */
    bus_id  = qemu_opt_get_number(legacy_opts, "bus", 0);
    unit_id = qemu_opt_get_number(legacy_opts, "unit", -1);
    index   = qemu_opt_get_number(legacy_opts, "index", -1);

    max_devs = if_max_devs[type];

    if (index != -1) {
        if (bus_id != 0 || unit_id != -1) {
906
            error_setg(errp, "index cannot be used with bus and unit");
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
            goto fail;
        }
        bus_id = drive_index_to_bus_id(type, index);
        unit_id = drive_index_to_unit_id(type, index);
    }

    if (unit_id == -1) {
       unit_id = 0;
       while (drive_get(type, bus_id, unit_id) != NULL) {
           unit_id++;
           if (max_devs && unit_id >= max_devs) {
               unit_id -= max_devs;
               bus_id++;
           }
       }
    }

    if (max_devs && unit_id >= max_devs) {
925
        error_setg(errp, "unit %d too big (max is %d)", unit_id, max_devs - 1);
926 927 928 929
        goto fail;
    }

    if (drive_get(type, bus_id, unit_id) != NULL) {
930 931
        error_setg(errp, "drive with bus=%d, unit=%d (index=%d) exists",
                   bus_id, unit_id, index);
932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948
        goto fail;
    }

    /* no id supplied -> create one */
    if (qemu_opts_id(all_opts) == NULL) {
        char *new_id;
        const char *mediastr = "";
        if (type == IF_IDE || type == IF_SCSI) {
            mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
        }
        if (max_devs) {
            new_id = g_strdup_printf("%s%i%s%i", if_name[type], bus_id,
                                     mediastr, unit_id);
        } else {
            new_id = g_strdup_printf("%s%s%i", if_name[type],
                                     mediastr, unit_id);
        }
949
        qdict_put_str(bs_opts, "id", new_id);
950 951 952
        g_free(new_id);
    }

953 954 955
    /* Add virtio block device */
    if (type == IF_VIRTIO) {
        QemuOpts *devopts;
956 957
        devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                   &error_abort);
958
        if (arch_type == QEMU_ARCH_S390X) {
959
            qemu_opt_set(devopts, "driver", "virtio-blk-ccw", &error_abort);
960
        } else {
961
            qemu_opt_set(devopts, "driver", "virtio-blk-pci", &error_abort);
962
        }
963 964
        qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
                     &error_abort);
965 966
    }

967 968
    filename = qemu_opt_get(legacy_opts, "file");

969 970 971 972 973
    /* Check werror/rerror compatibility with if=... */
    werror = qemu_opt_get(legacy_opts, "werror");
    if (werror != NULL) {
        if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO &&
            type != IF_NONE) {
974
            error_setg(errp, "werror is not supported by this bus type");
975 976
            goto fail;
        }
977
        qdict_put_str(bs_opts, "werror", werror);
978 979 980 981 982 983
    }

    rerror = qemu_opt_get(legacy_opts, "rerror");
    if (rerror != NULL) {
        if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI &&
            type != IF_NONE) {
984
            error_setg(errp, "rerror is not supported by this bus type");
985 986
            goto fail;
        }
987
        qdict_put_str(bs_opts, "rerror", rerror);
988 989
    }

990
    /* Actual block device init: Functionality shared with blockdev-add */
991
    blk = blockdev_init(filename, bs_opts, &local_err);
992
    bs_opts = NULL;
993
    if (!blk) {
994
        if (local_err) {
995
            error_propagate(errp, local_err);
996
        }
997
        goto fail;
998
    } else {
999
        assert(!local_err);
1000 1001
    }

1002 1003
    /* Create legacy DriveInfo */
    dinfo = g_malloc0(sizeof(*dinfo));
1004
    dinfo->opts = all_opts;
1005

1006
    dinfo->type = type;
1007 1008
    dinfo->bus = bus_id;
    dinfo->unit = unit_id;
1009

1010 1011
    blk_set_legacy_dinfo(blk, dinfo);

1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
    switch(type) {
    case IF_IDE:
    case IF_SCSI:
    case IF_XEN:
    case IF_NONE:
        dinfo->media_cd = media == MEDIA_CDROM;
        break;
    default:
        break;
    }

1023
fail:
1024
    qemu_opts_del(legacy_opts);
1025
    qobject_unref(bs_opts);
1026
    return dinfo;
1027 1028
}

1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
static BlockDriverState *qmp_get_root_bs(const char *name, Error **errp)
{
    BlockDriverState *bs;

    bs = bdrv_lookup_bs(name, name, errp);
    if (bs == NULL) {
        return NULL;
    }

    if (!bdrv_is_root_node(bs)) {
        error_setg(errp, "Need a root block node");
        return NULL;
    }

    if (!bdrv_is_inserted(bs)) {
        error_setg(errp, "Device has no medium");
        return NULL;
    }

    return bs;
}

1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
static BlockBackend *qmp_get_blk(const char *blk_name, const char *qdev_id,
                                 Error **errp)
{
    BlockBackend *blk;

    if (!blk_name == !qdev_id) {
        error_setg(errp, "Need exactly one of 'device' and 'id'");
        return NULL;
    }

    if (qdev_id) {
        blk = blk_by_qdev_id(qdev_id, errp);
    } else {
        blk = blk_by_name(blk_name);
        if (blk == NULL) {
            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                      "Device '%s' not found", blk_name);
        }
    }

    return blk;
}

1074
void hmp_commit(Monitor *mon, const QDict *qdict)
1075 1076
{
    const char *device = qdict_get_str(qdict, "device");
1077
    BlockBackend *blk;
1078
    int ret;
1079

1080
    if (!strcmp(device, "all")) {
1081
        ret = blk_commit_all();
1082
    } else {
1083 1084 1085
        BlockDriverState *bs;
        AioContext *aio_context;

1086 1087
        blk = blk_by_name(device);
        if (!blk) {
1088
            monitor_printf(mon, "Device '%s' not found\n", device);
1089
            return;
1090
        }
M
Max Reitz 已提交
1091 1092 1093 1094
        if (!blk_is_available(blk)) {
            monitor_printf(mon, "Device '%s' has no medium\n", device);
            return;
        }
1095 1096 1097 1098 1099 1100 1101 1102

        bs = blk_bs(blk);
        aio_context = bdrv_get_aio_context(bs);
        aio_context_acquire(aio_context);

        ret = bdrv_commit(bs);

        aio_context_release(aio_context);
1103 1104 1105 1106
    }
    if (ret < 0) {
        monitor_printf(mon, "'commit' error for '%s': %s\n", device,
                       strerror(-ret));
1107 1108 1109
    }
}

1110
static void blockdev_do_action(TransactionAction *action, Error **errp)
1111
{
1112
    TransactionActionList list;
1113

1114
    list.value = action;
1115
    list.next = NULL;
1116
    qmp_transaction(&list, false, NULL, errp);
1117 1118
}

1119 1120 1121 1122 1123
void qmp_blockdev_snapshot_sync(bool has_device, const char *device,
                                bool has_node_name, const char *node_name,
                                const char *snapshot_file,
                                bool has_snapshot_node_name,
                                const char *snapshot_node_name,
1124
                                bool has_format, const char *format,
1125
                                bool has_mode, NewImageMode mode, Error **errp)
1126
{
1127
    BlockdevSnapshotSync snapshot = {
1128
        .has_device = has_device,
1129
        .device = (char *) device,
1130 1131
        .has_node_name = has_node_name,
        .node_name = (char *) node_name,
1132
        .snapshot_file = (char *) snapshot_file,
1133 1134
        .has_snapshot_node_name = has_snapshot_node_name,
        .snapshot_node_name = (char *) snapshot_node_name,
1135 1136 1137 1138 1139
        .has_format = has_format,
        .format = (char *) format,
        .has_mode = has_mode,
        .mode = mode,
    };
1140 1141
    TransactionAction action = {
        .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC,
1142
        .u.blockdev_snapshot_sync.data = &snapshot,
1143 1144
    };
    blockdev_do_action(&action, errp);
1145 1146
}

1147 1148 1149 1150 1151 1152 1153
void qmp_blockdev_snapshot(const char *node, const char *overlay,
                           Error **errp)
{
    BlockdevSnapshot snapshot_data = {
        .node = (char *) node,
        .overlay = (char *) overlay
    };
1154 1155
    TransactionAction action = {
        .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT,
1156
        .u.blockdev_snapshot.data = &snapshot_data,
1157 1158
    };
    blockdev_do_action(&action, errp);
1159 1160
}

1161 1162 1163 1164 1165 1166 1167 1168
void qmp_blockdev_snapshot_internal_sync(const char *device,
                                         const char *name,
                                         Error **errp)
{
    BlockdevSnapshotInternal snapshot = {
        .device = (char *) device,
        .name = (char *) name
    };
1169 1170
    TransactionAction action = {
        .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
1171
        .u.blockdev_snapshot_internal_sync.data = &snapshot,
1172 1173
    };
    blockdev_do_action(&action, errp);
1174 1175
}

1176 1177 1178 1179 1180 1181 1182
SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
                                                         bool has_id,
                                                         const char *id,
                                                         bool has_name,
                                                         const char *name,
                                                         Error **errp)
{
1183
    BlockDriverState *bs;
1184
    AioContext *aio_context;
1185 1186 1187 1188 1189
    QEMUSnapshotInfo sn;
    Error *local_err = NULL;
    SnapshotInfo *info = NULL;
    int ret;

1190 1191
    bs = qmp_get_root_bs(device, errp);
    if (!bs) {
1192 1193
        return NULL;
    }
1194
    aio_context = bdrv_get_aio_context(bs);
M
Max Reitz 已提交
1195
    aio_context_acquire(aio_context);
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206

    if (!has_id) {
        id = NULL;
    }

    if (!has_name) {
        name = NULL;
    }

    if (!id && !name) {
        error_setg(errp, "Name or id must be provided");
M
Max Reitz 已提交
1207
        goto out_aio_context;
1208 1209
    }

1210 1211 1212 1213
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, errp)) {
        goto out_aio_context;
    }

1214
    ret = bdrv_snapshot_find_by_id_and_name(bs, id, name, &sn, &local_err);
1215
    if (local_err) {
1216
        error_propagate(errp, local_err);
1217
        goto out_aio_context;
1218 1219 1220 1221 1222 1223
    }
    if (!ret) {
        error_setg(errp,
                   "Snapshot with id '%s' and name '%s' does not exist on "
                   "device '%s'",
                   STR_OR_NULL(id), STR_OR_NULL(name), device);
1224
        goto out_aio_context;
1225 1226 1227
    }

    bdrv_snapshot_delete(bs, id, name, &local_err);
1228
    if (local_err) {
1229
        error_propagate(errp, local_err);
1230
        goto out_aio_context;
1231 1232
    }

1233 1234
    aio_context_release(aio_context);

1235
    info = g_new0(SnapshotInfo, 1);
1236 1237 1238 1239 1240 1241 1242 1243 1244
    info->id = g_strdup(sn.id_str);
    info->name = g_strdup(sn.name);
    info->date_nsec = sn.date_nsec;
    info->date_sec = sn.date_sec;
    info->vm_state_size = sn.vm_state_size;
    info->vm_clock_nsec = sn.vm_clock_nsec % 1000000000;
    info->vm_clock_sec = sn.vm_clock_nsec / 1000000000;

    return info;
1245 1246 1247 1248

out_aio_context:
    aio_context_release(aio_context);
    return NULL;
1249
}
1250

1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
/**
 * block_dirty_bitmap_lookup:
 * Return a dirty bitmap (if present), after validating
 * the node reference and bitmap names.
 *
 * @node: The name of the BDS node to search for bitmaps
 * @name: The name of the bitmap to search for
 * @pbs: Output pointer for BDS lookup, if desired. Can be NULL.
 * @paio: Output pointer for aio_context acquisition, if desired. Can be NULL.
 * @errp: Output pointer for error information. Can be NULL.
 *
 * @return: A bitmap object on success, or NULL on failure.
 */
static BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node,
                                                  const char *name,
                                                  BlockDriverState **pbs,
                                                  Error **errp)
{
    BlockDriverState *bs;
    BdrvDirtyBitmap *bitmap;

    if (!node) {
        error_setg(errp, "Node cannot be NULL");
        return NULL;
    }
    if (!name) {
        error_setg(errp, "Bitmap name cannot be NULL");
        return NULL;
    }
    bs = bdrv_lookup_bs(node, node, NULL);
    if (!bs) {
        error_setg(errp, "Node '%s' not found", node);
        return NULL;
    }

    bitmap = bdrv_find_dirty_bitmap(bs, name);
    if (!bitmap) {
        error_setg(errp, "Dirty bitmap '%s' not found", name);
1289
        return NULL;
1290 1291 1292 1293 1294 1295 1296 1297 1298
    }

    if (pbs) {
        *pbs = bs;
    }

    return bitmap;
}

1299
/* New and old BlockDriverState structs for atomic group operations */
1300

1301
typedef struct BlkActionState BlkActionState;
1302

1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
/**
 * BlkActionOps:
 * Table of operations that define an Action.
 *
 * @instance_size: Size of state struct, in bytes.
 * @prepare: Prepare the work, must NOT be NULL.
 * @commit: Commit the changes, can be NULL.
 * @abort: Abort the changes on fail, can be NULL.
 * @clean: Clean up resources after all transaction actions have called
 *         commit() or abort(). Can be NULL.
 *
 * Only prepare() may fail. In a single transaction, only one of commit() or
 * abort() will be called. clean() will always be called if it is present.
 */
typedef struct BlkActionOps {
1318
    size_t instance_size;
1319 1320 1321 1322 1323
    void (*prepare)(BlkActionState *common, Error **errp);
    void (*commit)(BlkActionState *common);
    void (*abort)(BlkActionState *common);
    void (*clean)(BlkActionState *common);
} BlkActionOps;
1324

1325 1326 1327 1328 1329 1330
/**
 * BlkActionState:
 * Describes one Action's state within a Transaction.
 *
 * @action: QAPI-defined enum identifying which Action to perform.
 * @ops: Table of ActionOps this Action can perform.
1331
 * @block_job_txn: Transaction which this action belongs to.
1332 1333 1334 1335 1336
 * @entry: List membership for all Actions in this Transaction.
 *
 * This structure must be arranged as first member in a subclassed type,
 * assuming that the compiler will also arrange it to the same offsets as the
 * base class.
1337
 */
1338
struct BlkActionState {
1339
    TransactionAction *action;
1340
    const BlkActionOps *ops;
1341
    JobTxn *block_job_txn;
1342
    TransactionProperties *txn_props;
1343
    QSIMPLEQ_ENTRY(BlkActionState) entry;
1344 1345
};

1346 1347
/* internal snapshot private data */
typedef struct InternalSnapshotState {
1348
    BlkActionState common;
1349 1350
    BlockDriverState *bs;
    QEMUSnapshotInfo sn;
1351
    bool created;
1352 1353
} InternalSnapshotState;

1354 1355 1356 1357 1358 1359 1360

static int action_check_completion_mode(BlkActionState *s, Error **errp)
{
    if (s->txn_props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
        error_setg(errp,
                   "Action '%s' does not support Transaction property "
                   "completion-mode = %s",
1361 1362
                   TransactionActionKind_str(s->action->type),
                   ActionCompletionMode_str(s->txn_props->completion_mode));
1363 1364 1365 1366 1367
        return -1;
    }
    return 0;
}

1368
static void internal_snapshot_prepare(BlkActionState *common,
1369 1370
                                      Error **errp)
{
1371
    Error *local_err = NULL;
1372 1373 1374 1375 1376 1377 1378 1379
    const char *device;
    const char *name;
    BlockDriverState *bs;
    QEMUSnapshotInfo old_sn, *sn;
    bool ret;
    qemu_timeval tv;
    BlockdevSnapshotInternal *internal;
    InternalSnapshotState *state;
1380
    AioContext *aio_context;
1381 1382
    int ret1;

1383
    g_assert(common->action->type ==
1384
             TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC);
1385
    internal = common->action->u.blockdev_snapshot_internal_sync.data;
1386 1387 1388 1389 1390 1391 1392
    state = DO_UPCAST(InternalSnapshotState, common, common);

    /* 1. parse input */
    device = internal->device;
    name = internal->name;

    /* 2. check for validation */
1393 1394 1395 1396
    if (action_check_completion_mode(common, errp) < 0) {
        return;
    }

1397 1398
    bs = qmp_get_root_bs(device, errp);
    if (!bs) {
1399 1400 1401
        return;
    }

1402 1403
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);
1404

1405
    state->bs = bs;
1406 1407

    /* Paired with .clean() */
1408 1409
    bdrv_drained_begin(bs);

1410
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, errp)) {
1411
        goto out;
1412 1413
    }

1414
    if (bdrv_is_read_only(bs)) {
1415
        error_setg(errp, "Device '%s' is read only", device);
1416
        goto out;
1417 1418 1419
    }

    if (!bdrv_can_snapshot(bs)) {
1420 1421 1422
        error_setg(errp, "Block format '%s' used by device '%s' "
                   "does not support internal snapshots",
                   bs->drv->format_name, device);
1423
        goto out;
1424 1425 1426 1427
    }

    if (!strlen(name)) {
        error_setg(errp, "Name is empty");
1428
        goto out;
1429 1430 1431
    }

    /* check whether a snapshot with name exist */
1432 1433 1434 1435
    ret = bdrv_snapshot_find_by_id_and_name(bs, NULL, name, &old_sn,
                                            &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
1436
        goto out;
1437 1438 1439 1440
    } else if (ret) {
        error_setg(errp,
                   "Snapshot with name '%s' already exists on device '%s'",
                   name, device);
1441
        goto out;
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
    }

    /* 3. take the snapshot */
    sn = &state->sn;
    pstrcpy(sn->name, sizeof(sn->name), name);
    qemu_gettimeofday(&tv);
    sn->date_sec = tv.tv_sec;
    sn->date_nsec = tv.tv_usec * 1000;
    sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);

    ret1 = bdrv_snapshot_create(bs, sn);
    if (ret1 < 0) {
        error_setg_errno(errp, -ret1,
                         "Failed to create snapshot '%s' on device '%s'",
                         name, device);
1457
        goto out;
1458 1459 1460
    }

    /* 4. succeed, mark a snapshot is created */
1461
    state->created = true;
1462 1463 1464

out:
    aio_context_release(aio_context);
1465 1466
}

1467
static void internal_snapshot_abort(BlkActionState *common)
1468 1469 1470 1471 1472
{
    InternalSnapshotState *state =
                             DO_UPCAST(InternalSnapshotState, common, common);
    BlockDriverState *bs = state->bs;
    QEMUSnapshotInfo *sn = &state->sn;
1473
    AioContext *aio_context;
1474 1475
    Error *local_error = NULL;

1476
    if (!state->created) {
1477 1478 1479
        return;
    }

1480 1481 1482
    aio_context = bdrv_get_aio_context(state->bs);
    aio_context_acquire(aio_context);

1483
    if (bdrv_snapshot_delete(bs, sn->id_str, sn->name, &local_error) < 0) {
1484 1485 1486 1487 1488
        error_reportf_err(local_error,
                          "Failed to delete snapshot with id '%s' and "
                          "name '%s' on device '%s' in abort: ",
                          sn->id_str, sn->name,
                          bdrv_get_device_name(bs));
1489
    }
1490 1491

    aio_context_release(aio_context);
1492 1493
}

1494
static void internal_snapshot_clean(BlkActionState *common)
1495 1496 1497
{
    InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
                                             common, common);
1498
    AioContext *aio_context;
1499

1500 1501
    if (!state->bs) {
        return;
1502
    }
1503 1504 1505 1506 1507 1508 1509

    aio_context = bdrv_get_aio_context(state->bs);
    aio_context_acquire(aio_context);

    bdrv_drained_end(state->bs);

    aio_context_release(aio_context);
1510 1511
}

1512
/* external snapshot private data */
1513
typedef struct ExternalSnapshotState {
1514
    BlkActionState common;
1515 1516
    BlockDriverState *old_bs;
    BlockDriverState *new_bs;
1517
    bool overlay_appended;
1518
} ExternalSnapshotState;
1519

1520
static void external_snapshot_prepare(BlkActionState *common,
1521 1522
                                      Error **errp)
{
1523
    int flags = 0;
1524
    QDict *options = NULL;
1525
    Error *local_err = NULL;
1526
    /* Device and node name of the image to generate the snapshot from */
1527
    const char *device;
1528
    const char *node_name;
1529 1530 1531
    /* Reference to the new image (for 'blockdev-snapshot') */
    const char *snapshot_ref;
    /* File name of the new image (for 'blockdev-snapshot-sync') */
1532
    const char *new_image_file;
1533 1534
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
1535
    TransactionAction *action = common->action;
1536
    AioContext *aio_context;
1537

1538 1539 1540 1541 1542
    /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
     * purpose but a different set of parameters */
    switch (action->type) {
    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
        {
1543
            BlockdevSnapshot *s = action->u.blockdev_snapshot.data;
1544 1545 1546 1547 1548 1549 1550 1551
            device = s->node;
            node_name = s->node;
            new_image_file = NULL;
            snapshot_ref = s->overlay;
        }
        break;
    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
        {
1552
            BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1553 1554 1555 1556 1557 1558 1559 1560
            device = s->has_device ? s->device : NULL;
            node_name = s->has_node_name ? s->node_name : NULL;
            new_image_file = s->snapshot_file;
            snapshot_ref = NULL;
        }
        break;
    default:
        g_assert_not_reached();
1561 1562 1563
    }

    /* start processing */
1564 1565 1566 1567
    if (action_check_completion_mode(common, errp) < 0) {
        return;
    }

1568 1569
    state->old_bs = bdrv_lookup_bs(device, node_name, errp);
    if (!state->old_bs) {
1570 1571 1572
        return;
    }

1573 1574 1575 1576
    aio_context = bdrv_get_aio_context(state->old_bs);
    aio_context_acquire(aio_context);

    /* Paired with .clean() */
1577
    bdrv_drained_begin(state->old_bs);
1578

1579
    if (!bdrv_is_inserted(state->old_bs)) {
1580
        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
1581
        goto out;
1582 1583
    }

1584 1585
    if (bdrv_op_is_blocked(state->old_bs,
                           BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) {
1586
        goto out;
1587 1588
    }

1589 1590
    if (!bdrv_is_read_only(state->old_bs)) {
        if (bdrv_flush(state->old_bs)) {
1591
            error_setg(errp, QERR_IO_ERROR);
1592
            goto out;
1593 1594 1595
        }
    }

1596
    if (!bdrv_is_first_non_filter(state->old_bs)) {
1597
        error_setg(errp, QERR_FEATURE_DISABLED, "snapshot");
1598
        goto out;
1599 1600
    }

1601
    if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) {
1602
        BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1603 1604 1605 1606
        const char *format = s->has_format ? s->format : "qcow2";
        enum NewImageMode mode;
        const char *snapshot_node_name =
            s->has_snapshot_node_name ? s->snapshot_node_name : NULL;
1607

1608 1609
        if (node_name && !snapshot_node_name) {
            error_setg(errp, "New snapshot node name missing");
1610
            goto out;
1611 1612
        }

1613 1614 1615
        if (snapshot_node_name &&
            bdrv_lookup_bs(snapshot_node_name, snapshot_node_name, NULL)) {
            error_setg(errp, "New snapshot node name already in use");
1616
            goto out;
1617 1618 1619
        }

        flags = state->old_bs->open_flags;
1620 1621
        flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_COPY_ON_READ);
        flags |= BDRV_O_NO_BACKING;
1622 1623 1624 1625

        /* create new image w/backing file */
        mode = s->has_mode ? s->mode : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
        if (mode != NEW_IMAGE_MODE_EXISTING) {
1626 1627 1628
            int64_t size = bdrv_getlength(state->old_bs);
            if (size < 0) {
                error_setg_errno(errp, -size, "bdrv_getlength failed");
1629
                goto out;
1630
            }
1631 1632 1633
            bdrv_img_create(new_image_file, format,
                            state->old_bs->filename,
                            state->old_bs->drv->format_name,
1634
                            NULL, size, flags, false, &local_err);
1635 1636
            if (local_err) {
                error_propagate(errp, local_err);
1637
                goto out;
1638 1639 1640 1641 1642
            }
        }

        options = qdict_new();
        if (s->has_snapshot_node_name) {
1643
            qdict_put_str(options, "node-name", snapshot_node_name);
1644
        }
1645
        qdict_put_str(options, "driver", format);
1646 1647
    }

1648 1649
    state->new_bs = bdrv_open(new_image_file, snapshot_ref, options, flags,
                              errp);
1650
    /* We will manually add the backing_hd field to the bs later */
1651
    if (!state->new_bs) {
1652
        goto out;
1653 1654
    }

1655
    if (bdrv_has_blk(state->new_bs)) {
1656
        error_setg(errp, "The snapshot is already in use");
1657
        goto out;
1658 1659 1660 1661
    }

    if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
                           errp)) {
1662
        goto out;
1663 1664 1665 1666
    }

    if (state->new_bs->backing != NULL) {
        error_setg(errp, "The snapshot already has a backing image");
1667
        goto out;
1668 1669 1670 1671
    }

    if (!state->new_bs->drv->supports_backing) {
        error_setg(errp, "The snapshot does not support backing images");
1672
        goto out;
1673 1674
    }

1675
    bdrv_set_aio_context(state->new_bs, aio_context);
1676

1677 1678 1679 1680 1681 1682 1683
    /* This removes our old bs and adds the new bs. This is an operation that
     * can fail, so we need to do it in .prepare; undoing it for abort is
     * always possible. */
    bdrv_ref(state->new_bs);
    bdrv_append(state->new_bs, state->old_bs, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
1684
        goto out;
1685
    }
1686
    state->overlay_appended = true;
1687 1688 1689

out:
    aio_context_release(aio_context);
1690 1691
}

1692
static void external_snapshot_commit(BlkActionState *common)
1693
{
1694 1695
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
1696 1697 1698 1699
    AioContext *aio_context;

    aio_context = bdrv_get_aio_context(state->old_bs);
    aio_context_acquire(aio_context);
1700

1701 1702 1703
    /* We don't need (or want) to use the transactional
     * bdrv_reopen_multiple() across all the entries at once, because we
     * don't want to abort all of them if one of them fails the reopen */
1704
    if (!atomic_read(&state->old_bs->copy_on_read)) {
1705 1706 1707
        bdrv_reopen(state->old_bs, state->old_bs->open_flags & ~BDRV_O_RDWR,
                    NULL);
    }
1708 1709

    aio_context_release(aio_context);
1710 1711
}

1712
static void external_snapshot_abort(BlkActionState *common)
1713
{
1714 1715 1716
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
    if (state->new_bs) {
1717
        if (state->overlay_appended) {
1718 1719 1720 1721 1722
            AioContext *aio_context;

            aio_context = bdrv_get_aio_context(state->old_bs);
            aio_context_acquire(aio_context);

1723 1724 1725
            bdrv_ref(state->old_bs);   /* we can't let bdrv_set_backind_hd()
                                          close state->old_bs; we need it */
            bdrv_set_backing_hd(state->new_bs, NULL, &error_abort);
1726
            bdrv_replace_node(state->new_bs, state->old_bs, &error_abort);
1727
            bdrv_unref(state->old_bs); /* bdrv_replace_node() ref'ed old_bs */
1728 1729

            aio_context_release(aio_context);
1730
        }
1731
    }
1732 1733
}

1734
static void external_snapshot_clean(BlkActionState *common)
1735 1736 1737
{
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
1738 1739 1740 1741
    AioContext *aio_context;

    if (!state->old_bs) {
        return;
1742
    }
1743 1744 1745 1746 1747 1748 1749 1750

    aio_context = bdrv_get_aio_context(state->old_bs);
    aio_context_acquire(aio_context);

    bdrv_drained_end(state->old_bs);
    bdrv_unref(state->new_bs);

    aio_context_release(aio_context);
1751 1752
}

1753
typedef struct DriveBackupState {
1754
    BlkActionState common;
1755 1756 1757 1758
    BlockDriverState *bs;
    BlockJob *job;
} DriveBackupState;

1759
static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,
1760
                            Error **errp);
1761

1762
static void drive_backup_prepare(BlkActionState *common, Error **errp)
1763 1764
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1765
    BlockDriverState *bs;
1766
    DriveBackup *backup;
1767
    AioContext *aio_context;
1768 1769
    Error *local_err = NULL;

1770
    assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
1771
    backup = common->action->u.drive_backup.data;
1772

1773 1774
    bs = qmp_get_root_bs(backup->device, errp);
    if (!bs) {
1775 1776 1777
        return;
    }

1778 1779 1780 1781
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

    /* Paired with .clean() */
1782
    bdrv_drained_begin(bs);
1783

1784
    state->bs = bs;
1785

1786
    state->job = do_drive_backup(backup, common->block_job_txn, &local_err);
1787
    if (local_err) {
1788
        error_propagate(errp, local_err);
1789
        goto out;
1790
    }
1791 1792 1793

out:
    aio_context_release(aio_context);
1794
}
1795

1796 1797 1798
static void drive_backup_commit(BlkActionState *common)
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1799 1800 1801 1802 1803
    AioContext *aio_context;

    aio_context = bdrv_get_aio_context(state->bs);
    aio_context_acquire(aio_context);

1804
    assert(state->job);
1805
    job_start(&state->job->job);
1806 1807

    aio_context_release(aio_context);
1808 1809
}

1810
static void drive_backup_abort(BlkActionState *common)
1811 1812 1813
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);

1814
    if (state->job) {
1815 1816 1817 1818 1819
        AioContext *aio_context;

        aio_context = bdrv_get_aio_context(state->bs);
        aio_context_acquire(aio_context);

1820
        job_cancel_sync(&state->job->job);
1821 1822

        aio_context_release(aio_context);
1823 1824 1825
    }
}

1826
static void drive_backup_clean(BlkActionState *common)
1827 1828
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1829
    AioContext *aio_context;
1830

1831 1832
    if (!state->bs) {
        return;
1833
    }
1834 1835 1836 1837 1838 1839 1840

    aio_context = bdrv_get_aio_context(state->bs);
    aio_context_acquire(aio_context);

    bdrv_drained_end(state->bs);

    aio_context_release(aio_context);
1841 1842
}

1843
typedef struct BlockdevBackupState {
1844
    BlkActionState common;
1845 1846 1847 1848
    BlockDriverState *bs;
    BlockJob *job;
} BlockdevBackupState;

1849
static BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,
1850
                                    Error **errp);
1851

1852
static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
1853 1854 1855
{
    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
    BlockdevBackup *backup;
1856
    BlockDriverState *bs, *target;
1857
    AioContext *aio_context;
1858 1859
    Error *local_err = NULL;

1860
    assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
1861
    backup = common->action->u.blockdev_backup.data;
1862

1863
    bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1864
    if (!bs) {
1865 1866 1867
        return;
    }

1868
    target = bdrv_lookup_bs(backup->target, backup->target, errp);
M
Max Reitz 已提交
1869
    if (!target) {
1870 1871 1872
        return;
    }

1873 1874
    aio_context = bdrv_get_aio_context(bs);
    if (aio_context != bdrv_get_aio_context(target)) {
1875 1876 1877
        error_setg(errp, "Backup between two IO threads is not implemented");
        return;
    }
1878
    aio_context_acquire(aio_context);
1879
    state->bs = bs;
1880 1881

    /* Paired with .clean() */
1882
    bdrv_drained_begin(state->bs);
1883

1884
    state->job = do_blockdev_backup(backup, common->block_job_txn, &local_err);
1885 1886
    if (local_err) {
        error_propagate(errp, local_err);
1887
        goto out;
1888
    }
1889 1890 1891

out:
    aio_context_release(aio_context);
1892
}
1893

1894 1895 1896
static void blockdev_backup_commit(BlkActionState *common)
{
    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1897 1898 1899 1900 1901
    AioContext *aio_context;

    aio_context = bdrv_get_aio_context(state->bs);
    aio_context_acquire(aio_context);

1902
    assert(state->job);
1903
    job_start(&state->job->job);
1904 1905

    aio_context_release(aio_context);
1906 1907
}

1908
static void blockdev_backup_abort(BlkActionState *common)
1909 1910 1911
{
    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);

1912
    if (state->job) {
1913 1914 1915 1916 1917
        AioContext *aio_context;

        aio_context = bdrv_get_aio_context(state->bs);
        aio_context_acquire(aio_context);

1918
        job_cancel_sync(&state->job->job);
1919 1920

        aio_context_release(aio_context);
1921 1922 1923
    }
}

1924
static void blockdev_backup_clean(BlkActionState *common)
1925 1926
{
    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1927
    AioContext *aio_context;
1928

1929 1930
    if (!state->bs) {
        return;
1931
    }
1932 1933 1934 1935 1936 1937 1938

    aio_context = bdrv_get_aio_context(state->bs);
    aio_context_acquire(aio_context);

    bdrv_drained_end(state->bs);

    aio_context_release(aio_context);
1939 1940
}

F
Fam Zheng 已提交
1941
typedef struct BlockDirtyBitmapState {
1942
    BlkActionState common;
F
Fam Zheng 已提交
1943 1944 1945 1946
    BdrvDirtyBitmap *bitmap;
    BlockDriverState *bs;
    HBitmap *backup;
    bool prepared;
1947
    bool was_enabled;
F
Fam Zheng 已提交
1948 1949
} BlockDirtyBitmapState;

1950
static void block_dirty_bitmap_add_prepare(BlkActionState *common,
F
Fam Zheng 已提交
1951 1952 1953 1954 1955 1956 1957
                                           Error **errp)
{
    Error *local_err = NULL;
    BlockDirtyBitmapAdd *action;
    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                             common, common);

1958 1959 1960 1961
    if (action_check_completion_mode(common, errp) < 0) {
        return;
    }

1962
    action = common->action->u.block_dirty_bitmap_add.data;
F
Fam Zheng 已提交
1963 1964 1965
    /* AIO context taken and released within qmp_block_dirty_bitmap_add */
    qmp_block_dirty_bitmap_add(action->node, action->name,
                               action->has_granularity, action->granularity,
1966
                               action->has_persistent, action->persistent,
1967
                               action->has_autoload, action->autoload,
1968
                               action->has_x_disabled, action->x_disabled,
F
Fam Zheng 已提交
1969 1970 1971 1972 1973 1974 1975 1976 1977
                               &local_err);

    if (!local_err) {
        state->prepared = true;
    } else {
        error_propagate(errp, local_err);
    }
}

1978
static void block_dirty_bitmap_add_abort(BlkActionState *common)
F
Fam Zheng 已提交
1979 1980 1981 1982 1983
{
    BlockDirtyBitmapAdd *action;
    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                             common, common);

1984
    action = common->action->u.block_dirty_bitmap_add.data;
F
Fam Zheng 已提交
1985 1986 1987 1988 1989 1990 1991 1992
    /* Should not be able to fail: IF the bitmap was added via .prepare(),
     * then the node reference and bitmap name must have been valid.
     */
    if (state->prepared) {
        qmp_block_dirty_bitmap_remove(action->node, action->name, &error_abort);
    }
}

1993
static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
F
Fam Zheng 已提交
1994 1995 1996 1997 1998 1999
                                             Error **errp)
{
    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                             common, common);
    BlockDirtyBitmap *action;

2000 2001 2002 2003
    if (action_check_completion_mode(common, errp) < 0) {
        return;
    }

2004
    action = common->action->u.block_dirty_bitmap_clear.data;
F
Fam Zheng 已提交
2005 2006 2007 2008 2009 2010 2011 2012
    state->bitmap = block_dirty_bitmap_lookup(action->node,
                                              action->name,
                                              &state->bs,
                                              errp);
    if (!state->bitmap) {
        return;
    }

2013 2014
    if (bdrv_dirty_bitmap_user_locked(state->bitmap)) {
        error_setg(errp, "Cannot modify a bitmap in use by another operation");
2015
        return;
2016 2017 2018
    } else if (bdrv_dirty_bitmap_readonly(state->bitmap)) {
        error_setg(errp, "Cannot clear a readonly bitmap");
        return;
F
Fam Zheng 已提交
2019 2020 2021 2022 2023
    }

    bdrv_clear_dirty_bitmap(state->bitmap, &state->backup);
}

2024
static void block_dirty_bitmap_restore(BlkActionState *common)
F
Fam Zheng 已提交
2025 2026 2027 2028
{
    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                             common, common);

2029
    if (state->backup) {
2030
        bdrv_restore_dirty_bitmap(state->bitmap, state->backup);
2031
    }
F
Fam Zheng 已提交
2032 2033
}

2034
static void block_dirty_bitmap_free_backup(BlkActionState *common)
F
Fam Zheng 已提交
2035 2036 2037 2038 2039 2040 2041
{
    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                             common, common);

    hbitmap_free(state->backup);
}

2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
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;
    }

2062 2063 2064 2065 2066 2067 2068
    if (bdrv_dirty_bitmap_user_locked(state->bitmap)) {
        error_setg(errp,
                   "Bitmap '%s' is currently in use by another operation"
                   " and cannot be enabled", action->name);
        return;
    }

2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
    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;
    }

2103 2104 2105 2106 2107 2108 2109
    if (bdrv_dirty_bitmap_user_locked(state->bitmap)) {
        error_setg(errp,
                   "Bitmap '%s' is currently in use by another operation"
                   " and cannot be disabled", action->name);
        return;
    }

2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123
    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);
    }
}

2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152
static void block_dirty_bitmap_merge_prepare(BlkActionState *common,
                                             Error **errp)
{
    BlockDirtyBitmapMerge *action;
    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                             common, common);
    BdrvDirtyBitmap *merge_source;

    if (action_check_completion_mode(common, errp) < 0) {
        return;
    }

    action = common->action->u.x_block_dirty_bitmap_merge.data;
    state->bitmap = block_dirty_bitmap_lookup(action->node,
                                              action->dst_name,
                                              &state->bs,
                                              errp);
    if (!state->bitmap) {
        return;
    }

    merge_source = bdrv_find_dirty_bitmap(state->bs, action->src_name);
    if (!merge_source) {
        return;
    }

    bdrv_merge_dirty_bitmap(state->bitmap, merge_source, &state->backup, errp);
}

2153
static void abort_prepare(BlkActionState *common, Error **errp)
2154 2155 2156 2157
{
    error_setg(errp, "Transaction aborted using Abort action");
}

2158
static void abort_commit(BlkActionState *common)
2159
{
2160
    g_assert_not_reached(); /* this action never succeeds */
2161 2162
}

2163
static const BlkActionOps actions[] = {
2164 2165 2166 2167 2168
    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
        .instance_size = sizeof(ExternalSnapshotState),
        .prepare  = external_snapshot_prepare,
        .commit   = external_snapshot_commit,
        .abort = external_snapshot_abort,
2169
        .clean = external_snapshot_clean,
2170
    },
2171
    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
2172
        .instance_size = sizeof(ExternalSnapshotState),
2173 2174 2175
        .prepare  = external_snapshot_prepare,
        .commit   = external_snapshot_commit,
        .abort = external_snapshot_abort,
2176
        .clean = external_snapshot_clean,
2177
    },
2178 2179 2180
    [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
        .instance_size = sizeof(DriveBackupState),
        .prepare = drive_backup_prepare,
2181
        .commit = drive_backup_commit,
2182
        .abort = drive_backup_abort,
2183
        .clean = drive_backup_clean,
2184
    },
2185 2186 2187
    [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
        .instance_size = sizeof(BlockdevBackupState),
        .prepare = blockdev_backup_prepare,
2188
        .commit = blockdev_backup_commit,
2189 2190 2191
        .abort = blockdev_backup_abort,
        .clean = blockdev_backup_clean,
    },
2192
    [TRANSACTION_ACTION_KIND_ABORT] = {
2193
        .instance_size = sizeof(BlkActionState),
2194 2195 2196
        .prepare = abort_prepare,
        .commit = abort_commit,
    },
2197 2198 2199 2200
    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
        .instance_size = sizeof(InternalSnapshotState),
        .prepare  = internal_snapshot_prepare,
        .abort = internal_snapshot_abort,
2201
        .clean = internal_snapshot_clean,
2202
    },
F
Fam Zheng 已提交
2203 2204 2205 2206 2207 2208 2209 2210
    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = {
        .instance_size = sizeof(BlockDirtyBitmapState),
        .prepare = block_dirty_bitmap_add_prepare,
        .abort = block_dirty_bitmap_add_abort,
    },
    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = {
        .instance_size = sizeof(BlockDirtyBitmapState),
        .prepare = block_dirty_bitmap_clear_prepare,
2211 2212
        .commit = block_dirty_bitmap_free_backup,
        .abort = block_dirty_bitmap_restore,
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222
    },
    [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,
2223
    },
2224 2225 2226 2227 2228 2229
    [TRANSACTION_ACTION_KIND_X_BLOCK_DIRTY_BITMAP_MERGE] = {
        .instance_size = sizeof(BlockDirtyBitmapState),
        .prepare = block_dirty_bitmap_merge_prepare,
        .commit = block_dirty_bitmap_free_backup,
        .abort = block_dirty_bitmap_restore,
    },
2230 2231 2232 2233 2234 2235
    /* Where are transactions for MIRROR, COMMIT and STREAM?
     * Although these blockjobs use transaction callbacks like the backup job,
     * these jobs do not necessarily adhere to transaction semantics.
     * These jobs may not fully undo all of their actions on abort, nor do they
     * necessarily work in transactions with more than one job in them.
     */
2236 2237
};

2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
/**
 * Allocate a TransactionProperties structure if necessary, and fill
 * that structure with desired defaults if they are unset.
 */
static TransactionProperties *get_transaction_properties(
    TransactionProperties *props)
{
    if (!props) {
        props = g_new0(TransactionProperties, 1);
    }

    if (!props->has_completion_mode) {
        props->has_completion_mode = true;
        props->completion_mode = ACTION_COMPLETION_MODE_INDIVIDUAL;
    }

    return props;
}

2257
/*
2258 2259
 * 'Atomic' group operations.  The operations are performed as a set, and if
 * any fail then we roll back all operations in the group.
2260
 */
2261 2262 2263 2264
void qmp_transaction(TransactionActionList *dev_list,
                     bool has_props,
                     struct TransactionProperties *props,
                     Error **errp)
2265
{
2266
    TransactionActionList *dev_entry = dev_list;
2267
    JobTxn *block_job_txn = NULL;
2268
    BlkActionState *state, *next;
2269
    Error *local_err = NULL;
2270

2271
    QSIMPLEQ_HEAD(snap_bdrv_states, BlkActionState) snap_bdrv_states;
2272 2273
    QSIMPLEQ_INIT(&snap_bdrv_states);

2274
    /* Does this transaction get canceled as a group on failure?
2275
     * If not, we don't really need to make a JobTxn.
2276 2277 2278
     */
    props = get_transaction_properties(props);
    if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
2279
        block_job_txn = job_txn_new();
2280 2281
    }

2282
    /* drain all i/o before any operations */
2283 2284
    bdrv_drain_all();

2285
    /* We don't do anything in this loop that commits us to the operations */
2286
    while (NULL != dev_entry) {
2287
        TransactionAction *dev_info = NULL;
2288
        const BlkActionOps *ops;
2289

2290 2291 2292
        dev_info = dev_entry->value;
        dev_entry = dev_entry->next;

2293
        assert(dev_info->type < ARRAY_SIZE(actions));
2294

2295
        ops = &actions[dev_info->type];
2296 2297
        assert(ops->instance_size > 0);

2298 2299 2300
        state = g_malloc0(ops->instance_size);
        state->ops = ops;
        state->action = dev_info;
2301 2302
        state->block_job_txn = block_job_txn;
        state->txn_props = props;
2303
        QSIMPLEQ_INSERT_TAIL(&snap_bdrv_states, state, entry);
2304

2305
        state->ops->prepare(state, &local_err);
2306
        if (local_err) {
2307 2308
            error_propagate(errp, local_err);
            goto delete_and_fail;
2309 2310 2311
        }
    }

2312
    QSIMPLEQ_FOREACH(state, &snap_bdrv_states, entry) {
2313 2314 2315
        if (state->ops->commit) {
            state->ops->commit(state);
        }
2316 2317 2318 2319 2320 2321
    }

    /* success */
    goto exit;

delete_and_fail:
2322
    /* failure, and it is all-or-none; roll back all operations */
2323 2324 2325
    QSIMPLEQ_FOREACH(state, &snap_bdrv_states, entry) {
        if (state->ops->abort) {
            state->ops->abort(state);
2326
        }
2327 2328
    }
exit:
2329 2330 2331
    QSIMPLEQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) {
        if (state->ops->clean) {
            state->ops->clean(state);
2332
        }
2333
        g_free(state);
2334
    }
2335 2336 2337
    if (!has_props) {
        qapi_free_TransactionProperties(props);
    }
2338
    job_txn_unref(block_job_txn);
2339 2340
}

2341 2342 2343
void qmp_eject(bool has_device, const char *device,
               bool has_id, const char *id,
               bool has_force, bool force, Error **errp)
2344
{
2345
    Error *local_err = NULL;
2346 2347 2348 2349 2350
    int rc;

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

2352 2353 2354
    rc = do_open_tray(has_device ? device : NULL,
                      has_id ? id : NULL,
                      force, &local_err);
2355
    if (rc && rc != -ENOSYS) {
2356
        error_propagate(errp, local_err);
L
Luiz Capitulino 已提交
2357
        return;
2358
    }
2359
    error_free(local_err);
2360

2361
    blockdev_remove_medium(has_device, device, has_id, id, errp);
2362 2363
}

2364 2365 2366
void qmp_block_passwd(bool has_device, const char *device,
                      bool has_node_name, const char *node_name,
                      const char *password, Error **errp)
2367
{
2368 2369
    error_setg(errp,
               "Setting block passwords directly is no longer supported");
2370 2371
}

2372 2373 2374 2375 2376 2377 2378 2379 2380 2381
/*
 * Attempt to open the tray of @device.
 * If @force, ignore its tray lock.
 * Else, if the tray is locked, don't open it, but ask the guest to open it.
 * On error, store an error through @errp and return -errno.
 * If @device does not exist, return -ENODEV.
 * If it has no removable media, return -ENOTSUP.
 * If it has no tray, return -ENOSYS.
 * If the guest was asked to open the tray, return -EINPROGRESS.
 * Else, return 0.
2382
 */
2383 2384
static int do_open_tray(const char *blk_name, const char *qdev_id,
                        bool force, Error **errp)
2385 2386
{
    BlockBackend *blk;
2387
    const char *device = qdev_id ?: blk_name;
2388 2389
    bool locked;

2390
    blk = qmp_get_blk(blk_name, qdev_id, errp);
2391
    if (!blk) {
2392
        return -ENODEV;
2393 2394 2395 2396
    }

    if (!blk_dev_has_removable_media(blk)) {
        error_setg(errp, "Device '%s' is not removable", device);
2397
        return -ENOTSUP;
2398 2399
    }

2400
    if (!blk_dev_has_tray(blk)) {
2401 2402
        error_setg(errp, "Device '%s' does not have a tray", device);
        return -ENOSYS;
2403 2404
    }

2405
    if (blk_dev_is_tray_open(blk)) {
2406
        return 0;
2407 2408 2409 2410 2411 2412 2413 2414
    }

    locked = blk_dev_is_medium_locked(blk);
    if (locked) {
        blk_dev_eject_request(blk, force);
    }

    if (!locked || force) {
2415
        blk_dev_change_media_cb(blk, false, &error_abort);
2416
    }
2417 2418

    if (locked && !force) {
2419 2420 2421
        error_setg(errp, "Device '%s' is locked and force was not specified, "
                   "wait for tray to open and try again", device);
        return -EINPROGRESS;
2422 2423 2424 2425 2426
    }

    return 0;
}

2427 2428 2429
void qmp_blockdev_open_tray(bool has_device, const char *device,
                            bool has_id, const char *id,
                            bool has_force, bool force,
2430 2431
                            Error **errp)
{
2432 2433 2434
    Error *local_err = NULL;
    int rc;

2435 2436 2437
    if (!has_force) {
        force = false;
    }
2438 2439 2440
    rc = do_open_tray(has_device ? device : NULL,
                      has_id ? id : NULL,
                      force, &local_err);
2441 2442 2443 2444 2445
    if (rc && rc != -ENOSYS && rc != -EINPROGRESS) {
        error_propagate(errp, local_err);
        return;
    }
    error_free(local_err);
2446 2447
}

2448 2449 2450
void qmp_blockdev_close_tray(bool has_device, const char *device,
                             bool has_id, const char *id,
                             Error **errp)
2451 2452
{
    BlockBackend *blk;
2453
    Error *local_err = NULL;
2454

2455 2456 2457 2458
    device = has_device ? device : NULL;
    id = has_id ? id : NULL;

    blk = qmp_get_blk(device, id, errp);
2459 2460 2461 2462 2463
    if (!blk) {
        return;
    }

    if (!blk_dev_has_removable_media(blk)) {
2464
        error_setg(errp, "Device '%s' is not removable", device ?: id);
2465 2466 2467
        return;
    }

2468 2469 2470 2471 2472
    if (!blk_dev_has_tray(blk)) {
        /* Ignore this command on tray-less devices */
        return;
    }

2473 2474 2475 2476
    if (!blk_dev_is_tray_open(blk)) {
        return;
    }

2477 2478 2479 2480 2481
    blk_dev_change_media_cb(blk, true, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
    }
2482 2483
}

2484 2485
static void blockdev_remove_medium(bool has_device, const char *device,
                                   bool has_id, const char *id, Error **errp)
2486 2487 2488 2489
{
    BlockBackend *blk;
    BlockDriverState *bs;
    AioContext *aio_context;
2490
    bool has_attached_device;
2491

2492 2493 2494 2495
    device = has_device ? device : NULL;
    id = has_id ? id : NULL;

    blk = qmp_get_blk(device, id, errp);
2496 2497 2498 2499 2500
    if (!blk) {
        return;
    }

    /* For BBs without a device, we can exchange the BDS tree at will */
2501
    has_attached_device = blk_get_attached_dev(blk);
2502

2503 2504
    if (has_attached_device && !blk_dev_has_removable_media(blk)) {
        error_setg(errp, "Device '%s' is not removable", device ?: id);
2505 2506 2507
        return;
    }

2508 2509 2510 2511
    if (has_attached_device && blk_dev_has_tray(blk) &&
        !blk_dev_is_tray_open(blk))
    {
        error_setg(errp, "Tray of device '%s' is not open", device ?: id);
2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528
        return;
    }

    bs = blk_bs(blk);
    if (!bs) {
        return;
    }

    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) {
        goto out;
    }

    blk_remove_bs(blk);

2529 2530 2531 2532 2533
    if (!blk_dev_has_tray(blk)) {
        /* For tray-less devices, blockdev-open-tray is a no-op (or may not be
         * called at all); therefore, the medium needs to be ejected here.
         * Do it after blk_remove_bs() so blk_is_inserted(blk) returns the @load
         * value passed here (i.e. false). */
2534
        blk_dev_change_media_cb(blk, false, &error_abort);
2535 2536
    }

2537 2538 2539 2540
out:
    aio_context_release(aio_context);
}

2541
void qmp_blockdev_remove_medium(const char *id, Error **errp)
2542 2543 2544 2545
{
    blockdev_remove_medium(false, NULL, true, id, errp);
}

2546
static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
2547 2548
                                            BlockDriverState *bs, Error **errp)
{
2549
    Error *local_err = NULL;
2550
    bool has_device;
2551
    int ret;
2552 2553 2554 2555 2556

    /* For BBs without a device, we can exchange the BDS tree at will */
    has_device = blk_get_attached_dev(blk);

    if (has_device && !blk_dev_has_removable_media(blk)) {
2557
        error_setg(errp, "Device is not removable");
2558 2559 2560
        return;
    }

2561
    if (has_device && blk_dev_has_tray(blk) && !blk_dev_is_tray_open(blk)) {
2562
        error_setg(errp, "Tray of the device is not open");
2563 2564 2565 2566
        return;
    }

    if (blk_bs(blk)) {
2567
        error_setg(errp, "There already is a medium in the device");
2568 2569 2570
        return;
    }

2571 2572 2573 2574
    ret = blk_insert_bs(blk, bs, errp);
    if (ret < 0) {
        return;
    }
2575

2576 2577 2578 2579 2580 2581
    if (!blk_dev_has_tray(blk)) {
        /* For tray-less devices, blockdev-close-tray is a no-op (or may not be
         * called at all); therefore, the medium needs to be pushed into the
         * slot here.
         * Do it after blk_insert_bs() so blk_is_inserted(blk) returns the @load
         * value passed here (i.e. true). */
2582 2583 2584 2585 2586 2587
        blk_dev_change_media_cb(blk, true, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            blk_remove_bs(blk);
            return;
        }
2588
    }
2589 2590
}

2591 2592 2593
static void blockdev_insert_medium(bool has_device, const char *device,
                                   bool has_id, const char *id,
                                   const char *node_name, Error **errp)
2594
{
2595
    BlockBackend *blk;
2596 2597
    BlockDriverState *bs;

2598 2599 2600 2601 2602 2603 2604
    blk = qmp_get_blk(has_device ? device : NULL,
                      has_id ? id : NULL,
                      errp);
    if (!blk) {
        return;
    }

2605 2606 2607 2608 2609 2610
    bs = bdrv_find_node(node_name);
    if (!bs) {
        error_setg(errp, "Node '%s' not found", node_name);
        return;
    }

2611
    if (bdrv_has_blk(bs)) {
2612
        error_setg(errp, "Node '%s' is already in use", node_name);
2613 2614 2615
        return;
    }

2616
    qmp_blockdev_insert_anon_medium(blk, bs, errp);
2617 2618
}

2619 2620
void qmp_blockdev_insert_medium(const char *id, const char *node_name,
                                Error **errp)
2621 2622 2623 2624
{
    blockdev_insert_medium(false, NULL, true, id, node_name, errp);
}

2625 2626 2627
void qmp_blockdev_change_medium(bool has_device, const char *device,
                                bool has_id, const char *id,
                                const char *filename,
2628
                                bool has_format, const char *format,
2629 2630
                                bool has_read_only,
                                BlockdevChangeReadOnlyMode read_only,
2631
                                Error **errp)
2632 2633 2634
{
    BlockBackend *blk;
    BlockDriverState *medium_bs = NULL;
2635
    int bdrv_flags;
2636
    bool detect_zeroes;
2637
    int rc;
2638 2639 2640
    QDict *options = NULL;
    Error *err = NULL;

2641 2642 2643
    blk = qmp_get_blk(has_device ? device : NULL,
                      has_id ? id : NULL,
                      errp);
2644 2645 2646 2647 2648 2649 2650 2651 2652
    if (!blk) {
        goto fail;
    }

    if (blk_bs(blk)) {
        blk_update_root_state(blk);
    }

    bdrv_flags = blk_get_open_flags_from_root_state(blk);
2653 2654
    bdrv_flags &= ~(BDRV_O_TEMPORARY | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING |
        BDRV_O_PROTOCOL);
2655

2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675
    if (!has_read_only) {
        read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;
    }

    switch (read_only) {
    case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN:
        break;

    case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY:
        bdrv_flags &= ~BDRV_O_RDWR;
        break;

    case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE:
        bdrv_flags |= BDRV_O_RDWR;
        break;

    default:
        abort();
    }

2676 2677
    options = qdict_new();
    detect_zeroes = blk_get_detect_zeroes_from_root_state(blk);
2678
    qdict_put_str(options, "detect-zeroes", detect_zeroes ? "on" : "off");
2679

2680
    if (has_format) {
2681
        qdict_put_str(options, "driver", format);
2682 2683
    }

2684 2685
    medium_bs = bdrv_open(filename, NULL, options, bdrv_flags, errp);
    if (!medium_bs) {
2686 2687 2688
        goto fail;
    }

2689 2690 2691
    rc = do_open_tray(has_device ? device : NULL,
                      has_id ? id : NULL,
                      false, &err);
2692
    if (rc && rc != -ENOSYS) {
2693 2694 2695
        error_propagate(errp, err);
        goto fail;
    }
2696 2697
    error_free(err);
    err = NULL;
2698

2699
    blockdev_remove_medium(has_device, device, has_id, id, &err);
2700 2701 2702 2703 2704
    if (err) {
        error_propagate(errp, err);
        goto fail;
    }

2705
    qmp_blockdev_insert_anon_medium(blk, medium_bs, &err);
2706 2707 2708 2709 2710
    if (err) {
        error_propagate(errp, err);
        goto fail;
    }

2711
    qmp_blockdev_close_tray(has_device, device, has_id, id, errp);
2712 2713 2714 2715 2716 2717 2718 2719

fail:
    /* If the medium has been inserted, the device has its own reference, so
     * ours must be relinquished; and if it has not been inserted successfully,
     * the reference must be relinquished anyway */
    bdrv_unref(medium_bs);
}

2720
/* throttling disk I/O limits */
2721
void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp)
2722
{
2723
    ThrottleConfig cfg;
2724
    BlockDriverState *bs;
2725
    BlockBackend *blk;
2726
    AioContext *aio_context;
2727

2728 2729 2730
    blk = qmp_get_blk(arg->has_device ? arg->device : NULL,
                      arg->has_id ? arg->id : NULL,
                      errp);
2731
    if (!blk) {
2732
        return;
2733
    }
M
Max Reitz 已提交
2734 2735 2736 2737

    aio_context = blk_get_aio_context(blk);
    aio_context_acquire(aio_context);

2738
    bs = blk_bs(blk);
M
Max Reitz 已提交
2739
    if (!bs) {
2740
        error_setg(errp, "Device has no medium");
M
Max Reitz 已提交
2741 2742
        goto out;
    }
2743

2744
    throttle_config_init(&cfg);
2745 2746 2747
    cfg.buckets[THROTTLE_BPS_TOTAL].avg = arg->bps;
    cfg.buckets[THROTTLE_BPS_READ].avg  = arg->bps_rd;
    cfg.buckets[THROTTLE_BPS_WRITE].avg = arg->bps_wr;
2748

2749 2750 2751
    cfg.buckets[THROTTLE_OPS_TOTAL].avg = arg->iops;
    cfg.buckets[THROTTLE_OPS_READ].avg  = arg->iops_rd;
    cfg.buckets[THROTTLE_OPS_WRITE].avg = arg->iops_wr;
2752

2753 2754
    if (arg->has_bps_max) {
        cfg.buckets[THROTTLE_BPS_TOTAL].max = arg->bps_max;
2755
    }
2756 2757
    if (arg->has_bps_rd_max) {
        cfg.buckets[THROTTLE_BPS_READ].max = arg->bps_rd_max;
2758
    }
2759 2760
    if (arg->has_bps_wr_max) {
        cfg.buckets[THROTTLE_BPS_WRITE].max = arg->bps_wr_max;
2761
    }
2762 2763
    if (arg->has_iops_max) {
        cfg.buckets[THROTTLE_OPS_TOTAL].max = arg->iops_max;
2764
    }
2765 2766
    if (arg->has_iops_rd_max) {
        cfg.buckets[THROTTLE_OPS_READ].max = arg->iops_rd_max;
2767
    }
2768 2769
    if (arg->has_iops_wr_max) {
        cfg.buckets[THROTTLE_OPS_WRITE].max = arg->iops_wr_max;
2770
    }
2771

2772 2773
    if (arg->has_bps_max_length) {
        cfg.buckets[THROTTLE_BPS_TOTAL].burst_length = arg->bps_max_length;
2774
    }
2775 2776
    if (arg->has_bps_rd_max_length) {
        cfg.buckets[THROTTLE_BPS_READ].burst_length = arg->bps_rd_max_length;
2777
    }
2778 2779
    if (arg->has_bps_wr_max_length) {
        cfg.buckets[THROTTLE_BPS_WRITE].burst_length = arg->bps_wr_max_length;
2780
    }
2781 2782
    if (arg->has_iops_max_length) {
        cfg.buckets[THROTTLE_OPS_TOTAL].burst_length = arg->iops_max_length;
2783
    }
2784 2785
    if (arg->has_iops_rd_max_length) {
        cfg.buckets[THROTTLE_OPS_READ].burst_length = arg->iops_rd_max_length;
2786
    }
2787 2788
    if (arg->has_iops_wr_max_length) {
        cfg.buckets[THROTTLE_OPS_WRITE].burst_length = arg->iops_wr_max_length;
2789 2790
    }

2791 2792
    if (arg->has_iops_size) {
        cfg.op_size = arg->iops_size;
2793
    }
2794

2795
    if (!throttle_is_valid(&cfg, errp)) {
M
Max Reitz 已提交
2796
        goto out;
2797 2798
    }

2799 2800 2801
    if (throttle_enabled(&cfg)) {
        /* Enable I/O limits if they're not enabled yet, otherwise
         * just update the throttling group. */
2802
        if (!blk_get_public(blk)->throttle_group_member.throttle_state) {
2803
            blk_io_limits_enable(blk,
2804 2805 2806
                                 arg->has_group ? arg->group :
                                 arg->has_device ? arg->device :
                                 arg->id);
2807 2808
        } else if (arg->has_group) {
            blk_io_limits_update_group(blk, arg->group);
2809 2810
        }
        /* Set the new throttling configuration */
2811
        blk_set_io_limits(blk, &cfg);
2812
    } else if (blk_get_public(blk)->throttle_group_member.throttle_state) {
2813
        /* If all throttling settings are set to 0, disable I/O limits */
2814
        blk_io_limits_disable(blk);
2815
    }
2816

M
Max Reitz 已提交
2817
out:
2818
    aio_context_release(aio_context);
2819 2820
}

2821 2822
void qmp_block_dirty_bitmap_add(const char *node, const char *name,
                                bool has_granularity, uint32_t granularity,
2823
                                bool has_persistent, bool persistent,
2824
                                bool has_autoload, bool autoload,
2825
                                bool has_disabled, bool disabled,
2826 2827 2828
                                Error **errp)
{
    BlockDriverState *bs;
2829
    BdrvDirtyBitmap *bitmap;
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844

    if (!name || name[0] == '\0') {
        error_setg(errp, "Bitmap name cannot be empty");
        return;
    }

    bs = bdrv_lookup_bs(node, node, errp);
    if (!bs) {
        return;
    }

    if (has_granularity) {
        if (granularity < 512 || !is_power_of_2(granularity)) {
            error_setg(errp, "Granularity must be power of 2 "
                             "and at least 512");
2845
            return;
2846 2847 2848 2849 2850 2851
        }
    } else {
        /* Default to cluster size, if available: */
        granularity = bdrv_get_default_bitmap_granularity(bs);
    }

2852 2853 2854
    if (!has_persistent) {
        persistent = false;
    }
2855

2856 2857
    if (has_autoload) {
        warn_report("Autoload option is deprecated and its value is ignored");
2858
    }
2859

2860 2861 2862 2863
    if (!has_disabled) {
        disabled = false;
    }

2864 2865 2866 2867 2868 2869 2870
    if (persistent &&
        !bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp))
    {
        return;
    }

    bitmap = bdrv_create_dirty_bitmap(bs, granularity, name, errp);
2871 2872
    if (bitmap == NULL) {
        return;
2873
    }
2874

2875 2876 2877 2878
    if (disabled) {
        bdrv_disable_dirty_bitmap(bitmap);
    }

2879
    bdrv_dirty_bitmap_set_persistance(bitmap, persistent);
2880 2881 2882 2883 2884 2885 2886
}

void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
                                   Error **errp)
{
    BlockDriverState *bs;
    BdrvDirtyBitmap *bitmap;
2887
    Error *local_err = NULL;
2888

2889
    bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2890 2891 2892 2893
    if (!bitmap || !bs) {
        return;
    }

2894
    if (bdrv_dirty_bitmap_user_locked(bitmap)) {
2895
        error_setg(errp,
2896 2897
                   "Bitmap '%s' is currently in use by another operation and"
                   " cannot be removed", name);
2898
        return;
2899
    }
2900 2901 2902 2903 2904 2905 2906 2907 2908

    if (bdrv_dirty_bitmap_get_persistance(bitmap)) {
        bdrv_remove_persistent_dirty_bitmap(bs, name, &local_err);
        if (local_err != NULL) {
            error_propagate(errp, local_err);
            return;
        }
    }

2909 2910 2911
    bdrv_release_dirty_bitmap(bs, bitmap);
}

2912 2913 2914 2915 2916 2917 2918 2919 2920 2921
/**
 * Completely clear a bitmap, for the purposes of synchronizing a bitmap
 * immediately after a full backup operation.
 */
void qmp_block_dirty_bitmap_clear(const char *node, const char *name,
                                  Error **errp)
{
    BdrvDirtyBitmap *bitmap;
    BlockDriverState *bs;

2922
    bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2923 2924 2925 2926
    if (!bitmap || !bs) {
        return;
    }

2927
    if (bdrv_dirty_bitmap_user_locked(bitmap)) {
2928
        error_setg(errp,
2929 2930
                   "Bitmap '%s' is currently in use by another operation"
                   " and cannot be cleared", name);
2931
        return;
2932 2933 2934
    } else if (bdrv_dirty_bitmap_readonly(bitmap)) {
        error_setg(errp, "Bitmap '%s' is readonly and cannot be cleared", name);
        return;
2935 2936
    }

F
Fam Zheng 已提交
2937
    bdrv_clear_dirty_bitmap(bitmap, NULL);
2938 2939
}

2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950
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;
    }

2951
    if (bdrv_dirty_bitmap_user_locked(bitmap)) {
2952
        error_setg(errp,
2953 2954
                   "Bitmap '%s' is currently in use by another operation"
                   " and cannot be enabled", name);
2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971
        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;
    }

2972
    if (bdrv_dirty_bitmap_user_locked(bitmap)) {
2973
        error_setg(errp,
2974 2975
                   "Bitmap '%s' is currently in use by another operation"
                   " and cannot be disabled", name);
2976 2977 2978 2979 2980 2981
        return;
    }

    bdrv_disable_dirty_bitmap(bitmap);
}

2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998
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;
    }

    src = bdrv_find_dirty_bitmap(bs, src_name);
    if (!src) {
        error_setg(errp, "Dirty bitmap '%s' not found", src_name);
        return;
    }

2999
    bdrv_merge_dirty_bitmap(dst, src, NULL, errp);
3000 3001
}

3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026
BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node,
                                                              const char *name,
                                                              Error **errp)
{
    BdrvDirtyBitmap *bitmap;
    BlockDriverState *bs;
    BlockDirtyBitmapSha256 *ret = NULL;
    char *sha256;

    bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
    if (!bitmap || !bs) {
        return NULL;
    }

    sha256 = bdrv_dirty_bitmap_sha256(bitmap, errp);
    if (sha256 == NULL) {
        return NULL;
    }

    ret = g_new(BlockDirtyBitmapSha256, 1);
    ret->sha256 = sha256;

    return ret;
}

3027
void hmp_drive_del(Monitor *mon, const QDict *qdict)
3028 3029
{
    const char *id = qdict_get_str(qdict, "id");
3030
    BlockBackend *blk;
3031
    BlockDriverState *bs;
3032
    AioContext *aio_context;
3033
    Error *local_err = NULL;
3034

3035 3036
    bs = bdrv_find_node(id);
    if (bs) {
3037
        qmp_blockdev_del(id, &local_err);
3038 3039 3040 3041 3042 3043
        if (local_err) {
            error_report_err(local_err);
        }
        return;
    }

3044 3045
    blk = blk_by_name(id);
    if (!blk) {
3046
        error_report("Device '%s' not found", id);
3047
        return;
3048
    }
3049

3050
    if (!blk_legacy_dinfo(blk)) {
3051 3052
        error_report("Deleting device added with blockdev-add"
                     " is not supported");
3053
        return;
3054 3055
    }

M
Max Reitz 已提交
3056
    aio_context = blk_get_aio_context(blk);
3057 3058
    aio_context_acquire(aio_context);

M
Max Reitz 已提交
3059 3060 3061 3062 3063 3064 3065
    bs = blk_bs(blk);
    if (bs) {
        if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) {
            error_report_err(local_err);
            aio_context_release(aio_context);
            return;
        }
3066

3067
        blk_remove_bs(blk);
M
Max Reitz 已提交
3068
    }
3069

3070
    /* Make the BlockBackend and the attached BlockDriverState anonymous */
3071 3072
    monitor_remove_blk(blk);

3073 3074
    /* If this BlockBackend has a device attached to it, its refcount will be
     * decremented when the device is removed; otherwise we have to do so here.
3075
     */
3076
    if (blk_get_attached_dev(blk)) {
3077
        /* Further I/O must not pause the guest */
3078 3079
        blk_set_on_error(blk, BLOCKDEV_ON_ERROR_REPORT,
                         BLOCKDEV_ON_ERROR_REPORT);
3080
    } else {
3081
        blk_unref(blk);
3082 3083
    }

3084
    aio_context_release(aio_context);
3085
}
3086

3087 3088 3089
void qmp_block_resize(bool has_device, const char *device,
                      bool has_node_name, const char *node_name,
                      int64_t size, Error **errp)
3090
{
3091
    Error *local_err = NULL;
3092
    BlockBackend *blk = NULL;
3093
    BlockDriverState *bs;
3094
    AioContext *aio_context;
3095
    int ret;
3096

3097 3098 3099
    bs = bdrv_lookup_bs(has_device ? device : NULL,
                        has_node_name ? node_name : NULL,
                        &local_err);
3100
    if (local_err) {
3101 3102 3103 3104
        error_propagate(errp, local_err);
        return;
    }

3105 3106 3107
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

3108
    if (!bdrv_is_first_non_filter(bs)) {
3109
        error_setg(errp, QERR_FEATURE_DISABLED, "resize");
3110
        goto out;
3111 3112 3113
    }

    if (size < 0) {
3114
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size");
3115
        goto out;
3116 3117
    }

3118
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
3119
        error_setg(errp, QERR_DEVICE_IN_USE, device);
3120
        goto out;
3121 3122
    }

3123
    blk = blk_new(BLK_PERM_RESIZE, BLK_PERM_ALL);
3124 3125 3126 3127
    ret = blk_insert_bs(blk, bs, errp);
    if (ret < 0) {
        goto out;
    }
3128

3129
    bdrv_drained_begin(bs);
3130
    ret = blk_truncate(blk, size, PREALLOC_MODE_OFF, errp);
3131
    bdrv_drained_end(bs);
3132 3133

out:
3134
    blk_unref(blk);
3135
    aio_context_release(aio_context);
3136
}
3137

3138
void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
3139
                      bool has_base, const char *base,
3140
                      bool has_base_node, const char *base_node,
3141 3142
                      bool has_backing_file, const char *backing_file,
                      bool has_speed, int64_t speed,
3143
                      bool has_on_error, BlockdevOnError on_error,
3144 3145
                      bool has_auto_finalize, bool auto_finalize,
                      bool has_auto_dismiss, bool auto_dismiss,
3146
                      Error **errp)
3147
{
3148
    BlockDriverState *bs, *iter;
3149
    BlockDriverState *base_bs = NULL;
3150
    AioContext *aio_context;
3151
    Error *local_err = NULL;
3152
    const char *base_name = NULL;
3153
    int job_flags = JOB_DEFAULT;
3154

3155 3156 3157 3158
    if (!has_on_error) {
        on_error = BLOCKDEV_ON_ERROR_REPORT;
    }

3159
    bs = bdrv_lookup_bs(device, device, errp);
3160
    if (!bs) {
3161 3162 3163
        return;
    }

3164
    aio_context = bdrv_get_aio_context(bs);
3165 3166
    aio_context_acquire(aio_context);

3167 3168 3169 3170 3171 3172
    if (has_base && has_base_node) {
        error_setg(errp, "'base' and 'base-node' cannot be specified "
                   "at the same time");
        goto out;
    }

3173
    if (has_base) {
3174 3175
        base_bs = bdrv_find_backing_image(bs, base);
        if (base_bs == NULL) {
3176
            error_setg(errp, QERR_BASE_NOT_FOUND, base);
3177
            goto out;
3178
        }
3179
        assert(bdrv_get_aio_context(base_bs) == aio_context);
3180
        base_name = base;
3181 3182
    }

3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196
    if (has_base_node) {
        base_bs = bdrv_lookup_bs(NULL, base_node, errp);
        if (!base_bs) {
            goto out;
        }
        if (bs == base_bs || !bdrv_chain_contains(bs, base_bs)) {
            error_setg(errp, "Node '%s' is not a backing image of '%s'",
                       base_node, device);
            goto out;
        }
        assert(bdrv_get_aio_context(base_bs) == aio_context);
        base_name = base_bs->filename;
    }

3197 3198 3199 3200 3201 3202 3203
    /* Check for op blockers in the whole chain between bs and base */
    for (iter = bs; iter && iter != base_bs; iter = backing_bs(iter)) {
        if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_STREAM, errp)) {
            goto out;
        }
    }

3204 3205 3206 3207 3208
    /* if we are streaming the entire chain, the result will have no backing
     * file, and specifying one is therefore an error */
    if (base_bs == NULL && has_backing_file) {
        error_setg(errp, "backing file specified, but streaming the "
                         "entire chain");
3209
        goto out;
3210 3211 3212 3213 3214
    }

    /* backing_file string overrides base bs filename */
    base_name = has_backing_file ? backing_file : base_name;

3215 3216 3217 3218 3219 3220 3221
    if (has_auto_finalize && !auto_finalize) {
        job_flags |= JOB_MANUAL_FINALIZE;
    }
    if (has_auto_dismiss && !auto_dismiss) {
        job_flags |= JOB_MANUAL_DISMISS;
    }

3222
    stream_start(has_job_id ? job_id : NULL, bs, base_bs, base_name,
3223
                 job_flags, has_speed ? speed : 0, on_error, &local_err);
3224
    if (local_err) {
3225
        error_propagate(errp, local_err);
3226
        goto out;
3227 3228 3229
    }

    trace_qmp_block_stream(bs, bs->job);
3230 3231 3232

out:
    aio_context_release(aio_context);
3233
}
3234

3235
void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
3236
                      bool has_base_node, const char *base_node,
3237
                      bool has_base, const char *base,
3238
                      bool has_top_node, const char *top_node,
3239
                      bool has_top, const char *top,
3240
                      bool has_backing_file, const char *backing_file,
3241
                      bool has_speed, int64_t speed,
3242
                      bool has_filter_node_name, const char *filter_node_name,
3243 3244
                      bool has_auto_finalize, bool auto_finalize,
                      bool has_auto_dismiss, bool auto_dismiss,
3245 3246 3247
                      Error **errp)
{
    BlockDriverState *bs;
3248
    BlockDriverState *iter;
3249
    BlockDriverState *base_bs, *top_bs;
3250
    AioContext *aio_context;
3251 3252 3253 3254
    Error *local_err = NULL;
    /* This will be part of the QMP command, if/when the
     * BlockdevOnError change for blkmirror makes it in
     */
3255
    BlockdevOnError on_error = BLOCKDEV_ON_ERROR_REPORT;
3256
    int job_flags = JOB_DEFAULT;
3257

3258 3259 3260
    if (!has_speed) {
        speed = 0;
    }
3261 3262 3263
    if (!has_filter_node_name) {
        filter_node_name = NULL;
    }
3264 3265 3266 3267 3268 3269
    if (has_auto_finalize && !auto_finalize) {
        job_flags |= JOB_MANUAL_FINALIZE;
    }
    if (has_auto_dismiss && !auto_dismiss) {
        job_flags |= JOB_MANUAL_DISMISS;
    }
3270

3271 3272 3273 3274 3275
    /* Important Note:
     *  libvirt relies on the DeviceNotFound error class in order to probe for
     *  live commit feature versions; for this to work, we must make sure to
     *  perform the device lookup before any generic errors that may occur in a
     *  scenario in which all optional arguments are omitted. */
3276 3277 3278 3279 3280 3281 3282 3283 3284 3285
    bs = qmp_get_root_bs(device, &local_err);
    if (!bs) {
        bs = bdrv_lookup_bs(device, device, NULL);
        if (!bs) {
            error_free(local_err);
            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                      "Device '%s' not found", device);
        } else {
            error_propagate(errp, local_err);
        }
3286
        return;
3287 3288
    }

3289
    aio_context = bdrv_get_aio_context(bs);
3290 3291
    aio_context_acquire(aio_context);

3292
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, errp)) {
3293
        goto out;
3294 3295 3296 3297 3298
    }

    /* default top_bs is the active layer */
    top_bs = bs;

3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312
    if (has_top_node && has_top) {
        error_setg(errp, "'top-node' and 'top' are mutually exclusive");
        goto out;
    } else if (has_top_node) {
        top_bs = bdrv_lookup_bs(NULL, top_node, errp);
        if (top_bs == NULL) {
            goto out;
        }
        if (!bdrv_chain_contains(bs, top_bs)) {
            error_setg(errp, "'%s' is not in this backing file chain",
                       top_node);
            goto out;
        }
    } else if (has_top && top) {
3313 3314 3315 3316 3317 3318 3319
        if (strcmp(bs->filename, top) != 0) {
            top_bs = bdrv_find_backing_image(bs, top);
        }
    }

    if (top_bs == NULL) {
        error_setg(errp, "Top image file %s not found", top ? top : "NULL");
3320
        goto out;
3321 3322
    }

3323 3324
    assert(bdrv_get_aio_context(top_bs) == aio_context);

3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338
    if (has_base_node && has_base) {
        error_setg(errp, "'base-node' and 'base' are mutually exclusive");
        goto out;
    } else if (has_base_node) {
        base_bs = bdrv_lookup_bs(NULL, base_node, errp);
        if (base_bs == NULL) {
            goto out;
        }
        if (!bdrv_chain_contains(top_bs, base_bs)) {
            error_setg(errp, "'%s' is not in this backing file chain",
                       base_node);
            goto out;
        }
    } else if (has_base && base) {
3339 3340 3341 3342 3343 3344
        base_bs = bdrv_find_backing_image(top_bs, base);
    } else {
        base_bs = bdrv_find_base(top_bs);
    }

    if (base_bs == NULL) {
3345
        error_setg(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL");
3346
        goto out;
3347 3348
    }

3349 3350
    assert(bdrv_get_aio_context(base_bs) == aio_context);

3351 3352 3353 3354
    for (iter = top_bs; iter != backing_bs(base_bs); iter = backing_bs(iter)) {
        if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
            goto out;
        }
3355 3356
    }

3357 3358 3359
    /* Do not allow attempts to commit an image into itself */
    if (top_bs == base_bs) {
        error_setg(errp, "cannot commit an image into itself");
3360
        goto out;
3361 3362
    }

3363
    if (top_bs == bs) {
3364 3365 3366
        if (has_backing_file) {
            error_setg(errp, "'backing-file' specified,"
                             " but 'top' is the active layer");
3367
            goto out;
3368
        }
3369
        commit_active_start(has_job_id ? job_id : NULL, bs, base_bs,
3370
                            job_flags, speed, on_error,
3371
                            filter_node_name, NULL, NULL, false, &local_err);
3372
    } else {
3373 3374 3375 3376
        BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);
        if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
            goto out;
        }
3377 3378
        commit_start(has_job_id ? job_id : NULL, bs, base_bs, top_bs, job_flags,
                     speed, on_error, has_backing_file ? backing_file : NULL,
3379
                     filter_node_name, &local_err);
3380
    }
3381 3382
    if (local_err != NULL) {
        error_propagate(errp, local_err);
3383
        goto out;
3384
    }
3385 3386 3387

out:
    aio_context_release(aio_context);
3388 3389
}

3390
static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,
3391
                                 Error **errp)
3392 3393 3394
{
    BlockDriverState *bs;
    BlockDriverState *target_bs;
3395
    BlockDriverState *source = NULL;
3396
    BlockJob *job = NULL;
3397
    BdrvDirtyBitmap *bmap = NULL;
3398
    AioContext *aio_context;
3399
    QDict *options = NULL;
3400
    Error *local_err = NULL;
3401
    int flags, job_flags = JOB_DEFAULT;
3402
    int64_t size;
3403
    bool set_backing_hd = false;
3404

3405 3406
    if (!backup->has_speed) {
        backup->speed = 0;
3407
    }
3408 3409
    if (!backup->has_on_source_error) {
        backup->on_source_error = BLOCKDEV_ON_ERROR_REPORT;
3410
    }
3411 3412
    if (!backup->has_on_target_error) {
        backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT;
3413
    }
3414 3415 3416 3417 3418
    if (!backup->has_mode) {
        backup->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
    }
    if (!backup->has_job_id) {
        backup->job_id = NULL;
3419
    }
3420 3421 3422 3423 3424 3425
    if (!backup->has_auto_finalize) {
        backup->auto_finalize = true;
    }
    if (!backup->has_auto_dismiss) {
        backup->auto_dismiss = true;
    }
3426 3427 3428
    if (!backup->has_compress) {
        backup->compress = false;
    }
3429

3430
    bs = qmp_get_root_bs(backup->device, errp);
3431
    if (!bs) {
3432
        return NULL;
3433 3434
    }

3435
    aio_context = bdrv_get_aio_context(bs);
3436 3437
    aio_context_acquire(aio_context);

3438 3439 3440
    if (!backup->has_format) {
        backup->format = backup->mode == NEW_IMAGE_MODE_EXISTING ?
                         NULL : (char*) bs->drv->format_name;
3441 3442
    }

3443
    /* Early check to avoid creating target */
3444
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
3445
        goto out;
3446 3447
    }

3448
    flags = bs->open_flags | BDRV_O_RDWR;
3449

3450 3451
    /* See if we have a backing HD we can use to create our new image
     * on top of. */
3452
    if (backup->sync == MIRROR_SYNC_MODE_TOP) {
3453
        source = backing_bs(bs);
3454
        if (!source) {
3455
            backup->sync = MIRROR_SYNC_MODE_FULL;
3456 3457
        }
    }
3458
    if (backup->sync == MIRROR_SYNC_MODE_NONE) {
3459
        source = bs;
3460 3461
        flags |= BDRV_O_NO_BACKING;
        set_backing_hd = true;
3462 3463
    }

3464 3465 3466
    size = bdrv_getlength(bs);
    if (size < 0) {
        error_setg_errno(errp, -size, "bdrv_getlength failed");
3467
        goto out;
3468 3469
    }

3470 3471
    if (backup->mode != NEW_IMAGE_MODE_EXISTING) {
        assert(backup->format);
3472
        if (source) {
3473
            bdrv_img_create(backup->target, backup->format, source->filename,
3474
                            source->drv->format_name, NULL,
3475
                            size, flags, false, &local_err);
3476
        } else {
3477
            bdrv_img_create(backup->target, backup->format, NULL, NULL, NULL,
3478
                            size, flags, false, &local_err);
3479
        }
3480 3481
    }

3482
    if (local_err) {
3483
        error_propagate(errp, local_err);
3484
        goto out;
3485 3486
    }

3487
    if (backup->format) {
3488 3489 3490
        if (!options) {
            options = qdict_new();
        }
3491
        qdict_put_str(options, "driver", backup->format);
3492 3493
    }

3494
    target_bs = bdrv_open(backup->target, NULL, options, flags, errp);
3495
    if (!target_bs) {
3496
        goto out;
3497 3498
    }

3499 3500
    bdrv_set_aio_context(target_bs, aio_context);

3501 3502 3503 3504 3505 3506 3507 3508
    if (set_backing_hd) {
        bdrv_set_backing_hd(target_bs, source, &local_err);
        if (local_err) {
            bdrv_unref(target_bs);
            goto out;
        }
    }

3509 3510
    if (backup->has_bitmap) {
        bmap = bdrv_find_dirty_bitmap(bs, backup->bitmap);
3511
        if (!bmap) {
3512
            error_setg(errp, "Bitmap '%s' could not be found", backup->bitmap);
3513
            bdrv_unref(target_bs);
3514 3515
            goto out;
        }
3516
        if (bdrv_dirty_bitmap_user_locked(bmap)) {
3517
            error_setg(errp,
3518 3519
                       "Bitmap '%s' is currently in use by another operation"
                       " and cannot be used for backup", backup->bitmap);
3520 3521
            goto out;
        }
3522
    }
3523
    if (!backup->auto_finalize) {
3524
        job_flags |= JOB_MANUAL_FINALIZE;
3525 3526
    }
    if (!backup->auto_dismiss) {
3527
        job_flags |= JOB_MANUAL_DISMISS;
3528
    }
3529

3530 3531 3532
    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,
3533
                            job_flags, NULL, NULL, txn, &local_err);
3534
    bdrv_unref(target_bs);
3535 3536
    if (local_err != NULL) {
        error_propagate(errp, local_err);
3537
        goto out;
3538
    }
3539 3540 3541

out:
    aio_context_release(aio_context);
3542
    return job;
3543 3544
}

3545
void qmp_drive_backup(DriveBackup *arg, Error **errp)
3546
{
3547 3548 3549 3550

    BlockJob *job;
    job = do_drive_backup(arg, NULL, errp);
    if (job) {
3551
        job_start(&job->job);
3552
    }
3553 3554
}

3555 3556
BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
{
3557
    return bdrv_named_nodes_list(errp);
3558 3559
}

3560
BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,
3561
                             Error **errp)
3562 3563 3564 3565
{
    BlockDriverState *bs;
    BlockDriverState *target_bs;
    Error *local_err = NULL;
3566
    BdrvDirtyBitmap *bmap = NULL;
3567
    AioContext *aio_context;
3568
    BlockJob *job = NULL;
3569
    int job_flags = JOB_DEFAULT;
3570

3571 3572
    if (!backup->has_speed) {
        backup->speed = 0;
3573
    }
3574 3575 3576 3577 3578
    if (!backup->has_on_source_error) {
        backup->on_source_error = BLOCKDEV_ON_ERROR_REPORT;
    }
    if (!backup->has_on_target_error) {
        backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT;
3579
    }
3580 3581
    if (!backup->has_job_id) {
        backup->job_id = NULL;
3582
    }
3583 3584 3585 3586 3587 3588
    if (!backup->has_auto_finalize) {
        backup->auto_finalize = true;
    }
    if (!backup->has_auto_dismiss) {
        backup->auto_dismiss = true;
    }
3589 3590 3591
    if (!backup->has_compress) {
        backup->compress = false;
    }
3592

3593
    bs = bdrv_lookup_bs(backup->device, backup->device, errp);
3594
    if (!bs) {
3595
        return NULL;
3596 3597
    }

3598
    aio_context = bdrv_get_aio_context(bs);
3599 3600
    aio_context_acquire(aio_context);

3601
    target_bs = bdrv_lookup_bs(backup->target, backup->target, errp);
3602
    if (!target_bs) {
M
Max Reitz 已提交
3603 3604
        goto out;
    }
3605

3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616
    if (bdrv_get_aio_context(target_bs) != aio_context) {
        if (!bdrv_has_blk(target_bs)) {
            /* The target BDS is not attached, we can safely move it to another
             * AioContext. */
            bdrv_set_aio_context(target_bs, aio_context);
        } else {
            error_setg(errp, "Target is attached to a different thread from "
                             "source.");
            goto out;
        }
    }
3617 3618 3619 3620 3621 3622 3623

    if (backup->has_bitmap) {
        bmap = bdrv_find_dirty_bitmap(bs, backup->bitmap);
        if (!bmap) {
            error_setg(errp, "Bitmap '%s' could not be found", backup->bitmap);
            goto out;
        }
3624
        if (bdrv_dirty_bitmap_user_locked(bmap)) {
3625
            error_setg(errp,
3626 3627
                       "Bitmap '%s' is currently in use by another operation"
                       " and cannot be used for backup", backup->bitmap);
3628 3629 3630 3631
            goto out;
        }
    }

3632
    if (!backup->auto_finalize) {
3633
        job_flags |= JOB_MANUAL_FINALIZE;
3634 3635
    }
    if (!backup->auto_dismiss) {
3636
        job_flags |= JOB_MANUAL_DISMISS;
3637
    }
3638
    job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
3639
                            backup->sync, bmap, backup->compress,
3640
                            backup->on_source_error, backup->on_target_error,
3641
                            job_flags, NULL, NULL, txn, &local_err);
3642 3643 3644 3645 3646
    if (local_err != NULL) {
        error_propagate(errp, local_err);
    }
out:
    aio_context_release(aio_context);
3647
    return job;
3648 3649
}

3650 3651
void qmp_blockdev_backup(BlockdevBackup *arg, Error **errp)
{
3652 3653 3654
    BlockJob *job;
    job = do_blockdev_backup(arg, NULL, errp);
    if (job) {
3655
        job_start(&job->job);
3656
    }
3657 3658
}

3659 3660 3661
/* Parameter check and block job starting for drive mirroring.
 * Caller should hold @device and @target's aio context (must be the same).
 **/
3662
static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
3663 3664 3665
                                   BlockDriverState *target,
                                   bool has_replaces, const char *replaces,
                                   enum MirrorSyncMode sync,
3666
                                   BlockMirrorBackingMode backing_mode,
3667 3668 3669 3670 3671 3672 3673 3674
                                   bool has_speed, int64_t speed,
                                   bool has_granularity, uint32_t granularity,
                                   bool has_buf_size, int64_t buf_size,
                                   bool has_on_source_error,
                                   BlockdevOnError on_source_error,
                                   bool has_on_target_error,
                                   BlockdevOnError on_target_error,
                                   bool has_unmap, bool unmap,
3675 3676
                                   bool has_filter_node_name,
                                   const char *filter_node_name,
3677
                                   bool has_copy_mode, MirrorCopyMode copy_mode,
3678 3679
                                   bool has_auto_finalize, bool auto_finalize,
                                   bool has_auto_dismiss, bool auto_dismiss,
3680
                                   Error **errp)
3681
{
3682
    int job_flags = JOB_DEFAULT;
3683 3684 3685 3686

    if (!has_speed) {
        speed = 0;
    }
3687 3688 3689 3690 3691 3692
    if (!has_on_source_error) {
        on_source_error = BLOCKDEV_ON_ERROR_REPORT;
    }
    if (!has_on_target_error) {
        on_target_error = BLOCKDEV_ON_ERROR_REPORT;
    }
3693 3694 3695
    if (!has_granularity) {
        granularity = 0;
    }
3696
    if (!has_buf_size) {
W
Wen Congyang 已提交
3697
        buf_size = 0;
3698
    }
3699 3700 3701
    if (!has_unmap) {
        unmap = true;
    }
3702 3703 3704
    if (!has_filter_node_name) {
        filter_node_name = NULL;
    }
3705 3706 3707
    if (!has_copy_mode) {
        copy_mode = MIRROR_COPY_MODE_BACKGROUND;
    }
3708 3709 3710 3711 3712 3713
    if (has_auto_finalize && !auto_finalize) {
        job_flags |= JOB_MANUAL_FINALIZE;
    }
    if (has_auto_dismiss && !auto_dismiss) {
        job_flags |= JOB_MANUAL_DISMISS;
    }
3714

3715
    if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) {
3716 3717
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
                   "a value in range [512B, 64MB]");
3718 3719 3720
        return;
    }
    if (granularity & (granularity - 1)) {
3721 3722
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
                   "power of 2");
3723 3724
        return;
    }
3725

3726 3727 3728
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) {
        return;
    }
3729 3730 3731
    if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_MIRROR_TARGET, errp)) {
        return;
    }
3732 3733 3734 3735 3736 3737 3738 3739

    if (!bs->backing && sync == MIRROR_SYNC_MODE_TOP) {
        sync = MIRROR_SYNC_MODE_FULL;
    }

    /* pass the node name to replace to mirror start since it's loose coupling
     * and will allow to check whether the node still exist at mirror completion
     */
3740
    mirror_start(job_id, bs, target,
3741
                 has_replaces ? replaces : NULL, job_flags,
3742
                 speed, granularity, buf_size, sync, backing_mode,
3743
                 on_source_error, on_target_error, unmap, filter_node_name,
3744
                 copy_mode, errp);
3745 3746
}

3747
void qmp_drive_mirror(DriveMirror *arg, Error **errp)
3748 3749 3750 3751
{
    BlockDriverState *bs;
    BlockDriverState *source, *target_bs;
    AioContext *aio_context;
3752
    BlockMirrorBackingMode backing_mode;
3753 3754 3755 3756
    Error *local_err = NULL;
    QDict *options = NULL;
    int flags;
    int64_t size;
3757
    const char *format = arg->format;
3758

3759 3760
    bs = qmp_get_root_bs(arg->device, errp);
    if (!bs) {
3761 3762 3763
        return;
    }

3764 3765 3766 3767 3768
    /* Early check to avoid creating target */
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) {
        return;
    }

3769
    aio_context = bdrv_get_aio_context(bs);
3770 3771
    aio_context_acquire(aio_context);

3772 3773
    if (!arg->has_mode) {
        arg->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
3774
    }
3775

3776 3777 3778
    if (!arg->has_format) {
        format = (arg->mode == NEW_IMAGE_MODE_EXISTING
                  ? NULL : bs->drv->format_name);
3779 3780
    }

3781
    flags = bs->open_flags | BDRV_O_RDWR;
3782
    source = backing_bs(bs);
3783 3784
    if (!source && arg->sync == MIRROR_SYNC_MODE_TOP) {
        arg->sync = MIRROR_SYNC_MODE_FULL;
3785
    }
3786
    if (arg->sync == MIRROR_SYNC_MODE_NONE) {
3787 3788
        source = bs;
    }
3789

3790 3791 3792
    size = bdrv_getlength(bs);
    if (size < 0) {
        error_setg_errno(errp, -size, "bdrv_getlength failed");
3793
        goto out;
3794 3795
    }

3796
    if (arg->has_replaces) {
3797
        BlockDriverState *to_replace_bs;
3798 3799
        AioContext *replace_aio_context;
        int64_t replace_size;
3800

3801
        if (!arg->has_node_name) {
3802 3803
            error_setg(errp, "a node-name must be provided when replacing a"
                             " named node of the graph");
3804
            goto out;
3805 3806
        }

3807
        to_replace_bs = check_to_replace_node(bs, arg->replaces, &local_err);
3808 3809 3810

        if (!to_replace_bs) {
            error_propagate(errp, local_err);
3811
            goto out;
3812 3813
        }

3814 3815 3816 3817 3818 3819
        replace_aio_context = bdrv_get_aio_context(to_replace_bs);
        aio_context_acquire(replace_aio_context);
        replace_size = bdrv_getlength(to_replace_bs);
        aio_context_release(replace_aio_context);

        if (size != replace_size) {
3820 3821
            error_setg(errp, "cannot replace image with a mirror image of "
                             "different size");
3822
            goto out;
3823 3824 3825
        }
    }

3826
    if (arg->mode == NEW_IMAGE_MODE_ABSOLUTE_PATHS) {
3827 3828 3829 3830 3831
        backing_mode = MIRROR_SOURCE_BACKING_CHAIN;
    } else {
        backing_mode = MIRROR_OPEN_BACKING_CHAIN;
    }

3832 3833 3834
    /* Don't open backing image in create() */
    flags |= BDRV_O_NO_BACKING;

3835 3836
    if ((arg->sync == MIRROR_SYNC_MODE_FULL || !source)
        && arg->mode != NEW_IMAGE_MODE_EXISTING)
3837
    {
3838
        /* create new image w/o backing file */
3839
        assert(format);
3840
        bdrv_img_create(arg->target, format,
3841
                        NULL, NULL, NULL, size, flags, false, &local_err);
3842
    } else {
3843
        switch (arg->mode) {
3844 3845 3846 3847
        case NEW_IMAGE_MODE_EXISTING:
            break;
        case NEW_IMAGE_MODE_ABSOLUTE_PATHS:
            /* create new image with backing file */
3848
            bdrv_img_create(arg->target, format,
3849 3850
                            source->filename,
                            source->drv->format_name,
3851
                            NULL, size, flags, false, &local_err);
3852 3853 3854 3855 3856 3857
            break;
        default:
            abort();
        }
    }

3858
    if (local_err) {
3859
        error_propagate(errp, local_err);
3860
        goto out;
3861 3862
    }

3863
    options = qdict_new();
3864
    if (arg->has_node_name) {
3865
        qdict_put_str(options, "node-name", arg->node_name);
3866
    }
3867
    if (format) {
3868
        qdict_put_str(options, "driver", format);
3869
    }
3870

3871 3872 3873
    /* Mirroring takes care of copy-on-write using the source's backing
     * file.
     */
3874
    target_bs = bdrv_open(arg->target, NULL, options, flags, errp);
3875
    if (!target_bs) {
3876
        goto out;
3877 3878
    }

3879 3880
    bdrv_set_aio_context(target_bs, aio_context);

3881 3882 3883 3884 3885 3886 3887 3888
    blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs,
                           arg->has_replaces, arg->replaces, arg->sync,
                           backing_mode, arg->has_speed, arg->speed,
                           arg->has_granularity, arg->granularity,
                           arg->has_buf_size, arg->buf_size,
                           arg->has_on_source_error, arg->on_source_error,
                           arg->has_on_target_error, arg->on_target_error,
                           arg->has_unmap, arg->unmap,
3889
                           false, NULL,
3890
                           arg->has_copy_mode, arg->copy_mode,
3891 3892
                           arg->has_auto_finalize, arg->auto_finalize,
                           arg->has_auto_dismiss, arg->auto_dismiss,
3893
                           &local_err);
3894
    bdrv_unref(target_bs);
3895
    error_propagate(errp, local_err);
3896 3897
out:
    aio_context_release(aio_context);
3898 3899
}

3900 3901
void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
                         const char *device, const char *target,
3902 3903 3904 3905 3906 3907 3908 3909 3910
                         bool has_replaces, const char *replaces,
                         MirrorSyncMode sync,
                         bool has_speed, int64_t speed,
                         bool has_granularity, uint32_t granularity,
                         bool has_buf_size, int64_t buf_size,
                         bool has_on_source_error,
                         BlockdevOnError on_source_error,
                         bool has_on_target_error,
                         BlockdevOnError on_target_error,
3911 3912
                         bool has_filter_node_name,
                         const char *filter_node_name,
3913
                         bool has_copy_mode, MirrorCopyMode copy_mode,
3914 3915
                         bool has_auto_finalize, bool auto_finalize,
                         bool has_auto_dismiss, bool auto_dismiss,
3916 3917 3918 3919 3920
                         Error **errp)
{
    BlockDriverState *bs;
    BlockDriverState *target_bs;
    AioContext *aio_context;
3921
    BlockMirrorBackingMode backing_mode = MIRROR_LEAVE_BACKING_CHAIN;
3922 3923
    Error *local_err = NULL;

3924
    bs = qmp_get_root_bs(device, errp);
3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938
    if (!bs) {
        return;
    }

    target_bs = bdrv_lookup_bs(target, target, errp);
    if (!target_bs) {
        return;
    }

    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

    bdrv_set_aio_context(target_bs, aio_context);

3939
    blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs,
3940
                           has_replaces, replaces, sync, backing_mode,
3941 3942 3943 3944 3945 3946
                           has_speed, speed,
                           has_granularity, granularity,
                           has_buf_size, buf_size,
                           has_on_source_error, on_source_error,
                           has_on_target_error, on_target_error,
                           true, true,
3947
                           has_filter_node_name, filter_node_name,
3948
                           has_copy_mode, copy_mode,
3949 3950
                           has_auto_finalize, auto_finalize,
                           has_auto_dismiss, auto_dismiss,
3951
                           &local_err);
3952
    error_propagate(errp, local_err);
3953 3954 3955 3956

    aio_context_release(aio_context);
}

3957 3958
/* Get a block job using its ID and acquire its AioContext */
static BlockJob *find_block_job(const char *id, AioContext **aio_context,
3959
                                Error **errp)
3960
{
3961
    BlockJob *job;
3962

3963
    assert(id != NULL);
M
Max Reitz 已提交
3964

3965
    *aio_context = NULL;
3966

3967
    job = block_job_get(id);
M
Max Reitz 已提交
3968

3969 3970 3971 3972
    if (!job) {
        error_set(errp, ERROR_CLASS_DEVICE_NOT_ACTIVE,
                  "Block job '%s' not found", id);
        return NULL;
3973
    }
3974

3975 3976
    *aio_context = blk_get_aio_context(job->blk);
    aio_context_acquire(*aio_context);
3977

3978
    return job;
3979 3980
}

3981
void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
3982
{
3983
    AioContext *aio_context;
3984
    BlockJob *job = find_block_job(device, &aio_context, errp);
3985 3986 3987 3988 3989

    if (!job) {
        return;
    }

3990
    block_job_set_speed(job, speed, errp);
3991
    aio_context_release(aio_context);
3992
}
3993

3994 3995
void qmp_block_job_cancel(const char *device,
                          bool has_force, bool force, Error **errp)
3996
{
3997
    AioContext *aio_context;
3998
    BlockJob *job = find_block_job(device, &aio_context, errp);
3999

4000 4001 4002
    if (!job) {
        return;
    }
4003 4004 4005 4006 4007

    if (!has_force) {
        force = false;
    }

4008
    if (job_user_paused(&job->job) && !force) {
4009 4010
        error_setg(errp, "The block job for device '%s' is currently paused",
                   device);
4011
        goto out;
4012
    }
4013 4014

    trace_qmp_block_job_cancel(job);
4015
    job_user_cancel(&job->job, force, errp);
4016 4017
out:
    aio_context_release(aio_context);
4018
}
4019

4020 4021
void qmp_block_job_pause(const char *device, Error **errp)
{
4022
    AioContext *aio_context;
4023
    BlockJob *job = find_block_job(device, &aio_context, errp);
4024

4025
    if (!job) {
4026 4027 4028 4029
        return;
    }

    trace_qmp_block_job_pause(job);
4030
    job_user_pause(&job->job, errp);
4031
    aio_context_release(aio_context);
4032 4033 4034 4035
}

void qmp_block_job_resume(const char *device, Error **errp)
{
4036
    AioContext *aio_context;
4037
    BlockJob *job = find_block_job(device, &aio_context, errp);
4038

4039
    if (!job) {
4040 4041 4042 4043
        return;
    }

    trace_qmp_block_job_resume(job);
4044
    job_user_resume(&job->job, errp);
4045
    aio_context_release(aio_context);
4046 4047
}

4048 4049
void qmp_block_job_complete(const char *device, Error **errp)
{
4050
    AioContext *aio_context;
4051
    BlockJob *job = find_block_job(device, &aio_context, errp);
4052 4053 4054 4055 4056 4057

    if (!job) {
        return;
    }

    trace_qmp_block_job_complete(job);
4058
    job_complete(&job->job, errp);
4059
    aio_context_release(aio_context);
4060 4061
}

4062 4063 4064 4065 4066 4067 4068 4069 4070 4071
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);
4072
    job_finalize(&job->job, errp);
4073 4074 4075
    aio_context_release(aio_context);
}

4076 4077 4078
void qmp_block_job_dismiss(const char *id, Error **errp)
{
    AioContext *aio_context;
K
Kevin Wolf 已提交
4079 4080
    BlockJob *bjob = find_block_job(id, &aio_context, errp);
    Job *job;
4081

K
Kevin Wolf 已提交
4082
    if (!bjob) {
4083 4084 4085
        return;
    }

K
Kevin Wolf 已提交
4086 4087 4088
    trace_qmp_block_job_dismiss(bjob);
    job = &bjob->job;
    job_dismiss(&job, errp);
4089 4090 4091
    aio_context_release(aio_context);
}

4092 4093 4094 4095 4096 4097
void qmp_change_backing_file(const char *device,
                             const char *image_node_name,
                             const char *backing_file,
                             Error **errp)
{
    BlockDriverState *bs = NULL;
4098
    AioContext *aio_context;
4099 4100 4101 4102 4103 4104
    BlockDriverState *image_bs = NULL;
    Error *local_err = NULL;
    bool ro;
    int open_flags;
    int ret;

4105 4106
    bs = qmp_get_root_bs(device, errp);
    if (!bs) {
4107 4108 4109
        return;
    }

4110
    aio_context = bdrv_get_aio_context(bs);
4111 4112
    aio_context_acquire(aio_context);

4113 4114 4115
    image_bs = bdrv_lookup_bs(NULL, image_node_name, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
4116
        goto out;
4117 4118 4119 4120
    }

    if (!image_bs) {
        error_setg(errp, "image file not found");
4121
        goto out;
4122 4123 4124 4125 4126
    }

    if (bdrv_find_base(image_bs) == image_bs) {
        error_setg(errp, "not allowing backing file change on an image "
                         "without a backing file");
4127
        goto out;
4128 4129 4130 4131 4132
    }

    /* even though we are not necessarily operating on bs, we need it to
     * determine if block ops are currently prohibited on the chain */
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_CHANGE, errp)) {
4133
        goto out;
4134 4135 4136 4137 4138 4139
    }

    /* final sanity check */
    if (!bdrv_chain_contains(bs, image_bs)) {
        error_setg(errp, "'%s' and image file are not in the same chain",
                   device);
4140
        goto out;
4141 4142 4143 4144 4145 4146 4147 4148 4149 4150
    }

    /* if not r/w, reopen to make r/w */
    open_flags = image_bs->open_flags;
    ro = bdrv_is_read_only(image_bs);

    if (ro) {
        bdrv_reopen(image_bs, open_flags | BDRV_O_RDWR, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
4151
            goto out;
4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166
        }
    }

    ret = bdrv_change_backing_file(image_bs, backing_file,
                               image_bs->drv ? image_bs->drv->format_name : "");

    if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not change backing file to '%s'",
                         backing_file);
        /* don't exit here, so we can try to restore open flags if
         * appropriate */
    }

    if (ro) {
        bdrv_reopen(image_bs, open_flags, &local_err);
4167
        error_propagate(errp, local_err);
4168
    }
4169 4170 4171

out:
    aio_context_release(aio_context);
4172 4173
}

4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187
void hmp_drive_add_node(Monitor *mon, const char *optstr)
{
    QemuOpts *opts;
    QDict *qdict;
    Error *local_err = NULL;

    opts = qemu_opts_parse_noisily(&qemu_drive_opts, optstr, false);
    if (!opts) {
        return;
    }

    qdict = qemu_opts_to_qdict(opts, NULL);

    if (!qdict_get_try_str(qdict, "node-name")) {
4188
        qobject_unref(qdict);
4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204
        error_report("'node-name' needs to be specified");
        goto out;
    }

    BlockDriverState *bs = bds_tree_init(qdict, &local_err);
    if (!bs) {
        error_report_err(local_err);
        goto out;
    }

    QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list);

out:
    qemu_opts_del(opts);
}

4205 4206
void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
{
4207
    BlockDriverState *bs;
4208
    QObject *obj;
4209
    Visitor *v = qobject_output_visitor_new(&obj);
4210 4211 4212
    QDict *qdict;
    Error *local_err = NULL;

4213
    visit_type_BlockdevOptions(v, NULL, &options, &local_err);
4214
    if (local_err) {
4215 4216 4217 4218
        error_propagate(errp, local_err);
        goto fail;
    }

4219
    visit_complete(v, &obj);
4220
    qdict = qobject_to(QDict, obj);
4221 4222 4223

    qdict_flatten(qdict);

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

4229 4230 4231
    bs = bds_tree_init(qdict, errp);
    if (!bs) {
        goto fail;
4232 4233
    }

4234 4235
    QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list);

4236
fail:
4237
    visit_free(v);
4238 4239
}

4240
void qmp_blockdev_del(const char *node_name, Error **errp)
4241 4242 4243 4244
{
    AioContext *aio_context;
    BlockDriverState *bs;

4245 4246 4247
    bs = bdrv_find_node(node_name);
    if (!bs) {
        error_setg(errp, "Cannot find node %s", node_name);
4248 4249
        return;
    }
4250 4251 4252
    if (bdrv_has_blk(bs)) {
        error_setg(errp, "Node %s is in use", node_name);
        return;
4253
    }
4254
    aio_context = bdrv_get_aio_context(bs);
4255 4256
    aio_context_acquire(aio_context);

4257 4258 4259
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, errp)) {
        goto out;
    }
4260

4261 4262 4263 4264
    if (!bs->monitor_list.tqe_prev) {
        error_setg(errp, "Node %s is not owned by the monitor",
                   bs->node_name);
        goto out;
4265 4266
    }

4267 4268 4269 4270
    if (bs->refcnt > 1) {
        error_setg(errp, "Block device %s is in use",
                   bdrv_get_device_or_node_name(bs));
        goto out;
4271 4272
    }

4273 4274 4275
    QTAILQ_REMOVE(&monitor_bdrv_states, bs, monitor_list);
    bdrv_unref(bs);

4276 4277 4278 4279
out:
    aio_context_release(aio_context);
}

4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334
static BdrvChild *bdrv_find_child(BlockDriverState *parent_bs,
                                  const char *child_name)
{
    BdrvChild *child;

    QLIST_FOREACH(child, &parent_bs->children, next) {
        if (strcmp(child->name, child_name) == 0) {
            return child;
        }
    }

    return NULL;
}

void qmp_x_blockdev_change(const char *parent, bool has_child,
                           const char *child, bool has_node,
                           const char *node, Error **errp)
{
    BlockDriverState *parent_bs, *new_bs = NULL;
    BdrvChild *p_child;

    parent_bs = bdrv_lookup_bs(parent, parent, errp);
    if (!parent_bs) {
        return;
    }

    if (has_child == has_node) {
        if (has_child) {
            error_setg(errp, "The parameters child and node are in conflict");
        } else {
            error_setg(errp, "Either child or node must be specified");
        }
        return;
    }

    if (has_child) {
        p_child = bdrv_find_child(parent_bs, child);
        if (!p_child) {
            error_setg(errp, "Node '%s' does not have child '%s'",
                       parent, child);
            return;
        }
        bdrv_del_child(parent_bs, p_child, errp);
    }

    if (has_node) {
        new_bs = bdrv_find_node(node);
        if (!new_bs) {
            error_setg(errp, "Node '%s' not found", node);
            return;
        }
        bdrv_add_child(parent_bs, new_bs, errp);
    }
}

4335
BlockJobInfoList *qmp_query_block_jobs(Error **errp)
4336
{
4337
    BlockJobInfoList *head = NULL, **p_next = &head;
4338
    BlockJob *job;
4339

4340
    for (job = block_job_next(NULL); job; job = block_job_next(job)) {
4341 4342
        BlockJobInfoList *elem;
        AioContext *aio_context;
4343

4344 4345 4346 4347 4348
        if (block_job_is_internal(job)) {
            continue;
        }
        elem = g_new0(BlockJobInfoList, 1);
        aio_context = blk_get_aio_context(job->blk);
4349
        aio_context_acquire(aio_context);
4350
        elem->value = block_job_query(job, errp);
4351
        aio_context_release(aio_context);
4352 4353 4354 4355 4356
        if (!elem->value) {
            g_free(elem);
            qapi_free_BlockJobInfoList(head);
            return NULL;
        }
4357 4358
        *p_next = elem;
        p_next = &elem->next;
4359 4360
    }

4361
    return head;
4362
}
4363

4364
void qmp_x_blockdev_set_iothread(const char *node_name, StrOrNull *iothread,
4365
                                 bool has_force, bool force, Error **errp)
4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376
{
    AioContext *old_context;
    AioContext *new_context;
    BlockDriverState *bs;

    bs = bdrv_find_node(node_name);
    if (!bs) {
        error_setg(errp, "Cannot find node %s", node_name);
        return;
    }

4377 4378 4379 4380 4381
    /* Protects against accidents. */
    if (!(has_force && force) && bdrv_has_blk(bs)) {
        error_setg(errp, "Node %s is associated with a BlockBackend and could "
                         "be in use (use force=true to override this check)",
                         node_name);
4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404
        return;
    }

    if (iothread->type == QTYPE_QSTRING) {
        IOThread *obj = iothread_by_id(iothread->u.s);
        if (!obj) {
            error_setg(errp, "Cannot find iothread %s", iothread->u.s);
            return;
        }

        new_context = iothread_get_aio_context(obj);
    } else {
        new_context = qemu_get_aio_context();
    }

    old_context = bdrv_get_aio_context(bs);
    aio_context_acquire(old_context);

    bdrv_set_aio_context(bs, new_context);

    aio_context_release(old_context);
}

4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
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);
    }
}

4448
QemuOptsList qemu_common_drive_opts = {
4449
    .name = "drive",
4450
    .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),
4451 4452 4453 4454 4455 4456 4457 4458 4459
    .desc = {
        {
            .name = "snapshot",
            .type = QEMU_OPT_BOOL,
            .help = "enable/disable snapshot mode",
        },{
            .name = "aio",
            .type = QEMU_OPT_STRING,
            .help = "host AIO implementation (threads, native)",
4460 4461 4462 4463
        },{
            .name = BDRV_OPT_CACHE_WB,
            .type = QEMU_OPT_BOOL,
            .help = "Enable writeback mode",
4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476
        },{
            .name = "format",
            .type = QEMU_OPT_STRING,
            .help = "disk format (raw, qcow2, ...)",
        },{
            .name = "rerror",
            .type = QEMU_OPT_STRING,
            .help = "read error action",
        },{
            .name = "werror",
            .type = QEMU_OPT_STRING,
            .help = "write error action",
        },{
4477
            .name = BDRV_OPT_READ_ONLY,
4478 4479
            .type = QEMU_OPT_BOOL,
            .help = "open drive file as read-only",
4480 4481 4482 4483 4484
        },

        THROTTLE_OPTS,

        {
4485 4486 4487
            .name = "throttling.group",
            .type = QEMU_OPT_STRING,
            .help = "name of the block throttling group",
4488 4489 4490 4491
        },{
            .name = "copy-on-read",
            .type = QEMU_OPT_BOOL,
            .help = "copy read data from backing file into image file",
4492 4493 4494 4495
        },{
            .name = "detect-zeroes",
            .type = QEMU_OPT_STRING,
            .help = "try to optimize zero writes (off, on, unmap)",
4496 4497 4498 4499 4500 4501 4502 4503 4504 4505
        },{
            .name = "stats-account-invalid",
            .type = QEMU_OPT_BOOL,
            .help = "whether to account for invalid I/O operations "
                    "in the statistics",
        },{
            .name = "stats-account-failed",
            .type = QEMU_OPT_BOOL,
            .help = "whether to account for failed I/O operations "
                    "in the statistics",
4506 4507 4508 4509
        },
        { /* end of list */ }
    },
};
4510 4511 4512 4513 4514

QemuOptsList qemu_drive_opts = {
    .name = "drive",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
    .desc = {
4515 4516 4517 4518
        /*
         * no elements => accept any params
         * validation will happen later
         */
4519 4520 4521
        { /* end of list */ }
    },
};
反馈
建议
客服 返回
顶部