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
3991
3992 bdrv_ref(from);
3993
3994 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
3995 bdrv_drained_begin(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_drained_end(from);
4038 bdrv_unref(from);
4039}
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
4058 Error **errp)
4059{
4060 Error *local_err = NULL;
4061
4062 bdrv_set_backing_hd(bs_new, bs_top, &local_err);
4063 if (local_err) {
4064 error_propagate(errp, local_err);
4065 goto out;
4066 }
4067
4068 bdrv_replace_node(bs_top, bs_new, &local_err);
4069 if (local_err) {
4070 error_propagate(errp, local_err);
4071 bdrv_set_backing_hd(bs_new, NULL, &error_abort);
4072 goto out;
4073 }
4074
4075
4076
4077out:
4078 bdrv_unref(bs_new);
4079}
4080
4081static void bdrv_delete(BlockDriverState *bs)
4082{
4083 assert(!bs->job);
4084 assert(bdrv_op_blocker_is_empty(bs));
4085 assert(!bs->refcnt);
4086
4087 bdrv_close(bs);
4088
4089
4090 if (bs->node_name[0] != '\0') {
4091 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
4092 }
4093 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
4094
4095 g_free(bs);
4096}
4097
4098
4099
4100
4101
4102
4103
4104
4105static int coroutine_fn bdrv_co_check(BlockDriverState *bs,
4106 BdrvCheckResult *res, BdrvCheckMode fix)
4107{
4108 if (bs->drv == NULL) {
4109 return -ENOMEDIUM;
4110 }
4111 if (bs->drv->bdrv_co_check == NULL) {
4112 return -ENOTSUP;
4113 }
4114
4115 memset(res, 0, sizeof(*res));
4116 return bs->drv->bdrv_co_check(bs, res, fix);
4117}
4118
4119typedef struct CheckCo {
4120 BlockDriverState *bs;
4121 BdrvCheckResult *res;
4122 BdrvCheckMode fix;
4123 int ret;
4124} CheckCo;
4125
4126static void bdrv_check_co_entry(void *opaque)
4127{
4128 CheckCo *cco = opaque;
4129 cco->ret = bdrv_co_check(cco->bs, cco->res, cco->fix);
4130 aio_wait_kick();
4131}
4132
4133int bdrv_check(BlockDriverState *bs,
4134 BdrvCheckResult *res, BdrvCheckMode fix)
4135{
4136 Coroutine *co;
4137 CheckCo cco = {
4138 .bs = bs,
4139 .res = res,
4140 .ret = -EINPROGRESS,
4141 .fix = fix,
4142 };
4143
4144 if (qemu_in_coroutine()) {
4145
4146 bdrv_check_co_entry(&cco);
4147 } else {
4148 co = qemu_coroutine_create(bdrv_check_co_entry, &cco);
4149 bdrv_coroutine_enter(bs, co);
4150 BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS);
4151 }
4152
4153 return cco.ret;
4154}
4155
4156
4157
4158
4159
4160
4161
4162
4163
4164int bdrv_change_backing_file(BlockDriverState *bs,
4165 const char *backing_file, const char *backing_fmt)
4166{
4167 BlockDriver *drv = bs->drv;
4168 int ret;
4169
4170 if (!drv) {
4171 return -ENOMEDIUM;
4172 }
4173
4174
4175 if (backing_fmt && !backing_file) {
4176 return -EINVAL;
4177 }
4178
4179 if (drv->bdrv_change_backing_file != NULL) {
4180 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
4181 } else {
4182 ret = -ENOTSUP;
4183 }
4184
4185 if (ret == 0) {
4186 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
4187 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
4188 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
4189 backing_file ?: "");
4190 }
4191 return ret;
4192}
4193
4194
4195
4196
4197
4198
4199
4200
4201
4202
4203
4204BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
4205 BlockDriverState *bs)
4206{
4207 while (active && bs != backing_bs(active)) {
4208 active = backing_bs(active);
4209 }
4210
4211 return active;
4212}
4213
4214
4215BlockDriverState *bdrv_find_base(BlockDriverState *bs)
4216{
4217 return bdrv_find_overlay(bs, NULL);
4218}
4219
4220
4221
4222
4223
4224
4225bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
4226 Error **errp)
4227{
4228 BlockDriverState *i;
4229
4230 for (i = bs; i != base; i = backing_bs(i)) {
4231 if (i->backing && i->backing->frozen) {
4232 error_setg(errp, "Cannot change '%s' link from '%s' to '%s'",
4233 i->backing->name, i->node_name,
4234 backing_bs(i)->node_name);
4235 return true;
4236 }
4237 }
4238
4239 return false;
4240}
4241
4242
4243
4244
4245
4246
4247
4248
4249int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
4250 Error **errp)
4251{
4252 BlockDriverState *i;
4253
4254 if (bdrv_is_backing_chain_frozen(bs, base, errp)) {
4255 return -EPERM;
4256 }
4257
4258 for (i = bs; i != base; i = backing_bs(i)) {
4259 if (i->backing) {
4260 i->backing->frozen = true;
4261 }
4262 }
4263
4264 return 0;
4265}
4266
4267
4268
4269
4270
4271
4272void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base)
4273{
4274 BlockDriverState *i;
4275
4276 for (i = bs; i != base; i = backing_bs(i)) {
4277 if (i->backing) {
4278 assert(i->backing->frozen);
4279 i->backing->frozen = false;
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
4312
4313int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
4314 const char *backing_file_str)
4315{
4316 BlockDriverState *explicit_top = top;
4317 bool update_inherits_from;
4318 BdrvChild *c, *next;
4319 Error *local_err = NULL;
4320 int ret = -EIO;
4321
4322 bdrv_ref(top);
4323
4324 if (!top->drv || !base->drv) {
4325 goto exit;
4326 }
4327
4328
4329 if (!bdrv_chain_contains(top, base)) {
4330 goto exit;
4331 }
4332
4333
4334
4335 QLIST_FOREACH(c, &top->parents, next_parent) {
4336 if (c->frozen) {
4337 goto exit;
4338 }
4339 }
4340
4341
4342
4343
4344
4345
4346 while (explicit_top && explicit_top->implicit) {
4347 explicit_top = backing_bs(explicit_top);
4348 }
4349 update_inherits_from = bdrv_inherits_from_recursive(base, explicit_top);
4350
4351
4352
4353
4354 if (!backing_file_str) {
4355 bdrv_refresh_filename(base);
4356 backing_file_str = base->filename;
4357 }
4358
4359 QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) {
4360
4361 GSList *ignore_children = g_slist_prepend(NULL, c);
4362 ret = bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm,
4363 ignore_children, &local_err);
4364 g_slist_free(ignore_children);
4365 if (ret < 0) {
4366 error_report_err(local_err);
4367 goto exit;
4368 }
4369
4370
4371 if (c->role->update_filename) {
4372 ret = c->role->update_filename(c, base, backing_file_str,
4373 &local_err);
4374 if (ret < 0) {
4375 bdrv_abort_perm_update(base);
4376 error_report_err(local_err);
4377 goto exit;
4378 }
4379 }
4380
4381
4382
4383 bdrv_ref(base);
4384 bdrv_replace_child(c, base);
4385 bdrv_unref(top);
4386 }
4387
4388 if (update_inherits_from) {
4389 base->inherits_from = explicit_top->inherits_from;
4390 }
4391
4392 ret = 0;
4393exit:
4394 bdrv_unref(top);
4395 return ret;
4396}
4397
4398
4399
4400
4401
4402int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
4403{
4404 BlockDriver *drv = bs->drv;
4405 if (!drv) {
4406 return -ENOMEDIUM;
4407 }
4408 if (drv->bdrv_get_allocated_file_size) {
4409 return drv->bdrv_get_allocated_file_size(bs);
4410 }
4411 if (bs->file) {
4412 return bdrv_get_allocated_file_size(bs->file->bs);
4413 }
4414 return -ENOTSUP;
4415}
4416
4417
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430
4431
4432
4433
4434
4435
4436
4437
4438
4439
4440BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
4441 BlockDriverState *in_bs, Error **errp)
4442{
4443 if (!drv->bdrv_measure) {
4444 error_setg(errp, "Block driver '%s' does not support size measurement",
4445 drv->format_name);
4446 return NULL;
4447 }
4448
4449 return drv->bdrv_measure(opts, in_bs, errp);
4450}
4451
4452
4453
4454
4455int64_t bdrv_nb_sectors(BlockDriverState *bs)
4456{
4457 BlockDriver *drv = bs->drv;
4458
4459 if (!drv)
4460 return -ENOMEDIUM;
4461
4462 if (drv->has_variable_length) {
4463 int ret = refresh_total_sectors(bs, bs->total_sectors);
4464 if (ret < 0) {
4465 return ret;
4466 }
4467 }
4468 return bs->total_sectors;
4469}
4470
4471
4472
4473
4474
4475int64_t bdrv_getlength(BlockDriverState *bs)
4476{
4477 int64_t ret = bdrv_nb_sectors(bs);
4478
4479 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
4480 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
4481}
4482
4483
4484void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
4485{
4486 int64_t nb_sectors = bdrv_nb_sectors(bs);
4487
4488 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
4489}
4490
4491bool bdrv_is_sg(BlockDriverState *bs)
4492{
4493 return bs->sg;
4494}
4495
4496bool bdrv_is_encrypted(BlockDriverState *bs)
4497{
4498 if (bs->backing && bs->backing->bs->encrypted) {
4499 return true;
4500 }
4501 return bs->encrypted;
4502}
4503
4504const char *bdrv_get_format_name(BlockDriverState *bs)
4505{
4506 return bs->drv ? bs->drv->format_name : NULL;
4507}
4508
4509static int qsort_strcmp(const void *a, const void *b)
4510{
4511 return strcmp(*(char *const *)a, *(char *const *)b);
4512}
4513
4514void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
4515 void *opaque, bool read_only)
4516{
4517 BlockDriver *drv;
4518 int count = 0;
4519 int i;
4520 const char **formats = NULL;
4521
4522 QLIST_FOREACH(drv, &bdrv_drivers, list) {
4523 if (drv->format_name) {
4524 bool found = false;
4525 int i = count;
4526
4527 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, read_only)) {
4528 continue;
4529 }
4530
4531 while (formats && i && !found) {
4532 found = !strcmp(formats[--i], drv->format_name);
4533 }
4534
4535 if (!found) {
4536 formats = g_renew(const char *, formats, count + 1);
4537 formats[count++] = drv->format_name;
4538 }
4539 }
4540 }
4541
4542 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
4543 const char *format_name = block_driver_modules[i].format_name;
4544
4545 if (format_name) {
4546 bool found = false;
4547 int j = count;
4548
4549 if (use_bdrv_whitelist &&
4550 !bdrv_format_is_whitelisted(format_name, read_only)) {
4551 continue;
4552 }
4553
4554 while (formats && j && !found) {
4555 found = !strcmp(formats[--j], format_name);
4556 }
4557
4558 if (!found) {
4559 formats = g_renew(const char *, formats, count + 1);
4560 formats[count++] = format_name;
4561 }
4562 }
4563 }
4564
4565 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
4566
4567 for (i = 0; i < count; i++) {
4568 it(opaque, formats[i]);
4569 }
4570
4571 g_free(formats);
4572}
4573
4574
4575BlockDriverState *bdrv_find_node(const char *node_name)
4576{
4577 BlockDriverState *bs;
4578
4579 assert(node_name);
4580
4581 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
4582 if (!strcmp(node_name, bs->node_name)) {
4583 return bs;
4584 }
4585 }
4586 return NULL;
4587}
4588
4589
4590BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
4591{
4592 BlockDeviceInfoList *list, *entry;
4593 BlockDriverState *bs;
4594
4595 list = NULL;
4596 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
4597 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
4598 if (!info) {
4599 qapi_free_BlockDeviceInfoList(list);
4600 return NULL;
4601 }
4602 entry = g_malloc0(sizeof(*entry));
4603 entry->value = info;
4604 entry->next = list;
4605 list = entry;
4606 }
4607
4608 return list;
4609}
4610
4611#define QAPI_LIST_ADD(list, element) do { \
4612 typeof(list) _tmp = g_new(typeof(*(list)), 1); \
4613 _tmp->value = (element); \
4614 _tmp->next = (list); \
4615 (list) = _tmp; \
4616} while (0)
4617
4618typedef struct XDbgBlockGraphConstructor {
4619 XDbgBlockGraph *graph;
4620 GHashTable *graph_nodes;
4621} XDbgBlockGraphConstructor;
4622
4623static XDbgBlockGraphConstructor *xdbg_graph_new(void)
4624{
4625 XDbgBlockGraphConstructor *gr = g_new(XDbgBlockGraphConstructor, 1);
4626
4627 gr->graph = g_new0(XDbgBlockGraph, 1);
4628 gr->graph_nodes = g_hash_table_new(NULL, NULL);
4629
4630 return gr;
4631}
4632
4633static XDbgBlockGraph *xdbg_graph_finalize(XDbgBlockGraphConstructor *gr)
4634{
4635 XDbgBlockGraph *graph = gr->graph;
4636
4637 g_hash_table_destroy(gr->graph_nodes);
4638 g_free(gr);
4639
4640 return graph;
4641}
4642
4643static uintptr_t xdbg_graph_node_num(XDbgBlockGraphConstructor *gr, void *node)
4644{
4645 uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node);
4646
4647 if (ret != 0) {
4648 return ret;
4649 }
4650
4651
4652
4653
4654
4655 ret = g_hash_table_size(gr->graph_nodes) + 1;
4656 g_hash_table_insert(gr->graph_nodes, node, (void *)ret);
4657
4658 return ret;
4659}
4660
4661static void xdbg_graph_add_node(XDbgBlockGraphConstructor *gr, void *node,
4662 XDbgBlockGraphNodeType type, const char *name)
4663{
4664 XDbgBlockGraphNode *n;
4665
4666 n = g_new0(XDbgBlockGraphNode, 1);
4667
4668 n->id = xdbg_graph_node_num(gr, node);
4669 n->type = type;
4670 n->name = g_strdup(name);
4671
4672 QAPI_LIST_ADD(gr->graph->nodes, n);
4673}
4674
4675static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent,
4676 const BdrvChild *child)
4677{
4678 typedef struct {
4679 unsigned int flag;
4680 BlockPermission num;
4681 } PermissionMap;
4682
4683 static const PermissionMap permissions[] = {
4684 { BLK_PERM_CONSISTENT_READ, BLOCK_PERMISSION_CONSISTENT_READ },
4685 { BLK_PERM_WRITE, BLOCK_PERMISSION_WRITE },
4686 { BLK_PERM_WRITE_UNCHANGED, BLOCK_PERMISSION_WRITE_UNCHANGED },
4687 { BLK_PERM_RESIZE, BLOCK_PERMISSION_RESIZE },
4688 { BLK_PERM_GRAPH_MOD, BLOCK_PERMISSION_GRAPH_MOD },
4689 { 0, 0 }
4690 };
4691 const PermissionMap *p;
4692 XDbgBlockGraphEdge *edge;
4693
4694 QEMU_BUILD_BUG_ON(1UL << (ARRAY_SIZE(permissions) - 1) != BLK_PERM_ALL + 1);
4695
4696 edge = g_new0(XDbgBlockGraphEdge, 1);
4697
4698 edge->parent = xdbg_graph_node_num(gr, parent);
4699 edge->child = xdbg_graph_node_num(gr, child->bs);
4700 edge->name = g_strdup(child->name);
4701
4702 for (p = permissions; p->flag; p++) {
4703 if (p->flag & child->perm) {
4704 QAPI_LIST_ADD(edge->perm, p->num);
4705 }
4706 if (p->flag & child->shared_perm) {
4707 QAPI_LIST_ADD(edge->shared_perm, p->num);
4708 }
4709 }
4710
4711 QAPI_LIST_ADD(gr->graph->edges, edge);
4712}
4713
4714
4715XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp)
4716{
4717 BlockBackend *blk;
4718 BlockJob *job;
4719 BlockDriverState *bs;
4720 BdrvChild *child;
4721 XDbgBlockGraphConstructor *gr = xdbg_graph_new();
4722
4723 for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {
4724 char *allocated_name = NULL;
4725 const char *name = blk_name(blk);
4726
4727 if (!*name) {
4728 name = allocated_name = blk_get_attached_dev_id(blk);
4729 }
4730 xdbg_graph_add_node(gr, blk, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_BACKEND,
4731 name);
4732 g_free(allocated_name);
4733 if (blk_root(blk)) {
4734 xdbg_graph_add_edge(gr, blk, blk_root(blk));
4735 }
4736 }
4737
4738 for (job = block_job_next(NULL); job; job = block_job_next(job)) {
4739 GSList *el;
4740
4741 xdbg_graph_add_node(gr, job, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_JOB,
4742 job->job.id);
4743 for (el = job->nodes; el; el = el->next) {
4744 xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data);
4745 }
4746 }
4747
4748 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
4749 xdbg_graph_add_node(gr, bs, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_DRIVER,
4750 bs->node_name);
4751 QLIST_FOREACH(child, &bs->children, next) {
4752 xdbg_graph_add_edge(gr, bs, child);
4753 }
4754 }
4755
4756 return xdbg_graph_finalize(gr);
4757}
4758
4759BlockDriverState *bdrv_lookup_bs(const char *device,
4760 const char *node_name,
4761 Error **errp)
4762{
4763 BlockBackend *blk;
4764 BlockDriverState *bs;
4765
4766 if (device) {
4767 blk = blk_by_name(device);
4768
4769 if (blk) {
4770 bs = blk_bs(blk);
4771 if (!bs) {
4772 error_setg(errp, "Device '%s' has no medium", device);
4773 }
4774
4775 return bs;
4776 }
4777 }
4778
4779 if (node_name) {
4780 bs = bdrv_find_node(node_name);
4781
4782 if (bs) {
4783 return bs;
4784 }
4785 }
4786
4787 error_setg(errp, "Cannot find device=%s nor node_name=%s",
4788 device ? device : "",
4789 node_name ? node_name : "");
4790 return NULL;
4791}
4792
4793
4794
4795bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
4796{
4797 while (top && top != base) {
4798 top = backing_bs(top);
4799 }
4800
4801 return top != NULL;
4802}
4803
4804BlockDriverState *bdrv_next_node(BlockDriverState *bs)
4805{
4806 if (!bs) {
4807 return QTAILQ_FIRST(&graph_bdrv_states);
4808 }
4809 return QTAILQ_NEXT(bs, node_list);
4810}
4811
4812BlockDriverState *bdrv_next_all_states(BlockDriverState *bs)
4813{
4814 if (!bs) {
4815 return QTAILQ_FIRST(&all_bdrv_states);
4816 }
4817 return QTAILQ_NEXT(bs, bs_list);
4818}
4819
4820const char *bdrv_get_node_name(const BlockDriverState *bs)
4821{
4822 return bs->node_name;
4823}
4824
4825const char *bdrv_get_parent_name(const BlockDriverState *bs)
4826{
4827 BdrvChild *c;
4828 const char *name;
4829
4830
4831 QLIST_FOREACH(c, &bs->parents, next_parent) {
4832 if (c->role->get_name) {
4833 name = c->role->get_name(c);
4834 if (name && *name) {
4835 return name;
4836 }
4837 }
4838 }
4839
4840 return NULL;
4841}
4842
4843
4844const char *bdrv_get_device_name(const BlockDriverState *bs)
4845{
4846 return bdrv_get_parent_name(bs) ?: "";
4847}
4848
4849
4850
4851
4852
4853const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
4854{
4855 return bdrv_get_parent_name(bs) ?: bs->node_name;
4856}
4857
4858int bdrv_get_flags(BlockDriverState *bs)
4859{
4860 return bs->open_flags;
4861}
4862
4863int bdrv_has_zero_init_1(BlockDriverState *bs)
4864{
4865 return 1;
4866}
4867
4868int bdrv_has_zero_init(BlockDriverState *bs)
4869{
4870 if (!bs->drv) {
4871 return 0;
4872 }
4873
4874
4875
4876 if (bs->backing) {
4877 return 0;
4878 }
4879 if (bs->drv->bdrv_has_zero_init) {
4880 return bs->drv->bdrv_has_zero_init(bs);
4881 }
4882 if (bs->file && bs->drv->is_filter) {
4883 return bdrv_has_zero_init(bs->file->bs);
4884 }
4885
4886
4887 return 0;
4888}
4889
4890bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
4891{
4892 BlockDriverInfo bdi;
4893
4894 if (bs->backing) {
4895 return false;
4896 }
4897
4898 if (bdrv_get_info(bs, &bdi) == 0) {
4899 return bdi.unallocated_blocks_are_zero;
4900 }
4901
4902 return false;
4903}
4904
4905bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
4906{
4907 if (!(bs->open_flags & BDRV_O_UNMAP)) {
4908 return false;
4909 }
4910
4911 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP;
4912}
4913
4914void bdrv_get_backing_filename(BlockDriverState *bs,
4915 char *filename, int filename_size)
4916{
4917 pstrcpy(filename, filename_size, bs->backing_file);
4918}
4919
4920int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4921{
4922 BlockDriver *drv = bs->drv;
4923
4924 if (!drv) {
4925 return -ENOMEDIUM;
4926 }
4927 if (!drv->bdrv_get_info) {
4928 if (bs->file && drv->is_filter) {
4929 return bdrv_get_info(bs->file->bs, bdi);
4930 }
4931 return -ENOTSUP;
4932 }
4933 memset(bdi, 0, sizeof(*bdi));
4934 return drv->bdrv_get_info(bs, bdi);
4935}
4936
4937ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs,
4938 Error **errp)
4939{
4940 BlockDriver *drv = bs->drv;
4941 if (drv && drv->bdrv_get_specific_info) {
4942 return drv->bdrv_get_specific_info(bs, errp);
4943 }
4944 return NULL;
4945}
4946
4947void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
4948{
4949 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4950 return;
4951 }
4952
4953 bs->drv->bdrv_debug_event(bs, event);
4954}
4955
4956int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4957 const char *tag)
4958{
4959 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4960 bs = bs->file ? bs->file->bs : NULL;
4961 }
4962
4963 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4964 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4965 }
4966
4967 return -ENOTSUP;
4968}
4969
4970int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4971{
4972 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4973 bs = bs->file ? bs->file->bs : NULL;
4974 }
4975
4976 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4977 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4978 }
4979
4980 return -ENOTSUP;
4981}
4982
4983int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4984{
4985 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4986 bs = bs->file ? bs->file->bs : NULL;
4987 }
4988
4989 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4990 return bs->drv->bdrv_debug_resume(bs, tag);
4991 }
4992
4993 return -ENOTSUP;
4994}
4995
4996bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4997{
4998 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4999 bs = bs->file ? bs->file->bs : NULL;
5000 }
5001
5002 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
5003 return bs->drv->bdrv_debug_is_suspended(bs, tag);
5004 }
5005
5006 return false;
5007}
5008
5009
5010
5011
5012
5013BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
5014 const char *backing_file)
5015{
5016 char *filename_full = NULL;
5017 char *backing_file_full = NULL;
5018 char *filename_tmp = NULL;
5019 int is_protocol = 0;
5020 BlockDriverState *curr_bs = NULL;
5021 BlockDriverState *retval = NULL;
5022
5023 if (!bs || !bs->drv || !backing_file) {
5024 return NULL;
5025 }
5026
5027 filename_full = g_malloc(PATH_MAX);
5028 backing_file_full = g_malloc(PATH_MAX);
5029
5030 is_protocol = path_has_protocol(backing_file);
5031
5032 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
5033
5034
5035
5036 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
5037 char *backing_file_full_ret;
5038
5039 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
5040 retval = curr_bs->backing->bs;
5041 break;
5042 }
5043
5044 backing_file_full_ret = bdrv_get_full_backing_filename(curr_bs,
5045 NULL);
5046 if (backing_file_full_ret) {
5047 bool equal = strcmp(backing_file, backing_file_full_ret) == 0;
5048 g_free(backing_file_full_ret);
5049 if (equal) {
5050 retval = curr_bs->backing->bs;
5051 break;
5052 }
5053 }
5054 } else {
5055
5056
5057 filename_tmp = bdrv_make_absolute_filename(curr_bs, backing_file,
5058 NULL);
5059
5060 if (!filename_tmp || !realpath(filename_tmp, filename_full)) {
5061 g_free(filename_tmp);
5062 continue;
5063 }
5064 g_free(filename_tmp);
5065
5066
5067
5068 filename_tmp = bdrv_get_full_backing_filename(curr_bs, NULL);
5069 if (!filename_tmp || !realpath(filename_tmp, backing_file_full)) {
5070 g_free(filename_tmp);
5071 continue;
5072 }
5073 g_free(filename_tmp);
5074
5075 if (strcmp(backing_file_full, filename_full) == 0) {
5076 retval = curr_bs->backing->bs;
5077 break;
5078 }
5079 }
5080 }
5081
5082 g_free(filename_full);
5083 g_free(backing_file_full);
5084 return retval;
5085}
5086
5087void bdrv_init(void)
5088{
5089 module_call_init(MODULE_INIT_BLOCK);
5090}
5091
5092void bdrv_init_with_whitelist(void)
5093{
5094 use_bdrv_whitelist = 1;
5095 bdrv_init();
5096}
5097
5098static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
5099 Error **errp)
5100{
5101 BdrvChild *child, *parent;
5102 uint64_t perm, shared_perm;
5103 Error *local_err = NULL;
5104 int ret;
5105 BdrvDirtyBitmap *bm;
5106
5107 if (!bs->drv) {
5108 return;
5109 }
5110
5111 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
5112 return;
5113 }
5114
5115 QLIST_FOREACH(child, &bs->children, next) {
5116 bdrv_co_invalidate_cache(child->bs, &local_err);
5117 if (local_err) {
5118 error_propagate(errp, local_err);
5119 return;
5120 }
5121 }
5122
5123
5124
5125
5126
5127
5128
5129
5130
5131
5132
5133
5134
5135
5136 bs->open_flags &= ~BDRV_O_INACTIVE;
5137 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
5138 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err);
5139 if (ret < 0) {
5140 bs->open_flags |= BDRV_O_INACTIVE;
5141 error_propagate(errp, local_err);
5142 return;
5143 }
5144 bdrv_set_perm(bs, perm, shared_perm);
5145
5146 if (bs->drv->bdrv_co_invalidate_cache) {
5147 bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
5148 if (local_err) {
5149 bs->open_flags |= BDRV_O_INACTIVE;
5150 error_propagate(errp, local_err);
5151 return;
5152 }
5153 }
5154
5155 for (bm = bdrv_dirty_bitmap_next(bs, NULL); bm;
5156 bm = bdrv_dirty_bitmap_next(bs, bm))
5157 {
5158 bdrv_dirty_bitmap_set_migration(bm, false);
5159 }
5160
5161 ret = refresh_total_sectors(bs, bs->total_sectors);
5162 if (ret < 0) {
5163 bs->open_flags |= BDRV_O_INACTIVE;
5164 error_setg_errno(errp, -ret, "Could not refresh total sector count");
5165 return;
5166 }
5167
5168 QLIST_FOREACH(parent, &bs->parents, next_parent) {
5169 if (parent->role->activate) {
5170 parent->role->activate(parent, &local_err);
5171 if (local_err) {
5172 bs->open_flags |= BDRV_O_INACTIVE;
5173 error_propagate(errp, local_err);
5174 return;
5175 }
5176 }
5177 }
5178}
5179
5180typedef struct InvalidateCacheCo {
5181 BlockDriverState *bs;
5182 Error **errp;
5183 bool done;
5184} InvalidateCacheCo;
5185
5186static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque)
5187{
5188 InvalidateCacheCo *ico = opaque;
5189 bdrv_co_invalidate_cache(ico->bs, ico->errp);
5190 ico->done = true;
5191 aio_wait_kick();
5192}
5193
5194void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
5195{
5196 Coroutine *co;
5197 InvalidateCacheCo ico = {
5198 .bs = bs,
5199 .done = false,
5200 .errp = errp
5201 };
5202
5203 if (qemu_in_coroutine()) {
5204
5205 bdrv_invalidate_cache_co_entry(&ico);
5206 } else {
5207 co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico);
5208 bdrv_coroutine_enter(bs, co);
5209 BDRV_POLL_WHILE(bs, !ico.done);
5210 }
5211}
5212
5213void bdrv_invalidate_cache_all(Error **errp)
5214{
5215 BlockDriverState *bs;
5216 Error *local_err = NULL;
5217 BdrvNextIterator it;
5218
5219 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
5220 AioContext *aio_context = bdrv_get_aio_context(bs);
5221
5222 aio_context_acquire(aio_context);
5223 bdrv_invalidate_cache(bs, &local_err);
5224 aio_context_release(aio_context);
5225 if (local_err) {
5226 error_propagate(errp, local_err);
5227 bdrv_next_cleanup(&it);
5228 return;
5229 }
5230 }
5231}
5232
5233static bool bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
5234{
5235 BdrvChild *parent;
5236
5237 QLIST_FOREACH(parent, &bs->parents, next_parent) {
5238 if (parent->role->parent_is_bds) {
5239 BlockDriverState *parent_bs = parent->opaque;
5240 if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) {
5241 return true;
5242 }
5243 }
5244 }
5245
5246 return false;
5247}
5248
5249static int bdrv_inactivate_recurse(BlockDriverState *bs)
5250{
5251 BdrvChild *child, *parent;
5252 uint64_t perm, shared_perm;
5253 int ret;
5254
5255 if (!bs->drv) {
5256 return -ENOMEDIUM;
5257 }
5258
5259
5260
5261 if (bdrv_has_bds_parent(bs, true)) {
5262 return 0;
5263 }
5264
5265 assert(!(bs->open_flags & BDRV_O_INACTIVE));
5266
5267
5268 if (bs->drv->bdrv_inactivate) {
5269 ret = bs->drv->bdrv_inactivate(bs);
5270 if (ret < 0) {
5271 return ret;
5272 }
5273 }
5274
5275 QLIST_FOREACH(parent, &bs->parents, next_parent) {
5276 if (parent->role->inactivate) {
5277 ret = parent->role->inactivate(parent);
5278 if (ret < 0) {
5279 return ret;
5280 }
5281 }
5282 }
5283
5284 bs->open_flags |= BDRV_O_INACTIVE;
5285
5286
5287 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
5288 bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &error_abort);
5289 bdrv_set_perm(bs, perm, shared_perm);
5290
5291
5292
5293 QLIST_FOREACH(child, &bs->children, next) {
5294 ret = bdrv_inactivate_recurse(child->bs);
5295 if (ret < 0) {
5296 return ret;
5297 }
5298 }
5299
5300 return 0;
5301}
5302
5303int bdrv_inactivate_all(void)
5304{
5305 BlockDriverState *bs = NULL;
5306 BdrvNextIterator it;
5307 int ret = 0;
5308 GSList *aio_ctxs = NULL, *ctx;
5309
5310 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
5311 AioContext *aio_context = bdrv_get_aio_context(bs);
5312
5313 if (!g_slist_find(aio_ctxs, aio_context)) {
5314 aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
5315 aio_context_acquire(aio_context);
5316 }
5317 }
5318
5319 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
5320
5321
5322
5323 if (bdrv_has_bds_parent(bs, false)) {
5324 continue;
5325 }
5326 ret = bdrv_inactivate_recurse(bs);
5327 if (ret < 0) {
5328 bdrv_next_cleanup(&it);
5329 goto out;
5330 }
5331 }
5332
5333out:
5334 for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
5335 AioContext *aio_context = ctx->data;
5336 aio_context_release(aio_context);
5337 }
5338 g_slist_free(aio_ctxs);
5339
5340 return ret;
5341}
5342
5343
5344
5345
5346
5347
5348
5349bool bdrv_is_inserted(BlockDriverState *bs)
5350{
5351 BlockDriver *drv = bs->drv;
5352 BdrvChild *child;
5353
5354 if (!drv) {
5355 return false;
5356 }
5357 if (drv->bdrv_is_inserted) {
5358 return drv->bdrv_is_inserted(bs);
5359 }
5360 QLIST_FOREACH(child, &bs->children, next) {
5361 if (!bdrv_is_inserted(child->bs)) {
5362 return false;
5363 }
5364 }
5365 return true;
5366}
5367
5368
5369
5370
5371void bdrv_eject(BlockDriverState *bs, bool eject_flag)
5372{
5373 BlockDriver *drv = bs->drv;
5374
5375 if (drv && drv->bdrv_eject) {
5376 drv->bdrv_eject(bs, eject_flag);
5377 }
5378}
5379
5380
5381
5382
5383
5384void bdrv_lock_medium(BlockDriverState *bs, bool locked)
5385{
5386 BlockDriver *drv = bs->drv;
5387
5388 trace_bdrv_lock_medium(bs, locked);
5389
5390 if (drv && drv->bdrv_lock_medium) {
5391 drv->bdrv_lock_medium(bs, locked);
5392 }
5393}
5394
5395
5396void bdrv_ref(BlockDriverState *bs)
5397{
5398 bs->refcnt++;
5399}
5400
5401
5402
5403
5404void bdrv_unref(BlockDriverState *bs)
5405{
5406 if (!bs) {
5407 return;
5408 }
5409 assert(bs->refcnt > 0);
5410 if (--bs->refcnt == 0) {
5411 bdrv_delete(bs);
5412 }
5413}
5414
5415struct BdrvOpBlocker {
5416 Error *reason;
5417 QLIST_ENTRY(BdrvOpBlocker) list;
5418};
5419
5420bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5421{
5422 BdrvOpBlocker *blocker;
5423 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5424 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5425 blocker = QLIST_FIRST(&bs->op_blockers[op]);
5426 error_propagate_prepend(errp, error_copy(blocker->reason),
5427 "Node '%s' is busy: ",
5428 bdrv_get_device_or_node_name(bs));
5429 return true;
5430 }
5431 return false;
5432}
5433
5434void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5435{
5436 BdrvOpBlocker *blocker;
5437 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5438
5439 blocker = g_new0(BdrvOpBlocker, 1);
5440 blocker->reason = reason;
5441 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5442}
5443
5444void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5445{
5446 BdrvOpBlocker *blocker, *next;
5447 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5448 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5449 if (blocker->reason == reason) {
5450 QLIST_REMOVE(blocker, list);
5451 g_free(blocker);
5452 }
5453 }
5454}
5455
5456void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5457{
5458 int i;
5459 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5460 bdrv_op_block(bs, i, reason);
5461 }
5462}
5463
5464void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5465{
5466 int i;
5467 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5468 bdrv_op_unblock(bs, i, reason);
5469 }
5470}
5471
5472bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5473{
5474 int i;
5475
5476 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5477 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5478 return false;
5479 }
5480 }
5481 return true;
5482}
5483
5484void bdrv_img_create(const char *filename, const char *fmt,
5485 const char *base_filename, const char *base_fmt,
5486 char *options, uint64_t img_size, int flags, bool quiet,
5487 Error **errp)
5488{
5489 QemuOptsList *create_opts = NULL;
5490 QemuOpts *opts = NULL;
5491 const char *backing_fmt, *backing_file;
5492 int64_t size;
5493 BlockDriver *drv, *proto_drv;
5494 Error *local_err = NULL;
5495 int ret = 0;
5496
5497
5498 drv = bdrv_find_format(fmt);
5499 if (!drv) {
5500 error_setg(errp, "Unknown file format '%s'", fmt);
5501 return;
5502 }
5503
5504 proto_drv = bdrv_find_protocol(filename, true, errp);
5505 if (!proto_drv) {
5506 return;
5507 }
5508
5509 if (!drv->create_opts) {
5510 error_setg(errp, "Format driver '%s' does not support image creation",
5511 drv->format_name);
5512 return;
5513 }
5514
5515 if (!proto_drv->create_opts) {
5516 error_setg(errp, "Protocol driver '%s' does not support image creation",
5517 proto_drv->format_name);
5518 return;
5519 }
5520
5521 create_opts = qemu_opts_append(create_opts, drv->create_opts);
5522 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
5523
5524
5525 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5526 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
5527
5528
5529 if (options) {
5530 qemu_opts_do_parse(opts, options, NULL, &local_err);
5531 if (local_err) {
5532 goto out;
5533 }
5534 }
5535
5536 if (base_filename) {
5537 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
5538 if (local_err) {
5539 error_setg(errp, "Backing file not supported for file format '%s'",
5540 fmt);
5541 goto out;
5542 }
5543 }
5544
5545 if (base_fmt) {
5546 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
5547 if (local_err) {
5548 error_setg(errp, "Backing file format not supported for file "
5549 "format '%s'", fmt);
5550 goto out;
5551 }
5552 }
5553
5554 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5555 if (backing_file) {
5556 if (!strcmp(filename, backing_file)) {
5557 error_setg(errp, "Error: Trying to create an image with the "
5558 "same filename as the backing file");
5559 goto out;
5560 }
5561 }
5562
5563 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5564
5565
5566
5567 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
5568 if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
5569 BlockDriverState *bs;
5570 char *full_backing;
5571 int back_flags;
5572 QDict *backing_options = NULL;
5573
5574 full_backing =
5575 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
5576 &local_err);
5577 if (local_err) {
5578 goto out;
5579 }
5580 assert(full_backing);
5581
5582
5583 back_flags = flags;
5584 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
5585
5586 backing_options = qdict_new();
5587 if (backing_fmt) {
5588 qdict_put_str(backing_options, "driver", backing_fmt);
5589 }
5590 qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
5591
5592 bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
5593 &local_err);
5594 g_free(full_backing);
5595 if (!bs && size != -1) {
5596
5597 warn_reportf_err(local_err,
5598 "Could not verify backing image. "
5599 "This may become an error in future versions.\n");
5600 local_err = NULL;
5601 } else if (!bs) {
5602
5603 error_append_hint(&local_err,
5604 "Could not open backing image to determine size.\n");
5605 goto out;
5606 } else {
5607 if (size == -1) {
5608
5609 size = bdrv_getlength(bs);
5610 if (size < 0) {
5611 error_setg_errno(errp, -size, "Could not get size of '%s'",
5612 backing_file);
5613 bdrv_unref(bs);
5614 goto out;
5615 }
5616 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
5617 }
5618 bdrv_unref(bs);
5619 }
5620 }
5621
5622 if (size == -1) {
5623 error_setg(errp, "Image creation needs a size parameter");
5624 goto out;
5625 }
5626
5627 if (!quiet) {
5628 printf("Formatting '%s', fmt=%s ", filename, fmt);
5629 qemu_opts_print(opts, " ");
5630 puts("");
5631 }
5632
5633 ret = bdrv_create(drv, filename, opts, &local_err);
5634
5635 if (ret == -EFBIG) {
5636
5637
5638
5639 const char *cluster_size_hint = "";
5640 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
5641 cluster_size_hint = " (try using a larger cluster size)";
5642 }
5643 error_setg(errp, "The image size is too large for file format '%s'"
5644 "%s", fmt, cluster_size_hint);
5645 error_free(local_err);
5646 local_err = NULL;
5647 }
5648
5649out:
5650 qemu_opts_del(opts);
5651 qemu_opts_free(create_opts);
5652 error_propagate(errp, local_err);
5653}
5654
5655AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5656{
5657 return bs ? bs->aio_context : qemu_get_aio_context();
5658}
5659
5660void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)
5661{
5662 aio_co_enter(bdrv_get_aio_context(bs), co);
5663}
5664
5665static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
5666{
5667 QLIST_REMOVE(ban, list);
5668 g_free(ban);
5669}
5670
5671void bdrv_detach_aio_context(BlockDriverState *bs)
5672{
5673 BdrvAioNotifier *baf, *baf_tmp;
5674 BdrvChild *child;
5675
5676 assert(!bs->walking_aio_notifiers);
5677 bs->walking_aio_notifiers = true;
5678 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
5679 if (baf->deleted) {
5680 bdrv_do_remove_aio_context_notifier(baf);
5681 } else {
5682 baf->detach_aio_context(baf->opaque);
5683 }
5684 }
5685
5686
5687
5688 bs->walking_aio_notifiers = false;
5689
5690 if (bs->drv && bs->drv->bdrv_detach_aio_context) {
5691 bs->drv->bdrv_detach_aio_context(bs);
5692 }
5693 QLIST_FOREACH(child, &bs->children, next) {
5694 bdrv_detach_aio_context(child->bs);
5695 }
5696
5697 if (bs->quiesce_counter) {
5698 aio_enable_external(bs->aio_context);
5699 }
5700 bs->aio_context = NULL;
5701}
5702
5703void bdrv_attach_aio_context(BlockDriverState *bs,
5704 AioContext *new_context)
5705{
5706 BdrvAioNotifier *ban, *ban_tmp;
5707 BdrvChild *child;
5708
5709 if (bs->quiesce_counter) {
5710 aio_disable_external(new_context);
5711 }
5712
5713 bs->aio_context = new_context;
5714
5715 QLIST_FOREACH(child, &bs->children, next) {
5716 bdrv_attach_aio_context(child->bs, new_context);
5717 }
5718 if (bs->drv && bs->drv->bdrv_attach_aio_context) {
5719 bs->drv->bdrv_attach_aio_context(bs, new_context);
5720 }
5721
5722 assert(!bs->walking_aio_notifiers);
5723 bs->walking_aio_notifiers = true;
5724 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
5725 if (ban->deleted) {
5726 bdrv_do_remove_aio_context_notifier(ban);
5727 } else {
5728 ban->attached_aio_context(new_context, ban->opaque);
5729 }
5730 }
5731 bs->walking_aio_notifiers = false;
5732}
5733
5734
5735
5736
5737void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5738{
5739 if (bdrv_get_aio_context(bs) == new_context) {
5740 return;
5741 }
5742
5743 bdrv_drained_begin(bs);
5744 bdrv_detach_aio_context(bs);
5745
5746
5747
5748
5749 aio_context_acquire(new_context);
5750 bdrv_attach_aio_context(bs, new_context);
5751 bdrv_drained_end(bs);
5752 aio_context_release(new_context);
5753}
5754
5755void bdrv_add_aio_context_notifier(BlockDriverState *bs,
5756 void (*attached_aio_context)(AioContext *new_context, void *opaque),
5757 void (*detach_aio_context)(void *opaque), void *opaque)
5758{
5759 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
5760 *ban = (BdrvAioNotifier){
5761 .attached_aio_context = attached_aio_context,
5762 .detach_aio_context = detach_aio_context,
5763 .opaque = opaque
5764 };
5765
5766 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
5767}
5768
5769void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
5770 void (*attached_aio_context)(AioContext *,
5771 void *),
5772 void (*detach_aio_context)(void *),
5773 void *opaque)
5774{
5775 BdrvAioNotifier *ban, *ban_next;
5776
5777 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
5778 if (ban->attached_aio_context == attached_aio_context &&
5779 ban->detach_aio_context == detach_aio_context &&
5780 ban->opaque == opaque &&
5781 ban->deleted == false)
5782 {
5783 if (bs->walking_aio_notifiers) {
5784 ban->deleted = true;
5785 } else {
5786 bdrv_do_remove_aio_context_notifier(ban);
5787 }
5788 return;
5789 }
5790 }
5791
5792 abort();
5793}
5794
5795int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
5796 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
5797 Error **errp)
5798{
5799 if (!bs->drv) {
5800 error_setg(errp, "Node is ejected");
5801 return -ENOMEDIUM;
5802 }
5803 if (!bs->drv->bdrv_amend_options) {
5804 error_setg(errp, "Block driver '%s' does not support option amendment",
5805 bs->drv->format_name);
5806 return -ENOTSUP;
5807 }
5808 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque, errp);
5809}
5810
5811
5812
5813
5814
5815
5816bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5817 BlockDriverState *candidate)
5818{
5819
5820 if (!bs || !bs->drv) {
5821 return false;
5822 }
5823
5824
5825
5826
5827 if (!bs->drv->is_filter) {
5828 return bs == candidate;
5829 }
5830
5831
5832
5833
5834
5835 if (bs->drv->bdrv_recurse_is_first_non_filter) {
5836 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5837 }
5838
5839
5840
5841 return false;
5842}
5843
5844
5845
5846
5847
5848bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5849{
5850 BlockDriverState *bs;
5851 BdrvNextIterator it;
5852
5853
5854 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
5855 bool perm;
5856
5857
5858 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5859
5860
5861 if (perm) {
5862 bdrv_next_cleanup(&it);
5863 return true;
5864 }
5865 }
5866
5867 return false;
5868}
5869
5870BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
5871 const char *node_name, Error **errp)
5872{
5873 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5874 AioContext *aio_context;
5875
5876 if (!to_replace_bs) {
5877 error_setg(errp, "Node name '%s' not found", node_name);
5878 return NULL;
5879 }
5880
5881 aio_context = bdrv_get_aio_context(to_replace_bs);
5882 aio_context_acquire(aio_context);
5883
5884 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5885 to_replace_bs = NULL;
5886 goto out;
5887 }
5888
5889
5890
5891
5892
5893
5894 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
5895 error_setg(errp, "Only top most non filter can be replaced");
5896 to_replace_bs = NULL;
5897 goto out;
5898 }
5899
5900out:
5901 aio_context_release(aio_context);
5902 return to_replace_bs;
5903}
5904
5905
5906
5907
5908
5909
5910
5911
5912
5913
5914
5915static const char *const *strong_options(BlockDriverState *bs,
5916 const char *const *curopt)
5917{
5918 static const char *const global_options[] = {
5919 "driver", "filename", NULL
5920 };
5921
5922 if (!curopt) {
5923 return &global_options[0];
5924 }
5925
5926 curopt++;
5927 if (curopt == &global_options[ARRAY_SIZE(global_options) - 1] && bs->drv) {
5928 curopt = bs->drv->strong_runtime_opts;
5929 }
5930
5931 return (curopt && *curopt) ? curopt : NULL;
5932}
5933
5934
5935
5936
5937
5938
5939
5940
5941
5942
5943
5944
5945static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs)
5946{
5947 bool found_any = false;
5948 const char *const *option_name = NULL;
5949
5950 if (!bs->drv) {
5951 return false;
5952 }
5953
5954 while ((option_name = strong_options(bs, option_name))) {
5955 bool option_given = false;
5956
5957 assert(strlen(*option_name) > 0);
5958 if ((*option_name)[strlen(*option_name) - 1] != '.') {
5959 QObject *entry = qdict_get(bs->options, *option_name);
5960 if (!entry) {
5961 continue;
5962 }
5963
5964 qdict_put_obj(d, *option_name, qobject_ref(entry));
5965 option_given = true;
5966 } else {
5967 const QDictEntry *entry;
5968 for (entry = qdict_first(bs->options); entry;
5969 entry = qdict_next(bs->options, entry))
5970 {
5971 if (strstart(qdict_entry_key(entry), *option_name, NULL)) {
5972 qdict_put_obj(d, qdict_entry_key(entry),
5973 qobject_ref(qdict_entry_value(entry)));
5974 option_given = true;
5975 }
5976 }
5977 }
5978
5979
5980
5981 if (!found_any && option_given &&
5982 strcmp(*option_name, "driver") && strcmp(*option_name, "filename"))
5983 {
5984 found_any = true;
5985 }
5986 }
5987
5988 if (!qdict_haskey(d, "driver")) {
5989
5990
5991 qdict_put_str(d, "driver", bs->drv->format_name);
5992 }
5993
5994 return found_any;
5995}
5996
5997
5998
5999
6000static bool bdrv_backing_overridden(BlockDriverState *bs)
6001{
6002 if (bs->backing) {
6003 return strcmp(bs->auto_backing_file,
6004 bs->backing->bs->filename);
6005 } else {
6006
6007
6008 return bs->auto_backing_file[0] != '\0';
6009 }
6010}
6011
6012
6013
6014
6015
6016
6017
6018
6019
6020
6021
6022
6023
6024void bdrv_refresh_filename(BlockDriverState *bs)
6025{
6026 BlockDriver *drv = bs->drv;
6027 BdrvChild *child;
6028 QDict *opts;
6029 bool backing_overridden;
6030 bool generate_json_filename;
6031
6032
6033 if (!drv) {
6034 return;
6035 }
6036
6037
6038
6039 QLIST_FOREACH(child, &bs->children, next) {
6040 bdrv_refresh_filename(child->bs);
6041 }
6042
6043 if (bs->implicit) {
6044
6045 child = QLIST_FIRST(&bs->children);
6046 assert(QLIST_NEXT(child, next) == NULL);
6047
6048 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
6049 child->bs->exact_filename);
6050 pstrcpy(bs->filename, sizeof(bs->filename), child->bs->filename);
6051
6052 bs->full_open_options = qobject_ref(child->bs->full_open_options);
6053
6054 return;
6055 }
6056
6057 backing_overridden = bdrv_backing_overridden(bs);
6058
6059 if (bs->open_flags & BDRV_O_NO_IO) {
6060
6061
6062
6063
6064 backing_overridden = false;
6065 }
6066
6067
6068 opts = qdict_new();
6069 generate_json_filename = append_strong_runtime_options(opts, bs);
6070 generate_json_filename |= backing_overridden;
6071
6072 if (drv->bdrv_gather_child_options) {
6073
6074
6075 drv->bdrv_gather_child_options(bs, opts, backing_overridden);
6076 } else {
6077 QLIST_FOREACH(child, &bs->children, next) {
6078 if (child->role == &child_backing && !backing_overridden) {
6079
6080 continue;
6081 }
6082
6083 qdict_put(opts, child->name,
6084 qobject_ref(child->bs->full_open_options));
6085 }
6086
6087 if (backing_overridden && !bs->backing) {
6088
6089 qdict_put_null(opts, "backing");
6090 }
6091 }
6092
6093 qobject_unref(bs->full_open_options);
6094 bs->full_open_options = opts;
6095
6096 if (drv->bdrv_refresh_filename) {
6097
6098
6099 bs->exact_filename[0] = '\0';
6100
6101 drv->bdrv_refresh_filename(bs);
6102 } else if (bs->file) {
6103
6104
6105 bs->exact_filename[0] = '\0';
6106
6107
6108
6109
6110
6111
6112
6113
6114
6115
6116
6117
6118 if (bs->file->bs->exact_filename[0] &&
6119 bs->file->bs->drv->bdrv_file_open &&
6120 !generate_json_filename)
6121 {
6122 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
6123 }
6124 }
6125
6126 if (bs->exact_filename[0]) {
6127 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
6128 } else {
6129 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
6130 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
6131 qstring_get_str(json));
6132 qobject_unref(json);
6133 }
6134}
6135
6136char *bdrv_dirname(BlockDriverState *bs, Error **errp)
6137{
6138 BlockDriver *drv = bs->drv;
6139
6140 if (!drv) {
6141 error_setg(errp, "Node '%s' is ejected", bs->node_name);
6142 return NULL;
6143 }
6144
6145 if (drv->bdrv_dirname) {
6146 return drv->bdrv_dirname(bs, errp);
6147 }
6148
6149 if (bs->file) {
6150 return bdrv_dirname(bs->file->bs, errp);
6151 }
6152
6153 bdrv_refresh_filename(bs);
6154 if (bs->exact_filename[0] != '\0') {
6155 return path_combine(bs->exact_filename, "");
6156 }
6157
6158 error_setg(errp, "Cannot generate a base directory for %s nodes",
6159 drv->format_name);
6160 return NULL;
6161}
6162
6163
6164
6165
6166
6167void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
6168 Error **errp)
6169{
6170
6171 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
6172 error_setg(errp, "The node %s does not support adding a child",
6173 bdrv_get_device_or_node_name(parent_bs));
6174 return;
6175 }
6176
6177 if (!QLIST_EMPTY(&child_bs->parents)) {
6178 error_setg(errp, "The node %s already has a parent",
6179 child_bs->node_name);
6180 return;
6181 }
6182
6183 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
6184}
6185
6186void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
6187{
6188 BdrvChild *tmp;
6189
6190 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
6191 error_setg(errp, "The node %s does not support removing a child",
6192 bdrv_get_device_or_node_name(parent_bs));
6193 return;
6194 }
6195
6196 QLIST_FOREACH(tmp, &parent_bs->children, next) {
6197 if (tmp == child) {
6198 break;
6199 }
6200 }
6201
6202 if (!tmp) {
6203 error_setg(errp, "The node %s does not have a child named %s",
6204 bdrv_get_device_or_node_name(parent_bs),
6205 bdrv_get_device_or_node_name(child->bs));
6206 return;
6207 }
6208
6209 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
6210}
6211
6212bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
6213 uint32_t granularity, Error **errp)
6214{
6215 BlockDriver *drv = bs->drv;
6216
6217 if (!drv) {
6218 error_setg_errno(errp, ENOMEDIUM,
6219 "Can't store persistent bitmaps to %s",
6220 bdrv_get_device_or_node_name(bs));
6221 return false;
6222 }
6223
6224 if (!drv->bdrv_can_store_new_dirty_bitmap) {
6225 error_setg_errno(errp, ENOTSUP,
6226 "Can't store persistent bitmaps to %s",
6227 bdrv_get_device_or_node_name(bs));
6228 return false;
6229 }
6230
6231 return drv->bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp);
6232}
6233