blockdev.c 94.1 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
 */

M
Markus Armbruster 已提交
33
#include "sysemu/block-backend.h"
34
#include "sysemu/blockdev.h"
P
Paolo Bonzini 已提交
35
#include "hw/block/block.h"
36
#include "block/blockjob.h"
37
#include "block/throttle-groups.h"
38
#include "monitor/monitor.h"
39
#include "qemu/error-report.h"
40 41
#include "qemu/option.h"
#include "qemu/config-file.h"
42
#include "qapi/qmp/types.h"
K
Kevin Wolf 已提交
43
#include "qapi-visit.h"
44
#include "qapi/qmp/qerror.h"
K
Kevin Wolf 已提交
45
#include "qapi/qmp-output-visitor.h"
46
#include "qapi/util.h"
47
#include "sysemu/sysemu.h"
48
#include "block/block_int.h"
L
Luiz Capitulino 已提交
49
#include "qmp-commands.h"
S
Stefan Hajnoczi 已提交
50
#include "trace.h"
51
#include "sysemu/arch_init.h"
52

53 54 55 56 57 58 59 60 61 62 63 64
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",
};

65
static int if_max_devs[IF_COUNT] = {
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
    /*
     * Do not change these numbers!  They govern how drive option
     * index maps to unit and bus.  That mapping is ABI.
     *
     * All controllers used to imlement if=T drives need to support
     * 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,
82 83
};

84 85 86 87 88 89
/**
 * Boards may call this to offer board-by-board overrides
 * of the default, global values.
 */
void override_max_devs(BlockInterfaceType type, int max_devs)
{
90
    BlockBackend *blk;
91 92 93 94 95 96
    DriveInfo *dinfo;

    if (max_devs <= 0) {
        return;
    }

97 98
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
        dinfo = blk_legacy_dinfo(blk);
99 100 101 102 103 104 105 106 107 108 109
        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;
}

110 111 112 113 114 115 116
/*
 * 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.
 */
117
void blockdev_mark_auto_del(BlockBackend *blk)
118
{
119
    DriveInfo *dinfo = blk_legacy_dinfo(blk);
120
    BlockDriverState *bs = blk_bs(blk);
121
    AioContext *aio_context;
122

123
    if (!dinfo) {
124 125 126
        return;
    }

127 128 129
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

130 131 132
    if (bs->job) {
        block_job_cancel(bs->job);
    }
133 134 135

    aio_context_release(aio_context);

136
    dinfo->auto_del = 1;
137 138
}

139
void blockdev_auto_del(BlockBackend *blk)
140
{
141
    DriveInfo *dinfo = blk_legacy_dinfo(blk);
142

143
    if (dinfo && dinfo->auto_del) {
144
        blk_unref(blk);
145 146 147
    }
}

148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
/**
 * 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;
}

165 166 167 168 169 170 171 172 173 174 175 176
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;
}

177 178
QemuOpts *drive_def(const char *optstr)
{
179
    return qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr, false);
180 181 182
}

QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
183
                    const char *optstr)
184 185 186
{
    QemuOpts *opts;

187
    opts = drive_def(optstr);
188 189 190
    if (!opts) {
        return NULL;
    }
191
    if (type != IF_DEFAULT) {
192
        qemu_opt_set(opts, "if", if_name[type], &error_abort);
193 194
    }
    if (index >= 0) {
195
        qemu_opt_set_number(opts, "index", index, &error_abort);
196
    }
197
    if (file)
198
        qemu_opt_set(opts, "file", file, &error_abort);
199 200 201 202 203
    return opts;
}

DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
{
204
    BlockBackend *blk;
205 206
    DriveInfo *dinfo;

207 208 209 210
    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) {
211
            return dinfo;
212
        }
213 214 215 216 217
    }

    return NULL;
}

J
John Snow 已提交
218 219
bool drive_check_orphaned(void)
{
220
    BlockBackend *blk;
J
John Snow 已提交
221 222 223
    DriveInfo *dinfo;
    bool rs = false;

224 225
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
        dinfo = blk_legacy_dinfo(blk);
J
John Snow 已提交
226 227
        /* If dinfo->bdrv->dev is NULL, it has no device attached. */
        /* Unless this is a default drive, this may be an oversight. */
228
        if (!blk_get_attached_dev(blk) && !dinfo->is_default &&
J
John Snow 已提交
229 230 231
            dinfo->type != IF_NONE) {
            fprintf(stderr, "Warning: Orphaned drive without device: "
                    "id=%s,file=%s,if=%s,bus=%d,unit=%d\n",
232
                    blk_name(blk), blk_bs(blk)->filename, if_name[dinfo->type],
J
John Snow 已提交
233 234 235 236 237 238 239 240
                    dinfo->bus, dinfo->unit);
            rs = true;
        }
    }

    return rs;
}

241 242 243 244 245 246 247
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));
}

248 249 250
int drive_get_max_bus(BlockInterfaceType type)
{
    int max_bus;
251
    BlockBackend *blk;
252 253 254
    DriveInfo *dinfo;

    max_bus = -1;
255 256 257
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
        dinfo = blk_legacy_dinfo(blk);
        if (dinfo && dinfo->type == type && dinfo->bus > max_bus) {
258
            max_bus = dinfo->bus;
259
        }
260 261 262 263
    }
    return max_bus;
}

264 265 266 267 268 269 270 271 272 273
/* 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]++);
}

274 275
static void bdrv_format_print(void *opaque, const char *name)
{
276
    error_printf(" %s", name);
277 278
}

279 280
typedef struct {
    QEMUBH *bh;
F
Fam Zheng 已提交
281 282
    BlockDriverState *bs;
} BDRVPutRefBH;
283

F
Fam Zheng 已提交
284
static void bdrv_put_ref_bh(void *opaque)
285
{
F
Fam Zheng 已提交
286
    BDRVPutRefBH *s = opaque;
287

F
Fam Zheng 已提交
288
    bdrv_unref(s->bs);
289 290 291 292 293
    qemu_bh_delete(s->bh);
    g_free(s);
}

/*
F
Fam Zheng 已提交
294
 * Release a BDS reference in a BH
295
 *
F
Fam Zheng 已提交
296 297 298
 * It is not safe to use bdrv_unref() from a callback function when the callers
 * still need the BlockDriverState.  In such cases we schedule a BH to release
 * the reference.
299
 */
F
Fam Zheng 已提交
300
static void bdrv_put_ref_bh_schedule(BlockDriverState *bs)
301
{
F
Fam Zheng 已提交
302
    BDRVPutRefBH *s;
303

F
Fam Zheng 已提交
304 305 306
    s = g_new(BDRVPutRefBH, 1);
    s->bh = qemu_bh_new(bdrv_put_ref_bh, s);
    s->bs = bs;
307 308 309
    qemu_bh_schedule(s->bh);
}

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

327
static bool check_throttle_config(ThrottleConfig *cfg, Error **errp)
328
{
329 330 331
    if (throttle_conflicting(cfg)) {
        error_setg(errp, "bps/iops/max total values and read/write values"
                         " cannot be used at the same time");
332 333 334
        return false;
    }

335 336
    if (!throttle_is_valid(cfg)) {
        error_setg(errp, "bps/iops/maxs values must be 0 or greater");
337 338 339
        return false;
    }

340 341 342 343 344 345
    if (throttle_max_is_missing_limit(cfg)) {
        error_setg(errp, "bps_max/iops_max require corresponding"
                         " bps/iops values");
        return false;
    }

346 347 348
    return true;
}

349 350
typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType;

351
/* Takes the ownership of bs_opts */
352 353
static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
                                   Error **errp)
354 355 356 357 358
{
    const char *buf;
    int ro = 0;
    int bdrv_flags = 0;
    int on_read_error, on_write_error;
M
Markus Armbruster 已提交
359
    BlockBackend *blk;
360
    BlockDriverState *bs;
361
    ThrottleConfig cfg;
362
    int snapshot = 0;
363
    bool copy_on_read;
364
    Error *error = NULL;
365 366
    QemuOpts *opts;
    const char *id;
367
    bool has_driver_specific_opts;
368
    BlockdevDetectZeroesOptions detect_zeroes;
369
    const char *throttling_group;
370

371 372 373
    /* 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");
374
    opts = qemu_opts_create(&qemu_common_drive_opts, id, 1, &error);
375
    if (error) {
376
        error_propagate(errp, error);
377
        goto err_no_opts;
378 379 380
    }

    qemu_opts_absorb_qdict(opts, bs_opts, &error);
381
    if (error) {
382
        error_propagate(errp, error);
383
        goto early_err;
384 385 386 387 388 389
    }

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

390 391
    has_driver_specific_opts = !!qdict_size(bs_opts);

392 393
    /* extract parameters */
    snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
394
    ro = qemu_opt_get_bool(opts, "read-only", 0);
395
    copy_on_read = qemu_opt_get_bool(opts, "copy-on-read", false);
396

397 398
    if ((buf = qemu_opt_get(opts, "discard")) != NULL) {
        if (bdrv_parse_discard_flags(buf, &bdrv_flags) != 0) {
399
            error_setg(errp, "invalid discard option");
400
            goto early_err;
401 402 403
        }
    }

404
    if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, true)) {
K
Kevin Wolf 已提交
405 406
        bdrv_flags |= BDRV_O_CACHE_WB;
    }
407
    if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
K
Kevin Wolf 已提交
408 409
        bdrv_flags |= BDRV_O_NOCACHE;
    }
410
    if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
K
Kevin Wolf 已提交
411
        bdrv_flags |= BDRV_O_NO_FLUSH;
412 413 414 415 416 417 418 419 420
    }

#ifdef CONFIG_LINUX_AIO
    if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
        if (!strcmp(buf, "native")) {
            bdrv_flags |= BDRV_O_NATIVE_AIO;
        } else if (!strcmp(buf, "threads")) {
            /* this is the default */
        } else {
421
           error_setg(errp, "invalid aio option");
422
           goto early_err;
423 424 425 426 427
        }
    }
#endif

    if ((buf = qemu_opt_get(opts, "format")) != NULL) {
428 429 430 431
        if (is_help_option(buf)) {
            error_printf("Supported formats:");
            bdrv_iterate_format(bdrv_format_print, NULL);
            error_printf("\n");
432
            goto early_err;
433
        }
434

435 436
        if (qdict_haskey(bs_opts, "driver")) {
            error_setg(errp, "Cannot specify both 'driver' and 'format'");
437
            goto early_err;
438
        }
439
        qdict_put(bs_opts, "driver", qstring_from_str(buf));
440 441
    }

442
    /* disk I/O throttling */
443 444
    memset(&cfg, 0, sizeof(cfg));
    cfg.buckets[THROTTLE_BPS_TOTAL].avg =
445
        qemu_opt_get_number(opts, "throttling.bps-total", 0);
446
    cfg.buckets[THROTTLE_BPS_READ].avg  =
447
        qemu_opt_get_number(opts, "throttling.bps-read", 0);
448
    cfg.buckets[THROTTLE_BPS_WRITE].avg =
449
        qemu_opt_get_number(opts, "throttling.bps-write", 0);
450
    cfg.buckets[THROTTLE_OPS_TOTAL].avg =
451
        qemu_opt_get_number(opts, "throttling.iops-total", 0);
452
    cfg.buckets[THROTTLE_OPS_READ].avg =
453
        qemu_opt_get_number(opts, "throttling.iops-read", 0);
454
    cfg.buckets[THROTTLE_OPS_WRITE].avg =
455
        qemu_opt_get_number(opts, "throttling.iops-write", 0);
456

457 458 459 460 461 462 463 464 465 466 467 468
    cfg.buckets[THROTTLE_BPS_TOTAL].max =
        qemu_opt_get_number(opts, "throttling.bps-total-max", 0);
    cfg.buckets[THROTTLE_BPS_READ].max  =
        qemu_opt_get_number(opts, "throttling.bps-read-max", 0);
    cfg.buckets[THROTTLE_BPS_WRITE].max =
        qemu_opt_get_number(opts, "throttling.bps-write-max", 0);
    cfg.buckets[THROTTLE_OPS_TOTAL].max =
        qemu_opt_get_number(opts, "throttling.iops-total-max", 0);
    cfg.buckets[THROTTLE_OPS_READ].max =
        qemu_opt_get_number(opts, "throttling.iops-read-max", 0);
    cfg.buckets[THROTTLE_OPS_WRITE].max =
        qemu_opt_get_number(opts, "throttling.iops-write-max", 0);
