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 aio_wait_kick();
3740}
3741
3742int bdrv_check(BlockDriverState *bs,
3743 BdrvCheckResult *res, BdrvCheckMode fix)
3744{
3745 Coroutine *co;
3746 CheckCo cco = {
3747 .bs = bs,
3748 .res = res,
3749 .ret = -EINPROGRESS,
3750 .fix = fix,
3751 };
3752
3753 if (qemu_in_coroutine()) {
3754
3755 bdrv_check_co_entry(&cco);
3756 } else {
3757 co = qemu_coroutine_create(bdrv_check_co_entry, &cco);
3758 bdrv_coroutine_enter(bs, co);
3759 BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS);
3760 }
3761
3762 return cco.ret;
3763}
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773int bdrv_change_backing_file(BlockDriverState *bs,
3774 const char *backing_file, const char *backing_fmt)
3775{
3776 BlockDriver *drv = bs->drv;
3777 int ret;
3778
3779 if (!drv) {
3780 return -ENOMEDIUM;
3781 }
3782
3783
3784 if (backing_fmt && !backing_file) {
3785 return -EINVAL;
3786 }
3787
3788 if (drv->bdrv_change_backing_file != NULL) {
3789 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
3790 } else {
3791 ret = -ENOTSUP;
3792 }
3793
3794 if (ret == 0) {
3795 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
3796 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
3797 }
3798 return ret;
3799}
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
3812 BlockDriverState *bs)
3813{
3814 while (active && bs != backing_bs(active)) {
3815 active = backing_bs(active);
3816 }
3817
3818 return active;
3819}
3820
3821
3822BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3823{
3824 return bdrv_find_overlay(bs, NULL);
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
3855
3856int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
3857 const char *backing_file_str)
3858{
3859 BlockDriverState *explicit_top = top;
3860 bool update_inherits_from;
3861 BdrvChild *c, *next;
3862 Error *local_err = NULL;
3863 int ret = -EIO;
3864
3865 bdrv_ref(top);
3866
3867 if (!top->drv || !base->drv) {
3868 goto exit;
3869 }
3870
3871
3872 if (!bdrv_chain_contains(top, base)) {
3873 goto exit;
3874 }
3875
3876
3877
3878
3879
3880
3881 while (explicit_top && explicit_top->implicit) {
3882 explicit_top = backing_bs(explicit_top);
3883 }
3884 update_inherits_from = bdrv_inherits_from_recursive(base, explicit_top);
3885
3886
3887
3888
3889 backing_file_str = backing_file_str ? backing_file_str : base->filename;
3890
3891 QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) {
3892
3893 GSList *ignore_children = g_slist_prepend(NULL, c);
3894 bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm,
3895 ignore_children, &local_err);
3896 g_slist_free(ignore_children);
3897 if (local_err) {
3898 ret = -EPERM;
3899 error_report_err(local_err);
3900 goto exit;
3901 }
3902
3903
3904 if (c->role->update_filename) {
3905 ret = c->role->update_filename(c, base, backing_file_str,
3906 &local_err);
3907 if (ret < 0) {
3908 bdrv_abort_perm_update(base);
3909 error_report_err(local_err);
3910 goto exit;
3911 }
3912 }
3913
3914
3915
3916 bdrv_ref(base);
3917 bdrv_replace_child(c, base);
3918 bdrv_unref(top);
3919 }
3920
3921 if (update_inherits_from) {
3922 base->inherits_from = explicit_top->inherits_from;
3923 }
3924
3925 ret = 0;
3926exit:
3927 bdrv_unref(top);
3928 return ret;
3929}
3930
3931
3932
3933
3934
3935int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3936{
3937 BlockDriver *drv = bs->drv;
3938 if (!drv) {
3939 return -ENOMEDIUM;
3940 }
3941 if (drv->bdrv_get_allocated_file_size) {
3942 return drv->bdrv_get_allocated_file_size(bs);
3943 }
3944 if (bs->file) {
3945 return bdrv_get_allocated_file_size(bs->file->bs);
3946 }
3947 return -ENOTSUP;
3948}
3949
3950
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
3969
3970
3971
3972
3973BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
3974 BlockDriverState *in_bs, Error **errp)
3975{
3976 if (!drv->bdrv_measure) {
3977 error_setg(errp, "Block driver '%s' does not support size measurement",
3978 drv->format_name);
3979 return NULL;
3980 }
3981
3982 return drv->bdrv_measure(opts, in_bs, errp);
3983}
3984
3985
3986
3987
3988int64_t bdrv_nb_sectors(BlockDriverState *bs)
3989{
3990 BlockDriver *drv = bs->drv;
3991
3992 if (!drv)
3993 return -ENOMEDIUM;
3994
3995 if (drv->has_variable_length) {
3996 int ret = refresh_total_sectors(bs, bs->total_sectors);
3997 if (ret < 0) {
3998 return ret;
3999 }
4000 }
4001 return bs->total_sectors;
4002}
4003
4004
4005
4006
4007
4008int64_t bdrv_getlength(BlockDriverState *bs)
4009{
4010 int64_t ret = bdrv_nb_sectors(bs);
4011
4012 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
4013 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
4014}
4015
4016
4017void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
4018{
4019 int64_t nb_sectors = bdrv_nb_sectors(bs);
4020
4021 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
4022}
4023
4024bool bdrv_is_sg(BlockDriverState *bs)
4025{
4026 return bs->sg;
4027}
4028
4029bool bdrv_is_encrypted(BlockDriverState *bs)
4030{
4031 if (bs->backing && bs->backing->bs->encrypted) {
4032 return true;
4033 }
4034 return bs->encrypted;
4035}
4036
4037const char *bdrv_get_format_name(BlockDriverState *bs)
4038{
4039 return bs->drv ? bs->drv->format_name : NULL;
4040}
4041
4042static int qsort_strcmp(const void *a, const void *b)
4043{
4044 return strcmp(*(char *const *)a, *(char *const *)b);
4045}
4046
4047void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
4048 void *opaque)
4049{
4050 BlockDriver *drv;
4051 int count = 0;
4052 int i;
4053 const char **formats = NULL;
4054
4055 QLIST_FOREACH(drv, &bdrv_drivers, list) {
4056 if (drv->format_name) {
4057 bool found = false;
4058 int i = count;
4059 while (formats && i && !found) {
4060 found = !strcmp(formats[--i], drv->format_name);
4061 }
4062
4063 if (!found) {
4064 formats = g_renew(const char *, formats, count + 1);
4065 formats[count++] = drv->format_name;
4066 }
4067 }
4068 }
4069
4070 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
4071 const char *format_name = block_driver_modules[i].format_name;
4072
4073 if (format_name) {
4074 bool found = false;
4075 int j = count;
4076
4077 while (formats && j && !found) {
4078 found = !strcmp(formats[--j], format_name);
4079 }
4080
4081 if (!found) {
4082 formats = g_renew(const char *, formats, count + 1);
4083 formats[count++] = format_name;
4084 }
4085 }
4086 }
4087
4088 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
4089
4090 for (i = 0; i < count; i++) {
4091 it(opaque, formats[i]);
4092 }
4093
4094 g_free(formats);
4095}
4096
4097
4098BlockDriverState *bdrv_find_node(const char *node_name)
4099{
4100 BlockDriverState *bs;
4101
4102 assert(node_name);
4103
4104 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
4105 if (!strcmp(node_name, bs->node_name)) {
4106 return bs;
4107 }
4108 }
4109 return NULL;
4110}
4111
4112
4113BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
4114{
4115 BlockDeviceInfoList *list, *entry;
4116 BlockDriverState *bs;
4117
4118 list = NULL;
4119 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
4120 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
4121 if (!info) {
4122 qapi_free_BlockDeviceInfoList(list);
4123 return NULL;
4124 }
4125 entry = g_malloc0(sizeof(*entry));
4126 entry->value = info;
4127 entry->next = list;
4128 list = entry;
4129 }
4130
4131 return list;
4132}
4133
4134BlockDriverState *bdrv_lookup_bs(const char *device,
4135 const char *node_name,
4136 Error **errp)
4137{
4138 BlockBackend *blk;
4139 BlockDriverState *bs;
4140
4141 if (device) {
4142 blk = blk_by_name(device);
4143
4144 if (blk) {
4145 bs = blk_bs(blk);
4146 if (!bs) {
4147 error_setg(errp, "Device '%s' has no medium", device);
4148 }
4149
4150 return bs;
4151 }
4152 }
4153
4154 if (node_name) {
4155 bs = bdrv_find_node(node_name);
4156
4157 if (bs) {
4158 return bs;
4159 }
4160 }
4161
4162 error_setg(errp, "Cannot find device=%s nor node_name=%s",
4163 device ? device : "",
4164 node_name ? node_name : "");
4165 return NULL;
4166}
4167
4168
4169
4170bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
4171{
4172 while (top && top != base) {
4173 top = backing_bs(top);
4174 }
4175
4176 return top != NULL;
4177}
4178
4179BlockDriverState *bdrv_next_node(BlockDriverState *bs)
4180{
4181 if (!bs) {
4182 return QTAILQ_FIRST(&graph_bdrv_states);
4183 }
4184 return QTAILQ_NEXT(bs, node_list);
4185}
4186
4187BlockDriverState *bdrv_next_all_states(BlockDriverState *bs)
4188{
4189 if (!bs) {
4190 return QTAILQ_FIRST(&all_bdrv_states);
4191 }
4192 return QTAILQ_NEXT(bs, bs_list);
4193}
4194
4195const char *bdrv_get_node_name(const BlockDriverState *bs)
4196{
4197 return bs->node_name;
4198}
4199
4200const char *bdrv_get_parent_name(const BlockDriverState *bs)
4201{
4202 BdrvChild *c;
4203 const char *name;
4204
4205
4206 QLIST_FOREACH(c, &bs->parents, next_parent) {
4207 if (c->role->get_name) {
4208 name = c->role->get_name(c);
4209 if (name && *name) {
4210 return name;
4211 }
4212 }
4213 }
4214
4215 return NULL;
4216}
4217
4218
4219const char *bdrv_get_device_name(const BlockDriverState *bs)
4220{
4221 return bdrv_get_parent_name(bs) ?: "";
4222}
4223
4224
4225
4226
4227
4228const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
4229{
4230 return bdrv_get_parent_name(bs) ?: bs->node_name;
4231}
4232
4233int bdrv_get_flags(BlockDriverState *bs)
4234{
4235 return bs->open_flags;
4236}
4237
4238int bdrv_has_zero_init_1(BlockDriverState *bs)
4239{
4240 return 1;
4241}
4242
4243int bdrv_has_zero_init(BlockDriverState *bs)
4244{
4245 if (!bs->drv) {
4246 return 0;
4247 }
4248
4249
4250
4251 if (bs->backing) {
4252 return 0;
4253 }
4254 if (bs->drv->bdrv_has_zero_init) {
4255 return bs->drv->bdrv_has_zero_init(bs);
4256 }
4257 if (bs->file && bs->drv->is_filter) {
4258 return bdrv_has_zero_init(bs->file->bs);
4259 }
4260
4261
4262 return 0;
4263}
4264
4265bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
4266{
4267 BlockDriverInfo bdi;
4268
4269 if (bs->backing) {
4270 return false;
4271 }
4272
4273 if (bdrv_get_info(bs, &bdi) == 0) {
4274 return bdi.unallocated_blocks_are_zero;
4275 }
4276
4277 return false;
4278}
4279
4280bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
4281{
4282 if (!(bs->open_flags & BDRV_O_UNMAP)) {
4283 return false;
4284 }
4285
4286 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP;
4287}
4288
4289const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4290{
4291 if (bs->backing && bs->backing->bs->encrypted)
4292 return bs->backing_file;
4293 else if (bs->encrypted)
4294 return bs->filename;
4295 else
4296 return NULL;
4297}
4298
4299void bdrv_get_backing_filename(BlockDriverState *bs,
4300 char *filename, int filename_size)
4301{
4302 pstrcpy(filename, filename_size, bs->backing_file);
4303}
4304
4305int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4306{
4307 BlockDriver *drv = bs->drv;
4308
4309 if (!drv) {
4310 return -ENOMEDIUM;
4311 }
4312 if (!drv->bdrv_get_info) {
4313 if (bs->file && drv->is_filter) {
4314 return bdrv_get_info(bs->file->bs, bdi);
4315 }
4316 return -ENOTSUP;
4317 }
4318 memset(bdi, 0, sizeof(*bdi));
4319 return drv->bdrv_get_info(bs, bdi);
4320}
4321
4322ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4323{
4324 BlockDriver *drv = bs->drv;
4325 if (drv && drv->bdrv_get_specific_info) {
4326 return drv->bdrv_get_specific_info(bs);
4327 }
4328 return NULL;
4329}
4330
4331void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
4332{
4333 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4334 return;
4335 }
4336
4337 bs->drv->bdrv_debug_event(bs, event);
4338}
4339
4340int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4341 const char *tag)
4342{
4343 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4344 bs = bs->file ? bs->file->bs : NULL;
4345 }
4346
4347 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4348 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4349 }
4350
4351 return -ENOTSUP;
4352}
4353
4354int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4355{
4356 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4357 bs = bs->file ? bs->file->bs : NULL;
4358 }
4359
4360 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4361 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4362 }
4363
4364 return -ENOTSUP;
4365}
4366
4367int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4368{
4369 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4370 bs = bs->file ? bs->file->bs : NULL;
4371 }
4372
4373 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4374 return bs->drv->bdrv_debug_resume(bs, tag);
4375 }
4376
4377 return -ENOTSUP;
4378}
4379
4380bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4381{
4382 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4383 bs = bs->file ? bs->file->bs : NULL;
4384 }
4385
4386 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4387 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4388 }
4389
4390 return false;
4391}
4392
4393
4394
4395
4396
4397BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4398 const char *backing_file)
4399{
4400 char *filename_full = NULL;
4401 char *backing_file_full = NULL;
4402 char *filename_tmp = NULL;
4403 int is_protocol = 0;
4404 BlockDriverState *curr_bs = NULL;
4405 BlockDriverState *retval = NULL;
4406 Error *local_error = NULL;
4407
4408 if (!bs || !bs->drv || !backing_file) {
4409 return NULL;
4410 }
4411
4412 filename_full = g_malloc(PATH_MAX);
4413 backing_file_full = g_malloc(PATH_MAX);
4414 filename_tmp = g_malloc(PATH_MAX);
4415
4416 is_protocol = path_has_protocol(backing_file);
4417
4418 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
4419
4420
4421
4422 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4423 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4424 retval = curr_bs->backing->bs;
4425 break;
4426 }
4427
4428 bdrv_get_full_backing_filename(curr_bs, backing_file_full, PATH_MAX,
4429 &local_error);
4430 if (local_error == NULL) {
4431 if (strcmp(backing_file, backing_file_full) == 0) {
4432 retval = curr_bs->backing->bs;
4433 break;
4434 }
4435 } else {
4436 error_free(local_error);
4437 local_error = NULL;
4438 }
4439 } else {
4440
4441
4442 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4443 backing_file);
4444
4445
4446 if (!realpath(filename_tmp, filename_full)) {
4447 continue;
4448 }
4449
4450
4451
4452 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4453 curr_bs->backing_file);
4454
4455 if (!realpath(filename_tmp, backing_file_full)) {
4456 continue;
4457 }
4458
4459 if (strcmp(backing_file_full, filename_full) == 0) {
4460 retval = curr_bs->backing->bs;
4461 break;
4462 }
4463 }
4464 }
4465
4466 g_free(filename_full);
4467 g_free(backing_file_full);
4468 g_free(filename_tmp);
4469 return retval;
4470}
4471
4472void bdrv_init(void)
4473{
4474 module_call_init(MODULE_INIT_BLOCK);
4475}
4476
4477void bdrv_init_with_whitelist(void)
4478{
4479 use_bdrv_whitelist = 1;
4480 bdrv_init();
4481}
4482
4483static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
4484 Error **errp)
4485{
4486 BdrvChild *child, *parent;
4487 uint64_t perm, shared_perm;
4488 Error *local_err = NULL;
4489 int ret;
4490 BdrvDirtyBitmap *bm;
4491
4492 if (!bs->drv) {
4493 return;
4494 }
4495
4496 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
4497 return;
4498 }
4499
4500 QLIST_FOREACH(child, &bs->children, next) {
4501 bdrv_co_invalidate_cache(child->bs, &local_err);
4502 if (local_err) {
4503 error_propagate(errp, local_err);
4504 return;
4505 }
4506 }
4507
4508
4509
4510
4511
4512
4513
4514
4515
4516
4517
4518
4519
4520
4521 bs->open_flags &= ~BDRV_O_INACTIVE;
4522 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
4523 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err);
4524 if (ret < 0) {
4525 bs->open_flags |= BDRV_O_INACTIVE;
4526 error_propagate(errp, local_err);
4527 return;
4528 }
4529 bdrv_set_perm(bs, perm, shared_perm);
4530
4531 if (bs->drv->bdrv_co_invalidate_cache) {
4532 bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
4533 if (local_err) {
4534 bs->open_flags |= BDRV_O_INACTIVE;
4535 error_propagate(errp, local_err);
4536 return;
4537 }
4538 }
4539
4540 for (bm = bdrv_dirty_bitmap_next(bs, NULL); bm;
4541 bm = bdrv_dirty_bitmap_next(bs, bm))
4542 {
4543 bdrv_dirty_bitmap_set_migration(bm, false);
4544 }
4545
4546 ret = refresh_total_sectors(bs, bs->total_sectors);
4547 if (ret < 0) {
4548 bs->open_flags |= BDRV_O_INACTIVE;
4549 error_setg_errno(errp, -ret, "Could not refresh total sector count");
4550 return;
4551 }
4552
4553 QLIST_FOREACH(parent, &bs->parents, next_parent) {
4554 if (parent->role->activate) {
4555 parent->role->activate(parent, &local_err);
4556 if (local_err) {
4557 bs->open_flags |= BDRV_O_INACTIVE;
4558 error_propagate(errp, local_err);
4559 return;
4560 }
4561 }
4562 }
4563}
4564
4565typedef struct InvalidateCacheCo {
4566 BlockDriverState *bs;
4567 Error **errp;
4568 bool done;
4569} InvalidateCacheCo;
4570
4571static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque)
4572{
4573 InvalidateCacheCo *ico = opaque;
4574 bdrv_co_invalidate_cache(ico->bs, ico->errp);
4575 ico->done = true;
4576 aio_wait_kick();
4577}
4578
4579void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4580{
4581 Coroutine *co;
4582 InvalidateCacheCo ico = {
4583 .bs = bs,
4584 .done = false,
4585 .errp = errp
4586 };
4587
4588 if (qemu_in_coroutine()) {
4589
4590 bdrv_invalidate_cache_co_entry(&ico);
4591 } else {
4592 co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico);
4593 bdrv_coroutine_enter(bs, co);
4594 BDRV_POLL_WHILE(bs, !ico.done);
4595 }
4596}
4597
4598void bdrv_invalidate_cache_all(Error **errp)
4599{
4600 BlockDriverState *bs;
4601 Error *local_err = NULL;
4602 BdrvNextIterator it;
4603
4604 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4605 AioContext *aio_context = bdrv_get_aio_context(bs);
4606
4607 aio_context_acquire(aio_context);
4608 bdrv_invalidate_cache(bs, &local_err);
4609 aio_context_release(aio_context);
4610 if (local_err) {
4611 error_propagate(errp, local_err);
4612 bdrv_next_cleanup(&it);
4613 return;
4614 }
4615 }
4616}
4617
4618static bool bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
4619{
4620 BdrvChild *parent;
4621
4622 QLIST_FOREACH(parent, &bs->parents, next_parent) {
4623 if (parent->role->parent_is_bds) {
4624 BlockDriverState *parent_bs = parent->opaque;
4625 if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) {
4626 return true;
4627 }
4628 }
4629 }
4630
4631 return false;
4632}
4633
4634static int bdrv_inactivate_recurse(BlockDriverState *bs)
4635{
4636 BdrvChild *child, *parent;
4637 uint64_t perm, shared_perm;
4638 int ret;
4639
4640 if (!bs->drv) {
4641 return -ENOMEDIUM;
4642 }
4643
4644
4645
4646 if (bdrv_has_bds_parent(bs, true)) {
4647 return 0;
4648 }
4649
4650 assert(!(bs->open_flags & BDRV_O_INACTIVE));
4651
4652
4653 if (bs->drv->bdrv_inactivate) {
4654 ret = bs->drv->bdrv_inactivate(bs);
4655 if (ret < 0) {
4656 return ret;
4657 }
4658 }
4659
4660 QLIST_FOREACH(parent, &bs->parents, next_parent) {
4661 if (parent->role->inactivate) {
4662 ret = parent->role->inactivate(parent);
4663 if (ret < 0) {
4664 return ret;
4665 }
4666 }
4667 }
4668
4669 bs->open_flags |= BDRV_O_INACTIVE;
4670
4671
4672 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
4673 bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &error_abort);
4674 bdrv_set_perm(bs, perm, shared_perm);
4675
4676
4677
4678 QLIST_FOREACH(child, &bs->children, next) {
4679 ret = bdrv_inactivate_recurse(child->bs);
4680 if (ret < 0) {
4681 return ret;
4682 }
4683 }
4684
4685 return 0;
4686}
4687
4688int bdrv_inactivate_all(void)
4689{
4690 BlockDriverState *bs = NULL;
4691 BdrvNextIterator it;
4692 int ret = 0;
4693 GSList *aio_ctxs = NULL, *ctx;
4694
4695 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4696 AioContext *aio_context = bdrv_get_aio_context(bs);
4697
4698 if (!g_slist_find(aio_ctxs, aio_context)) {
4699 aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
4700 aio_context_acquire(aio_context);
4701 }
4702 }
4703
4704 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4705
4706
4707
4708 if (bdrv_has_bds_parent(bs, false)) {
4709 continue;
4710 }
4711 ret = bdrv_inactivate_recurse(bs);
4712 if (ret < 0) {
4713 bdrv_next_cleanup(&it);
4714 goto out;
4715 }
4716 }
4717
4718out:
4719 for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
4720 AioContext *aio_context = ctx->data;
4721 aio_context_release(aio_context);
4722 }
4723 g_slist_free(aio_ctxs);
4724
4725 return ret;
4726}
4727
4728
4729
4730
4731
4732
4733
4734bool bdrv_is_inserted(BlockDriverState *bs)
4735{
4736 BlockDriver *drv = bs->drv;
4737 BdrvChild *child;
4738
4739 if (!drv) {
4740 return false;
4741 }
4742 if (drv->bdrv_is_inserted) {
4743 return drv->bdrv_is_inserted(bs);
4744 }
4745 QLIST_FOREACH(child, &bs->children, next) {
4746 if (!bdrv_is_inserted(child->bs)) {
4747 return false;
4748 }
4749 }
4750 return true;
4751}
4752
4753
4754
4755
4756void bdrv_eject(BlockDriverState *bs, bool eject_flag)
4757{
4758 BlockDriver *drv = bs->drv;
4759
4760 if (drv && drv->bdrv_eject) {
4761 drv->bdrv_eject(bs, eject_flag);
4762 }
4763}
4764
4765
4766
4767
4768
4769void bdrv_lock_medium(BlockDriverState *bs, bool locked)
4770{
4771 BlockDriver *drv = bs->drv;
4772
4773 trace_bdrv_lock_medium(bs, locked);
4774
4775 if (drv && drv->bdrv_lock_medium) {
4776 drv->bdrv_lock_medium(bs, locked);
4777 }
4778}
4779
4780
4781void bdrv_ref(BlockDriverState *bs)
4782{
4783 bs->refcnt++;
4784}
4785
4786
4787
4788
4789void bdrv_unref(BlockDriverState *bs)
4790{
4791 if (!bs) {
4792 return;
4793 }
4794 assert(bs->refcnt > 0);
4795 if (--bs->refcnt == 0) {
4796 bdrv_delete(bs);
4797 }
4798}
4799
4800struct BdrvOpBlocker {
4801 Error *reason;
4802 QLIST_ENTRY(BdrvOpBlocker) list;
4803};
4804
4805bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
4806{
4807 BdrvOpBlocker *blocker;
4808 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4809 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
4810 blocker = QLIST_FIRST(&bs->op_blockers[op]);
4811 error_propagate_prepend(errp, error_copy(blocker->reason),
4812 "Node '%s' is busy: ",
4813 bdrv_get_device_or_node_name(bs));
4814 return true;
4815 }
4816 return false;
4817}
4818
4819void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
4820{
4821 BdrvOpBlocker *blocker;
4822 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4823
4824 blocker = g_new0(BdrvOpBlocker, 1);
4825 blocker->reason = reason;
4826 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
4827}
4828
4829void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
4830{
4831 BdrvOpBlocker *blocker, *next;
4832 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4833 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
4834 if (blocker->reason == reason) {
4835 QLIST_REMOVE(blocker, list);
4836 g_free(blocker);
4837 }
4838 }
4839}
4840
4841void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
4842{
4843 int i;
4844 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4845 bdrv_op_block(bs, i, reason);
4846 }
4847}
4848
4849void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
4850{
4851 int i;
4852 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4853 bdrv_op_unblock(bs, i, reason);
4854 }
4855}
4856
4857bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
4858{
4859 int i;
4860
4861 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4862 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
4863 return false;
4864 }
4865 }
4866 return true;
4867}
4868
4869void bdrv_img_create(const char *filename, const char *fmt,
4870 const char *base_filename, const char *base_fmt,
4871 char *options, uint64_t img_size, int flags, bool quiet,
4872 Error **errp)
4873{
4874 QemuOptsList *create_opts = NULL;
4875 QemuOpts *opts = NULL;
4876 const char *backing_fmt, *backing_file;
4877 int64_t size;
4878 BlockDriver *drv, *proto_drv;
4879 Error *local_err = NULL;
4880 int ret = 0;
4881
4882
4883 drv = bdrv_find_format(fmt);
4884 if (!drv) {
4885 error_setg(errp, "Unknown file format '%s'", fmt);
4886 return;
4887 }
4888
4889 proto_drv = bdrv_find_protocol(filename, true, errp);
4890 if (!proto_drv) {
4891 return;
4892 }
4893
4894 if (!drv->create_opts) {
4895 error_setg(errp, "Format driver '%s' does not support image creation",
4896 drv->format_name);
4897 return;
4898 }
4899
4900 if (!proto_drv->create_opts) {
4901 error_setg(errp, "Protocol driver '%s' does not support image creation",
4902 proto_drv->format_name);
4903 return;
4904 }
4905
4906 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4907 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
4908
4909
4910 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4911 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
4912
4913
4914 if (options) {
4915 qemu_opts_do_parse(opts, options, NULL, &local_err);
4916 if (local_err) {
4917 goto out;
4918 }
4919 }
4920
4921 if (base_filename) {
4922 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
4923 if (local_err) {
4924 error_setg(errp, "Backing file not supported for file format '%s'",
4925 fmt);
4926 goto out;
4927 }
4928 }
4929
4930 if (base_fmt) {
4931 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
4932 if (local_err) {
4933 error_setg(errp, "Backing file format not supported for file "
4934 "format '%s'", fmt);
4935 goto out;
4936 }
4937 }
4938
4939 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
4940 if (backing_file) {
4941 if (!strcmp(filename, backing_file)) {
4942 error_setg(errp, "Error: Trying to create an image with the "
4943 "same filename as the backing file");
4944 goto out;
4945 }
4946 }
4947
4948 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
4949
4950
4951
4952 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
4953 if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
4954 BlockDriverState *bs;
4955 char *full_backing = g_new0(char, PATH_MAX);
4956 int back_flags;
4957 QDict *backing_options = NULL;
4958
4959 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
4960 full_backing, PATH_MAX,
4961 &local_err);
4962 if (local_err) {
4963 g_free(full_backing);
4964 goto out;
4965 }
4966
4967
4968 back_flags = flags;
4969 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
4970
4971 backing_options = qdict_new();
4972 if (backing_fmt) {
4973 qdict_put_str(backing_options, "driver", backing_fmt);
4974 }
4975 qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
4976
4977 bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
4978 &local_err);
4979 g_free(full_backing);
4980 if (!bs && size != -1) {
4981
4982 warn_reportf_err(local_err,
4983 "Could not verify backing image. "
4984 "This may become an error in future versions.\n");
4985 local_err = NULL;
4986 } else if (!bs) {
4987
4988 error_append_hint(&local_err,
4989 "Could not open backing image to determine size.\n");
4990 goto out;
4991 } else {
4992 if (size == -1) {
4993
4994 size = bdrv_getlength(bs);
4995 if (size < 0) {
4996 error_setg_errno(errp, -size, "Could not get size of '%s'",
4997 backing_file);
4998 bdrv_unref(bs);
4999 goto out;
5000 }
5001 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
5002 }
5003 bdrv_unref(bs);
5004 }
5005 }
5006
5007 if (size == -1) {
5008 error_setg(errp, "Image creation needs a size parameter");
5009 goto out;
5010 }
5011
5012 if (!quiet) {
5013 printf("Formatting '%s', fmt=%s ", filename, fmt);
5014 qemu_opts_print(opts, " ");
5015 puts("");
5016 }
5017
5018 ret = bdrv_create(drv, filename, opts, &local_err);
5019
5020 if (ret == -EFBIG) {
5021
5022
5023
5024 const char *cluster_size_hint = "";
5025 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
5026 cluster_size_hint = " (try using a larger cluster size)";
5027 }
5028 error_setg(errp, "The image size is too large for file format '%s'"
5029 "%s", fmt, cluster_size_hint);
5030 error_free(local_err);
5031 local_err = NULL;
5032 }
5033
5034out:
5035 qemu_opts_del(opts);
5036 qemu_opts_free(create_opts);
5037 error_propagate(errp, local_err);
5038}
5039
5040AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5041{
5042 return bs ? bs->aio_context : qemu_get_aio_context();
5043}
5044
5045void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)
5046{
5047 aio_co_enter(bdrv_get_aio_context(bs), co);
5048}
5049
5050static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
5051{
5052 QLIST_REMOVE(ban, list);
5053 g_free(ban);
5054}
5055
5056void bdrv_detach_aio_context(BlockDriverState *bs)
5057{
5058 BdrvAioNotifier *baf, *baf_tmp;
5059 BdrvChild *child;
5060
5061 assert(!bs->walking_aio_notifiers);
5062 bs->walking_aio_notifiers = true;
5063 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
5064 if (baf->deleted) {
5065 bdrv_do_remove_aio_context_notifier(baf);
5066 } else {
5067 baf->detach_aio_context(baf->opaque);
5068 }
5069 }
5070
5071
5072
5073 bs->walking_aio_notifiers = false;
5074
5075 if (bs->drv && bs->drv->bdrv_detach_aio_context) {
5076 bs->drv->bdrv_detach_aio_context(bs);
5077 }
5078 QLIST_FOREACH(child, &bs->children, next) {
5079 bdrv_detach_aio_context(child->bs);
5080 }
5081
5082 bs->aio_context = NULL;
5083}
5084
5085void bdrv_attach_aio_context(BlockDriverState *bs,
5086 AioContext *new_context)
5087{
5088 BdrvAioNotifier *ban, *ban_tmp;
5089 BdrvChild *child;
5090
5091 bs->aio_context = new_context;
5092
5093 QLIST_FOREACH(child, &bs->children, next) {
5094 bdrv_attach_aio_context(child->bs, new_context);
5095 }
5096 if (bs->drv && bs->drv->bdrv_attach_aio_context) {
5097 bs->drv->bdrv_attach_aio_context(bs, new_context);
5098 }
5099
5100 assert(!bs->walking_aio_notifiers);
5101 bs->walking_aio_notifiers = true;
5102 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
5103 if (ban->deleted) {
5104 bdrv_do_remove_aio_context_notifier(ban);
5105 } else {
5106 ban->attached_aio_context(new_context, ban->opaque);
5107 }
5108 }
5109 bs->walking_aio_notifiers = false;
5110}
5111
5112void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5113{
5114 AioContext *ctx = bdrv_get_aio_context(bs);
5115
5116 aio_disable_external(ctx);
5117 bdrv_parent_drained_begin(bs, NULL, false);
5118 bdrv_drain(bs);
5119
5120 while (aio_poll(ctx, false)) {
5121
5122 }
5123
5124 bdrv_detach_aio_context(bs);
5125
5126
5127
5128
5129 aio_context_acquire(new_context);
5130 bdrv_attach_aio_context(bs, new_context);
5131 bdrv_parent_drained_end(bs, NULL, false);
5132 aio_enable_external(ctx);
5133 aio_context_release(new_context);
5134}
5135
5136void bdrv_add_aio_context_notifier(BlockDriverState *bs,
5137 void (*attached_aio_context)(AioContext *new_context, void *opaque),
5138 void (*detach_aio_context)(void *opaque), void *opaque)
5139{
5140 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
5141 *ban = (BdrvAioNotifier){
5142 .attached_aio_context = attached_aio_context,
5143 .detach_aio_context = detach_aio_context,
5144 .opaque = opaque
5145 };
5146
5147 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
5148}
5149
5150void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
5151 void (*attached_aio_context)(AioContext *,
5152 void *),
5153 void (*detach_aio_context)(void *),
5154 void *opaque)
5155{
5156 BdrvAioNotifier *ban, *ban_next;
5157
5158 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
5159 if (ban->attached_aio_context == attached_aio_context &&
5160 ban->detach_aio_context == detach_aio_context &&
5161 ban->opaque == opaque &&
5162 ban->deleted == false)
5163 {
5164 if (bs->walking_aio_notifiers) {
5165 ban->deleted = true;
5166 } else {
5167 bdrv_do_remove_aio_context_notifier(ban);
5168 }
5169 return;
5170 }
5171 }
5172
5173 abort();
5174}
5175
5176int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
5177 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
5178 Error **errp)
5179{
5180 if (!bs->drv) {
5181 error_setg(errp, "Node is ejected");
5182 return -ENOMEDIUM;
5183 }
5184 if (!bs->drv->bdrv_amend_options) {
5185 error_setg(errp, "Block driver '%s' does not support option amendment",
5186 bs->drv->format_name);
5187 return -ENOTSUP;
5188 }
5189 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque, errp);
5190}
5191
5192
5193
5194
5195
5196
5197bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5198 BlockDriverState *candidate)
5199{
5200
5201 if (!bs || !bs->drv) {
5202 return false;
5203 }
5204
5205
5206
5207
5208 if (!bs->drv->is_filter) {
5209 return bs == candidate;
5210 }
5211
5212
5213
5214
5215
5216 if (bs->drv->bdrv_recurse_is_first_non_filter) {
5217 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5218 }
5219
5220
5221
5222 return false;
5223}
5224
5225
5226
5227
5228
5229bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5230{
5231 BlockDriverState *bs;
5232 BdrvNextIterator it;
5233
5234
5235 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
5236 bool perm;
5237
5238
5239 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5240
5241
5242 if (perm) {
5243 bdrv_next_cleanup(&it);
5244 return true;
5245 }
5246 }
5247
5248 return false;
5249}
5250
5251BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
5252 const char *node_name, Error **errp)
5253{
5254 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5255 AioContext *aio_context;
5256
5257 if (!to_replace_bs) {
5258 error_setg(errp, "Node name '%s' not found", node_name);
5259 return NULL;
5260 }
5261
5262 aio_context = bdrv_get_aio_context(to_replace_bs);
5263 aio_context_acquire(aio_context);
5264
5265 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5266 to_replace_bs = NULL;
5267 goto out;
5268 }
5269
5270
5271
5272
5273
5274
5275 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
5276 error_setg(errp, "Only top most non filter can be replaced");
5277 to_replace_bs = NULL;
5278 goto out;
5279 }
5280
5281out:
5282 aio_context_release(aio_context);
5283 return to_replace_bs;
5284}
5285
5286static bool append_open_options(QDict *d, BlockDriverState *bs)
5287{
5288 const QDictEntry *entry;
5289 QemuOptDesc *desc;
5290 bool found_any = false;
5291
5292 for (entry = qdict_first(bs->options); entry;
5293 entry = qdict_next(bs->options, entry))
5294 {
5295
5296 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
5297 if (!strcmp(qdict_entry_key(entry), desc->name)) {
5298 break;
5299 }
5300 }
5301 if (desc->name) {
5302 continue;
5303 }
5304
5305 qdict_put_obj(d, qdict_entry_key(entry),
5306 qobject_ref(qdict_entry_value(entry)));
5307 found_any = true;
5308 }
5309
5310 return found_any;
5311}
5312
5313
5314
5315
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325void bdrv_refresh_filename(BlockDriverState *bs)
5326{
5327 BlockDriver *drv = bs->drv;
5328 QDict *opts;
5329
5330 if (!drv) {
5331 return;
5332 }
5333
5334
5335
5336 if (bs->file) {
5337 bdrv_refresh_filename(bs->file->bs);
5338 }
5339
5340 if (drv->bdrv_refresh_filename) {
5341
5342
5343 bs->exact_filename[0] = '\0';
5344 if (bs->full_open_options) {
5345 qobject_unref(bs->full_open_options);
5346 bs->full_open_options = NULL;
5347 }
5348
5349 opts = qdict_new();
5350 append_open_options(opts, bs);
5351 drv->bdrv_refresh_filename(bs, opts);
5352 qobject_unref(opts);
5353 } else if (bs->file) {
5354
5355 bool has_open_options;
5356
5357 bs->exact_filename[0] = '\0';
5358 if (bs->full_open_options) {
5359 qobject_unref(bs->full_open_options);
5360 bs->full_open_options = NULL;
5361 }
5362
5363 opts = qdict_new();
5364 has_open_options = append_open_options(opts, bs);
5365
5366
5367
5368 if (bs->file->bs->exact_filename[0] && !has_open_options) {
5369 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
5370 }
5371
5372
5373
5374
5375
5376 if (bs->file->bs->full_open_options) {
5377 qdict_put_str(opts, "driver", drv->format_name);
5378 qdict_put(opts, "file",
5379 qobject_ref(bs->file->bs->full_open_options));
5380
5381 bs->full_open_options = opts;
5382 } else {
5383 qobject_unref(opts);
5384 }
5385 } else if (!bs->full_open_options && qdict_size(bs->options)) {
5386
5387
5388
5389
5390
5391
5392
5393 opts = qdict_new();
5394 append_open_options(opts, bs);
5395 qdict_put_str(opts, "driver", drv->format_name);
5396
5397 if (bs->exact_filename[0]) {
5398
5399
5400
5401
5402
5403
5404
5405 qdict_put_str(opts, "filename", bs->exact_filename);
5406 }
5407
5408 bs->full_open_options = opts;
5409 }
5410
5411 if (bs->exact_filename[0]) {
5412 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
5413 } else if (bs->full_open_options) {
5414 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
5415 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
5416 qstring_get_str(json));
5417 qobject_unref(json);
5418 }
5419}
5420
5421
5422
5423
5424
5425void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
5426 Error **errp)
5427{
5428
5429 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
5430 error_setg(errp, "The node %s does not support adding a child",
5431 bdrv_get_device_or_node_name(parent_bs));
5432 return;
5433 }
5434
5435 if (!QLIST_EMPTY(&child_bs->parents)) {
5436 error_setg(errp, "The node %s already has a parent",
5437 child_bs->node_name);
5438 return;
5439 }
5440
5441 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
5442}
5443
5444void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
5445{
5446 BdrvChild *tmp;
5447
5448 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
5449 error_setg(errp, "The node %s does not support removing a child",
5450 bdrv_get_device_or_node_name(parent_bs));
5451 return;
5452 }
5453
5454 QLIST_FOREACH(tmp, &parent_bs->children, next) {
5455 if (tmp == child) {
5456 break;
5457 }
5458 }
5459
5460 if (!tmp) {
5461 error_setg(errp, "The node %s does not have a child named %s",
5462 bdrv_get_device_or_node_name(parent_bs),
5463 bdrv_get_device_or_node_name(child->bs));
5464 return;
5465 }
5466
5467 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
5468}
5469
5470bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
5471 uint32_t granularity, Error **errp)
5472{
5473 BlockDriver *drv = bs->drv;
5474
5475 if (!drv) {
5476 error_setg_errno(errp, ENOMEDIUM,
5477 "Can't store persistent bitmaps to %s",
5478 bdrv_get_device_or_node_name(bs));
5479 return false;
5480 }
5481
5482 if (!drv->bdrv_can_store_new_dirty_bitmap) {
5483 error_setg_errno(errp, ENOTSUP,
5484 "Can't store persistent bitmaps to %s",
5485 bdrv_get_device_or_node_name(bs));
5486 return false;
5487 }
5488
5489 return drv->bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp);
5490}
5491