blockdev.c 87.2 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 "monitor/monitor.h"
38 39
#include "qemu/option.h"
#include "qemu/config-file.h"
40
#include "qapi/qmp/types.h"
K
Kevin Wolf 已提交
41 42
#include "qapi-visit.h"
#include "qapi/qmp-output-visitor.h"
43
#include "qapi/util.h"
44
#include "sysemu/sysemu.h"
45
#include "block/block_int.h"
L
Luiz Capitulino 已提交
46
#include "qmp-commands.h"
S
Stefan Hajnoczi 已提交
47
#include "trace.h"
48
#include "sysemu/arch_init.h"
49

50 51 52 53 54 55 56 57 58 59 60 61
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",
};

62
static int if_max_devs[IF_COUNT] = {
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
    /*
     * 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,
79 80
};

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

    if (max_devs <= 0) {
        return;
    }

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

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

120
    if (!dinfo) {
121 122 123
        return;
    }

124 125 126
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

127 128 129
    if (bs->job) {
        block_job_cancel(bs->job);
    }
130 131 132

    aio_context_release(aio_context);

133
    dinfo->auto_del = 1;
134 135
}

136
void blockdev_auto_del(BlockBackend *blk)
137
{
138
    DriveInfo *dinfo = blk_legacy_dinfo(blk);
139

140
    if (dinfo && dinfo->auto_del) {
141
        blk_unref(blk);
142 143 144
    }
}

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

162 163 164 165 166 167 168 169 170 171 172 173
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;
}

174 175 176 177 178 179
QemuOpts *drive_def(const char *optstr)
{
    return qemu_opts_parse(qemu_find_opts("drive"), optstr, 0);
}

QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
180
                    const char *optstr)
181 182
{
    QemuOpts *opts;
183
    char buf[32];
184

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

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

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

    return NULL;
}

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

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

    return rs;
}

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

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

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

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

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

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

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

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

/*
F
Fam Zheng 已提交
293
 * Release a BDS reference in a BH
294
 *
F
Fam Zheng 已提交
295 296 297
 * 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.
298
 */
F
Fam Zheng 已提交
299
static void bdrv_put_ref_bh_schedule(BlockDriverState *bs)
300
{
F
Fam Zheng 已提交
301
    BDRVPutRefBH *s;
302

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

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

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

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

339 340 341
    return true;
}

342 343
typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType;

344
/* Takes the ownership of bs_opts */
345 346
static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
                                   Error **errp)
347 348 349 350 351
{
    const char *buf;
    int ro = 0;
    int bdrv_flags = 0;
    int on_read_error, on_write_error;
M
Markus Armbruster 已提交
352
    BlockBackend *blk;
353
    BlockDriverState *bs;
354
    ThrottleConfig cfg;
355
    int snapshot = 0;
356
    bool copy_on_read;
357
    Error *error = NULL;
358 359
    QemuOpts *opts;
    const char *id;
360
    bool has_driver_specific_opts;
361
    BlockdevDetectZeroesOptions detect_zeroes;
362

363 364 365
    /* 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");
366
    opts = qemu_opts_create(&qemu_common_drive_opts, id, 1, &error);
367
    if (error) {
368
        error_propagate(errp, error);
369
        goto err_no_opts;
370 371 372
    }

    qemu_opts_absorb_qdict(opts, bs_opts, &error);
373
    if (error) {
374
        error_propagate(errp, error);
375
        goto early_err;
376 377 378 379 380 381
    }

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

382 383
    has_driver_specific_opts = !!qdict_size(bs_opts);

384 385
    /* extract parameters */
    snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
386
    ro = qemu_opt_get_bool(opts, "read-only", 0);
387
    copy_on_read = qemu_opt_get_bool(opts, "copy-on-read", false);
388

389 390
    if ((buf = qemu_opt_get(opts, "discard")) != NULL) {
        if (bdrv_parse_discard_flags(buf, &bdrv_flags) != 0) {
391
            error_setg(errp, "invalid discard option");
392
            goto early_err;
393 394 395
        }
    }

K
Kevin Wolf 已提交
396 397 398 399 400 401
    if (qemu_opt_get_bool(opts, "cache.writeback", true)) {
        bdrv_flags |= BDRV_O_CACHE_WB;
    }
    if (qemu_opt_get_bool(opts, "cache.direct", false)) {
        bdrv_flags |= BDRV_O_NOCACHE;
    }
402
    if (qemu_opt_get_bool(opts, "cache.no-flush", false)) {
K
Kevin Wolf 已提交
403
        bdrv_flags |= BDRV_O_NO_FLUSH;
404 405 406 407 408 409 410 411 412
    }

#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 {
413
           error_setg(errp, "invalid aio option");
414
           goto early_err;
415 416 417 418 419
        }
    }
#endif

    if ((buf = qemu_opt_get(opts, "format")) != NULL) {
420 421 422 423
        if (is_help_option(buf)) {
            error_printf("Supported formats:");
            bdrv_iterate_format(bdrv_format_print, NULL);
            error_printf("\n");
424
            goto early_err;
425
        }
426

427 428
        if (qdict_haskey(bs_opts, "driver")) {
            error_setg(errp, "Cannot specify both 'driver' and 'format'");
429
            goto early_err;
430
        }
431
        qdict_put(bs_opts, "driver", qstring_from_str(buf));
432 433
    }

434
    /* disk I/O throttling */
435 436
    memset(&cfg, 0, sizeof(cfg));
    cfg.buckets[THROTTLE_BPS_TOTAL].avg =
437
        qemu_opt_get_number(opts, "throttling.bps-total", 0);
438
    cfg.buckets[THROTTLE_BPS_READ].avg  =
439
        qemu_opt_get_number(opts, "throttling.bps-read", 0);
440
    cfg.buckets[THROTTLE_BPS_WRITE].avg =
441
        qemu_opt_get_number(opts, "throttling.bps-write", 0);
442
    cfg.buckets[THROTTLE_OPS_TOTAL].avg =
443
        qemu_opt_get_number(opts, "throttling.iops-total", 0);
444
    cfg.buckets[THROTTLE_OPS_READ].avg =
445
        qemu_opt_get_number(opts, "throttling.iops-read", 0);
446
    cfg.buckets[THROTTLE_OPS_WRITE].avg =
447
        qemu_opt_get_number(opts, "throttling.iops-write", 0);
448

449 450 451 452 453 454 455 456 457 458 459 460
    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);
461

462
    cfg.op_size = qemu_opt_get_number(opts, "throttling.iops-size", 0);
463 464

    if (!check_throttle_config(&cfg, &error)) {
465
        error_propagate(errp, error);
466
        goto early_err;
467 468
    }

469
    on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
470
    if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
471
        on_write_error = parse_block_error_action(buf, 0, &error);
472
        if (error) {
473
            error_propagate(errp, error);
474
            goto early_err;
475 476 477
        }
    }

478
    on_read_error = BLOCKDEV_ON_ERROR_REPORT;
479
    if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
480
        on_read_error = parse_block_error_action(buf, 1, &error);
481
        if (error) {
482
            error_propagate(errp, error);
483
            goto early_err;
484 485 486
        }
    }

487
    detect_zeroes =
488 489 490 491 492
        qapi_enum_parse(BlockdevDetectZeroesOptions_lookup,
                        qemu_opt_get(opts, "detect-zeroes"),
                        BLOCKDEV_DETECT_ZEROES_OPTIONS_MAX,
                        BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
                        &error);
493 494 495 496 497 498 499 500 501 502 503 504
    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;
    }

505
    /* init */
506 507 508 509 510
    if ((!file || !*file) && !has_driver_specific_opts) {
        blk = blk_new_with_bs(qemu_opts_id(opts), errp);
        if (!blk) {
            goto early_err;
        }
511

512 513 514
        bs = blk_bs(blk);
        bs->open_flags = snapshot ? BDRV_O_SNAPSHOT : 0;
        bs->read_only = ro;
515

516 517 518
        QDECREF(bs_opts);
    } else {
        if (file && !*file) {
519 520
            file = NULL;
        }
521

522 523 524 525 526 527 528 529 530
        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;
        }
531

532 533 534 535 536 537 538 539 540 541 542 543
        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);
544 545
    }

546
    bs->detect_zeroes = detect_zeroes;
547

548
    bdrv_set_on_error(bs, on_read_error, on_write_error);
549

550 551 552 553
    /* disk I/O throttling */
    if (throttle_enabled(&cfg)) {
        bdrv_io_limits_enable(bs);
        bdrv_set_io_limits(bs, &cfg);
554 555
    }

556
    if (bdrv_key_required(bs)) {
557
        autostart = 0;
558
    }
559