469

470
    cfg.op_size = qemu_opt_get_number(opts, "throttling.iops-size", 0);
471

472 473
    throttling_group = qemu_opt_get(opts, "throttling.group");

474
    if (!check_throttle_config(&cfg, &error)) {
475
        error_propagate(errp, error);
476
        goto early_err;
477 478
    }

479
    on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
480
    if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
481
        on_write_error = parse_block_error_action(buf, 0, &error);
482
        if (error) {
483
            error_propagate(errp, error);
484
            goto early_err;
485 486 487
        }
    }

488
    on_read_error = BLOCKDEV_ON_ERROR_REPORT;
489
    if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
490
        on_read_error = parse_block_error_action(buf, 1, &error);
491
        if (error) {
492
            error_propagate(errp, error);
493
            goto early_err;
494 495 496
        }
    }

497
    detect_zeroes =
498 499 500 501 502
        qapi_enum_parse(BlockdevDetectZeroesOptions_lookup,
                        qemu_opt_get(opts, "detect-zeroes"),
                        BLOCKDEV_DETECT_ZEROES_OPTIONS_MAX,
                        BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
                        &error);
503 504 505 506 507 508 509 510 511 512 513 514
    if (error) {
        error_propagate(errp, error);
        goto early_err;
    }

    if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
        !(bdrv_flags & BDRV_O_UNMAP)) {
        error_setg(errp, "setting detect-zeroes to unmap is not allowed "
                         "without setting discard operation to unmap");
        goto early_err;
    }

515
    /* init */
516 517 518 519 520
    if ((!file || !*file) && !has_driver_specific_opts) {
        blk = blk_new_with_bs(qemu_opts_id(opts), errp);
        if (!blk) {
            goto early_err;
        }
521

522 523 524
        bs = blk_bs(blk);
        bs->open_flags = snapshot ? BDRV_O_SNAPSHOT : 0;
        bs->read_only = ro;
525

526 527 528
        QDECREF(bs_opts);
    } else {
        if (file && !*file) {
529 530
            file = NULL;
        }
531

532 533 534 535 536 537 538 539 540
        if (snapshot) {
            /* always use cache=unsafe with snapshot */
            bdrv_flags &= ~BDRV_O_CACHE_MASK;
            bdrv_flags |= (BDRV_O_SNAPSHOT|BDRV_O_CACHE_WB|BDRV_O_NO_FLUSH);
        }

        if (copy_on_read) {
            bdrv_flags |= BDRV_O_COPY_ON_READ;
        }
541

542 543 544 545 546 547 548 549 550 551 552 553
        if (runstate_check(RUN_STATE_INMIGRATE)) {
            bdrv_flags |= BDRV_O_INCOMING;
        }

        bdrv_flags |= ro ? 0 : BDRV_O_RDWR;

        blk = blk_new_open(qemu_opts_id(opts), file, NULL, bs_opts, bdrv_flags,
                           errp);
        if (!blk) {
            goto err_no_bs_opts;
        }
        bs = blk_bs(blk);
554 555
    }

556
    bs->detect_zeroes = detect_zeroes;
557

558
    bdrv_set_on_error(bs, on_read_error, on_write_error);
559

560 561
    /* disk I/O throttling */
    if (throttle_enabled(&cfg)) {
562 563 564 565
        if (!throttling_group) {
            throttling_group = blk_name(blk);
        }
        bdrv_io_limits_enable(bs, throttling_group);
566
        bdrv_set_io_limits(bs, &cfg);
567 568
    }

569
    if (bdrv_key_required(bs)) {
570
        autostart = 0;
571
    }
572

573
err_no_bs_opts:
574
    qemu_opts_del(opts);
575
    return blk;
576

577 578
early_err:
    qemu_opts_del(opts);
579 580
err_no_opts:
    QDECREF(bs_opts);
581
    return NULL;
582 583
}

584 585
static void qemu_opt_rename(QemuOpts *opts, const char *from, const char *to,
                            Error **errp)
586 587 588 589 590
{
    const char *value;

    value = qemu_opt_get(opts, from);
    if (value) {
591 592 593 594 595
        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;
        }
596 597 598 599
    }

    /* rename all items in opts */
    while ((value = qemu_opt_get(opts, from))) {
600
        qemu_opt_set(opts, to, value, &error_abort);
601 602 603 604
        qemu_opt_unset(opts, from);
    }
}

605 606 607 608 609
QemuOptsList qemu_legacy_drive_opts = {
    .name = "drive",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts.head),
    .desc = {
        {
610 611 612 613 614 615 616 617 618 619 620 621
            .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",
        },{
622 623 624
            .name = "media",
            .type = QEMU_OPT_STRING,
            .help = "media type (disk, cdrom)",
625 626 627 628
        },{
            .name = "if",
            .type = QEMU_OPT_STRING,
            .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
        },{
            .name = "cyls",
            .type = QEMU_OPT_NUMBER,
            .help = "number of cylinders (ide disk geometry)",
        },{
            .name = "heads",
            .type = QEMU_OPT_NUMBER,
            .help = "number of heads (ide disk geometry)",
        },{
            .name = "secs",
            .type = QEMU_OPT_NUMBER,
            .help = "number of sectors (ide disk geometry)",
        },{
            .name = "trans",
            .type = QEMU_OPT_STRING,
            .help = "chs translation (auto, lba, none)",
645 646 647 648
        },{
            .name = "boot",
            .type = QEMU_OPT_BOOL,
            .help = "(deprecated, ignored)",
649 650 651 652
        },{
            .name = "addr",
            .type = QEMU_OPT_STRING,
            .help = "pci address (virtio only)",
653 654 655 656
        },{
            .name = "serial",
            .type = QEMU_OPT_STRING,
            .help = "disk serial number",
M
Max Reitz 已提交
657 658 659 660
        },{
            .name = "file",
            .type = QEMU_OPT_STRING,
            .help = "file name",
661
        },
662 663 664 665 666 667

        /* Options that are passed on, but have special semantics with -drive */
        {
            .name = "read-only",
            .type = QEMU_OPT_BOOL,
            .help = "open drive file as read-only",
668 669 670 671 672 673 674 675
        },{
            .name = "rerror",
            .type = QEMU_OPT_STRING,
            .help = "read error action",
        },{
            .name = "werror",
            .type = QEMU_OPT_STRING,
            .help = "write error action",
676 677 678 679 680 681
        },{
            .name = "copy-on-read",
            .type = QEMU_OPT_BOOL,
            .help = "copy read data from backing file into image file",
        },

682 683 684 685
        { /* end of list */ }
    },
};

686
DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
687
{
K
Kevin Wolf 已提交
688
    const char *value;
689
    BlockBackend *blk;
690
    DriveInfo *dinfo = NULL;
691
    QDict *bs_opts;
692 693
    QemuOpts *legacy_opts;
    DriveMediaType media = MEDIA_DISK;
694
    BlockInterfaceType type;
695
    int cyls, heads, secs, translation;
696
    int max_devs, bus_id, unit_id, index;
697
    const char *devaddr;
698
    const char *werror, *rerror;
F
Fam Zheng 已提交
699 700
    bool read_only = false;
    bool copy_on_read;
701
    const char *serial;
M
Max Reitz 已提交
702
    const char *filename;
703
    Error *local_err = NULL;
704
    int i;
K
Kevin Wolf 已提交
705

706
    /* Change legacy command line options into QMP ones */
707 708 709 710 711 712 713
    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" },
714

715 716 717
        { "bps",            "throttling.bps-total" },
        { "bps_rd",         "throttling.bps-read" },
        { "bps_wr",         "throttling.bps-write" },
718

719 720 721
        { "iops_max",       "throttling.iops-total-max" },
        { "iops_rd_max",    "throttling.iops-read-max" },
        { "iops_wr_max",    "throttling.iops-write-max" },
722

723 724 725
        { "bps_max",        "throttling.bps-total-max" },
        { "bps_rd_max",     "throttling.bps-read-max" },
        { "bps_wr_max",     "throttling.bps-write-max" },
726

727
        { "iops_size",      "throttling.iops-size" },
728

729 730
        { "group",          "throttling.group" },

731 732 733 734
        { "readonly",       "read-only" },
    };

    for (i = 0; i < ARRAY_SIZE(opt_renames); i++) {
735 736 737
        qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to,
                        &local_err);
        if (local_err) {
738
            error_report_err(local_err);
739 740
            return NULL;
        }
741
    }
742

K
Kevin Wolf 已提交
743 744 745 746 747 748 749 750 751 752
    value = qemu_opt_get(all_opts, "cache");
    if (value) {
        int flags = 0;

        if (bdrv_parse_cache_flags(value, &flags) != 0) {
            error_report("invalid cache option");
            return NULL;
        }

        /* Specific options take precedence */
753 754
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_WB)) {
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_WB,
755
                              !!(flags & BDRV_O_CACHE_WB), &error_abort);
K
Kevin Wolf 已提交
756
        }
757 758
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_DIRECT)) {
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_DIRECT,
759
                              !!(flags & BDRV_O_NOCACHE), &error_abort);
K
Kevin Wolf 已提交
760
        }
761 762
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_NO_FLUSH)) {
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_NO_FLUSH,
763
                              !!(flags & BDRV_O_NO_FLUSH), &error_abort);
K
Kevin Wolf 已提交
764 765 766 767
        }
        qemu_opt_unset(all_opts, "cache");
    }

768 769 770 771
    /* Get a QDict for processing the options */
    bs_opts = qdict_new();
    qemu_opts_to_qdict(all_opts, bs_opts);

772 773
    legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0,
                                   &error_abort);
774
    qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err);
775
    if (local_err) {
776
        error_report_err(local_err);
777 778 779
        goto fail;
    }

780 781 782 783 784 785 786
    /* Deprecated option boot=[on|off] */
    if (qemu_opt_get(legacy_opts, "boot") != NULL) {
        fprintf(stderr, "qemu-kvm: boot=on|off is deprecated and will be "
                "ignored. Future versions will reject this parameter. Please "
                "update your scripts.\n");
    }

787 788 789 790 791 792 793
    /* 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;
F
Fam Zheng 已提交
794
            read_only = true;
795 796 797 798 799 800
        } else {
            error_report("'%s' invalid media", value);
            goto fail;
        }
    }

801
    /* copy-on-read is disabled with a warning for read-only devices */
F
Fam Zheng 已提交
802
    read_only |= qemu_opt_get_bool(legacy_opts, "read-only", false);
803 804 805 806 807 808 809 810 811 812 813 814
    copy_on_read = qemu_opt_get_bool(legacy_opts, "copy-on-read", false);

    if (read_only && copy_on_read) {
        error_report("warning: disabling copy-on-read on read-only drive");
        copy_on_read = false;
    }

    qdict_put(bs_opts, "read-only",
              qstring_from_str(read_only ? "on" : "off"));
    qdict_put(bs_opts, "copy-on-read",
              qstring_from_str(copy_on_read ? "on" :"off"));

815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
    /* 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) {
            error_report("unsupported bus type '%s'", value);
            goto fail;
        }
    } else {
        type = block_default_type;
    }

830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
    /* Geometry */
    cyls  = qemu_opt_get_number(legacy_opts, "cyls", 0);
    heads = qemu_opt_get_number(legacy_opts, "heads", 0);
    secs  = qemu_opt_get_number(legacy_opts, "secs", 0);

    if (cyls || heads || secs) {
        if (cyls < 1) {
            error_report("invalid physical cyls number");
            goto fail;
        }
        if (heads < 1) {
            error_report("invalid physical heads number");
            goto fail;
        }
        if (secs < 1) {
            error_report("invalid physical secs number");
            goto fail;
        }
    }

    translation = BIOS_ATA_TRANSLATION_AUTO;
    value = qemu_opt_get(legacy_opts, "trans");
    if (value != NULL) {
        if (!cyls) {
            error_report("'%s' trans must be used with cyls, heads and secs",
                         value);
            goto fail;
        }
        if (!strcmp(value, "none")) {
            translation = BIOS_ATA_TRANSLATION_NONE;
        } else if (!strcmp(value, "lba")) {
            translation = BIOS_ATA_TRANSLATION_LBA;
862 863 864 865
        } else if (!strcmp(value, "large")) {
            translation = BIOS_ATA_TRANSLATION_LARGE;
        } else if (!strcmp(value, "rechs")) {
            translation = BIOS_ATA_TRANSLATION_RECHS;
866 867 868 869 870 871 872 873 874 875 876 877 878 879 880
        } else if (!strcmp(value, "auto")) {
            translation = BIOS_ATA_TRANSLATION_AUTO;
        } else {
            error_report("'%s' invalid translation type", value);
            goto fail;
        }
    }

    if (media == MEDIA_CDROM) {
        if (cyls || secs || heads) {
            error_report("CHS can't be set with media=cdrom");
            goto fail;
        }
    }

