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