560
err_no_bs_opts:
561
    qemu_opts_del(opts);
562
    return blk;
563

564 565
early_err:
    qemu_opts_del(opts);
566 567
err_no_opts:
    QDECREF(bs_opts);
568
    return NULL;
569 570
}

571 572
static void qemu_opt_rename(QemuOpts *opts, const char *from, const char *to,
                            Error **errp)
573 574 575 576 577
{
    const char *value;

    value = qemu_opt_get(opts, from);
    if (value) {
578 579 580 581 582
        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;
        }
583 584 585 586
    }

    /* rename all items in opts */
    while ((value = qemu_opt_get(opts, from))) {
587
        qemu_opt_set(opts, to, value, &error_abort);
588 589 590 591
        qemu_opt_unset(opts, from);
    }
}

592 593 594 595 596
QemuOptsList qemu_legacy_drive_opts = {
    .name = "drive",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts.head),
    .desc = {
        {
597 598 599 600 601 602 603 604 605 606 607 608
            .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",
        },{
609 610 611
            .name = "media",
            .type = QEMU_OPT_STRING,
            .help = "media type (disk, cdrom)",
612 613 614 615
        },{
            .name = "if",
            .type = QEMU_OPT_STRING,
            .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
        },{
            .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)",
632 633 634 635
        },{
            .name = "boot",
            .type = QEMU_OPT_BOOL,
            .help = "(deprecated, ignored)",
636 637 638 639
        },{
            .name = "addr",
            .type = QEMU_OPT_STRING,
            .help = "pci address (virtio only)",
640 641 642 643
        },{
            .name = "serial",
            .type = QEMU_OPT_STRING,
            .help = "disk serial number",
M
Max Reitz 已提交
644 645 646 647
        },{
            .name = "file",
            .type = QEMU_OPT_STRING,
            .help = "file name",
648
        },
649 650 651 652 653 654

        /* 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",
655 656 657 658 659 660 661 662
        },{
            .name = "rerror",
            .type = QEMU_OPT_STRING,
            .help = "read error action",
        },{
            .name = "werror",
            .type = QEMU_OPT_STRING,
            .help = "write error action",
663 664 665 666 667 668
        },{
            .name = "copy-on-read",
            .type = QEMU_OPT_BOOL,
            .help = "copy read data from backing file into image file",
        },

669 670 671 672
        { /* end of list */ }
    },
};

673
DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
674
{
K
Kevin Wolf 已提交
675
    const char *value;
676
    BlockBackend *blk;
677
    DriveInfo *dinfo = NULL;
678
    QDict *bs_opts;
679 680
    QemuOpts *legacy_opts;
    DriveMediaType media = MEDIA_DISK;
681
    BlockInterfaceType type;
682
    int cyls, heads, secs, translation;
683
    int max_devs, bus_id, unit_id, index;
684
    const char *devaddr;
685
    const char *werror, *rerror;
F
Fam Zheng 已提交
686 687
    bool read_only = false;
    bool copy_on_read;
688
    const char *serial;
M
Max Reitz 已提交
689
    const char *filename;
690
    Error *local_err = NULL;
691
    int i;
K
Kevin Wolf 已提交
692

693
    /* Change legacy command line options into QMP ones */
694 695 696 697 698 699 700
    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" },
701

702 703 704
        { "bps",            "throttling.bps-total" },
        { "bps_rd",         "throttling.bps-read" },
        { "bps_wr",         "throttling.bps-write" },
705

706 707 708
        { "iops_max",       "throttling.iops-total-max" },
        { "iops_rd_max",    "throttling.iops-read-max" },
        { "iops_wr_max",    "throttling.iops-write-max" },
709

710 711 712
        { "bps_max",        "throttling.bps-total-max" },
        { "bps_rd_max",     "throttling.bps-read-max" },
        { "bps_wr_max",     "throttling.bps-write-max" },
713

714
        { "iops_size",      "throttling.iops-size" },
715

716 717 718 719
        { "readonly",       "read-only" },
    };

    for (i = 0; i < ARRAY_SIZE(opt_renames); i++) {
720 721 722
        qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to,
                        &local_err);
        if (local_err) {
723
            error_report_err(local_err);
724 725
            return NULL;
        }
726
    }
727

K
Kevin Wolf 已提交
728 729 730 731 732 733 734 735 736 737 738 739
    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 */
        if (!qemu_opt_get(all_opts, "cache.writeback")) {
            qemu_opt_set_bool(all_opts, "cache.writeback",
740
                              !!(flags & BDRV_O_CACHE_WB), &error_abort);
K
Kevin Wolf 已提交
741 742 743
        }
        if (!qemu_opt_get(all_opts, "cache.direct")) {
            qemu_opt_set_bool(all_opts, "cache.direct",
744
                              !!(flags & BDRV_O_NOCACHE), &error_abort);
K
Kevin Wolf 已提交
745 746 747
        }
        if (!qemu_opt_get(all_opts, "cache.no-flush")) {
            qemu_opt_set_bool(all_opts, "cache.no-flush",
748
                              !!(flags & BDRV_O_NO_FLUSH), &error_abort);
K
Kevin Wolf 已提交
749 750 751 752
        }
        qemu_opt_unset(all_opts, "cache");
    }

753 754 755 756
    /* Get a QDict for processing the options */
    bs_opts = qdict_new();
    qemu_opts_to_qdict(all_opts, bs_opts);

757 758
    legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0,
                                   &error_abort);
759
    qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err);
760
    if (local_err) {
761
        error_report_err(local_err);
762 763 764
        goto fail;
    }

765 766 767 768 769 770 771
    /* 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");
    }

772 773 774 775 776 777 778
    /* 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 已提交
779
            read_only = true;
780 781 782 783 784 785
        } else {
            error_report("'%s' invalid media", value);
            goto fail;
        }
    }

786
    /* copy-on-read is disabled with a warning for read-only devices */
F
Fam Zheng 已提交
787
    read_only |= qemu_opt_get_bool(legacy_opts, "read-only", false);
788 789 790 791 792 793 794 795 796 797 798 799
    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"));

800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
    /* 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;
    }

815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
    /* 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;
847 848 849 850
        } else if (!strcmp(value, "large")) {
            translation = BIOS_ATA_TRANSLATION_LARGE;
        } else if (!strcmp(value, "rechs")) {
            translation = BIOS_ATA_TRANSLATION_RECHS;
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
        } 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;
        }
    }

866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
    /* 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;
    }

905 906 907
    /* Serial number */
    serial = qemu_opt_get(legacy_opts, "serial");

908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
    /* 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);
    }

926 927 928 929 930 931 932 933 934
    /* 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;
935 936
        devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                   &error_abort);
937
        if (arch_type == QEMU_ARCH_S390X) {
938
            qemu_opt_set(devopts, "driver", "virtio-blk-s390", &error_abort);
939
        } else {
940
            qemu_opt_set(devopts, "driver", "virtio-blk-pci", &error_abort);
941
        }
942 943
        qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
                     &error_abort);
944
        if (devaddr) {
945
            qemu_opt_set(devopts, "addr", devaddr, &error_abort);
946 947 948
        }
    }

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

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
    /* 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));
    }

972
    /* Actual block device init: Functionality shared with blockdev-add */
973
    blk = blockdev_init(filename, bs_opts, &local_err);
974
    bs_opts = NULL;
975
    if (!blk) {
976
        if (local_err) {
977
            error_report_err(local_err);
978
        }
979
        goto fail;
980
    } else {
981
        assert(!local_err);
982 983
    }

984 985
    /* Create legacy DriveInfo */
    dinfo = g_malloc0(sizeof(*dinfo));
986
    dinfo->opts = all_opts;
987

988 989 990 991 992
    dinfo->cyls = cyls;
    dinfo->heads = heads;
    dinfo->secs = secs;
    dinfo->trans = translation;

993
    dinfo->type = type;
994 995
    dinfo->bus = bus_id;
    dinfo->unit = unit_id;
996
    dinfo->devaddr = devaddr;
997 998
    dinfo->serial = g_strdup(serial);

999 1000
    blk_set_legacy_dinfo(blk, dinfo);

1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
    switch(type) {
    case IF_IDE:
    case IF_SCSI:
    case IF_XEN:
    case IF_NONE:
        dinfo->media_cd = media == MEDIA_CDROM;
        break;
    default:
        break;
    }

1012
fail:
1013
    qemu_opts_del(legacy_opts);
1014
    QDECREF(bs_opts);
1015
    return dinfo;
1016 1017
}

