qemu

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

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

67
/* Protected by BQL */
68
QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states =
69
    QTAILQ_HEAD_INITIALIZER(monitor_bdrv_states);
70

71
void bdrv_set_monitor_owned(BlockDriverState *bs)
72
{
73
    GLOBAL_STATE_CODE();
74
    QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list);
75
}
76

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

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

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

117
    GLOBAL_STATE_CODE();
118

119
    if (max_devs <= 0) {
120
        return;
121
    }
122

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

133
    if_max_devs[type] = max_devs;
134
}
135

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

148
    GLOBAL_STATE_CODE();
149

150
    if (!dinfo) {
151
        return;
152
    }
153

154
    JOB_LOCK_GUARD();
155

156
    do {
157
        job = block_job_next_locked(NULL);
158
        while (job && (job->job.cancelled ||
159
                       job->job.deferred_to_main_loop ||
160
                       !block_job_has_bdrv(job, blk_bs(blk))))
161
        {
162
            job = block_job_next_locked(job);
163
        }
164
        if (job) {
165
            /*
166
             * This drops the job lock temporarily and polls, so we need to
167
             * restart processing the list from the start after this.
168
             */
169
            job_cancel_locked(&job->job, false);
170
        }
171
    } while (job);
172

173
    dinfo->auto_del = 1;
174
}
175

176
void blockdev_auto_del(BlockBackend *blk)
177
{
178
    DriveInfo *dinfo = blk_legacy_dinfo(blk);
179
    GLOBAL_STATE_CODE();
180

181
    if (dinfo && dinfo->auto_del) {
182
        monitor_remove_blk(blk);
183
        blk_unref(blk);
184
    }
185
}
186

187
static int drive_index_to_bus_id(BlockInterfaceType type, int index)
188
{
189
    int max_devs = if_max_devs[type];
190
    return max_devs ? index / max_devs : 0;
191
}
192

193
static int drive_index_to_unit_id(BlockInterfaceType type, int index)
194
{
195
    int max_devs = if_max_devs[type];
196
    return max_devs ? index % max_devs : index;
197
}
198

199
QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
200
                    const char *optstr)
201
{
202
    QemuOpts *opts;
203

204
    GLOBAL_STATE_CODE();
205

206
    opts = qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr, false);
207
    if (!opts) {
208
        return NULL;
209
    }
210
    if (type != IF_DEFAULT) {
211
        qemu_opt_set(opts, "if", if_name[type], &error_abort);
212
    }
213
    if (index >= 0) {
214
        qemu_opt_set_number(opts, "index", index, &error_abort);
215
    }
216
    if (file)
217
        qemu_opt_set(opts, "file", file, &error_abort);
218
    return opts;
219
}
220

221
DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
222
{
223
    BlockBackend *blk;
224
    DriveInfo *dinfo;
225

226
    GLOBAL_STATE_CODE();
227

228
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
229
        dinfo = blk_legacy_dinfo(blk);
230
        if (dinfo && dinfo->type == type
231
            && dinfo->bus == bus && dinfo->unit == unit) {
232
            return dinfo;
233
        }
234
    }
235

236
    return NULL;
237
}
238

239
/*
240
 * Check board claimed all -drive that are meant to be claimed.
241
 * Fatal error if any remain unclaimed.
242
 */
243
void drive_check_orphaned(void)
244
{
245
    BlockBackend *blk;
246
    DriveInfo *dinfo;
247
    Location loc;
248
    bool orphans = false;
249

250
    GLOBAL_STATE_CODE();
251

252
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
253
        dinfo = blk_legacy_dinfo(blk);
254
        /*
255
         * Ignore default drives, because we create certain default
256
         * drives unconditionally, then leave them unclaimed.  Not the
257
         * users fault.
258
         * Ignore IF_VIRTIO or IF_XEN, because it gets desugared into
259
         * -device, so we can leave failing to -device.
260
         * Ignore IF_NONE, because leaving unclaimed IF_NONE remains
261
         * available for device_add is a feature.
262
         */
263
        if (dinfo->is_default || dinfo->type == IF_VIRTIO
264
            || dinfo->type == IF_XEN || dinfo->type == IF_NONE) {
265
            continue;
266
        }
267
        if (!blk_get_attached_dev(blk)) {
268
            loc_push_none(&loc);
269
            qemu_opts_loc_restore(dinfo->opts);
270
            error_report("machine type does not support"
271
                         " if=%s,bus=%d,unit=%d",
272
                         if_name[dinfo->type], dinfo->bus, dinfo->unit);
273
            loc_pop(&loc);
274
            orphans = true;
275
        }
276
    }
277

278
    if (orphans) {
279
        exit(1);
280
    }
281
}
282

283
DriveInfo *drive_get_by_index(BlockInterfaceType type, int index)
284
{
285
    GLOBAL_STATE_CODE();
286
    return drive_get(type,
287
                     drive_index_to_bus_id(type, index),
288
                     drive_index_to_unit_id(type, index));
289
}
290

291
int drive_get_max_bus(BlockInterfaceType type)
292
{
293
    int max_bus;
294
    BlockBackend *blk;
295
    DriveInfo *dinfo;
296

297
    GLOBAL_STATE_CODE();
298

299
    max_bus = -1;
300
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
301
        dinfo = blk_legacy_dinfo(blk);
302
        if (dinfo && dinfo->type == type && dinfo->bus > max_bus) {
303
            max_bus = dinfo->bus;
304
        }
305
    }
306
    return max_bus;
307
}
308

309
static void bdrv_format_print(void *opaque, const char *name)
310
{
311
    qemu_printf(" %s", name);
312
}
313

314
typedef struct {
315
    QEMUBH *bh;
316
    BlockDriverState *bs;
317
} BDRVPutRefBH;
318

319
static int parse_block_error_action(const char *buf, bool is_read, Error **errp)
320
{
321
    if (!strcmp(buf, "ignore")) {
322
        return BLOCKDEV_ON_ERROR_IGNORE;
323
    } else if (!is_read && !strcmp(buf, "enospc")) {
324
        return BLOCKDEV_ON_ERROR_ENOSPC;
325
    } else if (!strcmp(buf, "stop")) {
326
        return BLOCKDEV_ON_ERROR_STOP;
327
    } else if (!strcmp(buf, "report")) {
328
        return BLOCKDEV_ON_ERROR_REPORT;
329
    } else {
330
        error_setg(errp, "'%s' invalid %s error action",
331
                   buf, is_read ? "read" : "write");
332
        return -1;
333
    }
334
}
335

336
static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals,
337
                                  Error **errp)
338
{
339
    const QListEntry *entry;
340
    for (entry = qlist_first(intervals); entry; entry = qlist_next(entry)) {
341
        switch (qobject_type(entry->value)) {
342

343
        case QTYPE_QSTRING: {
344
            uint64_t length;
345
            const char *str = qstring_get_str(qobject_to(QString,
346
                                                         entry->value));
347
            if (parse_uint_full(str, 10, &length) == 0 &&
348
                length > 0 && length <= UINT_MAX) {
349
                block_acct_add_interval(stats, (unsigned) length);
350
            } else {
351
                error_setg(errp, "Invalid interval length: %s", str);
352
                return false;
353
            }
354
            break;
355
        }
356

357
        case QTYPE_QNUM: {
358
            int64_t length = qnum_get_int(qobject_to(QNum, entry->value));
359

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

369
        default:
370
            error_setg(errp, "The specification of stats-intervals is invalid");
371
            return false;
372
        }
373
    }
374
    return true;
375
}
376

377
typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType;
378

379
/* All parameters but @opts are optional and may be set to NULL. */
380
static void extract_common_blockdev_options(QemuOpts *opts, int *bdrv_flags,
381
    const char **throttling_group, ThrottleConfig *throttle_cfg,
382
    BlockdevDetectZeroesOptions *detect_zeroes, Error **errp)
383
{
384
    Error *local_error = NULL;
385
    const char *aio;
386

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

392
        if ((aio = qemu_opt_get(opts, "aio")) != NULL) {
393
            if (bdrv_parse_aio(aio, bdrv_flags) < 0) {
394
                error_setg(errp, "invalid aio option");
395
                return;
396
            }
397
        }
398
    }
399

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

405
    if (throttle_cfg) {
406
        throttle_config_init(throttle_cfg);
407
        throttle_cfg->buckets[THROTTLE_BPS_TOTAL].avg =
408
            qemu_opt_get_number(opts, "throttling.bps-total", 0);
409
        throttle_cfg->buckets[THROTTLE_BPS_READ].avg  =
410
            qemu_opt_get_number(opts, "throttling.bps-read", 0);
411
        throttle_cfg->buckets[THROTTLE_BPS_WRITE].avg =
412
            qemu_opt_get_number(opts, "throttling.bps-write", 0);
413
        throttle_cfg->buckets[THROTTLE_OPS_TOTAL].avg =
414
            qemu_opt_get_number(opts, "throttling.iops-total", 0);
415
        throttle_cfg->buckets[THROTTLE_OPS_READ].avg =
416
            qemu_opt_get_number(opts, "throttling.iops-read", 0);
417
        throttle_cfg->buckets[THROTTLE_OPS_WRITE].avg =
418
            qemu_opt_get_number(opts, "throttling.iops-write", 0);
419

420
        throttle_cfg->buckets[THROTTLE_BPS_TOTAL].max =
421
            qemu_opt_get_number(opts, "throttling.bps-total-max", 0);
422
        throttle_cfg->buckets[THROTTLE_BPS_READ].max  =
423
            qemu_opt_get_number(opts, "throttling.bps-read-max", 0);
424
        throttle_cfg->buckets[THROTTLE_BPS_WRITE].max =
425
            qemu_opt_get_number(opts, "throttling.bps-write-max", 0);
426
        throttle_cfg->buckets[THROTTLE_OPS_TOTAL].max =
427
            qemu_opt_get_number(opts, "throttling.iops-total-max", 0);
428
        throttle_cfg->buckets[THROTTLE_OPS_READ].max =
429
            qemu_opt_get_number(opts, "throttling.iops-read-max", 0);
430
        throttle_cfg->buckets[THROTTLE_OPS_WRITE].max =
431
            qemu_opt_get_number(opts, "throttling.iops-write-max", 0);
432

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

446
        throttle_cfg->op_size =
447
            qemu_opt_get_number(opts, "throttling.iops-size", 0);
448

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

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

467
static OnOffAuto account_get_opt(QemuOpts *opts, const char *name)
468
{
469
    if (!qemu_opt_find(opts, name)) {
470
        return ON_OFF_AUTO_AUTO;
471
    }
472
    if (qemu_opt_get_bool(opts, name, true)) {
473
        return ON_OFF_AUTO_ON;
474
    }
475
    return ON_OFF_AUTO_OFF;
476
}
477

478
/* Takes the ownership of bs_opts */
479
static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
480
                                   Error **errp)
481
{
482
    const char *buf;
483
    int bdrv_flags = 0;
484
    int on_read_error, on_write_error;
485
    OnOffAuto account_invalid, account_failed;
486
    bool writethrough, read_only;
487
    BlockBackend *blk;
488
    BlockDriverState *bs;
489
    ThrottleConfig cfg;
490
    int snapshot = 0;
491
    Error *error = NULL;
492
    QemuOpts *opts;
493
    QDict *interval_dict = NULL;
494
    QList *interval_list = NULL;
495
    const char *id;
496
    BlockdevDetectZeroesOptions detect_zeroes =
497
        BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
498
    const char *throttling_group = NULL;
499

500
    /* Check common options by copying from bs_opts to opts, all other options
501
     * stay in bs_opts for processing by bdrv_open(). */
502
    id = qdict_get_try_str(bs_opts, "id");
503
    opts = qemu_opts_create(&qemu_common_drive_opts, id, 1, errp);
504
    if (!opts) {
505
        goto err_no_opts;
506
    }
507

508
    if (!qemu_opts_absorb_qdict(opts, bs_opts, errp)) {
509
        goto early_err;
510
    }
511

512
    if (id) {
513
        qdict_del(bs_opts, "id");
514
    }
515

516
    /* extract parameters */
517
    snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
518

519
    account_invalid = account_get_opt(opts, "stats-account-invalid");
520
    account_failed = account_get_opt(opts, "stats-account-failed");
521

522
    writethrough = !qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, true);
523

524
    id = qemu_opts_id(opts);
525

526
    qdict_extract_subqdict(bs_opts, &interval_dict, "stats-intervals.");
527
    qdict_array_split(interval_dict, &interval_list);
528

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

535
    extract_common_blockdev_options(opts, &bdrv_flags, &throttling_group, &cfg,
536
                                    &detect_zeroes, &error);
537
    if (error) {
538
        error_propagate(errp, error);
539
        goto early_err;
540
    }
541

542
    if ((buf = qemu_opt_get(opts, "format")) != NULL) {
543
        if (is_help_option(buf)) {
544
            qemu_printf("Supported formats:");
545
            bdrv_iterate_format(bdrv_format_print, NULL, false);
546
            qemu_printf("\nSupported formats (read-only):");
547
            bdrv_iterate_format(bdrv_format_print, NULL, true);
548
            qemu_printf("\n");
549
            goto early_err;
550
        }
551

552
        if (qdict_haskey(bs_opts, "driver")) {
553
            error_setg(errp, "Cannot specify both 'driver' and 'format'");
554
            goto early_err;
555
        }
556
        qdict_put_str(bs_opts, "driver", buf);
557
    }
558

559
    on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
560
    if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
561
        on_write_error = parse_block_error_action(buf, 0, &error);
562
        if (error) {
563
            error_propagate(errp, error);
564
            goto early_err;
565
        }
566
    }
567

568
    on_read_error = BLOCKDEV_ON_ERROR_REPORT;
569
    if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
570
        on_read_error = parse_block_error_action(buf, 1, &error);
571
        if (error) {
572
            error_propagate(errp, error);
573
            goto early_err;
574
        }
575
    }
576

577
    if (snapshot) {
578
        bdrv_flags |= BDRV_O_SNAPSHOT;
579
    }
580

581
    read_only = qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false);
582

583
    /* init */
584
    if ((!file || !*file) && !qdict_size(bs_opts)) {
585
        BlockBackendRootState *blk_rs;
586

587
        blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
588
        blk_rs = blk_get_root_state(blk);
589
        blk_rs->open_flags    = bdrv_flags | (read_only ? 0 : BDRV_O_RDWR);
590
        blk_rs->detect_zeroes = detect_zeroes;
591

592
        qobject_unref(bs_opts);
593
    } else {
594
        if (file && !*file) {
595
            file = NULL;
596
        }
597

598
        /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
599
         * with other callers) rather than what we want as the real defaults.
600
         * Apply the defaults here instead. */
601
        qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off");
602
        qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
603
        qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY,
604
                              read_only ? "on" : "off");
605
        qdict_set_default_str(bs_opts, BDRV_OPT_AUTO_READ_ONLY, "on");
606
        assert((bdrv_flags & BDRV_O_CACHE_MASK) == 0);
607

608
        if (runstate_check(RUN_STATE_INMIGRATE)) {
609
            bdrv_flags |= BDRV_O_INACTIVE;
610
        }
