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