1018
void hmp_commit(Monitor *mon, const QDict *qdict)
1019 1020
{
    const char *device = qdict_get_str(qdict, "device");
1021
    BlockDriverState *bs;
1022
    int ret;
1023

1024
    if (!strcmp(device, "all")) {
1025
        ret = bdrv_commit_all();
1026 1027
    } else {
        bs = bdrv_find(device);
1028
        if (!bs) {
1029
            monitor_printf(mon, "Device '%s' not found\n", device);
1030
            return;
1031
        }
1032
        ret = bdrv_commit(bs);
1033 1034 1035 1036
    }
    if (ret < 0) {
        monitor_printf(mon, "'commit' error for '%s': %s\n", device,
                       strerror(-ret));
1037 1038 1039
    }
}

1040 1041
static void blockdev_do_action(int kind, void *data, Error **errp)
{
1042 1043
    TransactionAction action;
    TransactionActionList list;
1044 1045 1046 1047 1048 1049 1050 1051

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

1052 1053 1054 1055 1056
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,
1057
                                bool has_format, const char *format,
1058
                                bool has_mode, NewImageMode mode, Error **errp)
1059
{
1060
    BlockdevSnapshot snapshot = {
1061
        .has_device = has_device,
1062
        .device = (char *) device,
1063 1064
        .has_node_name = has_node_name,
        .node_name = (char *) node_name,
1065
        .snapshot_file = (char *) snapshot_file,
1066 1067
        .has_snapshot_node_name = has_snapshot_node_name,
        .snapshot_node_name = (char *) snapshot_node_name,
1068 1069 1070 1071 1072
        .has_format = has_format,
        .format = (char *) format,
        .has_mode = has_mode,
        .mode = mode,
    };
1073 1074
    blockdev_do_action(TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC,
                       &snapshot, errp);
1075 1076
}

1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
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);
}

1090 1091 1092 1093 1094 1095 1096 1097
SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
                                                         bool has_id,
                                                         const char *id,
                                                         bool has_name,
                                                         const char *name,
                                                         Error **errp)
{
    BlockDriverState *bs = bdrv_find(device);
1098
    AioContext *aio_context;
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
    QEMUSnapshotInfo sn;
    Error *local_err = NULL;
    SnapshotInfo *info = NULL;
    int ret;

    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return NULL;
    }

    if (!has_id) {
        id = NULL;
    }

    if (!has_name) {
        name = NULL;
    }

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

1122 1123 1124
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

1125 1126 1127 1128
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, errp)) {
        goto out_aio_context;
    }

1129
    ret = bdrv_snapshot_find_by_id_and_name(bs, id, name, &sn, &local_err);
1130
    if (local_err) {
1131
        error_propagate(errp, local_err);
1132
        goto out_aio_context;
1133 1134 1135 1136 1137 1138
    }
    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);
1139
        goto out_aio_context;
1140 1141 1142
    }

    bdrv_snapshot_delete(bs, id, name, &local_err);
1143
    if (local_err) {
1144
        error_propagate(errp, local_err);
1145
        goto out_aio_context;
1146 1147
    }

1148 1149
    aio_context_release(aio_context);

1150
    info = g_new0(SnapshotInfo, 1);
1151 1152 1153 1154 1155 1156 1157 1158 1159
    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;
1160 1161 1162 1163

out_aio_context:
    aio_context_release(aio_context);
    return NULL;
1164
}
1165

1166
/* New and old BlockDriverState structs for atomic group operations */
1167

1168
typedef struct BlkTransactionState BlkTransactionState;
1169 1170 1171 1172 1173 1174 1175

/* 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. */
1176
    void (*prepare)(BlkTransactionState *common, Error **errp);
1177
    /* Commit the changes, can be NULL. */
1178
    void (*commit)(BlkTransactionState *common);
1179
    /* Abort the changes on fail, can be NULL. */
1180
    void (*abort)(BlkTransactionState *common);
1181
    /* Clean up resource in the end, can be NULL. */
1182
    void (*clean)(BlkTransactionState *common);
1183 1184 1185 1186 1187 1188 1189
} 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().
 */
1190
struct BlkTransactionState {
1191
    TransactionAction *action;
1192
    const BdrvActionOps *ops;
1193
    QSIMPLEQ_ENTRY(BlkTransactionState) entry;
1194 1195
};

1196 1197 1198 1199
/* internal snapshot private data */
typedef struct InternalSnapshotState {
    BlkTransactionState common;
    BlockDriverState *bs;
1200
    AioContext *aio_context;
1201 1202 1203 1204 1205 1206
    QEMUSnapshotInfo sn;
} InternalSnapshotState;

static void internal_snapshot_prepare(BlkTransactionState *common,
                                      Error **errp)
{
1207
    Error *local_err = NULL;
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
    const char *device;
    const char *name;
    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 */
    bs = bdrv_find(device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
    }

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

1238 1239 1240 1241 1242
    if (!bdrv_is_inserted(bs)) {
        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
        return;
    }

1243 1244 1245 1246
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, errp)) {
        return;
    }

1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
    if (bdrv_is_read_only(bs)) {
        error_set(errp, QERR_DEVICE_IS_READ_ONLY, device);
        return;
    }

    if (!bdrv_can_snapshot(bs)) {
        error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
                  bs->drv->format_name, device, "internal snapshot");
        return;
    }

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

    /* check whether a snapshot with name exist */
1264 1265 1266 1267
    ret = bdrv_snapshot_find_by_id_and_name(bs, NULL, name, &old_sn,
                                            &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
        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);
    }
}

1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
static void internal_snapshot_clean(BlkTransactionState *common)
{
    InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
                                             common, common);

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

1329
/* external snapshot private data */
1330 1331
typedef struct ExternalSnapshotState {
    BlkTransactionState common;
1332 1333
    BlockDriverState *old_bs;
    BlockDriverState *new_bs;
1334
    AioContext *aio_context;
1335
} ExternalSnapshotState;
1336

1337
static void external_snapshot_prepare(BlkTransactionState *common,
1338 1339 1340 1341
                                      Error **errp)
{
    BlockDriver *drv;
    int flags, ret;
1342
    QDict *options = NULL;
1343
    Error *local_err = NULL;
1344
    bool has_device = false;
1345
    const char *device;
1346 1347 1348 1349
    bool has_node_name = false;
    const char *node_name;
    bool has_snapshot_node_name = false;
    const char *snapshot_node_name;
1350 1351 1352
    const char *new_image_file;
    const char *format = "qcow2";
    enum NewImageMode mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1353 1354
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
1355
    TransactionAction *action = common->action;
1356

1357
    /* get parameters */
1358
    g_assert(action->kind == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC);
1359

1360
    has_device = action->blockdev_snapshot_sync->has_device;
1361
    device = action->blockdev_snapshot_sync->device;
1362 1363 1364 1365 1366 1367
    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;

1368 1369 1370 1371 1372 1373 1374 1375 1376
    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 */
1377 1378 1379 1380 1381 1382
    drv = bdrv_find_format(format);
    if (!drv) {
        error_set(errp, QERR_INVALID_BLOCK_FORMAT, format);
        return;
    }

1383 1384 1385
    state->old_bs = bdrv_lookup_bs(has_device ? device : NULL,
                                   has_node_name ? node_name : NULL,
                                   &local_err);
1386
    if (local_err) {
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
        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");
1398 1399 1400
        return;
    }

1401 1402 1403 1404
    /* 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);

1405
    if (!bdrv_is_inserted(state->old_bs)) {
1406 1407 1408 1409
        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
        return;
    }

1410 1411
    if (bdrv_op_is_blocked(state->old_bs,
                           BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) {
1412 1413 1414
        return;
    }

1415 1416
    if (!bdrv_is_read_only(state->old_bs)) {
        if (bdrv_flush(state->old_bs)) {
1417 1418 1419 1420 1421
            error_set(errp, QERR_IO_ERROR);
            return;
        }
    }

1422
    if (!bdrv_is_first_non_filter(state->old_bs)) {
1423 1424 1425 1426
        error_set(errp, QERR_FEATURE_DISABLED, "snapshot");
        return;
    }

1427
    flags = state->old_bs->open_flags;
1428 1429 1430 1431

    /* create new image w/backing file */
    if (mode != NEW_IMAGE_MODE_EXISTING) {
        bdrv_img_create(new_image_file, format,
1432 1433
                        state->old_bs->filename,
                        state->old_bs->drv->format_name,
1434
                        NULL, -1, flags, &local_err, false);
1435
        if (local_err) {
1436 1437 1438 1439 1440
            error_propagate(errp, local_err);
            return;
        }
    }

1441 1442 1443 1444 1445 1446
    if (has_snapshot_node_name) {
        options = qdict_new();
        qdict_put(options, "node-name",
                  qstring_from_str(snapshot_node_name));
    }

1447 1448
    /* TODO Inherit bs->options or only take explicit options with an
     * extended QMP command? */
1449
    assert(state->new_bs == NULL);
1450
    ret = bdrv_open(&state->new_bs, new_image_file, NULL, options,
1451
                    flags | BDRV_O_NO_BACKING, drv, &local_err);
1452
    /* We will manually add the backing_hd field to the bs later */
1453
    if (ret != 0) {
1454
        error_propagate(errp, local_err);
1455 1456 1457
    }
}