611

612
        blk = blk_new_open(file, NULL, bs_opts, bdrv_flags, errp);
613
        if (!blk) {
614
            goto err_no_bs_opts;
615
        }
616
        bs = blk_bs(blk);
617

618
        bs->detect_zeroes = detect_zeroes;
619

620
        block_acct_setup(blk_get_stats(blk), account_invalid, account_failed);
621

622
        if (!parse_stats_intervals(blk_get_stats(blk), interval_list, errp)) {
623
            blk_unref(blk);
624
            blk = NULL;
625
            goto err_no_bs_opts;
626
        }
627
    }
628

629
    /* disk I/O throttling */
630
    if (throttle_enabled(&cfg)) {
631
        if (!throttling_group) {
632
            throttling_group = id;
633
        }
634
        blk_io_limits_enable(blk, throttling_group);
635
        blk_set_io_limits(blk, &cfg);
636
    }
637

638
    blk_set_enable_write_cache(blk, !writethrough);
639
    blk_set_on_error(blk, on_read_error, on_write_error);
640

641
    if (!monitor_add_blk(blk, id, errp)) {
642
        blk_unref(blk);
643
        blk = NULL;
644
        goto err_no_bs_opts;
645
    }
646

647
err_no_bs_opts:
648
    qemu_opts_del(opts);
649
    qobject_unref(interval_dict);
650
    qobject_unref(interval_list);
651
    return blk;
652

653
early_err:
654
    qemu_opts_del(opts);
655
    qobject_unref(interval_dict);
656
    qobject_unref(interval_list);
657
err_no_opts:
658
    qobject_unref(bs_opts);
659
    return NULL;
660
}
661

662
/* Takes the ownership of bs_opts */
663
BlockDriverState *bds_tree_init(QDict *bs_opts, Error **errp)
664
{
665
    int bdrv_flags = 0;
666

667
    GLOBAL_STATE_CODE();
668
    /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
669
     * with other callers) rather than what we want as the real defaults.
670
     * Apply the defaults here instead. */
671
    qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off");
672
    qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
673
    qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY, "off");
674

675
    if (runstate_check(RUN_STATE_INMIGRATE)) {
676
        bdrv_flags |= BDRV_O_INACTIVE;
677
    }
678

679
    return bdrv_open(NULL, NULL, bs_opts, bdrv_flags, errp);
680
}
681

682
void blockdev_close_all_bdrv_states(void)
683
{
684
    BlockDriverState *bs, *next_bs;
685

686
    GLOBAL_STATE_CODE();
687
    QTAILQ_FOREACH_SAFE(bs, &monitor_bdrv_states, monitor_list, next_bs) {
688
        bdrv_unref(bs);
689
    }
690
}
691

692
/* Iterates over the list of monitor-owned BlockDriverStates */
693
BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs)
694
{
695
    GLOBAL_STATE_CODE();
696
    return bs ? QTAILQ_NEXT(bs, monitor_list)
697
              : QTAILQ_FIRST(&monitor_bdrv_states);
698
}
699

700
static bool qemu_opt_rename(QemuOpts *opts, const char *from, const char *to,
701
                            Error **errp)
702
{
703
    const char *value;
704

705
    value = qemu_opt_get(opts, from);
706
    if (value) {
707
        if (qemu_opt_find(opts, to)) {
708
            error_setg(errp, "'%s' and its alias '%s' can't be used at the "
709
                       "same time", to, from);
710
            return false;
711
        }
712
    }
713

714
    /* rename all items in opts */
715
    while ((value = qemu_opt_get(opts, from))) {
716
        qemu_opt_set(opts, to, value, &error_abort);
717
        qemu_opt_unset(opts, from);
718
    }
719
    return true;
720
}
721

722
QemuOptsList qemu_legacy_drive_opts = {
723
    .name = "drive",
724
    .head = QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts.head),
725
    .desc = {
726
        {
727
            .name = "bus",
728
            .type = QEMU_OPT_NUMBER,
729
            .help = "bus number",
730
        },{
731
            .name = "unit",
732
            .type = QEMU_OPT_NUMBER,
733
            .help = "unit number (i.e. lun for scsi)",
734
        },{
735
            .name = "index",
736
            .type = QEMU_OPT_NUMBER,
737
            .help = "index number",
738
        },{
739
            .name = "media",
740
            .type = QEMU_OPT_STRING,
741
            .help = "media type (disk, cdrom)",
742
        },{
743
            .name = "if",
744
            .type = QEMU_OPT_STRING,
745
            .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
746
        },{
747
            .name = "file",
748
            .type = QEMU_OPT_STRING,
749
            .help = "file name",
750
        },
751

752
        /* Options that are passed on, but have special semantics with -drive */
753
        {
754
            .name = BDRV_OPT_READ_ONLY,
755
            .type = QEMU_OPT_BOOL,
756
            .help = "open drive file as read-only",
757
        },{
758
            .name = "rerror",
759
            .type = QEMU_OPT_STRING,
760
            .help = "read error action",
761
        },{
762
            .name = "werror",
763
            .type = QEMU_OPT_STRING,
764
            .help = "write error action",
765
        },{
766
            .name = "copy-on-read",
767
            .type = QEMU_OPT_BOOL,
768
            .help = "copy read data from backing file into image file",
769
        },
770

771
        { /* end of list */ }
772
    },
773
};
774

775
DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type,
776
                     Error **errp)
777
{
778
    const char *value;
779
    BlockBackend *blk;
780
    DriveInfo *dinfo = NULL;
781
    QDict *bs_opts;
782
    QemuOpts *legacy_opts;
783
    DriveMediaType media = MEDIA_DISK;
784
    BlockInterfaceType type;
785
    int max_devs, bus_id, unit_id, index;
786
    const char *werror, *rerror;
787
    bool read_only = false;
788
    bool copy_on_read;
789
    const char *filename;
790
    int i;
791

792
    GLOBAL_STATE_CODE();
793

794
    /* Change legacy command line options into QMP ones */
795
    static const struct {
796
        const char *from;
797
        const char *to;
798
    } opt_renames[] = {
799
        { "iops",           "throttling.iops-total" },
800
        { "iops_rd",        "throttling.iops-read" },
801
        { "iops_wr",        "throttling.iops-write" },
802

803
        { "bps",            "throttling.bps-total" },
804
        { "bps_rd",         "throttling.bps-read" },
805
        { "bps_wr",         "throttling.bps-write" },
806

807
        { "iops_max",       "throttling.iops-total-max" },
808
        { "iops_rd_max",    "throttling.iops-read-max" },
809
        { "iops_wr_max",    "throttling.iops-write-max" },
810

811
        { "bps_max",        "throttling.bps-total-max" },
812
        { "bps_rd_max",     "throttling.bps-read-max" },
813
        { "bps_wr_max",     "throttling.bps-write-max" },
814

815
        { "iops_size",      "throttling.iops-size" },
816

817
        { "group",          "throttling.group" },
818

819
        { "readonly",       BDRV_OPT_READ_ONLY },
820
    };
821

822
    for (i = 0; i < ARRAY_SIZE(opt_renames); i++) {
823
        if (!qemu_opt_rename(all_opts, opt_renames[i].from,
824
                             opt_renames[i].to, errp)) {
825
            return NULL;
826
        }
827
    }
828

829
    value = qemu_opt_get(all_opts, "cache");
830
    if (value) {
831
        int flags = 0;
832
        bool writethrough;
833

834
        if (bdrv_parse_cache_mode(value, &flags, &writethrough) != 0) {
835
            error_setg(errp, "invalid cache option");
836
            return NULL;
837
        }
838

839
        /* Specific options take precedence */
840
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_WB)) {
841
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_WB,
842
                              !writethrough, &error_abort);
843
        }
844
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_DIRECT)) {
845
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_DIRECT,
846
                              !!(flags & BDRV_O_NOCACHE), &error_abort);
847
        }
848
        if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_NO_FLUSH)) {
849
            qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_NO_FLUSH,
850
                              !!(flags & BDRV_O_NO_FLUSH), &error_abort);
851
        }
852
        qemu_opt_unset(all_opts, "cache");
853
    }
854

855
    /* Get a QDict for processing the options */
856
    bs_opts = qdict_new();
857
    qemu_opts_to_qdict(all_opts, bs_opts);
858

859
    legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0,
860
                                   &error_abort);
861
    if (!qemu_opts_absorb_qdict(legacy_opts, bs_opts, errp)) {
862
        goto fail;
863
    }
864

865
    /* Media type */
866
    value = qemu_opt_get(legacy_opts, "media");
867
    if (value) {
868
        if (!strcmp(value, "disk")) {
869
            media = MEDIA_DISK;
870
        } else if (!strcmp(value, "cdrom")) {
871
            media = MEDIA_CDROM;
872
            read_only = true;
873
        } else {
874
            error_setg(errp, "'%s' invalid media", value);
875
            goto fail;
876
        }
877
    }
878

879
    /* copy-on-read is disabled with a warning for read-only devices */
880
    read_only |= qemu_opt_get_bool(legacy_opts, BDRV_OPT_READ_ONLY, false);
881
    copy_on_read = qemu_opt_get_bool(legacy_opts, "copy-on-read", false);
882

883
    if (read_only && copy_on_read) {
884
        warn_report("disabling copy-on-read on read-only drive");
885
        copy_on_read = false;
886
    }
887

888
    qdict_put_str(bs_opts, BDRV_OPT_READ_ONLY, read_only ? "on" : "off");
889
    qdict_put_str(bs_opts, "copy-on-read", copy_on_read ? "on" : "off");
890

891
    /* Controller type */
892
    value = qemu_opt_get(legacy_opts, "if");
893
    if (value) {
894
        for (type = 0;
895
             type < IF_COUNT && strcmp(value, if_name[type]);
896
             type++) {
897
        }
898
        if (type == IF_COUNT) {
899
            error_setg(errp, "unsupported bus type '%s'", value);
900
            goto fail;
901
        }
902
    } else {
903
        type = block_default_type;
904
    }
905

906
    /* Device address specified by bus/unit or index.
907
     * If none was specified, try to find the first free one. */
908
    bus_id  = qemu_opt_get_number(legacy_opts, "bus", 0);
909
    unit_id = qemu_opt_get_number(legacy_opts, "unit", -1);
910
    index   = qemu_opt_get_number(legacy_opts, "index", -1);
911

912
    max_devs = if_max_devs[type];
913

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

923
    if (unit_id == -1) {
924
       unit_id = 0;
925
       while (drive_get(type, bus_id, unit_id) != NULL) {
926
           unit_id++;
927
           if (max_devs && unit_id >= max_devs) {
928
               unit_id -= max_devs;
929
               bus_id++;
930
           }
931
       }
932
    }
933

934
    if (max_devs && unit_id >= max_devs) {
935
        error_setg(errp, "unit %d too big (max is %d)", unit_id, max_devs - 1);
936
        goto fail;
937
    }
938

939
    if (drive_get(type, bus_id, unit_id) != NULL) {
940
        error_setg(errp, "drive with bus=%d, unit=%d (index=%d) exists",
941
                   bus_id, unit_id, index);
942
        goto fail;
943
    }
944

945
    /* no id supplied -> create one */
946
    if (qemu_opts_id(all_opts) == NULL) {
947
        char *new_id;
948
        const char *mediastr = "";
949
        if (type == IF_IDE || type == IF_SCSI) {
950
            mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
951
        }
952
        if (max_devs) {
953
            new_id = g_strdup_printf("%s%i%s%i", if_name[type], bus_id,
954
                                     mediastr, unit_id);
955
        } else {
956
            new_id = g_strdup_printf("%s%s%i", if_name[type],
957
                                     mediastr, unit_id);
958
        }
959
        qdict_put_str(bs_opts, "id", new_id);
960
        g_free(new_id);
961
    }
962

963
    /* Add virtio block device */
964
    if (type == IF_VIRTIO) {
965
        QemuOpts *devopts;
966
        devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
967
                                   &error_abort);
968
        qemu_opt_set(devopts, "driver", "virtio-blk", &error_abort);
969
        qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
970
                     &error_abort);
971
    } else if (type == IF_XEN) {
972
        QemuOpts *devopts;
973
        devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
974
                                   &error_abort);
975
        qemu_opt_set(devopts, "driver",
976
                     (media == MEDIA_CDROM) ? "xen-cdrom" : "xen-disk",
977
                     &error_abort);
978
        qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
979
                     &error_abort);
980
    }
981

982
    filename = qemu_opt_get(legacy_opts, "file");
983

984
    /* Check werror/rerror compatibility with if=... */
985
    werror = qemu_opt_get(legacy_opts, "werror");
986
    if (werror != NULL) {
987
        if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO &&
988
            type != IF_NONE) {
989
            error_setg(errp, "werror is not supported by this bus type");
990
            goto fail;
991
        }
992
        qdict_put_str(bs_opts, "werror", werror);
993
    }
994

995
    rerror = qemu_opt_get(legacy_opts, "rerror");
996
    if (rerror != NULL) {
997
        if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI &&
998
            type != IF_NONE) {
999
            error_setg(errp, "rerror is not supported by this bus type");
1000
            goto fail;
1001
        }
1002
        qdict_put_str(bs_opts, "rerror", rerror);
1003
    }
1004

1005
    /* Actual block device init: Functionality shared with blockdev-add */
1006
    blk = blockdev_init(filename, bs_opts, errp);
1007
    bs_opts = NULL;
1008
    if (!blk) {
1009
        goto fail;
1010
    }
1011

1012
    /* Create legacy DriveInfo */
1013
    dinfo = g_malloc0(sizeof(*dinfo));
1014
    dinfo->opts = all_opts;
1015

1016
    dinfo->type = type;
1017
    dinfo->bus = bus_id;
1018
    dinfo->unit = unit_id;
1019

1020
    blk_set_legacy_dinfo(blk, dinfo);
1021

1022
    switch(type) {
1023
    case IF_IDE:
1024
    case IF_SCSI:
1025
    case IF_XEN:
1026
    case IF_NONE:
1027
        dinfo->media_cd = media == MEDIA_CDROM;
1028
        break;
1029
    default:
1030
        break;
1031
    }
1032

1033
fail:
1034
    qemu_opts_del(legacy_opts);
1035
    qobject_unref(bs_opts);
1036
    return dinfo;
1037
}
1038

1039
static BlockDriverState *qmp_get_root_bs(const char *name, Error **errp)
1040
{
1041
    BlockDriverState *bs;
1042

1043
    GRAPH_RDLOCK_GUARD_MAINLOOP();
1044

1045
    bs = bdrv_lookup_bs(name, name, errp);
1046
    if (bs == NULL) {
1047
        return NULL;
1048
    }
1049

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

1055
    if (!bdrv_is_inserted(bs)) {
1056
        error_setg(errp, "Device has no medium");
1057
        bs = NULL;
1058
    }
1059

1060
    return bs;
1061
}
1062

1063
static void blockdev_do_action(TransactionAction *action, Error **errp)
1064
{
1065
    TransactionActionList list;
1066

1067
    list.value = action;
1068
    list.next = NULL;
1069
    qmp_transaction(&list, NULL, errp);
1070
}
1071

