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