i.MX: Fix FEC code for MDIO address selection
[qemu.git] / block.c
1 /*
2 * QEMU System Emulator block driver
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
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 */
24 #include "qemu/osdep.h"
25 #include "trace.h"
26 #include "block/block_int.h"
27 #include "block/blockjob.h"
28 #include "qemu/error-report.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qerror.h"
31 #include "qapi/qmp/qbool.h"
32 #include "qapi/qmp/qjson.h"
33 #include "sysemu/block-backend.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/notify.h"
36 #include "qemu/coroutine.h"
37 #include "block/qapi.h"
38 #include "qmp-commands.h"
39 #include "qemu/timer.h"
40 #include "qapi-event.h"
41 #include "qemu/cutils.h"
42 #include "qemu/id.h"
43
44 #ifdef CONFIG_BSD
45 #include <sys/ioctl.h>
46 #include <sys/queue.h>
47 #ifndef __DragonFly__
48 #include <sys/disk.h>
49 #endif
50 #endif
51
52 #ifdef _WIN32
53 #include <windows.h>
54 #endif
55
56 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
57
58 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
59 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
60
61 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
62 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
63
64 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
65 QLIST_HEAD_INITIALIZER(bdrv_drivers);
66
67 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
68 const char *reference, QDict *options, int flags,
69 BlockDriverState *parent,
70 const BdrvChildRole *child_role, Error **errp);
71
72 /* If non-zero, use only whitelisted block drivers */
73 static int use_bdrv_whitelist;
74
75 static void bdrv_close(BlockDriverState *bs);
76
77 #ifdef _WIN32
78 static 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
85 int 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
97 size_t bdrv_opt_mem_align(BlockDriverState *bs)
98 {
99 if (!bs || !bs->drv) {
100 /* page size or 4k (hdd sector size) should be on the safe side */
101 return MAX(4096, getpagesize());
102 }
103
104 return bs->bl.opt_mem_alignment;
105 }
106
107 size_t bdrv_min_mem_align(BlockDriverState *bs)
108 {
109 if (!bs || !bs->drv) {
110 /* page size or 4k (hdd sector size) should be on the safe side */
111 return MAX(4096, getpagesize());
112 }
113
114 return bs->bl.min_mem_alignment;
115 }
116
117 /* check if the path starts with "<protocol>:" */
118 int path_has_protocol(const char *path)
119 {
120 const char *p;
121
122 #ifdef _WIN32
123 if (is_windows_drive(path) ||
124 is_windows_drive_prefix(path)) {
125 return 0;
126 }
127 p = path + strcspn(path, ":/\\");
128 #else
129 p = path + strcspn(path, ":/");
130 #endif
131
132 return *p == ':';
133 }
134
135 int path_is_absolute(const char *path)
136 {
137 #ifdef _WIN32
138 /* specific case for names like: "\\.\d:" */
139 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
140 return 1;
141 }
142 return (*path == '/' || *path == '\\');
143 #else
144 return (*path == '/');
145 #endif
146 }
147
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. */
151 void path_combine(char *dest, int dest_size,
152 const char *base_path,
153 const char *filename)
154 {
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;
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
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);
189 }
190 }
191
192 void bdrv_get_full_backing_filename_from_filename(const char *backed,
193 const char *backing,
194 char *dest, size_t sz,
195 Error **errp)
196 {
197 if (backing[0] == '\0' || path_has_protocol(backing) ||
198 path_is_absolute(backing))
199 {
200 pstrcpy(dest, sz, backing);
201 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
202 error_setg(errp, "Cannot use relative backing file names for '%s'",
203 backed);
204 } else {
205 path_combine(dest, sz, backed, backing);
206 }
207 }
208
209 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
210 Error **errp)
211 {
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);
216 }
217
218 void bdrv_register(BlockDriver *bdrv)
219 {
220 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
221 }
222
223 BlockDriverState *bdrv_new_root(void)
224 {
225 return bdrv_new();
226 }
227
228 BlockDriverState *bdrv_new(void)
229 {
230 BlockDriverState *bs;
231 int i;
232
233 bs = g_new0(BlockDriverState, 1);
234 QLIST_INIT(&bs->dirty_bitmaps);
235 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
236 QLIST_INIT(&bs->op_blockers[i]);
237 }
238 notifier_with_return_list_init(&bs->before_write_notifiers);
239 bs->refcnt = 1;
240 bs->aio_context = qemu_get_aio_context();
241
242 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
243
244 return bs;
245 }
246
247 BlockDriver *bdrv_find_format(const char *format_name)
248 {
249 BlockDriver *drv1;
250 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
251 if (!strcmp(drv1->format_name, format_name)) {
252 return drv1;
253 }
254 }
255 return NULL;
256 }
257
258 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
259 {
260 static const char *whitelist_rw[] = {
261 CONFIG_BDRV_RW_WHITELIST
262 };
263 static const char *whitelist_ro[] = {
264 CONFIG_BDRV_RO_WHITELIST
265 };
266 const char **p;
267
268 if (!whitelist_rw[0] && !whitelist_ro[0]) {
269 return 1; /* no whitelist, anything goes */
270 }
271
272 for (p = whitelist_rw; *p; p++) {
273 if (!strcmp(drv->format_name, *p)) {
274 return 1;
275 }
276 }
277 if (read_only) {
278 for (p = whitelist_ro; *p; p++) {
279 if (!strcmp(drv->format_name, *p)) {
280 return 1;
281 }
282 }
283 }
284 return 0;
285 }
286
287 bool bdrv_uses_whitelist(void)
288 {
289 return use_bdrv_whitelist;
290 }
291
292 typedef struct CreateCo {
293 BlockDriver *drv;
294 char *filename;
295 QemuOpts *opts;
296 int ret;
297 Error *err;
298 } CreateCo;
299
300 static void coroutine_fn bdrv_create_co_entry(void *opaque)
301 {
302 Error *local_err = NULL;
303 int ret;
304
305 CreateCo *cco = opaque;
306 assert(cco->drv);
307
308 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
309 if (local_err) {
310 error_propagate(&cco->err, local_err);
311 }
312 cco->ret = ret;
313 }
314
315 int bdrv_create(BlockDriver *drv, const char* filename,
316 QemuOpts *opts, Error **errp)
317 {
318 int ret;
319
320 Coroutine *co;
321 CreateCo cco = {
322 .drv = drv,
323 .filename = g_strdup(filename),
324 .opts = opts,
325 .ret = NOT_DONE,
326 .err = NULL,
327 };
328
329 if (!drv->bdrv_create) {
330 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
331 ret = -ENOTSUP;
332 goto out;
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) {
342 aio_poll(qemu_get_aio_context(), true);
343 }
344 }
345
346 ret = cco.ret;
347 if (ret < 0) {
348 if (cco.err) {
349 error_propagate(errp, cco.err);
350 } else {
351 error_setg_errno(errp, -ret, "Could not create image");
352 }
353 }
354
355 out:
356 g_free(cco.filename);
357 return ret;
358 }
359
360 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
361 {
362 BlockDriver *drv;
363 Error *local_err = NULL;
364 int ret;
365
366 drv = bdrv_find_protocol(filename, true, errp);
367 if (drv == NULL) {
368 return -ENOENT;
369 }
370
371 ret = bdrv_create(drv, filename, opts, &local_err);
372 if (local_err) {
373 error_propagate(errp, local_err);
374 }
375 return ret;
376 }
377
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 */
384 int 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 */
401 int 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
412 /*
413 * Create a uniquely-named empty temporary file.
414 * Return 0 upon success, otherwise a negative errno value.
415 */
416 int get_tmp_filename(char *filename, int size)
417 {
418 #ifdef _WIN32
419 char temp_dir[MAX_PATH];
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());
426 #else
427 int fd;
428 const char *tmpdir;
429 tmpdir = getenv("TMPDIR");
430 if (!tmpdir) {
431 tmpdir = "/var/tmp";
432 }
433 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
434 return -EOVERFLOW;
435 }
436 fd = mkstemp(filename);
437 if (fd < 0) {
438 return -errno;
439 }
440 if (close(fd) != 0) {
441 unlink(filename);
442 return -errno;
443 }
444 return 0;
445 #endif
446 }
447
448 /*
449 * Detect host devices. By convention, /dev/cdrom[N] is always
450 * recognized as a host CDROM.
451 */
452 static 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
470 BlockDriver *bdrv_find_protocol(const char *filename,
471 bool allow_protocol_prefix,
472 Error **errp)
473 {
474 BlockDriver *drv1;
475 char protocol[128];
476 int len;
477 const char *p;
478
479 /* TODO Drivers without bdrv_file_open must be specified explicitly */
480
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
493 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
494 return &bdrv_file;
495 }
496
497 p = strchr(filename, ':');
498 assert(p != NULL);
499 len = p - filename;
500 if (len > sizeof(protocol) - 1)
501 len = sizeof(protocol) - 1;
502 memcpy(protocol, filename, len);
503 protocol[len] = '\0';
504 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
505 if (drv1->protocol_name &&
506 !strcmp(drv1->protocol_name, protocol)) {
507 return drv1;
508 }
509 }
510
511 error_setg(errp, "Unknown protocol '%s'", protocol);
512 return NULL;
513 }
514
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.
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)
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 */
529 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
530 const char *filename)
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
548 static int find_image_format(BlockDriverState *bs, const char *filename,
549 BlockDriver **pdrv, Error **errp)
550 {
551 BlockDriver *drv;
552 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
553 int ret = 0;
554
555 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
556 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
557 *pdrv = &bdrv_raw;
558 return ret;
559 }
560
561 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
562 if (ret < 0) {
563 error_setg_errno(errp, -ret, "Could not read image for determining its "
564 "format");
565 *pdrv = NULL;
566 return ret;
567 }
568
569 drv = bdrv_probe_all(buf, ret, filename);
570 if (!drv) {
571 error_setg(errp, "Could not determine image format: No compatible "
572 "driver found");
573 ret = -ENOENT;
574 }
575 *pdrv = drv;
576 return ret;
577 }
578
579 /**
580 * Set the current 'total_sectors' value
581 * Return 0 on success, -errno on error.
582 */
583 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
584 {
585 BlockDriver *drv = bs->drv;
586
587 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
588 if (bdrv_is_sg(bs))
589 return 0;
590
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 }
597 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
598 }
599
600 bs->total_sectors = hint;
601 return 0;
602 }
603
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 */
608 static 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
618 /**
619 * Set open flags for a given discard mode
620 *
621 * Return 0 on success, -1 if the discard mode was invalid.
622 */
623 int 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
638 /**
639 * Set open flags for a given cache mode
640 *
641 * Return 0 on success, -1 if the cache mode was invalid.
642 */
643 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
644 {
645 *flags &= ~BDRV_O_CACHE_MASK;
646
647 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
648 *writethrough = false;
649 *flags |= BDRV_O_NOCACHE;
650 } else if (!strcmp(mode, "directsync")) {
651 *writethrough = true;
652 *flags |= BDRV_O_NOCACHE;
653 } else if (!strcmp(mode, "writeback")) {
654 *writethrough = false;
655 } else if (!strcmp(mode, "unsafe")) {
656 *writethrough = false;
657 *flags |= BDRV_O_NO_FLUSH;
658 } else if (!strcmp(mode, "writethrough")) {
659 *writethrough = true;
660 } else {
661 return -1;
662 }
663
664 return 0;
665 }
666
667 /*
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)
671 */
672 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
673 int parent_flags, QDict *parent_options)
674 {
675 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
676
677 /* For temporary files, unconditional cache=unsafe is fine */
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");
680 }
681
682 /*
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
685 */
686 static void bdrv_inherited_options(int *child_flags, QDict *child_options,
687 int parent_flags, QDict *parent_options)
688 {
689 int flags = parent_flags;
690
691 /* Enable protocol handling, disable format probing for bs->file */
692 flags |= BDRV_O_PROTOCOL;
693
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
699 /* Our block drivers take care to send flushes and respect unmap policy,
700 * so we can default to enable both on lower layers regardless of the
701 * corresponding parent options. */
702 flags |= BDRV_O_UNMAP;
703
704 /* Clear flags that only apply to the top layer */
705 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
706 BDRV_O_NO_IO);
707
708 *child_flags = flags;
709 }
710
711 const BdrvChildRole child_file = {
712 .inherit_options = bdrv_inherited_options,
713 };
714
715 /*
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
719 */
720 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
721 int parent_flags, QDict *parent_options)
722 {
723 child_file.inherit_options(child_flags, child_options,
724 parent_flags, parent_options);
725
726 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
727 }
728
729 const BdrvChildRole child_format = {
730 .inherit_options = bdrv_inherited_fmt_options,
731 };
732
733 /*
734 * Returns the options and flags that bs->backing should get, based on the
735 * given options and flags for the parent BDS
736 */
737 static void bdrv_backing_options(int *child_flags, QDict *child_options,
738 int parent_flags, QDict *parent_options)
739 {
740 int flags = parent_flags;
741
742 /* The cache mode is inherited unmodified for backing files; except WCE,
743 * which is only applied on the top level (BlockBackend) */
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
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 */
751 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
752
753 *child_flags = flags;
754 }
755
756 static const BdrvChildRole child_backing = {
757 .inherit_options = bdrv_backing_options,
758 };
759
760 static int bdrv_open_flags(BlockDriverState *bs, int flags)
761 {
762 int open_flags = flags;
763
764 /*
765 * Clear flags that are internal to the block layer before opening the
766 * image.
767 */
768 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
769
770 /*
771 * Snapshots should be writable.
772 */
773 if (flags & BDRV_O_TEMPORARY) {
774 open_flags |= BDRV_O_RDWR;
775 }
776
777 return open_flags;
778 }
779
780 static void update_flags_from_options(int *flags, QemuOpts *opts)
781 {
782 *flags &= ~BDRV_O_CACHE_MASK;
783
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
795 static void update_options_from_flags(QDict *options, int flags)
796 {
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
807 static void bdrv_assign_node_name(BlockDriverState *bs,
808 const char *node_name,
809 Error **errp)
810 {
811 char *gen_node_name = NULL;
812
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 */
820 error_setg(errp, "Invalid node name");
821 return;
822 }
823
824 /* takes care of avoiding namespaces collisions */
825 if (blk_by_name(node_name)) {
826 error_setg(errp, "node-name=%s is conflicting with a device id",
827 node_name);
828 goto out;
829 }
830
831 /* takes care of avoiding duplicates node names */
832 if (bdrv_find_node(node_name)) {
833 error_setg(errp, "Duplicate node name");
834 goto out;
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);
840 out:
841 g_free(gen_node_name);
842 }
843
844 static 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 },
853 {
854 .name = "driver",
855 .type = QEMU_OPT_STRING,
856 .help = "Block driver to use for the node",
857 },
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 },
868 { /* end of list */ }
869 },
870 };
871
872 /*
873 * Common part for opening disk images and files
874 *
875 * Removes all processed options from *options.
876 */
877 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
878 QDict *options, Error **errp)
879 {
880 int ret, open_flags;
881 const char *filename;
882 const char *driver_name = NULL;
883 const char *node_name = NULL;
884 QemuOpts *opts;
885 BlockDriver *drv;
886 Error *local_err = NULL;
887
888 assert(bs->file == NULL);
889 assert(options != NULL && bs->options != options);
890
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
903 if (file != NULL) {
904 filename = file->bs->filename;
905 } else {
906 filename = qdict_get_try_str(options, "filename");
907 }
908
909 if (drv->bdrv_needs_filename && !filename) {
910 error_setg(errp, "The '%s' block driver requires a file name",
911 drv->format_name);
912 ret = -EINVAL;
913 goto fail_opts;
914 }
915
916 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
917 drv->format_name);
918
919 node_name = qemu_opt_get(opts, "node-name");
920 bdrv_assign_node_name(bs, node_name, &local_err);
921 if (local_err) {
922 error_propagate(errp, local_err);
923 ret = -EINVAL;
924 goto fail_opts;
925 }
926
927 bs->request_alignment = 512;
928 bs->zero_beyond_eof = true;
929 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
930
931 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
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);
937 ret = -ENOTSUP;
938 goto fail_opts;
939 }
940
941 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
942 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
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");
947 ret = -EINVAL;
948 goto fail_opts;
949 }
950 }
951
952 if (filename != NULL) {
953 pstrcpy(bs->filename, sizeof(bs->filename), filename);
954 } else {
955 bs->filename[0] = '\0';
956 }
957 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
958
959 bs->drv = drv;
960 bs->opaque = g_malloc0(drv->instance_size);
961
962 /* Apply cache mode options */
963 update_flags_from_options(&bs->open_flags, opts);
964
965 /* Open the image, either directly or using a protocol */
966 open_flags = bdrv_open_flags(bs, bs->open_flags);
967 if (drv->bdrv_file_open) {
968 assert(file == NULL);
969 assert(!drv->bdrv_needs_filename || filename != NULL);
970 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
971 } else {
972 if (file == NULL) {
973 error_setg(errp, "Can't use '%s' as a block driver for the "
974 "protocol level", drv->format_name);
975 ret = -EINVAL;
976 goto free_and_fail;
977 }
978 bs->file = file;
979 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
980 }
981
982 if (ret < 0) {
983 if (local_err) {
984 error_propagate(errp, local_err);
985 } else if (bs->filename[0]) {
986 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
987 } else {
988 error_setg_errno(errp, -ret, "Could not open image");
989 }
990 goto free_and_fail;
991 }
992
993 ret = refresh_total_sectors(bs, bs->total_sectors);
994 if (ret < 0) {
995 error_setg_errno(errp, -ret, "Could not refresh total sector count");
996 goto free_and_fail;
997 }
998
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
1006 assert(bdrv_opt_mem_align(bs) != 0);
1007 assert(bdrv_min_mem_align(bs) != 0);
1008 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
1009
1010 qemu_opts_del(opts);
1011 return 0;
1012
1013 free_and_fail:
1014 bs->file = NULL;
1015 g_free(bs->opaque);
1016 bs->opaque = NULL;
1017 bs->drv = NULL;
1018 fail_opts:
1019 qemu_opts_del(opts);
1020 return ret;
1021 }
1022
1023 static 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
1050 static 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
1074 /*
1075 * Fills in default options for opening images and converts the legacy
1076 * filename/flags pair to option QDict entries.
1077 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1078 * block driver has been specified explicitly.
1079 */
1080 static int bdrv_fill_options(QDict **options, const char *filename,
1081 int *flags, Error **errp)
1082 {
1083 const char *drvname;
1084 bool protocol = *flags & BDRV_O_PROTOCOL;
1085 bool parse_filename = false;
1086 BlockDriver *drv = NULL;
1087 Error *local_err = NULL;
1088
1089 drvname = qdict_get_try_str(*options, "driver");
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;
1099 }
1100
1101 if (protocol) {
1102 *flags |= BDRV_O_PROTOCOL;
1103 } else {
1104 *flags &= ~BDRV_O_PROTOCOL;
1105 }
1106
1107 /* Translate cache options from flags into options */
1108 update_options_from_flags(*options, *flags);
1109
1110 /* Fetch the file name from the options QDict if necessary */
1111 if (protocol && filename) {
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 }
1120 }
1121
1122 /* Find the right block driver */
1123 filename = qdict_get_try_str(*options, "filename");
1124
1125 if (!drvname && protocol) {
1126 if (filename) {
1127 drv = bdrv_find_protocol(filename, parse_filename, errp);
1128 if (!drv) {
1129 return -EINVAL;
1130 }
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;
1137 }
1138 }
1139
1140 assert(drv || !protocol);
1141
1142 /* Driver-specific filename parsing */
1143 if (drv && drv->bdrv_parse_filename && parse_filename) {
1144 drv->bdrv_parse_filename(filename, *options, &local_err);
1145 if (local_err) {
1146 error_propagate(errp, local_err);
1147 return -EINVAL;
1148 }
1149
1150 if (!drv->bdrv_needs_filename) {
1151 qdict_del(*options, "filename");
1152 }
1153 }
1154
1155 return 0;
1156 }
1157
1158 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
1159 const char *child_name,
1160 const BdrvChildRole *child_role)
1161 {
1162 BdrvChild *child = g_new(BdrvChild, 1);
1163 *child = (BdrvChild) {
1164 .bs = child_bs,
1165 .name = g_strdup(child_name),
1166 .role = child_role,
1167 };
1168
1169 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
1170
1171 return child;
1172 }
1173
1174 BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1175 BlockDriverState *child_bs,
1176 const char *child_name,
1177 const BdrvChildRole *child_role)
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
1184 static void bdrv_detach_child(BdrvChild *child)
1185 {
1186 if (child->next.le_prev) {
1187 QLIST_REMOVE(child, next);
1188 child->next.le_prev = NULL;
1189 }
1190 QLIST_REMOVE(child, next_parent);
1191 g_free(child->name);
1192 g_free(child);
1193 }
1194
1195 void bdrv_root_unref_child(BdrvChild *child)
1196 {
1197 BlockDriverState *child_bs;
1198
1199 child_bs = child->bs;
1200 bdrv_detach_child(child);
1201 bdrv_unref(child_bs);
1202 }
1203
1204 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1205 {
1206 if (child == NULL) {
1207 return;
1208 }
1209
1210 if (child->bs->inherits_from == parent) {
1211 child->bs->inherits_from = NULL;
1212 }
1213
1214 bdrv_root_unref_child(child);
1215 }
1216
1217
1218 static 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
1228 static 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
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 */
1242 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1243 {
1244 if (backing_hd) {
1245 bdrv_ref(backing_hd);
1246 }
1247
1248 if (bs->backing) {
1249 assert(bs->backing_blocker);
1250 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
1251 bdrv_unref_child(bs, bs->backing);
1252 } else if (backing_hd) {
1253 error_setg(&bs->backing_blocker,
1254 "node is used as backing hd of '%s'",
1255 bdrv_get_device_or_node_name(bs));
1256 }
1257
1258 if (!backing_hd) {
1259 error_free(bs->backing_blocker);
1260 bs->backing_blocker = NULL;
1261 bs->backing = NULL;
1262 goto out;
1263 }
1264 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing);
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 : "");
1269
1270 bdrv_op_block_all(backing_hd, bs->backing_blocker);
1271 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1272 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1273 bs->backing_blocker);
1274 out:
1275 bdrv_refresh_limits(bs, NULL);
1276 }
1277
1278 /*
1279 * Opens the backing file for a BlockDriverState if not yet open
1280 *
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()?
1287 */
1288 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
1289 const char *bdref_key, Error **errp)
1290 {
1291 char *backing_filename = g_malloc0(PATH_MAX);
1292 char *bdref_key_dot;
1293 const char *reference = NULL;
1294 int ret = 0;
1295 BlockDriverState *backing_hd;
1296 QDict *options;
1297 QDict *tmp_parent_options = NULL;
1298 Error *local_err = NULL;
1299
1300 if (bs->backing != NULL) {
1301 goto free_exit;
1302 }
1303
1304 /* NULL means an empty set of options */
1305 if (parent_options == NULL) {
1306 tmp_parent_options = qdict_new();
1307 parent_options = tmp_parent_options;
1308 }
1309
1310 bs->open_flags &= ~BDRV_O_NO_BACKING;
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")) {
1318 backing_filename[0] = '\0';
1319 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1320 QDECREF(options);
1321 goto free_exit;
1322 } else {
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 }
1331 }
1332
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
1340 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1341 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1342 }
1343
1344 backing_hd = NULL;
1345 ret = bdrv_open_inherit(&backing_hd,
1346 *backing_filename ? backing_filename : NULL,
1347 reference, options, 0, bs, &child_backing,
1348 errp);
1349 if (ret < 0) {
1350 bs->open_flags |= BDRV_O_NO_BACKING;
1351 error_prepend(errp, "Could not open backing file: ");
1352 goto free_exit;
1353 }
1354
1355 /* Hook up the backing file link; drop our reference, bs owns the
1356 * backing_hd reference now */
1357 bdrv_set_backing_hd(bs, backing_hd);
1358 bdrv_unref(backing_hd);
1359
1360 qdict_del(parent_options, bdref_key);
1361
1362 free_exit:
1363 g_free(backing_filename);
1364 QDECREF(tmp_parent_options);
1365 return ret;
1366 }
1367
1368 /*
1369 * Opens a disk image whose options are given as BlockdevRef in another block
1370 * device's options.
1371 *
1372 * If allow_none is true, no image will be opened if filename is false and no
1373 * BlockdevRef is given. NULL will be returned, but errp remains unset.
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 */
1382 BdrvChild *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)
1387 {
1388 BdrvChild *c = NULL;
1389 BlockDriverState *bs;
1390 QDict *image_options;
1391 int ret;
1392 char *bdref_key_dot;
1393 const char *reference;
1394
1395 assert(child_role != NULL);
1396
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)) {
1403 if (!allow_none) {
1404 error_setg(errp, "A block device must be specified for \"%s\"",
1405 bdref_key);
1406 }
1407 QDECREF(image_options);
1408 goto done;
1409 }
1410
1411 bs = NULL;
1412 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1413 parent, child_role, errp);
1414 if (ret < 0) {
1415 goto done;
1416 }
1417
1418 c = bdrv_attach_child(parent, bs, bdref_key, child_role);
1419
1420 done:
1421 qdict_del(options, bdref_key);
1422 return c;
1423 }
1424
1425 static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags,
1426 QDict *snapshot_options, Error **errp)
1427 {
1428 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1429 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1430 int64_t total_size;
1431 QemuOpts *opts = NULL;
1432 BlockDriverState *bs_snapshot;
1433 Error *local_err = NULL;
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 */
1440 total_size = bdrv_getlength(bs);
1441 if (total_size < 0) {
1442 ret = total_size;
1443 error_setg_errno(errp, -total_size, "Could not get image size");
1444 goto out;
1445 }
1446
1447 /* Create the temporary image */
1448 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1449 if (ret < 0) {
1450 error_setg_errno(errp, -ret, "Could not get temporary filename");
1451 goto out;
1452 }
1453
1454 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1455 &error_abort);
1456 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1457 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
1458 qemu_opts_del(opts);
1459 if (ret < 0) {
1460 error_prepend(errp, "Could not create temporary overlay '%s': ",
1461 tmp_filename);
1462 goto out;
1463 }
1464
1465 /* Prepare options QDict for the temporary file */
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));
1470 qdict_put(snapshot_options, "driver",
1471 qstring_from_str("qcow2"));
1472
1473 bs_snapshot = bdrv_new();
1474
1475 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1476 flags, &local_err);
1477 snapshot_options = NULL;
1478 if (ret < 0) {
1479 error_propagate(errp, local_err);
1480 goto out;
1481 }
1482
1483 bdrv_append(bs_snapshot, bs);
1484
1485 out:
1486 QDECREF(snapshot_options);
1487 g_free(tmp_filename);
1488 return ret;
1489 }
1490
1491 /*
1492 * Opens a disk image (raw, qcow2, vmdk, ...)
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.
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.
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).
1505 */
1506 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1507 const char *reference, QDict *options, int flags,
1508 BlockDriverState *parent,
1509 const BdrvChildRole *child_role, Error **errp)
1510 {
1511 int ret;
1512 BdrvChild *file = NULL;
1513 BlockDriverState *bs;
1514 BlockDriver *drv = NULL;
1515 const char *drvname;
1516 const char *backing;
1517 Error *local_err = NULL;
1518 QDict *snapshot_options = NULL;
1519 int snapshot_flags = 0;
1520
1521 assert(pbs);
1522 assert(!child_role || !flags);
1523 assert(!child_role == !parent);
1524
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 }
1545
1546 bdrv_ref(bs);
1547 *pbs = bs;
1548 return 0;
1549 }
1550
1551 if (*pbs) {
1552 bs = *pbs;
1553 } else {
1554 bs = bdrv_new();
1555 }
1556
1557 /* NULL means an empty set of options */
1558 if (options == NULL) {
1559 options = qdict_new();
1560 }
1561
1562 /* json: syntax counts as explicit options, as if in the QDict */
1563 parse_json_protocol(options, &filename, &local_err);
1564 if (local_err) {
1565 ret = -EINVAL;
1566 goto fail;
1567 }
1568
1569 bs->explicit_options = qdict_clone_shallow(options);
1570
1571 if (child_role) {
1572 bs->inherits_from = parent;
1573 child_role->inherit_options(&flags, options,
1574 parent->open_flags, parent->options);
1575 }
1576
1577 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
1578 if (local_err) {
1579 goto fail;
1580 }
1581
1582 bs->open_flags = flags;
1583 bs->options = options;
1584 options = qdict_clone_shallow(options);
1585
1586 /* Find the right image format driver */
1587 drvname = qdict_get_try_str(options, "driver");
1588 if (drvname) {
1589 drv = bdrv_find_format(drvname);
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));
1598
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
1605 /* Open image file without format layer */
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) {
1611 snapshot_options = qdict_new();
1612 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
1613 flags, options);
1614 bdrv_backing_options(&flags, options, flags, options);
1615 }
1616
1617 bs->open_flags = flags;
1618
1619 file = bdrv_open_child(filename, options, "file", bs,
1620 &child_file, true, &local_err);
1621 if (local_err) {
1622 ret = -EINVAL;
1623 goto fail;
1624 }
1625 }
1626
1627 /* Image format probing */
1628 bs->probed = !drv;
1629 if (!drv && file) {
1630 ret = find_image_format(file->bs, filename, &drv, &local_err);
1631 if (ret < 0) {
1632 goto fail;
1633 }
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));
1647 } else if (!drv) {
1648 error_setg(errp, "Must specify either driver or file");
1649 ret = -EINVAL;
1650 goto fail;
1651 }
1652
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
1659 /* Open the image */
1660 ret = bdrv_open_common(bs, file, options, &local_err);
1661 if (ret < 0) {
1662 goto fail;
1663 }
1664
1665 if (file && (bs->file != file)) {
1666 bdrv_unref_child(bs, file);
1667 file = NULL;
1668 }
1669
1670 /* If there is a backing file, use it */
1671 if ((flags & BDRV_O_NO_BACKING) == 0) {
1672 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
1673 if (ret < 0) {
1674 goto close_and_fail;
1675 }
1676 }
1677
1678 bdrv_refresh_filename(bs);
1679
1680 /* Check if any unknown options were used */
1681 if (options && (qdict_size(options) != 0)) {
1682 const QDictEntry *entry = qdict_first(options);
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 {
1687 error_setg(errp,
1688 "Block format '%s' does not support the option '%s'",
1689 drv->format_name, entry->key);
1690 }
1691
1692 ret = -EINVAL;
1693 goto close_and_fail;
1694 }
1695
1696 if (!bdrv_key_required(bs)) {
1697 bdrv_parent_cb_change_media(bs, true);
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;
1705 }
1706
1707 QDECREF(options);
1708 *pbs = bs;
1709
1710 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1711 * temporary snapshot afterwards. */
1712 if (snapshot_flags) {
1713 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, snapshot_options,
1714 &local_err);
1715 snapshot_options = NULL;
1716 if (local_err) {
1717 goto close_and_fail;
1718 }
1719 }
1720
1721 return 0;
1722
1723 fail:
1724 if (file != NULL) {
1725 bdrv_unref_child(bs, file);
1726 }
1727 QDECREF(snapshot_options);
1728 QDECREF(bs->explicit_options);
1729 QDECREF(bs->options);
1730 QDECREF(options);
1731 bs->options = NULL;
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 }
1738 if (local_err) {
1739 error_propagate(errp, local_err);
1740 }
1741 return ret;
1742
1743 close_and_fail:
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 }
1750 QDECREF(snapshot_options);
1751 QDECREF(options);
1752 if (local_err) {
1753 error_propagate(errp, local_err);
1754 }
1755 return ret;
1756 }
1757
1758 int bdrv_open(BlockDriverState **pbs, const char *filename,
1759 const char *reference, QDict *options, int flags, Error **errp)
1760 {
1761 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1762 NULL, errp);
1763 }
1764
1765 typedef 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 *
1783 * options contains the changed options for the associated bs
1784 * (the BlockReopenQueue takes ownership)
1785 *
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 */
1792 static 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)
1799 {
1800 assert(bs != NULL);
1801
1802 BlockReopenQueueEntry *bs_entry;
1803 BdrvChild *child;
1804 QDict *old_options, *explicit_options;
1805
1806 if (bs_queue == NULL) {
1807 bs_queue = g_new0(BlockReopenQueue, 1);
1808 QSIMPLEQ_INIT(bs_queue);
1809 }
1810
1811 if (!options) {
1812 options = qdict_new();
1813 }
1814
1815 /*
1816 * Precedence of options:
1817 * 1. Explicitly passed in options (highest)
1818 * 2. Set in flags (only for top level)
1819 * 3. Retained from explicitly set options of bs
1820 * 4. Inherited from parent node
1821 * 5. Retained from effective options of bs
1822 */
1823
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
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
1841 /* Inherit from parent node */
1842 if (parent_options) {
1843 assert(!flags);
1844 role->inherit_options(&flags, options, parent_flags, parent_options);
1845 }
1846
1847 /* Old values are used for options that aren't set yet */
1848 old_options = qdict_clone_shallow(bs->options);
1849 bdrv_join_options(bs, options, old_options);
1850 QDECREF(old_options);
1851
1852 /* bdrv_open() masks this flag out */
1853 flags &= ~BDRV_O_PROTOCOL;
1854
1855 QLIST_FOREACH(child, &bs->children, next) {
1856 QDict *new_child_options;
1857 char *child_key_dot;
1858
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. */
1862 if (child->bs->inherits_from != bs) {
1863 continue;
1864 }
1865
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
1870 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
1871 child->role, options, flags);
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;
1878 bs_entry->state.options = options;
1879 bs_entry->state.explicit_options = explicit_options;
1880 bs_entry->state.flags = flags;
1881
1882 return bs_queue;
1883 }
1884
1885 BlockReopenQueue *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
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 */
1908 int 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
1935 cleanup:
1936 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1937 if (ret && bs_entry->prepared) {
1938 bdrv_reopen_abort(&bs_entry->state);
1939 } else if (ret) {
1940 QDECREF(bs_entry->state.explicit_options);
1941 }
1942 QDECREF(bs_entry->state.options);
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. */
1951 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1952 {
1953 int ret = -1;
1954 Error *local_err = NULL;
1955 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
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 */
1982 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1983 Error **errp)
1984 {
1985 int ret = -1;
1986 Error *local_err = NULL;
1987 BlockDriver *drv;
1988 QemuOpts *opts;
1989 const char *value;
1990
1991 assert(reopen_state != NULL);
1992 assert(reopen_state->bs->drv != NULL);
1993 drv = reopen_state->bs->drv;
1994
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
2004 update_flags_from_options(&reopen_state->flags, opts);
2005
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
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) {
2022 error_setg(errp, "Node '%s' is read only",
2023 bdrv_get_device_or_node_name(reopen_state->bs));
2024 goto error;
2025 }
2026
2027
2028 ret = bdrv_flush(reopen_state->bs);
2029 if (ret) {
2030 error_setg_errno(errp, -ret, "Error flushing drive");
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 {
2040 error_setg(errp, "failed while preparing to reopen image '%s'",
2041 reopen_state->bs->filename);
2042 }
2043 goto error;
2044 }
2045 } else {
2046 /* It is currently mandatory to have a bdrv_reopen_prepare()
2047 * handler for each supported drv. */
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));
2051 ret = -1;
2052 goto error;
2053 }
2054
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
2075 ret = 0;
2076
2077 error:
2078 qemu_opts_del(opts);
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 */
2087 void 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 */
2101 QDECREF(reopen_state->bs->explicit_options);
2102
2103 reopen_state->bs->explicit_options = reopen_state->explicit_options;
2104 reopen_state->bs->open_flags = reopen_state->flags;
2105 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
2106
2107 bdrv_refresh_limits(reopen_state->bs, NULL);
2108 }
2109
2110 /*
2111 * Abort the reopen, and delete and free the staged changes in
2112 * reopen_state
2113 */
2114 void 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 }
2125
2126 QDECREF(reopen_state->explicit_options);
2127 }
2128
2129
2130 static void bdrv_close(BlockDriverState *bs)
2131 {
2132 BdrvAioNotifier *ban, *ban_next;
2133
2134 assert(!bs->job);
2135
2136 bdrv_drained_begin(bs); /* complete I/O */
2137 bdrv_flush(bs);
2138 bdrv_drain(bs); /* in case flush left pending I/O */
2139
2140 bdrv_release_named_dirty_bitmaps(bs);
2141 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2142
2143 bdrv_parent_cb_change_media(bs, false);
2144
2145 if (bs->drv) {
2146 BdrvChild *child, *next;
2147
2148 bs->drv->bdrv_close(bs);
2149 bs->drv = NULL;
2150
2151 bdrv_set_backing_hd(bs, NULL);
2152
2153 if (bs->file != NULL) {
2154 bdrv_unref_child(bs, bs->file);
2155 bs->file = NULL;
2156 }
2157
2158 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
2159 /* TODO Remove bdrv_unref() from drivers' close function and use
2160 * bdrv_unref_child() here */
2161 if (child->bs->inherits_from == bs) {
2162 child->bs->inherits_from = NULL;
2163 }
2164 bdrv_detach_child(child);
2165 }
2166
2167 g_free(bs->opaque);
2168 bs->opaque = NULL;
2169 bs->copy_on_read = 0;
2170 bs->backing_file[0] = '\0';
2171 bs->backing_format[0] = '\0';
2172 bs->total_sectors = 0;
2173 bs->encrypted = 0;
2174 bs->valid_key = 0;
2175 bs->sg = 0;
2176 bs->zero_beyond_eof = false;
2177 QDECREF(bs->options);
2178 QDECREF(bs->explicit_options);
2179 bs->options = NULL;
2180 QDECREF(bs->full_open_options);
2181 bs->full_open_options = NULL;
2182 }
2183
2184 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
2185 g_free(ban);
2186 }
2187 QLIST_INIT(&bs->aio_notifiers);
2188 bdrv_drained_end(bs);
2189 }
2190
2191 void bdrv_close_all(void)
2192 {
2193 BlockDriverState *bs;
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();
2199
2200 blk_remove_all_bs();
2201 blockdev_close_all_bdrv_states();
2202
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);
2221 }
2222 }
2223
2224 static void change_parent_backing_link(BlockDriverState *from,
2225 BlockDriverState *to)
2226 {
2227 BdrvChild *c, *next;
2228
2229 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2230 assert(c->role != &child_backing);
2231 c->bs = to;
2232 QLIST_REMOVE(c, next_parent);
2233 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2234 bdrv_ref(to);
2235 bdrv_unref(from);
2236 }
2237 }
2238
2239 /*
2240 * Add new bs contents at the top of an image chain while the chain is
2241 * live, while keeping required fields on the top layer.
2242 *
2243 * This will modify the BlockDriverState fields, and swap contents
2244 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2245 *
2246 * bs_new must not be attached to a BlockBackend.
2247 *
2248 * This function does not create any image files.
2249 *
2250 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2251 * that's what the callers commonly need. bs_new will be referenced by the old
2252 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2253 * reference of its own, it must call bdrv_ref().
2254 */
2255 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2256 {
2257 assert(!bdrv_requests_pending(bs_top));
2258 assert(!bdrv_requests_pending(bs_new));
2259
2260 bdrv_ref(bs_top);
2261
2262 change_parent_backing_link(bs_top, bs_new);
2263 bdrv_set_backing_hd(bs_new, bs_top);
2264 bdrv_unref(bs_top);
2265
2266 /* bs_new is now referenced by its new parents, we don't need the
2267 * additional reference any more. */
2268 bdrv_unref(bs_new);
2269 }
2270
2271 void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2272 {
2273 assert(!bdrv_requests_pending(old));
2274 assert(!bdrv_requests_pending(new));
2275
2276 bdrv_ref(old);
2277
2278 change_parent_backing_link(old, new);
2279
2280 /* Change backing files if a previously independent node is added to the
2281 * chain. For active commit, we replace top by its own (indirect) backing
2282 * file and don't do anything here so we don't build a loop. */
2283 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2284 bdrv_set_backing_hd(new, backing_bs(old));
2285 bdrv_set_backing_hd(old, NULL);
2286 }
2287
2288 bdrv_unref(old);
2289 }
2290
2291 static void bdrv_delete(BlockDriverState *bs)
2292 {
2293 assert(!bs->job);
2294 assert(bdrv_op_blocker_is_empty(bs));
2295 assert(!bs->refcnt);
2296
2297 bdrv_close(bs);
2298
2299 /* remove from list, if necessary */
2300 if (bs->node_name[0] != '\0') {
2301 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
2302 }
2303 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
2304
2305 g_free(bs);
2306 }
2307
2308 /*
2309 * Run consistency checks on an image
2310 *
2311 * Returns 0 if the check could be completed (it doesn't mean that the image is
2312 * free of errors) or -errno when an internal error occurred. The results of the
2313 * check are stored in res.
2314 */
2315 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2316 {
2317 if (bs->drv == NULL) {
2318 return -ENOMEDIUM;
2319 }
2320 if (bs->drv->bdrv_check == NULL) {
2321 return -ENOTSUP;
2322 }
2323
2324 memset(res, 0, sizeof(*res));
2325 return bs->drv->bdrv_check(bs, res, fix);
2326 }
2327
2328 #define COMMIT_BUF_SECTORS 2048
2329
2330 /* commit COW file into the raw image */
2331 int bdrv_commit(BlockDriverState *bs)
2332 {
2333 BlockDriver *drv = bs->drv;
2334 int64_t sector, total_sectors, length, backing_length;
2335 int n, ro, open_flags;
2336 int ret = 0;
2337 uint8_t *buf = NULL;
2338
2339 if (!drv)
2340 return -ENOMEDIUM;
2341
2342 if (!bs->backing) {
2343 return -ENOTSUP;
2344 }
2345
2346 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2347 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2348 return -EBUSY;
2349 }
2350
2351 ro = bs->backing->bs->read_only;
2352 open_flags = bs->backing->bs->open_flags;
2353
2354 if (ro) {
2355 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
2356 return -EACCES;
2357 }
2358 }
2359
2360 length = bdrv_getlength(bs);
2361 if (length < 0) {
2362 ret = length;
2363 goto ro_cleanup;
2364 }
2365
2366 backing_length = bdrv_getlength(bs->backing->bs);
2367 if (backing_length < 0) {
2368 ret = backing_length;
2369 goto ro_cleanup;
2370 }
2371
2372 /* If our top snapshot is larger than the backing file image,
2373 * grow the backing file image if possible. If not possible,
2374 * we must return an error */
2375 if (length > backing_length) {
2376 ret = bdrv_truncate(bs->backing->bs, length);
2377 if (ret < 0) {
2378 goto ro_cleanup;
2379 }
2380 }
2381
2382 total_sectors = length >> BDRV_SECTOR_BITS;
2383
2384 /* qemu_try_blockalign() for bs will choose an alignment that works for
2385 * bs->backing->bs as well, so no need to compare the alignment manually. */
2386 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2387 if (buf == NULL) {
2388 ret = -ENOMEM;
2389 goto ro_cleanup;
2390 }
2391
2392 for (sector = 0; sector < total_sectors; sector += n) {
2393 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2394 if (ret < 0) {
2395 goto ro_cleanup;
2396 }
2397 if (ret) {
2398 ret = bdrv_read(bs, sector, buf, n);
2399 if (ret < 0) {
2400 goto ro_cleanup;
2401 }
2402
2403 ret = bdrv_write(bs->backing->bs, sector, buf, n);
2404 if (ret < 0) {
2405 goto ro_cleanup;
2406 }
2407 }
2408 }
2409
2410 if (drv->bdrv_make_empty) {
2411 ret = drv->bdrv_make_empty(bs);
2412 if (ret < 0) {
2413 goto ro_cleanup;
2414 }
2415 bdrv_flush(bs);
2416 }
2417
2418 /*
2419 * Make sure all data we wrote to the backing device is actually
2420 * stable on disk.
2421 */
2422 if (bs->backing) {
2423 bdrv_flush(bs->backing->bs);
2424 }
2425
2426 ret = 0;
2427 ro_cleanup:
2428 qemu_vfree(buf);
2429
2430 if (ro) {
2431 /* ignoring error return here */
2432 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
2433 }
2434
2435 return ret;
2436 }
2437
2438 /*
2439 * Return values:
2440 * 0 - success
2441 * -EINVAL - backing format specified, but no file
2442 * -ENOSPC - can't update the backing file because no space is left in the
2443 * image file header
2444 * -ENOTSUP - format driver doesn't support changing the backing file
2445 */
2446 int bdrv_change_backing_file(BlockDriverState *bs,
2447 const char *backing_file, const char *backing_fmt)
2448 {
2449 BlockDriver *drv = bs->drv;
2450 int ret;
2451
2452 /* Backing file format doesn't make sense without a backing file */
2453 if (backing_fmt && !backing_file) {
2454 return -EINVAL;
2455 }
2456
2457 if (drv->bdrv_change_backing_file != NULL) {
2458 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2459 } else {
2460 ret = -ENOTSUP;
2461 }
2462
2463 if (ret == 0) {
2464 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2465 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2466 }
2467 return ret;
2468 }
2469
2470 /*
2471 * Finds the image layer in the chain that has 'bs' as its backing file.
2472 *
2473 * active is the current topmost image.
2474 *
2475 * Returns NULL if bs is not found in active's image chain,
2476 * or if active == bs.
2477 *
2478 * Returns the bottommost base image if bs == NULL.
2479 */
2480 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2481 BlockDriverState *bs)
2482 {
2483 while (active && bs != backing_bs(active)) {
2484 active = backing_bs(active);
2485 }
2486
2487 return active;
2488 }
2489
2490 /* Given a BDS, searches for the base layer. */
2491 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2492 {
2493 return bdrv_find_overlay(bs, NULL);
2494 }
2495
2496 /*
2497 * Drops images above 'base' up to and including 'top', and sets the image
2498 * above 'top' to have base as its backing file.
2499 *
2500 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2501 * information in 'bs' can be properly updated.
2502 *
2503 * E.g., this will convert the following chain:
2504 * bottom <- base <- intermediate <- top <- active
2505 *
2506 * to
2507 *
2508 * bottom <- base <- active
2509 *
2510 * It is allowed for bottom==base, in which case it converts:
2511 *
2512 * base <- intermediate <- top <- active
2513 *
2514 * to
2515 *
2516 * base <- active
2517 *
2518 * If backing_file_str is non-NULL, it will be used when modifying top's
2519 * overlay image metadata.
2520 *
2521 * Error conditions:
2522 * if active == top, that is considered an error
2523 *
2524 */
2525 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2526 BlockDriverState *base, const char *backing_file_str)
2527 {
2528 BlockDriverState *new_top_bs = NULL;
2529 int ret = -EIO;
2530
2531 if (!top->drv || !base->drv) {
2532 goto exit;
2533 }
2534
2535 new_top_bs = bdrv_find_overlay(active, top);
2536
2537 if (new_top_bs == NULL) {
2538 /* we could not find the image above 'top', this is an error */
2539 goto exit;
2540 }
2541
2542 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2543 * to do, no intermediate images */
2544 if (backing_bs(new_top_bs) == base) {
2545 ret = 0;
2546 goto exit;
2547 }
2548
2549 /* Make sure that base is in the backing chain of top */
2550 if (!bdrv_chain_contains(top, base)) {
2551 goto exit;
2552 }
2553
2554 /* success - we can delete the intermediate states, and link top->base */
2555 backing_file_str = backing_file_str ? backing_file_str : base->filename;
2556 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2557 base->drv ? base->drv->format_name : "");
2558 if (ret) {
2559 goto exit;
2560 }
2561 bdrv_set_backing_hd(new_top_bs, base);
2562
2563 ret = 0;
2564 exit:
2565 return ret;
2566 }
2567
2568 /**
2569 * Truncate file to 'offset' bytes (needed only for file protocols)
2570 */
2571 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2572 {
2573 BlockDriver *drv = bs->drv;
2574 int ret;
2575 if (!drv)
2576 return -ENOMEDIUM;
2577 if (!drv->bdrv_truncate)
2578 return -ENOTSUP;
2579 if (bs->read_only)
2580 return -EACCES;
2581
2582 ret = drv->bdrv_truncate(bs, offset);
2583 if (ret == 0) {
2584 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2585 bdrv_dirty_bitmap_truncate(bs);
2586 bdrv_parent_cb_resize(bs);
2587 }
2588 return ret;
2589 }
2590
2591 /**
2592 * Length of a allocated file in bytes. Sparse files are counted by actual
2593 * allocated space. Return < 0 if error or unknown.
2594 */
2595 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2596 {
2597 BlockDriver *drv = bs->drv;
2598 if (!drv) {
2599 return -ENOMEDIUM;
2600 }
2601 if (drv->bdrv_get_allocated_file_size) {
2602 return drv->bdrv_get_allocated_file_size(bs);
2603 }
2604 if (bs->file) {
2605 return bdrv_get_allocated_file_size(bs->file->bs);
2606 }
2607 return -ENOTSUP;
2608 }
2609
2610 /**
2611 * Return number of sectors on success, -errno on error.
2612 */
2613 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2614 {
2615 BlockDriver *drv = bs->drv;
2616
2617 if (!drv)
2618 return -ENOMEDIUM;
2619
2620 if (drv->has_variable_length) {
2621 int ret = refresh_total_sectors(bs, bs->total_sectors);
2622 if (ret < 0) {
2623 return ret;
2624 }
2625 }
2626 return bs->total_sectors;
2627 }
2628
2629 /**
2630 * Return length in bytes on success, -errno on error.
2631 * The length is always a multiple of BDRV_SECTOR_SIZE.
2632 */
2633 int64_t bdrv_getlength(BlockDriverState *bs)
2634 {
2635 int64_t ret = bdrv_nb_sectors(bs);
2636
2637 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2638 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2639 }
2640
2641 /* return 0 as number of sectors if no device present or error */
2642 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2643 {
2644 int64_t nb_sectors = bdrv_nb_sectors(bs);
2645
2646 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2647 }
2648
2649 int bdrv_is_read_only(BlockDriverState *bs)
2650 {
2651 return bs->read_only;
2652 }
2653
2654 int bdrv_is_sg(BlockDriverState *bs)
2655 {
2656 return bs->sg;
2657 }
2658
2659 int bdrv_is_encrypted(BlockDriverState *bs)
2660 {
2661 if (bs->backing && bs->backing->bs->encrypted) {
2662 return 1;
2663 }
2664 return bs->encrypted;
2665 }
2666
2667 int bdrv_key_required(BlockDriverState *bs)
2668 {
2669 BdrvChild *backing = bs->backing;
2670
2671 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2672 return 1;
2673 }
2674 return (bs->encrypted && !bs->valid_key);
2675 }
2676
2677 int bdrv_set_key(BlockDriverState *bs, const char *key)
2678 {
2679 int ret;
2680 if (bs->backing && bs->backing->bs->encrypted) {
2681 ret = bdrv_set_key(bs->backing->bs, key);
2682 if (ret < 0)
2683 return ret;
2684 if (!bs->encrypted)
2685 return 0;
2686 }
2687 if (!bs->encrypted) {
2688 return -EINVAL;
2689 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2690 return -ENOMEDIUM;
2691 }
2692 ret = bs->drv->bdrv_set_key(bs, key);
2693 if (ret < 0) {
2694 bs->valid_key = 0;
2695 } else if (!bs->valid_key) {
2696 /* call the change callback now, we skipped it on open */
2697 bs->valid_key = 1;
2698 bdrv_parent_cb_change_media(bs, true);
2699 }
2700 return ret;
2701 }
2702
2703 /*
2704 * Provide an encryption key for @bs.
2705 * If @key is non-null:
2706 * If @bs is not encrypted, fail.
2707 * Else if the key is invalid, fail.
2708 * Else set @bs's key to @key, replacing the existing key, if any.
2709 * If @key is null:
2710 * If @bs is encrypted and still lacks a key, fail.
2711 * Else do nothing.
2712 * On failure, store an error object through @errp if non-null.
2713 */
2714 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2715 {
2716 if (key) {
2717 if (!bdrv_is_encrypted(bs)) {
2718 error_setg(errp, "Node '%s' is not encrypted",
2719 bdrv_get_device_or_node_name(bs));
2720 } else if (bdrv_set_key(bs, key) < 0) {
2721 error_setg(errp, QERR_INVALID_PASSWORD);
2722 }
2723 } else {
2724 if (bdrv_key_required(bs)) {
2725 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2726 "'%s' (%s) is encrypted",
2727 bdrv_get_device_or_node_name(bs),
2728 bdrv_get_encrypted_filename(bs));
2729 }
2730 }
2731 }
2732
2733 const char *bdrv_get_format_name(BlockDriverState *bs)
2734 {
2735 return bs->drv ? bs->drv->format_name : NULL;
2736 }
2737
2738 static int qsort_strcmp(const void *a, const void *b)
2739 {
2740 return strcmp(a, b);
2741 }
2742
2743 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2744 void *opaque)
2745 {
2746 BlockDriver *drv;
2747 int count = 0;
2748 int i;
2749 const char **formats = NULL;
2750
2751 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2752 if (drv->format_name) {
2753 bool found = false;
2754 int i = count;
2755 while (formats && i && !found) {
2756 found = !strcmp(formats[--i], drv->format_name);
2757 }
2758
2759 if (!found) {
2760 formats = g_renew(const char *, formats, count + 1);
2761 formats[count++] = drv->format_name;
2762 }
2763 }
2764 }
2765
2766 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2767
2768 for (i = 0; i < count; i++) {
2769 it(opaque, formats[i]);
2770 }
2771
2772 g_free(formats);
2773 }
2774
2775 /* This function is to find a node in the bs graph */
2776 BlockDriverState *bdrv_find_node(const char *node_name)
2777 {
2778 BlockDriverState *bs;
2779
2780 assert(node_name);
2781
2782 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2783 if (!strcmp(node_name, bs->node_name)) {
2784 return bs;
2785 }
2786 }
2787 return NULL;
2788 }
2789
2790 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2791 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2792 {
2793 BlockDeviceInfoList *list, *entry;
2794 BlockDriverState *bs;
2795
2796 list = NULL;
2797 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2798 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
2799 if (!info) {
2800 qapi_free_BlockDeviceInfoList(list);
2801 return NULL;
2802 }
2803 entry = g_malloc0(sizeof(*entry));
2804 entry->value = info;
2805 entry->next = list;
2806 list = entry;
2807 }
2808
2809 return list;
2810 }
2811
2812 BlockDriverState *bdrv_lookup_bs(const char *device,
2813 const char *node_name,
2814 Error **errp)
2815 {
2816 BlockBackend *blk;
2817 BlockDriverState *bs;
2818
2819 if (device) {
2820 blk = blk_by_name(device);
2821
2822 if (blk) {
2823 bs = blk_bs(blk);
2824 if (!bs) {
2825 error_setg(errp, "Device '%s' has no medium", device);
2826 }
2827
2828 return bs;
2829 }
2830 }
2831
2832 if (node_name) {
2833 bs = bdrv_find_node(node_name);
2834
2835 if (bs) {
2836 return bs;
2837 }
2838 }
2839
2840 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2841 device ? device : "",
2842 node_name ? node_name : "");
2843 return NULL;
2844 }
2845
2846 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2847 * return false. If either argument is NULL, return false. */
2848 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2849 {
2850 while (top && top != base) {
2851 top = backing_bs(top);
2852 }
2853
2854 return top != NULL;
2855 }
2856
2857 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2858 {
2859 if (!bs) {
2860 return QTAILQ_FIRST(&graph_bdrv_states);
2861 }
2862 return QTAILQ_NEXT(bs, node_list);
2863 }
2864
2865 const char *bdrv_get_node_name(const BlockDriverState *bs)
2866 {
2867 return bs->node_name;
2868 }
2869
2870 const char *bdrv_get_parent_name(const BlockDriverState *bs)
2871 {
2872 BdrvChild *c;
2873 const char *name;
2874
2875 /* If multiple parents have a name, just pick the first one. */
2876 QLIST_FOREACH(c, &bs->parents, next_parent) {
2877 if (c->role->get_name) {
2878 name = c->role->get_name(c);
2879 if (name && *name) {
2880 return name;
2881 }
2882 }
2883 }
2884
2885 return NULL;
2886 }
2887
2888 /* TODO check what callers really want: bs->node_name or blk_name() */
2889 const char *bdrv_get_device_name(const BlockDriverState *bs)
2890 {
2891 return bdrv_get_parent_name(bs) ?: "";
2892 }
2893
2894 /* This can be used to identify nodes that might not have a device
2895 * name associated. Since node and device names live in the same
2896 * namespace, the result is unambiguous. The exception is if both are
2897 * absent, then this returns an empty (non-null) string. */
2898 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2899 {
2900 return bdrv_get_parent_name(bs) ?: bs->node_name;
2901 }
2902
2903 int bdrv_get_flags(BlockDriverState *bs)
2904 {
2905 return bs->open_flags;
2906 }
2907
2908 int bdrv_has_zero_init_1(BlockDriverState *bs)
2909 {
2910 return 1;
2911 }
2912
2913 int bdrv_has_zero_init(BlockDriverState *bs)
2914 {
2915 assert(bs->drv);
2916
2917 /* If BS is a copy on write image, it is initialized to
2918 the contents of the base image, which may not be zeroes. */
2919 if (bs->backing) {
2920 return 0;
2921 }
2922 if (bs->drv->bdrv_has_zero_init) {
2923 return bs->drv->bdrv_has_zero_init(bs);
2924 }
2925
2926 /* safe default */
2927 return 0;
2928 }
2929
2930 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2931 {
2932 BlockDriverInfo bdi;
2933
2934 if (bs->backing) {
2935 return false;
2936 }
2937
2938 if (bdrv_get_info(bs, &bdi) == 0) {
2939 return bdi.unallocated_blocks_are_zero;
2940 }
2941
2942 return false;
2943 }
2944
2945 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2946 {
2947 BlockDriverInfo bdi;
2948
2949 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
2950 return false;
2951 }
2952
2953 if (bdrv_get_info(bs, &bdi) == 0) {
2954 return bdi.can_write_zeroes_with_unmap;
2955 }
2956
2957 return false;
2958 }
2959
2960 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2961 {
2962 if (bs->backing && bs->backing->bs->encrypted)
2963 return bs->backing_file;
2964 else if (bs->encrypted)
2965 return bs->filename;
2966 else
2967 return NULL;
2968 }
2969
2970 void bdrv_get_backing_filename(BlockDriverState *bs,
2971 char *filename, int filename_size)
2972 {
2973 pstrcpy(filename, filename_size, bs->backing_file);
2974 }
2975
2976 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2977 {
2978 BlockDriver *drv = bs->drv;
2979 if (!drv)
2980 return -ENOMEDIUM;
2981 if (!drv->bdrv_get_info)
2982 return -ENOTSUP;
2983 memset(bdi, 0, sizeof(*bdi));
2984 return drv->bdrv_get_info(bs, bdi);
2985 }
2986
2987 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
2988 {
2989 BlockDriver *drv = bs->drv;
2990 if (drv && drv->bdrv_get_specific_info) {
2991 return drv->bdrv_get_specific_info(bs);
2992 }
2993 return NULL;
2994 }
2995
2996 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
2997 {
2998 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
2999 return;
3000 }
3001
3002 bs->drv->bdrv_debug_event(bs, event);
3003 }
3004
3005 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3006 const char *tag)
3007 {
3008 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3009 bs = bs->file ? bs->file->bs : NULL;
3010 }
3011
3012 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3013 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3014 }
3015
3016 return -ENOTSUP;
3017 }
3018
3019 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3020 {
3021 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3022 bs = bs->file ? bs->file->bs : NULL;
3023 }
3024
3025 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3026 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3027 }
3028
3029 return -ENOTSUP;
3030 }
3031
3032 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3033 {
3034 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3035 bs = bs->file ? bs->file->bs : NULL;
3036 }
3037
3038 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3039 return bs->drv->bdrv_debug_resume(bs, tag);
3040 }
3041
3042 return -ENOTSUP;
3043 }
3044
3045 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3046 {
3047 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3048 bs = bs->file ? bs->file->bs : NULL;
3049 }
3050
3051 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3052 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3053 }
3054
3055 return false;
3056 }
3057
3058 int bdrv_is_snapshot(BlockDriverState *bs)
3059 {
3060 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3061 }
3062
3063 /* backing_file can either be relative, or absolute, or a protocol. If it is
3064 * relative, it must be relative to the chain. So, passing in bs->filename
3065 * from a BDS as backing_file should not be done, as that may be relative to
3066 * the CWD rather than the chain. */
3067 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3068 const char *backing_file)
3069 {
3070 char *filename_full = NULL;
3071 char *backing_file_full = NULL;
3072 char *filename_tmp = NULL;
3073 int is_protocol = 0;
3074 BlockDriverState *curr_bs = NULL;
3075 BlockDriverState *retval = NULL;
3076
3077 if (!bs || !bs->drv || !backing_file) {
3078 return NULL;
3079 }
3080
3081 filename_full = g_malloc(PATH_MAX);
3082 backing_file_full = g_malloc(PATH_MAX);
3083 filename_tmp = g_malloc(PATH_MAX);
3084
3085 is_protocol = path_has_protocol(backing_file);
3086
3087 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
3088
3089 /* If either of the filename paths is actually a protocol, then
3090 * compare unmodified paths; otherwise make paths relative */
3091 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3092 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3093 retval = curr_bs->backing->bs;
3094 break;
3095 }
3096 } else {
3097 /* If not an absolute filename path, make it relative to the current
3098 * image's filename path */
3099 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3100 backing_file);
3101
3102 /* We are going to compare absolute pathnames */
3103 if (!realpath(filename_tmp, filename_full)) {
3104 continue;
3105 }
3106
3107 /* We need to make sure the backing filename we are comparing against
3108 * is relative to the current image filename (or absolute) */
3109 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3110 curr_bs->backing_file);
3111
3112 if (!realpath(filename_tmp, backing_file_full)) {
3113 continue;
3114 }
3115
3116 if (strcmp(backing_file_full, filename_full) == 0) {
3117 retval = curr_bs->backing->bs;
3118 break;
3119 }
3120 }
3121 }
3122
3123 g_free(filename_full);
3124 g_free(backing_file_full);
3125 g_free(filename_tmp);
3126 return retval;
3127 }
3128
3129 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3130 {
3131 if (!bs->drv) {
3132 return 0;
3133 }
3134
3135 if (!bs->backing) {
3136 return 0;
3137 }
3138
3139 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3140 }
3141
3142 void bdrv_init(void)
3143 {
3144 module_call_init(MODULE_INIT_BLOCK);
3145 }
3146
3147 void bdrv_init_with_whitelist(void)
3148 {
3149 use_bdrv_whitelist = 1;
3150 bdrv_init();
3151 }
3152
3153 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3154 {
3155 BdrvChild *child;
3156 Error *local_err = NULL;
3157 int ret;
3158
3159 if (!bs->drv) {
3160 return;
3161 }
3162
3163 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
3164 return;
3165 }
3166 bs->open_flags &= ~BDRV_O_INACTIVE;
3167
3168 if (bs->drv->bdrv_invalidate_cache) {
3169 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3170 if (local_err) {
3171 bs->open_flags |= BDRV_O_INACTIVE;
3172 error_propagate(errp, local_err);
3173 return;
3174 }
3175 }
3176
3177 QLIST_FOREACH(child, &bs->children, next) {
3178 bdrv_invalidate_cache(child->bs, &local_err);
3179 if (local_err) {
3180 bs->open_flags |= BDRV_O_INACTIVE;
3181 error_propagate(errp, local_err);
3182 return;
3183 }
3184 }
3185
3186 ret = refresh_total_sectors(bs, bs->total_sectors);
3187 if (ret < 0) {
3188 bs->open_flags |= BDRV_O_INACTIVE;
3189 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3190 return;
3191 }
3192 }
3193
3194 void bdrv_invalidate_cache_all(Error **errp)
3195 {
3196 BlockDriverState *bs;
3197 Error *local_err = NULL;
3198 BdrvNextIterator *it = NULL;
3199
3200 while ((it = bdrv_next(it, &bs)) != NULL) {
3201 AioContext *aio_context = bdrv_get_aio_context(bs);
3202
3203 aio_context_acquire(aio_context);
3204 bdrv_invalidate_cache(bs, &local_err);
3205 aio_context_release(aio_context);
3206 if (local_err) {
3207 error_propagate(errp, local_err);
3208 return;
3209 }
3210 }
3211 }
3212
3213 static int bdrv_inactivate_recurse(BlockDriverState *bs,
3214 bool setting_flag)
3215 {
3216 BdrvChild *child;
3217 int ret;
3218
3219 if (!setting_flag && bs->drv->bdrv_inactivate) {
3220 ret = bs->drv->bdrv_inactivate(bs);
3221 if (ret < 0) {
3222 return ret;
3223 }
3224 }
3225
3226 QLIST_FOREACH(child, &bs->children, next) {
3227 ret = bdrv_inactivate_recurse(child->bs, setting_flag);
3228 if (ret < 0) {
3229 return ret;
3230 }
3231 }
3232
3233 if (setting_flag) {
3234 bs->open_flags |= BDRV_O_INACTIVE;
3235 }
3236 return 0;
3237 }
3238
3239 int bdrv_inactivate_all(void)
3240 {
3241 BlockDriverState *bs = NULL;
3242 BdrvNextIterator *it = NULL;
3243 int ret = 0;
3244 int pass;
3245
3246 while ((it = bdrv_next(it, &bs)) != NULL) {
3247 aio_context_acquire(bdrv_get_aio_context(bs));
3248 }
3249
3250 /* We do two passes of inactivation. The first pass calls to drivers'
3251 * .bdrv_inactivate callbacks recursively so all cache is flushed to disk;
3252 * the second pass sets the BDRV_O_INACTIVE flag so that no further write
3253 * is allowed. */
3254 for (pass = 0; pass < 2; pass++) {
3255 it = NULL;
3256 while ((it = bdrv_next(it, &bs)) != NULL) {
3257 ret = bdrv_inactivate_recurse(bs, pass);
3258 if (ret < 0) {
3259 goto out;
3260 }
3261 }
3262 }
3263
3264 out:
3265 it = NULL;
3266 while ((it = bdrv_next(it, &bs)) != NULL) {
3267 aio_context_release(bdrv_get_aio_context(bs));
3268 }
3269
3270 return ret;
3271 }
3272
3273 /**************************************************************/
3274 /* removable device support */
3275
3276 /**
3277 * Return TRUE if the media is present
3278 */
3279 bool bdrv_is_inserted(BlockDriverState *bs)
3280 {
3281 BlockDriver *drv = bs->drv;
3282 BdrvChild *child;
3283
3284 if (!drv) {
3285 return false;
3286 }
3287 if (drv->bdrv_is_inserted) {
3288 return drv->bdrv_is_inserted(bs);
3289 }
3290 QLIST_FOREACH(child, &bs->children, next) {
3291 if (!bdrv_is_inserted(child->bs)) {
3292 return false;
3293 }
3294 }
3295 return true;
3296 }
3297
3298 /**
3299 * Return whether the media changed since the last call to this
3300 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3301 */
3302 int bdrv_media_changed(BlockDriverState *bs)
3303 {
3304 BlockDriver *drv = bs->drv;
3305
3306 if (drv && drv->bdrv_media_changed) {
3307 return drv->bdrv_media_changed(bs);
3308 }
3309 return -ENOTSUP;
3310 }
3311
3312 /**
3313 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3314 */
3315 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3316 {
3317 BlockDriver *drv = bs->drv;
3318 const char *device_name;
3319
3320 if (drv && drv->bdrv_eject) {
3321 drv->bdrv_eject(bs, eject_flag);
3322 }
3323
3324 device_name = bdrv_get_device_name(bs);
3325 if (device_name[0] != '\0') {
3326 qapi_event_send_device_tray_moved(device_name,
3327 eject_flag, &error_abort);
3328 }
3329 }
3330
3331 /**
3332 * Lock or unlock the media (if it is locked, the user won't be able
3333 * to eject it manually).
3334 */
3335 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3336 {
3337 BlockDriver *drv = bs->drv;
3338
3339 trace_bdrv_lock_medium(bs, locked);
3340
3341 if (drv && drv->bdrv_lock_medium) {
3342 drv->bdrv_lock_medium(bs, locked);
3343 }
3344 }
3345
3346 /* Get a reference to bs */
3347 void bdrv_ref(BlockDriverState *bs)
3348 {
3349 bs->refcnt++;
3350 }
3351
3352 /* Release a previously grabbed reference to bs.
3353 * If after releasing, reference count is zero, the BlockDriverState is
3354 * deleted. */
3355 void bdrv_unref(BlockDriverState *bs)
3356 {
3357 if (!bs) {
3358 return;
3359 }
3360 assert(bs->refcnt > 0);
3361 if (--bs->refcnt == 0) {
3362 bdrv_delete(bs);
3363 }
3364 }
3365
3366 struct BdrvOpBlocker {
3367 Error *reason;
3368 QLIST_ENTRY(BdrvOpBlocker) list;
3369 };
3370
3371 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3372 {
3373 BdrvOpBlocker *blocker;
3374 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3375 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3376 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3377 if (errp) {
3378 *errp = error_copy(blocker->reason);
3379 error_prepend(errp, "Node '%s' is busy: ",
3380 bdrv_get_device_or_node_name(bs));
3381 }
3382 return true;
3383 }
3384 return false;
3385 }
3386
3387 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3388 {
3389 BdrvOpBlocker *blocker;
3390 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3391
3392 blocker = g_new0(BdrvOpBlocker, 1);
3393 blocker->reason = reason;
3394 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3395 }
3396
3397 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3398 {
3399 BdrvOpBlocker *blocker, *next;
3400 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3401 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3402 if (blocker->reason == reason) {
3403 QLIST_REMOVE(blocker, list);
3404 g_free(blocker);
3405 }
3406 }
3407 }
3408
3409 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3410 {
3411 int i;
3412 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3413 bdrv_op_block(bs, i, reason);
3414 }
3415 }
3416
3417 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3418 {
3419 int i;
3420 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3421 bdrv_op_unblock(bs, i, reason);
3422 }
3423 }
3424
3425 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3426 {
3427 int i;
3428
3429 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3430 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3431 return false;
3432 }
3433 }
3434 return true;
3435 }
3436
3437 void bdrv_img_create(const char *filename, const char *fmt,
3438 const char *base_filename, const char *base_fmt,
3439 char *options, uint64_t img_size, int flags,
3440 Error **errp, bool quiet)
3441 {
3442 QemuOptsList *create_opts = NULL;
3443 QemuOpts *opts = NULL;
3444 const char *backing_fmt, *backing_file;
3445 int64_t size;
3446 BlockDriver *drv, *proto_drv;
3447 Error *local_err = NULL;
3448 int ret = 0;
3449
3450 /* Find driver and parse its options */
3451 drv = bdrv_find_format(fmt);
3452 if (!drv) {
3453 error_setg(errp, "Unknown file format '%s'", fmt);
3454 return;
3455 }
3456
3457 proto_drv = bdrv_find_protocol(filename, true, errp);
3458 if (!proto_drv) {
3459 return;
3460 }
3461
3462 if (!drv->create_opts) {
3463 error_setg(errp, "Format driver '%s' does not support image creation",
3464 drv->format_name);
3465 return;
3466 }
3467
3468 if (!proto_drv->create_opts) {
3469 error_setg(errp, "Protocol driver '%s' does not support image creation",
3470 proto_drv->format_name);
3471 return;
3472 }
3473
3474 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3475 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3476
3477 /* Create parameter list with default values */
3478 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3479 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3480
3481 /* Parse -o options */
3482 if (options) {
3483 qemu_opts_do_parse(opts, options, NULL, &local_err);
3484 if (local_err) {
3485 error_report_err(local_err);
3486 local_err = NULL;
3487 error_setg(errp, "Invalid options for file format '%s'", fmt);
3488 goto out;
3489 }
3490 }
3491
3492 if (base_filename) {
3493 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3494 if (local_err) {
3495 error_setg(errp, "Backing file not supported for file format '%s'",
3496 fmt);
3497 goto out;
3498 }
3499 }
3500
3501 if (base_fmt) {
3502 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3503 if (local_err) {
3504 error_setg(errp, "Backing file format not supported for file "
3505 "format '%s'", fmt);
3506 goto out;
3507 }
3508 }
3509
3510 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3511 if (backing_file) {
3512 if (!strcmp(filename, backing_file)) {
3513 error_setg(errp, "Error: Trying to create an image with the "
3514 "same filename as the backing file");
3515 goto out;
3516 }
3517 }
3518
3519 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3520
3521 // The size for the image must always be specified, with one exception:
3522 // If we are using a backing file, we can obtain the size from there
3523 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3524 if (size == -1) {
3525 if (backing_file) {
3526 BlockDriverState *bs;
3527 char *full_backing = g_new0(char, PATH_MAX);
3528 int64_t size;
3529 int back_flags;
3530 QDict *backing_options = NULL;
3531
3532 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3533 full_backing, PATH_MAX,
3534 &local_err);
3535 if (local_err) {
3536 g_free(full_backing);
3537 goto out;
3538 }
3539
3540 /* backing files always opened read-only */
3541 back_flags = flags;
3542 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3543
3544 if (backing_fmt) {
3545 backing_options = qdict_new();
3546 qdict_put(backing_options, "driver",
3547 qstring_from_str(backing_fmt));
3548 }
3549
3550 bs = NULL;
3551 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
3552 back_flags, &local_err);
3553 g_free(full_backing);
3554 if (ret < 0) {
3555 goto out;
3556 }
3557 size = bdrv_getlength(bs);
3558 if (size < 0) {
3559 error_setg_errno(errp, -size, "Could not get size of '%s'",
3560 backing_file);
3561 bdrv_unref(bs);
3562 goto out;
3563 }
3564
3565 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3566
3567 bdrv_unref(bs);
3568 } else {
3569 error_setg(errp, "Image creation needs a size parameter");
3570 goto out;
3571 }
3572 }
3573
3574 if (!quiet) {
3575 printf("Formatting '%s', fmt=%s ", filename, fmt);
3576 qemu_opts_print(opts, " ");
3577 puts("");
3578 }
3579
3580 ret = bdrv_create(drv, filename, opts, &local_err);
3581