1072
void qmp_blockdev_snapshot_sync(const char *device, const char *node_name,
1073
                                const char *snapshot_file,
1074
                                const char *snapshot_node_name,
1075
                                const char *format,
1076
                                bool has_mode, NewImageMode mode, Error **errp)
1077
{
1078
    BlockdevSnapshotSync snapshot = {
1079
        .device = (char *) device,
1080
        .node_name = (char *) node_name,
1081
        .snapshot_file = (char *) snapshot_file,
1082
        .snapshot_node_name = (char *) snapshot_node_name,
1083
        .format = (char *) format,
1084
        .has_mode = has_mode,
1085
        .mode = mode,
1086
    };
1087
    TransactionAction action = {
1088
        .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC,
1089
        .u.blockdev_snapshot_sync.data = &snapshot,
1090
    };
1091
    blockdev_do_action(&action, errp);
1092
}
1093

1094
void qmp_blockdev_snapshot(const char *node, const char *overlay,
1095
                           Error **errp)
1096
{
1097
    BlockdevSnapshot snapshot_data = {
1098
        .node = (char *) node,
1099
        .overlay = (char *) overlay
1100
    };
1101
    TransactionAction action = {
1102
        .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT,
1103
        .u.blockdev_snapshot.data = &snapshot_data,
1104
    };
1105
    blockdev_do_action(&action, errp);
1106
}
1107

1108
void qmp_blockdev_snapshot_internal_sync(const char *device,
1109
                                         const char *name,
1110
                                         Error **errp)
1111
{
1112
    BlockdevSnapshotInternal snapshot = {
1113
        .device = (char *) device,
1114
        .name = (char *) name
1115
    };
1116
    TransactionAction action = {
1117
        .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
1118
        .u.blockdev_snapshot_internal_sync.data = &snapshot,
1119
    };
1120
    blockdev_do_action(&action, errp);
1121
}
1122

1123
SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
1124
                                                         const char *id,
1125
                                                         const char *name,
1126
                                                         Error **errp)
1127
{
1128
    BlockDriverState *bs;
1129
    QEMUSnapshotInfo sn;
1130
    Error *local_err = NULL;
1131
    SnapshotInfo *info = NULL;
1132
    int ret;
1133

1134
    GLOBAL_STATE_CODE();
1135
    GRAPH_RDLOCK_GUARD_MAINLOOP();
1136

1137
    bs = qmp_get_root_bs(device, errp);
1138
    if (!bs) {
1139
        return NULL;
1140
    }
1141

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

1147
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, errp)) {
1148
        return NULL;
1149
    }
1150

1151
    ret = bdrv_snapshot_find_by_id_and_name(bs, id, name, &sn, &local_err);
1152
    if (local_err) {
1153
        error_propagate(errp, local_err);
1154
        return NULL;
1155
    }
1156
    if (!ret) {
1157
        error_setg(errp,
1158
                   "Snapshot with id '%s' and name '%s' does not exist on "
1159
                   "device '%s'",
1160
                   STR_OR_NULL(id), STR_OR_NULL(name), device);
1161
        return NULL;
1162
    }
1163

1164
    bdrv_snapshot_delete(bs, id, name, &local_err);
1165
    if (local_err) {
1166
        error_propagate(errp, local_err);
1167
        return NULL;
1168
    }
1169

1170
    info = g_new0(SnapshotInfo, 1);
1171
    info->id = g_strdup(sn.id_str);
1172
    info->name = g_strdup(sn.name);
1173
    info->date_nsec = sn.date_nsec;
1174
    info->date_sec = sn.date_sec;
1175
    info->vm_state_size = sn.vm_state_size;
1176
    info->vm_clock_nsec = sn.vm_clock_nsec % 1000000000;
1177
    info->vm_clock_sec = sn.vm_clock_nsec / 1000000000;
1178
    if (sn.icount != -1ULL) {
1179
        info->icount = sn.icount;
1180
        info->has_icount = true;
1181
    }
1182

1183
    return info;
1184
}
1185

1186
/* internal snapshot private data */
1187
typedef struct InternalSnapshotState {
1188
    BlockDriverState *bs;
1189
    QEMUSnapshotInfo sn;
1190
    bool created;
1191
} InternalSnapshotState;
1192

1193
static void internal_snapshot_abort(void *opaque);
1194
static void internal_snapshot_clean(void *opaque);
1195
TransactionActionDrv internal_snapshot_drv = {
1196
    .abort = internal_snapshot_abort,
1197
    .clean = internal_snapshot_clean,
1198
};
1199

1200
static void internal_snapshot_action(BlockdevSnapshotInternal *internal,
1201
                                     Transaction *tran, Error **errp)
1202
{
1203
    Error *local_err = NULL;
1204
    const char *device;
1205
    const char *name;
1206
    BlockDriverState *bs;
1207
    QEMUSnapshotInfo old_sn, *sn;
1208
    bool ret;
1209
    int64_t rt;
1210
    InternalSnapshotState *state = g_new0(InternalSnapshotState, 1);
1211
    int ret1;
1212

1213
    GLOBAL_STATE_CODE();
1214
    GRAPH_RDLOCK_GUARD_MAINLOOP();
1215

1216
    tran_add(tran, &internal_snapshot_drv, state);
1217

1218
    device = internal->device;
1219
    name = internal->name;
1220

1221
    bs = qmp_get_root_bs(device, errp);
1222
    if (!bs) {
1223
        return;
1224
    }
1225

1226
    state->bs = bs;
1227

1228
    /* Paired with .clean() */
1229
    bdrv_drained_begin(bs);
1230

1231
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, errp)) {
1232
        return;
1233
    }
1234

1235
    if (bdrv_is_read_only(bs)) {
1236
        error_setg(errp, "Device '%s' is read only", device);
1237
        return;
1238
    }
1239

1240
    if (!bdrv_can_snapshot(bs)) {
1241
        error_setg(errp, "Block format '%s' used by device '%s' "
1242
                   "does not support internal snapshots",
1243
                   bs->drv->format_name, device);
1244
        return;
1245
    }
1246

1247
    if (!strlen(name)) {
1248
        error_setg(errp, "Name is empty");
1249
        return;
1250
    }
1251

1252
    /* check whether a snapshot with name exist */
1253
    ret = bdrv_snapshot_find_by_id_and_name(bs, NULL, name, &old_sn,
1254
                                            &local_err);
1255
    if (local_err) {
1256
        error_propagate(errp, local_err);
1257
        return;
1258
    } else if (ret) {
1259
        error_setg(errp,
1260
                   "Snapshot with name '%s' already exists on device '%s'",
1261
                   name, device);
1262
        return;
1263
    }
1264

1265
    /* 3. take the snapshot */
1266
    sn = &state->sn;
1267
    pstrcpy(sn->name, sizeof(sn->name), name);
1268
    rt = g_get_real_time();
1269
    sn->date_sec = rt / G_USEC_PER_SEC;
1270
    sn->date_nsec = (rt % G_USEC_PER_SEC) * 1000;
1271
    sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
1272
    if (replay_mode != REPLAY_MODE_NONE) {
1273
        sn->icount = replay_get_current_icount();
1274
    } else {
1275
        sn->icount = -1ULL;
1276
    }
1277

1278
    ret1 = bdrv_snapshot_create(bs, sn);
1279
    if (ret1 < 0) {
1280
        error_setg_errno(errp, -ret1,
1281
                         "Failed to create snapshot '%s' on device '%s'",
1282
                         name, device);
1283
        return;
1284
    }
1285

1286
    /* 4. succeed, mark a snapshot is created */
1287
    state->created = true;
1288
}
1289

1290
static void internal_snapshot_abort(void *opaque)
1291
{
1292
    InternalSnapshotState *state = opaque;
1293
    BlockDriverState *bs = state->bs;
1294
    QEMUSnapshotInfo *sn = &state->sn;
1295
    Error *local_error = NULL;
1296

1297
    GLOBAL_STATE_CODE();
1298
    GRAPH_RDLOCK_GUARD_MAINLOOP();
1299

1300
    if (!state->created) {
1301
        return;
1302
    }
1303

1304
    if (bdrv_snapshot_delete(bs, sn->id_str, sn->name, &local_error) < 0) {
1305
        error_reportf_err(local_error,
1306
                          "Failed to delete snapshot with id '%s' and "
1307
                          "name '%s' on device '%s' in abort: ",
1308
                          sn->id_str, sn->name,
1309
                          bdrv_get_device_name(bs));
1310
    }
1311
}
1312

1313
static void internal_snapshot_clean(void *opaque)
1314
{
1315
    g_autofree InternalSnapshotState *state = opaque;
1316

1317
    if (!state->bs) {
1318
        return;
1319
    }
1320

1321
    bdrv_drained_end(state->bs);
1322
}
1323

1324
/* external snapshot private data */
1325
typedef struct ExternalSnapshotState {
1326
    BlockDriverState *old_bs;
1327
    BlockDriverState *new_bs;
1328
    bool overlay_appended;
1329
} ExternalSnapshotState;
1330

1331
static void external_snapshot_commit(void *opaque);
1332
static void external_snapshot_abort(void *opaque);
1333
static void external_snapshot_clean(void *opaque);
1334
TransactionActionDrv external_snapshot_drv = {
1335
    .commit = external_snapshot_commit,
1336
    .abort = external_snapshot_abort,
1337
    .clean = external_snapshot_clean,
1338
};
1339

1340
static void external_snapshot_action(TransactionAction *action,
1341
                                     Transaction *tran, Error **errp)
1342
{
1343
    int ret;
1344
    int flags = 0;
1345
    QDict *options = NULL;
1346
    Error *local_err = NULL;
1347
    /* Device and node name of the image to generate the snapshot from */
1348
    const char *device;
1349
    const char *node_name;
1350
    /* Reference to the new image (for 'blockdev-snapshot') */
1351
    const char *snapshot_ref;
1352
    /* File name of the new image (for 'blockdev-snapshot-sync') */
1353
    const char *new_image_file;
1354
    ExternalSnapshotState *state = g_new0(ExternalSnapshotState, 1);
1355
    uint64_t perm, shared;
1356

1357
    /* TODO We'll eventually have to take a writer lock in this function */
1358
    GRAPH_RDLOCK_GUARD_MAINLOOP();
1359

1360
    tran_add(tran, &external_snapshot_drv, state);
1361

1362
    /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
1363
     * purpose but a different set of parameters */
1364
    switch (action->type) {
1365
    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
1366
        {
1367
            BlockdevSnapshot *s = action->u.blockdev_snapshot.data;
1368
            device = s->node;
1369
            node_name = s->node;
1370
            new_image_file = NULL;
1371
            snapshot_ref = s->overlay;
1372
        }
1373
        break;
1374
    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
1375
        {
1376
            BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1377
            device = s->device;
1378
            node_name = s->node_name;
1379
            new_image_file = s->snapshot_file;
1380
            snapshot_ref = NULL;
1381
        }
1382
        break;
1383
    default:
1384
        g_assert_not_reached();
1385
    }
1386

1387
    /* start processing */
1388

1389
    state->old_bs = bdrv_lookup_bs(device, node_name, errp);
1390
    if (!state->old_bs) {
1391
        return;
1392
    }
1393

1394
    /* Paired with .clean() */
1395
    bdrv_drained_begin(state->old_bs);
1396

1397
    if (!bdrv_is_inserted(state->old_bs)) {
1398
        error_setg(errp, "Device '%s' has no medium",
1399
                   bdrv_get_device_or_node_name(state->old_bs));
1400
        return;
1401
    }
1402

1403
    if (bdrv_op_is_blocked(state->old_bs,
1404
                           BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) {
1405
        return;
1406
    }
1407

1408
    if (!bdrv_is_read_only(state->old_bs)) {
1409
        ret = bdrv_flush(state->old_bs);
1410
        if (ret < 0) {
1411
            error_setg_errno(errp, -ret, "Write to node '%s' failed",
1412
                             bdrv_get_device_or_node_name(state->old_bs));
1413
            return;
1414
        }
1415
    }
1416

1417
    if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) {
1418
        BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1419
        const char *format = s->format ?: "qcow2";
1420
        enum NewImageMode mode;
1421
        const char *snapshot_node_name = s->snapshot_node_name;
1422

1423
        if (node_name && !snapshot_node_name) {
1424
            error_setg(errp, "New overlay node-name missing");
1425
            return;
1426
        }
1427

1428
        if (snapshot_node_name &&
1429
            bdrv_lookup_bs(snapshot_node_name, snapshot_node_name, NULL)) {
1430
            error_setg(errp, "New overlay node-name already in use");
1431
            return;
1432
        }
1433

1434
        flags = state->old_bs->open_flags;
1435
        flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_COPY_ON_READ);
1436
        flags |= BDRV_O_NO_BACKING;
1437

1438
        /* create new image w/backing file */
1439
        mode = s->has_mode ? s->mode : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1440
        if (mode != NEW_IMAGE_MODE_EXISTING) {
1441
            int64_t size = bdrv_getlength(state->old_bs);
1442
            if (size < 0) {
1443
                error_setg_errno(errp, -size, "bdrv_getlength failed");
1444
                return;
1445
            }
1446
            bdrv_refresh_filename(state->old_bs);
1447

1448
            bdrv_img_create(new_image_file, format,
1449
                            state->old_bs->filename,
1450
                            state->old_bs->drv->format_name,
1451
                            NULL, size, flags, false, &local_err);
1452

1453
            if (local_err) {
1454
                error_propagate(errp, local_err);
1455
                return;
1456
            }
1457
        }
1458

1459
        options = qdict_new();
1460
        if (snapshot_node_name) {
1461
            qdict_put_str(options, "node-name", snapshot_node_name);
1462
        }
1463
        qdict_put_str(options, "driver", format);
1464
    }
1465

1466
    state->new_bs = bdrv_open(new_image_file, snapshot_ref, options, flags,
1467
                              errp);
1468

1469
    /* We will manually add the backing_hd field to the bs later */
1470
    if (!state->new_bs) {
1471
        return;
1472
    }
1473

1474
    /*
1475
     * Allow attaching a backing file to an overlay that's already in use only
1476
     * if the parents don't assume that they are already seeing a valid image.
1477
     * (Specifically, allow it as a mirror target, which is write-only access.)
1478
     */
1479
    bdrv_get_cumulative_perm(state->new_bs, &perm, &shared);
1480
    if (perm & BLK_PERM_CONSISTENT_READ) {
1481
        error_setg(errp, "The overlay is already in use");
1482
        return;
1483
    }
1484

1485
    if (state->new_bs->drv->is_filter) {
1486
        error_setg(errp, "Filters cannot be used as overlays");
1487
        return;
1488
    }
1489

1490
    if (bdrv_cow_child(state->new_bs)) {
1491
        error_setg(errp, "The overlay already has a backing image");
1492
        return;
1493
    }
1494

1495
    if (!state->new_bs->drv->supports_backing) {
1496
        error_setg(errp, "The overlay does not support backing images");
1497
        return;
1498
    }
1499

1500
    ret = bdrv_append(state->new_bs, state->old_bs, errp);