881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
    /* 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) {
            error_report("index cannot be used with bus and unit");
            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) {
        error_report("unit %d too big (max is %d)", unit_id, max_devs - 1);
        goto fail;
    }

    if (drive_get(type, bus_id, unit_id) != NULL) {
        error_report("drive with bus=%d, unit=%d (index=%d) exists",
                     bus_id, unit_id, index);
        goto fail;
    }

920 921 922
    /* Serial number */
    serial = qemu_opt_get(legacy_opts, "serial");

923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
    /* 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);
        }
        qdict_put(bs_opts, "id", qstring_from_str(new_id));
        g_free(new_id);
    }

941 942 943 944 945 946 947 948 949
    /* Add virtio block device */
    devaddr = qemu_opt_get(legacy_opts, "addr");
    if (devaddr && type != IF_VIRTIO) {
        error_report("addr is not supported by this bus type");
        goto fail;
    }

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

M
Max Reitz 已提交
964 965
    filename = qemu_opt_get(legacy_opts, "file");

966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986
    /* 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) {
            error_report("werror is not supported by this bus type");
            goto fail;
        }
        qdict_put(bs_opts, "werror", qstring_from_str(werror));
    }

    rerror = qemu_opt_get(legacy_opts, "rerror");
    if (rerror != NULL) {
        if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI &&
            type != IF_NONE) {
            error_report("rerror is not supported by this bus type");
            goto fail;
        }
        qdict_put(bs_opts, "rerror", qstring_from_str(rerror));
    }

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

999 1000
    /* Create legacy DriveInfo */
    dinfo = g_malloc0(sizeof(*dinfo));
1001
    dinfo->opts = all_opts;
1002

1003 1004 1005 1006 1007
    dinfo->cyls = cyls;
    dinfo->heads = heads;
    dinfo->secs = secs;
    dinfo->trans = translation;

1008
    dinfo->type = type;
1009 1010
    dinfo->bus = bus_id;
    dinfo->unit = unit_id;
1011
    dinfo->devaddr = devaddr;
1012 1013
    dinfo->serial = g_strdup(serial);

1014 1015
    blk_set_legacy_dinfo(blk, dinfo);

1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
    switch(type) {
    case IF_IDE:
    case IF_SCSI:
    case IF_XEN:
    case IF_NONE:
        dinfo->media_cd = media == MEDIA_CDROM;
        break;
    default:
        break;
    }

1027
fail:
1028
    qemu_opts_del(legacy_opts);
1029
    QDECREF(bs_opts);
1030
    return dinfo;
1031 1032
}

1033
void hmp_commit(Monitor *mon, const QDict *qdict)
1034 1035
{
    const char *device = qdict_get_str(qdict, "device");
1036
    BlockBackend *blk;
1037
    int ret;
1038

1039
    if (!strcmp(device, "all")) {
1040
        ret = bdrv_commit_all();
1041
    } else {
1042 1043
        blk = blk_by_name(device);
        if (!blk) {
1044
            monitor_printf(mon, "Device '%s' not found\n", device);
1045
            return;
1046
        }
1047
        ret = bdrv_commit(blk_bs(blk));
1048 1049 1050 1051
    }
    if (ret < 0) {
        monitor_printf(mon, "'commit' error for '%s': %s\n", device,
                       strerror(-ret));
1052 1053 1054
    }
}

1055 1056
static void blockdev_do_action(int kind, void *data, Error **errp)
{
1057 1058
    TransactionAction action;
    TransactionActionList list;
1059 1060 1061 1062 1063 1064 1065 1066

    action.kind = kind;
    action.data = data;
    list.value = &action;
    list.next = NULL;
    qmp_transaction(&list, errp);
}

1067 1068 1069 1070 1071
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,
1072
                                bool has_format, const char *format,
1073
                                bool has_mode, NewImageMode mode, Error **errp)
1074
{
1075
    BlockdevSnapshot snapshot = {
1076
        .has_device = has_device,
1077
        .device = (char *) device,
1078 1079
        .has_node_name = has_node_name,
        .node_name = (char *) node_name,
1080
        .snapshot_file = (char *) snapshot_file,
1081 1082
        .has_snapshot_node_name = has_snapshot_node_name,
        .snapshot_node_name = (char *) snapshot_node_name,
1083 1084 1085 1086 1087
        .has_format = has_format,
        .format = (char *) format,
        .has_mode = has_mode,
        .mode = mode,
    };
1088 1089
    blockdev_do_action(TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC,
                       &snapshot, errp);
1090 1091
}

1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
void qmp_blockdev_snapshot_internal_sync(const char *device,
                                         const char *name,
                                         Error **errp)
{
    BlockdevSnapshotInternal snapshot = {
        .device = (char *) device,
        .name = (char *) name
    };

    blockdev_do_action(TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
                       &snapshot, errp);
}

1105 1106 1107 1108 1109 1110 1111
SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
                                                         bool has_id,
                                                         const char *id,
                                                         bool has_name,
                                                         const char *name,
                                                         Error **errp)
{
1112 1113
    BlockDriverState *bs;
    BlockBackend *blk;
1114
    AioContext *aio_context;
1115 1116 1117 1118 1119
    QEMUSnapshotInfo sn;
    Error *local_err = NULL;
    SnapshotInfo *info = NULL;
    int ret;

1120 1121
    blk = blk_by_name(device);
    if (!blk) {
1122 1123
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
1124 1125
        return NULL;
    }
1126
    bs = blk_bs(blk);
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140

    if (!has_id) {
        id = NULL;
    }

    if (!has_name) {
        name = NULL;
    }

    if (!id && !name) {
        error_setg(errp, "Name or id must be provided");
        return NULL;
    }

1141 1142 1143
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

1144 1145 1146 1147
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, errp)) {
        goto out_aio_context;
    }

1148
    ret = bdrv_snapshot_find_by_id_and_name(bs, id, name, &sn, &local_err);
1149
    if (local_err) {
1150
        error_propagate(errp, local_err);
1151
        goto out_aio_context;
1152 1153 1154 1155 1156 1157
    }
    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);
1158
        goto out_aio_context;
1159 1160 1161
    }

    bdrv_snapshot_delete(bs, id, name, &local_err);
1162
    if (local_err) {
1163
        error_propagate(errp, local_err);
1164
        goto out_aio_context;
1165 1166
    }

1167 1168
    aio_context_release(aio_context);

1169
    info = g_new0(SnapshotInfo, 1);
1170 1171 1172 1173 1174 1175 1176 1177 1178
    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;
1179 1180 1181 1182

out_aio_context:
    aio_context_release(aio_context);
    return NULL;
1183
}
1184

1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
/**
 * 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,
                                                  AioContext **paio,
                                                  Error **errp)
{
    BlockDriverState *bs;
    BdrvDirtyBitmap *bitmap;
    AioContext *aio_context;

    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;
    }

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

    bitmap = bdrv_find_dirty_bitmap(bs, name);
    if (!bitmap) {
        error_setg(errp, "Dirty bitmap '%s' not found", name);
        goto fail;
    }

    if (pbs) {
        *pbs = bs;
    }
    if (paio) {
        *paio = aio_context;
    } else {
        aio_context_release(aio_context);
    }

    return bitmap;

 fail:
    aio_context_release(aio_context);
    return NULL;
}

1247
/* New and old BlockDriverState structs for atomic group operations */
1248

1249
typedef struct BlkTransactionState BlkTransactionState;
1250 1251 1252 1253 1254 1255 1256

/* Only prepare() may fail. In a single transaction, only one of commit() or
   abort() will be called, clean() will always be called if it present. */
typedef struct BdrvActionOps {
    /* Size of state struct, in bytes. */
    size_t instance_size;
    /* Prepare the work, must NOT be NULL. */
1257
    void (*prepare)(BlkTransactionState *common, Error **errp);
1258
    /* Commit the changes, can be NULL. */
1259
    void (*commit)(BlkTransactionState *common);
1260
    /* Abort the changes on fail, can be NULL. */
1261
    void (*abort)(BlkTransactionState *common);
1262
    /* Clean up resource in the end, can be NULL. */
1263
    void (*clean)(BlkTransactionState *common);
1264 1265 1266 1267 1268 1269 1270
} BdrvActionOps;

/*
 * This structure must be arranged as first member in child type, assuming
 * that compiler will also arrange it to the same address with parent instance.
 * Later it will be used in free().
 */
1271
struct BlkTransactionState {
1272
    TransactionAction *action;
1273
    const BdrvActionOps *ops;
1274
    QSIMPLEQ_ENTRY(BlkTransactionState) entry;
1275 1276
};

1277 1278 1279 1280
/* internal snapshot private data */
typedef struct InternalSnapshotState {
    BlkTransactionState common;
    BlockDriverState *bs;
1281
    AioContext *aio_context;
1282 1283 1284 1285 1286 1287
    QEMUSnapshotInfo sn;
} InternalSnapshotState;

static void internal_snapshot_prepare(BlkTransactionState *common,
                                      Error **errp)
{
1288
    Error *local_err = NULL;
1289 1290
    const char *device;
    const char *name;
1291
    BlockBackend *blk;
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
    BlockDriverState *bs;
    QEMUSnapshotInfo old_sn, *sn;
    bool ret;
    qemu_timeval tv;
    BlockdevSnapshotInternal *internal;
    InternalSnapshotState *state;
    int ret1;

    g_assert(common->action->kind ==
             TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC);
    internal = common->action->blockdev_snapshot_internal_sync;
    state = DO_UPCAST(InternalSnapshotState, common, common);

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

    /* 2. check for validation */
1310 1311
    blk = blk_by_name(device);
    if (!blk) {
1312 1313
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
1314 1315
        return;
    }
1316
    bs = blk_bs(blk);
1317

1318 1319 1320 1321
    /* AioContext is released in .clean() */
    state->aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(state->aio_context);

1322
    if (!bdrv_is_inserted(bs)) {
1323
        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
1324 1325 1326
        return;
    }

1327 1328 1329 1330
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, errp)) {
        return;
    }

1331
    if (bdrv_is_read_only(bs)) {
1332
        error_setg(errp, "Device '%s' is read only", device);
1333 1334 1335 1336
        return;
    }

    if (!bdrv_can_snapshot(bs)) {
1337 1338 1339
        error_setg(errp, "Block format '%s' used by device '%s' "
                   "does not support internal snapshots",
                   bs->drv->format_name, device);
1340 1341 1342 1343 1344 1345 1346 1347 1348
        return;
    }

    if (!strlen(name)) {
        error_setg(errp, "Name is empty");
        return;
    }

    /* check whether a snapshot with name exist */
1349 1350 1351 1352
    ret = bdrv_snapshot_find_by_id_and_name(bs, NULL, name, &old_sn,
                                            &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403
        return;
    } else if (ret) {
        error_setg(errp,
                   "Snapshot with name '%s' already exists on device '%s'",
                   name, device);
        return;
    }

    /* 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);
        return;
    }

    /* 4. succeed, mark a snapshot is created */
    state->bs = bs;
}

static void internal_snapshot_abort(BlkTransactionState *common)
{
    InternalSnapshotState *state =
                             DO_UPCAST(InternalSnapshotState, common, common);
    BlockDriverState *bs = state->bs;
    QEMUSnapshotInfo *sn = &state->sn;
    Error *local_error = NULL;

    if (!bs) {
        return;
    }

    if (bdrv_snapshot_delete(bs, sn->id_str, sn->name, &local_error) < 0) {
        error_report("Failed to delete snapshot with id '%s' and name '%s' on "
                     "device '%s' in abort: %s",
                     sn->id_str,
                     sn->name,
                     bdrv_get_device_name(bs),
                     error_get_pretty(local_error));
        error_free(local_error);
    }
}

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
static void internal_snapshot_clean(BlkTransactionState *common)
{
    InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
                                             common, common);

    if (state->aio_context) {
        aio_context_release(state->aio_context);
    }
}

