block: Add bdrv_has_blk()
[qemu.git] / block.c
CommitLineData
fc01f7e7
FB
1/*
2 * QEMU System Emulator block driver
5fafdf24 3 *
fc01f7e7 4 * Copyright (c) 2003 Fabrice Bellard
5fafdf24 5 *
fc01f7e7
FB
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
d38ea87a 24#include "qemu/osdep.h"
6d519a5f 25#include "trace.h"
737e150e
PB
26#include "block/block_int.h"
27#include "block/blockjob.h"
d49b6836 28#include "qemu/error-report.h"
1de7afc9 29#include "qemu/module.h"
cc7a8ea7 30#include "qapi/qmp/qerror.h"
91a097e7 31#include "qapi/qmp/qbool.h"
7b1b5d19 32#include "qapi/qmp/qjson.h"
bfb197e0 33#include "sysemu/block-backend.h"
9c17d615 34#include "sysemu/sysemu.h"
1de7afc9 35#include "qemu/notify.h"
10817bf0 36#include "qemu/coroutine.h"
c13163fb 37#include "block/qapi.h"
b2023818 38#include "qmp-commands.h"
1de7afc9 39#include "qemu/timer.h"
a5ee7bd4 40#include "qapi-event.h"
f348b6d1
VB
41#include "qemu/cutils.h"
42#include "qemu/id.h"
fc01f7e7 43
71e72a19 44#ifdef CONFIG_BSD
7674e7bf 45#include <sys/ioctl.h>
72cf2d4f 46#include <sys/queue.h>
c5e97233 47#ifndef __DragonFly__
7674e7bf
FB
48#include <sys/disk.h>
49#endif
c5e97233 50#endif
7674e7bf 51
49dc768d
AL
52#ifdef _WIN32
53#include <windows.h>
54#endif
55
1c9805a3
SH
56#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
57
dc364f4c
BC
58static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
59 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
60
2c1d04e0
HR
61static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
62 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
63
8a22f02a
SH
64static QLIST_HEAD(, BlockDriver) bdrv_drivers =
65 QLIST_HEAD_INITIALIZER(bdrv_drivers);
ea2384d3 66
f3930ed0
KW
67static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
68 const char *reference, QDict *options, int flags,
69 BlockDriverState *parent,
ce343771 70 const BdrvChildRole *child_role, Error **errp);
f3930ed0 71
eb852011
MA
72/* If non-zero, use only whitelisted block drivers */
73static int use_bdrv_whitelist;
74
64dff520
HR
75static void bdrv_close(BlockDriverState *bs);
76
9e0b22f4
SH
77#ifdef _WIN32
78static int is_windows_drive_prefix(const char *filename)
79{
80 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
81 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
82 filename[1] == ':');
83}
84
85int is_windows_drive(const char *filename)
86{
87 if (is_windows_drive_prefix(filename) &&
88 filename[2] == '\0')
89 return 1;
90 if (strstart(filename, "\\\\.\\", NULL) ||
91 strstart(filename, "//./", NULL))
92 return 1;
93 return 0;
94}
95#endif
96
339064d5
KW
97size_t bdrv_opt_mem_align(BlockDriverState *bs)
98{
99 if (!bs || !bs->drv) {
459b4e66
DL
100 /* page size or 4k (hdd sector size) should be on the safe side */
101 return MAX(4096, getpagesize());
339064d5
KW
102 }
103
104 return bs->bl.opt_mem_alignment;
105}
106
4196d2f0
DL
107size_t bdrv_min_mem_align(BlockDriverState *bs)
108{
109 if (!bs || !bs->drv) {
459b4e66
DL
110 /* page size or 4k (hdd sector size) should be on the safe side */
111 return MAX(4096, getpagesize());
4196d2f0
DL
112 }
113
114 return bs->bl.min_mem_alignment;
115}
116
9e0b22f4 117/* check if the path starts with "<protocol>:" */
5c98415b 118int path_has_protocol(const char *path)
9e0b22f4 119{
947995c0
PB
120 const char *p;
121
9e0b22f4
SH
122#ifdef _WIN32
123 if (is_windows_drive(path) ||
124 is_windows_drive_prefix(path)) {
125 return 0;
126 }
947995c0
PB
127 p = path + strcspn(path, ":/\\");
128#else
129 p = path + strcspn(path, ":/");
9e0b22f4
SH
130#endif
131
947995c0 132 return *p == ':';
9e0b22f4
SH
133}
134
83f64091 135int path_is_absolute(const char *path)
3b0d4f61 136{
21664424
FB
137#ifdef _WIN32
138 /* specific case for names like: "\\.\d:" */
f53f4da9 139 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
21664424 140 return 1;
f53f4da9
PB
141 }
142 return (*path == '/' || *path == '\\');
3b9f94e1 143#else
f53f4da9 144 return (*path == '/');
3b9f94e1 145#endif
3b0d4f61
FB
146}
147
83f64091
FB
148/* if filename is absolute, just copy it to dest. Otherwise, build a
149 path to it by considering it is relative to base_path. URL are
150 supported. */
151void path_combine(char *dest, int dest_size,
152 const char *base_path,
153 const char *filename)
3b0d4f61 154{
83f64091
FB
155 const char *p, *p1;
156 int len;
157
158 if (dest_size <= 0)
159 return;
160 if (path_is_absolute(filename)) {
161 pstrcpy(dest, dest_size, filename);
162 } else {
163 p = strchr(base_path, ':');
164 if (p)
165 p++;
166 else
167 p = base_path;
3b9f94e1
FB
168 p1 = strrchr(base_path, '/');
169#ifdef _WIN32
170 {
171 const char *p2;
172 p2 = strrchr(base_path, '\\');
173 if (!p1 || p2 > p1)
174 p1 = p2;
175 }
176#endif
83f64091
FB
177 if (p1)
178 p1++;
179 else
180 p1 = base_path;
181 if (p1 > p)
182 p = p1;
183 len = p - base_path;
184 if (len > dest_size - 1)
185 len = dest_size - 1;
186 memcpy(dest, base_path, len);
187 dest[len] = '\0';
188 pstrcat(dest, dest_size, filename);
3b0d4f61 189 }
3b0d4f61
FB
190}
191
0a82855a
HR
192void bdrv_get_full_backing_filename_from_filename(const char *backed,
193 const char *backing,
9f07429e
HR
194 char *dest, size_t sz,
195 Error **errp)
dc5a1371 196{
9f07429e
HR
197 if (backing[0] == '\0' || path_has_protocol(backing) ||
198 path_is_absolute(backing))
199 {
0a82855a 200 pstrcpy(dest, sz, backing);
9f07429e
HR
201 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
202 error_setg(errp, "Cannot use relative backing file names for '%s'",
203 backed);
dc5a1371 204 } else {
0a82855a 205 path_combine(dest, sz, backed, backing);
dc5a1371
PB
206 }
207}
208
9f07429e
HR
209void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
210 Error **errp)
0a82855a 211{
9f07429e
HR
212 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
213
214 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
215 dest, sz, errp);
0a82855a
HR
216}
217
0eb7217e
SH
218void bdrv_register(BlockDriver *bdrv)
219{
8a22f02a 220 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
ea2384d3 221}
b338082b 222
7f06d47e 223BlockDriverState *bdrv_new_root(void)
b338082b 224{
9aaf28c6 225 return bdrv_new();
e4e9986b
MA
226}
227
228BlockDriverState *bdrv_new(void)
229{
230 BlockDriverState *bs;
231 int i;
232
5839e53b 233 bs = g_new0(BlockDriverState, 1);
e4654d2d 234 QLIST_INIT(&bs->dirty_bitmaps);
fbe40ff7
FZ
235 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
236 QLIST_INIT(&bs->op_blockers[i]);
237 }
d616b224 238 notifier_with_return_list_init(&bs->before_write_notifiers);
9fcb0251 239 bs->refcnt = 1;
dcd04228 240 bs->aio_context = qemu_get_aio_context();
d7d512f6 241
2c1d04e0
HR
242 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
243
b338082b
FB
244 return bs;
245}
246
ea2384d3
FB
247BlockDriver *bdrv_find_format(const char *format_name)
248{
249 BlockDriver *drv1;
8a22f02a
SH
250 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
251 if (!strcmp(drv1->format_name, format_name)) {
ea2384d3 252 return drv1;
8a22f02a 253 }
ea2384d3
FB
254 }
255 return NULL;
256}
257
b64ec4e4 258static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
eb852011 259{
b64ec4e4
FZ
260 static const char *whitelist_rw[] = {
261 CONFIG_BDRV_RW_WHITELIST
262 };
263 static const char *whitelist_ro[] = {
264 CONFIG_BDRV_RO_WHITELIST
eb852011
MA
265 };
266 const char **p;
267
b64ec4e4 268 if (!whitelist_rw[0] && !whitelist_ro[0]) {
eb852011 269 return 1; /* no whitelist, anything goes */
b64ec4e4 270 }
eb852011 271
b64ec4e4 272 for (p = whitelist_rw; *p; p++) {
eb852011
MA
273 if (!strcmp(drv->format_name, *p)) {
274 return 1;
275 }
276 }
b64ec4e4
FZ
277 if (read_only) {
278 for (p = whitelist_ro; *p; p++) {
279 if (!strcmp(drv->format_name, *p)) {
280 return 1;
281 }
282 }
283 }
eb852011
MA
284 return 0;
285}
286
e6ff69bf
DB
287bool bdrv_uses_whitelist(void)
288{
289 return use_bdrv_whitelist;
290}
291
5b7e1542
ZYW
292typedef struct CreateCo {
293 BlockDriver *drv;
294 char *filename;
83d0521a 295 QemuOpts *opts;
5b7e1542 296 int ret;
cc84d90f 297 Error *err;
5b7e1542
ZYW
298} CreateCo;
299
300static void coroutine_fn bdrv_create_co_entry(void *opaque)
301{
cc84d90f
HR
302 Error *local_err = NULL;
303 int ret;
304
5b7e1542
ZYW
305 CreateCo *cco = opaque;
306 assert(cco->drv);
307
c282e1fd 308 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
84d18f06 309 if (local_err) {
cc84d90f
HR
310 error_propagate(&cco->err, local_err);
311 }
312 cco->ret = ret;
5b7e1542
ZYW
313}
314
0e7e1989 315int bdrv_create(BlockDriver *drv, const char* filename,
83d0521a 316 QemuOpts *opts, Error **errp)
ea2384d3 317{
5b7e1542
ZYW
318 int ret;
319
320 Coroutine *co;
321 CreateCo cco = {
322 .drv = drv,
323 .filename = g_strdup(filename),
83d0521a 324 .opts = opts,
5b7e1542 325 .ret = NOT_DONE,
cc84d90f 326 .err = NULL,
5b7e1542
ZYW
327 };
328
c282e1fd 329 if (!drv->bdrv_create) {
cc84d90f 330 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
80168bff
LC
331 ret = -ENOTSUP;
332 goto out;
5b7e1542
ZYW
333 }
334
335 if (qemu_in_coroutine()) {
336 /* Fast-path if already in coroutine context */
337 bdrv_create_co_entry(&cco);
338 } else {
339 co = qemu_coroutine_create(bdrv_create_co_entry);
340 qemu_coroutine_enter(co, &cco);
341 while (cco.ret == NOT_DONE) {
b47ec2c4 342 aio_poll(qemu_get_aio_context(), true);
5b7e1542
ZYW
343 }
344 }
345
346 ret = cco.ret;
cc84d90f 347 if (ret < 0) {
84d18f06 348 if (cco.err) {
cc84d90f
HR
349 error_propagate(errp, cco.err);
350 } else {
351 error_setg_errno(errp, -ret, "Could not create image");
352 }
353 }
0e7e1989 354
80168bff
LC
355out:
356 g_free(cco.filename);
5b7e1542 357 return ret;
ea2384d3
FB
358}
359
c282e1fd 360int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
84a12e66
CH
361{
362 BlockDriver *drv;
cc84d90f
HR
363 Error *local_err = NULL;
364 int ret;
84a12e66 365
b65a5e12 366 drv = bdrv_find_protocol(filename, true, errp);
84a12e66 367 if (drv == NULL) {
16905d71 368 return -ENOENT;
84a12e66
CH
369 }
370
c282e1fd 371 ret = bdrv_create(drv, filename, opts, &local_err);
84d18f06 372 if (local_err) {
cc84d90f
HR
373 error_propagate(errp, local_err);
374 }
375 return ret;
84a12e66
CH
376}
377
892b7de8
ET
378/**
379 * Try to get @bs's logical and physical block size.
380 * On success, store them in @bsz struct and return 0.
381 * On failure return -errno.
382 * @bs must not be empty.
383 */
384int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
385{
386 BlockDriver *drv = bs->drv;
387
388 if (drv && drv->bdrv_probe_blocksizes) {
389 return drv->bdrv_probe_blocksizes(bs, bsz);
390 }
391
392 return -ENOTSUP;
393}
394
395/**
396 * Try to get @bs's geometry (cyls, heads, sectors).
397 * On success, store them in @geo struct and return 0.
398 * On failure return -errno.
399 * @bs must not be empty.
400 */
401int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
402{
403 BlockDriver *drv = bs->drv;
404
405 if (drv && drv->bdrv_probe_geometry) {
406 return drv->bdrv_probe_geometry(bs, geo);
407 }
408
409 return -ENOTSUP;
410}
411
eba25057
JM
412/*
413 * Create a uniquely-named empty temporary file.
414 * Return 0 upon success, otherwise a negative errno value.
415 */
416int get_tmp_filename(char *filename, int size)
d5249393 417{
eba25057 418#ifdef _WIN32
3b9f94e1 419 char temp_dir[MAX_PATH];
eba25057
JM
420 /* GetTempFileName requires that its output buffer (4th param)
421 have length MAX_PATH or greater. */
422 assert(size >= MAX_PATH);
423 return (GetTempPath(MAX_PATH, temp_dir)
424 && GetTempFileName(temp_dir, "qem", 0, filename)
425 ? 0 : -GetLastError());
d5249393 426#else
67b915a5 427 int fd;
7ccfb2eb 428 const char *tmpdir;
0badc1ee 429 tmpdir = getenv("TMPDIR");
69bef793
AS
430 if (!tmpdir) {
431 tmpdir = "/var/tmp";
432 }
eba25057
JM
433 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
434 return -EOVERFLOW;
435 }
ea2384d3 436 fd = mkstemp(filename);
fe235a06
DH
437 if (fd < 0) {
438 return -errno;
439 }
440 if (close(fd) != 0) {
441 unlink(filename);
eba25057
JM
442 return -errno;
443 }
444 return 0;
d5249393 445#endif
eba25057 446}
fc01f7e7 447
84a12e66
CH
448/*
449 * Detect host devices. By convention, /dev/cdrom[N] is always
450 * recognized as a host CDROM.
451 */
452static BlockDriver *find_hdev_driver(const char *filename)
453{
454 int score_max = 0, score;
455 BlockDriver *drv = NULL, *d;
456
457 QLIST_FOREACH(d, &bdrv_drivers, list) {
458 if (d->bdrv_probe_device) {
459 score = d->bdrv_probe_device(filename);
460 if (score > score_max) {
461 score_max = score;
462 drv = d;
463 }
464 }
465 }
466
467 return drv;
468}
469
98289620 470BlockDriver *bdrv_find_protocol(const char *filename,
b65a5e12
HR
471 bool allow_protocol_prefix,
472 Error **errp)
83f64091
FB
473{
474 BlockDriver *drv1;
475 char protocol[128];
1cec71e3 476 int len;
83f64091 477 const char *p;
19cb3738 478
66f82cee
KW
479 /* TODO Drivers without bdrv_file_open must be specified explicitly */
480
39508e7a
CH
481 /*
482 * XXX(hch): we really should not let host device detection
483 * override an explicit protocol specification, but moving this
484 * later breaks access to device names with colons in them.
485 * Thanks to the brain-dead persistent naming schemes on udev-
486 * based Linux systems those actually are quite common.
487 */
488 drv1 = find_hdev_driver(filename);
489 if (drv1) {
490 return drv1;
491 }
492
98289620 493 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
ef810437 494 return &bdrv_file;
84a12e66 495 }
98289620 496
9e0b22f4
SH
497 p = strchr(filename, ':');
498 assert(p != NULL);
1cec71e3
AL
499 len = p - filename;
500 if (len > sizeof(protocol) - 1)
501 len = sizeof(protocol) - 1;
502 memcpy(protocol, filename, len);
503 protocol[len] = '\0';
8a22f02a 504 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
5fafdf24 505 if (drv1->protocol_name &&
8a22f02a 506 !strcmp(drv1->protocol_name, protocol)) {
83f64091 507 return drv1;
8a22f02a 508 }
83f64091 509 }
b65a5e12
HR
510
511 error_setg(errp, "Unknown protocol '%s'", protocol);
83f64091
FB
512 return NULL;
513}
514
c6684249
MA
515/*
516 * Guess image format by probing its contents.
517 * This is not a good idea when your image is raw (CVE-2008-2004), but
518 * we do it anyway for backward compatibility.
519 *
520 * @buf contains the image's first @buf_size bytes.
7cddd372
KW
521 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
522 * but can be smaller if the image file is smaller)
c6684249
MA
523 * @filename is its filename.
524 *
525 * For all block drivers, call the bdrv_probe() method to get its
526 * probing score.
527 * Return the first block driver with the highest probing score.
528 */
38f3ef57
KW
529BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
530 const char *filename)
c6684249
MA
531{
532 int score_max = 0, score;
533 BlockDriver *drv = NULL, *d;
534
535 QLIST_FOREACH(d, &bdrv_drivers, list) {
536 if (d->bdrv_probe) {
537 score = d->bdrv_probe(buf, buf_size, filename);
538 if (score > score_max) {
539 score_max = score;
540 drv = d;
541 }
542 }
543 }
544
545 return drv;
546}
547
f500a6d3 548static int find_image_format(BlockDriverState *bs, const char *filename,
34b5d2c6 549 BlockDriver **pdrv, Error **errp)
f3a5d3f8 550{
c6684249 551 BlockDriver *drv;
7cddd372 552 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
f500a6d3 553 int ret = 0;
f8ea0b00 554
08a00559 555 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
b192af8a 556 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
ef810437 557 *pdrv = &bdrv_raw;
c98ac35d 558 return ret;
1a396859 559 }
f8ea0b00 560
83f64091 561 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
83f64091 562 if (ret < 0) {
34b5d2c6
HR
563 error_setg_errno(errp, -ret, "Could not read image for determining its "
564 "format");
c98ac35d
SW
565 *pdrv = NULL;
566 return ret;
83f64091
FB
567 }
568
c6684249 569 drv = bdrv_probe_all(buf, ret, filename);
c98ac35d 570 if (!drv) {
34b5d2c6
HR
571 error_setg(errp, "Could not determine image format: No compatible "
572 "driver found");
c98ac35d
SW
573 ret = -ENOENT;
574 }
575 *pdrv = drv;
576 return ret;
ea2384d3
FB
577}
578
51762288
SH
579/**
580 * Set the current 'total_sectors' value
65a9bb25 581 * Return 0 on success, -errno on error.
51762288
SH
582 */
583static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
584{
585 BlockDriver *drv = bs->drv;
586
396759ad 587 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
b192af8a 588 if (bdrv_is_sg(bs))
396759ad
NB
589 return 0;
590
51762288
SH
591 /* query actual device if possible, otherwise just trust the hint */
592 if (drv->bdrv_getlength) {
593 int64_t length = drv->bdrv_getlength(bs);
594 if (length < 0) {
595 return length;
596 }
7e382003 597 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
51762288
SH
598 }
599
600 bs->total_sectors = hint;
601 return 0;
602}
603
cddff5ba
KW
604/**
605 * Combines a QDict of new block driver @options with any missing options taken
606 * from @old_options, so that leaving out an option defaults to its old value.
607 */
608static void bdrv_join_options(BlockDriverState *bs, QDict *options,
609 QDict *old_options)
610{
611 if (bs->drv && bs->drv->bdrv_join_options) {
612 bs->drv->bdrv_join_options(options, old_options);
613 } else {
614 qdict_join(options, old_options, false);
615 }
616}
617
9e8f1835
PB
618/**
619 * Set open flags for a given discard mode
620 *
621 * Return 0 on success, -1 if the discard mode was invalid.
622 */
623int bdrv_parse_discard_flags(const char *mode, int *flags)
624{
625 *flags &= ~BDRV_O_UNMAP;
626
627 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
628 /* do nothing */
629 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
630 *flags |= BDRV_O_UNMAP;
631 } else {
632 return -1;
633 }
634
635 return 0;
636}
637
c3993cdc
SH
638/**
639 * Set open flags for a given cache mode
640 *
641 * Return 0 on success, -1 if the cache mode was invalid.
642 */
53e8ae01 643int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
c3993cdc
SH
644{
645 *flags &= ~BDRV_O_CACHE_MASK;
646
647 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
53e8ae01
KW
648 *writethrough = false;
649 *flags |= BDRV_O_NOCACHE;
92196b2f 650 } else if (!strcmp(mode, "directsync")) {
53e8ae01 651 *writethrough = true;
92196b2f 652 *flags |= BDRV_O_NOCACHE;
c3993cdc 653 } else if (!strcmp(mode, "writeback")) {
53e8ae01 654 *writethrough = false;
c3993cdc 655 } else if (!strcmp(mode, "unsafe")) {
53e8ae01 656 *writethrough = false;
c3993cdc
SH
657 *flags |= BDRV_O_NO_FLUSH;
658 } else if (!strcmp(mode, "writethrough")) {
53e8ae01 659 *writethrough = true;
c3993cdc
SH
660 } else {
661 return -1;
662 }
663
664 return 0;
665}
666
b1e6fc08 667/*
73176bee
KW
668 * Returns the options and flags that a temporary snapshot should get, based on
669 * the originally requested flags (the originally requested image will have
670 * flags like a backing file)
b1e6fc08 671 */
73176bee
KW
672static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
673 int parent_flags, QDict *parent_options)
b1e6fc08 674{
73176bee
KW
675 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
676
677 /* For temporary files, unconditional cache=unsafe is fine */
73176bee
KW
678 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
679 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
b1e6fc08
KW
680}
681
0b50cc88 682/*
8e2160e2
KW
683 * Returns the options and flags that bs->file should get if a protocol driver
684 * is expected, based on the given options and flags for the parent BDS
0b50cc88 685 */
8e2160e2
KW
686static void bdrv_inherited_options(int *child_flags, QDict *child_options,
687 int parent_flags, QDict *parent_options)
0b50cc88 688{
8e2160e2
KW
689 int flags = parent_flags;
690
0b50cc88
KW
691 /* Enable protocol handling, disable format probing for bs->file */
692 flags |= BDRV_O_PROTOCOL;
693
91a097e7
KW
694 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
695 * the parent. */
696 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
697 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
698
0b50cc88 699 /* Our block drivers take care to send flushes and respect unmap policy,
91a097e7
KW
700 * so we can default to enable both on lower layers regardless of the
701 * corresponding parent options. */
91a097e7 702 flags |= BDRV_O_UNMAP;
0b50cc88 703
0b50cc88 704 /* Clear flags that only apply to the top layer */
abb06c5a
DB
705 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
706 BDRV_O_NO_IO);
0b50cc88 707
8e2160e2 708 *child_flags = flags;
0b50cc88
KW
709}
710
f3930ed0 711const BdrvChildRole child_file = {
8e2160e2 712 .inherit_options = bdrv_inherited_options,
f3930ed0
KW
713};
714
715/*
8e2160e2
KW
716 * Returns the options and flags that bs->file should get if the use of formats
717 * (and not only protocols) is permitted for it, based on the given options and
718 * flags for the parent BDS
f3930ed0 719 */
8e2160e2
KW
720static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
721 int parent_flags, QDict *parent_options)
f3930ed0 722{
8e2160e2
KW
723 child_file.inherit_options(child_flags, child_options,
724 parent_flags, parent_options);
725
abb06c5a 726 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
f3930ed0
KW
727}
728
729const BdrvChildRole child_format = {
8e2160e2 730 .inherit_options = bdrv_inherited_fmt_options,
f3930ed0
KW
731};
732
317fc44e 733/*
8e2160e2
KW
734 * Returns the options and flags that bs->backing should get, based on the
735 * given options and flags for the parent BDS
317fc44e 736 */
8e2160e2
KW
737static void bdrv_backing_options(int *child_flags, QDict *child_options,
738 int parent_flags, QDict *parent_options)
317fc44e 739{
8e2160e2
KW
740 int flags = parent_flags;
741
b8816a43
KW
742 /* The cache mode is inherited unmodified for backing files; except WCE,
743 * which is only applied on the top level (BlockBackend) */
91a097e7
KW
744 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
745 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
746
317fc44e
KW
747 /* backing files always opened read-only */
748 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
749
750 /* snapshot=on is handled on the top layer */
8bfea15d 751 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
317fc44e 752
8e2160e2 753 *child_flags = flags;
317fc44e
KW
754}
755
f3930ed0 756static const BdrvChildRole child_backing = {
8e2160e2 757 .inherit_options = bdrv_backing_options,
f3930ed0
KW
758};
759
7b272452
KW
760static int bdrv_open_flags(BlockDriverState *bs, int flags)
761{
61de4c68 762 int open_flags = flags;
7b272452
KW
763
764 /*
765 * Clear flags that are internal to the block layer before opening the
766 * image.
767 */
20cca275 768 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
7b272452
KW
769
770 /*
771 * Snapshots should be writable.
772 */
8bfea15d 773 if (flags & BDRV_O_TEMPORARY) {
7b272452
KW
774 open_flags |= BDRV_O_RDWR;
775 }
776
777 return open_flags;
778}
779
91a097e7
KW
780static void update_flags_from_options(int *flags, QemuOpts *opts)
781{
782 *flags &= ~BDRV_O_CACHE_MASK;
783
91a097e7
KW
784 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
785 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
786 *flags |= BDRV_O_NO_FLUSH;
787 }
788
789 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
790 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
791 *flags |= BDRV_O_NOCACHE;
792 }
793}
794
795static void update_options_from_flags(QDict *options, int flags)
796{
91a097e7
KW
797 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
798 qdict_put(options, BDRV_OPT_CACHE_DIRECT,
799 qbool_from_bool(flags & BDRV_O_NOCACHE));
800 }
801 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
802 qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH,
803 qbool_from_bool(flags & BDRV_O_NO_FLUSH));
804 }
805}
806
636ea370
KW
807static void bdrv_assign_node_name(BlockDriverState *bs,
808 const char *node_name,
809 Error **errp)
6913c0c2 810{
15489c76 811 char *gen_node_name = NULL;
6913c0c2 812
15489c76
JC
813 if (!node_name) {
814 node_name = gen_node_name = id_generate(ID_BLOCK);
815 } else if (!id_wellformed(node_name)) {
816 /*
817 * Check for empty string or invalid characters, but not if it is
818 * generated (generated names use characters not available to the user)
819 */
9aebf3b8 820 error_setg(errp, "Invalid node name");
636ea370 821 return;
6913c0c2
BC
822 }
823
0c5e94ee 824 /* takes care of avoiding namespaces collisions */
7f06d47e 825 if (blk_by_name(node_name)) {
0c5e94ee
BC
826 error_setg(errp, "node-name=%s is conflicting with a device id",
827 node_name);
15489c76 828 goto out;
0c5e94ee
BC
829 }
830
6913c0c2
BC
831 /* takes care of avoiding duplicates node names */
832 if (bdrv_find_node(node_name)) {
833 error_setg(errp, "Duplicate node name");
15489c76 834 goto out;
6913c0c2
BC
835 }
836
837 /* copy node name into the bs and insert it into the graph list */
838 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
839 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
15489c76
JC
840out:
841 g_free(gen_node_name);
6913c0c2
BC
842}
843
18edf289
KW
844static QemuOptsList bdrv_runtime_opts = {
845 .name = "bdrv_common",
846 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
847 .desc = {
848 {
849 .name = "node-name",
850 .type = QEMU_OPT_STRING,
851 .help = "Node name of the block device node",
852 },
62392ebb
KW
853 {
854 .name = "driver",
855 .type = QEMU_OPT_STRING,
856 .help = "Block driver to use for the node",
857 },
91a097e7
KW
858 {
859 .name = BDRV_OPT_CACHE_DIRECT,
860 .type = QEMU_OPT_BOOL,
861 .help = "Bypass software writeback cache on the host",
862 },
863 {
864 .name = BDRV_OPT_CACHE_NO_FLUSH,
865 .type = QEMU_OPT_BOOL,
866 .help = "Ignore flush requests",
867 },
18edf289
KW
868 { /* end of list */ }
869 },
870};
871
57915332
KW
872/*
873 * Common part for opening disk images and files
b6ad491a
KW
874 *
875 * Removes all processed options from *options.
57915332 876 */
9a4f4c31 877static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
82dc8b41 878 QDict *options, Error **errp)
57915332
KW
879{
880 int ret, open_flags;
035fccdf 881 const char *filename;
62392ebb 882 const char *driver_name = NULL;
6913c0c2 883 const char *node_name = NULL;
18edf289 884 QemuOpts *opts;
62392ebb 885 BlockDriver *drv;
34b5d2c6 886 Error *local_err = NULL;
57915332 887
6405875c 888 assert(bs->file == NULL);
707ff828 889 assert(options != NULL && bs->options != options);
57915332 890
62392ebb
KW
891 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
892 qemu_opts_absorb_qdict(opts, options, &local_err);
893 if (local_err) {
894 error_propagate(errp, local_err);
895 ret = -EINVAL;
896 goto fail_opts;
897 }
898
899 driver_name = qemu_opt_get(opts, "driver");
900 drv = bdrv_find_format(driver_name);
901 assert(drv != NULL);
902
45673671 903 if (file != NULL) {
9a4f4c31 904 filename = file->bs->filename;
45673671
KW
905 } else {
906 filename = qdict_get_try_str(options, "filename");
907 }
908
765003db
KW
909 if (drv->bdrv_needs_filename && !filename) {
910 error_setg(errp, "The '%s' block driver requires a file name",
911 drv->format_name);
18edf289
KW
912 ret = -EINVAL;
913 goto fail_opts;
6913c0c2 914 }
6913c0c2 915
82dc8b41
KW
916 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
917 drv->format_name);
62392ebb 918
18edf289 919 node_name = qemu_opt_get(opts, "node-name");
636ea370 920 bdrv_assign_node_name(bs, node_name, &local_err);
0fb6395c 921 if (local_err) {
636ea370 922 error_propagate(errp, local_err);
18edf289
KW
923 ret = -EINVAL;
924 goto fail_opts;
5d186eb0
KW
925 }
926
c25f53b0 927 bs->request_alignment = 512;
0d51b4de 928 bs->zero_beyond_eof = true;
82dc8b41 929 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
b64ec4e4
FZ
930
931 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
8f94a6e4
KW
932 error_setg(errp,
933 !bs->read_only && bdrv_is_whitelisted(drv, true)
934 ? "Driver '%s' can only be used for read-only devices"
935 : "Driver '%s' is not whitelisted",
936 drv->format_name);
18edf289
KW
937 ret = -ENOTSUP;
938 goto fail_opts;
b64ec4e4 939 }
57915332 940
53fec9d3 941 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
82dc8b41 942 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
0ebd24e0
KW
943 if (!bs->read_only) {
944 bdrv_enable_copy_on_read(bs);
945 } else {
946 error_setg(errp, "Can't use copy-on-read on read-only device");
18edf289
KW
947 ret = -EINVAL;
948 goto fail_opts;
0ebd24e0 949 }
53fec9d3
SH
950 }
951
c2ad1b0c
KW
952 if (filename != NULL) {
953 pstrcpy(bs->filename, sizeof(bs->filename), filename);
954 } else {
955 bs->filename[0] = '\0';
956 }
91af7014 957 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
57915332 958
57915332 959 bs->drv = drv;
7267c094 960 bs->opaque = g_malloc0(drv->instance_size);
57915332 961
91a097e7
KW
962 /* Apply cache mode options */
963 update_flags_from_options(&bs->open_flags, opts);
73ac451f 964
66f82cee 965 /* Open the image, either directly or using a protocol */
82dc8b41 966 open_flags = bdrv_open_flags(bs, bs->open_flags);
66f82cee 967 if (drv->bdrv_file_open) {
5d186eb0 968 assert(file == NULL);
030be321 969 assert(!drv->bdrv_needs_filename || filename != NULL);
34b5d2c6 970 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
f500a6d3 971 } else {
2af5ef70 972 if (file == NULL) {
34b5d2c6
HR
973 error_setg(errp, "Can't use '%s' as a block driver for the "
974 "protocol level", drv->format_name);
2af5ef70
KW
975 ret = -EINVAL;
976 goto free_and_fail;
977 }
f500a6d3 978 bs->file = file;
34b5d2c6 979 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
66f82cee
KW
980 }
981
57915332 982 if (ret < 0) {
84d18f06 983 if (local_err) {
34b5d2c6 984 error_propagate(errp, local_err);
2fa9aa59
DH
985 } else if (bs->filename[0]) {
986 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
34b5d2c6
HR
987 } else {
988 error_setg_errno(errp, -ret, "Could not open image");
989 }
57915332
KW
990 goto free_and_fail;
991 }
992
51762288
SH
993 ret = refresh_total_sectors(bs, bs->total_sectors);
994 if (ret < 0) {
34b5d2c6 995 error_setg_errno(errp, -ret, "Could not refresh total sector count");
51762288 996 goto free_and_fail;
57915332 997 }
51762288 998
3baca891
KW
999 bdrv_refresh_limits(bs, &local_err);
1000 if (local_err) {
1001 error_propagate(errp, local_err);
1002 ret = -EINVAL;
1003 goto free_and_fail;
1004 }
1005
c25f53b0 1006 assert(bdrv_opt_mem_align(bs) != 0);
4196d2f0 1007 assert(bdrv_min_mem_align(bs) != 0);
b192af8a 1008 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
18edf289
KW
1009
1010 qemu_opts_del(opts);
57915332
KW
1011 return 0;
1012
1013free_and_fail:
f500a6d3 1014 bs->file = NULL;
7267c094 1015 g_free(bs->opaque);
57915332
KW
1016 bs->opaque = NULL;
1017 bs->drv = NULL;
18edf289
KW
1018fail_opts:
1019 qemu_opts_del(opts);
57915332
KW
1020 return ret;
1021}
1022
5e5c4f63
KW
1023static QDict *parse_json_filename(const char *filename, Error **errp)
1024{
1025 QObject *options_obj;
1026 QDict *options;
1027 int ret;
1028
1029 ret = strstart(filename, "json:", &filename);
1030 assert(ret);
1031
1032 options_obj = qobject_from_json(filename);
1033 if (!options_obj) {
1034 error_setg(errp, "Could not parse the JSON options");
1035 return NULL;
1036 }
1037
1038 if (qobject_type(options_obj) != QTYPE_QDICT) {
1039 qobject_decref(options_obj);
1040 error_setg(errp, "Invalid JSON object given");
1041 return NULL;
1042 }
1043
1044 options = qobject_to_qdict(options_obj);
1045 qdict_flatten(options);
1046
1047 return options;
1048}
1049
de3b53f0
KW
1050static void parse_json_protocol(QDict *options, const char **pfilename,
1051 Error **errp)
1052{
1053 QDict *json_options;
1054 Error *local_err = NULL;
1055
1056 /* Parse json: pseudo-protocol */
1057 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1058 return;
1059 }
1060
1061 json_options = parse_json_filename(*pfilename, &local_err);
1062 if (local_err) {
1063 error_propagate(errp, local_err);
1064 return;
1065 }
1066
1067 /* Options given in the filename have lower priority than options
1068 * specified directly */
1069 qdict_join(options, json_options, false);
1070 QDECREF(json_options);
1071 *pfilename = NULL;
1072}
1073
b6ce07aa 1074/*
f54120ff
KW
1075 * Fills in default options for opening images and converts the legacy
1076 * filename/flags pair to option QDict entries.
53a29513
HR
1077 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1078 * block driver has been specified explicitly.
b6ce07aa 1079 */
de3b53f0 1080static int bdrv_fill_options(QDict **options, const char *filename,
053e1578 1081 int *flags, Error **errp)
ea2384d3 1082{
c2ad1b0c 1083 const char *drvname;
53a29513 1084 bool protocol = *flags & BDRV_O_PROTOCOL;
e3fa4bfa 1085 bool parse_filename = false;
053e1578 1086 BlockDriver *drv = NULL;
34b5d2c6 1087 Error *local_err = NULL;
83f64091 1088
53a29513 1089 drvname = qdict_get_try_str(*options, "driver");
053e1578
HR
1090 if (drvname) {
1091 drv = bdrv_find_format(drvname);
1092 if (!drv) {
1093 error_setg(errp, "Unknown driver '%s'", drvname);
1094 return -ENOENT;
1095 }
1096 /* If the user has explicitly specified the driver, this choice should
1097 * override the BDRV_O_PROTOCOL flag */
1098 protocol = drv->bdrv_file_open;
53a29513
HR
1099 }
1100
1101 if (protocol) {
1102 *flags |= BDRV_O_PROTOCOL;
1103 } else {
1104 *flags &= ~BDRV_O_PROTOCOL;
1105 }
1106
91a097e7
KW
1107 /* Translate cache options from flags into options */
1108 update_options_from_flags(*options, *flags);
1109
035fccdf 1110 /* Fetch the file name from the options QDict if necessary */
17b005f1 1111 if (protocol && filename) {
f54120ff
KW
1112 if (!qdict_haskey(*options, "filename")) {
1113 qdict_put(*options, "filename", qstring_from_str(filename));
1114 parse_filename = true;
1115 } else {
1116 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1117 "the same time");
1118 return -EINVAL;
1119 }
035fccdf
KW
1120 }
1121
c2ad1b0c 1122 /* Find the right block driver */
f54120ff 1123 filename = qdict_get_try_str(*options, "filename");
f54120ff 1124
053e1578
HR
1125 if (!drvname && protocol) {
1126 if (filename) {
1127 drv = bdrv_find_protocol(filename, parse_filename, errp);
17b005f1 1128 if (!drv) {
053e1578 1129 return -EINVAL;
17b005f1 1130 }
053e1578
HR
1131
1132 drvname = drv->format_name;
1133 qdict_put(*options, "driver", qstring_from_str(drvname));
1134 } else {
1135 error_setg(errp, "Must specify either driver or file");
1136 return -EINVAL;
98289620 1137 }
c2ad1b0c
KW
1138 }
1139
17b005f1 1140 assert(drv || !protocol);
c2ad1b0c 1141
f54120ff 1142 /* Driver-specific filename parsing */
17b005f1 1143 if (drv && drv->bdrv_parse_filename && parse_filename) {
5acd9d81 1144 drv->bdrv_parse_filename(filename, *options, &local_err);
84d18f06 1145 if (local_err) {
34b5d2c6 1146 error_propagate(errp, local_err);
f54120ff 1147 return -EINVAL;
6963a30d 1148 }
cd5d031e
HR
1149
1150 if (!drv->bdrv_needs_filename) {
1151 qdict_del(*options, "filename");
cd5d031e 1152 }
6963a30d
KW
1153 }
1154
f54120ff
KW
1155 return 0;
1156}
1157
f21d96d0
KW
1158BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
1159 const char *child_name,
1160 const BdrvChildRole *child_role)
df581792
KW
1161{
1162 BdrvChild *child = g_new(BdrvChild, 1);
1163 *child = (BdrvChild) {
1164 .bs = child_bs,
260fecf1 1165 .name = g_strdup(child_name),
df581792
KW
1166 .role = child_role,
1167 };
1168
d42a8a93 1169 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
b4b059f6
KW
1170
1171 return child;
df581792
KW
1172}
1173
98292c61
WC
1174BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1175 BlockDriverState *child_bs,
1176 const char *child_name,
1177 const BdrvChildRole *child_role)
f21d96d0
KW
1178{
1179 BdrvChild *child = bdrv_root_attach_child(child_bs, child_name, child_role);
1180 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1181 return child;
1182}
1183
3f09bfbc 1184static void bdrv_detach_child(BdrvChild *child)
33a60407 1185{
f21d96d0
KW
1186 if (child->next.le_prev) {
1187 QLIST_REMOVE(child, next);
1188 child->next.le_prev = NULL;
1189 }
d42a8a93 1190 QLIST_REMOVE(child, next_parent);
260fecf1 1191 g_free(child->name);
33a60407
KW
1192 g_free(child);
1193}
1194
f21d96d0 1195void bdrv_root_unref_child(BdrvChild *child)
33a60407 1196{
779020cb
KW
1197 BlockDriverState *child_bs;
1198
f21d96d0
KW
1199 child_bs = child->bs;
1200 bdrv_detach_child(child);
1201 bdrv_unref(child_bs);
1202}
1203
1204void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1205{
779020cb
KW
1206 if (child == NULL) {
1207 return;
1208 }
33a60407
KW
1209
1210 if (child->bs->inherits_from == parent) {
1211 child->bs->inherits_from = NULL;
1212 }
1213
f21d96d0 1214 bdrv_root_unref_child(child);
33a60407
KW
1215}
1216
5c8cab48
KW
1217
1218static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
1219{
1220 BdrvChild *c;
1221 QLIST_FOREACH(c, &bs->parents, next_parent) {
1222 if (c->role->change_media) {
1223 c->role->change_media(c, load);
1224 }
1225 }
1226}
1227
1228static void bdrv_parent_cb_resize(BlockDriverState *bs)
1229{
1230 BdrvChild *c;
1231 QLIST_FOREACH(c, &bs->parents, next_parent) {
1232 if (c->role->resize) {
1233 c->role->resize(c);
1234 }
1235 }
1236}
1237
5db15a57
KW
1238/*
1239 * Sets the backing file link of a BDS. A new reference is created; callers
1240 * which don't need their own reference any more must call bdrv_unref().
1241 */
8d24cce1
FZ
1242void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1243{
5db15a57
KW
1244 if (backing_hd) {
1245 bdrv_ref(backing_hd);
1246 }
8d24cce1 1247
760e0063 1248 if (bs->backing) {
826b6ca0 1249 assert(bs->backing_blocker);
760e0063 1250 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
5db15a57 1251 bdrv_unref_child(bs, bs->backing);
826b6ca0
FZ
1252 } else if (backing_hd) {
1253 error_setg(&bs->backing_blocker,
81e5f78a
AG
1254 "node is used as backing hd of '%s'",
1255 bdrv_get_device_or_node_name(bs));
826b6ca0
FZ
1256 }
1257
8d24cce1 1258 if (!backing_hd) {
826b6ca0
FZ
1259 error_free(bs->backing_blocker);
1260 bs->backing_blocker = NULL;
760e0063 1261 bs->backing = NULL;
8d24cce1
FZ
1262 goto out;
1263 }
260fecf1 1264 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing);
8d24cce1
FZ
1265 bs->open_flags &= ~BDRV_O_NO_BACKING;
1266 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1267 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1268 backing_hd->drv ? backing_hd->drv->format_name : "");
826b6ca0 1269
760e0063 1270 bdrv_op_block_all(backing_hd, bs->backing_blocker);
826b6ca0 1271 /* Otherwise we won't be able to commit due to check in bdrv_commit */
760e0063 1272 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
826b6ca0 1273 bs->backing_blocker);
8d24cce1 1274out:
3baca891 1275 bdrv_refresh_limits(bs, NULL);
8d24cce1
FZ
1276}
1277
31ca6d07
KW
1278/*
1279 * Opens the backing file for a BlockDriverState if not yet open
1280 *
d9b7b057
KW
1281 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1282 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1283 * itself, all options starting with "${bdref_key}." are considered part of the
1284 * BlockdevRef.
1285 *
1286 * TODO Can this be unified with bdrv_open_image()?
31ca6d07 1287 */
d9b7b057
KW
1288int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
1289 const char *bdref_key, Error **errp)
9156df12 1290{
1ba4b6a5 1291 char *backing_filename = g_malloc0(PATH_MAX);
d9b7b057
KW
1292 char *bdref_key_dot;
1293 const char *reference = NULL;
317fc44e 1294 int ret = 0;
8d24cce1 1295 BlockDriverState *backing_hd;
d9b7b057
KW
1296 QDict *options;
1297 QDict *tmp_parent_options = NULL;
34b5d2c6 1298 Error *local_err = NULL;
9156df12 1299
760e0063 1300 if (bs->backing != NULL) {
1ba4b6a5 1301 goto free_exit;
9156df12
PB
1302 }
1303
31ca6d07 1304 /* NULL means an empty set of options */
d9b7b057
KW
1305 if (parent_options == NULL) {
1306 tmp_parent_options = qdict_new();
1307 parent_options = tmp_parent_options;
31ca6d07
KW
1308 }
1309
9156df12 1310 bs->open_flags &= ~BDRV_O_NO_BACKING;
d9b7b057
KW
1311
1312 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1313 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
1314 g_free(bdref_key_dot);
1315
1316 reference = qdict_get_try_str(parent_options, bdref_key);
1317 if (reference || qdict_haskey(options, "file.filename")) {
1cb6f506
KW
1318 backing_filename[0] = '\0';
1319 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
31ca6d07 1320 QDECREF(options);
1ba4b6a5 1321 goto free_exit;
dbecebdd 1322 } else {
9f07429e
HR
1323 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1324 &local_err);
1325 if (local_err) {
1326 ret = -EINVAL;
1327 error_propagate(errp, local_err);
1328 QDECREF(options);
1329 goto free_exit;
1330 }
9156df12
PB
1331 }
1332
8ee79e70
KW
1333 if (!bs->drv || !bs->drv->supports_backing) {
1334 ret = -EINVAL;
1335 error_setg(errp, "Driver doesn't support backing files");
1336 QDECREF(options);
1337 goto free_exit;
1338 }
1339
c5f6e493
KW
1340 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1341 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
9156df12
PB
1342 }
1343
d9b7b057 1344 backing_hd = NULL;
f3930ed0
KW
1345 ret = bdrv_open_inherit(&backing_hd,
1346 *backing_filename ? backing_filename : NULL,
d9b7b057 1347 reference, options, 0, bs, &child_backing,
e43bfd9c 1348 errp);
9156df12 1349 if (ret < 0) {
9156df12 1350 bs->open_flags |= BDRV_O_NO_BACKING;
e43bfd9c 1351 error_prepend(errp, "Could not open backing file: ");
1ba4b6a5 1352 goto free_exit;
9156df12 1353 }
df581792 1354
5db15a57
KW
1355 /* Hook up the backing file link; drop our reference, bs owns the
1356 * backing_hd reference now */
8d24cce1 1357 bdrv_set_backing_hd(bs, backing_hd);
5db15a57 1358 bdrv_unref(backing_hd);
d80ac658 1359
d9b7b057
KW
1360 qdict_del(parent_options, bdref_key);
1361
1ba4b6a5
BC
1362free_exit:
1363 g_free(backing_filename);
d9b7b057 1364 QDECREF(tmp_parent_options);
1ba4b6a5 1365 return ret;
9156df12
PB
1366}
1367
da557aac
HR
1368/*
1369 * Opens a disk image whose options are given as BlockdevRef in another block
1370 * device's options.
1371 *
da557aac 1372 * If allow_none is true, no image will be opened if filename is false and no
b4b059f6 1373 * BlockdevRef is given. NULL will be returned, but errp remains unset.
da557aac
HR
1374 *
1375 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1376 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1377 * itself, all options starting with "${bdref_key}." are considered part of the
1378 * BlockdevRef.
1379 *
1380 * The BlockdevRef will be removed from the options QDict.
1381 */
b4b059f6
KW
1382BdrvChild *bdrv_open_child(const char *filename,
1383 QDict *options, const char *bdref_key,
1384 BlockDriverState* parent,
1385 const BdrvChildRole *child_role,
1386 bool allow_none, Error **errp)
da557aac 1387{
b4b059f6
KW
1388 BdrvChild *c = NULL;
1389 BlockDriverState *bs;
da557aac
HR
1390 QDict *image_options;
1391 int ret;
1392 char *bdref_key_dot;
1393 const char *reference;
1394
df581792 1395 assert(child_role != NULL);
f67503e5 1396
da557aac
HR
1397 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1398 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1399 g_free(bdref_key_dot);
1400
1401 reference = qdict_get_try_str(options, bdref_key);
1402 if (!filename && !reference && !qdict_size(image_options)) {
b4b059f6 1403 if (!allow_none) {
da557aac
HR
1404 error_setg(errp, "A block device must be specified for \"%s\"",
1405 bdref_key);
da557aac 1406 }
b20e61e0 1407 QDECREF(image_options);
da557aac
HR
1408 goto done;
1409 }
1410
b4b059f6
KW
1411 bs = NULL;
1412 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
ce343771 1413 parent, child_role, errp);
df581792
KW
1414 if (ret < 0) {
1415 goto done;
1416 }
1417
260fecf1 1418 c = bdrv_attach_child(parent, bs, bdref_key, child_role);
da557aac
HR
1419
1420done:
1421 qdict_del(options, bdref_key);
b4b059f6
KW
1422 return c;
1423}
1424
73176bee
KW
1425static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags,
1426 QDict *snapshot_options, Error **errp)
b998875d
KW
1427{
1428 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1ba4b6a5 1429 char *tmp_filename = g_malloc0(PATH_MAX + 1);
b998875d 1430 int64_t total_size;
83d0521a 1431 QemuOpts *opts = NULL;
b998875d 1432 BlockDriverState *bs_snapshot;
c2e0dbbf 1433 Error *local_err = NULL;
b998875d
KW
1434 int ret;
1435
1436 /* if snapshot, we create a temporary backing file and open it
1437 instead of opening 'filename' directly */
1438
1439 /* Get the required size from the image */
f187743a
KW
1440 total_size = bdrv_getlength(bs);
1441 if (total_size < 0) {
6b8aeca5 1442 ret = total_size;
f187743a 1443 error_setg_errno(errp, -total_size, "Could not get image size");
1ba4b6a5 1444 goto out;
f187743a 1445 }
b998875d
KW
1446
1447 /* Create the temporary image */
1ba4b6a5 1448 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
b998875d
KW
1449 if (ret < 0) {
1450 error_setg_errno(errp, -ret, "Could not get temporary filename");
1ba4b6a5 1451 goto out;
b998875d
KW
1452 }
1453
ef810437 1454 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
c282e1fd 1455 &error_abort);
39101f25 1456 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
e43bfd9c 1457 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
83d0521a 1458 qemu_opts_del(opts);
b998875d 1459 if (ret < 0) {
e43bfd9c
MA
1460 error_prepend(errp, "Could not create temporary overlay '%s': ",
1461 tmp_filename);
1ba4b6a5 1462 goto out;
b998875d
KW
1463 }
1464
73176bee 1465 /* Prepare options QDict for the temporary file */
b998875d
KW
1466 qdict_put(snapshot_options, "file.driver",
1467 qstring_from_str("file"));
1468 qdict_put(snapshot_options, "file.filename",
1469 qstring_from_str(tmp_filename));
e6641719
HR
1470 qdict_put(snapshot_options, "driver",
1471 qstring_from_str("qcow2"));
b998875d 1472
e4e9986b 1473 bs_snapshot = bdrv_new();
b998875d
KW
1474
1475 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
6ebf9aa2 1476 flags, &local_err);
73176bee 1477 snapshot_options = NULL;
b998875d
KW
1478 if (ret < 0) {
1479 error_propagate(errp, local_err);
1ba4b6a5 1480 goto out;
b998875d
KW
1481 }
1482
1483 bdrv_append(bs_snapshot, bs);
1ba4b6a5
BC
1484
1485out:
73176bee 1486 QDECREF(snapshot_options);
1ba4b6a5 1487 g_free(tmp_filename);
6b8aeca5 1488 return ret;
b998875d
KW
1489}
1490
b6ce07aa
KW
1491/*
1492 * Opens a disk image (raw, qcow2, vmdk, ...)
de9c0cec
KW
1493 *
1494 * options is a QDict of options to pass to the block drivers, or NULL for an
1495 * empty set of options. The reference to the QDict belongs to the block layer
1496 * after the call (even on failure), so if the caller intends to reuse the
1497 * dictionary, it needs to use QINCREF() before calling bdrv_open.
f67503e5
HR
1498 *
1499 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1500 * If it is not NULL, the referenced BDS will be reused.
ddf5636d
HR
1501 *
1502 * The reference parameter may be used to specify an existing block device which
1503 * should be opened. If specified, neither options nor a filename may be given,
1504 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
b6ce07aa 1505 */
f3930ed0
KW
1506static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1507 const char *reference, QDict *options, int flags,
1508 BlockDriverState *parent,
ce343771 1509 const BdrvChildRole *child_role, Error **errp)
ea2384d3 1510{
b6ce07aa 1511 int ret;
9a4f4c31
KW
1512 BdrvChild *file = NULL;
1513 BlockDriverState *bs;
ce343771 1514 BlockDriver *drv = NULL;
74fe54f2 1515 const char *drvname;
3e8c2e57 1516 const char *backing;
34b5d2c6 1517 Error *local_err = NULL;
73176bee 1518 QDict *snapshot_options = NULL;
b1e6fc08 1519 int snapshot_flags = 0;
712e7874 1520
f67503e5 1521 assert(pbs);
f3930ed0
KW
1522 assert(!child_role || !flags);
1523 assert(!child_role == !parent);
f67503e5 1524
ddf5636d
HR
1525 if (reference) {
1526 bool options_non_empty = options ? qdict_size(options) : false;
1527 QDECREF(options);
1528
1529 if (*pbs) {
1530 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1531 "another block device");
1532 return -EINVAL;
1533 }
1534
1535 if (filename || options_non_empty) {
1536 error_setg(errp, "Cannot reference an existing block device with "
1537 "additional options or a new filename");
1538 return -EINVAL;
1539 }
1540
1541 bs = bdrv_lookup_bs(reference, reference, errp);
1542 if (!bs) {
1543 return -ENODEV;
1544 }
76b22320 1545
ddf5636d
HR
1546 bdrv_ref(bs);
1547 *pbs = bs;
1548 return 0;
1549 }
1550
f67503e5
HR
1551 if (*pbs) {
1552 bs = *pbs;
1553 } else {
e4e9986b 1554 bs = bdrv_new();
f67503e5
HR
1555 }
1556
de9c0cec
KW
1557 /* NULL means an empty set of options */
1558 if (options == NULL) {
1559 options = qdict_new();
1560 }
1561
145f598e 1562 /* json: syntax counts as explicit options, as if in the QDict */
de3b53f0
KW
1563 parse_json_protocol(options, &filename, &local_err);
1564 if (local_err) {
1565 ret = -EINVAL;
1566 goto fail;
1567 }
1568
145f598e
KW
1569 bs->explicit_options = qdict_clone_shallow(options);
1570
f3930ed0 1571 if (child_role) {
bddcec37 1572 bs->inherits_from = parent;
8e2160e2
KW
1573 child_role->inherit_options(&flags, options,
1574 parent->open_flags, parent->options);
f3930ed0
KW
1575 }
1576
de3b53f0 1577 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
462f5bcf
KW
1578 if (local_err) {
1579 goto fail;
1580 }
1581
62392ebb
KW
1582 bs->open_flags = flags;
1583 bs->options = options;
1584 options = qdict_clone_shallow(options);
1585
76c591b0 1586 /* Find the right image format driver */
76c591b0
KW
1587 drvname = qdict_get_try_str(options, "driver");
1588 if (drvname) {
1589 drv = bdrv_find_format(drvname);
76c591b0
KW
1590 if (!drv) {
1591 error_setg(errp, "Unknown driver: '%s'", drvname);
1592 ret = -EINVAL;
1593 goto fail;
1594 }
1595 }
1596
1597 assert(drvname || !(flags & BDRV_O_PROTOCOL));
76c591b0 1598
3e8c2e57
AG
1599 backing = qdict_get_try_str(options, "backing");
1600 if (backing && *backing == '\0') {
1601 flags |= BDRV_O_NO_BACKING;
1602 qdict_del(options, "backing");
1603 }
1604
f500a6d3 1605 /* Open image file without format layer */
f4788adc
KW
1606 if ((flags & BDRV_O_PROTOCOL) == 0) {
1607 if (flags & BDRV_O_RDWR) {
1608 flags |= BDRV_O_ALLOW_RDWR;
1609 }
1610 if (flags & BDRV_O_SNAPSHOT) {
73176bee
KW
1611 snapshot_options = qdict_new();
1612 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
1613 flags, options);
8e2160e2 1614 bdrv_backing_options(&flags, options, flags, options);
f4788adc 1615 }
f500a6d3 1616
f3930ed0 1617 bs->open_flags = flags;
1fdd6933 1618
9a4f4c31
KW
1619 file = bdrv_open_child(filename, options, "file", bs,
1620 &child_file, true, &local_err);
1fdd6933
KW
1621 if (local_err) {
1622 ret = -EINVAL;
f4788adc
KW
1623 goto fail;
1624 }
f500a6d3
KW
1625 }
1626
76c591b0 1627 /* Image format probing */
38f3ef57 1628 bs->probed = !drv;
76c591b0 1629 if (!drv && file) {
9a4f4c31 1630 ret = find_image_format(file->bs, filename, &drv, &local_err);
17b005f1 1631 if (ret < 0) {
8bfea15d 1632 goto fail;
2a05cbe4 1633 }
62392ebb
KW
1634 /*
1635 * This option update would logically belong in bdrv_fill_options(),
1636 * but we first need to open bs->file for the probing to work, while
1637 * opening bs->file already requires the (mostly) final set of options
1638 * so that cache mode etc. can be inherited.
1639 *
1640 * Adding the driver later is somewhat ugly, but it's not an option
1641 * that would ever be inherited, so it's correct. We just need to make
1642 * sure to update both bs->options (which has the full effective
1643 * options for bs) and options (which has file.* already removed).
1644 */
1645 qdict_put(bs->options, "driver", qstring_from_str(drv->format_name));
1646 qdict_put(options, "driver", qstring_from_str(drv->format_name));
76c591b0 1647 } else if (!drv) {
17b005f1
KW
1648 error_setg(errp, "Must specify either driver or file");
1649 ret = -EINVAL;
8bfea15d 1650 goto fail;
ea2384d3 1651 }
b6ce07aa 1652
53a29513
HR
1653 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1654 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1655 /* file must be NULL if a protocol BDS is about to be created
1656 * (the inverse results in an error message from bdrv_open_common()) */
1657 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1658
b6ce07aa 1659 /* Open the image */
82dc8b41 1660 ret = bdrv_open_common(bs, file, options, &local_err);
b6ce07aa 1661 if (ret < 0) {
8bfea15d 1662 goto fail;
6987307c
CH
1663 }
1664
2a05cbe4 1665 if (file && (bs->file != file)) {
9a4f4c31 1666 bdrv_unref_child(bs, file);
f500a6d3
KW
1667 file = NULL;
1668 }
1669
b6ce07aa 1670 /* If there is a backing file, use it */
9156df12 1671 if ((flags & BDRV_O_NO_BACKING) == 0) {
d9b7b057 1672 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
b6ce07aa 1673 if (ret < 0) {
b6ad491a 1674 goto close_and_fail;
b6ce07aa 1675 }
b6ce07aa
KW
1676 }
1677
91af7014
HR
1678 bdrv_refresh_filename(bs);
1679
b6ad491a 1680 /* Check if any unknown options were used */
5acd9d81 1681 if (options && (qdict_size(options) != 0)) {
b6ad491a 1682 const QDictEntry *entry = qdict_first(options);
5acd9d81
HR
1683 if (flags & BDRV_O_PROTOCOL) {
1684 error_setg(errp, "Block protocol '%s' doesn't support the option "
1685 "'%s'", drv->format_name, entry->key);
1686 } else {
d0e46a55
HR
1687 error_setg(errp,
1688 "Block format '%s' does not support the option '%s'",
1689 drv->format_name, entry->key);
5acd9d81 1690 }
b6ad491a
KW
1691
1692 ret = -EINVAL;
1693 goto close_and_fail;
1694 }
b6ad491a 1695
b6ce07aa 1696 if (!bdrv_key_required(bs)) {
5c8cab48 1697 bdrv_parent_cb_change_media(bs, true);
c3adb58f
MA
1698 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1699 && !runstate_check(RUN_STATE_INMIGRATE)
1700 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1701 error_setg(errp,
1702 "Guest must be stopped for opening of encrypted image");
1703 ret = -EBUSY;
1704 goto close_and_fail;
b6ce07aa
KW
1705 }
1706
c3adb58f 1707 QDECREF(options);
f67503e5 1708 *pbs = bs;
dd62f1ca
KW
1709
1710 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1711 * temporary snapshot afterwards. */
1712 if (snapshot_flags) {
73176bee
KW
1713 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, snapshot_options,
1714 &local_err);
1715 snapshot_options = NULL;
dd62f1ca
KW
1716 if (local_err) {
1717 goto close_and_fail;
1718 }
1719 }
1720
b6ce07aa
KW
1721 return 0;
1722
8bfea15d 1723fail:
f500a6d3 1724 if (file != NULL) {
9a4f4c31 1725 bdrv_unref_child(bs, file);
f500a6d3 1726 }
73176bee 1727 QDECREF(snapshot_options);
145f598e 1728 QDECREF(bs->explicit_options);
de9c0cec 1729 QDECREF(bs->options);
b6ad491a 1730 QDECREF(options);
de9c0cec 1731 bs->options = NULL;
f67503e5
HR
1732 if (!*pbs) {
1733 /* If *pbs is NULL, a new BDS has been created in this function and
1734 needs to be freed now. Otherwise, it does not need to be closed,
1735 since it has not really been opened yet. */
1736 bdrv_unref(bs);
1737 }
84d18f06 1738 if (local_err) {
34b5d2c6
HR
1739 error_propagate(errp, local_err);
1740 }
b6ad491a 1741 return ret;
de9c0cec 1742
b6ad491a 1743close_and_fail:
f67503e5
HR
1744 /* See fail path, but now the BDS has to be always closed */
1745 if (*pbs) {
1746 bdrv_close(bs);
1747 } else {
1748 bdrv_unref(bs);
1749 }
73176bee 1750 QDECREF(snapshot_options);
b6ad491a 1751 QDECREF(options);
84d18f06 1752 if (local_err) {
34b5d2c6
HR
1753 error_propagate(errp, local_err);
1754 }
b6ce07aa
KW
1755 return ret;
1756}
1757
f3930ed0 1758int bdrv_open(BlockDriverState **pbs, const char *filename,
6ebf9aa2 1759 const char *reference, QDict *options, int flags, Error **errp)
f3930ed0
KW
1760{
1761 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
ce343771 1762 NULL, errp);
f3930ed0
KW
1763}
1764
e971aa12
JC
1765typedef struct BlockReopenQueueEntry {
1766 bool prepared;
1767 BDRVReopenState state;
1768 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1769} BlockReopenQueueEntry;
1770
1771/*
1772 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1773 * reopen of multiple devices.
1774 *
1775 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1776 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1777 * be created and initialized. This newly created BlockReopenQueue should be
1778 * passed back in for subsequent calls that are intended to be of the same
1779 * atomic 'set'.
1780 *
1781 * bs is the BlockDriverState to add to the reopen queue.
1782 *
4d2cb092
KW
1783 * options contains the changed options for the associated bs
1784 * (the BlockReopenQueue takes ownership)
1785 *
e971aa12
JC
1786 * flags contains the open flags for the associated bs
1787 *
1788 * returns a pointer to bs_queue, which is either the newly allocated
1789 * bs_queue, or the existing bs_queue being used.
1790 *
1791 */
28518102
KW
1792static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
1793 BlockDriverState *bs,
1794 QDict *options,
1795 int flags,
1796 const BdrvChildRole *role,
1797 QDict *parent_options,
1798 int parent_flags)
e971aa12
JC
1799{
1800 assert(bs != NULL);
1801
1802 BlockReopenQueueEntry *bs_entry;
67251a31 1803 BdrvChild *child;
145f598e 1804 QDict *old_options, *explicit_options;
67251a31 1805
e971aa12
JC
1806 if (bs_queue == NULL) {
1807 bs_queue = g_new0(BlockReopenQueue, 1);
1808 QSIMPLEQ_INIT(bs_queue);
1809 }
1810
4d2cb092
KW
1811 if (!options) {
1812 options = qdict_new();
1813 }
1814
28518102
KW
1815 /*
1816 * Precedence of options:
1817 * 1. Explicitly passed in options (highest)
91a097e7 1818 * 2. Set in flags (only for top level)
145f598e 1819 * 3. Retained from explicitly set options of bs
8e2160e2 1820 * 4. Inherited from parent node
28518102
KW
1821 * 5. Retained from effective options of bs
1822 */
1823
91a097e7
KW
1824 if (!parent_options) {
1825 /*
1826 * Any setting represented by flags is always updated. If the
1827 * corresponding QDict option is set, it takes precedence. Otherwise
1828 * the flag is translated into a QDict option. The old setting of bs is
1829 * not considered.
1830 */
1831 update_options_from_flags(options, flags);
1832 }
1833
145f598e
KW
1834 /* Old explicitly set values (don't overwrite by inherited value) */
1835 old_options = qdict_clone_shallow(bs->explicit_options);
1836 bdrv_join_options(bs, options, old_options);
1837 QDECREF(old_options);
1838
1839 explicit_options = qdict_clone_shallow(options);
1840
28518102
KW
1841 /* Inherit from parent node */
1842 if (parent_options) {
1843 assert(!flags);
8e2160e2 1844 role->inherit_options(&flags, options, parent_flags, parent_options);
28518102
KW
1845 }
1846
1847 /* Old values are used for options that aren't set yet */
4d2cb092 1848 old_options = qdict_clone_shallow(bs->options);
cddff5ba 1849 bdrv_join_options(bs, options, old_options);
4d2cb092
KW
1850 QDECREF(old_options);
1851
f1f25a2e
KW
1852 /* bdrv_open() masks this flag out */
1853 flags &= ~BDRV_O_PROTOCOL;
1854
67251a31 1855 QLIST_FOREACH(child, &bs->children, next) {
4c9dfe5d
KW
1856 QDict *new_child_options;
1857 char *child_key_dot;
67251a31 1858
4c9dfe5d
KW
1859 /* reopen can only change the options of block devices that were
1860 * implicitly created and inherited options. For other (referenced)
1861 * block devices, a syntax like "backing.foo" results in an error. */
67251a31
KW
1862 if (child->bs->inherits_from != bs) {
1863 continue;
1864 }
1865
4c9dfe5d
KW
1866 child_key_dot = g_strdup_printf("%s.", child->name);
1867 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
1868 g_free(child_key_dot);
1869
28518102
KW
1870 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
1871 child->role, options, flags);
e971aa12
JC
1872 }
1873
1874 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1875 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1876
1877 bs_entry->state.bs = bs;
4d2cb092 1878 bs_entry->state.options = options;
145f598e 1879 bs_entry->state.explicit_options = explicit_options;
e971aa12
JC
1880 bs_entry->state.flags = flags;
1881
1882 return bs_queue;
1883}
1884
28518102
KW
1885BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1886 BlockDriverState *bs,
1887 QDict *options, int flags)
1888{
1889 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
1890 NULL, NULL, 0);
1891}
1892
e971aa12
JC
1893/*
1894 * Reopen multiple BlockDriverStates atomically & transactionally.
1895 *
1896 * The queue passed in (bs_queue) must have been built up previous
1897 * via bdrv_reopen_queue().
1898 *
1899 * Reopens all BDS specified in the queue, with the appropriate
1900 * flags. All devices are prepared for reopen, and failure of any
1901 * device will cause all device changes to be abandonded, and intermediate
1902 * data cleaned up.
1903 *
1904 * If all devices prepare successfully, then the changes are committed
1905 * to all devices.
1906 *
1907 */
1908int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1909{
1910 int ret = -1;
1911 BlockReopenQueueEntry *bs_entry, *next;
1912 Error *local_err = NULL;
1913
1914 assert(bs_queue != NULL);
1915
1916 bdrv_drain_all();
1917
1918 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1919 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1920 error_propagate(errp, local_err);
1921 goto cleanup;
1922 }
1923 bs_entry->prepared = true;
1924 }
1925
1926 /* If we reach this point, we have success and just need to apply the
1927 * changes
1928 */
1929 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1930 bdrv_reopen_commit(&bs_entry->state);
1931 }
1932
1933 ret = 0;
1934
1935cleanup:
1936 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1937 if (ret && bs_entry->prepared) {
1938 bdrv_reopen_abort(&bs_entry->state);
145f598e
KW
1939 } else if (ret) {
1940 QDECREF(bs_entry->state.explicit_options);
e971aa12 1941 }
4d2cb092 1942 QDECREF(bs_entry->state.options);
e971aa12
JC
1943 g_free(bs_entry);
1944 }
1945 g_free(bs_queue);
1946 return ret;
1947}
1948
1949
1950/* Reopen a single BlockDriverState with the specified flags. */
1951int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1952{
1953 int ret = -1;
1954 Error *local_err = NULL;
4d2cb092 1955 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
e971aa12
JC
1956
1957 ret = bdrv_reopen_multiple(queue, &local_err);
1958 if (local_err != NULL) {
1959 error_propagate(errp, local_err);
1960 }
1961 return ret;
1962}
1963
1964
1965/*
1966 * Prepares a BlockDriverState for reopen. All changes are staged in the
1967 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1968 * the block driver layer .bdrv_reopen_prepare()
1969 *
1970 * bs is the BlockDriverState to reopen
1971 * flags are the new open flags
1972 * queue is the reopen queue
1973 *
1974 * Returns 0 on success, non-zero on error. On error errp will be set
1975 * as well.
1976 *
1977 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1978 * It is the responsibility of the caller to then call the abort() or
1979 * commit() for any other BDS that have been left in a prepare() state
1980 *
1981 */
1982int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1983 Error **errp)
1984{
1985 int ret = -1;
1986 Error *local_err = NULL;
1987 BlockDriver *drv;
ccf9dc07
KW
1988 QemuOpts *opts;
1989 const char *value;
e971aa12
JC
1990
1991 assert(reopen_state != NULL);
1992 assert(reopen_state->bs->drv != NULL);
1993 drv = reopen_state->bs->drv;
1994
ccf9dc07
KW
1995 /* Process generic block layer options */
1996 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1997 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
1998 if (local_err) {
1999 error_propagate(errp, local_err);
2000 ret = -EINVAL;
2001 goto error;
2002 }
2003
91a097e7
KW
2004 update_flags_from_options(&reopen_state->flags, opts);
2005
ccf9dc07
KW
2006 /* node-name and driver must be unchanged. Put them back into the QDict, so
2007 * that they are checked at the end of this function. */
2008 value = qemu_opt_get(opts, "node-name");
2009 if (value) {
2010 qdict_put(reopen_state->options, "node-name", qstring_from_str(value));
2011 }
2012
2013 value = qemu_opt_get(opts, "driver");
2014 if (value) {
2015 qdict_put(reopen_state->options, "driver", qstring_from_str(value));
2016 }
2017
e971aa12
JC
2018 /* if we are to stay read-only, do not allow permission change
2019 * to r/w */
2020 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
2021 reopen_state->flags & BDRV_O_RDWR) {
81e5f78a
AG
2022 error_setg(errp, "Node '%s' is read only",
2023 bdrv_get_device_or_node_name(reopen_state->bs));
e971aa12
JC
2024 goto error;
2025 }
2026
2027
2028 ret = bdrv_flush(reopen_state->bs);
2029 if (ret) {
455b0fde 2030 error_setg_errno(errp, -ret, "Error flushing drive");
e971aa12
JC
2031 goto error;
2032 }
2033
2034 if (drv->bdrv_reopen_prepare) {
2035 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
2036 if (ret) {
2037 if (local_err != NULL) {
2038 error_propagate(errp, local_err);
2039 } else {
d8b6895f
LC
2040 error_setg(errp, "failed while preparing to reopen image '%s'",
2041 reopen_state->bs->filename);
e971aa12
JC
2042 }
2043 goto error;
2044 }
2045 } else {
2046 /* It is currently mandatory to have a bdrv_reopen_prepare()
2047 * handler for each supported drv. */
81e5f78a
AG
2048 error_setg(errp, "Block format '%s' used by node '%s' "
2049 "does not support reopening files", drv->format_name,
2050 bdrv_get_device_or_node_name(reopen_state->bs));
e971aa12
JC
2051 ret = -1;
2052 goto error;
2053 }
2054
4d2cb092
KW
2055 /* Options that are not handled are only okay if they are unchanged
2056 * compared to the old state. It is expected that some options are only
2057 * used for the initial open, but not reopen (e.g. filename) */
2058 if (qdict_size(reopen_state->options)) {
2059 const QDictEntry *entry = qdict_first(reopen_state->options);
2060
2061 do {
2062 QString *new_obj = qobject_to_qstring(entry->value);
2063 const char *new = qstring_get_str(new_obj);
2064 const char *old = qdict_get_try_str(reopen_state->bs->options,
2065 entry->key);
2066
2067 if (!old || strcmp(new, old)) {
2068 error_setg(errp, "Cannot change the option '%s'", entry->key);
2069 ret = -EINVAL;
2070 goto error;
2071 }
2072 } while ((entry = qdict_next(reopen_state->options, entry)));
2073 }
2074
e971aa12
JC
2075 ret = 0;
2076
2077error:
ccf9dc07 2078 qemu_opts_del(opts);
e971aa12
JC
2079 return ret;
2080}
2081
2082/*
2083 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2084 * makes them final by swapping the staging BlockDriverState contents into
2085 * the active BlockDriverState contents.
2086 */
2087void bdrv_reopen_commit(BDRVReopenState *reopen_state)
2088{
2089 BlockDriver *drv;
2090
2091 assert(reopen_state != NULL);
2092 drv = reopen_state->bs->drv;
2093 assert(drv != NULL);
2094
2095 /* If there are any driver level actions to take */
2096 if (drv->bdrv_reopen_commit) {
2097 drv->bdrv_reopen_commit(reopen_state);
2098 }
2099
2100 /* set BDS specific flags now */
145f598e
KW
2101 QDECREF(reopen_state->bs->explicit_options);
2102
2103 reopen_state->bs->explicit_options = reopen_state->explicit_options;
e971aa12 2104 reopen_state->bs->open_flags = reopen_state->flags;
e971aa12 2105 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
355ef4ac 2106
3baca891 2107 bdrv_refresh_limits(reopen_state->bs, NULL);
e971aa12
JC
2108}
2109
2110/*
2111 * Abort the reopen, and delete and free the staged changes in
2112 * reopen_state
2113 */
2114void bdrv_reopen_abort(BDRVReopenState *reopen_state)
2115{
2116 BlockDriver *drv;
2117
2118 assert(reopen_state != NULL);
2119 drv = reopen_state->bs->drv;
2120 assert(drv != NULL);
2121
2122 if (drv->bdrv_reopen_abort) {
2123 drv->bdrv_reopen_abort(reopen_state);
2124 }
145f598e
KW
2125
2126 QDECREF(reopen_state->explicit_options);
e971aa12
JC
2127}
2128
2129
64dff520 2130static void bdrv_close(BlockDriverState *bs)
fc01f7e7 2131{
33384421
HR
2132 BdrvAioNotifier *ban, *ban_next;
2133
ca9bd24c 2134 assert(!bs->job);
99b7e775 2135
fc27291d 2136 bdrv_drained_begin(bs); /* complete I/O */
58fda173 2137 bdrv_flush(bs);
53ec73e2 2138 bdrv_drain(bs); /* in case flush left pending I/O */
fc27291d 2139
c5acdc9a
HR
2140 bdrv_release_named_dirty_bitmaps(bs);
2141 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2142
5c8cab48 2143 bdrv_parent_cb_change_media(bs, false);
b4d02820 2144
3cbc002c 2145 if (bs->drv) {
6e93e7c4
KW
2146 BdrvChild *child, *next;
2147
9a7dedbc 2148 bs->drv->bdrv_close(bs);
9a4f4c31 2149 bs->drv = NULL;
9a7dedbc 2150
5db15a57 2151 bdrv_set_backing_hd(bs, NULL);
9a7dedbc 2152
9a4f4c31
KW
2153 if (bs->file != NULL) {
2154 bdrv_unref_child(bs, bs->file);
2155 bs->file = NULL;
2156 }
2157
6e93e7c4 2158 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
33a60407
KW
2159 /* TODO Remove bdrv_unref() from drivers' close function and use
2160 * bdrv_unref_child() here */
bddcec37
KW
2161 if (child->bs->inherits_from == bs) {
2162 child->bs->inherits_from = NULL;
2163 }
33a60407 2164 bdrv_detach_child(child);
6e93e7c4
KW
2165 }
2166
7267c094 2167 g_free(bs->opaque);
ea2384d3 2168 bs->opaque = NULL;
53fec9d3 2169 bs->copy_on_read = 0;
a275fa42
PB
2170 bs->backing_file[0] = '\0';
2171 bs->backing_format[0] = '\0';
6405875c
PB
2172 bs->total_sectors = 0;
2173 bs->encrypted = 0;
2174 bs->valid_key = 0;
2175 bs->sg = 0;
0d51b4de 2176 bs->zero_beyond_eof = false;
de9c0cec 2177 QDECREF(bs->options);
145f598e 2178 QDECREF(bs->explicit_options);
de9c0cec 2179 bs->options = NULL;
91af7014
HR
2180 QDECREF(bs->full_open_options);
2181 bs->full_open_options = NULL;
b338082b 2182 }
98f90dba 2183
33384421
HR
2184 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
2185 g_free(ban);
2186 }
2187 QLIST_INIT(&bs->aio_notifiers);
fc27291d 2188 bdrv_drained_end(bs);
b338082b
FB
2189}
2190
2bc93fed
MK
2191void bdrv_close_all(void)
2192{
2193 BlockDriverState *bs;
ca9bd24c
HR
2194 AioContext *aio_context;
2195
2196 /* Drop references from requests still in flight, such as canceled block
2197 * jobs whose AIO context has not been polled yet */
2198 bdrv_drain_all();
2bc93fed 2199
ca9bd24c
HR
2200 blk_remove_all_bs();
2201 blockdev_close_all_bdrv_states();
ed78cda3 2202
ca9bd24c
HR
2203 /* Cancel all block jobs */
2204 while (!QTAILQ_EMPTY(&all_bdrv_states)) {
2205 QTAILQ_FOREACH(bs, &all_bdrv_states, bs_list) {
2206 aio_context = bdrv_get_aio_context(bs);
2207
2208 aio_context_acquire(aio_context);
2209 if (bs->job) {
2210 block_job_cancel_sync(bs->job);
2211 aio_context_release(aio_context);
2212 break;
2213 }
2214 aio_context_release(aio_context);
2215 }
2216
2217 /* All the remaining BlockDriverStates are referenced directly or
2218 * indirectly from block jobs, so there needs to be at least one BDS
2219 * directly used by a block job */
2220 assert(bs);
2bc93fed
MK
2221 }
2222}
2223
dd62f1ca
KW
2224static void change_parent_backing_link(BlockDriverState *from,
2225 BlockDriverState *to)
2226{
2227 BdrvChild *c, *next;
2228
f21d96d0
KW
2229 if (from->blk) {
2230 /* FIXME We bypass blk_set_bs(), so we need to make these updates
2231 * manually. The root problem is not in this change function, but the
2232 * existence of BlockDriverState.blk. */
2233 to->blk = from->blk;
2234 from->blk = NULL;
2235 }
2236
dd62f1ca
KW
2237 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2238 assert(c->role != &child_backing);
2239 c->bs = to;
2240 QLIST_REMOVE(c, next_parent);
2241 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2242 bdrv_ref(to);
2243 bdrv_unref(from);
2244 }
dd62f1ca
KW
2245}
2246
4ddc07ca
PB
2247/*
2248 * Add new bs contents at the top of an image chain while the chain is
2249 * live, while keeping required fields on the top layer.
2250 *
2251 * This will modify the BlockDriverState fields, and swap contents
2252 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2253 *
bfb197e0 2254 * bs_new must not be attached to a BlockBackend.
4ddc07ca
PB
2255 *
2256 * This function does not create any image files.
dd62f1ca
KW
2257 *
2258 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2259 * that's what the callers commonly need. bs_new will be referenced by the old
2260 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2261 * reference of its own, it must call bdrv_ref().
4ddc07ca
PB
2262 */
2263void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2264{
dd62f1ca
KW
2265 assert(!bdrv_requests_pending(bs_top));
2266 assert(!bdrv_requests_pending(bs_new));
2267
2268 bdrv_ref(bs_top);
dd62f1ca 2269
27ccdd52 2270 change_parent_backing_link(bs_top, bs_new);
dd62f1ca
KW
2271 bdrv_set_backing_hd(bs_new, bs_top);
2272 bdrv_unref(bs_top);
4ddc07ca 2273
dd62f1ca
KW
2274 /* bs_new is now referenced by its new parents, we don't need the
2275 * additional reference any more. */
2276 bdrv_unref(bs_new);
8802d1fd
JC
2277}
2278
3f09bfbc
KW
2279void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2280{
2281 assert(!bdrv_requests_pending(old));
2282 assert(!bdrv_requests_pending(new));
2283
2284 bdrv_ref(old);
2285
3f09bfbc
KW
2286 change_parent_backing_link(old, new);
2287
2288 /* Change backing files if a previously independent node is added to the
2289 * chain. For active commit, we replace top by its own (indirect) backing
2290 * file and don't do anything here so we don't build a loop. */
2291 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2292 bdrv_set_backing_hd(new, backing_bs(old));
2293 bdrv_set_backing_hd(old, NULL);
2294 }
2295
2296 bdrv_unref(old);
2297}
2298
4f6fd349 2299static void bdrv_delete(BlockDriverState *bs)
b338082b 2300{
3e914655 2301 assert(!bs->job);
3718d8ab 2302 assert(bdrv_op_blocker_is_empty(bs));
4f6fd349 2303 assert(!bs->refcnt);
18846dee 2304
e1b5c52e
SH
2305 bdrv_close(bs);
2306
1b7bdbc1 2307 /* remove from list, if necessary */
63eaaae0
KW
2308 if (bs->node_name[0] != '\0') {
2309 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
2310 }
2c1d04e0
HR
2311 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
2312
7267c094 2313 g_free(bs);
fc01f7e7
FB
2314}
2315
e97fc193
AL
2316/*
2317 * Run consistency checks on an image
2318 *
e076f338 2319 * Returns 0 if the check could be completed (it doesn't mean that the image is
a1c7273b 2320 * free of errors) or -errno when an internal error occurred. The results of the
e076f338 2321 * check are stored in res.
e97fc193 2322 */
4534ff54 2323int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
e97fc193 2324{
908bcd54
HR
2325 if (bs->drv == NULL) {
2326 return -ENOMEDIUM;
2327 }
e97fc193
AL
2328 if (bs->drv->bdrv_check == NULL) {
2329 return -ENOTSUP;
2330 }
2331
e076f338 2332 memset(res, 0, sizeof(*res));
4534ff54 2333 return bs->drv->bdrv_check(bs, res, fix);
e97fc193
AL
2334}
2335
8a426614
KW
2336#define COMMIT_BUF_SECTORS 2048
2337
33e3963e
FB
2338/* commit COW file into the raw image */
2339int bdrv_commit(BlockDriverState *bs)
2340{
19cb3738 2341 BlockDriver *drv = bs->drv;
72706ea4 2342 int64_t sector, total_sectors, length, backing_length;
8a426614 2343 int n, ro, open_flags;
0bce597d 2344 int ret = 0;
72706ea4 2345 uint8_t *buf = NULL;
33e3963e 2346
19cb3738
FB
2347 if (!drv)
2348 return -ENOMEDIUM;
6bb45158 2349
760e0063 2350 if (!bs->backing) {
4dca4b63 2351 return -ENOTSUP;
33e3963e
FB
2352 }
2353
bb00021d 2354 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
760e0063 2355 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2d3735d3
SH
2356 return -EBUSY;
2357 }
2358
760e0063
KW
2359 ro = bs->backing->bs->read_only;
2360 open_flags = bs->backing->bs->open_flags;
4dca4b63
NS
2361
2362 if (ro) {
760e0063 2363 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
0bce597d 2364 return -EACCES;
4dca4b63 2365 }
ea2384d3 2366 }
33e3963e 2367
72706ea4
JC
2368 length = bdrv_getlength(bs);
2369 if (length < 0) {
2370 ret = length;
2371 goto ro_cleanup;
2372 }
2373
760e0063 2374 backing_length = bdrv_getlength(bs->backing->bs);
72706ea4
JC
2375 if (backing_length < 0) {
2376 ret = backing_length;
2377 goto ro_cleanup;
2378 }
2379
2380 /* If our top snapshot is larger than the backing file image,
2381 * grow the backing file image if possible. If not possible,
2382 * we must return an error */
2383 if (length > backing_length) {
760e0063 2384 ret = bdrv_truncate(bs->backing->bs, length);
72706ea4
JC
2385 if (ret < 0) {
2386 goto ro_cleanup;
2387 }
2388 }
2389
2390 total_sectors = length >> BDRV_SECTOR_BITS;
857d4f46
KW
2391
2392 /* qemu_try_blockalign() for bs will choose an alignment that works for
760e0063 2393 * bs->backing->bs as well, so no need to compare the alignment manually. */
857d4f46
KW
2394 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2395 if (buf == NULL) {
2396 ret = -ENOMEM;
2397 goto ro_cleanup;
2398 }
8a426614
KW
2399
2400 for (sector = 0; sector < total_sectors; sector += n) {
d663640c
PB
2401 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2402 if (ret < 0) {
2403 goto ro_cleanup;
2404 }
2405 if (ret) {
dabfa6cc
KW
2406 ret = bdrv_read(bs, sector, buf, n);
2407 if (ret < 0) {
8a426614
KW
2408 goto ro_cleanup;
2409 }
2410
760e0063 2411 ret = bdrv_write(bs->backing->bs, sector, buf, n);
dabfa6cc 2412 if (ret < 0) {
8a426614
KW
2413 goto ro_cleanup;
2414 }
ea2384d3 2415 }
33e3963e 2416 }
95389c86 2417
1d44952f
CH
2418 if (drv->bdrv_make_empty) {
2419 ret = drv->bdrv_make_empty(bs);
dabfa6cc
KW
2420 if (ret < 0) {
2421 goto ro_cleanup;
2422 }
1d44952f
CH
2423 bdrv_flush(bs);
2424 }
95389c86 2425
3f5075ae
CH
2426 /*
2427 * Make sure all data we wrote to the backing device is actually
2428 * stable on disk.
2429 */
760e0063
KW
2430 if (bs->backing) {
2431 bdrv_flush(bs->backing->bs);
dabfa6cc 2432 }
4dca4b63 2433
dabfa6cc 2434 ret = 0;
4dca4b63 2435ro_cleanup:
857d4f46 2436 qemu_vfree(buf);
4dca4b63
NS
2437
2438 if (ro) {
0bce597d 2439 /* ignoring error return here */
760e0063 2440 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
4dca4b63
NS
2441 }
2442
1d44952f 2443 return ret;
33e3963e
FB
2444}
2445
756e6736
KW
2446/*
2447 * Return values:
2448 * 0 - success
2449 * -EINVAL - backing format specified, but no file
2450 * -ENOSPC - can't update the backing file because no space is left in the
2451 * image file header
2452 * -ENOTSUP - format driver doesn't support changing the backing file
2453 */
2454int bdrv_change_backing_file(BlockDriverState *bs,
2455 const char *backing_file, const char *backing_fmt)
2456{
2457 BlockDriver *drv = bs->drv;
469ef350 2458 int ret;
756e6736 2459
5f377794
PB
2460 /* Backing file format doesn't make sense without a backing file */
2461 if (backing_fmt && !backing_file) {
2462 return -EINVAL;
2463 }
2464
756e6736 2465 if (drv->bdrv_change_backing_file != NULL) {
469ef350 2466 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
756e6736 2467 } else {
469ef350 2468 ret = -ENOTSUP;
756e6736 2469 }
469ef350
PB
2470
2471 if (ret == 0) {
2472 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2473 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2474 }
2475 return ret;
756e6736
KW
2476}
2477
6ebdcee2
JC
2478/*
2479 * Finds the image layer in the chain that has 'bs' as its backing file.
2480 *
2481 * active is the current topmost image.
2482 *
2483 * Returns NULL if bs is not found in active's image chain,
2484 * or if active == bs.
4caf0fcd
JC
2485 *
2486 * Returns the bottommost base image if bs == NULL.
6ebdcee2
JC
2487 */
2488BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2489 BlockDriverState *bs)
2490{
760e0063
KW
2491 while (active && bs != backing_bs(active)) {
2492 active = backing_bs(active);
6ebdcee2
JC
2493 }
2494
4caf0fcd
JC
2495 return active;
2496}
6ebdcee2 2497
4caf0fcd
JC
2498/* Given a BDS, searches for the base layer. */
2499BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2500{
2501 return bdrv_find_overlay(bs, NULL);
6ebdcee2
JC
2502}
2503
6ebdcee2
JC
2504/*
2505 * Drops images above 'base' up to and including 'top', and sets the image
2506 * above 'top' to have base as its backing file.
2507 *
2508 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2509 * information in 'bs' can be properly updated.
2510 *
2511 * E.g., this will convert the following chain:
2512 * bottom <- base <- intermediate <- top <- active
2513 *
2514 * to
2515 *
2516 * bottom <- base <- active
2517 *
2518 * It is allowed for bottom==base, in which case it converts:
2519 *
2520 * base <- intermediate <- top <- active
2521 *
2522 * to
2523 *
2524 * base <- active
2525 *
54e26900
JC
2526 * If backing_file_str is non-NULL, it will be used when modifying top's
2527 * overlay image metadata.
2528 *
6ebdcee2
JC
2529 * Error conditions:
2530 * if active == top, that is considered an error
2531 *
2532 */
2533int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
54e26900 2534 BlockDriverState *base, const char *backing_file_str)
6ebdcee2 2535{
6ebdcee2 2536 BlockDriverState *new_top_bs = NULL;
6ebdcee2
JC
2537 int ret = -EIO;
2538
6ebdcee2
JC
2539 if (!top->drv || !base->drv) {
2540 goto exit;
2541 }
2542
2543 new_top_bs = bdrv_find_overlay(active, top);
2544
2545 if (new_top_bs == NULL) {
2546 /* we could not find the image above 'top', this is an error */
2547 goto exit;
2548 }
2549
760e0063 2550 /* special case of new_top_bs->backing->bs already pointing to base - nothing
6ebdcee2 2551 * to do, no intermediate images */
760e0063 2552 if (backing_bs(new_top_bs) == base) {
6ebdcee2
JC
2553 ret = 0;
2554 goto exit;
2555 }
2556
5db15a57
KW
2557 /* Make sure that base is in the backing chain of top */
2558 if (!bdrv_chain_contains(top, base)) {
6ebdcee2
JC
2559 goto exit;
2560 }
2561
2562 /* success - we can delete the intermediate states, and link top->base */
5db15a57 2563 backing_file_str = backing_file_str ? backing_file_str : base->filename;
54e26900 2564 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
5db15a57 2565 base->drv ? base->drv->format_name : "");
6ebdcee2
JC
2566 if (ret) {
2567 goto exit;
2568 }
5db15a57 2569 bdrv_set_backing_hd(new_top_bs, base);
6ebdcee2 2570
6ebdcee2 2571 ret = 0;
6ebdcee2 2572exit:
6ebdcee2
JC
2573 return ret;
2574}
2575
61007b31
SH
2576/**
2577 * Truncate file to 'offset' bytes (needed only for file protocols)
2578 */
2579int bdrv_truncate(BlockDriverState *bs, int64_t offset)
71d0770c 2580{
61007b31
SH
2581 BlockDriver *drv = bs->drv;
2582 int ret;
2583 if (!drv)
71d0770c 2584 return -ENOMEDIUM;
61007b31
SH
2585 if (!drv->bdrv_truncate)
2586 return -ENOTSUP;
2587 if (bs->read_only)
2588 return -EACCES;
71d0770c 2589
61007b31
SH
2590 ret = drv->bdrv_truncate(bs, offset);
2591 if (ret == 0) {
2592 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2593 bdrv_dirty_bitmap_truncate(bs);
5c8cab48 2594 bdrv_parent_cb_resize(bs);
c0191e76 2595 }
61007b31 2596 return ret;
71d0770c
AL
2597}
2598
61007b31
SH
2599/**
2600 * Length of a allocated file in bytes. Sparse files are counted by actual
2601 * allocated space. Return < 0 if error or unknown.
2602 */
2603int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
71d0770c 2604{
61007b31
SH
2605 BlockDriver *drv = bs->drv;
2606 if (!drv) {
2607 return -ENOMEDIUM;
8f4754ed 2608 }
61007b31
SH
2609 if (drv->bdrv_get_allocated_file_size) {
2610 return drv->bdrv_get_allocated_file_size(bs);
2611 }
2612 if (bs->file) {
9a4f4c31 2613 return bdrv_get_allocated_file_size(bs->file->bs);
1c9805a3 2614 }
61007b31 2615 return -ENOTSUP;
1c9805a3 2616}
e7a8a783 2617
61007b31
SH
2618/**
2619 * Return number of sectors on success, -errno on error.
1c9805a3 2620 */
61007b31 2621int64_t bdrv_nb_sectors(BlockDriverState *bs)
1c9805a3 2622{
61007b31 2623 BlockDriver *drv = bs->drv;
498e386c 2624
61007b31
SH
2625 if (!drv)
2626 return -ENOMEDIUM;
2572b37a 2627
61007b31
SH
2628 if (drv->has_variable_length) {
2629 int ret = refresh_total_sectors(bs, bs->total_sectors);
2630 if (ret < 0) {
2631 return ret;
1c9805a3
SH
2632 }
2633 }
61007b31 2634 return bs->total_sectors;
1c9805a3 2635}
b338082b 2636
61007b31
SH
2637/**
2638 * Return length in bytes on success, -errno on error.
2639 * The length is always a multiple of BDRV_SECTOR_SIZE.
8d3b1a2d 2640 */
61007b31 2641int64_t bdrv_getlength(BlockDriverState *bs)
8d3b1a2d 2642{
61007b31 2643 int64_t ret = bdrv_nb_sectors(bs);
8d3b1a2d 2644
4a9c9ea0 2645 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
61007b31 2646 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
fc01f7e7
FB
2647}
2648
61007b31
SH
2649/* return 0 as number of sectors if no device present or error */
2650void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
07d27a44 2651{
61007b31 2652 int64_t nb_sectors = bdrv_nb_sectors(bs);
07d27a44 2653
61007b31 2654 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
07d27a44
MA
2655}
2656
61007b31 2657int bdrv_is_read_only(BlockDriverState *bs)
8d3b1a2d 2658{
61007b31 2659 return bs->read_only;
83f64091 2660}
83f64091 2661
61007b31 2662int bdrv_is_sg(BlockDriverState *bs)
f08145fe 2663{
61007b31 2664 return bs->sg;
f08145fe
KW
2665}
2666
61007b31 2667int bdrv_is_encrypted(BlockDriverState *bs)
fc3959e4 2668{
760e0063 2669 if (bs->backing && bs->backing->bs->encrypted) {
61007b31 2670 return 1;
760e0063 2671 }
61007b31 2672 return bs->encrypted;
fc3959e4
FZ
2673}
2674
61007b31 2675int bdrv_key_required(BlockDriverState *bs)
fc3959e4 2676{
760e0063 2677 BdrvChild *backing = bs->backing;
61007b31 2678
760e0063 2679 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
61007b31 2680 return 1;
760e0063 2681 }
61007b31 2682 return (bs->encrypted && !bs->valid_key);
fc3959e4
FZ
2683}
2684
61007b31 2685int bdrv_set_key(BlockDriverState *bs, const char *key)
d0c7f642 2686{
d0c7f642 2687 int ret;
760e0063
KW
2688 if (bs->backing && bs->backing->bs->encrypted) {
2689 ret = bdrv_set_key(bs->backing->bs, key);
61007b31
SH
2690 if (ret < 0)
2691 return ret;
2692 if (!bs->encrypted)
2693 return 0;
2694 }
2695 if (!bs->encrypted) {
2696 return -EINVAL;
2697 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
d0c7f642
KW
2698 return -ENOMEDIUM;
2699 }
61007b31 2700 ret = bs->drv->bdrv_set_key(bs, key);
b9c64947 2701 if (ret < 0) {
61007b31
SH
2702 bs->valid_key = 0;
2703 } else if (!bs->valid_key) {
5c8cab48 2704 /* call the change callback now, we skipped it on open */
61007b31 2705 bs->valid_key = 1;
5c8cab48 2706 bdrv_parent_cb_change_media(bs, true);
1b0288ae 2707 }
61007b31
SH
2708 return ret;
2709}
f08f2dda 2710
c5fbe571 2711/*
61007b31
SH
2712 * Provide an encryption key for @bs.
2713 * If @key is non-null:
2714 * If @bs is not encrypted, fail.
2715 * Else if the key is invalid, fail.
2716 * Else set @bs's key to @key, replacing the existing key, if any.
2717 * If @key is null:
2718 * If @bs is encrypted and still lacks a key, fail.
2719 * Else do nothing.
2720 * On failure, store an error object through @errp if non-null.
c5fbe571 2721 */
61007b31 2722void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
c5fbe571 2723{
61007b31
SH
2724 if (key) {
2725 if (!bdrv_is_encrypted(bs)) {
2726 error_setg(errp, "Node '%s' is not encrypted",
2727 bdrv_get_device_or_node_name(bs));
2728 } else if (bdrv_set_key(bs, key) < 0) {
c6bd8c70 2729 error_setg(errp, QERR_INVALID_PASSWORD);
4d2855a3
MA
2730 }
2731 } else {
2732 if (bdrv_key_required(bs)) {
b1ca6391
MA
2733 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2734 "'%s' (%s) is encrypted",
81e5f78a 2735 bdrv_get_device_or_node_name(bs),
4d2855a3
MA
2736 bdrv_get_encrypted_filename(bs));
2737 }
2738 }
2739}
2740
61007b31 2741const char *bdrv_get_format_name(BlockDriverState *bs)
40b4f539 2742{
61007b31 2743 return bs->drv ? bs->drv->format_name : NULL;
40b4f539
KW
2744}
2745
61007b31 2746static int qsort_strcmp(const void *a, const void *b)
40b4f539 2747{
61007b31 2748 return strcmp(a, b);
40b4f539
KW
2749}
2750
61007b31
SH
2751void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2752 void *opaque)
40b4f539 2753{
61007b31
SH
2754 BlockDriver *drv;
2755 int count = 0;
2756 int i;
2757 const char **formats = NULL;
40b4f539 2758
61007b31
SH
2759 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2760 if (drv->format_name) {
2761 bool found = false;
2762 int i = count;
2763 while (formats && i && !found) {
2764 found = !strcmp(formats[--i], drv->format_name);
2765 }
e2a305fb 2766
61007b31
SH
2767 if (!found) {
2768 formats = g_renew(const char *, formats, count + 1);
2769 formats[count++] = drv->format_name;
2770 }
6c5a42ac 2771 }
61007b31 2772 }
6c5a42ac 2773
61007b31 2774 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
40b4f539 2775
61007b31
SH
2776 for (i = 0; i < count; i++) {
2777 it(opaque, formats[i]);
2778 }
40b4f539 2779
61007b31
SH
2780 g_free(formats);
2781}
40b4f539 2782
61007b31
SH
2783/* This function is to find a node in the bs graph */
2784BlockDriverState *bdrv_find_node(const char *node_name)
2785{
2786 BlockDriverState *bs;
391827eb 2787
61007b31 2788 assert(node_name);
40b4f539 2789
61007b31
SH
2790 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2791 if (!strcmp(node_name, bs->node_name)) {
2792 return bs;
40b4f539
KW
2793 }
2794 }
61007b31 2795 return NULL;
40b4f539
KW
2796}
2797
61007b31
SH
2798/* Put this QMP function here so it can access the static graph_bdrv_states. */
2799BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
40b4f539 2800{
61007b31
SH
2801 BlockDeviceInfoList *list, *entry;
2802 BlockDriverState *bs;
40b4f539 2803
61007b31
SH
2804 list = NULL;
2805 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
c83f9fba 2806 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
61007b31
SH
2807 if (!info) {
2808 qapi_free_BlockDeviceInfoList(list);
2809 return NULL;
301db7c2 2810 }
61007b31
SH
2811 entry = g_malloc0(sizeof(*entry));
2812 entry->value = info;
2813 entry->next = list;
2814 list = entry;
301db7c2
RH
2815 }
2816
61007b31
SH
2817 return list;
2818}
40b4f539 2819
61007b31
SH
2820BlockDriverState *bdrv_lookup_bs(const char *device,
2821 const char *node_name,
2822 Error **errp)
2823{
2824 BlockBackend *blk;
2825 BlockDriverState *bs;
40b4f539 2826
61007b31
SH
2827 if (device) {
2828 blk = blk_by_name(device);
40b4f539 2829
61007b31 2830 if (blk) {
9f4ed6fb
AG
2831 bs = blk_bs(blk);
2832 if (!bs) {
5433c24f 2833 error_setg(errp, "Device '%s' has no medium", device);
5433c24f
HR
2834 }
2835
9f4ed6fb 2836 return bs;
61007b31
SH
2837 }
2838 }
40b4f539 2839
61007b31
SH
2840 if (node_name) {
2841 bs = bdrv_find_node(node_name);
6d519a5f 2842
61007b31
SH
2843 if (bs) {
2844 return bs;
2845 }
40b4f539
KW
2846 }
2847
61007b31
SH
2848 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2849 device ? device : "",
2850 node_name ? node_name : "");
2851 return NULL;
40b4f539
KW
2852}
2853
61007b31
SH
2854/* If 'base' is in the same chain as 'top', return true. Otherwise,
2855 * return false. If either argument is NULL, return false. */
2856bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
83f64091 2857{
61007b31 2858 while (top && top != base) {
760e0063 2859 top = backing_bs(top);
02c50efe 2860 }
61007b31
SH
2861
2862 return top != NULL;
02c50efe
FZ
2863}
2864
61007b31 2865BlockDriverState *bdrv_next_node(BlockDriverState *bs)
02c50efe 2866{
61007b31
SH
2867 if (!bs) {
2868 return QTAILQ_FIRST(&graph_bdrv_states);
02c50efe 2869 }
61007b31 2870 return QTAILQ_NEXT(bs, node_list);
83f64091
FB
2871}
2872
26260580
HR
2873/* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
2874 * the monitor or attached to a BlockBackend */
61007b31 2875BlockDriverState *bdrv_next(BlockDriverState *bs)
83f64091 2876{
26260580
HR
2877 if (!bs || bs->blk) {
2878 bs = blk_next_root_bs(bs);
2879 if (bs) {
2880 return bs;
2881 }
857d4f46 2882 }
26260580
HR
2883
2884 /* Ignore all BDSs that are attached to a BlockBackend here; they have been
2885 * handled by the above block already */
2886 do {
2887 bs = bdrv_next_monitor_owned(bs);
2888 } while (bs && bs->blk);
2889 return bs;
83f64091 2890}
beac80cd 2891
61007b31 2892const char *bdrv_get_node_name(const BlockDriverState *bs)
83f64091 2893{
61007b31 2894 return bs->node_name;
beac80cd
FB
2895}
2896
4c265bf9
KW
2897static const char *bdrv_get_parent_name(const BlockDriverState *bs)
2898{
2899 BdrvChild *c;
2900 const char *name;
2901
2902 /* If multiple parents have a name, just pick the first one. */
2903 QLIST_FOREACH(c, &bs->parents, next_parent) {
2904 if (c->role->get_name) {
2905 name = c->role->get_name(c);
2906 if (name && *name) {
2907 return name;
2908 }
2909 }
2910 }
2911
2912 return NULL;
2913}
2914
61007b31
SH
2915/* TODO check what callers really want: bs->node_name or blk_name() */
2916const char *bdrv_get_device_name(const BlockDriverState *bs)
beac80cd 2917{
4c265bf9 2918 return bdrv_get_parent_name(bs) ?: "";
f141eafe 2919}
83f64091 2920
61007b31
SH
2921/* This can be used to identify nodes that might not have a device
2922 * name associated. Since node and device names live in the same
2923 * namespace, the result is unambiguous. The exception is if both are
2924 * absent, then this returns an empty (non-null) string. */
2925const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
f141eafe 2926{
4c265bf9 2927 return bdrv_get_parent_name(bs) ?: bs->node_name;
beac80cd 2928}
beac80cd 2929
61007b31 2930int bdrv_get_flags(BlockDriverState *bs)
0b5a2445 2931{
61007b31 2932 return bs->open_flags;
0b5a2445
PB
2933}
2934
61007b31 2935int bdrv_has_zero_init_1(BlockDriverState *bs)
68485420 2936{
61007b31 2937 return 1;
0b5a2445
PB
2938}
2939
61007b31 2940int bdrv_has_zero_init(BlockDriverState *bs)
0b5a2445 2941{
61007b31 2942 assert(bs->drv);
0b5a2445 2943
61007b31
SH
2944 /* If BS is a copy on write image, it is initialized to
2945 the contents of the base image, which may not be zeroes. */
760e0063 2946 if (bs->backing) {
61007b31
SH
2947 return 0;
2948 }
2949 if (bs->drv->bdrv_has_zero_init) {
2950 return bs->drv->bdrv_has_zero_init(bs);
0b5a2445 2951 }
61007b31
SH
2952
2953 /* safe default */
2954 return 0;
68485420
KW
2955}
2956
61007b31 2957bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
b2a61371 2958{
61007b31 2959 BlockDriverInfo bdi;
b2a61371 2960
760e0063 2961 if (bs->backing) {
61007b31
SH
2962 return false;
2963 }
2964
2965 if (bdrv_get_info(bs, &bdi) == 0) {
2966 return bdi.unallocated_blocks_are_zero;
b2a61371
SH
2967 }
2968
61007b31 2969 return false;
b2a61371
SH
2970}
2971
61007b31 2972bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
68485420 2973{
61007b31 2974 BlockDriverInfo bdi;
68485420 2975
760e0063 2976 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
61007b31
SH
2977 return false;
2978 }
68485420 2979
61007b31
SH
2980 if (bdrv_get_info(bs, &bdi) == 0) {
2981 return bdi.can_write_zeroes_with_unmap;
2982 }
68485420 2983
61007b31 2984 return false;
68485420
KW
2985}
2986
61007b31 2987const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
b2e12bc6 2988{
760e0063 2989 if (bs->backing && bs->backing->bs->encrypted)
61007b31
SH
2990 return bs->backing_file;
2991 else if (bs->encrypted)
2992 return bs->filename;
2993 else
2994 return NULL;
b2e12bc6
CH
2995}
2996
61007b31
SH
2997void bdrv_get_backing_filename(BlockDriverState *bs,
2998 char *filename, int filename_size)
016f5cf6 2999{
61007b31
SH
3000 pstrcpy(filename, filename_size, bs->backing_file);
3001}
d318aea9 3002
61007b31
SH
3003int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3004{
3005 BlockDriver *drv = bs->drv;
3006 if (!drv)
3007 return -ENOMEDIUM;
3008 if (!drv->bdrv_get_info)
3009 return -ENOTSUP;
3010 memset(bdi, 0, sizeof(*bdi));
3011 return drv->bdrv_get_info(bs, bdi);
3012}
016f5cf6 3013
61007b31
SH
3014ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3015{
3016 BlockDriver *drv = bs->drv;
3017 if (drv && drv->bdrv_get_specific_info) {
3018 return drv->bdrv_get_specific_info(bs);
3019 }
3020 return NULL;
016f5cf6
AG
3021}
3022
a31939e6 3023void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
4265d620 3024{
61007b31
SH
3025 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3026 return;
3027 }
4265d620 3028
61007b31 3029 bs->drv->bdrv_debug_event(bs, event);
4265d620
PB
3030}
3031
61007b31
SH
3032int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3033 const char *tag)
4265d620 3034{
61007b31 3035 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
9a4f4c31 3036 bs = bs->file ? bs->file->bs : NULL;
61007b31 3037 }
4265d620 3038
61007b31
SH
3039 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3040 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3041 }
4265d620 3042
61007b31 3043 return -ENOTSUP;
4265d620
PB
3044}
3045
61007b31 3046int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
ea2384d3 3047{
61007b31 3048 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
9a4f4c31 3049 bs = bs->file ? bs->file->bs : NULL;
61007b31 3050 }
ce1a14dc 3051
61007b31
SH
3052 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3053 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3054 }
3055
3056 return -ENOTSUP;
eb852011
MA
3057}
3058
61007b31 3059int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
ce1a14dc 3060{
61007b31 3061 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
9a4f4c31 3062 bs = bs->file ? bs->file->bs : NULL;
61007b31 3063 }
ce1a14dc 3064
61007b31
SH
3065 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3066 return bs->drv->bdrv_debug_resume(bs, tag);
3067 }
ce1a14dc 3068
61007b31 3069 return -ENOTSUP;
f197fe2b
FZ
3070}
3071
61007b31 3072bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
ce1a14dc 3073{
61007b31 3074 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
9a4f4c31 3075 bs = bs->file ? bs->file->bs : NULL;
f197fe2b 3076 }
19cb3738 3077
61007b31
SH
3078 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3079 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3080 }
f9f05dc5 3081
61007b31
SH
3082 return false;
3083}
f9f05dc5 3084
61007b31 3085int bdrv_is_snapshot(BlockDriverState *bs)
f9f05dc5 3086{
61007b31 3087 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
f9f05dc5
KW
3088}
3089
61007b31
SH
3090/* backing_file can either be relative, or absolute, or a protocol. If it is
3091 * relative, it must be relative to the chain. So, passing in bs->filename
3092 * from a BDS as backing_file should not be done, as that may be relative to
3093 * the CWD rather than the chain. */
3094BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3095 const char *backing_file)
f9f05dc5 3096{
61007b31
SH
3097 char *filename_full = NULL;
3098 char *backing_file_full = NULL;
3099 char *filename_tmp = NULL;
3100 int is_protocol = 0;
3101 BlockDriverState *curr_bs = NULL;
3102 BlockDriverState *retval = NULL;
f9f05dc5 3103
61007b31
SH
3104 if (!bs || !bs->drv || !backing_file) {
3105 return NULL;
f9f05dc5
KW
3106 }
3107
61007b31
SH
3108 filename_full = g_malloc(PATH_MAX);
3109 backing_file_full = g_malloc(PATH_MAX);
3110 filename_tmp = g_malloc(PATH_MAX);
f9f05dc5 3111
61007b31 3112 is_protocol = path_has_protocol(backing_file);
f9f05dc5 3113
760e0063 3114 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
f9f05dc5 3115
61007b31
SH
3116 /* If either of the filename paths is actually a protocol, then
3117 * compare unmodified paths; otherwise make paths relative */
3118 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3119 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
760e0063 3120 retval = curr_bs->backing->bs;
61007b31
SH
3121 break;
3122 }
3123 } else {
3124 /* If not an absolute filename path, make it relative to the current
3125 * image's filename path */
3126 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3127 backing_file);
f9f05dc5 3128
61007b31
SH
3129 /* We are going to compare absolute pathnames */
3130 if (!realpath(filename_tmp, filename_full)) {
3131 continue;
3132 }
07f07615 3133
61007b31
SH
3134 /* We need to make sure the backing filename we are comparing against
3135 * is relative to the current image filename (or absolute) */
3136 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3137 curr_bs->backing_file);
07f07615 3138
61007b31
SH
3139 if (!realpath(filename_tmp, backing_file_full)) {
3140 continue;
3141 }
eb489bb1 3142
61007b31 3143 if (strcmp(backing_file_full, filename_full) == 0) {
760e0063 3144 retval = curr_bs->backing->bs;
61007b31
SH
3145 break;
3146 }
3147 }
eb489bb1
KW
3148 }
3149
61007b31
SH
3150 g_free(filename_full);
3151 g_free(backing_file_full);
3152 g_free(filename_tmp);
3153 return retval;
3154}
3155
3156int bdrv_get_backing_file_depth(BlockDriverState *bs)
3157{
3158 if (!bs->drv) {
3159 return 0;
eb489bb1
KW
3160 }
3161
760e0063 3162 if (!bs->backing) {
61007b31 3163 return 0;
ca716364
KW
3164 }
3165
760e0063 3166 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
61007b31 3167}
07f07615 3168
61007b31
SH
3169void bdrv_init(void)
3170{
3171 module_call_init(MODULE_INIT_BLOCK);
3172}
29cdb251 3173
61007b31
SH
3174void bdrv_init_with_whitelist(void)
3175{
3176 use_bdrv_whitelist = 1;
3177 bdrv_init();
07f07615
PB
3178}
3179
5a8a30db 3180void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
0f15423c 3181{
0d1c5c91 3182 BdrvChild *child;
5a8a30db
KW
3183 Error *local_err = NULL;
3184 int ret;
3185
3456a8d1
KW
3186 if (!bs->drv) {
3187 return;
3188 }
3189
04c01a5c 3190 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
7ea2d269
AK
3191 return;
3192 }
04c01a5c 3193 bs->open_flags &= ~BDRV_O_INACTIVE;
7ea2d269 3194
3456a8d1 3195 if (bs->drv->bdrv_invalidate_cache) {
5a8a30db 3196 bs->drv->bdrv_invalidate_cache(bs, &local_err);
0d1c5c91
FZ
3197 if (local_err) {
3198 bs->open_flags |= BDRV_O_INACTIVE;
3199 error_propagate(errp, local_err);
3200 return;
3201 }
5a8a30db 3202 }
0d1c5c91
FZ
3203
3204 QLIST_FOREACH(child, &bs->children, next) {
3205 bdrv_invalidate_cache(child->bs, &local_err);
3206 if (local_err) {
3207 bs->open_flags |= BDRV_O_INACTIVE;
3208 error_propagate(errp, local_err);
3209 return;
3210 }
0f15423c 3211 }
3456a8d1 3212
5a8a30db
KW
3213 ret = refresh_total_sectors(bs, bs->total_sectors);
3214 if (ret < 0) {
04c01a5c 3215 bs->open_flags |= BDRV_O_INACTIVE;
5a8a30db
KW
3216 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3217 return;
3218 }
0f15423c
AL
3219}
3220
5a8a30db 3221void bdrv_invalidate_cache_all(Error **errp)
0f15423c 3222{
79720af6 3223 BlockDriverState *bs = NULL;
5a8a30db 3224 Error *local_err = NULL;
0f15423c 3225
79720af6 3226 while ((bs = bdrv_next(bs)) != NULL) {
ed78cda3
SH
3227 AioContext *aio_context = bdrv_get_aio_context(bs);
3228
3229 aio_context_acquire(aio_context);
5a8a30db 3230 bdrv_invalidate_cache(bs, &local_err);
ed78cda3 3231 aio_context_release(aio_context);
5a8a30db
KW
3232 if (local_err) {
3233 error_propagate(errp, local_err);
3234 return;
3235 }
0f15423c
AL
3236 }
3237}
3238
aad0b7a0
FZ
3239static int bdrv_inactivate_recurse(BlockDriverState *bs,
3240 bool setting_flag)
76b1c7fe 3241{
aad0b7a0 3242 BdrvChild *child;
76b1c7fe
KW
3243 int ret;
3244
aad0b7a0 3245 if (!setting_flag && bs->drv->bdrv_inactivate) {
76b1c7fe
KW
3246 ret = bs->drv->bdrv_inactivate(bs);
3247 if (ret < 0) {
3248 return ret;
3249 }
3250 }
3251
aad0b7a0
FZ
3252 QLIST_FOREACH(child, &bs->children, next) {
3253 ret = bdrv_inactivate_recurse(child->bs, setting_flag);
3254 if (ret < 0) {
3255 return ret;
3256 }
3257 }
3258
3259 if (setting_flag) {
3260 bs->open_flags |= BDRV_O_INACTIVE;
3261 }
76b1c7fe
KW
3262 return 0;
3263}
3264
3265int bdrv_inactivate_all(void)
3266{
79720af6 3267 BlockDriverState *bs = NULL;
aad0b7a0
FZ
3268 int ret = 0;
3269 int pass;
76b1c7fe 3270
79720af6 3271 while ((bs = bdrv_next(bs)) != NULL) {
aad0b7a0
FZ
3272 aio_context_acquire(bdrv_get_aio_context(bs));
3273 }
76b1c7fe 3274
aad0b7a0
FZ
3275 /* We do two passes of inactivation. The first pass calls to drivers'
3276 * .bdrv_inactivate callbacks recursively so all cache is flushed to disk;
3277 * the second pass sets the BDRV_O_INACTIVE flag so that no further write
3278 * is allowed. */
3279 for (pass = 0; pass < 2; pass++) {
3280 bs = NULL;
3281 while ((bs = bdrv_next(bs)) != NULL) {
3282 ret = bdrv_inactivate_recurse(bs, pass);
3283 if (ret < 0) {
3284 goto out;
3285 }
76b1c7fe
KW
3286 }
3287 }
3288
aad0b7a0
FZ
3289out:
3290 bs = NULL;
3291 while ((bs = bdrv_next(bs)) != NULL) {
3292 aio_context_release(bdrv_get_aio_context(bs));
3293 }
3294
3295 return ret;
76b1c7fe
KW
3296}
3297
19cb3738
FB
3298/**************************************************************/
3299/* removable device support */
3300
3301/**
3302 * Return TRUE if the media is present
3303 */
e031f750 3304bool bdrv_is_inserted(BlockDriverState *bs)
19cb3738
FB
3305{
3306 BlockDriver *drv = bs->drv;
28d7a789 3307 BdrvChild *child;
a1aff5bf 3308
e031f750
HR
3309 if (!drv) {
3310 return false;
3311 }
28d7a789
HR
3312 if (drv->bdrv_is_inserted) {
3313 return drv->bdrv_is_inserted(bs);
3314 }
3315 QLIST_FOREACH(child, &bs->children, next) {
3316 if (!bdrv_is_inserted(child->bs)) {
3317 return false;
3318 }
e031f750 3319 }
28d7a789 3320 return true;
19cb3738
FB
3321}
3322
3323/**
8e49ca46
MA
3324 * Return whether the media changed since the last call to this
3325 * function, or -ENOTSUP if we don't know. Most drivers don't know.
19cb3738
FB
3326 */
3327int bdrv_media_changed(BlockDriverState *bs)
3328{
3329 BlockDriver *drv = bs->drv;
19cb3738 3330
8e49ca46
MA
3331 if (drv && drv->bdrv_media_changed) {
3332 return drv->bdrv_media_changed(bs);
3333 }
3334 return -ENOTSUP;
19cb3738
FB
3335}
3336
3337/**
3338 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3339 */
f36f3949 3340void bdrv_eject(BlockDriverState *bs, bool eject_flag)
19cb3738
FB
3341{
3342 BlockDriver *drv = bs->drv;
bfb197e0 3343 const char *device_name;
19cb3738 3344
822e1cd1
MA
3345 if (drv && drv->bdrv_eject) {
3346 drv->bdrv_eject(bs, eject_flag);
19cb3738 3347 }
6f382ed2 3348
bfb197e0
MA
3349 device_name = bdrv_get_device_name(bs);
3350 if (device_name[0] != '\0') {
3351 qapi_event_send_device_tray_moved(device_name,
a5ee7bd4 3352 eject_flag, &error_abort);
6f382ed2 3353 }
19cb3738
FB
3354}
3355
19cb3738
FB
3356/**
3357 * Lock or unlock the media (if it is locked, the user won't be able
3358 * to eject it manually).
3359 */
025e849a 3360void bdrv_lock_medium(BlockDriverState *bs, bool locked)
19cb3738
FB
3361{
3362 BlockDriver *drv = bs->drv;
3363
025e849a 3364 trace_bdrv_lock_medium(bs, locked);
b8c6d095 3365
025e849a
MA
3366 if (drv && drv->bdrv_lock_medium) {
3367 drv->bdrv_lock_medium(bs, locked);
19cb3738
FB
3368 }
3369}
985a03b0 3370
9fcb0251
FZ
3371/* Get a reference to bs */
3372void bdrv_ref(BlockDriverState *bs)
3373{
3374 bs->refcnt++;
3375}
3376
3377/* Release a previously grabbed reference to bs.
3378 * If after releasing, reference count is zero, the BlockDriverState is
3379 * deleted. */
3380void bdrv_unref(BlockDriverState *bs)
3381{
9a4d5ca6
JC
3382 if (!bs) {
3383 return;
3384 }
9fcb0251
FZ
3385 assert(bs->refcnt > 0);
3386 if (--bs->refcnt == 0) {
3387 bdrv_delete(bs);
3388 }
3389}
3390
fbe40ff7
FZ
3391struct BdrvOpBlocker {
3392 Error *reason;
3393 QLIST_ENTRY(BdrvOpBlocker) list;
3394};
3395
3396bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3397{
3398 BdrvOpBlocker *blocker;
3399 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3400 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3401 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3402 if (errp) {
e43bfd9c
MA
3403 *errp = error_copy(blocker->reason);
3404 error_prepend(errp, "Node '%s' is busy: ",
3405 bdrv_get_device_or_node_name(bs));
fbe40ff7
FZ
3406 }
3407 return true;
3408 }
3409 return false;
3410}
3411
3412void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3413{
3414 BdrvOpBlocker *blocker;
3415 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3416
5839e53b 3417 blocker = g_new0(BdrvOpBlocker, 1);
fbe40ff7
FZ
3418 blocker->reason = reason;
3419 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3420}
3421
3422void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3423{
3424 BdrvOpBlocker *blocker, *next;
3425 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3426 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3427 if (blocker->reason == reason) {
3428 QLIST_REMOVE(blocker, list);
3429 g_free(blocker);
3430 }
3431 }
3432}
3433
3434void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3435{
3436 int i;
3437 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3438 bdrv_op_block(bs, i, reason);
3439 }
3440}
3441
3442void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3443{
3444 int i;
3445 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3446 bdrv_op_unblock(bs, i, reason);
3447 }
3448}
3449
3450bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3451{
3452 int i;
3453
3454 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3455 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3456 return false;
3457 }
3458 }
3459 return true;
3460}
3461
d92ada22
LC
3462void bdrv_img_create(const char *filename, const char *fmt,
3463 const char *base_filename, const char *base_fmt,
f382d43a
MR
3464 char *options, uint64_t img_size, int flags,
3465 Error **errp, bool quiet)
f88e1a42 3466{
83d0521a
CL
3467 QemuOptsList *create_opts = NULL;
3468 QemuOpts *opts = NULL;
3469 const char *backing_fmt, *backing_file;
3470 int64_t size;
f88e1a42 3471 BlockDriver *drv, *proto_drv;
cc84d90f 3472 Error *local_err = NULL;
f88e1a42
JS
3473 int ret = 0;
3474
3475 /* Find driver and parse its options */
3476 drv = bdrv_find_format(fmt);
3477 if (!drv) {
71c79813 3478 error_setg(errp, "Unknown file format '%s'", fmt);
d92ada22 3479 return;
f88e1a42
JS
3480 }
3481
b65a5e12 3482 proto_drv = bdrv_find_protocol(filename, true, errp);
f88e1a42 3483 if (!proto_drv) {
d92ada22 3484 return;
f88e1a42
JS
3485 }
3486
c6149724
HR
3487 if (!drv->create_opts) {
3488 error_setg(errp, "Format driver '%s' does not support image creation",
3489 drv->format_name);
3490 return;
3491 }
3492
3493 if (!proto_drv->create_opts) {
3494 error_setg(errp, "Protocol driver '%s' does not support image creation",
3495 proto_drv->format_name);
3496 return;
3497 }
3498
c282e1fd
CL
3499 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3500 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
f88e1a42
JS
3501
3502 /* Create parameter list with default values */
83d0521a 3503 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
39101f25 3504 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
f88e1a42
JS
3505
3506 /* Parse -o options */
3507 if (options) {
dc523cd3
MA
3508 qemu_opts_do_parse(opts, options, NULL, &local_err);
3509 if (local_err) {
3510 error_report_err(local_err);
3511 local_err = NULL;
83d0521a 3512 error_setg(errp, "Invalid options for file format '%s'", fmt);
f88e1a42
JS
3513 goto out;
3514 }
3515 }
3516
3517 if (base_filename) {
f43e47db 3518 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
6be4194b 3519 if (local_err) {
71c79813
LC
3520 error_setg(errp, "Backing file not supported for file format '%s'",
3521 fmt);
f88e1a42
JS
3522 goto out;
3523 }
3524 }
3525
3526 if (base_fmt) {
f43e47db 3527 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
6be4194b 3528 if (local_err) {
71c79813
LC
3529 error_setg(errp, "Backing file format not supported for file "
3530 "format '%s'", fmt);
f88e1a42
JS
3531 goto out;
3532 }
3533 }
3534
83d0521a
CL
3535 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3536 if (backing_file) {
3537 if (!strcmp(filename, backing_file)) {
71c79813
LC
3538 error_setg(errp, "Error: Trying to create an image with the "
3539 "same filename as the backing file");
792da93a
JS
3540 goto out;
3541 }
3542 }
3543
83d0521a 3544 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
f88e1a42
JS
3545
3546 // The size for the image must always be specified, with one exception:
3547 // If we are using a backing file, we can obtain the size from there
83d0521a
CL
3548 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3549 if (size == -1) {
3550 if (backing_file) {
66f6b814 3551 BlockDriverState *bs;
29168018 3552 char *full_backing = g_new0(char, PATH_MAX);
52bf1e72 3553 int64_t size;
63090dac 3554 int back_flags;
e6641719 3555 QDict *backing_options = NULL;
63090dac 3556
29168018
HR
3557 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3558 full_backing, PATH_MAX,
3559 &local_err);
3560 if (local_err) {
3561 g_free(full_backing);
3562 goto out;
3563 }
3564
63090dac 3565 /* backing files always opened read-only */
61de4c68 3566 back_flags = flags;
bfd18d1e 3567 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
f88e1a42 3568
e6641719
HR
3569 if (backing_fmt) {
3570 backing_options = qdict_new();
3571 qdict_put(backing_options, "driver",
3572 qstring_from_str(backing_fmt));
3573 }
3574
f67503e5 3575 bs = NULL;
e6641719 3576 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
6ebf9aa2 3577 back_flags, &local_err);
29168018 3578 g_free(full_backing);
f88e1a42 3579 if (ret < 0) {
f88e1a42
JS
3580 goto out;
3581 }
52bf1e72
MA
3582 size = bdrv_getlength(bs);
3583 if (size < 0) {
3584 error_setg_errno(errp, -size, "Could not get size of '%s'",
3585 backing_file);
3586 bdrv_unref(bs);
3587 goto out;
3588 }
f88e1a42 3589
39101f25 3590 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
66f6b814
HR
3591
3592 bdrv_unref(bs);
f88e1a42 3593 } else {
71c79813 3594 error_setg(errp, "Image creation needs a size parameter");
f88e1a42
JS
3595 goto out;
3596 }
3597 }
3598
f382d43a 3599 if (!quiet) {
fe646693 3600 printf("Formatting '%s', fmt=%s ", filename, fmt);
43c5d8f8 3601 qemu_opts_print(opts, " ");
f382d43a
MR
3602 puts("");
3603 }
83d0521a 3604
c282e1fd 3605 ret = bdrv_create(drv, filename, opts, &local_err);
83d0521a 3606
cc84d90f
HR
3607 if (ret == -EFBIG) {
3608 /* This is generally a better message than whatever the driver would
3609 * deliver (especially because of the cluster_size_hint), since that
3610 * is most probably not much different from "image too large". */
3611 const char *cluster_size_hint = "";
83d0521a 3612 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
cc84d90f 3613 cluster_size_hint = " (try using a larger cluster size)";
f88e1a42 3614 }
cc84d90f
HR
3615 error_setg(errp, "The image size is too large for file format '%s'"
3616 "%s", fmt, cluster_size_hint);
3617 error_free(local_err);
3618 local_err = NULL;
f88e1a42
JS
3619 }
3620
3621out:
83d0521a
CL
3622 qemu_opts_del(opts);
3623 qemu_opts_free(create_opts);
84d18f06 3624 if (local_err) {
cc84d90f
HR
3625 error_propagate(errp, local_err);
3626 }
f88e1a42 3627}
85d126f3
SH
3628
3629AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3630{
dcd04228
SH
3631 return bs->aio_context;
3632}
3633
3634void bdrv_detach_aio_context(BlockDriverState *bs)
3635{
33384421
HR
3636 BdrvAioNotifier *baf;
3637
dcd04228
SH
3638 if (!bs->drv) {
3639 return;
3640 }
3641
33384421
HR
3642 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3643 baf->detach_aio_context(baf->opaque);
3644 }
3645
dcd04228
SH
3646 if (bs->drv->bdrv_detach_aio_context) {
3647 bs->drv->bdrv_detach_aio_context(bs);
3648 }
3649 if (bs->file) {
9a4f4c31 3650 bdrv_detach_aio_context(bs->file->bs);
dcd04228 3651 }
760e0063
KW
3652 if (bs->backing) {
3653 bdrv_detach_aio_context(bs->backing->bs);
dcd04228
SH
3654 }
3655
3656 bs->aio_context = NULL;
3657}
3658
3659void bdrv_attach_aio_context(BlockDriverState *bs,
3660 AioContext *new_context)
3661{
33384421
HR
3662 BdrvAioNotifier *ban;
3663
dcd04228
SH
3664 if (!bs->drv) {
3665 return;
3666 }
3667
3668 bs->aio_context = new_context;
3669
760e0063
KW
3670 if (bs->backing) {
3671 bdrv_attach_aio_context(bs->backing->bs, new_context);
dcd04228
SH
3672 }
3673 if (bs->file) {
9a4f4c31 3674 bdrv_attach_aio_context(bs->file->bs, new_context);
dcd04228
SH
3675 }
3676 if (bs->drv->bdrv_attach_aio_context) {
3677 bs->drv->bdrv_attach_aio_context(bs, new_context);
3678 }
33384421
HR
3679
3680 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3681 ban->attached_aio_context(new_context, ban->opaque);
3682 }
dcd04228
SH
3683}
3684
3685void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3686{
53ec73e2 3687 bdrv_drain(bs); /* ensure there are no in-flight requests */
dcd04228
SH
3688
3689 bdrv_detach_aio_context(bs);
3690
3691 /* This function executes in the old AioContext so acquire the new one in
3692 * case it runs in a different thread.
3693 */
3694 aio_context_acquire(new_context);
3695 bdrv_attach_aio_context(bs, new_context);
3696 aio_context_release(new_context);
85d126f3 3697}
d616b224 3698
33384421
HR
3699void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3700 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3701 void (*detach_aio_context)(void *opaque), void *opaque)
3702{
3703 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3704 *ban = (BdrvAioNotifier){
3705 .attached_aio_context = attached_aio_context,
3706 .detach_aio_context = detach_aio_context,
3707 .opaque = opaque
3708 };
3709
3710 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3711}
3712
3713void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3714 void (*attached_aio_context)(AioContext *,
3715 void *),
3716 void (*detach_aio_context)(void *),
3717 void *opaque)
3718{
3719 BdrvAioNotifier *ban, *ban_next;
3720
3721 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3722 if (ban->attached_aio_context == attached_aio_context &&
3723 ban->detach_aio_context == detach_aio_context &&
3724 ban->opaque == opaque)
3725 {
3726 QLIST_REMOVE(ban, list);
3727 g_free(ban);
3728
3729 return;
3730 }
3731 }
3732
3733 abort();
3734}
3735
77485434 3736int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
8b13976d 3737 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
6f176b48 3738{
c282e1fd 3739 if (!bs->drv->bdrv_amend_options) {
6f176b48
HR
3740 return -ENOTSUP;
3741 }
8b13976d 3742 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
6f176b48 3743}
f6186f49 3744
b5042a36
BC
3745/* This function will be called by the bdrv_recurse_is_first_non_filter method
3746 * of block filter and by bdrv_is_first_non_filter.
3747 * It is used to test if the given bs is the candidate or recurse more in the
3748 * node graph.
212a5a8f 3749 */
b5042a36 3750bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
212a5a8f 3751 BlockDriverState *candidate)
f6186f49 3752{
b5042a36
BC
3753 /* return false if basic checks fails */
3754 if (!bs || !bs->drv) {
212a5a8f 3755 return false;
f6186f49
BC
3756 }
3757
b5042a36
BC
3758 /* the code reached a non block filter driver -> check if the bs is
3759 * the same as the candidate. It's the recursion termination condition.
3760 */
3761 if (!bs->drv->is_filter) {
3762 return bs == candidate;
212a5a8f 3763 }
b5042a36 3764 /* Down this path the driver is a block filter driver */
212a5a8f 3765
b5042a36
BC
3766 /* If the block filter recursion method is defined use it to recurse down
3767 * the node graph.
3768 */
3769 if (bs->drv->bdrv_recurse_is_first_non_filter) {
212a5a8f 3770 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
f6186f49
BC
3771 }
3772
b5042a36
BC
3773 /* the driver is a block filter but don't allow to recurse -> return false
3774 */
3775 return false;
f6186f49
BC
3776}
3777
212a5a8f
BC
3778/* This function checks if the candidate is the first non filter bs down it's
3779 * bs chain. Since we don't have pointers to parents it explore all bs chains
3780 * from the top. Some filters can choose not to pass down the recursion.
3781 */
3782bool bdrv_is_first_non_filter(BlockDriverState *candidate)
f6186f49 3783{
79720af6 3784 BlockDriverState *bs = NULL;
212a5a8f
BC
3785
3786 /* walk down the bs forest recursively */
79720af6 3787 while ((bs = bdrv_next(bs)) != NULL) {
212a5a8f
BC
3788 bool perm;
3789
b5042a36 3790 /* try to recurse in this top level bs */
e6dc8a1f 3791 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
212a5a8f
BC
3792
3793 /* candidate is the first non filter */
3794 if (perm) {
3795 return true;
3796 }
3797 }
3798
3799 return false;
f6186f49 3800}
09158f00 3801
e12f3784
WC
3802BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
3803 const char *node_name, Error **errp)
09158f00
BC
3804{
3805 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5a7e7a0b
SH
3806 AioContext *aio_context;
3807
09158f00
BC
3808 if (!to_replace_bs) {
3809 error_setg(errp, "Node name '%s' not found", node_name);
3810 return NULL;
3811 }
3812
5a7e7a0b
SH
3813 aio_context = bdrv_get_aio_context(to_replace_bs);
3814 aio_context_acquire(aio_context);
3815
09158f00 3816 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5a7e7a0b
SH
3817 to_replace_bs = NULL;
3818 goto out;
09158f00
BC
3819 }
3820
3821 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3822 * most non filter in order to prevent data corruption.
3823 * Another benefit is that this tests exclude backing files which are
3824 * blocked by the backing blockers.
3825 */
e12f3784 3826 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
09158f00 3827 error_setg(errp, "Only top most non filter can be replaced");
5a7e7a0b
SH
3828 to_replace_bs = NULL;
3829 goto out;
09158f00
BC
3830 }
3831
5a7e7a0b
SH
3832out:
3833 aio_context_release(aio_context);
09158f00
BC
3834 return to_replace_bs;
3835}
448ad91d 3836
91af7014
HR
3837static bool append_open_options(QDict *d, BlockDriverState *bs)
3838{
3839 const QDictEntry *entry;
9e700c1a 3840 QemuOptDesc *desc;
260fecf1 3841 BdrvChild *child;
91af7014 3842 bool found_any = false;
260fecf1 3843 const char *p;
91af7014
HR
3844
3845 for (entry = qdict_first(bs->options); entry;
3846 entry = qdict_next(bs->options, entry))
3847 {
260fecf1
KW
3848 /* Exclude options for children */
3849 QLIST_FOREACH(child, &bs->children, next) {
3850 if (strstart(qdict_entry_key(entry), child->name, &p)
3851 && (!*p || *p == '.'))
3852 {
3853 break;
3854 }
3855 }
3856 if (child) {
9e700c1a 3857 continue;
91af7014 3858 }
9e700c1a
KW
3859
3860 /* And exclude all non-driver-specific options */
3861 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
3862 if (!strcmp(qdict_entry_key(entry), desc->name)) {
3863 break;
3864 }
3865 }
3866 if (desc->name) {
3867 continue;
3868 }
3869
3870 qobject_incref(qdict_entry_value(entry));
3871 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
3872 found_any = true;
91af7014
HR
3873 }
3874
3875 return found_any;
3876}
3877
3878/* Updates the following BDS fields:
3879 * - exact_filename: A filename which may be used for opening a block device
3880 * which (mostly) equals the given BDS (even without any
3881 * other options; so reading and writing must return the same
3882 * results, but caching etc. may be different)
3883 * - full_open_options: Options which, when given when opening a block device
3884 * (without a filename), result in a BDS (mostly)
3885 * equalling the given one
3886 * - filename: If exact_filename is set, it is copied here. Otherwise,
3887 * full_open_options is converted to a JSON object, prefixed with
3888 * "json:" (for use through the JSON pseudo protocol) and put here.
3889 */
3890void bdrv_refresh_filename(BlockDriverState *bs)
3891{
3892 BlockDriver *drv = bs->drv;
3893 QDict *opts;
3894
3895 if (!drv) {
3896 return;
3897 }
3898
3899 /* This BDS's file name will most probably depend on its file's name, so
3900 * refresh that first */
3901 if (bs->file) {
9a4f4c31 3902 bdrv_refresh_filename(bs->file->bs);
91af7014
HR
3903 }
3904
3905 if (drv->bdrv_refresh_filename) {
3906 /* Obsolete information is of no use here, so drop the old file name
3907 * information before refreshing it */
3908 bs->exact_filename[0] = '\0';
3909 if (bs->full_open_options) {
3910 QDECREF(bs->full_open_options);
3911 bs->full_open_options = NULL;
3912 }
3913
4cdd01d3
KW
3914 opts = qdict_new();
3915 append_open_options(opts, bs);
3916 drv->bdrv_refresh_filename(bs, opts);
3917 QDECREF(opts);
91af7014
HR
3918 } else if (bs->file) {
3919 /* Try to reconstruct valid information from the underlying file */
3920 bool has_open_options;
3921
3922 bs->exact_filename[0] = '\0';
3923 if (bs->full_open_options) {
3924 QDECREF(bs->full_open_options);
3925 bs->full_open_options = NULL;
3926 }
3927
3928 opts = qdict_new();
3929 has_open_options = append_open_options(opts, bs);
3930
3931 /* If no specific options have been given for this BDS, the filename of
3932 * the underlying file should suffice for this one as well */
9a4f4c31
KW
3933 if (bs->file->bs->exact_filename[0] && !has_open_options) {
3934 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
91af7014
HR
3935 }
3936 /* Reconstructing the full options QDict is simple for most format block
3937 * drivers, as long as the full options are known for the underlying
3938 * file BDS. The full options QDict of that file BDS should somehow
3939 * contain a representation of the filename, therefore the following
3940 * suffices without querying the (exact_)filename of this BDS. */
9a4f4c31 3941 if (bs->file->bs->full_open_options) {
91af7014
HR
3942 qdict_put_obj(opts, "driver",
3943 QOBJECT(qstring_from_str(drv->format_name)));
9a4f4c31
KW
3944 QINCREF(bs->file->bs->full_open_options);
3945 qdict_put_obj(opts, "file",
3946 QOBJECT(bs->file->bs->full_open_options));
91af7014
HR
3947
3948 bs->full_open_options = opts;
3949 } else {
3950 QDECREF(opts);
3951 }
3952 } else if (!bs->full_open_options && qdict_size(bs->options)) {
3953 /* There is no underlying file BDS (at least referenced by BDS.file),
3954 * so the full options QDict should be equal to the options given
3955 * specifically for this block device when it was opened (plus the
3956 * driver specification).
3957 * Because those options don't change, there is no need to update
3958 * full_open_options when it's already set. */
3959
3960 opts = qdict_new();
3961 append_open_options(opts, bs);
3962 qdict_put_obj(opts, "driver",
3963 QOBJECT(qstring_from_str(drv->format_name)));
3964
3965 if (bs->exact_filename[0]) {
3966 /* This may not work for all block protocol drivers (some may
3967 * require this filename to be parsed), but we have to find some
3968 * default solution here, so just include it. If some block driver
3969 * does not support pure options without any filename at all or
3970 * needs some special format of the options QDict, it needs to
3971 * implement the driver-specific bdrv_refresh_filename() function.
3972 */
3973 qdict_put_obj(opts, "filename",
3974 QOBJECT(qstring_from_str(bs->exact_filename)));
3975 }
3976
3977 bs->full_open_options = opts;
3978 }
3979
3980 if (bs->exact_filename[0]) {
3981 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
3982 } else if (bs->full_open_options) {
3983 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
3984 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
3985 qstring_get_str(json));
3986 QDECREF(json);
3987 }
3988}
e06018ad
WC
3989
3990/*
3991 * Hot add/remove a BDS's child. So the user can take a child offline when
3992 * it is broken and take a new child online
3993 */
3994void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
3995 Error **errp)
3996{
3997
3998 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
3999 error_setg(errp, "The node %s does not support adding a child",
4000 bdrv_get_device_or_node_name(parent_bs));
4001 return;
4002 }
4003
4004 if (!QLIST_EMPTY(&child_bs->parents)) {
4005 error_setg(errp, "The node %s already has a parent",
4006 child_bs->node_name);
4007 return;
4008 }
4009
4010 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
4011}
4012
4013void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
4014{
4015 BdrvChild *tmp;
4016
4017 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
4018 error_setg(errp, "The node %s does not support removing a child",
4019 bdrv_get_device_or_node_name(parent_bs));
4020 return;
4021 }
4022
4023 QLIST_FOREACH(tmp, &parent_bs->children, next) {
4024 if (tmp == child) {
4025 break;
4026 }
4027 }
4028
4029 if (!tmp) {
4030 error_setg(errp, "The node %s does not have a child named %s",
4031 bdrv_get_device_or_node_name(parent_bs),
4032 bdrv_get_device_or_node_name(child->bs));
4033 return;
4034 }
4035
4036 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
4037}
This page took 1.787409 seconds and 4 git commands to generate.