1501
    if (ret < 0) {
1502
        return;
1503
    }
1504
    state->overlay_appended = true;
1505
}
1506

1507
static void external_snapshot_commit(void *opaque)
1508
{
1509
    ExternalSnapshotState *state = opaque;
1510

1511
    /* We don't need (or want) to use the transactional
1512
     * bdrv_reopen_multiple() across all the entries at once, because we
1513
     * don't want to abort all of them if one of them fails the reopen */
1514
    if (!qatomic_read(&state->old_bs->copy_on_read)) {
1515
        bdrv_reopen_set_read_only(state->old_bs, true, NULL);
1516
    }
1517
}
1518

1519
static void external_snapshot_abort(void *opaque)
1520
{
1521
    ExternalSnapshotState *state = opaque;
1522
    if (state->new_bs) {
1523
        if (state->overlay_appended) {
1524
            AioContext *aio_context;
1525
            AioContext *tmp_context;
1526
            int ret;
1527

1528
            aio_context = bdrv_get_aio_context(state->old_bs);
1529

1530
            bdrv_ref(state->old_bs);   /* we can't let bdrv_set_backind_hd()
1531
                                          close state->old_bs; we need it */
1532
            bdrv_set_backing_hd(state->new_bs, NULL, &error_abort);
1533

1534
            /*
1535
             * The call to bdrv_set_backing_hd() above returns state->old_bs to
1536
             * the main AioContext. As we're still going to be using it, return
1537
             * it to the AioContext it was before.
1538
             */
1539
            tmp_context = bdrv_get_aio_context(state->old_bs);
1540
            if (aio_context != tmp_context) {
1541
                ret = bdrv_try_change_aio_context(state->old_bs,
1542
                                                  aio_context, NULL, NULL);
1543
                assert(ret == 0);
1544
            }
1545

1546
            bdrv_drained_begin(state->new_bs);
1547
            bdrv_graph_wrlock();
1548
            bdrv_replace_node(state->new_bs, state->old_bs, &error_abort);
1549
            bdrv_graph_wrunlock();
1550
            bdrv_drained_end(state->new_bs);
1551

1552
            bdrv_unref(state->old_bs); /* bdrv_replace_node() ref'ed old_bs */
1553
        }
1554
    }
1555
}
1556

1557
static void external_snapshot_clean(void *opaque)
1558
{
1559
    g_autofree ExternalSnapshotState *state = opaque;
1560

1561
    if (!state->old_bs) {
1562
        return;
1563
    }
1564

1565
    bdrv_drained_end(state->old_bs);
1566
    bdrv_unref(state->new_bs);
1567
}
1568

1569
typedef struct DriveBackupState {
1570
    BlockDriverState *bs;
1571
    BlockJob *job;
1572
} DriveBackupState;
1573

1574
static BlockJob *do_backup_common(BackupCommon *backup,
1575
                                  BlockDriverState *bs,
1576
                                  BlockDriverState *target_bs,
1577
                                  AioContext *aio_context,
1578
                                  JobTxn *txn, Error **errp);
1579

1580
static void drive_backup_commit(void *opaque);
1581
static void drive_backup_abort(void *opaque);
1582
static void drive_backup_clean(void *opaque);
1583
TransactionActionDrv drive_backup_drv = {
1584
    .commit = drive_backup_commit,
1585
    .abort = drive_backup_abort,
1586
    .clean = drive_backup_clean,
1587
};
1588

1589
static void drive_backup_action(DriveBackup *backup,
1590
                                JobTxn *block_job_txn,
1591
                                Transaction *tran, Error **errp)
1592
{
1593
    DriveBackupState *state = g_new0(DriveBackupState, 1);
1594
    BlockDriverState *bs;
1595
    BlockDriverState *target_bs;
1596
    BlockDriverState *source = NULL;
1597
    AioContext *aio_context;
1598
    const char *format;
1599
    QDict *options;
1600
    Error *local_err = NULL;
1601
    int flags;
1602
    int64_t size;
1603
    bool set_backing_hd = false;
1604
    int ret;
1605

1606
    GLOBAL_STATE_CODE();
1607

1608
    tran_add(tran, &drive_backup_drv, state);
1609

1610
    if (!backup->has_mode) {
1611
        backup->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1612
    }
1613

1614
    bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1615
    if (!bs) {
1616
        return;
1617
    }
1618

1619
    if (!bs->drv) {
1620
        error_setg(errp, "Device has no medium");
1621
        return;
1622
    }
1623

1624
    aio_context = bdrv_get_aio_context(bs);
1625

1626
    state->bs = bs;
1627
    /* Paired with .clean() */
1628
    bdrv_drained_begin(bs);
1629

1630
    format = backup->format;
1631
    if (!format && backup->mode != NEW_IMAGE_MODE_EXISTING) {
1632
        format = bs->drv->format_name;
1633
    }
1634

1635
    /* Early check to avoid creating target */
1636
    bdrv_graph_rdlock_main_loop();
1637
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
1638
        bdrv_graph_rdunlock_main_loop();
1639
        return;
1640
    }
1641

1642
    flags = bs->open_flags | BDRV_O_RDWR;
1643

1644
    /*
1645
     * See if we have a backing HD we can use to create our new image
1646
     * on top of.
1647
     */
1648
    if (backup->sync == MIRROR_SYNC_MODE_TOP) {
1649
        /*
1650
         * Backup will not replace the source by the target, so none
1651
         * of the filters skipped here will be removed (in contrast to
1652
         * mirror).  Therefore, we can skip all of them when looking
1653
         * for the first COW relationship.
1654
         */
1655
        source = bdrv_cow_bs(bdrv_skip_filters(bs));
1656
        if (!source) {
1657
            backup->sync = MIRROR_SYNC_MODE_FULL;
1658
        }
1659
    }
1660
    if (backup->sync == MIRROR_SYNC_MODE_NONE) {
1661
        source = bs;
1662
        flags |= BDRV_O_NO_BACKING;
1663
        set_backing_hd = true;
1664
    }
1665
    bdrv_graph_rdunlock_main_loop();
1666

1667
    size = bdrv_getlength(bs);
1668
    if (size < 0) {
1669
        error_setg_errno(errp, -size, "bdrv_getlength failed");
1670
        return;
1671
    }
1672

1673
    if (backup->mode != NEW_IMAGE_MODE_EXISTING) {
1674
        assert(format);
1675
        if (source) {
1676
            /* Implicit filters should not appear in the filename */
1677
            BlockDriverState *explicit_backing;
1678

1679
            bdrv_graph_rdlock_main_loop();
1680
            explicit_backing = bdrv_skip_implicit_filters(source);
1681
            bdrv_refresh_filename(explicit_backing);
1682
            bdrv_graph_rdunlock_main_loop();
1683

1684
            bdrv_img_create(backup->target, format,
1685
                            explicit_backing->filename,
1686
                            explicit_backing->drv->format_name, NULL,
1687
                            size, flags, false, &local_err);
1688
        } else {
1689
            bdrv_img_create(backup->target, format, NULL, NULL, NULL,
1690
                            size, flags, false, &local_err);
1691
        }
1692
    }
1693

1694
    if (local_err) {
1695
        error_propagate(errp, local_err);
1696
        return;
1697
    }
1698

1699
    options = qdict_new();
1700
    qdict_put_str(options, "discard", "unmap");
1701
    qdict_put_str(options, "detect-zeroes", "unmap");
1702
    if (format) {
1703
        qdict_put_str(options, "driver", format);
1704
    }
1705

1706
    target_bs = bdrv_open(backup->target, NULL, options, flags, errp);
1707
    if (!target_bs) {
1708
        return;
1709
    }
1710

1711
    ret = bdrv_try_change_aio_context(target_bs, aio_context, NULL, errp);
1712
    if (ret < 0) {
1713
        bdrv_unref(target_bs);
1714
        return;
1715
    }
1716

1717
    if (set_backing_hd) {
1718
        if (bdrv_set_backing_hd(target_bs, source, errp) < 0) {
1719
            goto unref;
1720
        }
1721
    }
1722

1723
    state->job = do_backup_common(qapi_DriveBackup_base(backup),
1724
                                  bs, target_bs, aio_context,
1725
                                  block_job_txn, errp);
1726

1727
unref:
1728
    bdrv_unref(target_bs);
1729
}
1730

1731
static void drive_backup_commit(void *opaque)
1732
{
1733
    DriveBackupState *state = opaque;
1734

1735
    assert(state->job);
1736
    job_start(&state->job->job);
1737
}
1738

1739
static void drive_backup_abort(void *opaque)
1740
{
1741
    DriveBackupState *state = opaque;
1742

1743
    if (state->job) {
1744
        job_cancel_sync(&state->job->job, true);
1745
    }
1746
}
1747

1748
static void drive_backup_clean(void *opaque)
1749
{
1750
    g_autofree DriveBackupState *state = opaque;
1751

1752
    if (!state->bs) {
1753
        return;
1754
    }
1755

1756
    bdrv_drained_end(state->bs);
1757
}
1758

1759
typedef struct BlockdevBackupState {
1760
    BlockDriverState *bs;
1761
    BlockJob *job;
1762
} BlockdevBackupState;
1763

1764
static void blockdev_backup_commit(void *opaque);
1765
static void blockdev_backup_abort(void *opaque);
1766
static void blockdev_backup_clean(void *opaque);
1767
TransactionActionDrv blockdev_backup_drv = {
1768
    .commit = blockdev_backup_commit,
1769
    .abort = blockdev_backup_abort,
1770
    .clean = blockdev_backup_clean,
1771
};
1772

1773
static void blockdev_backup_action(BlockdevBackup *backup,
1774
                                   JobTxn *block_job_txn,
1775
                                   Transaction *tran, Error **errp)
1776
{
1777
    BlockdevBackupState *state = g_new0(BlockdevBackupState, 1);
1778
    BlockDriverState *bs;
1779
    BlockDriverState *target_bs;
1780
    AioContext *aio_context;
1781
    int ret;
1782

1783
    tran_add(tran, &blockdev_backup_drv, state);
1784

1785
    bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1786
    if (!bs) {
1787
        return;
1788
    }
1789

1790
    target_bs = bdrv_lookup_bs(backup->target, backup->target, errp);
1791
    if (!target_bs) {
1792
        return;
1793
    }
1794

1795
    /* Honor bdrv_try_change_aio_context() context acquisition requirements. */
1796
    aio_context = bdrv_get_aio_context(bs);
1797

1798
    ret = bdrv_try_change_aio_context(target_bs, aio_context, NULL, errp);
1799
    if (ret < 0) {
1800
        return;
1801
    }
1802

1803
    state->bs = bs;
1804

1805
    /* Paired with .clean() */
1806
    bdrv_drained_begin(state->bs);
1807

1808
    state->job = do_backup_common(qapi_BlockdevBackup_base(backup),
1809
                                  bs, target_bs, aio_context,
1810
                                  block_job_txn, errp);
1811
}
1812

1813
static void blockdev_backup_commit(void *opaque)
1814
{
1815
    BlockdevBackupState *state = opaque;
1816

1817
    assert(state->job);
1818
    job_start(&state->job->job);
1819
}
1820

1821
static void blockdev_backup_abort(void *opaque)
1822
{
1823
    BlockdevBackupState *state = opaque;
1824

1825
    if (state->job) {
1826
        job_cancel_sync(&state->job->job, true);
1827
    }
1828
}
1829

1830
static void blockdev_backup_clean(void *opaque)
1831
{
1832
    g_autofree BlockdevBackupState *state = opaque;
1833

1834
    if (!state->bs) {
1835
        return;
1836
    }
1837

1838
    bdrv_drained_end(state->bs);
1839
}
1840

1841
typedef struct BlockDirtyBitmapState {
1842
    BdrvDirtyBitmap *bitmap;
1843
    BlockDriverState *bs;
1844
    HBitmap *backup;
1845
    bool was_enabled;
1846
} BlockDirtyBitmapState;
1847

1848
static void block_dirty_bitmap_add_abort(void *opaque);
1849
TransactionActionDrv block_dirty_bitmap_add_drv = {
1850
    .abort = block_dirty_bitmap_add_abort,
1851
    .clean = g_free,
1852
};
1853

1854
static void block_dirty_bitmap_add_action(BlockDirtyBitmapAdd *action,
1855
                                          Transaction *tran, Error **errp)
1856
{
1857
    Error *local_err = NULL;
1858
    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
1859

1860
    tran_add(tran, &block_dirty_bitmap_add_drv, state);
1861

1862
    /* AIO context taken and released within qmp_block_dirty_bitmap_add */
1863
    qmp_block_dirty_bitmap_add(action->node, action->name,
1864
                               action->has_granularity, action->granularity,
1865
                               action->has_persistent, action->persistent,
1866
                               action->has_disabled, action->disabled,
1867
                               &local_err);
1868

1869
    if (!local_err) {
1870
        state->bitmap = block_dirty_bitmap_lookup(action->node, action->name,
1871
                                                  NULL, &error_abort);
1872
    } else {
1873
        error_propagate(errp, local_err);
1874
    }
1875
}
1876

1877
static void block_dirty_bitmap_add_abort(void *opaque)
1878
{
1879
    BlockDirtyBitmapState *state = opaque;
1880

1881
    if (state->bitmap) {
1882
        bdrv_release_dirty_bitmap(state->bitmap);
1883
    }
1884
}
1885

1886
static void block_dirty_bitmap_restore(void *opaque);
1887
static void block_dirty_bitmap_free_backup(void *opaque);
1888
TransactionActionDrv block_dirty_bitmap_clear_drv = {
1889
    .abort = block_dirty_bitmap_restore,
1890
    .commit = block_dirty_bitmap_free_backup,
1891
    .clean = g_free,
1892
};
1893

1894
static void block_dirty_bitmap_clear_action(BlockDirtyBitmap *action,
1895
                                            Transaction *tran, Error **errp)
1896
{
1897
    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
1898

1899
    tran_add(tran, &block_dirty_bitmap_clear_drv, state);
1900

1901
    state->bitmap = block_dirty_bitmap_lookup(action->node,
1902
                                              action->name,
1903
                                              &state->bs,
1904
                                              errp);
1905
    if (!state->bitmap) {
1906
        return;
1907
    }
1908

1909
    if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_DEFAULT, errp)) {
1910
        return;
1911
    }
1912

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

1916
static void block_dirty_bitmap_restore(void *opaque)
1917
{
1918
    BlockDirtyBitmapState *state = opaque;
1919

1920
    if (state->backup) {
1921
        bdrv_restore_dirty_bitmap(state->bitmap, state->backup);
1922
    }
1923
}
1924

1925
static void block_dirty_bitmap_free_backup(void *opaque)
1926
{
1927
    BlockDirtyBitmapState *state = opaque;
1928

1929
    hbitmap_free(state->backup);
1930
}
1931

1932
static void block_dirty_bitmap_enable_abort(void *opaque);
1933
TransactionActionDrv block_dirty_bitmap_enable_drv = {
1934
    .abort = block_dirty_bitmap_enable_abort,
1935
    .clean = g_free,
1936
};
1937

1938
static void block_dirty_bitmap_enable_action(BlockDirtyBitmap *action,
1939
                                             Transaction *tran, Error **errp)