1414
/* external snapshot private data */
1415 1416
typedef struct ExternalSnapshotState {
    BlkTransactionState common;
1417 1418
    BlockDriverState *old_bs;
    BlockDriverState *new_bs;
1419
    AioContext *aio_context;
1420
} ExternalSnapshotState;
1421

1422
static void external_snapshot_prepare(BlkTransactionState *common,
1423 1424 1425 1426
                                      Error **errp)
{
    BlockDriver *drv;
    int flags, ret;
1427
    QDict *options = NULL;
1428
    Error *local_err = NULL;
1429
    bool has_device = false;
1430
    const char *device;
1431 1432 1433 1434
    bool has_node_name = false;
    const char *node_name;
    bool has_snapshot_node_name = false;
    const char *snapshot_node_name;
1435 1436 1437
    const char *new_image_file;
    const char *format = "qcow2";
    enum NewImageMode mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1438 1439
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
1440
    TransactionAction *action = common->action;
1441

1442
    /* get parameters */
1443
    g_assert(action->kind == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC);
1444

1445
    has_device = action->blockdev_snapshot_sync->has_device;
1446
    device = action->blockdev_snapshot_sync->device;
1447 1448 1449 1450 1451 1452
    has_node_name = action->blockdev_snapshot_sync->has_node_name;
    node_name = action->blockdev_snapshot_sync->node_name;
    has_snapshot_node_name =
        action->blockdev_snapshot_sync->has_snapshot_node_name;
    snapshot_node_name = action->blockdev_snapshot_sync->snapshot_node_name;

1453 1454 1455 1456 1457 1458 1459 1460 1461
    new_image_file = action->blockdev_snapshot_sync->snapshot_file;
    if (action->blockdev_snapshot_sync->has_format) {
        format = action->blockdev_snapshot_sync->format;
    }
    if (action->blockdev_snapshot_sync->has_mode) {
        mode = action->blockdev_snapshot_sync->mode;
    }

    /* start processing */
1462 1463
    drv = bdrv_find_format(format);
    if (!drv) {
1464
        error_setg(errp, QERR_INVALID_BLOCK_FORMAT, format);
1465 1466 1467
        return;
    }

1468 1469 1470
    state->old_bs = bdrv_lookup_bs(has_device ? device : NULL,
                                   has_node_name ? node_name : NULL,
                                   &local_err);
1471
    if (local_err) {
1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
        error_propagate(errp, local_err);
        return;
    }

    if (has_node_name && !has_snapshot_node_name) {
        error_setg(errp, "New snapshot node name missing");
        return;
    }

    if (has_snapshot_node_name && bdrv_find_node(snapshot_node_name)) {
        error_setg(errp, "New snapshot node name already existing");
1483 1484 1485
        return;
    }

1486 1487 1488 1489
    /* Acquire AioContext now so any threads operating on old_bs stop */
    state->aio_context = bdrv_get_aio_context(state->old_bs);
    aio_context_acquire(state->aio_context);

1490
    if (!bdrv_is_inserted(state->old_bs)) {
1491
        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
1492 1493 1494
        return;
    }

1495 1496
    if (bdrv_op_is_blocked(state->old_bs,
                           BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) {
1497 1498 1499
        return;
    }

1500 1501
    if (!bdrv_is_read_only(state->old_bs)) {
        if (bdrv_flush(state->old_bs)) {
1502
            error_setg(errp, QERR_IO_ERROR);
1503 1504 1505 1506
            return;
        }
    }

1507
    if (!bdrv_is_first_non_filter(state->old_bs)) {
1508
        error_setg(errp, QERR_FEATURE_DISABLED, "snapshot");
1509 1510 1511
        return;
    }

1512
    flags = state->old_bs->open_flags;
1513 1514 1515 1516

    /* create new image w/backing file */
    if (mode != NEW_IMAGE_MODE_EXISTING) {
        bdrv_img_create(new_image_file, format,
1517 1518
                        state->old_bs->filename,
                        state->old_bs->drv->format_name,
1519
                        NULL, -1, flags, &local_err, false);
1520
        if (local_err) {
1521 1522 1523 1524 1525
            error_propagate(errp, local_err);
            return;
        }
    }

1526 1527 1528 1529 1530 1531
    if (has_snapshot_node_name) {
        options = qdict_new();
        qdict_put(options, "node-name",
                  qstring_from_str(snapshot_node_name));
    }

1532 1533
    /* TODO Inherit bs->options or only take explicit options with an
     * extended QMP command? */
1534
    assert(state->new_bs == NULL);
1535
    ret = bdrv_open(&state->new_bs, new_image_file, NULL, options,
1536
                    flags | BDRV_O_NO_BACKING, drv, &local_err);
1537
    /* We will manually add the backing_hd field to the bs later */
1538
    if (ret != 0) {
1539
        error_propagate(errp, local_err);
1540 1541 1542
    }
}

1543
static void external_snapshot_commit(BlkTransactionState *common)
1544
{
1545 1546
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
1547

1548 1549
    bdrv_set_aio_context(state->new_bs, state->aio_context);

1550 1551
    /* This removes our old bs and adds the new bs */
    bdrv_append(state->new_bs, state->old_bs);
1552 1553 1554
    /* 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 */
1555
    bdrv_reopen(state->new_bs, state->new_bs->open_flags & ~BDRV_O_RDWR,
1556
                NULL);
1557 1558

    aio_context_release(state->aio_context);
1559 1560
}

1561
static void external_snapshot_abort(BlkTransactionState *common)
1562
{
1563 1564 1565
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
    if (state->new_bs) {
F
Fam Zheng 已提交
1566
        bdrv_unref(state->new_bs);
1567
    }
1568 1569 1570
    if (state->aio_context) {
        aio_context_release(state->aio_context);
    }
1571 1572
}

1573 1574 1575
typedef struct DriveBackupState {
    BlkTransactionState common;
    BlockDriverState *bs;
1576
    AioContext *aio_context;
1577 1578 1579 1580 1581 1582
    BlockJob *job;
} DriveBackupState;

static void drive_backup_prepare(BlkTransactionState *common, Error **errp)
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1583
    BlockDriverState *bs;
1584
    BlockBackend *blk;
1585 1586 1587 1588 1589 1590
    DriveBackup *backup;
    Error *local_err = NULL;

    assert(common->action->kind == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
    backup = common->action->drive_backup;

1591 1592
    blk = blk_by_name(backup->device);
    if (!blk) {
1593 1594
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", backup->device);
1595 1596
        return;
    }
1597
    bs = blk_bs(blk);
1598 1599 1600 1601 1602

    /* AioContext is released in .clean() */
    state->aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(state->aio_context);

1603 1604
    qmp_drive_backup(backup->device, backup->target,
                     backup->has_format, backup->format,
1605
                     backup->sync,
1606 1607
                     backup->has_mode, backup->mode,
                     backup->has_speed, backup->speed,
1608
                     backup->has_bitmap, backup->bitmap,
1609 1610 1611
                     backup->has_on_source_error, backup->on_source_error,
                     backup->has_on_target_error, backup->on_target_error,
                     &local_err);
1612
    if (local_err) {
1613 1614 1615 1616
        error_propagate(errp, local_err);
        return;
    }

1617
    state->bs = bs;
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631
    state->job = state->bs->job;
}

static void drive_backup_abort(BlkTransactionState *common)
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
    BlockDriverState *bs = state->bs;

    /* Only cancel if it's the job we started */
    if (bs && bs->job && bs->job == state->job) {
        block_job_cancel_sync(bs->job);
    }
}

1632 1633 1634 1635 1636 1637 1638 1639 1640
static void drive_backup_clean(BlkTransactionState *common)
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);

    if (state->aio_context) {
        aio_context_release(state->aio_context);
    }
}

1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
typedef struct BlockdevBackupState {
    BlkTransactionState common;
    BlockDriverState *bs;
    BlockJob *job;
    AioContext *aio_context;
} BlockdevBackupState;

static void blockdev_backup_prepare(BlkTransactionState *common, Error **errp)
{
    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
    BlockdevBackup *backup;
    BlockDriverState *bs, *target;
1653
    BlockBackend *blk;
1654 1655 1656 1657 1658
    Error *local_err = NULL;

    assert(common->action->kind == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
    backup = common->action->blockdev_backup;

1659 1660
    blk = blk_by_name(backup->device);
    if (!blk) {
1661
        error_setg(errp, "Device '%s' not found", backup->device);
1662 1663
        return;
    }
1664
    bs = blk_bs(blk);
1665

1666 1667
    blk = blk_by_name(backup->target);
    if (!blk) {
1668
        error_setg(errp, "Device '%s' not found", backup->target);
1669 1670
        return;
    }
1671
    target = blk_bs(blk);
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716

    /* AioContext is released in .clean() */
    state->aio_context = bdrv_get_aio_context(bs);
    if (state->aio_context != bdrv_get_aio_context(target)) {
        state->aio_context = NULL;
        error_setg(errp, "Backup between two IO threads is not implemented");
        return;
    }
    aio_context_acquire(state->aio_context);

    qmp_blockdev_backup(backup->device, backup->target,
                        backup->sync,
                        backup->has_speed, backup->speed,
                        backup->has_on_source_error, backup->on_source_error,
                        backup->has_on_target_error, backup->on_target_error,
                        &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
    }

    state->bs = bs;
    state->job = state->bs->job;
}

static void blockdev_backup_abort(BlkTransactionState *common)
{
    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
    BlockDriverState *bs = state->bs;

    /* Only cancel if it's the job we started */
    if (bs && bs->job && bs->job == state->job) {
        block_job_cancel_sync(bs->job);
    }
}

static void blockdev_backup_clean(BlkTransactionState *common)
{
    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);

    if (state->aio_context) {
        aio_context_release(state->aio_context);
    }
}

1717 1718 1719 1720 1721 1722 1723
static void abort_prepare(BlkTransactionState *common, Error **errp)
{
    error_setg(errp, "Transaction aborted using Abort action");
}

static void abort_commit(BlkTransactionState *common)
{
1724
    g_assert_not_reached(); /* this action never succeeds */
1725 1726
}

1727
static const BdrvActionOps actions[] = {
1728
    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
1729
        .instance_size = sizeof(ExternalSnapshotState),
1730 1731 1732 1733
        .prepare  = external_snapshot_prepare,
        .commit   = external_snapshot_commit,
        .abort = external_snapshot_abort,
    },
1734 1735 1736 1737
    [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
        .instance_size = sizeof(DriveBackupState),
        .prepare = drive_backup_prepare,
        .abort = drive_backup_abort,
1738
        .clean = drive_backup_clean,
1739
    },
1740 1741 1742 1743 1744 1745
    [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
        .instance_size = sizeof(BlockdevBackupState),
        .prepare = blockdev_backup_prepare,
        .abort = blockdev_backup_abort,
        .clean = blockdev_backup_clean,
    },
1746 1747 1748 1749 1750
    [TRANSACTION_ACTION_KIND_ABORT] = {
        .instance_size = sizeof(BlkTransactionState),
        .prepare = abort_prepare,
        .commit = abort_commit,
    },
1751 1752 1753 1754
    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
        .instance_size = sizeof(InternalSnapshotState),
        .prepare  = internal_snapshot_prepare,
        .abort = internal_snapshot_abort,
1755
        .clean = internal_snapshot_clean,
1756
    },
1757 1758
};

1759
/*
1760 1761
 * 'Atomic' group operations.  The operations are performed as a set, and if
 * any fail then we roll back all operations in the group.
1762
 */
