xref: /openbmc/qemu/block.c (revision 10500ce2)
1 /*
2  * QEMU System Emulator block driver
3  *
4  * Copyright (c) 2003 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 #include "config-host.h"
25 #include "qemu-common.h"
26 #include "trace.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qjson.h"
31 #include "sysemu/block-backend.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "block/qapi.h"
36 #include "qmp-commands.h"
37 #include "qemu/timer.h"
38 #include "qapi-event.h"
39 #include "block/throttle-groups.h"
40 
41 #ifdef CONFIG_BSD
42 #include <sys/types.h>
43 #include <sys/stat.h>
44 #include <sys/ioctl.h>
45 #include <sys/queue.h>
46 #ifndef __DragonFly__
47 #include <sys/disk.h>
48 #endif
49 #endif
50 
51 #ifdef _WIN32
52 #include <windows.h>
53 #endif
54 
55 /**
56  * A BdrvDirtyBitmap can be in three possible states:
57  * (1) successor is NULL and disabled is false: full r/w mode
58  * (2) successor is NULL and disabled is true: read only mode ("disabled")
59  * (3) successor is set: frozen mode.
60  *     A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
61  *     or enabled. A frozen bitmap can only abdicate() or reclaim().
62  */
63 struct BdrvDirtyBitmap {
64     HBitmap *bitmap;            /* Dirty sector bitmap implementation */
65     BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
66     char *name;                 /* Optional non-empty unique ID */
67     int64_t size;               /* Size of the bitmap (Number of sectors) */
68     bool disabled;              /* Bitmap is read-only */
69     QLIST_ENTRY(BdrvDirtyBitmap) list;
70 };
71 
72 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
73 
74 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
75     QTAILQ_HEAD_INITIALIZER(bdrv_states);
76 
77 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
78     QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
79 
80 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
81     QLIST_HEAD_INITIALIZER(bdrv_drivers);
82 
83 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
84                              const char *reference, QDict *options, int flags,
85                              BlockDriverState *parent,
86                              const BdrvChildRole *child_role,
87                              BlockDriver *drv, Error **errp);
88 
89 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
90 /* If non-zero, use only whitelisted block drivers */
91 static int use_bdrv_whitelist;
92 
93 #ifdef _WIN32
94 static int is_windows_drive_prefix(const char *filename)
95 {
96     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
97              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
98             filename[1] == ':');
99 }
100 
101 int is_windows_drive(const char *filename)
102 {
103     if (is_windows_drive_prefix(filename) &&
104         filename[2] == '\0')
105         return 1;
106     if (strstart(filename, "\\\\.\\", NULL) ||
107         strstart(filename, "//./", NULL))
108         return 1;
109     return 0;
110 }
111 #endif
112 
113 size_t bdrv_opt_mem_align(BlockDriverState *bs)
114 {
115     if (!bs || !bs->drv) {
116         /* page size or 4k (hdd sector size) should be on the safe side */
117         return MAX(4096, getpagesize());
118     }
119 
120     return bs->bl.opt_mem_alignment;
121 }
122 
123 size_t bdrv_min_mem_align(BlockDriverState *bs)
124 {
125     if (!bs || !bs->drv) {
126         /* page size or 4k (hdd sector size) should be on the safe side */
127         return MAX(4096, getpagesize());
128     }
129 
130     return bs->bl.min_mem_alignment;
131 }
132 
133 /* check if the path starts with "<protocol>:" */
134 int path_has_protocol(const char *path)
135 {
136     const char *p;
137 
138 #ifdef _WIN32
139     if (is_windows_drive(path) ||
140         is_windows_drive_prefix(path)) {
141         return 0;
142     }
143     p = path + strcspn(path, ":/\\");
144 #else
145     p = path + strcspn(path, ":/");
146 #endif
147 
148     return *p == ':';
149 }
150 
151 int path_is_absolute(const char *path)
152 {
153 #ifdef _WIN32
154     /* specific case for names like: "\\.\d:" */
155     if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
156         return 1;
157     }
158     return (*path == '/' || *path == '\\');
159 #else
160     return (*path == '/');
161 #endif
162 }
163 
164 /* if filename is absolute, just copy it to dest. Otherwise, build a
165    path to it by considering it is relative to base_path. URL are
166    supported. */
167 void path_combine(char *dest, int dest_size,
168                   const char *base_path,
169                   const char *filename)
170 {
171     const char *p, *p1;
172     int len;
173 
174     if (dest_size <= 0)
175         return;
176     if (path_is_absolute(filename)) {
177         pstrcpy(dest, dest_size, filename);
178     } else {
179         p = strchr(base_path, ':');
180         if (p)
181             p++;
182         else
183             p = base_path;
184         p1 = strrchr(base_path, '/');
185 #ifdef _WIN32
186         {
187             const char *p2;
188             p2 = strrchr(base_path, '\\');
189             if (!p1 || p2 > p1)
190                 p1 = p2;
191         }
192 #endif
193         if (p1)
194             p1++;
195         else
196             p1 = base_path;
197         if (p1 > p)
198             p = p1;
199         len = p - base_path;
200         if (len > dest_size - 1)
201             len = dest_size - 1;
202         memcpy(dest, base_path, len);
203         dest[len] = '\0';
204         pstrcat(dest, dest_size, filename);
205     }
206 }
207 
208 void bdrv_get_full_backing_filename_from_filename(const char *backed,
209                                                   const char *backing,
210                                                   char *dest, size_t sz,
211                                                   Error **errp)
212 {
213     if (backing[0] == '\0' || path_has_protocol(backing) ||
214         path_is_absolute(backing))
215     {
216         pstrcpy(dest, sz, backing);
217     } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
218         error_setg(errp, "Cannot use relative backing file names for '%s'",
219                    backed);
220     } else {
221         path_combine(dest, sz, backed, backing);
222     }
223 }
224 
225 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
226                                     Error **errp)
227 {
228     char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
229 
230     bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
231                                                  dest, sz, errp);
232 }
233 
234 void bdrv_register(BlockDriver *bdrv)
235 {
236     bdrv_setup_io_funcs(bdrv);
237 
238     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
239 }
240 
241 BlockDriverState *bdrv_new_root(void)
242 {
243     BlockDriverState *bs = bdrv_new();
244 
245     QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
246     return bs;
247 }
248 
249 BlockDriverState *bdrv_new(void)
250 {
251     BlockDriverState *bs;
252     int i;
253 
254     bs = g_new0(BlockDriverState, 1);
255     QLIST_INIT(&bs->dirty_bitmaps);
256     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
257         QLIST_INIT(&bs->op_blockers[i]);
258     }
259     bdrv_iostatus_disable(bs);
260     notifier_list_init(&bs->close_notifiers);
261     notifier_with_return_list_init(&bs->before_write_notifiers);
262     qemu_co_queue_init(&bs->throttled_reqs[0]);
263     qemu_co_queue_init(&bs->throttled_reqs[1]);
264     bs->refcnt = 1;
265     bs->aio_context = qemu_get_aio_context();
266 
267     return bs;
268 }
269 
270 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
271 {
272     notifier_list_add(&bs->close_notifiers, notify);
273 }
274 
275 BlockDriver *bdrv_find_format(const char *format_name)
276 {
277     BlockDriver *drv1;
278     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
279         if (!strcmp(drv1->format_name, format_name)) {
280             return drv1;
281         }
282     }
283     return NULL;
284 }
285 
286 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
287 {
288     static const char *whitelist_rw[] = {
289         CONFIG_BDRV_RW_WHITELIST
290     };
291     static const char *whitelist_ro[] = {
292         CONFIG_BDRV_RO_WHITELIST
293     };
294     const char **p;
295 
296     if (!whitelist_rw[0] && !whitelist_ro[0]) {
297         return 1;               /* no whitelist, anything goes */
298     }
299 
300     for (p = whitelist_rw; *p; p++) {
301         if (!strcmp(drv->format_name, *p)) {
302             return 1;
303         }
304     }
305     if (read_only) {
306         for (p = whitelist_ro; *p; p++) {
307             if (!strcmp(drv->format_name, *p)) {
308                 return 1;
309             }
310         }
311     }
312     return 0;
313 }
314 
315 BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
316                                           bool read_only)
317 {
318     BlockDriver *drv = bdrv_find_format(format_name);
319     return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
320 }
321 
322 typedef struct CreateCo {
323     BlockDriver *drv;
324     char *filename;
325     QemuOpts *opts;
326     int ret;
327     Error *err;
328 } CreateCo;
329 
330 static void coroutine_fn bdrv_create_co_entry(void *opaque)
331 {
332     Error *local_err = NULL;
333     int ret;
334 
335     CreateCo *cco = opaque;
336     assert(cco->drv);
337 
338     ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
339     if (local_err) {
340         error_propagate(&cco->err, local_err);
341     }
342     cco->ret = ret;
343 }
344 
345 int bdrv_create(BlockDriver *drv, const char* filename,
346                 QemuOpts *opts, Error **errp)
347 {
348     int ret;
349 
350     Coroutine *co;
351     CreateCo cco = {
352         .drv = drv,
353         .filename = g_strdup(filename),
354         .opts = opts,
355         .ret = NOT_DONE,
356         .err = NULL,
357     };
358 
359     if (!drv->bdrv_create) {
360         error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
361         ret = -ENOTSUP;
362         goto out;
363     }
364 
365     if (qemu_in_coroutine()) {
366         /* Fast-path if already in coroutine context */
367         bdrv_create_co_entry(&cco);
368     } else {
369         co = qemu_coroutine_create(bdrv_create_co_entry);
370         qemu_coroutine_enter(co, &cco);
371         while (cco.ret == NOT_DONE) {
372             aio_poll(qemu_get_aio_context(), true);
373         }
374     }
375 
376     ret = cco.ret;
377     if (ret < 0) {
378         if (cco.err) {
379             error_propagate(errp, cco.err);
380         } else {
381             error_setg_errno(errp, -ret, "Could not create image");
382         }
383     }
384 
385 out:
386     g_free(cco.filename);
387     return ret;
388 }
389 
390 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
391 {
392     BlockDriver *drv;
393     Error *local_err = NULL;
394     int ret;
395 
396     drv = bdrv_find_protocol(filename, true, errp);
397     if (drv == NULL) {
398         return -ENOENT;
399     }
400 
401     ret = bdrv_create(drv, filename, opts, &local_err);
402     if (local_err) {
403         error_propagate(errp, local_err);
404     }
405     return ret;
406 }
407 
408 /**
409  * Try to get @bs's logical and physical block size.
410  * On success, store them in @bsz struct and return 0.
411  * On failure return -errno.
412  * @bs must not be empty.
413  */
414 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
415 {
416     BlockDriver *drv = bs->drv;
417 
418     if (drv && drv->bdrv_probe_blocksizes) {
419         return drv->bdrv_probe_blocksizes(bs, bsz);
420     }
421 
422     return -ENOTSUP;
423 }
424 
425 /**
426  * Try to get @bs's geometry (cyls, heads, sectors).
427  * On success, store them in @geo struct and return 0.
428  * On failure return -errno.
429  * @bs must not be empty.
430  */
431 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
432 {
433     BlockDriver *drv = bs->drv;
434 
435     if (drv && drv->bdrv_probe_geometry) {
436         return drv->bdrv_probe_geometry(bs, geo);
437     }
438 
439     return -ENOTSUP;
440 }
441 
442 /*
443  * Create a uniquely-named empty temporary file.
444  * Return 0 upon success, otherwise a negative errno value.
445  */
446 int get_tmp_filename(char *filename, int size)
447 {
448 #ifdef _WIN32
449     char temp_dir[MAX_PATH];
450     /* GetTempFileName requires that its output buffer (4th param)
451        have length MAX_PATH or greater.  */
452     assert(size >= MAX_PATH);
453     return (GetTempPath(MAX_PATH, temp_dir)
454             && GetTempFileName(temp_dir, "qem", 0, filename)
455             ? 0 : -GetLastError());
456 #else
457     int fd;
458     const char *tmpdir;
459     tmpdir = getenv("TMPDIR");
460     if (!tmpdir) {
461         tmpdir = "/var/tmp";
462     }
463     if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
464         return -EOVERFLOW;
465     }
466     fd = mkstemp(filename);
467     if (fd < 0) {
468         return -errno;
469     }
470     if (close(fd) != 0) {
471         unlink(filename);
472         return -errno;
473     }
474     return 0;
475 #endif
476 }
477 
478 /*
479  * Detect host devices. By convention, /dev/cdrom[N] is always
480  * recognized as a host CDROM.
481  */
482 static BlockDriver *find_hdev_driver(const char *filename)
483 {
484     int score_max = 0, score;
485     BlockDriver *drv = NULL, *d;
486 
487     QLIST_FOREACH(d, &bdrv_drivers, list) {
488         if (d->bdrv_probe_device) {
489             score = d->bdrv_probe_device(filename);
490             if (score > score_max) {
491                 score_max = score;
492                 drv = d;
493             }
494         }
495     }
496 
497     return drv;
498 }
499 
500 BlockDriver *bdrv_find_protocol(const char *filename,
501                                 bool allow_protocol_prefix,
502                                 Error **errp)
503 {
504     BlockDriver *drv1;
505     char protocol[128];
506     int len;
507     const char *p;
508 
509     /* TODO Drivers without bdrv_file_open must be specified explicitly */
510 
511     /*
512      * XXX(hch): we really should not let host device detection
513      * override an explicit protocol specification, but moving this
514      * later breaks access to device names with colons in them.
515      * Thanks to the brain-dead persistent naming schemes on udev-
516      * based Linux systems those actually are quite common.
517      */
518     drv1 = find_hdev_driver(filename);
519     if (drv1) {
520         return drv1;
521     }
522 
523     if (!path_has_protocol(filename) || !allow_protocol_prefix) {
524         return &bdrv_file;
525     }
526 
527     p = strchr(filename, ':');
528     assert(p != NULL);
529     len = p - filename;
530     if (len > sizeof(protocol) - 1)
531         len = sizeof(protocol) - 1;
532     memcpy(protocol, filename, len);
533     protocol[len] = '\0';
534     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
535         if (drv1->protocol_name &&
536             !strcmp(drv1->protocol_name, protocol)) {
537             return drv1;
538         }
539     }
540 
541     error_setg(errp, "Unknown protocol '%s'", protocol);
542     return NULL;
543 }
544 
545 /*
546  * Guess image format by probing its contents.
547  * This is not a good idea when your image is raw (CVE-2008-2004), but
548  * we do it anyway for backward compatibility.
549  *
550  * @buf         contains the image's first @buf_size bytes.
551  * @buf_size    is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
552  *              but can be smaller if the image file is smaller)
553  * @filename    is its filename.
554  *
555  * For all block drivers, call the bdrv_probe() method to get its
556  * probing score.
557  * Return the first block driver with the highest probing score.
558  */
559 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
560                             const char *filename)
561 {
562     int score_max = 0, score;
563     BlockDriver *drv = NULL, *d;
564 
565     QLIST_FOREACH(d, &bdrv_drivers, list) {
566         if (d->bdrv_probe) {
567             score = d->bdrv_probe(buf, buf_size, filename);
568             if (score > score_max) {
569                 score_max = score;
570                 drv = d;
571             }
572         }
573     }
574 
575     return drv;
576 }
577 
578 static int find_image_format(BlockDriverState *bs, const char *filename,
579                              BlockDriver **pdrv, Error **errp)
580 {
581     BlockDriver *drv;
582     uint8_t buf[BLOCK_PROBE_BUF_SIZE];
583     int ret = 0;
584 
585     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
586     if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
587         *pdrv = &bdrv_raw;
588         return ret;
589     }
590 
591     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
592     if (ret < 0) {
593         error_setg_errno(errp, -ret, "Could not read image for determining its "
594                          "format");
595         *pdrv = NULL;
596         return ret;
597     }
598 
599     drv = bdrv_probe_all(buf, ret, filename);
600     if (!drv) {
601         error_setg(errp, "Could not determine image format: No compatible "
602                    "driver found");
603         ret = -ENOENT;
604     }
605     *pdrv = drv;
606     return ret;
607 }
608 
609 /**
610  * Set the current 'total_sectors' value
611  * Return 0 on success, -errno on error.
612  */
613 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
614 {
615     BlockDriver *drv = bs->drv;
616 
617     /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
618     if (bs->sg)
619         return 0;
620 
621     /* query actual device if possible, otherwise just trust the hint */
622     if (drv->bdrv_getlength) {
623         int64_t length = drv->bdrv_getlength(bs);
624         if (length < 0) {
625             return length;
626         }
627         hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
628     }
629 
630     bs->total_sectors = hint;
631     return 0;
632 }
633 
634 /**
635  * Set open flags for a given discard mode
636  *
637  * Return 0 on success, -1 if the discard mode was invalid.
638  */
639 int bdrv_parse_discard_flags(const char *mode, int *flags)
640 {
641     *flags &= ~BDRV_O_UNMAP;
642 
643     if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
644         /* do nothing */
645     } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
646         *flags |= BDRV_O_UNMAP;
647     } else {
648         return -1;
649     }
650 
651     return 0;
652 }
653 
654 /**
655  * Set open flags for a given cache mode
656  *
657  * Return 0 on success, -1 if the cache mode was invalid.
658  */
659 int bdrv_parse_cache_flags(const char *mode, int *flags)
660 {
661     *flags &= ~BDRV_O_CACHE_MASK;
662 
663     if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
664         *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
665     } else if (!strcmp(mode, "directsync")) {
666         *flags |= BDRV_O_NOCACHE;
667     } else if (!strcmp(mode, "writeback")) {
668         *flags |= BDRV_O_CACHE_WB;
669     } else if (!strcmp(mode, "unsafe")) {
670         *flags |= BDRV_O_CACHE_WB;
671         *flags |= BDRV_O_NO_FLUSH;
672     } else if (!strcmp(mode, "writethrough")) {
673         /* this is the default */
674     } else {
675         return -1;
676     }
677 
678     return 0;
679 }
680 
681 /*
682  * Returns the flags that a temporary snapshot should get, based on the
683  * originally requested flags (the originally requested image will have flags
684  * like a backing file)
685  */
686 static int bdrv_temp_snapshot_flags(int flags)
687 {
688     return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
689 }
690 
691 /*
692  * Returns the flags that bs->file should get if a protocol driver is expected,
693  * based on the given flags for the parent BDS
694  */
695 static int bdrv_inherited_flags(int flags)
696 {
697     /* Enable protocol handling, disable format probing for bs->file */
698     flags |= BDRV_O_PROTOCOL;
699 
700     /* Our block drivers take care to send flushes and respect unmap policy,
701      * so we can enable both unconditionally on lower layers. */
702     flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
703 
704     /* Clear flags that only apply to the top layer */
705     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
706 
707     return flags;
708 }
709 
710 const BdrvChildRole child_file = {
711     .inherit_flags = bdrv_inherited_flags,
712 };
713 
714 /*
715  * Returns the flags that bs->file should get if the use of formats (and not
716  * only protocols) is permitted for it, based on the given flags for the parent
717  * BDS
718  */
719 static int bdrv_inherited_fmt_flags(int parent_flags)
720 {
721     int flags = child_file.inherit_flags(parent_flags);
722     return flags & ~BDRV_O_PROTOCOL;
723 }
724 
725 const BdrvChildRole child_format = {
726     .inherit_flags = bdrv_inherited_fmt_flags,
727 };
728 
729 /*
730  * Returns the flags that bs->backing_hd should get, based on the given flags
731  * for the parent BDS
732  */
733 static int bdrv_backing_flags(int flags)
734 {
735     /* backing files always opened read-only */
736     flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
737 
738     /* snapshot=on is handled on the top layer */
739     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
740 
741     return flags;
742 }
743 
744 static const BdrvChildRole child_backing = {
745     .inherit_flags = bdrv_backing_flags,
746 };
747 
748 static int bdrv_open_flags(BlockDriverState *bs, int flags)
749 {
750     int open_flags = flags | BDRV_O_CACHE_WB;
751 
752     /*
753      * Clear flags that are internal to the block layer before opening the
754      * image.
755      */
756     open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
757 
758     /*
759      * Snapshots should be writable.
760      */
761     if (flags & BDRV_O_TEMPORARY) {
762         open_flags |= BDRV_O_RDWR;
763     }
764 
765     return open_flags;
766 }
767 
768 static void bdrv_assign_node_name(BlockDriverState *bs,
769                                   const char *node_name,
770                                   Error **errp)
771 {
772     if (!node_name) {
773         return;
774     }
775 
776     /* Check for empty string or invalid characters */
777     if (!id_wellformed(node_name)) {
778         error_setg(errp, "Invalid node name");
779         return;
780     }
781 
782     /* takes care of avoiding namespaces collisions */
783     if (blk_by_name(node_name)) {
784         error_setg(errp, "node-name=%s is conflicting with a device id",
785                    node_name);
786         return;
787     }
788 
789     /* takes care of avoiding duplicates node names */
790     if (bdrv_find_node(node_name)) {
791         error_setg(errp, "Duplicate node name");
792         return;
793     }
794 
795     /* copy node name into the bs and insert it into the graph list */
796     pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
797     QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
798 }
799 
800 static QemuOptsList bdrv_runtime_opts = {
801     .name = "bdrv_common",
802     .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
803     .desc = {
804         {
805             .name = "node-name",
806             .type = QEMU_OPT_STRING,
807             .help = "Node name of the block device node",
808         },
809         { /* end of list */ }
810     },
811 };
812 
813 /*
814  * Common part for opening disk images and files
815  *
816  * Removes all processed options from *options.
817  */
818 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
819     QDict *options, int flags, BlockDriver *drv, Error **errp)
820 {
821     int ret, open_flags;
822     const char *filename;
823     const char *node_name = NULL;
824     QemuOpts *opts;
825     Error *local_err = NULL;
826 
827     assert(drv != NULL);
828     assert(bs->file == NULL);
829     assert(options != NULL && bs->options != options);
830 
831     if (file != NULL) {
832         filename = file->filename;
833     } else {
834         filename = qdict_get_try_str(options, "filename");
835     }
836 
837     if (drv->bdrv_needs_filename && !filename) {
838         error_setg(errp, "The '%s' block driver requires a file name",
839                    drv->format_name);
840         return -EINVAL;
841     }
842 
843     trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
844 
845     opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
846     qemu_opts_absorb_qdict(opts, options, &local_err);
847     if (local_err) {
848         error_propagate(errp, local_err);
849         ret = -EINVAL;
850         goto fail_opts;
851     }
852 
853     node_name = qemu_opt_get(opts, "node-name");
854     bdrv_assign_node_name(bs, node_name, &local_err);
855     if (local_err) {
856         error_propagate(errp, local_err);
857         ret = -EINVAL;
858         goto fail_opts;
859     }
860 
861     bs->guest_block_size = 512;
862     bs->request_alignment = 512;
863     bs->zero_beyond_eof = true;
864     open_flags = bdrv_open_flags(bs, flags);
865     bs->read_only = !(open_flags & BDRV_O_RDWR);
866 
867     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
868         error_setg(errp,
869                    !bs->read_only && bdrv_is_whitelisted(drv, true)
870                         ? "Driver '%s' can only be used for read-only devices"
871                         : "Driver '%s' is not whitelisted",
872                    drv->format_name);
873         ret = -ENOTSUP;
874         goto fail_opts;
875     }
876 
877     assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
878     if (flags & BDRV_O_COPY_ON_READ) {
879         if (!bs->read_only) {
880             bdrv_enable_copy_on_read(bs);
881         } else {
882             error_setg(errp, "Can't use copy-on-read on read-only device");
883             ret = -EINVAL;
884             goto fail_opts;
885         }
886     }
887 
888     if (filename != NULL) {
889         pstrcpy(bs->filename, sizeof(bs->filename), filename);
890     } else {
891         bs->filename[0] = '\0';
892     }
893     pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
894 
895     bs->drv = drv;
896     bs->opaque = g_malloc0(drv->instance_size);
897 
898     bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
899 
900     /* Open the image, either directly or using a protocol */
901     if (drv->bdrv_file_open) {
902         assert(file == NULL);
903         assert(!drv->bdrv_needs_filename || filename != NULL);
904         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
905     } else {
906         if (file == NULL) {
907             error_setg(errp, "Can't use '%s' as a block driver for the "
908                        "protocol level", drv->format_name);
909             ret = -EINVAL;
910             goto free_and_fail;
911         }
912         bs->file = file;
913         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
914     }
915 
916     if (ret < 0) {
917         if (local_err) {
918             error_propagate(errp, local_err);
919         } else if (bs->filename[0]) {
920             error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
921         } else {
922             error_setg_errno(errp, -ret, "Could not open image");
923         }
924         goto free_and_fail;
925     }
926 
927     if (bs->encrypted) {
928         error_report("Encrypted images are deprecated");
929         error_printf("Support for them will be removed in a future release.\n"
930                      "You can use 'qemu-img convert' to convert your image"
931                      " to an unencrypted one.\n");
932     }
933 
934     ret = refresh_total_sectors(bs, bs->total_sectors);
935     if (ret < 0) {
936         error_setg_errno(errp, -ret, "Could not refresh total sector count");
937         goto free_and_fail;
938     }
939 
940     bdrv_refresh_limits(bs, &local_err);
941     if (local_err) {
942         error_propagate(errp, local_err);
943         ret = -EINVAL;
944         goto free_and_fail;
945     }
946 
947     assert(bdrv_opt_mem_align(bs) != 0);
948     assert(bdrv_min_mem_align(bs) != 0);
949     assert((bs->request_alignment != 0) || bs->sg);
950 
951     qemu_opts_del(opts);
952     return 0;
953 
954 free_and_fail:
955     bs->file = NULL;
956     g_free(bs->opaque);
957     bs->opaque = NULL;
958     bs->drv = NULL;
959 fail_opts:
960     qemu_opts_del(opts);
961     return ret;
962 }
963 
964 static QDict *parse_json_filename(const char *filename, Error **errp)
965 {
966     QObject *options_obj;
967     QDict *options;
968     int ret;
969 
970     ret = strstart(filename, "json:", &filename);
971     assert(ret);
972 
973     options_obj = qobject_from_json(filename);
974     if (!options_obj) {
975         error_setg(errp, "Could not parse the JSON options");
976         return NULL;
977     }
978 
979     if (qobject_type(options_obj) != QTYPE_QDICT) {
980         qobject_decref(options_obj);
981         error_setg(errp, "Invalid JSON object given");
982         return NULL;
983     }
984 
985     options = qobject_to_qdict(options_obj);
986     qdict_flatten(options);
987 
988     return options;
989 }
990 
991 /*
992  * Fills in default options for opening images and converts the legacy
993  * filename/flags pair to option QDict entries.
994  * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
995  * block driver has been specified explicitly.
996  */
997 static int bdrv_fill_options(QDict **options, const char **pfilename,
998                              int *flags, BlockDriver *drv, Error **errp)
999 {
1000     const char *filename = *pfilename;
1001     const char *drvname;
1002     bool protocol = *flags & BDRV_O_PROTOCOL;
1003     bool parse_filename = false;
1004     BlockDriver *tmp_drv;
1005     Error *local_err = NULL;
1006 
1007     /* Parse json: pseudo-protocol */
1008     if (filename && g_str_has_prefix(filename, "json:")) {
1009         QDict *json_options = parse_json_filename(filename, &local_err);
1010         if (local_err) {
1011             error_propagate(errp, local_err);
1012             return -EINVAL;
1013         }
1014 
1015         /* Options given in the filename have lower priority than options
1016          * specified directly */
1017         qdict_join(*options, json_options, false);
1018         QDECREF(json_options);
1019         *pfilename = filename = NULL;
1020     }
1021 
1022     drvname = qdict_get_try_str(*options, "driver");
1023 
1024     /* If the user has explicitly specified the driver, this choice should
1025      * override the BDRV_O_PROTOCOL flag */
1026     tmp_drv = drv;
1027     if (!tmp_drv && drvname) {
1028         tmp_drv = bdrv_find_format(drvname);
1029     }
1030     if (tmp_drv) {
1031         protocol = tmp_drv->bdrv_file_open;
1032     }
1033 
1034     if (protocol) {
1035         *flags |= BDRV_O_PROTOCOL;
1036     } else {
1037         *flags &= ~BDRV_O_PROTOCOL;
1038     }
1039 
1040     /* Fetch the file name from the options QDict if necessary */
1041     if (protocol && filename) {
1042         if (!qdict_haskey(*options, "filename")) {
1043             qdict_put(*options, "filename", qstring_from_str(filename));
1044             parse_filename = true;
1045         } else {
1046             error_setg(errp, "Can't specify 'file' and 'filename' options at "
1047                              "the same time");
1048             return -EINVAL;
1049         }
1050     }
1051 
1052     /* Find the right block driver */
1053     filename = qdict_get_try_str(*options, "filename");
1054 
1055     if (drv) {
1056         if (drvname) {
1057             error_setg(errp, "Driver specified twice");
1058             return -EINVAL;
1059         }
1060         drvname = drv->format_name;
1061         qdict_put(*options, "driver", qstring_from_str(drvname));
1062     } else {
1063         if (!drvname && protocol) {
1064             if (filename) {
1065                 drv = bdrv_find_protocol(filename, parse_filename, errp);
1066                 if (!drv) {
1067                     return -EINVAL;
1068                 }
1069 
1070                 drvname = drv->format_name;
1071                 qdict_put(*options, "driver", qstring_from_str(drvname));
1072             } else {
1073                 error_setg(errp, "Must specify either driver or file");
1074                 return -EINVAL;
1075             }
1076         } else if (drvname) {
1077             drv = bdrv_find_format(drvname);
1078             if (!drv) {
1079                 error_setg(errp, "Unknown driver '%s'", drvname);
1080                 return -ENOENT;
1081             }
1082         }
1083     }
1084 
1085     assert(drv || !protocol);
1086 
1087     /* Driver-specific filename parsing */
1088     if (drv && drv->bdrv_parse_filename && parse_filename) {
1089         drv->bdrv_parse_filename(filename, *options, &local_err);
1090         if (local_err) {
1091             error_propagate(errp, local_err);
1092             return -EINVAL;
1093         }
1094 
1095         if (!drv->bdrv_needs_filename) {
1096             qdict_del(*options, "filename");
1097         }
1098     }
1099 
1100     return 0;
1101 }
1102 
1103 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1104 {
1105 
1106     if (bs->backing_hd) {
1107         assert(bs->backing_blocker);
1108         bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1109     } else if (backing_hd) {
1110         error_setg(&bs->backing_blocker,
1111                    "node is used as backing hd of '%s'",
1112                    bdrv_get_device_or_node_name(bs));
1113     }
1114 
1115     bs->backing_hd = backing_hd;
1116     if (!backing_hd) {
1117         error_free(bs->backing_blocker);
1118         bs->backing_blocker = NULL;
1119         goto out;
1120     }
1121     bs->open_flags &= ~BDRV_O_NO_BACKING;
1122     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1123     pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1124             backing_hd->drv ? backing_hd->drv->format_name : "");
1125 
1126     bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1127     /* Otherwise we won't be able to commit due to check in bdrv_commit */
1128     bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1129                     bs->backing_blocker);
1130 out:
1131     bdrv_refresh_limits(bs, NULL);
1132 }
1133 
1134 /*
1135  * Opens the backing file for a BlockDriverState if not yet open
1136  *
1137  * options is a QDict of options to pass to the block drivers, or NULL for an
1138  * empty set of options. The reference to the QDict is transferred to this
1139  * function (even on failure), so if the caller intends to reuse the dictionary,
1140  * it needs to use QINCREF() before calling bdrv_file_open.
1141  */
1142 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1143 {
1144     char *backing_filename = g_malloc0(PATH_MAX);
1145     int ret = 0;
1146     BlockDriverState *backing_hd;
1147     Error *local_err = NULL;
1148 
1149     if (bs->backing_hd != NULL) {
1150         QDECREF(options);
1151         goto free_exit;
1152     }
1153 
1154     /* NULL means an empty set of options */
1155     if (options == NULL) {
1156         options = qdict_new();
1157     }
1158 
1159     bs->open_flags &= ~BDRV_O_NO_BACKING;
1160     if (qdict_haskey(options, "file.filename")) {
1161         backing_filename[0] = '\0';
1162     } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1163         QDECREF(options);
1164         goto free_exit;
1165     } else {
1166         bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1167                                        &local_err);
1168         if (local_err) {
1169             ret = -EINVAL;
1170             error_propagate(errp, local_err);
1171             QDECREF(options);
1172             goto free_exit;
1173         }
1174     }
1175 
1176     if (!bs->drv || !bs->drv->supports_backing) {
1177         ret = -EINVAL;
1178         error_setg(errp, "Driver doesn't support backing files");
1179         QDECREF(options);
1180         goto free_exit;
1181     }
1182 
1183     backing_hd = bdrv_new();
1184 
1185     if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1186         qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1187     }
1188 
1189     assert(bs->backing_hd == NULL);
1190     ret = bdrv_open_inherit(&backing_hd,
1191                             *backing_filename ? backing_filename : NULL,
1192                             NULL, options, 0, bs, &child_backing,
1193                             NULL, &local_err);
1194     if (ret < 0) {
1195         bdrv_unref(backing_hd);
1196         backing_hd = NULL;
1197         bs->open_flags |= BDRV_O_NO_BACKING;
1198         error_setg(errp, "Could not open backing file: %s",
1199                    error_get_pretty(local_err));
1200         error_free(local_err);
1201         goto free_exit;
1202     }
1203     bdrv_set_backing_hd(bs, backing_hd);
1204 
1205 free_exit:
1206     g_free(backing_filename);
1207     return ret;
1208 }
1209 
1210 /*
1211  * Opens a disk image whose options are given as BlockdevRef in another block
1212  * device's options.
1213  *
1214  * If allow_none is true, no image will be opened if filename is false and no
1215  * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1216  *
1217  * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1218  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1219  * itself, all options starting with "${bdref_key}." are considered part of the
1220  * BlockdevRef.
1221  *
1222  * The BlockdevRef will be removed from the options QDict.
1223  *
1224  * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1225  */
1226 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1227                     QDict *options, const char *bdref_key,
1228                     BlockDriverState* parent, const BdrvChildRole *child_role,
1229                     bool allow_none, Error **errp)
1230 {
1231     QDict *image_options;
1232     int ret;
1233     char *bdref_key_dot;
1234     const char *reference;
1235 
1236     assert(pbs);
1237     assert(*pbs == NULL);
1238 
1239     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1240     qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1241     g_free(bdref_key_dot);
1242 
1243     reference = qdict_get_try_str(options, bdref_key);
1244     if (!filename && !reference && !qdict_size(image_options)) {
1245         if (allow_none) {
1246             ret = 0;
1247         } else {
1248             error_setg(errp, "A block device must be specified for \"%s\"",
1249                        bdref_key);
1250             ret = -EINVAL;
1251         }
1252         QDECREF(image_options);
1253         goto done;
1254     }
1255 
1256     ret = bdrv_open_inherit(pbs, filename, reference, image_options, 0,
1257                             parent, child_role, NULL, errp);
1258 
1259 done:
1260     qdict_del(options, bdref_key);
1261     return ret;
1262 }
1263 
1264 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1265 {
1266     /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1267     char *tmp_filename = g_malloc0(PATH_MAX + 1);
1268     int64_t total_size;
1269     QemuOpts *opts = NULL;
1270     QDict *snapshot_options;
1271     BlockDriverState *bs_snapshot;
1272     Error *local_err;
1273     int ret;
1274 
1275     /* if snapshot, we create a temporary backing file and open it
1276        instead of opening 'filename' directly */
1277 
1278     /* Get the required size from the image */
1279     total_size = bdrv_getlength(bs);
1280     if (total_size < 0) {
1281         ret = total_size;
1282         error_setg_errno(errp, -total_size, "Could not get image size");
1283         goto out;
1284     }
1285 
1286     /* Create the temporary image */
1287     ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1288     if (ret < 0) {
1289         error_setg_errno(errp, -ret, "Could not get temporary filename");
1290         goto out;
1291     }
1292 
1293     opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1294                             &error_abort);
1295     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1296     ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
1297     qemu_opts_del(opts);
1298     if (ret < 0) {
1299         error_setg_errno(errp, -ret, "Could not create temporary overlay "
1300                          "'%s': %s", tmp_filename,
1301                          error_get_pretty(local_err));
1302         error_free(local_err);
1303         goto out;
1304     }
1305 
1306     /* Prepare a new options QDict for the temporary file */
1307     snapshot_options = qdict_new();
1308     qdict_put(snapshot_options, "file.driver",
1309               qstring_from_str("file"));
1310     qdict_put(snapshot_options, "file.filename",
1311               qstring_from_str(tmp_filename));
1312 
1313     bs_snapshot = bdrv_new();
1314 
1315     ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1316                     flags, &bdrv_qcow2, &local_err);
1317     if (ret < 0) {
1318         error_propagate(errp, local_err);
1319         goto out;
1320     }
1321 
1322     bdrv_append(bs_snapshot, bs);
1323 
1324 out:
1325     g_free(tmp_filename);
1326     return ret;
1327 }
1328 
1329 static void bdrv_attach_child(BlockDriverState *parent_bs,
1330                               BlockDriverState *child_bs,
1331                               const BdrvChildRole *child_role)
1332 {
1333     BdrvChild *child = g_new(BdrvChild, 1);
1334     *child = (BdrvChild) {
1335         .bs     = child_bs,
1336         .role   = child_role,
1337     };
1338 
1339     QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1340 }
1341 
1342 /*
1343  * Opens a disk image (raw, qcow2, vmdk, ...)
1344  *
1345  * options is a QDict of options to pass to the block drivers, or NULL for an
1346  * empty set of options. The reference to the QDict belongs to the block layer
1347  * after the call (even on failure), so if the caller intends to reuse the
1348  * dictionary, it needs to use QINCREF() before calling bdrv_open.
1349  *
1350  * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1351  * If it is not NULL, the referenced BDS will be reused.
1352  *
1353  * The reference parameter may be used to specify an existing block device which
1354  * should be opened. If specified, neither options nor a filename may be given,
1355  * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1356  */
1357 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1358                              const char *reference, QDict *options, int flags,
1359                              BlockDriverState *parent,
1360                              const BdrvChildRole *child_role,
1361                              BlockDriver *drv, Error **errp)
1362 {
1363     int ret;
1364     BlockDriverState *file = NULL, *bs;
1365     const char *drvname;
1366     Error *local_err = NULL;
1367     int snapshot_flags = 0;
1368 
1369     assert(pbs);
1370     assert(!child_role || !flags);
1371     assert(!child_role == !parent);
1372 
1373     if (reference) {
1374         bool options_non_empty = options ? qdict_size(options) : false;
1375         QDECREF(options);
1376 
1377         if (*pbs) {
1378             error_setg(errp, "Cannot reuse an existing BDS when referencing "
1379                        "another block device");
1380             return -EINVAL;
1381         }
1382 
1383         if (filename || options_non_empty) {
1384             error_setg(errp, "Cannot reference an existing block device with "
1385                        "additional options or a new filename");
1386             return -EINVAL;
1387         }
1388 
1389         bs = bdrv_lookup_bs(reference, reference, errp);
1390         if (!bs) {
1391             return -ENODEV;
1392         }
1393         bdrv_ref(bs);
1394         if (child_role) {
1395             bdrv_attach_child(parent, bs, child_role);
1396         }
1397         *pbs = bs;
1398         return 0;
1399     }
1400 
1401     if (*pbs) {
1402         bs = *pbs;
1403     } else {
1404         bs = bdrv_new();
1405     }
1406 
1407     /* NULL means an empty set of options */
1408     if (options == NULL) {
1409         options = qdict_new();
1410     }
1411 
1412     if (child_role) {
1413         bs->inherits_from = parent;
1414         flags = child_role->inherit_flags(parent->open_flags);
1415     }
1416 
1417     ret = bdrv_fill_options(&options, &filename, &flags, drv, &local_err);
1418     if (local_err) {
1419         goto fail;
1420     }
1421 
1422     /* Find the right image format driver */
1423     drv = NULL;
1424     drvname = qdict_get_try_str(options, "driver");
1425     if (drvname) {
1426         drv = bdrv_find_format(drvname);
1427         qdict_del(options, "driver");
1428         if (!drv) {
1429             error_setg(errp, "Unknown driver: '%s'", drvname);
1430             ret = -EINVAL;
1431             goto fail;
1432         }
1433     }
1434 
1435     assert(drvname || !(flags & BDRV_O_PROTOCOL));
1436 
1437     bs->open_flags = flags;
1438     bs->options = options;
1439     options = qdict_clone_shallow(options);
1440 
1441     /* Open image file without format layer */
1442     if ((flags & BDRV_O_PROTOCOL) == 0) {
1443         if (flags & BDRV_O_RDWR) {
1444             flags |= BDRV_O_ALLOW_RDWR;
1445         }
1446         if (flags & BDRV_O_SNAPSHOT) {
1447             snapshot_flags = bdrv_temp_snapshot_flags(flags);
1448             flags = bdrv_backing_flags(flags);
1449         }
1450 
1451         assert(file == NULL);
1452         bs->open_flags = flags;
1453         ret = bdrv_open_image(&file, filename, options, "file",
1454                               bs, &child_file, true, &local_err);
1455         if (ret < 0) {
1456             goto fail;
1457         }
1458     }
1459 
1460     /* Image format probing */
1461     bs->probed = !drv;
1462     if (!drv && file) {
1463         ret = find_image_format(file, filename, &drv, &local_err);
1464         if (ret < 0) {
1465             goto fail;
1466         }
1467     } else if (!drv) {
1468         error_setg(errp, "Must specify either driver or file");
1469         ret = -EINVAL;
1470         goto fail;
1471     }
1472 
1473     /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1474     assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1475     /* file must be NULL if a protocol BDS is about to be created
1476      * (the inverse results in an error message from bdrv_open_common()) */
1477     assert(!(flags & BDRV_O_PROTOCOL) || !file);
1478 
1479     /* Open the image */
1480     ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1481     if (ret < 0) {
1482         goto fail;
1483     }
1484 
1485     if (file && (bs->file != file)) {
1486         bdrv_unref(file);
1487         file = NULL;
1488     }
1489 
1490     /* If there is a backing file, use it */
1491     if ((flags & BDRV_O_NO_BACKING) == 0) {
1492         QDict *backing_options;
1493 
1494         qdict_extract_subqdict(options, &backing_options, "backing.");
1495         ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1496         if (ret < 0) {
1497             goto close_and_fail;
1498         }
1499     }
1500 
1501     bdrv_refresh_filename(bs);
1502 
1503     /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1504      * temporary snapshot afterwards. */
1505     if (snapshot_flags) {
1506         ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1507         if (local_err) {
1508             goto close_and_fail;
1509         }
1510     }
1511 
1512     /* Check if any unknown options were used */
1513     if (options && (qdict_size(options) != 0)) {
1514         const QDictEntry *entry = qdict_first(options);
1515         if (flags & BDRV_O_PROTOCOL) {
1516             error_setg(errp, "Block protocol '%s' doesn't support the option "
1517                        "'%s'", drv->format_name, entry->key);
1518         } else {
1519             error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1520                        "support the option '%s'", drv->format_name,
1521                        bdrv_get_device_name(bs), entry->key);
1522         }
1523 
1524         ret = -EINVAL;
1525         goto close_and_fail;
1526     }
1527 
1528     if (!bdrv_key_required(bs)) {
1529         if (bs->blk) {
1530             blk_dev_change_media_cb(bs->blk, true);
1531         }
1532     } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1533                && !runstate_check(RUN_STATE_INMIGRATE)
1534                && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1535         error_setg(errp,
1536                    "Guest must be stopped for opening of encrypted image");
1537         ret = -EBUSY;
1538         goto close_and_fail;
1539     }
1540 
1541     if (child_role) {
1542         bdrv_attach_child(parent, bs, child_role);
1543     }
1544 
1545     QDECREF(options);
1546     *pbs = bs;
1547     return 0;
1548 
1549 fail:
1550     if (file != NULL) {
1551         bdrv_unref(file);
1552     }
1553     QDECREF(bs->options);
1554     QDECREF(options);
1555     bs->options = NULL;
1556     if (!*pbs) {
1557         /* If *pbs is NULL, a new BDS has been created in this function and
1558            needs to be freed now. Otherwise, it does not need to be closed,
1559            since it has not really been opened yet. */
1560         bdrv_unref(bs);
1561     }
1562     if (local_err) {
1563         error_propagate(errp, local_err);
1564     }
1565     return ret;
1566 
1567 close_and_fail:
1568     /* See fail path, but now the BDS has to be always closed */
1569     if (*pbs) {
1570         bdrv_close(bs);
1571     } else {
1572         bdrv_unref(bs);
1573     }
1574     QDECREF(options);
1575     if (local_err) {
1576         error_propagate(errp, local_err);
1577     }
1578     return ret;
1579 }
1580 
1581 int bdrv_open(BlockDriverState **pbs, const char *filename,
1582               const char *reference, QDict *options, int flags,
1583               BlockDriver *drv, Error **errp)
1584 {
1585     return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1586                              NULL, drv, errp);
1587 }
1588 
1589 typedef struct BlockReopenQueueEntry {
1590      bool prepared;
1591      BDRVReopenState state;
1592      QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1593 } BlockReopenQueueEntry;
1594 
1595 /*
1596  * Adds a BlockDriverState to a simple queue for an atomic, transactional
1597  * reopen of multiple devices.
1598  *
1599  * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1600  * already performed, or alternatively may be NULL a new BlockReopenQueue will
1601  * be created and initialized. This newly created BlockReopenQueue should be
1602  * passed back in for subsequent calls that are intended to be of the same
1603  * atomic 'set'.
1604  *
1605  * bs is the BlockDriverState to add to the reopen queue.
1606  *
1607  * flags contains the open flags for the associated bs
1608  *
1609  * returns a pointer to bs_queue, which is either the newly allocated
1610  * bs_queue, or the existing bs_queue being used.
1611  *
1612  */
1613 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1614                                     BlockDriverState *bs, int flags)
1615 {
1616     assert(bs != NULL);
1617 
1618     BlockReopenQueueEntry *bs_entry;
1619     BdrvChild *child;
1620 
1621     if (bs_queue == NULL) {
1622         bs_queue = g_new0(BlockReopenQueue, 1);
1623         QSIMPLEQ_INIT(bs_queue);
1624     }
1625 
1626     /* bdrv_open() masks this flag out */
1627     flags &= ~BDRV_O_PROTOCOL;
1628 
1629     QLIST_FOREACH(child, &bs->children, next) {
1630         int child_flags;
1631 
1632         if (child->bs->inherits_from != bs) {
1633             continue;
1634         }
1635 
1636         child_flags = child->role->inherit_flags(flags);
1637         bdrv_reopen_queue(bs_queue, child->bs, child_flags);
1638     }
1639 
1640     bs_entry = g_new0(BlockReopenQueueEntry, 1);
1641     QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1642 
1643     bs_entry->state.bs = bs;
1644     bs_entry->state.flags = flags;
1645 
1646     return bs_queue;
1647 }
1648 
1649 /*
1650  * Reopen multiple BlockDriverStates atomically & transactionally.
1651  *
1652  * The queue passed in (bs_queue) must have been built up previous
1653  * via bdrv_reopen_queue().
1654  *
1655  * Reopens all BDS specified in the queue, with the appropriate
1656  * flags.  All devices are prepared for reopen, and failure of any
1657  * device will cause all device changes to be abandonded, and intermediate
1658  * data cleaned up.
1659  *
1660  * If all devices prepare successfully, then the changes are committed
1661  * to all devices.
1662  *
1663  */
1664 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1665 {
1666     int ret = -1;
1667     BlockReopenQueueEntry *bs_entry, *next;
1668     Error *local_err = NULL;
1669 
1670     assert(bs_queue != NULL);
1671 
1672     bdrv_drain_all();
1673 
1674     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1675         if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1676             error_propagate(errp, local_err);
1677             goto cleanup;
1678         }
1679         bs_entry->prepared = true;
1680     }
1681 
1682     /* If we reach this point, we have success and just need to apply the
1683      * changes
1684      */
1685     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1686         bdrv_reopen_commit(&bs_entry->state);
1687     }
1688 
1689     ret = 0;
1690 
1691 cleanup:
1692     QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1693         if (ret && bs_entry->prepared) {
1694             bdrv_reopen_abort(&bs_entry->state);
1695         }
1696         g_free(bs_entry);
1697     }
1698     g_free(bs_queue);
1699     return ret;
1700 }
1701 
1702 
1703 /* Reopen a single BlockDriverState with the specified flags. */
1704 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1705 {
1706     int ret = -1;
1707     Error *local_err = NULL;
1708     BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1709 
1710     ret = bdrv_reopen_multiple(queue, &local_err);
1711     if (local_err != NULL) {
1712         error_propagate(errp, local_err);
1713     }
1714     return ret;
1715 }
1716 
1717 
1718 /*
1719  * Prepares a BlockDriverState for reopen. All changes are staged in the
1720  * 'opaque' field of the BDRVReopenState, which is used and allocated by
1721  * the block driver layer .bdrv_reopen_prepare()
1722  *
1723  * bs is the BlockDriverState to reopen
1724  * flags are the new open flags
1725  * queue is the reopen queue
1726  *
1727  * Returns 0 on success, non-zero on error.  On error errp will be set
1728  * as well.
1729  *
1730  * On failure, bdrv_reopen_abort() will be called to clean up any data.
1731  * It is the responsibility of the caller to then call the abort() or
1732  * commit() for any other BDS that have been left in a prepare() state
1733  *
1734  */
1735 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1736                         Error **errp)
1737 {
1738     int ret = -1;
1739     Error *local_err = NULL;
1740     BlockDriver *drv;
1741 
1742     assert(reopen_state != NULL);
1743     assert(reopen_state->bs->drv != NULL);
1744     drv = reopen_state->bs->drv;
1745 
1746     /* if we are to stay read-only, do not allow permission change
1747      * to r/w */
1748     if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1749         reopen_state->flags & BDRV_O_RDWR) {
1750         error_setg(errp, "Node '%s' is read only",
1751                    bdrv_get_device_or_node_name(reopen_state->bs));
1752         goto error;
1753     }
1754 
1755 
1756     ret = bdrv_flush(reopen_state->bs);
1757     if (ret) {
1758         error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1759                   strerror(-ret));
1760         goto error;
1761     }
1762 
1763     if (drv->bdrv_reopen_prepare) {
1764         ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1765         if (ret) {
1766             if (local_err != NULL) {
1767                 error_propagate(errp, local_err);
1768             } else {
1769                 error_setg(errp, "failed while preparing to reopen image '%s'",
1770                            reopen_state->bs->filename);
1771             }
1772             goto error;
1773         }
1774     } else {
1775         /* It is currently mandatory to have a bdrv_reopen_prepare()
1776          * handler for each supported drv. */
1777         error_setg(errp, "Block format '%s' used by node '%s' "
1778                    "does not support reopening files", drv->format_name,
1779                    bdrv_get_device_or_node_name(reopen_state->bs));
1780         ret = -1;
1781         goto error;
1782     }
1783 
1784     ret = 0;
1785 
1786 error:
1787     return ret;
1788 }
1789 
1790 /*
1791  * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1792  * makes them final by swapping the staging BlockDriverState contents into
1793  * the active BlockDriverState contents.
1794  */
1795 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1796 {
1797     BlockDriver *drv;
1798 
1799     assert(reopen_state != NULL);
1800     drv = reopen_state->bs->drv;
1801     assert(drv != NULL);
1802 
1803     /* If there are any driver level actions to take */
1804     if (drv->bdrv_reopen_commit) {
1805         drv->bdrv_reopen_commit(reopen_state);
1806     }
1807 
1808     /* set BDS specific flags now */
1809     reopen_state->bs->open_flags         = reopen_state->flags;
1810     reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1811                                               BDRV_O_CACHE_WB);
1812     reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1813 
1814     bdrv_refresh_limits(reopen_state->bs, NULL);
1815 }
1816 
1817 /*
1818  * Abort the reopen, and delete and free the staged changes in
1819  * reopen_state
1820  */
1821 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1822 {
1823     BlockDriver *drv;
1824 
1825     assert(reopen_state != NULL);
1826     drv = reopen_state->bs->drv;
1827     assert(drv != NULL);
1828 
1829     if (drv->bdrv_reopen_abort) {
1830         drv->bdrv_reopen_abort(reopen_state);
1831     }
1832 }
1833 
1834 
1835 void bdrv_close(BlockDriverState *bs)
1836 {
1837     BdrvAioNotifier *ban, *ban_next;
1838 
1839     if (bs->job) {
1840         block_job_cancel_sync(bs->job);
1841     }
1842     bdrv_drain_all(); /* complete I/O */
1843     bdrv_flush(bs);
1844     bdrv_drain_all(); /* in case flush left pending I/O */
1845     notifier_list_notify(&bs->close_notifiers, bs);
1846 
1847     if (bs->drv) {
1848         BdrvChild *child, *next;
1849 
1850         QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
1851             if (child->bs->inherits_from == bs) {
1852                 child->bs->inherits_from = NULL;
1853             }
1854             QLIST_REMOVE(child, next);
1855             g_free(child);
1856         }
1857 
1858         if (bs->backing_hd) {
1859             BlockDriverState *backing_hd = bs->backing_hd;
1860             bdrv_set_backing_hd(bs, NULL);
1861             bdrv_unref(backing_hd);
1862         }
1863         bs->drv->bdrv_close(bs);
1864         g_free(bs->opaque);
1865         bs->opaque = NULL;
1866         bs->drv = NULL;
1867         bs->copy_on_read = 0;
1868         bs->backing_file[0] = '\0';
1869         bs->backing_format[0] = '\0';
1870         bs->total_sectors = 0;
1871         bs->encrypted = 0;
1872         bs->valid_key = 0;
1873         bs->sg = 0;
1874         bs->zero_beyond_eof = false;
1875         QDECREF(bs->options);
1876         bs->options = NULL;
1877         QDECREF(bs->full_open_options);
1878         bs->full_open_options = NULL;
1879 
1880         if (bs->file != NULL) {
1881             bdrv_unref(bs->file);
1882             bs->file = NULL;
1883         }
1884     }
1885 
1886     if (bs->blk) {
1887         blk_dev_change_media_cb(bs->blk, false);
1888     }
1889 
1890     /*throttling disk I/O limits*/
1891     if (bs->io_limits_enabled) {
1892         bdrv_io_limits_disable(bs);
1893     }
1894 
1895     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1896         g_free(ban);
1897     }
1898     QLIST_INIT(&bs->aio_notifiers);
1899 }
1900 
1901 void bdrv_close_all(void)
1902 {
1903     BlockDriverState *bs;
1904 
1905     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1906         AioContext *aio_context = bdrv_get_aio_context(bs);
1907 
1908         aio_context_acquire(aio_context);
1909         bdrv_close(bs);
1910         aio_context_release(aio_context);
1911     }
1912 }
1913 
1914 /* make a BlockDriverState anonymous by removing from bdrv_state and
1915  * graph_bdrv_state list.
1916    Also, NULL terminate the device_name to prevent double remove */
1917 void bdrv_make_anon(BlockDriverState *bs)
1918 {
1919     /*
1920      * Take care to remove bs from bdrv_states only when it's actually
1921      * in it.  Note that bs->device_list.tqe_prev is initially null,
1922      * and gets set to non-null by QTAILQ_INSERT_TAIL().  Establish
1923      * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1924      * resetting it to null on remove.
1925      */
1926     if (bs->device_list.tqe_prev) {
1927         QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1928         bs->device_list.tqe_prev = NULL;
1929     }
1930     if (bs->node_name[0] != '\0') {
1931         QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1932     }
1933     bs->node_name[0] = '\0';
1934 }
1935 
1936 static void bdrv_rebind(BlockDriverState *bs)
1937 {
1938     if (bs->drv && bs->drv->bdrv_rebind) {
1939         bs->drv->bdrv_rebind(bs);
1940     }
1941 }
1942 
1943 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1944                                      BlockDriverState *bs_src)
1945 {
1946     /* move some fields that need to stay attached to the device */
1947 
1948     /* dev info */
1949     bs_dest->guest_block_size   = bs_src->guest_block_size;
1950     bs_dest->copy_on_read       = bs_src->copy_on_read;
1951 
1952     bs_dest->enable_write_cache = bs_src->enable_write_cache;
1953 
1954     /* i/o throttled req */
1955     bs_dest->throttle_state     = bs_src->throttle_state,
1956     bs_dest->io_limits_enabled  = bs_src->io_limits_enabled;
1957     bs_dest->pending_reqs[0]    = bs_src->pending_reqs[0];
1958     bs_dest->pending_reqs[1]    = bs_src->pending_reqs[1];
1959     bs_dest->throttled_reqs[0]  = bs_src->throttled_reqs[0];
1960     bs_dest->throttled_reqs[1]  = bs_src->throttled_reqs[1];
1961     memcpy(&bs_dest->round_robin,
1962            &bs_src->round_robin,
1963            sizeof(bs_dest->round_robin));
1964     memcpy(&bs_dest->throttle_timers,
1965            &bs_src->throttle_timers,
1966            sizeof(ThrottleTimers));
1967 
1968     /* r/w error */
1969     bs_dest->on_read_error      = bs_src->on_read_error;
1970     bs_dest->on_write_error     = bs_src->on_write_error;
1971 
1972     /* i/o status */
1973     bs_dest->iostatus_enabled   = bs_src->iostatus_enabled;
1974     bs_dest->iostatus           = bs_src->iostatus;
1975 
1976     /* dirty bitmap */
1977     bs_dest->dirty_bitmaps      = bs_src->dirty_bitmaps;
1978 
1979     /* reference count */
1980     bs_dest->refcnt             = bs_src->refcnt;
1981 
1982     /* job */
1983     bs_dest->job                = bs_src->job;
1984 
1985     /* keep the same entry in bdrv_states */
1986     bs_dest->device_list = bs_src->device_list;
1987     bs_dest->blk = bs_src->blk;
1988 
1989     memcpy(bs_dest->op_blockers, bs_src->op_blockers,
1990            sizeof(bs_dest->op_blockers));
1991 }
1992 
1993 /*
1994  * Swap bs contents for two image chains while they are live,
1995  * while keeping required fields on the BlockDriverState that is
1996  * actually attached to a device.
1997  *
1998  * This will modify the BlockDriverState fields, and swap contents
1999  * between bs_new and bs_old. Both bs_new and bs_old are modified.
2000  *
2001  * bs_new must not be attached to a BlockBackend.
2002  *
2003  * This function does not create any image files.
2004  */
2005 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2006 {
2007     BlockDriverState tmp;
2008     BdrvChild *child;
2009 
2010     bdrv_drain(bs_new);
2011     bdrv_drain(bs_old);
2012 
2013     /* The code needs to swap the node_name but simply swapping node_list won't
2014      * work so first remove the nodes from the graph list, do the swap then
2015      * insert them back if needed.
2016      */
2017     if (bs_new->node_name[0] != '\0') {
2018         QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2019     }
2020     if (bs_old->node_name[0] != '\0') {
2021         QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2022     }
2023 
2024     /* If the BlockDriverState is part of a throttling group acquire
2025      * its lock since we're going to mess with the protected fields.
2026      * Otherwise there's no need to worry since no one else can touch
2027      * them. */
2028     if (bs_old->throttle_state) {
2029         throttle_group_lock(bs_old);
2030     }
2031 
2032     /* bs_new must be unattached and shouldn't have anything fancy enabled */
2033     assert(!bs_new->blk);
2034     assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2035     assert(bs_new->job == NULL);
2036     assert(bs_new->io_limits_enabled == false);
2037     assert(bs_new->throttle_state == NULL);
2038     assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2039 
2040     tmp = *bs_new;
2041     *bs_new = *bs_old;
2042     *bs_old = tmp;
2043 
2044     /* there are some fields that should not be swapped, move them back */
2045     bdrv_move_feature_fields(&tmp, bs_old);
2046     bdrv_move_feature_fields(bs_old, bs_new);
2047     bdrv_move_feature_fields(bs_new, &tmp);
2048 
2049     /* bs_new must remain unattached */
2050     assert(!bs_new->blk);
2051 
2052     /* Check a few fields that should remain attached to the device */
2053     assert(bs_new->job == NULL);
2054     assert(bs_new->io_limits_enabled == false);
2055     assert(bs_new->throttle_state == NULL);
2056     assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2057 
2058     /* Release the ThrottleGroup lock */
2059     if (bs_old->throttle_state) {
2060         throttle_group_unlock(bs_old);
2061     }
2062 
2063     /* insert the nodes back into the graph node list if needed */
2064     if (bs_new->node_name[0] != '\0') {
2065         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2066     }
2067     if (bs_old->node_name[0] != '\0') {
2068         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2069     }
2070 
2071     /*
2072      * Update lh_first.le_prev for non-empty lists.
2073      *
2074      * The head of the op blocker list doesn't change because it is moved back
2075      * in bdrv_move_feature_fields().
2076      */
2077     assert(QLIST_EMPTY(&bs_old->tracked_requests));
2078     assert(QLIST_EMPTY(&bs_new->tracked_requests));
2079 
2080     QLIST_FIX_HEAD_PTR(&bs_new->children, next);
2081     QLIST_FIX_HEAD_PTR(&bs_old->children, next);
2082 
2083     /* Update references in bs->opaque and children */
2084     QLIST_FOREACH(child, &bs_old->children, next) {
2085         if (child->bs->inherits_from == bs_new) {
2086             child->bs->inherits_from = bs_old;
2087         }
2088     }
2089     QLIST_FOREACH(child, &bs_new->children, next) {
2090         if (child->bs->inherits_from == bs_old) {
2091             child->bs->inherits_from = bs_new;
2092         }
2093     }
2094 
2095     bdrv_rebind(bs_new);
2096     bdrv_rebind(bs_old);
2097 }
2098 
2099 /*
2100  * Add new bs contents at the top of an image chain while the chain is
2101  * live, while keeping required fields on the top layer.
2102  *
2103  * This will modify the BlockDriverState fields, and swap contents
2104  * between bs_new and bs_top. Both bs_new and bs_top are modified.
2105  *
2106  * bs_new must not be attached to a BlockBackend.
2107  *
2108  * This function does not create any image files.
2109  */
2110 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2111 {
2112     bdrv_swap(bs_new, bs_top);
2113 
2114     /* The contents of 'tmp' will become bs_top, as we are
2115      * swapping bs_new and bs_top contents. */
2116     bdrv_set_backing_hd(bs_top, bs_new);
2117     bdrv_attach_child(bs_top, bs_new, &child_backing);
2118 }
2119 
2120 static void bdrv_delete(BlockDriverState *bs)
2121 {
2122     assert(!bs->job);
2123     assert(bdrv_op_blocker_is_empty(bs));
2124     assert(!bs->refcnt);
2125     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2126 
2127     bdrv_close(bs);
2128 
2129     /* remove from list, if necessary */
2130     bdrv_make_anon(bs);
2131 
2132     g_free(bs);
2133 }
2134 
2135 /*
2136  * Run consistency checks on an image
2137  *
2138  * Returns 0 if the check could be completed (it doesn't mean that the image is
2139  * free of errors) or -errno when an internal error occurred. The results of the
2140  * check are stored in res.
2141  */
2142 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2143 {
2144     if (bs->drv == NULL) {
2145         return -ENOMEDIUM;
2146     }
2147     if (bs->drv->bdrv_check == NULL) {
2148         return -ENOTSUP;
2149     }
2150 
2151     memset(res, 0, sizeof(*res));
2152     return bs->drv->bdrv_check(bs, res, fix);
2153 }
2154 
2155 #define COMMIT_BUF_SECTORS 2048
2156 
2157 /* commit COW file into the raw image */
2158 int bdrv_commit(BlockDriverState *bs)
2159 {
2160     BlockDriver *drv = bs->drv;
2161     int64_t sector, total_sectors, length, backing_length;
2162     int n, ro, open_flags;
2163     int ret = 0;
2164     uint8_t *buf = NULL;
2165 
2166     if (!drv)
2167         return -ENOMEDIUM;
2168 
2169     if (!bs->backing_hd) {
2170         return -ENOTSUP;
2171     }
2172 
2173     if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2174         bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2175         return -EBUSY;
2176     }
2177 
2178     ro = bs->backing_hd->read_only;
2179     open_flags =  bs->backing_hd->open_flags;
2180 
2181     if (ro) {
2182         if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2183             return -EACCES;
2184         }
2185     }
2186 
2187     length = bdrv_getlength(bs);
2188     if (length < 0) {
2189         ret = length;
2190         goto ro_cleanup;
2191     }
2192 
2193     backing_length = bdrv_getlength(bs->backing_hd);
2194     if (backing_length < 0) {
2195         ret = backing_length;
2196         goto ro_cleanup;
2197     }
2198 
2199     /* If our top snapshot is larger than the backing file image,
2200      * grow the backing file image if possible.  If not possible,
2201      * we must return an error */
2202     if (length > backing_length) {
2203         ret = bdrv_truncate(bs->backing_hd, length);
2204         if (ret < 0) {
2205             goto ro_cleanup;
2206         }
2207     }
2208 
2209     total_sectors = length >> BDRV_SECTOR_BITS;
2210 
2211     /* qemu_try_blockalign() for bs will choose an alignment that works for
2212      * bs->backing_hd as well, so no need to compare the alignment manually. */
2213     buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2214     if (buf == NULL) {
2215         ret = -ENOMEM;
2216         goto ro_cleanup;
2217     }
2218 
2219     for (sector = 0; sector < total_sectors; sector += n) {
2220         ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2221         if (ret < 0) {
2222             goto ro_cleanup;
2223         }
2224         if (ret) {
2225             ret = bdrv_read(bs, sector, buf, n);
2226             if (ret < 0) {
2227                 goto ro_cleanup;
2228             }
2229 
2230             ret = bdrv_write(bs->backing_hd, sector, buf, n);
2231             if (ret < 0) {
2232                 goto ro_cleanup;
2233             }
2234         }
2235     }
2236 
2237     if (drv->bdrv_make_empty) {
2238         ret = drv->bdrv_make_empty(bs);
2239         if (ret < 0) {
2240             goto ro_cleanup;
2241         }
2242         bdrv_flush(bs);
2243     }
2244 
2245     /*
2246      * Make sure all data we wrote to the backing device is actually
2247      * stable on disk.
2248      */
2249     if (bs->backing_hd) {
2250         bdrv_flush(bs->backing_hd);
2251     }
2252 
2253     ret = 0;
2254 ro_cleanup:
2255     qemu_vfree(buf);
2256 
2257     if (ro) {
2258         /* ignoring error return here */
2259         bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2260     }
2261 
2262     return ret;
2263 }
2264 
2265 int bdrv_commit_all(void)
2266 {
2267     BlockDriverState *bs;
2268 
2269     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2270         AioContext *aio_context = bdrv_get_aio_context(bs);
2271 
2272         aio_context_acquire(aio_context);
2273         if (bs->drv && bs->backing_hd) {
2274             int ret = bdrv_commit(bs);
2275             if (ret < 0) {
2276                 aio_context_release(aio_context);
2277                 return ret;
2278             }
2279         }
2280         aio_context_release(aio_context);
2281     }
2282     return 0;
2283 }
2284 
2285 /*
2286  * Return values:
2287  * 0        - success
2288  * -EINVAL  - backing format specified, but no file
2289  * -ENOSPC  - can't update the backing file because no space is left in the
2290  *            image file header
2291  * -ENOTSUP - format driver doesn't support changing the backing file
2292  */
2293 int bdrv_change_backing_file(BlockDriverState *bs,
2294     const char *backing_file, const char *backing_fmt)
2295 {
2296     BlockDriver *drv = bs->drv;
2297     int ret;
2298 
2299     /* Backing file format doesn't make sense without a backing file */
2300     if (backing_fmt && !backing_file) {
2301         return -EINVAL;
2302     }
2303 
2304     if (drv->bdrv_change_backing_file != NULL) {
2305         ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2306     } else {
2307         ret = -ENOTSUP;
2308     }
2309 
2310     if (ret == 0) {
2311         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2312         pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2313     }
2314     return ret;
2315 }
2316 
2317 /*
2318  * Finds the image layer in the chain that has 'bs' as its backing file.
2319  *
2320  * active is the current topmost image.
2321  *
2322  * Returns NULL if bs is not found in active's image chain,
2323  * or if active == bs.
2324  *
2325  * Returns the bottommost base image if bs == NULL.
2326  */
2327 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2328                                     BlockDriverState *bs)
2329 {
2330     while (active && bs != active->backing_hd) {
2331         active = active->backing_hd;
2332     }
2333 
2334     return active;
2335 }
2336 
2337 /* Given a BDS, searches for the base layer. */
2338 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2339 {
2340     return bdrv_find_overlay(bs, NULL);
2341 }
2342 
2343 typedef struct BlkIntermediateStates {
2344     BlockDriverState *bs;
2345     QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2346 } BlkIntermediateStates;
2347 
2348 
2349 /*
2350  * Drops images above 'base' up to and including 'top', and sets the image
2351  * above 'top' to have base as its backing file.
2352  *
2353  * Requires that the overlay to 'top' is opened r/w, so that the backing file
2354  * information in 'bs' can be properly updated.
2355  *
2356  * E.g., this will convert the following chain:
2357  * bottom <- base <- intermediate <- top <- active
2358  *
2359  * to
2360  *
2361  * bottom <- base <- active
2362  *
2363  * It is allowed for bottom==base, in which case it converts:
2364  *
2365  * base <- intermediate <- top <- active
2366  *
2367  * to
2368  *
2369  * base <- active
2370  *
2371  * If backing_file_str is non-NULL, it will be used when modifying top's
2372  * overlay image metadata.
2373  *
2374  * Error conditions:
2375  *  if active == top, that is considered an error
2376  *
2377  */
2378 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2379                            BlockDriverState *base, const char *backing_file_str)
2380 {
2381     BlockDriverState *intermediate;
2382     BlockDriverState *base_bs = NULL;
2383     BlockDriverState *new_top_bs = NULL;
2384     BlkIntermediateStates *intermediate_state, *next;
2385     int ret = -EIO;
2386 
2387     QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2388     QSIMPLEQ_INIT(&states_to_delete);
2389 
2390     if (!top->drv || !base->drv) {
2391         goto exit;
2392     }
2393 
2394     new_top_bs = bdrv_find_overlay(active, top);
2395 
2396     if (new_top_bs == NULL) {
2397         /* we could not find the image above 'top', this is an error */
2398         goto exit;
2399     }
2400 
2401     /* special case of new_top_bs->backing_hd already pointing to base - nothing
2402      * to do, no intermediate images */
2403     if (new_top_bs->backing_hd == base) {
2404         ret = 0;
2405         goto exit;
2406     }
2407 
2408     intermediate = top;
2409 
2410     /* now we will go down through the list, and add each BDS we find
2411      * into our deletion queue, until we hit the 'base'
2412      */
2413     while (intermediate) {
2414         intermediate_state = g_new0(BlkIntermediateStates, 1);
2415         intermediate_state->bs = intermediate;
2416         QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2417 
2418         if (intermediate->backing_hd == base) {
2419             base_bs = intermediate->backing_hd;
2420             break;
2421         }
2422         intermediate = intermediate->backing_hd;
2423     }
2424     if (base_bs == NULL) {
2425         /* something went wrong, we did not end at the base. safely
2426          * unravel everything, and exit with error */
2427         goto exit;
2428     }
2429 
2430     /* success - we can delete the intermediate states, and link top->base */
2431     backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2432     ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2433                                    base_bs->drv ? base_bs->drv->format_name : "");
2434     if (ret) {
2435         goto exit;
2436     }
2437     bdrv_set_backing_hd(new_top_bs, base_bs);
2438 
2439     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2440         /* so that bdrv_close() does not recursively close the chain */
2441         bdrv_set_backing_hd(intermediate_state->bs, NULL);
2442         bdrv_unref(intermediate_state->bs);
2443     }
2444     ret = 0;
2445 
2446 exit:
2447     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2448         g_free(intermediate_state);
2449     }
2450     return ret;
2451 }
2452 
2453 /**
2454  * Truncate file to 'offset' bytes (needed only for file protocols)
2455  */
2456 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2457 {
2458     BlockDriver *drv = bs->drv;
2459     int ret;
2460     if (!drv)
2461         return -ENOMEDIUM;
2462     if (!drv->bdrv_truncate)
2463         return -ENOTSUP;
2464     if (bs->read_only)
2465         return -EACCES;
2466 
2467     ret = drv->bdrv_truncate(bs, offset);
2468     if (ret == 0) {
2469         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2470         bdrv_dirty_bitmap_truncate(bs);
2471         if (bs->blk) {
2472             blk_dev_resize_cb(bs->blk);
2473         }
2474     }
2475     return ret;
2476 }
2477 
2478 /**
2479  * Length of a allocated file in bytes. Sparse files are counted by actual
2480  * allocated space. Return < 0 if error or unknown.
2481  */
2482 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2483 {
2484     BlockDriver *drv = bs->drv;
2485     if (!drv) {
2486         return -ENOMEDIUM;
2487     }
2488     if (drv->bdrv_get_allocated_file_size) {
2489         return drv->bdrv_get_allocated_file_size(bs);
2490     }
2491     if (bs->file) {
2492         return bdrv_get_allocated_file_size(bs->file);
2493     }
2494     return -ENOTSUP;
2495 }
2496 
2497 /**
2498  * Return number of sectors on success, -errno on error.
2499  */
2500 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2501 {
2502     BlockDriver *drv = bs->drv;
2503 
2504     if (!drv)
2505         return -ENOMEDIUM;
2506 
2507     if (drv->has_variable_length) {
2508         int ret = refresh_total_sectors(bs, bs->total_sectors);
2509         if (ret < 0) {
2510             return ret;
2511         }
2512     }
2513     return bs->total_sectors;
2514 }
2515 
2516 /**
2517  * Return length in bytes on success, -errno on error.
2518  * The length is always a multiple of BDRV_SECTOR_SIZE.
2519  */
2520 int64_t bdrv_getlength(BlockDriverState *bs)
2521 {
2522     int64_t ret = bdrv_nb_sectors(bs);
2523 
2524     ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2525     return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2526 }
2527 
2528 /* return 0 as number of sectors if no device present or error */
2529 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2530 {
2531     int64_t nb_sectors = bdrv_nb_sectors(bs);
2532 
2533     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2534 }
2535 
2536 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2537                        BlockdevOnError on_write_error)
2538 {
2539     bs->on_read_error = on_read_error;
2540     bs->on_write_error = on_write_error;
2541 }
2542 
2543 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2544 {
2545     return is_read ? bs->on_read_error : bs->on_write_error;
2546 }
2547 
2548 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2549 {
2550     BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2551 
2552     switch (on_err) {
2553     case BLOCKDEV_ON_ERROR_ENOSPC:
2554         return (error == ENOSPC) ?
2555                BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2556     case BLOCKDEV_ON_ERROR_STOP:
2557         return BLOCK_ERROR_ACTION_STOP;
2558     case BLOCKDEV_ON_ERROR_REPORT:
2559         return BLOCK_ERROR_ACTION_REPORT;
2560     case BLOCKDEV_ON_ERROR_IGNORE:
2561         return BLOCK_ERROR_ACTION_IGNORE;
2562     default:
2563         abort();
2564     }
2565 }
2566 
2567 static void send_qmp_error_event(BlockDriverState *bs,
2568                                  BlockErrorAction action,
2569                                  bool is_read, int error)
2570 {
2571     IoOperationType optype;
2572 
2573     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2574     qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
2575                                    bdrv_iostatus_is_enabled(bs),
2576                                    error == ENOSPC, strerror(error),
2577                                    &error_abort);
2578 }
2579 
2580 /* This is done by device models because, while the block layer knows
2581  * about the error, it does not know whether an operation comes from
2582  * the device or the block layer (from a job, for example).
2583  */
2584 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2585                        bool is_read, int error)
2586 {
2587     assert(error >= 0);
2588 
2589     if (action == BLOCK_ERROR_ACTION_STOP) {
2590         /* First set the iostatus, so that "info block" returns an iostatus
2591          * that matches the events raised so far (an additional error iostatus
2592          * is fine, but not a lost one).
2593          */
2594         bdrv_iostatus_set_err(bs, error);
2595 
2596         /* Then raise the request to stop the VM and the event.
2597          * qemu_system_vmstop_request_prepare has two effects.  First,
2598          * it ensures that the STOP event always comes after the
2599          * BLOCK_IO_ERROR event.  Second, it ensures that even if management
2600          * can observe the STOP event and do a "cont" before the STOP
2601          * event is issued, the VM will not stop.  In this case, vm_start()
2602          * also ensures that the STOP/RESUME pair of events is emitted.
2603          */
2604         qemu_system_vmstop_request_prepare();
2605         send_qmp_error_event(bs, action, is_read, error);
2606         qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2607     } else {
2608         send_qmp_error_event(bs, action, is_read, error);
2609     }
2610 }
2611 
2612 int bdrv_is_read_only(BlockDriverState *bs)
2613 {
2614     return bs->read_only;
2615 }
2616 
2617 int bdrv_is_sg(BlockDriverState *bs)
2618 {
2619     return bs->sg;
2620 }
2621 
2622 int bdrv_enable_write_cache(BlockDriverState *bs)
2623 {
2624     return bs->enable_write_cache;
2625 }
2626 
2627 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2628 {
2629     bs->enable_write_cache = wce;
2630 
2631     /* so a reopen() will preserve wce */
2632     if (wce) {
2633         bs->open_flags |= BDRV_O_CACHE_WB;
2634     } else {
2635         bs->open_flags &= ~BDRV_O_CACHE_WB;
2636     }
2637 }
2638 
2639 int bdrv_is_encrypted(BlockDriverState *bs)
2640 {
2641     if (bs->backing_hd && bs->backing_hd->encrypted)
2642         return 1;
2643     return bs->encrypted;
2644 }
2645 
2646 int bdrv_key_required(BlockDriverState *bs)
2647 {
2648     BlockDriverState *backing_hd = bs->backing_hd;
2649 
2650     if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2651         return 1;
2652     return (bs->encrypted && !bs->valid_key);
2653 }
2654 
2655 int bdrv_set_key(BlockDriverState *bs, const char *key)
2656 {
2657     int ret;
2658     if (bs->backing_hd && bs->backing_hd->encrypted) {
2659         ret = bdrv_set_key(bs->backing_hd, key);
2660         if (ret < 0)
2661             return ret;
2662         if (!bs->encrypted)
2663             return 0;
2664     }
2665     if (!bs->encrypted) {
2666         return -EINVAL;
2667     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2668         return -ENOMEDIUM;
2669     }
2670     ret = bs->drv->bdrv_set_key(bs, key);
2671     if (ret < 0) {
2672         bs->valid_key = 0;
2673     } else if (!bs->valid_key) {
2674         bs->valid_key = 1;
2675         if (bs->blk) {
2676             /* call the change callback now, we skipped it on open */
2677             blk_dev_change_media_cb(bs->blk, true);
2678         }
2679     }
2680     return ret;
2681 }
2682 
2683 /*
2684  * Provide an encryption key for @bs.
2685  * If @key is non-null:
2686  *     If @bs is not encrypted, fail.
2687  *     Else if the key is invalid, fail.
2688  *     Else set @bs's key to @key, replacing the existing key, if any.
2689  * If @key is null:
2690  *     If @bs is encrypted and still lacks a key, fail.
2691  *     Else do nothing.
2692  * On failure, store an error object through @errp if non-null.
2693  */
2694 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2695 {
2696     if (key) {
2697         if (!bdrv_is_encrypted(bs)) {
2698             error_setg(errp, "Node '%s' is not encrypted",
2699                       bdrv_get_device_or_node_name(bs));
2700         } else if (bdrv_set_key(bs, key) < 0) {
2701             error_set(errp, QERR_INVALID_PASSWORD);
2702         }
2703     } else {
2704         if (bdrv_key_required(bs)) {
2705             error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2706                       "'%s' (%s) is encrypted",
2707                       bdrv_get_device_or_node_name(bs),
2708                       bdrv_get_encrypted_filename(bs));
2709         }
2710     }
2711 }
2712 
2713 const char *bdrv_get_format_name(BlockDriverState *bs)
2714 {
2715     return bs->drv ? bs->drv->format_name : NULL;
2716 }
2717 
2718 static int qsort_strcmp(const void *a, const void *b)
2719 {
2720     return strcmp(a, b);
2721 }
2722 
2723 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2724                          void *opaque)
2725 {
2726     BlockDriver *drv;
2727     int count = 0;
2728     int i;
2729     const char **formats = NULL;
2730 
2731     QLIST_FOREACH(drv, &bdrv_drivers, list) {
2732         if (drv->format_name) {
2733             bool found = false;
2734             int i = count;
2735             while (formats && i && !found) {
2736                 found = !strcmp(formats[--i], drv->format_name);
2737             }
2738 
2739             if (!found) {
2740                 formats = g_renew(const char *, formats, count + 1);
2741                 formats[count++] = drv->format_name;
2742             }
2743         }
2744     }
2745 
2746     qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2747 
2748     for (i = 0; i < count; i++) {
2749         it(opaque, formats[i]);
2750     }
2751 
2752     g_free(formats);
2753 }
2754 
2755 /* This function is to find a node in the bs graph */
2756 BlockDriverState *bdrv_find_node(const char *node_name)
2757 {
2758     BlockDriverState *bs;
2759 
2760     assert(node_name);
2761 
2762     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2763         if (!strcmp(node_name, bs->node_name)) {
2764             return bs;
2765         }
2766     }
2767     return NULL;
2768 }
2769 
2770 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2771 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2772 {
2773     BlockDeviceInfoList *list, *entry;
2774     BlockDriverState *bs;
2775 
2776     list = NULL;
2777     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2778         BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2779         if (!info) {
2780             qapi_free_BlockDeviceInfoList(list);
2781             return NULL;
2782         }
2783         entry = g_malloc0(sizeof(*entry));
2784         entry->value = info;
2785         entry->next = list;
2786         list = entry;
2787     }
2788 
2789     return list;
2790 }
2791 
2792 BlockDriverState *bdrv_lookup_bs(const char *device,
2793                                  const char *node_name,
2794                                  Error **errp)
2795 {
2796     BlockBackend *blk;
2797     BlockDriverState *bs;
2798 
2799     if (device) {
2800         blk = blk_by_name(device);
2801 
2802         if (blk) {
2803             return blk_bs(blk);
2804         }
2805     }
2806 
2807     if (node_name) {
2808         bs = bdrv_find_node(node_name);
2809 
2810         if (bs) {
2811             return bs;
2812         }
2813     }
2814 
2815     error_setg(errp, "Cannot find device=%s nor node_name=%s",
2816                      device ? device : "",
2817                      node_name ? node_name : "");
2818     return NULL;
2819 }
2820 
2821 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2822  * return false.  If either argument is NULL, return false. */
2823 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2824 {
2825     while (top && top != base) {
2826         top = top->backing_hd;
2827     }
2828 
2829     return top != NULL;
2830 }
2831 
2832 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2833 {
2834     if (!bs) {
2835         return QTAILQ_FIRST(&graph_bdrv_states);
2836     }
2837     return QTAILQ_NEXT(bs, node_list);
2838 }
2839 
2840 BlockDriverState *bdrv_next(BlockDriverState *bs)
2841 {
2842     if (!bs) {
2843         return QTAILQ_FIRST(&bdrv_states);
2844     }
2845     return QTAILQ_NEXT(bs, device_list);
2846 }
2847 
2848 const char *bdrv_get_node_name(const BlockDriverState *bs)
2849 {
2850     return bs->node_name;
2851 }
2852 
2853 /* TODO check what callers really want: bs->node_name or blk_name() */
2854 const char *bdrv_get_device_name(const BlockDriverState *bs)
2855 {
2856     return bs->blk ? blk_name(bs->blk) : "";
2857 }
2858 
2859 /* This can be used to identify nodes that might not have a device
2860  * name associated. Since node and device names live in the same
2861  * namespace, the result is unambiguous. The exception is if both are
2862  * absent, then this returns an empty (non-null) string. */
2863 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2864 {
2865     return bs->blk ? blk_name(bs->blk) : bs->node_name;
2866 }
2867 
2868 int bdrv_get_flags(BlockDriverState *bs)
2869 {
2870     return bs->open_flags;
2871 }
2872 
2873 int bdrv_has_zero_init_1(BlockDriverState *bs)
2874 {
2875     return 1;
2876 }
2877 
2878 int bdrv_has_zero_init(BlockDriverState *bs)
2879 {
2880     assert(bs->drv);
2881 
2882     /* If BS is a copy on write image, it is initialized to
2883        the contents of the base image, which may not be zeroes.  */
2884     if (bs->backing_hd) {
2885         return 0;
2886     }
2887     if (bs->drv->bdrv_has_zero_init) {
2888         return bs->drv->bdrv_has_zero_init(bs);
2889     }
2890 
2891     /* safe default */
2892     return 0;
2893 }
2894 
2895 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2896 {
2897     BlockDriverInfo bdi;
2898 
2899     if (bs->backing_hd) {
2900         return false;
2901     }
2902 
2903     if (bdrv_get_info(bs, &bdi) == 0) {
2904         return bdi.unallocated_blocks_are_zero;
2905     }
2906 
2907     return false;
2908 }
2909 
2910 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2911 {
2912     BlockDriverInfo bdi;
2913 
2914     if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
2915         return false;
2916     }
2917 
2918     if (bdrv_get_info(bs, &bdi) == 0) {
2919         return bdi.can_write_zeroes_with_unmap;
2920     }
2921 
2922     return false;
2923 }
2924 
2925 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2926 {
2927     if (bs->backing_hd && bs->backing_hd->encrypted)
2928         return bs->backing_file;
2929     else if (bs->encrypted)
2930         return bs->filename;
2931     else
2932         return NULL;
2933 }
2934 
2935 void bdrv_get_backing_filename(BlockDriverState *bs,
2936                                char *filename, int filename_size)
2937 {
2938     pstrcpy(filename, filename_size, bs->backing_file);
2939 }
2940 
2941 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2942 {
2943     BlockDriver *drv = bs->drv;
2944     if (!drv)
2945         return -ENOMEDIUM;
2946     if (!drv->bdrv_get_info)
2947         return -ENOTSUP;
2948     memset(bdi, 0, sizeof(*bdi));
2949     return drv->bdrv_get_info(bs, bdi);
2950 }
2951 
2952 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
2953 {
2954     BlockDriver *drv = bs->drv;
2955     if (drv && drv->bdrv_get_specific_info) {
2956         return drv->bdrv_get_specific_info(bs);
2957     }
2958     return NULL;
2959 }
2960 
2961 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2962 {
2963     if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
2964         return;
2965     }
2966 
2967     bs->drv->bdrv_debug_event(bs, event);
2968 }
2969 
2970 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
2971                           const char *tag)
2972 {
2973     while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
2974         bs = bs->file;
2975     }
2976 
2977     if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
2978         return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
2979     }
2980 
2981     return -ENOTSUP;
2982 }
2983 
2984 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
2985 {
2986     while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
2987         bs = bs->file;
2988     }
2989 
2990     if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
2991         return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
2992     }
2993 
2994     return -ENOTSUP;
2995 }
2996 
2997 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
2998 {
2999     while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3000         bs = bs->file;
3001     }
3002 
3003     if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3004         return bs->drv->bdrv_debug_resume(bs, tag);
3005     }
3006 
3007     return -ENOTSUP;
3008 }
3009 
3010 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3011 {
3012     while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3013         bs = bs->file;
3014     }
3015 
3016     if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3017         return bs->drv->bdrv_debug_is_suspended(bs, tag);
3018     }
3019 
3020     return false;
3021 }
3022 
3023 int bdrv_is_snapshot(BlockDriverState *bs)
3024 {
3025     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3026 }
3027 
3028 /* backing_file can either be relative, or absolute, or a protocol.  If it is
3029  * relative, it must be relative to the chain.  So, passing in bs->filename
3030  * from a BDS as backing_file should not be done, as that may be relative to
3031  * the CWD rather than the chain. */
3032 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3033         const char *backing_file)
3034 {
3035     char *filename_full = NULL;
3036     char *backing_file_full = NULL;
3037     char *filename_tmp = NULL;
3038     int is_protocol = 0;
3039     BlockDriverState *curr_bs = NULL;
3040     BlockDriverState *retval = NULL;
3041 
3042     if (!bs || !bs->drv || !backing_file) {
3043         return NULL;
3044     }
3045 
3046     filename_full     = g_malloc(PATH_MAX);
3047     backing_file_full = g_malloc(PATH_MAX);
3048     filename_tmp      = g_malloc(PATH_MAX);
3049 
3050     is_protocol = path_has_protocol(backing_file);
3051 
3052     for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3053 
3054         /* If either of the filename paths is actually a protocol, then
3055          * compare unmodified paths; otherwise make paths relative */
3056         if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3057             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3058                 retval = curr_bs->backing_hd;
3059                 break;
3060             }
3061         } else {
3062             /* If not an absolute filename path, make it relative to the current
3063              * image's filename path */
3064             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3065                          backing_file);
3066 
3067             /* We are going to compare absolute pathnames */
3068             if (!realpath(filename_tmp, filename_full)) {
3069                 continue;
3070             }
3071 
3072             /* We need to make sure the backing filename we are comparing against
3073              * is relative to the current image filename (or absolute) */
3074             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3075                          curr_bs->backing_file);
3076 
3077             if (!realpath(filename_tmp, backing_file_full)) {
3078                 continue;
3079             }
3080 
3081             if (strcmp(backing_file_full, filename_full) == 0) {
3082                 retval = curr_bs->backing_hd;
3083                 break;
3084             }
3085         }
3086     }
3087 
3088     g_free(filename_full);
3089     g_free(backing_file_full);
3090     g_free(filename_tmp);
3091     return retval;
3092 }
3093 
3094 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3095 {
3096     if (!bs->drv) {
3097         return 0;
3098     }
3099 
3100     if (!bs->backing_hd) {
3101         return 0;
3102     }
3103 
3104     return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3105 }
3106 
3107 void bdrv_init(void)
3108 {
3109     module_call_init(MODULE_INIT_BLOCK);
3110 }
3111 
3112 void bdrv_init_with_whitelist(void)
3113 {
3114     use_bdrv_whitelist = 1;
3115     bdrv_init();
3116 }
3117 
3118 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3119 {
3120     Error *local_err = NULL;
3121     int ret;
3122 
3123     if (!bs->drv)  {
3124         return;
3125     }
3126 
3127     if (!(bs->open_flags & BDRV_O_INCOMING)) {
3128         return;
3129     }
3130     bs->open_flags &= ~BDRV_O_INCOMING;
3131 
3132     if (bs->drv->bdrv_invalidate_cache) {
3133         bs->drv->bdrv_invalidate_cache(bs, &local_err);
3134     } else if (bs->file) {
3135         bdrv_invalidate_cache(bs->file, &local_err);
3136     }
3137     if (local_err) {
3138         error_propagate(errp, local_err);
3139         return;
3140     }
3141 
3142     ret = refresh_total_sectors(bs, bs->total_sectors);
3143     if (ret < 0) {
3144         error_setg_errno(errp, -ret, "Could not refresh total sector count");
3145         return;
3146     }
3147 }
3148 
3149 void bdrv_invalidate_cache_all(Error **errp)
3150 {
3151     BlockDriverState *bs;
3152     Error *local_err = NULL;
3153 
3154     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3155         AioContext *aio_context = bdrv_get_aio_context(bs);
3156 
3157         aio_context_acquire(aio_context);
3158         bdrv_invalidate_cache(bs, &local_err);
3159         aio_context_release(aio_context);
3160         if (local_err) {
3161             error_propagate(errp, local_err);
3162             return;
3163         }
3164     }
3165 }
3166 
3167 /**************************************************************/
3168 /* removable device support */
3169 
3170 /**
3171  * Return TRUE if the media is present
3172  */
3173 int bdrv_is_inserted(BlockDriverState *bs)
3174 {
3175     BlockDriver *drv = bs->drv;
3176 
3177     if (!drv)
3178         return 0;
3179     if (!drv->bdrv_is_inserted)
3180         return 1;
3181     return drv->bdrv_is_inserted(bs);
3182 }
3183 
3184 /**
3185  * Return whether the media changed since the last call to this
3186  * function, or -ENOTSUP if we don't know.  Most drivers don't know.
3187  */
3188 int bdrv_media_changed(BlockDriverState *bs)
3189 {
3190     BlockDriver *drv = bs->drv;
3191 
3192     if (drv && drv->bdrv_media_changed) {
3193         return drv->bdrv_media_changed(bs);
3194     }
3195     return -ENOTSUP;
3196 }
3197 
3198 /**
3199  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3200  */
3201 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3202 {
3203     BlockDriver *drv = bs->drv;
3204     const char *device_name;
3205 
3206     if (drv && drv->bdrv_eject) {
3207         drv->bdrv_eject(bs, eject_flag);
3208     }
3209 
3210     device_name = bdrv_get_device_name(bs);
3211     if (device_name[0] != '\0') {
3212         qapi_event_send_device_tray_moved(device_name,
3213                                           eject_flag, &error_abort);
3214     }
3215 }
3216 
3217 /**
3218  * Lock or unlock the media (if it is locked, the user won't be able
3219  * to eject it manually).
3220  */
3221 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3222 {
3223     BlockDriver *drv = bs->drv;
3224 
3225     trace_bdrv_lock_medium(bs, locked);
3226 
3227     if (drv && drv->bdrv_lock_medium) {
3228         drv->bdrv_lock_medium(bs, locked);
3229     }
3230 }
3231 
3232 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
3233 {
3234     bs->guest_block_size = align;
3235 }
3236 
3237 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3238 {
3239     BdrvDirtyBitmap *bm;
3240 
3241     assert(name);
3242     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3243         if (bm->name && !strcmp(name, bm->name)) {
3244             return bm;
3245         }
3246     }
3247     return NULL;
3248 }
3249 
3250 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3251 {
3252     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3253     g_free(bitmap->name);
3254     bitmap->name = NULL;
3255 }
3256 
3257 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3258                                           uint32_t granularity,
3259                                           const char *name,
3260                                           Error **errp)
3261 {
3262     int64_t bitmap_size;
3263     BdrvDirtyBitmap *bitmap;
3264     uint32_t sector_granularity;
3265 
3266     assert((granularity & (granularity - 1)) == 0);
3267 
3268     if (name && bdrv_find_dirty_bitmap(bs, name)) {
3269         error_setg(errp, "Bitmap already exists: %s", name);
3270         return NULL;
3271     }
3272     sector_granularity = granularity >> BDRV_SECTOR_BITS;
3273     assert(sector_granularity);
3274     bitmap_size = bdrv_nb_sectors(bs);
3275     if (bitmap_size < 0) {
3276         error_setg_errno(errp, -bitmap_size, "could not get length of device");
3277         errno = -bitmap_size;
3278         return NULL;
3279     }
3280     bitmap = g_new0(BdrvDirtyBitmap, 1);
3281     bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3282     bitmap->size = bitmap_size;
3283     bitmap->name = g_strdup(name);
3284     bitmap->disabled = false;
3285     QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3286     return bitmap;
3287 }
3288 
3289 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3290 {
3291     return bitmap->successor;
3292 }
3293 
3294 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3295 {
3296     return !(bitmap->disabled || bitmap->successor);
3297 }
3298 
3299 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3300 {
3301     if (bdrv_dirty_bitmap_frozen(bitmap)) {
3302         return DIRTY_BITMAP_STATUS_FROZEN;
3303     } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3304         return DIRTY_BITMAP_STATUS_DISABLED;
3305     } else {
3306         return DIRTY_BITMAP_STATUS_ACTIVE;
3307     }
3308 }
3309 
3310 /**
3311  * Create a successor bitmap destined to replace this bitmap after an operation.
3312  * Requires that the bitmap is not frozen and has no successor.
3313  */
3314 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3315                                        BdrvDirtyBitmap *bitmap, Error **errp)
3316 {
3317     uint64_t granularity;
3318     BdrvDirtyBitmap *child;
3319 
3320     if (bdrv_dirty_bitmap_frozen(bitmap)) {
3321         error_setg(errp, "Cannot create a successor for a bitmap that is "
3322                    "currently frozen");
3323         return -1;
3324     }
3325     assert(!bitmap->successor);
3326 
3327     /* Create an anonymous successor */
3328     granularity = bdrv_dirty_bitmap_granularity(bitmap);
3329     child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3330     if (!child) {
3331         return -1;
3332     }
3333 
3334     /* Successor will be on or off based on our current state. */
3335     child->disabled = bitmap->disabled;
3336 
3337     /* Install the successor and freeze the parent */
3338     bitmap->successor = child;
3339     return 0;
3340 }
3341 
3342 /**
3343  * For a bitmap with a successor, yield our name to the successor,
3344  * delete the old bitmap, and return a handle to the new bitmap.
3345  */
3346 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3347                                             BdrvDirtyBitmap *bitmap,
3348                                             Error **errp)
3349 {
3350     char *name;
3351     BdrvDirtyBitmap *successor = bitmap->successor;
3352 
3353     if (successor == NULL) {
3354         error_setg(errp, "Cannot relinquish control if "
3355                    "there's no successor present");
3356         return NULL;
3357     }
3358 
3359     name = bitmap->name;
3360     bitmap->name = NULL;
3361     successor->name = name;
3362     bitmap->successor = NULL;
3363     bdrv_release_dirty_bitmap(bs, bitmap);
3364 
3365     return successor;
3366 }
3367 
3368 /**
3369  * In cases of failure where we can no longer safely delete the parent,
3370  * we may wish to re-join the parent and child/successor.
3371  * The merged parent will be un-frozen, but not explicitly re-enabled.
3372  */
3373 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3374                                            BdrvDirtyBitmap *parent,
3375                                            Error **errp)
3376 {
3377     BdrvDirtyBitmap *successor = parent->successor;
3378 
3379     if (!successor) {
3380         error_setg(errp, "Cannot reclaim a successor when none is present");
3381         return NULL;
3382     }
3383 
3384     if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3385         error_setg(errp, "Merging of parent and successor bitmap failed");
3386         return NULL;
3387     }
3388     bdrv_release_dirty_bitmap(bs, successor);
3389     parent->successor = NULL;
3390 
3391     return parent;
3392 }
3393 
3394 /**
3395  * Truncates _all_ bitmaps attached to a BDS.
3396  */
3397 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3398 {
3399     BdrvDirtyBitmap *bitmap;
3400     uint64_t size = bdrv_nb_sectors(bs);
3401 
3402     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3403         assert(!bdrv_dirty_bitmap_frozen(bitmap));
3404         hbitmap_truncate(bitmap->bitmap, size);
3405         bitmap->size = size;
3406     }
3407 }
3408 
3409 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3410 {
3411     BdrvDirtyBitmap *bm, *next;
3412     QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3413         if (bm == bitmap) {
3414             assert(!bdrv_dirty_bitmap_frozen(bm));
3415             QLIST_REMOVE(bitmap, list);
3416             hbitmap_free(bitmap->bitmap);
3417             g_free(bitmap->name);
3418             g_free(bitmap);
3419             return;
3420         }
3421     }
3422 }
3423 
3424 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3425 {
3426     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3427     bitmap->disabled = true;
3428 }
3429 
3430 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3431 {
3432     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3433     bitmap->disabled = false;
3434 }
3435 
3436 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3437 {
3438     BdrvDirtyBitmap *bm;
3439     BlockDirtyInfoList *list = NULL;
3440     BlockDirtyInfoList **plist = &list;
3441 
3442     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3443         BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3444         BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3445         info->count = bdrv_get_dirty_count(bm);
3446         info->granularity = bdrv_dirty_bitmap_granularity(bm);
3447         info->has_name = !!bm->name;
3448         info->name = g_strdup(bm->name);
3449         info->status = bdrv_dirty_bitmap_status(bm);
3450         entry->value = info;
3451         *plist = entry;
3452         plist = &entry->next;
3453     }
3454 
3455     return list;
3456 }
3457 
3458 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3459 {
3460     if (bitmap) {
3461         return hbitmap_get(bitmap->bitmap, sector);
3462     } else {
3463         return 0;
3464     }
3465 }
3466 
3467 /**
3468  * Chooses a default granularity based on the existing cluster size,
3469  * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3470  * is no cluster size information available.
3471  */
3472 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3473 {
3474     BlockDriverInfo bdi;
3475     uint32_t granularity;
3476 
3477     if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3478         granularity = MAX(4096, bdi.cluster_size);
3479         granularity = MIN(65536, granularity);
3480     } else {
3481         granularity = 65536;
3482     }
3483 
3484     return granularity;
3485 }
3486 
3487 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3488 {
3489     return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3490 }
3491 
3492 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3493 {
3494     hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3495 }
3496 
3497 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3498                            int64_t cur_sector, int nr_sectors)
3499 {
3500     assert(bdrv_dirty_bitmap_enabled(bitmap));
3501     hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3502 }
3503 
3504 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3505                              int64_t cur_sector, int nr_sectors)
3506 {
3507     assert(bdrv_dirty_bitmap_enabled(bitmap));
3508     hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3509 }
3510 
3511 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3512 {
3513     assert(bdrv_dirty_bitmap_enabled(bitmap));
3514     hbitmap_reset(bitmap->bitmap, 0, bitmap->size);
3515 }
3516 
3517 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3518                     int nr_sectors)
3519 {
3520     BdrvDirtyBitmap *bitmap;
3521     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3522         if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3523             continue;
3524         }
3525         hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3526     }
3527 }
3528 
3529 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
3530                       int nr_sectors)
3531 {
3532     BdrvDirtyBitmap *bitmap;
3533     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3534         if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3535             continue;
3536         }
3537         hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3538     }
3539 }
3540 
3541 /**
3542  * Advance an HBitmapIter to an arbitrary offset.
3543  */
3544 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3545 {
3546     assert(hbi->hb);
3547     hbitmap_iter_init(hbi, hbi->hb, offset);
3548 }
3549 
3550 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3551 {
3552     return hbitmap_count(bitmap->bitmap);
3553 }
3554 
3555 /* Get a reference to bs */
3556 void bdrv_ref(BlockDriverState *bs)
3557 {
3558     bs->refcnt++;
3559 }
3560 
3561 /* Release a previously grabbed reference to bs.
3562  * If after releasing, reference count is zero, the BlockDriverState is
3563  * deleted. */
3564 void bdrv_unref(BlockDriverState *bs)
3565 {
3566     if (!bs) {
3567         return;
3568     }
3569     assert(bs->refcnt > 0);
3570     if (--bs->refcnt == 0) {
3571         bdrv_delete(bs);
3572     }
3573 }
3574 
3575 struct BdrvOpBlocker {
3576     Error *reason;
3577     QLIST_ENTRY(BdrvOpBlocker) list;
3578 };
3579 
3580 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3581 {
3582     BdrvOpBlocker *blocker;
3583     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3584     if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3585         blocker = QLIST_FIRST(&bs->op_blockers[op]);
3586         if (errp) {
3587             error_setg(errp, "Node '%s' is busy: %s",
3588                        bdrv_get_device_or_node_name(bs),
3589                        error_get_pretty(blocker->reason));
3590         }
3591         return true;
3592     }
3593     return false;
3594 }
3595 
3596 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3597 {
3598     BdrvOpBlocker *blocker;
3599     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3600 
3601     blocker = g_new0(BdrvOpBlocker, 1);
3602     blocker->reason = reason;
3603     QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3604 }
3605 
3606 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3607 {
3608     BdrvOpBlocker *blocker, *next;
3609     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3610     QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3611         if (blocker->reason == reason) {
3612             QLIST_REMOVE(blocker, list);
3613             g_free(blocker);
3614         }
3615     }
3616 }
3617 
3618 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3619 {
3620     int i;
3621     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3622         bdrv_op_block(bs, i, reason);
3623     }
3624 }
3625 
3626 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3627 {
3628     int i;
3629     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3630         bdrv_op_unblock(bs, i, reason);
3631     }
3632 }
3633 
3634 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3635 {
3636     int i;
3637 
3638     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3639         if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3640             return false;
3641         }
3642     }
3643     return true;
3644 }
3645 
3646 void bdrv_iostatus_enable(BlockDriverState *bs)
3647 {
3648     bs->iostatus_enabled = true;
3649     bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3650 }
3651 
3652 /* The I/O status is only enabled if the drive explicitly
3653  * enables it _and_ the VM is configured to stop on errors */
3654 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3655 {
3656     return (bs->iostatus_enabled &&
3657            (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
3658             bs->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
3659             bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
3660 }
3661 
3662 void bdrv_iostatus_disable(BlockDriverState *bs)
3663 {
3664     bs->iostatus_enabled = false;
3665 }
3666 
3667 void bdrv_iostatus_reset(BlockDriverState *bs)
3668 {
3669     if (bdrv_iostatus_is_enabled(bs)) {
3670         bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3671         if (bs->job) {
3672             block_job_iostatus_reset(bs->job);
3673         }
3674     }
3675 }
3676 
3677 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3678 {
3679     assert(bdrv_iostatus_is_enabled(bs));
3680     if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3681         bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3682                                          BLOCK_DEVICE_IO_STATUS_FAILED;
3683     }
3684 }
3685 
3686 void bdrv_img_create(const char *filename, const char *fmt,
3687                      const char *base_filename, const char *base_fmt,
3688                      char *options, uint64_t img_size, int flags,
3689                      Error **errp, bool quiet)
3690 {
3691     QemuOptsList *create_opts = NULL;
3692     QemuOpts *opts = NULL;
3693     const char *backing_fmt, *backing_file;
3694     int64_t size;
3695     BlockDriver *drv, *proto_drv;
3696     BlockDriver *backing_drv = NULL;
3697     Error *local_err = NULL;
3698     int ret = 0;
3699 
3700     /* Find driver and parse its options */
3701     drv = bdrv_find_format(fmt);
3702     if (!drv) {
3703         error_setg(errp, "Unknown file format '%s'", fmt);
3704         return;
3705     }
3706 
3707     proto_drv = bdrv_find_protocol(filename, true, errp);
3708     if (!proto_drv) {
3709         return;
3710     }
3711 
3712     if (!drv->create_opts) {
3713         error_setg(errp, "Format driver '%s' does not support image creation",
3714                    drv->format_name);
3715         return;
3716     }
3717 
3718     if (!proto_drv->create_opts) {
3719         error_setg(errp, "Protocol driver '%s' does not support image creation",
3720                    proto_drv->format_name);
3721         return;
3722     }
3723 
3724     create_opts = qemu_opts_append(create_opts, drv->create_opts);
3725     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3726 
3727     /* Create parameter list with default values */
3728     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3729     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3730 
3731     /* Parse -o options */
3732     if (options) {
3733         qemu_opts_do_parse(opts, options, NULL, &local_err);
3734         if (local_err) {
3735             error_report_err(local_err);
3736             local_err = NULL;
3737             error_setg(errp, "Invalid options for file format '%s'", fmt);
3738             goto out;
3739         }
3740     }
3741 
3742     if (base_filename) {
3743         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3744         if (local_err) {
3745             error_setg(errp, "Backing file not supported for file format '%s'",
3746                        fmt);
3747             goto out;
3748         }
3749     }
3750 
3751     if (base_fmt) {
3752         qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3753         if (local_err) {
3754             error_setg(errp, "Backing file format not supported for file "
3755                              "format '%s'", fmt);
3756             goto out;
3757         }
3758     }
3759 
3760     backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3761     if (backing_file) {
3762         if (!strcmp(filename, backing_file)) {
3763             error_setg(errp, "Error: Trying to create an image with the "
3764                              "same filename as the backing file");
3765             goto out;
3766         }
3767     }
3768 
3769     backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3770     if (backing_fmt) {
3771         backing_drv = bdrv_find_format(backing_fmt);
3772         if (!backing_drv) {
3773             error_setg(errp, "Unknown backing file format '%s'",
3774                        backing_fmt);
3775             goto out;
3776         }
3777     }
3778 
3779     // The size for the image must always be specified, with one exception:
3780     // If we are using a backing file, we can obtain the size from there
3781     size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3782     if (size == -1) {
3783         if (backing_file) {
3784             BlockDriverState *bs;
3785             char *full_backing = g_new0(char, PATH_MAX);
3786             int64_t size;
3787             int back_flags;
3788 
3789             bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3790                                                          full_backing, PATH_MAX,
3791                                                          &local_err);
3792             if (local_err) {
3793                 g_free(full_backing);
3794                 goto out;
3795             }
3796 
3797             /* backing files always opened read-only */
3798             back_flags =
3799                 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3800 
3801             bs = NULL;
3802             ret = bdrv_open(&bs, full_backing, NULL, NULL, back_flags,
3803                             backing_drv, &local_err);
3804             g_free(full_backing);
3805             if (ret < 0) {
3806                 goto out;
3807             }
3808             size = bdrv_getlength(bs);
3809             if (size < 0) {
3810                 error_setg_errno(errp, -size, "Could not get size of '%s'",
3811                                  backing_file);
3812                 bdrv_unref(bs);
3813                 goto out;
3814             }
3815 
3816             qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3817 
3818             bdrv_unref(bs);
3819         } else {
3820             error_setg(errp, "Image creation needs a size parameter");
3821             goto out;
3822         }
3823     }
3824 
3825     if (!quiet) {
3826         printf("Formatting '%s', fmt=%s", filename, fmt);
3827         qemu_opts_print(opts, " ");
3828         puts("");
3829     }
3830 
3831     ret = bdrv_create(drv, filename, opts, &local_err);
3832 
3833     if (ret == -EFBIG) {
3834         /* This is generally a better message than whatever the driver would
3835          * deliver (especially because of the cluster_size_hint), since that
3836          * is most probably not much different from "image too large". */
3837         const char *cluster_size_hint = "";
3838         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3839             cluster_size_hint = " (try using a larger cluster size)";
3840         }
3841         error_setg(errp, "The image size is too large for file format '%s'"
3842                    "%s", fmt, cluster_size_hint);
3843         error_free(local_err);
3844         local_err = NULL;
3845     }
3846 
3847 out:
3848     qemu_opts_del(opts);
3849     qemu_opts_free(create_opts);
3850     if (local_err) {
3851         error_propagate(errp, local_err);
3852     }
3853 }
3854 
3855 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3856 {
3857     return bs->aio_context;
3858 }
3859 
3860 void bdrv_detach_aio_context(BlockDriverState *bs)
3861 {
3862     BdrvAioNotifier *baf;
3863 
3864     if (!bs->drv) {
3865         return;
3866     }
3867 
3868     QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3869         baf->detach_aio_context(baf->opaque);
3870     }
3871 
3872     if (bs->io_limits_enabled) {
3873         throttle_timers_detach_aio_context(&bs->throttle_timers);
3874     }
3875     if (bs->drv->bdrv_detach_aio_context) {
3876         bs->drv->bdrv_detach_aio_context(bs);
3877     }
3878     if (bs->file) {
3879         bdrv_detach_aio_context(bs->file);
3880     }
3881     if (bs->backing_hd) {
3882         bdrv_detach_aio_context(bs->backing_hd);
3883     }
3884 
3885     bs->aio_context = NULL;
3886 }
3887 
3888 void bdrv_attach_aio_context(BlockDriverState *bs,
3889                              AioContext *new_context)
3890 {
3891     BdrvAioNotifier *ban;
3892 
3893     if (!bs->drv) {
3894         return;
3895     }
3896 
3897     bs->aio_context = new_context;
3898 
3899     if (bs->backing_hd) {
3900         bdrv_attach_aio_context(bs->backing_hd, new_context);
3901     }
3902     if (bs->file) {
3903         bdrv_attach_aio_context(bs->file, new_context);
3904     }
3905     if (bs->drv->bdrv_attach_aio_context) {
3906         bs->drv->bdrv_attach_aio_context(bs, new_context);
3907     }
3908     if (bs->io_limits_enabled) {
3909         throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3910     }
3911 
3912     QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3913         ban->attached_aio_context(new_context, ban->opaque);
3914     }
3915 }
3916 
3917 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3918 {
3919     bdrv_drain_all(); /* ensure there are no in-flight requests */
3920 
3921     bdrv_detach_aio_context(bs);
3922 
3923     /* This function executes in the old AioContext so acquire the new one in
3924      * case it runs in a different thread.
3925      */
3926     aio_context_acquire(new_context);
3927     bdrv_attach_aio_context(bs, new_context);
3928     aio_context_release(new_context);
3929 }
3930 
3931 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3932         void (*attached_aio_context)(AioContext *new_context, void *opaque),
3933         void (*detach_aio_context)(void *opaque), void *opaque)
3934 {
3935     BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3936     *ban = (BdrvAioNotifier){
3937         .attached_aio_context = attached_aio_context,
3938         .detach_aio_context   = detach_aio_context,
3939         .opaque               = opaque
3940     };
3941 
3942     QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3943 }
3944 
3945 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3946                                       void (*attached_aio_context)(AioContext *,
3947                                                                    void *),
3948                                       void (*detach_aio_context)(void *),
3949                                       void *opaque)
3950 {
3951     BdrvAioNotifier *ban, *ban_next;
3952 
3953     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3954         if (ban->attached_aio_context == attached_aio_context &&
3955             ban->detach_aio_context   == detach_aio_context   &&
3956             ban->opaque               == opaque)
3957         {
3958             QLIST_REMOVE(ban, list);
3959             g_free(ban);
3960 
3961             return;
3962         }
3963     }
3964 
3965     abort();
3966 }
3967 
3968 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3969                        BlockDriverAmendStatusCB *status_cb)
3970 {
3971     if (!bs->drv->bdrv_amend_options) {
3972         return -ENOTSUP;
3973     }
3974     return bs->drv->bdrv_amend_options(bs, opts, status_cb);
3975 }
3976 
3977 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3978  * of block filter and by bdrv_is_first_non_filter.
3979  * It is used to test if the given bs is the candidate or recurse more in the
3980  * node graph.
3981  */
3982 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3983                                       BlockDriverState *candidate)
3984 {
3985     /* return false if basic checks fails */
3986     if (!bs || !bs->drv) {
3987         return false;
3988     }
3989 
3990     /* the code reached a non block filter driver -> check if the bs is
3991      * the same as the candidate. It's the recursion termination condition.
3992      */
3993     if (!bs->drv->is_filter) {
3994         return bs == candidate;
3995     }
3996     /* Down this path the driver is a block filter driver */
3997 
3998     /* If the block filter recursion method is defined use it to recurse down
3999      * the node graph.
4000      */
4001     if (bs->drv->bdrv_recurse_is_first_non_filter) {
4002         return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4003     }
4004 
4005     /* the driver is a block filter but don't allow to recurse -> return false
4006      */
4007     return false;
4008 }
4009 
4010 /* This function checks if the candidate is the first non filter bs down it's
4011  * bs chain. Since we don't have pointers to parents it explore all bs chains
4012  * from the top. Some filters can choose not to pass down the recursion.
4013  */
4014 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4015 {
4016     BlockDriverState *bs;
4017 
4018     /* walk down the bs forest recursively */
4019     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4020         bool perm;
4021 
4022         /* try to recurse in this top level bs */
4023         perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4024 
4025         /* candidate is the first non filter */
4026         if (perm) {
4027             return true;
4028         }
4029     }
4030 
4031     return false;
4032 }
4033 
4034 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
4035 {
4036     BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4037     AioContext *aio_context;
4038 
4039     if (!to_replace_bs) {
4040         error_setg(errp, "Node name '%s' not found", node_name);
4041         return NULL;
4042     }
4043 
4044     aio_context = bdrv_get_aio_context(to_replace_bs);
4045     aio_context_acquire(aio_context);
4046 
4047     if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4048         to_replace_bs = NULL;
4049         goto out;
4050     }
4051 
4052     /* We don't want arbitrary node of the BDS chain to be replaced only the top
4053      * most non filter in order to prevent data corruption.
4054      * Another benefit is that this tests exclude backing files which are
4055      * blocked by the backing blockers.
4056      */
4057     if (!bdrv_is_first_non_filter(to_replace_bs)) {
4058         error_setg(errp, "Only top most non filter can be replaced");
4059         to_replace_bs = NULL;
4060         goto out;
4061     }
4062 
4063 out:
4064     aio_context_release(aio_context);
4065     return to_replace_bs;
4066 }
4067 
4068 static bool append_open_options(QDict *d, BlockDriverState *bs)
4069 {
4070     const QDictEntry *entry;
4071     bool found_any = false;
4072 
4073     for (entry = qdict_first(bs->options); entry;
4074          entry = qdict_next(bs->options, entry))
4075     {
4076         /* Only take options for this level and exclude all non-driver-specific
4077          * options */
4078         if (!strchr(qdict_entry_key(entry), '.') &&
4079             strcmp(qdict_entry_key(entry), "node-name"))
4080         {
4081             qobject_incref(qdict_entry_value(entry));
4082             qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4083             found_any = true;
4084         }
4085     }
4086 
4087     return found_any;
4088 }
4089 
4090 /* Updates the following BDS fields:
4091  *  - exact_filename: A filename which may be used for opening a block device
4092  *                    which (mostly) equals the given BDS (even without any
4093  *                    other options; so reading and writing must return the same
4094  *                    results, but caching etc. may be different)
4095  *  - full_open_options: Options which, when given when opening a block device
4096  *                       (without a filename), result in a BDS (mostly)
4097  *                       equalling the given one
4098  *  - filename: If exact_filename is set, it is copied here. Otherwise,
4099  *              full_open_options is converted to a JSON object, prefixed with
4100  *              "json:" (for use through the JSON pseudo protocol) and put here.
4101  */
4102 void bdrv_refresh_filename(BlockDriverState *bs)
4103 {
4104     BlockDriver *drv = bs->drv;
4105     QDict *opts;
4106 
4107     if (!drv) {
4108         return;
4109     }
4110 
4111     /* This BDS's file name will most probably depend on its file's name, so
4112      * refresh that first */
4113     if (bs->file) {
4114         bdrv_refresh_filename(bs->file);
4115     }
4116 
4117     if (drv->bdrv_refresh_filename) {
4118         /* Obsolete information is of no use here, so drop the old file name
4119          * information before refreshing it */
4120         bs->exact_filename[0] = '\0';
4121         if (bs->full_open_options) {
4122             QDECREF(bs->full_open_options);
4123             bs->full_open_options = NULL;
4124         }
4125 
4126         drv->bdrv_refresh_filename(bs);
4127     } else if (bs->file) {
4128         /* Try to reconstruct valid information from the underlying file */
4129         bool has_open_options;
4130 
4131         bs->exact_filename[0] = '\0';
4132         if (bs->full_open_options) {
4133             QDECREF(bs->full_open_options);
4134             bs->full_open_options = NULL;
4135         }
4136 
4137         opts = qdict_new();
4138         has_open_options = append_open_options(opts, bs);
4139 
4140         /* If no specific options have been given for this BDS, the filename of
4141          * the underlying file should suffice for this one as well */
4142         if (bs->file->exact_filename[0] && !has_open_options) {
4143             strcpy(bs->exact_filename, bs->file->exact_filename);
4144         }
4145         /* Reconstructing the full options QDict is simple for most format block
4146          * drivers, as long as the full options are known for the underlying
4147          * file BDS. The full options QDict of that file BDS should somehow
4148          * contain a representation of the filename, therefore the following
4149          * suffices without querying the (exact_)filename of this BDS. */
4150         if (bs->file->full_open_options) {
4151             qdict_put_obj(opts, "driver",
4152                           QOBJECT(qstring_from_str(drv->format_name)));
4153             QINCREF(bs->file->full_open_options);
4154             qdict_put_obj(opts, "file", QOBJECT(bs->file->full_open_options));
4155 
4156             bs->full_open_options = opts;
4157         } else {
4158             QDECREF(opts);
4159         }
4160     } else if (!bs->full_open_options && qdict_size(bs->options)) {
4161         /* There is no underlying file BDS (at least referenced by BDS.file),
4162          * so the full options QDict should be equal to the options given
4163          * specifically for this block device when it was opened (plus the
4164          * driver specification).
4165          * Because those options don't change, there is no need to update
4166          * full_open_options when it's already set. */
4167 
4168         opts = qdict_new();
4169         append_open_options(opts, bs);
4170         qdict_put_obj(opts, "driver",
4171                       QOBJECT(qstring_from_str(drv->format_name)));
4172 
4173         if (bs->exact_filename[0]) {
4174             /* This may not work for all block protocol drivers (some may
4175              * require this filename to be parsed), but we have to find some
4176              * default solution here, so just include it. If some block driver
4177              * does not support pure options without any filename at all or
4178              * needs some special format of the options QDict, it needs to
4179              * implement the driver-specific bdrv_refresh_filename() function.
4180              */
4181             qdict_put_obj(opts, "filename",
4182                           QOBJECT(qstring_from_str(bs->exact_filename)));
4183         }
4184 
4185         bs->full_open_options = opts;
4186     }
4187 
4188     if (bs->exact_filename[0]) {
4189         pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4190     } else if (bs->full_open_options) {
4191         QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4192         snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4193                  qstring_get_str(json));
4194         QDECREF(json);
4195     }
4196 }
4197 
4198 /* This accessor function purpose is to allow the device models to access the
4199  * BlockAcctStats structure embedded inside a BlockDriverState without being
4200  * aware of the BlockDriverState structure layout.
4201  * It will go away when the BlockAcctStats structure will be moved inside
4202  * the device models.
4203  */
4204 BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)
4205 {
4206     return &bs->stats;
4207 }
4208