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