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