1763
void qmp_transaction(TransactionActionList *dev_list, Error **errp)
1764
{
1765
    TransactionActionList *dev_entry = dev_list;
1766
    BlkTransactionState *state, *next;
1767
    Error *local_err = NULL;
1768

1769
    QSIMPLEQ_HEAD(snap_bdrv_states, BlkTransactionState) snap_bdrv_states;
1770 1771
    QSIMPLEQ_INIT(&snap_bdrv_states);

1772
    /* drain all i/o before any operations */
1773 1774
    bdrv_drain_all();

1775
    /* We don't do anything in this loop that commits us to the operations */
1776
    while (NULL != dev_entry) {
1777
        TransactionAction *dev_info = NULL;
1778
        const BdrvActionOps *ops;
1779

1780 1781 1782
        dev_info = dev_entry->value;
        dev_entry = dev_entry->next;

1783 1784 1785
        assert(dev_info->kind < ARRAY_SIZE(actions));

        ops = &actions[dev_info->kind];
1786 1787
        assert(ops->instance_size > 0);

1788 1789 1790 1791
        state = g_malloc0(ops->instance_size);
        state->ops = ops;
        state->action = dev_info;
        QSIMPLEQ_INSERT_TAIL(&snap_bdrv_states, state, entry);
1792

1793
        state->ops->prepare(state, &local_err);
1794
        if (local_err) {
1795 1796
            error_propagate(errp, local_err);
            goto delete_and_fail;
1797 1798 1799
        }
    }

1800
    QSIMPLEQ_FOREACH(state, &snap_bdrv_states, entry) {
1801 1802 1803
        if (state->ops->commit) {
            state->ops->commit(state);
        }
1804 1805 1806 1807 1808 1809
    }

    /* success */
    goto exit;

delete_and_fail:
1810
    /* failure, and it is all-or-none; roll back all operations */
1811 1812 1813
    QSIMPLEQ_FOREACH(state, &snap_bdrv_states, entry) {
        if (state->ops->abort) {
            state->ops->abort(state);
1814
        }
1815 1816
    }
exit:
1817 1818 1819
    QSIMPLEQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) {
        if (state->ops->clean) {
            state->ops->clean(state);
1820
        }
1821
        g_free(state);
1822 1823 1824 1825
    }
}


1826
static void eject_device(BlockBackend *blk, int force, Error **errp)
1827
{
1828
    BlockDriverState *bs = blk_bs(blk);
1829 1830 1831 1832
    AioContext *aio_context;

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

1834
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) {
1835
        goto out;
1836
    }
1837
    if (!blk_dev_has_removable_media(blk)) {
1838 1839
        error_setg(errp, "Device '%s' is not removable",
                   bdrv_get_device_name(bs));
1840
        goto out;
1841
    }
1842

1843 1844
    if (blk_dev_is_medium_locked(blk) && !blk_dev_is_tray_open(blk)) {
        blk_dev_eject_request(blk, force);
P
Paolo Bonzini 已提交
1845
        if (!force) {
1846 1847
            error_setg(errp, "Device '%s' is locked",
                       bdrv_get_device_name(bs));
1848
            goto out;
P
Paolo Bonzini 已提交
1849
        }
1850
    }
1851

1852
    bdrv_close(bs);
1853 1854 1855

out:
    aio_context_release(aio_context);
1856 1857
}

L
Luiz Capitulino 已提交
1858
void qmp_eject(const char *device, bool has_force, bool force, Error **errp)
1859
{
1860
    BlockBackend *blk;
1861

1862 1863
    blk = blk_by_name(device);
    if (!blk) {
1864 1865
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
L
Luiz Capitulino 已提交
1866
        return;
1867 1868
    }

1869
    eject_device(blk, force, errp);
1870 1871
}

1872 1873 1874
void qmp_block_passwd(bool has_device, const char *device,
                      bool has_node_name, const char *node_name,
                      const char *password, Error **errp)
1875
{
1876
    Error *local_err = NULL;
1877
    BlockDriverState *bs;
1878
    AioContext *aio_context;
1879

1880 1881 1882
    bs = bdrv_lookup_bs(has_device ? device : NULL,
                        has_node_name ? node_name : NULL,
                        &local_err);
1883
    if (local_err) {
1884
        error_propagate(errp, local_err);
L
Luiz Capitulino 已提交
1885
        return;
1886 1887
    }

1888 1889 1890
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

1891
    bdrv_add_key(bs, password, errp);
1892 1893

    aio_context_release(aio_context);
1894 1895
}

1896
/* Assumes AioContext is held */
L
Luiz Capitulino 已提交
1897 1898 1899 1900
static void qmp_bdrv_open_encrypted(BlockDriverState *bs, const char *filename,
                                    int bdrv_flags, BlockDriver *drv,
                                    const char *password, Error **errp)
{
1901
    Error *local_err = NULL;
1902 1903
    int ret;

1904
    ret = bdrv_open(&bs, filename, NULL, NULL, bdrv_flags, drv, &local_err);
1905
    if (ret < 0) {
1906
        error_propagate(errp, local_err);
L
Luiz Capitulino 已提交
1907 1908 1909
        return;
    }

1910
    bdrv_add_key(bs, password, errp);
L
Luiz Capitulino 已提交
1911 1912 1913
}

void qmp_change_blockdev(const char *device, const char *filename,
1914
                         const char *format, Error **errp)
1915
{
1916
    BlockBackend *blk;
1917
    BlockDriverState *bs;
1918
    AioContext *aio_context;
1919 1920
    BlockDriver *drv = NULL;
    int bdrv_flags;
1921
    Error *err = NULL;
1922

1923 1924
    blk = blk_by_name(device);
    if (!blk) {
1925 1926
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
L
Luiz Capitulino 已提交
1927
        return;
1928
    }
1929
    bs = blk_bs(blk);
L
Luiz Capitulino 已提交
1930

1931 1932 1933
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

L
Luiz Capitulino 已提交
1934
    if (format) {
1935
        drv = bdrv_find_whitelisted_format(format, bs->read_only);
1936
        if (!drv) {
1937
            error_setg(errp, QERR_INVALID_BLOCK_FORMAT, format);
1938
            goto out;
1939 1940
        }
    }
L
Luiz Capitulino 已提交
1941

1942
    eject_device(blk, 0, &err);
1943
    if (err) {
L
Luiz Capitulino 已提交
1944
        error_propagate(errp, err);
1945
        goto out;
1946
    }
L
Luiz Capitulino 已提交
1947

1948
    bdrv_flags = bdrv_is_read_only(bs) ? 0 : BDRV_O_RDWR;
1949
    bdrv_flags |= bdrv_is_snapshot(bs) ? BDRV_O_SNAPSHOT : 0;
L
Luiz Capitulino 已提交
1950 1951

    qmp_bdrv_open_encrypted(bs, filename, bdrv_flags, drv, NULL, errp);
1952 1953 1954

out:
    aio_context_release(aio_context);
1955
}
1956

Z
Zhi Yong Wu 已提交
1957
/* throttling disk I/O limits */
1958
void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
                               int64_t bps_wr,
                               int64_t iops,
                               int64_t iops_rd,
                               int64_t iops_wr,
                               bool has_bps_max,
                               int64_t bps_max,
                               bool has_bps_rd_max,
                               int64_t bps_rd_max,
                               bool has_bps_wr_max,
                               int64_t bps_wr_max,
                               bool has_iops_max,
                               int64_t iops_max,
                               bool has_iops_rd_max,
                               int64_t iops_rd_max,
                               bool has_iops_wr_max,
1974 1975
                               int64_t iops_wr_max,
                               bool has_iops_size,
1976 1977 1978
                               int64_t iops_size,
                               bool has_group,
                               const char *group, Error **errp)
Z
Zhi Yong Wu 已提交
1979
{
1980
    ThrottleConfig cfg;
Z
Zhi Yong Wu 已提交
1981
    BlockDriverState *bs;
1982
    BlockBackend *blk;
1983
    AioContext *aio_context;
Z
Zhi Yong Wu 已提交
1984

1985 1986
    blk = blk_by_name(device);
    if (!blk) {
1987 1988
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
1989
        return;
Z
Zhi Yong Wu 已提交
1990
    }
1991
    bs = blk_bs(blk);
Z
Zhi Yong Wu 已提交
1992

1993 1994 1995 1996 1997 1998 1999 2000 2001
    memset(&cfg, 0, sizeof(cfg));
    cfg.buckets[THROTTLE_BPS_TOTAL].avg = bps;
    cfg.buckets[THROTTLE_BPS_READ].avg  = bps_rd;
    cfg.buckets[THROTTLE_BPS_WRITE].avg = bps_wr;

    cfg.buckets[THROTTLE_OPS_TOTAL].avg = iops;
    cfg.buckets[THROTTLE_OPS_READ].avg  = iops_rd;
    cfg.buckets[THROTTLE_OPS_WRITE].avg = iops_wr;

2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
    if (has_bps_max) {
        cfg.buckets[THROTTLE_BPS_TOTAL].max = bps_max;
    }
    if (has_bps_rd_max) {
        cfg.buckets[THROTTLE_BPS_READ].max = bps_rd_max;
    }
    if (has_bps_wr_max) {
        cfg.buckets[THROTTLE_BPS_WRITE].max = bps_wr_max;
    }
    if (has_iops_max) {
        cfg.buckets[THROTTLE_OPS_TOTAL].max = iops_max;
    }
    if (has_iops_rd_max) {
        cfg.buckets[THROTTLE_OPS_READ].max = iops_rd_max;
    }
    if (has_iops_wr_max) {
        cfg.buckets[THROTTLE_OPS_WRITE].max = iops_wr_max;
    }
Z
Zhi Yong Wu 已提交
2020

2021 2022 2023
    if (has_iops_size) {
        cfg.op_size = iops_size;
    }
2024 2025

    if (!check_throttle_config(&cfg, errp)) {
2026
        return;
Z
Zhi Yong Wu 已提交
2027 2028
    }

2029 2030 2031
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2032 2033 2034 2035 2036 2037 2038 2039 2040
    if (throttle_enabled(&cfg)) {
        /* Enable I/O limits if they're not enabled yet, otherwise
         * just update the throttling group. */
        if (!bs->io_limits_enabled) {
            bdrv_io_limits_enable(bs, has_group ? group : device);
        } else if (has_group) {
            bdrv_io_limits_update_group(bs, group);
        }
        /* Set the new throttling configuration */
2041
        bdrv_set_io_limits(bs, &cfg);
2042 2043 2044
    } else if (bs->io_limits_enabled) {
        /* If all throttling settings are set to 0, disable I/O limits */
        bdrv_io_limits_disable(bs);
Z
Zhi Yong Wu 已提交
2045
    }
2046 2047

    aio_context_release(aio_context);
Z
Zhi Yong Wu 已提交
2048 2049
}

2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 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
void qmp_block_dirty_bitmap_add(const char *node, const char *name,
                                bool has_granularity, uint32_t granularity,
                                Error **errp)
{
    AioContext *aio_context;
    BlockDriverState *bs;

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

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

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

    if (has_granularity) {
        if (granularity < 512 || !is_power_of_2(granularity)) {
            error_setg(errp, "Granularity must be power of 2 "
                             "and at least 512");
            goto out;
        }
    } else {
        /* Default to cluster size, if available: */
        granularity = bdrv_get_default_bitmap_granularity(bs);
    }

    bdrv_create_dirty_bitmap(bs, granularity, name, errp);

 out:
    aio_context_release(aio_context);
}

void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
                                   Error **errp)
{
    AioContext *aio_context;
    BlockDriverState *bs;
    BdrvDirtyBitmap *bitmap;

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

J
John Snow 已提交
2099 2100 2101 2102 2103 2104
    if (bdrv_dirty_bitmap_frozen(bitmap)) {
        error_setg(errp,
                   "Bitmap '%s' is currently frozen and cannot be removed",
                   name);
        goto out;
    }
2105
    bdrv_dirty_bitmap_make_anon(bitmap);
2106 2107
    bdrv_release_dirty_bitmap(bs, bitmap);

J
John Snow 已提交
2108
 out:
2109 2110 2111
    aio_context_release(aio_context);
}