1458
static void external_snapshot_commit(BlkTransactionState *common)
1459
{
1460 1461
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
1462

1463 1464
    bdrv_set_aio_context(state->new_bs, state->aio_context);

1465 1466
    /* This removes our old bs and adds the new bs */
    bdrv_append(state->new_bs, state->old_bs);
1467 1468 1469
    /* 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 */
1470
    bdrv_reopen(state->new_bs, state->new_bs->open_flags & ~BDRV_O_RDWR,
1471
                NULL);
1472 1473

    aio_context_release(state->aio_context);
1474 1475
}

1476
static void external_snapshot_abort(BlkTransactionState *common)
1477
{
1478 1479 1480
    ExternalSnapshotState *state =
                             DO_UPCAST(ExternalSnapshotState, common, common);
    if (state->new_bs) {
F
Fam Zheng 已提交
1481
        bdrv_unref(state->new_bs);
1482
    }
1483 1484 1485
    if (state->aio_context) {
        aio_context_release(state->aio_context);
    }
1486 1487
}

1488 1489 1490
typedef struct DriveBackupState {
    BlkTransactionState common;
    BlockDriverState *bs;
1491
    AioContext *aio_context;
1492 1493 1494 1495 1496 1497
    BlockJob *job;
} DriveBackupState;

static void drive_backup_prepare(BlkTransactionState *common, Error **errp)
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1498
    BlockDriverState *bs;
1499 1500 1501 1502 1503 1504
    DriveBackup *backup;
    Error *local_err = NULL;

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

1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
    bs = bdrv_find(backup->device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, backup->device);
        return;
    }

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

1515 1516
    qmp_drive_backup(backup->device, backup->target,
                     backup->has_format, backup->format,
1517
                     backup->sync,
1518 1519 1520 1521 1522
                     backup->has_mode, backup->mode,
                     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);
1523
    if (local_err) {
1524 1525 1526 1527
        error_propagate(errp, local_err);
        return;
    }

1528
    state->bs = bs;
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
    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);
    }
}

1543 1544 1545 1546 1547 1548 1549 1550 1551
static void drive_backup_clean(BlkTransactionState *common)
{
    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);

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

1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624
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;
    Error *local_err = NULL;

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

    bs = bdrv_find(backup->device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, backup->device);
        return;
    }

    target = bdrv_find(backup->target);
    if (!target) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, backup->target);
        return;
    }

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

1625 1626 1627 1628 1629 1630 1631
static void abort_prepare(BlkTransactionState *common, Error **errp)
{
    error_setg(errp, "Transaction aborted using Abort action");
}

static void abort_commit(BlkTransactionState *common)
{
1632
    g_assert_not_reached(); /* this action never succeeds */
1633 1634
}

1635
static const BdrvActionOps actions[] = {
1636
    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
1637
        .instance_size = sizeof(ExternalSnapshotState),
1638 1639 1640 1641
        .prepare  = external_snapshot_prepare,
        .commit   = external_snapshot_commit,
        .abort = external_snapshot_abort,
    },
1642 1643 1644 1645
    [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
        .instance_size = sizeof(DriveBackupState),
        .prepare = drive_backup_prepare,
        .abort = drive_backup_abort,
1646
        .clean = drive_backup_clean,
1647
    },
1648 1649 1650 1651 1652 1653
    [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
        .instance_size = sizeof(BlockdevBackupState),
        .prepare = blockdev_backup_prepare,
        .abort = blockdev_backup_abort,
        .clean = blockdev_backup_clean,
    },
1654 1655 1656 1657 1658
    [TRANSACTION_ACTION_KIND_ABORT] = {
        .instance_size = sizeof(BlkTransactionState),
        .prepare = abort_prepare,
        .commit = abort_commit,
    },
1659 1660 1661 1662
    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
        .instance_size = sizeof(InternalSnapshotState),
        .prepare  = internal_snapshot_prepare,
        .abort = internal_snapshot_abort,
1663
        .clean = internal_snapshot_clean,
1664
    },
1665 1666
};

1667
/*
1668 1669
 * 'Atomic' group operations.  The operations are performed as a set, and if
 * any fail then we roll back all operations in the group.
1670
 */
1671
void qmp_transaction(TransactionActionList *dev_list, Error **errp)
1672
{
1673
    TransactionActionList *dev_entry = dev_list;
1674
    BlkTransactionState *state, *next;
1675
    Error *local_err = NULL;
1676

1677
    QSIMPLEQ_HEAD(snap_bdrv_states, BlkTransactionState) snap_bdrv_states;
1678 1679
    QSIMPLEQ_INIT(&snap_bdrv_states);

1680
    /* drain all i/o before any operations */
1681 1682
    bdrv_drain_all();

1683
    /* We don't do anything in this loop that commits us to the operations */
1684
    while (NULL != dev_entry) {
1685
        TransactionAction *dev_info = NULL;
1686
        const BdrvActionOps *ops;
1687

1688 1689 1690
        dev_info = dev_entry->value;
        dev_entry = dev_entry->next;

1691 1692 1693
        assert(dev_info->kind < ARRAY_SIZE(actions));

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

1696 1697 1698 1699
        state = g_malloc0(ops->instance_size);
        state->ops = ops;
        state->action = dev_info;
        QSIMPLEQ_INSERT_TAIL(&snap_bdrv_states, state, entry);
1700

1701
        state->ops->prepare(state, &local_err);
1702
        if (local_err) {
1703 1704
            error_propagate(errp, local_err);
            goto delete_and_fail;
1705 1706 1707
        }
    }

1708
    QSIMPLEQ_FOREACH(state, &snap_bdrv_states, entry) {
1709 1710 1711
        if (state->ops->commit) {
            state->ops->commit(state);
        }
1712 1713 1714 1715 1716 1717
    }

    /* success */
    goto exit;

delete_and_fail:
1718
    /* failure, and it is all-or-none; roll back all operations */
1719 1720 1721
    QSIMPLEQ_FOREACH(state, &snap_bdrv_states, entry) {
        if (state->ops->abort) {
            state->ops->abort(state);
1722
        }
1723 1724
    }
exit:
1725 1726 1727
    QSIMPLEQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) {
        if (state->ops->clean) {
            state->ops->clean(state);
1728
        }
1729
        g_free(state);
1730 1731 1732 1733
    }
}


1734
static void eject_device(BlockBackend *blk, int force, Error **errp)
1735
{
1736
    BlockDriverState *bs = blk_bs(blk);
1737 1738 1739 1740
    AioContext *aio_context;

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

1742
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) {
1743
        goto out;
1744
    }
1745
    if (!blk_dev_has_removable_media(blk)) {
1746 1747
        error_setg(errp, "Device '%s' is not removable",
                   bdrv_get_device_name(bs));
1748
        goto out;
1749
    }
1750

1751 1752
    if (blk_dev_is_medium_locked(blk) && !blk_dev_is_tray_open(blk)) {
        blk_dev_eject_request(blk, force);
P
Paolo Bonzini 已提交
1753
        if (!force) {
1754 1755
            error_setg(errp, "Device '%s' is locked",
                       bdrv_get_device_name(bs));
1756
            goto out;
P
Paolo Bonzini 已提交
1757
        }
1758
    }
1759

1760
    bdrv_close(bs);
1761 1762 1763

out:
    aio_context_release(aio_context);
1764 1765
}

L
Luiz Capitulino 已提交
1766
void qmp_eject(const char *device, bool has_force, bool force, Error **errp)
1767
{
1768
    BlockBackend *blk;
1769

1770 1771
    blk = blk_by_name(device);
    if (!blk) {
L
Luiz Capitulino 已提交
1772 1773
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
1774 1775
    }

1776
    eject_device(blk, force, errp);
1777 1778
}

1779 1780 1781
void qmp_block_passwd(bool has_device, const char *device,
                      bool has_node_name, const char *node_name,
                      const char *password, Error **errp)
