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