J
John Snow 已提交
2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
/**
 * 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)
{
    AioContext *aio_context;
    BdrvDirtyBitmap *bitmap;
    BlockDriverState *bs;

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

    if (bdrv_dirty_bitmap_frozen(bitmap)) {
        error_setg(errp,
                   "Bitmap '%s' is currently frozen and cannot be modified",
                   name);
        goto out;
    } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
        error_setg(errp,
                   "Bitmap '%s' is currently disabled and cannot be cleared",
                   name);
        goto out;
    }

    bdrv_clear_dirty_bitmap(bitmap);

 out:
    aio_context_release(aio_context);
}

2146
void hmp_drive_del(Monitor *mon, const QDict *qdict)
2147 2148
{
    const char *id = qdict_get_str(qdict, "id");
2149
    BlockBackend *blk;
2150
    BlockDriverState *bs;
2151
    AioContext *aio_context;
2152
    Error *local_err = NULL;
2153

2154 2155
    blk = blk_by_name(id);
    if (!blk) {
2156
        error_report("Device '%s' not found", id);
2157
        return;
2158
    }
2159
    bs = blk_bs(blk);
2160

2161
    if (!blk_legacy_dinfo(blk)) {
2162 2163
        error_report("Deleting device added with blockdev-add"
                     " is not supported");
2164
        return;
2165 2166
    }

2167 2168 2169
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2170
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) {
2171
        error_report_err(local_err);
2172
        aio_context_release(aio_context);
2173
        return;
M
Marcelo Tosatti 已提交
2174
    }
2175 2176 2177

    bdrv_close(bs);

2178
    /* if we have a device attached to this BlockDriverState
2179 2180 2181 2182
     * then we need to make the drive anonymous until the device
     * can be removed.  If this is a drive with no device backing
     * then we can just get rid of the block driver state right here.
     */
2183
    if (blk_get_attached_dev(blk)) {
2184
        blk_hide_on_behalf_of_hmp_drive_del(blk);
2185 2186 2187
        /* Further I/O must not pause the guest */
        bdrv_set_on_error(bs, BLOCKDEV_ON_ERROR_REPORT,
                          BLOCKDEV_ON_ERROR_REPORT);
2188
    } else {
2189
        blk_unref(blk);
2190 2191
    }

2192
    aio_context_release(aio_context);
2193
}
2194

2195 2196 2197
void qmp_block_resize(bool has_device, const char *device,
                      bool has_node_name, const char *node_name,
                      int64_t size, Error **errp)
2198
{
2199
    Error *local_err = NULL;
2200
    BlockDriverState *bs;
2201
    AioContext *aio_context;
2202
    int ret;
2203

2204 2205 2206
    bs = bdrv_lookup_bs(has_device ? device : NULL,
                        has_node_name ? node_name : NULL,
                        &local_err);
2207
    if (local_err) {
2208 2209 2210 2211
        error_propagate(errp, local_err);
        return;
    }

2212 2213 2214
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2215
    if (!bdrv_is_first_non_filter(bs)) {
2216
        error_setg(errp, QERR_FEATURE_DISABLED, "resize");
2217
        goto out;
2218 2219 2220
    }

    if (size < 0) {
2221
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size");
2222
        goto out;
2223 2224
    }

2225
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
2226
        error_setg(errp, QERR_DEVICE_IN_USE, device);
2227
        goto out;
2228 2229
    }

2230 2231 2232
    /* complete all in-flight operations before resizing the device */
    bdrv_drain_all();

2233 2234
    ret = bdrv_truncate(bs, size);
    switch (ret) {
2235 2236 2237
    case 0:
        break;
    case -ENOMEDIUM:
2238
        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
2239 2240
        break;
    case -ENOTSUP:
2241
        error_setg(errp, QERR_UNSUPPORTED);
2242 2243
        break;
    case -EACCES:
2244
        error_setg(errp, "Device '%s' is read only", device);
2245 2246
        break;
    case -EBUSY:
2247
        error_setg(errp, QERR_DEVICE_IN_USE, device);
2248 2249
        break;
    default:
2250
        error_setg_errno(errp, -ret, "Could not resize");
2251
        break;
2252
    }
2253 2254 2255

out:
    aio_context_release(aio_context);
2256
}
S
Stefan Hajnoczi 已提交
2257

2258
static void block_job_cb(void *opaque, int ret)
S
Stefan Hajnoczi 已提交
2259
{
2260 2261 2262 2263 2264
    /* Note that this function may be executed from another AioContext besides
     * the QEMU main loop.  If you need to access anything that assumes the
     * QEMU global mutex, use a BH or introduce a mutex.
     */

S
Stefan Hajnoczi 已提交
2265
    BlockDriverState *bs = opaque;
2266
    const char *msg = NULL;
S
Stefan Hajnoczi 已提交
2267

2268
    trace_block_job_cb(bs, bs->job, ret);
S
Stefan Hajnoczi 已提交
2269 2270

    assert(bs->job);
2271

S
Stefan Hajnoczi 已提交
2272
    if (ret < 0) {
2273
        msg = strerror(-ret);
S
Stefan Hajnoczi 已提交
2274 2275
    }

2276
    if (block_job_is_cancelled(bs->job)) {
2277
        block_job_event_cancelled(bs->job);
2278
    } else {
2279
        block_job_event_completed(bs->job, msg);
2280
    }
2281

F
Fam Zheng 已提交
2282
    bdrv_put_ref_bh_schedule(bs);
S
Stefan Hajnoczi 已提交
2283 2284
}

2285 2286 2287 2288
void qmp_block_stream(const char *device,
                      bool has_base, const char *base,
                      bool has_backing_file, const char *backing_file,
                      bool has_speed, int64_t speed,
P
Paolo Bonzini 已提交
2289 2290
                      bool has_on_error, BlockdevOnError on_error,
                      Error **errp)
S
Stefan Hajnoczi 已提交
2291
{
2292
    BlockBackend *blk;
S
Stefan Hajnoczi 已提交
2293
    BlockDriverState *bs;
2294
    BlockDriverState *base_bs = NULL;
2295
    AioContext *aio_context;
2296
    Error *local_err = NULL;
2297
    const char *base_name = NULL;
S
Stefan Hajnoczi 已提交
2298

P
Paolo Bonzini 已提交
2299 2300 2301 2302
    if (!has_on_error) {
        on_error = BLOCKDEV_ON_ERROR_REPORT;
    }

2303 2304
    blk = blk_by_name(device);
    if (!blk) {
2305 2306
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
S
Stefan Hajnoczi 已提交
2307 2308
        return;
    }
2309
    bs = blk_bs(blk);
S
Stefan Hajnoczi 已提交
2310

2311 2312 2313
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2314
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_STREAM, errp)) {
2315
        goto out;
2316 2317
    }

2318
    if (has_base) {
2319 2320
        base_bs = bdrv_find_backing_image(bs, base);
        if (base_bs == NULL) {
2321
            error_setg(errp, QERR_BASE_NOT_FOUND, base);
2322
            goto out;
2323
        }
2324
        assert(bdrv_get_aio_context(base_bs) == aio_context);
2325
        base_name = base;
S
Stefan Hajnoczi 已提交
2326 2327
    }

2328 2329 2330 2331 2332
    /* 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");
2333
        goto out;
2334 2335 2336 2337 2338 2339
    }

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

    stream_start(bs, base_bs, base_name, has_speed ? speed : 0,
P
Paolo Bonzini 已提交
2340
                 on_error, block_job_cb, bs, &local_err);
2341
    if (local_err) {
2342
        error_propagate(errp, local_err);
2343
        goto out;
S
Stefan Hajnoczi 已提交
2344 2345 2346
    }

    trace_qmp_block_stream(bs, bs->job);
2347 2348 2349

out:
    aio_context_release(aio_context);
S
Stefan Hajnoczi 已提交
2350
}
2351

2352
void qmp_block_commit(const char *device,
2353 2354
                      bool has_base, const char *base,
                      bool has_top, const char *top,
2355
                      bool has_backing_file, const char *backing_file,
2356 2357 2358
                      bool has_speed, int64_t speed,
                      Error **errp)
{
2359
    BlockBackend *blk;
2360 2361
    BlockDriverState *bs;
    BlockDriverState *base_bs, *top_bs;
2362
    AioContext *aio_context;
2363 2364 2365 2366
    Error *local_err = NULL;
    /* This will be part of the QMP command, if/when the
     * BlockdevOnError change for blkmirror makes it in
     */
2367
    BlockdevOnError on_error = BLOCKDEV_ON_ERROR_REPORT;
2368

2369 2370 2371 2372
    if (!has_speed) {
        speed = 0;
    }

2373 2374 2375 2376 2377
    /* 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. */
2378 2379
    blk = blk_by_name(device);
    if (!blk) {
2380 2381
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
2382
        return;
2383
    }
2384
    bs = blk_bs(blk);
2385

2386 2387 2388
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2389
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, errp)) {
2390
        goto out;
2391 2392 2393 2394 2395
    }

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

2396
    if (has_top && top) {
2397 2398 2399 2400 2401 2402 2403
        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");
2404
        goto out;
2405 2406
    }

2407 2408
    assert(bdrv_get_aio_context(top_bs) == aio_context);

2409 2410 2411 2412 2413 2414 2415
    if (has_base && base) {
        base_bs = bdrv_find_backing_image(top_bs, base);
    } else {
        base_bs = bdrv_find_base(top_bs);
    }

    if (base_bs == NULL) {
2416
        error_setg(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL");
2417
        goto out;
2418 2419
    }

2420 2421
    assert(bdrv_get_aio_context(base_bs) == aio_context);

2422 2423 2424 2425
    if (bdrv_op_is_blocked(base_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
        goto out;
    }

2426 2427 2428
    /* Do not allow attempts to commit an image into itself */
    if (top_bs == base_bs) {
        error_setg(errp, "cannot commit an image into itself");
2429
        goto out;
2430 2431
    }

F
Fam Zheng 已提交
2432
    if (top_bs == bs) {
2433 2434 2435
        if (has_backing_file) {
            error_setg(errp, "'backing-file' specified,"
                             " but 'top' is the active layer");
2436
            goto out;
2437
        }
F
Fam Zheng 已提交
2438 2439 2440 2441
        commit_active_start(bs, base_bs, speed, on_error, block_job_cb,
                            bs, &local_err);
    } else {
        commit_start(bs, base_bs, top_bs, speed, on_error, block_job_cb, bs,
2442
                     has_backing_file ? backing_file : NULL, &local_err);
F
Fam Zheng 已提交
2443
    }
2444 2445
    if (local_err != NULL) {
        error_propagate(errp, local_err);
2446
        goto out;
2447
    }
2448 2449 2450

out:
    aio_context_release(aio_context);
2451 2452
}

2453 2454
void qmp_drive_backup(const char *device, const char *target,
                      bool has_format, const char *format,
2455
                      enum MirrorSyncMode sync,
2456 2457
                      bool has_mode, enum NewImageMode mode,
                      bool has_speed, int64_t speed,
2458
                      bool has_bitmap, const char *bitmap,
2459 2460 2461 2462
                      bool has_on_source_error, BlockdevOnError on_source_error,
                      bool has_on_target_error, BlockdevOnError on_target_error,
                      Error **errp)
{
2463
    BlockBackend *blk;
2464 2465
    BlockDriverState *bs;
    BlockDriverState *target_bs;
2466
    BlockDriverState *source = NULL;
2467
    BdrvDirtyBitmap *bmap = NULL;
2468
    AioContext *aio_context;
2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
    BlockDriver *drv = NULL;
    Error *local_err = NULL;
    int flags;
    int64_t size;
    int ret;

    if (!has_speed) {
        speed = 0;
    }
    if (!has_on_source_error) {
        on_source_error = BLOCKDEV_ON_ERROR_REPORT;
    }
    if (!has_on_target_error) {
        on_target_error = BLOCKDEV_ON_ERROR_REPORT;
    }
    if (!has_mode) {
        mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
    }

2488 2489
    blk = blk_by_name(device);
    if (!blk) {
2490 2491
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
2492 2493
        return;
    }
2494
    bs = blk_bs(blk);
2495

2496 2497 2498
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

F
Fam Zheng 已提交
2499 2500
    /* Although backup_run has this check too, we need to use bs->drv below, so
     * do an early check redundantly. */
2501
    if (!bdrv_is_inserted(bs)) {
2502
        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
2503
        goto out;
2504 2505 2506 2507 2508 2509 2510 2511
    }

    if (!has_format) {
        format = mode == NEW_IMAGE_MODE_EXISTING ? NULL : bs->drv->format_name;
    }
    if (format) {
        drv = bdrv_find_format(format);
        if (!drv) {
2512
            error_setg(errp, QERR_INVALID_BLOCK_FORMAT, format);
2513
            goto out;
2514 2515 2516
        }
    }

F
Fam Zheng 已提交
2517
    /* Early check to avoid creating target */
2518
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
2519
        goto out;
2520 2521 2522 2523
    }

    flags = bs->open_flags | BDRV_O_RDWR;

2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535
    /* See if we have a backing HD we can use to create our new image
     * on top of. */
    if (sync == MIRROR_SYNC_MODE_TOP) {
        source = bs->backing_hd;
        if (!source) {
            sync = MIRROR_SYNC_MODE_FULL;
        }
    }
    if (sync == MIRROR_SYNC_MODE_NONE) {
        source = bs;
    }

2536 2537 2538
    size = bdrv_getlength(bs);
    if (size < 0) {
        error_setg_errno(errp, -size, "bdrv_getlength failed");
2539
        goto out;
2540 2541 2542 2543
    }

    if (mode != NEW_IMAGE_MODE_EXISTING) {
        assert(format && drv);
2544 2545 2546 2547 2548 2549 2550 2551
        if (source) {
            bdrv_img_create(target, format, source->filename,
                            source->drv->format_name, NULL,
                            size, flags, &local_err, false);
        } else {
            bdrv_img_create(target, format, NULL, NULL, NULL,
                            size, flags, &local_err, false);
        }
2552 2553
    }

2554
    if (local_err) {
2555
        error_propagate(errp, local_err);
2556
        goto out;
2557 2558
    }

2559
    target_bs = NULL;
2560
    ret = bdrv_open(&target_bs, target, NULL, NULL, flags, drv, &local_err);
2561
    if (ret < 0) {
2562
        error_propagate(errp, local_err);
2563
        goto out;
2564 2565
    }

2566 2567
    bdrv_set_aio_context(target_bs, aio_context);

2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
    if (has_bitmap) {
        bmap = bdrv_find_dirty_bitmap(bs, bitmap);
        if (!bmap) {
            error_setg(errp, "Bitmap '%s' could not be found", bitmap);
            goto out;
        }
    }

    backup_start(bs, target_bs, speed, sync, bmap,
                 on_source_error, on_target_error,
2578 2579
                 block_job_cb, bs, &local_err);
    if (local_err != NULL) {
F
Fam Zheng 已提交
2580
        bdrv_unref(target_bs);
2581
        error_propagate(errp, local_err);
2582
        goto out;
2583
    }
2584 2585 2586

out:
    aio_context_release(aio_context);
2587 2588
}