1782
{
1783
    Error *local_err = NULL;
1784
    BlockDriverState *bs;
1785
    AioContext *aio_context;
1786

1787 1788 1789
    bs = bdrv_lookup_bs(has_device ? device : NULL,
                        has_node_name ? node_name : NULL,
                        &local_err);
1790
    if (local_err) {
1791
        error_propagate(errp, local_err);
L
Luiz Capitulino 已提交
1792
        return;
1793 1794
    }

1795 1796 1797
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

1798
    bdrv_add_key(bs, password, errp);
1799 1800

    aio_context_release(aio_context);
1801 1802
}

1803
/* Assumes AioContext is held */
L
Luiz Capitulino 已提交
1804 1805 1806 1807
static void qmp_bdrv_open_encrypted(BlockDriverState *bs, const char *filename,
                                    int bdrv_flags, BlockDriver *drv,
                                    const char *password, Error **errp)
{
1808
    Error *local_err = NULL;
1809 1810
    int ret;

1811
    ret = bdrv_open(&bs, filename, NULL, NULL, bdrv_flags, drv, &local_err);
1812
    if (ret < 0) {
1813
        error_propagate(errp, local_err);
L
Luiz Capitulino 已提交
1814 1815 1816
        return;
    }

1817
    bdrv_add_key(bs, password, errp);
L
Luiz Capitulino 已提交
1818 1819 1820
}

void qmp_change_blockdev(const char *device, const char *filename,
1821
                         const char *format, Error **errp)
1822
{
1823
    BlockBackend *blk;
1824
    BlockDriverState *bs;
1825
    AioContext *aio_context;
1826 1827
    BlockDriver *drv = NULL;
    int bdrv_flags;
1828
    Error *err = NULL;
1829

1830 1831
    blk = blk_by_name(device);
    if (!blk) {
L
Luiz Capitulino 已提交
1832 1833
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
1834
    }
1835
    bs = blk_bs(blk);
L
Luiz Capitulino 已提交
1836

1837 1838 1839
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

L
Luiz Capitulino 已提交
1840
    if (format) {
1841
        drv = bdrv_find_whitelisted_format(format, bs->read_only);
1842
        if (!drv) {
L
Luiz Capitulino 已提交
1843
            error_set(errp, QERR_INVALID_BLOCK_FORMAT, format);
1844
            goto out;
1845 1846
        }
    }
L
Luiz Capitulino 已提交
1847

1848
    eject_device(blk, 0, &err);
1849
    if (err) {
L
Luiz Capitulino 已提交
1850
        error_propagate(errp, err);
1851
        goto out;
1852
    }
L
Luiz Capitulino 已提交
1853

1854
    bdrv_flags = bdrv_is_read_only(bs) ? 0 : BDRV_O_RDWR;
1855
    bdrv_flags |= bdrv_is_snapshot(bs) ? BDRV_O_SNAPSHOT : 0;
L
Luiz Capitulino 已提交
1856 1857

    qmp_bdrv_open_encrypted(bs, filename, bdrv_flags, drv, NULL, errp);
1858 1859 1860

out:
    aio_context_release(aio_context);
1861
}
1862

Z
Zhi Yong Wu 已提交
1863
/* throttling disk I/O limits */
1864
void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
                               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,
1880 1881 1882
                               int64_t iops_wr_max,
                               bool has_iops_size,
                               int64_t iops_size, Error **errp)
Z
Zhi Yong Wu 已提交
1883
{
1884
    ThrottleConfig cfg;
Z
Zhi Yong Wu 已提交
1885
    BlockDriverState *bs;
1886
    AioContext *aio_context;
Z
Zhi Yong Wu 已提交
1887

1888
    bs = bdrv_find(device);
Z
Zhi Yong Wu 已提交
1889
    if (!bs) {
1890 1891
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
Z
Zhi Yong Wu 已提交
1892 1893
    }

1894 1895 1896 1897 1898 1899 1900 1901 1902
    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;

1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
    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 已提交
1921

1922 1923 1924
    if (has_iops_size) {
        cfg.op_size = iops_size;
    }
1925 1926

    if (!check_throttle_config(&cfg, errp)) {
1927
        return;
Z
Zhi Yong Wu 已提交
1928 1929
    }

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

1933
    if (!bs->io_limits_enabled && throttle_enabled(&cfg)) {
Z
Zhi Yong Wu 已提交
1934
        bdrv_io_limits_enable(bs);
1935
    } else if (bs->io_limits_enabled && !throttle_enabled(&cfg)) {
Z
Zhi Yong Wu 已提交
1936
        bdrv_io_limits_disable(bs);
1937 1938 1939 1940
    }

    if (bs->io_limits_enabled) {
        bdrv_set_io_limits(bs, &cfg);
Z
Zhi Yong Wu 已提交
1941
    }
1942 1943

    aio_context_release(aio_context);
Z
Zhi Yong Wu 已提交
1944 1945
}

1946
int hmp_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
1947 1948
{
    const char *id = qdict_get_str(qdict, "id");
1949
    BlockBackend *blk;
1950
    BlockDriverState *bs;
1951
    AioContext *aio_context;
1952
    Error *local_err = NULL;
1953

1954 1955
    blk = blk_by_name(id);
    if (!blk) {
1956
        error_report("Device '%s' not found", id);
1957 1958
        return -1;
    }
1959
    bs = blk_bs(blk);
1960

1961
    if (!blk_legacy_dinfo(blk)) {
1962 1963 1964 1965 1966
        error_report("Deleting device added with blockdev-add"
                     " is not supported");
        return -1;
    }

1967 1968 1969
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

1970
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) {
1971
        error_report_err(local_err);
1972
        aio_context_release(aio_context);
M
Marcelo Tosatti 已提交
1973 1974
        return -1;
    }
1975 1976

    /* quiesce block driver; prevent further io */
1977
    bdrv_drain_all();
1978 1979 1980
    bdrv_flush(bs);
    bdrv_close(bs);

1981
    /* if we have a device attached to this BlockDriverState
1982 1983 1984 1985
     * 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.
     */
1986
    if (blk_get_attached_dev(blk)) {
1987
        blk_hide_on_behalf_of_hmp_drive_del(blk);
1988 1989 1990
        /* Further I/O must not pause the guest */
        bdrv_set_on_error(bs, BLOCKDEV_ON_ERROR_REPORT,
                          BLOCKDEV_ON_ERROR_REPORT);
1991
    } else {
1992
        blk_unref(blk);
1993 1994
    }

1995
    aio_context_release(aio_context);
1996 1997
    return 0;
}
1998

1999 2000 2001
void qmp_block_resize(bool has_device, const char *device,
                      bool has_node_name, const char *node_name,
                      int64_t size, Error **errp)
2002
{
2003
    Error *local_err = NULL;
2004
    BlockDriverState *bs;
2005
    AioContext *aio_context;
2006
    int ret;
2007

2008 2009 2010
    bs = bdrv_lookup_bs(has_device ? device : NULL,
                        has_node_name ? node_name : NULL,
                        &local_err);
2011
    if (local_err) {
2012 2013 2014 2015
        error_propagate(errp, local_err);
        return;
    }

2016 2017 2018
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2019 2020
    if (!bdrv_is_first_non_filter(bs)) {
        error_set(errp, QERR_FEATURE_DISABLED, "resize");
2021
        goto out;
2022 2023 2024
    }

    if (size < 0) {
2025
        error_set(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size");
2026
        goto out;
2027 2028
    }

2029 2030
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
        error_set(errp, QERR_DEVICE_IN_USE, device);
2031
        goto out;
2032 2033
    }

2034 2035 2036
    /* complete all in-flight operations before resizing the device */
    bdrv_drain_all();

2037 2038
    ret = bdrv_truncate(bs, size);
    switch (ret) {
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053
    case 0:
        break;
    case -ENOMEDIUM:
        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
        break;
    case -ENOTSUP:
        error_set(errp, QERR_UNSUPPORTED);
        break;
    case -EACCES:
        error_set(errp, QERR_DEVICE_IS_READ_ONLY, device);
        break;
    case -EBUSY:
        error_set(errp, QERR_DEVICE_IN_USE, device);
        break;
    default:
2054
        error_setg_errno(errp, -ret, "Could not resize");
2055
        break;
2056
    }
2057 2058 2059

out:
    aio_context_release(aio_context);
2060
}
S
Stefan Hajnoczi 已提交
2061

