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