2589 2590
BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
{
2591
    return bdrv_named_nodes_list(errp);
2592 2593
}

F
Fam Zheng 已提交
2594 2595 2596 2597 2598 2599 2600 2601 2602
void qmp_blockdev_backup(const char *device, const char *target,
                         enum MirrorSyncMode sync,
                         bool has_speed, int64_t speed,
                         bool has_on_source_error,
                         BlockdevOnError on_source_error,
                         bool has_on_target_error,
                         BlockdevOnError on_target_error,
                         Error **errp)
{
2603
    BlockBackend *blk;
F
Fam Zheng 已提交
2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618
    BlockDriverState *bs;
    BlockDriverState *target_bs;
    Error *local_err = NULL;
    AioContext *aio_context;

    if (!has_speed) {
        speed = 0;
    }
    if (!has_on_source_error) {
        on_source_error = BLOCKDEV_ON_ERROR_REPORT;
    }
    if (!has_on_target_error) {
        on_target_error = BLOCKDEV_ON_ERROR_REPORT;
    }

2619 2620
    blk = blk_by_name(device);
    if (!blk) {
2621
        error_setg(errp, "Device '%s' not found", device);
F
Fam Zheng 已提交
2622 2623
        return;
    }
2624
    bs = blk_bs(blk);
F
Fam Zheng 已提交
2625 2626 2627 2628

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

2629 2630
    blk = blk_by_name(target);
    if (!blk) {
2631
        error_setg(errp, "Device '%s' not found", target);
F
Fam Zheng 已提交
2632 2633
        goto out;
    }
2634
    target_bs = blk_bs(blk);
F
Fam Zheng 已提交
2635 2636 2637

    bdrv_ref(target_bs);
    bdrv_set_aio_context(target_bs, aio_context);
2638 2639
    backup_start(bs, target_bs, speed, sync, NULL, on_source_error,
                 on_target_error, block_job_cb, bs, &local_err);
F
Fam Zheng 已提交
2640 2641 2642 2643 2644 2645 2646 2647
    if (local_err != NULL) {
        bdrv_unref(target_bs);
        error_propagate(errp, local_err);
    }
out:
    aio_context_release(aio_context);
}

P
Paolo Bonzini 已提交
2648 2649
void qmp_drive_mirror(const char *device, const char *target,
                      bool has_format, const char *format,
2650
                      bool has_node_name, const char *node_name,
2651
                      bool has_replaces, const char *replaces,
P
Paolo Bonzini 已提交
2652 2653
                      enum MirrorSyncMode sync,
                      bool has_mode, enum NewImageMode mode,
2654
                      bool has_speed, int64_t speed,
2655
                      bool has_granularity, uint32_t granularity,
2656
                      bool has_buf_size, int64_t buf_size,
2657 2658
                      bool has_on_source_error, BlockdevOnError on_source_error,
                      bool has_on_target_error, BlockdevOnError on_target_error,
2659
                      bool has_unmap, bool unmap,
2660
                      Error **errp)
P
Paolo Bonzini 已提交
2661
{
2662
    BlockBackend *blk;
P
Paolo Bonzini 已提交
2663 2664
    BlockDriverState *bs;
    BlockDriverState *source, *target_bs;
2665
    AioContext *aio_context;
P
Paolo Bonzini 已提交
2666 2667
    BlockDriver *drv = NULL;
    Error *local_err = NULL;
2668
    QDict *options = NULL;
P
Paolo Bonzini 已提交
2669
    int flags;
2670
    int64_t size;
P
Paolo Bonzini 已提交
2671 2672 2673 2674 2675
    int ret;

    if (!has_speed) {
        speed = 0;
    }
2676 2677 2678 2679 2680 2681
    if (!has_on_source_error) {
        on_source_error = BLOCKDEV_ON_ERROR_REPORT;
    }
    if (!has_on_target_error) {
        on_target_error = BLOCKDEV_ON_ERROR_REPORT;
    }
P
Paolo Bonzini 已提交
2682 2683 2684
    if (!has_mode) {
        mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
    }
2685 2686 2687
    if (!has_granularity) {
        granularity = 0;
    }
2688
    if (!has_buf_size) {
W
Wen Congyang 已提交
2689
        buf_size = 0;
2690
    }
2691 2692 2693
    if (!has_unmap) {
        unmap = true;
    }
2694

2695
    if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) {
2696 2697
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
                   "a value in range [512B, 64MB]");
2698 2699 2700
        return;
    }
    if (granularity & (granularity - 1)) {
2701 2702
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
                   "power of 2");
2703 2704
        return;
    }
P
Paolo Bonzini 已提交
2705

2706 2707
    blk = blk_by_name(device);
    if (!blk) {
2708 2709
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
P
Paolo Bonzini 已提交
2710 2711
        return;
    }
2712
    bs = blk_bs(blk);
P
Paolo Bonzini 已提交
2713

2714 2715 2716
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

P
Paolo Bonzini 已提交
2717
    if (!bdrv_is_inserted(bs)) {
2718
        error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
2719
        goto out;
P
Paolo Bonzini 已提交
2720 2721 2722 2723 2724 2725 2726 2727
    }

    if (!has_format) {
        format = mode == NEW_IMAGE_MODE_EXISTING ? NULL : bs->drv->format_name;
    }
    if (format) {
        drv = bdrv_find_format(format);
        if (!drv) {
2728
            error_setg(errp, QERR_INVALID_BLOCK_FORMAT, format);
2729
            goto out;
P
Paolo Bonzini 已提交
2730 2731 2732
        }
    }

2733
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR, errp)) {
2734
        goto out;
P
Paolo Bonzini 已提交
2735 2736 2737 2738 2739 2740 2741
    }

    flags = bs->open_flags | BDRV_O_RDWR;
    source = bs->backing_hd;
    if (!source && sync == MIRROR_SYNC_MODE_TOP) {
        sync = MIRROR_SYNC_MODE_FULL;
    }
2742 2743 2744
    if (sync == MIRROR_SYNC_MODE_NONE) {
        source = bs;
    }
P
Paolo Bonzini 已提交
2745

2746 2747 2748
    size = bdrv_getlength(bs);
    if (size < 0) {
        error_setg_errno(errp, -size, "bdrv_getlength failed");
2749
        goto out;
2750 2751
    }

2752 2753
    if (has_replaces) {
        BlockDriverState *to_replace_bs;
2754 2755
        AioContext *replace_aio_context;
        int64_t replace_size;
2756 2757 2758 2759

        if (!has_node_name) {
            error_setg(errp, "a node-name must be provided when replacing a"
                             " named node of the graph");
2760
            goto out;
2761 2762 2763 2764 2765 2766
        }

        to_replace_bs = check_to_replace_node(replaces, &local_err);

        if (!to_replace_bs) {
            error_propagate(errp, local_err);
2767
            goto out;
2768 2769
        }

2770 2771 2772 2773 2774 2775
        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) {
2776 2777
            error_setg(errp, "cannot replace image with a mirror image of "
                             "different size");
2778
            goto out;
2779 2780 2781
        }
    }

2782 2783 2784
    if ((sync == MIRROR_SYNC_MODE_FULL || !source)
        && mode != NEW_IMAGE_MODE_EXISTING)
    {
P
Paolo Bonzini 已提交
2785 2786
        /* create new image w/o backing file */
        assert(format && drv);
2787
        bdrv_img_create(target, format,
2788
                        NULL, NULL, NULL, size, flags, &local_err, false);
P
Paolo Bonzini 已提交
2789 2790 2791 2792 2793 2794
    } else {
        switch (mode) {
        case NEW_IMAGE_MODE_EXISTING:
            break;
        case NEW_IMAGE_MODE_ABSOLUTE_PATHS:
            /* create new image with backing file */
2795 2796 2797
            bdrv_img_create(target, format,
                            source->filename,
                            source->drv->format_name,
2798
                            NULL, size, flags, &local_err, false);
P
Paolo Bonzini 已提交
2799 2800 2801 2802 2803 2804
            break;
        default:
            abort();
        }
    }

2805
    if (local_err) {
2806
        error_propagate(errp, local_err);
2807
        goto out;
P
Paolo Bonzini 已提交
2808 2809
    }

2810 2811 2812 2813 2814
    if (has_node_name) {
        options = qdict_new();
        qdict_put(options, "node-name", qstring_from_str(node_name));
    }

2815 2816 2817
    /* Mirroring takes care of copy-on-write using the source's backing
     * file.
     */
2818
    target_bs = NULL;
2819 2820
    ret = bdrv_open(&target_bs, target, NULL, options,
                    flags | BDRV_O_NO_BACKING, drv, &local_err);
P
Paolo Bonzini 已提交
2821
    if (ret < 0) {
2822
        error_propagate(errp, local_err);
2823
        goto out;
P
Paolo Bonzini 已提交
2824 2825
    }

2826 2827
    bdrv_set_aio_context(target_bs, aio_context);

2828 2829 2830 2831 2832 2833
    /* 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
     */
    mirror_start(bs, target_bs,
                 has_replaces ? replaces : NULL,
                 speed, granularity, buf_size, sync,
2834
                 on_source_error, on_target_error,
2835
                 unmap,
2836
                 block_job_cb, bs, &local_err);
P
Paolo Bonzini 已提交
2837
    if (local_err != NULL) {
F
Fam Zheng 已提交
2838
        bdrv_unref(target_bs);
P
Paolo Bonzini 已提交
2839
        error_propagate(errp, local_err);
2840
        goto out;
P
Paolo Bonzini 已提交
2841
    }
2842 2843 2844

out:
    aio_context_release(aio_context);
P
Paolo Bonzini 已提交
2845 2846
}

2847
/* Get the block job for a given device name and acquire its AioContext */
2848 2849
static BlockJob *find_block_job(const char *device, AioContext **aio_context,
                                Error **errp)
2850
{
2851
    BlockBackend *blk;
2852 2853
    BlockDriverState *bs;

2854 2855
    blk = blk_by_name(device);
    if (!blk) {
2856 2857
        goto notfound;
    }
2858
    bs = blk_bs(blk);
2859 2860 2861 2862 2863 2864 2865

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

    if (!bs->job) {
        aio_context_release(*aio_context);
        goto notfound;
2866
    }
2867

2868
    return bs->job;
2869 2870

notfound:
2871 2872
    error_set(errp, ERROR_CLASS_DEVICE_NOT_ACTIVE,
              "No active block job on device '%s'", device);
2873 2874
    *aio_context = NULL;
    return NULL;
2875 2876
}