2062
static void block_job_cb(void *opaque, int ret)
S
Stefan Hajnoczi 已提交
2063
{
2064 2065 2066 2067 2068
    /* 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 已提交
2069
    BlockDriverState *bs = opaque;
2070
    const char *msg = NULL;
S
Stefan Hajnoczi 已提交
2071

2072
    trace_block_job_cb(bs, bs->job, ret);
S
Stefan Hajnoczi 已提交
2073 2074

    assert(bs->job);
2075

S
Stefan Hajnoczi 已提交
2076
    if (ret < 0) {
2077
        msg = strerror(-ret);
S
Stefan Hajnoczi 已提交
2078 2079
    }

2080
    if (block_job_is_cancelled(bs->job)) {
2081
        block_job_event_cancelled(bs->job);
2082
    } else {
2083
        block_job_event_completed(bs->job, msg);
2084
    }
2085

F
Fam Zheng 已提交
2086
    bdrv_put_ref_bh_schedule(bs);
S
Stefan Hajnoczi 已提交
2087 2088
}

2089 2090 2091 2092
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 已提交
2093 2094
                      bool has_on_error, BlockdevOnError on_error,
                      Error **errp)
S
Stefan Hajnoczi 已提交
2095 2096
{
    BlockDriverState *bs;
2097
    BlockDriverState *base_bs = NULL;
2098
    AioContext *aio_context;
2099
    Error *local_err = NULL;
2100
    const char *base_name = NULL;
S
Stefan Hajnoczi 已提交
2101

P
Paolo Bonzini 已提交
2102 2103 2104 2105
    if (!has_on_error) {
        on_error = BLOCKDEV_ON_ERROR_REPORT;
    }

S
Stefan Hajnoczi 已提交
2106 2107 2108 2109 2110 2111
    bs = bdrv_find(device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
    }

2112 2113 2114
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2115
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_STREAM, errp)) {
2116
        goto out;
2117 2118
    }

2119
    if (has_base) {
2120 2121 2122
        base_bs = bdrv_find_backing_image(bs, base);
        if (base_bs == NULL) {
            error_set(errp, QERR_BASE_NOT_FOUND, base);
2123
            goto out;
2124
        }
2125
        assert(bdrv_get_aio_context(base_bs) == aio_context);
2126
        base_name = base;
S
Stefan Hajnoczi 已提交
2127 2128
    }

2129 2130 2131 2132 2133
    /* 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");
2134
        goto out;
2135 2136 2137 2138 2139 2140
    }

    /* 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 已提交
2141
                 on_error, block_job_cb, bs, &local_err);
2142
    if (local_err) {
2143
        error_propagate(errp, local_err);
2144
        goto out;
S
Stefan Hajnoczi 已提交
2145 2146 2147
    }

    trace_qmp_block_stream(bs, bs->job);
2148 2149 2150

out:
    aio_context_release(aio_context);
S
Stefan Hajnoczi 已提交
2151
}
2152

2153
void qmp_block_commit(const char *device,
2154 2155
                      bool has_base, const char *base,
                      bool has_top, const char *top,
2156
                      bool has_backing_file, const char *backing_file,
2157 2158 2159 2160 2161
                      bool has_speed, int64_t speed,
                      Error **errp)
{
    BlockDriverState *bs;
    BlockDriverState *base_bs, *top_bs;
2162
    AioContext *aio_context;
2163 2164 2165 2166
    Error *local_err = NULL;
    /* This will be part of the QMP command, if/when the
     * BlockdevOnError change for blkmirror makes it in
     */
2167
    BlockdevOnError on_error = BLOCKDEV_ON_ERROR_REPORT;
2168

2169 2170 2171 2172
    if (!has_speed) {
        speed = 0;
    }

2173 2174 2175 2176 2177
    /* 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. */
2178 2179 2180 2181
    bs = bdrv_find(device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
2182 2183
    }

2184 2185 2186 2187 2188 2189
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

    /* drain all i/o before commits */
    bdrv_drain_all();

2190
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, errp)) {
2191
        goto out;
2192 2193 2194 2195 2196
    }

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

2197
    if (has_top && top) {
2198 2199 2200 2201 2202 2203 2204
        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");
2205
        goto out;
2206 2207
    }

2208 2209
    assert(bdrv_get_aio_context(top_bs) == aio_context);

2210 2211 2212 2213 2214 2215 2216 2217
    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) {
        error_set(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL");
2218
        goto out;
2219 2220
    }

2221 2222
    assert(bdrv_get_aio_context(base_bs) == aio_context);

2223 2224 2225 2226
    if (bdrv_op_is_blocked(base_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
        goto out;
    }

2227 2228 2229
    /* Do not allow attempts to commit an image into itself */
    if (top_bs == base_bs) {
        error_setg(errp, "cannot commit an image into itself");
2230
        goto out;
2231 2232
    }

F
Fam Zheng 已提交
2233
    if (top_bs == bs) {
2234 2235 2236
        if (has_backing_file) {
            error_setg(errp, "'backing-file' specified,"
                             " but 'top' is the active layer");
2237
            goto out;
2238
        }
F
Fam Zheng 已提交
2239 2240 2241 2242
        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,
2243
                     has_backing_file ? backing_file : NULL, &local_err);
F
Fam Zheng 已提交
2244
    }
2245 2246
    if (local_err != NULL) {
        error_propagate(errp, local_err);
2247
        goto out;
2248
    }
2249 2250 2251

out:
    aio_context_release(aio_context);
2252 2253
}

2254 2255
void qmp_drive_backup(const char *device, const char *target,
                      bool has_format, const char *format,
2256
                      enum MirrorSyncMode sync,
2257 2258 2259 2260 2261 2262 2263 2264
                      bool has_mode, enum NewImageMode mode,
                      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)
{
    BlockDriverState *bs;
    BlockDriverState *target_bs;
2265
    BlockDriverState *source = NULL;
2266
    AioContext *aio_context;
2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291
    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;
    }

    bs = bdrv_find(device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
    }

2292 2293 2294
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

F
Fam Zheng 已提交
2295 2296
    /* Although backup_run has this check too, we need to use bs->drv below, so
     * do an early check redundantly. */
2297 2298
    if (!bdrv_is_inserted(bs)) {
        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
2299
        goto out;
2300 2301 2302 2303 2304 2305 2306 2307 2308
    }

    if (!has_format) {
        format = mode == NEW_IMAGE_MODE_EXISTING ? NULL : bs->drv->format_name;
    }
    if (format) {
        drv = bdrv_find_format(format);
        if (!drv) {
            error_set(errp, QERR_INVALID_BLOCK_FORMAT, format);
2309
            goto out;
2310 2311 2312
        }
    }

F
Fam Zheng 已提交
2313
    /* Early check to avoid creating target */
2314
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
2315
        goto out;
2316 2317 2318 2319
    }

    flags = bs->open_flags | BDRV_O_RDWR;