1940
{
1941
    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
1942

1943
    tran_add(tran, &block_dirty_bitmap_enable_drv, state);
1944

1945
    state->bitmap = block_dirty_bitmap_lookup(action->node,
1946
                                              action->name,
1947
                                              NULL,
1948
                                              errp);
1949
    if (!state->bitmap) {
1950
        return;
1951
    }
1952

1953
    if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
1954
        return;
1955
    }
1956

1957
    state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
1958
    bdrv_enable_dirty_bitmap(state->bitmap);
1959
}
1960

1961
static void block_dirty_bitmap_enable_abort(void *opaque)
1962
{
1963
    BlockDirtyBitmapState *state = opaque;
1964

1965
    if (!state->was_enabled) {
1966
        bdrv_disable_dirty_bitmap(state->bitmap);
1967
    }
1968
}
1969

1970
static void block_dirty_bitmap_disable_abort(void *opaque);
1971
TransactionActionDrv block_dirty_bitmap_disable_drv = {
1972
    .abort = block_dirty_bitmap_disable_abort,
1973
    .clean = g_free,
1974
};
1975

1976
static void block_dirty_bitmap_disable_action(BlockDirtyBitmap *action,
1977
                                              Transaction *tran, Error **errp)
1978
{
1979
    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
1980

1981
    tran_add(tran, &block_dirty_bitmap_disable_drv, state);
1982

1983
    state->bitmap = block_dirty_bitmap_lookup(action->node,
1984
                                              action->name,
1985
                                              NULL,
1986
                                              errp);
1987
    if (!state->bitmap) {
1988
        return;
1989
    }
1990

1991
    if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
1992
        return;
1993
    }
1994

1995
    state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
1996
    bdrv_disable_dirty_bitmap(state->bitmap);
1997
}
1998

1999
static void block_dirty_bitmap_disable_abort(void *opaque)
2000
{
2001
    BlockDirtyBitmapState *state = opaque;
2002

2003
    if (state->was_enabled) {
2004
        bdrv_enable_dirty_bitmap(state->bitmap);
2005
    }
2006
}
2007

2008
TransactionActionDrv block_dirty_bitmap_merge_drv = {
2009
    .commit = block_dirty_bitmap_free_backup,
2010
    .abort = block_dirty_bitmap_restore,
2011
    .clean = g_free,
2012
};
2013

2014
static void block_dirty_bitmap_merge_action(BlockDirtyBitmapMerge *action,
2015
                                            Transaction *tran, Error **errp)
2016
{
2017
    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
2018

2019
    tran_add(tran, &block_dirty_bitmap_merge_drv, state);
2020

2021
    state->bitmap = block_dirty_bitmap_merge(action->node, action->target,
2022
                                             action->bitmaps, &state->backup,
2023
                                             errp);
2024
}
2025

2026
static void block_dirty_bitmap_remove_commit(void *opaque);
2027
static void block_dirty_bitmap_remove_abort(void *opaque);
2028
TransactionActionDrv block_dirty_bitmap_remove_drv = {
2029
    .commit = block_dirty_bitmap_remove_commit,
2030
    .abort = block_dirty_bitmap_remove_abort,
2031
    .clean = g_free,
2032
};
2033

2034
static void block_dirty_bitmap_remove_action(BlockDirtyBitmap *action,
2035
                                             Transaction *tran, Error **errp)
2036
{
2037
    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
2038

2039
    tran_add(tran, &block_dirty_bitmap_remove_drv, state);
2040

2041

2042
    state->bitmap = block_dirty_bitmap_remove(action->node, action->name,
2043
                                              false, &state->bs, errp);
2044
    if (state->bitmap) {
2045
        bdrv_dirty_bitmap_skip_store(state->bitmap, true);
2046
        bdrv_dirty_bitmap_set_busy(state->bitmap, true);
2047
    }
2048
}
2049

2050
static void block_dirty_bitmap_remove_abort(void *opaque)
2051
{
2052
    BlockDirtyBitmapState *state = opaque;
2053

2054
    if (state->bitmap) {
2055
        bdrv_dirty_bitmap_skip_store(state->bitmap, false);
2056
        bdrv_dirty_bitmap_set_busy(state->bitmap, false);
2057
    }
2058
}
2059

2060
static void block_dirty_bitmap_remove_commit(void *opaque)
2061
{
2062
    BlockDirtyBitmapState *state = opaque;
2063

2064
    bdrv_dirty_bitmap_set_busy(state->bitmap, false);
2065
    bdrv_release_dirty_bitmap(state->bitmap);
2066
}
2067

2068
static void abort_commit(void *opaque);
2069
TransactionActionDrv abort_drv = {
2070
    .commit = abort_commit,
2071
};
2072

2073
static void abort_action(Transaction *tran, Error **errp)
2074
{
2075
    tran_add(tran, &abort_drv, NULL);
2076
    error_setg(errp, "Transaction aborted using Abort action");
2077
}
2078

2079
static void abort_commit(void *opaque)
2080
{
2081
    g_assert_not_reached(); /* this action never succeeds */
2082
}
2083

2084
static void transaction_action(TransactionAction *act, JobTxn *block_job_txn,
2085
                               Transaction *tran, Error **errp)
2086
{
2087
    switch (act->type) {
2088
    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
2089
    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
2090
        external_snapshot_action(act, tran, errp);
2091
        return;
2092
    case TRANSACTION_ACTION_KIND_DRIVE_BACKUP:
2093
        drive_backup_action(act->u.drive_backup.data,
2094
                            block_job_txn, tran, errp);
2095
        return;
2096
    case TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP:
2097
        blockdev_backup_action(act->u.blockdev_backup.data,
2098
                               block_job_txn, tran, errp);
2099
        return;
2100
    case TRANSACTION_ACTION_KIND_ABORT:
2101
        abort_action(tran, errp);
2102
        return;
2103
    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC:
2104
        internal_snapshot_action(act->u.blockdev_snapshot_internal_sync.data,
2105
                                 tran, errp);
2106
        return;
2107
    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD:
2108
        block_dirty_bitmap_add_action(act->u.block_dirty_bitmap_add.data,
2109
                                      tran, errp);
2110
        return;
2111
    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR:
2112
        block_dirty_bitmap_clear_action(act->u.block_dirty_bitmap_clear.data,
2113
                                        tran, errp);
2114
        return;
2115
    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE:
2116
        block_dirty_bitmap_enable_action(act->u.block_dirty_bitmap_enable.data,
2117
                                         tran, errp);
2118
        return;
2119
    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE:
2120
        block_dirty_bitmap_disable_action(
2121
                act->u.block_dirty_bitmap_disable.data, tran, errp);
2122
        return;
2123
    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE:
2124
        block_dirty_bitmap_merge_action(act->u.block_dirty_bitmap_merge.data,
2125
                                        tran, errp);
2126
        return;
2127
    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE:
2128
        block_dirty_bitmap_remove_action(act->u.block_dirty_bitmap_remove.data,
2129
                                         tran, errp);
2130
        return;
2131
    /*
2132
     * Where are transactions for MIRROR, COMMIT and STREAM?
2133
     * Although these blockjobs use transaction callbacks like the backup job,
2134
     * these jobs do not necessarily adhere to transaction semantics.
2135
     * These jobs may not fully undo all of their actions on abort, nor do they
2136
     * necessarily work in transactions with more than one job in them.
2137
     */
2138
    case TRANSACTION_ACTION_KIND__MAX:
2139
    default:
2140
        g_assert_not_reached();
2141
    };
2142
}
2143

2144

2145
/*
2146
 * 'Atomic' group operations.  The operations are performed as a set, and if
2147
 * any fail then we roll back all operations in the group.
2148
 *
2149
 * Always run under BQL.
2150
 */
2151
void qmp_transaction(TransactionActionList *actions,
2152
                     struct TransactionProperties *properties,
2153
                     Error **errp)
2154
{
2155
    TransactionActionList *act;
2156
    JobTxn *block_job_txn = NULL;
2157
    Error *local_err = NULL;
2158
    Transaction *tran;
2159
    ActionCompletionMode comp_mode =
2160
        properties ? properties->completion_mode :
2161
        ACTION_COMPLETION_MODE_INDIVIDUAL;
2162

2163
    GLOBAL_STATE_CODE();
2164

2165
    /* Does this transaction get canceled as a group on failure?
2166
     * If not, we don't really need to make a JobTxn.
2167
     */
2168
    if (comp_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
2169
        for (act = actions; act; act = act->next) {
2170
            TransactionActionKind type = act->value->type;
2171

2172
            if (type != TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP &&
2173
                type != TRANSACTION_ACTION_KIND_DRIVE_BACKUP)
2174
            {
2175
                error_setg(errp,
2176
                           "Action '%s' does not support transaction property "
2177
                           "completion-mode = %s",
2178
                           TransactionActionKind_str(type),
2179
                           ActionCompletionMode_str(comp_mode));
2180
                return;
2181
            }
2182
        }
2183

2184
        block_job_txn = job_txn_new();
2185
    }
2186

2187
    /* drain all i/o before any operations */
2188
    bdrv_drain_all();
2189

2190
    tran = tran_new();
2191

2192
    /* We don't do anything in this loop that commits us to the operations */
2193
    for (act = actions; act; act = act->next) {
2194
        transaction_action(act->value, block_job_txn, tran, &local_err);
2195
        if (local_err) {
2196
            error_propagate(errp, local_err);
2197
            goto delete_and_fail;
2198
        }
2199
    }
2200

2201
    tran_commit(tran);
2202

2203
    /* success */
2204
    goto exit;
2205

2206
delete_and_fail:
2207
    /* failure, and it is all-or-none; roll back all operations */
2208
    tran_abort(tran);
2209
exit:
2210
    job_txn_unref(block_job_txn);
2211
}
2212

2213
BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node,
2214
                                                              const char *name,
2215
                                                              Error **errp)
2216
{
2217
    BdrvDirtyBitmap *bitmap;
2218
    BlockDriverState *bs;
2219
    BlockDirtyBitmapSha256 *ret = NULL;
2220
    char *sha256;
2221

2222
    bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2223
    if (!bitmap || !bs) {
2224
        return NULL;
2225
    }
2226

2227
    sha256 = bdrv_dirty_bitmap_sha256(bitmap, errp);
2228
    if (sha256 == NULL) {
2229
        return NULL;
2230
    }
2231

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

2235
    return ret;
2236
}
2237

2238
void coroutine_fn qmp_block_resize(const char *device, const char *node_name,
2239
                                   int64_t size, Error **errp)
2240
{
2241
    Error *local_err = NULL;
2242
    BlockBackend *blk;
2243
    BlockDriverState *bs;
2244
    AioContext *old_ctx;
2245

2246
    bs = bdrv_lookup_bs(device, node_name, &local_err);
2247
    if (local_err) {
2248
        error_propagate(errp, local_err);
2249
        return;
2250
    }
2251

2252
    if (size < 0) {
2253
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size");
2254
        return;
2255
    }
2256

2257
    bdrv_graph_co_rdlock();
2258
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, errp)) {
2259
        bdrv_graph_co_rdunlock();
2260
        return;
2261
    }
2262
    bdrv_graph_co_rdunlock();
2263

2264
    blk = blk_co_new_with_bs(bs, BLK_PERM_RESIZE, BLK_PERM_ALL, errp);
2265
    if (!blk) {
2266
        return;
2267
    }
2268

2269
    bdrv_drained_begin(bs);
2270

2271
    old_ctx = bdrv_co_enter(bs);
2272
    blk_co_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp);
2273
    bdrv_co_leave(bs, old_ctx);
2274

2275
    bdrv_drained_end(bs);
2276
    blk_co_unref(blk);
2277
}
2278

2279
void qmp_block_stream(const char *job_id, const char *device,
2280
                      const char *base,
2281
                      const char *base_node,
2282
                      const char *backing_file,
2283
                      bool has_backing_mask_protocol,
2284
                      bool backing_mask_protocol,
2285
                      const char *bottom,
2286
                      bool has_speed, int64_t speed,
2287
                      bool has_on_error, BlockdevOnError on_error,
2288
                      const char *filter_node_name,
2289
                      bool has_auto_finalize, bool auto_finalize,
2290
                      bool has_auto_dismiss, bool auto_dismiss,
2291
                      Error **errp)
2292
{
2293
    BlockDriverState *bs, *iter, *iter_end;
2294
    BlockDriverState *base_bs = NULL;
2295
    BlockDriverState *bottom_bs = NULL;
2296
    AioContext *aio_context;
2297
    Error *local_err = NULL;
2298
    int job_flags = JOB_DEFAULT;
2299

2300
    GLOBAL_STATE_CODE();
2301

2302
    if (base && base_node) {
2303
        error_setg(errp, "'base' and 'base-node' cannot be specified "
2304
                   "at the same time");
2305
        return;
2306
    }
2307

2308
    if (base && bottom) {
2309
        error_setg(errp, "'base' and 'bottom' cannot be specified "
2310
                   "at the same time");
2311
        return;
2312
    }
2313

2314
    if (bottom && base_node) {
2315
        error_setg(errp, "'bottom' and 'base-node' cannot be specified "
2316
                   "at the same time");
2317
        return;
2318
    }
2319

2320
    if (!has_backing_mask_protocol) {
2321
        backing_mask_protocol = false;
2322
    }
2323

2324
    if (!has_on_error) {
2325
        on_error = BLOCKDEV_ON_ERROR_REPORT;
2326
    }
2327

2328
    bs = bdrv_lookup_bs(device, device, errp);
2329
    if (!bs) {
2330
        return;
2331
    }
2332

2333
    aio_context = bdrv_get_aio_context(bs);
2334

2335
    bdrv_graph_rdlock_main_loop();
2336
    if (base) {
2337
        base_bs = bdrv_find_backing_image(bs, base);
2338
        if (base_bs == NULL) {
2339
            error_setg(errp, "Can't find '%s' in the backing chain", base);
2340
            goto out_rdlock;
2341
        }
2342
        assert(bdrv_get_aio_context(base_bs) == aio_context);
2343
    }
2344

2345
    if (base_node) {
2346
        base_bs = bdrv_lookup_bs(NULL, base_node, errp);
2347
        if (!base_bs) {
2348
            goto out_rdlock;
2349
        }
2350
        if (bs == base_bs || !bdrv_chain_contains(bs, base_bs)) {
2351
            error_setg(errp, "Node '%s' is not a backing image of '%s'",
2352
                       base_node, device);
2353
            goto out_rdlock;
2354
        }
2355
        assert(bdrv_get_aio_context(base_bs) == aio_context);
2356

2357
        bdrv_refresh_filename(base_bs);
2358
    }
2359

2360
    if (bottom) {
2361
        bottom_bs = bdrv_lookup_bs(NULL, bottom, errp);
2362
        if (!bottom_bs) {
2363
            goto out_rdlock;
2364
        }
2365
        if (!bottom_bs->drv) {
2366
            error_setg(errp, "Node '%s' is not open", bottom);
2367
            goto out_rdlock;
2368
        }
2369
        if (bottom_bs->drv->is_filter) {
2370
            error_setg(errp, "Node '%s' is a filter, use a non-filter node "
2371
                       "as 'bottom'", bottom);
2372
            goto out_rdlock;
2373
        }
2374
        if (!bdrv_chain_contains(bs, bottom_bs)) {
2375
            error_setg(errp, "Node '%s' is not in a chain starting from '%s'",
2376
                       bottom, device);
2377
            goto out_rdlock;
2378
        }
2379
        assert(bdrv_get_aio_context(bottom_bs) == aio_context);
2380
    }
2381

2382
    /*
2383
     * Check for op blockers in the whole chain between bs and base (or bottom)
2384
     */
2385
    iter_end = bottom ? bdrv_filter_or_cow_bs(bottom_bs) : base_bs;
2386
    for (iter = bs; iter && iter != iter_end;
2387
         iter = bdrv_filter_or_cow_bs(iter))
2388
    {
2389
        if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_STREAM, errp)) {
2390
            goto out_rdlock;
2391
        }
