block: Catch backing files assigned to non-COW drivers
[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 static QDict *parse_json_filename(const char *filename, Error **errp)
1009 {
1010 QObject *options_obj;
1011 QDict *options;
1012 int ret;
1013
1014 ret = strstart(filename, "json:", &filename);
1015 assert(ret);
1016
1017 options_obj = qobject_from_json(filename);
1018 if (!options_obj) {
1019 error_setg(errp, "Could not parse the JSON options");
1020 return NULL;
1021 }
1022
1023 if (qobject_type(options_obj) != QTYPE_QDICT) {
1024 qobject_decref(options_obj);
1025 error_setg(errp, "Invalid JSON object given");
1026 return NULL;
1027 }
1028
1029 options = qobject_to_qdict(options_obj);
1030 qdict_flatten(options);
1031
1032 return options;
1033 }
1034
1035 /*
1036 * Fills in default options for opening images and converts the legacy
1037 * filename/flags pair to option QDict entries.
1038 */
1039 static int bdrv_fill_options(QDict **options, const char **pfilename, int flags,
1040 BlockDriver *drv, Error **errp)
1041 {
1042 const char *filename = *pfilename;
1043 const char *drvname;
1044 bool protocol = flags & BDRV_O_PROTOCOL;
1045 bool parse_filename = false;
1046 Error *local_err = NULL;
1047
1048 /* Parse json: pseudo-protocol */
1049 if (filename && g_str_has_prefix(filename, "json:")) {
1050 QDict *json_options = parse_json_filename(filename, &local_err);
1051 if (local_err) {
1052 error_propagate(errp, local_err);
1053 return -EINVAL;
1054 }
1055
1056 /* Options given in the filename have lower priority than options
1057 * specified directly */
1058 qdict_join(*options, json_options, false);
1059 QDECREF(json_options);
1060 *pfilename = filename = NULL;
1061 }
1062
1063 /* Fetch the file name from the options QDict if necessary */
1064 if (protocol && filename) {
1065 if (!qdict_haskey(*options, "filename")) {
1066 qdict_put(*options, "filename", qstring_from_str(filename));
1067 parse_filename = true;
1068 } else {
1069 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1070 "the same time");
1071 return -EINVAL;
1072 }
1073 }
1074
1075 /* Find the right block driver */
1076 filename = qdict_get_try_str(*options, "filename");
1077 drvname = qdict_get_try_str(*options, "driver");
1078
1079 if (drv) {
1080 if (drvname) {
1081 error_setg(errp, "Driver specified twice");
1082 return -EINVAL;
1083 }
1084 drvname = drv->format_name;
1085 qdict_put(*options, "driver", qstring_from_str(drvname));
1086 } else {
1087 if (!drvname && protocol) {
1088 if (filename) {
1089 drv = bdrv_find_protocol(filename, parse_filename);
1090 if (!drv) {
1091 error_setg(errp, "Unknown protocol");
1092 return -EINVAL;
1093 }
1094
1095 drvname = drv->format_name;
1096 qdict_put(*options, "driver", qstring_from_str(drvname));
1097 } else {
1098 error_setg(errp, "Must specify either driver or file");
1099 return -EINVAL;
1100 }
1101 } else if (drvname) {
1102 drv = bdrv_find_format(drvname);
1103 if (!drv) {
1104 error_setg(errp, "Unknown driver '%s'", drvname);
1105 return -ENOENT;
1106 }
1107 }
1108 }
1109
1110 assert(drv || !protocol);
1111
1112 /* Driver-specific filename parsing */
1113 if (drv && drv->bdrv_parse_filename && parse_filename) {
1114 drv->bdrv_parse_filename(filename, *options, &local_err);
1115 if (local_err) {
1116 error_propagate(errp, local_err);
1117 return -EINVAL;
1118 }
1119
1120 if (!drv->bdrv_needs_filename) {
1121 qdict_del(*options, "filename");
1122 }
1123 }
1124
1125 return 0;
1126 }
1127
1128 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1129 {
1130
1131 if (bs->backing_hd) {
1132 assert(bs->backing_blocker);
1133 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1134 } else if (backing_hd) {
1135 error_setg(&bs->backing_blocker,
1136 "device is used as backing hd of '%s'",
1137 bs->device_name);
1138 }
1139
1140 bs->backing_hd = backing_hd;
1141 if (!backing_hd) {
1142 error_free(bs->backing_blocker);
1143 bs->backing_blocker = NULL;
1144 goto out;
1145 }
1146 bs->open_flags &= ~BDRV_O_NO_BACKING;
1147 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1148 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1149 backing_hd->drv ? backing_hd->drv->format_name : "");
1150
1151 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1152 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1153 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
1154 bs->backing_blocker);
1155 out:
1156 bdrv_refresh_limits(bs);
1157 }
1158
1159 /*
1160 * Opens the backing file for a BlockDriverState if not yet open
1161 *
1162 * options is a QDict of options to pass to the block drivers, or NULL for an
1163 * empty set of options. The reference to the QDict is transferred to this
1164 * function (even on failure), so if the caller intends to reuse the dictionary,
1165 * it needs to use QINCREF() before calling bdrv_file_open.
1166 */
1167 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1168 {
1169 char *backing_filename = g_malloc0(PATH_MAX);
1170 int ret = 0;
1171 BlockDriver *back_drv = NULL;
1172 BlockDriverState *backing_hd;
1173 Error *local_err = NULL;
1174
1175 if (bs->backing_hd != NULL) {
1176 QDECREF(options);
1177 goto free_exit;
1178 }
1179
1180 /* NULL means an empty set of options */
1181 if (options == NULL) {
1182 options = qdict_new();
1183 }
1184
1185 bs->open_flags &= ~BDRV_O_NO_BACKING;
1186 if (qdict_haskey(options, "file.filename")) {
1187 backing_filename[0] = '\0';
1188 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1189 QDECREF(options);
1190 goto free_exit;
1191 } else {
1192 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
1193 }
1194
1195 if (!bs->drv || !bs->drv->supports_backing) {
1196 ret = -EINVAL;
1197 error_setg(errp, "Driver doesn't support backing files");
1198 QDECREF(options);
1199 goto free_exit;
1200 }
1201
1202 backing_hd = bdrv_new("", errp);
1203
1204 if (bs->backing_format[0] != '\0') {
1205 back_drv = bdrv_find_format(bs->backing_format);
1206 }
1207
1208 assert(bs->backing_hd == NULL);
1209 ret = bdrv_open(&backing_hd,
1210 *backing_filename ? backing_filename : NULL, NULL, options,
1211 bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
1212 if (ret < 0) {
1213 bdrv_unref(backing_hd);
1214 backing_hd = NULL;
1215 bs->open_flags |= BDRV_O_NO_BACKING;
1216 error_setg(errp, "Could not open backing file: %s",
1217 error_get_pretty(local_err));
1218 error_free(local_err);
1219 goto free_exit;
1220 }
1221 bdrv_set_backing_hd(bs, backing_hd);
1222
1223 free_exit:
1224 g_free(backing_filename);
1225 return ret;
1226 }
1227
1228 /*
1229 * Opens a disk image whose options are given as BlockdevRef in another block
1230 * device's options.
1231 *
1232 * If allow_none is true, no image will be opened if filename is false and no
1233 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1234 *
1235 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1236 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1237 * itself, all options starting with "${bdref_key}." are considered part of the
1238 * BlockdevRef.
1239 *
1240 * The BlockdevRef will be removed from the options QDict.
1241 *
1242 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1243 */
1244 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1245 QDict *options, const char *bdref_key, int flags,
1246 bool allow_none, Error **errp)
1247 {
1248 QDict *image_options;
1249 int ret;
1250 char *bdref_key_dot;
1251 const char *reference;
1252
1253 assert(pbs);
1254 assert(*pbs == NULL);
1255
1256 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1257 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1258 g_free(bdref_key_dot);
1259
1260 reference = qdict_get_try_str(options, bdref_key);
1261 if (!filename && !reference && !qdict_size(image_options)) {
1262 if (allow_none) {
1263 ret = 0;
1264 } else {
1265 error_setg(errp, "A block device must be specified for \"%s\"",
1266 bdref_key);
1267 ret = -EINVAL;
1268 }
1269 QDECREF(image_options);
1270 goto done;
1271 }
1272
1273 ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
1274
1275 done:
1276 qdict_del(options, bdref_key);
1277 return ret;
1278 }
1279
1280 void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1281 {
1282 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1283 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1284 int64_t total_size;
1285 BlockDriver *bdrv_qcow2;
1286 QemuOpts *opts = NULL;
1287 QDict *snapshot_options;
1288 BlockDriverState *bs_snapshot;
1289 Error *local_err;
1290 int ret;
1291
1292 /* if snapshot, we create a temporary backing file and open it
1293 instead of opening 'filename' directly */
1294
1295 /* Get the required size from the image */
1296 total_size = bdrv_getlength(bs);
1297 if (total_size < 0) {
1298 error_setg_errno(errp, -total_size, "Could not get image size");
1299 goto out;
1300 }
1301 total_size &= BDRV_SECTOR_MASK;
1302
1303 /* Create the temporary image */
1304 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1305 if (ret < 0) {
1306 error_setg_errno(errp, -ret, "Could not get temporary filename");
1307 goto out;
1308 }
1309
1310 bdrv_qcow2 = bdrv_find_format("qcow2");
1311 opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,
1312 &error_abort);
1313 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
1314 ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);
1315 qemu_opts_del(opts);
1316 if (ret < 0) {
1317 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1318 "'%s': %s", tmp_filename,
1319 error_get_pretty(local_err));
1320 error_free(local_err);
1321 goto out;
1322 }
1323
1324 /* Prepare a new options QDict for the temporary file */
1325 snapshot_options = qdict_new();
1326 qdict_put(snapshot_options, "file.driver",
1327 qstring_from_str("file"));
1328 qdict_put(snapshot_options, "file.filename",
1329 qstring_from_str(tmp_filename));
1330
1331 bs_snapshot = bdrv_new("", &error_abort);
1332
1333 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1334 flags, bdrv_qcow2, &local_err);
1335 if (ret < 0) {
1336 error_propagate(errp, local_err);
1337 goto out;
1338 }
1339
1340 bdrv_append(bs_snapshot, bs);
1341
1342 out:
1343 g_free(tmp_filename);
1344 }
1345
1346 /*
1347 * Opens a disk image (raw, qcow2, vmdk, ...)
1348 *
1349 * options is a QDict of options to pass to the block drivers, or NULL for an
1350 * empty set of options. The reference to the QDict belongs to the block layer
1351 * after the call (even on failure), so if the caller intends to reuse the
1352 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1353 *
1354 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1355 * If it is not NULL, the referenced BDS will be reused.
1356 *
1357 * The reference parameter may be used to specify an existing block device which
1358 * should be opened. If specified, neither options nor a filename may be given,
1359 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1360 */
1361 int bdrv_open(BlockDriverState **pbs, const char *filename,
1362 const char *reference, QDict *options, int flags,
1363 BlockDriver *drv, Error **errp)
1364 {
1365 int ret;
1366 BlockDriverState *file = NULL, *bs;
1367 const char *drvname;
1368 Error *local_err = NULL;
1369 int snapshot_flags = 0;
1370
1371 assert(pbs);
1372
1373 if (reference) {
1374 bool options_non_empty = options ? qdict_size(options) : false;
1375 QDECREF(options);
1376
1377 if (*pbs) {
1378 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1379 "another block device");
1380 return -EINVAL;
1381 }
1382
1383 if (filename || options_non_empty) {
1384 error_setg(errp, "Cannot reference an existing block device with "
1385 "additional options or a new filename");
1386 return -EINVAL;
1387 }
1388
1389 bs = bdrv_lookup_bs(reference, reference, errp);
1390 if (!bs) {
1391 return -ENODEV;
1392 }
1393 bdrv_ref(bs);
1394 *pbs = bs;
1395 return 0;
1396 }
1397
1398 if (*pbs) {
1399 bs = *pbs;
1400 } else {
1401 bs = bdrv_new("", &error_abort);
1402 }
1403
1404 /* NULL means an empty set of options */
1405 if (options == NULL) {
1406 options = qdict_new();
1407 }
1408
1409 ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err);
1410 if (local_err) {
1411 goto fail;
1412 }
1413
1414 /* Find the right image format driver */
1415 drv = NULL;
1416 drvname = qdict_get_try_str(options, "driver");
1417 if (drvname) {
1418 drv = bdrv_find_format(drvname);
1419 qdict_del(options, "driver");
1420 if (!drv) {
1421 error_setg(errp, "Unknown driver: '%s'", drvname);
1422 ret = -EINVAL;
1423 goto fail;
1424 }
1425 }
1426
1427 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1428 if (drv && !drv->bdrv_file_open) {
1429 /* If the user explicitly wants a format driver here, we'll need to add
1430 * another layer for the protocol in bs->file */
1431 flags &= ~BDRV_O_PROTOCOL;
1432 }
1433
1434 bs->options = options;
1435 options = qdict_clone_shallow(options);
1436
1437 /* Open image file without format layer */
1438 if ((flags & BDRV_O_PROTOCOL) == 0) {
1439 if (flags & BDRV_O_RDWR) {
1440 flags |= BDRV_O_ALLOW_RDWR;
1441 }
1442 if (flags & BDRV_O_SNAPSHOT) {
1443 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1444 flags = bdrv_backing_flags(flags);
1445 }
1446
1447 assert(file == NULL);
1448 ret = bdrv_open_image(&file, filename, options, "file",
1449 bdrv_inherited_flags(flags),
1450 true, &local_err);
1451 if (ret < 0) {
1452 goto fail;
1453 }
1454 }
1455
1456 /* Image format probing */
1457 if (!drv && file) {
1458 ret = find_image_format(file, filename, &drv, &local_err);
1459 if (ret < 0) {
1460 goto fail;
1461 }
1462 } else if (!drv) {
1463 error_setg(errp, "Must specify either driver or file");
1464 ret = -EINVAL;
1465 goto fail;
1466 }
1467
1468 /* Open the image */
1469 if (flags & BDRV_O_PROTOCOL) {
1470 ret = bdrv_open_common(bs, NULL, options,
1471 flags & ~BDRV_O_PROTOCOL, drv, &local_err);
1472 if (!ret) {
1473 bs->growable = 1;
1474 goto done;
1475 } else if (bs->drv) {
1476 goto close_and_fail;
1477 } else {
1478 goto fail;
1479 }
1480 }
1481
1482 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1483 if (ret < 0) {
1484 goto fail;
1485 }
1486
1487 if (file && (bs->file != file)) {
1488 bdrv_unref(file);
1489 file = NULL;
1490 }
1491
1492 /* If there is a backing file, use it */
1493 if ((flags & BDRV_O_NO_BACKING) == 0) {
1494 QDict *backing_options;
1495
1496 qdict_extract_subqdict(options, &backing_options, "backing.");
1497 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1498 if (ret < 0) {
1499 goto close_and_fail;
1500 }
1501 }
1502
1503 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1504 * temporary snapshot afterwards. */
1505 if (snapshot_flags) {
1506 bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1507 if (local_err) {
1508 error_propagate(errp, local_err);
1509 goto close_and_fail;
1510 }
1511 }
1512
1513
1514 done:
1515 /* Check if any unknown options were used */
1516 if (options && (qdict_size(options) != 0)) {
1517 const QDictEntry *entry = qdict_first(options);
1518 if (flags & BDRV_O_PROTOCOL) {
1519 error_setg(errp, "Block protocol '%s' doesn't support the option "
1520 "'%s'", drv->format_name, entry->key);
1521 } else {
1522 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1523 "support the option '%s'", drv->format_name,
1524 bs->device_name, entry->key);
1525 }
1526
1527 ret = -EINVAL;
1528 goto close_and_fail;
1529 }
1530
1531 if (!bdrv_key_required(bs)) {
1532 bdrv_dev_change_media_cb(bs, true);
1533 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1534 && !runstate_check(RUN_STATE_INMIGRATE)
1535 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1536 error_setg(errp,
1537 "Guest must be stopped for opening of encrypted image");
1538 ret = -EBUSY;
1539 goto close_and_fail;
1540 }
1541
1542 QDECREF(options);
1543 *pbs = bs;
1544 return 0;
1545
1546 fail:
1547 if (file != NULL) {
1548 bdrv_unref(file);
1549 }
1550 QDECREF(bs->options);
1551 QDECREF(options);
1552 bs->options = NULL;
1553 if (!*pbs) {
1554 /* If *pbs is NULL, a new BDS has been created in this function and
1555 needs to be freed now. Otherwise, it does not need to be closed,
1556 since it has not really been opened yet. */
1557 bdrv_unref(bs);
1558 }
1559 if (local_err) {
1560 error_propagate(errp, local_err);
1561 }
1562 return ret;
1563
1564 close_and_fail:
1565 /* See fail path, but now the BDS has to be always closed */
1566 if (*pbs) {
1567 bdrv_close(bs);
1568 } else {
1569 bdrv_unref(bs);
1570 }
1571 QDECREF(options);
1572 if (local_err) {
1573 error_propagate(errp, local_err);
1574 }
1575 return ret;
1576 }
1577
1578 typedef struct BlockReopenQueueEntry {
1579 bool prepared;
1580 BDRVReopenState state;
1581 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1582 } BlockReopenQueueEntry;
1583
1584 /*
1585 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1586 * reopen of multiple devices.
1587 *
1588 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1589 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1590 * be created and initialized. This newly created BlockReopenQueue should be
1591 * passed back in for subsequent calls that are intended to be of the same
1592 * atomic 'set'.
1593 *
1594 * bs is the BlockDriverState to add to the reopen queue.
1595 *
1596 * flags contains the open flags for the associated bs
1597 *
1598 * returns a pointer to bs_queue, which is either the newly allocated
1599 * bs_queue, or the existing bs_queue being used.
1600 *
1601 */
1602 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1603 BlockDriverState *bs, int flags)
1604 {
1605 assert(bs != NULL);
1606
1607 BlockReopenQueueEntry *bs_entry;
1608 if (bs_queue == NULL) {
1609 bs_queue = g_new0(BlockReopenQueue, 1);
1610 QSIMPLEQ_INIT(bs_queue);
1611 }
1612
1613 /* bdrv_open() masks this flag out */
1614 flags &= ~BDRV_O_PROTOCOL;
1615
1616 if (bs->file) {
1617 bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
1618 }
1619
1620 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1621 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1622
1623 bs_entry->state.bs = bs;
1624 bs_entry->state.flags = flags;
1625
1626 return bs_queue;
1627 }
1628
1629 /*
1630 * Reopen multiple BlockDriverStates atomically & transactionally.
1631 *
1632 * The queue passed in (bs_queue) must have been built up previous
1633 * via bdrv_reopen_queue().
1634 *
1635 * Reopens all BDS specified in the queue, with the appropriate
1636 * flags. All devices are prepared for reopen, and failure of any
1637 * device will cause all device changes to be abandonded, and intermediate
1638 * data cleaned up.
1639 *
1640 * If all devices prepare successfully, then the changes are committed
1641 * to all devices.
1642 *
1643 */
1644 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1645 {
1646 int ret = -1;
1647 BlockReopenQueueEntry *bs_entry, *next;
1648 Error *local_err = NULL;
1649
1650 assert(bs_queue != NULL);
1651
1652 bdrv_drain_all();
1653
1654 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1655 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1656 error_propagate(errp, local_err);
1657 goto cleanup;
1658 }
1659 bs_entry->prepared = true;
1660 }
1661
1662 /* If we reach this point, we have success and just need to apply the
1663 * changes
1664 */
1665 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1666 bdrv_reopen_commit(&bs_entry->state);
1667 }
1668
1669 ret = 0;
1670
1671 cleanup:
1672 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1673 if (ret && bs_entry->prepared) {
1674 bdrv_reopen_abort(&bs_entry->state);
1675 }
1676 g_free(bs_entry);
1677 }
1678 g_free(bs_queue);
1679 return ret;
1680 }
1681
1682
1683 /* Reopen a single BlockDriverState with the specified flags. */
1684 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1685 {
1686 int ret = -1;
1687 Error *local_err = NULL;
1688 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1689
1690 ret = bdrv_reopen_multiple(queue, &local_err);
1691 if (local_err != NULL) {
1692 error_propagate(errp, local_err);
1693 }
1694 return ret;
1695 }
1696
1697
1698 /*
1699 * Prepares a BlockDriverState for reopen. All changes are staged in the
1700 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1701 * the block driver layer .bdrv_reopen_prepare()
1702 *
1703 * bs is the BlockDriverState to reopen
1704 * flags are the new open flags
1705 * queue is the reopen queue
1706 *
1707 * Returns 0 on success, non-zero on error. On error errp will be set
1708 * as well.
1709 *
1710 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1711 * It is the responsibility of the caller to then call the abort() or
1712 * commit() for any other BDS that have been left in a prepare() state
1713 *
1714 */
1715 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1716 Error **errp)
1717 {
1718 int ret = -1;
1719 Error *local_err = NULL;
1720 BlockDriver *drv;
1721
1722 assert(reopen_state != NULL);
1723 assert(reopen_state->bs->drv != NULL);
1724 drv = reopen_state->bs->drv;
1725
1726 /* if we are to stay read-only, do not allow permission change
1727 * to r/w */
1728 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1729 reopen_state->flags & BDRV_O_RDWR) {
1730 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1731 reopen_state->bs->device_name);
1732 goto error;
1733 }
1734
1735
1736 ret = bdrv_flush(reopen_state->bs);
1737 if (ret) {
1738 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1739 strerror(-ret));
1740 goto error;
1741 }
1742
1743 if (drv->bdrv_reopen_prepare) {
1744 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1745 if (ret) {
1746 if (local_err != NULL) {
1747 error_propagate(errp, local_err);
1748 } else {
1749 error_setg(errp, "failed while preparing to reopen image '%s'",
1750 reopen_state->bs->filename);
1751 }
1752 goto error;
1753 }
1754 } else {
1755 /* It is currently mandatory to have a bdrv_reopen_prepare()
1756 * handler for each supported drv. */
1757 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1758 drv->format_name, reopen_state->bs->device_name,
1759 "reopening of file");
1760 ret = -1;
1761 goto error;
1762 }
1763
1764 ret = 0;
1765
1766 error:
1767 return ret;
1768 }
1769
1770 /*
1771 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1772 * makes them final by swapping the staging BlockDriverState contents into
1773 * the active BlockDriverState contents.
1774 */
1775 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1776 {
1777 BlockDriver *drv;
1778
1779 assert(reopen_state != NULL);
1780 drv = reopen_state->bs->drv;
1781 assert(drv != NULL);
1782
1783 /* If there are any driver level actions to take */
1784 if (drv->bdrv_reopen_commit) {
1785 drv->bdrv_reopen_commit(reopen_state);
1786 }
1787
1788 /* set BDS specific flags now */
1789 reopen_state->bs->open_flags = reopen_state->flags;
1790 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1791 BDRV_O_CACHE_WB);
1792 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1793
1794 bdrv_refresh_limits(reopen_state->bs);
1795 }
1796
1797 /*
1798 * Abort the reopen, and delete and free the staged changes in
1799 * reopen_state
1800 */
1801 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1802 {
1803 BlockDriver *drv;
1804
1805 assert(reopen_state != NULL);
1806 drv = reopen_state->bs->drv;
1807 assert(drv != NULL);
1808
1809 if (drv->bdrv_reopen_abort) {
1810 drv->bdrv_reopen_abort(reopen_state);
1811 }
1812 }
1813
1814
1815 void bdrv_close(BlockDriverState *bs)
1816 {
1817 if (bs->job) {
1818 block_job_cancel_sync(bs->job);
1819 }
1820 bdrv_drain_all(); /* complete I/O */
1821 bdrv_flush(bs);
1822 bdrv_drain_all(); /* in case flush left pending I/O */
1823 notifier_list_notify(&bs->close_notifiers, bs);
1824
1825 if (bs->drv) {
1826 if (bs->backing_hd) {
1827 BlockDriverState *backing_hd = bs->backing_hd;
1828 bdrv_set_backing_hd(bs, NULL);
1829 bdrv_unref(backing_hd);
1830 }
1831 bs->drv->bdrv_close(bs);
1832 g_free(bs->opaque);
1833 bs->opaque = NULL;
1834 bs->drv = NULL;
1835 bs->copy_on_read = 0;
1836 bs->backing_file[0] = '\0';
1837 bs->backing_format[0] = '\0';
1838 bs->total_sectors = 0;
1839 bs->encrypted = 0;
1840 bs->valid_key = 0;
1841 bs->sg = 0;
1842 bs->growable = 0;
1843 bs->zero_beyond_eof = false;
1844 QDECREF(bs->options);
1845 bs->options = NULL;
1846
1847 if (bs->file != NULL) {
1848 bdrv_unref(bs->file);
1849 bs->file = NULL;
1850 }
1851 }
1852
1853 bdrv_dev_change_media_cb(bs, false);
1854
1855 /*throttling disk I/O limits*/
1856 if (bs->io_limits_enabled) {
1857 bdrv_io_limits_disable(bs);
1858 }
1859 }
1860
1861 void bdrv_close_all(void)
1862 {
1863 BlockDriverState *bs;
1864
1865 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1866 AioContext *aio_context = bdrv_get_aio_context(bs);
1867
1868 aio_context_acquire(aio_context);
1869 bdrv_close(bs);
1870 aio_context_release(aio_context);
1871 }
1872 }
1873
1874 /* Check if any requests are in-flight (including throttled requests) */
1875 static bool bdrv_requests_pending(BlockDriverState *bs)
1876 {
1877 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1878 return true;
1879 }
1880 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1881 return true;
1882 }
1883 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
1884 return true;
1885 }
1886 if (bs->file && bdrv_requests_pending(bs->file)) {
1887 return true;
1888 }
1889 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1890 return true;
1891 }
1892 return false;
1893 }
1894
1895 /*
1896 * Wait for pending requests to complete across all BlockDriverStates
1897 *
1898 * This function does not flush data to disk, use bdrv_flush_all() for that
1899 * after calling this function.
1900 *
1901 * Note that completion of an asynchronous I/O operation can trigger any
1902 * number of other I/O operations on other devices---for example a coroutine
1903 * can be arbitrarily complex and a constant flow of I/O can come until the
1904 * coroutine is complete. Because of this, it is not possible to have a
1905 * function to drain a single device's I/O queue.
1906 */
1907 void bdrv_drain_all(void)
1908 {
1909 /* Always run first iteration so any pending completion BHs run */
1910 bool busy = true;
1911 BlockDriverState *bs;
1912
1913 while (busy) {
1914 busy = false;
1915
1916 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1917 AioContext *aio_context = bdrv_get_aio_context(bs);
1918 bool bs_busy;
1919
1920 aio_context_acquire(aio_context);
1921 bdrv_start_throttled_reqs(bs);
1922 bs_busy = bdrv_requests_pending(bs);
1923 bs_busy |= aio_poll(aio_context, bs_busy);
1924 aio_context_release(aio_context);
1925
1926 busy |= bs_busy;
1927 }
1928 }
1929 }
1930
1931 /* make a BlockDriverState anonymous by removing from bdrv_state and
1932 * graph_bdrv_state list.
1933 Also, NULL terminate the device_name to prevent double remove */
1934 void bdrv_make_anon(BlockDriverState *bs)
1935 {
1936 if (bs->device_name[0] != '\0') {
1937 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1938 }
1939 bs->device_name[0] = '\0';
1940 if (bs->node_name[0] != '\0') {
1941 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1942 }
1943 bs->node_name[0] = '\0';
1944 }
1945
1946 static void bdrv_rebind(BlockDriverState *bs)
1947 {
1948 if (bs->drv && bs->drv->bdrv_rebind) {
1949 bs->drv->bdrv_rebind(bs);
1950 }
1951 }
1952
1953 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1954 BlockDriverState *bs_src)
1955 {
1956 /* move some fields that need to stay attached to the device */
1957
1958 /* dev info */
1959 bs_dest->dev_ops = bs_src->dev_ops;
1960 bs_dest->dev_opaque = bs_src->dev_opaque;
1961 bs_dest->dev = bs_src->dev;
1962 bs_dest->guest_block_size = bs_src->guest_block_size;
1963 bs_dest->copy_on_read = bs_src->copy_on_read;
1964
1965 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1966
1967 /* i/o throttled req */
1968 memcpy(&bs_dest->throttle_state,
1969 &bs_src->throttle_state,
1970 sizeof(ThrottleState));
1971 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1972 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
1973 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1974
1975 /* r/w error */
1976 bs_dest->on_read_error = bs_src->on_read_error;
1977 bs_dest->on_write_error = bs_src->on_write_error;
1978
1979 /* i/o status */
1980 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1981 bs_dest->iostatus = bs_src->iostatus;
1982
1983 /* dirty bitmap */
1984 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
1985
1986 /* reference count */
1987 bs_dest->refcnt = bs_src->refcnt;
1988
1989 /* job */
1990 bs_dest->job = bs_src->job;
1991
1992 /* keep the same entry in bdrv_states */
1993 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1994 bs_src->device_name);
1995 bs_dest->device_list = bs_src->device_list;
1996 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
1997 sizeof(bs_dest->op_blockers));
1998 }
1999
2000 /*
2001 * Swap bs contents for two image chains while they are live,
2002 * while keeping required fields on the BlockDriverState that is
2003 * actually attached to a device.
2004 *
2005 * This will modify the BlockDriverState fields, and swap contents
2006 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2007 *
2008 * bs_new is required to be anonymous.
2009 *
2010 * This function does not create any image files.
2011 */
2012 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2013 {
2014 BlockDriverState tmp;
2015
2016 /* The code needs to swap the node_name but simply swapping node_list won't
2017 * work so first remove the nodes from the graph list, do the swap then
2018 * insert them back if needed.
2019 */
2020 if (bs_new->node_name[0] != '\0') {
2021 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2022 }
2023 if (bs_old->node_name[0] != '\0') {
2024 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2025 }
2026
2027 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2028 assert(bs_new->device_name[0] == '\0');
2029 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2030 assert(bs_new->job == NULL);
2031 assert(bs_new->dev == NULL);
2032 assert(bs_new->io_limits_enabled == false);
2033 assert(!throttle_have_timer(&bs_new->throttle_state));
2034
2035 tmp = *bs_new;
2036 *bs_new = *bs_old;
2037 *bs_old = tmp;
2038
2039 /* there are some fields that should not be swapped, move them back */
2040 bdrv_move_feature_fields(&tmp, bs_old);
2041 bdrv_move_feature_fields(bs_old, bs_new);
2042 bdrv_move_feature_fields(bs_new, &tmp);
2043
2044 /* bs_new shouldn't be in bdrv_states even after the swap! */
2045 assert(bs_new->device_name[0] == '\0');
2046
2047 /* Check a few fields that should remain attached to the device */
2048 assert(bs_new->dev == NULL);
2049 assert(bs_new->job == NULL);
2050 assert(bs_new->io_limits_enabled == false);
2051 assert(!throttle_have_timer(&bs_new->throttle_state));
2052
2053 /* insert the nodes back into the graph node list if needed */
2054 if (bs_new->node_name[0] != '\0') {
2055 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2056 }
2057 if (bs_old->node_name[0] != '\0') {
2058 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2059 }
2060
2061 bdrv_rebind(bs_new);
2062 bdrv_rebind(bs_old);
2063 }
2064
2065 /*
2066 * Add new bs contents at the top of an image chain while the chain is
2067 * live, while keeping required fields on the top layer.
2068 *
2069 * This will modify the BlockDriverState fields, and swap contents
2070 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2071 *
2072 * bs_new is required to be anonymous.
2073 *
2074 * This function does not create any image files.
2075 */
2076 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2077 {
2078 bdrv_swap(bs_new, bs_top);
2079
2080 /* The contents of 'tmp' will become bs_top, as we are
2081 * swapping bs_new and bs_top contents. */
2082 bdrv_set_backing_hd(bs_top, bs_new);
2083 }
2084
2085 static void bdrv_delete(BlockDriverState *bs)
2086 {
2087 assert(!bs->dev);
2088 assert(!bs->job);
2089 assert(bdrv_op_blocker_is_empty(bs));
2090 assert(!bs->refcnt);
2091 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2092
2093 bdrv_close(bs);
2094
2095 /* remove from list, if necessary */
2096 bdrv_make_anon(bs);
2097
2098 g_free(bs);
2099 }
2100
2101 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
2102 /* TODO change to DeviceState *dev when all users are qdevified */
2103 {
2104 if (bs->dev) {
2105 return -EBUSY;
2106 }
2107 bs->dev = dev;
2108 bdrv_iostatus_reset(bs);
2109 return 0;
2110 }
2111
2112 /* TODO qdevified devices don't use this, remove when devices are qdevified */
2113 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
2114 {
2115 if (bdrv_attach_dev(bs, dev) < 0) {
2116 abort();
2117 }
2118 }
2119
2120 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
2121 /* TODO change to DeviceState *dev when all users are qdevified */
2122 {
2123 assert(bs->dev == dev);
2124 bs->dev = NULL;
2125 bs->dev_ops = NULL;
2126 bs->dev_opaque = NULL;
2127 bs->guest_block_size = 512;
2128 }
2129
2130 /* TODO change to return DeviceState * when all users are qdevified */
2131 void *bdrv_get_attached_dev(BlockDriverState *bs)
2132 {
2133 return bs->dev;
2134 }
2135
2136 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
2137 void *opaque)
2138 {
2139 bs->dev_ops = ops;
2140 bs->dev_opaque = opaque;
2141 }
2142
2143 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
2144 {
2145 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
2146 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
2147 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
2148 if (tray_was_closed) {
2149 /* tray open */
2150 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2151 true, &error_abort);
2152 }
2153 if (load) {
2154 /* tray close */
2155 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2156 false, &error_abort);
2157 }
2158 }
2159 }
2160
2161 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2162 {
2163 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2164 }
2165
2166 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2167 {
2168 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2169 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2170 }
2171 }
2172
2173 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2174 {
2175 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2176 return bs->dev_ops->is_tray_open(bs->dev_opaque);
2177 }
2178 return false;
2179 }
2180
2181 static void bdrv_dev_resize_cb(BlockDriverState *bs)
2182 {
2183 if (bs->dev_ops && bs->dev_ops->resize_cb) {
2184 bs->dev_ops->resize_cb(bs->dev_opaque);
2185 }
2186 }
2187
2188 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2189 {
2190 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2191 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2192 }
2193 return false;
2194 }
2195
2196 /*
2197 * Run consistency checks on an image
2198 *
2199 * Returns 0 if the check could be completed (it doesn't mean that the image is
2200 * free of errors) or -errno when an internal error occurred. The results of the
2201 * check are stored in res.
2202 */
2203 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2204 {
2205 if (bs->drv->bdrv_check == NULL) {
2206 return -ENOTSUP;
2207 }
2208
2209 memset(res, 0, sizeof(*res));
2210 return bs->drv->bdrv_check(bs, res, fix);
2211 }
2212
2213 #define COMMIT_BUF_SECTORS 2048
2214
2215 /* commit COW file into the raw image */
2216 int bdrv_commit(BlockDriverState *bs)
2217 {
2218 BlockDriver *drv = bs->drv;
2219 int64_t sector, total_sectors, length, backing_length;
2220 int n, ro, open_flags;
2221 int ret = 0;
2222 uint8_t *buf = NULL;
2223 char filename[PATH_MAX];
2224
2225 if (!drv)
2226 return -ENOMEDIUM;
2227
2228 if (!bs->backing_hd) {
2229 return -ENOTSUP;
2230 }
2231
2232 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2233 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
2234 return -EBUSY;
2235 }
2236
2237 ro = bs->backing_hd->read_only;
2238 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2239 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
2240 open_flags = bs->backing_hd->open_flags;
2241
2242 if (ro) {
2243 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2244 return -EACCES;
2245 }
2246 }
2247
2248 length = bdrv_getlength(bs);
2249 if (length < 0) {
2250 ret = length;
2251 goto ro_cleanup;
2252 }
2253
2254 backing_length = bdrv_getlength(bs->backing_hd);
2255 if (backing_length < 0) {
2256 ret = backing_length;
2257 goto ro_cleanup;
2258 }
2259
2260 /* If our top snapshot is larger than the backing file image,
2261 * grow the backing file image if possible. If not possible,
2262 * we must return an error */
2263 if (length > backing_length) {
2264 ret = bdrv_truncate(bs->backing_hd, length);
2265 if (ret < 0) {
2266 goto ro_cleanup;
2267 }
2268 }
2269
2270 total_sectors = length >> BDRV_SECTOR_BITS;
2271 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2272
2273 for (sector = 0; sector < total_sectors; sector += n) {
2274 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2275 if (ret < 0) {
2276 goto ro_cleanup;
2277 }
2278 if (ret) {
2279 ret = bdrv_read(bs, sector, buf, n);
2280 if (ret < 0) {
2281 goto ro_cleanup;
2282 }
2283
2284 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2285 if (ret < 0) {
2286 goto ro_cleanup;
2287 }
2288 }
2289 }
2290
2291 if (drv->bdrv_make_empty) {
2292 ret = drv->bdrv_make_empty(bs);
2293 if (ret < 0) {
2294 goto ro_cleanup;
2295 }
2296 bdrv_flush(bs);
2297 }
2298
2299 /*
2300 * Make sure all data we wrote to the backing device is actually
2301 * stable on disk.
2302 */
2303 if (bs->backing_hd) {
2304 bdrv_flush(bs->backing_hd);
2305 }
2306
2307 ret = 0;
2308 ro_cleanup:
2309 g_free(buf);
2310
2311 if (ro) {
2312 /* ignoring error return here */
2313 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2314 }
2315
2316 return ret;
2317 }
2318
2319 int bdrv_commit_all(void)
2320 {
2321 BlockDriverState *bs;
2322
2323 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2324 AioContext *aio_context = bdrv_get_aio_context(bs);
2325
2326 aio_context_acquire(aio_context);
2327 if (bs->drv && bs->backing_hd) {
2328 int ret = bdrv_commit(bs);
2329 if (ret < 0) {
2330 aio_context_release(aio_context);
2331 return ret;
2332 }
2333 }
2334 aio_context_release(aio_context);
2335 }
2336 return 0;
2337 }
2338
2339 /**
2340 * Remove an active request from the tracked requests list
2341 *
2342 * This function should be called when a tracked request is completing.
2343 */
2344 static void tracked_request_end(BdrvTrackedRequest *req)
2345 {
2346 if (req->serialising) {
2347 req->bs->serialising_in_flight--;
2348 }
2349
2350 QLIST_REMOVE(req, list);
2351 qemu_co_queue_restart_all(&req->wait_queue);
2352 }
2353
2354 /**
2355 * Add an active request to the tracked requests list
2356 */
2357 static void tracked_request_begin(BdrvTrackedRequest *req,
2358 BlockDriverState *bs,
2359 int64_t offset,
2360 unsigned int bytes, bool is_write)
2361 {
2362 *req = (BdrvTrackedRequest){
2363 .bs = bs,
2364 .offset = offset,
2365 .bytes = bytes,
2366 .is_write = is_write,
2367 .co = qemu_coroutine_self(),
2368 .serialising = false,
2369 .overlap_offset = offset,
2370 .overlap_bytes = bytes,
2371 };
2372
2373 qemu_co_queue_init(&req->wait_queue);
2374
2375 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2376 }
2377
2378 static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2379 {
2380 int64_t overlap_offset = req->offset & ~(align - 1);
2381 unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2382 - overlap_offset;
2383
2384 if (!req->serialising) {
2385 req->bs->serialising_in_flight++;
2386 req->serialising = true;
2387 }
2388
2389 req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2390 req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2391 }
2392
2393 /**
2394 * Round a region to cluster boundaries
2395 */
2396 void bdrv_round_to_clusters(BlockDriverState *bs,
2397 int64_t sector_num, int nb_sectors,
2398 int64_t *cluster_sector_num,
2399 int *cluster_nb_sectors)
2400 {
2401 BlockDriverInfo bdi;
2402
2403 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2404 *cluster_sector_num = sector_num;
2405 *cluster_nb_sectors = nb_sectors;
2406 } else {
2407 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2408 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2409 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2410 nb_sectors, c);
2411 }
2412 }
2413
2414 static int bdrv_get_cluster_size(BlockDriverState *bs)
2415 {
2416 BlockDriverInfo bdi;
2417 int ret;
2418
2419 ret = bdrv_get_info(bs, &bdi);
2420 if (ret < 0 || bdi.cluster_size == 0) {
2421 return bs->request_alignment;
2422 } else {
2423 return bdi.cluster_size;
2424 }
2425 }
2426
2427 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2428 int64_t offset, unsigned int bytes)
2429 {
2430 /* aaaa bbbb */
2431 if (offset >= req->overlap_offset + req->overlap_bytes) {
2432 return false;
2433 }
2434 /* bbbb aaaa */
2435 if (req->overlap_offset >= offset + bytes) {
2436 return false;
2437 }
2438 return true;
2439 }
2440
2441 static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
2442 {
2443 BlockDriverState *bs = self->bs;
2444 BdrvTrackedRequest *req;
2445 bool retry;
2446 bool waited = false;
2447
2448 if (!bs->serialising_in_flight) {
2449 return false;
2450 }
2451
2452 do {
2453 retry = false;
2454 QLIST_FOREACH(req, &bs->tracked_requests, list) {
2455 if (req == self || (!req->serialising && !self->serialising)) {
2456 continue;
2457 }
2458 if (tracked_request_overlaps(req, self->overlap_offset,
2459 self->overlap_bytes))
2460 {
2461 /* Hitting this means there was a reentrant request, for
2462 * example, a block driver issuing nested requests. This must
2463 * never happen since it means deadlock.
2464 */
2465 assert(qemu_coroutine_self() != req->co);
2466
2467 /* If the request is already (indirectly) waiting for us, or
2468 * will wait for us as soon as it wakes up, then just go on
2469 * (instead of producing a deadlock in the former case). */
2470 if (!req->waiting_for) {
2471 self->waiting_for = req;
2472 qemu_co_queue_wait(&req->wait_queue);
2473 self->waiting_for = NULL;
2474 retry = true;
2475 waited = true;
2476 break;
2477 }
2478 }
2479 }
2480 } while (retry);
2481
2482 return waited;
2483 }
2484
2485 /*
2486 * Return values:
2487 * 0 - success
2488 * -EINVAL - backing format specified, but no file
2489 * -ENOSPC - can't update the backing file because no space is left in the
2490 * image file header
2491 * -ENOTSUP - format driver doesn't support changing the backing file
2492 */
2493 int bdrv_change_backing_file(BlockDriverState *bs,
2494 const char *backing_file, const char *backing_fmt)
2495 {
2496 BlockDriver *drv = bs->drv;
2497 int ret;
2498
2499 /* Backing file format doesn't make sense without a backing file */
2500 if (backing_fmt && !backing_file) {
2501 return -EINVAL;
2502 }
2503
2504 if (drv->bdrv_change_backing_file != NULL) {
2505 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2506 } else {
2507 ret = -ENOTSUP;
2508 }
2509
2510 if (ret == 0) {
2511 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2512 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2513 }
2514 return ret;
2515 }
2516
2517 /*
2518 * Finds the image layer in the chain that has 'bs' as its backing file.
2519 *
2520 * active is the current topmost image.
2521 *
2522 * Returns NULL if bs is not found in active's image chain,
2523 * or if active == bs.
2524 */
2525 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2526 BlockDriverState *bs)
2527 {
2528 BlockDriverState *overlay = NULL;
2529 BlockDriverState *intermediate;
2530
2531 assert(active != NULL);
2532 assert(bs != NULL);
2533
2534 /* if bs is the same as active, then by definition it has no overlay
2535 */
2536 if (active == bs) {
2537 return NULL;
2538 }
2539
2540 intermediate = active;
2541 while (intermediate->backing_hd) {
2542 if (intermediate->backing_hd == bs) {
2543 overlay = intermediate;
2544 break;
2545 }
2546 intermediate = intermediate->backing_hd;
2547 }
2548
2549 return overlay;
2550 }
2551
2552 typedef struct BlkIntermediateStates {
2553 BlockDriverState *bs;
2554 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2555 } BlkIntermediateStates;
2556
2557
2558 /*
2559 * Drops images above 'base' up to and including 'top', and sets the image
2560 * above 'top' to have base as its backing file.
2561 *
2562 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2563 * information in 'bs' can be properly updated.
2564 *
2565 * E.g., this will convert the following chain:
2566 * bottom <- base <- intermediate <- top <- active
2567 *
2568 * to
2569 *
2570 * bottom <- base <- active
2571 *
2572 * It is allowed for bottom==base, in which case it converts:
2573 *
2574 * base <- intermediate <- top <- active
2575 *
2576 * to
2577 *
2578 * base <- active
2579 *
2580 * Error conditions:
2581 * if active == top, that is considered an error
2582 *
2583 */
2584 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2585 BlockDriverState *base)
2586 {
2587 BlockDriverState *intermediate;
2588 BlockDriverState *base_bs = NULL;
2589 BlockDriverState *new_top_bs = NULL;
2590 BlkIntermediateStates *intermediate_state, *next;
2591 int ret = -EIO;
2592
2593 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2594 QSIMPLEQ_INIT(&states_to_delete);
2595
2596 if (!top->drv || !base->drv) {
2597 goto exit;
2598 }
2599
2600 new_top_bs = bdrv_find_overlay(active, top);
2601
2602 if (new_top_bs == NULL) {
2603 /* we could not find the image above 'top', this is an error */
2604 goto exit;
2605 }
2606
2607 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2608 * to do, no intermediate images */
2609 if (new_top_bs->backing_hd == base) {
2610 ret = 0;
2611 goto exit;
2612 }
2613
2614 intermediate = top;
2615
2616 /* now we will go down through the list, and add each BDS we find
2617 * into our deletion queue, until we hit the 'base'
2618 */
2619 while (intermediate) {
2620 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2621 intermediate_state->bs = intermediate;
2622 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2623
2624 if (intermediate->backing_hd == base) {
2625 base_bs = intermediate->backing_hd;
2626 break;
2627 }
2628 intermediate = intermediate->backing_hd;
2629 }
2630 if (base_bs == NULL) {
2631 /* something went wrong, we did not end at the base. safely
2632 * unravel everything, and exit with error */
2633 goto exit;
2634 }
2635
2636 /* success - we can delete the intermediate states, and link top->base */
2637 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2638 base_bs->drv ? base_bs->drv->format_name : "");
2639 if (ret) {
2640 goto exit;
2641 }
2642 bdrv_set_backing_hd(new_top_bs, base_bs);
2643
2644 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2645 /* so that bdrv_close() does not recursively close the chain */
2646 bdrv_set_backing_hd(intermediate_state->bs, NULL);
2647 bdrv_unref(intermediate_state->bs);
2648 }
2649 ret = 0;
2650
2651 exit:
2652 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2653 g_free(intermediate_state);
2654 }
2655 return ret;
2656 }
2657
2658
2659 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2660 size_t size)
2661 {
2662 int64_t len;
2663
2664 if (size > INT_MAX) {
2665 return -EIO;
2666 }
2667
2668 if (!bdrv_is_inserted(bs))
2669 return -ENOMEDIUM;
2670
2671 if (bs->growable)
2672 return 0;
2673
2674 len = bdrv_getlength(bs);
2675
2676 if (offset < 0)
2677 return -EIO;
2678
2679 if ((offset > len) || (len - offset < size))
2680 return -EIO;
2681
2682 return 0;
2683 }
2684
2685 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2686 int nb_sectors)
2687 {
2688 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2689 return -EIO;
2690 }
2691
2692 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2693 nb_sectors * BDRV_SECTOR_SIZE);
2694 }
2695
2696 typedef struct RwCo {
2697 BlockDriverState *bs;
2698 int64_t offset;
2699 QEMUIOVector *qiov;
2700 bool is_write;
2701 int ret;
2702 BdrvRequestFlags flags;
2703 } RwCo;
2704
2705 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2706 {
2707 RwCo *rwco = opaque;
2708
2709 if (!rwco->is_write) {
2710 rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2711 rwco->qiov->size, rwco->qiov,
2712 rwco->flags);
2713 } else {
2714 rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2715 rwco->qiov->size, rwco->qiov,
2716 rwco->flags);
2717 }
2718 }
2719
2720 /*
2721 * Process a vectored synchronous request using coroutines
2722 */
2723 static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2724 QEMUIOVector *qiov, bool is_write,
2725 BdrvRequestFlags flags)
2726 {
2727 Coroutine *co;
2728 RwCo rwco = {
2729 .bs = bs,
2730 .offset = offset,
2731 .qiov = qiov,
2732 .is_write = is_write,
2733 .ret = NOT_DONE,
2734 .flags = flags,
2735 };
2736
2737 /**
2738 * In sync call context, when the vcpu is blocked, this throttling timer
2739 * will not fire; so the I/O throttling function has to be disabled here
2740 * if it has been enabled.
2741 */
2742 if (bs->io_limits_enabled) {
2743 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2744 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2745 bdrv_io_limits_disable(bs);
2746 }
2747
2748 if (qemu_in_coroutine()) {
2749 /* Fast-path if already in coroutine context */
2750 bdrv_rw_co_entry(&rwco);
2751 } else {
2752 AioContext *aio_context = bdrv_get_aio_context(bs);
2753
2754 co = qemu_coroutine_create(bdrv_rw_co_entry);
2755 qemu_coroutine_enter(co, &rwco);
2756 while (rwco.ret == NOT_DONE) {
2757 aio_poll(aio_context, true);
2758 }
2759 }
2760 return rwco.ret;
2761 }
2762
2763 /*
2764 * Process a synchronous request using coroutines
2765 */
2766 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
2767 int nb_sectors, bool is_write, BdrvRequestFlags flags)
2768 {
2769 QEMUIOVector qiov;
2770 struct iovec iov = {
2771 .iov_base = (void *)buf,
2772 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2773 };
2774
2775 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2776 return -EINVAL;
2777 }
2778
2779 qemu_iovec_init_external(&qiov, &iov, 1);
2780 return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2781 &qiov, is_write, flags);
2782 }
2783
2784 /* return < 0 if error. See bdrv_write() for the return codes */
2785 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2786 uint8_t *buf, int nb_sectors)
2787 {
2788 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
2789 }
2790
2791 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2792 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2793 uint8_t *buf, int nb_sectors)
2794 {
2795 bool enabled;
2796 int ret;
2797
2798 enabled = bs->io_limits_enabled;
2799 bs->io_limits_enabled = false;
2800 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
2801 bs->io_limits_enabled = enabled;
2802 return ret;
2803 }
2804
2805 /* Return < 0 if error. Important errors are:
2806 -EIO generic I/O error (may happen for all errors)
2807 -ENOMEDIUM No media inserted.
2808 -EINVAL Invalid sector number or nb_sectors
2809 -EACCES Trying to write a read-only device
2810 */
2811 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2812 const uint8_t *buf, int nb_sectors)
2813 {
2814 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
2815 }
2816
2817 int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2818 int nb_sectors, BdrvRequestFlags flags)
2819 {
2820 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2821 BDRV_REQ_ZERO_WRITE | flags);
2822 }
2823
2824 /*
2825 * Completely zero out a block device with the help of bdrv_write_zeroes.
2826 * The operation is sped up by checking the block status and only writing
2827 * zeroes to the device if they currently do not return zeroes. Optional
2828 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2829 *
2830 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2831 */
2832 int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2833 {
2834 int64_t target_size;
2835 int64_t ret, nb_sectors, sector_num = 0;
2836 int n;
2837
2838 target_size = bdrv_getlength(bs);
2839 if (target_size < 0) {
2840 return target_size;
2841 }
2842 target_size /= BDRV_SECTOR_SIZE;
2843
2844 for (;;) {
2845 nb_sectors = target_size - sector_num;
2846 if (nb_sectors <= 0) {
2847 return 0;
2848 }
2849 if (nb_sectors > INT_MAX) {
2850 nb_sectors = INT_MAX;
2851 }
2852 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
2853 if (ret < 0) {
2854 error_report("error getting block status at sector %" PRId64 ": %s",
2855 sector_num, strerror(-ret));
2856 return ret;
2857 }
2858 if (ret & BDRV_BLOCK_ZERO) {
2859 sector_num += n;
2860 continue;
2861 }
2862 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2863 if (ret < 0) {
2864 error_report("error writing zeroes at sector %" PRId64 ": %s",
2865 sector_num, strerror(-ret));
2866 return ret;
2867 }
2868 sector_num += n;
2869 }
2870 }
2871
2872 int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
2873 {
2874 QEMUIOVector qiov;
2875 struct iovec iov = {
2876 .iov_base = (void *)buf,
2877 .iov_len = bytes,
2878 };
2879 int ret;
2880
2881 if (bytes < 0) {
2882 return -EINVAL;
2883 }
2884
2885 qemu_iovec_init_external(&qiov, &iov, 1);
2886 ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2887 if (ret < 0) {
2888 return ret;
2889 }
2890
2891 return bytes;
2892 }
2893
2894 int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
2895 {
2896 int ret;
2897
2898 ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2899 if (ret < 0) {
2900 return ret;
2901 }
2902
2903 return qiov->size;
2904 }
2905
2906 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2907 const void *buf, int bytes)
2908 {
2909 QEMUIOVector qiov;
2910 struct iovec iov = {
2911 .iov_base = (void *) buf,
2912 .iov_len = bytes,
2913 };
2914
2915 if (bytes < 0) {
2916 return -EINVAL;
2917 }
2918
2919 qemu_iovec_init_external(&qiov, &iov, 1);
2920 return bdrv_pwritev(bs, offset, &qiov);
2921 }
2922
2923 /*
2924 * Writes to the file and ensures that no writes are reordered across this
2925 * request (acts as a barrier)
2926 *
2927 * Returns 0 on success, -errno in error cases.
2928 */
2929 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2930 const void *buf, int count)
2931 {
2932 int ret;
2933
2934 ret = bdrv_pwrite(bs, offset, buf, count);
2935 if (ret < 0) {
2936 return ret;
2937 }
2938
2939 /* No flush needed for cache modes that already do it */
2940 if (bs->enable_write_cache) {
2941 bdrv_flush(bs);
2942 }
2943
2944 return 0;
2945 }
2946
2947 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2948 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2949 {
2950 /* Perform I/O through a temporary buffer so that users who scribble over
2951 * their read buffer while the operation is in progress do not end up
2952 * modifying the image file. This is critical for zero-copy guest I/O
2953 * where anything might happen inside guest memory.
2954 */
2955 void *bounce_buffer;
2956
2957 BlockDriver *drv = bs->drv;
2958 struct iovec iov;
2959 QEMUIOVector bounce_qiov;
2960 int64_t cluster_sector_num;
2961 int cluster_nb_sectors;
2962 size_t skip_bytes;
2963 int ret;
2964
2965 /* Cover entire cluster so no additional backing file I/O is required when
2966 * allocating cluster in the image file.
2967 */
2968 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2969 &cluster_sector_num, &cluster_nb_sectors);
2970
2971 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2972 cluster_sector_num, cluster_nb_sectors);
2973
2974 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2975 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2976 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2977
2978 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2979 &bounce_qiov);
2980 if (ret < 0) {
2981 goto err;
2982 }
2983
2984 if (drv->bdrv_co_write_zeroes &&
2985 buffer_is_zero(bounce_buffer, iov.iov_len)) {
2986 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2987 cluster_nb_sectors, 0);
2988 } else {
2989 /* This does not change the data on the disk, it is not necessary
2990 * to flush even in cache=writethrough mode.
2991 */
2992 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
2993 &bounce_qiov);
2994 }
2995
2996 if (ret < 0) {
2997 /* It might be okay to ignore write errors for guest requests. If this
2998 * is a deliberate copy-on-read then we don't want to ignore the error.
2999 * Simply report it in all cases.
3000 */
3001 goto err;
3002 }
3003
3004 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
3005 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
3006 nb_sectors * BDRV_SECTOR_SIZE);
3007
3008 err:
3009 qemu_vfree(bounce_buffer);
3010 return ret;
3011 }
3012
3013 /*
3014 * Forwards an already correctly aligned request to the BlockDriver. This
3015 * handles copy on read and zeroing after EOF; any other features must be
3016 * implemented by the caller.
3017 */
3018 static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
3019 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3020 int64_t align, QEMUIOVector *qiov, int flags)
3021 {
3022 BlockDriver *drv = bs->drv;
3023 int ret;
3024
3025 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3026 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3027
3028 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3029 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3030
3031 /* Handle Copy on Read and associated serialisation */
3032 if (flags & BDRV_REQ_COPY_ON_READ) {
3033 /* If we touch the same cluster it counts as an overlap. This
3034 * guarantees that allocating writes will be serialized and not race
3035 * with each other for the same cluster. For example, in copy-on-read
3036 * it ensures that the CoR read and write operations are atomic and
3037 * guest writes cannot interleave between them. */
3038 mark_request_serialising(req, bdrv_get_cluster_size(bs));
3039 }
3040
3041 wait_serialising_requests(req);
3042
3043 if (flags & BDRV_REQ_COPY_ON_READ) {
3044 int pnum;
3045
3046 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
3047 if (ret < 0) {
3048 goto out;
3049 }
3050
3051 if (!ret || pnum != nb_sectors) {
3052 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
3053 goto out;
3054 }
3055 }
3056
3057 /* Forward the request to the BlockDriver */
3058 if (!(bs->zero_beyond_eof && bs->growable)) {
3059 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3060 } else {
3061 /* Read zeros after EOF of growable BDSes */
3062 int64_t len, total_sectors, max_nb_sectors;
3063
3064 len = bdrv_getlength(bs);
3065 if (len < 0) {
3066 ret = len;
3067 goto out;
3068 }
3069
3070 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
3071 max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3072 align >> BDRV_SECTOR_BITS);
3073 if (max_nb_sectors > 0) {
3074 ret = drv->bdrv_co_readv(bs, sector_num,
3075 MIN(nb_sectors, max_nb_sectors), qiov);
3076 } else {
3077 ret = 0;
3078 }
3079
3080 /* Reading beyond end of file is supposed to produce zeroes */
3081 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3082 uint64_t offset = MAX(0, total_sectors - sector_num);
3083 uint64_t bytes = (sector_num + nb_sectors - offset) *
3084 BDRV_SECTOR_SIZE;
3085 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3086 }
3087 }
3088
3089 out:
3090 return ret;
3091 }
3092
3093 /*
3094 * Handle a read request in coroutine context
3095 */
3096 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3097 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3098 BdrvRequestFlags flags)
3099 {
3100 BlockDriver *drv = bs->drv;
3101 BdrvTrackedRequest req;
3102
3103 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3104 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3105 uint8_t *head_buf = NULL;
3106 uint8_t *tail_buf = NULL;
3107 QEMUIOVector local_qiov;
3108 bool use_local_qiov = false;
3109 int ret;
3110
3111 if (!drv) {
3112 return -ENOMEDIUM;
3113 }
3114 if (bdrv_check_byte_request(bs, offset, bytes)) {
3115 return -EIO;
3116 }
3117
3118 if (bs->copy_on_read) {
3119 flags |= BDRV_REQ_COPY_ON_READ;
3120 }
3121
3122 /* throttling disk I/O */
3123 if (bs->io_limits_enabled) {
3124 bdrv_io_limits_intercept(bs, bytes, false);
3125 }
3126
3127 /* Align read if necessary by padding qiov */
3128 if (offset & (align - 1)) {
3129 head_buf = qemu_blockalign(bs, align);
3130 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3131 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3132 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3133 use_local_qiov = true;
3134
3135 bytes += offset & (align - 1);
3136 offset = offset & ~(align - 1);
3137 }
3138
3139 if ((offset + bytes) & (align - 1)) {
3140 if (!use_local_qiov) {
3141 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3142 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3143 use_local_qiov = true;
3144 }
3145 tail_buf = qemu_blockalign(bs, align);
3146 qemu_iovec_add(&local_qiov, tail_buf,
3147 align - ((offset + bytes) & (align - 1)));
3148
3149 bytes = ROUND_UP(bytes, align);
3150 }
3151
3152 tracked_request_begin(&req, bs, offset, bytes, false);
3153 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
3154 use_local_qiov ? &local_qiov : qiov,
3155 flags);
3156 tracked_request_end(&req);
3157
3158 if (use_local_qiov) {
3159 qemu_iovec_destroy(&local_qiov);
3160 qemu_vfree(head_buf);
3161 qemu_vfree(tail_buf);
3162 }
3163
3164 return ret;
3165 }
3166
3167 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3168 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3169 BdrvRequestFlags flags)
3170 {
3171 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3172 return -EINVAL;
3173 }
3174
3175 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3176 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3177 }
3178
3179 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
3180 int nb_sectors, QEMUIOVector *qiov)
3181 {
3182 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
3183
3184 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3185 }
3186
3187 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3188 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3189 {
3190 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3191
3192 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3193 BDRV_REQ_COPY_ON_READ);
3194 }
3195
3196 /* if no limit is specified in the BlockLimits use a default
3197 * of 32768 512-byte sectors (16 MiB) per request.
3198 */
3199 #define MAX_WRITE_ZEROES_DEFAULT 32768
3200
3201 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
3202 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
3203 {
3204 BlockDriver *drv = bs->drv;
3205 QEMUIOVector qiov;
3206 struct iovec iov = {0};
3207 int ret = 0;
3208
3209 int max_write_zeroes = bs->bl.max_write_zeroes ?
3210 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
3211
3212 while (nb_sectors > 0 && !ret) {
3213 int num = nb_sectors;
3214
3215 /* Align request. Block drivers can expect the "bulk" of the request
3216 * to be aligned.
3217 */
3218 if (bs->bl.write_zeroes_alignment
3219 && num > bs->bl.write_zeroes_alignment) {
3220 if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3221 /* Make a small request up to the first aligned sector. */
3222 num = bs->bl.write_zeroes_alignment;
3223 num -= sector_num % bs->bl.write_zeroes_alignment;
3224 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3225 /* Shorten the request to the last aligned sector. num cannot
3226 * underflow because num > bs->bl.write_zeroes_alignment.
3227 */
3228 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
3229 }
3230 }
3231
3232 /* limit request size */
3233 if (num > max_write_zeroes) {
3234 num = max_write_zeroes;
3235 }
3236
3237 ret = -ENOTSUP;
3238 /* First try the efficient write zeroes operation */
3239 if (drv->bdrv_co_write_zeroes) {
3240 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3241 }
3242
3243 if (ret == -ENOTSUP) {
3244 /* Fall back to bounce buffer if write zeroes is unsupported */
3245 iov.iov_len = num * BDRV_SECTOR_SIZE;
3246 if (iov.iov_base == NULL) {
3247 iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE);
3248 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
3249 }
3250 qemu_iovec_init_external(&qiov, &iov, 1);
3251
3252 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
3253
3254 /* Keep bounce buffer around if it is big enough for all
3255 * all future requests.
3256 */
3257 if (num < max_write_zeroes) {
3258 qemu_vfree(iov.iov_base);
3259 iov.iov_base = NULL;
3260 }
3261 }
3262
3263 sector_num += num;
3264 nb_sectors -= num;
3265 }
3266
3267 qemu_vfree(iov.iov_base);
3268 return ret;
3269 }
3270
3271 /*
3272 * Forwards an already correctly aligned write request to the BlockDriver.
3273 */
3274 static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
3275 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3276 QEMUIOVector *qiov, int flags)
3277 {
3278 BlockDriver *drv = bs->drv;
3279 bool waited;
3280 int ret;
3281
3282 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3283 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3284
3285 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3286 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3287
3288 waited = wait_serialising_requests(req);
3289 assert(!waited || !req->serialising);
3290 assert(req->overlap_offset <= offset);
3291 assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
3292
3293 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
3294
3295 if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3296 !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3297 qemu_iovec_is_zero(qiov)) {
3298 flags |= BDRV_REQ_ZERO_WRITE;
3299 if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3300 flags |= BDRV_REQ_MAY_UNMAP;
3301 }
3302 }
3303
3304 if (ret < 0) {
3305 /* Do nothing, write notifier decided to fail this request */
3306 } else if (flags & BDRV_REQ_ZERO_WRITE) {
3307 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
3308 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
3309 } else {
3310 BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
3311 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3312 }
3313 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
3314
3315 if (ret == 0 && !bs->enable_write_cache) {
3316 ret = bdrv_co_flush(bs);
3317 }
3318
3319 bdrv_set_dirty(bs, sector_num, nb_sectors);
3320
3321 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3322 bs->wr_highest_sector = sector_num + nb_sectors - 1;
3323 }
3324 if (bs->growable && ret >= 0) {
3325 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3326 }
3327
3328 return ret;
3329 }
3330
3331 /*
3332 * Handle a write request in coroutine context
3333 */
3334 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3335 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3336 BdrvRequestFlags flags)
3337 {
3338 BdrvTrackedRequest req;
3339 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3340 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3341 uint8_t *head_buf = NULL;
3342 uint8_t *tail_buf = NULL;
3343 QEMUIOVector local_qiov;
3344 bool use_local_qiov = false;
3345 int ret;
3346
3347 if (!bs->drv) {
3348 return -ENOMEDIUM;
3349 }
3350 if (bs->read_only) {
3351 return -EACCES;
3352 }
3353 if (bdrv_check_byte_request(bs, offset, bytes)) {
3354 return -EIO;
3355 }
3356
3357 /* throttling disk I/O */
3358 if (bs->io_limits_enabled) {
3359 bdrv_io_limits_intercept(bs, bytes, true);
3360 }
3361
3362 /*
3363 * Align write if necessary by performing a read-modify-write cycle.
3364 * Pad qiov with the read parts and be sure to have a tracked request not
3365 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3366 */
3367 tracked_request_begin(&req, bs, offset, bytes, true);
3368
3369 if (offset & (align - 1)) {
3370 QEMUIOVector head_qiov;
3371 struct iovec head_iov;
3372
3373 mark_request_serialising(&req, align);
3374 wait_serialising_requests(&req);
3375
3376 head_buf = qemu_blockalign(bs, align);
3377 head_iov = (struct iovec) {
3378 .iov_base = head_buf,
3379 .iov_len = align,
3380 };
3381 qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3382
3383 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3384 ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3385 align, &head_qiov, 0);
3386 if (ret < 0) {
3387 goto fail;
3388 }
3389 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3390
3391 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3392 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3393 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3394 use_local_qiov = true;
3395
3396 bytes += offset & (align - 1);
3397 offset = offset & ~(align - 1);
3398 }
3399
3400 if ((offset + bytes) & (align - 1)) {
3401 QEMUIOVector tail_qiov;
3402 struct iovec tail_iov;
3403 size_t tail_bytes;
3404 bool waited;
3405
3406 mark_request_serialising(&req, align);
3407 waited = wait_serialising_requests(&req);
3408 assert(!waited || !use_local_qiov);
3409
3410 tail_buf = qemu_blockalign(bs, align);
3411 tail_iov = (struct iovec) {
3412 .iov_base = tail_buf,
3413 .iov_len = align,
3414 };
3415 qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3416
3417 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3418 ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3419 align, &tail_qiov, 0);
3420 if (ret < 0) {
3421 goto fail;
3422 }
3423 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3424
3425 if (!use_local_qiov) {
3426 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3427 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3428 use_local_qiov = true;
3429 }
3430
3431 tail_bytes = (offset + bytes) & (align - 1);
3432 qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3433
3434 bytes = ROUND_UP(bytes, align);
3435 }
3436
3437 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3438 use_local_qiov ? &local_qiov : qiov,
3439 flags);
3440
3441 fail:
3442 tracked_request_end(&req);
3443
3444 if (use_local_qiov) {
3445 qemu_iovec_destroy(&local_qiov);
3446 }
3447 qemu_vfree(head_buf);
3448 qemu_vfree(tail_buf);
3449
3450 return ret;
3451 }
3452
3453 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3454 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3455 BdrvRequestFlags flags)
3456 {
3457 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3458 return -EINVAL;
3459 }
3460
3461 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3462 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3463 }
3464
3465 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3466 int nb_sectors, QEMUIOVector *qiov)
3467 {
3468 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3469
3470 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3471 }
3472
3473 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
3474 int64_t sector_num, int nb_sectors,
3475 BdrvRequestFlags flags)
3476 {
3477 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
3478
3479 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3480 flags &= ~BDRV_REQ_MAY_UNMAP;
3481 }
3482
3483 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
3484 BDRV_REQ_ZERO_WRITE | flags);
3485 }
3486
3487 /**
3488 * Truncate file to 'offset' bytes (needed only for file protocols)
3489 */
3490 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3491 {
3492 BlockDriver *drv = bs->drv;
3493 int ret;
3494 if (!drv)
3495 return -ENOMEDIUM;
3496 if (!drv->bdrv_truncate)
3497 return -ENOTSUP;
3498 if (bs->read_only)
3499 return -EACCES;
3500 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
3501 return -EBUSY;
3502 }
3503 ret = drv->bdrv_truncate(bs, offset);
3504 if (ret == 0) {
3505 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3506 bdrv_dev_resize_cb(bs);
3507 }
3508 return ret;
3509 }
3510
3511 /**
3512 * Length of a allocated file in bytes. Sparse files are counted by actual
3513 * allocated space. Return < 0 if error or unknown.
3514 */
3515 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3516 {
3517 BlockDriver *drv = bs->drv;
3518 if (!drv) {
3519 return -ENOMEDIUM;
3520 }
3521 if (drv->bdrv_get_allocated_file_size) {
3522 return drv->bdrv_get_allocated_file_size(bs);
3523 }
3524 if (bs->file) {
3525 return bdrv_get_allocated_file_size(bs->file);
3526 }
3527 return -ENOTSUP;
3528 }
3529
3530 /**
3531 * Length of a file in bytes. Return < 0 if error or unknown.
3532 */
3533 int64_t bdrv_getlength(BlockDriverState *bs)
3534 {
3535 BlockDriver *drv = bs->drv;
3536 if (!drv)
3537 return -ENOMEDIUM;
3538
3539 if (drv->has_variable_length) {
3540 int ret = refresh_total_sectors(bs, bs->total_sectors);
3541 if (ret < 0) {
3542 return ret;
3543 }
3544 }
3545 return bs->total_sectors * BDRV_SECTOR_SIZE;
3546 }
3547
3548 /* return 0 as number of sectors if no device present or error */
3549 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3550 {
3551 int64_t length;
3552 length = bdrv_getlength(bs);
3553 if (length < 0)
3554 length = 0;
3555 else