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