2392
    }
2393
    bdrv_graph_rdunlock_main_loop();
2394

2395
    /* if we are streaming the entire chain, the result will have no backing
2396
     * file, and specifying one is therefore an error */
2397
    if (!base_bs && backing_file) {
2398
        error_setg(errp, "backing file specified, but streaming the "
2399
                         "entire chain");
2400
        return;
2401
    }
2402

2403
    if (has_auto_finalize && !auto_finalize) {
2404
        job_flags |= JOB_MANUAL_FINALIZE;
2405
    }
2406
    if (has_auto_dismiss && !auto_dismiss) {
2407
        job_flags |= JOB_MANUAL_DISMISS;
2408
    }
2409

2410
    stream_start(job_id, bs, base_bs, backing_file,
2411
                 backing_mask_protocol,
2412
                 bottom_bs, job_flags, has_speed ? speed : 0, on_error,
2413
                 filter_node_name, &local_err);
2414
    if (local_err) {
2415
        error_propagate(errp, local_err);
2416
        return;
2417
    }
2418

2419
    trace_qmp_block_stream(bs);
2420
    return;
2421

2422
out_rdlock:
2423
    bdrv_graph_rdunlock_main_loop();
2424
}
2425

2426
void qmp_block_commit(const char *job_id, const char *device,
2427
                      const char *base_node,
2428
                      const char *base,
2429
                      const char *top_node,
2430
                      const char *top,
2431
                      const char *backing_file,
2432
                      bool has_backing_mask_protocol,
2433
                      bool backing_mask_protocol,
2434
                      bool has_speed, int64_t speed,
2435
                      bool has_on_error, BlockdevOnError on_error,
2436
                      const char *filter_node_name,
2437
                      bool has_auto_finalize, bool auto_finalize,
2438
                      bool has_auto_dismiss, bool auto_dismiss,
2439
                      Error **errp)
2440
{
2441
    BlockDriverState *bs;
2442
    BlockDriverState *iter;
2443
    BlockDriverState *base_bs, *top_bs;
2444
    AioContext *aio_context;
2445
    Error *local_err = NULL;
2446
    int job_flags = JOB_DEFAULT;
2447
    uint64_t top_perm, top_shared;
2448

2449
    /* TODO We'll eventually have to take a writer lock in this function */
2450
    GRAPH_RDLOCK_GUARD_MAINLOOP();
2451

2452
    if (!has_speed) {
2453
        speed = 0;
2454
    }
2455
    if (!has_on_error) {
2456
        on_error = BLOCKDEV_ON_ERROR_REPORT;
2457
    }
2458
    if (has_auto_finalize && !auto_finalize) {
2459
        job_flags |= JOB_MANUAL_FINALIZE;
2460
    }
2461
    if (has_auto_dismiss && !auto_dismiss) {
2462
        job_flags |= JOB_MANUAL_DISMISS;
2463
    }
2464
    if (!has_backing_mask_protocol) {
2465
        backing_mask_protocol = false;
2466
    }
2467

2468
    /* Important Note:
2469
     *  libvirt relies on the DeviceNotFound error class in order to probe for
2470
     *  live commit feature versions; for this to work, we must make sure to
2471
     *  perform the device lookup before any generic errors that may occur in a
2472
     *  scenario in which all optional arguments are omitted. */
2473
    bs = qmp_get_root_bs(device, &local_err);
2474
    if (!bs) {
2475
        bs = bdrv_lookup_bs(device, device, NULL);
2476
        if (!bs) {
2477
            error_free(local_err);
2478
            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
2479
                      "Device '%s' not found", device);
2480
        } else {
2481
            error_propagate(errp, local_err);
2482
        }
2483
        return;
2484
    }
2485

2486
    aio_context = bdrv_get_aio_context(bs);
2487

2488
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, errp)) {
2489
        return;
2490
    }
2491

2492
    /* default top_bs is the active layer */
2493
    top_bs = bs;
2494

2495
    if (top_node && top) {
2496
        error_setg(errp, "'top-node' and 'top' are mutually exclusive");
2497
        return;
2498
    } else if (top_node) {
2499
        top_bs = bdrv_lookup_bs(NULL, top_node, errp);
2500
        if (top_bs == NULL) {
2501
            return;
2502
        }
2503
        if (!bdrv_chain_contains(bs, top_bs)) {
2504
            error_setg(errp, "'%s' is not in this backing file chain",
2505
                       top_node);
2506
            return;
2507
        }
2508
    } else if (top) {
2509
        /* This strcmp() is just a shortcut, there is no need to
2510
         * refresh @bs's filename.  If it mismatches,
2511
         * bdrv_find_backing_image() will do the refresh and may still
2512
         * return @bs. */
2513
        if (strcmp(bs->filename, top) != 0) {
2514
            top_bs = bdrv_find_backing_image(bs, top);
2515
        }
2516
    }
2517

2518
    if (top_bs == NULL) {
2519
        error_setg(errp, "Top image file %s not found", top ? top : "NULL");
2520
        return;
2521
    }
2522

2523
    assert(bdrv_get_aio_context(top_bs) == aio_context);
2524

2525
    if (base_node && base) {
2526
        error_setg(errp, "'base-node' and 'base' are mutually exclusive");
2527
        return;
2528
    } else if (base_node) {
2529
        base_bs = bdrv_lookup_bs(NULL, base_node, errp);
2530
        if (base_bs == NULL) {
2531
            return;
2532
        }
2533
        if (!bdrv_chain_contains(top_bs, base_bs)) {
2534
            error_setg(errp, "'%s' is not in this backing file chain",
2535
                       base_node);
2536
            return;
2537
        }
2538
    } else if (base) {
2539
        base_bs = bdrv_find_backing_image(top_bs, base);
2540
        if (base_bs == NULL) {
2541
            error_setg(errp, "Can't find '%s' in the backing chain", base);
2542
            return;
2543
        }
2544
    } else {
2545
        base_bs = bdrv_find_base(top_bs);
2546
        if (base_bs == NULL) {
2547
            error_setg(errp, "There is no backimg image");
2548
            return;
2549
        }
2550
    }
2551

2552
    assert(bdrv_get_aio_context(base_bs) == aio_context);
2553

2554
    for (iter = top_bs; iter != bdrv_filter_or_cow_bs(base_bs);
2555
         iter = bdrv_filter_or_cow_bs(iter))
2556
    {
2557
        if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
2558
            return;
2559
        }
2560
    }
2561

2562
    /* Do not allow attempts to commit an image into itself */
2563
    if (top_bs == base_bs) {
2564
        error_setg(errp, "cannot commit an image into itself");
2565
        return;
2566
    }
2567

2568
    /*
2569
     * Active commit is required if and only if someone has taken a
2570
     * WRITE permission on the top node.  Historically, we have always
2571
     * used active commit for top nodes, so continue that practice
2572
     * lest we possibly break clients that rely on this behavior, e.g.
2573
     * to later attach this node to a writing parent.
2574
     * (Active commit is never really wrong.)
2575
     */
2576
    bdrv_get_cumulative_perm(top_bs, &top_perm, &top_shared);
2577
    if (top_perm & BLK_PERM_WRITE ||
2578
        bdrv_skip_filters(top_bs) == bdrv_skip_filters(bs))
2579
    {
2580
        if (backing_file) {
2581
            if (bdrv_skip_filters(top_bs) == bdrv_skip_filters(bs)) {
2582
                error_setg(errp, "'backing-file' specified,"
2583
                                 " but 'top' is the active layer");
2584
            } else {
2585
                error_setg(errp, "'backing-file' specified, but 'top' has a "
2586
                                 "writer on it");
2587
            }
2588
            return;
2589
        }
2590
        if (!job_id) {
2591
            /*
2592
             * Emulate here what block_job_create() does, because it
2593
             * is possible that @bs != @top_bs (the block job should
2594
             * be named after @bs, even if @top_bs is the actual
2595
             * source)
2596
             */
2597
            job_id = bdrv_get_device_name(bs);
2598
        }
2599
        commit_active_start(job_id, top_bs, base_bs, job_flags, speed, on_error,
2600
                            filter_node_name, NULL, NULL, false, &local_err);
2601
    } else {
2602
        BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);
2603
        if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
2604
            return;
2605
        }
2606
        commit_start(job_id, bs, base_bs, top_bs, job_flags,
2607
                     speed, on_error, backing_file,
2608
                     backing_mask_protocol,
2609
                     filter_node_name, &local_err);
2610
    }
2611
    if (local_err != NULL) {
2612
        error_propagate(errp, local_err);
2613
        return;
2614
    }
2615
}
2616

2617
/* Common QMP interface for drive-backup and blockdev-backup */
2618
static BlockJob *do_backup_common(BackupCommon *backup,
2619
                                  BlockDriverState *bs,
2620
                                  BlockDriverState *target_bs,
2621
                                  AioContext *aio_context,
2622
                                  JobTxn *txn, Error **errp)
2623
{
2624
    BlockJob *job = NULL;
2625
    BdrvDirtyBitmap *bmap = NULL;
2626
    BackupPerf perf = { .max_workers = 64 };
2627
    int job_flags = JOB_DEFAULT;
2628

2629
    if (!backup->has_speed) {
2630
        backup->speed = 0;
2631
    }
2632
    if (!backup->has_on_source_error) {
2633
        backup->on_source_error = BLOCKDEV_ON_ERROR_REPORT;
2634
    }
2635
    if (!backup->has_on_target_error) {
2636
        backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT;
2637
    }
2638
    if (!backup->has_auto_finalize) {
2639
        backup->auto_finalize = true;
2640
    }
2641
    if (!backup->has_auto_dismiss) {
2642
        backup->auto_dismiss = true;
2643
    }
2644
    if (!backup->has_compress) {
2645
        backup->compress = false;
2646
    }
2647

2648
    if (backup->x_perf) {
2649
        if (backup->x_perf->has_use_copy_range) {
2650
            perf.use_copy_range = backup->x_perf->use_copy_range;
2651
        }
2652
        if (backup->x_perf->has_max_workers) {
2653
            perf.max_workers = backup->x_perf->max_workers;
2654
        }
2655
        if (backup->x_perf->has_max_chunk) {
2656
            perf.max_chunk = backup->x_perf->max_chunk;
2657
        }
2658
    }
2659

2660
    if ((backup->sync == MIRROR_SYNC_MODE_BITMAP) ||
2661
        (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL)) {
2662
        /* done before desugaring 'incremental' to print the right message */
2663
        if (!backup->bitmap) {
2664
            error_setg(errp, "must provide a valid bitmap name for "
2665
                       "'%s' sync mode", MirrorSyncMode_str(backup->sync));
2666
            return NULL;
2667
        }
2668
    }
2669

2670
    if (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL) {
2671
        if (backup->has_bitmap_mode &&
2672
            backup->bitmap_mode != BITMAP_SYNC_MODE_ON_SUCCESS) {
2673
            error_setg(errp, "Bitmap sync mode must be '%s' "
2674
                       "when using sync mode '%s'",
2675
                       BitmapSyncMode_str(BITMAP_SYNC_MODE_ON_SUCCESS),
2676
                       MirrorSyncMode_str(backup->sync));
2677
            return NULL;
2678
        }
2679
        backup->has_bitmap_mode = true;
2680
        backup->sync = MIRROR_SYNC_MODE_BITMAP;
2681
        backup->bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS;
2682
    }
2683

2684
    if (backup->bitmap) {
2685
        bmap = bdrv_find_dirty_bitmap(bs, backup->bitmap);
2686
        if (!bmap) {
2687
            error_setg(errp, "Bitmap '%s' could not be found", backup->bitmap);
2688
            return NULL;
2689
        }
2690
        if (!backup->has_bitmap_mode) {
2691
            error_setg(errp, "Bitmap sync mode must be given "
2692
                       "when providing a bitmap");
2693
            return NULL;
2694
        }
2695
        if (bdrv_dirty_bitmap_check(bmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2696
            return NULL;
2697
        }
2698

2699
        /* This does not produce a useful bitmap artifact: */
2700
        if (backup->sync == MIRROR_SYNC_MODE_NONE) {
2701
            error_setg(errp, "sync mode '%s' does not produce meaningful bitmap"
2702
                       " outputs", MirrorSyncMode_str(backup->sync));
2703
            return NULL;
2704
        }
2705

2706
        /* If the bitmap isn't used for input or output, this is useless: */
2707
        if (backup->bitmap_mode == BITMAP_SYNC_MODE_NEVER &&
2708
            backup->sync != MIRROR_SYNC_MODE_BITMAP) {
2709
            error_setg(errp, "Bitmap sync mode '%s' has no meaningful effect"
2710
                       " when combined with sync mode '%s'",
2711
                       BitmapSyncMode_str(backup->bitmap_mode),
2712
                       MirrorSyncMode_str(backup->sync));
2713
            return NULL;
2714
        }
2715
    }
2716

2717
    if (!backup->bitmap && backup->has_bitmap_mode) {
2718
        error_setg(errp, "Cannot specify bitmap sync mode without a bitmap");
2719
        return NULL;
2720
    }
2721

2722
    if (!backup->auto_finalize) {
2723
        job_flags |= JOB_MANUAL_FINALIZE;
2724
    }
2725
    if (!backup->auto_dismiss) {
2726
        job_flags |= JOB_MANUAL_DISMISS;
2727
    }
2728

2729
    job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
2730
                            backup->sync, bmap, backup->bitmap_mode,
2731
                            backup->compress, backup->discard_source,
2732
                            backup->filter_node_name,
2733
                            &perf,
2734
                            backup->on_source_error,
2735
                            backup->on_target_error,
2736
                            job_flags, NULL, NULL, txn, errp);
2737
    return job;
2738
}
2739

2740
void qmp_drive_backup(DriveBackup *backup, Error **errp)
2741
{
2742
    TransactionAction action = {
2743
        .type = TRANSACTION_ACTION_KIND_DRIVE_BACKUP,
2744
        .u.drive_backup.data = backup,
2745
    };
2746
    blockdev_do_action(&action, errp);
2747
}
2748

2749
BlockDeviceInfoList *qmp_query_named_block_nodes(bool has_flat,
2750
                                                 bool flat,
2751
                                                 Error **errp)
