1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "trace.h"
26#include "block/block_int.h"
27#include "block/blockjob.h"
28#include "block/nbd.h"
29#include "qemu/error-report.h"
30#include "module_block.h"
31#include "qemu/module.h"
32#include "qapi/qmp/qerror.h"
33#include "qapi/qmp/qbool.h"
34#include "qapi/qmp/qjson.h"
35#include "sysemu/block-backend.h"
36#include "sysemu/sysemu.h"
37#include "qemu/notify.h"
38#include "qemu/coroutine.h"
39#include "block/qapi.h"
40#include "qmp-commands.h"
41#include "qemu/timer.h"
42#include "qapi-event.h"
43#include "qemu/cutils.h"
44#include "qemu/id.h"
45#include "qapi/util.h"
46
47#ifdef CONFIG_BSD
48#include <sys/ioctl.h>
49#include <sys/queue.h>
50#ifndef __DragonFly__
51#include <sys/disk.h>
52#endif
53#endif
54
55#ifdef _WIN32
56#include <windows.h>
57#endif
58
59#define NOT_DONE 0x7fffffff
60
61static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
62 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
63
64static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
65 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
66
67static QLIST_HEAD(, BlockDriver) bdrv_drivers =
68 QLIST_HEAD_INITIALIZER(bdrv_drivers);
69
70static BlockDriverState *bdrv_open_inherit(const char *filename,
71 const char *reference,
72 QDict *options, int flags,
73 BlockDriverState *parent,
74 const BdrvChildRole *child_role,
75 Error **errp);
76
77
78static int use_bdrv_whitelist;
79
80#ifdef _WIN32
81static int is_windows_drive_prefix(const char *filename)
82{
83 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
84 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
85 filename[1] == ':');
86}
87
88int is_windows_drive(const char *filename)
89{
90 if (is_windows_drive_prefix(filename) &&
91 filename[2] == '\0')
92 return 1;
93 if (strstart(filename, "\\\\.\\", NULL) ||
94 strstart(filename, "//./", NULL))
95 return 1;
96 return 0;
97}
98#endif
99
100size_t bdrv_opt_mem_align(BlockDriverState *bs)
101{
102 if (!bs || !bs->drv) {
103
104 return MAX(4096, getpagesize());
105 }
106
107 return bs->bl.opt_mem_alignment;
108}
109
110size_t bdrv_min_mem_align(BlockDriverState *bs)
111{
112 if (!bs || !bs->drv) {
113
114 return MAX(4096, getpagesize());
115 }
116
117 return bs->bl.min_mem_alignment;
118}
119
120
121int path_has_protocol(const char *path)
122{
123 const char *p;
124
125#ifdef _WIN32
126 if (is_windows_drive(path) ||
127 is_windows_drive_prefix(path)) {
128 return 0;
129 }
130 p = path + strcspn(path, ":/\\");
131#else
132 p = path + strcspn(path, ":/");
133#endif
134
135 return *p == ':';
136}
137
138int path_is_absolute(const char *path)
139{
140#ifdef _WIN32
141
142 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
143 return 1;
144 }
145 return (*path == '/' || *path == '\\');
146#else
147 return (*path == '/');
148#endif
149}
150
151
152
153
154void path_combine(char *dest, int dest_size,
155 const char *base_path,
156 const char *filename)
157{
158 const char *p, *p1;
159 int len;
160
161 if (dest_size <= 0)
162 return;
163 if (path_is_absolute(filename)) {
164 pstrcpy(dest, dest_size, filename);
165 } else {
166 p = strchr(base_path, ':');
167 if (p)
168 p++;
169 else
170 p = base_path;
171 p1 = strrchr(base_path, '/');
172#ifdef _WIN32
173 {
174 const char *p2;
175 p2 = strrchr(base_path, '\\');
176 if (!p1 || p2 > p1)
177 p1 = p2;
178 }
179#endif
180 if (p1)
181 p1++;
182 else
183 p1 = base_path;
184 if (p1 > p)
185 p = p1;
186 len = p - base_path;
187 if (len > dest_size - 1)
188 len = dest_size - 1;
189 memcpy(dest, base_path, len);
190 dest[len] = '\0';
191 pstrcat(dest, dest_size, filename);
192 }
193}
194
195void bdrv_get_full_backing_filename_from_filename(const char *backed,
196 const char *backing,
197 char *dest, size_t sz,
198 Error **errp)
199{
200 if (backing[0] == '\0' || path_has_protocol(backing) ||
201 path_is_absolute(backing))
202 {
203 pstrcpy(dest, sz, backing);
204 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
205 error_setg(errp, "Cannot use relative backing file names for '%s'",
206 backed);
207 } else {
208 path_combine(dest, sz, backed, backing);
209 }
210}
211
212void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
213 Error **errp)
214{
215 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
216
217 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
218 dest, sz, errp);
219}
220
221void bdrv_register(BlockDriver *bdrv)
222{
223 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
224}
225
226BlockDriverState *bdrv_new(void)
227{
228 BlockDriverState *bs;
229 int i;
230
231 bs = g_new0(BlockDriverState, 1);
232 QLIST_INIT(&bs->dirty_bitmaps);
233 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
234 QLIST_INIT(&bs->op_blockers[i]);
235 }
236 notifier_with_return_list_init(&bs->before_write_notifiers);
237 bs->refcnt = 1;
238 bs->aio_context = qemu_get_aio_context();
239
240 qemu_co_queue_init(&bs->flush_queue);
241
242 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
243
244 return bs;
245}
246
247static BlockDriver *bdrv_do_find_format(const char *format_name)
248{
249 BlockDriver *drv1;
250
251 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
252 if (!strcmp(drv1->format_name, format_name)) {
253 return drv1;
254 }
255 }
256
257 return NULL;
258}
259
260BlockDriver *bdrv_find_format(const char *format_name)
261{
262 BlockDriver *drv1;
263 int i;
264
265 drv1 = bdrv_do_find_format(format_name);
266 if (drv1) {
267 return drv1;
268 }
269
270
271 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
272 if (!strcmp(block_driver_modules[i].format_name, format_name)) {
273 block_module_load_one(block_driver_modules[i].library_name);
274 break;
275 }
276 }
277
278 return bdrv_do_find_format(format_name);
279}
280
281static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
282{
283 static const char *whitelist_rw[] = {
284 CONFIG_BDRV_RW_WHITELIST
285 };
286 static const char *whitelist_ro[] = {
287 CONFIG_BDRV_RO_WHITELIST
288 };
289 const char **p;
290
291 if (!whitelist_rw[0] && !whitelist_ro[0]) {
292 return 1;
293 }
294
295 for (p = whitelist_rw; *p; p++) {
296 if (!strcmp(drv->format_name, *p)) {
297 return 1;
298 }
299 }
300 if (read_only) {
301 for (p = whitelist_ro; *p; p++) {
302 if (!strcmp(drv->format_name, *p)) {
303 return 1;
304 }
305 }
306 }
307 return 0;
308}
309
310bool bdrv_uses_whitelist(void)
311{
312 return use_bdrv_whitelist;
313}
314
315typedef struct CreateCo {
316 BlockDriver *drv;
317 char *filename;
318 QemuOpts *opts;
319 int ret;
320 Error *err;
321} CreateCo;
322
323static void coroutine_fn bdrv_create_co_entry(void *opaque)
324{
325 Error *local_err = NULL;
326 int ret;
327
328 CreateCo *cco = opaque;
329 assert(cco->drv);
330
331 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
332 error_propagate(&cco->err, local_err);
333 cco->ret = ret;
334}
335
336int bdrv_create(BlockDriver *drv, const char* filename,
337 QemuOpts *opts, Error **errp)
338{
339 int ret;
340
341 Coroutine *co;
342 CreateCo cco = {
343 .drv = drv,
344 .filename = g_strdup(filename),
345 .opts = opts,
346 .ret = NOT_DONE,
347 .err = NULL,
348 };
349
350 if (!drv->bdrv_create) {
351 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
352 ret = -ENOTSUP;
353 goto out;
354 }
355
356 if (qemu_in_coroutine()) {
357
358 bdrv_create_co_entry(&cco);
359 } else {
360 co = qemu_coroutine_create(bdrv_create_co_entry, &cco);
361 qemu_coroutine_enter(co);
362 while (cco.ret == NOT_DONE) {
363 aio_poll(qemu_get_aio_context(), true);
364 }
365 }
366
367 ret = cco.ret;
368 if (ret < 0) {
369 if (cco.err) {
370 error_propagate(errp, cco.err);
371 } else {
372 error_setg_errno(errp, -ret, "Could not create image");
373 }
374 }
375
376out:
377 g_free(cco.filename);
378 return ret;
379}
380
381int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
382{
383 BlockDriver *drv;
384 Error *local_err = NULL;
385 int ret;
386
387 drv = bdrv_find_protocol(filename, true, errp);
388 if (drv == NULL) {
389 return -ENOENT;
390 }
391
392 ret = bdrv_create(drv, filename, opts, &local_err);
393 error_propagate(errp, local_err);
394 return ret;
395}
396
397
398
399
400
401
402
403int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
404{
405 BlockDriver *drv = bs->drv;
406
407 if (drv && drv->bdrv_probe_blocksizes) {
408 return drv->bdrv_probe_blocksizes(bs, bsz);
409 }
410
411 return -ENOTSUP;
412}
413
414
415
416
417
418
419
420int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
421{
422 BlockDriver *drv = bs->drv;
423
424 if (drv && drv->bdrv_probe_geometry) {
425 return drv->bdrv_probe_geometry(bs, geo);
426 }
427
428 return -ENOTSUP;
429}
430
431
432
433
434
435int get_tmp_filename(char *filename, int size)
436{
437#ifdef _WIN32
438 char temp_dir[MAX_PATH];
439
440
441 assert(size >= MAX_PATH);
442 return (GetTempPath(MAX_PATH, temp_dir)
443 && GetTempFileName(temp_dir, "qem", 0, filename)
444 ? 0 : -GetLastError());
445#else
446 int fd;
447 const char *tmpdir;
448 tmpdir = getenv("TMPDIR");
449 if (!tmpdir) {
450 tmpdir = "/var/tmp";
451 }
452 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
453 return -EOVERFLOW;
454 }
455 fd = mkstemp(filename);
456 if (fd < 0) {
457 return -errno;
458 }
459 if (close(fd) != 0) {
460 unlink(filename);
461 return -errno;
462 }
463 return 0;
464#endif
465}
466
467
468
469
470
471static BlockDriver *find_hdev_driver(const char *filename)
472{
473 int score_max = 0, score;
474 BlockDriver *drv = NULL, *d;
475
476 QLIST_FOREACH(d, &bdrv_drivers, list) {
477 if (d->bdrv_probe_device) {
478 score = d->bdrv_probe_device(filename);
479 if (score > score_max) {
480 score_max = score;
481 drv = d;
482 }
483 }
484 }
485
486 return drv;
487}
488
489static BlockDriver *bdrv_do_find_protocol(const char *protocol)
490{
491 BlockDriver *drv1;
492
493 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
494 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
495 return drv1;
496 }
497 }
498
499 return NULL;
500}
501
502BlockDriver *bdrv_find_protocol(const char *filename,
503 bool allow_protocol_prefix,
504 Error **errp)
505{
506 BlockDriver *drv1;
507 char protocol[128];
508 int len;
509 const char *p;
510 int i;
511
512
513
514
515
516
517
518
519
520
521 drv1 = find_hdev_driver(filename);
522 if (drv1) {
523 return drv1;
524 }
525
526 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
527 return &bdrv_file;
528 }
529
530 p = strchr(filename, ':');
531 assert(p != NULL);
532 len = p - filename;
533 if (len > sizeof(protocol) - 1)
534 len = sizeof(protocol) - 1;
535 memcpy(protocol, filename, len);
536 protocol[len] = '\0';
537
538 drv1 = bdrv_do_find_protocol(protocol);
539 if (drv1) {
540 return drv1;
541 }
542
543 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
544 if (block_driver_modules[i].protocol_name &&
545 !strcmp(block_driver_modules[i].protocol_name, protocol)) {
546 block_module_load_one(block_driver_modules[i].library_name);
547 break;
548 }
549 }
550
551 drv1 = bdrv_do_find_protocol(protocol);
552 if (!drv1) {
553 error_setg(errp, "Unknown protocol '%s'", protocol);
554 }
555 return drv1;
556}
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
573 const char *filename)
574{
575 int score_max = 0, score;
576 BlockDriver *drv = NULL, *d;
577
578 QLIST_FOREACH(d, &bdrv_drivers, list) {
579 if (d->bdrv_probe) {
580 score = d->bdrv_probe(buf, buf_size, filename);
581 if (score > score_max) {
582 score_max = score;
583 drv = d;
584 }
585 }
586 }
587
588 return drv;
589}
590
591static int find_image_format(BdrvChild *file, const char *filename,
592 BlockDriver **pdrv, Error **errp)
593{
594 BlockDriverState *bs = file->bs;
595 BlockDriver *drv;
596 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
597 int ret = 0;
598
599
600 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
601 *pdrv = &bdrv_raw;
602 return ret;
603 }
604
605 ret = bdrv_pread(file, 0, buf, sizeof(buf));
606 if (ret < 0) {
607 error_setg_errno(errp, -ret, "Could not read image for determining its "
608 "format");
609 *pdrv = NULL;
610 return ret;
611 }
612
613 drv = bdrv_probe_all(buf, ret, filename);
614 if (!drv) {
615 error_setg(errp, "Could not determine image format: No compatible "
616 "driver found");
617 ret = -ENOENT;
618 }
619 *pdrv = drv;
620 return ret;
621}
622
623
624
625
626
627static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
628{
629 BlockDriver *drv = bs->drv;
630
631
632 if (bdrv_is_sg(bs))
633 return 0;
634
635
636 if (drv->bdrv_getlength) {
637 int64_t length = drv->bdrv_getlength(bs);
638 if (length < 0) {
639 return length;
640 }
641 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
642 }
643
644 bs->total_sectors = hint;
645 return 0;
646}
647
648
649
650
651
652static void bdrv_join_options(BlockDriverState *bs, QDict *options,
653 QDict *old_options)
654{
655 if (bs->drv && bs->drv->bdrv_join_options) {
656 bs->drv->bdrv_join_options(options, old_options);
657 } else {
658 qdict_join(options, old_options, false);
659 }
660}
661
662
663
664
665
666
667int bdrv_parse_discard_flags(const char *mode, int *flags)
668{
669 *flags &= ~BDRV_O_UNMAP;
670
671 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
672
673 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
674 *flags |= BDRV_O_UNMAP;
675 } else {
676 return -1;
677 }
678
679 return 0;
680}
681
682
683
684
685
686
687int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
688{
689 *flags &= ~BDRV_O_CACHE_MASK;
690
691 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
692 *writethrough = false;
693 *flags |= BDRV_O_NOCACHE;
694 } else if (!strcmp(mode, "directsync")) {
695 *writethrough = true;
696 *flags |= BDRV_O_NOCACHE;
697 } else if (!strcmp(mode, "writeback")) {
698 *writethrough = false;
699 } else if (!strcmp(mode, "unsafe")) {
700 *writethrough = false;
701 *flags |= BDRV_O_NO_FLUSH;
702 } else if (!strcmp(mode, "writethrough")) {
703 *writethrough = true;
704 } else {
705 return -1;
706 }
707
708 return 0;
709}
710
711static void bdrv_child_cb_drained_begin(BdrvChild *child)
712{
713 BlockDriverState *bs = child->opaque;
714 bdrv_drained_begin(bs);
715}
716
717static void bdrv_child_cb_drained_end(BdrvChild *child)
718{
719 BlockDriverState *bs = child->opaque;
720 bdrv_drained_end(bs);
721}
722
723
724
725
726
727
728static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
729 int parent_flags, QDict *parent_options)
730{
731 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
732
733
734 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
735 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
736
737
738 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
739
740
741
742 *child_flags &= ~BDRV_O_NATIVE_AIO;
743}
744
745
746
747
748
749static void bdrv_inherited_options(int *child_flags, QDict *child_options,
750 int parent_flags, QDict *parent_options)
751{
752 int flags = parent_flags;
753
754
755 flags |= BDRV_O_PROTOCOL;
756
757
758
759 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
760 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
761
762
763 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
764
765
766
767
768 qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
769
770
771 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
772 BDRV_O_NO_IO);
773
774 *child_flags = flags;
775}
776
777const BdrvChildRole child_file = {
778 .inherit_options = bdrv_inherited_options,
779 .drained_begin = bdrv_child_cb_drained_begin,
780 .drained_end = bdrv_child_cb_drained_end,
781};
782
783
784
785
786
787
788static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
789 int parent_flags, QDict *parent_options)
790{
791 child_file.inherit_options(child_flags, child_options,
792 parent_flags, parent_options);
793
794 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
795}
796
797const BdrvChildRole child_format = {
798 .inherit_options = bdrv_inherited_fmt_options,
799 .drained_begin = bdrv_child_cb_drained_begin,
800 .drained_end = bdrv_child_cb_drained_end,
801};
802
803
804
805
806
807static void bdrv_backing_options(int *child_flags, QDict *child_options,
808 int parent_flags, QDict *parent_options)
809{
810 int flags = parent_flags;
811
812
813
814 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
815 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
816
817
818 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
819 flags &= ~BDRV_O_COPY_ON_READ;
820
821
822 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
823
824 *child_flags = flags;
825}
826
827static const BdrvChildRole child_backing = {
828 .inherit_options = bdrv_backing_options,
829 .drained_begin = bdrv_child_cb_drained_begin,
830 .drained_end = bdrv_child_cb_drained_end,
831};
832
833static int bdrv_open_flags(BlockDriverState *bs, int flags)
834{
835 int open_flags = flags;
836
837
838
839
840
841 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
842
843
844
845
846 if (flags & BDRV_O_TEMPORARY) {
847 open_flags |= BDRV_O_RDWR;
848 }
849
850 return open_flags;
851}
852
853static void update_flags_from_options(int *flags, QemuOpts *opts)
854{
855 *flags &= ~BDRV_O_CACHE_MASK;
856
857 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
858 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
859 *flags |= BDRV_O_NO_FLUSH;
860 }
861
862 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
863 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
864 *flags |= BDRV_O_NOCACHE;
865 }
866
867 *flags &= ~BDRV_O_RDWR;
868
869 assert(qemu_opt_find(opts, BDRV_OPT_READ_ONLY));
870 if (!qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false)) {
871 *flags |= BDRV_O_RDWR;
872 }
873
874}
875
876static void update_options_from_flags(QDict *options, int flags)
877{
878 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
879 qdict_put(options, BDRV_OPT_CACHE_DIRECT,
880 qbool_from_bool(flags & BDRV_O_NOCACHE));
881 }
882 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
883 qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH,
884 qbool_from_bool(flags & BDRV_O_NO_FLUSH));
885 }
886 if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
887 qdict_put(options, BDRV_OPT_READ_ONLY,
888 qbool_from_bool(!(flags & BDRV_O_RDWR)));
889 }
890}
891
892static void bdrv_assign_node_name(BlockDriverState *bs,
893 const char *node_name,
894 Error **errp)
895{
896 char *gen_node_name = NULL;
897
898 if (!node_name) {
899 node_name = gen_node_name = id_generate(ID_BLOCK);
900 } else if (!id_wellformed(node_name)) {
901
902
903
904
905 error_setg(errp, "Invalid node name");
906 return;
907 }
908
909
910 if (blk_by_name(node_name)) {
911 error_setg(errp, "node-name=%s is conflicting with a device id",
912 node_name);
913 goto out;
914 }
915
916
917 if (bdrv_find_node(node_name)) {
918 error_setg(errp, "Duplicate node name");
919 goto out;
920 }
921
922
923 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
924 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
925out:
926 g_free(gen_node_name);
927}
928
929QemuOptsList bdrv_runtime_opts = {
930 .name = "bdrv_common",
931 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
932 .desc = {
933 {
934 .name = "node-name",
935 .type = QEMU_OPT_STRING,
936 .help = "Node name of the block device node",
937 },
938 {
939 .name = "driver",
940 .type = QEMU_OPT_STRING,
941 .help = "Block driver to use for the node",
942 },
943 {
944 .name = BDRV_OPT_CACHE_DIRECT,
945 .type = QEMU_OPT_BOOL,
946 .help = "Bypass software writeback cache on the host",
947 },
948 {
949 .name = BDRV_OPT_CACHE_NO_FLUSH,
950 .type = QEMU_OPT_BOOL,
951 .help = "Ignore flush requests",
952 },
953 {
954 .name = BDRV_OPT_READ_ONLY,
955 .type = QEMU_OPT_BOOL,
956 .help = "Node is opened in read-only mode",
957 },
958 {
959 .name = "detect-zeroes",
960 .type = QEMU_OPT_STRING,
961 .help = "try to optimize zero writes (off, on, unmap)",
962 },
963 {
964 .name = "discard",
965 .type = QEMU_OPT_STRING,
966 .help = "discard operation (ignore/off, unmap/on)",
967 },
968 { }
969 },
970};
971
972
973
974
975
976
977static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
978 QDict *options, Error **errp)
979{
980 int ret, open_flags;
981 const char *filename;
982 const char *driver_name = NULL;
983 const char *node_name = NULL;
984 const char *discard;
985 const char *detect_zeroes;
986 QemuOpts *opts;
987 BlockDriver *drv;
988 Error *local_err = NULL;
989
990 assert(bs->file == NULL);
991 assert(options != NULL && bs->options != options);
992
993 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
994 qemu_opts_absorb_qdict(opts, options, &local_err);
995 if (local_err) {
996 error_propagate(errp, local_err);
997 ret = -EINVAL;
998 goto fail_opts;
999 }
1000
1001 update_flags_from_options(&bs->open_flags, opts);
1002
1003 driver_name = qemu_opt_get(opts, "driver");
1004 drv = bdrv_find_format(driver_name);
1005 assert(drv != NULL);
1006
1007 if (file != NULL) {
1008 filename = file->bs->filename;
1009 } else {
1010 filename = qdict_get_try_str(options, "filename");
1011 }
1012
1013 if (drv->bdrv_needs_filename && !filename) {
1014 error_setg(errp, "The '%s' block driver requires a file name",
1015 drv->format_name);
1016 ret = -EINVAL;
1017 goto fail_opts;
1018 }
1019
1020 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
1021 drv->format_name);
1022
1023 node_name = qemu_opt_get(opts, "node-name");
1024 bdrv_assign_node_name(bs, node_name, &local_err);
1025 if (local_err) {
1026 error_propagate(errp, local_err);
1027 ret = -EINVAL;
1028 goto fail_opts;
1029 }
1030
1031 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
1032
1033 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
1034 error_setg(errp,
1035 !bs->read_only && bdrv_is_whitelisted(drv, true)
1036 ? "Driver '%s' can only be used for read-only devices"
1037 : "Driver '%s' is not whitelisted",
1038 drv->format_name);
1039 ret = -ENOTSUP;
1040 goto fail_opts;
1041 }
1042
1043 assert(bs->copy_on_read == 0);
1044 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
1045 if (!bs->read_only) {
1046 bdrv_enable_copy_on_read(bs);
1047 } else {
1048 error_setg(errp, "Can't use copy-on-read on read-only device");
1049 ret = -EINVAL;
1050 goto fail_opts;
1051 }
1052 }
1053
1054 discard = qemu_opt_get(opts, "discard");
1055 if (discard != NULL) {
1056 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
1057 error_setg(errp, "Invalid discard option");
1058 ret = -EINVAL;
1059 goto fail_opts;
1060 }
1061 }
1062
1063 detect_zeroes = qemu_opt_get(opts, "detect-zeroes");
1064 if (detect_zeroes) {
1065 BlockdevDetectZeroesOptions value =
1066 qapi_enum_parse(BlockdevDetectZeroesOptions_lookup,
1067 detect_zeroes,
1068 BLOCKDEV_DETECT_ZEROES_OPTIONS__MAX,
1069 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
1070 &local_err);
1071 if (local_err) {
1072 error_propagate(errp, local_err);
1073 ret = -EINVAL;
1074 goto fail_opts;
1075 }
1076
1077 if (value == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
1078 !(bs->open_flags & BDRV_O_UNMAP))
1079 {
1080 error_setg(errp, "setting detect-zeroes to unmap is not allowed "
1081 "without setting discard operation to unmap");
1082 ret = -EINVAL;
1083 goto fail_opts;
1084 }
1085
1086 bs->detect_zeroes = value;
1087 }
1088
1089 if (filename != NULL) {
1090 pstrcpy(bs->filename, sizeof(bs->filename), filename);
1091 } else {
1092 bs->filename[0] = '\0';
1093 }
1094 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
1095
1096 bs->drv = drv;
1097 bs->opaque = g_malloc0(drv->instance_size);
1098
1099
1100 open_flags = bdrv_open_flags(bs, bs->open_flags);
1101 if (drv->bdrv_file_open) {
1102 assert(file == NULL);
1103 assert(!drv->bdrv_needs_filename || filename != NULL);
1104 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
1105 } else {
1106 if (file == NULL) {
1107 error_setg(errp, "Can't use '%s' as a block driver for the "
1108 "protocol level", drv->format_name);
1109 ret = -EINVAL;
1110 goto free_and_fail;
1111 }
1112 bs->file = file;
1113 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
1114 }
1115
1116 if (ret < 0) {
1117 if (local_err) {
1118 error_propagate(errp, local_err);
1119 } else if (bs->filename[0]) {
1120 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1121 } else {
1122 error_setg_errno(errp, -ret, "Could not open image");
1123 }
1124 goto free_and_fail;
1125 }
1126
1127 ret = refresh_total_sectors(bs, bs->total_sectors);
1128 if (ret < 0) {
1129 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1130 goto free_and_fail;
1131 }
1132
1133 bdrv_refresh_limits(bs, &local_err);
1134 if (local_err) {
1135 error_propagate(errp, local_err);
1136 ret = -EINVAL;
1137 goto free_and_fail;
1138 }
1139
1140 assert(bdrv_opt_mem_align(bs) != 0);
1141 assert(bdrv_min_mem_align(bs) != 0);
1142 assert(is_power_of_2(bs->bl.request_alignment));
1143
1144 qemu_opts_del(opts);
1145 return 0;
1146
1147free_and_fail:
1148 bs->file = NULL;
1149 g_free(bs->opaque);
1150 bs->opaque = NULL;
1151 bs->drv = NULL;
1152fail_opts:
1153 qemu_opts_del(opts);
1154 return ret;
1155}
1156
1157static QDict *parse_json_filename(const char *filename, Error **errp)
1158{
1159 QObject *options_obj;
1160 QDict *options;
1161 int ret;
1162
1163 ret = strstart(filename, "json:", &filename);
1164 assert(ret);
1165
1166 options_obj = qobject_from_json(filename);
1167 if (!options_obj) {
1168 error_setg(errp, "Could not parse the JSON options");
1169 return NULL;
1170 }
1171
1172 if (qobject_type(options_obj) != QTYPE_QDICT) {
1173 qobject_decref(options_obj);
1174 error_setg(errp, "Invalid JSON object given");
1175 return NULL;
1176 }
1177
1178 options = qobject_to_qdict(options_obj);
1179 qdict_flatten(options);
1180
1181 return options;
1182}
1183
1184static void parse_json_protocol(QDict *options, const char **pfilename,
1185 Error **errp)
1186{
1187 QDict *json_options;
1188 Error *local_err = NULL;
1189
1190
1191 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1192 return;
1193 }
1194
1195 json_options = parse_json_filename(*pfilename, &local_err);
1196 if (local_err) {
1197 error_propagate(errp, local_err);
1198 return;
1199 }
1200
1201
1202
1203 qdict_join(options, json_options, false);
1204 QDECREF(json_options);
1205 *pfilename = NULL;
1206}
1207
1208
1209
1210
1211
1212
1213
1214static int bdrv_fill_options(QDict **options, const char *filename,
1215 int *flags, Error **errp)
1216{
1217 const char *drvname;
1218 bool protocol = *flags & BDRV_O_PROTOCOL;
1219 bool parse_filename = false;
1220 BlockDriver *drv = NULL;
1221 Error *local_err = NULL;
1222
1223 drvname = qdict_get_try_str(*options, "driver");
1224 if (drvname) {
1225 drv = bdrv_find_format(drvname);
1226 if (!drv) {
1227 error_setg(errp, "Unknown driver '%s'", drvname);
1228 return -ENOENT;
1229 }
1230
1231
1232 protocol = drv->bdrv_file_open;
1233 }
1234
1235 if (protocol) {
1236 *flags |= BDRV_O_PROTOCOL;
1237 } else {
1238 *flags &= ~BDRV_O_PROTOCOL;
1239 }
1240
1241
1242 update_options_from_flags(*options, *flags);
1243
1244
1245 if (protocol && filename) {
1246 if (!qdict_haskey(*options, "filename")) {
1247 qdict_put(*options, "filename", qstring_from_str(filename));
1248 parse_filename = true;
1249 } else {
1250 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1251 "the same time");
1252 return -EINVAL;
1253 }
1254 }
1255
1256
1257 filename = qdict_get_try_str(*options, "filename");
1258
1259 if (!drvname && protocol) {
1260 if (filename) {
1261 drv = bdrv_find_protocol(filename, parse_filename, errp);
1262 if (!drv) {
1263 return -EINVAL;
1264 }
1265
1266 drvname = drv->format_name;
1267 qdict_put(*options, "driver", qstring_from_str(drvname));
1268 } else {
1269 error_setg(errp, "Must specify either driver or file");
1270 return -EINVAL;
1271 }
1272 }
1273
1274 assert(drv || !protocol);
1275
1276
1277 if (drv && drv->bdrv_parse_filename && parse_filename) {
1278 drv->bdrv_parse_filename(filename, *options, &local_err);
1279 if (local_err) {
1280 error_propagate(errp, local_err);
1281 return -EINVAL;
1282 }
1283
1284 if (!drv->bdrv_needs_filename) {
1285 qdict_del(*options, "filename");
1286 }
1287 }
1288
1289 return 0;
1290}
1291
1292static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)
1293{
1294 BlockDriverState *old_bs = child->bs;
1295
1296 if (old_bs) {
1297 if (old_bs->quiesce_counter && child->role->drained_end) {
1298 child->role->drained_end(child);
1299 }
1300 QLIST_REMOVE(child, next_parent);
1301 }
1302
1303 child->bs = new_bs;
1304
1305 if (new_bs) {
1306 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
1307 if (new_bs->quiesce_counter && child->role->drained_begin) {
1308 child->role->drained_begin(child);
1309 }
1310 }
1311}
1312
1313BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
1314 const char *child_name,
1315 const BdrvChildRole *child_role,
1316 void *opaque)
1317{
1318 BdrvChild *child = g_new(BdrvChild, 1);
1319 *child = (BdrvChild) {
1320 .bs = NULL,
1321 .name = g_strdup(child_name),
1322 .role = child_role,
1323 .opaque = opaque,
1324 };
1325
1326 bdrv_replace_child(child, child_bs);
1327
1328 return child;
1329}
1330
1331BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1332 BlockDriverState *child_bs,
1333 const char *child_name,
1334 const BdrvChildRole *child_role)
1335{
1336 BdrvChild *child = bdrv_root_attach_child(child_bs, child_name, child_role,
1337 parent_bs);
1338 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1339 return child;
1340}
1341
1342static void bdrv_detach_child(BdrvChild *child)
1343{
1344 if (child->next.le_prev) {
1345 QLIST_REMOVE(child, next);
1346 child->next.le_prev = NULL;
1347 }
1348
1349 bdrv_replace_child(child, NULL);
1350
1351 g_free(child->name);
1352 g_free(child);
1353}
1354
1355void bdrv_root_unref_child(BdrvChild *child)
1356{
1357 BlockDriverState *child_bs;
1358
1359 child_bs = child->bs;
1360 bdrv_detach_child(child);
1361 bdrv_unref(child_bs);
1362}
1363
1364void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1365{
1366 if (child == NULL) {
1367 return;
1368 }
1369
1370 if (child->bs->inherits_from == parent) {
1371 child->bs->inherits_from = NULL;
1372 }
1373
1374 bdrv_root_unref_child(child);
1375}
1376
1377
1378static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
1379{
1380 BdrvChild *c;
1381 QLIST_FOREACH(c, &bs->parents, next_parent) {
1382 if (c->role->change_media) {
1383 c->role->change_media(c, load);
1384 }
1385 }
1386}
1387
1388static void bdrv_parent_cb_resize(BlockDriverState *bs)
1389{
1390 BdrvChild *c;
1391 QLIST_FOREACH(c, &bs->parents, next_parent) {
1392 if (c->role->resize) {
1393 c->role->resize(c);
1394 }
1395 }
1396}
1397
1398
1399
1400
1401
1402void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1403{
1404 if (backing_hd) {
1405 bdrv_ref(backing_hd);
1406 }
1407
1408 if (bs->backing) {
1409 assert(bs->backing_blocker);
1410 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
1411 bdrv_unref_child(bs, bs->backing);
1412 } else if (backing_hd) {
1413 error_setg(&bs->backing_blocker,
1414 "node is used as backing hd of '%s'",
1415 bdrv_get_device_or_node_name(bs));
1416 }
1417
1418 if (!backing_hd) {
1419 error_free(bs->backing_blocker);
1420 bs->backing_blocker = NULL;
1421 bs->backing = NULL;
1422 goto out;
1423 }
1424 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing);
1425 bs->open_flags &= ~BDRV_O_NO_BACKING;
1426 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1427 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1428 backing_hd->drv ? backing_hd->drv->format_name : "");
1429
1430 bdrv_op_block_all(backing_hd, bs->backing_blocker);
1431
1432 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1433 bs->backing_blocker);
1434 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
1435 bs->backing_blocker);
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
1450 bs->backing_blocker);
1451 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
1452 bs->backing_blocker);
1453out:
1454 bdrv_refresh_limits(bs, NULL);
1455}
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
1468 const char *bdref_key, Error **errp)
1469{
1470 char *backing_filename = g_malloc0(PATH_MAX);
1471 char *bdref_key_dot;
1472 const char *reference = NULL;
1473 int ret = 0;
1474 BlockDriverState *backing_hd;
1475 QDict *options;
1476 QDict *tmp_parent_options = NULL;
1477 Error *local_err = NULL;
1478
1479 if (bs->backing != NULL) {
1480 goto free_exit;
1481 }
1482
1483
1484 if (parent_options == NULL) {
1485 tmp_parent_options = qdict_new();
1486 parent_options = tmp_parent_options;
1487 }
1488
1489 bs->open_flags &= ~BDRV_O_NO_BACKING;
1490
1491 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1492 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
1493 g_free(bdref_key_dot);
1494
1495 reference = qdict_get_try_str(parent_options, bdref_key);
1496 if (reference || qdict_haskey(options, "file.filename")) {
1497 backing_filename[0] = '\0';
1498 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1499 QDECREF(options);
1500 goto free_exit;
1501 } else {
1502 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1503 &local_err);
1504 if (local_err) {
1505 ret = -EINVAL;
1506 error_propagate(errp, local_err);
1507 QDECREF(options);
1508 goto free_exit;
1509 }
1510 }
1511
1512 if (!bs->drv || !bs->drv->supports_backing) {
1513 ret = -EINVAL;
1514 error_setg(errp, "Driver doesn't support backing files");
1515 QDECREF(options);
1516 goto free_exit;
1517 }
1518
1519 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1520 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1521 }
1522
1523 backing_hd = bdrv_open_inherit(*backing_filename ? backing_filename : NULL,
1524 reference, options, 0, bs, &child_backing,
1525 errp);
1526 if (!backing_hd) {
1527 bs->open_flags |= BDRV_O_NO_BACKING;
1528 error_prepend(errp, "Could not open backing file: ");
1529 ret = -EINVAL;
1530 goto free_exit;
1531 }
1532
1533
1534
1535 bdrv_set_backing_hd(bs, backing_hd);
1536 bdrv_unref(backing_hd);
1537
1538 qdict_del(parent_options, bdref_key);
1539
1540free_exit:
1541 g_free(backing_filename);
1542 QDECREF(tmp_parent_options);
1543 return ret;
1544}
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560BdrvChild *bdrv_open_child(const char *filename,
1561 QDict *options, const char *bdref_key,
1562 BlockDriverState* parent,
1563 const BdrvChildRole *child_role,
1564 bool allow_none, Error **errp)
1565{
1566 BdrvChild *c = NULL;
1567 BlockDriverState *bs;
1568 QDict *image_options;
1569 char *bdref_key_dot;
1570 const char *reference;
1571
1572 assert(child_role != NULL);
1573
1574 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1575 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1576 g_free(bdref_key_dot);
1577
1578 reference = qdict_get_try_str(options, bdref_key);
1579 if (!filename && !reference && !qdict_size(image_options)) {
1580 if (!allow_none) {
1581 error_setg(errp, "A block device must be specified for \"%s\"",
1582 bdref_key);
1583 }
1584 QDECREF(image_options);
1585 goto done;
1586 }
1587
1588 bs = bdrv_open_inherit(filename, reference, image_options, 0,
1589 parent, child_role, errp);
1590 if (!bs) {
1591 goto done;
1592 }
1593
1594 c = bdrv_attach_child(parent, bs, bdref_key, child_role);
1595
1596done:
1597 qdict_del(options, bdref_key);
1598 return c;
1599}
1600
1601static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
1602 int flags,
1603 QDict *snapshot_options,
1604 Error **errp)
1605{
1606
1607 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1608 int64_t total_size;
1609 QemuOpts *opts = NULL;
1610 BlockDriverState *bs_snapshot;
1611 int ret;
1612
1613
1614
1615
1616
1617 total_size = bdrv_getlength(bs);
1618 if (total_size < 0) {
1619 error_setg_errno(errp, -total_size, "Could not get image size");
1620 goto out;
1621 }
1622
1623
1624 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1625 if (ret < 0) {
1626 error_setg_errno(errp, -ret, "Could not get temporary filename");
1627 goto out;
1628 }
1629
1630 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1631 &error_abort);
1632 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1633 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
1634 qemu_opts_del(opts);
1635 if (ret < 0) {
1636 error_prepend(errp, "Could not create temporary overlay '%s': ",
1637 tmp_filename);
1638 goto out;
1639 }
1640
1641
1642 qdict_put(snapshot_options, "file.driver",
1643 qstring_from_str("file"));
1644 qdict_put(snapshot_options, "file.filename",
1645 qstring_from_str(tmp_filename));
1646 qdict_put(snapshot_options, "driver",
1647 qstring_from_str("qcow2"));
1648
1649 bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
1650 snapshot_options = NULL;
1651 if (!bs_snapshot) {
1652 ret = -EINVAL;
1653 goto out;
1654 }
1655
1656
1657
1658
1659 bdrv_ref(bs_snapshot);
1660 bdrv_append(bs_snapshot, bs);
1661
1662 g_free(tmp_filename);
1663 return bs_snapshot;
1664
1665out:
1666 QDECREF(snapshot_options);
1667 g_free(tmp_filename);
1668 return NULL;
1669}
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686static BlockDriverState *bdrv_open_inherit(const char *filename,
1687 const char *reference,
1688 QDict *options, int flags,
1689 BlockDriverState *parent,
1690 const BdrvChildRole *child_role,
1691 Error **errp)
1692{
1693 int ret;
1694 BdrvChild *file = NULL;
1695 BlockDriverState *bs;
1696 BlockDriver *drv = NULL;
1697 const char *drvname;
1698 const char *backing;
1699 Error *local_err = NULL;
1700 QDict *snapshot_options = NULL;
1701 int snapshot_flags = 0;
1702
1703 assert(!child_role || !flags);
1704 assert(!child_role == !parent);
1705
1706 if (reference) {
1707 bool options_non_empty = options ? qdict_size(options) : false;
1708 QDECREF(options);
1709
1710 if (filename || options_non_empty) {
1711 error_setg(errp, "Cannot reference an existing block device with "
1712 "additional options or a new filename");
1713 return NULL;
1714 }
1715
1716 bs = bdrv_lookup_bs(reference, reference, errp);
1717 if (!bs) {
1718 return NULL;
1719 }
1720
1721 bdrv_ref(bs);
1722 return bs;
1723 }
1724
1725 bs = bdrv_new();
1726
1727
1728 if (options == NULL) {
1729 options = qdict_new();
1730 }
1731
1732
1733 parse_json_protocol(options, &filename, &local_err);
1734 if (local_err) {
1735 goto fail;
1736 }
1737
1738 bs->explicit_options = qdict_clone_shallow(options);
1739
1740 if (child_role) {
1741 bs->inherits_from = parent;
1742 child_role->inherit_options(&flags, options,
1743 parent->open_flags, parent->options);
1744 }
1745
1746 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
1747 if (local_err) {
1748 goto fail;
1749 }
1750
1751
1752
1753
1754 if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
1755 !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
1756 flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
1757 } else {
1758 flags &= ~BDRV_O_RDWR;
1759 }
1760
1761 if (flags & BDRV_O_SNAPSHOT) {
1762 snapshot_options = qdict_new();
1763 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
1764 flags, options);
1765
1766 qdict_del(options, BDRV_OPT_READ_ONLY);
1767 bdrv_backing_options(&flags, options, flags, options);
1768 }
1769
1770 bs->open_flags = flags;
1771 bs->options = options;
1772 options = qdict_clone_shallow(options);
1773
1774
1775 drvname = qdict_get_try_str(options, "driver");
1776 if (drvname) {
1777 drv = bdrv_find_format(drvname);
1778 if (!drv) {
1779 error_setg(errp, "Unknown driver: '%s'", drvname);
1780 goto fail;
1781 }
1782 }
1783
1784 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1785
1786 backing = qdict_get_try_str(options, "backing");
1787 if (backing && *backing == '\0') {
1788 flags |= BDRV_O_NO_BACKING;
1789 qdict_del(options, "backing");
1790 }
1791
1792
1793 if ((flags & BDRV_O_PROTOCOL) == 0) {
1794 file = bdrv_open_child(filename, options, "file", bs,
1795 &child_file, true, &local_err);
1796 if (local_err) {
1797 goto fail;
1798 }
1799 }
1800
1801
1802 bs->probed = !drv;
1803 if (!drv && file) {
1804 ret = find_image_format(file, filename, &drv, &local_err);
1805 if (ret < 0) {
1806 goto fail;
1807 }
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819 qdict_put(bs->options, "driver", qstring_from_str(drv->format_name));
1820 qdict_put(options, "driver", qstring_from_str(drv->format_name));
1821 } else if (!drv) {
1822 error_setg(errp, "Must specify either driver or file");
1823 goto fail;
1824 }
1825
1826
1827 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1828
1829
1830 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1831
1832
1833 ret = bdrv_open_common(bs, file, options, &local_err);
1834 if (ret < 0) {
1835 goto fail;
1836 }
1837
1838 if (file && (bs->file != file)) {
1839 bdrv_unref_child(bs, file);
1840 file = NULL;
1841 }
1842
1843
1844 if ((flags & BDRV_O_NO_BACKING) == 0) {
1845 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
1846 if (ret < 0) {
1847 goto close_and_fail;
1848 }
1849 }
1850
1851 bdrv_refresh_filename(bs);
1852
1853
1854 if (options && (qdict_size(options) != 0)) {
1855 const QDictEntry *entry = qdict_first(options);
1856 if (flags & BDRV_O_PROTOCOL) {
1857 error_setg(errp, "Block protocol '%s' doesn't support the option "
1858 "'%s'", drv->format_name, entry->key);
1859 } else {
1860 error_setg(errp,
1861 "Block format '%s' does not support the option '%s'",
1862 drv->format_name, entry->key);
1863 }
1864
1865 goto close_and_fail;
1866 }
1867
1868 if (!bdrv_key_required(bs)) {
1869 bdrv_parent_cb_change_media(bs, true);
1870 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1871 && !runstate_check(RUN_STATE_INMIGRATE)
1872 && !runstate_check(RUN_STATE_PAUSED)) {
1873 error_setg(errp,
1874 "Guest must be stopped for opening of encrypted image");
1875 goto close_and_fail;
1876 }
1877
1878 QDECREF(options);
1879
1880
1881
1882 if (snapshot_flags) {
1883 BlockDriverState *snapshot_bs;
1884 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
1885 snapshot_options, &local_err);
1886 snapshot_options = NULL;
1887 if (local_err) {
1888 goto close_and_fail;
1889 }
1890
1891
1892
1893
1894 bdrv_unref(bs);
1895 bs = snapshot_bs;
1896 }
1897
1898 return bs;
1899
1900fail:
1901 if (file != NULL) {
1902 bdrv_unref_child(bs, file);
1903 }
1904 QDECREF(snapshot_options);
1905 QDECREF(bs->explicit_options);
1906 QDECREF(bs->options);
1907 QDECREF(options);
1908 bs->options = NULL;
1909 bdrv_unref(bs);
1910 error_propagate(errp, local_err);
1911 return NULL;
1912
1913close_and_fail:
1914 bdrv_unref(bs);
1915 QDECREF(snapshot_options);
1916 QDECREF(options);
1917 error_propagate(errp, local_err);
1918 return NULL;
1919}
1920
1921BlockDriverState *bdrv_open(const char *filename, const char *reference,
1922 QDict *options, int flags, Error **errp)
1923{
1924 return bdrv_open_inherit(filename, reference, options, flags, NULL,
1925 NULL, errp);
1926}
1927
1928typedef struct BlockReopenQueueEntry {
1929 bool prepared;
1930 BDRVReopenState state;
1931 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1932} BlockReopenQueueEntry;
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
1956 BlockDriverState *bs,
1957 QDict *options,
1958 int flags,
1959 const BdrvChildRole *role,
1960 QDict *parent_options,
1961 int parent_flags)
1962{
1963 assert(bs != NULL);
1964
1965 BlockReopenQueueEntry *bs_entry;
1966 BdrvChild *child;
1967 QDict *old_options, *explicit_options;
1968
1969 if (bs_queue == NULL) {
1970 bs_queue = g_new0(BlockReopenQueue, 1);
1971 QSIMPLEQ_INIT(bs_queue);
1972 }
1973
1974 if (!options) {
1975 options = qdict_new();
1976 }
1977
1978
1979 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1980 if (bs == bs_entry->state.bs) {
1981 break;
1982 }
1983 }
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994 if (!parent_options) {
1995
1996
1997
1998
1999
2000
2001 update_options_from_flags(options, flags);
2002 }
2003
2004
2005 if (bs_entry) {
2006 old_options = qdict_clone_shallow(bs_entry->state.explicit_options);
2007 } else {
2008 old_options = qdict_clone_shallow(bs->explicit_options);
2009 }
2010 bdrv_join_options(bs, options, old_options);
2011 QDECREF(old_options);
2012
2013 explicit_options = qdict_clone_shallow(options);
2014
2015
2016 if (parent_options) {
2017 assert(!flags);
2018 role->inherit_options(&flags, options, parent_flags, parent_options);
2019 }
2020
2021
2022 old_options = qdict_clone_shallow(bs->options);
2023 bdrv_join_options(bs, options, old_options);
2024 QDECREF(old_options);
2025
2026
2027 flags &= ~BDRV_O_PROTOCOL;
2028
2029 QLIST_FOREACH(child, &bs->children, next) {
2030 QDict *new_child_options;
2031 char *child_key_dot;
2032
2033
2034
2035
2036 if (child->bs->inherits_from != bs) {
2037 continue;
2038 }
2039
2040 child_key_dot = g_strdup_printf("%s.", child->name);
2041 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
2042 g_free(child_key_dot);
2043
2044 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
2045 child->role, options, flags);
2046 }
2047
2048 if (!bs_entry) {
2049 bs_entry = g_new0(BlockReopenQueueEntry, 1);
2050 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
2051 } else {
2052 QDECREF(bs_entry->state.options);
2053 QDECREF(bs_entry->state.explicit_options);
2054 }
2055
2056 bs_entry->state.bs = bs;
2057 bs_entry->state.options = options;
2058 bs_entry->state.explicit_options = explicit_options;
2059 bs_entry->state.flags = flags;
2060
2061 return bs_queue;
2062}
2063
2064BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
2065 BlockDriverState *bs,
2066 QDict *options, int flags)
2067{
2068 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
2069 NULL, NULL, 0);
2070}
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp)
2088{
2089 int ret = -1;
2090 BlockReopenQueueEntry *bs_entry, *next;
2091 Error *local_err = NULL;
2092
2093 assert(bs_queue != NULL);
2094
2095 aio_context_release(ctx);
2096 bdrv_drain_all_begin();
2097 aio_context_acquire(ctx);
2098
2099 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2100 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
2101 error_propagate(errp, local_err);
2102 goto cleanup;
2103 }
2104 bs_entry->prepared = true;
2105 }
2106
2107
2108
2109
2110 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2111 bdrv_reopen_commit(&bs_entry->state);
2112 }
2113
2114 ret = 0;
2115
2116cleanup:
2117 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
2118 if (ret && bs_entry->prepared) {
2119 bdrv_reopen_abort(&bs_entry->state);
2120 } else if (ret) {
2121 QDECREF(bs_entry->state.explicit_options);
2122 }
2123 QDECREF(bs_entry->state.options);
2124 g_free(bs_entry);
2125 }
2126 g_free(bs_queue);
2127
2128 bdrv_drain_all_end();
2129
2130 return ret;
2131}
2132
2133
2134
2135int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
2136{
2137 int ret = -1;
2138 Error *local_err = NULL;
2139 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
2140
2141 ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, &local_err);
2142 if (local_err != NULL) {
2143 error_propagate(errp, local_err);
2144 }
2145 return ret;
2146}
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
2167 Error **errp)
2168{
2169 int ret = -1;
2170 Error *local_err = NULL;
2171 BlockDriver *drv;
2172 QemuOpts *opts;
2173 const char *value;
2174
2175 assert(reopen_state != NULL);
2176 assert(reopen_state->bs->drv != NULL);
2177 drv = reopen_state->bs->drv;
2178
2179
2180 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
2181 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
2182 if (local_err) {
2183 error_propagate(errp, local_err);
2184 ret = -EINVAL;
2185 goto error;
2186 }
2187
2188 update_flags_from_options(&reopen_state->flags, opts);
2189
2190
2191
2192 value = qemu_opt_get(opts, "node-name");
2193 if (value) {
2194 qdict_put(reopen_state->options, "node-name", qstring_from_str(value));
2195 }
2196
2197 value = qemu_opt_get(opts, "driver");
2198 if (value) {
2199 qdict_put(reopen_state->options, "driver", qstring_from_str(value));
2200 }
2201
2202
2203
2204 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
2205 reopen_state->flags & BDRV_O_RDWR) {
2206 error_setg(errp, "Node '%s' is read only",
2207 bdrv_get_device_or_node_name(reopen_state->bs));
2208 goto error;
2209 }
2210
2211
2212 ret = bdrv_flush(reopen_state->bs);
2213 if (ret) {
2214 error_setg_errno(errp, -ret, "Error flushing drive");
2215 goto error;
2216 }
2217
2218 if (drv->bdrv_reopen_prepare) {
2219 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
2220 if (ret) {
2221 if (local_err != NULL) {
2222 error_propagate(errp, local_err);
2223 } else {
2224 error_setg(errp, "failed while preparing to reopen image '%s'",
2225 reopen_state->bs->filename);
2226 }
2227 goto error;
2228 }
2229 } else {
2230
2231
2232 error_setg(errp, "Block format '%s' used by node '%s' "
2233 "does not support reopening files", drv->format_name,
2234 bdrv_get_device_or_node_name(reopen_state->bs));
2235 ret = -1;
2236 goto error;
2237 }
2238
2239
2240
2241
2242 if (qdict_size(reopen_state->options)) {
2243 const QDictEntry *entry = qdict_first(reopen_state->options);
2244
2245 do {
2246 QString *new_obj = qobject_to_qstring(entry->value);
2247 const char *new = qstring_get_str(new_obj);
2248 const char *old = qdict_get_try_str(reopen_state->bs->options,
2249 entry->key);
2250
2251 if (!old || strcmp(new, old)) {
2252 error_setg(errp, "Cannot change the option '%s'", entry->key);
2253 ret = -EINVAL;
2254 goto error;
2255 }
2256 } while ((entry = qdict_next(reopen_state->options, entry)));
2257 }
2258
2259 ret = 0;
2260
2261error:
2262 qemu_opts_del(opts);
2263 return ret;
2264}
2265
2266
2267
2268
2269
2270
2271void bdrv_reopen_commit(BDRVReopenState *reopen_state)
2272{
2273 BlockDriver *drv;
2274
2275 assert(reopen_state != NULL);
2276 drv = reopen_state->bs->drv;
2277 assert(drv != NULL);
2278
2279
2280 if (drv->bdrv_reopen_commit) {
2281 drv->bdrv_reopen_commit(reopen_state);
2282 }
2283
2284
2285 QDECREF(reopen_state->bs->explicit_options);
2286
2287 reopen_state->bs->explicit_options = reopen_state->explicit_options;
2288 reopen_state->bs->open_flags = reopen_state->flags;
2289 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
2290
2291 bdrv_refresh_limits(reopen_state->bs, NULL);
2292}
2293
2294
2295
2296
2297
2298void bdrv_reopen_abort(BDRVReopenState *reopen_state)
2299{
2300 BlockDriver *drv;
2301
2302 assert(reopen_state != NULL);
2303 drv = reopen_state->bs->drv;
2304 assert(drv != NULL);
2305
2306 if (drv->bdrv_reopen_abort) {
2307 drv->bdrv_reopen_abort(reopen_state);
2308 }
2309
2310 QDECREF(reopen_state->explicit_options);
2311}
2312
2313
2314static void bdrv_close(BlockDriverState *bs)
2315{
2316 BdrvAioNotifier *ban, *ban_next;
2317
2318 assert(!bs->job);
2319 assert(!bs->refcnt);
2320
2321 bdrv_drained_begin(bs);
2322 bdrv_flush(bs);
2323 bdrv_drain(bs);
2324
2325 bdrv_release_named_dirty_bitmaps(bs);
2326 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2327
2328 if (bs->drv) {
2329 BdrvChild *child, *next;
2330
2331 bs->drv->bdrv_close(bs);
2332 bs->drv = NULL;
2333
2334 bdrv_set_backing_hd(bs, NULL);
2335
2336 if (bs->file != NULL) {
2337 bdrv_unref_child(bs, bs->file);
2338 bs->file = NULL;
2339 }
2340
2341 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
2342
2343
2344 if (child->bs->inherits_from == bs) {
2345 child->bs->inherits_from = NULL;
2346 }
2347 bdrv_detach_child(child);
2348 }
2349
2350 g_free(bs->opaque);
2351 bs->opaque = NULL;
2352 bs->copy_on_read = 0;
2353 bs->backing_file[0] = '\0';
2354 bs->backing_format[0] = '\0';
2355 bs->total_sectors = 0;
2356 bs->encrypted = false;
2357 bs->valid_key = false;
2358 bs->sg = false;
2359 QDECREF(bs->options);
2360 QDECREF(bs->explicit_options);
2361 bs->options = NULL;
2362 QDECREF(bs->full_open_options);
2363 bs->full_open_options = NULL;
2364 }
2365
2366 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
2367 g_free(ban);
2368 }
2369 QLIST_INIT(&bs->aio_notifiers);
2370 bdrv_drained_end(bs);
2371}
2372
2373void bdrv_close_all(void)
2374{
2375 block_job_cancel_sync_all();
2376 nbd_export_close_all();
2377
2378
2379
2380 bdrv_drain_all();
2381
2382 blk_remove_all_bs();
2383 blockdev_close_all_bdrv_states();
2384
2385 assert(QTAILQ_EMPTY(&all_bdrv_states));
2386}
2387
2388static void change_parent_backing_link(BlockDriverState *from,
2389 BlockDriverState *to)
2390{
2391 BdrvChild *c, *next, *to_c;
2392
2393 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2394 if (c->role == &child_backing) {
2395
2396
2397
2398 QLIST_FOREACH(to_c, &to->children, next) {
2399 if (to_c == c) {
2400 break;
2401 }
2402 }
2403 if (to_c) {
2404 continue;
2405 }
2406 }
2407
2408 assert(c->role != &child_backing);
2409 bdrv_ref(to);
2410 bdrv_replace_child(c, to);
2411 bdrv_unref(from);
2412 }
2413}
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2432{
2433 assert(!bdrv_requests_pending(bs_top));
2434 assert(!bdrv_requests_pending(bs_new));
2435
2436 bdrv_ref(bs_top);
2437
2438 change_parent_backing_link(bs_top, bs_new);
2439 bdrv_set_backing_hd(bs_new, bs_top);
2440 bdrv_unref(bs_top);
2441
2442
2443
2444 bdrv_unref(bs_new);
2445}
2446
2447void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2448{
2449 assert(!bdrv_requests_pending(old));
2450 assert(!bdrv_requests_pending(new));
2451
2452 bdrv_ref(old);
2453
2454 change_parent_backing_link(old, new);
2455
2456 bdrv_unref(old);
2457}
2458
2459static void bdrv_delete(BlockDriverState *bs)
2460{
2461 assert(!bs->job);
2462 assert(bdrv_op_blocker_is_empty(bs));
2463 assert(!bs->refcnt);
2464
2465 bdrv_close(bs);
2466
2467
2468 if (bs->node_name[0] != '\0') {
2469 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
2470 }
2471 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
2472
2473 g_free(bs);
2474}
2475
2476
2477
2478
2479
2480
2481
2482
2483int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2484{
2485 if (bs->drv == NULL) {
2486 return -ENOMEDIUM;
2487 }
2488 if (bs->drv->bdrv_check == NULL) {
2489 return -ENOTSUP;
2490 }
2491
2492 memset(res, 0, sizeof(*res));
2493 return bs->drv->bdrv_check(bs, res, fix);
2494}
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504int bdrv_change_backing_file(BlockDriverState *bs,
2505 const char *backing_file, const char *backing_fmt)
2506{
2507 BlockDriver *drv = bs->drv;
2508 int ret;
2509
2510
2511 if (backing_fmt && !backing_file) {
2512 return -EINVAL;
2513 }
2514
2515 if (drv->bdrv_change_backing_file != NULL) {
2516 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2517 } else {
2518 ret = -ENOTSUP;
2519 }
2520
2521 if (ret == 0) {
2522 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2523 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2524 }
2525 return ret;
2526}
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2539 BlockDriverState *bs)
2540{
2541 while (active && bs != backing_bs(active)) {
2542 active = backing_bs(active);
2543 }
2544
2545 return active;
2546}
2547
2548
2549BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2550{
2551 return bdrv_find_overlay(bs, NULL);
2552}
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2584 BlockDriverState *base, const char *backing_file_str)
2585{
2586 BlockDriverState *new_top_bs = NULL;
2587 int ret = -EIO;
2588
2589 if (!top->drv || !base->drv) {
2590 goto exit;
2591 }
2592
2593 new_top_bs = bdrv_find_overlay(active, top);
2594
2595 if (new_top_bs == NULL) {
2596
2597 goto exit;
2598 }
2599
2600
2601
2602 if (backing_bs(new_top_bs) == base) {
2603 ret = 0;
2604 goto exit;
2605 }
2606
2607
2608 if (!bdrv_chain_contains(top, base)) {
2609 goto exit;
2610 }
2611
2612
2613 backing_file_str = backing_file_str ? backing_file_str : base->filename;
2614 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2615 base->drv ? base->drv->format_name : "");
2616 if (ret) {
2617 goto exit;
2618 }
2619 bdrv_set_backing_hd(new_top_bs, base);
2620
2621 ret = 0;
2622exit:
2623 return ret;
2624}
2625
2626
2627
2628
2629int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2630{
2631 BlockDriver *drv = bs->drv;
2632 int ret;
2633 if (!drv)
2634 return -ENOMEDIUM;
2635 if (!drv->bdrv_truncate)
2636 return -ENOTSUP;
2637 if (bs->read_only)
2638 return -EACCES;
2639
2640 ret = drv->bdrv_truncate(bs, offset);
2641 if (ret == 0) {
2642 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2643 bdrv_dirty_bitmap_truncate(bs);
2644 bdrv_parent_cb_resize(bs);
2645 ++bs->write_gen;
2646 }
2647 return ret;
2648}
2649
2650
2651
2652
2653
2654int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2655{
2656 BlockDriver *drv = bs->drv;
2657 if (!drv) {
2658 return -ENOMEDIUM;
2659 }
2660 if (drv->bdrv_get_allocated_file_size) {
2661 return drv->bdrv_get_allocated_file_size(bs);
2662 }
2663 if (bs->file) {
2664 return bdrv_get_allocated_file_size(bs->file->bs);
2665 }
2666 return -ENOTSUP;
2667}
2668
2669
2670
2671
2672int64_t bdrv_nb_sectors(BlockDriverState *bs)
2673{
2674 BlockDriver *drv = bs->drv;
2675
2676 if (!drv)
2677 return -ENOMEDIUM;
2678
2679 if (drv->has_variable_length) {
2680 int ret = refresh_total_sectors(bs, bs->total_sectors);
2681 if (ret < 0) {
2682 return ret;
2683 }
2684 }
2685 return bs->total_sectors;
2686}
2687
2688
2689
2690
2691
2692int64_t bdrv_getlength(BlockDriverState *bs)
2693{
2694 int64_t ret = bdrv_nb_sectors(bs);
2695
2696 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2697 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2698}
2699
2700
2701void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2702{
2703 int64_t nb_sectors = bdrv_nb_sectors(bs);
2704
2705 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2706}
2707
2708bool bdrv_is_read_only(BlockDriverState *bs)
2709{
2710 return bs->read_only;
2711}
2712
2713bool bdrv_is_sg(BlockDriverState *bs)
2714{
2715 return bs->sg;
2716}
2717
2718bool bdrv_is_encrypted(BlockDriverState *bs)
2719{
2720 if (bs->backing && bs->backing->bs->encrypted) {
2721 return true;
2722 }
2723 return bs->encrypted;
2724}
2725
2726bool bdrv_key_required(BlockDriverState *bs)
2727{
2728 BdrvChild *backing = bs->backing;
2729
2730 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2731 return true;
2732 }
2733 return (bs->encrypted && !bs->valid_key);
2734}
2735
2736int bdrv_set_key(BlockDriverState *bs, const char *key)
2737{
2738 int ret;
2739 if (bs->backing && bs->backing->bs->encrypted) {
2740 ret = bdrv_set_key(bs->backing->bs, key);
2741 if (ret < 0)
2742 return ret;
2743 if (!bs->encrypted)
2744 return 0;
2745 }
2746 if (!bs->encrypted) {
2747 return -EINVAL;
2748 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2749 return -ENOMEDIUM;
2750 }
2751 ret = bs->drv->bdrv_set_key(bs, key);
2752 if (ret < 0) {
2753 bs->valid_key = false;
2754 } else if (!bs->valid_key) {
2755
2756 bs->valid_key = true;
2757 bdrv_parent_cb_change_media(bs, true);
2758 }
2759 return ret;
2760}
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2774{
2775 if (key) {
2776 if (!bdrv_is_encrypted(bs)) {
2777 error_setg(errp, "Node '%s' is not encrypted",
2778 bdrv_get_device_or_node_name(bs));
2779 } else if (bdrv_set_key(bs, key) < 0) {
2780 error_setg(errp, QERR_INVALID_PASSWORD);
2781 }
2782 } else {
2783 if (bdrv_key_required(bs)) {
2784 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2785 "'%s' (%s) is encrypted",
2786 bdrv_get_device_or_node_name(bs),
2787 bdrv_get_encrypted_filename(bs));
2788 }
2789 }
2790}
2791
2792const char *bdrv_get_format_name(BlockDriverState *bs)
2793{
2794 return bs->drv ? bs->drv->format_name : NULL;
2795}
2796
2797static int qsort_strcmp(const void *a, const void *b)
2798{
2799 return strcmp(*(char *const *)a, *(char *const *)b);
2800}
2801
2802void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2803 void *opaque)
2804{
2805 BlockDriver *drv;
2806 int count = 0;
2807 int i;
2808 const char **formats = NULL;
2809
2810 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2811 if (drv->format_name) {
2812 bool found = false;
2813 int i = count;
2814 while (formats && i && !found) {
2815 found = !strcmp(formats[--i], drv->format_name);
2816 }
2817
2818 if (!found) {
2819 formats = g_renew(const char *, formats, count + 1);
2820 formats[count++] = drv->format_name;
2821 }
2822 }
2823 }
2824
2825 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
2826 const char *format_name = block_driver_modules[i].format_name;
2827
2828 if (format_name) {
2829 bool found = false;
2830 int j = count;
2831
2832 while (formats && j && !found) {
2833 found = !strcmp(formats[--j], format_name);
2834 }
2835
2836 if (!found) {
2837 formats = g_renew(const char *, formats, count + 1);
2838 formats[count++] = format_name;
2839 }
2840 }
2841 }
2842
2843 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2844
2845 for (i = 0; i < count; i++) {
2846 it(opaque, formats[i]);
2847 }
2848
2849 g_free(formats);
2850}
2851
2852
2853BlockDriverState *bdrv_find_node(const char *node_name)
2854{
2855 BlockDriverState *bs;
2856
2857 assert(node_name);
2858
2859 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2860 if (!strcmp(node_name, bs->node_name)) {
2861 return bs;
2862 }
2863 }
2864 return NULL;
2865}
2866
2867
2868BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2869{
2870 BlockDeviceInfoList *list, *entry;
2871 BlockDriverState *bs;
2872
2873 list = NULL;
2874 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2875 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
2876 if (!info) {
2877 qapi_free_BlockDeviceInfoList(list);
2878 return NULL;
2879 }
2880 entry = g_malloc0(sizeof(*entry));
2881 entry->value = info;
2882 entry->next = list;
2883 list = entry;
2884 }
2885
2886 return list;
2887}
2888
2889BlockDriverState *bdrv_lookup_bs(const char *device,
2890 const char *node_name,
2891 Error **errp)
2892{
2893 BlockBackend *blk;
2894 BlockDriverState *bs;
2895
2896 if (device) {
2897 blk = blk_by_name(device);
2898
2899 if (blk) {
2900 bs = blk_bs(blk);
2901 if (!bs) {
2902 error_setg(errp, "Device '%s' has no medium", device);
2903 }
2904
2905 return bs;
2906 }
2907 }
2908
2909 if (node_name) {
2910 bs = bdrv_find_node(node_name);
2911
2912 if (bs) {
2913 return bs;
2914 }
2915 }
2916
2917 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2918 device ? device : "",
2919 node_name ? node_name : "");
2920 return NULL;
2921}
2922
2923
2924
2925bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2926{
2927 while (top && top != base) {
2928 top = backing_bs(top);
2929 }
2930
2931 return top != NULL;
2932}
2933
2934BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2935{
2936 if (!bs) {
2937 return QTAILQ_FIRST(&graph_bdrv_states);
2938 }
2939 return QTAILQ_NEXT(bs, node_list);
2940}
2941
2942const char *bdrv_get_node_name(const BlockDriverState *bs)
2943{
2944 return bs->node_name;
2945}
2946
2947const char *bdrv_get_parent_name(const BlockDriverState *bs)
2948{
2949 BdrvChild *c;
2950 const char *name;
2951
2952
2953 QLIST_FOREACH(c, &bs->parents, next_parent) {
2954 if (c->role->get_name) {
2955 name = c->role->get_name(c);
2956 if (name && *name) {
2957 return name;
2958 }
2959 }
2960 }
2961
2962 return NULL;
2963}
2964
2965
2966const char *bdrv_get_device_name(const BlockDriverState *bs)
2967{
2968 return bdrv_get_parent_name(bs) ?: "";
2969}
2970
2971
2972
2973
2974
2975const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2976{
2977 return bdrv_get_parent_name(bs) ?: bs->node_name;
2978}
2979
2980int bdrv_get_flags(BlockDriverState *bs)
2981{
2982 return bs->open_flags;
2983}
2984
2985int bdrv_has_zero_init_1(BlockDriverState *bs)
2986{
2987 return 1;
2988}
2989
2990int bdrv_has_zero_init(BlockDriverState *bs)
2991{
2992 assert(bs->drv);
2993
2994
2995
2996 if (bs->backing) {
2997 return 0;
2998 }
2999 if (bs->drv->bdrv_has_zero_init) {
3000 return bs->drv->bdrv_has_zero_init(bs);
3001 }
3002
3003
3004 return 0;
3005}
3006
3007bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3008{
3009 BlockDriverInfo bdi;
3010
3011 if (bs->backing) {
3012 return false;
3013 }
3014
3015 if (bdrv_get_info(bs, &bdi) == 0) {
3016 return bdi.unallocated_blocks_are_zero;
3017 }
3018
3019 return false;
3020}
3021
3022bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3023{
3024 BlockDriverInfo bdi;
3025
3026 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3027 return false;
3028 }
3029
3030 if (bdrv_get_info(bs, &bdi) == 0) {
3031 return bdi.can_write_zeroes_with_unmap;
3032 }
3033
3034 return false;
3035}
3036
3037const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3038{
3039 if (bs->backing && bs->backing->bs->encrypted)
3040 return bs->backing_file;
3041 else if (bs->encrypted)
3042 return bs->filename;
3043 else
3044 return NULL;
3045}
3046
3047void bdrv_get_backing_filename(BlockDriverState *bs,
3048 char *filename, int filename_size)
3049{
3050 pstrcpy(filename, filename_size, bs->backing_file);
3051}
3052
3053int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3054{
3055 BlockDriver *drv = bs->drv;
3056 if (!drv)
3057 return -ENOMEDIUM;
3058 if (!drv->bdrv_get_info)
3059 return -ENOTSUP;
3060 memset(bdi, 0, sizeof(*bdi));
3061 return drv->bdrv_get_info(bs, bdi);
3062}
3063
3064ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3065{
3066 BlockDriver *drv = bs->drv;
3067 if (drv && drv->bdrv_get_specific_info) {
3068 return drv->bdrv_get_specific_info(bs);
3069 }
3070 return NULL;
3071}
3072
3073void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
3074{
3075 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3076 return;
3077 }
3078
3079 bs->drv->bdrv_debug_event(bs, event);
3080}
3081
3082int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3083 const char *tag)
3084{
3085 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3086 bs = bs->file ? bs->file->bs : NULL;
3087 }
3088
3089 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3090 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3091 }
3092
3093 return -ENOTSUP;
3094}
3095
3096int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3097{
3098 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3099 bs = bs->file ? bs->file->bs : NULL;
3100 }
3101
3102 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3103 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3104 }
3105
3106 return -ENOTSUP;
3107}
3108
3109int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3110{
3111 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3112 bs = bs->file ? bs->file->bs : NULL;
3113 }
3114
3115 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3116 return bs->drv->bdrv_debug_resume(bs, tag);
3117 }
3118
3119 return -ENOTSUP;
3120}
3121
3122bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3123{
3124 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3125 bs = bs->file ? bs->file->bs : NULL;
3126 }
3127
3128 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3129 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3130 }
3131
3132 return false;
3133}
3134
3135
3136
3137
3138
3139BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3140 const char *backing_file)
3141{
3142 char *filename_full = NULL;
3143 char *backing_file_full = NULL;
3144 char *filename_tmp = NULL;
3145 int is_protocol = 0;
3146 BlockDriverState *curr_bs = NULL;
3147 BlockDriverState *retval = NULL;
3148
3149 if (!bs || !bs->drv || !backing_file) {
3150 return NULL;
3151 }
3152
3153 filename_full = g_malloc(PATH_MAX);
3154 backing_file_full = g_malloc(PATH_MAX);
3155 filename_tmp = g_malloc(PATH_MAX);
3156
3157 is_protocol = path_has_protocol(backing_file);
3158
3159 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
3160
3161
3162
3163 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3164 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3165 retval = curr_bs->backing->bs;
3166 break;
3167 }
3168 } else {
3169
3170
3171 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3172 backing_file);
3173
3174
3175 if (!realpath(filename_tmp, filename_full)) {
3176 continue;
3177 }
3178
3179
3180
3181 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3182 curr_bs->backing_file);
3183
3184 if (!realpath(filename_tmp, backing_file_full)) {
3185 continue;
3186 }
3187
3188 if (strcmp(backing_file_full, filename_full) == 0) {
3189 retval = curr_bs->backing->bs;
3190 break;
3191 }
3192 }
3193 }
3194
3195 g_free(filename_full);
3196 g_free(backing_file_full);
3197 g_free(filename_tmp);
3198 return retval;
3199}
3200
3201int bdrv_get_backing_file_depth(BlockDriverState *bs)
3202{
3203 if (!bs->drv) {
3204 return 0;
3205 }
3206
3207 if (!bs->backing) {
3208 return 0;
3209 }
3210
3211 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3212}
3213
3214void bdrv_init(void)
3215{
3216 module_call_init(MODULE_INIT_BLOCK);
3217}
3218
3219void bdrv_init_with_whitelist(void)
3220{
3221 use_bdrv_whitelist = 1;
3222 bdrv_init();
3223}
3224
3225void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3226{
3227 BdrvChild *child;
3228 Error *local_err = NULL;
3229 int ret;
3230
3231 if (!bs->drv) {
3232 return;
3233 }
3234
3235 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
3236 return;
3237 }
3238 bs->open_flags &= ~BDRV_O_INACTIVE;
3239
3240 if (bs->drv->bdrv_invalidate_cache) {
3241 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3242 if (local_err) {
3243 bs->open_flags |= BDRV_O_INACTIVE;
3244 error_propagate(errp, local_err);
3245 return;
3246 }
3247 }
3248
3249 QLIST_FOREACH(child, &bs->children, next) {
3250 bdrv_invalidate_cache(child->bs, &local_err);
3251 if (local_err) {
3252 bs->open_flags |= BDRV_O_INACTIVE;
3253 error_propagate(errp, local_err);
3254 return;
3255 }
3256 }
3257
3258 ret = refresh_total_sectors(bs, bs->total_sectors);
3259 if (ret < 0) {
3260 bs->open_flags |= BDRV_O_INACTIVE;
3261 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3262 return;
3263 }
3264}
3265
3266void bdrv_invalidate_cache_all(Error **errp)
3267{
3268 BlockDriverState *bs;
3269 Error *local_err = NULL;
3270 BdrvNextIterator it;
3271
3272 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3273 AioContext *aio_context = bdrv_get_aio_context(bs);
3274
3275 aio_context_acquire(aio_context);
3276 bdrv_invalidate_cache(bs, &local_err);
3277 aio_context_release(aio_context);
3278 if (local_err) {
3279 error_propagate(errp, local_err);
3280 return;
3281 }
3282 }
3283}
3284
3285static int bdrv_inactivate_recurse(BlockDriverState *bs,
3286 bool setting_flag)
3287{
3288 BdrvChild *child;
3289 int ret;
3290
3291 if (!setting_flag && bs->drv->bdrv_inactivate) {
3292 ret = bs->drv->bdrv_inactivate(bs);
3293 if (ret < 0) {
3294 return ret;
3295 }
3296 }
3297
3298 QLIST_FOREACH(child, &bs->children, next) {
3299 ret = bdrv_inactivate_recurse(child->bs, setting_flag);
3300 if (ret < 0) {
3301 return ret;
3302 }
3303 }
3304
3305 if (setting_flag) {
3306 bs->open_flags |= BDRV_O_INACTIVE;
3307 }
3308 return 0;
3309}
3310
3311int bdrv_inactivate_all(void)
3312{
3313 BlockDriverState *bs = NULL;
3314 BdrvNextIterator it;
3315 int ret = 0;
3316 int pass;
3317
3318 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3319 aio_context_acquire(bdrv_get_aio_context(bs));
3320 }
3321
3322
3323
3324
3325
3326 for (pass = 0; pass < 2; pass++) {
3327 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3328 ret = bdrv_inactivate_recurse(bs, pass);
3329 if (ret < 0) {
3330 goto out;
3331 }
3332 }
3333 }
3334
3335out:
3336 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3337 aio_context_release(bdrv_get_aio_context(bs));
3338 }
3339
3340 return ret;
3341}
3342
3343
3344
3345
3346
3347
3348
3349bool bdrv_is_inserted(BlockDriverState *bs)
3350{
3351 BlockDriver *drv = bs->drv;
3352 BdrvChild *child;
3353
3354 if (!drv) {
3355 return false;
3356 }
3357 if (drv->bdrv_is_inserted) {
3358 return drv->bdrv_is_inserted(bs);
3359 }
3360 QLIST_FOREACH(child, &bs->children, next) {
3361 if (!bdrv_is_inserted(child->bs)) {
3362 return false;
3363 }
3364 }
3365 return true;
3366}
3367
3368
3369
3370
3371
3372int bdrv_media_changed(BlockDriverState *bs)
3373{
3374 BlockDriver *drv = bs->drv;
3375
3376 if (drv && drv->bdrv_media_changed) {
3377 return drv->bdrv_media_changed(bs);
3378 }
3379 return -ENOTSUP;
3380}
3381
3382
3383
3384
3385void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3386{
3387 BlockDriver *drv = bs->drv;
3388
3389 if (drv && drv->bdrv_eject) {
3390 drv->bdrv_eject(bs, eject_flag);
3391 }
3392}
3393
3394
3395
3396
3397
3398void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3399{
3400 BlockDriver *drv = bs->drv;
3401
3402 trace_bdrv_lock_medium(bs, locked);
3403
3404 if (drv && drv->bdrv_lock_medium) {
3405 drv->bdrv_lock_medium(bs, locked);
3406 }
3407}
3408
3409
3410void bdrv_ref(BlockDriverState *bs)
3411{
3412 bs->refcnt++;
3413}
3414
3415
3416
3417
3418void bdrv_unref(BlockDriverState *bs)
3419{
3420 if (!bs) {
3421 return;
3422 }
3423 assert(bs->refcnt > 0);
3424 if (--bs->refcnt == 0) {
3425 bdrv_delete(bs);
3426 }
3427}
3428
3429struct BdrvOpBlocker {
3430 Error *reason;
3431 QLIST_ENTRY(BdrvOpBlocker) list;
3432};
3433
3434bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3435{
3436 BdrvOpBlocker *blocker;
3437 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3438 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3439 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3440 if (errp) {
3441 *errp = error_copy(blocker->reason);
3442 error_prepend(errp, "Node '%s' is busy: ",
3443 bdrv_get_device_or_node_name(bs));
3444 }
3445 return true;
3446 }
3447 return false;
3448}
3449
3450void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3451{
3452 BdrvOpBlocker *blocker;
3453 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3454
3455 blocker = g_new0(BdrvOpBlocker, 1);
3456 blocker->reason = reason;
3457 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3458}
3459
3460void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3461{
3462 BdrvOpBlocker *blocker, *next;
3463 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3464 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3465 if (blocker->reason == reason) {
3466 QLIST_REMOVE(blocker, list);
3467 g_free(blocker);
3468 }
3469 }
3470}
3471
3472void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3473{
3474 int i;
3475 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3476 bdrv_op_block(bs, i, reason);
3477 }
3478}
3479
3480void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3481{
3482 int i;
3483 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3484 bdrv_op_unblock(bs, i, reason);
3485 }
3486}
3487
3488bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3489{
3490 int i;
3491
3492 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3493 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3494 return false;
3495 }
3496 }
3497 return true;
3498}
3499
3500void bdrv_img_create(const char *filename, const char *fmt,
3501 const char *base_filename, const char *base_fmt,
3502 char *options, uint64_t img_size, int flags,
3503 Error **errp, bool quiet)
3504{
3505 QemuOptsList *create_opts = NULL;
3506 QemuOpts *opts = NULL;
3507 const char *backing_fmt, *backing_file;
3508 int64_t size;
3509 BlockDriver *drv, *proto_drv;
3510 Error *local_err = NULL;
3511 int ret = 0;
3512
3513
3514 drv = bdrv_find_format(fmt);
3515 if (!drv) {
3516 error_setg(errp, "Unknown file format '%s'", fmt);
3517 return;
3518 }
3519
3520 proto_drv = bdrv_find_protocol(filename, true, errp);
3521 if (!proto_drv) {
3522 return;
3523 }
3524
3525 if (!drv->create_opts) {
3526 error_setg(errp, "Format driver '%s' does not support image creation",
3527 drv->format_name);
3528 return;
3529 }
3530
3531 if (!proto_drv->create_opts) {
3532 error_setg(errp, "Protocol driver '%s' does not support image creation",
3533 proto_drv->format_name);
3534 return;
3535 }
3536
3537 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3538 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3539
3540
3541 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3542 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3543
3544
3545 if (options) {
3546 qemu_opts_do_parse(opts, options, NULL, &local_err);
3547 if (local_err) {
3548 error_report_err(local_err);
3549 local_err = NULL;
3550 error_setg(errp, "Invalid options for file format '%s'", fmt);
3551 goto out;
3552 }
3553 }
3554
3555 if (base_filename) {
3556 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3557 if (local_err) {
3558 error_setg(errp, "Backing file not supported for file format '%s'",
3559 fmt);
3560 goto out;
3561 }
3562 }
3563
3564 if (base_fmt) {
3565 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3566 if (local_err) {
3567 error_setg(errp, "Backing file format not supported for file "
3568 "format '%s'", fmt);
3569 goto out;
3570 }
3571 }
3572
3573 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3574 if (backing_file) {
3575 if (!strcmp(filename, backing_file)) {
3576 error_setg(errp, "Error: Trying to create an image with the "
3577 "same filename as the backing file");
3578 goto out;
3579 }
3580 }
3581
3582 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3583
3584
3585
3586 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3587 if (size == -1) {
3588 if (backing_file) {
3589 BlockDriverState *bs;
3590 char *full_backing = g_new0(char, PATH_MAX);
3591 int64_t size;
3592 int back_flags;
3593 QDict *backing_options = NULL;
3594
3595 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3596 full_backing, PATH_MAX,
3597 &local_err);
3598 if (local_err) {
3599 g_free(full_backing);
3600 goto out;
3601 }
3602
3603
3604 back_flags = flags;
3605 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3606
3607 if (backing_fmt) {
3608 backing_options = qdict_new();
3609 qdict_put(backing_options, "driver",
3610 qstring_from_str(backing_fmt));
3611 }
3612
3613 bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
3614 &local_err);
3615 g_free(full_backing);
3616 if (!bs) {
3617 goto out;
3618 }
3619 size = bdrv_getlength(bs);
3620 if (size < 0) {
3621 error_setg_errno(errp, -size, "Could not get size of '%s'",
3622 backing_file);
3623 bdrv_unref(bs);
3624 goto out;
3625 }
3626
3627 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3628
3629 bdrv_unref(bs);
3630 } else {
3631 error_setg(errp, "Image creation needs a size parameter");
3632 goto out;
3633 }
3634 }
3635
3636 if (!quiet) {
3637 printf("Formatting '%s', fmt=%s ", filename, fmt);
3638 qemu_opts_print(opts, " ");
3639 puts("");
3640 }
3641
3642 ret = bdrv_create(drv, filename, opts, &local_err);
3643
3644 if (ret == -EFBIG) {
3645
3646
3647
3648 const char *cluster_size_hint = "";
3649 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3650 cluster_size_hint = " (try using a larger cluster size)";
3651 }
3652 error_setg(errp, "The image size is too large for file format '%s'"
3653 "%s", fmt, cluster_size_hint);
3654 error_free(local_err);
3655 local_err = NULL;
3656 }
3657
3658out:
3659 qemu_opts_del(opts);
3660 qemu_opts_free(create_opts);
3661 error_propagate(errp, local_err);
3662}
3663
3664AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3665{
3666 return bs->aio_context;
3667}
3668
3669static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
3670{
3671 QLIST_REMOVE(ban, list);
3672 g_free(ban);
3673}
3674
3675void bdrv_detach_aio_context(BlockDriverState *bs)
3676{
3677 BdrvAioNotifier *baf, *baf_tmp;
3678 BdrvChild *child;
3679
3680 if (!bs->drv) {
3681 return;
3682 }
3683
3684 assert(!bs->walking_aio_notifiers);
3685 bs->walking_aio_notifiers = true;
3686 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
3687 if (baf->deleted) {
3688 bdrv_do_remove_aio_context_notifier(baf);
3689 } else {
3690 baf->detach_aio_context(baf->opaque);
3691 }
3692 }
3693
3694
3695
3696 bs->walking_aio_notifiers = false;
3697
3698 if (bs->drv->bdrv_detach_aio_context) {
3699 bs->drv->bdrv_detach_aio_context(bs);
3700 }
3701 QLIST_FOREACH(child, &bs->children, next) {
3702 bdrv_detach_aio_context(child->bs);
3703 }
3704
3705 bs->aio_context = NULL;
3706}
3707
3708void bdrv_attach_aio_context(BlockDriverState *bs,
3709 AioContext *new_context)
3710{
3711 BdrvAioNotifier *ban, *ban_tmp;
3712 BdrvChild *child;
3713
3714 if (!bs->drv) {
3715 return;
3716 }
3717
3718 bs->aio_context = new_context;
3719
3720 QLIST_FOREACH(child, &bs->children, next) {
3721 bdrv_attach_aio_context(child->bs, new_context);
3722 }
3723 if (bs->drv->bdrv_attach_aio_context) {
3724 bs->drv->bdrv_attach_aio_context(bs, new_context);
3725 }
3726
3727 assert(!bs->walking_aio_notifiers);
3728 bs->walking_aio_notifiers = true;
3729 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
3730 if (ban->deleted) {
3731 bdrv_do_remove_aio_context_notifier(ban);
3732 } else {
3733 ban->attached_aio_context(new_context, ban->opaque);
3734 }
3735 }
3736 bs->walking_aio_notifiers = false;
3737}
3738
3739void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3740{
3741 bdrv_drain(bs);
3742
3743 bdrv_detach_aio_context(bs);
3744
3745
3746
3747
3748 aio_context_acquire(new_context);
3749 bdrv_attach_aio_context(bs, new_context);
3750 aio_context_release(new_context);
3751}
3752
3753void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3754 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3755 void (*detach_aio_context)(void *opaque), void *opaque)
3756{
3757 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3758 *ban = (BdrvAioNotifier){
3759 .attached_aio_context = attached_aio_context,
3760 .detach_aio_context = detach_aio_context,
3761 .opaque = opaque
3762 };
3763
3764 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3765}
3766
3767void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3768 void (*attached_aio_context)(AioContext *,
3769 void *),
3770 void (*detach_aio_context)(void *),
3771 void *opaque)
3772{
3773 BdrvAioNotifier *ban, *ban_next;
3774
3775 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3776 if (ban->attached_aio_context == attached_aio_context &&
3777 ban->detach_aio_context == detach_aio_context &&
3778 ban->opaque == opaque &&
3779 ban->deleted == false)
3780 {
3781 if (bs->walking_aio_notifiers) {
3782 ban->deleted = true;
3783 } else {
3784 bdrv_do_remove_aio_context_notifier(ban);
3785 }
3786 return;
3787 }
3788 }
3789
3790 abort();
3791}
3792
3793int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3794 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
3795{
3796 if (!bs->drv->bdrv_amend_options) {
3797 return -ENOTSUP;
3798 }
3799 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
3800}
3801
3802
3803
3804
3805
3806
3807bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3808 BlockDriverState *candidate)
3809{
3810
3811 if (!bs || !bs->drv) {
3812 return false;
3813 }
3814
3815
3816
3817
3818 if (!bs->drv->is_filter) {
3819 return bs == candidate;
3820 }
3821
3822
3823
3824
3825
3826 if (bs->drv->bdrv_recurse_is_first_non_filter) {
3827 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
3828 }
3829
3830
3831
3832 return false;
3833}
3834
3835
3836
3837
3838
3839bool bdrv_is_first_non_filter(BlockDriverState *candidate)
3840{
3841 BlockDriverState *bs;
3842 BdrvNextIterator it;
3843
3844
3845 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3846 bool perm;
3847
3848
3849 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
3850
3851
3852 if (perm) {
3853 return true;
3854 }
3855 }
3856
3857 return false;
3858}
3859
3860BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
3861 const char *node_name, Error **errp)
3862{
3863 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
3864 AioContext *aio_context;
3865
3866 if (!to_replace_bs) {
3867 error_setg(errp, "Node name '%s' not found", node_name);
3868 return NULL;
3869 }
3870
3871 aio_context = bdrv_get_aio_context(to_replace_bs);
3872 aio_context_acquire(aio_context);
3873
3874 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
3875 to_replace_bs = NULL;
3876 goto out;
3877 }
3878
3879
3880
3881
3882
3883
3884 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
3885 error_setg(errp, "Only top most non filter can be replaced");
3886 to_replace_bs = NULL;
3887 goto out;
3888 }
3889
3890out:
3891 aio_context_release(aio_context);
3892 return to_replace_bs;
3893}
3894
3895static bool append_open_options(QDict *d, BlockDriverState *bs)
3896{
3897 const QDictEntry *entry;
3898 QemuOptDesc *desc;
3899 BdrvChild *child;
3900 bool found_any = false;
3901 const char *p;
3902
3903 for (entry = qdict_first(bs->options); entry;
3904 entry = qdict_next(bs->options, entry))
3905 {
3906
3907 QLIST_FOREACH(child, &bs->children, next) {
3908 if (strstart(qdict_entry_key(entry), child->name, &p)
3909 && (!*p || *p == '.'))
3910 {
3911 break;
3912 }
3913 }
3914 if (child) {
3915 continue;
3916 }
3917
3918
3919 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
3920 if (!strcmp(qdict_entry_key(entry), desc->name)) {
3921 break;
3922 }
3923 }
3924 if (desc->name) {
3925 continue;
3926 }
3927
3928 qobject_incref(qdict_entry_value(entry));
3929 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
3930 found_any = true;
3931 }
3932
3933 return found_any;
3934}
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948void bdrv_refresh_filename(BlockDriverState *bs)
3949{
3950 BlockDriver *drv = bs->drv;
3951 QDict *opts;
3952
3953 if (!drv) {
3954 return;
3955 }
3956
3957
3958
3959 if (bs->file) {
3960 bdrv_refresh_filename(bs->file->bs);
3961 }
3962
3963 if (drv->bdrv_refresh_filename) {
3964
3965
3966 bs->exact_filename[0] = '\0';
3967 if (bs->full_open_options) {
3968 QDECREF(bs->full_open_options);
3969 bs->full_open_options = NULL;
3970 }
3971
3972 opts = qdict_new();
3973 append_open_options(opts, bs);
3974 drv->bdrv_refresh_filename(bs, opts);
3975 QDECREF(opts);
3976 } else if (bs->file) {
3977
3978 bool has_open_options;
3979
3980 bs->exact_filename[0] = '\0';
3981 if (bs->full_open_options) {
3982 QDECREF(bs->full_open_options);
3983 bs->full_open_options = NULL;
3984 }
3985
3986 opts = qdict_new();
3987 has_open_options = append_open_options(opts, bs);
3988
3989
3990
3991 if (bs->file->bs->exact_filename[0] && !has_open_options) {
3992 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
3993 }
3994
3995
3996
3997
3998
3999 if (bs->file->bs->full_open_options) {
4000 qdict_put_obj(opts, "driver",
4001 QOBJECT(qstring_from_str(drv->format_name)));
4002 QINCREF(bs->file->bs->full_open_options);
4003 qdict_put_obj(opts, "file",
4004 QOBJECT(bs->file->bs->full_open_options));
4005
4006 bs->full_open_options = opts;
4007 } else {
4008 QDECREF(opts);
4009 }
4010 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4011
4012
4013
4014
4015
4016
4017
4018 opts = qdict_new();
4019 append_open_options(opts, bs);
4020 qdict_put_obj(opts, "driver",
4021 QOBJECT(qstring_from_str(drv->format_name)));
4022
4023 if (bs->exact_filename[0]) {
4024
4025
4026
4027
4028
4029
4030
4031 qdict_put_obj(opts, "filename",
4032 QOBJECT(qstring_from_str(bs->exact_filename)));
4033 }
4034
4035 bs->full_open_options = opts;
4036 }
4037
4038 if (bs->exact_filename[0]) {
4039 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4040 } else if (bs->full_open_options) {
4041 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4042 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4043 qstring_get_str(json));
4044 QDECREF(json);
4045 }
4046}
4047
4048
4049
4050
4051
4052void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
4053 Error **errp)
4054{
4055
4056 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
4057 error_setg(errp, "The node %s does not support adding a child",
4058 bdrv_get_device_or_node_name(parent_bs));
4059 return;
4060 }
4061
4062 if (!QLIST_EMPTY(&child_bs->parents)) {
4063 error_setg(errp, "The node %s already has a parent",
4064 child_bs->node_name);
4065 return;
4066 }
4067
4068 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
4069}
4070
4071void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
4072{
4073 BdrvChild *tmp;
4074
4075 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
4076 error_setg(errp, "The node %s does not support removing a child",
4077 bdrv_get_device_or_node_name(parent_bs));
4078 return;
4079 }
4080
4081 QLIST_FOREACH(tmp, &parent_bs->children, next) {
4082 if (tmp == child) {
4083 break;
4084 }
4085 }
4086
4087 if (!tmp) {
4088 error_setg(errp, "The node %s does not have a child named %s",
4089 bdrv_get_device_or_node_name(parent_bs),
4090 bdrv_get_device_or_node_name(child->bs));
4091 return;
4092 }
4093
4094 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
4095}
4096