1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "block/trace.h"
26#include "block/block_int.h"
27#include "block/blockjob.h"
28#include "block/nbd.h"
29#include "qemu/error-report.h"
30#include "module_block.h"
31#include "qemu/module.h"
32#include "qapi/qmp/qerror.h"
33#include "qapi/qmp/qbool.h"
34#include "qapi/qmp/qjson.h"
35#include "sysemu/block-backend.h"
36#include "sysemu/sysemu.h"
37#include "qemu/notify.h"
38#include "qemu/coroutine.h"
39#include "block/qapi.h"
40#include "qmp-commands.h"
41#include "qemu/timer.h"
42#include "qapi-event.h"
43#include "qemu/cutils.h"
44#include "qemu/id.h"
45
46#ifdef CONFIG_BSD
47#include <sys/ioctl.h>
48#include <sys/queue.h>
49#ifndef __DragonFly__
50#include <sys/disk.h>
51#endif
52#endif
53
54#ifdef _WIN32
55#include <windows.h>
56#endif
57
58#define NOT_DONE 0x7fffffff
59
60static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
61 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
62
63static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
64 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
65
66static QLIST_HEAD(, BlockDriver) bdrv_drivers =
67 QLIST_HEAD_INITIALIZER(bdrv_drivers);
68
69static BlockDriverState *bdrv_open_inherit(const char *filename,
70 const char *reference,
71 QDict *options, int flags,
72 BlockDriverState *parent,
73 const BdrvChildRole *child_role,
74 Error **errp);
75
76
77static int use_bdrv_whitelist;
78
79#ifdef _WIN32
80static int is_windows_drive_prefix(const char *filename)
81{
82 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
83 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
84 filename[1] == ':');
85}
86
87int is_windows_drive(const char *filename)
88{
89 if (is_windows_drive_prefix(filename) &&
90 filename[2] == '\0')
91 return 1;
92 if (strstart(filename, "\\\\.\\", NULL) ||
93 strstart(filename, "//./", NULL))
94 return 1;
95 return 0;
96}
97#endif
98
99size_t bdrv_opt_mem_align(BlockDriverState *bs)
100{
101 if (!bs || !bs->drv) {
102
103 return MAX(4096, getpagesize());
104 }
105
106 return bs->bl.opt_mem_alignment;
107}
108
109size_t bdrv_min_mem_align(BlockDriverState *bs)
110{
111 if (!bs || !bs->drv) {
112
113 return MAX(4096, getpagesize());
114 }
115
116 return bs->bl.min_mem_alignment;
117}
118
119
120int path_has_protocol(const char *path)
121{
122 const char *p;
123
124#ifdef _WIN32
125 if (is_windows_drive(path) ||
126 is_windows_drive_prefix(path)) {
127 return 0;
128 }
129 p = path + strcspn(path, ":/\\");
130#else
131 p = path + strcspn(path, ":/");
132#endif
133
134 return *p == ':';
135}
136
137int path_is_absolute(const char *path)
138{
139#ifdef _WIN32
140
141 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
142 return 1;
143 }
144 return (*path == '/' || *path == '\\');
145#else
146 return (*path == '/');
147#endif
148}
149
150
151
152
153void path_combine(char *dest, int dest_size,
154 const char *base_path,
155 const char *filename)
156{
157 const char *p, *p1;
158 int len;
159
160 if (dest_size <= 0)
161 return;
162 if (path_is_absolute(filename)) {
163 pstrcpy(dest, dest_size, filename);
164 } else {
165 const char *protocol_stripped = NULL;
166
167 if (path_has_protocol(base_path)) {
168 protocol_stripped = strchr(base_path, ':');
169 if (protocol_stripped) {
170 protocol_stripped++;
171 }
172 }
173 p = protocol_stripped ?: base_path;
174
175 p1 = strrchr(base_path, '/');
176#ifdef _WIN32
177 {
178 const char *p2;
179 p2 = strrchr(base_path, '\\');
180 if (!p1 || p2 > p1)
181 p1 = p2;
182 }
183#endif
184 if (p1)
185 p1++;
186 else
187 p1 = base_path;
188 if (p1 > p)
189 p = p1;
190 len = p - base_path;
191 if (len > dest_size - 1)
192 len = dest_size - 1;
193 memcpy(dest, base_path, len);
194 dest[len] = '\0';
195 pstrcat(dest, dest_size, filename);
196 }
197}
198
199
200
201
202
203
204void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix,
205 QDict *options)
206{
207 if (strstart(filename, prefix, &filename)) {
208
209
210 if (path_has_protocol(filename)) {
211 QString *fat_filename;
212
213
214
215 assert(!path_is_absolute(filename));
216
217
218
219 fat_filename = qstring_from_str("./");
220 qstring_append(fat_filename, filename);
221
222 assert(!path_has_protocol(qstring_get_str(fat_filename)));
223
224 qdict_put(options, "filename", fat_filename);
225 } else {
226
227
228 qdict_put_str(options, "filename", filename);
229 }
230 }
231}
232
233
234
235
236
237bool bdrv_is_read_only(BlockDriverState *bs)
238{
239 return bs->read_only;
240}
241
242int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
243 bool ignore_allow_rdw, Error **errp)
244{
245
246 if (bs->copy_on_read && read_only) {
247 error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
248 bdrv_get_device_or_node_name(bs));
249 return -EINVAL;
250 }
251
252
253 if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&
254 !ignore_allow_rdw)
255 {
256 error_setg(errp, "Node '%s' is read only",
257 bdrv_get_device_or_node_name(bs));
258 return -EPERM;
259 }
260
261 return 0;
262}
263
264
265
266
267
268
269int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
270{
271 int ret = 0;
272
273 ret = bdrv_can_set_read_only(bs, read_only, false, errp);
274 if (ret < 0) {
275 return ret;
276 }
277
278 bs->read_only = read_only;
279 return 0;
280}
281
282void bdrv_get_full_backing_filename_from_filename(const char *backed,
283 const char *backing,
284 char *dest, size_t sz,
285 Error **errp)
286{
287 if (backing[0] == '\0' || path_has_protocol(backing) ||
288 path_is_absolute(backing))
289 {
290 pstrcpy(dest, sz, backing);
291 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
292 error_setg(errp, "Cannot use relative backing file names for '%s'",
293 backed);
294 } else {
295 path_combine(dest, sz, backed, backing);
296 }
297}
298
299void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
300 Error **errp)
301{
302 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
303
304 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
305 dest, sz, errp);
306}
307
308void bdrv_register(BlockDriver *bdrv)
309{
310 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
311}
312
313BlockDriverState *bdrv_new(void)
314{
315 BlockDriverState *bs;
316 int i;
317
318 bs = g_new0(BlockDriverState, 1);
319 QLIST_INIT(&bs->dirty_bitmaps);
320 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
321 QLIST_INIT(&bs->op_blockers[i]);
322 }
323 notifier_with_return_list_init(&bs->before_write_notifiers);
324 qemu_co_mutex_init(&bs->reqs_lock);
325 qemu_mutex_init(&bs->dirty_bitmap_mutex);
326 bs->refcnt = 1;
327 bs->aio_context = qemu_get_aio_context();
328
329 qemu_co_queue_init(&bs->flush_queue);
330
331 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
332
333 return bs;
334}
335
336static BlockDriver *bdrv_do_find_format(const char *format_name)
337{
338 BlockDriver *drv1;
339
340 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
341 if (!strcmp(drv1->format_name, format_name)) {
342 return drv1;
343 }
344 }
345
346 return NULL;
347}
348
349BlockDriver *bdrv_find_format(const char *format_name)
350{
351 BlockDriver *drv1;
352 int i;
353
354 drv1 = bdrv_do_find_format(format_name);
355 if (drv1) {
356 return drv1;
357 }
358
359
360 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
361 if (!strcmp(block_driver_modules[i].format_name, format_name)) {
362 block_module_load_one(block_driver_modules[i].library_name);
363 break;
364 }
365 }
366
367 return bdrv_do_find_format(format_name);
368}
369
370static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
371{
372 static const char *whitelist_rw[] = {
373 CONFIG_BDRV_RW_WHITELIST
374 };
375 static const char *whitelist_ro[] = {
376 CONFIG_BDRV_RO_WHITELIST
377 };
378 const char **p;
379
380 if (!whitelist_rw[0] && !whitelist_ro[0]) {
381 return 1;
382 }
383
384 for (p = whitelist_rw; *p; p++) {
385 if (!strcmp(drv->format_name, *p)) {
386 return 1;
387 }
388 }
389 if (read_only) {
390 for (p = whitelist_ro; *p; p++) {
391 if (!strcmp(drv->format_name, *p)) {
392 return 1;
393 }
394 }
395 }
396 return 0;
397}
398
399bool bdrv_uses_whitelist(void)
400{
401 return use_bdrv_whitelist;
402}
403
404typedef struct CreateCo {
405 BlockDriver *drv;
406 char *filename;
407 QemuOpts *opts;
408 int ret;
409 Error *err;
410} CreateCo;
411
412static void coroutine_fn bdrv_create_co_entry(void *opaque)
413{
414 Error *local_err = NULL;
415 int ret;
416
417 CreateCo *cco = opaque;
418 assert(cco->drv);
419
420 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
421 error_propagate(&cco->err, local_err);
422 cco->ret = ret;
423}
424
425int bdrv_create(BlockDriver *drv, const char* filename,
426 QemuOpts *opts, Error **errp)
427{
428 int ret;
429
430 Coroutine *co;
431 CreateCo cco = {
432 .drv = drv,
433 .filename = g_strdup(filename),
434 .opts = opts,
435 .ret = NOT_DONE,
436 .err = NULL,
437 };
438
439 if (!drv->bdrv_create) {
440 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
441 ret = -ENOTSUP;
442 goto out;
443 }
444
445 if (qemu_in_coroutine()) {
446
447 bdrv_create_co_entry(&cco);
448 } else {
449 co = qemu_coroutine_create(bdrv_create_co_entry, &cco);
450 qemu_coroutine_enter(co);
451 while (cco.ret == NOT_DONE) {
452 aio_poll(qemu_get_aio_context(), true);
453 }
454 }
455
456 ret = cco.ret;
457 if (ret < 0) {
458 if (cco.err) {
459 error_propagate(errp, cco.err);
460 } else {
461 error_setg_errno(errp, -ret, "Could not create image");
462 }
463 }
464
465out:
466 g_free(cco.filename);
467 return ret;
468}
469
470int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
471{
472 BlockDriver *drv;
473 Error *local_err = NULL;
474 int ret;
475
476 drv = bdrv_find_protocol(filename, true, errp);
477 if (drv == NULL) {
478 return -ENOENT;
479 }
480
481 ret = bdrv_create(drv, filename, opts, &local_err);
482 error_propagate(errp, local_err);
483 return ret;
484}
485
486
487
488
489
490
491
492int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
493{
494 BlockDriver *drv = bs->drv;
495
496 if (drv && drv->bdrv_probe_blocksizes) {
497 return drv->bdrv_probe_blocksizes(bs, bsz);
498 } else if (drv && drv->is_filter && bs->file) {
499 return bdrv_probe_blocksizes(bs->file->bs, bsz);
500 }
501
502 return -ENOTSUP;
503}
504
505
506
507
508
509
510
511int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
512{
513 BlockDriver *drv = bs->drv;
514
515 if (drv && drv->bdrv_probe_geometry) {
516 return drv->bdrv_probe_geometry(bs, geo);
517 } else if (drv && drv->is_filter && bs->file) {
518 return bdrv_probe_geometry(bs->file->bs, geo);
519 }
520
521 return -ENOTSUP;
522}
523
524
525
526
527
528int get_tmp_filename(char *filename, int size)
529{
530#ifdef _WIN32
531 char temp_dir[MAX_PATH];
532
533
534 assert(size >= MAX_PATH);
535 return (GetTempPath(MAX_PATH, temp_dir)
536 && GetTempFileName(temp_dir, "qem", 0, filename)
537 ? 0 : -GetLastError());
538#else
539 int fd;
540 const char *tmpdir;
541 tmpdir = getenv("TMPDIR");
542 if (!tmpdir) {
543 tmpdir = "/var/tmp";
544 }
545 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
546 return -EOVERFLOW;
547 }
548 fd = mkstemp(filename);
549 if (fd < 0) {
550 return -errno;
551 }
552 if (close(fd) != 0) {
553 unlink(filename);
554 return -errno;
555 }
556 return 0;
557#endif
558}
559
560
561
562
563
564static BlockDriver *find_hdev_driver(const char *filename)
565{
566 int score_max = 0, score;
567 BlockDriver *drv = NULL, *d;
568
569 QLIST_FOREACH(d, &bdrv_drivers, list) {
570 if (d->bdrv_probe_device) {
571 score = d->bdrv_probe_device(filename);
572 if (score > score_max) {
573 score_max = score;
574 drv = d;
575 }
576 }
577 }
578
579 return drv;
580}
581
582static BlockDriver *bdrv_do_find_protocol(const char *protocol)
583{
584 BlockDriver *drv1;
585
586 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
587 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
588 return drv1;
589 }
590 }
591
592 return NULL;
593}
594
595BlockDriver *bdrv_find_protocol(const char *filename,
596 bool allow_protocol_prefix,
597 Error **errp)
598{
599 BlockDriver *drv1;
600 char protocol[128];
601 int len;
602 const char *p;
603 int i;
604
605
606
607
608
609
610
611
612
613
614 drv1 = find_hdev_driver(filename);
615 if (drv1) {
616 return drv1;
617 }
618
619 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
620 return &bdrv_file;
621 }
622
623 p = strchr(filename, ':');
624 assert(p != NULL);
625 len = p - filename;
626 if (len > sizeof(protocol) - 1)
627 len = sizeof(protocol) - 1;
628 memcpy(protocol, filename, len);
629 protocol[len] = '\0';
630
631 drv1 = bdrv_do_find_protocol(protocol);
632 if (drv1) {
633 return drv1;
634 }
635
636 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
637 if (block_driver_modules[i].protocol_name &&
638 !strcmp(block_driver_modules[i].protocol_name, protocol)) {
639 block_module_load_one(block_driver_modules[i].library_name);
640 break;
641 }
642 }
643
644 drv1 = bdrv_do_find_protocol(protocol);
645 if (!drv1) {
646 error_setg(errp, "Unknown protocol '%s'", protocol);
647 }
648 return drv1;
649}
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
666 const char *filename)
667{
668 int score_max = 0, score;
669 BlockDriver *drv = NULL, *d;
670
671 QLIST_FOREACH(d, &bdrv_drivers, list) {
672 if (d->bdrv_probe) {
673 score = d->bdrv_probe(buf, buf_size, filename);
674 if (score > score_max) {
675 score_max = score;
676 drv = d;
677 }
678 }
679 }
680
681 return drv;
682}
683
684static int find_image_format(BlockBackend *file, const char *filename,
685 BlockDriver **pdrv, Error **errp)
686{
687 BlockDriver *drv;
688 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
689 int ret = 0;
690
691
692 if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
693 *pdrv = &bdrv_raw;
694 return ret;
695 }
696
697 ret = blk_pread(file, 0, buf, sizeof(buf));
698 if (ret < 0) {
699 error_setg_errno(errp, -ret, "Could not read image for determining its "
700 "format");
701 *pdrv = NULL;
702 return ret;
703 }
704
705 drv = bdrv_probe_all(buf, ret, filename);
706 if (!drv) {
707 error_setg(errp, "Could not determine image format: No compatible "
708 "driver found");
709 ret = -ENOENT;
710 }
711 *pdrv = drv;
712 return ret;
713}
714
715
716
717
718
719static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
720{
721 BlockDriver *drv = bs->drv;
722
723 if (!drv) {
724 return -ENOMEDIUM;
725 }
726
727
728 if (bdrv_is_sg(bs))
729 return 0;
730
731
732 if (drv->bdrv_getlength) {
733 int64_t length = drv->bdrv_getlength(bs);
734 if (length < 0) {
735 return length;
736 }
737 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
738 }
739
740 bs->total_sectors = hint;
741 return 0;
742}
743
744
745
746
747
748static void bdrv_join_options(BlockDriverState *bs, QDict *options,
749 QDict *old_options)
750{
751 if (bs->drv && bs->drv->bdrv_join_options) {
752 bs->drv->bdrv_join_options(options, old_options);
753 } else {
754 qdict_join(options, old_options, false);
755 }
756}
757
758
759
760
761
762
763int bdrv_parse_discard_flags(const char *mode, int *flags)
764{
765 *flags &= ~BDRV_O_UNMAP;
766
767 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
768
769 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
770 *flags |= BDRV_O_UNMAP;
771 } else {
772 return -1;
773 }
774
775 return 0;
776}
777
778
779
780
781
782
783int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
784{
785 *flags &= ~BDRV_O_CACHE_MASK;
786
787 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
788 *writethrough = false;
789 *flags |= BDRV_O_NOCACHE;
790 } else if (!strcmp(mode, "directsync")) {
791 *writethrough = true;
792 *flags |= BDRV_O_NOCACHE;
793 } else if (!strcmp(mode, "writeback")) {
794 *writethrough = false;
795 } else if (!strcmp(mode, "unsafe")) {
796 *writethrough = false;
797 *flags |= BDRV_O_NO_FLUSH;
798 } else if (!strcmp(mode, "writethrough")) {
799 *writethrough = true;
800 } else {
801 return -1;
802 }
803
804 return 0;
805}
806
807static char *bdrv_child_get_parent_desc(BdrvChild *c)
808{
809 BlockDriverState *parent = c->opaque;
810 return g_strdup(bdrv_get_device_or_node_name(parent));
811}
812
813static void bdrv_child_cb_drained_begin(BdrvChild *child)
814{
815 BlockDriverState *bs = child->opaque;
816 bdrv_drained_begin(bs);
817}
818
819static void bdrv_child_cb_drained_end(BdrvChild *child)
820{
821 BlockDriverState *bs = child->opaque;
822 bdrv_drained_end(bs);
823}
824
825static int bdrv_child_cb_inactivate(BdrvChild *child)
826{
827 BlockDriverState *bs = child->opaque;
828 assert(bs->open_flags & BDRV_O_INACTIVE);
829 return 0;
830}
831
832
833
834
835
836
837static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
838 int parent_flags, QDict *parent_options)
839{
840 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
841
842
843 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
844 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
845
846
847 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
848
849
850
851 *child_flags &= ~BDRV_O_NATIVE_AIO;
852}
853
854
855
856
857
858static void bdrv_inherited_options(int *child_flags, QDict *child_options,
859 int parent_flags, QDict *parent_options)
860{
861 int flags = parent_flags;
862
863
864 flags |= BDRV_O_PROTOCOL;
865
866
867
868 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
869 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
870 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
871
872
873 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
874
875
876
877
878 qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
879
880
881 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
882 BDRV_O_NO_IO);
883
884 *child_flags = flags;
885}
886
887const BdrvChildRole child_file = {
888 .get_parent_desc = bdrv_child_get_parent_desc,
889 .inherit_options = bdrv_inherited_options,
890 .drained_begin = bdrv_child_cb_drained_begin,
891 .drained_end = bdrv_child_cb_drained_end,
892 .inactivate = bdrv_child_cb_inactivate,
893};
894
895
896
897
898
899
900static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
901 int parent_flags, QDict *parent_options)
902{
903 child_file.inherit_options(child_flags, child_options,
904 parent_flags, parent_options);
905
906 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
907}
908
909const BdrvChildRole child_format = {
910 .get_parent_desc = bdrv_child_get_parent_desc,
911 .inherit_options = bdrv_inherited_fmt_options,
912 .drained_begin = bdrv_child_cb_drained_begin,
913 .drained_end = bdrv_child_cb_drained_end,
914 .inactivate = bdrv_child_cb_inactivate,
915};
916
917static void bdrv_backing_attach(BdrvChild *c)
918{
919 BlockDriverState *parent = c->opaque;
920 BlockDriverState *backing_hd = c->bs;
921
922 assert(!parent->backing_blocker);
923 error_setg(&parent->backing_blocker,
924 "node is used as backing hd of '%s'",
925 bdrv_get_device_or_node_name(parent));
926
927 parent->open_flags &= ~BDRV_O_NO_BACKING;
928 pstrcpy(parent->backing_file, sizeof(parent->backing_file),
929 backing_hd->filename);
930 pstrcpy(parent->backing_format, sizeof(parent->backing_format),
931 backing_hd->drv ? backing_hd->drv->format_name : "");
932
933 bdrv_op_block_all(backing_hd, parent->backing_blocker);
934
935 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
936 parent->backing_blocker);
937 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
938 parent->backing_blocker);
939
940
941
942
943
944
945
946
947
948
949
950
951
952 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
953 parent->backing_blocker);
954 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
955 parent->backing_blocker);
956}
957
958static void bdrv_backing_detach(BdrvChild *c)
959{
960 BlockDriverState *parent = c->opaque;
961
962 assert(parent->backing_blocker);
963 bdrv_op_unblock_all(c->bs, parent->backing_blocker);
964 error_free(parent->backing_blocker);
965 parent->backing_blocker = NULL;
966}
967
968
969
970
971
972static void bdrv_backing_options(int *child_flags, QDict *child_options,
973 int parent_flags, QDict *parent_options)
974{
975 int flags = parent_flags;
976
977
978
979 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
980 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
981 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
982
983
984 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
985 flags &= ~BDRV_O_COPY_ON_READ;
986
987
988 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
989
990 *child_flags = flags;
991}
992
993static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
994 const char *filename, Error **errp)
995{
996 BlockDriverState *parent = c->opaque;
997 int orig_flags = bdrv_get_flags(parent);
998 int ret;
999
1000 if (!(orig_flags & BDRV_O_RDWR)) {
1001 ret = bdrv_reopen(parent, orig_flags | BDRV_O_RDWR, errp);
1002 if (ret < 0) {
1003 return ret;
1004 }
1005 }
1006
1007 ret = bdrv_change_backing_file(parent, filename,
1008 base->drv ? base->drv->format_name : "");
1009 if (ret < 0) {
1010 error_setg_errno(errp, -ret, "Could not update backing file link");
1011 }
1012
1013 if (!(orig_flags & BDRV_O_RDWR)) {
1014 bdrv_reopen(parent, orig_flags, NULL);
1015 }
1016
1017 return ret;
1018}
1019
1020const BdrvChildRole child_backing = {
1021 .get_parent_desc = bdrv_child_get_parent_desc,
1022 .attach = bdrv_backing_attach,
1023 .detach = bdrv_backing_detach,
1024 .inherit_options = bdrv_backing_options,
1025 .drained_begin = bdrv_child_cb_drained_begin,
1026 .drained_end = bdrv_child_cb_drained_end,
1027 .inactivate = bdrv_child_cb_inactivate,
1028 .update_filename = bdrv_backing_update_filename,
1029};
1030
1031static int bdrv_open_flags(BlockDriverState *bs, int flags)
1032{
1033 int open_flags = flags;
1034
1035
1036
1037
1038
1039 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
1040
1041
1042
1043
1044 if (flags & BDRV_O_TEMPORARY) {
1045 open_flags |= BDRV_O_RDWR;
1046 }
1047
1048 return open_flags;
1049}
1050
1051static void update_flags_from_options(int *flags, QemuOpts *opts)
1052{
1053 *flags &= ~BDRV_O_CACHE_MASK;
1054
1055 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
1056 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
1057 *flags |= BDRV_O_NO_FLUSH;
1058 }
1059
1060 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
1061 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
1062 *flags |= BDRV_O_NOCACHE;
1063 }
1064
1065 *flags &= ~BDRV_O_RDWR;
1066
1067 assert(qemu_opt_find(opts, BDRV_OPT_READ_ONLY));
1068 if (!qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false)) {
1069 *flags |= BDRV_O_RDWR;
1070 }
1071
1072}
1073
1074static void update_options_from_flags(QDict *options, int flags)
1075{
1076 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
1077 qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
1078 }
1079 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
1080 qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
1081 flags & BDRV_O_NO_FLUSH);
1082 }
1083 if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
1084 qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
1085 }
1086}
1087
1088static void bdrv_assign_node_name(BlockDriverState *bs,
1089 const char *node_name,
1090 Error **errp)
1091{
1092 char *gen_node_name = NULL;
1093
1094 if (!node_name) {
1095 node_name = gen_node_name = id_generate(ID_BLOCK);
1096 } else if (!id_wellformed(node_name)) {
1097
1098
1099
1100
1101 error_setg(errp, "Invalid node name");
1102 return;
1103 }
1104
1105
1106 if (blk_by_name(node_name)) {
1107 error_setg(errp, "node-name=%s is conflicting with a device id",
1108 node_name);
1109 goto out;
1110 }
1111
1112
1113 if (bdrv_find_node(node_name)) {
1114 error_setg(errp, "Duplicate node name");
1115 goto out;
1116 }
1117
1118
1119 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
1120 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
1121out:
1122 g_free(gen_node_name);
1123}
1124
1125static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
1126 const char *node_name, QDict *options,
1127 int open_flags, Error **errp)
1128{
1129 Error *local_err = NULL;
1130 int ret;
1131
1132 bdrv_assign_node_name(bs, node_name, &local_err);
1133 if (local_err) {
1134 error_propagate(errp, local_err);
1135 return -EINVAL;
1136 }
1137
1138 bs->drv = drv;
1139 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
1140 bs->opaque = g_malloc0(drv->instance_size);
1141
1142 if (drv->bdrv_file_open) {
1143 assert(!drv->bdrv_needs_filename || bs->filename[0]);
1144 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
1145 } else if (drv->bdrv_open) {
1146 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
1147 } else {
1148 ret = 0;
1149 }
1150
1151 if (ret < 0) {
1152 if (local_err) {
1153 error_propagate(errp, local_err);
1154 } else if (bs->filename[0]) {
1155 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1156 } else {
1157 error_setg_errno(errp, -ret, "Could not open image");
1158 }
1159 goto open_failed;
1160 }
1161
1162 ret = refresh_total_sectors(bs, bs->total_sectors);
1163 if (ret < 0) {
1164 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1165 return ret;
1166 }
1167
1168 bdrv_refresh_limits(bs, &local_err);
1169 if (local_err) {
1170 error_propagate(errp, local_err);
1171 return -EINVAL;
1172 }
1173
1174 assert(bdrv_opt_mem_align(bs) != 0);
1175 assert(bdrv_min_mem_align(bs) != 0);
1176 assert(is_power_of_2(bs->bl.request_alignment));
1177
1178 return 0;
1179open_failed:
1180 bs->drv = NULL;
1181 if (bs->file != NULL) {
1182 bdrv_unref_child(bs, bs->file);
1183 bs->file = NULL;
1184 }
1185 g_free(bs->opaque);
1186 bs->opaque = NULL;
1187 return ret;
1188}
1189
1190BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
1191 int flags, Error **errp)
1192{
1193 BlockDriverState *bs;
1194 int ret;
1195
1196 bs = bdrv_new();
1197 bs->open_flags = flags;
1198 bs->explicit_options = qdict_new();
1199 bs->options = qdict_new();
1200 bs->opaque = NULL;
1201
1202 update_options_from_flags(bs->options, flags);
1203
1204 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
1205 if (ret < 0) {
1206 QDECREF(bs->explicit_options);
1207 bs->explicit_options = NULL;
1208 QDECREF(bs->options);
1209 bs->options = NULL;
1210 bdrv_unref(bs);
1211 return NULL;
1212 }
1213
1214 return bs;
1215}
1216
1217QemuOptsList bdrv_runtime_opts = {
1218 .name = "bdrv_common",
1219 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
1220 .desc = {
1221 {
1222 .name = "node-name",
1223 .type = QEMU_OPT_STRING,
1224 .help = "Node name of the block device node",
1225 },
1226 {
1227 .name = "driver",
1228 .type = QEMU_OPT_STRING,
1229 .help = "Block driver to use for the node",
1230 },
1231 {
1232 .name = BDRV_OPT_CACHE_DIRECT,
1233 .type = QEMU_OPT_BOOL,
1234 .help = "Bypass software writeback cache on the host",
1235 },
1236 {
1237 .name = BDRV_OPT_CACHE_NO_FLUSH,
1238 .type = QEMU_OPT_BOOL,
1239 .help = "Ignore flush requests",
1240 },
1241 {
1242 .name = BDRV_OPT_READ_ONLY,
1243 .type = QEMU_OPT_BOOL,
1244 .help = "Node is opened in read-only mode",
1245 },
1246 {
1247 .name = "detect-zeroes",
1248 .type = QEMU_OPT_STRING,
1249 .help = "try to optimize zero writes (off, on, unmap)",
1250 },
1251 {
1252 .name = "discard",
1253 .type = QEMU_OPT_STRING,
1254 .help = "discard operation (ignore/off, unmap/on)",
1255 },
1256 {
1257 .name = BDRV_OPT_FORCE_SHARE,
1258 .type = QEMU_OPT_BOOL,
1259 .help = "always accept other writers (default: off)",
1260 },
1261 { }
1262 },
1263};
1264
1265
1266
1267
1268
1269
1270static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
1271 QDict *options, Error **errp)
1272{
1273 int ret, open_flags;
1274 const char *filename;
1275 const char *driver_name = NULL;
1276 const char *node_name = NULL;
1277 const char *discard;
1278 const char *detect_zeroes;
1279 QemuOpts *opts;
1280 BlockDriver *drv;
1281 Error *local_err = NULL;
1282
1283 assert(bs->file == NULL);
1284 assert(options != NULL && bs->options != options);
1285
1286 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1287 qemu_opts_absorb_qdict(opts, options, &local_err);
1288 if (local_err) {
1289 error_propagate(errp, local_err);
1290 ret = -EINVAL;
1291 goto fail_opts;
1292 }
1293
1294 update_flags_from_options(&bs->open_flags, opts);
1295
1296 driver_name = qemu_opt_get(opts, "driver");
1297 drv = bdrv_find_format(driver_name);
1298 assert(drv != NULL);
1299
1300 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);
1301
1302 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {
1303 error_setg(errp,
1304 BDRV_OPT_FORCE_SHARE
1305 "=on can only be used with read-only images");
1306 ret = -EINVAL;
1307 goto fail_opts;
1308 }
1309
1310 if (file != NULL) {
1311 filename = blk_bs(file)->filename;
1312 } else {
1313
1314
1315
1316
1317
1318
1319
1320 filename = qdict_get_try_str(options, "filename");
1321 }
1322
1323 if (drv->bdrv_needs_filename && (!filename || !filename[0])) {
1324 error_setg(errp, "The '%s' block driver requires a file name",
1325 drv->format_name);
1326 ret = -EINVAL;
1327 goto fail_opts;
1328 }
1329
1330 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
1331 drv->format_name);
1332
1333 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
1334
1335 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
1336 error_setg(errp,
1337 !bs->read_only && bdrv_is_whitelisted(drv, true)
1338 ? "Driver '%s' can only be used for read-only devices"
1339 : "Driver '%s' is not whitelisted",
1340 drv->format_name);
1341 ret = -ENOTSUP;
1342 goto fail_opts;
1343 }
1344
1345
1346 assert(atomic_read(&bs->copy_on_read) == 0);
1347
1348 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
1349 if (!bs->read_only) {
1350 bdrv_enable_copy_on_read(bs);
1351 } else {
1352 error_setg(errp, "Can't use copy-on-read on read-only device");
1353 ret = -EINVAL;
1354 goto fail_opts;
1355 }
1356 }
1357
1358 discard = qemu_opt_get(opts, "discard");
1359 if (discard != NULL) {
1360 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
1361 error_setg(errp, "Invalid discard option");
1362 ret = -EINVAL;
1363 goto fail_opts;
1364 }
1365 }
1366
1367 detect_zeroes = qemu_opt_get(opts, "detect-zeroes");
1368 if (detect_zeroes) {
1369 BlockdevDetectZeroesOptions value =
1370 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup,
1371 detect_zeroes,
1372 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
1373 &local_err);
1374 if (local_err) {
1375 error_propagate(errp, local_err);
1376 ret = -EINVAL;
1377 goto fail_opts;
1378 }
1379
1380 if (value == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
1381 !(bs->open_flags & BDRV_O_UNMAP))
1382 {
1383 error_setg(errp, "setting detect-zeroes to unmap is not allowed "
1384 "without setting discard operation to unmap");
1385 ret = -EINVAL;
1386 goto fail_opts;
1387 }
1388
1389 bs->detect_zeroes = value;
1390 }
1391
1392 if (filename != NULL) {
1393 pstrcpy(bs->filename, sizeof(bs->filename), filename);
1394 } else {
1395 bs->filename[0] = '\0';
1396 }
1397 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
1398
1399
1400 open_flags = bdrv_open_flags(bs, bs->open_flags);
1401 node_name = qemu_opt_get(opts, "node-name");
1402
1403 assert(!drv->bdrv_file_open || file == NULL);
1404 ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
1405 if (ret < 0) {
1406 goto fail_opts;
1407 }
1408
1409 qemu_opts_del(opts);
1410 return 0;
1411
1412fail_opts:
1413 qemu_opts_del(opts);
1414 return ret;
1415}
1416
1417static QDict *parse_json_filename(const char *filename, Error **errp)
1418{
1419 QObject *options_obj;
1420 QDict *options;
1421 int ret;
1422
1423 ret = strstart(filename, "json:", &filename);
1424 assert(ret);
1425
1426 options_obj = qobject_from_json(filename, errp);
1427 if (!options_obj) {
1428
1429 if (errp && !*errp) {
1430 error_setg(errp, "Could not parse the JSON options");
1431 return NULL;
1432 }
1433 error_prepend(errp, "Could not parse the JSON options: ");
1434 return NULL;
1435 }
1436
1437 options = qobject_to_qdict(options_obj);
1438 if (!options) {
1439 qobject_decref(options_obj);
1440 error_setg(errp, "Invalid JSON object given");
1441 return NULL;
1442 }
1443
1444 qdict_flatten(options);
1445
1446 return options;
1447}
1448
1449static void parse_json_protocol(QDict *options, const char **pfilename,
1450 Error **errp)
1451{
1452 QDict *json_options;
1453 Error *local_err = NULL;
1454
1455
1456 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1457 return;
1458 }
1459
1460 json_options = parse_json_filename(*pfilename, &local_err);
1461 if (local_err) {
1462 error_propagate(errp, local_err);
1463 return;
1464 }
1465
1466
1467
1468 qdict_join(options, json_options, false);
1469 QDECREF(json_options);
1470 *pfilename = NULL;
1471}
1472
1473
1474
1475
1476
1477
1478
1479static int bdrv_fill_options(QDict **options, const char *filename,
1480 int *flags, Error **errp)
1481{
1482 const char *drvname;
1483 bool protocol = *flags & BDRV_O_PROTOCOL;
1484 bool parse_filename = false;
1485 BlockDriver *drv = NULL;
1486 Error *local_err = NULL;
1487
1488
1489
1490
1491
1492
1493
1494
1495 drvname = qdict_get_try_str(*options, "driver");
1496 if (drvname) {
1497 drv = bdrv_find_format(drvname);
1498 if (!drv) {
1499 error_setg(errp, "Unknown driver '%s'", drvname);
1500 return -ENOENT;
1501 }
1502
1503
1504 protocol = drv->bdrv_file_open;
1505 }
1506
1507 if (protocol) {
1508 *flags |= BDRV_O_PROTOCOL;
1509 } else {
1510 *flags &= ~BDRV_O_PROTOCOL;
1511 }
1512
1513
1514 update_options_from_flags(*options, *flags);
1515
1516
1517 if (protocol && filename) {
1518 if (!qdict_haskey(*options, "filename")) {
1519 qdict_put_str(*options, "filename", filename);
1520 parse_filename = true;
1521 } else {
1522 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1523 "the same time");
1524 return -EINVAL;
1525 }
1526 }
1527
1528
1529
1530 filename = qdict_get_try_str(*options, "filename");
1531
1532 if (!drvname && protocol) {
1533 if (filename) {
1534 drv = bdrv_find_protocol(filename, parse_filename, errp);
1535 if (!drv) {
1536 return -EINVAL;
1537 }
1538
1539 drvname = drv->format_name;
1540 qdict_put_str(*options, "driver", drvname);
1541 } else {
1542 error_setg(errp, "Must specify either driver or file");
1543 return -EINVAL;
1544 }
1545 }
1546
1547 assert(drv || !protocol);
1548
1549
1550 if (drv && drv->bdrv_parse_filename && parse_filename) {
1551 drv->bdrv_parse_filename(filename, *options, &local_err);
1552 if (local_err) {
1553 error_propagate(errp, local_err);
1554 return -EINVAL;
1555 }
1556
1557 if (!drv->bdrv_needs_filename) {
1558 qdict_del(*options, "filename");
1559 }
1560 }
1561
1562 return 0;
1563}
1564
1565static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
1566 uint64_t perm, uint64_t shared,
1567 GSList *ignore_children, Error **errp);
1568static void bdrv_child_abort_perm_update(BdrvChild *c);
1569static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);
1570
1571typedef struct BlockReopenQueueEntry {
1572 bool prepared;
1573 BDRVReopenState state;
1574 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1575} BlockReopenQueueEntry;
1576
1577
1578
1579
1580
1581
1582static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs)
1583{
1584 BlockReopenQueueEntry *entry;
1585
1586 if (q != NULL) {
1587 QSIMPLEQ_FOREACH(entry, q, entry) {
1588 if (entry->state.bs == bs) {
1589 return entry->state.flags;
1590 }
1591 }
1592 }
1593
1594 return bs->open_flags;
1595}
1596
1597
1598
1599static bool bdrv_is_writable_after_reopen(BlockDriverState *bs,
1600 BlockReopenQueue *q)
1601{
1602 int flags = bdrv_reopen_get_flags(q, bs);
1603
1604 return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR;
1605}
1606
1607
1608
1609
1610
1611
1612bool bdrv_is_writable(BlockDriverState *bs)
1613{
1614 return bdrv_is_writable_after_reopen(bs, NULL);
1615}
1616
1617static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
1618 BdrvChild *c, const BdrvChildRole *role,
1619 BlockReopenQueue *reopen_queue,
1620 uint64_t parent_perm, uint64_t parent_shared,
1621 uint64_t *nperm, uint64_t *nshared)
1622{
1623 if (bs->drv && bs->drv->bdrv_child_perm) {
1624 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
1625 parent_perm, parent_shared,
1626 nperm, nshared);
1627 }
1628
1629 if (child_bs && child_bs->force_share) {
1630 *nshared = BLK_PERM_ALL;
1631 }
1632}
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q,
1644 uint64_t cumulative_perms,
1645 uint64_t cumulative_shared_perms,
1646 GSList *ignore_children, Error **errp)
1647{
1648 BlockDriver *drv = bs->drv;
1649 BdrvChild *c;
1650 int ret;
1651
1652
1653 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
1654 !bdrv_is_writable_after_reopen(bs, q))
1655 {
1656 error_setg(errp, "Block node is read-only");
1657 return -EPERM;
1658 }
1659
1660
1661 if (!drv) {
1662 return 0;
1663 }
1664
1665 if (drv->bdrv_check_perm) {
1666 return drv->bdrv_check_perm(bs, cumulative_perms,
1667 cumulative_shared_perms, errp);
1668 }
1669
1670
1671 if (!drv->bdrv_child_perm) {
1672 assert(QLIST_EMPTY(&bs->children));
1673 return 0;
1674 }
1675
1676
1677 QLIST_FOREACH(c, &bs->children, next) {
1678 uint64_t cur_perm, cur_shared;
1679 bdrv_child_perm(bs, c->bs, c, c->role, q,
1680 cumulative_perms, cumulative_shared_perms,
1681 &cur_perm, &cur_shared);
1682 ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared,
1683 ignore_children, errp);
1684 if (ret < 0) {
1685 return ret;
1686 }
1687 }
1688
1689 return 0;
1690}
1691
1692
1693
1694
1695
1696
1697
1698
1699static void bdrv_abort_perm_update(BlockDriverState *bs)
1700{
1701 BlockDriver *drv = bs->drv;
1702 BdrvChild *c;
1703
1704 if (!drv) {
1705 return;
1706 }
1707
1708 if (drv->bdrv_abort_perm_update) {
1709 drv->bdrv_abort_perm_update(bs);
1710 }
1711
1712 QLIST_FOREACH(c, &bs->children, next) {
1713 bdrv_child_abort_perm_update(c);
1714 }
1715}
1716
1717static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
1718 uint64_t cumulative_shared_perms)
1719{
1720 BlockDriver *drv = bs->drv;
1721 BdrvChild *c;
1722
1723 if (!drv) {
1724 return;
1725 }
1726
1727
1728 if (drv->bdrv_set_perm) {
1729 drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);
1730 }
1731
1732
1733 if (!drv->bdrv_child_perm) {
1734 assert(QLIST_EMPTY(&bs->children));
1735 return;
1736 }
1737
1738
1739 QLIST_FOREACH(c, &bs->children, next) {
1740 uint64_t cur_perm, cur_shared;
1741 bdrv_child_perm(bs, c->bs, c, c->role, NULL,
1742 cumulative_perms, cumulative_shared_perms,
1743 &cur_perm, &cur_shared);
1744 bdrv_child_set_perm(c, cur_perm, cur_shared);
1745 }
1746}
1747
1748static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
1749 uint64_t *shared_perm)
1750{
1751 BdrvChild *c;
1752 uint64_t cumulative_perms = 0;
1753 uint64_t cumulative_shared_perms = BLK_PERM_ALL;
1754
1755 QLIST_FOREACH(c, &bs->parents, next_parent) {
1756 cumulative_perms |= c->perm;
1757 cumulative_shared_perms &= c->shared_perm;
1758 }
1759
1760 *perm = cumulative_perms;
1761 *shared_perm = cumulative_shared_perms;
1762}
1763
1764static char *bdrv_child_user_desc(BdrvChild *c)
1765{
1766 if (c->role->get_parent_desc) {
1767 return c->role->get_parent_desc(c);
1768 }
1769
1770 return g_strdup("another user");
1771}
1772
1773char *bdrv_perm_names(uint64_t perm)
1774{
1775 struct perm_name {
1776 uint64_t perm;
1777 const char *name;
1778 } permissions[] = {
1779 { BLK_PERM_CONSISTENT_READ, "consistent read" },
1780 { BLK_PERM_WRITE, "write" },
1781 { BLK_PERM_WRITE_UNCHANGED, "write unchanged" },
1782 { BLK_PERM_RESIZE, "resize" },
1783 { BLK_PERM_GRAPH_MOD, "change children" },
1784 { 0, NULL }
1785 };
1786
1787 char *result = g_strdup("");
1788 struct perm_name *p;
1789
1790 for (p = permissions; p->name; p++) {
1791 if (perm & p->perm) {
1792 char *old = result;
1793 result = g_strdup_printf("%s%s%s", old, *old ? ", " : "", p->name);
1794 g_free(old);
1795 }
1796 }
1797
1798 return result;
1799}
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809static int bdrv_check_update_perm(BlockDriverState *bs, BlockReopenQueue *q,
1810 uint64_t new_used_perm,
1811 uint64_t new_shared_perm,
1812 GSList *ignore_children, Error **errp)
1813{
1814 BdrvChild *c;
1815 uint64_t cumulative_perms = new_used_perm;
1816 uint64_t cumulative_shared_perms = new_shared_perm;
1817
1818
1819 assert(new_shared_perm & BLK_PERM_WRITE_UNCHANGED);
1820
1821 QLIST_FOREACH(c, &bs->parents, next_parent) {
1822 if (g_slist_find(ignore_children, c)) {
1823 continue;
1824 }
1825
1826 if ((new_used_perm & c->shared_perm) != new_used_perm) {
1827 char *user = bdrv_child_user_desc(c);
1828 char *perm_names = bdrv_perm_names(new_used_perm & ~c->shared_perm);
1829 error_setg(errp, "Conflicts with use by %s as '%s', which does not "
1830 "allow '%s' on %s",
1831 user, c->name, perm_names, bdrv_get_node_name(c->bs));
1832 g_free(user);
1833 g_free(perm_names);
1834 return -EPERM;
1835 }
1836
1837 if ((c->perm & new_shared_perm) != c->perm) {
1838 char *user = bdrv_child_user_desc(c);
1839 char *perm_names = bdrv_perm_names(c->perm & ~new_shared_perm);
1840 error_setg(errp, "Conflicts with use by %s as '%s', which uses "
1841 "'%s' on %s",
1842 user, c->name, perm_names, bdrv_get_node_name(c->bs));
1843 g_free(user);
1844 g_free(perm_names);
1845 return -EPERM;
1846 }
1847
1848 cumulative_perms |= c->perm;
1849 cumulative_shared_perms &= c->shared_perm;
1850 }
1851
1852 return bdrv_check_perm(bs, q, cumulative_perms, cumulative_shared_perms,
1853 ignore_children, errp);
1854}
1855
1856
1857
1858static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
1859 uint64_t perm, uint64_t shared,
1860 GSList *ignore_children, Error **errp)
1861{
1862 int ret;
1863
1864 ignore_children = g_slist_prepend(g_slist_copy(ignore_children), c);
1865 ret = bdrv_check_update_perm(c->bs, q, perm, shared, ignore_children, errp);
1866 g_slist_free(ignore_children);
1867
1868 return ret;
1869}
1870
1871static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared)
1872{
1873 uint64_t cumulative_perms, cumulative_shared_perms;
1874
1875 c->perm = perm;
1876 c->shared_perm = shared;
1877
1878 bdrv_get_cumulative_perm(c->bs, &cumulative_perms,
1879 &cumulative_shared_perms);
1880 bdrv_set_perm(c->bs, cumulative_perms, cumulative_shared_perms);
1881}
1882
1883static void bdrv_child_abort_perm_update(BdrvChild *c)
1884{
1885 bdrv_abort_perm_update(c->bs);
1886}
1887
1888int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
1889 Error **errp)
1890{
1891 int ret;
1892
1893 ret = bdrv_child_check_perm(c, NULL, perm, shared, NULL, errp);
1894 if (ret < 0) {
1895 bdrv_child_abort_perm_update(c);
1896 return ret;
1897 }
1898
1899 bdrv_child_set_perm(c, perm, shared);
1900
1901 return 0;
1902}
1903
1904#define DEFAULT_PERM_PASSTHROUGH (BLK_PERM_CONSISTENT_READ \
1905 | BLK_PERM_WRITE \
1906 | BLK_PERM_WRITE_UNCHANGED \
1907 | BLK_PERM_RESIZE)
1908#define DEFAULT_PERM_UNCHANGED (BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH)
1909
1910void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
1911 const BdrvChildRole *role,
1912 BlockReopenQueue *reopen_queue,
1913 uint64_t perm, uint64_t shared,
1914 uint64_t *nperm, uint64_t *nshared)
1915{
1916 if (c == NULL) {
1917 *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
1918 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
1919 return;
1920 }
1921
1922 *nperm = (perm & DEFAULT_PERM_PASSTHROUGH) |
1923 (c->perm & DEFAULT_PERM_UNCHANGED);
1924 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) |
1925 (c->shared_perm & DEFAULT_PERM_UNCHANGED);
1926}
1927
1928void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
1929 const BdrvChildRole *role,
1930 BlockReopenQueue *reopen_queue,
1931 uint64_t perm, uint64_t shared,
1932 uint64_t *nperm, uint64_t *nshared)
1933{
1934 bool backing = (role == &child_backing);
1935 assert(role == &child_backing || role == &child_file);
1936
1937 if (!backing) {
1938
1939
1940 bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
1941 &perm, &shared);
1942
1943
1944 if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
1945 perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
1946 }
1947
1948
1949
1950 perm |= BLK_PERM_CONSISTENT_READ;
1951 shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
1952 } else {
1953
1954
1955 perm &= BLK_PERM_CONSISTENT_READ;
1956
1957
1958
1959
1960 if (shared & BLK_PERM_WRITE) {
1961 shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
1962 } else {
1963 shared = 0;
1964 }
1965
1966 shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
1967 BLK_PERM_WRITE_UNCHANGED;
1968 }
1969
1970 if (bs->open_flags & BDRV_O_INACTIVE) {
1971 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
1972 }
1973
1974 *nperm = perm;
1975 *nshared = shared;
1976}
1977
1978static void bdrv_replace_child_noperm(BdrvChild *child,
1979 BlockDriverState *new_bs)
1980{
1981 BlockDriverState *old_bs = child->bs;
1982
1983 if (old_bs && new_bs) {
1984 assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
1985 }
1986 if (old_bs) {
1987 if (old_bs->quiesce_counter && child->role->drained_end) {
1988 child->role->drained_end(child);
1989 }
1990 if (child->role->detach) {
1991 child->role->detach(child);
1992 }
1993 QLIST_REMOVE(child, next_parent);
1994 }
1995
1996 child->bs = new_bs;
1997
1998 if (new_bs) {
1999 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
2000 if (new_bs->quiesce_counter && child->role->drained_begin) {
2001 child->role->drained_begin(child);
2002 }
2003
2004 if (child->role->attach) {
2005 child->role->attach(child);
2006 }
2007 }
2008}
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)
2022{
2023 BlockDriverState *old_bs = child->bs;
2024 uint64_t perm, shared_perm;
2025
2026 bdrv_replace_child_noperm(child, new_bs);
2027
2028 if (old_bs) {
2029
2030
2031
2032 bdrv_get_cumulative_perm(old_bs, &perm, &shared_perm);
2033 bdrv_check_perm(old_bs, NULL, perm, shared_perm, NULL, &error_abort);
2034 bdrv_set_perm(old_bs, perm, shared_perm);
2035 }
2036
2037 if (new_bs) {
2038 bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm);
2039 bdrv_set_perm(new_bs, perm, shared_perm);
2040 }
2041}
2042
2043BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
2044 const char *child_name,
2045 const BdrvChildRole *child_role,
2046 uint64_t perm, uint64_t shared_perm,
2047 void *opaque, Error **errp)
2048{
2049 BdrvChild *child;
2050 int ret;
2051
2052 ret = bdrv_check_update_perm(child_bs, NULL, perm, shared_perm, NULL, errp);
2053 if (ret < 0) {
2054 bdrv_abort_perm_update(child_bs);
2055 return NULL;
2056 }
2057
2058 child = g_new(BdrvChild, 1);
2059 *child = (BdrvChild) {
2060 .bs = NULL,
2061 .name = g_strdup(child_name),
2062 .role = child_role,
2063 .perm = perm,
2064 .shared_perm = shared_perm,
2065 .opaque = opaque,
2066 };
2067
2068
2069 bdrv_replace_child(child, child_bs);
2070
2071 return child;
2072}
2073
2074BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
2075 BlockDriverState *child_bs,
2076 const char *child_name,
2077 const BdrvChildRole *child_role,
2078 Error **errp)
2079{
2080 BdrvChild *child;
2081 uint64_t perm, shared_perm;
2082
2083 bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
2084
2085 assert(parent_bs->drv);
2086 assert(bdrv_get_aio_context(parent_bs) == bdrv_get_aio_context(child_bs));
2087 bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
2088 perm, shared_perm, &perm, &shared_perm);
2089
2090 child = bdrv_root_attach_child(child_bs, child_name, child_role,
2091 perm, shared_perm, parent_bs, errp);
2092 if (child == NULL) {
2093 return NULL;
2094 }
2095
2096 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
2097 return child;
2098}
2099
2100static void bdrv_detach_child(BdrvChild *child)
2101{
2102 if (child->next.le_prev) {
2103 QLIST_REMOVE(child, next);
2104 child->next.le_prev = NULL;
2105 }
2106
2107 bdrv_replace_child(child, NULL);
2108
2109 g_free(child->name);
2110 g_free(child);
2111}
2112
2113void bdrv_root_unref_child(BdrvChild *child)
2114{
2115 BlockDriverState *child_bs;
2116
2117 child_bs = child->bs;
2118 bdrv_detach_child(child);
2119 bdrv_unref(child_bs);
2120}
2121
2122void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
2123{
2124 if (child == NULL) {
2125 return;
2126 }
2127
2128 if (child->bs->inherits_from == parent) {
2129 BdrvChild *c;
2130
2131
2132
2133 QLIST_FOREACH(c, &parent->children, next) {
2134 if (c != child && c->bs == child->bs) {
2135 break;
2136 }
2137 }
2138 if (c == NULL) {
2139 child->bs->inherits_from = NULL;
2140 }
2141 }
2142
2143 bdrv_root_unref_child(child);
2144}
2145
2146
2147static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
2148{
2149 BdrvChild *c;
2150 QLIST_FOREACH(c, &bs->parents, next_parent) {
2151 if (c->role->change_media) {
2152 c->role->change_media(c, load);
2153 }
2154 }
2155}
2156
2157static void bdrv_parent_cb_resize(BlockDriverState *bs)
2158{
2159 BdrvChild *c;
2160 QLIST_FOREACH(c, &bs->parents, next_parent) {
2161 if (c->role->resize) {
2162 c->role->resize(c);
2163 }
2164 }
2165}
2166
2167
2168
2169
2170
2171void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
2172 Error **errp)
2173{
2174 if (backing_hd) {
2175 bdrv_ref(backing_hd);
2176 }
2177
2178 if (bs->backing) {
2179 bdrv_unref_child(bs, bs->backing);
2180 }
2181
2182 if (!backing_hd) {
2183 bs->backing = NULL;
2184 goto out;
2185 }
2186
2187 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
2188 errp);
2189 if (!bs->backing) {
2190 bdrv_unref(backing_hd);
2191 }
2192
2193 bdrv_refresh_filename(bs);
2194
2195out:
2196 bdrv_refresh_limits(bs, NULL);
2197}
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
2210 const char *bdref_key, Error **errp)
2211{
2212 char *backing_filename = g_malloc0(PATH_MAX);
2213 char *bdref_key_dot;
2214 const char *reference = NULL;
2215 int ret = 0;
2216 BlockDriverState *backing_hd;
2217 QDict *options;
2218 QDict *tmp_parent_options = NULL;
2219 Error *local_err = NULL;
2220
2221 if (bs->backing != NULL) {
2222 goto free_exit;
2223 }
2224
2225
2226 if (parent_options == NULL) {
2227 tmp_parent_options = qdict_new();
2228 parent_options = tmp_parent_options;
2229 }
2230
2231 bs->open_flags &= ~BDRV_O_NO_BACKING;
2232
2233 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
2234 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
2235 g_free(bdref_key_dot);
2236
2237
2238
2239
2240
2241
2242
2243
2244 reference = qdict_get_try_str(parent_options, bdref_key);
2245 if (reference || qdict_haskey(options, "file.filename")) {
2246 backing_filename[0] = '\0';
2247 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
2248 QDECREF(options);
2249 goto free_exit;
2250 } else {
2251 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
2252 &local_err);
2253 if (local_err) {
2254 ret = -EINVAL;
2255 error_propagate(errp, local_err);
2256 QDECREF(options);
2257 goto free_exit;
2258 }
2259 }
2260
2261 if (!bs->drv || !bs->drv->supports_backing) {
2262 ret = -EINVAL;
2263 error_setg(errp, "Driver doesn't support backing files");
2264 QDECREF(options);
2265 goto free_exit;
2266 }
2267
2268 if (!reference &&
2269 bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
2270 qdict_put_str(options, "driver", bs->backing_format);
2271 }
2272
2273 backing_hd = bdrv_open_inherit(*backing_filename ? backing_filename : NULL,
2274 reference, options, 0, bs, &child_backing,
2275 errp);
2276 if (!backing_hd) {
2277 bs->open_flags |= BDRV_O_NO_BACKING;
2278 error_prepend(errp, "Could not open backing file: ");
2279 ret = -EINVAL;
2280 goto free_exit;
2281 }
2282 bdrv_set_aio_context(backing_hd, bdrv_get_aio_context(bs));
2283
2284
2285
2286 bdrv_set_backing_hd(bs, backing_hd, &local_err);
2287 bdrv_unref(backing_hd);
2288 if (local_err) {
2289 error_propagate(errp, local_err);
2290 ret = -EINVAL;
2291 goto free_exit;
2292 }
2293
2294 qdict_del(parent_options, bdref_key);
2295
2296free_exit:
2297 g_free(backing_filename);
2298 QDECREF(tmp_parent_options);
2299 return ret;
2300}
2301
2302static BlockDriverState *
2303bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
2304 BlockDriverState *parent, const BdrvChildRole *child_role,
2305 bool allow_none, Error **errp)
2306{
2307 BlockDriverState *bs = NULL;
2308 QDict *image_options;
2309 char *bdref_key_dot;
2310 const char *reference;
2311
2312 assert(child_role != NULL);
2313
2314 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
2315 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
2316 g_free(bdref_key_dot);
2317
2318
2319
2320
2321
2322
2323
2324
2325 reference = qdict_get_try_str(options, bdref_key);
2326 if (!filename && !reference && !qdict_size(image_options)) {
2327 if (!allow_none) {
2328 error_setg(errp, "A block device must be specified for \"%s\"",
2329 bdref_key);
2330 }
2331 QDECREF(image_options);
2332 goto done;
2333 }
2334
2335 bs = bdrv_open_inherit(filename, reference, image_options, 0,
2336 parent, child_role, errp);
2337 if (!bs) {
2338 goto done;
2339 }
2340
2341done:
2342 qdict_del(options, bdref_key);
2343 return bs;
2344}
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360BdrvChild *bdrv_open_child(const char *filename,
2361 QDict *options, const char *bdref_key,
2362 BlockDriverState *parent,
2363 const BdrvChildRole *child_role,
2364 bool allow_none, Error **errp)
2365{
2366 BdrvChild *c;
2367 BlockDriverState *bs;
2368
2369 bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,
2370 allow_none, errp);
2371 if (bs == NULL) {
2372 return NULL;
2373 }
2374
2375 c = bdrv_attach_child(parent, bs, bdref_key, child_role, errp);
2376 if (!c) {
2377 bdrv_unref(bs);
2378 return NULL;
2379 }
2380
2381 return c;
2382}
2383
2384static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
2385 int flags,
2386 QDict *snapshot_options,
2387 Error **errp)
2388{
2389
2390 char *tmp_filename = g_malloc0(PATH_MAX + 1);
2391 int64_t total_size;
2392 QemuOpts *opts = NULL;
2393 BlockDriverState *bs_snapshot = NULL;
2394 Error *local_err = NULL;
2395 int ret;
2396
2397
2398
2399
2400
2401 total_size = bdrv_getlength(bs);
2402 if (total_size < 0) {
2403 error_setg_errno(errp, -total_size, "Could not get image size");
2404 goto out;
2405 }
2406
2407
2408 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
2409 if (ret < 0) {
2410 error_setg_errno(errp, -ret, "Could not get temporary filename");
2411 goto out;
2412 }
2413
2414 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
2415 &error_abort);
2416 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
2417 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
2418 qemu_opts_del(opts);
2419 if (ret < 0) {
2420 error_prepend(errp, "Could not create temporary overlay '%s': ",
2421 tmp_filename);
2422 goto out;
2423 }
2424
2425
2426 qdict_put_str(snapshot_options, "file.driver", "file");
2427 qdict_put_str(snapshot_options, "file.filename", tmp_filename);
2428 qdict_put_str(snapshot_options, "driver", "qcow2");
2429
2430 bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
2431 snapshot_options = NULL;
2432 if (!bs_snapshot) {
2433 goto out;
2434 }
2435
2436
2437
2438
2439
2440 bdrv_ref(bs_snapshot);
2441 bdrv_append(bs_snapshot, bs, &local_err);
2442 if (local_err) {
2443 error_propagate(errp, local_err);
2444 bs_snapshot = NULL;
2445 goto out;
2446 }
2447
2448out:
2449 QDECREF(snapshot_options);
2450 g_free(tmp_filename);
2451 return bs_snapshot;
2452}
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469static BlockDriverState *bdrv_open_inherit(const char *filename,
2470 const char *reference,
2471 QDict *options, int flags,
2472 BlockDriverState *parent,
2473 const BdrvChildRole *child_role,
2474 Error **errp)
2475{
2476 int ret;
2477 BlockBackend *file = NULL;
2478 BlockDriverState *bs;
2479 BlockDriver *drv = NULL;
2480 const char *drvname;
2481 const char *backing;
2482 Error *local_err = NULL;
2483 QDict *snapshot_options = NULL;
2484 int snapshot_flags = 0;
2485
2486 assert(!child_role || !flags);
2487 assert(!child_role == !parent);
2488
2489 if (reference) {
2490 bool options_non_empty = options ? qdict_size(options) : false;
2491 QDECREF(options);
2492
2493 if (filename || options_non_empty) {
2494 error_setg(errp, "Cannot reference an existing block device with "
2495 "additional options or a new filename");
2496 return NULL;
2497 }
2498
2499 bs = bdrv_lookup_bs(reference, reference, errp);
2500 if (!bs) {
2501 return NULL;
2502 }
2503
2504 bdrv_ref(bs);
2505 return bs;
2506 }
2507
2508 bs = bdrv_new();
2509
2510
2511 if (options == NULL) {
2512 options = qdict_new();
2513 }
2514
2515
2516 parse_json_protocol(options, &filename, &local_err);
2517 if (local_err) {
2518 goto fail;
2519 }
2520
2521 bs->explicit_options = qdict_clone_shallow(options);
2522
2523 if (child_role) {
2524 bs->inherits_from = parent;
2525 child_role->inherit_options(&flags, options,
2526 parent->open_flags, parent->options);
2527 }
2528
2529 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
2530 if (local_err) {
2531 goto fail;
2532 }
2533
2534
2535
2536
2537
2538
2539
2540
2541 if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
2542 !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
2543 flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
2544 } else {
2545 flags &= ~BDRV_O_RDWR;
2546 }
2547
2548 if (flags & BDRV_O_SNAPSHOT) {
2549 snapshot_options = qdict_new();
2550 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
2551 flags, options);
2552
2553 qdict_del(options, BDRV_OPT_READ_ONLY);
2554 bdrv_backing_options(&flags, options, flags, options);
2555 }
2556
2557 bs->open_flags = flags;
2558 bs->options = options;
2559 options = qdict_clone_shallow(options);
2560
2561
2562
2563 drvname = qdict_get_try_str(options, "driver");
2564 if (drvname) {
2565 drv = bdrv_find_format(drvname);
2566 if (!drv) {
2567 error_setg(errp, "Unknown driver: '%s'", drvname);
2568 goto fail;
2569 }
2570 }
2571
2572 assert(drvname || !(flags & BDRV_O_PROTOCOL));
2573
2574
2575 backing = qdict_get_try_str(options, "backing");
2576 if (backing && *backing == '\0') {
2577 flags |= BDRV_O_NO_BACKING;
2578 qdict_del(options, "backing");
2579 }
2580
2581
2582
2583
2584 if ((flags & BDRV_O_PROTOCOL) == 0) {
2585 BlockDriverState *file_bs;
2586
2587 file_bs = bdrv_open_child_bs(filename, options, "file", bs,
2588 &child_file, true, &local_err);
2589 if (local_err) {
2590 goto fail;
2591 }
2592 if (file_bs != NULL) {
2593
2594
2595
2596 file = blk_new(0, BLK_PERM_ALL);
2597 blk_insert_bs(file, file_bs, &local_err);
2598 bdrv_unref(file_bs);
2599 if (local_err) {
2600 goto fail;
2601 }
2602
2603 qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
2604 }
2605 }
2606
2607
2608 bs->probed = !drv;
2609 if (!drv && file) {
2610 ret = find_image_format(file, filename, &drv, &local_err);
2611 if (ret < 0) {
2612 goto fail;
2613 }
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625 qdict_put_str(bs->options, "driver", drv->format_name);
2626 qdict_put_str(options, "driver", drv->format_name);
2627 } else if (!drv) {
2628 error_setg(errp, "Must specify either driver or file");
2629 goto fail;
2630 }
2631
2632
2633 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
2634
2635
2636 assert(!(flags & BDRV_O_PROTOCOL) || !file);
2637
2638
2639 ret = bdrv_open_common(bs, file, options, &local_err);
2640 if (ret < 0) {
2641 goto fail;
2642 }
2643
2644 if (file) {
2645 blk_unref(file);
2646 file = NULL;
2647 }
2648
2649
2650 if ((flags & BDRV_O_NO_BACKING) == 0) {
2651 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
2652 if (ret < 0) {
2653 goto close_and_fail;
2654 }
2655 }
2656
2657 bdrv_refresh_filename(bs);
2658
2659
2660 if (qdict_size(options) != 0) {
2661 const QDictEntry *entry = qdict_first(options);
2662 if (flags & BDRV_O_PROTOCOL) {
2663 error_setg(errp, "Block protocol '%s' doesn't support the option "
2664 "'%s'", drv->format_name, entry->key);
2665 } else {
2666 error_setg(errp,
2667 "Block format '%s' does not support the option '%s'",
2668 drv->format_name, entry->key);
2669 }
2670
2671 goto close_and_fail;
2672 }
2673
2674 bdrv_parent_cb_change_media(bs, true);
2675
2676 QDECREF(options);
2677
2678
2679
2680 if (snapshot_flags) {
2681 BlockDriverState *snapshot_bs;
2682 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
2683 snapshot_options, &local_err);
2684 snapshot_options = NULL;
2685 if (local_err) {
2686 goto close_and_fail;
2687 }
2688
2689
2690
2691
2692 bdrv_unref(bs);
2693 bs = snapshot_bs;
2694 }
2695
2696 return bs;
2697
2698fail:
2699 blk_unref(file);
2700 QDECREF(snapshot_options);
2701 QDECREF(bs->explicit_options);
2702 QDECREF(bs->options);
2703 QDECREF(options);
2704 bs->options = NULL;
2705 bs->explicit_options = NULL;
2706 bdrv_unref(bs);
2707 error_propagate(errp, local_err);
2708 return NULL;
2709
2710close_and_fail:
2711 bdrv_unref(bs);
2712 QDECREF(snapshot_options);
2713 QDECREF(options);
2714 error_propagate(errp, local_err);
2715 return NULL;
2716}
2717
2718BlockDriverState *bdrv_open(const char *filename, const char *reference,
2719 QDict *options, int flags, Error **errp)
2720{
2721 return bdrv_open_inherit(filename, reference, options, flags, NULL,
2722 NULL, errp);
2723}
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
2747 BlockDriverState *bs,
2748 QDict *options,
2749 int flags,
2750 const BdrvChildRole *role,
2751 QDict *parent_options,
2752 int parent_flags)
2753{
2754 assert(bs != NULL);
2755
2756 BlockReopenQueueEntry *bs_entry;
2757 BdrvChild *child;
2758 QDict *old_options, *explicit_options;
2759
2760 if (bs_queue == NULL) {
2761 bs_queue = g_new0(BlockReopenQueue, 1);
2762 QSIMPLEQ_INIT(bs_queue);
2763 }
2764
2765 if (!options) {
2766 options = qdict_new();
2767 }
2768
2769
2770 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2771 if (bs == bs_entry->state.bs) {
2772 break;
2773 }
2774 }
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785 if (!parent_options) {
2786
2787
2788
2789
2790
2791
2792 update_options_from_flags(options, flags);
2793 }
2794
2795
2796 if (bs_entry) {
2797 old_options = qdict_clone_shallow(bs_entry->state.explicit_options);
2798 } else {
2799 old_options = qdict_clone_shallow(bs->explicit_options);
2800 }
2801 bdrv_join_options(bs, options, old_options);
2802 QDECREF(old_options);
2803
2804 explicit_options = qdict_clone_shallow(options);
2805
2806
2807 if (parent_options) {
2808 assert(!flags);
2809 role->inherit_options(&flags, options, parent_flags, parent_options);
2810 }
2811
2812
2813 old_options = qdict_clone_shallow(bs->options);
2814 bdrv_join_options(bs, options, old_options);
2815 QDECREF(old_options);
2816
2817
2818 flags &= ~BDRV_O_PROTOCOL;
2819 if (flags & BDRV_O_RDWR) {
2820 flags |= BDRV_O_ALLOW_RDWR;
2821 }
2822
2823 if (!bs_entry) {
2824 bs_entry = g_new0(BlockReopenQueueEntry, 1);
2825 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
2826 } else {
2827 QDECREF(bs_entry->state.options);
2828 QDECREF(bs_entry->state.explicit_options);
2829 }
2830
2831 bs_entry->state.bs = bs;
2832 bs_entry->state.options = options;
2833 bs_entry->state.explicit_options = explicit_options;
2834 bs_entry->state.flags = flags;
2835
2836
2837 bs_entry->state.perm = UINT64_MAX;
2838 bs_entry->state.shared_perm = 0;
2839
2840 QLIST_FOREACH(child, &bs->children, next) {
2841 QDict *new_child_options;
2842 char *child_key_dot;
2843
2844
2845
2846
2847 if (child->bs->inherits_from != bs) {
2848 continue;
2849 }
2850
2851 child_key_dot = g_strdup_printf("%s.", child->name);
2852 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
2853 g_free(child_key_dot);
2854
2855 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
2856 child->role, options, flags);
2857 }
2858
2859 return bs_queue;
2860}
2861
2862BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
2863 BlockDriverState *bs,
2864 QDict *options, int flags)
2865{
2866 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
2867 NULL, NULL, 0);
2868}
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp)
2886{
2887 int ret = -1;
2888 BlockReopenQueueEntry *bs_entry, *next;
2889 Error *local_err = NULL;
2890
2891 assert(bs_queue != NULL);
2892
2893 aio_context_release(ctx);
2894 bdrv_drain_all_begin();
2895 aio_context_acquire(ctx);
2896
2897 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2898 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
2899 error_propagate(errp, local_err);
2900 goto cleanup;
2901 }
2902 bs_entry->prepared = true;
2903 }
2904
2905
2906
2907
2908 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2909 bdrv_reopen_commit(&bs_entry->state);
2910 }
2911
2912 ret = 0;
2913
2914cleanup:
2915 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
2916 if (ret && bs_entry->prepared) {
2917 bdrv_reopen_abort(&bs_entry->state);
2918 } else if (ret) {
2919 QDECREF(bs_entry->state.explicit_options);
2920 }
2921 QDECREF(bs_entry->state.options);
2922 g_free(bs_entry);
2923 }
2924 g_free(bs_queue);
2925
2926 bdrv_drain_all_end();
2927
2928 return ret;
2929}
2930
2931
2932
2933int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
2934{
2935 int ret = -1;
2936 Error *local_err = NULL;
2937 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
2938
2939 ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, &local_err);
2940 if (local_err != NULL) {
2941 error_propagate(errp, local_err);
2942 }
2943 return ret;
2944}
2945
2946static BlockReopenQueueEntry *find_parent_in_reopen_queue(BlockReopenQueue *q,
2947 BdrvChild *c)
2948{
2949 BlockReopenQueueEntry *entry;
2950
2951 QSIMPLEQ_FOREACH(entry, q, entry) {
2952 BlockDriverState *bs = entry->state.bs;
2953 BdrvChild *child;
2954
2955 QLIST_FOREACH(child, &bs->children, next) {
2956 if (child == c) {
2957 return entry;
2958 }
2959 }
2960 }
2961
2962 return NULL;
2963}
2964
2965static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
2966 uint64_t *perm, uint64_t *shared)
2967{
2968 BdrvChild *c;
2969 BlockReopenQueueEntry *parent;
2970 uint64_t cumulative_perms = 0;
2971 uint64_t cumulative_shared_perms = BLK_PERM_ALL;
2972
2973 QLIST_FOREACH(c, &bs->parents, next_parent) {
2974 parent = find_parent_in_reopen_queue(q, c);
2975 if (!parent) {
2976 cumulative_perms |= c->perm;
2977 cumulative_shared_perms &= c->shared_perm;
2978 } else {
2979 uint64_t nperm, nshared;
2980
2981 bdrv_child_perm(parent->state.bs, bs, c, c->role, q,
2982 parent->state.perm, parent->state.shared_perm,
2983 &nperm, &nshared);
2984
2985 cumulative_perms |= nperm;
2986 cumulative_shared_perms &= nshared;
2987 }
2988 }
2989 *perm = cumulative_perms;
2990 *shared = cumulative_shared_perms;
2991}
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
3011 Error **errp)
3012{
3013 int ret = -1;
3014 Error *local_err = NULL;
3015 BlockDriver *drv;
3016 QemuOpts *opts;
3017 const char *value;
3018 bool read_only;
3019
3020 assert(reopen_state != NULL);
3021 assert(reopen_state->bs->drv != NULL);
3022 drv = reopen_state->bs->drv;
3023
3024
3025 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
3026 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
3027 if (local_err) {
3028 error_propagate(errp, local_err);
3029 ret = -EINVAL;
3030 goto error;
3031 }
3032
3033 update_flags_from_options(&reopen_state->flags, opts);
3034
3035
3036
3037 value = qemu_opt_get(opts, "node-name");
3038 if (value) {
3039 qdict_put_str(reopen_state->options, "node-name", value);
3040 }
3041
3042 value = qemu_opt_get(opts, "driver");
3043 if (value) {
3044 qdict_put_str(reopen_state->options, "driver", value);
3045 }
3046
3047
3048
3049
3050 read_only = !(reopen_state->flags & BDRV_O_RDWR);
3051 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);
3052 if (local_err) {
3053 error_propagate(errp, local_err);
3054 goto error;
3055 }
3056
3057
3058 bdrv_reopen_perm(queue, reopen_state->bs,
3059 &reopen_state->perm, &reopen_state->shared_perm);
3060
3061 ret = bdrv_flush(reopen_state->bs);
3062 if (ret) {
3063 error_setg_errno(errp, -ret, "Error flushing drive");
3064 goto error;
3065 }
3066
3067 if (drv->bdrv_reopen_prepare) {
3068 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
3069 if (ret) {
3070 if (local_err != NULL) {
3071 error_propagate(errp, local_err);
3072 } else {
3073 error_setg(errp, "failed while preparing to reopen image '%s'",
3074 reopen_state->bs->filename);
3075 }
3076 goto error;
3077 }
3078 } else {
3079
3080
3081 error_setg(errp, "Block format '%s' used by node '%s' "
3082 "does not support reopening files", drv->format_name,
3083 bdrv_get_device_or_node_name(reopen_state->bs));
3084 ret = -1;
3085 goto error;
3086 }
3087
3088
3089
3090
3091 if (qdict_size(reopen_state->options)) {
3092 const QDictEntry *entry = qdict_first(reopen_state->options);
3093
3094 do {
3095 QObject *new = entry->value;
3096 QObject *old = qdict_get(reopen_state->bs->options, entry->key);
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114 if (!qobject_is_equal(new, old)) {
3115 error_setg(errp, "Cannot change the option '%s'", entry->key);
3116 ret = -EINVAL;
3117 goto error;
3118 }
3119 } while ((entry = qdict_next(reopen_state->options, entry)));
3120 }
3121
3122 ret = bdrv_check_perm(reopen_state->bs, queue, reopen_state->perm,
3123 reopen_state->shared_perm, NULL, errp);
3124 if (ret < 0) {
3125 goto error;
3126 }
3127
3128 ret = 0;
3129
3130error:
3131 qemu_opts_del(opts);
3132 return ret;
3133}
3134
3135
3136
3137
3138
3139
3140void bdrv_reopen_commit(BDRVReopenState *reopen_state)
3141{
3142 BlockDriver *drv;
3143 BlockDriverState *bs;
3144 bool old_can_write, new_can_write;
3145
3146 assert(reopen_state != NULL);
3147 bs = reopen_state->bs;
3148 drv = bs->drv;
3149 assert(drv != NULL);
3150
3151 old_can_write =
3152 !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
3153
3154
3155 if (drv->bdrv_reopen_commit) {
3156 drv->bdrv_reopen_commit(reopen_state);
3157 }
3158
3159
3160 QDECREF(bs->explicit_options);
3161
3162 bs->explicit_options = reopen_state->explicit_options;
3163 bs->open_flags = reopen_state->flags;
3164 bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
3165
3166 bdrv_refresh_limits(bs, NULL);
3167
3168 bdrv_set_perm(reopen_state->bs, reopen_state->perm,
3169 reopen_state->shared_perm);
3170
3171 new_can_write =
3172 !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
3173 if (!old_can_write && new_can_write && drv->bdrv_reopen_bitmaps_rw) {
3174 Error *local_err = NULL;
3175 if (drv->bdrv_reopen_bitmaps_rw(bs, &local_err) < 0) {
3176
3177
3178
3179
3180 error_reportf_err(local_err,
3181 "%s: Failed to make dirty bitmaps writable: ",
3182 bdrv_get_node_name(bs));
3183 }
3184 }
3185}
3186
3187
3188
3189
3190
3191void bdrv_reopen_abort(BDRVReopenState *reopen_state)
3192{
3193 BlockDriver *drv;
3194
3195 assert(reopen_state != NULL);
3196 drv = reopen_state->bs->drv;
3197 assert(drv != NULL);
3198
3199 if (drv->bdrv_reopen_abort) {
3200 drv->bdrv_reopen_abort(reopen_state);
3201 }
3202
3203 QDECREF(reopen_state->explicit_options);
3204
3205 bdrv_abort_perm_update(reopen_state->bs);
3206}
3207
3208
3209static void bdrv_close(BlockDriverState *bs)
3210{
3211 BdrvAioNotifier *ban, *ban_next;
3212 BdrvChild *child, *next;
3213
3214 assert(!bs->job);
3215 assert(!bs->refcnt);
3216
3217 bdrv_drained_begin(bs);
3218 bdrv_flush(bs);
3219 bdrv_drain(bs);
3220
3221 if (bs->drv) {
3222 bs->drv->bdrv_close(bs);
3223 bs->drv = NULL;
3224 }
3225
3226 bdrv_set_backing_hd(bs, NULL, &error_abort);
3227
3228 if (bs->file != NULL) {
3229 bdrv_unref_child(bs, bs->file);
3230 bs->file = NULL;
3231 }
3232
3233 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
3234
3235
3236 if (child->bs->inherits_from == bs) {
3237 child->bs->inherits_from = NULL;
3238 }
3239 bdrv_detach_child(child);
3240 }
3241
3242 g_free(bs->opaque);
3243 bs->opaque = NULL;
3244 atomic_set(&bs->copy_on_read, 0);
3245 bs->backing_file[0] = '\0';
3246 bs->backing_format[0] = '\0';
3247 bs->total_sectors = 0;
3248 bs->encrypted = false;
3249 bs->sg = false;
3250 QDECREF(bs->options);
3251 QDECREF(bs->explicit_options);
3252 bs->options = NULL;
3253 bs->explicit_options = NULL;
3254 QDECREF(bs->full_open_options);
3255 bs->full_open_options = NULL;
3256
3257 bdrv_release_named_dirty_bitmaps(bs);
3258 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
3259
3260 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3261 g_free(ban);
3262 }
3263 QLIST_INIT(&bs->aio_notifiers);
3264 bdrv_drained_end(bs);
3265}
3266
3267void bdrv_close_all(void)
3268{
3269 block_job_cancel_sync_all();
3270 nbd_export_close_all();
3271
3272
3273
3274 bdrv_drain_all();
3275
3276 blk_remove_all_bs();
3277 blockdev_close_all_bdrv_states();
3278
3279 assert(QTAILQ_EMPTY(&all_bdrv_states));
3280}
3281
3282static bool should_update_child(BdrvChild *c, BlockDriverState *to)
3283{
3284 BdrvChild *to_c;
3285
3286 if (c->role->stay_at_node) {
3287 return false;
3288 }
3289
3290 if (c->role == &child_backing) {
3291
3292
3293
3294 QLIST_FOREACH(to_c, &to->children, next) {
3295 if (to_c == c) {
3296 break;
3297 }
3298 }
3299 if (to_c) {
3300 return false;
3301 }
3302 }
3303
3304 return true;
3305}
3306
3307void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
3308 Error **errp)
3309{
3310 BdrvChild *c, *next;
3311 GSList *list = NULL, *p;
3312 uint64_t old_perm, old_shared;
3313 uint64_t perm = 0, shared = BLK_PERM_ALL;
3314 int ret;
3315
3316 assert(!atomic_read(&from->in_flight));
3317 assert(!atomic_read(&to->in_flight));
3318
3319
3320
3321 bdrv_ref(from);
3322
3323
3324 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
3325 if (!should_update_child(c, to)) {
3326 continue;
3327 }
3328 list = g_slist_prepend(list, c);
3329 perm |= c->perm;
3330 shared &= c->shared_perm;
3331 }
3332
3333
3334
3335 ret = bdrv_check_update_perm(to, NULL, perm, shared, list, errp);
3336 if (ret < 0) {
3337 bdrv_abort_perm_update(to);
3338 goto out;
3339 }
3340
3341
3342
3343
3344 for (p = list; p != NULL; p = p->next) {
3345 c = p->data;
3346
3347 bdrv_ref(to);
3348 bdrv_replace_child_noperm(c, to);
3349 bdrv_unref(from);
3350 }
3351
3352 bdrv_get_cumulative_perm(to, &old_perm, &old_shared);
3353 bdrv_set_perm(to, old_perm | perm, old_shared | shared);
3354
3355out:
3356 g_slist_free(list);
3357 bdrv_unref(from);
3358}
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
3377 Error **errp)
3378{
3379 Error *local_err = NULL;
3380
3381 bdrv_set_backing_hd(bs_new, bs_top, &local_err);
3382 if (local_err) {
3383 error_propagate(errp, local_err);
3384 goto out;
3385 }
3386
3387 bdrv_replace_node(bs_top, bs_new, &local_err);
3388 if (local_err) {
3389 error_propagate(errp, local_err);
3390 bdrv_set_backing_hd(bs_new, NULL, &error_abort);
3391 goto out;
3392 }
3393
3394
3395
3396out:
3397 bdrv_unref(bs_new);
3398}
3399
3400static void bdrv_delete(BlockDriverState *bs)
3401{
3402 assert(!bs->job);
3403 assert(bdrv_op_blocker_is_empty(bs));
3404 assert(!bs->refcnt);
3405
3406 bdrv_close(bs);
3407
3408
3409 if (bs->node_name[0] != '\0') {
3410 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
3411 }
3412 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
3413
3414 g_free(bs);
3415}
3416
3417
3418
3419
3420
3421
3422
3423
3424int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
3425{
3426 if (bs->drv == NULL) {
3427 return -ENOMEDIUM;
3428 }
3429 if (bs->drv->bdrv_check == NULL) {
3430 return -ENOTSUP;
3431 }
3432
3433 memset(res, 0, sizeof(*res));
3434 return bs->drv->bdrv_check(bs, res, fix);
3435}
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445int bdrv_change_backing_file(BlockDriverState *bs,
3446 const char *backing_file, const char *backing_fmt)
3447{
3448 BlockDriver *drv = bs->drv;
3449 int ret;
3450
3451 if (!drv) {
3452 return -ENOMEDIUM;
3453 }
3454
3455
3456 if (backing_fmt && !backing_file) {
3457 return -EINVAL;
3458 }
3459
3460 if (drv->bdrv_change_backing_file != NULL) {
3461 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
3462 } else {
3463 ret = -ENOTSUP;
3464 }
3465
3466 if (ret == 0) {
3467 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
3468 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
3469 }
3470 return ret;
3471}
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
3484 BlockDriverState *bs)
3485{
3486 while (active && bs != backing_bs(active)) {
3487 active = backing_bs(active);
3488 }
3489
3490 return active;
3491}
3492
3493
3494BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3495{
3496 return bdrv_find_overlay(bs, NULL);
3497}
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
3529 const char *backing_file_str)
3530{
3531 BdrvChild *c, *next;
3532 Error *local_err = NULL;
3533 int ret = -EIO;
3534
3535 bdrv_ref(top);
3536
3537 if (!top->drv || !base->drv) {
3538 goto exit;
3539 }
3540
3541
3542 if (!bdrv_chain_contains(top, base)) {
3543 goto exit;
3544 }
3545
3546
3547
3548
3549 backing_file_str = backing_file_str ? backing_file_str : base->filename;
3550
3551 QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) {
3552
3553 GSList *ignore_children = g_slist_prepend(NULL, c);
3554 bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm,
3555 ignore_children, &local_err);
3556 if (local_err) {
3557 ret = -EPERM;
3558 error_report_err(local_err);
3559 goto exit;
3560 }
3561 g_slist_free(ignore_children);
3562
3563
3564 if (c->role->update_filename) {
3565 ret = c->role->update_filename(c, base, backing_file_str,
3566 &local_err);
3567 if (ret < 0) {
3568 bdrv_abort_perm_update(base);
3569 error_report_err(local_err);
3570 goto exit;
3571 }
3572 }
3573
3574
3575
3576 bdrv_ref(base);
3577 bdrv_replace_child(c, base);
3578 bdrv_unref(top);
3579 }
3580
3581 ret = 0;
3582exit:
3583 bdrv_unref(top);
3584 return ret;
3585}
3586
3587
3588
3589
3590int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,
3591 Error **errp)
3592{
3593 BlockDriverState *bs = child->bs;
3594 BlockDriver *drv = bs->drv;
3595 int ret;
3596
3597 assert(child->perm & BLK_PERM_RESIZE);
3598
3599
3600 if (!drv) {
3601 error_setg(errp, "No medium inserted");
3602 return -ENOMEDIUM;
3603 }
3604 if (!drv->bdrv_truncate) {
3605 if (bs->file && drv->is_filter) {
3606 return bdrv_truncate(bs->file, offset, prealloc, errp);
3607 }
3608 error_setg(errp, "Image format driver does not support resize");
3609 return -ENOTSUP;
3610 }
3611 if (bs->read_only) {
3612 error_setg(errp, "Image is read-only");
3613 return -EACCES;
3614 }
3615
3616 assert(!(bs->open_flags & BDRV_O_INACTIVE));
3617
3618 ret = drv->bdrv_truncate(bs, offset, prealloc, errp);
3619 if (ret < 0) {
3620 return ret;
3621 }
3622 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3623 if (ret < 0) {
3624 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3625 } else {
3626 offset = bs->total_sectors * BDRV_SECTOR_SIZE;
3627 }
3628 bdrv_dirty_bitmap_truncate(bs, offset);
3629 bdrv_parent_cb_resize(bs);
3630 atomic_inc(&bs->write_gen);
3631 return ret;
3632}
3633
3634
3635
3636
3637
3638int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3639{
3640 BlockDriver *drv = bs->drv;
3641 if (!drv) {
3642 return -ENOMEDIUM;
3643 }
3644 if (drv->bdrv_get_allocated_file_size) {
3645 return drv->bdrv_get_allocated_file_size(bs);
3646 }
3647 if (bs->file) {
3648 return bdrv_get_allocated_file_size(bs->file->bs);
3649 }
3650 return -ENOTSUP;
3651}
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
3677 BlockDriverState *in_bs, Error **errp)
3678{
3679 if (!drv->bdrv_measure) {
3680 error_setg(errp, "Block driver '%s' does not support size measurement",
3681 drv->format_name);
3682 return NULL;
3683 }
3684
3685 return drv->bdrv_measure(opts, in_bs, errp);
3686}
3687
3688
3689
3690
3691int64_t bdrv_nb_sectors(BlockDriverState *bs)
3692{
3693 BlockDriver *drv = bs->drv;
3694
3695 if (!drv)
3696 return -ENOMEDIUM;
3697
3698 if (drv->has_variable_length) {
3699 int ret = refresh_total_sectors(bs, bs->total_sectors);
3700 if (ret < 0) {
3701 return ret;
3702 }
3703 }
3704 return bs->total_sectors;
3705}
3706
3707
3708
3709
3710
3711int64_t bdrv_getlength(BlockDriverState *bs)
3712{
3713 int64_t ret = bdrv_nb_sectors(bs);
3714
3715 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
3716 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
3717}
3718
3719
3720void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3721{
3722 int64_t nb_sectors = bdrv_nb_sectors(bs);
3723
3724 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
3725}
3726
3727bool bdrv_is_sg(BlockDriverState *bs)
3728{
3729 return bs->sg;
3730}
3731
3732bool bdrv_is_encrypted(BlockDriverState *bs)
3733{
3734 if (bs->backing && bs->backing->bs->encrypted) {
3735 return true;
3736 }
3737 return bs->encrypted;
3738}
3739
3740const char *bdrv_get_format_name(BlockDriverState *bs)
3741{
3742 return bs->drv ? bs->drv->format_name : NULL;
3743}
3744
3745static int qsort_strcmp(const void *a, const void *b)
3746{
3747 return strcmp(*(char *const *)a, *(char *const *)b);
3748}
3749
3750void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
3751 void *opaque)
3752{
3753 BlockDriver *drv;
3754 int count = 0;
3755 int i;
3756 const char **formats = NULL;
3757
3758 QLIST_FOREACH(drv, &bdrv_drivers, list) {
3759 if (drv->format_name) {
3760 bool found = false;
3761 int i = count;
3762 while (formats && i && !found) {
3763 found = !strcmp(formats[--i], drv->format_name);
3764 }
3765
3766 if (!found) {
3767 formats = g_renew(const char *, formats, count + 1);
3768 formats[count++] = drv->format_name;
3769 }
3770 }
3771 }
3772
3773 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
3774 const char *format_name = block_driver_modules[i].format_name;
3775
3776 if (format_name) {
3777 bool found = false;
3778 int j = count;
3779
3780 while (formats && j && !found) {
3781 found = !strcmp(formats[--j], format_name);
3782 }
3783
3784 if (!found) {
3785 formats = g_renew(const char *, formats, count + 1);
3786 formats[count++] = format_name;
3787 }
3788 }
3789 }
3790
3791 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
3792
3793 for (i = 0; i < count; i++) {
3794 it(opaque, formats[i]);
3795 }
3796
3797 g_free(formats);
3798}
3799
3800
3801BlockDriverState *bdrv_find_node(const char *node_name)
3802{
3803 BlockDriverState *bs;
3804
3805 assert(node_name);
3806
3807 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3808 if (!strcmp(node_name, bs->node_name)) {
3809 return bs;
3810 }
3811 }
3812 return NULL;
3813}
3814
3815
3816BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
3817{
3818 BlockDeviceInfoList *list, *entry;
3819 BlockDriverState *bs;
3820
3821 list = NULL;
3822 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3823 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
3824 if (!info) {
3825 qapi_free_BlockDeviceInfoList(list);
3826 return NULL;
3827 }
3828 entry = g_malloc0(sizeof(*entry));
3829 entry->value = info;
3830 entry->next = list;
3831 list = entry;
3832 }
3833
3834 return list;
3835}
3836
3837BlockDriverState *bdrv_lookup_bs(const char *device,
3838 const char *node_name,
3839 Error **errp)
3840{
3841 BlockBackend *blk;
3842 BlockDriverState *bs;
3843
3844 if (device) {
3845 blk = blk_by_name(device);
3846
3847 if (blk) {
3848 bs = blk_bs(blk);
3849 if (!bs) {
3850 error_setg(errp, "Device '%s' has no medium", device);
3851 }
3852
3853 return bs;
3854 }
3855 }
3856
3857 if (node_name) {
3858 bs = bdrv_find_node(node_name);
3859
3860 if (bs) {
3861 return bs;
3862 }
3863 }
3864
3865 error_setg(errp, "Cannot find device=%s nor node_name=%s",
3866 device ? device : "",
3867 node_name ? node_name : "");
3868 return NULL;
3869}
3870
3871
3872
3873bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
3874{
3875 while (top && top != base) {
3876 top = backing_bs(top);
3877 }
3878
3879 return top != NULL;
3880}
3881
3882BlockDriverState *bdrv_next_node(BlockDriverState *bs)
3883{
3884 if (!bs) {
3885 return QTAILQ_FIRST(&graph_bdrv_states);
3886 }
3887 return QTAILQ_NEXT(bs, node_list);
3888}
3889
3890const char *bdrv_get_node_name(const BlockDriverState *bs)
3891{
3892 return bs->node_name;
3893}
3894
3895const char *bdrv_get_parent_name(const BlockDriverState *bs)
3896{
3897 BdrvChild *c;
3898 const char *name;
3899
3900
3901 QLIST_FOREACH(c, &bs->parents, next_parent) {
3902 if (c->role->get_name) {
3903 name = c->role->get_name(c);
3904 if (name && *name) {
3905 return name;
3906 }
3907 }
3908 }
3909
3910 return NULL;
3911}
3912
3913
3914const char *bdrv_get_device_name(const BlockDriverState *bs)
3915{
3916 return bdrv_get_parent_name(bs) ?: "";
3917}
3918
3919
3920
3921
3922
3923const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
3924{
3925 return bdrv_get_parent_name(bs) ?: bs->node_name;
3926}
3927
3928int bdrv_get_flags(BlockDriverState *bs)
3929{
3930 return bs->open_flags;
3931}
3932
3933int bdrv_has_zero_init_1(BlockDriverState *bs)
3934{
3935 return 1;
3936}
3937
3938int bdrv_has_zero_init(BlockDriverState *bs)
3939{
3940 if (!bs->drv) {
3941 return 0;
3942 }
3943
3944
3945
3946 if (bs->backing) {
3947 return 0;
3948 }
3949 if (bs->drv->bdrv_has_zero_init) {
3950 return bs->drv->bdrv_has_zero_init(bs);
3951 }
3952 if (bs->file && bs->drv->is_filter) {
3953 return bdrv_has_zero_init(bs->file->bs);
3954 }
3955
3956
3957 return 0;
3958}
3959
3960bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3961{
3962 BlockDriverInfo bdi;
3963
3964 if (bs->backing) {
3965 return false;
3966 }
3967
3968 if (bdrv_get_info(bs, &bdi) == 0) {
3969 return bdi.unallocated_blocks_are_zero;
3970 }
3971
3972 return false;
3973}
3974
3975bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3976{
3977 BlockDriverInfo bdi;
3978
3979 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3980 return false;
3981 }
3982
3983 if (bdrv_get_info(bs, &bdi) == 0) {
3984 return bdi.can_write_zeroes_with_unmap;
3985 }
3986
3987 return false;
3988}
3989
3990const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3991{
3992 if (bs->backing && bs->backing->bs->encrypted)
3993 return bs->backing_file;
3994 else if (bs->encrypted)
3995 return bs->filename;
3996 else
3997 return NULL;
3998}
3999
4000void bdrv_get_backing_filename(BlockDriverState *bs,
4001 char *filename, int filename_size)
4002{
4003 pstrcpy(filename, filename_size, bs->backing_file);
4004}
4005
4006int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4007{
4008 BlockDriver *drv = bs->drv;
4009
4010 if (!drv) {
4011 return -ENOMEDIUM;
4012 }
4013 if (!drv->bdrv_get_info) {
4014 if (bs->file && drv->is_filter) {
4015 return bdrv_get_info(bs->file->bs, bdi);
4016 }
4017 return -ENOTSUP;
4018 }
4019 memset(bdi, 0, sizeof(*bdi));
4020 return drv->bdrv_get_info(bs, bdi);
4021}
4022
4023ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4024{
4025 BlockDriver *drv = bs->drv;
4026 if (drv && drv->bdrv_get_specific_info) {
4027 return drv->bdrv_get_specific_info(bs);
4028 }
4029 return NULL;
4030}
4031
4032void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
4033{
4034 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4035 return;
4036 }
4037
4038 bs->drv->bdrv_debug_event(bs, event);
4039}
4040
4041int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4042 const char *tag)
4043{
4044 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4045 bs = bs->file ? bs->file->bs : NULL;
4046 }
4047
4048 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4049 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4050 }
4051
4052 return -ENOTSUP;
4053}
4054
4055int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4056{
4057 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4058 bs = bs->file ? bs->file->bs : NULL;
4059 }
4060
4061 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4062 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4063 }
4064
4065 return -ENOTSUP;
4066}
4067
4068int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4069{
4070 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4071 bs = bs->file ? bs->file->bs : NULL;
4072 }
4073
4074 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4075 return bs->drv->bdrv_debug_resume(bs, tag);
4076 }
4077
4078 return -ENOTSUP;
4079}
4080
4081bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4082{
4083 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4084 bs = bs->file ? bs->file->bs : NULL;
4085 }
4086
4087 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4088 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4089 }
4090
4091 return false;
4092}
4093
4094
4095
4096
4097
4098BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4099 const char *backing_file)
4100{
4101 char *filename_full = NULL;
4102 char *backing_file_full = NULL;
4103 char *filename_tmp = NULL;
4104 int is_protocol = 0;
4105 BlockDriverState *curr_bs = NULL;
4106 BlockDriverState *retval = NULL;
4107 Error *local_error = NULL;
4108
4109 if (!bs || !bs->drv || !backing_file) {
4110 return NULL;
4111 }
4112
4113 filename_full = g_malloc(PATH_MAX);
4114 backing_file_full = g_malloc(PATH_MAX);
4115 filename_tmp = g_malloc(PATH_MAX);
4116
4117 is_protocol = path_has_protocol(backing_file);
4118
4119 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
4120
4121
4122
4123 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4124 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4125 retval = curr_bs->backing->bs;
4126 break;
4127 }
4128
4129 bdrv_get_full_backing_filename(curr_bs, backing_file_full, PATH_MAX,
4130 &local_error);
4131 if (local_error == NULL) {
4132 if (strcmp(backing_file, backing_file_full) == 0) {
4133 retval = curr_bs->backing->bs;
4134 break;
4135 }
4136 } else {
4137 error_free(local_error);
4138 local_error = NULL;
4139 }
4140 } else {
4141
4142
4143 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4144 backing_file);
4145
4146
4147 if (!realpath(filename_tmp, filename_full)) {
4148 continue;
4149 }
4150
4151
4152
4153 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4154 curr_bs->backing_file);
4155
4156 if (!realpath(filename_tmp, backing_file_full)) {
4157 continue;
4158 }
4159
4160 if (strcmp(backing_file_full, filename_full) == 0) {
4161 retval = curr_bs->backing->bs;
4162 break;
4163 }
4164 }
4165 }
4166
4167 g_free(filename_full);
4168 g_free(backing_file_full);
4169 g_free(filename_tmp);
4170 return retval;
4171}
4172
4173void bdrv_init(void)
4174{
4175 module_call_init(MODULE_INIT_BLOCK);
4176}
4177
4178void bdrv_init_with_whitelist(void)
4179{
4180 use_bdrv_whitelist = 1;
4181 bdrv_init();
4182}
4183
4184void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4185{
4186 BdrvChild *child, *parent;
4187 uint64_t perm, shared_perm;
4188 Error *local_err = NULL;
4189 int ret;
4190
4191 if (!bs->drv) {
4192 return;
4193 }
4194
4195 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
4196 return;
4197 }
4198
4199 QLIST_FOREACH(child, &bs->children, next) {
4200 bdrv_invalidate_cache(child->bs, &local_err);
4201 if (local_err) {
4202 error_propagate(errp, local_err);
4203 return;
4204 }
4205 }
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220 bs->open_flags &= ~BDRV_O_INACTIVE;
4221 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
4222 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err);
4223 if (ret < 0) {
4224 bs->open_flags |= BDRV_O_INACTIVE;
4225 error_propagate(errp, local_err);
4226 return;
4227 }
4228 bdrv_set_perm(bs, perm, shared_perm);
4229
4230 if (bs->drv->bdrv_invalidate_cache) {
4231 bs->drv->bdrv_invalidate_cache(bs, &local_err);
4232 if (local_err) {
4233 bs->open_flags |= BDRV_O_INACTIVE;
4234 error_propagate(errp, local_err);
4235 return;
4236 }
4237 }
4238
4239 ret = refresh_total_sectors(bs, bs->total_sectors);
4240 if (ret < 0) {
4241 bs->open_flags |= BDRV_O_INACTIVE;
4242 error_setg_errno(errp, -ret, "Could not refresh total sector count");
4243 return;
4244 }
4245
4246 QLIST_FOREACH(parent, &bs->parents, next_parent) {
4247 if (parent->role->activate) {
4248 parent->role->activate(parent, &local_err);
4249 if (local_err) {
4250 error_propagate(errp, local_err);
4251 return;
4252 }
4253 }
4254 }
4255}
4256
4257void bdrv_invalidate_cache_all(Error **errp)
4258{
4259 BlockDriverState *bs;
4260 Error *local_err = NULL;
4261 BdrvNextIterator it;
4262
4263 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4264 AioContext *aio_context = bdrv_get_aio_context(bs);
4265
4266 aio_context_acquire(aio_context);
4267 bdrv_invalidate_cache(bs, &local_err);
4268 aio_context_release(aio_context);
4269 if (local_err) {
4270 error_propagate(errp, local_err);
4271 bdrv_next_cleanup(&it);
4272 return;
4273 }
4274 }
4275}
4276
4277static int bdrv_inactivate_recurse(BlockDriverState *bs,
4278 bool setting_flag)
4279{
4280 BdrvChild *child, *parent;
4281 int ret;
4282
4283 if (!bs->drv) {
4284 return -ENOMEDIUM;
4285 }
4286
4287 if (!setting_flag && bs->drv->bdrv_inactivate) {
4288 ret = bs->drv->bdrv_inactivate(bs);
4289 if (ret < 0) {
4290 return ret;
4291 }
4292 }
4293
4294 if (setting_flag && !(bs->open_flags & BDRV_O_INACTIVE)) {
4295 uint64_t perm, shared_perm;
4296
4297 QLIST_FOREACH(parent, &bs->parents, next_parent) {
4298 if (parent->role->inactivate) {
4299 ret = parent->role->inactivate(parent);
4300 if (ret < 0) {
4301 return ret;
4302 }
4303 }
4304 }
4305
4306 bs->open_flags |= BDRV_O_INACTIVE;
4307
4308
4309 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
4310 bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &error_abort);
4311 bdrv_set_perm(bs, perm, shared_perm);
4312 }
4313
4314 QLIST_FOREACH(child, &bs->children, next) {
4315 ret = bdrv_inactivate_recurse(child->bs, setting_flag);
4316 if (ret < 0) {
4317 return ret;
4318 }
4319 }
4320
4321
4322
4323 bdrv_release_persistent_dirty_bitmaps(bs);
4324
4325 return 0;
4326}
4327
4328int bdrv_inactivate_all(void)
4329{
4330 BlockDriverState *bs = NULL;
4331 BdrvNextIterator it;
4332 int ret = 0;
4333 int pass;
4334
4335 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4336 aio_context_acquire(bdrv_get_aio_context(bs));
4337 }
4338
4339
4340
4341
4342
4343 for (pass = 0; pass < 2; pass++) {
4344 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4345 ret = bdrv_inactivate_recurse(bs, pass);
4346 if (ret < 0) {
4347 bdrv_next_cleanup(&it);
4348 goto out;
4349 }
4350 }
4351 }
4352
4353out:
4354 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4355 aio_context_release(bdrv_get_aio_context(bs));
4356 }
4357
4358 return ret;
4359}
4360
4361
4362
4363
4364
4365
4366
4367bool bdrv_is_inserted(BlockDriverState *bs)
4368{
4369 BlockDriver *drv = bs->drv;
4370 BdrvChild *child;
4371
4372 if (!drv) {
4373 return false;
4374 }
4375 if (drv->bdrv_is_inserted) {
4376 return drv->bdrv_is_inserted(bs);
4377 }
4378 QLIST_FOREACH(child, &bs->children, next) {
4379 if (!bdrv_is_inserted(child->bs)) {
4380 return false;
4381 }
4382 }
4383 return true;
4384}
4385
4386
4387
4388
4389void bdrv_eject(BlockDriverState *bs, bool eject_flag)
4390{
4391 BlockDriver *drv = bs->drv;
4392
4393 if (drv && drv->bdrv_eject) {
4394 drv->bdrv_eject(bs, eject_flag);
4395 }
4396}
4397
4398
4399
4400
4401
4402void bdrv_lock_medium(BlockDriverState *bs, bool locked)
4403{
4404 BlockDriver *drv = bs->drv;
4405
4406 trace_bdrv_lock_medium(bs, locked);
4407
4408 if (drv && drv->bdrv_lock_medium) {
4409 drv->bdrv_lock_medium(bs, locked);
4410 }
4411}
4412
4413
4414void bdrv_ref(BlockDriverState *bs)
4415{
4416 bs->refcnt++;
4417}
4418
4419
4420
4421
4422void bdrv_unref(BlockDriverState *bs)
4423{
4424 if (!bs) {
4425 return;
4426 }
4427 assert(bs->refcnt > 0);
4428 if (--bs->refcnt == 0) {
4429 bdrv_delete(bs);
4430 }
4431}
4432
4433struct BdrvOpBlocker {
4434 Error *reason;
4435 QLIST_ENTRY(BdrvOpBlocker) list;
4436};
4437
4438bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
4439{
4440 BdrvOpBlocker *blocker;
4441 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4442 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
4443 blocker = QLIST_FIRST(&bs->op_blockers[op]);
4444 error_propagate(errp, error_copy(blocker->reason));
4445 error_prepend(errp, "Node '%s' is busy: ",
4446 bdrv_get_device_or_node_name(bs));
4447 return true;
4448 }
4449 return false;
4450}
4451
4452void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
4453{
4454 BdrvOpBlocker *blocker;
4455 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4456
4457 blocker = g_new0(BdrvOpBlocker, 1);
4458 blocker->reason = reason;
4459 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
4460}
4461
4462void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
4463{
4464 BdrvOpBlocker *blocker, *next;
4465 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4466 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
4467 if (blocker->reason == reason) {
4468 QLIST_REMOVE(blocker, list);
4469 g_free(blocker);
4470 }
4471 }
4472}
4473
4474void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
4475{
4476 int i;
4477 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4478 bdrv_op_block(bs, i, reason);
4479 }
4480}
4481
4482void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
4483{
4484 int i;
4485 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4486 bdrv_op_unblock(bs, i, reason);
4487 }
4488}
4489
4490bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
4491{
4492 int i;
4493
4494 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4495 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
4496 return false;
4497 }
4498 }
4499 return true;
4500}
4501
4502void bdrv_img_create(const char *filename, const char *fmt,
4503 const char *base_filename, const char *base_fmt,
4504 char *options, uint64_t img_size, int flags, bool quiet,
4505 Error **errp)
4506{
4507 QemuOptsList *create_opts = NULL;
4508 QemuOpts *opts = NULL;
4509 const char *backing_fmt, *backing_file;
4510 int64_t size;
4511 BlockDriver *drv, *proto_drv;
4512 Error *local_err = NULL;
4513 int ret = 0;
4514
4515
4516 drv = bdrv_find_format(fmt);
4517 if (!drv) {
4518 error_setg(errp, "Unknown file format '%s'", fmt);
4519 return;
4520 }
4521
4522 proto_drv = bdrv_find_protocol(filename, true, errp);
4523 if (!proto_drv) {
4524 return;
4525 }
4526
4527 if (!drv->create_opts) {
4528 error_setg(errp, "Format driver '%s' does not support image creation",
4529 drv->format_name);
4530 return;
4531 }
4532
4533 if (!proto_drv->create_opts) {
4534 error_setg(errp, "Protocol driver '%s' does not support image creation",
4535 proto_drv->format_name);
4536 return;
4537 }
4538
4539 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4540 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
4541
4542
4543 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4544 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
4545
4546
4547 if (options) {
4548 qemu_opts_do_parse(opts, options, NULL, &local_err);
4549 if (local_err) {
4550 error_report_err(local_err);
4551 local_err = NULL;
4552 error_setg(errp, "Invalid options for file format '%s'", fmt);
4553 goto out;
4554 }
4555 }
4556
4557 if (base_filename) {
4558 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
4559 if (local_err) {
4560 error_setg(errp, "Backing file not supported for file format '%s'",
4561 fmt);
4562 goto out;
4563 }
4564 }
4565
4566 if (base_fmt) {
4567 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
4568 if (local_err) {
4569 error_setg(errp, "Backing file format not supported for file "
4570 "format '%s'", fmt);
4571 goto out;
4572 }
4573 }
4574
4575 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
4576 if (backing_file) {
4577 if (!strcmp(filename, backing_file)) {
4578 error_setg(errp, "Error: Trying to create an image with the "
4579 "same filename as the backing file");
4580 goto out;
4581 }
4582 }
4583
4584 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
4585
4586
4587
4588 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
4589 if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
4590 BlockDriverState *bs;
4591 char *full_backing = g_new0(char, PATH_MAX);
4592 int back_flags;
4593 QDict *backing_options = NULL;
4594
4595 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
4596 full_backing, PATH_MAX,
4597 &local_err);
4598 if (local_err) {
4599 g_free(full_backing);
4600 goto out;
4601 }
4602
4603
4604 back_flags = flags;
4605 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
4606
4607 backing_options = qdict_new();
4608 if (backing_fmt) {
4609 qdict_put_str(backing_options, "driver", backing_fmt);
4610 }
4611 qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
4612
4613 bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
4614 &local_err);
4615 g_free(full_backing);
4616 if (!bs && size != -1) {
4617
4618 warn_reportf_err(local_err,
4619 "Could not verify backing image. "
4620 "This may become an error in future versions.\n");
4621 local_err = NULL;
4622 } else if (!bs) {
4623
4624 error_append_hint(&local_err,
4625 "Could not open backing image to determine size.\n");
4626 goto out;
4627 } else {
4628 if (size == -1) {
4629
4630 size = bdrv_getlength(bs);
4631 if (size < 0) {
4632 error_setg_errno(errp, -size, "Could not get size of '%s'",
4633 backing_file);
4634 bdrv_unref(bs);
4635 goto out;
4636 }
4637 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
4638 }
4639 bdrv_unref(bs);
4640 }
4641 }
4642
4643 if (size == -1) {
4644 error_setg(errp, "Image creation needs a size parameter");
4645 goto out;
4646 }
4647
4648 if (!quiet) {
4649 printf("Formatting '%s', fmt=%s ", filename, fmt);
4650 qemu_opts_print(opts, " ");
4651 puts("");
4652 }
4653
4654 ret = bdrv_create(drv, filename, opts, &local_err);
4655
4656 if (ret == -EFBIG) {
4657
4658
4659
4660 const char *cluster_size_hint = "";
4661 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
4662 cluster_size_hint = " (try using a larger cluster size)";
4663 }
4664 error_setg(errp, "The image size is too large for file format '%s'"
4665 "%s", fmt, cluster_size_hint);
4666 error_free(local_err);
4667 local_err = NULL;
4668 }
4669
4670out:
4671 qemu_opts_del(opts);
4672 qemu_opts_free(create_opts);
4673 error_propagate(errp, local_err);
4674}
4675
4676AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4677{
4678 return bs->aio_context;
4679}
4680
4681void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)
4682{
4683 aio_co_enter(bdrv_get_aio_context(bs), co);
4684}
4685
4686static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
4687{
4688 QLIST_REMOVE(ban, list);
4689 g_free(ban);
4690}
4691
4692void bdrv_detach_aio_context(BlockDriverState *bs)
4693{
4694 BdrvAioNotifier *baf, *baf_tmp;
4695 BdrvChild *child;
4696
4697 if (!bs->drv) {
4698 return;
4699 }
4700
4701 assert(!bs->walking_aio_notifiers);
4702 bs->walking_aio_notifiers = true;
4703 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
4704 if (baf->deleted) {
4705 bdrv_do_remove_aio_context_notifier(baf);
4706 } else {
4707 baf->detach_aio_context(baf->opaque);
4708 }
4709 }
4710
4711
4712
4713 bs->walking_aio_notifiers = false;
4714
4715 if (bs->drv->bdrv_detach_aio_context) {
4716 bs->drv->bdrv_detach_aio_context(bs);
4717 }
4718 QLIST_FOREACH(child, &bs->children, next) {
4719 bdrv_detach_aio_context(child->bs);
4720 }
4721
4722 bs->aio_context = NULL;
4723}
4724
4725void bdrv_attach_aio_context(BlockDriverState *bs,
4726 AioContext *new_context)
4727{
4728 BdrvAioNotifier *ban, *ban_tmp;
4729 BdrvChild *child;
4730
4731 if (!bs->drv) {
4732 return;
4733 }
4734
4735 bs->aio_context = new_context;
4736
4737 QLIST_FOREACH(child, &bs->children, next) {
4738 bdrv_attach_aio_context(child->bs, new_context);
4739 }
4740 if (bs->drv->bdrv_attach_aio_context) {
4741 bs->drv->bdrv_attach_aio_context(bs, new_context);
4742 }
4743
4744 assert(!bs->walking_aio_notifiers);
4745 bs->walking_aio_notifiers = true;
4746 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
4747 if (ban->deleted) {
4748 bdrv_do_remove_aio_context_notifier(ban);
4749 } else {
4750 ban->attached_aio_context(new_context, ban->opaque);
4751 }
4752 }
4753 bs->walking_aio_notifiers = false;
4754}
4755
4756void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
4757{
4758 AioContext *ctx = bdrv_get_aio_context(bs);
4759
4760 aio_disable_external(ctx);
4761 bdrv_parent_drained_begin(bs);
4762 bdrv_drain(bs);
4763
4764 while (aio_poll(ctx, false)) {
4765
4766 }
4767
4768 bdrv_detach_aio_context(bs);
4769
4770
4771
4772
4773 aio_context_acquire(new_context);
4774 bdrv_attach_aio_context(bs, new_context);
4775 bdrv_parent_drained_end(bs);
4776 aio_enable_external(ctx);
4777 aio_context_release(new_context);
4778}
4779
4780void bdrv_add_aio_context_notifier(BlockDriverState *bs,
4781 void (*attached_aio_context)(AioContext *new_context, void *opaque),
4782 void (*detach_aio_context)(void *opaque), void *opaque)
4783{
4784 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
4785 *ban = (BdrvAioNotifier){
4786 .attached_aio_context = attached_aio_context,
4787 .detach_aio_context = detach_aio_context,
4788 .opaque = opaque
4789 };
4790
4791 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
4792}
4793
4794void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
4795 void (*attached_aio_context)(AioContext *,
4796 void *),
4797 void (*detach_aio_context)(void *),
4798 void *opaque)
4799{
4800 BdrvAioNotifier *ban, *ban_next;
4801
4802 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4803 if (ban->attached_aio_context == attached_aio_context &&
4804 ban->detach_aio_context == detach_aio_context &&
4805 ban->opaque == opaque &&
4806 ban->deleted == false)
4807 {
4808 if (bs->walking_aio_notifiers) {
4809 ban->deleted = true;
4810 } else {
4811 bdrv_do_remove_aio_context_notifier(ban);
4812 }
4813 return;
4814 }
4815 }
4816
4817 abort();
4818}
4819
4820int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
4821 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
4822{
4823 if (!bs->drv) {
4824 return -ENOMEDIUM;
4825 }
4826 if (!bs->drv->bdrv_amend_options) {
4827 return -ENOTSUP;
4828 }
4829 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
4830}
4831
4832
4833
4834
4835
4836
4837bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
4838 BlockDriverState *candidate)
4839{
4840
4841 if (!bs || !bs->drv) {
4842 return false;
4843 }
4844
4845
4846
4847
4848 if (!bs->drv->is_filter) {
4849 return bs == candidate;
4850 }
4851
4852
4853
4854
4855
4856 if (bs->drv->bdrv_recurse_is_first_non_filter) {
4857 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4858 }
4859
4860
4861
4862 return false;
4863}
4864
4865
4866
4867
4868
4869bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4870{
4871 BlockDriverState *bs;
4872 BdrvNextIterator it;
4873
4874
4875 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4876 bool perm;
4877
4878
4879 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4880
4881
4882 if (perm) {
4883 bdrv_next_cleanup(&it);
4884 return true;
4885 }
4886 }
4887
4888 return false;
4889}
4890
4891BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
4892 const char *node_name, Error **errp)
4893{
4894 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4895 AioContext *aio_context;
4896
4897 if (!to_replace_bs) {
4898 error_setg(errp, "Node name '%s' not found", node_name);
4899 return NULL;
4900 }
4901
4902 aio_context = bdrv_get_aio_context(to_replace_bs);
4903 aio_context_acquire(aio_context);
4904
4905 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4906 to_replace_bs = NULL;
4907 goto out;
4908 }
4909
4910
4911
4912
4913
4914
4915 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
4916 error_setg(errp, "Only top most non filter can be replaced");
4917 to_replace_bs = NULL;
4918 goto out;
4919 }
4920
4921out:
4922 aio_context_release(aio_context);
4923 return to_replace_bs;
4924}
4925
4926static bool append_open_options(QDict *d, BlockDriverState *bs)
4927{
4928 const QDictEntry *entry;
4929 QemuOptDesc *desc;
4930 BdrvChild *child;
4931 bool found_any = false;
4932 const char *p;
4933
4934 for (entry = qdict_first(bs->options); entry;
4935 entry = qdict_next(bs->options, entry))
4936 {
4937
4938 QLIST_FOREACH(child, &bs->children, next) {
4939 if (strstart(qdict_entry_key(entry), child->name, &p)
4940 && (!*p || *p == '.'))
4941 {
4942 break;
4943 }
4944 }
4945 if (child) {
4946 continue;
4947 }
4948
4949
4950 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
4951 if (!strcmp(qdict_entry_key(entry), desc->name)) {
4952 break;
4953 }
4954 }
4955 if (desc->name) {
4956 continue;
4957 }
4958
4959 qobject_incref(qdict_entry_value(entry));
4960 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4961 found_any = true;
4962 }
4963
4964 return found_any;
4965}
4966
4967
4968
4969
4970
4971
4972
4973
4974
4975
4976
4977
4978
4979void bdrv_refresh_filename(BlockDriverState *bs)
4980{
4981 BlockDriver *drv = bs->drv;
4982 QDict *opts;
4983
4984 if (!drv) {
4985 return;
4986 }
4987
4988
4989
4990 if (bs->file) {
4991 bdrv_refresh_filename(bs->file->bs);
4992 }
4993
4994 if (drv->bdrv_refresh_filename) {
4995
4996
4997 bs->exact_filename[0] = '\0';
4998 if (bs->full_open_options) {
4999 QDECREF(bs->full_open_options);
5000 bs->full_open_options = NULL;
5001 }
5002
5003 opts = qdict_new();
5004 append_open_options(opts, bs);
5005 drv->bdrv_refresh_filename(bs, opts);
5006 QDECREF(opts);
5007 } else if (bs->file) {
5008
5009 bool has_open_options;
5010
5011 bs->exact_filename[0] = '\0';
5012 if (bs->full_open_options) {
5013 QDECREF(bs->full_open_options);
5014 bs->full_open_options = NULL;
5015 }
5016
5017 opts = qdict_new();
5018 has_open_options = append_open_options(opts, bs);
5019
5020
5021
5022 if (bs->file->bs->exact_filename[0] && !has_open_options) {
5023 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
5024 }
5025
5026
5027
5028
5029
5030 if (bs->file->bs->full_open_options) {
5031 qdict_put_str(opts, "driver", drv->format_name);
5032 QINCREF(bs->file->bs->full_open_options);
5033 qdict_put(opts, "file", bs->file->bs->full_open_options);
5034
5035 bs->full_open_options = opts;
5036 } else {
5037 QDECREF(opts);
5038 }
5039 } else if (!bs->full_open_options && qdict_size(bs->options)) {
5040
5041
5042
5043
5044
5045
5046
5047 opts = qdict_new();
5048 append_open_options(opts, bs);
5049 qdict_put_str(opts, "driver", drv->format_name);
5050
5051 if (bs->exact_filename[0]) {
5052
5053
5054
5055
5056
5057
5058
5059 qdict_put_str(opts, "filename", bs->exact_filename);
5060 }
5061
5062 bs->full_open_options = opts;
5063 }
5064
5065 if (bs->exact_filename[0]) {
5066 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
5067 } else if (bs->full_open_options) {
5068 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
5069 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
5070 qstring_get_str(json));
5071 QDECREF(json);
5072 }
5073}
5074
5075
5076
5077
5078
5079void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
5080 Error **errp)
5081{
5082
5083 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
5084 error_setg(errp, "The node %s does not support adding a child",
5085 bdrv_get_device_or_node_name(parent_bs));
5086 return;
5087 }
5088
5089 if (!QLIST_EMPTY(&child_bs->parents)) {
5090 error_setg(errp, "The node %s already has a parent",
5091 child_bs->node_name);
5092 return;
5093 }
5094
5095 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
5096}
5097
5098void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
5099{
5100 BdrvChild *tmp;
5101
5102 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
5103 error_setg(errp, "The node %s does not support removing a child",
5104 bdrv_get_device_or_node_name(parent_bs));
5105 return;
5106 }
5107
5108 QLIST_FOREACH(tmp, &parent_bs->children, next) {
5109 if (tmp == child) {
5110 break;
5111 }
5112 }
5113
5114 if (!tmp) {
5115 error_setg(errp, "The node %s does not have a child named %s",
5116 bdrv_get_device_or_node_name(parent_bs),
5117 bdrv_get_device_or_node_name(child->bs));
5118 return;
5119 }
5120
5121 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
5122}
5123
5124bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
5125 uint32_t granularity, Error **errp)
5126{
5127 BlockDriver *drv = bs->drv;
5128
5129 if (!drv) {
5130 error_setg_errno(errp, ENOMEDIUM,
5131 "Can't store persistent bitmaps to %s",
5132 bdrv_get_device_or_node_name(bs));
5133 return false;
5134 }
5135
5136 if (!drv->bdrv_can_store_new_dirty_bitmap) {
5137 error_setg_errno(errp, ENOTSUP,
5138 "Can't store persistent bitmaps to %s",
5139 bdrv_get_device_or_node_name(bs));
5140 return false;
5141 }
5142
5143 return drv->bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp);
5144}
5145