2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331
    /* 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;
    }

2332 2333 2334
    size = bdrv_getlength(bs);
    if (size < 0) {
        error_setg_errno(errp, -size, "bdrv_getlength failed");
2335
        goto out;
2336 2337 2338 2339
    }

    if (mode != NEW_IMAGE_MODE_EXISTING) {
        assert(format && drv);
2340 2341 2342 2343 2344 2345 2346 2347
        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);
        }
2348 2349
    }

2350
    if (local_err) {
2351
        error_propagate(errp, local_err);
2352
        goto out;
2353 2354
    }

2355
    target_bs = NULL;
2356
    ret = bdrv_open(&target_bs, target, NULL, NULL, flags, drv, &local_err);
2357
    if (ret < 0) {
2358
        error_propagate(errp, local_err);
2359
        goto out;
2360 2361
    }

2362 2363
    bdrv_set_aio_context(target_bs, aio_context);

2364
    backup_start(bs, target_bs, speed, sync, on_source_error, on_target_error,
2365 2366
                 block_job_cb, bs, &local_err);
    if (local_err != NULL) {
F
Fam Zheng 已提交
2367
        bdrv_unref(target_bs);
2368
        error_propagate(errp, local_err);
2369
        goto out;
2370
    }
2371 2372 2373

out:
    aio_context_release(aio_context);
2374 2375
}

2376 2377 2378 2379 2380
BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
{
    return bdrv_named_nodes_list();
}

F
Fam Zheng 已提交
2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431
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)
{
    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;
    }

    bs = bdrv_find(device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
    }

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

    target_bs = bdrv_find(target);
    if (!target_bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, target);
        goto out;
    }

    bdrv_ref(target_bs);
    bdrv_set_aio_context(target_bs, aio_context);
    backup_start(bs, target_bs, speed, sync, on_source_error, on_target_error,
                 block_job_cb, bs, &local_err);
    if (local_err != NULL) {
        bdrv_unref(target_bs);
        error_propagate(errp, local_err);
    }
out:
    aio_context_release(aio_context);
}

2432 2433
#define DEFAULT_MIRROR_BUF_SIZE   (10 << 20)

P
Paolo Bonzini 已提交
2434 2435
void qmp_drive_mirror(const char *device, const char *target,
                      bool has_format, const char *format,
2436
                      bool has_node_name, const char *node_name,
2437
                      bool has_replaces, const char *replaces,
P
Paolo Bonzini 已提交
2438 2439
                      enum MirrorSyncMode sync,
                      bool has_mode, enum NewImageMode mode,
2440
                      bool has_speed, int64_t speed,
2441
                      bool has_granularity, uint32_t granularity,
2442
                      bool has_buf_size, int64_t buf_size,
2443 2444 2445
                      bool has_on_source_error, BlockdevOnError on_source_error,
                      bool has_on_target_error, BlockdevOnError on_target_error,
                      Error **errp)
P
Paolo Bonzini 已提交
2446 2447 2448
{
    BlockDriverState *bs;
    BlockDriverState *source, *target_bs;
2449
    AioContext *aio_context;
P
Paolo Bonzini 已提交
2450 2451
    BlockDriver *drv = NULL;
    Error *local_err = NULL;
2452
    QDict *options = NULL;
P
Paolo Bonzini 已提交
2453
    int flags;
2454
    int64_t size;
P
Paolo Bonzini 已提交
2455 2456 2457 2458 2459
    int ret;

    if (!has_speed) {
        speed = 0;
    }
2460 2461 2462 2463 2464 2465
    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 已提交
2466 2467 2468
    if (!has_mode) {
        mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
    }
2469 2470 2471
    if (!has_granularity) {
        granularity = 0;
    }
2472 2473 2474 2475
    if (!has_buf_size) {
        buf_size = DEFAULT_MIRROR_BUF_SIZE;
    }

2476
    if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) {
2477 2478
        error_set(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
                  "a value in range [512B, 64MB]");
2479 2480 2481
        return;
    }
    if (granularity & (granularity - 1)) {
2482
        error_set(errp, QERR_INVALID_PARAMETER_VALUE, "granularity", "power of 2");
2483 2484
        return;
    }
P
Paolo Bonzini 已提交
2485 2486 2487 2488 2489 2490 2491

    bs = bdrv_find(device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
    }

2492 2493 2494
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

P
Paolo Bonzini 已提交
2495 2496
    if (!bdrv_is_inserted(bs)) {
        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
2497
        goto out;
P
Paolo Bonzini 已提交
2498 2499 2500 2501 2502 2503 2504 2505 2506
    }

    if (!has_format) {
        format = mode == NEW_IMAGE_MODE_EXISTING ? NULL : bs->drv->format_name;
    }
    if (format) {
        drv = bdrv_find_format(format);
        if (!drv) {
            error_set(errp, QERR_INVALID_BLOCK_FORMAT, format);
2507
            goto out;
P
Paolo Bonzini 已提交
2508 2509 2510
        }
    }

2511
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR, errp)) {
2512
        goto out;
P
Paolo Bonzini 已提交
2513 2514 2515 2516 2517 2518 2519
    }

    flags = bs->open_flags | BDRV_O_RDWR;
    source = bs->backing_hd;
    if (!source && sync == MIRROR_SYNC_MODE_TOP) {
        sync = MIRROR_SYNC_MODE_FULL;
    }
2520 2521 2522
    if (sync == MIRROR_SYNC_MODE_NONE) {
        source = bs;
    }
P
Paolo Bonzini 已提交
2523

2524 2525 2526
    size = bdrv_getlength(bs);
    if (size < 0) {
        error_setg_errno(errp, -size, "bdrv_getlength failed");
2527
        goto out;
2528 2529
    }

2530 2531
    if (has_replaces) {
        BlockDriverState *to_replace_bs;
2532 2533
        AioContext *replace_aio_context;
        int64_t replace_size;
2534 2535 2536 2537

        if (!has_node_name) {
            error_setg(errp, "a node-name must be provided when replacing a"
                             " named node of the graph");
2538
            goto out;
2539 2540 2541 2542 2543 2544
        }

        to_replace_bs = check_to_replace_node(replaces, &local_err);

        if (!to_replace_bs) {
            error_propagate(errp, local_err);
2545
            goto out;
2546 2547
        }

2548 2549 2550 2551 2552 2553
        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) {
2554 2555
            error_setg(errp, "cannot replace image with a mirror image of "
                             "different size");
2556
            goto out;
2557 2558 2559
        }
    }

2560 2561 2562
    if ((sync == MIRROR_SYNC_MODE_FULL || !source)
        && mode != NEW_IMAGE_MODE_EXISTING)
    {
P
Paolo Bonzini 已提交
2563 2564
        /* create new image w/o backing file */
        assert(format && drv);
2565
        bdrv_img_create(target, format,
2566
                        NULL, NULL, NULL, size, flags, &local_err, false);
P
Paolo Bonzini 已提交
2567 2568 2569 2570 2571 2572
    } else {
        switch (mode) {
        case NEW_IMAGE_MODE_EXISTING:
            break;
        case NEW_IMAGE_MODE_ABSOLUTE_PATHS:
            /* create new image with backing file */
2573 2574 2575
            bdrv_img_create(target, format,
                            source->filename,
                            source->drv->format_name,
2576
                            NULL, size, flags, &local_err, false);
P
Paolo Bonzini 已提交
2577 2578 2579 2580 2581 2582
            break;
        default:
            abort();
        }
    }

2583
    if (local_err) {
2584
        error_propagate(errp, local_err);
2585
        goto out;
P
Paolo Bonzini 已提交
2586 2587
    }

2588 2589 2590 2591 2592
    if (has_node_name) {
        options = qdict_new();
        qdict_put(options, "node-name", qstring_from_str(node_name));
    }

2593 2594 2595
    /* Mirroring takes care of copy-on-write using the source's backing
     * file.
     */
2596
    target_bs = NULL;
2597 2598
    ret = bdrv_open(&target_bs, target, NULL, options,
                    flags | BDRV_O_NO_BACKING, drv, &local_err);
P
Paolo Bonzini 已提交
2599
    if (ret < 0) {
2600
        error_propagate(errp, local_err);
2601
        goto out;
P
Paolo Bonzini 已提交
2602 2603
    }

2604 2605
    bdrv_set_aio_context(target_bs, aio_context);

2606 2607 2608 2609 2610 2611
    /* 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,
2612
                 on_source_error, on_target_error,
2613
                 block_job_cb, bs, &local_err);
P
Paolo Bonzini 已提交
2614
    if (local_err != NULL) {
F
Fam Zheng 已提交
2615
        bdrv_unref(target_bs);
P
Paolo Bonzini 已提交
2616
        error_propagate(errp, local_err);
2617
        goto out;
P
Paolo Bonzini 已提交
2618
    }
2619 2620 2621

out:
    aio_context_release(aio_context);
P
Paolo Bonzini 已提交
2622 2623
}

2624
/* Get the block job for a given device name and acquire its AioContext */
2625 2626
static BlockJob *find_block_job(const char *device, AioContext **aio_context,
                                Error **errp)
2627 2628 2629 2630
{
    BlockDriverState *bs;

    bs = bdrv_find(device);
2631 2632 2633 2634 2635 2636 2637 2638 2639 2640
    if (!bs) {
        goto notfound;
    }

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

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

2643
    return bs->job;
2644 2645

notfound:
2646 2647
    error_set(errp, ERROR_CLASS_DEVICE_NOT_ACTIVE,
              "No active block job on device '%s'", device);
2648 2649
    *aio_context = NULL;
    return NULL;
2650 2651
}

2652
void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
2653
{
2654
    AioContext *aio_context;
2655
    BlockJob *job = find_block_job(device, &aio_context, errp);
2656 2657 2658 2659 2660

    if (!job) {
        return;
    }

2661
    block_job_set_speed(job, speed, errp);
2662
    aio_context_release(aio_context);
2663
}
2664

2665 2666
void qmp_block_job_cancel(const char *device,
                          bool has_force, bool force, Error **errp)
2667
{
2668
    AioContext *aio_context;
2669
    BlockJob *job = find_block_job(device, &aio_context, errp);
2670

2671 2672 2673
    if (!job) {
        return;
    }
2674 2675 2676 2677 2678

    if (!has_force) {
        force = false;
    }

2679
    if (job->paused && !force) {
2680 2681
        error_setg(errp, "The block job for device '%s' is currently paused",
                   device);
2682
        goto out;
2683
    }
2684 2685 2686

    trace_qmp_block_job_cancel(job);
    block_job_cancel(job);
2687 2688
out:
    aio_context_release(aio_context);
2689
}
S
Stefan Hajnoczi 已提交
2690

2691 2692
void qmp_block_job_pause(const char *device, Error **errp)
{
2693
    AioContext *aio_context;
2694
    BlockJob *job = find_block_job(device, &aio_context, errp);
2695 2696 2697 2698 2699 2700 2701

    if (!job) {
        return;
    }

    trace_qmp_block_job_pause(job);
    block_job_pause(job);
2702
    aio_context_release(aio_context);
2703 2704 2705 2706
}