2877
void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
2878
{
2879
    AioContext *aio_context;
2880
    BlockJob *job = find_block_job(device, &aio_context, errp);
2881 2882 2883 2884 2885

    if (!job) {
        return;
    }

2886
    block_job_set_speed(job, speed, errp);
2887
    aio_context_release(aio_context);
2888
}
2889

2890 2891
void qmp_block_job_cancel(const char *device,
                          bool has_force, bool force, Error **errp)
2892
{
2893
    AioContext *aio_context;
2894
    BlockJob *job = find_block_job(device, &aio_context, errp);
2895

2896 2897 2898
    if (!job) {
        return;
    }
2899 2900 2901 2902 2903

    if (!has_force) {
        force = false;
    }

F
Fam Zheng 已提交
2904
    if (job->user_paused && !force) {
2905 2906
        error_setg(errp, "The block job for device '%s' is currently paused",
                   device);
2907
        goto out;
2908
    }
2909 2910 2911

    trace_qmp_block_job_cancel(job);
    block_job_cancel(job);
2912 2913
out:
    aio_context_release(aio_context);
2914
}
S
Stefan Hajnoczi 已提交
2915

2916 2917
void qmp_block_job_pause(const char *device, Error **errp)
{
2918
    AioContext *aio_context;
2919
    BlockJob *job = find_block_job(device, &aio_context, errp);
2920

F
Fam Zheng 已提交
2921
    if (!job || job->user_paused) {
2922 2923 2924
        return;
    }

F
Fam Zheng 已提交
2925
    job->user_paused = true;
2926 2927
    trace_qmp_block_job_pause(job);
    block_job_pause(job);
2928
    aio_context_release(aio_context);
2929 2930 2931 2932
}

void qmp_block_job_resume(const char *device, Error **errp)
{
2933
    AioContext *aio_context;
2934
    BlockJob *job = find_block_job(device, &aio_context, errp);
2935

F
Fam Zheng 已提交
2936
    if (!job || !job->user_paused) {
2937 2938 2939
        return;
    }

F
Fam Zheng 已提交
2940
    job->user_paused = false;
2941 2942
    trace_qmp_block_job_resume(job);
    block_job_resume(job);
2943
    aio_context_release(aio_context);
2944 2945
}

P
Paolo Bonzini 已提交
2946 2947
void qmp_block_job_complete(const char *device, Error **errp)
{
2948
    AioContext *aio_context;
2949
    BlockJob *job = find_block_job(device, &aio_context, errp);
P
Paolo Bonzini 已提交
2950 2951 2952 2953 2954 2955 2956

    if (!job) {
        return;
    }

    trace_qmp_block_job_complete(job);
    block_job_complete(job, errp);
2957
    aio_context_release(aio_context);
P
Paolo Bonzini 已提交
2958 2959
}

2960 2961 2962 2963 2964
void qmp_change_backing_file(const char *device,
                             const char *image_node_name,
                             const char *backing_file,
                             Error **errp)
{
2965
    BlockBackend *blk;
2966
    BlockDriverState *bs = NULL;
2967
    AioContext *aio_context;
2968 2969 2970 2971 2972 2973
    BlockDriverState *image_bs = NULL;
    Error *local_err = NULL;
    bool ro;
    int open_flags;
    int ret;

2974 2975
    blk = blk_by_name(device);
    if (!blk) {
2976 2977
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", device);
2978 2979
        return;
    }
2980
    bs = blk_bs(blk);
2981

2982 2983 2984
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2985 2986 2987
    image_bs = bdrv_lookup_bs(NULL, image_node_name, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
2988
        goto out;
2989 2990 2991 2992
    }

    if (!image_bs) {
        error_setg(errp, "image file not found");
2993
        goto out;
2994 2995 2996 2997 2998
    }

    if (bdrv_find_base(image_bs) == image_bs) {
        error_setg(errp, "not allowing backing file change on an image "
                         "without a backing file");
2999
        goto out;
3000 3001 3002 3003 3004
    }

    /* 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)) {
3005
        goto out;
3006 3007 3008 3009 3010 3011
    }

    /* final sanity check */
    if (!bdrv_chain_contains(bs, image_bs)) {
        error_setg(errp, "'%s' and image file are not in the same chain",
                   device);
3012
        goto out;
3013 3014 3015 3016 3017 3018 3019 3020 3021 3022
    }

    /* 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);
3023
            goto out;
3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042
        }
    }

    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);
        if (local_err) {
            error_propagate(errp, local_err); /* will preserve prior errp */
        }
    }
3043 3044 3045

out:
    aio_context_release(aio_context);
3046 3047
}

K
Kevin Wolf 已提交
3048 3049 3050
void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
{
    QmpOutputVisitor *ov = qmp_output_visitor_new();
3051
    BlockBackend *blk;
K
Kevin Wolf 已提交
3052 3053 3054 3055 3056 3057 3058 3059 3060 3061
    QObject *obj;
    QDict *qdict;
    Error *local_err = NULL;

    /* Require an ID in the top level */
    if (!options->has_id) {
        error_setg(errp, "Block device needs an ID");
        goto fail;
    }

3062
    /* TODO Sort it out in raw-posix and drive_new(): Reject aio=native with
K
Kevin Wolf 已提交
3063
     * cache.direct=false instead of silently switching to aio=threads, except
3064
     * when called from drive_new().
K
Kevin Wolf 已提交
3065 3066 3067
     *
     * For now, simply forbidding the combination for all drivers will do. */
    if (options->has_aio && options->aio == BLOCKDEV_AIO_OPTIONS_NATIVE) {
3068 3069 3070 3071
        bool direct = options->has_cache &&
                      options->cache->has_direct &&
                      options->cache->direct;
        if (!direct) {
K
Kevin Wolf 已提交
3072 3073 3074 3075 3076 3077 3078
            error_setg(errp, "aio=native requires cache.direct=true");
            goto fail;
        }
    }

    visit_type_BlockdevOptions(qmp_output_get_visitor(ov),
                               &options, NULL, &local_err);
3079
    if (local_err) {
K
Kevin Wolf 已提交
3080 3081 3082 3083 3084 3085 3086 3087 3088
        error_propagate(errp, local_err);
        goto fail;
    }

    obj = qmp_output_get_qobject(ov);
    qdict = qobject_to_qdict(obj);

    qdict_flatten(qdict);

3089
    blk = blockdev_init(NULL, qdict, &local_err);
3090
    if (local_err) {
3091
        error_propagate(errp, local_err);
K
Kevin Wolf 已提交
3092 3093 3094
        goto fail;
    }

3095 3096
    if (bdrv_key_required(blk_bs(blk))) {
        blk_unref(blk);
3097 3098 3099 3100
        error_setg(errp, "blockdev-add doesn't support encrypted devices");
        goto fail;
    }

K
Kevin Wolf 已提交
3101 3102 3103 3104
fail:
    qmp_output_visitor_cleanup(ov);
}

3105
BlockJobInfoList *qmp_query_block_jobs(Error **errp)
S
Stefan Hajnoczi 已提交
3106
{
3107 3108
    BlockJobInfoList *head = NULL, **p_next = &head;
    BlockDriverState *bs;
S
Stefan Hajnoczi 已提交
3109

3110
    for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) {
3111 3112 3113 3114
        AioContext *aio_context = bdrv_get_aio_context(bs);

        aio_context_acquire(aio_context);

3115 3116 3117 3118 3119 3120
        if (bs->job) {
            BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1);
            elem->value = block_job_query(bs->job);
            *p_next = elem;
            p_next = &elem->next;
        }
3121 3122

        aio_context_release(aio_context);
S
Stefan Hajnoczi 已提交
3123 3124
    }

3125
    return head;
S
Stefan Hajnoczi 已提交
3126
}
3127

3128
QemuOptsList qemu_common_drive_opts = {
3129
    .name = "drive",
3130
    .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),
3131 3132 3133 3134 3135
    .desc = {
        {
            .name = "snapshot",
            .type = QEMU_OPT_BOOL,
            .help = "enable/disable snapshot mode",
3136 3137 3138 3139
        },{
            .name = "discard",
            .type = QEMU_OPT_STRING,
            .help = "discard operation (ignore/off, unmap/on)",
3140
        },{
3141
            .name = BDRV_OPT_CACHE_WB,
K
Kevin Wolf 已提交
3142 3143 3144
            .type = QEMU_OPT_BOOL,
            .help = "enables writeback mode for any caches",
        },{
3145
            .name = BDRV_OPT_CACHE_DIRECT,
K
Kevin Wolf 已提交
3146 3147 3148
            .type = QEMU_OPT_BOOL,
            .help = "enables use of O_DIRECT (bypass the host page cache)",
        },{
3149
            .name = BDRV_OPT_CACHE_NO_FLUSH,
K
Kevin Wolf 已提交
3150 3151
            .type = QEMU_OPT_BOOL,
            .help = "ignore any flush requests for the device",
3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
        },{
            .name = "aio",
            .type = QEMU_OPT_STRING,
            .help = "host AIO implementation (threads, native)",
        },{
            .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",
        },{
3169
            .name = "read-only",
3170 3171 3172
            .type = QEMU_OPT_BOOL,
            .help = "open drive file as read-only",
        },{
3173
            .name = "throttling.iops-total",
3174 3175 3176
            .type = QEMU_OPT_NUMBER,
            .help = "limit total I/O operations per second",
        },{
3177
            .name = "throttling.iops-read",
3178 3179 3180
            .type = QEMU_OPT_NUMBER,
            .help = "limit read operations per second",
        },{
3181
            .name = "throttling.iops-write",
3182 3183 3184
            .type = QEMU_OPT_NUMBER,
            .help = "limit write operations per second",
        },{
3185
            .name = "throttling.bps-total",
3186 3187 3188
            .type = QEMU_OPT_NUMBER,
            .help = "limit total bytes per second",
        },{
3189
            .name = "throttling.bps-read",
3190 3191 3192
            .type = QEMU_OPT_NUMBER,
            .help = "limit read bytes per second",
        },{
3193
            .name = "throttling.bps-write",
3194 3195
            .type = QEMU_OPT_NUMBER,
            .help = "limit write bytes per second",
3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219
        },{
            .name = "throttling.iops-total-max",
            .type = QEMU_OPT_NUMBER,
            .help = "I/O operations burst",
        },{
            .name = "throttling.iops-read-max",
            .type = QEMU_OPT_NUMBER,
            .help = "I/O operations read burst",
        },{
            .name = "throttling.iops-write-max",
            .type = QEMU_OPT_NUMBER,
            .help = "I/O operations write burst",
        },{
            .name = "throttling.bps-total-max",
            .type = QEMU_OPT_NUMBER,
            .help = "total bytes burst",
        },{
            .name = "throttling.bps-read-max",
            .type = QEMU_OPT_NUMBER,
            .help = "total bytes read burst",
        },{
            .name = "throttling.bps-write-max",
            .type = QEMU_OPT_NUMBER,
            .help = "total bytes write burst",
3220 3221 3222 3223
        },{
            .name = "throttling.iops-size",
            .type = QEMU_OPT_NUMBER,
            .help = "when limiting by iops max size of an I/O in bytes",
3224 3225 3226 3227
        },{
            .name = "throttling.group",
            .type = QEMU_OPT_STRING,
            .help = "name of the block throttling group",
3228 3229 3230 3231
        },{
            .name = "copy-on-read",
            .type = QEMU_OPT_BOOL,
            .help = "copy read data from backing file into image file",
3232 3233 3234 3235
        },{
            .name = "detect-zeroes",
            .type = QEMU_OPT_STRING,
            .help = "try to optimize zero writes (off, on, unmap)",
3236 3237 3238 3239
        },
        { /* end of list */ }
    },
};
3240 3241 3242 3243 3244

QemuOptsList qemu_drive_opts = {
    .name = "drive",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
    .desc = {
3245 3246 3247 3248
        /*
         * no elements => accept any params
         * validation will happen later
         */
3249 3250 3251
        { /* end of list */ }
    },
};