2752
{
2753
    bool return_flat = has_flat && flat;
2754

2755
    return bdrv_named_nodes_list(return_flat, errp);
2756
}
2757

2758
XDbgBlockGraph *qmp_x_debug_query_block_graph(Error **errp)
2759
{
2760
    GRAPH_RDLOCK_GUARD_MAINLOOP();
2761

2762
    return bdrv_get_xdbg_block_graph(errp);
2763
}
2764

2765
void qmp_blockdev_backup(BlockdevBackup *backup, Error **errp)
2766
{
2767
    TransactionAction action = {
2768
        .type = TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP,
2769
        .u.blockdev_backup.data = backup,
2770
    };
2771
    blockdev_do_action(&action, errp);
2772
}
2773

2774
/* Parameter check and block job starting for drive mirroring.
2775
 * Caller should hold @device and @target's aio context (must be the same).
2776
 **/
2777
static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
2778
                                   BlockDriverState *target,
2779
                                   const char *replaces,
2780
                                   enum MirrorSyncMode sync,
2781
                                   BlockMirrorBackingMode backing_mode,
2782
                                   bool zero_target,
2783
                                   bool has_speed, int64_t speed,
2784
                                   bool has_granularity, uint32_t granularity,
2785
                                   bool has_buf_size, int64_t buf_size,
2786
                                   bool has_on_source_error,
2787
                                   BlockdevOnError on_source_error,
2788
                                   bool has_on_target_error,
2789
                                   BlockdevOnError on_target_error,
2790
                                   bool has_unmap, bool unmap,
2791
                                   const char *filter_node_name,
2792
                                   bool has_copy_mode, MirrorCopyMode copy_mode,
2793
                                   bool has_auto_finalize, bool auto_finalize,
2794
                                   bool has_auto_dismiss, bool auto_dismiss,
2795
                                   Error **errp)
2796
{
2797
    BlockDriverState *unfiltered_bs;
2798
    int job_flags = JOB_DEFAULT;
2799

2800
    GLOBAL_STATE_CODE();
2801
    GRAPH_RDLOCK_GUARD_MAINLOOP();
2802

2803
    if (!has_speed) {
2804
        speed = 0;
2805
    }
2806
    if (!has_on_source_error) {
2807
        on_source_error = BLOCKDEV_ON_ERROR_REPORT;
2808
    }
2809
    if (!has_on_target_error) {
2810
        on_target_error = BLOCKDEV_ON_ERROR_REPORT;
2811
    }
2812
    if (!has_granularity) {
2813
        granularity = 0;
2814
    }
2815
    if (!has_buf_size) {
2816
        buf_size = 0;
2817
    }
2818
    if (!has_unmap) {
2819
        unmap = true;
2820
    }
2821
    if (!has_copy_mode) {
2822
        copy_mode = MIRROR_COPY_MODE_BACKGROUND;
2823
    }
2824
    if (has_auto_finalize && !auto_finalize) {
2825
        job_flags |= JOB_MANUAL_FINALIZE;
2826
    }
2827
    if (has_auto_dismiss && !auto_dismiss) {
2828
        job_flags |= JOB_MANUAL_DISMISS;
2829
    }
2830

2831
    if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) {
2832
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
2833
                   "a value in range [512B, 64MB]");
2834
        return;
2835
    }
2836
    if (granularity & (granularity - 1)) {
2837
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
2838
                   "a power of 2");
2839
        return;
2840
    }
2841

2842
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) {
2843
        return;
2844
    }
2845
    if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_MIRROR_TARGET, errp)) {
2846
        return;
2847
    }
2848

2849
    if (!bdrv_backing_chain_next(bs) && sync == MIRROR_SYNC_MODE_TOP) {
2850
        sync = MIRROR_SYNC_MODE_FULL;
2851
    }
2852

2853
    if (!replaces) {
2854
        /* We want to mirror from @bs, but keep implicit filters on top */
2855
        unfiltered_bs = bdrv_skip_implicit_filters(bs);
2856
        if (unfiltered_bs != bs) {
2857
            replaces = unfiltered_bs->node_name;
2858
        }
2859
    }
2860

2861
    if (replaces) {
2862
        BlockDriverState *to_replace_bs;
2863
        int64_t bs_size, replace_size;
2864

2865
        bs_size = bdrv_getlength(bs);
2866
        if (bs_size < 0) {
2867
            error_setg_errno(errp, -bs_size, "Failed to query device's size");
2868
            return;
2869
        }
2870

2871
        to_replace_bs = check_to_replace_node(bs, replaces, errp);
2872
        if (!to_replace_bs) {
2873
            return;
2874
        }
2875

2876
        replace_size = bdrv_getlength(to_replace_bs);
2877

2878
        if (replace_size < 0) {
2879
            error_setg_errno(errp, -replace_size,
2880
                             "Failed to query the replacement node's size");
2881
            return;
2882
        }
2883
        if (bs_size != replace_size) {
2884
            error_setg(errp, "cannot replace image with a mirror image of "
2885
                             "different size");
2886
            return;
2887
        }
2888
    }
2889

2890
    /* pass the node name to replace to mirror start since it's loose coupling
2891
     * and will allow to check whether the node still exist at mirror completion
2892
     */
2893
    mirror_start(job_id, bs, target,
2894
                 replaces, job_flags,
2895
                 speed, granularity, buf_size, sync, backing_mode, zero_target,
2896
                 on_source_error, on_target_error, unmap, filter_node_name,
2897
                 copy_mode, errp);
2898
}
2899

2900
void qmp_drive_mirror(DriveMirror *arg, Error **errp)
2901
{
2902
    BlockDriverState *bs;
2903
    BlockDriverState *target_backing_bs, *target_bs;
2904
    AioContext *aio_context;
2905
    BlockMirrorBackingMode backing_mode;
2906
    Error *local_err = NULL;
2907
    QDict *options = NULL;
2908
    int flags;
2909
    int64_t size;
2910
    const char *format = arg->format;
2911
    bool zero_target;
2912
    int ret;
2913

2914
    bs = qmp_get_root_bs(arg->device, errp);
2915
    if (!bs) {
2916
        return;
2917
    }
2918

2919
    /* Early check to avoid creating target */
2920
    bdrv_graph_rdlock_main_loop();
2921
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) {
2922
        bdrv_graph_rdunlock_main_loop();
2923
        return;
2924
    }
2925

2926
    aio_context = bdrv_get_aio_context(bs);
2927

2928
    if (!arg->has_mode) {
2929
        arg->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
2930
    }
2931

2932
    if (!arg->format) {
2933
        format = (arg->mode == NEW_IMAGE_MODE_EXISTING
2934
                  ? NULL : bs->drv->format_name);
2935
    }
2936

2937
    flags = bs->open_flags | BDRV_O_RDWR;
2938
    target_backing_bs = bdrv_cow_bs(bdrv_skip_filters(bs));
2939
    if (!target_backing_bs && arg->sync == MIRROR_SYNC_MODE_TOP) {
2940
        arg->sync = MIRROR_SYNC_MODE_FULL;
2941
    }
2942
    if (arg->sync == MIRROR_SYNC_MODE_NONE) {
2943
        target_backing_bs = bs;
2944
    }
2945
    bdrv_graph_rdunlock_main_loop();
2946

2947
    size = bdrv_getlength(bs);
2948
    if (size < 0) {
2949
        error_setg_errno(errp, -size, "bdrv_getlength failed");
2950
        return;
2951
    }
2952

2953
    if (arg->replaces) {
2954
        if (!arg->node_name) {
2955
            error_setg(errp, "a node-name must be provided when replacing a"
2956
                             " named node of the graph");
2957
            return;
2958
        }
2959
    }
2960

2961
    if (arg->mode == NEW_IMAGE_MODE_ABSOLUTE_PATHS) {
2962
        backing_mode = MIRROR_SOURCE_BACKING_CHAIN;
2963
    } else {
2964
        backing_mode = MIRROR_OPEN_BACKING_CHAIN;
2965
    }
2966

2967
    /* Don't open backing image in create() */
2968
    flags |= BDRV_O_NO_BACKING;
2969

2970
    if ((arg->sync == MIRROR_SYNC_MODE_FULL || !target_backing_bs)
2971
        && arg->mode != NEW_IMAGE_MODE_EXISTING)
2972
    {
2973
        /* create new image w/o backing file */
2974
        assert(format);
2975
        bdrv_img_create(arg->target, format,
2976
                        NULL, NULL, NULL, size, flags, false, &local_err);
2977
    } else {
2978
        BlockDriverState *explicit_backing;
2979

2980
        switch (arg->mode) {
2981
        case NEW_IMAGE_MODE_EXISTING:
2982
            break;
2983
        case NEW_IMAGE_MODE_ABSOLUTE_PATHS:
2984
            /*
2985
             * Create new image with backing file.
2986
             * Implicit filters should not appear in the filename.
2987
             */
2988
            bdrv_graph_rdlock_main_loop();
2989
            explicit_backing = bdrv_skip_implicit_filters(target_backing_bs);
2990
            bdrv_refresh_filename(explicit_backing);
2991
            bdrv_graph_rdunlock_main_loop();
2992

2993
            bdrv_img_create(arg->target, format,
2994
                            explicit_backing->filename,
2995
                            explicit_backing->drv->format_name,
2996
                            NULL, size, flags, false, &local_err);
2997
            break;
2998
        default:
2999
            abort();
3000
        }
3001
    }
3002

3003
    if (local_err) {
3004
        error_propagate(errp, local_err);
3005
        return;
3006
    }
3007

3008
    options = qdict_new();
3009
    if (arg->node_name) {
3010
        qdict_put_str(options, "node-name", arg->node_name);
3011
    }
3012
    if (format) {
3013
        qdict_put_str(options, "driver", format);
3014
    }
3015

3016
    /* Mirroring takes care of copy-on-write using the source's backing
3017
     * file.
3018
     */
3019
    target_bs = bdrv_open(arg->target, NULL, options, flags, errp);
3020
    if (!target_bs) {
3021
        return;
3022
    }
3023

3024
    bdrv_graph_rdlock_main_loop();
3025
    zero_target = (arg->sync == MIRROR_SYNC_MODE_FULL &&
3026
                   (arg->mode == NEW_IMAGE_MODE_EXISTING ||
3027
                    !bdrv_has_zero_init(target_bs)));
3028
    bdrv_graph_rdunlock_main_loop();
3029

3030

3031
    ret = bdrv_try_change_aio_context(target_bs, aio_context, NULL, errp);
3032
    if (ret < 0) {
3033
        bdrv_unref(target_bs);
3034
        return;
3035
    }
3036

3037
    blockdev_mirror_common(arg->job_id, bs, target_bs,
3038
                           arg->replaces, arg->sync,
3039
                           backing_mode, zero_target,
3040
                           arg->has_speed, arg->speed,
3041
                           arg->has_granularity, arg->granularity,
3042
                           arg->has_buf_size, arg->buf_size,
3043
                           arg->has_on_source_error, arg->on_source_error,
3044
                           arg->has_on_target_error, arg->on_target_error,
3045
                           arg->has_unmap, arg->unmap,
3046
                           NULL,
3047
                           arg->has_copy_mode, arg->copy_mode,
3048
                           arg->has_auto_finalize, arg->auto_finalize,
3049
                           arg->has_auto_dismiss, arg->auto_dismiss,
3050
                           errp);
3051
    bdrv_unref(target_bs);
3052
}
3053

3054
void qmp_blockdev_mirror(const char *job_id,
3055
                         const char *device, const char *target,
3056
                         const char *replaces,
3057
                         MirrorSyncMode sync,
3058
                         bool has_speed, int64_t speed,
3059
                         bool has_granularity, uint32_t granularity,
3060
                         bool has_buf_size, int64_t buf_size,
3061
                         bool has_on_source_error,
3062
                         BlockdevOnError on_source_error,
3063
                         bool has_on_target_error,
3064
                         BlockdevOnError on_target_error,
3065
                         const char *filter_node_name,
3066
                         bool has_copy_mode, MirrorCopyMode copy_mode,
3067
                         bool has_auto_finalize, bool auto_finalize,
3068
                         bool has_auto_dismiss, bool auto_dismiss,
3069
                         Error **errp)
3070
{
3071
    BlockDriverState *bs;
3072
    BlockDriverState *target_bs;
3073
    AioContext *aio_context;
3074
    BlockMirrorBackingMode backing_mode = MIRROR_LEAVE_BACKING_CHAIN;
3075
    bool zero_target;
3076
    int ret;
3077

3078
    bs = qmp_get_root_bs(device, errp);
3079
    if (!bs) {
3080
        return;
3081
    }
3082

3083
    target_bs = bdrv_lookup_bs(target, target, errp);
3084
    if (!target_bs) {
3085
        return;
3086
    }
3087

3088
    zero_target = (sync == MIRROR_SYNC_MODE_FULL);
3089

3090
    aio_context = bdrv_get_aio_context(bs);
3091

3092
    ret = bdrv_try_change_aio_context(target_bs, aio_context, NULL, errp);
3093
    if (ret < 0) {
3094
        return;
3095
    }
3096

3097
    blockdev_mirror_common(job_id, bs, target_bs,
3098
                           replaces, sync, backing_mode,
3099
                           zero_target, has_speed, speed,
3100
                           has_granularity, granularity,
3101
                           has_buf_size, buf_size,
3102
                           has_on_source_error, on_source_error,
3103
                           has_on_target_error, on_target_error,
3104
                           true, true, filter_node_name,
3105
                           has_copy_mode, copy_mode,
3106
                           has_auto_finalize, auto_finalize,
3107
                           has_auto_dismiss, auto_dismiss,
3108
                           errp);
3109
}
3110

3111
/*
3112
 * Get a block job using its ID. Called with job_mutex held.
3113
 */
3114
static BlockJob *find_block_job_locked(const char *id, Error **errp)
3115
{
3116
    BlockJob *job;
3117

3118
    assert(id != NULL);
3119

3120
    job = block_job_get_locked(id);
3121

3122
    if (!job) {
3123
        error_set(errp, ERROR_CLASS_DEVICE_NOT_ACTIVE,
3124
                  "Block job '%s' not found", id);
3125
        return NULL;
3126
    }
3127

3128
    return job;
3129
}
3130

3131
void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
3132
{
3133
    BlockJob *job;
3134

3135
    JOB_LOCK_GUARD();
3136
    job = find_block_job_locked(device, errp);
3137

3138
    if (!job) {
3139
        return;
3140
    }
3141

3142
    block_job_set_speed_locked(job, speed, errp);
3143
}
3144

3145
void qmp_block_job_cancel(const char *device,
3146
                          bool has_force, bool force, Error **errp)
3147
{
3148
    BlockJob *job;
3149

3150
    JOB_LOCK_GUARD();
3151
    job = find_block_job_locked(device, errp);
3152

3153
    if (!job) {
3154
        return;
3155
    }
3156

3157
    if (!has_force) {
3158
        force = false;
3159
    }
3160

3161
    if (job_user_paused_locked(&job->job) && !force) {
3162
        error_setg(errp, "The block job for device '%s' is currently paused",
3163
                   device);
3164
        return;
3165
    }
3166

3167
    trace_qmp_block_job_cancel(job);
3168
    job_user_cancel_locked(&job->job, force, errp);
3169
}
3170

