]> git.proxmox.com Git - mirror_qemu.git/blob - block.c
crypto: Make QCryptoTLSCreds* structures private
[mirror_qemu.git] / block.c
1 /*
2 * QEMU System Emulator block driver
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 * Copyright (c) 2020 Virtuozzo International GmbH.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "qemu/osdep.h"
27 #include "block/trace.h"
28 #include "block/block_int.h"
29 #include "block/blockjob.h"
30 #include "block/fuse.h"
31 #include "block/nbd.h"
32 #include "block/qdict.h"
33 #include "qemu/error-report.h"
34 #include "block/module_block.h"
35 #include "qemu/main-loop.h"
36 #include "qemu/module.h"
37 #include "qapi/error.h"
38 #include "qapi/qmp/qdict.h"
39 #include "qapi/qmp/qjson.h"
40 #include "qapi/qmp/qnull.h"
41 #include "qapi/qmp/qstring.h"
42 #include "qapi/qobject-output-visitor.h"
43 #include "qapi/qapi-visit-block-core.h"
44 #include "sysemu/block-backend.h"
45 #include "qemu/notify.h"
46 #include "qemu/option.h"
47 #include "qemu/coroutine.h"
48 #include "block/qapi.h"
49 #include "qemu/timer.h"
50 #include "qemu/cutils.h"
51 #include "qemu/id.h"
52 #include "block/coroutines.h"
53
54 #ifdef CONFIG_BSD
55 #include <sys/ioctl.h>
56 #include <sys/queue.h>
57 #if defined(HAVE_SYS_DISK_H)
58 #include <sys/disk.h>
59 #endif
60 #endif
61
62 #ifdef _WIN32
63 #include <windows.h>
64 #endif
65
66 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
67
68 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
69 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
70
71 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
72 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
73
74 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
75 QLIST_HEAD_INITIALIZER(bdrv_drivers);
76
77 static BlockDriverState *bdrv_open_inherit(const char *filename,
78 const char *reference,
79 QDict *options, int flags,
80 BlockDriverState *parent,
81 const BdrvChildClass *child_class,
82 BdrvChildRole child_role,
83 Error **errp);
84
85 static void bdrv_replace_child_noperm(BdrvChild *child,
86 BlockDriverState *new_bs);
87 static void bdrv_remove_filter_or_cow_child(BlockDriverState *bs,
88 Transaction *tran);
89
90 static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
91 BlockReopenQueue *queue,
92 Transaction *set_backings_tran, Error **errp);
93 static void bdrv_reopen_commit(BDRVReopenState *reopen_state);
94 static void bdrv_reopen_abort(BDRVReopenState *reopen_state);
95
96 /* If non-zero, use only whitelisted block drivers */
97 static int use_bdrv_whitelist;
98
99 #ifdef _WIN32
100 static int is_windows_drive_prefix(const char *filename)
101 {
102 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
103 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
104 filename[1] == ':');
105 }
106
107 int is_windows_drive(const char *filename)
108 {
109 if (is_windows_drive_prefix(filename) &&
110 filename[2] == '\0')
111 return 1;
112 if (strstart(filename, "\\\\.\\", NULL) ||
113 strstart(filename, "//./", NULL))
114 return 1;
115 return 0;
116 }
117 #endif
118
119 size_t bdrv_opt_mem_align(BlockDriverState *bs)
120 {
121 if (!bs || !bs->drv) {
122 /* page size or 4k (hdd sector size) should be on the safe side */
123 return MAX(4096, qemu_real_host_page_size);
124 }
125
126 return bs->bl.opt_mem_alignment;
127 }
128
129 size_t bdrv_min_mem_align(BlockDriverState *bs)
130 {
131 if (!bs || !bs->drv) {
132 /* page size or 4k (hdd sector size) should be on the safe side */
133 return MAX(4096, qemu_real_host_page_size);
134 }
135
136 return bs->bl.min_mem_alignment;
137 }
138
139 /* check if the path starts with "<protocol>:" */
140 int path_has_protocol(const char *path)
141 {
142 const char *p;
143
144 #ifdef _WIN32
145 if (is_windows_drive(path) ||
146 is_windows_drive_prefix(path)) {
147 return 0;
148 }
149 p = path + strcspn(path, ":/\\");
150 #else
151 p = path + strcspn(path, ":/");
152 #endif
153
154 return *p == ':';
155 }
156
157 int path_is_absolute(const char *path)
158 {
159 #ifdef _WIN32
160 /* specific case for names like: "\\.\d:" */
161 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
162 return 1;
163 }
164 return (*path == '/' || *path == '\\');
165 #else
166 return (*path == '/');
167 #endif
168 }
169
170 /* if filename is absolute, just return its duplicate. Otherwise, build a
171 path to it by considering it is relative to base_path. URL are
172 supported. */
173 char *path_combine(const char *base_path, const char *filename)
174 {
175 const char *protocol_stripped = NULL;
176 const char *p, *p1;
177 char *result;
178 int len;
179
180 if (path_is_absolute(filename)) {
181 return g_strdup(filename);
182 }
183
184 if (path_has_protocol(base_path)) {
185 protocol_stripped = strchr(base_path, ':');
186 if (protocol_stripped) {
187 protocol_stripped++;
188 }
189 }
190 p = protocol_stripped ?: base_path;
191
192 p1 = strrchr(base_path, '/');
193 #ifdef _WIN32
194 {
195 const char *p2;
196 p2 = strrchr(base_path, '\\');
197 if (!p1 || p2 > p1) {
198 p1 = p2;
199 }
200 }
201 #endif
202 if (p1) {
203 p1++;
204 } else {
205 p1 = base_path;
206 }
207 if (p1 > p) {
208 p = p1;
209 }
210 len = p - base_path;
211
212 result = g_malloc(len + strlen(filename) + 1);
213 memcpy(result, base_path, len);
214 strcpy(result + len, filename);
215
216 return result;
217 }
218
219 /*
220 * Helper function for bdrv_parse_filename() implementations to remove optional
221 * protocol prefixes (especially "file:") from a filename and for putting the
222 * stripped filename into the options QDict if there is such a prefix.
223 */
224 void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix,
225 QDict *options)
226 {
227 if (strstart(filename, prefix, &filename)) {
228 /* Stripping the explicit protocol prefix may result in a protocol
229 * prefix being (wrongly) detected (if the filename contains a colon) */
230 if (path_has_protocol(filename)) {
231 GString *fat_filename;
232
233 /* This means there is some colon before the first slash; therefore,
234 * this cannot be an absolute path */
235 assert(!path_is_absolute(filename));
236
237 /* And we can thus fix the protocol detection issue by prefixing it
238 * by "./" */
239 fat_filename = g_string_new("./");
240 g_string_append(fat_filename, filename);
241
242 assert(!path_has_protocol(fat_filename->str));
243
244 qdict_put(options, "filename",
245 qstring_from_gstring(fat_filename));
246 } else {
247 /* If no protocol prefix was detected, we can use the shortened
248 * filename as-is */
249 qdict_put_str(options, "filename", filename);
250 }
251 }
252 }
253
254
255 /* Returns whether the image file is opened as read-only. Note that this can
256 * return false and writing to the image file is still not possible because the
257 * image is inactivated. */
258 bool bdrv_is_read_only(BlockDriverState *bs)
259 {
260 return !(bs->open_flags & BDRV_O_RDWR);
261 }
262
263 int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
264 bool ignore_allow_rdw, Error **errp)
265 {
266 /* Do not set read_only if copy_on_read is enabled */
267 if (bs->copy_on_read && read_only) {
268 error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
269 bdrv_get_device_or_node_name(bs));
270 return -EINVAL;
271 }
272
273 /* Do not clear read_only if it is prohibited */
274 if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&
275 !ignore_allow_rdw)
276 {
277 error_setg(errp, "Node '%s' is read only",
278 bdrv_get_device_or_node_name(bs));
279 return -EPERM;
280 }
281
282 return 0;
283 }
284
285 /*
286 * Called by a driver that can only provide a read-only image.
287 *
288 * Returns 0 if the node is already read-only or it could switch the node to
289 * read-only because BDRV_O_AUTO_RDONLY is set.
290 *
291 * Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set
292 * or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg
293 * is not NULL, it is used as the error message for the Error object.
294 */
295 int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
296 Error **errp)
297 {
298 int ret = 0;
299
300 if (!(bs->open_flags & BDRV_O_RDWR)) {
301 return 0;
302 }
303 if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) {
304 goto fail;
305 }
306
307 ret = bdrv_can_set_read_only(bs, true, false, NULL);
308 if (ret < 0) {
309 goto fail;
310 }
311
312 bs->open_flags &= ~BDRV_O_RDWR;
313
314 return 0;
315
316 fail:
317 error_setg(errp, "%s", errmsg ?: "Image is read-only");
318 return -EACCES;
319 }
320
321 /*
322 * If @backing is empty, this function returns NULL without setting
323 * @errp. In all other cases, NULL will only be returned with @errp
324 * set.
325 *
326 * Therefore, a return value of NULL without @errp set means that
327 * there is no backing file; if @errp is set, there is one but its
328 * absolute filename cannot be generated.
329 */
330 char *bdrv_get_full_backing_filename_from_filename(const char *backed,
331 const char *backing,
332 Error **errp)
333 {
334 if (backing[0] == '\0') {
335 return NULL;
336 } else if (path_has_protocol(backing) || path_is_absolute(backing)) {
337 return g_strdup(backing);
338 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
339 error_setg(errp, "Cannot use relative backing file names for '%s'",
340 backed);
341 return NULL;
342 } else {
343 return path_combine(backed, backing);
344 }
345 }
346
347 /*
348 * If @filename is empty or NULL, this function returns NULL without
349 * setting @errp. In all other cases, NULL will only be returned with
350 * @errp set.
351 */
352 static char *bdrv_make_absolute_filename(BlockDriverState *relative_to,
353 const char *filename, Error **errp)
354 {
355 char *dir, *full_name;
356
357 if (!filename || filename[0] == '\0') {
358 return NULL;
359 } else if (path_has_protocol(filename) || path_is_absolute(filename)) {
360 return g_strdup(filename);
361 }
362
363 dir = bdrv_dirname(relative_to, errp);
364 if (!dir) {
365 return NULL;
366 }
367
368 full_name = g_strconcat(dir, filename, NULL);
369 g_free(dir);
370 return full_name;
371 }
372
373 char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp)
374 {
375 return bdrv_make_absolute_filename(bs, bs->backing_file, errp);
376 }
377
378 void bdrv_register(BlockDriver *bdrv)
379 {
380 assert(bdrv->format_name);
381 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
382 }
383
384 BlockDriverState *bdrv_new(void)
385 {
386 BlockDriverState *bs;
387 int i;
388
389 bs = g_new0(BlockDriverState, 1);
390 QLIST_INIT(&bs->dirty_bitmaps);
391 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
392 QLIST_INIT(&bs->op_blockers[i]);
393 }
394 qemu_co_mutex_init(&bs->reqs_lock);
395 qemu_mutex_init(&bs->dirty_bitmap_mutex);
396 bs->refcnt = 1;
397 bs->aio_context = qemu_get_aio_context();
398
399 qemu_co_queue_init(&bs->flush_queue);
400
401 for (i = 0; i < bdrv_drain_all_count; i++) {
402 bdrv_drained_begin(bs);
403 }
404
405 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
406
407 return bs;
408 }
409
410 static BlockDriver *bdrv_do_find_format(const char *format_name)
411 {
412 BlockDriver *drv1;
413
414 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
415 if (!strcmp(drv1->format_name, format_name)) {
416 return drv1;
417 }
418 }
419
420 return NULL;
421 }
422
423 BlockDriver *bdrv_find_format(const char *format_name)
424 {
425 BlockDriver *drv1;
426 int i;
427
428 drv1 = bdrv_do_find_format(format_name);
429 if (drv1) {
430 return drv1;
431 }
432
433 /* The driver isn't registered, maybe we need to load a module */
434 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
435 if (!strcmp(block_driver_modules[i].format_name, format_name)) {
436 block_module_load_one(block_driver_modules[i].library_name);
437 break;
438 }
439 }
440
441 return bdrv_do_find_format(format_name);
442 }
443
444 static int bdrv_format_is_whitelisted(const char *format_name, bool read_only)
445 {
446 static const char *whitelist_rw[] = {
447 CONFIG_BDRV_RW_WHITELIST
448 NULL
449 };
450 static const char *whitelist_ro[] = {
451 CONFIG_BDRV_RO_WHITELIST
452 NULL
453 };
454 const char **p;
455
456 if (!whitelist_rw[0] && !whitelist_ro[0]) {
457 return 1; /* no whitelist, anything goes */
458 }
459
460 for (p = whitelist_rw; *p; p++) {
461 if (!strcmp(format_name, *p)) {
462 return 1;
463 }
464 }
465 if (read_only) {
466 for (p = whitelist_ro; *p; p++) {
467 if (!strcmp(format_name, *p)) {
468 return 1;
469 }
470 }
471 }
472 return 0;
473 }
474
475 int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
476 {
477 return bdrv_format_is_whitelisted(drv->format_name, read_only);
478 }
479
480 bool bdrv_uses_whitelist(void)
481 {
482 return use_bdrv_whitelist;
483 }
484
485 typedef struct CreateCo {
486 BlockDriver *drv;
487 char *filename;
488 QemuOpts *opts;
489 int ret;
490 Error *err;
491 } CreateCo;
492
493 static void coroutine_fn bdrv_create_co_entry(void *opaque)
494 {
495 Error *local_err = NULL;
496 int ret;
497
498 CreateCo *cco = opaque;
499 assert(cco->drv);
500
501 ret = cco->drv->bdrv_co_create_opts(cco->drv,
502 cco->filename, cco->opts, &local_err);
503 error_propagate(&cco->err, local_err);
504 cco->ret = ret;
505 }
506
507 int bdrv_create(BlockDriver *drv, const char* filename,
508 QemuOpts *opts, Error **errp)
509 {
510 int ret;
511
512 Coroutine *co;
513 CreateCo cco = {
514 .drv = drv,
515 .filename = g_strdup(filename),
516 .opts = opts,
517 .ret = NOT_DONE,
518 .err = NULL,
519 };
520
521 if (!drv->bdrv_co_create_opts) {
522 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
523 ret = -ENOTSUP;
524 goto out;
525 }
526
527 if (qemu_in_coroutine()) {
528 /* Fast-path if already in coroutine context */
529 bdrv_create_co_entry(&cco);
530 } else {
531 co = qemu_coroutine_create(bdrv_create_co_entry, &cco);
532 qemu_coroutine_enter(co);
533 while (cco.ret == NOT_DONE) {
534 aio_poll(qemu_get_aio_context(), true);
535 }
536 }
537
538 ret = cco.ret;
539 if (ret < 0) {
540 if (cco.err) {
541 error_propagate(errp, cco.err);
542 } else {
543 error_setg_errno(errp, -ret, "Could not create image");
544 }
545 }
546
547 out:
548 g_free(cco.filename);
549 return ret;
550 }
551
552 /**
553 * Helper function for bdrv_create_file_fallback(): Resize @blk to at
554 * least the given @minimum_size.
555 *
556 * On success, return @blk's actual length.
557 * Otherwise, return -errno.
558 */
559 static int64_t create_file_fallback_truncate(BlockBackend *blk,
560 int64_t minimum_size, Error **errp)
561 {
562 Error *local_err = NULL;
563 int64_t size;
564 int ret;
565
566 ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
567 &local_err);
568 if (ret < 0 && ret != -ENOTSUP) {
569 error_propagate(errp, local_err);
570 return ret;
571 }
572
573 size = blk_getlength(blk);
574 if (size < 0) {
575 error_free(local_err);
576 error_setg_errno(errp, -size,
577 "Failed to inquire the new image file's length");
578 return size;
579 }
580
581 if (size < minimum_size) {
582 /* Need to grow the image, but we failed to do that */
583 error_propagate(errp, local_err);
584 return -ENOTSUP;
585 }
586
587 error_free(local_err);
588 local_err = NULL;
589
590 return size;
591 }
592
593 /**
594 * Helper function for bdrv_create_file_fallback(): Zero the first
595 * sector to remove any potentially pre-existing image header.
596 */
597 static int create_file_fallback_zero_first_sector(BlockBackend *blk,
598 int64_t current_size,
599 Error **errp)
600 {
601 int64_t bytes_to_clear;
602 int ret;
603
604 bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE);
605 if (bytes_to_clear) {
606 ret = blk_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP);
607 if (ret < 0) {
608 error_setg_errno(errp, -ret,
609 "Failed to clear the new image's first sector");
610 return ret;
611 }
612 }
613
614 return 0;
615 }
616
617 /**
618 * Simple implementation of bdrv_co_create_opts for protocol drivers
619 * which only support creation via opening a file
620 * (usually existing raw storage device)
621 */
622 int coroutine_fn bdrv_co_create_opts_simple(BlockDriver *drv,
623 const char *filename,
624 QemuOpts *opts,
625 Error **errp)
626 {
627 BlockBackend *blk;
628 QDict *options;
629 int64_t size = 0;
630 char *buf = NULL;
631 PreallocMode prealloc;
632 Error *local_err = NULL;
633 int ret;
634
635 size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
636 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
637 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
638 PREALLOC_MODE_OFF, &local_err);
639 g_free(buf);
640 if (local_err) {
641 error_propagate(errp, local_err);
642 return -EINVAL;
643 }
644
645 if (prealloc != PREALLOC_MODE_OFF) {
646 error_setg(errp, "Unsupported preallocation mode '%s'",
647 PreallocMode_str(prealloc));
648 return -ENOTSUP;
649 }
650
651 options = qdict_new();
652 qdict_put_str(options, "driver", drv->format_name);
653
654 blk = blk_new_open(filename, NULL, options,
655 BDRV_O_RDWR | BDRV_O_RESIZE, errp);
656 if (!blk) {
657 error_prepend(errp, "Protocol driver '%s' does not support image "
658 "creation, and opening the image failed: ",
659 drv->format_name);
660 return -EINVAL;
661 }
662
663 size = create_file_fallback_truncate(blk, size, errp);
664 if (size < 0) {
665 ret = size;
666 goto out;
667 }
668
669 ret = create_file_fallback_zero_first_sector(blk, size, errp);
670 if (ret < 0) {
671 goto out;
672 }
673
674 ret = 0;
675 out:
676 blk_unref(blk);
677 return ret;
678 }
679
680 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
681 {
682 QemuOpts *protocol_opts;
683 BlockDriver *drv;
684 QDict *qdict;
685 int ret;
686
687 drv = bdrv_find_protocol(filename, true, errp);
688 if (drv == NULL) {
689 return -ENOENT;
690 }
691
692 if (!drv->create_opts) {
693 error_setg(errp, "Driver '%s' does not support image creation",
694 drv->format_name);
695 return -ENOTSUP;
696 }
697
698 /*
699 * 'opts' contains a QemuOptsList with a combination of format and protocol
700 * default values.
701 *
702 * The format properly removes its options, but the default values remain
703 * in 'opts->list'. So if the protocol has options with the same name
704 * (e.g. rbd has 'cluster_size' as qcow2), it will see the default values
705 * of the format, since for overlapping options, the format wins.
706 *
707 * To avoid this issue, lets convert QemuOpts to QDict, in this way we take
708 * only the set options, and then convert it back to QemuOpts, using the
709 * create_opts of the protocol. So the new QemuOpts, will contain only the
710 * protocol defaults.
711 */
712 qdict = qemu_opts_to_qdict(opts, NULL);
713 protocol_opts = qemu_opts_from_qdict(drv->create_opts, qdict, errp);
714 if (protocol_opts == NULL) {
715 ret = -EINVAL;
716 goto out;
717 }
718
719 ret = bdrv_create(drv, filename, protocol_opts, errp);
720 out:
721 qemu_opts_del(protocol_opts);
722 qobject_unref(qdict);
723 return ret;
724 }
725
726 int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp)
727 {
728 Error *local_err = NULL;
729 int ret;
730
731 assert(bs != NULL);
732
733 if (!bs->drv) {
734 error_setg(errp, "Block node '%s' is not opened", bs->filename);
735 return -ENOMEDIUM;
736 }
737
738 if (!bs->drv->bdrv_co_delete_file) {
739 error_setg(errp, "Driver '%s' does not support image deletion",
740 bs->drv->format_name);
741 return -ENOTSUP;
742 }
743
744 ret = bs->drv->bdrv_co_delete_file(bs, &local_err);
745 if (ret < 0) {
746 error_propagate(errp, local_err);
747 }
748
749 return ret;
750 }
751
752 void coroutine_fn bdrv_co_delete_file_noerr(BlockDriverState *bs)
753 {
754 Error *local_err = NULL;
755 int ret;
756
757 if (!bs) {
758 return;
759 }
760
761 ret = bdrv_co_delete_file(bs, &local_err);
762 /*
763 * ENOTSUP will happen if the block driver doesn't support
764 * the 'bdrv_co_delete_file' interface. This is a predictable
765 * scenario and shouldn't be reported back to the user.
766 */
767 if (ret == -ENOTSUP) {
768 error_free(local_err);
769 } else if (ret < 0) {
770 error_report_err(local_err);
771 }
772 }
773
774 /**
775 * Try to get @bs's logical and physical block size.
776 * On success, store them in @bsz struct and return 0.
777 * On failure return -errno.
778 * @bs must not be empty.
779 */
780 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
781 {
782 BlockDriver *drv = bs->drv;
783 BlockDriverState *filtered = bdrv_filter_bs(bs);
784
785 if (drv && drv->bdrv_probe_blocksizes) {
786 return drv->bdrv_probe_blocksizes(bs, bsz);
787 } else if (filtered) {
788 return bdrv_probe_blocksizes(filtered, bsz);
789 }
790
791 return -ENOTSUP;
792 }
793
794 /**
795 * Try to get @bs's geometry (cyls, heads, sectors).
796 * On success, store them in @geo struct and return 0.
797 * On failure return -errno.
798 * @bs must not be empty.
799 */
800 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
801 {
802 BlockDriver *drv = bs->drv;
803 BlockDriverState *filtered = bdrv_filter_bs(bs);
804
805 if (drv && drv->bdrv_probe_geometry) {
806 return drv->bdrv_probe_geometry(bs, geo);
807 } else if (filtered) {
808 return bdrv_probe_geometry(filtered, geo);
809 }
810
811 return -ENOTSUP;
812 }
813
814 /*
815 * Create a uniquely-named empty temporary file.
816 * Return 0 upon success, otherwise a negative errno value.
817 */
818 int get_tmp_filename(char *filename, int size)
819 {
820 #ifdef _WIN32
821 char temp_dir[MAX_PATH];
822 /* GetTempFileName requires that its output buffer (4th param)
823 have length MAX_PATH or greater. */
824 assert(size >= MAX_PATH);
825 return (GetTempPath(MAX_PATH, temp_dir)
826 && GetTempFileName(temp_dir, "qem", 0, filename)
827 ? 0 : -GetLastError());
828 #else
829 int fd;
830 const char *tmpdir;
831 tmpdir = getenv("TMPDIR");
832 if (!tmpdir) {
833 tmpdir = "/var/tmp";
834 }
835 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
836 return -EOVERFLOW;
837 }
838 fd = mkstemp(filename);
839 if (fd < 0) {
840 return -errno;
841 }
842 if (close(fd) != 0) {
843 unlink(filename);
844 return -errno;
845 }
846 return 0;
847 #endif
848 }
849
850 /*
851 * Detect host devices. By convention, /dev/cdrom[N] is always
852 * recognized as a host CDROM.
853 */
854 static BlockDriver *find_hdev_driver(const char *filename)
855 {
856 int score_max = 0, score;
857 BlockDriver *drv = NULL, *d;
858
859 QLIST_FOREACH(d, &bdrv_drivers, list) {
860 if (d->bdrv_probe_device) {
861 score = d->bdrv_probe_device(filename);
862 if (score > score_max) {
863 score_max = score;
864 drv = d;
865 }
866 }
867 }
868
869 return drv;
870 }
871
872 static BlockDriver *bdrv_do_find_protocol(const char *protocol)
873 {
874 BlockDriver *drv1;
875
876 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
877 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
878 return drv1;
879 }
880 }
881
882 return NULL;
883 }
884
885 BlockDriver *bdrv_find_protocol(const char *filename,
886 bool allow_protocol_prefix,
887 Error **errp)
888 {
889 BlockDriver *drv1;
890 char protocol[128];
891 int len;
892 const char *p;
893 int i;
894
895 /* TODO Drivers without bdrv_file_open must be specified explicitly */
896
897 /*
898 * XXX(hch): we really should not let host device detection
899 * override an explicit protocol specification, but moving this
900 * later breaks access to device names with colons in them.
901 * Thanks to the brain-dead persistent naming schemes on udev-
902 * based Linux systems those actually are quite common.
903 */
904 drv1 = find_hdev_driver(filename);
905 if (drv1) {
906 return drv1;
907 }
908
909 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
910 return &bdrv_file;
911 }
912
913 p = strchr(filename, ':');
914 assert(p != NULL);
915 len = p - filename;
916 if (len > sizeof(protocol) - 1)
917 len = sizeof(protocol) - 1;
918 memcpy(protocol, filename, len);
919 protocol[len] = '\0';
920
921 drv1 = bdrv_do_find_protocol(protocol);
922 if (drv1) {
923 return drv1;
924 }
925
926 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
927 if (block_driver_modules[i].protocol_name &&
928 !strcmp(block_driver_modules[i].protocol_name, protocol)) {
929 block_module_load_one(block_driver_modules[i].library_name);
930 break;
931 }
932 }
933
934 drv1 = bdrv_do_find_protocol(protocol);
935 if (!drv1) {
936 error_setg(errp, "Unknown protocol '%s'", protocol);
937 }
938 return drv1;
939 }
940
941 /*
942 * Guess image format by probing its contents.
943 * This is not a good idea when your image is raw (CVE-2008-2004), but
944 * we do it anyway for backward compatibility.
945 *
946 * @buf contains the image's first @buf_size bytes.
947 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
948 * but can be smaller if the image file is smaller)
949 * @filename is its filename.
950 *
951 * For all block drivers, call the bdrv_probe() method to get its
952 * probing score.
953 * Return the first block driver with the highest probing score.
954 */
955 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
956 const char *filename)
957 {
958 int score_max = 0, score;
959 BlockDriver *drv = NULL, *d;
960
961 QLIST_FOREACH(d, &bdrv_drivers, list) {
962 if (d->bdrv_probe) {
963 score = d->bdrv_probe(buf, buf_size, filename);
964 if (score > score_max) {
965 score_max = score;
966 drv = d;
967 }
968 }
969 }
970
971 return drv;
972 }
973
974 static int find_image_format(BlockBackend *file, const char *filename,
975 BlockDriver **pdrv, Error **errp)
976 {
977 BlockDriver *drv;
978 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
979 int ret = 0;
980
981 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
982 if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
983 *pdrv = &bdrv_raw;
984 return ret;
985 }
986
987 ret = blk_pread(file, 0, buf, sizeof(buf));
988 if (ret < 0) {
989 error_setg_errno(errp, -ret, "Could not read image for determining its "
990 "format");
991 *pdrv = NULL;
992 return ret;
993 }
994
995 drv = bdrv_probe_all(buf, ret, filename);
996 if (!drv) {
997 error_setg(errp, "Could not determine image format: No compatible "
998 "driver found");
999 ret = -ENOENT;
1000 }
1001 *pdrv = drv;
1002 return ret;
1003 }
1004
1005 /**
1006 * Set the current 'total_sectors' value
1007 * Return 0 on success, -errno on error.
1008 */
1009 int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
1010 {
1011 BlockDriver *drv = bs->drv;
1012
1013 if (!drv) {
1014 return -ENOMEDIUM;
1015 }
1016
1017 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
1018 if (bdrv_is_sg(bs))
1019 return 0;
1020
1021 /* query actual device if possible, otherwise just trust the hint */
1022 if (drv->bdrv_getlength) {
1023 int64_t length = drv->bdrv_getlength(bs);
1024 if (length < 0) {
1025 return length;
1026 }
1027 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
1028 }
1029
1030 bs->total_sectors = hint;
1031
1032 if (bs->total_sectors * BDRV_SECTOR_SIZE > BDRV_MAX_LENGTH) {
1033 return -EFBIG;
1034 }
1035
1036 return 0;
1037 }
1038
1039 /**
1040 * Combines a QDict of new block driver @options with any missing options taken
1041 * from @old_options, so that leaving out an option defaults to its old value.
1042 */
1043 static void bdrv_join_options(BlockDriverState *bs, QDict *options,
1044 QDict *old_options)
1045 {
1046 if (bs->drv && bs->drv->bdrv_join_options) {
1047 bs->drv->bdrv_join_options(options, old_options);
1048 } else {
1049 qdict_join(options, old_options, false);
1050 }
1051 }
1052
1053 static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
1054 int open_flags,
1055 Error **errp)
1056 {
1057 Error *local_err = NULL;
1058 char *value = qemu_opt_get_del(opts, "detect-zeroes");
1059 BlockdevDetectZeroesOptions detect_zeroes =
1060 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup, value,
1061 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, &local_err);
1062 g_free(value);
1063 if (local_err) {
1064 error_propagate(errp, local_err);
1065 return detect_zeroes;
1066 }
1067
1068 if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
1069 !(open_flags & BDRV_O_UNMAP))
1070 {
1071 error_setg(errp, "setting detect-zeroes to unmap is not allowed "
1072 "without setting discard operation to unmap");
1073 }
1074
1075 return detect_zeroes;
1076 }
1077
1078 /**
1079 * Set open flags for aio engine
1080 *
1081 * Return 0 on success, -1 if the engine specified is invalid
1082 */
1083 int bdrv_parse_aio(const char *mode, int *flags)
1084 {
1085 if (!strcmp(mode, "threads")) {
1086 /* do nothing, default */
1087 } else if (!strcmp(mode, "native")) {
1088 *flags |= BDRV_O_NATIVE_AIO;
1089 #ifdef CONFIG_LINUX_IO_URING
1090 } else if (!strcmp(mode, "io_uring")) {
1091 *flags |= BDRV_O_IO_URING;
1092 #endif
1093 } else {
1094 return -1;
1095 }
1096
1097 return 0;
1098 }
1099
1100 /**
1101 * Set open flags for a given discard mode
1102 *
1103 * Return 0 on success, -1 if the discard mode was invalid.
1104 */
1105 int bdrv_parse_discard_flags(const char *mode, int *flags)
1106 {
1107 *flags &= ~BDRV_O_UNMAP;
1108
1109 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
1110 /* do nothing */
1111 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
1112 *flags |= BDRV_O_UNMAP;
1113 } else {
1114 return -1;
1115 }
1116
1117 return 0;
1118 }
1119
1120 /**
1121 * Set open flags for a given cache mode
1122 *
1123 * Return 0 on success, -1 if the cache mode was invalid.
1124 */
1125 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
1126 {
1127 *flags &= ~BDRV_O_CACHE_MASK;
1128
1129 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
1130 *writethrough = false;
1131 *flags |= BDRV_O_NOCACHE;
1132 } else if (!strcmp(mode, "directsync")) {
1133 *writethrough = true;
1134 *flags |= BDRV_O_NOCACHE;
1135 } else if (!strcmp(mode, "writeback")) {
1136 *writethrough = false;
1137 } else if (!strcmp(mode, "unsafe")) {
1138 *writethrough = false;
1139 *flags |= BDRV_O_NO_FLUSH;
1140 } else if (!strcmp(mode, "writethrough")) {
1141 *writethrough = true;
1142 } else {
1143 return -1;
1144 }
1145
1146 return 0;
1147 }
1148
1149 static char *bdrv_child_get_parent_desc(BdrvChild *c)
1150 {
1151 BlockDriverState *parent = c->opaque;
1152 return g_strdup_printf("node '%s'", bdrv_get_node_name(parent));
1153 }
1154
1155 static void bdrv_child_cb_drained_begin(BdrvChild *child)
1156 {
1157 BlockDriverState *bs = child->opaque;
1158 bdrv_do_drained_begin_quiesce(bs, NULL, false);
1159 }
1160
1161 static bool bdrv_child_cb_drained_poll(BdrvChild *child)
1162 {
1163 BlockDriverState *bs = child->opaque;
1164 return bdrv_drain_poll(bs, false, NULL, false);
1165 }
1166
1167 static void bdrv_child_cb_drained_end(BdrvChild *child,
1168 int *drained_end_counter)
1169 {
1170 BlockDriverState *bs = child->opaque;
1171 bdrv_drained_end_no_poll(bs, drained_end_counter);
1172 }
1173
1174 static int bdrv_child_cb_inactivate(BdrvChild *child)
1175 {
1176 BlockDriverState *bs = child->opaque;
1177 assert(bs->open_flags & BDRV_O_INACTIVE);
1178 return 0;
1179 }
1180
1181 static bool bdrv_child_cb_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
1182 GSList **ignore, Error **errp)
1183 {
1184 BlockDriverState *bs = child->opaque;
1185 return bdrv_can_set_aio_context(bs, ctx, ignore, errp);
1186 }
1187
1188 static void bdrv_child_cb_set_aio_ctx(BdrvChild *child, AioContext *ctx,
1189 GSList **ignore)
1190 {
1191 BlockDriverState *bs = child->opaque;
1192 return bdrv_set_aio_context_ignore(bs, ctx, ignore);
1193 }
1194
1195 /*
1196 * Returns the options and flags that a temporary snapshot should get, based on
1197 * the originally requested flags (the originally requested image will have
1198 * flags like a backing file)
1199 */
1200 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
1201 int parent_flags, QDict *parent_options)
1202 {
1203 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
1204
1205 /* For temporary files, unconditional cache=unsafe is fine */
1206 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
1207 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
1208
1209 /* Copy the read-only and discard options from the parent */
1210 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
1211 qdict_copy_default(child_options, parent_options, BDRV_OPT_DISCARD);
1212
1213 /* aio=native doesn't work for cache.direct=off, so disable it for the
1214 * temporary snapshot */
1215 *child_flags &= ~BDRV_O_NATIVE_AIO;
1216 }
1217
1218 static void bdrv_backing_attach(BdrvChild *c)
1219 {
1220 BlockDriverState *parent = c->opaque;
1221 BlockDriverState *backing_hd = c->bs;
1222
1223 assert(!parent->backing_blocker);
1224 error_setg(&parent->backing_blocker,
1225 "node is used as backing hd of '%s'",
1226 bdrv_get_device_or_node_name(parent));
1227
1228 bdrv_refresh_filename(backing_hd);
1229
1230 parent->open_flags &= ~BDRV_O_NO_BACKING;
1231
1232 bdrv_op_block_all(backing_hd, parent->backing_blocker);
1233 /* Otherwise we won't be able to commit or stream */
1234 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1235 parent->backing_blocker);
1236 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
1237 parent->backing_blocker);
1238 /*
1239 * We do backup in 3 ways:
1240 * 1. drive backup
1241 * The target bs is new opened, and the source is top BDS
1242 * 2. blockdev backup
1243 * Both the source and the target are top BDSes.
1244 * 3. internal backup(used for block replication)
1245 * Both the source and the target are backing file
1246 *
1247 * In case 1 and 2, neither the source nor the target is the backing file.
1248 * In case 3, we will block the top BDS, so there is only one block job
1249 * for the top BDS and its backing chain.
1250 */
1251 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
1252 parent->backing_blocker);
1253 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
1254 parent->backing_blocker);
1255 }
1256
1257 static void bdrv_backing_detach(BdrvChild *c)
1258 {
1259 BlockDriverState *parent = c->opaque;
1260
1261 assert(parent->backing_blocker);
1262 bdrv_op_unblock_all(c->bs, parent->backing_blocker);
1263 error_free(parent->backing_blocker);
1264 parent->backing_blocker = NULL;
1265 }
1266
1267 static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
1268 const char *filename, Error **errp)
1269 {
1270 BlockDriverState *parent = c->opaque;
1271 bool read_only = bdrv_is_read_only(parent);
1272 int ret;
1273
1274 if (read_only) {
1275 ret = bdrv_reopen_set_read_only(parent, false, errp);
1276 if (ret < 0) {
1277 return ret;
1278 }
1279 }
1280
1281 ret = bdrv_change_backing_file(parent, filename,
1282 base->drv ? base->drv->format_name : "",
1283 false);
1284 if (ret < 0) {
1285 error_setg_errno(errp, -ret, "Could not update backing file link");
1286 }
1287
1288 if (read_only) {
1289 bdrv_reopen_set_read_only(parent, true, NULL);
1290 }
1291
1292 return ret;
1293 }
1294
1295 /*
1296 * Returns the options and flags that a generic child of a BDS should
1297 * get, based on the given options and flags for the parent BDS.
1298 */
1299 static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
1300 int *child_flags, QDict *child_options,
1301 int parent_flags, QDict *parent_options)
1302 {
1303 int flags = parent_flags;
1304
1305 /*
1306 * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
1307 * Generally, the question to answer is: Should this child be
1308 * format-probed by default?
1309 */
1310
1311 /*
1312 * Pure and non-filtered data children of non-format nodes should
1313 * be probed by default (even when the node itself has BDRV_O_PROTOCOL
1314 * set). This only affects a very limited set of drivers (namely
1315 * quorum and blkverify when this comment was written).
1316 * Force-clear BDRV_O_PROTOCOL then.
1317 */
1318 if (!parent_is_format &&
1319 (role & BDRV_CHILD_DATA) &&
1320 !(role & (BDRV_CHILD_METADATA | BDRV_CHILD_FILTERED)))
1321 {
1322 flags &= ~BDRV_O_PROTOCOL;
1323 }
1324
1325 /*
1326 * All children of format nodes (except for COW children) and all
1327 * metadata children in general should never be format-probed.
1328 * Force-set BDRV_O_PROTOCOL then.
1329 */
1330 if ((parent_is_format && !(role & BDRV_CHILD_COW)) ||
1331 (role & BDRV_CHILD_METADATA))
1332 {
1333 flags |= BDRV_O_PROTOCOL;
1334 }
1335
1336 /*
1337 * If the cache mode isn't explicitly set, inherit direct and no-flush from
1338 * the parent.
1339 */
1340 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
1341 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
1342 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
1343
1344 if (role & BDRV_CHILD_COW) {
1345 /* backing files are opened read-only by default */
1346 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
1347 qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
1348 } else {
1349 /* Inherit the read-only option from the parent if it's not set */
1350 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
1351 qdict_copy_default(child_options, parent_options,
1352 BDRV_OPT_AUTO_READ_ONLY);
1353 }
1354
1355 /*
1356 * bdrv_co_pdiscard() respects unmap policy for the parent, so we
1357 * can default to enable it on lower layers regardless of the
1358 * parent option.
1359 */
1360 qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
1361
1362 /* Clear flags that only apply to the top layer */
1363 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
1364
1365 if (role & BDRV_CHILD_METADATA) {
1366 flags &= ~BDRV_O_NO_IO;
1367 }
1368 if (role & BDRV_CHILD_COW) {
1369 flags &= ~BDRV_O_TEMPORARY;
1370 }
1371
1372 *child_flags = flags;
1373 }
1374
1375 static void bdrv_child_cb_attach(BdrvChild *child)
1376 {
1377 BlockDriverState *bs = child->opaque;
1378
1379 if (child->role & BDRV_CHILD_COW) {
1380 bdrv_backing_attach(child);
1381 }
1382
1383 bdrv_apply_subtree_drain(child, bs);
1384 }
1385
1386 static void bdrv_child_cb_detach(BdrvChild *child)
1387 {
1388 BlockDriverState *bs = child->opaque;
1389
1390 if (child->role & BDRV_CHILD_COW) {
1391 bdrv_backing_detach(child);
1392 }
1393
1394 bdrv_unapply_subtree_drain(child, bs);
1395 }
1396
1397 static int bdrv_child_cb_update_filename(BdrvChild *c, BlockDriverState *base,
1398 const char *filename, Error **errp)
1399 {
1400 if (c->role & BDRV_CHILD_COW) {
1401 return bdrv_backing_update_filename(c, base, filename, errp);
1402 }
1403 return 0;
1404 }
1405
1406 AioContext *child_of_bds_get_parent_aio_context(BdrvChild *c)
1407 {
1408 BlockDriverState *bs = c->opaque;
1409
1410 return bdrv_get_aio_context(bs);
1411 }
1412
1413 const BdrvChildClass child_of_bds = {
1414 .parent_is_bds = true,
1415 .get_parent_desc = bdrv_child_get_parent_desc,
1416 .inherit_options = bdrv_inherited_options,
1417 .drained_begin = bdrv_child_cb_drained_begin,
1418 .drained_poll = bdrv_child_cb_drained_poll,
1419 .drained_end = bdrv_child_cb_drained_end,
1420 .attach = bdrv_child_cb_attach,
1421 .detach = bdrv_child_cb_detach,
1422 .inactivate = bdrv_child_cb_inactivate,
1423 .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx,
1424 .set_aio_ctx = bdrv_child_cb_set_aio_ctx,
1425 .update_filename = bdrv_child_cb_update_filename,
1426 .get_parent_aio_context = child_of_bds_get_parent_aio_context,
1427 };
1428
1429 AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c)
1430 {
1431 return c->klass->get_parent_aio_context(c);
1432 }
1433
1434 static int bdrv_open_flags(BlockDriverState *bs, int flags)
1435 {
1436 int open_flags = flags;
1437
1438 /*
1439 * Clear flags that are internal to the block layer before opening the
1440 * image.
1441 */
1442 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
1443
1444 return open_flags;
1445 }
1446
1447 static void update_flags_from_options(int *flags, QemuOpts *opts)
1448 {
1449 *flags &= ~(BDRV_O_CACHE_MASK | BDRV_O_RDWR | BDRV_O_AUTO_RDONLY);
1450
1451 if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
1452 *flags |= BDRV_O_NO_FLUSH;
1453 }
1454
1455 if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_DIRECT, false)) {
1456 *flags |= BDRV_O_NOCACHE;
1457 }
1458
1459 if (!qemu_opt_get_bool_del(opts, BDRV_OPT_READ_ONLY, false)) {
1460 *flags |= BDRV_O_RDWR;
1461 }
1462
1463 if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
1464 *flags |= BDRV_O_AUTO_RDONLY;
1465 }
1466 }
1467
1468 static void update_options_from_flags(QDict *options, int flags)
1469 {
1470 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
1471 qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
1472 }
1473 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
1474 qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
1475 flags & BDRV_O_NO_FLUSH);
1476 }
1477 if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
1478 qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
1479 }
1480 if (!qdict_haskey(options, BDRV_OPT_AUTO_READ_ONLY)) {
1481 qdict_put_bool(options, BDRV_OPT_AUTO_READ_ONLY,
1482 flags & BDRV_O_AUTO_RDONLY);
1483 }
1484 }
1485
1486 static void bdrv_assign_node_name(BlockDriverState *bs,
1487 const char *node_name,
1488 Error **errp)
1489 {
1490 char *gen_node_name = NULL;
1491
1492 if (!node_name) {
1493 node_name = gen_node_name = id_generate(ID_BLOCK);
1494 } else if (!id_wellformed(node_name)) {
1495 /*
1496 * Check for empty string or invalid characters, but not if it is
1497 * generated (generated names use characters not available to the user)
1498 */
1499 error_setg(errp, "Invalid node-name: '%s'", node_name);
1500 return;
1501 }
1502
1503 /* takes care of avoiding namespaces collisions */
1504 if (blk_by_name(node_name)) {
1505 error_setg(errp, "node-name=%s is conflicting with a device id",
1506 node_name);
1507 goto out;
1508 }
1509
1510 /* takes care of avoiding duplicates node names */
1511 if (bdrv_find_node(node_name)) {
1512 error_setg(errp, "Duplicate nodes with node-name='%s'", node_name);
1513 goto out;
1514 }
1515
1516 /* Make sure that the node name isn't truncated */
1517 if (strlen(node_name) >= sizeof(bs->node_name)) {
1518 error_setg(errp, "Node name too long");
1519 goto out;
1520 }
1521
1522 /* copy node name into the bs and insert it into the graph list */
1523 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
1524 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
1525 out:
1526 g_free(gen_node_name);
1527 }
1528
1529 static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
1530 const char *node_name, QDict *options,
1531 int open_flags, Error **errp)
1532 {
1533 Error *local_err = NULL;
1534 int i, ret;
1535
1536 bdrv_assign_node_name(bs, node_name, &local_err);
1537 if (local_err) {
1538 error_propagate(errp, local_err);
1539 return -EINVAL;
1540 }
1541
1542 bs->drv = drv;
1543 bs->opaque = g_malloc0(drv->instance_size);
1544
1545 if (drv->bdrv_file_open) {
1546 assert(!drv->bdrv_needs_filename || bs->filename[0]);
1547 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
1548 } else if (drv->bdrv_open) {
1549 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
1550 } else {
1551 ret = 0;
1552 }
1553
1554 if (ret < 0) {
1555 if (local_err) {
1556 error_propagate(errp, local_err);
1557 } else if (bs->filename[0]) {
1558 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1559 } else {
1560 error_setg_errno(errp, -ret, "Could not open image");
1561 }
1562 goto open_failed;
1563 }
1564
1565 ret = refresh_total_sectors(bs, bs->total_sectors);
1566 if (ret < 0) {
1567 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1568 return ret;
1569 }
1570
1571 bdrv_refresh_limits(bs, NULL, &local_err);
1572 if (local_err) {
1573 error_propagate(errp, local_err);
1574 return -EINVAL;
1575 }
1576
1577 assert(bdrv_opt_mem_align(bs) != 0);
1578 assert(bdrv_min_mem_align(bs) != 0);
1579 assert(is_power_of_2(bs->bl.request_alignment));
1580
1581 for (i = 0; i < bs->quiesce_counter; i++) {
1582 if (drv->bdrv_co_drain_begin) {
1583 drv->bdrv_co_drain_begin(bs);
1584 }
1585 }
1586
1587 return 0;
1588 open_failed:
1589 bs->drv = NULL;
1590 if (bs->file != NULL) {
1591 bdrv_unref_child(bs, bs->file);
1592 bs->file = NULL;
1593 }
1594 g_free(bs->opaque);
1595 bs->opaque = NULL;
1596 return ret;
1597 }
1598
1599 BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
1600 int flags, Error **errp)
1601 {
1602 BlockDriverState *bs;
1603 int ret;
1604
1605 bs = bdrv_new();
1606 bs->open_flags = flags;
1607 bs->explicit_options = qdict_new();
1608 bs->options = qdict_new();
1609 bs->opaque = NULL;
1610
1611 update_options_from_flags(bs->options, flags);
1612
1613 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
1614 if (ret < 0) {
1615 qobject_unref(bs->explicit_options);
1616 bs->explicit_options = NULL;
1617 qobject_unref(bs->options);
1618 bs->options = NULL;
1619 bdrv_unref(bs);
1620 return NULL;
1621 }
1622
1623 return bs;
1624 }
1625
1626 QemuOptsList bdrv_runtime_opts = {
1627 .name = "bdrv_common",
1628 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
1629 .desc = {
1630 {
1631 .name = "node-name",
1632 .type = QEMU_OPT_STRING,
1633 .help = "Node name of the block device node",
1634 },
1635 {
1636 .name = "driver",
1637 .type = QEMU_OPT_STRING,
1638 .help = "Block driver to use for the node",
1639 },
1640 {
1641 .name = BDRV_OPT_CACHE_DIRECT,
1642 .type = QEMU_OPT_BOOL,
1643 .help = "Bypass software writeback cache on the host",
1644 },
1645 {
1646 .name = BDRV_OPT_CACHE_NO_FLUSH,
1647 .type = QEMU_OPT_BOOL,
1648 .help = "Ignore flush requests",
1649 },
1650 {
1651 .name = BDRV_OPT_READ_ONLY,
1652 .type = QEMU_OPT_BOOL,
1653 .help = "Node is opened in read-only mode",
1654 },
1655 {
1656 .name = BDRV_OPT_AUTO_READ_ONLY,
1657 .type = QEMU_OPT_BOOL,
1658 .help = "Node can become read-only if opening read-write fails",
1659 },
1660 {
1661 .name = "detect-zeroes",
1662 .type = QEMU_OPT_STRING,
1663 .help = "try to optimize zero writes (off, on, unmap)",
1664 },
1665 {
1666 .name = BDRV_OPT_DISCARD,
1667 .type = QEMU_OPT_STRING,
1668 .help = "discard operation (ignore/off, unmap/on)",
1669 },
1670 {
1671 .name = BDRV_OPT_FORCE_SHARE,
1672 .type = QEMU_OPT_BOOL,
1673 .help = "always accept other writers (default: off)",
1674 },
1675 { /* end of list */ }
1676 },
1677 };
1678
1679 QemuOptsList bdrv_create_opts_simple = {
1680 .name = "simple-create-opts",
1681 .head = QTAILQ_HEAD_INITIALIZER(bdrv_create_opts_simple.head),
1682 .desc = {
1683 {
1684 .name = BLOCK_OPT_SIZE,
1685 .type = QEMU_OPT_SIZE,
1686 .help = "Virtual disk size"
1687 },
1688 {
1689 .name = BLOCK_OPT_PREALLOC,
1690 .type = QEMU_OPT_STRING,
1691 .help = "Preallocation mode (allowed values: off)"
1692 },
1693 { /* end of list */ }
1694 }
1695 };
1696
1697 /*
1698 * Common part for opening disk images and files
1699 *
1700 * Removes all processed options from *options.
1701 */
1702 static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
1703 QDict *options, Error **errp)
1704 {
1705 int ret, open_flags;
1706 const char *filename;
1707 const char *driver_name = NULL;
1708 const char *node_name = NULL;
1709 const char *discard;
1710 QemuOpts *opts;
1711 BlockDriver *drv;
1712 Error *local_err = NULL;
1713 bool ro;
1714
1715 assert(bs->file == NULL);
1716 assert(options != NULL && bs->options != options);
1717
1718 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1719 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
1720 ret = -EINVAL;
1721 goto fail_opts;
1722 }
1723
1724 update_flags_from_options(&bs->open_flags, opts);
1725
1726 driver_name = qemu_opt_get(opts, "driver");
1727 drv = bdrv_find_format(driver_name);
1728 assert(drv != NULL);
1729
1730 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);
1731
1732 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {
1733 error_setg(errp,
1734 BDRV_OPT_FORCE_SHARE
1735 "=on can only be used with read-only images");
1736 ret = -EINVAL;
1737 goto fail_opts;
1738 }
1739
1740 if (file != NULL) {
1741 bdrv_refresh_filename(blk_bs(file));
1742 filename = blk_bs(file)->filename;
1743 } else {
1744 /*
1745 * Caution: while qdict_get_try_str() is fine, getting
1746 * non-string types would require more care. When @options
1747 * come from -blockdev or blockdev_add, its members are typed
1748 * according to the QAPI schema, but when they come from
1749 * -drive, they're all QString.
1750 */
1751 filename = qdict_get_try_str(options, "filename");
1752 }
1753
1754 if (drv->bdrv_needs_filename && (!filename || !filename[0])) {
1755 error_setg(errp, "The '%s' block driver requires a file name",
1756 drv->format_name);
1757 ret = -EINVAL;
1758 goto fail_opts;
1759 }
1760
1761 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
1762 drv->format_name);
1763
1764 ro = bdrv_is_read_only(bs);
1765
1766 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, ro)) {
1767 if (!ro && bdrv_is_whitelisted(drv, true)) {
1768 ret = bdrv_apply_auto_read_only(bs, NULL, NULL);
1769 } else {
1770 ret = -ENOTSUP;
1771 }
1772 if (ret < 0) {
1773 error_setg(errp,
1774 !ro && bdrv_is_whitelisted(drv, true)
1775 ? "Driver '%s' can only be used for read-only devices"
1776 : "Driver '%s' is not whitelisted",
1777 drv->format_name);
1778 goto fail_opts;
1779 }
1780 }
1781
1782 /* bdrv_new() and bdrv_close() make it so */
1783 assert(qatomic_read(&bs->copy_on_read) == 0);
1784
1785 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
1786 if (!ro) {
1787 bdrv_enable_copy_on_read(bs);
1788 } else {
1789 error_setg(errp, "Can't use copy-on-read on read-only device");
1790 ret = -EINVAL;
1791 goto fail_opts;
1792 }
1793 }
1794
1795 discard = qemu_opt_get(opts, BDRV_OPT_DISCARD);
1796 if (discard != NULL) {
1797 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
1798 error_setg(errp, "Invalid discard option");
1799 ret = -EINVAL;
1800 goto fail_opts;
1801 }
1802 }
1803
1804 bs->detect_zeroes =
1805 bdrv_parse_detect_zeroes(opts, bs->open_flags, &local_err);
1806 if (local_err) {
1807 error_propagate(errp, local_err);
1808 ret = -EINVAL;
1809 goto fail_opts;
1810 }
1811
1812 if (filename != NULL) {
1813 pstrcpy(bs->filename, sizeof(bs->filename), filename);
1814 } else {
1815 bs->filename[0] = '\0';
1816 }
1817 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
1818
1819 /* Open the image, either directly or using a protocol */
1820 open_flags = bdrv_open_flags(bs, bs->open_flags);
1821 node_name = qemu_opt_get(opts, "node-name");
1822
1823 assert(!drv->bdrv_file_open || file == NULL);
1824 ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
1825 if (ret < 0) {
1826 goto fail_opts;
1827 }
1828
1829 qemu_opts_del(opts);
1830 return 0;
1831
1832 fail_opts:
1833 qemu_opts_del(opts);
1834 return ret;
1835 }
1836
1837 static QDict *parse_json_filename(const char *filename, Error **errp)
1838 {
1839 QObject *options_obj;
1840 QDict *options;
1841 int ret;
1842
1843 ret = strstart(filename, "json:", &filename);
1844 assert(ret);
1845
1846 options_obj = qobject_from_json(filename, errp);
1847 if (!options_obj) {
1848 error_prepend(errp, "Could not parse the JSON options: ");
1849 return NULL;
1850 }
1851
1852 options = qobject_to(QDict, options_obj);
1853 if (!options) {
1854 qobject_unref(options_obj);
1855 error_setg(errp, "Invalid JSON object given");
1856 return NULL;
1857 }
1858
1859 qdict_flatten(options);
1860
1861 return options;
1862 }
1863
1864 static void parse_json_protocol(QDict *options, const char **pfilename,
1865 Error **errp)
1866 {
1867 QDict *json_options;
1868 Error *local_err = NULL;
1869
1870 /* Parse json: pseudo-protocol */
1871 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1872 return;
1873 }
1874
1875 json_options = parse_json_filename(*pfilename, &local_err);
1876 if (local_err) {
1877 error_propagate(errp, local_err);
1878 return;
1879 }
1880
1881 /* Options given in the filename have lower priority than options
1882 * specified directly */
1883 qdict_join(options, json_options, false);
1884 qobject_unref(json_options);
1885 *pfilename = NULL;
1886 }
1887
1888 /*
1889 * Fills in default options for opening images and converts the legacy
1890 * filename/flags pair to option QDict entries.
1891 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1892 * block driver has been specified explicitly.
1893 */
1894 static int bdrv_fill_options(QDict **options, const char *filename,
1895 int *flags, Error **errp)
1896 {
1897 const char *drvname;
1898 bool protocol = *flags & BDRV_O_PROTOCOL;
1899 bool parse_filename = false;
1900 BlockDriver *drv = NULL;
1901 Error *local_err = NULL;
1902
1903 /*
1904 * Caution: while qdict_get_try_str() is fine, getting non-string
1905 * types would require more care. When @options come from
1906 * -blockdev or blockdev_add, its members are typed according to
1907 * the QAPI schema, but when they come from -drive, they're all
1908 * QString.
1909 */
1910 drvname = qdict_get_try_str(*options, "driver");
1911 if (drvname) {
1912 drv = bdrv_find_format(drvname);
1913 if (!drv) {
1914 error_setg(errp, "Unknown driver '%s'", drvname);
1915 return -ENOENT;
1916 }
1917 /* If the user has explicitly specified the driver, this choice should
1918 * override the BDRV_O_PROTOCOL flag */
1919 protocol = drv->bdrv_file_open;
1920 }
1921
1922 if (protocol) {
1923 *flags |= BDRV_O_PROTOCOL;
1924 } else {
1925 *flags &= ~BDRV_O_PROTOCOL;
1926 }
1927
1928 /* Translate cache options from flags into options */
1929 update_options_from_flags(*options, *flags);
1930
1931 /* Fetch the file name from the options QDict if necessary */
1932 if (protocol && filename) {
1933 if (!qdict_haskey(*options, "filename")) {
1934 qdict_put_str(*options, "filename", filename);
1935 parse_filename = true;
1936 } else {
1937 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1938 "the same time");
1939 return -EINVAL;
1940 }
1941 }
1942
1943 /* Find the right block driver */
1944 /* See cautionary note on accessing @options above */
1945 filename = qdict_get_try_str(*options, "filename");
1946
1947 if (!drvname && protocol) {
1948 if (filename) {
1949 drv = bdrv_find_protocol(filename, parse_filename, errp);
1950 if (!drv) {
1951 return -EINVAL;
1952 }
1953
1954 drvname = drv->format_name;
1955 qdict_put_str(*options, "driver", drvname);
1956 } else {
1957 error_setg(errp, "Must specify either driver or file");
1958 return -EINVAL;
1959 }
1960 }
1961
1962 assert(drv || !protocol);
1963
1964 /* Driver-specific filename parsing */
1965 if (drv && drv->bdrv_parse_filename && parse_filename) {
1966 drv->bdrv_parse_filename(filename, *options, &local_err);
1967 if (local_err) {
1968 error_propagate(errp, local_err);
1969 return -EINVAL;
1970 }
1971
1972 if (!drv->bdrv_needs_filename) {
1973 qdict_del(*options, "filename");
1974 }
1975 }
1976
1977 return 0;
1978 }
1979
1980 typedef struct BlockReopenQueueEntry {
1981 bool prepared;
1982 bool perms_checked;
1983 BDRVReopenState state;
1984 QTAILQ_ENTRY(BlockReopenQueueEntry) entry;
1985 } BlockReopenQueueEntry;
1986
1987 /*
1988 * Return the flags that @bs will have after the reopens in @q have
1989 * successfully completed. If @q is NULL (or @bs is not contained in @q),
1990 * return the current flags.
1991 */
1992 static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs)
1993 {
1994 BlockReopenQueueEntry *entry;
1995
1996 if (q != NULL) {
1997 QTAILQ_FOREACH(entry, q, entry) {
1998 if (entry->state.bs == bs) {
1999 return entry->state.flags;
2000 }
2001 }
2002 }
2003
2004 return bs->open_flags;
2005 }
2006
2007 /* Returns whether the image file can be written to after the reopen queue @q
2008 * has been successfully applied, or right now if @q is NULL. */
2009 static bool bdrv_is_writable_after_reopen(BlockDriverState *bs,
2010 BlockReopenQueue *q)
2011 {
2012 int flags = bdrv_reopen_get_flags(q, bs);
2013
2014 return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR;
2015 }
2016
2017 /*
2018 * Return whether the BDS can be written to. This is not necessarily
2019 * the same as !bdrv_is_read_only(bs), as inactivated images may not
2020 * be written to but do not count as read-only images.
2021 */
2022 bool bdrv_is_writable(BlockDriverState *bs)
2023 {
2024 return bdrv_is_writable_after_reopen(bs, NULL);
2025 }
2026
2027 static char *bdrv_child_user_desc(BdrvChild *c)
2028 {
2029 return c->klass->get_parent_desc(c);
2030 }
2031
2032 /*
2033 * Check that @a allows everything that @b needs. @a and @b must reference same
2034 * child node.
2035 */
2036 static bool bdrv_a_allow_b(BdrvChild *a, BdrvChild *b, Error **errp)
2037 {
2038 const char *child_bs_name;
2039 g_autofree char *a_user = NULL;
2040 g_autofree char *b_user = NULL;
2041 g_autofree char *perms = NULL;
2042
2043 assert(a->bs);
2044 assert(a->bs == b->bs);
2045
2046 if ((b->perm & a->shared_perm) == b->perm) {
2047 return true;
2048 }
2049
2050 child_bs_name = bdrv_get_node_name(b->bs);
2051 a_user = bdrv_child_user_desc(a);
2052 b_user = bdrv_child_user_desc(b);
2053 perms = bdrv_perm_names(b->perm & ~a->shared_perm);
2054
2055 error_setg(errp, "Permission conflict on node '%s': permissions '%s' are "
2056 "both required by %s (uses node '%s' as '%s' child) and "
2057 "unshared by %s (uses node '%s' as '%s' child).",
2058 child_bs_name, perms,
2059 b_user, child_bs_name, b->name,
2060 a_user, child_bs_name, a->name);
2061
2062 return false;
2063 }
2064
2065 static bool bdrv_parent_perms_conflict(BlockDriverState *bs, Error **errp)
2066 {
2067 BdrvChild *a, *b;
2068
2069 /*
2070 * During the loop we'll look at each pair twice. That's correct because
2071 * bdrv_a_allow_b() is asymmetric and we should check each pair in both
2072 * directions.
2073 */
2074 QLIST_FOREACH(a, &bs->parents, next_parent) {
2075 QLIST_FOREACH(b, &bs->parents, next_parent) {
2076 if (a == b) {
2077 continue;
2078 }
2079
2080 if (!bdrv_a_allow_b(a, b, errp)) {
2081 return true;
2082 }
2083 }
2084 }
2085
2086 return false;
2087 }
2088
2089 static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
2090 BdrvChild *c, BdrvChildRole role,
2091 BlockReopenQueue *reopen_queue,
2092 uint64_t parent_perm, uint64_t parent_shared,
2093 uint64_t *nperm, uint64_t *nshared)
2094 {
2095 assert(bs->drv && bs->drv->bdrv_child_perm);
2096 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
2097 parent_perm, parent_shared,
2098 nperm, nshared);
2099 /* TODO Take force_share from reopen_queue */
2100 if (child_bs && child_bs->force_share) {
2101 *nshared = BLK_PERM_ALL;
2102 }
2103 }
2104
2105 /*
2106 * Adds the whole subtree of @bs (including @bs itself) to the @list (except for
2107 * nodes that are already in the @list, of course) so that final list is
2108 * topologically sorted. Return the result (GSList @list object is updated, so
2109 * don't use old reference after function call).
2110 *
2111 * On function start @list must be already topologically sorted and for any node
2112 * in the @list the whole subtree of the node must be in the @list as well. The
2113 * simplest way to satisfy this criteria: use only result of
2114 * bdrv_topological_dfs() or NULL as @list parameter.
2115 */
2116 static GSList *bdrv_topological_dfs(GSList *list, GHashTable *found,
2117 BlockDriverState *bs)
2118 {
2119 BdrvChild *child;
2120 g_autoptr(GHashTable) local_found = NULL;
2121
2122 if (!found) {
2123 assert(!list);
2124 found = local_found = g_hash_table_new(NULL, NULL);
2125 }
2126
2127 if (g_hash_table_contains(found, bs)) {
2128 return list;
2129 }
2130 g_hash_table_add(found, bs);
2131
2132 QLIST_FOREACH(child, &bs->children, next) {
2133 list = bdrv_topological_dfs(list, found, child->bs);
2134 }
2135
2136 return g_slist_prepend(list, bs);
2137 }
2138
2139 typedef struct BdrvChildSetPermState {
2140 BdrvChild *child;
2141 uint64_t old_perm;
2142 uint64_t old_shared_perm;
2143 } BdrvChildSetPermState;
2144
2145 static void bdrv_child_set_perm_abort(void *opaque)
2146 {
2147 BdrvChildSetPermState *s = opaque;
2148
2149 s->child->perm = s->old_perm;
2150 s->child->shared_perm = s->old_shared_perm;
2151 }
2152
2153 static TransactionActionDrv bdrv_child_set_pem_drv = {
2154 .abort = bdrv_child_set_perm_abort,
2155 .clean = g_free,
2156 };
2157
2158 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm,
2159 uint64_t shared, Transaction *tran)
2160 {
2161 BdrvChildSetPermState *s = g_new(BdrvChildSetPermState, 1);
2162
2163 *s = (BdrvChildSetPermState) {
2164 .child = c,
2165 .old_perm = c->perm,
2166 .old_shared_perm = c->shared_perm,
2167 };
2168
2169 c->perm = perm;
2170 c->shared_perm = shared;
2171
2172 tran_add(tran, &bdrv_child_set_pem_drv, s);
2173 }
2174
2175 static void bdrv_drv_set_perm_commit(void *opaque)
2176 {
2177 BlockDriverState *bs = opaque;
2178 uint64_t cumulative_perms, cumulative_shared_perms;
2179
2180 if (bs->drv->bdrv_set_perm) {
2181 bdrv_get_cumulative_perm(bs, &cumulative_perms,
2182 &cumulative_shared_perms);
2183 bs->drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);
2184 }
2185 }
2186
2187 static void bdrv_drv_set_perm_abort(void *opaque)
2188 {
2189 BlockDriverState *bs = opaque;
2190
2191 if (bs->drv->bdrv_abort_perm_update) {
2192 bs->drv->bdrv_abort_perm_update(bs);
2193 }
2194 }
2195
2196 TransactionActionDrv bdrv_drv_set_perm_drv = {
2197 .abort = bdrv_drv_set_perm_abort,
2198 .commit = bdrv_drv_set_perm_commit,
2199 };
2200
2201 static int bdrv_drv_set_perm(BlockDriverState *bs, uint64_t perm,
2202 uint64_t shared_perm, Transaction *tran,
2203 Error **errp)
2204 {
2205 if (!bs->drv) {
2206 return 0;
2207 }
2208
2209 if (bs->drv->bdrv_check_perm) {
2210 int ret = bs->drv->bdrv_check_perm(bs, perm, shared_perm, errp);
2211 if (ret < 0) {
2212 return ret;
2213 }
2214 }
2215
2216 if (tran) {
2217 tran_add(tran, &bdrv_drv_set_perm_drv, bs);
2218 }
2219
2220 return 0;
2221 }
2222
2223 typedef struct BdrvReplaceChildState {
2224 BdrvChild *child;
2225 BlockDriverState *old_bs;
2226 } BdrvReplaceChildState;
2227
2228 static void bdrv_replace_child_commit(void *opaque)
2229 {
2230 BdrvReplaceChildState *s = opaque;
2231
2232 bdrv_unref(s->old_bs);
2233 }
2234
2235 static void bdrv_replace_child_abort(void *opaque)
2236 {
2237 BdrvReplaceChildState *s = opaque;
2238 BlockDriverState *new_bs = s->child->bs;
2239
2240 /* old_bs reference is transparently moved from @s to @s->child */
2241 bdrv_replace_child_noperm(s->child, s->old_bs);
2242 bdrv_unref(new_bs);
2243 }
2244
2245 static TransactionActionDrv bdrv_replace_child_drv = {
2246 .commit = bdrv_replace_child_commit,
2247 .abort = bdrv_replace_child_abort,
2248 .clean = g_free,
2249 };
2250
2251 /*
2252 * bdrv_replace_child
2253 *
2254 * Note: real unref of old_bs is done only on commit.
2255 */
2256 static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs,
2257 Transaction *tran)
2258 {
2259 BdrvReplaceChildState *s = g_new(BdrvReplaceChildState, 1);
2260 *s = (BdrvReplaceChildState) {
2261 .child = child,
2262 .old_bs = child->bs,
2263 };
2264 tran_add(tran, &bdrv_replace_child_drv, s);
2265
2266 if (new_bs) {
2267 bdrv_ref(new_bs);
2268 }
2269 bdrv_replace_child_noperm(child, new_bs);
2270 /* old_bs reference is transparently moved from @child to @s */
2271 }
2272
2273 /*
2274 * Refresh permissions in @bs subtree. The function is intended to be called
2275 * after some graph modification that was done without permission update.
2276 */
2277 static int bdrv_node_refresh_perm(BlockDriverState *bs, BlockReopenQueue *q,
2278 Transaction *tran, Error **errp)
2279 {
2280 BlockDriver *drv = bs->drv;
2281 BdrvChild *c;
2282 int ret;
2283 uint64_t cumulative_perms, cumulative_shared_perms;
2284
2285 bdrv_get_cumulative_perm(bs, &cumulative_perms, &cumulative_shared_perms);
2286
2287 /* Write permissions never work with read-only images */
2288 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
2289 !bdrv_is_writable_after_reopen(bs, q))
2290 {
2291 if (!bdrv_is_writable_after_reopen(bs, NULL)) {
2292 error_setg(errp, "Block node is read-only");
2293 } else {
2294 error_setg(errp, "Read-only block node '%s' cannot support "
2295 "read-write users", bdrv_get_node_name(bs));
2296 }
2297
2298 return -EPERM;
2299 }
2300
2301 /*
2302 * Unaligned requests will automatically be aligned to bl.request_alignment
2303 * and without RESIZE we can't extend requests to write to space beyond the
2304 * end of the image, so it's required that the image size is aligned.
2305 */
2306 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
2307 !(cumulative_perms & BLK_PERM_RESIZE))
2308 {
2309 if ((bs->total_sectors * BDRV_SECTOR_SIZE) % bs->bl.request_alignment) {
2310 error_setg(errp, "Cannot get 'write' permission without 'resize': "
2311 "Image size is not a multiple of request "
2312 "alignment");
2313 return -EPERM;
2314 }
2315 }
2316
2317 /* Check this node */
2318 if (!drv) {
2319 return 0;
2320 }
2321
2322 ret = bdrv_drv_set_perm(bs, cumulative_perms, cumulative_shared_perms, tran,
2323 errp);
2324 if (ret < 0) {
2325 return ret;
2326 }
2327
2328 /* Drivers that never have children can omit .bdrv_child_perm() */
2329 if (!drv->bdrv_child_perm) {
2330 assert(QLIST_EMPTY(&bs->children));
2331 return 0;
2332 }
2333
2334 /* Check all children */
2335 QLIST_FOREACH(c, &bs->children, next) {
2336 uint64_t cur_perm, cur_shared;
2337
2338 bdrv_child_perm(bs, c->bs, c, c->role, q,
2339 cumulative_perms, cumulative_shared_perms,
2340 &cur_perm, &cur_shared);
2341 bdrv_child_set_perm(c, cur_perm, cur_shared, tran);
2342 }
2343
2344 return 0;
2345 }
2346
2347 static int bdrv_list_refresh_perms(GSList *list, BlockReopenQueue *q,
2348 Transaction *tran, Error **errp)
2349 {
2350 int ret;
2351 BlockDriverState *bs;
2352
2353 for ( ; list; list = list->next) {
2354 bs = list->data;
2355
2356 if (bdrv_parent_perms_conflict(bs, errp)) {
2357 return -EINVAL;
2358 }
2359
2360 ret = bdrv_node_refresh_perm(bs, q, tran, errp);
2361 if (ret < 0) {
2362 return ret;
2363 }
2364 }
2365
2366 return 0;
2367 }
2368
2369 void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
2370 uint64_t *shared_perm)
2371 {
2372 BdrvChild *c;
2373 uint64_t cumulative_perms = 0;
2374 uint64_t cumulative_shared_perms = BLK_PERM_ALL;
2375
2376 QLIST_FOREACH(c, &bs->parents, next_parent) {
2377 cumulative_perms |= c->perm;
2378 cumulative_shared_perms &= c->shared_perm;
2379 }
2380
2381 *perm = cumulative_perms;
2382 *shared_perm = cumulative_shared_perms;
2383 }
2384
2385 char *bdrv_perm_names(uint64_t perm)
2386 {
2387 struct perm_name {
2388 uint64_t perm;
2389 const char *name;
2390 } permissions[] = {
2391 { BLK_PERM_CONSISTENT_READ, "consistent read" },
2392 { BLK_PERM_WRITE, "write" },
2393 { BLK_PERM_WRITE_UNCHANGED, "write unchanged" },
2394 { BLK_PERM_RESIZE, "resize" },
2395 { BLK_PERM_GRAPH_MOD, "change children" },
2396 { 0, NULL }
2397 };
2398
2399 GString *result = g_string_sized_new(30);
2400 struct perm_name *p;
2401
2402 for (p = permissions; p->name; p++) {
2403 if (perm & p->perm) {
2404 if (result->len > 0) {
2405 g_string_append(result, ", ");
2406 }
2407 g_string_append(result, p->name);
2408 }
2409 }
2410
2411 return g_string_free(result, FALSE);
2412 }
2413
2414
2415 static int bdrv_refresh_perms(BlockDriverState *bs, Error **errp)
2416 {
2417 int ret;
2418 Transaction *tran = tran_new();
2419 g_autoptr(GSList) list = bdrv_topological_dfs(NULL, NULL, bs);
2420
2421 ret = bdrv_list_refresh_perms(list, NULL, tran, errp);
2422 tran_finalize(tran, ret);
2423
2424 return ret;
2425 }
2426
2427 int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
2428 Error **errp)
2429 {
2430 Error *local_err = NULL;
2431 Transaction *tran = tran_new();
2432 int ret;
2433
2434 bdrv_child_set_perm(c, perm, shared, tran);
2435
2436 ret = bdrv_refresh_perms(c->bs, &local_err);
2437
2438 tran_finalize(tran, ret);
2439
2440 if (ret < 0) {
2441 if ((perm & ~c->perm) || (c->shared_perm & ~shared)) {
2442 /* tighten permissions */
2443 error_propagate(errp, local_err);
2444 } else {
2445 /*
2446 * Our caller may intend to only loosen restrictions and
2447 * does not expect this function to fail. Errors are not
2448 * fatal in such a case, so we can just hide them from our
2449 * caller.
2450 */
2451 error_free(local_err);
2452 ret = 0;
2453 }
2454 }
2455
2456 return ret;
2457 }
2458
2459 int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
2460 {
2461 uint64_t parent_perms, parent_shared;
2462 uint64_t perms, shared;
2463
2464 bdrv_get_cumulative_perm(bs, &parent_perms, &parent_shared);
2465 bdrv_child_perm(bs, c->bs, c, c->role, NULL,
2466 parent_perms, parent_shared, &perms, &shared);
2467
2468 return bdrv_child_try_set_perm(c, perms, shared, errp);
2469 }
2470
2471 /*
2472 * Default implementation for .bdrv_child_perm() for block filters:
2473 * Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED, and RESIZE to the
2474 * filtered child.
2475 */
2476 static void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
2477 BdrvChildRole role,
2478 BlockReopenQueue *reopen_queue,
2479 uint64_t perm, uint64_t shared,
2480 uint64_t *nperm, uint64_t *nshared)
2481 {
2482 *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
2483 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
2484 }
2485
2486 static void bdrv_default_perms_for_cow(BlockDriverState *bs, BdrvChild *c,
2487 BdrvChildRole role,
2488 BlockReopenQueue *reopen_queue,
2489 uint64_t perm, uint64_t shared,
2490 uint64_t *nperm, uint64_t *nshared)
2491 {
2492 assert(role & BDRV_CHILD_COW);
2493
2494 /*
2495 * We want consistent read from backing files if the parent needs it.
2496 * No other operations are performed on backing files.
2497 */
2498 perm &= BLK_PERM_CONSISTENT_READ;
2499
2500 /*
2501 * If the parent can deal with changing data, we're okay with a
2502 * writable and resizable backing file.
2503 * TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too?
2504 */
2505 if (shared & BLK_PERM_WRITE) {
2506 shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2507 } else {
2508 shared = 0;
2509 }
2510
2511 shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
2512 BLK_PERM_WRITE_UNCHANGED;
2513
2514 if (bs->open_flags & BDRV_O_INACTIVE) {
2515 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2516 }
2517
2518 *nperm = perm;
2519 *nshared = shared;
2520 }
2521
2522 static void bdrv_default_perms_for_storage(BlockDriverState *bs, BdrvChild *c,
2523 BdrvChildRole role,
2524 BlockReopenQueue *reopen_queue,
2525 uint64_t perm, uint64_t shared,
2526 uint64_t *nperm, uint64_t *nshared)
2527 {
2528 int flags;
2529
2530 assert(role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA));
2531
2532 flags = bdrv_reopen_get_flags(reopen_queue, bs);
2533
2534 /*
2535 * Apart from the modifications below, the same permissions are
2536 * forwarded and left alone as for filters
2537 */
2538 bdrv_filter_default_perms(bs, c, role, reopen_queue,
2539 perm, shared, &perm, &shared);
2540
2541 if (role & BDRV_CHILD_METADATA) {
2542 /* Format drivers may touch metadata even if the guest doesn't write */
2543 if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
2544 perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2545 }
2546
2547 /*
2548 * bs->file always needs to be consistent because of the
2549 * metadata. We can never allow other users to resize or write
2550 * to it.
2551 */
2552 if (!(flags & BDRV_O_NO_IO)) {
2553 perm |= BLK_PERM_CONSISTENT_READ;
2554 }
2555 shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
2556 }
2557
2558 if (role & BDRV_CHILD_DATA) {
2559 /*
2560 * Technically, everything in this block is a subset of the
2561 * BDRV_CHILD_METADATA path taken above, and so this could
2562 * be an "else if" branch. However, that is not obvious, and
2563 * this function is not performance critical, therefore we let
2564 * this be an independent "if".
2565 */
2566
2567 /*
2568 * We cannot allow other users to resize the file because the
2569 * format driver might have some assumptions about the size
2570 * (e.g. because it is stored in metadata, or because the file
2571 * is split into fixed-size data files).
2572 */
2573 shared &= ~BLK_PERM_RESIZE;
2574
2575 /*
2576 * WRITE_UNCHANGED often cannot be performed as such on the
2577 * data file. For example, the qcow2 driver may still need to
2578 * write copied clusters on copy-on-read.
2579 */
2580 if (perm & BLK_PERM_WRITE_UNCHANGED) {
2581 perm |= BLK_PERM_WRITE;
2582 }
2583
2584 /*
2585 * If the data file is written to, the format driver may
2586 * expect to be able to resize it by writing beyond the EOF.
2587 */
2588 if (perm & BLK_PERM_WRITE) {
2589 perm |= BLK_PERM_RESIZE;
2590 }
2591 }
2592
2593 if (bs->open_flags & BDRV_O_INACTIVE) {
2594 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2595 }
2596
2597 *nperm = perm;
2598 *nshared = shared;
2599 }
2600
2601 void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
2602 BdrvChildRole role, BlockReopenQueue *reopen_queue,
2603 uint64_t perm, uint64_t shared,
2604 uint64_t *nperm, uint64_t *nshared)
2605 {
2606 if (role & BDRV_CHILD_FILTERED) {
2607 assert(!(role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
2608 BDRV_CHILD_COW)));
2609 bdrv_filter_default_perms(bs, c, role, reopen_queue,
2610 perm, shared, nperm, nshared);
2611 } else if (role & BDRV_CHILD_COW) {
2612 assert(!(role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA)));
2613 bdrv_default_perms_for_cow(bs, c, role, reopen_queue,
2614 perm, shared, nperm, nshared);
2615 } else if (role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA)) {
2616 bdrv_default_perms_for_storage(bs, c, role, reopen_queue,
2617 perm, shared, nperm, nshared);
2618 } else {
2619 g_assert_not_reached();
2620 }
2621 }
2622
2623 uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)
2624 {
2625 static const uint64_t permissions[] = {
2626 [BLOCK_PERMISSION_CONSISTENT_READ] = BLK_PERM_CONSISTENT_READ,
2627 [BLOCK_PERMISSION_WRITE] = BLK_PERM_WRITE,
2628 [BLOCK_PERMISSION_WRITE_UNCHANGED] = BLK_PERM_WRITE_UNCHANGED,
2629 [BLOCK_PERMISSION_RESIZE] = BLK_PERM_RESIZE,
2630 [BLOCK_PERMISSION_GRAPH_MOD] = BLK_PERM_GRAPH_MOD,
2631 };
2632
2633 QEMU_BUILD_BUG_ON(ARRAY_SIZE(permissions) != BLOCK_PERMISSION__MAX);
2634 QEMU_BUILD_BUG_ON(1UL << ARRAY_SIZE(permissions) != BLK_PERM_ALL + 1);
2635
2636 assert(qapi_perm < BLOCK_PERMISSION__MAX);
2637
2638 return permissions[qapi_perm];
2639 }
2640
2641 static void bdrv_replace_child_noperm(BdrvChild *child,
2642 BlockDriverState *new_bs)
2643 {
2644 BlockDriverState *old_bs = child->bs;
2645 int new_bs_quiesce_counter;
2646 int drain_saldo;
2647
2648 assert(!child->frozen);
2649
2650 if (old_bs && new_bs) {
2651 assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
2652 }
2653
2654 new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0);
2655 drain_saldo = new_bs_quiesce_counter - child->parent_quiesce_counter;
2656
2657 /*
2658 * If the new child node is drained but the old one was not, flush
2659 * all outstanding requests to the old child node.
2660 */
2661 while (drain_saldo > 0 && child->klass->drained_begin) {
2662 bdrv_parent_drained_begin_single(child, true);
2663 drain_saldo--;
2664 }
2665
2666 if (old_bs) {
2667 /* Detach first so that the recursive drain sections coming from @child
2668 * are already gone and we only end the drain sections that came from
2669 * elsewhere. */
2670 if (child->klass->detach) {
2671 child->klass->detach(child);
2672 }
2673 QLIST_REMOVE(child, next_parent);
2674 }
2675
2676 child->bs = new_bs;
2677
2678 if (new_bs) {
2679 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
2680
2681 /*
2682 * Detaching the old node may have led to the new node's
2683 * quiesce_counter having been decreased. Not a problem, we
2684 * just need to recognize this here and then invoke
2685 * drained_end appropriately more often.
2686 */
2687 assert(new_bs->quiesce_counter <= new_bs_quiesce_counter);
2688 drain_saldo += new_bs->quiesce_counter - new_bs_quiesce_counter;
2689
2690 /* Attach only after starting new drained sections, so that recursive
2691 * drain sections coming from @child don't get an extra .drained_begin
2692 * callback. */
2693 if (child->klass->attach) {
2694 child->klass->attach(child);
2695 }
2696 }
2697
2698 /*
2699 * If the old child node was drained but the new one is not, allow
2700 * requests to come in only after the new node has been attached.
2701 */
2702 while (drain_saldo < 0 && child->klass->drained_end) {
2703 bdrv_parent_drained_end_single(child);
2704 drain_saldo++;
2705 }
2706 }
2707
2708 static void bdrv_child_free(void *opaque)
2709 {
2710 BdrvChild *c = opaque;
2711
2712 g_free(c->name);
2713 g_free(c);
2714 }
2715
2716 static void bdrv_remove_empty_child(BdrvChild *child)
2717 {
2718 assert(!child->bs);
2719 QLIST_SAFE_REMOVE(child, next);
2720 bdrv_child_free(child);
2721 }
2722
2723 typedef struct BdrvAttachChildCommonState {
2724 BdrvChild **child;
2725 AioContext *old_parent_ctx;
2726 AioContext *old_child_ctx;
2727 } BdrvAttachChildCommonState;
2728
2729 static void bdrv_attach_child_common_abort(void *opaque)
2730 {
2731 BdrvAttachChildCommonState *s = opaque;
2732 BdrvChild *child = *s->child;
2733 BlockDriverState *bs = child->bs;
2734
2735 bdrv_replace_child_noperm(child, NULL);
2736
2737 if (bdrv_get_aio_context(bs) != s->old_child_ctx) {
2738 bdrv_try_set_aio_context(bs, s->old_child_ctx, &error_abort);
2739 }
2740
2741 if (bdrv_child_get_parent_aio_context(child) != s->old_parent_ctx) {
2742 GSList *ignore = g_slist_prepend(NULL, child);
2743
2744 child->klass->can_set_aio_ctx(child, s->old_parent_ctx, &ignore,
2745 &error_abort);
2746 g_slist_free(ignore);
2747 ignore = g_slist_prepend(NULL, child);
2748 child->klass->set_aio_ctx(child, s->old_parent_ctx, &ignore);
2749
2750 g_slist_free(ignore);
2751 }
2752
2753 bdrv_unref(bs);
2754 bdrv_remove_empty_child(child);
2755 *s->child = NULL;
2756 }
2757
2758 static TransactionActionDrv bdrv_attach_child_common_drv = {
2759 .abort = bdrv_attach_child_common_abort,
2760 .clean = g_free,
2761 };
2762
2763 /*
2764 * Common part of attaching bdrv child to bs or to blk or to job
2765 *
2766 * Resulting new child is returned through @child.
2767 * At start *@child must be NULL.
2768 * @child is saved to a new entry of @tran, so that *@child could be reverted to
2769 * NULL on abort(). So referenced variable must live at least until transaction
2770 * end.
2771 */
2772 static int bdrv_attach_child_common(BlockDriverState *child_bs,
2773 const char *child_name,
2774 const BdrvChildClass *child_class,
2775 BdrvChildRole child_role,
2776 uint64_t perm, uint64_t shared_perm,
2777 void *opaque, BdrvChild **child,
2778 Transaction *tran, Error **errp)
2779 {
2780 BdrvChild *new_child;
2781 AioContext *parent_ctx;
2782 AioContext *child_ctx = bdrv_get_aio_context(child_bs);
2783
2784 assert(child);
2785 assert(*child == NULL);
2786 assert(child_class->get_parent_desc);
2787
2788 new_child = g_new(BdrvChild, 1);
2789 *new_child = (BdrvChild) {
2790 .bs = NULL,
2791 .name = g_strdup(child_name),
2792 .klass = child_class,
2793 .role = child_role,
2794 .perm = perm,
2795 .shared_perm = shared_perm,
2796 .opaque = opaque,
2797 };
2798
2799 /*
2800 * If the AioContexts don't match, first try to move the subtree of
2801 * child_bs into the AioContext of the new parent. If this doesn't work,
2802 * try moving the parent into the AioContext of child_bs instead.
2803 */
2804 parent_ctx = bdrv_child_get_parent_aio_context(new_child);
2805 if (child_ctx != parent_ctx) {
2806 Error *local_err = NULL;
2807 int ret = bdrv_try_set_aio_context(child_bs, parent_ctx, &local_err);
2808
2809 if (ret < 0 && child_class->can_set_aio_ctx) {
2810 GSList *ignore = g_slist_prepend(NULL, new_child);
2811 if (child_class->can_set_aio_ctx(new_child, child_ctx, &ignore,
2812 NULL))
2813 {
2814 error_free(local_err);
2815 ret = 0;
2816 g_slist_free(ignore);
2817 ignore = g_slist_prepend(NULL, new_child);
2818 child_class->set_aio_ctx(new_child, child_ctx, &ignore);
2819 }
2820 g_slist_free(ignore);
2821 }
2822
2823 if (ret < 0) {
2824 error_propagate(errp, local_err);
2825 bdrv_remove_empty_child(new_child);
2826 return ret;
2827 }
2828 }
2829
2830 bdrv_ref(child_bs);
2831 bdrv_replace_child_noperm(new_child, child_bs);
2832
2833 *child = new_child;
2834
2835 BdrvAttachChildCommonState *s = g_new(BdrvAttachChildCommonState, 1);
2836 *s = (BdrvAttachChildCommonState) {
2837 .child = child,
2838 .old_parent_ctx = parent_ctx,
2839 .old_child_ctx = child_ctx,
2840 };
2841 tran_add(tran, &bdrv_attach_child_common_drv, s);
2842
2843 return 0;
2844 }
2845
2846 /*
2847 * Variable referenced by @child must live at least until transaction end.
2848 * (see bdrv_attach_child_common() doc for details)
2849 */
2850 static int bdrv_attach_child_noperm(BlockDriverState *parent_bs,
2851 BlockDriverState *child_bs,
2852 const char *child_name,
2853 const BdrvChildClass *child_class,
2854 BdrvChildRole child_role,
2855 BdrvChild **child,
2856 Transaction *tran,
2857 Error **errp)
2858 {
2859 int ret;
2860 uint64_t perm, shared_perm;
2861
2862 assert(parent_bs->drv);
2863
2864 bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
2865 bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
2866 perm, shared_perm, &perm, &shared_perm);
2867
2868 ret = bdrv_attach_child_common(child_bs, child_name, child_class,
2869 child_role, perm, shared_perm, parent_bs,
2870 child, tran, errp);
2871 if (ret < 0) {
2872 return ret;
2873 }
2874
2875 QLIST_INSERT_HEAD(&parent_bs->children, *child, next);
2876 /*
2877 * child is removed in bdrv_attach_child_common_abort(), so don't care to
2878 * abort this change separately.
2879 */
2880
2881 return 0;
2882 }
2883
2884 static void bdrv_detach_child(BdrvChild *child)
2885 {
2886 BlockDriverState *old_bs = child->bs;
2887
2888 bdrv_replace_child_noperm(child, NULL);
2889 bdrv_remove_empty_child(child);
2890
2891 if (old_bs) {
2892 /*
2893 * Update permissions for old node. We're just taking a parent away, so
2894 * we're loosening restrictions. Errors of permission update are not
2895 * fatal in this case, ignore them.
2896 */
2897 bdrv_refresh_perms(old_bs, NULL);
2898
2899 /*
2900 * When the parent requiring a non-default AioContext is removed, the
2901 * node moves back to the main AioContext
2902 */
2903 bdrv_try_set_aio_context(old_bs, qemu_get_aio_context(), NULL);
2904 }
2905 }
2906
2907 /*
2908 * This function steals the reference to child_bs from the caller.
2909 * That reference is later dropped by bdrv_root_unref_child().
2910 *
2911 * On failure NULL is returned, errp is set and the reference to
2912 * child_bs is also dropped.
2913 *
2914 * The caller must hold the AioContext lock @child_bs, but not that of @ctx
2915 * (unless @child_bs is already in @ctx).
2916 */
2917 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
2918 const char *child_name,
2919 const BdrvChildClass *child_class,
2920 BdrvChildRole child_role,
2921 uint64_t perm, uint64_t shared_perm,
2922 void *opaque, Error **errp)
2923 {
2924 int ret;
2925 BdrvChild *child = NULL;
2926 Transaction *tran = tran_new();
2927
2928 ret = bdrv_attach_child_common(child_bs, child_name, child_class,
2929 child_role, perm, shared_perm, opaque,
2930 &child, tran, errp);
2931 if (ret < 0) {
2932 goto out;
2933 }
2934
2935 ret = bdrv_refresh_perms(child_bs, errp);
2936
2937 out:
2938 tran_finalize(tran, ret);
2939 /* child is unset on failure by bdrv_attach_child_common_abort() */
2940 assert((ret < 0) == !child);
2941
2942 bdrv_unref(child_bs);
2943 return child;
2944 }
2945
2946 /*
2947 * This function transfers the reference to child_bs from the caller
2948 * to parent_bs. That reference is later dropped by parent_bs on
2949 * bdrv_close() or if someone calls bdrv_unref_child().
2950 *
2951 * On failure NULL is returned, errp is set and the reference to
2952 * child_bs is also dropped.
2953 *
2954 * If @parent_bs and @child_bs are in different AioContexts, the caller must
2955 * hold the AioContext lock for @child_bs, but not for @parent_bs.
2956 */
2957 BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
2958 BlockDriverState *child_bs,
2959 const char *child_name,
2960 const BdrvChildClass *child_class,
2961 BdrvChildRole child_role,
2962 Error **errp)
2963 {
2964 int ret;
2965 BdrvChild *child = NULL;
2966 Transaction *tran = tran_new();
2967
2968 ret = bdrv_attach_child_noperm(parent_bs, child_bs, child_name, child_class,
2969 child_role, &child, tran, errp);
2970 if (ret < 0) {
2971 goto out;
2972 }
2973
2974 ret = bdrv_refresh_perms(parent_bs, errp);
2975 if (ret < 0) {
2976 goto out;
2977 }
2978
2979 out:
2980 tran_finalize(tran, ret);
2981 /* child is unset on failure by bdrv_attach_child_common_abort() */
2982 assert((ret < 0) == !child);
2983
2984 bdrv_unref(child_bs);
2985
2986 return child;
2987 }
2988
2989 /* Callers must ensure that child->frozen is false. */
2990 void bdrv_root_unref_child(BdrvChild *child)
2991 {
2992 BlockDriverState *child_bs;
2993
2994 child_bs = child->bs;
2995 bdrv_detach_child(child);
2996 bdrv_unref(child_bs);
2997 }
2998
2999 typedef struct BdrvSetInheritsFrom {
3000 BlockDriverState *bs;
3001 BlockDriverState *old_inherits_from;
3002 } BdrvSetInheritsFrom;
3003
3004 static void bdrv_set_inherits_from_abort(void *opaque)
3005 {
3006 BdrvSetInheritsFrom *s = opaque;
3007
3008 s->bs->inherits_from = s->old_inherits_from;
3009 }
3010
3011 static TransactionActionDrv bdrv_set_inherits_from_drv = {
3012 .abort = bdrv_set_inherits_from_abort,
3013 .clean = g_free,
3014 };
3015
3016 /* @tran is allowed to be NULL. In this case no rollback is possible */
3017 static void bdrv_set_inherits_from(BlockDriverState *bs,
3018 BlockDriverState *new_inherits_from,
3019 Transaction *tran)
3020 {
3021 if (tran) {
3022 BdrvSetInheritsFrom *s = g_new(BdrvSetInheritsFrom, 1);
3023
3024 *s = (BdrvSetInheritsFrom) {
3025 .bs = bs,
3026 .old_inherits_from = bs->inherits_from,
3027 };
3028
3029 tran_add(tran, &bdrv_set_inherits_from_drv, s);
3030 }
3031
3032 bs->inherits_from = new_inherits_from;
3033 }
3034
3035 /**
3036 * Clear all inherits_from pointers from children and grandchildren of
3037 * @root that point to @root, where necessary.
3038 * @tran is allowed to be NULL. In this case no rollback is possible
3039 */
3040 static void bdrv_unset_inherits_from(BlockDriverState *root, BdrvChild *child,
3041 Transaction *tran)
3042 {
3043 BdrvChild *c;
3044
3045 if (child->bs->inherits_from == root) {
3046 /*
3047 * Remove inherits_from only when the last reference between root and
3048 * child->bs goes away.
3049 */
3050 QLIST_FOREACH(c, &root->children, next) {
3051 if (c != child && c->bs == child->bs) {
3052 break;
3053 }
3054 }
3055 if (c == NULL) {
3056 bdrv_set_inherits_from(child->bs, NULL, tran);
3057 }
3058 }
3059
3060 QLIST_FOREACH(c, &child->bs->children, next) {
3061 bdrv_unset_inherits_from(root, c, tran);
3062 }
3063 }
3064
3065 /* Callers must ensure that child->frozen is false. */
3066 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
3067 {
3068 if (child == NULL) {
3069 return;
3070 }
3071
3072 bdrv_unset_inherits_from(parent, child, NULL);
3073 bdrv_root_unref_child(child);
3074 }
3075
3076
3077 static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
3078 {
3079 BdrvChild *c;
3080 QLIST_FOREACH(c, &bs->parents, next_parent) {
3081 if (c->klass->change_media) {
3082 c->klass->change_media(c, load);
3083 }
3084 }
3085 }
3086
3087 /* Return true if you can reach parent going through child->inherits_from
3088 * recursively. If parent or child are NULL, return false */
3089 static bool bdrv_inherits_from_recursive(BlockDriverState *child,
3090 BlockDriverState *parent)
3091 {
3092 while (child && child != parent) {
3093 child = child->inherits_from;
3094 }
3095
3096 return child != NULL;
3097 }
3098
3099 /*
3100 * Return the BdrvChildRole for @bs's backing child. bs->backing is
3101 * mostly used for COW backing children (role = COW), but also for
3102 * filtered children (role = FILTERED | PRIMARY).
3103 */
3104 static BdrvChildRole bdrv_backing_role(BlockDriverState *bs)
3105 {
3106 if (bs->drv && bs->drv->is_filter) {
3107 return BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
3108 } else {
3109 return BDRV_CHILD_COW;
3110 }
3111 }
3112
3113 /*
3114 * Sets the bs->backing link of a BDS. A new reference is created; callers
3115 * which don't need their own reference any more must call bdrv_unref().
3116 */
3117 static int bdrv_set_backing_noperm(BlockDriverState *bs,
3118 BlockDriverState *backing_hd,
3119 Transaction *tran, Error **errp)
3120 {
3121 int ret = 0;
3122 bool update_inherits_from = bdrv_chain_contains(bs, backing_hd) &&
3123 bdrv_inherits_from_recursive(backing_hd, bs);
3124
3125 if (bdrv_is_backing_chain_frozen(bs, child_bs(bs->backing), errp)) {
3126 return -EPERM;
3127 }
3128
3129 if (bs->backing) {
3130 /* Cannot be frozen, we checked that above */
3131 bdrv_unset_inherits_from(bs, bs->backing, tran);
3132 bdrv_remove_filter_or_cow_child(bs, tran);
3133 }
3134
3135 if (!backing_hd) {
3136 goto out;
3137 }
3138
3139 ret = bdrv_attach_child_noperm(bs, backing_hd, "backing",
3140 &child_of_bds, bdrv_backing_role(bs),
3141 &bs->backing, tran, errp);
3142 if (ret < 0) {
3143 return ret;
3144 }
3145
3146
3147 /*
3148 * If backing_hd was already part of bs's backing chain, and
3149 * inherits_from pointed recursively to bs then let's update it to
3150 * point directly to bs (else it will become NULL).
3151 */
3152 if (update_inherits_from) {
3153 bdrv_set_inherits_from(backing_hd, bs, tran);
3154 }
3155
3156 out:
3157 bdrv_refresh_limits(bs, tran, NULL);
3158
3159 return 0;
3160 }
3161
3162 int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
3163 Error **errp)
3164 {
3165 int ret;
3166 Transaction *tran = tran_new();
3167
3168 ret = bdrv_set_backing_noperm(bs, backing_hd, tran, errp);
3169 if (ret < 0) {
3170 goto out;
3171 }
3172
3173 ret = bdrv_refresh_perms(bs, errp);
3174 out:
3175 tran_finalize(tran, ret);
3176
3177 return ret;
3178 }
3179
3180 /*
3181 * Opens the backing file for a BlockDriverState if not yet open
3182 *
3183 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
3184 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
3185 * itself, all options starting with "${bdref_key}." are considered part of the
3186 * BlockdevRef.
3187 *
3188 * TODO Can this be unified with bdrv_open_image()?
3189 */
3190 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
3191 const char *bdref_key, Error **errp)
3192 {
3193 char *backing_filename = NULL;
3194 char *bdref_key_dot;
3195 const char *reference = NULL;
3196 int ret = 0;
3197 bool implicit_backing = false;
3198 BlockDriverState *backing_hd;
3199 QDict *options;
3200 QDict *tmp_parent_options = NULL;
3201 Error *local_err = NULL;
3202
3203 if (bs->backing != NULL) {
3204 goto free_exit;
3205 }
3206
3207 /* NULL means an empty set of options */
3208 if (parent_options == NULL) {
3209 tmp_parent_options = qdict_new();
3210 parent_options = tmp_parent_options;
3211 }
3212
3213 bs->open_flags &= ~BDRV_O_NO_BACKING;
3214
3215 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
3216 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
3217 g_free(bdref_key_dot);
3218
3219 /*
3220 * Caution: while qdict_get_try_str() is fine, getting non-string
3221 * types would require more care. When @parent_options come from
3222 * -blockdev or blockdev_add, its members are typed according to
3223 * the QAPI schema, but when they come from -drive, they're all
3224 * QString.
3225 */
3226 reference = qdict_get_try_str(parent_options, bdref_key);
3227 if (reference || qdict_haskey(options, "file.filename")) {
3228 /* keep backing_filename NULL */
3229 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
3230 qobject_unref(options);
3231 goto free_exit;
3232 } else {
3233 if (qdict_size(options) == 0) {
3234 /* If the user specifies options that do not modify the
3235 * backing file's behavior, we might still consider it the
3236 * implicit backing file. But it's easier this way, and
3237 * just specifying some of the backing BDS's options is
3238 * only possible with -drive anyway (otherwise the QAPI
3239 * schema forces the user to specify everything). */
3240 implicit_backing = !strcmp(bs->auto_backing_file, bs->backing_file);
3241 }
3242
3243 backing_filename = bdrv_get_full_backing_filename(bs, &local_err);
3244 if (local_err) {
3245 ret = -EINVAL;
3246 error_propagate(errp, local_err);
3247 qobject_unref(options);
3248 goto free_exit;
3249 }
3250 }
3251
3252 if (!bs->drv || !bs->drv->supports_backing) {
3253 ret = -EINVAL;
3254 error_setg(errp, "Driver doesn't support backing files");
3255 qobject_unref(options);
3256 goto free_exit;
3257 }
3258
3259 if (!reference &&
3260 bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
3261 qdict_put_str(options, "driver", bs->backing_format);
3262 }
3263
3264 backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs,
3265 &child_of_bds, bdrv_backing_role(bs), errp);
3266 if (!backing_hd) {
3267 bs->open_flags |= BDRV_O_NO_BACKING;
3268 error_prepend(errp, "Could not open backing file: ");
3269 ret = -EINVAL;
3270 goto free_exit;
3271 }
3272
3273 if (implicit_backing) {
3274 bdrv_refresh_filename(backing_hd);
3275 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
3276 backing_hd->filename);
3277 }
3278
3279 /* Hook up the backing file link; drop our reference, bs owns the
3280 * backing_hd reference now */
3281 ret = bdrv_set_backing_hd(bs, backing_hd, errp);
3282 bdrv_unref(backing_hd);
3283 if (ret < 0) {
3284 goto free_exit;
3285 }
3286
3287 qdict_del(parent_options, bdref_key);
3288
3289 free_exit:
3290 g_free(backing_filename);
3291 qobject_unref(tmp_parent_options);
3292 return ret;
3293 }
3294
3295 static BlockDriverState *
3296 bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
3297 BlockDriverState *parent, const BdrvChildClass *child_class,
3298 BdrvChildRole child_role, bool allow_none, Error **errp)
3299 {
3300 BlockDriverState *bs = NULL;
3301 QDict *image_options;
3302 char *bdref_key_dot;
3303 const char *reference;
3304
3305 assert(child_class != NULL);
3306
3307 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
3308 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
3309 g_free(bdref_key_dot);
3310
3311 /*
3312 * Caution: while qdict_get_try_str() is fine, getting non-string
3313 * types would require more care. When @options come from
3314 * -blockdev or blockdev_add, its members are typed according to
3315 * the QAPI schema, but when they come from -drive, they're all
3316 * QString.
3317 */
3318 reference = qdict_get_try_str(options, bdref_key);
3319 if (!filename && !reference && !qdict_size(image_options)) {
3320 if (!allow_none) {
3321 error_setg(errp, "A block device must be specified for \"%s\"",
3322 bdref_key);
3323 }
3324 qobject_unref(image_options);
3325 goto done;
3326 }
3327
3328 bs = bdrv_open_inherit(filename, reference, image_options, 0,
3329 parent, child_class, child_role, errp);
3330 if (!bs) {
3331 goto done;
3332 }
3333
3334 done:
3335 qdict_del(options, bdref_key);
3336 return bs;
3337 }
3338
3339 /*
3340 * Opens a disk image whose options are given as BlockdevRef in another block
3341 * device's options.
3342 *
3343 * If allow_none is true, no image will be opened if filename is false and no
3344 * BlockdevRef is given. NULL will be returned, but errp remains unset.
3345 *
3346 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
3347 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
3348 * itself, all options starting with "${bdref_key}." are considered part of the
3349 * BlockdevRef.
3350 *
3351 * The BlockdevRef will be removed from the options QDict.
3352 */
3353 BdrvChild *bdrv_open_child(const char *filename,
3354 QDict *options, const char *bdref_key,
3355 BlockDriverState *parent,
3356 const BdrvChildClass *child_class,
3357 BdrvChildRole child_role,
3358 bool allow_none, Error **errp)
3359 {
3360 BlockDriverState *bs;
3361
3362 bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_class,
3363 child_role, allow_none, errp);
3364 if (bs == NULL) {
3365 return NULL;
3366 }
3367
3368 return bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
3369 errp);
3370 }
3371
3372 /*
3373 * TODO Future callers may need to specify parent/child_class in order for
3374 * option inheritance to work. Existing callers use it for the root node.
3375 */
3376 BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
3377 {
3378 BlockDriverState *bs = NULL;
3379 QObject *obj = NULL;
3380 QDict *qdict = NULL;
3381 const char *reference = NULL;
3382 Visitor *v = NULL;
3383
3384 if (ref->type == QTYPE_QSTRING) {
3385 reference = ref->u.reference;
3386 } else {
3387 BlockdevOptions *options = &ref->u.definition;
3388 assert(ref->type == QTYPE_QDICT);
3389
3390 v = qobject_output_visitor_new(&obj);
3391 visit_type_BlockdevOptions(v, NULL, &options, &error_abort);
3392 visit_complete(v, &obj);
3393
3394 qdict = qobject_to(QDict, obj);
3395 qdict_flatten(qdict);
3396
3397 /* bdrv_open_inherit() defaults to the values in bdrv_flags (for
3398 * compatibility with other callers) rather than what we want as the
3399 * real defaults. Apply the defaults here instead. */
3400 qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
3401 qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
3402 qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off");
3403 qdict_set_default_str(qdict, BDRV_OPT_AUTO_READ_ONLY, "off");
3404
3405 }
3406
3407 bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, 0, errp);
3408 obj = NULL;
3409 qobject_unref(obj);
3410 visit_free(v);
3411 return bs;
3412 }
3413
3414 static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
3415 int flags,
3416 QDict *snapshot_options,
3417 Error **errp)
3418 {
3419 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
3420 char *tmp_filename = g_malloc0(PATH_MAX + 1);
3421 int64_t total_size;
3422 QemuOpts *opts = NULL;
3423 BlockDriverState *bs_snapshot = NULL;
3424 int ret;
3425
3426 /* if snapshot, we create a temporary backing file and open it
3427 instead of opening 'filename' directly */
3428
3429 /* Get the required size from the image */
3430 total_size = bdrv_getlength(bs);
3431 if (total_size < 0) {
3432 error_setg_errno(errp, -total_size, "Could not get image size");
3433 goto out;
3434 }
3435
3436 /* Create the temporary image */
3437 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
3438 if (ret < 0) {
3439 error_setg_errno(errp, -ret, "Could not get temporary filename");
3440 goto out;
3441 }
3442
3443 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
3444 &error_abort);
3445 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
3446 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
3447 qemu_opts_del(opts);
3448 if (ret < 0) {
3449 error_prepend(errp, "Could not create temporary overlay '%s': ",
3450 tmp_filename);
3451 goto out;
3452 }
3453
3454 /* Prepare options QDict for the temporary file */
3455 qdict_put_str(snapshot_options, "file.driver", "file");
3456 qdict_put_str(snapshot_options, "file.filename", tmp_filename);
3457 qdict_put_str(snapshot_options, "driver", "qcow2");
3458
3459 bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
3460 snapshot_options = NULL;
3461 if (!bs_snapshot) {
3462 goto out;
3463 }
3464
3465 ret = bdrv_append(bs_snapshot, bs, errp);
3466 if (ret < 0) {
3467 bs_snapshot = NULL;
3468 goto out;
3469 }
3470
3471 out:
3472 qobject_unref(snapshot_options);
3473 g_free(tmp_filename);
3474 return bs_snapshot;
3475 }
3476
3477 /*
3478 * Opens a disk image (raw, qcow2, vmdk, ...)
3479 *
3480 * options is a QDict of options to pass to the block drivers, or NULL for an
3481 * empty set of options. The reference to the QDict belongs to the block layer
3482 * after the call (even on failure), so if the caller intends to reuse the
3483 * dictionary, it needs to use qobject_ref() before calling bdrv_open.
3484 *
3485 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
3486 * If it is not NULL, the referenced BDS will be reused.
3487 *
3488 * The reference parameter may be used to specify an existing block device which
3489 * should be opened. If specified, neither options nor a filename may be given,
3490 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
3491 */
3492 static BlockDriverState *bdrv_open_inherit(const char *filename,
3493 const char *reference,
3494 QDict *options, int flags,
3495 BlockDriverState *parent,
3496 const BdrvChildClass *child_class,
3497 BdrvChildRole child_role,
3498 Error **errp)
3499 {
3500 int ret;
3501 BlockBackend *file = NULL;
3502 BlockDriverState *bs;
3503 BlockDriver *drv = NULL;
3504 BdrvChild *child;
3505 const char *drvname;
3506 const char *backing;
3507 Error *local_err = NULL;
3508 QDict *snapshot_options = NULL;
3509 int snapshot_flags = 0;
3510
3511 assert(!child_class || !flags);
3512 assert(!child_class == !parent);
3513
3514 if (reference) {
3515 bool options_non_empty = options ? qdict_size(options) : false;
3516 qobject_unref(options);
3517
3518 if (filename || options_non_empty) {
3519 error_setg(errp, "Cannot reference an existing block device with "
3520 "additional options or a new filename");
3521 return NULL;
3522 }
3523
3524 bs = bdrv_lookup_bs(reference, reference, errp);
3525 if (!bs) {
3526 return NULL;
3527 }
3528
3529 bdrv_ref(bs);
3530 return bs;
3531 }
3532
3533 bs = bdrv_new();
3534
3535 /* NULL means an empty set of options */
3536 if (options == NULL) {
3537 options = qdict_new();
3538 }
3539
3540 /* json: syntax counts as explicit options, as if in the QDict */
3541 parse_json_protocol(options, &filename, &local_err);
3542 if (local_err) {
3543 goto fail;
3544 }
3545
3546 bs->explicit_options = qdict_clone_shallow(options);
3547
3548 if (child_class) {
3549 bool parent_is_format;
3550
3551 if (parent->drv) {
3552 parent_is_format = parent->drv->is_format;
3553 } else {
3554 /*
3555 * parent->drv is not set yet because this node is opened for
3556 * (potential) format probing. That means that @parent is going
3557 * to be a format node.
3558 */
3559 parent_is_format = true;
3560 }
3561
3562 bs->inherits_from = parent;
3563 child_class->inherit_options(child_role, parent_is_format,
3564 &flags, options,
3565 parent->open_flags, parent->options);
3566 }
3567
3568 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
3569 if (ret < 0) {
3570 goto fail;
3571 }
3572
3573 /*
3574 * Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags.
3575 * Caution: getting a boolean member of @options requires care.
3576 * When @options come from -blockdev or blockdev_add, members are
3577 * typed according to the QAPI schema, but when they come from
3578 * -drive, they're all QString.
3579 */
3580 if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
3581 !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
3582 flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
3583 } else {
3584 flags &= ~BDRV_O_RDWR;
3585 }
3586
3587 if (flags & BDRV_O_SNAPSHOT) {
3588 snapshot_options = qdict_new();
3589 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
3590 flags, options);
3591 /* Let bdrv_backing_options() override "read-only" */
3592 qdict_del(options, BDRV_OPT_READ_ONLY);
3593 bdrv_inherited_options(BDRV_CHILD_COW, true,
3594 &flags, options, flags, options);
3595 }
3596
3597 bs->open_flags = flags;
3598 bs->options = options;
3599 options = qdict_clone_shallow(options);
3600
3601 /* Find the right image format driver */
3602 /* See cautionary note on accessing @options above */
3603 drvname = qdict_get_try_str(options, "driver");
3604 if (drvname) {
3605 drv = bdrv_find_format(drvname);
3606 if (!drv) {
3607 error_setg(errp, "Unknown driver: '%s'", drvname);
3608 goto fail;
3609 }
3610 }
3611
3612 assert(drvname || !(flags & BDRV_O_PROTOCOL));
3613
3614 /* See cautionary note on accessing @options above */
3615 backing = qdict_get_try_str(options, "backing");
3616 if (qobject_to(QNull, qdict_get(options, "backing")) != NULL ||
3617 (backing && *backing == '\0'))
3618 {
3619 if (backing) {
3620 warn_report("Use of \"backing\": \"\" is deprecated; "
3621 "use \"backing\": null instead");
3622 }
3623 flags |= BDRV_O_NO_BACKING;
3624 qdict_del(bs->explicit_options, "backing");
3625 qdict_del(bs->options, "backing");
3626 qdict_del(options, "backing");
3627 }
3628
3629 /* Open image file without format layer. This BlockBackend is only used for
3630 * probing, the block drivers will do their own bdrv_open_child() for the
3631 * same BDS, which is why we put the node name back into options. */
3632 if ((flags & BDRV_O_PROTOCOL) == 0) {
3633 BlockDriverState *file_bs;
3634
3635 file_bs = bdrv_open_child_bs(filename, options, "file", bs,
3636 &child_of_bds, BDRV_CHILD_IMAGE,
3637 true, &local_err);
3638 if (local_err) {
3639 goto fail;
3640 }
3641 if (file_bs != NULL) {
3642 /* Not requesting BLK_PERM_CONSISTENT_READ because we're only
3643 * looking at the header to guess the image format. This works even
3644 * in cases where a guest would not see a consistent state. */
3645 file = blk_new(bdrv_get_aio_context(file_bs), 0, BLK_PERM_ALL);
3646 blk_insert_bs(file, file_bs, &local_err);
3647 bdrv_unref(file_bs);
3648 if (local_err) {
3649 goto fail;
3650 }
3651
3652 qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
3653 }
3654 }
3655
3656 /* Image format probing */
3657 bs->probed = !drv;
3658 if (!drv && file) {
3659 ret = find_image_format(file, filename, &drv, &local_err);
3660 if (ret < 0) {
3661 goto fail;
3662 }
3663 /*
3664 * This option update would logically belong in bdrv_fill_options(),
3665 * but we first need to open bs->file for the probing to work, while
3666 * opening bs->file already requires the (mostly) final set of options
3667 * so that cache mode etc. can be inherited.
3668 *
3669 * Adding the driver later is somewhat ugly, but it's not an option
3670 * that would ever be inherited, so it's correct. We just need to make
3671 * sure to update both bs->options (which has the full effective
3672 * options for bs) and options (which has file.* already removed).
3673 */
3674 qdict_put_str(bs->options, "driver", drv->format_name);
3675 qdict_put_str(options, "driver", drv->format_name);
3676 } else if (!drv) {
3677 error_setg(errp, "Must specify either driver or file");
3678 goto fail;
3679 }
3680
3681 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
3682 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
3683 /* file must be NULL if a protocol BDS is about to be created
3684 * (the inverse results in an error message from bdrv_open_common()) */
3685 assert(!(flags & BDRV_O_PROTOCOL) || !file);
3686
3687 /* Open the image */
3688 ret = bdrv_open_common(bs, file, options, &local_err);
3689 if (ret < 0) {
3690 goto fail;
3691 }
3692
3693 if (file) {
3694 blk_unref(file);
3695 file = NULL;
3696 }
3697
3698 /* If there is a backing file, use it */
3699 if ((flags & BDRV_O_NO_BACKING) == 0) {
3700 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
3701 if (ret < 0) {
3702 goto close_and_fail;
3703 }
3704 }
3705
3706 /* Remove all children options and references
3707 * from bs->options and bs->explicit_options */
3708 QLIST_FOREACH(child, &bs->children, next) {
3709 char *child_key_dot;
3710 child_key_dot = g_strdup_printf("%s.", child->name);
3711 qdict_extract_subqdict(bs->explicit_options, NULL, child_key_dot);
3712 qdict_extract_subqdict(bs->options, NULL, child_key_dot);
3713 qdict_del(bs->explicit_options, child->name);
3714 qdict_del(bs->options, child->name);
3715 g_free(child_key_dot);
3716 }
3717
3718 /* Check if any unknown options were used */
3719 if (qdict_size(options) != 0) {
3720 const QDictEntry *entry = qdict_first(options);
3721 if (flags & BDRV_O_PROTOCOL) {
3722 error_setg(errp, "Block protocol '%s' doesn't support the option "
3723 "'%s'", drv->format_name, entry->key);
3724 } else {
3725 error_setg(errp,
3726 "Block format '%s' does not support the option '%s'",
3727 drv->format_name, entry->key);
3728 }
3729
3730 goto close_and_fail;
3731 }
3732
3733 bdrv_parent_cb_change_media(bs, true);
3734
3735 qobject_unref(options);
3736 options = NULL;
3737
3738 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
3739 * temporary snapshot afterwards. */
3740 if (snapshot_flags) {
3741 BlockDriverState *snapshot_bs;
3742 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
3743 snapshot_options, &local_err);
3744 snapshot_options = NULL;
3745 if (local_err) {
3746 goto close_and_fail;
3747 }
3748 /* We are not going to return bs but the overlay on top of it
3749 * (snapshot_bs); thus, we have to drop the strong reference to bs
3750 * (which we obtained by calling bdrv_new()). bs will not be deleted,
3751 * though, because the overlay still has a reference to it. */
3752 bdrv_unref(bs);
3753 bs = snapshot_bs;
3754 }
3755
3756 return bs;
3757
3758 fail:
3759 blk_unref(file);
3760 qobject_unref(snapshot_options);
3761 qobject_unref(bs->explicit_options);
3762 qobject_unref(bs->options);
3763 qobject_unref(options);
3764 bs->options = NULL;
3765 bs->explicit_options = NULL;
3766 bdrv_unref(bs);
3767 error_propagate(errp, local_err);
3768 return NULL;
3769
3770 close_and_fail:
3771 bdrv_unref(bs);
3772 qobject_unref(snapshot_options);
3773 qobject_unref(options);
3774 error_propagate(errp, local_err);
3775 return NULL;
3776 }
3777
3778 BlockDriverState *bdrv_open(const char *filename, const char *reference,
3779 QDict *options, int flags, Error **errp)
3780 {
3781 return bdrv_open_inherit(filename, reference, options, flags, NULL,
3782 NULL, 0, errp);
3783 }
3784
3785 /* Return true if the NULL-terminated @list contains @str */
3786 static bool is_str_in_list(const char *str, const char *const *list)
3787 {
3788 if (str && list) {
3789 int i;
3790 for (i = 0; list[i] != NULL; i++) {
3791 if (!strcmp(str, list[i])) {
3792 return true;
3793 }
3794 }
3795 }
3796 return false;
3797 }
3798
3799 /*
3800 * Check that every option set in @bs->options is also set in
3801 * @new_opts.
3802 *
3803 * Options listed in the common_options list and in
3804 * @bs->drv->mutable_opts are skipped.
3805 *
3806 * Return 0 on success, otherwise return -EINVAL and set @errp.
3807 */
3808 static int bdrv_reset_options_allowed(BlockDriverState *bs,
3809 const QDict *new_opts, Error **errp)
3810 {
3811 const QDictEntry *e;
3812 /* These options are common to all block drivers and are handled
3813 * in bdrv_reopen_prepare() so they can be left out of @new_opts */
3814 const char *const common_options[] = {
3815 "node-name", "discard", "cache.direct", "cache.no-flush",
3816 "read-only", "auto-read-only", "detect-zeroes", NULL
3817 };
3818
3819 for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {
3820 if (!qdict_haskey(new_opts, e->key) &&
3821 !is_str_in_list(e->key, common_options) &&
3822 !is_str_in_list(e->key, bs->drv->mutable_opts)) {
3823 error_setg(errp, "Option '%s' cannot be reset "
3824 "to its default value", e->key);
3825 return -EINVAL;
3826 }
3827 }
3828
3829 return 0;
3830 }
3831
3832 /*
3833 * Returns true if @child can be reached recursively from @bs
3834 */
3835 static bool bdrv_recurse_has_child(BlockDriverState *bs,
3836 BlockDriverState *child)
3837 {
3838 BdrvChild *c;
3839
3840 if (bs == child) {
3841 return true;
3842 }
3843
3844 QLIST_FOREACH(c, &bs->children, next) {
3845 if (bdrv_recurse_has_child(c->bs, child)) {
3846 return true;
3847 }
3848 }
3849
3850 return false;
3851 }
3852
3853 /*
3854 * Adds a BlockDriverState to a simple queue for an atomic, transactional
3855 * reopen of multiple devices.
3856 *
3857 * bs_queue can either be an existing BlockReopenQueue that has had QTAILQ_INIT
3858 * already performed, or alternatively may be NULL a new BlockReopenQueue will
3859 * be created and initialized. This newly created BlockReopenQueue should be
3860 * passed back in for subsequent calls that are intended to be of the same
3861 * atomic 'set'.
3862 *
3863 * bs is the BlockDriverState to add to the reopen queue.
3864 *
3865 * options contains the changed options for the associated bs
3866 * (the BlockReopenQueue takes ownership)
3867 *
3868 * flags contains the open flags for the associated bs
3869 *
3870 * returns a pointer to bs_queue, which is either the newly allocated
3871 * bs_queue, or the existing bs_queue being used.
3872 *
3873 * bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple().
3874 */
3875 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
3876 BlockDriverState *bs,
3877 QDict *options,
3878 const BdrvChildClass *klass,
3879 BdrvChildRole role,
3880 bool parent_is_format,
3881 QDict *parent_options,
3882 int parent_flags,
3883 bool keep_old_opts)
3884 {
3885 assert(bs != NULL);
3886
3887 BlockReopenQueueEntry *bs_entry;
3888 BdrvChild *child;
3889 QDict *old_options, *explicit_options, *options_copy;
3890 int flags;
3891 QemuOpts *opts;
3892
3893 /* Make sure that the caller remembered to use a drained section. This is
3894 * important to avoid graph changes between the recursive queuing here and
3895 * bdrv_reopen_multiple(). */
3896 assert(bs->quiesce_counter > 0);
3897
3898 if (bs_queue == NULL) {
3899 bs_queue = g_new0(BlockReopenQueue, 1);
3900 QTAILQ_INIT(bs_queue);
3901 }
3902
3903 if (!options) {
3904 options = qdict_new();
3905 }
3906
3907 /* Check if this BlockDriverState is already in the queue */
3908 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
3909 if (bs == bs_entry->state.bs) {
3910 break;
3911 }
3912 }
3913
3914 /*
3915 * Precedence of options:
3916 * 1. Explicitly passed in options (highest)
3917 * 2. Retained from explicitly set options of bs
3918 * 3. Inherited from parent node
3919 * 4. Retained from effective options of bs
3920 */
3921
3922 /* Old explicitly set values (don't overwrite by inherited value) */
3923 if (bs_entry || keep_old_opts) {
3924 old_options = qdict_clone_shallow(bs_entry ?
3925 bs_entry->state.explicit_options :
3926 bs->explicit_options);
3927 bdrv_join_options(bs, options, old_options);
3928 qobject_unref(old_options);
3929 }
3930
3931 explicit_options = qdict_clone_shallow(options);
3932
3933 /* Inherit from parent node */
3934 if (parent_options) {
3935 flags = 0;
3936 klass->inherit_options(role, parent_is_format, &flags, options,
3937 parent_flags, parent_options);
3938 } else {
3939 flags = bdrv_get_flags(bs);
3940 }
3941
3942 if (keep_old_opts) {
3943 /* Old values are used for options that aren't set yet */
3944 old_options = qdict_clone_shallow(bs->options);
3945 bdrv_join_options(bs, options, old_options);
3946 qobject_unref(old_options);
3947 }
3948
3949 /* We have the final set of options so let's update the flags */
3950 options_copy = qdict_clone_shallow(options);
3951 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
3952 qemu_opts_absorb_qdict(opts, options_copy, NULL);
3953 update_flags_from_options(&flags, opts);
3954 qemu_opts_del(opts);
3955 qobject_unref(options_copy);
3956
3957 /* bdrv_open_inherit() sets and clears some additional flags internally */
3958 flags &= ~BDRV_O_PROTOCOL;
3959 if (flags & BDRV_O_RDWR) {
3960 flags |= BDRV_O_ALLOW_RDWR;
3961 }
3962
3963 if (!bs_entry) {
3964 bs_entry = g_new0(BlockReopenQueueEntry, 1);
3965 QTAILQ_INSERT_TAIL(bs_queue, bs_entry, entry);
3966 } else {
3967 qobject_unref(bs_entry->state.options);
3968 qobject_unref(bs_entry->state.explicit_options);
3969 }
3970
3971 bs_entry->state.bs = bs;
3972 bs_entry->state.options = options;
3973 bs_entry->state.explicit_options = explicit_options;
3974 bs_entry->state.flags = flags;
3975
3976 /*
3977 * If keep_old_opts is false then it means that unspecified
3978 * options must be reset to their original value. We don't allow
3979 * resetting 'backing' but we need to know if the option is
3980 * missing in order to decide if we have to return an error.
3981 */
3982 if (!keep_old_opts) {
3983 bs_entry->state.backing_missing =
3984 !qdict_haskey(options, "backing") &&
3985 !qdict_haskey(options, "backing.driver");
3986 }
3987
3988 QLIST_FOREACH(child, &bs->children, next) {
3989 QDict *new_child_options = NULL;
3990 bool child_keep_old = keep_old_opts;
3991
3992 /* reopen can only change the options of block devices that were
3993 * implicitly created and inherited options. For other (referenced)
3994 * block devices, a syntax like "backing.foo" results in an error. */
3995 if (child->bs->inherits_from != bs) {
3996 continue;
3997 }
3998
3999 /* Check if the options contain a child reference */
4000 if (qdict_haskey(options, child->name)) {
4001 const char *childref = qdict_get_try_str(options, child->name);
4002 /*
4003 * The current child must not be reopened if the child
4004 * reference is null or points to a different node.
4005 */
4006 if (g_strcmp0(childref, child->bs->node_name)) {
4007 continue;
4008 }
4009 /*
4010 * If the child reference points to the current child then
4011 * reopen it with its existing set of options (note that
4012 * it can still inherit new options from the parent).
4013 */
4014 child_keep_old = true;
4015 } else {
4016 /* Extract child options ("child-name.*") */
4017 char *child_key_dot = g_strdup_printf("%s.", child->name);
4018 qdict_extract_subqdict(explicit_options, NULL, child_key_dot);
4019 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
4020 g_free(child_key_dot);
4021 }
4022
4023 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options,
4024 child->klass, child->role, bs->drv->is_format,
4025 options, flags, child_keep_old);
4026 }
4027
4028 return bs_queue;
4029 }
4030
4031 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
4032 BlockDriverState *bs,
4033 QDict *options, bool keep_old_opts)
4034 {
4035 return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, 0, false,
4036 NULL, 0, keep_old_opts);
4037 }
4038
4039 /*
4040 * Reopen multiple BlockDriverStates atomically & transactionally.
4041 *
4042 * The queue passed in (bs_queue) must have been built up previous
4043 * via bdrv_reopen_queue().
4044 *
4045 * Reopens all BDS specified in the queue, with the appropriate
4046 * flags. All devices are prepared for reopen, and failure of any
4047 * device will cause all device changes to be abandoned, and intermediate
4048 * data cleaned up.
4049 *
4050 * If all devices prepare successfully, then the changes are committed
4051 * to all devices.
4052 *
4053 * All affected nodes must be drained between bdrv_reopen_queue() and
4054 * bdrv_reopen_multiple().
4055 */
4056 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
4057 {
4058 int ret = -1;
4059 BlockReopenQueueEntry *bs_entry, *next;
4060 Transaction *tran = tran_new();
4061 g_autoptr(GHashTable) found = NULL;
4062 g_autoptr(GSList) refresh_list = NULL;
4063
4064 assert(bs_queue != NULL);
4065
4066 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
4067 ret = bdrv_flush(bs_entry->state.bs);
4068 if (ret < 0) {
4069 error_setg_errno(errp, -ret, "Error flushing drive");
4070 goto abort;
4071 }
4072 }
4073
4074 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
4075 assert(bs_entry->state.bs->quiesce_counter > 0);
4076 ret = bdrv_reopen_prepare(&bs_entry->state, bs_queue, tran, errp);
4077 if (ret < 0) {
4078 goto abort;
4079 }
4080 bs_entry->prepared = true;
4081 }
4082
4083 found = g_hash_table_new(NULL, NULL);
4084 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
4085 BDRVReopenState *state = &bs_entry->state;
4086
4087 refresh_list = bdrv_topological_dfs(refresh_list, found, state->bs);
4088 if (state->old_backing_bs) {
4089 refresh_list = bdrv_topological_dfs(refresh_list, found,
4090 state->old_backing_bs);
4091 }
4092 }
4093
4094 /*
4095 * Note that file-posix driver rely on permission update done during reopen
4096 * (even if no permission changed), because it wants "new" permissions for
4097 * reconfiguring the fd and that's why it does it in raw_check_perm(), not
4098 * in raw_reopen_prepare() which is called with "old" permissions.
4099 */
4100 ret = bdrv_list_refresh_perms(refresh_list, bs_queue, tran, errp);
4101 if (ret < 0) {
4102 goto abort;
4103 }
4104
4105 /*
4106 * If we reach this point, we have success and just need to apply the
4107 * changes.
4108 *
4109 * Reverse order is used to comfort qcow2 driver: on commit it need to write
4110 * IN_USE flag to the image, to mark bitmaps in the image as invalid. But
4111 * children are usually goes after parents in reopen-queue, so go from last
4112 * to first element.
4113 */
4114 QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
4115 bdrv_reopen_commit(&bs_entry->state);
4116 }
4117
4118 tran_commit(tran);
4119
4120 QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
4121 BlockDriverState *bs = bs_entry->state.bs;
4122
4123 if (bs->drv->bdrv_reopen_commit_post) {
4124 bs->drv->bdrv_reopen_commit_post(&bs_entry->state);
4125 }
4126 }
4127
4128 ret = 0;
4129 goto cleanup;
4130
4131 abort:
4132 tran_abort(tran);
4133 QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
4134 if (bs_entry->prepared) {
4135 bdrv_reopen_abort(&bs_entry->state);
4136 }
4137 qobject_unref(bs_entry->state.explicit_options);
4138 qobject_unref(bs_entry->state.options);
4139 }
4140
4141 cleanup:
4142 QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
4143 g_free(bs_entry);
4144 }
4145 g_free(bs_queue);
4146
4147 return ret;
4148 }
4149
4150 int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
4151 Error **errp)
4152 {
4153 int ret;
4154 BlockReopenQueue *queue;
4155 QDict *opts = qdict_new();
4156
4157 qdict_put_bool(opts, BDRV_OPT_READ_ONLY, read_only);
4158
4159 bdrv_subtree_drained_begin(bs);
4160 queue = bdrv_reopen_queue(NULL, bs, opts, true);
4161 ret = bdrv_reopen_multiple(queue, errp);
4162 bdrv_subtree_drained_end(bs);
4163
4164 return ret;
4165 }
4166
4167 static bool bdrv_reopen_can_attach(BlockDriverState *parent,
4168 BdrvChild *child,
4169 BlockDriverState *new_child,
4170 Error **errp)
4171 {
4172 AioContext *parent_ctx = bdrv_get_aio_context(parent);
4173 AioContext *child_ctx = bdrv_get_aio_context(new_child);
4174 GSList *ignore;
4175 bool ret;
4176
4177 ignore = g_slist_prepend(NULL, child);
4178 ret = bdrv_can_set_aio_context(new_child, parent_ctx, &ignore, NULL);
4179 g_slist_free(ignore);
4180 if (ret) {
4181 return ret;
4182 }
4183
4184 ignore = g_slist_prepend(NULL, child);
4185 ret = bdrv_can_set_aio_context(parent, child_ctx, &ignore, errp);
4186 g_slist_free(ignore);
4187 return ret;
4188 }
4189
4190 /*
4191 * Take a BDRVReopenState and check if the value of 'backing' in the
4192 * reopen_state->options QDict is valid or not.
4193 *
4194 * If 'backing' is missing from the QDict then return 0.
4195 *
4196 * If 'backing' contains the node name of the backing file of
4197 * reopen_state->bs then return 0.
4198 *
4199 * If 'backing' contains a different node name (or is null) then check
4200 * whether the current backing file can be replaced with the new one.
4201 * If that's the case then reopen_state->replace_backing_bs is set to
4202 * true and reopen_state->new_backing_bs contains a pointer to the new
4203 * backing BlockDriverState (or NULL).
4204 *
4205 * Return 0 on success, otherwise return < 0 and set @errp.
4206 */
4207 static int bdrv_reopen_parse_backing(BDRVReopenState *reopen_state,
4208 Transaction *set_backings_tran,
4209 Error **errp)
4210 {
4211 BlockDriverState *bs = reopen_state->bs;
4212 BlockDriverState *overlay_bs, *below_bs, *new_backing_bs;
4213 QObject *value;
4214 const char *str;
4215
4216 value = qdict_get(reopen_state->options, "backing");
4217 if (value == NULL) {
4218 return 0;
4219 }
4220
4221 switch (qobject_type(value)) {
4222 case QTYPE_QNULL:
4223 new_backing_bs = NULL;
4224 break;
4225 case QTYPE_QSTRING:
4226 str = qstring_get_str(qobject_to(QString, value));
4227 new_backing_bs = bdrv_lookup_bs(NULL, str, errp);
4228 if (new_backing_bs == NULL) {
4229 return -EINVAL;
4230 } else if (bdrv_recurse_has_child(new_backing_bs, bs)) {
4231 error_setg(errp, "Making '%s' a backing file of '%s' "
4232 "would create a cycle", str, bs->node_name);
4233 return -EINVAL;
4234 }
4235 break;
4236 default:
4237 /* 'backing' does not allow any other data type */
4238 g_assert_not_reached();
4239 }
4240
4241 /*
4242 * Check AioContext compatibility so that the bdrv_set_backing_hd() call in
4243 * bdrv_reopen_commit() won't fail.
4244 */
4245 if (new_backing_bs) {
4246 if (!bdrv_reopen_can_attach(bs, bs->backing, new_backing_bs, errp)) {
4247 return -EINVAL;
4248 }
4249 }
4250
4251 /*
4252 * Ensure that @bs can really handle backing files, because we are
4253 * about to give it one (or swap the existing one)
4254 */
4255 if (bs->drv->is_filter) {
4256 /* Filters always have a file or a backing child */
4257 if (!bs->backing) {
4258 error_setg(errp, "'%s' is a %s filter node that does not support a "
4259 "backing child", bs->node_name, bs->drv->format_name);
4260 return -EINVAL;
4261 }
4262 } else if (!bs->drv->supports_backing) {
4263 error_setg(errp, "Driver '%s' of node '%s' does not support backing "
4264 "files", bs->drv->format_name, bs->node_name);
4265 return -EINVAL;
4266 }
4267
4268 /*
4269 * Find the "actual" backing file by skipping all links that point
4270 * to an implicit node, if any (e.g. a commit filter node).
4271 * We cannot use any of the bdrv_skip_*() functions here because
4272 * those return the first explicit node, while we are looking for
4273 * its overlay here.
4274 */
4275 overlay_bs = bs;
4276 for (below_bs = bdrv_filter_or_cow_bs(overlay_bs);
4277 below_bs && below_bs->implicit;
4278 below_bs = bdrv_filter_or_cow_bs(overlay_bs))
4279 {
4280 overlay_bs = below_bs;
4281 }
4282
4283 /* If we want to replace the backing file we need some extra checks */
4284 if (new_backing_bs != bdrv_filter_or_cow_bs(overlay_bs)) {
4285 int ret;
4286
4287 /* Check for implicit nodes between bs and its backing file */
4288 if (bs != overlay_bs) {
4289 error_setg(errp, "Cannot change backing link if '%s' has "
4290 "an implicit backing file", bs->node_name);
4291 return -EPERM;
4292 }
4293 /*
4294 * Check if the backing link that we want to replace is frozen.
4295 * Note that
4296 * bdrv_filter_or_cow_child(overlay_bs) == overlay_bs->backing,
4297 * because we know that overlay_bs == bs, and that @bs
4298 * either is a filter that uses ->backing or a COW format BDS
4299 * with bs->drv->supports_backing == true.
4300 */
4301 if (bdrv_is_backing_chain_frozen(overlay_bs,
4302 child_bs(overlay_bs->backing), errp))
4303 {
4304 return -EPERM;
4305 }
4306 reopen_state->replace_backing_bs = true;
4307 reopen_state->old_backing_bs = bs->backing ? bs->backing->bs : NULL;
4308 ret = bdrv_set_backing_noperm(bs, new_backing_bs, set_backings_tran,
4309 errp);
4310 if (ret < 0) {
4311 return ret;
4312 }
4313 }
4314
4315 return 0;
4316 }
4317
4318 /*
4319 * Prepares a BlockDriverState for reopen. All changes are staged in the
4320 * 'opaque' field of the BDRVReopenState, which is used and allocated by
4321 * the block driver layer .bdrv_reopen_prepare()
4322 *
4323 * bs is the BlockDriverState to reopen
4324 * flags are the new open flags
4325 * queue is the reopen queue
4326 *
4327 * Returns 0 on success, non-zero on error. On error errp will be set
4328 * as well.
4329 *
4330 * On failure, bdrv_reopen_abort() will be called to clean up any data.
4331 * It is the responsibility of the caller to then call the abort() or
4332 * commit() for any other BDS that have been left in a prepare() state
4333 *
4334 */
4335 static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
4336 BlockReopenQueue *queue,
4337 Transaction *set_backings_tran, Error **errp)
4338 {
4339 int ret = -1;
4340 int old_flags;
4341 Error *local_err = NULL;
4342 BlockDriver *drv;
4343 QemuOpts *opts;
4344 QDict *orig_reopen_opts;
4345 char *discard = NULL;
4346 bool read_only;
4347 bool drv_prepared = false;
4348
4349 assert(reopen_state != NULL);
4350 assert(reopen_state->bs->drv != NULL);
4351 drv = reopen_state->bs->drv;
4352
4353 /* This function and each driver's bdrv_reopen_prepare() remove
4354 * entries from reopen_state->options as they are processed, so
4355 * we need to make a copy of the original QDict. */
4356 orig_reopen_opts = qdict_clone_shallow(reopen_state->options);
4357
4358 /* Process generic block layer options */
4359 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
4360 if (!qemu_opts_absorb_qdict(opts, reopen_state->options, errp)) {
4361 ret = -EINVAL;
4362 goto error;
4363 }
4364
4365 /* This was already called in bdrv_reopen_queue_child() so the flags
4366 * are up-to-date. This time we simply want to remove the options from
4367 * QemuOpts in order to indicate that they have been processed. */
4368 old_flags = reopen_state->flags;
4369 update_flags_from_options(&reopen_state->flags, opts);
4370 assert(old_flags == reopen_state->flags);
4371
4372 discard = qemu_opt_get_del(opts, BDRV_OPT_DISCARD);
4373 if (discard != NULL) {
4374 if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) {
4375 error_setg(errp, "Invalid discard option");
4376 ret = -EINVAL;
4377 goto error;
4378 }
4379 }
4380
4381 reopen_state->detect_zeroes =
4382 bdrv_parse_detect_zeroes(opts, reopen_state->flags, &local_err);
4383 if (local_err) {
4384 error_propagate(errp, local_err);
4385 ret = -EINVAL;
4386 goto error;
4387 }
4388
4389 /* All other options (including node-name and driver) must be unchanged.
4390 * Put them back into the QDict, so that they are checked at the end
4391 * of this function. */
4392 qemu_opts_to_qdict(opts, reopen_state->options);
4393
4394 /* If we are to stay read-only, do not allow permission change
4395 * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
4396 * not set, or if the BDS still has copy_on_read enabled */
4397 read_only = !(reopen_state->flags & BDRV_O_RDWR);
4398 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);
4399 if (local_err) {
4400 error_propagate(errp, local_err);
4401 goto error;
4402 }
4403
4404 if (drv->bdrv_reopen_prepare) {
4405 /*
4406 * If a driver-specific option is missing, it means that we
4407 * should reset it to its default value.
4408 * But not all options allow that, so we need to check it first.
4409 */
4410 ret = bdrv_reset_options_allowed(reopen_state->bs,
4411 reopen_state->options, errp);
4412 if (ret) {
4413 goto error;
4414 }
4415
4416 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
4417 if (ret) {
4418 if (local_err != NULL) {
4419 error_propagate(errp, local_err);
4420 } else {
4421 bdrv_refresh_filename(reopen_state->bs);
4422 error_setg(errp, "failed while preparing to reopen image '%s'",
4423 reopen_state->bs->filename);
4424 }
4425 goto error;
4426 }
4427 } else {
4428 /* It is currently mandatory to have a bdrv_reopen_prepare()
4429 * handler for each supported drv. */
4430 error_setg(errp, "Block format '%s' used by node '%s' "
4431 "does not support reopening files", drv->format_name,
4432 bdrv_get_device_or_node_name(reopen_state->bs));
4433 ret = -1;
4434 goto error;
4435 }
4436
4437 drv_prepared = true;
4438
4439 /*
4440 * We must provide the 'backing' option if the BDS has a backing
4441 * file or if the image file has a backing file name as part of
4442 * its metadata. Otherwise the 'backing' option can be omitted.
4443 */
4444 if (drv->supports_backing && reopen_state->backing_missing &&
4445 (reopen_state->bs->backing || reopen_state->bs->backing_file[0])) {
4446 error_setg(errp, "backing is missing for '%s'",
4447 reopen_state->bs->node_name);
4448 ret = -EINVAL;
4449 goto error;
4450 }
4451
4452 /*
4453 * Allow changing the 'backing' option. The new value can be
4454 * either a reference to an existing node (using its node name)
4455 * or NULL to simply detach the current backing file.
4456 */
4457 ret = bdrv_reopen_parse_backing(reopen_state, set_backings_tran, errp);
4458 if (ret < 0) {
4459 goto error;
4460 }
4461 qdict_del(reopen_state->options, "backing");
4462
4463 /* Options that are not handled are only okay if they are unchanged
4464 * compared to the old state. It is expected that some options are only
4465 * used for the initial open, but not reopen (e.g. filename) */
4466 if (qdict_size(reopen_state->options)) {
4467 const QDictEntry *entry = qdict_first(reopen_state->options);
4468
4469 do {
4470 QObject *new = entry->value;
4471 QObject *old = qdict_get(reopen_state->bs->options, entry->key);
4472
4473 /* Allow child references (child_name=node_name) as long as they
4474 * point to the current child (i.e. everything stays the same). */
4475 if (qobject_type(new) == QTYPE_QSTRING) {
4476 BdrvChild *child;
4477 QLIST_FOREACH(child, &reopen_state->bs->children, next) {
4478 if (!strcmp(child->name, entry->key)) {
4479 break;
4480 }
4481 }
4482
4483 if (child) {
4484 if (!strcmp(child->bs->node_name,
4485 qstring_get_str(qobject_to(QString, new)))) {
4486 continue; /* Found child with this name, skip option */
4487 }
4488 }
4489 }
4490
4491 /*
4492 * TODO: When using -drive to specify blockdev options, all values
4493 * will be strings; however, when using -blockdev, blockdev-add or
4494 * filenames using the json:{} pseudo-protocol, they will be
4495 * correctly typed.
4496 * In contrast, reopening options are (currently) always strings
4497 * (because you can only specify them through qemu-io; all other
4498 * callers do not specify any options).
4499 * Therefore, when using anything other than -drive to create a BDS,
4500 * this cannot detect non-string options as unchanged, because
4501 * qobject_is_equal() always returns false for objects of different
4502 * type. In the future, this should be remedied by correctly typing
4503 * all options. For now, this is not too big of an issue because
4504 * the user can simply omit options which cannot be changed anyway,
4505 * so they will stay unchanged.
4506 */
4507 if (!qobject_is_equal(new, old)) {
4508 error_setg(errp, "Cannot change the option '%s'", entry->key);
4509 ret = -EINVAL;
4510 goto error;
4511 }
4512 } while ((entry = qdict_next(reopen_state->options, entry)));
4513 }
4514
4515 ret = 0;
4516
4517 /* Restore the original reopen_state->options QDict */
4518 qobject_unref(reopen_state->options);
4519 reopen_state->options = qobject_ref(orig_reopen_opts);
4520
4521 error:
4522 if (ret < 0 && drv_prepared) {
4523 /* drv->bdrv_reopen_prepare() has succeeded, so we need to
4524 * call drv->bdrv_reopen_abort() before signaling an error
4525 * (bdrv_reopen_multiple() will not call bdrv_reopen_abort()
4526 * when the respective bdrv_reopen_prepare() has failed) */
4527 if (drv->bdrv_reopen_abort) {
4528 drv->bdrv_reopen_abort(reopen_state);
4529 }
4530 }
4531 qemu_opts_del(opts);
4532 qobject_unref(orig_reopen_opts);
4533 g_free(discard);
4534 return ret;
4535 }
4536
4537 /*
4538 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
4539 * makes them final by swapping the staging BlockDriverState contents into
4540 * the active BlockDriverState contents.
4541 */
4542 static void bdrv_reopen_commit(BDRVReopenState *reopen_state)
4543 {
4544 BlockDriver *drv;
4545 BlockDriverState *bs;
4546 BdrvChild *child;
4547
4548 assert(reopen_state != NULL);
4549 bs = reopen_state->bs;
4550 drv = bs->drv;
4551 assert(drv != NULL);
4552
4553 /* If there are any driver level actions to take */
4554 if (drv->bdrv_reopen_commit) {
4555 drv->bdrv_reopen_commit(reopen_state);
4556 }
4557
4558 /* set BDS specific flags now */
4559 qobject_unref(bs->explicit_options);
4560 qobject_unref(bs->options);
4561
4562 bs->explicit_options = reopen_state->explicit_options;
4563 bs->options = reopen_state->options;
4564 bs->open_flags = reopen_state->flags;
4565 bs->detect_zeroes = reopen_state->detect_zeroes;
4566
4567 if (reopen_state->replace_backing_bs) {
4568 qdict_del(bs->explicit_options, "backing");
4569 qdict_del(bs->options, "backing");
4570 }
4571
4572 /* Remove child references from bs->options and bs->explicit_options.
4573 * Child options were already removed in bdrv_reopen_queue_child() */
4574 QLIST_FOREACH(child, &bs->children, next) {
4575 qdict_del(bs->explicit_options, child->name);
4576 qdict_del(bs->options, child->name);
4577 }
4578 bdrv_refresh_limits(bs, NULL, NULL);
4579 }
4580
4581 /*
4582 * Abort the reopen, and delete and free the staged changes in
4583 * reopen_state
4584 */
4585 static void bdrv_reopen_abort(BDRVReopenState *reopen_state)
4586 {
4587 BlockDriver *drv;
4588
4589 assert(reopen_state != NULL);
4590 drv = reopen_state->bs->drv;
4591 assert(drv != NULL);
4592
4593 if (drv->bdrv_reopen_abort) {
4594 drv->bdrv_reopen_abort(reopen_state);
4595 }
4596 }
4597
4598
4599 static void bdrv_close(BlockDriverState *bs)
4600 {
4601 BdrvAioNotifier *ban, *ban_next;
4602 BdrvChild *child, *next;
4603
4604 assert(!bs->refcnt);
4605
4606 bdrv_drained_begin(bs); /* complete I/O */
4607 bdrv_flush(bs);
4608 bdrv_drain(bs); /* in case flush left pending I/O */
4609
4610 if (bs->drv) {
4611 if (bs->drv->bdrv_close) {
4612 /* Must unfreeze all children, so bdrv_unref_child() works */
4613 bs->drv->bdrv_close(bs);
4614 }
4615 bs->drv = NULL;
4616 }
4617
4618 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
4619 bdrv_unref_child(bs, child);
4620 }
4621
4622 bs->backing = NULL;
4623 bs->file = NULL;
4624 g_free(bs->opaque);
4625 bs->opaque = NULL;
4626 qatomic_set(&bs->copy_on_read, 0);
4627 bs->backing_file[0] = '\0';
4628 bs->backing_format[0] = '\0';
4629 bs->total_sectors = 0;
4630 bs->encrypted = false;
4631 bs->sg = false;
4632 qobject_unref(bs->options);
4633 qobject_unref(bs->explicit_options);
4634 bs->options = NULL;
4635 bs->explicit_options = NULL;
4636 qobject_unref(bs->full_open_options);
4637 bs->full_open_options = NULL;
4638
4639 bdrv_release_named_dirty_bitmaps(bs);
4640 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
4641
4642 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4643 g_free(ban);
4644 }
4645 QLIST_INIT(&bs->aio_notifiers);
4646 bdrv_drained_end(bs);
4647
4648 /*
4649 * If we're still inside some bdrv_drain_all_begin()/end() sections, end
4650 * them now since this BDS won't exist anymore when bdrv_drain_all_end()
4651 * gets called.
4652 */
4653 if (bs->quiesce_counter) {
4654 bdrv_drain_all_end_quiesce(bs);
4655 }
4656 }
4657
4658 void bdrv_close_all(void)
4659 {
4660 assert(job_next(NULL) == NULL);
4661
4662 /* Drop references from requests still in flight, such as canceled block
4663 * jobs whose AIO context has not been polled yet */
4664 bdrv_drain_all();
4665
4666 blk_remove_all_bs();
4667 blockdev_close_all_bdrv_states();
4668
4669 assert(QTAILQ_EMPTY(&all_bdrv_states));
4670 }
4671
4672 static bool should_update_child(BdrvChild *c, BlockDriverState *to)
4673 {
4674 GQueue *queue;
4675 GHashTable *found;
4676 bool ret;
4677
4678 if (c->klass->stay_at_node) {
4679 return false;
4680 }
4681
4682 /* If the child @c belongs to the BDS @to, replacing the current
4683 * c->bs by @to would mean to create a loop.
4684 *
4685 * Such a case occurs when appending a BDS to a backing chain.
4686 * For instance, imagine the following chain:
4687 *
4688 * guest device -> node A -> further backing chain...
4689 *
4690 * Now we create a new BDS B which we want to put on top of this
4691 * chain, so we first attach A as its backing node:
4692 *
4693 * node B
4694 * |
4695 * v
4696 * guest device -> node A -> further backing chain...
4697 *
4698 * Finally we want to replace A by B. When doing that, we want to
4699 * replace all pointers to A by pointers to B -- except for the
4700 * pointer from B because (1) that would create a loop, and (2)
4701 * that pointer should simply stay intact:
4702 *
4703 * guest device -> node B
4704 * |
4705 * v
4706 * node A -> further backing chain...
4707 *
4708 * In general, when replacing a node A (c->bs) by a node B (@to),
4709 * if A is a child of B, that means we cannot replace A by B there
4710 * because that would create a loop. Silently detaching A from B
4711 * is also not really an option. So overall just leaving A in
4712 * place there is the most sensible choice.
4713 *
4714 * We would also create a loop in any cases where @c is only
4715 * indirectly referenced by @to. Prevent this by returning false
4716 * if @c is found (by breadth-first search) anywhere in the whole
4717 * subtree of @to.
4718 */
4719
4720 ret = true;
4721 found = g_hash_table_new(NULL, NULL);
4722 g_hash_table_add(found, to);
4723 queue = g_queue_new();
4724 g_queue_push_tail(queue, to);
4725
4726 while (!g_queue_is_empty(queue)) {
4727 BlockDriverState *v = g_queue_pop_head(queue);
4728 BdrvChild *c2;
4729
4730 QLIST_FOREACH(c2, &v->children, next) {
4731 if (c2 == c) {
4732 ret = false;
4733 break;
4734 }
4735
4736 if (g_hash_table_contains(found, c2->bs)) {
4737 continue;
4738 }
4739
4740 g_queue_push_tail(queue, c2->bs);
4741 g_hash_table_add(found, c2->bs);
4742 }
4743 }
4744
4745 g_queue_free(queue);
4746 g_hash_table_destroy(found);
4747
4748 return ret;
4749 }
4750
4751 typedef struct BdrvRemoveFilterOrCowChild {
4752 BdrvChild *child;
4753 bool is_backing;
4754 } BdrvRemoveFilterOrCowChild;
4755
4756 static void bdrv_remove_filter_or_cow_child_abort(void *opaque)
4757 {
4758 BdrvRemoveFilterOrCowChild *s = opaque;
4759 BlockDriverState *parent_bs = s->child->opaque;
4760
4761 QLIST_INSERT_HEAD(&parent_bs->children, s->child, next);
4762 if (s->is_backing) {
4763 parent_bs->backing = s->child;
4764 } else {
4765 parent_bs->file = s->child;
4766 }
4767
4768 /*
4769 * We don't have to restore child->bs here to undo bdrv_replace_child()
4770 * because that function is transactionable and it registered own completion
4771 * entries in @tran, so .abort() for bdrv_replace_child_safe() will be
4772 * called automatically.
4773 */
4774 }
4775
4776 static void bdrv_remove_filter_or_cow_child_commit(void *opaque)
4777 {
4778 BdrvRemoveFilterOrCowChild *s = opaque;
4779
4780 bdrv_child_free(s->child);
4781 }
4782
4783 static TransactionActionDrv bdrv_remove_filter_or_cow_child_drv = {
4784 .abort = bdrv_remove_filter_or_cow_child_abort,
4785 .commit = bdrv_remove_filter_or_cow_child_commit,
4786 .clean = g_free,
4787 };
4788
4789 /*
4790 * A function to remove backing-chain child of @bs if exists: cow child for
4791 * format nodes (always .backing) and filter child for filters (may be .file or
4792 * .backing)
4793 */
4794 static void bdrv_remove_filter_or_cow_child(BlockDriverState *bs,
4795 Transaction *tran)
4796 {
4797 BdrvRemoveFilterOrCowChild *s;
4798 BdrvChild *child = bdrv_filter_or_cow_child(bs);
4799
4800 if (!child) {
4801 return;
4802 }
4803
4804 if (child->bs) {
4805 bdrv_replace_child(child, NULL, tran);
4806 }
4807
4808 s = g_new(BdrvRemoveFilterOrCowChild, 1);
4809 *s = (BdrvRemoveFilterOrCowChild) {
4810 .child = child,
4811 .is_backing = (child == bs->backing),
4812 };
4813 tran_add(tran, &bdrv_remove_filter_or_cow_child_drv, s);
4814
4815 QLIST_SAFE_REMOVE(child, next);
4816 if (s->is_backing) {
4817 bs->backing = NULL;
4818 } else {
4819 bs->file = NULL;
4820 }
4821 }
4822
4823 static int bdrv_replace_node_noperm(BlockDriverState *from,
4824 BlockDriverState *to,
4825 bool auto_skip, Transaction *tran,
4826 Error **errp)
4827 {
4828 BdrvChild *c, *next;
4829
4830 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
4831 assert(c->bs == from);
4832 if (!should_update_child(c, to)) {
4833 if (auto_skip) {
4834 continue;
4835 }
4836 error_setg(errp, "Should not change '%s' link to '%s'",
4837 c->name, from->node_name);
4838 return -EINVAL;
4839 }
4840 if (c->frozen) {
4841 error_setg(errp, "Cannot change '%s' link to '%s'",
4842 c->name, from->node_name);
4843 return -EPERM;
4844 }
4845 bdrv_replace_child(c, to, tran);
4846 }
4847
4848 return 0;
4849 }
4850
4851 /*
4852 * With auto_skip=true bdrv_replace_node_common skips updating from parents
4853 * if it creates a parent-child relation loop or if parent is block-job.
4854 *
4855 * With auto_skip=false the error is returned if from has a parent which should
4856 * not be updated.
4857 *
4858 * With @detach_subchain=true @to must be in a backing chain of @from. In this
4859 * case backing link of the cow-parent of @to is removed.
4860 */
4861 static int bdrv_replace_node_common(BlockDriverState *from,
4862 BlockDriverState *to,
4863 bool auto_skip, bool detach_subchain,
4864 Error **errp)
4865 {
4866 Transaction *tran = tran_new();
4867 g_autoptr(GHashTable) found = NULL;
4868 g_autoptr(GSList) refresh_list = NULL;
4869 BlockDriverState *to_cow_parent;
4870 int ret;
4871
4872 if (detach_subchain) {
4873 assert(bdrv_chain_contains(from, to));
4874 assert(from != to);
4875 for (to_cow_parent = from;
4876 bdrv_filter_or_cow_bs(to_cow_parent) != to;
4877 to_cow_parent = bdrv_filter_or_cow_bs(to_cow_parent))
4878 {
4879 ;
4880 }
4881 }
4882
4883 /* Make sure that @from doesn't go away until we have successfully attached
4884 * all of its parents to @to. */
4885 bdrv_ref(from);
4886
4887 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
4888 assert(bdrv_get_aio_context(from) == bdrv_get_aio_context(to));
4889 bdrv_drained_begin(from);
4890
4891 /*
4892 * Do the replacement without permission update.
4893 * Replacement may influence the permissions, we should calculate new
4894 * permissions based on new graph. If we fail, we'll roll-back the
4895 * replacement.
4896 */
4897 ret = bdrv_replace_node_noperm(from, to, auto_skip, tran, errp);
4898 if (ret < 0) {
4899 goto out;
4900 }
4901
4902 if (detach_subchain) {
4903 bdrv_remove_filter_or_cow_child(to_cow_parent, tran);
4904 }
4905
4906 found = g_hash_table_new(NULL, NULL);
4907
4908 refresh_list = bdrv_topological_dfs(refresh_list, found, to);
4909 refresh_list = bdrv_topological_dfs(refresh_list, found, from);
4910
4911 ret = bdrv_list_refresh_perms(refresh_list, NULL, tran, errp);
4912 if (ret < 0) {
4913 goto out;
4914 }
4915
4916 ret = 0;
4917
4918 out:
4919 tran_finalize(tran, ret);
4920
4921 bdrv_drained_end(from);
4922 bdrv_unref(from);
4923
4924 return ret;
4925 }
4926
4927 int bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
4928 Error **errp)
4929 {
4930 return bdrv_replace_node_common(from, to, true, false, errp);
4931 }
4932
4933 int bdrv_drop_filter(BlockDriverState *bs, Error **errp)
4934 {
4935 return bdrv_replace_node_common(bs, bdrv_filter_or_cow_bs(bs), true, true,
4936 errp);
4937 }
4938
4939 /*
4940 * Add new bs contents at the top of an image chain while the chain is
4941 * live, while keeping required fields on the top layer.
4942 *
4943 * This will modify the BlockDriverState fields, and swap contents
4944 * between bs_new and bs_top. Both bs_new and bs_top are modified.
4945 *
4946 * bs_new must not be attached to a BlockBackend and must not have backing
4947 * child.
4948 *
4949 * This function does not create any image files.
4950 */
4951 int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
4952 Error **errp)
4953 {
4954 int ret;
4955 Transaction *tran = tran_new();
4956
4957 assert(!bs_new->backing);
4958
4959 ret = bdrv_attach_child_noperm(bs_new, bs_top, "backing",
4960 &child_of_bds, bdrv_backing_role(bs_new),
4961 &bs_new->backing, tran, errp);
4962 if (ret < 0) {
4963 goto out;
4964 }
4965
4966 ret = bdrv_replace_node_noperm(bs_top, bs_new, true, tran, errp);
4967 if (ret < 0) {
4968 goto out;
4969 }
4970
4971 ret = bdrv_refresh_perms(bs_new, errp);
4972 out:
4973 tran_finalize(tran, ret);
4974
4975 bdrv_refresh_limits(bs_top, NULL, NULL);
4976
4977 return ret;
4978 }
4979
4980 static void bdrv_delete(BlockDriverState *bs)
4981 {
4982 assert(bdrv_op_blocker_is_empty(bs));
4983 assert(!bs->refcnt);
4984
4985 /* remove from list, if necessary */
4986 if (bs->node_name[0] != '\0') {
4987 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
4988 }
4989 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
4990
4991 bdrv_close(bs);
4992
4993 g_free(bs);
4994 }
4995
4996 BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *node_options,
4997 int flags, Error **errp)
4998 {
4999 BlockDriverState *new_node_bs;
5000 Error *local_err = NULL;
5001
5002 new_node_bs = bdrv_open(NULL, NULL, node_options, flags, errp);
5003 if (new_node_bs == NULL) {
5004 error_prepend(errp, "Could not create node: ");
5005 return NULL;
5006 }
5007
5008 bdrv_drained_begin(bs);
5009 bdrv_replace_node(bs, new_node_bs, &local_err);
5010 bdrv_drained_end(bs);
5011
5012 if (local_err) {
5013 bdrv_unref(new_node_bs);
5014 error_propagate(errp, local_err);
5015 return NULL;
5016 }
5017
5018 return new_node_bs;
5019 }
5020
5021 /*
5022 * Run consistency checks on an image
5023 *
5024 * Returns 0 if the check could be completed (it doesn't mean that the image is
5025 * free of errors) or -errno when an internal error occurred. The results of the
5026 * check are stored in res.
5027 */
5028 int coroutine_fn bdrv_co_check(BlockDriverState *bs,
5029 BdrvCheckResult *res, BdrvCheckMode fix)
5030 {
5031 if (bs->drv == NULL) {
5032 return -ENOMEDIUM;
5033 }
5034 if (bs->drv->bdrv_co_check == NULL) {
5035 return -ENOTSUP;
5036 }
5037
5038 memset(res, 0, sizeof(*res));
5039 return bs->drv->bdrv_co_check(bs, res, fix);
5040 }
5041
5042 /*
5043 * Return values:
5044 * 0 - success
5045 * -EINVAL - backing format specified, but no file
5046 * -ENOSPC - can't update the backing file because no space is left in the
5047 * image file header
5048 * -ENOTSUP - format driver doesn't support changing the backing file
5049 */
5050 int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,
5051 const char *backing_fmt, bool warn)
5052 {
5053 BlockDriver *drv = bs->drv;
5054 int ret;
5055
5056 if (!drv) {
5057 return -ENOMEDIUM;
5058 }
5059
5060 /* Backing file format doesn't make sense without a backing file */
5061 if (backing_fmt && !backing_file) {
5062 return -EINVAL;
5063 }
5064
5065 if (warn && backing_file && !backing_fmt) {
5066 warn_report("Deprecated use of backing file without explicit "
5067 "backing format, use of this image requires "
5068 "potentially unsafe format probing");
5069 }
5070
5071 if (drv->bdrv_change_backing_file != NULL) {
5072 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
5073 } else {
5074 ret = -ENOTSUP;
5075 }
5076
5077 if (ret == 0) {
5078 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
5079 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
5080 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
5081 backing_file ?: "");
5082 }
5083 return ret;
5084 }
5085
5086 /*
5087 * Finds the first non-filter node above bs in the chain between
5088 * active and bs. The returned node is either an immediate parent of
5089 * bs, or there are only filter nodes between the two.
5090 *
5091 * Returns NULL if bs is not found in active's image chain,
5092 * or if active == bs.
5093 *
5094 * Returns the bottommost base image if bs == NULL.
5095 */
5096 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
5097 BlockDriverState *bs)
5098 {
5099 bs = bdrv_skip_filters(bs);
5100 active = bdrv_skip_filters(active);
5101
5102 while (active) {
5103 BlockDriverState *next = bdrv_backing_chain_next(active);
5104 if (bs == next) {
5105 return active;
5106 }
5107 active = next;
5108 }
5109
5110 return NULL;
5111 }
5112
5113 /* Given a BDS, searches for the base layer. */
5114 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
5115 {
5116 return bdrv_find_overlay(bs, NULL);
5117 }
5118
5119 /*
5120 * Return true if at least one of the COW (backing) and filter links
5121 * between @bs and @base is frozen. @errp is set if that's the case.
5122 * @base must be reachable from @bs, or NULL.
5123 */
5124 bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
5125 Error **errp)
5126 {
5127 BlockDriverState *i;
5128 BdrvChild *child;
5129
5130 for (i = bs; i != base; i = child_bs(child)) {
5131 child = bdrv_filter_or_cow_child(i);
5132
5133 if (child && child->frozen) {
5134 error_setg(errp, "Cannot change '%s' link from '%s' to '%s'",
5135 child->name, i->node_name, child->bs->node_name);
5136 return true;
5137 }
5138 }
5139
5140 return false;
5141 }
5142
5143 /*
5144 * Freeze all COW (backing) and filter links between @bs and @base.
5145 * If any of the links is already frozen the operation is aborted and
5146 * none of the links are modified.
5147 * @base must be reachable from @bs, or NULL.
5148 * Returns 0 on success. On failure returns < 0 and sets @errp.
5149 */
5150 int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
5151 Error **errp)
5152 {
5153 BlockDriverState *i;
5154 BdrvChild *child;
5155
5156 if (bdrv_is_backing_chain_frozen(bs, base, errp)) {
5157 return -EPERM;
5158 }
5159
5160 for (i = bs; i != base; i = child_bs(child)) {
5161 child = bdrv_filter_or_cow_child(i);
5162 if (child && child->bs->never_freeze) {
5163 error_setg(errp, "Cannot freeze '%s' link to '%s'",
5164 child->name, child->bs->node_name);
5165 return -EPERM;
5166 }
5167 }
5168
5169 for (i = bs; i != base; i = child_bs(child)) {
5170 child = bdrv_filter_or_cow_child(i);
5171 if (child) {
5172 child->frozen = true;
5173 }
5174 }
5175
5176 return 0;
5177 }
5178
5179 /*
5180 * Unfreeze all COW (backing) and filter links between @bs and @base.
5181 * The caller must ensure that all links are frozen before using this
5182 * function.
5183 * @base must be reachable from @bs, or NULL.
5184 */
5185 void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base)
5186 {
5187 BlockDriverState *i;
5188 BdrvChild *child;
5189
5190 for (i = bs; i != base; i = child_bs(child)) {
5191 child = bdrv_filter_or_cow_child(i);
5192 if (child) {
5193 assert(child->frozen);
5194 child->frozen = false;
5195 }
5196 }
5197 }
5198
5199 /*
5200 * Drops images above 'base' up to and including 'top', and sets the image
5201 * above 'top' to have base as its backing file.
5202 *
5203 * Requires that the overlay to 'top' is opened r/w, so that the backing file
5204 * information in 'bs' can be properly updated.
5205 *
5206 * E.g., this will convert the following chain:
5207 * bottom <- base <- intermediate <- top <- active
5208 *
5209 * to
5210 *
5211 * bottom <- base <- active
5212 *
5213 * It is allowed for bottom==base, in which case it converts:
5214 *
5215 * base <- intermediate <- top <- active
5216 *
5217 * to
5218 *
5219 * base <- active
5220 *
5221 * If backing_file_str is non-NULL, it will be used when modifying top's
5222 * overlay image metadata.
5223 *
5224 * Error conditions:
5225 * if active == top, that is considered an error
5226 *
5227 */
5228 int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
5229 const char *backing_file_str)
5230 {
5231 BlockDriverState *explicit_top = top;
5232 bool update_inherits_from;
5233 BdrvChild *c;
5234 Error *local_err = NULL;
5235 int ret = -EIO;
5236 g_autoptr(GSList) updated_children = NULL;
5237 GSList *p;
5238
5239 bdrv_ref(top);
5240 bdrv_subtree_drained_begin(top);
5241
5242 if (!top->drv || !base->drv) {
5243 goto exit;
5244 }
5245
5246 /* Make sure that base is in the backing chain of top */
5247 if (!bdrv_chain_contains(top, base)) {
5248 goto exit;
5249 }
5250
5251 /* If 'base' recursively inherits from 'top' then we should set
5252 * base->inherits_from to top->inherits_from after 'top' and all
5253 * other intermediate nodes have been dropped.
5254 * If 'top' is an implicit node (e.g. "commit_top") we should skip
5255 * it because no one inherits from it. We use explicit_top for that. */
5256 explicit_top = bdrv_skip_implicit_filters(explicit_top);
5257 update_inherits_from = bdrv_inherits_from_recursive(base, explicit_top);
5258
5259 /* success - we can delete the intermediate states, and link top->base */
5260 /* TODO Check graph modification op blockers (BLK_PERM_GRAPH_MOD) once
5261 * we've figured out how they should work. */
5262 if (!backing_file_str) {
5263 bdrv_refresh_filename(base);
5264 backing_file_str = base->filename;
5265 }
5266
5267 QLIST_FOREACH(c, &top->parents, next_parent) {
5268 updated_children = g_slist_prepend(updated_children, c);
5269 }
5270
5271 /*
5272 * It seems correct to pass detach_subchain=true here, but it triggers
5273 * one more yet not fixed bug, when due to nested aio_poll loop we switch to
5274 * another drained section, which modify the graph (for example, removing
5275 * the child, which we keep in updated_children list). So, it's a TODO.
5276 *
5277 * Note, bug triggered if pass detach_subchain=true here and run
5278 * test-bdrv-drain. test_drop_intermediate_poll() test-case will crash.
5279 * That's a FIXME.
5280 */
5281 bdrv_replace_node_common(top, base, false, false, &local_err);
5282 if (local_err) {
5283 error_report_err(local_err);
5284 goto exit;
5285 }
5286
5287 for (p = updated_children; p; p = p->next) {
5288 c = p->data;
5289
5290 if (c->klass->update_filename) {
5291 ret = c->klass->update_filename(c, base, backing_file_str,
5292 &local_err);
5293 if (ret < 0) {
5294 /*
5295 * TODO: Actually, we want to rollback all previous iterations
5296 * of this loop, and (which is almost impossible) previous
5297 * bdrv_replace_node()...
5298 *
5299 * Note, that c->klass->update_filename may lead to permission
5300 * update, so it's a bad idea to call it inside permission
5301 * update transaction of bdrv_replace_node.
5302 */
5303 error_report_err(local_err);
5304 goto exit;
5305 }
5306 }
5307 }
5308
5309 if (update_inherits_from) {
5310 base->inherits_from = explicit_top->inherits_from;
5311 }
5312
5313 ret = 0;
5314 exit:
5315 bdrv_subtree_drained_end(top);
5316 bdrv_unref(top);
5317 return ret;
5318 }
5319
5320 /**
5321 * Implementation of BlockDriver.bdrv_get_allocated_file_size() that
5322 * sums the size of all data-bearing children. (This excludes backing
5323 * children.)
5324 */
5325 static int64_t bdrv_sum_allocated_file_size(BlockDriverState *bs)
5326 {
5327 BdrvChild *child;
5328 int64_t child_size, sum = 0;
5329
5330 QLIST_FOREACH(child, &bs->children, next) {
5331 if (child->role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
5332 BDRV_CHILD_FILTERED))
5333 {
5334 child_size = bdrv_get_allocated_file_size(child->bs);
5335 if (child_size < 0) {
5336 return child_size;
5337 }
5338 sum += child_size;
5339 }
5340 }
5341
5342 return sum;
5343 }
5344
5345 /**
5346 * Length of a allocated file in bytes. Sparse files are counted by actual
5347 * allocated space. Return < 0 if error or unknown.
5348 */
5349 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
5350 {
5351 BlockDriver *drv = bs->drv;
5352 if (!drv) {
5353 return -ENOMEDIUM;
5354 }
5355 if (drv->bdrv_get_allocated_file_size) {
5356 return drv->bdrv_get_allocated_file_size(bs);
5357 }
5358
5359 if (drv->bdrv_file_open) {
5360 /*
5361 * Protocol drivers default to -ENOTSUP (most of their data is
5362 * not stored in any of their children (if they even have any),
5363 * so there is no generic way to figure it out).
5364 */
5365 return -ENOTSUP;
5366 } else if (drv->is_filter) {
5367 /* Filter drivers default to the size of their filtered child */
5368 return bdrv_get_allocated_file_size(bdrv_filter_bs(bs));
5369 } else {
5370 /* Other drivers default to summing their children's sizes */
5371 return bdrv_sum_allocated_file_size(bs);
5372 }
5373 }
5374
5375 /*
5376 * bdrv_measure:
5377 * @drv: Format driver
5378 * @opts: Creation options for new image
5379 * @in_bs: Existing image containing data for new image (may be NULL)
5380 * @errp: Error object
5381 * Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo())
5382 * or NULL on error
5383 *
5384 * Calculate file size required to create a new image.
5385 *
5386 * If @in_bs is given then space for allocated clusters and zero clusters
5387 * from that image are included in the calculation. If @opts contains a
5388 * backing file that is shared by @in_bs then backing clusters may be omitted
5389 * from the calculation.
5390 *
5391 * If @in_bs is NULL then the calculation includes no allocated clusters
5392 * unless a preallocation option is given in @opts.
5393 *
5394 * Note that @in_bs may use a different BlockDriver from @drv.
5395 *
5396 * If an error occurs the @errp pointer is set.
5397 */
5398 BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
5399 BlockDriverState *in_bs, Error **errp)
5400 {
5401 if (!drv->bdrv_measure) {
5402 error_setg(errp, "Block driver '%s' does not support size measurement",
5403 drv->format_name);
5404 return NULL;
5405 }
5406
5407 return drv->bdrv_measure(opts, in_bs, errp);
5408 }
5409
5410 /**
5411 * Return number of sectors on success, -errno on error.
5412 */
5413 int64_t bdrv_nb_sectors(BlockDriverState *bs)
5414 {
5415 BlockDriver *drv = bs->drv;
5416
5417 if (!drv)
5418 return -ENOMEDIUM;
5419
5420 if (drv->has_variable_length) {
5421 int ret = refresh_total_sectors(bs, bs->total_sectors);
5422 if (ret < 0) {
5423 return ret;
5424 }
5425 }
5426 return bs->total_sectors;
5427 }
5428
5429 /**
5430 * Return length in bytes on success, -errno on error.
5431 * The length is always a multiple of BDRV_SECTOR_SIZE.
5432 */
5433 int64_t bdrv_getlength(BlockDriverState *bs)
5434 {
5435 int64_t ret = bdrv_nb_sectors(bs);
5436
5437 if (ret < 0) {
5438 return ret;
5439 }
5440 if (ret > INT64_MAX / BDRV_SECTOR_SIZE) {
5441 return -EFBIG;
5442 }
5443 return ret * BDRV_SECTOR_SIZE;
5444 }
5445
5446 /* return 0 as number of sectors if no device present or error */
5447 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
5448 {
5449 int64_t nb_sectors = bdrv_nb_sectors(bs);
5450
5451 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
5452 }
5453
5454 bool bdrv_is_sg(BlockDriverState *bs)
5455 {
5456 return bs->sg;
5457 }
5458
5459 /**
5460 * Return whether the given node supports compressed writes.
5461 */
5462 bool bdrv_supports_compressed_writes(BlockDriverState *bs)
5463 {
5464 BlockDriverState *filtered;
5465
5466 if (!bs->drv || !block_driver_can_compress(bs->drv)) {
5467 return false;
5468 }
5469
5470 filtered = bdrv_filter_bs(bs);
5471 if (filtered) {
5472 /*
5473 * Filters can only forward compressed writes, so we have to
5474 * check the child.
5475 */
5476 return bdrv_supports_compressed_writes(filtered);
5477 }
5478
5479 return true;
5480 }
5481
5482 const char *bdrv_get_format_name(BlockDriverState *bs)
5483 {
5484 return bs->drv ? bs->drv->format_name : NULL;
5485 }
5486
5487 static int qsort_strcmp(const void *a, const void *b)
5488 {
5489 return strcmp(*(char *const *)a, *(char *const *)b);
5490 }
5491
5492 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
5493 void *opaque, bool read_only)
5494 {
5495 BlockDriver *drv;
5496 int count = 0;
5497 int i;
5498 const char **formats = NULL;
5499
5500 QLIST_FOREACH(drv, &bdrv_drivers, list) {
5501 if (drv->format_name) {
5502 bool found = false;
5503 int i = count;
5504
5505 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, read_only)) {
5506 continue;
5507 }
5508
5509 while (formats && i && !found) {
5510 found = !strcmp(formats[--i], drv->format_name);
5511 }
5512
5513 if (!found) {
5514 formats = g_renew(const char *, formats, count + 1);
5515 formats[count++] = drv->format_name;
5516 }
5517 }
5518 }
5519
5520 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
5521 const char *format_name = block_driver_modules[i].format_name;
5522
5523 if (format_name) {
5524 bool found = false;
5525 int j = count;
5526
5527 if (use_bdrv_whitelist &&
5528 !bdrv_format_is_whitelisted(format_name, read_only)) {
5529 continue;
5530 }
5531
5532 while (formats && j && !found) {
5533 found = !strcmp(formats[--j], format_name);
5534 }
5535
5536 if (!found) {
5537 formats = g_renew(const char *, formats, count + 1);
5538 formats[count++] = format_name;
5539 }
5540 }
5541 }
5542
5543 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
5544
5545 for (i = 0; i < count; i++) {
5546 it(opaque, formats[i]);
5547 }
5548
5549 g_free(formats);
5550 }
5551
5552 /* This function is to find a node in the bs graph */
5553 BlockDriverState *bdrv_find_node(const char *node_name)
5554 {
5555 BlockDriverState *bs;
5556
5557 assert(node_name);
5558
5559 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
5560 if (!strcmp(node_name, bs->node_name)) {
5561 return bs;
5562 }
5563 }
5564 return NULL;
5565 }
5566
5567 /* Put this QMP function here so it can access the static graph_bdrv_states. */
5568 BlockDeviceInfoList *bdrv_named_nodes_list(bool flat,
5569 Error **errp)
5570 {
5571 BlockDeviceInfoList *list;
5572 BlockDriverState *bs;
5573
5574 list = NULL;
5575 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
5576 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, flat, errp);
5577 if (!info) {
5578 qapi_free_BlockDeviceInfoList(list);
5579 return NULL;
5580 }
5581 QAPI_LIST_PREPEND(list, info);
5582 }
5583
5584 return list;
5585 }
5586
5587 typedef struct XDbgBlockGraphConstructor {
5588 XDbgBlockGraph *graph;
5589 GHashTable *graph_nodes;
5590 } XDbgBlockGraphConstructor;
5591
5592 static XDbgBlockGraphConstructor *xdbg_graph_new(void)
5593 {
5594 XDbgBlockGraphConstructor *gr = g_new(XDbgBlockGraphConstructor, 1);
5595
5596 gr->graph = g_new0(XDbgBlockGraph, 1);
5597 gr->graph_nodes = g_hash_table_new(NULL, NULL);
5598
5599 return gr;
5600 }
5601
5602 static XDbgBlockGraph *xdbg_graph_finalize(XDbgBlockGraphConstructor *gr)
5603 {
5604 XDbgBlockGraph *graph = gr->graph;
5605
5606 g_hash_table_destroy(gr->graph_nodes);
5607 g_free(gr);
5608
5609 return graph;
5610 }
5611
5612 static uintptr_t xdbg_graph_node_num(XDbgBlockGraphConstructor *gr, void *node)
5613 {
5614 uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node);
5615
5616 if (ret != 0) {
5617 return ret;
5618 }
5619
5620 /*
5621 * Start counting from 1, not 0, because 0 interferes with not-found (NULL)
5622 * answer of g_hash_table_lookup.
5623 */
5624 ret = g_hash_table_size(gr->graph_nodes) + 1;
5625 g_hash_table_insert(gr->graph_nodes, node, (void *)ret);
5626
5627 return ret;
5628 }
5629
5630 static void xdbg_graph_add_node(XDbgBlockGraphConstructor *gr, void *node,
5631 XDbgBlockGraphNodeType type, const char *name)
5632 {
5633 XDbgBlockGraphNode *n;
5634
5635 n = g_new0(XDbgBlockGraphNode, 1);
5636
5637 n->id = xdbg_graph_node_num(gr, node);
5638 n->type = type;
5639 n->name = g_strdup(name);
5640
5641 QAPI_LIST_PREPEND(gr->graph->nodes, n);
5642 }
5643
5644 static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent,
5645 const BdrvChild *child)
5646 {
5647 BlockPermission qapi_perm;
5648 XDbgBlockGraphEdge *edge;
5649
5650 edge = g_new0(XDbgBlockGraphEdge, 1);
5651
5652 edge->parent = xdbg_graph_node_num(gr, parent);
5653 edge->child = xdbg_graph_node_num(gr, child->bs);
5654 edge->name = g_strdup(child->name);
5655
5656 for (qapi_perm = 0; qapi_perm < BLOCK_PERMISSION__MAX; qapi_perm++) {
5657 uint64_t flag = bdrv_qapi_perm_to_blk_perm(qapi_perm);
5658
5659 if (flag & child->perm) {
5660 QAPI_LIST_PREPEND(edge->perm, qapi_perm);
5661 }
5662 if (flag & child->shared_perm) {
5663 QAPI_LIST_PREPEND(edge->shared_perm, qapi_perm);
5664 }
5665 }
5666
5667 QAPI_LIST_PREPEND(gr->graph->edges, edge);
5668 }
5669
5670
5671 XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp)
5672 {
5673 BlockBackend *blk;
5674 BlockJob *job;
5675 BlockDriverState *bs;
5676 BdrvChild *child;
5677 XDbgBlockGraphConstructor *gr = xdbg_graph_new();
5678
5679 for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {
5680 char *allocated_name = NULL;
5681 const char *name = blk_name(blk);
5682
5683 if (!*name) {
5684 name = allocated_name = blk_get_attached_dev_id(blk);
5685 }
5686 xdbg_graph_add_node(gr, blk, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_BACKEND,
5687 name);
5688 g_free(allocated_name);
5689 if (blk_root(blk)) {
5690 xdbg_graph_add_edge(gr, blk, blk_root(blk));
5691 }
5692 }
5693
5694 for (job = block_job_next(NULL); job; job = block_job_next(job)) {
5695 GSList *el;
5696
5697 xdbg_graph_add_node(gr, job, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_JOB,
5698 job->job.id);
5699 for (el = job->nodes; el; el = el->next) {
5700 xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data);
5701 }
5702 }
5703
5704 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
5705 xdbg_graph_add_node(gr, bs, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_DRIVER,
5706 bs->node_name);
5707 QLIST_FOREACH(child, &bs->children, next) {
5708 xdbg_graph_add_edge(gr, bs, child);
5709 }
5710 }
5711
5712 return xdbg_graph_finalize(gr);
5713 }
5714
5715 BlockDriverState *bdrv_lookup_bs(const char *device,
5716 const char *node_name,
5717 Error **errp)
5718 {
5719 BlockBackend *blk;
5720 BlockDriverState *bs;
5721
5722 if (device) {
5723 blk = blk_by_name(device);
5724
5725 if (blk) {
5726 bs = blk_bs(blk);
5727 if (!bs) {
5728 error_setg(errp, "Device '%s' has no medium", device);
5729 }
5730
5731 return bs;
5732 }
5733 }
5734
5735 if (node_name) {
5736 bs = bdrv_find_node(node_name);
5737
5738 if (bs) {
5739 return bs;
5740 }
5741 }
5742
5743 error_setg(errp, "Cannot find device=\'%s\' nor node-name=\'%s\'",
5744 device ? device : "",
5745 node_name ? node_name : "");
5746 return NULL;
5747 }
5748
5749 /* If 'base' is in the same chain as 'top', return true. Otherwise,
5750 * return false. If either argument is NULL, return false. */
5751 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
5752 {
5753 while (top && top != base) {
5754 top = bdrv_filter_or_cow_bs(top);
5755 }
5756
5757 return top != NULL;
5758 }
5759
5760 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
5761 {
5762 if (!bs) {
5763 return QTAILQ_FIRST(&graph_bdrv_states);
5764 }
5765 return QTAILQ_NEXT(bs, node_list);
5766 }
5767
5768 BlockDriverState *bdrv_next_all_states(BlockDriverState *bs)
5769 {
5770 if (!bs) {
5771 return QTAILQ_FIRST(&all_bdrv_states);
5772 }
5773 return QTAILQ_NEXT(bs, bs_list);
5774 }
5775
5776 const char *bdrv_get_node_name(const BlockDriverState *bs)
5777 {
5778 return bs->node_name;
5779 }
5780
5781 const char *bdrv_get_parent_name(const BlockDriverState *bs)
5782 {
5783 BdrvChild *c;
5784 const char *name;
5785
5786 /* If multiple parents have a name, just pick the first one. */
5787 QLIST_FOREACH(c, &bs->parents, next_parent) {
5788 if (c->klass->get_name) {
5789 name = c->klass->get_name(c);
5790 if (name && *name) {
5791 return name;
5792 }
5793 }
5794 }
5795
5796 return NULL;
5797 }
5798
5799 /* TODO check what callers really want: bs->node_name or blk_name() */
5800 const char *bdrv_get_device_name(const BlockDriverState *bs)
5801 {
5802 return bdrv_get_parent_name(bs) ?: "";
5803 }
5804
5805 /* This can be used to identify nodes that might not have a device
5806 * name associated. Since node and device names live in the same
5807 * namespace, the result is unambiguous. The exception is if both are
5808 * absent, then this returns an empty (non-null) string. */
5809 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
5810 {
5811 return bdrv_get_parent_name(bs) ?: bs->node_name;
5812 }
5813
5814 int bdrv_get_flags(BlockDriverState *bs)
5815 {
5816 return bs->open_flags;
5817 }
5818
5819 int bdrv_has_zero_init_1(BlockDriverState *bs)
5820 {
5821 return 1;
5822 }
5823
5824 int bdrv_has_zero_init(BlockDriverState *bs)
5825 {
5826 BlockDriverState *filtered;
5827
5828 if (!bs->drv) {
5829 return 0;
5830 }
5831
5832 /* If BS is a copy on write image, it is initialized to
5833 the contents of the base image, which may not be zeroes. */
5834 if (bdrv_cow_child(bs)) {
5835 return 0;
5836 }
5837 if (bs->drv->bdrv_has_zero_init) {
5838 return bs->drv->bdrv_has_zero_init(bs);
5839 }
5840
5841 filtered = bdrv_filter_bs(bs);
5842 if (filtered) {
5843 return bdrv_has_zero_init(filtered);
5844 }
5845
5846 /* safe default */
5847 return 0;
5848 }
5849
5850 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
5851 {
5852 if (!(bs->open_flags & BDRV_O_UNMAP)) {
5853 return false;
5854 }
5855
5856 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP;
5857 }
5858
5859 void bdrv_get_backing_filename(BlockDriverState *bs,
5860 char *filename, int filename_size)
5861 {
5862 pstrcpy(filename, filename_size, bs->backing_file);
5863 }
5864
5865 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
5866 {
5867 int ret;
5868 BlockDriver *drv = bs->drv;
5869 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
5870 if (!drv) {
5871 return -ENOMEDIUM;
5872 }
5873 if (!drv->bdrv_get_info) {
5874 BlockDriverState *filtered = bdrv_filter_bs(bs);
5875 if (filtered) {
5876 return bdrv_get_info(filtered, bdi);
5877 }
5878 return -ENOTSUP;
5879 }
5880 memset(bdi, 0, sizeof(*bdi));
5881 ret = drv->bdrv_get_info(bs, bdi);
5882 if (ret < 0) {
5883 return ret;
5884 }
5885
5886 if (bdi->cluster_size > BDRV_MAX_ALIGNMENT) {
5887 return -EINVAL;
5888 }
5889
5890 return 0;
5891 }
5892
5893 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs,
5894 Error **errp)
5895 {
5896 BlockDriver *drv = bs->drv;
5897 if (drv && drv->bdrv_get_specific_info) {
5898 return drv->bdrv_get_specific_info(bs, errp);
5899 }
5900 return NULL;
5901 }
5902
5903 BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs)
5904 {
5905 BlockDriver *drv = bs->drv;
5906 if (!drv || !drv->bdrv_get_specific_stats) {
5907 return NULL;
5908 }
5909 return drv->bdrv_get_specific_stats(bs);
5910 }
5911
5912 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
5913 {
5914 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
5915 return;
5916 }
5917
5918 bs->drv->bdrv_debug_event(bs, event);
5919 }
5920
5921 static BlockDriverState *bdrv_find_debug_node(BlockDriverState *bs)
5922 {
5923 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
5924 bs = bdrv_primary_bs(bs);
5925 }
5926
5927 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
5928 assert(bs->drv->bdrv_debug_remove_breakpoint);
5929 return bs;
5930 }
5931
5932 return NULL;
5933 }
5934
5935 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
5936 const char *tag)
5937 {
5938 bs = bdrv_find_debug_node(bs);
5939 if (bs) {
5940 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
5941 }
5942
5943 return -ENOTSUP;
5944 }
5945
5946 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
5947 {
5948 bs = bdrv_find_debug_node(bs);
5949 if (bs) {
5950 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
5951 }
5952
5953 return -ENOTSUP;
5954 }
5955
5956 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
5957 {
5958 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
5959 bs = bdrv_primary_bs(bs);
5960 }
5961
5962 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
5963 return bs->drv->bdrv_debug_resume(bs, tag);
5964 }
5965
5966 return -ENOTSUP;
5967 }
5968
5969 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
5970 {
5971 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
5972 bs = bdrv_primary_bs(bs);
5973 }
5974
5975 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
5976 return bs->drv->bdrv_debug_is_suspended(bs, tag);
5977 }
5978
5979 return false;
5980 }
5981
5982 /* backing_file can either be relative, or absolute, or a protocol. If it is
5983 * relative, it must be relative to the chain. So, passing in bs->filename
5984 * from a BDS as backing_file should not be done, as that may be relative to
5985 * the CWD rather than the chain. */
5986 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
5987 const char *backing_file)
5988 {
5989 char *filename_full = NULL;
5990 char *backing_file_full = NULL;
5991 char *filename_tmp = NULL;
5992 int is_protocol = 0;
5993 bool filenames_refreshed = false;
5994 BlockDriverState *curr_bs = NULL;
5995 BlockDriverState *retval = NULL;
5996 BlockDriverState *bs_below;
5997
5998 if (!bs || !bs->drv || !backing_file) {
5999 return NULL;
6000 }
6001
6002 filename_full = g_malloc(PATH_MAX);
6003 backing_file_full = g_malloc(PATH_MAX);
6004
6005 is_protocol = path_has_protocol(backing_file);
6006
6007 /*
6008 * Being largely a legacy function, skip any filters here
6009 * (because filters do not have normal filenames, so they cannot
6010 * match anyway; and allowing json:{} filenames is a bit out of
6011 * scope).
6012 */
6013 for (curr_bs = bdrv_skip_filters(bs);
6014 bdrv_cow_child(curr_bs) != NULL;
6015 curr_bs = bs_below)
6016 {
6017 bs_below = bdrv_backing_chain_next(curr_bs);
6018
6019 if (bdrv_backing_overridden(curr_bs)) {
6020 /*
6021 * If the backing file was overridden, we can only compare
6022 * directly against the backing node's filename.
6023 */
6024
6025 if (!filenames_refreshed) {
6026 /*
6027 * This will automatically refresh all of the
6028 * filenames in the rest of the backing chain, so we
6029 * only need to do this once.
6030 */
6031 bdrv_refresh_filename(bs_below);
6032 filenames_refreshed = true;
6033 }
6034
6035 if (strcmp(backing_file, bs_below->filename) == 0) {
6036 retval = bs_below;
6037 break;
6038 }
6039 } else if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
6040 /*
6041 * If either of the filename paths is actually a protocol, then
6042 * compare unmodified paths; otherwise make paths relative.
6043 */
6044 char *backing_file_full_ret;
6045
6046 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
6047 retval = bs_below;
6048 break;
6049 }
6050 /* Also check against the full backing filename for the image */
6051 backing_file_full_ret = bdrv_get_full_backing_filename(curr_bs,
6052 NULL);
6053 if (backing_file_full_ret) {
6054 bool equal = strcmp(backing_file, backing_file_full_ret) == 0;
6055 g_free(backing_file_full_ret);
6056 if (equal) {
6057 retval = bs_below;
6058 break;
6059 }
6060 }
6061 } else {
6062 /* If not an absolute filename path, make it relative to the current
6063 * image's filename path */
6064 filename_tmp = bdrv_make_absolute_filename(curr_bs, backing_file,
6065 NULL);
6066 /* We are going to compare canonicalized absolute pathnames */
6067 if (!filename_tmp || !realpath(filename_tmp, filename_full)) {
6068 g_free(filename_tmp);
6069 continue;
6070 }
6071 g_free(filename_tmp);
6072
6073 /* We need to make sure the backing filename we are comparing against
6074 * is relative to the current image filename (or absolute) */
6075 filename_tmp = bdrv_get_full_backing_filename(curr_bs, NULL);
6076 if (!filename_tmp || !realpath(filename_tmp, backing_file_full)) {
6077 g_free(filename_tmp);
6078 continue;
6079 }
6080 g_free(filename_tmp);
6081
6082 if (strcmp(backing_file_full, filename_full) == 0) {
6083 retval = bs_below;
6084 break;
6085 }
6086 }
6087 }
6088
6089 g_free(filename_full);
6090 g_free(backing_file_full);
6091 return retval;
6092 }
6093
6094 void bdrv_init(void)
6095 {
6096 module_call_init(MODULE_INIT_BLOCK);
6097 }
6098
6099 void bdrv_init_with_whitelist(void)
6100 {
6101 use_bdrv_whitelist = 1;
6102 bdrv_init();
6103 }
6104
6105 int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp)
6106 {
6107 BdrvChild *child, *parent;
6108 Error *local_err = NULL;
6109 int ret;
6110 BdrvDirtyBitmap *bm;
6111
6112 if (!bs->drv) {
6113 return -ENOMEDIUM;
6114 }
6115
6116 QLIST_FOREACH(child, &bs->children, next) {
6117 bdrv_co_invalidate_cache(child->bs, &local_err);
6118 if (local_err) {
6119 error_propagate(errp, local_err);
6120 return -EINVAL;
6121 }
6122 }
6123
6124 /*
6125 * Update permissions, they may differ for inactive nodes.
6126 *
6127 * Note that the required permissions of inactive images are always a
6128 * subset of the permissions required after activating the image. This
6129 * allows us to just get the permissions upfront without restricting
6130 * drv->bdrv_invalidate_cache().
6131 *
6132 * It also means that in error cases, we don't have to try and revert to
6133 * the old permissions (which is an operation that could fail, too). We can
6134 * just keep the extended permissions for the next time that an activation
6135 * of the image is tried.
6136 */
6137 if (bs->open_flags & BDRV_O_INACTIVE) {
6138 bs->open_flags &= ~BDRV_O_INACTIVE;
6139 ret = bdrv_refresh_perms(bs, errp);
6140 if (ret < 0) {
6141 bs->open_flags |= BDRV_O_INACTIVE;
6142 return ret;
6143 }
6144
6145 if (bs->drv->bdrv_co_invalidate_cache) {
6146 bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
6147 if (local_err) {
6148 bs->open_flags |= BDRV_O_INACTIVE;
6149 error_propagate(errp, local_err);
6150 return -EINVAL;
6151 }
6152 }
6153
6154 FOR_EACH_DIRTY_BITMAP(bs, bm) {
6155 bdrv_dirty_bitmap_skip_store(bm, false);
6156 }
6157
6158 ret = refresh_total_sectors(bs, bs->total_sectors);
6159 if (ret < 0) {
6160 bs->open_flags |= BDRV_O_INACTIVE;
6161 error_setg_errno(errp, -ret, "Could not refresh total sector count");
6162 return ret;
6163 }
6164 }
6165
6166 QLIST_FOREACH(parent, &bs->parents, next_parent) {
6167 if (parent->klass->activate) {
6168 parent->klass->activate(parent, &local_err);
6169 if (local_err) {
6170 bs->open_flags |= BDRV_O_INACTIVE;
6171 error_propagate(errp, local_err);
6172 return -EINVAL;
6173 }
6174 }
6175 }
6176
6177 return 0;
6178 }
6179
6180 void bdrv_invalidate_cache_all(Error **errp)
6181 {
6182 BlockDriverState *bs;
6183 BdrvNextIterator it;
6184
6185 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
6186 AioContext *aio_context = bdrv_get_aio_context(bs);
6187 int ret;
6188
6189 aio_context_acquire(aio_context);
6190 ret = bdrv_invalidate_cache(bs, errp);
6191 aio_context_release(aio_context);
6192 if (ret < 0) {
6193 bdrv_next_cleanup(&it);
6194 return;
6195 }
6196 }
6197 }
6198
6199 static bool bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
6200 {
6201 BdrvChild *parent;
6202
6203 QLIST_FOREACH(parent, &bs->parents, next_parent) {
6204 if (parent->klass->parent_is_bds) {
6205 BlockDriverState *parent_bs = parent->opaque;
6206 if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) {
6207 return true;
6208 }
6209 }
6210 }
6211
6212 return false;
6213 }
6214
6215 static int bdrv_inactivate_recurse(BlockDriverState *bs)
6216 {
6217 BdrvChild *child, *parent;
6218 int ret;
6219
6220 if (!bs->drv) {
6221 return -ENOMEDIUM;
6222 }
6223
6224 /* Make sure that we don't inactivate a child before its parent.
6225 * It will be covered by recursion from the yet active parent. */
6226 if (bdrv_has_bds_parent(bs, true)) {
6227 return 0;
6228 }
6229
6230 assert(!(bs->open_flags & BDRV_O_INACTIVE));
6231
6232 /* Inactivate this node */
6233 if (bs->drv->bdrv_inactivate) {
6234 ret = bs->drv->bdrv_inactivate(bs);
6235 if (ret < 0) {
6236 return ret;
6237 }
6238 }
6239
6240 QLIST_FOREACH(parent, &bs->parents, next_parent) {
6241 if (parent->klass->inactivate) {
6242 ret = parent->klass->inactivate(parent);
6243 if (ret < 0) {
6244 return ret;
6245 }
6246 }
6247 }
6248
6249 bs->open_flags |= BDRV_O_INACTIVE;
6250
6251 /*
6252 * Update permissions, they may differ for inactive nodes.
6253 * We only tried to loosen restrictions, so errors are not fatal, ignore
6254 * them.
6255 */
6256 bdrv_refresh_perms(bs, NULL);
6257
6258 /* Recursively inactivate children */
6259 QLIST_FOREACH(child, &bs->children, next) {
6260 ret = bdrv_inactivate_recurse(child->bs);
6261 if (ret < 0) {
6262 return ret;
6263 }
6264 }
6265
6266 return 0;
6267 }
6268
6269 int bdrv_inactivate_all(void)
6270 {
6271 BlockDriverState *bs = NULL;
6272 BdrvNextIterator it;
6273 int ret = 0;
6274 GSList *aio_ctxs = NULL, *ctx;
6275
6276 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
6277 AioContext *aio_context = bdrv_get_aio_context(bs);
6278
6279 if (!g_slist_find(aio_ctxs, aio_context)) {
6280 aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
6281 aio_context_acquire(aio_context);
6282 }
6283 }
6284
6285 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
6286 /* Nodes with BDS parents are covered by recursion from the last
6287 * parent that gets inactivated. Don't inactivate them a second
6288 * time if that has already happened. */
6289 if (bdrv_has_bds_parent(bs, false)) {
6290 continue;
6291 }
6292 ret = bdrv_inactivate_recurse(bs);
6293 if (ret < 0) {
6294 bdrv_next_cleanup(&it);
6295 goto out;
6296 }
6297 }
6298
6299 out:
6300 for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
6301 AioContext *aio_context = ctx->data;
6302 aio_context_release(aio_context);
6303 }
6304 g_slist_free(aio_ctxs);
6305
6306 return ret;
6307 }
6308
6309 /**************************************************************/
6310 /* removable device support */
6311
6312 /**
6313 * Return TRUE if the media is present
6314 */
6315 bool bdrv_is_inserted(BlockDriverState *bs)
6316 {
6317 BlockDriver *drv = bs->drv;
6318 BdrvChild *child;
6319
6320 if (!drv) {
6321 return false;
6322 }
6323 if (drv->bdrv_is_inserted) {
6324 return drv->bdrv_is_inserted(bs);
6325 }
6326 QLIST_FOREACH(child, &bs->children, next) {
6327 if (!bdrv_is_inserted(child->bs)) {
6328 return false;
6329 }
6330 }
6331 return true;
6332 }
6333
6334 /**
6335 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
6336 */
6337 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
6338 {
6339 BlockDriver *drv = bs->drv;
6340
6341 if (drv && drv->bdrv_eject) {
6342 drv->bdrv_eject(bs, eject_flag);
6343 }
6344 }
6345
6346 /**
6347 * Lock or unlock the media (if it is locked, the user won't be able
6348 * to eject it manually).
6349 */
6350 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
6351 {
6352 BlockDriver *drv = bs->drv;
6353
6354 trace_bdrv_lock_medium(bs, locked);
6355
6356 if (drv && drv->bdrv_lock_medium) {
6357 drv->bdrv_lock_medium(bs, locked);
6358 }
6359 }
6360
6361 /* Get a reference to bs */
6362 void bdrv_ref(BlockDriverState *bs)
6363 {
6364 bs->refcnt++;
6365 }
6366
6367 /* Release a previously grabbed reference to bs.
6368 * If after releasing, reference count is zero, the BlockDriverState is
6369 * deleted. */
6370 void bdrv_unref(BlockDriverState *bs)
6371 {
6372 if (!bs) {
6373 return;
6374 }
6375 assert(bs->refcnt > 0);
6376 if (--bs->refcnt == 0) {
6377 bdrv_delete(bs);
6378 }
6379 }
6380
6381 struct BdrvOpBlocker {
6382 Error *reason;
6383 QLIST_ENTRY(BdrvOpBlocker) list;
6384 };
6385
6386 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
6387 {
6388 BdrvOpBlocker *blocker;
6389 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
6390 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
6391 blocker = QLIST_FIRST(&bs->op_blockers[op]);
6392 error_propagate_prepend(errp, error_copy(blocker->reason),
6393 "Node '%s' is busy: ",
6394 bdrv_get_device_or_node_name(bs));
6395 return true;
6396 }
6397 return false;
6398 }
6399
6400 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
6401 {
6402 BdrvOpBlocker *blocker;
6403 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
6404
6405 blocker = g_new0(BdrvOpBlocker, 1);
6406 blocker->reason = reason;
6407 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
6408 }
6409
6410 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
6411 {
6412 BdrvOpBlocker *blocker, *next;
6413 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
6414 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
6415 if (blocker->reason == reason) {
6416 QLIST_REMOVE(blocker, list);
6417 g_free(blocker);
6418 }
6419 }
6420 }
6421
6422 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
6423 {
6424 int i;
6425 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
6426 bdrv_op_block(bs, i, reason);
6427 }
6428 }
6429
6430 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
6431 {
6432 int i;
6433 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
6434 bdrv_op_unblock(bs, i, reason);
6435 }
6436 }
6437
6438 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
6439 {
6440 int i;
6441
6442 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
6443 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
6444 return false;
6445 }
6446 }
6447 return true;
6448 }
6449
6450 void bdrv_img_create(const char *filename, const char *fmt,
6451 const char *base_filename, const char *base_fmt,
6452 char *options, uint64_t img_size, int flags, bool quiet,
6453 Error **errp)
6454 {
6455 QemuOptsList *create_opts = NULL;
6456 QemuOpts *opts = NULL;
6457 const char *backing_fmt, *backing_file;
6458 int64_t size;
6459 BlockDriver *drv, *proto_drv;
6460 Error *local_err = NULL;
6461 int ret = 0;
6462
6463 /* Find driver and parse its options */
6464 drv = bdrv_find_format(fmt);
6465 if (!drv) {
6466 error_setg(errp, "Unknown file format '%s'", fmt);
6467 return;
6468 }
6469
6470 proto_drv = bdrv_find_protocol(filename, true, errp);
6471 if (!proto_drv) {
6472 return;
6473 }
6474
6475 if (!drv->create_opts) {
6476 error_setg(errp, "Format driver '%s' does not support image creation",
6477 drv->format_name);
6478 return;
6479 }
6480
6481 if (!proto_drv->create_opts) {
6482 error_setg(errp, "Protocol driver '%s' does not support image creation",
6483 proto_drv->format_name);
6484 return;
6485 }
6486
6487 /* Create parameter list */
6488 create_opts = qemu_opts_append(create_opts, drv->create_opts);
6489 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
6490
6491 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
6492
6493 /* Parse -o options */
6494 if (options) {
6495 if (!qemu_opts_do_parse(opts, options, NULL, errp)) {
6496 goto out;
6497 }
6498 }
6499
6500 if (!qemu_opt_get(opts, BLOCK_OPT_SIZE)) {
6501 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
6502 } else if (img_size != UINT64_C(-1)) {
6503 error_setg(errp, "The image size must be specified only once");
6504 goto out;
6505 }
6506
6507 if (base_filename) {
6508 if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename,
6509 NULL)) {
6510 error_setg(errp, "Backing file not supported for file format '%s'",
6511 fmt);
6512 goto out;
6513 }
6514 }
6515
6516 if (base_fmt) {
6517 if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, NULL)) {
6518 error_setg(errp, "Backing file format not supported for file "
6519 "format '%s'", fmt);
6520 goto out;
6521 }
6522 }
6523
6524 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
6525 if (backing_file) {
6526 if (!strcmp(filename, backing_file)) {
6527 error_setg(errp, "Error: Trying to create an image with the "
6528 "same filename as the backing file");
6529 goto out;
6530 }
6531 if (backing_file[0] == '\0') {
6532 error_setg(errp, "Expected backing file name, got empty string");
6533 goto out;
6534 }
6535 }
6536
6537 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
6538
6539 /* The size for the image must always be specified, unless we have a backing
6540 * file and we have not been forbidden from opening it. */
6541 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
6542 if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
6543 BlockDriverState *bs;
6544 char *full_backing;
6545 int back_flags;
6546 QDict *backing_options = NULL;
6547
6548 full_backing =
6549 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
6550 &local_err);
6551 if (local_err) {
6552 goto out;
6553 }
6554 assert(full_backing);
6555
6556 /* backing files always opened read-only */
6557 back_flags = flags;
6558 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
6559
6560 backing_options = qdict_new();
6561 if (backing_fmt) {
6562 qdict_put_str(backing_options, "driver", backing_fmt);
6563 }
6564 qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
6565
6566 bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
6567 &local_err);
6568 g_free(full_backing);
6569 if (!bs) {
6570 error_append_hint(&local_err, "Could not open backing image.\n");
6571 goto out;
6572 } else {
6573 if (!backing_fmt) {
6574 warn_report("Deprecated use of backing file without explicit "
6575 "backing format (detected format of %s)",
6576 bs->drv->format_name);
6577 if (bs->drv != &bdrv_raw) {
6578 /*
6579 * A probe of raw deserves the most attention:
6580 * leaving the backing format out of the image
6581 * will ensure bs->probed is set (ensuring we
6582 * don't accidentally commit into the backing
6583 * file), and allow more spots to warn the users
6584 * to fix their toolchain when opening this image
6585 * later. For other images, we can safely record
6586 * the format that we probed.
6587 */
6588 backing_fmt = bs->drv->format_name;
6589 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, backing_fmt,
6590 NULL);
6591 }
6592 }
6593 if (size == -1) {
6594 /* Opened BS, have no size */
6595 size = bdrv_getlength(bs);
6596 if (size < 0) {
6597 error_setg_errno(errp, -size, "Could not get size of '%s'",
6598 backing_file);
6599 bdrv_unref(bs);
6600 goto out;
6601 }
6602 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
6603 }
6604 bdrv_unref(bs);
6605 }
6606 /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */
6607 } else if (backing_file && !backing_fmt) {
6608 warn_report("Deprecated use of unopened backing file without "
6609 "explicit backing format, use of this image requires "
6610 "potentially unsafe format probing");
6611 }
6612
6613 if (size == -1) {
6614 error_setg(errp, "Image creation needs a size parameter");
6615 goto out;
6616 }
6617
6618 if (!quiet) {
6619 printf("Formatting '%s', fmt=%s ", filename, fmt);
6620 qemu_opts_print(opts, " ");
6621 puts("");
6622 fflush(stdout);
6623 }
6624
6625 ret = bdrv_create(drv, filename, opts, &local_err);
6626
6627 if (ret == -EFBIG) {
6628 /* This is generally a better message than whatever the driver would
6629 * deliver (especially because of the cluster_size_hint), since that
6630 * is most probably not much different from "image too large". */
6631 const char *cluster_size_hint = "";
6632 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
6633 cluster_size_hint = " (try using a larger cluster size)";
6634 }
6635 error_setg(errp, "The image size is too large for file format '%s'"
6636 "%s", fmt, cluster_size_hint);
6637 error_free(local_err);
6638 local_err = NULL;
6639 }
6640
6641 out:
6642 qemu_opts_del(opts);
6643 qemu_opts_free(create_opts);
6644 error_propagate(errp, local_err);
6645 }
6646
6647 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
6648 {
6649 return bs ? bs->aio_context : qemu_get_aio_context();
6650 }
6651
6652 AioContext *coroutine_fn bdrv_co_enter(BlockDriverState *bs)
6653 {
6654 Coroutine *self = qemu_coroutine_self();
6655 AioContext *old_ctx = qemu_coroutine_get_aio_context(self);
6656 AioContext *new_ctx;
6657
6658 /*
6659 * Increase bs->in_flight to ensure that this operation is completed before
6660 * moving the node to a different AioContext. Read new_ctx only afterwards.
6661 */
6662 bdrv_inc_in_flight(bs);
6663
6664 new_ctx = bdrv_get_aio_context(bs);
6665 aio_co_reschedule_self(new_ctx);
6666 return old_ctx;
6667 }
6668
6669 void coroutine_fn bdrv_co_leave(BlockDriverState *bs, AioContext *old_ctx)
6670 {
6671 aio_co_reschedule_self(old_ctx);
6672 bdrv_dec_in_flight(bs);
6673 }
6674
6675 void coroutine_fn bdrv_co_lock(BlockDriverState *bs)
6676 {
6677 AioContext *ctx = bdrv_get_aio_context(bs);
6678
6679 /* In the main thread, bs->aio_context won't change concurrently */
6680 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
6681
6682 /*
6683 * We're in coroutine context, so we already hold the lock of the main
6684 * loop AioContext. Don't lock it twice to avoid deadlocks.
6685 */
6686 assert(qemu_in_coroutine());
6687 if (ctx != qemu_get_aio_context()) {
6688 aio_context_acquire(ctx);
6689 }
6690 }
6691
6692 void coroutine_fn bdrv_co_unlock(BlockDriverState *bs)
6693 {
6694 AioContext *ctx = bdrv_get_aio_context(bs);
6695
6696 assert(qemu_in_coroutine());
6697 if (ctx != qemu_get_aio_context()) {
6698 aio_context_release(ctx);
6699 }
6700 }
6701
6702 void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)
6703 {
6704 aio_co_enter(bdrv_get_aio_context(bs), co);
6705 }
6706
6707 static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
6708 {
6709 QLIST_REMOVE(ban, list);
6710 g_free(ban);
6711 }
6712
6713 static void bdrv_detach_aio_context(BlockDriverState *bs)
6714 {
6715 BdrvAioNotifier *baf, *baf_tmp;
6716
6717 assert(!bs->walking_aio_notifiers);
6718 bs->walking_aio_notifiers = true;
6719 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
6720 if (baf->deleted) {
6721 bdrv_do_remove_aio_context_notifier(baf);
6722 } else {
6723 baf->detach_aio_context(baf->opaque);
6724 }
6725 }
6726 /* Never mind iterating again to check for ->deleted. bdrv_close() will
6727 * remove remaining aio notifiers if we aren't called again.
6728 */
6729 bs->walking_aio_notifiers = false;
6730
6731 if (bs->drv && bs->drv->bdrv_detach_aio_context) {
6732 bs->drv->bdrv_detach_aio_context(bs);
6733 }
6734
6735 if (bs->quiesce_counter) {
6736 aio_enable_external(bs->aio_context);
6737 }
6738 bs->aio_context = NULL;
6739 }
6740
6741 static void bdrv_attach_aio_context(BlockDriverState *bs,
6742 AioContext *new_context)
6743 {
6744 BdrvAioNotifier *ban, *ban_tmp;
6745
6746 if (bs->quiesce_counter) {
6747 aio_disable_external(new_context);
6748 }
6749
6750 bs->aio_context = new_context;
6751
6752 if (bs->drv && bs->drv->bdrv_attach_aio_context) {
6753 bs->drv->bdrv_attach_aio_context(bs, new_context);
6754 }
6755
6756 assert(!bs->walking_aio_notifiers);
6757 bs->walking_aio_notifiers = true;
6758 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
6759 if (ban->deleted) {
6760 bdrv_do_remove_aio_context_notifier(ban);
6761 } else {
6762 ban->attached_aio_context(new_context, ban->opaque);
6763 }
6764 }
6765 bs->walking_aio_notifiers = false;
6766 }
6767
6768 /*
6769 * Changes the AioContext used for fd handlers, timers, and BHs by this
6770 * BlockDriverState and all its children and parents.
6771 *
6772 * Must be called from the main AioContext.
6773 *
6774 * The caller must own the AioContext lock for the old AioContext of bs, but it
6775 * must not own the AioContext lock for new_context (unless new_context is the
6776 * same as the current context of bs).
6777 *
6778 * @ignore will accumulate all visited BdrvChild object. The caller is
6779 * responsible for freeing the list afterwards.
6780 */
6781 void bdrv_set_aio_context_ignore(BlockDriverState *bs,
6782 AioContext *new_context, GSList **ignore)
6783 {
6784 AioContext *old_context = bdrv_get_aio_context(bs);
6785 GSList *children_to_process = NULL;
6786 GSList *parents_to_process = NULL;
6787 GSList *entry;
6788 BdrvChild *child, *parent;
6789
6790 g_assert(qemu_get_current_aio_context() == qemu_get_aio_context());
6791
6792 if (old_context == new_context) {
6793 return;
6794 }
6795
6796 bdrv_drained_begin(bs);
6797
6798 QLIST_FOREACH(child, &bs->children, next) {
6799 if (g_slist_find(*ignore, child)) {
6800 continue;
6801 }
6802 *ignore = g_slist_prepend(*ignore, child);
6803 children_to_process = g_slist_prepend(children_to_process, child);
6804 }
6805
6806 QLIST_FOREACH(parent, &bs->parents, next_parent) {
6807 if (g_slist_find(*ignore, parent)) {
6808 continue;
6809 }
6810 *ignore = g_slist_prepend(*ignore, parent);
6811 parents_to_process = g_slist_prepend(parents_to_process, parent);
6812 }
6813
6814 for (entry = children_to_process;
6815 entry != NULL;
6816 entry = g_slist_next(entry)) {
6817 child = entry->data;
6818 bdrv_set_aio_context_ignore(child->bs, new_context, ignore);
6819 }
6820 g_slist_free(children_to_process);
6821
6822 for (entry = parents_to_process;
6823 entry != NULL;
6824 entry = g_slist_next(entry)) {
6825 parent = entry->data;
6826 assert(parent->klass->set_aio_ctx);
6827 parent->klass->set_aio_ctx(parent, new_context, ignore);
6828 }
6829 g_slist_free(parents_to_process);
6830
6831 bdrv_detach_aio_context(bs);
6832
6833 /* Acquire the new context, if necessary */
6834 if (qemu_get_aio_context() != new_context) {
6835 aio_context_acquire(new_context);
6836 }
6837
6838 bdrv_attach_aio_context(bs, new_context);
6839
6840 /*
6841 * If this function was recursively called from
6842 * bdrv_set_aio_context_ignore(), there may be nodes in the
6843 * subtree that have not yet been moved to the new AioContext.
6844 * Release the old one so bdrv_drained_end() can poll them.
6845 */
6846 if (qemu_get_aio_context() != old_context) {
6847 aio_context_release(old_context);
6848 }
6849
6850 bdrv_drained_end(bs);
6851
6852 if (qemu_get_aio_context() != old_context) {
6853 aio_context_acquire(old_context);
6854 }
6855 if (qemu_get_aio_context() != new_context) {
6856 aio_context_release(new_context);
6857 }
6858 }
6859
6860 static bool bdrv_parent_can_set_aio_context(BdrvChild *c, AioContext *ctx,
6861 GSList **ignore, Error **errp)
6862 {
6863 if (g_slist_find(*ignore, c)) {
6864 return true;
6865 }
6866 *ignore = g_slist_prepend(*ignore, c);
6867
6868 /*
6869 * A BdrvChildClass that doesn't handle AioContext changes cannot
6870 * tolerate any AioContext changes
6871 */
6872 if (!c->klass->can_set_aio_ctx) {
6873 char *user = bdrv_child_user_desc(c);
6874 error_setg(errp, "Changing iothreads is not supported by %s", user);
6875 g_free(user);
6876 return false;
6877 }
6878 if (!c->klass->can_set_aio_ctx(c, ctx, ignore, errp)) {
6879 assert(!errp || *errp);
6880 return false;
6881 }
6882 return true;
6883 }
6884
6885 bool bdrv_child_can_set_aio_context(BdrvChild *c, AioContext *ctx,
6886 GSList **ignore, Error **errp)
6887 {
6888 if (g_slist_find(*ignore, c)) {
6889 return true;
6890 }
6891 *ignore = g_slist_prepend(*ignore, c);
6892 return bdrv_can_set_aio_context(c->bs, ctx, ignore, errp);
6893 }
6894
6895 /* @ignore will accumulate all visited BdrvChild object. The caller is
6896 * responsible for freeing the list afterwards. */
6897 bool bdrv_can_set_aio_context(BlockDriverState *bs, AioContext *ctx,
6898 GSList **ignore, Error **errp)
6899 {
6900 BdrvChild *c;
6901
6902 if (bdrv_get_aio_context(bs) == ctx) {
6903 return true;
6904 }
6905
6906 QLIST_FOREACH(c, &bs->parents, next_parent) {
6907 if (!bdrv_parent_can_set_aio_context(c, ctx, ignore, errp)) {
6908 return false;
6909 }
6910 }
6911 QLIST_FOREACH(c, &bs->children, next) {
6912 if (!bdrv_child_can_set_aio_context(c, ctx, ignore, errp)) {
6913 return false;
6914 }
6915 }
6916
6917 return true;
6918 }
6919
6920 int bdrv_child_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,
6921 BdrvChild *ignore_child, Error **errp)
6922 {
6923 GSList *ignore;
6924 bool ret;
6925
6926 ignore = ignore_child ? g_slist_prepend(NULL, ignore_child) : NULL;
6927 ret = bdrv_can_set_aio_context(bs, ctx, &ignore, errp);
6928 g_slist_free(ignore);
6929
6930 if (!ret) {
6931 return -EPERM;
6932 }
6933
6934 ignore = ignore_child ? g_slist_prepend(NULL, ignore_child) : NULL;
6935 bdrv_set_aio_context_ignore(bs, ctx, &ignore);
6936 g_slist_free(ignore);
6937
6938 return 0;
6939 }
6940
6941 int bdrv_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,
6942 Error **errp)
6943 {
6944 return bdrv_child_try_set_aio_context(bs, ctx, NULL, errp);
6945 }
6946
6947 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
6948 void (*attached_aio_context)(AioContext *new_context, void *opaque),
6949 void (*detach_aio_context)(void *opaque), void *opaque)
6950 {
6951 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
6952 *ban = (BdrvAioNotifier){
6953 .attached_aio_context = attached_aio_context,
6954 .detach_aio_context = detach_aio_context,
6955 .opaque = opaque
6956 };
6957
6958 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
6959 }
6960
6961 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
6962 void (*attached_aio_context)(AioContext *,
6963 void *),
6964 void (*detach_aio_context)(void *),
6965 void *opaque)
6966 {
6967 BdrvAioNotifier *ban, *ban_next;
6968
6969 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
6970 if (ban->attached_aio_context == attached_aio_context &&
6971 ban->detach_aio_context == detach_aio_context &&
6972 ban->opaque == opaque &&
6973 ban->deleted == false)
6974 {
6975 if (bs->walking_aio_notifiers) {
6976 ban->deleted = true;
6977 } else {
6978 bdrv_do_remove_aio_context_notifier(ban);
6979 }
6980 return;
6981 }
6982 }
6983
6984 abort();
6985 }
6986
6987 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
6988 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
6989 bool force,
6990 Error **errp)
6991 {
6992 if (!bs->drv) {
6993 error_setg(errp, "Node is ejected");
6994 return -ENOMEDIUM;
6995 }
6996 if (!bs->drv->bdrv_amend_options) {
6997 error_setg(errp, "Block driver '%s' does not support option amendment",
6998 bs->drv->format_name);
6999 return -ENOTSUP;
7000 }
7001 return bs->drv->bdrv_amend_options(bs, opts, status_cb,
7002 cb_opaque, force, errp);
7003 }
7004
7005 /*
7006 * This function checks whether the given @to_replace is allowed to be
7007 * replaced by a node that always shows the same data as @bs. This is
7008 * used for example to verify whether the mirror job can replace
7009 * @to_replace by the target mirrored from @bs.
7010 * To be replaceable, @bs and @to_replace may either be guaranteed to
7011 * always show the same data (because they are only connected through
7012 * filters), or some driver may allow replacing one of its children
7013 * because it can guarantee that this child's data is not visible at
7014 * all (for example, for dissenting quorum children that have no other
7015 * parents).
7016 */
7017 bool bdrv_recurse_can_replace(BlockDriverState *bs,
7018 BlockDriverState *to_replace)
7019 {
7020 BlockDriverState *filtered;
7021
7022 if (!bs || !bs->drv) {
7023 return false;
7024 }
7025
7026 if (bs == to_replace) {
7027 return true;
7028 }
7029
7030 /* See what the driver can do */
7031 if (bs->drv->bdrv_recurse_can_replace) {
7032 return bs->drv->bdrv_recurse_can_replace(bs, to_replace);
7033 }
7034
7035 /* For filters without an own implementation, we can recurse on our own */
7036 filtered = bdrv_filter_bs(bs);
7037 if (filtered) {
7038 return bdrv_recurse_can_replace(filtered, to_replace);
7039 }
7040
7041 /* Safe default */
7042 return false;
7043 }
7044
7045 /*
7046 * Check whether the given @node_name can be replaced by a node that
7047 * has the same data as @parent_bs. If so, return @node_name's BDS;
7048 * NULL otherwise.
7049 *
7050 * @node_name must be a (recursive) *child of @parent_bs (or this
7051 * function will return NULL).
7052 *
7053 * The result (whether the node can be replaced or not) is only valid
7054 * for as long as no graph or permission changes occur.
7055 */
7056 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
7057 const char *node_name, Error **errp)
7058 {
7059 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
7060 AioContext *aio_context;
7061
7062 if (!to_replace_bs) {
7063 error_setg(errp, "Failed to find node with node-name='%s'", node_name);
7064 return NULL;
7065 }
7066
7067 aio_context = bdrv_get_aio_context(to_replace_bs);
7068 aio_context_acquire(aio_context);
7069
7070 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
7071 to_replace_bs = NULL;
7072 goto out;
7073 }
7074
7075 /* We don't want arbitrary node of the BDS chain to be replaced only the top
7076 * most non filter in order to prevent data corruption.
7077 * Another benefit is that this tests exclude backing files which are
7078 * blocked by the backing blockers.
7079 */
7080 if (!bdrv_recurse_can_replace(parent_bs, to_replace_bs)) {
7081 error_setg(errp, "Cannot replace '%s' by a node mirrored from '%s', "
7082 "because it cannot be guaranteed that doing so would not "
7083 "lead to an abrupt change of visible data",
7084 node_name, parent_bs->node_name);
7085 to_replace_bs = NULL;
7086 goto out;
7087 }
7088
7089 out:
7090 aio_context_release(aio_context);
7091 return to_replace_bs;
7092 }
7093
7094 /**
7095 * Iterates through the list of runtime option keys that are said to
7096 * be "strong" for a BDS. An option is called "strong" if it changes
7097 * a BDS's data. For example, the null block driver's "size" and
7098 * "read-zeroes" options are strong, but its "latency-ns" option is
7099 * not.
7100 *
7101 * If a key returned by this function ends with a dot, all options
7102 * starting with that prefix are strong.
7103 */
7104 static const char *const *strong_options(BlockDriverState *bs,
7105 const char *const *curopt)
7106 {
7107 static const char *const global_options[] = {
7108 "driver", "filename", NULL
7109 };
7110
7111 if (!curopt) {
7112 return &global_options[0];
7113 }
7114
7115 curopt++;
7116 if (curopt == &global_options[ARRAY_SIZE(global_options) - 1] && bs->drv) {
7117 curopt = bs->drv->strong_runtime_opts;
7118 }
7119
7120 return (curopt && *curopt) ? curopt : NULL;
7121 }
7122
7123 /**
7124 * Copies all strong runtime options from bs->options to the given
7125 * QDict. The set of strong option keys is determined by invoking
7126 * strong_options().
7127 *
7128 * Returns true iff any strong option was present in bs->options (and
7129 * thus copied to the target QDict) with the exception of "filename"
7130 * and "driver". The caller is expected to use this value to decide
7131 * whether the existence of strong options prevents the generation of
7132 * a plain filename.
7133 */
7134 static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs)
7135 {
7136 bool found_any = false;
7137 const char *const *option_name = NULL;
7138
7139 if (!bs->drv) {
7140 return false;
7141 }
7142
7143 while ((option_name = strong_options(bs, option_name))) {
7144 bool option_given = false;
7145
7146 assert(strlen(*option_name) > 0);
7147 if ((*option_name)[strlen(*option_name) - 1] != '.') {
7148 QObject *entry = qdict_get(bs->options, *option_name);
7149 if (!entry) {
7150 continue;
7151 }
7152
7153 qdict_put_obj(d, *option_name, qobject_ref(entry));
7154 option_given = true;
7155 } else {
7156 const QDictEntry *entry;
7157 for (entry = qdict_first(bs->options); entry;
7158 entry = qdict_next(bs->options, entry))
7159 {
7160 if (strstart(qdict_entry_key(entry), *option_name, NULL)) {
7161 qdict_put_obj(d, qdict_entry_key(entry),
7162 qobject_ref(qdict_entry_value(entry)));
7163 option_given = true;
7164 }
7165 }
7166 }
7167
7168 /* While "driver" and "filename" need to be included in a JSON filename,
7169 * their existence does not prohibit generation of a plain filename. */
7170 if (!found_any && option_given &&
7171 strcmp(*option_name, "driver") && strcmp(*option_name, "filename"))
7172 {
7173 found_any = true;
7174 }
7175 }
7176
7177 if (!qdict_haskey(d, "driver")) {
7178 /* Drivers created with bdrv_new_open_driver() may not have a
7179 * @driver option. Add it here. */
7180 qdict_put_str(d, "driver", bs->drv->format_name);
7181 }
7182
7183 return found_any;
7184 }
7185
7186 /* Note: This function may return false positives; it may return true
7187 * even if opening the backing file specified by bs's image header
7188 * would result in exactly bs->backing. */
7189 bool bdrv_backing_overridden(BlockDriverState *bs)
7190 {
7191 if (bs->backing) {
7192 return strcmp(bs->auto_backing_file,
7193 bs->backing->bs->filename);
7194 } else {
7195 /* No backing BDS, so if the image header reports any backing
7196 * file, it must have been suppressed */
7197 return bs->auto_backing_file[0] != '\0';
7198 }
7199 }
7200
7201 /* Updates the following BDS fields:
7202 * - exact_filename: A filename which may be used for opening a block device
7203 * which (mostly) equals the given BDS (even without any
7204 * other options; so reading and writing must return the same
7205 * results, but caching etc. may be different)
7206 * - full_open_options: Options which, when given when opening a block device
7207 * (without a filename), result in a BDS (mostly)
7208 * equalling the given one
7209 * - filename: If exact_filename is set, it is copied here. Otherwise,
7210 * full_open_options is converted to a JSON object, prefixed with
7211 * "json:" (for use through the JSON pseudo protocol) and put here.
7212 */
7213 void bdrv_refresh_filename(BlockDriverState *bs)
7214 {
7215 BlockDriver *drv = bs->drv;
7216 BdrvChild *child;
7217 BlockDriverState *primary_child_bs;
7218 QDict *opts;
7219 bool backing_overridden;
7220 bool generate_json_filename; /* Whether our default implementation should
7221 fill exact_filename (false) or not (true) */
7222
7223 if (!drv) {
7224 return;
7225 }
7226
7227 /* This BDS's file name may depend on any of its children's file names, so
7228 * refresh those first */
7229 QLIST_FOREACH(child, &bs->children, next) {
7230 bdrv_refresh_filename(child->bs);
7231 }
7232
7233 if (bs->implicit) {
7234 /* For implicit nodes, just copy everything from the single child */
7235 child = QLIST_FIRST(&bs->children);
7236 assert(QLIST_NEXT(child, next) == NULL);
7237
7238 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
7239 child->bs->exact_filename);
7240 pstrcpy(bs->filename, sizeof(bs->filename), child->bs->filename);
7241
7242 qobject_unref(bs->full_open_options);
7243 bs->full_open_options = qobject_ref(child->bs->full_open_options);
7244
7245 return;
7246 }
7247
7248 backing_overridden = bdrv_backing_overridden(bs);
7249
7250 if (bs->open_flags & BDRV_O_NO_IO) {
7251 /* Without I/O, the backing file does not change anything.
7252 * Therefore, in such a case (primarily qemu-img), we can
7253 * pretend the backing file has not been overridden even if
7254 * it technically has been. */
7255 backing_overridden = false;
7256 }
7257
7258 /* Gather the options QDict */
7259 opts = qdict_new();
7260 generate_json_filename = append_strong_runtime_options(opts, bs);
7261 generate_json_filename |= backing_overridden;
7262
7263 if (drv->bdrv_gather_child_options) {
7264 /* Some block drivers may not want to present all of their children's
7265 * options, or name them differently from BdrvChild.name */
7266 drv->bdrv_gather_child_options(bs, opts, backing_overridden);
7267 } else {
7268 QLIST_FOREACH(child, &bs->children, next) {
7269 if (child == bs->backing && !backing_overridden) {
7270 /* We can skip the backing BDS if it has not been overridden */
7271 continue;
7272 }
7273
7274 qdict_put(opts, child->name,
7275 qobject_ref(child->bs->full_open_options));
7276 }
7277
7278 if (backing_overridden && !bs->backing) {
7279 /* Force no backing file */
7280 qdict_put_null(opts, "backing");
7281 }
7282 }
7283
7284 qobject_unref(bs->full_open_options);
7285 bs->full_open_options = opts;
7286
7287 primary_child_bs = bdrv_primary_bs(bs);
7288
7289 if (drv->bdrv_refresh_filename) {
7290 /* Obsolete information is of no use here, so drop the old file name
7291 * information before refreshing it */
7292 bs->exact_filename[0] = '\0';
7293
7294 drv->bdrv_refresh_filename(bs);
7295 } else if (primary_child_bs) {
7296 /*
7297 * Try to reconstruct valid information from the underlying
7298 * file -- this only works for format nodes (filter nodes
7299 * cannot be probed and as such must be selected by the user
7300 * either through an options dict, or through a special
7301 * filename which the filter driver must construct in its
7302 * .bdrv_refresh_filename() implementation).
7303 */
7304
7305 bs->exact_filename[0] = '\0';
7306
7307 /*
7308 * We can use the underlying file's filename if:
7309 * - it has a filename,
7310 * - the current BDS is not a filter,
7311 * - the file is a protocol BDS, and
7312 * - opening that file (as this BDS's format) will automatically create
7313 * the BDS tree we have right now, that is:
7314 * - the user did not significantly change this BDS's behavior with
7315 * some explicit (strong) options
7316 * - no non-file child of this BDS has been overridden by the user
7317 * Both of these conditions are represented by generate_json_filename.
7318 */
7319 if (primary_child_bs->exact_filename[0] &&
7320 primary_child_bs->drv->bdrv_file_open &&
7321 !drv->is_filter && !generate_json_filename)
7322 {
7323 strcpy(bs->exact_filename, primary_child_bs->exact_filename);
7324 }
7325 }
7326
7327 if (bs->exact_filename[0]) {
7328 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
7329 } else {
7330 GString *json = qobject_to_json(QOBJECT(bs->full_open_options));
7331 if (snprintf(bs->filename, sizeof(bs->filename), "json:%s",
7332 json->str) >= sizeof(bs->filename)) {
7333 /* Give user a hint if we truncated things. */
7334 strcpy(bs->filename + sizeof(bs->filename) - 4, "...");
7335 }
7336 g_string_free(json, true);
7337 }
7338 }
7339
7340 char *bdrv_dirname(BlockDriverState *bs, Error **errp)
7341 {
7342 BlockDriver *drv = bs->drv;
7343 BlockDriverState *child_bs;
7344
7345 if (!drv) {
7346 error_setg(errp, "Node '%s' is ejected", bs->node_name);
7347 return NULL;
7348 }
7349
7350 if (drv->bdrv_dirname) {
7351 return drv->bdrv_dirname(bs, errp);
7352 }
7353
7354 child_bs = bdrv_primary_bs(bs);
7355 if (child_bs) {
7356 return bdrv_dirname(child_bs, errp);
7357 }
7358
7359 bdrv_refresh_filename(bs);
7360 if (bs->exact_filename[0] != '\0') {
7361 return path_combine(bs->exact_filename, "");
7362 }
7363
7364 error_setg(errp, "Cannot generate a base directory for %s nodes",
7365 drv->format_name);
7366 return NULL;
7367 }
7368
7369 /*
7370 * Hot add/remove a BDS's child. So the user can take a child offline when
7371 * it is broken and take a new child online
7372 */
7373 void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
7374 Error **errp)
7375 {
7376
7377 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
7378 error_setg(errp, "The node %s does not support adding a child",
7379 bdrv_get_device_or_node_name(parent_bs));
7380 return;
7381 }
7382
7383 if (!QLIST_EMPTY(&child_bs->parents)) {
7384 error_setg(errp, "The node %s already has a parent",
7385 child_bs->node_name);
7386 return;
7387 }
7388
7389 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
7390 }
7391
7392 void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
7393 {
7394 BdrvChild *tmp;
7395
7396 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
7397 error_setg(errp, "The node %s does not support removing a child",
7398 bdrv_get_device_or_node_name(parent_bs));
7399 return;
7400 }
7401
7402 QLIST_FOREACH(tmp, &parent_bs->children, next) {
7403 if (tmp == child) {
7404 break;
7405 }
7406 }
7407
7408 if (!tmp) {
7409 error_setg(errp, "The node %s does not have a child named %s",
7410 bdrv_get_device_or_node_name(parent_bs),
7411 bdrv_get_device_or_node_name(child->bs));
7412 return;
7413 }
7414
7415 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
7416 }
7417
7418 int bdrv_make_empty(BdrvChild *c, Error **errp)
7419 {
7420 BlockDriver *drv = c->bs->drv;
7421 int ret;
7422
7423 assert(c->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED));
7424
7425 if (!drv->bdrv_make_empty) {
7426 error_setg(errp, "%s does not support emptying nodes",
7427 drv->format_name);
7428 return -ENOTSUP;
7429 }
7430
7431 ret = drv->bdrv_make_empty(c->bs);
7432 if (ret < 0) {
7433 error_setg_errno(errp, -ret, "Failed to empty %s",
7434 c->bs->filename);
7435 return ret;
7436 }
7437
7438 return 0;
7439 }
7440
7441 /*
7442 * Return the child that @bs acts as an overlay for, and from which data may be
7443 * copied in COW or COR operations. Usually this is the backing file.
7444 */
7445 BdrvChild *bdrv_cow_child(BlockDriverState *bs)
7446 {
7447 if (!bs || !bs->drv) {
7448 return NULL;
7449 }
7450
7451 if (bs->drv->is_filter) {
7452 return NULL;
7453 }
7454
7455 if (!bs->backing) {
7456 return NULL;
7457 }
7458
7459 assert(bs->backing->role & BDRV_CHILD_COW);
7460 return bs->backing;
7461 }
7462
7463 /*
7464 * If @bs acts as a filter for exactly one of its children, return
7465 * that child.
7466 */
7467 BdrvChild *bdrv_filter_child(BlockDriverState *bs)
7468 {
7469 BdrvChild *c;
7470
7471 if (!bs || !bs->drv) {
7472 return NULL;
7473 }
7474
7475 if (!bs->drv->is_filter) {
7476 return NULL;
7477 }
7478
7479 /* Only one of @backing or @file may be used */
7480 assert(!(bs->backing && bs->file));
7481
7482 c = bs->backing ?: bs->file;
7483 if (!c) {
7484 return NULL;
7485 }
7486
7487 assert(c->role & BDRV_CHILD_FILTERED);
7488 return c;
7489 }
7490
7491 /*
7492 * Return either the result of bdrv_cow_child() or bdrv_filter_child(),
7493 * whichever is non-NULL.
7494 *
7495 * Return NULL if both are NULL.
7496 */
7497 BdrvChild *bdrv_filter_or_cow_child(BlockDriverState *bs)
7498 {
7499 BdrvChild *cow_child = bdrv_cow_child(bs);
7500 BdrvChild *filter_child = bdrv_filter_child(bs);
7501
7502 /* Filter nodes cannot have COW backing files */
7503 assert(!(cow_child && filter_child));
7504
7505 return cow_child ?: filter_child;
7506 }
7507
7508 /*
7509 * Return the primary child of this node: For filters, that is the
7510 * filtered child. For other nodes, that is usually the child storing
7511 * metadata.
7512 * (A generally more helpful description is that this is (usually) the
7513 * child that has the same filename as @bs.)
7514 *
7515 * Drivers do not necessarily have a primary child; for example quorum
7516 * does not.
7517 */
7518 BdrvChild *bdrv_primary_child(BlockDriverState *bs)
7519 {
7520 BdrvChild *c, *found = NULL;
7521
7522 QLIST_FOREACH(c, &bs->children, next) {
7523 if (c->role & BDRV_CHILD_PRIMARY) {
7524 assert(!found);
7525 found = c;
7526 }
7527 }
7528
7529 return found;
7530 }
7531
7532 static BlockDriverState *bdrv_do_skip_filters(BlockDriverState *bs,
7533 bool stop_on_explicit_filter)
7534 {
7535 BdrvChild *c;
7536
7537 if (!bs) {
7538 return NULL;
7539 }
7540
7541 while (!(stop_on_explicit_filter && !bs->implicit)) {
7542 c = bdrv_filter_child(bs);
7543 if (!c) {
7544 /*
7545 * A filter that is embedded in a working block graph must
7546 * have a child. Assert this here so this function does
7547 * not return a filter node that is not expected by the
7548 * caller.
7549 */
7550 assert(!bs->drv || !bs->drv->is_filter);
7551 break;
7552 }
7553 bs = c->bs;
7554 }
7555 /*
7556 * Note that this treats nodes with bs->drv == NULL as not being
7557 * filters (bs->drv == NULL should be replaced by something else
7558 * anyway).
7559 * The advantage of this behavior is that this function will thus
7560 * always return a non-NULL value (given a non-NULL @bs).
7561 */
7562
7563 return bs;
7564 }
7565
7566 /*
7567 * Return the first BDS that has not been added implicitly or that
7568 * does not have a filtered child down the chain starting from @bs
7569 * (including @bs itself).
7570 */
7571 BlockDriverState *bdrv_skip_implicit_filters(BlockDriverState *bs)
7572 {
7573 return bdrv_do_skip_filters(bs, true);
7574 }
7575
7576 /*
7577 * Return the first BDS that does not have a filtered child down the
7578 * chain starting from @bs (including @bs itself).
7579 */
7580 BlockDriverState *bdrv_skip_filters(BlockDriverState *bs)
7581 {
7582 return bdrv_do_skip_filters(bs, false);
7583 }
7584
7585 /*
7586 * For a backing chain, return the first non-filter backing image of
7587 * the first non-filter image.
7588 */
7589 BlockDriverState *bdrv_backing_chain_next(BlockDriverState *bs)
7590 {
7591 return bdrv_skip_filters(bdrv_cow_bs(bdrv_skip_filters(bs)));
7592 }