void qmp_block_job_resume(const char *device, Error **errp)
{
2707
    AioContext *aio_context;
2708
    BlockJob *job = find_block_job(device, &aio_context, errp);
2709 2710 2711 2712 2713 2714 2715

    if (!job) {
        return;
    }

    trace_qmp_block_job_resume(job);
    block_job_resume(job);
2716
    aio_context_release(aio_context);
2717 2718
}

P
Paolo Bonzini 已提交
2719 2720
void qmp_block_job_complete(const char *device, Error **errp)
{
2721
    AioContext *aio_context;
2722
    BlockJob *job = find_block_job(device, &aio_context, errp);
P
Paolo Bonzini 已提交
2723 2724 2725 2726 2727 2728 2729

    if (!job) {
        return;
    }

    trace_qmp_block_job_complete(job);
    block_job_complete(job, errp);
2730
    aio_context_release(aio_context);
P
Paolo Bonzini 已提交
2731 2732
}

2733 2734 2735 2736 2737 2738
void qmp_change_backing_file(const char *device,
                             const char *image_node_name,
                             const char *backing_file,
                             Error **errp)
{
    BlockDriverState *bs = NULL;
2739
    AioContext *aio_context;
2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752
    BlockDriverState *image_bs = NULL;
    Error *local_err = NULL;
    bool ro;
    int open_flags;
    int ret;

    /* find the top layer BDS of the chain */
    bs = bdrv_find(device);
    if (!bs) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
        return;
    }

2753 2754 2755
    aio_context = bdrv_get_aio_context(bs);
    aio_context_acquire(aio_context);

2756 2757 2758
    image_bs = bdrv_lookup_bs(NULL, image_node_name, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
2759
        goto out;
2760 2761 2762 2763
    }

    if (!image_bs) {
        error_setg(errp, "image file not found");
2764
        goto out;
2765 2766 2767 2768 2769
    }

    if (bdrv_find_base(image_bs) == image_bs) {
        error_setg(errp, "not allowing backing file change on an image "
                         "without a backing file");
2770
        goto out;
2771 2772 2773 2774 2775
    }

    /* 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)) {
2776
        goto out;
2777 2778 2779 2780 2781 2782
    }

    /* final sanity check */
    if (!bdrv_chain_contains(bs, image_bs)) {
        error_setg(errp, "'%s' and image file are not in the same chain",
                   device);
2783
        goto out;
2784 2785 2786 2787 2788 2789 2790 2791 2792 2793
    }

    /* 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);
2794
            goto out;
2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813
        }
    }

    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 */
        }
    }
2814 2815 2816

out:
    aio_context_release(aio_context);
2817 2818
}

K
Kevin Wolf 已提交
2819 2820 2821
void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
{
    QmpOutputVisitor *ov = qmp_output_visitor_new();
2822
    BlockBackend *blk;
K
Kevin Wolf 已提交
2823 2824 2825 2826 2827 2828 2829 2830 2831 2832
    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;
    }

2833
    /* TODO Sort it out in raw-posix and drive_new(): Reject aio=native with
K
Kevin Wolf 已提交
2834
     * cache.direct=false instead of silently switching to aio=threads, except
2835
     * when called from drive_new().
K
Kevin Wolf 已提交
2836 2837 2838
     *
     * For now, simply forbidding the combination for all drivers will do. */
    if (options->has_aio && options->aio == BLOCKDEV_AIO_OPTIONS_NATIVE) {
2839 2840 2841 2842
        bool direct = options->has_cache &&
                      options->cache->has_direct &&
                      options->cache->direct;
        if (!direct) {
K
Kevin Wolf 已提交
2843 2844 2845 2846 2847 2848 2849
            error_setg(errp, "aio=native requires cache.direct=true");
            goto fail;
        }
    }

    visit_type_BlockdevOptions(qmp_output_get_visitor(ov),
                               &options, NULL, &local_err);
2850
    if (local_err) {
K
Kevin Wolf 已提交
2851 2852 2853 2854 2855 2856 2857 2858 2859
        error_propagate(errp, local_err);
        goto fail;
    }

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

    qdict_flatten(qdict);

2860
    blk = blockdev_init(NULL, qdict, &local_err);
2861
    if (local_err) {
2862
        error_propagate(errp, local_err);
K
Kevin Wolf 已提交
2863 2864 2865
        goto fail;
    }

2866 2867
    if (bdrv_key_required(blk_bs(blk))) {
        blk_unref(blk);
2868 2869 2870 2871
        error_setg(errp, "blockdev-add doesn't support encrypted devices");
        goto fail;
    }

K
Kevin Wolf 已提交
2872 2873 2874 2875
fail:
    qmp_output_visitor_cleanup(ov);
}

2876
BlockJobInfoList *qmp_query_block_jobs(Error **errp)
S
Stefan Hajnoczi 已提交
2877
{
2878 2879
    BlockJobInfoList *head = NULL, **p_next = &head;
    BlockDriverState *bs;
S
Stefan Hajnoczi 已提交
2880

2881
    for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) {
2882 2883 2884 2885
        AioContext *aio_context = bdrv_get_aio_context(bs);

        aio_context_acquire(aio_context);

2886 2887 2888 2889 2890 2891
        if (bs->job) {
            BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1);
            elem->value = block_job_query(bs->job);
            *p_next = elem;
            p_next = &elem->next;
        }
2892 2893

        aio_context_release(aio_context);
S
Stefan Hajnoczi 已提交
2894 2895
    }

2896
    return head;
S
Stefan Hajnoczi 已提交
2897
}
2898

2899
QemuOptsList qemu_common_drive_opts = {
2900
    .name = "drive",
2901
    .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),
2902 2903 2904 2905 2906
    .desc = {
        {
            .name = "snapshot",
            .type = QEMU_OPT_BOOL,
            .help = "enable/disable snapshot mode",
2907 2908 2909 2910
        },{
            .name = "discard",
            .type = QEMU_OPT_STRING,
            .help = "discard operation (ignore/off, unmap/on)",
2911
        },{
K
Kevin Wolf 已提交
2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922
            .name = "cache.writeback",
            .type = QEMU_OPT_BOOL,
            .help = "enables writeback mode for any caches",
        },{
            .name = "cache.direct",
            .type = QEMU_OPT_BOOL,
            .help = "enables use of O_DIRECT (bypass the host page cache)",
        },{
            .name = "cache.no-flush",
            .type = QEMU_OPT_BOOL,
            .help = "ignore any flush requests for the device",
2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939
        },{
            .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",
        },{
2940
            .name = "read-only",
2941 2942 2943
            .type = QEMU_OPT_BOOL,
            .help = "open drive file as read-only",
        },{
2944
            .name = "throttling.iops-total",
2945 2946 2947
            .type = QEMU_OPT_NUMBER,
            .help = "limit total I/O operations per second",
        },{
2948
            .name = "throttling.iops-read",
2949 2950 2951
            .type = QEMU_OPT_NUMBER,
            .help = "limit read operations per second",
        },{
2952
            .name = "throttling.iops-write",
2953 2954 2955
            .type = QEMU_OPT_NUMBER,
            .help = "limit write operations per second",
        },{
2956
            .name = "throttling.bps-total",
2957 2958 2959
            .type = QEMU_OPT_NUMBER,
            .help = "limit total bytes per second",
        },{
2960
            .name = "throttling.bps-read",
2961 2962 2963
            .type = QEMU_OPT_NUMBER,
            .help = "limit read bytes per second",
        },{
2964
            .name = "throttling.bps-write",
2965 2966
            .type = QEMU_OPT_NUMBER,
            .help = "limit write bytes per second",
2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
        },{
            .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",
2991 2992 2993 2994
        },{
            .name = "throttling.iops-size",
            .type = QEMU_OPT_NUMBER,
            .help = "when limiting by iops max size of an I/O in bytes",
2995 2996 2997 2998
        },{
            .name = "copy-on-read",
            .type = QEMU_OPT_BOOL,
            .help = "copy read data from backing file into image file",
2999 3000 3001 3002
        },{
            .name = "detect-zeroes",
            .type = QEMU_OPT_STRING,
            .help = "try to optimize zero writes (off, on, unmap)",
3003 3004 3005 3006
        },
        { /* end of list */ }
    },
};
3007 3008 3009 3010 3011

QemuOptsList qemu_drive_opts = {
    .name = "drive",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
    .desc = {
3012 3013 3014 3015
        /*
         * no elements => accept any params
         * validation will happen later
         */
3016 3017 3018
        { /* end of list */ }
    },
};