3171
void qmp_block_job_pause(const char *device, Error **errp)
3172
{
3173
    BlockJob *job;
3174

3175
    JOB_LOCK_GUARD();
3176
    job = find_block_job_locked(device, errp);
3177

3178
    if (!job) {
3179
        return;
3180
    }
3181

3182
    trace_qmp_block_job_pause(job);
3183
    job_user_pause_locked(&job->job, errp);
3184
}
3185

3186
void qmp_block_job_resume(const char *device, Error **errp)
3187
{
3188
    BlockJob *job;
3189

3190
    JOB_LOCK_GUARD();
3191
    job = find_block_job_locked(device, errp);
3192

3193
    if (!job) {
3194
        return;
3195
    }
3196

3197
    trace_qmp_block_job_resume(job);
3198
    job_user_resume_locked(&job->job, errp);
3199
}
3200

3201
void qmp_block_job_complete(const char *device, Error **errp)
3202
{
3203
    BlockJob *job;
3204

3205
    JOB_LOCK_GUARD();
3206
    job = find_block_job_locked(device, errp);
3207

3208
    if (!job) {
3209
        return;
3210
    }
3211

3212
    trace_qmp_block_job_complete(job);
3213
    job_complete_locked(&job->job, errp);
3214
}
3215

3216
void qmp_block_job_finalize(const char *id, Error **errp)
3217
{
3218
    BlockJob *job;
3219

3220
    JOB_LOCK_GUARD();
3221
    job = find_block_job_locked(id, errp);
3222

3223
    if (!job) {
3224
        return;
3225
    }
3226

3227
    trace_qmp_block_job_finalize(job);
3228
    job_ref_locked(&job->job);
3229
    job_finalize_locked(&job->job, errp);
3230

3231
    job_unref_locked(&job->job);
3232
}
3233

3234
void qmp_block_job_dismiss(const char *id, Error **errp)
3235
{
3236
    BlockJob *bjob;
3237
    Job *job;
3238

3239
    JOB_LOCK_GUARD();
3240
    bjob = find_block_job_locked(id, errp);
3241

3242
    if (!bjob) {
3243
        return;
3244
    }
3245

3246
    trace_qmp_block_job_dismiss(bjob);
3247
    job = &bjob->job;
3248
    job_dismiss_locked(&job, errp);
3249
}
3250

3251
void qmp_block_job_change(BlockJobChangeOptions *opts, Error **errp)
3252
{
3253
    BlockJob *job;
3254

3255
    JOB_LOCK_GUARD();
3256
    job = find_block_job_locked(opts->id, errp);
3257

3258
    if (!job) {
3259
        return;
3260
    }
3261

3262
    block_job_change_locked(job, opts, errp);
3263
}
3264

3265
void qmp_change_backing_file(const char *device,
3266
                             const char *image_node_name,
3267
                             const char *backing_file,
3268
                             Error **errp)
3269
{
3270
    BlockDriverState *bs = NULL;
3271
    BlockDriverState *image_bs = NULL;
3272
    Error *local_err = NULL;
3273
    bool ro;
3274
    int ret;
3275

3276
    bs = qmp_get_root_bs(device, errp);
3277
    if (!bs) {
3278
        return;
3279
    }
3280

3281
    bdrv_graph_rdlock_main_loop();
3282

3283
    image_bs = bdrv_lookup_bs(NULL, image_node_name, &local_err);
3284
    if (local_err) {
3285
        error_propagate(errp, local_err);
3286
        goto out_rdlock;
3287
    }
3288

3289
    if (!image_bs) {
3290
        error_setg(errp, "image file not found");
3291
        goto out_rdlock;
3292
    }
3293

3294
    if (bdrv_find_base(image_bs) == image_bs) {
3295
        error_setg(errp, "not allowing backing file change on an image "
3296
                         "without a backing file");
3297
        goto out_rdlock;
3298
    }
3299

3300
    /* even though we are not necessarily operating on bs, we need it to
3301
     * determine if block ops are currently prohibited on the chain */
3302
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_CHANGE, errp)) {
3303
        goto out_rdlock;
3304
    }
3305

3306
    /* final sanity check */
3307
    if (!bdrv_chain_contains(bs, image_bs)) {
3308
        error_setg(errp, "'%s' and image file are not in the same chain",
3309
                   device);
3310
        goto out_rdlock;
3311
    }
3312
    bdrv_graph_rdunlock_main_loop();
3313

3314
    /* if not r/w, reopen to make r/w */
3315
    ro = bdrv_is_read_only(image_bs);
3316

3317
    if (ro) {
3318
        if (bdrv_reopen_set_read_only(image_bs, false, errp) != 0) {
3319
            return;
3320
        }
3321
    }
3322

3323
    ret = bdrv_change_backing_file(image_bs, backing_file,
3324
                                   image_bs->drv ? image_bs->drv->format_name : "",
3325
                                   false);
3326

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

3334
    if (ro) {
3335
        bdrv_reopen_set_read_only(image_bs, true, errp);
3336
    }
3337
    return;
3338

3339
out_rdlock:
3340
    bdrv_graph_rdunlock_main_loop();
3341
}
3342

3343
void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
3344
{
3345
    BlockDriverState *bs;
3346
    QObject *obj;
3347
    Visitor *v = qobject_output_visitor_new(&obj);
3348
    QDict *qdict;
3349

3350
    visit_type_BlockdevOptions(v, NULL, &options, &error_abort);
3351
    visit_complete(v, &obj);
3352
    qdict = qobject_to(QDict, obj);
3353

3354
    qdict_flatten(qdict);
3355

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

3361
    bs = bds_tree_init(qdict, errp);
3362
    if (!bs) {
3363
        goto fail;
3364
    }
3365

3366
    bdrv_set_monitor_owned(bs);
3367

3368
fail:
3369
    visit_free(v);
3370
}
3371

3372
void qmp_blockdev_reopen(BlockdevOptionsList *reopen_list, Error **errp)
3373
{
3374
    BlockReopenQueue *queue = NULL;
3375

3376
    /* Add each one of the BDS that we want to reopen to the queue */
3377
    for (; reopen_list != NULL; reopen_list = reopen_list->next) {
3378
        BlockdevOptions *options = reopen_list->value;
3379
        BlockDriverState *bs;
3380
        QObject *obj;
3381
        Visitor *v;
3382
        QDict *qdict;
3383

3384
        /* Check for the selected node name */
3385
        if (!options->node_name) {
3386
            error_setg(errp, "node-name not specified");
3387
            goto fail;
3388
        }
3389

3390
        bs = bdrv_find_node(options->node_name);
3391
        if (!bs) {
3392
            error_setg(errp, "Failed to find node with node-name='%s'",
3393
                       options->node_name);
3394
            goto fail;
3395
        }
3396

3397
        /* Put all options in a QDict and flatten it */
3398
        v = qobject_output_visitor_new(&obj);
3399
        visit_type_BlockdevOptions(v, NULL, &options, &error_abort);
3400
        visit_complete(v, &obj);
3401
        visit_free(v);
3402

3403
        qdict = qobject_to(QDict, obj);
3404

3405
        qdict_flatten(qdict);
3406

3407
        queue = bdrv_reopen_queue(queue, bs, qdict, false);
3408
    }
3409

3410
    /* Perform the reopen operation */
3411
    bdrv_reopen_multiple(queue, errp);
3412
    queue = NULL;
3413

3414
fail:
3415
    bdrv_reopen_queue_free(queue);
3416
}
3417

3418
void qmp_blockdev_del(const char *node_name, Error **errp)
3419
{
3420
    BlockDriverState *bs;
3421

3422
    GLOBAL_STATE_CODE();
3423
    GRAPH_RDLOCK_GUARD_MAINLOOP();
3424

3425
    bs = bdrv_find_node(node_name);
3426
    if (!bs) {
3427
        error_setg(errp, "Failed to find node with node-name='%s'", node_name);
3428
        return;
3429
    }
3430
    if (bdrv_has_blk(bs)) {
3431
        error_setg(errp, "Node %s is in use", node_name);
3432
        return;
3433
    }
3434

3435
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, errp)) {
3436
        return;
3437
    }
3438

3439
    if (!QTAILQ_IN_USE(bs, monitor_list)) {
3440
        error_setg(errp, "Node %s is not owned by the monitor",
3441
                   bs->node_name);
3442
        return;
3443
    }
3444

3445
    if (bs->refcnt > 1) {
3446
        error_setg(errp, "Block device %s is in use",
3447
                   bdrv_get_device_or_node_name(bs));
3448
        return;
3449
    }
3450

3451
    QTAILQ_REMOVE(&monitor_bdrv_states, bs, monitor_list);
3452
    bdrv_unref(bs);
3453
}
3454

3455
static BdrvChild * GRAPH_RDLOCK
3456
bdrv_find_child(BlockDriverState *parent_bs, const char *child_name)
3457
{
3458
    BdrvChild *child;
3459

3460
    QLIST_FOREACH(child, &parent_bs->children, next) {
3461
        if (strcmp(child->name, child_name) == 0) {
3462
            return child;
3463
        }
3464
    }
3465

3466
    return NULL;
3467
}
3468

3469
void qmp_x_blockdev_change(const char *parent, const char *child,
3470
                           const char *node, Error **errp)
3471
{
3472
    BlockDriverState *parent_bs, *new_bs = NULL;
3473
    BdrvChild *p_child;
3474

3475
    bdrv_graph_wrlock();
3476

3477
    parent_bs = bdrv_lookup_bs(parent, parent, errp);
3478
    if (!parent_bs) {
3479
        goto out;
3480
    }
3481

3482
    if (!child == !node) {
3483
        if (child) {
3484
            error_setg(errp, "The parameters child and node are in conflict");
3485
        } else {
3486
            error_setg(errp, "Either child or node must be specified");
3487
        }
3488
        goto out;
3489
    }
3490

3491
    if (child) {
3492
        p_child = bdrv_find_child(parent_bs, child);
3493
        if (!p_child) {
3494
            error_setg(errp, "Node '%s' does not have child '%s'",
3495
                       parent, child);
3496
            goto out;
3497
        }
3498
        bdrv_del_child(parent_bs, p_child, errp);
3499
    }
3500

3501
    if (node) {
3502
        new_bs = bdrv_find_node(node);
3503
        if (!new_bs) {
3504
            error_setg(errp, "Node '%s' not found", node);
3505
            goto out;
3506
        }
3507
        bdrv_add_child(parent_bs, new_bs, errp);
3508
    }
3509

3510
out:
3511
    bdrv_graph_wrunlock();
3512
}
3513

3514
BlockJobInfoList *qmp_query_block_jobs(Error **errp)
3515
{
3516
    BlockJobInfoList *head = NULL, **tail = &head;
3517
    BlockJob *job;
3518

3519
    JOB_LOCK_GUARD();
3520

3521
    for (job = block_job_next_locked(NULL); job;
3522
         job = block_job_next_locked(job)) {
3523
        BlockJobInfo *value;
3524

3525
        if (block_job_is_internal(job)) {
3526
            continue;
3527
        }
3528
        value = block_job_query_locked(job, errp);
3529
        if (!value) {
3530
            qapi_free_BlockJobInfoList(head);
3531
            return NULL;
3532
        }
3533
        QAPI_LIST_APPEND(tail, value);
3534
    }
3535

3536
    return head;
3537
}
3538

3539
void qmp_x_blockdev_set_iothread(const char *node_name, StrOrNull *iothread,
3540
                                 bool has_force, bool force, Error **errp)
3541
{
3542
    AioContext *new_context;
3543
    BlockDriverState *bs;
3544

3545
    GRAPH_RDLOCK_GUARD_MAINLOOP();
3546

3547
    bs = bdrv_find_node(node_name);
3548
    if (!bs) {
3549
        error_setg(errp, "Failed to find node with node-name='%s'", node_name);
3550
        return;
3551
    }
3552

3553
    /* Protects against accidents. */
3554
    if (!(has_force && force) && bdrv_has_blk(bs)) {
3555
        error_setg(errp, "Node %s is associated with a BlockBackend and could "
3556
                         "be in use (use force=true to override this check)",
3557
                         node_name);
3558
        return;
3559
    }
3560

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

3568
        new_context = iothread_get_aio_context(obj);
3569
    } else {
3570
        new_context = qemu_get_aio_context();
3571
    }
3572

3573
    bdrv_try_change_aio_context(bs, new_context, NULL, errp);
3574
}
3575

3576
QemuOptsList qemu_common_drive_opts = {
3577
    .name = "drive",
3578
    .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),
3579
    .desc = {
3580
        {
3581
            .name = "snapshot",
3582
            .type = QEMU_OPT_BOOL,
3583
            .help = "enable/disable snapshot mode",
3584
        },{
3585
            .name = "aio",
3586
            .type = QEMU_OPT_STRING,
3587
            .help = "host AIO implementation (threads, native, io_uring)",
3588
        },{
3589
            .name = BDRV_OPT_CACHE_WB,
3590
            .type = QEMU_OPT_BOOL,
3591
            .help = "Enable writeback mode",
3592
        },{
3593
            .name = "format",
3594
            .type = QEMU_OPT_STRING,
3595
            .help = "disk format (raw, qcow2, ...)",
3596
        },{
3597
            .name = "rerror",
3598
            .type = QEMU_OPT_STRING,
3599
            .help = "read error action",
3600
        },{
3601
            .name = "werror",
3602
            .type = QEMU_OPT_STRING,
3603
            .help = "write error action",
3604
        },{
3605
            .name = BDRV_OPT_READ_ONLY,
3606
            .type = QEMU_OPT_BOOL,
3607
            .help = "open drive file as read-only",
3608
        },
3609

3610
        THROTTLE_OPTS,
3611

3612
        {
3613
            .name = "throttling.group",
3614
            .type = QEMU_OPT_STRING,
3615
            .help = "name of the block throttling group",
3616
        },{
3617
            .name = "copy-on-read",
3618
            .type = QEMU_OPT_BOOL,
3619
            .help = "copy read data from backing file into image file",
3620
        },{
3621
            .name = "detect-zeroes",
3622
            .type = QEMU_OPT_STRING,
3623
            .help = "try to optimize zero writes (off, on, unmap)",
3624
        },{
3625
            .name = "stats-account-invalid",
3626
            .type = QEMU_OPT_BOOL,
3627
            .help = "whether to account for invalid I/O operations "
3628
                    "in the statistics",
3629
        },{
3630
            .name = "stats-account-failed",
3631
            .type = QEMU_OPT_BOOL,
3632
            .help = "whether to account for failed I/O operations "
3633
                    "in the statistics",
3634
        },
3635
        { /* end of list */ }
3636
    },
3637
};
3638

3639
QemuOptsList qemu_drive_opts = {
3640
    .name = "drive",
3641
    .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
3642
    .desc = {
3643
        /*
3644
         * no elements => accept any params
3645
         * validation will happen later
3646
         */
3647
        { /* end of list */ }
3648
    },
3649
};
3650
qemu

Использование cookies
