Merge remote-tracking branch 'remotes/kraxel/tags/fixes-31-20181116-pull-request...
[qemu.git] / block.c
1 /*
2 * QEMU System Emulator block driver
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "config-host.h"
25 #include "qemu-common.h"
26 #include "trace.h"
27 #include "monitor.h"
28 #include "block_int.h"
29 #include "blockjob.h"
30 #include "module.h"
31 #include "qjson.h"
32 #include "sysemu.h"
33 #include "qemu-coroutine.h"
34 #include "qmp-commands.h"
35 #include "qemu-timer.h"
36
37 #ifdef CONFIG_BSD
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #include <sys/ioctl.h>
41 #include <sys/queue.h>
42 #ifndef __DragonFly__
43 #include <sys/disk.h>
44 #endif
45 #endif
46
47 #ifdef _WIN32
48 #include <windows.h>
49 #endif
50
51 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
52
53 typedef enum {
54 BDRV_REQ_COPY_ON_READ = 0x1,
55 BDRV_REQ_ZERO_WRITE = 0x2,
56 } BdrvRequestFlags;
57
58 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
59 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
60 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
61 BlockDriverCompletionFunc *cb, void *opaque);
62 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
63 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
64 BlockDriverCompletionFunc *cb, void *opaque);
65 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
66 int64_t sector_num, int nb_sectors,
67 QEMUIOVector *iov);
68 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
69 int64_t sector_num, int nb_sectors,
70 QEMUIOVector *iov);
71 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
72 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
73 BdrvRequestFlags flags);
74 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
75 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
76 BdrvRequestFlags flags);
77 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
78 int64_t sector_num,
79 QEMUIOVector *qiov,
80 int nb_sectors,
81 BlockDriverCompletionFunc *cb,
82 void *opaque,
83 bool is_write);
84 static void coroutine_fn bdrv_co_do_rw(void *opaque);
85 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
86 int64_t sector_num, int nb_sectors);
87
88 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
89 bool is_write, double elapsed_time, uint64_t *wait);
90 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
91 double elapsed_time, uint64_t *wait);
92 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
93 bool is_write, int64_t *wait);
94
95 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
96 QTAILQ_HEAD_INITIALIZER(bdrv_states);
97
98 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
99 QLIST_HEAD_INITIALIZER(bdrv_drivers);
100
101 /* The device to use for VM snapshots */
102 static BlockDriverState *bs_snapshots;
103
104 /* If non-zero, use only whitelisted block drivers */
105 static int use_bdrv_whitelist;
106
107 #ifdef _WIN32
108 static int is_windows_drive_prefix(const char *filename)
109 {
110 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
111 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
112 filename[1] == ':');
113 }
114
115 int is_windows_drive(const char *filename)
116 {
117 if (is_windows_drive_prefix(filename) &&
118 filename[2] == '\0')
119 return 1;
120 if (strstart(filename, "\\\\.\\", NULL) ||
121 strstart(filename, "//./", NULL))
122 return 1;
123 return 0;
124 }
125 #endif
126
127 /* throttling disk I/O limits */
128 void bdrv_io_limits_disable(BlockDriverState *bs)
129 {
130 bs->io_limits_enabled = false;
131
132 while (qemu_co_queue_next(&bs->throttled_reqs));
133
134 if (bs->block_timer) {
135 qemu_del_timer(bs->block_timer);
136 qemu_free_timer(bs->block_timer);
137 bs->block_timer = NULL;
138 }
139
140 bs->slice_start = 0;
141 bs->slice_end = 0;
142 bs->slice_time = 0;
143 memset(&bs->io_base, 0, sizeof(bs->io_base));
144 }
145
146 static void bdrv_block_timer(void *opaque)
147 {
148 BlockDriverState *bs = opaque;
149
150 qemu_co_queue_next(&bs->throttled_reqs);
151 }
152
153 void bdrv_io_limits_enable(BlockDriverState *bs)
154 {
155 qemu_co_queue_init(&bs->throttled_reqs);
156 bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs);
157 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME;
158 bs->slice_start = qemu_get_clock_ns(vm_clock);
159 bs->slice_end = bs->slice_start + bs->slice_time;
160 memset(&bs->io_base, 0, sizeof(bs->io_base));
161 bs->io_limits_enabled = true;
162 }
163
164 bool bdrv_io_limits_enabled(BlockDriverState *bs)
165 {
166 BlockIOLimit *io_limits = &bs->io_limits;
167 return io_limits->bps[BLOCK_IO_LIMIT_READ]
168 || io_limits->bps[BLOCK_IO_LIMIT_WRITE]
169 || io_limits->bps[BLOCK_IO_LIMIT_TOTAL]
170 || io_limits->iops[BLOCK_IO_LIMIT_READ]
171 || io_limits->iops[BLOCK_IO_LIMIT_WRITE]
172 || io_limits->iops[BLOCK_IO_LIMIT_TOTAL];
173 }
174
175 static void bdrv_io_limits_intercept(BlockDriverState *bs,
176 bool is_write, int nb_sectors)
177 {
178 int64_t wait_time = -1;
179
180 if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
181 qemu_co_queue_wait(&bs->throttled_reqs);
182 }
183
184 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
185 * throttled requests will not be dequeued until the current request is
186 * allowed to be serviced. So if the current request still exceeds the
187 * limits, it will be inserted to the head. All requests followed it will
188 * be still in throttled_reqs queue.
189 */
190
191 while (bdrv_exceed_io_limits(bs, nb_sectors, is_write, &wait_time)) {
192 qemu_mod_timer(bs->block_timer,
193 wait_time + qemu_get_clock_ns(vm_clock));
194 qemu_co_queue_wait_insert_head(&bs->throttled_reqs);
195 }
196
197 qemu_co_queue_next(&bs->throttled_reqs);
198 }
199
200 /* check if the path starts with "<protocol>:" */
201 static int path_has_protocol(const char *path)
202 {
203 const char *p;
204
205 #ifdef _WIN32
206 if (is_windows_drive(path) ||
207 is_windows_drive_prefix(path)) {
208 return 0;
209 }
210 p = path + strcspn(path, ":/\\");
211 #else
212 p = path + strcspn(path, ":/");
213 #endif
214
215 return *p == ':';
216 }
217
218 int path_is_absolute(const char *path)
219 {
220 #ifdef _WIN32
221 /* specific case for names like: "\\.\d:" */
222 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
223 return 1;
224 }
225 return (*path == '/' || *path == '\\');
226 #else
227 return (*path == '/');
228 #endif
229 }
230
231 /* if filename is absolute, just copy it to dest. Otherwise, build a
232 path to it by considering it is relative to base_path. URL are
233 supported. */
234 void path_combine(char *dest, int dest_size,
235 const char *base_path,
236 const char *filename)
237 {
238 const char *p, *p1;
239 int len;
240
241 if (dest_size <= 0)
242 return;
243 if (path_is_absolute(filename)) {
244 pstrcpy(dest, dest_size, filename);
245 } else {
246 p = strchr(base_path, ':');
247 if (p)
248 p++;
249 else
250 p = base_path;
251 p1 = strrchr(base_path, '/');
252 #ifdef _WIN32
253 {
254 const char *p2;
255 p2 = strrchr(base_path, '\\');
256 if (!p1 || p2 > p1)
257 p1 = p2;
258 }
259 #endif
260 if (p1)
261 p1++;
262 else
263 p1 = base_path;
264 if (p1 > p)
265 p = p1;
266 len = p - base_path;
267 if (len > dest_size - 1)
268 len = dest_size - 1;
269 memcpy(dest, base_path, len);
270 dest[len] = '\0';
271 pstrcat(dest, dest_size, filename);
272 }
273 }
274
275 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
276 {
277 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
278 pstrcpy(dest, sz, bs->backing_file);
279 } else {
280 path_combine(dest, sz, bs->filename, bs->backing_file);
281 }
282 }
283
284 void bdrv_register(BlockDriver *bdrv)
285 {
286 /* Block drivers without coroutine functions need emulation */
287 if (!bdrv->bdrv_co_readv) {
288 bdrv->bdrv_co_readv = bdrv_co_readv_em;
289 bdrv->bdrv_co_writev = bdrv_co_writev_em;
290
291 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
292 * the block driver lacks aio we need to emulate that too.
293 */
294 if (!bdrv->bdrv_aio_readv) {
295 /* add AIO emulation layer */
296 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
297 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
298 }
299 }
300
301 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
302 }
303
304 /* create a new block device (by default it is empty) */
305 BlockDriverState *bdrv_new(const char *device_name)
306 {
307 BlockDriverState *bs;
308
309 bs = g_malloc0(sizeof(BlockDriverState));
310 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
311 if (device_name[0] != '\0') {
312 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
313 }
314 bdrv_iostatus_disable(bs);
315 return bs;
316 }
317
318 BlockDriver *bdrv_find_format(const char *format_name)
319 {
320 BlockDriver *drv1;
321 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
322 if (!strcmp(drv1->format_name, format_name)) {
323 return drv1;
324 }
325 }
326 return NULL;
327 }
328
329 static int bdrv_is_whitelisted(BlockDriver *drv)
330 {
331 static const char *whitelist[] = {
332 CONFIG_BDRV_WHITELIST
333 };
334 const char **p;
335
336 if (!whitelist[0])
337 return 1; /* no whitelist, anything goes */
338
339 for (p = whitelist; *p; p++) {
340 if (!strcmp(drv->format_name, *p)) {
341 return 1;
342 }
343 }
344 return 0;
345 }
346
347 BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
348 {
349 BlockDriver *drv = bdrv_find_format(format_name);
350 return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
351 }
352
353 typedef struct CreateCo {
354 BlockDriver *drv;
355 char *filename;
356 QEMUOptionParameter *options;
357 int ret;
358 } CreateCo;
359
360 static void coroutine_fn bdrv_create_co_entry(void *opaque)
361 {
362 CreateCo *cco = opaque;
363 assert(cco->drv);
364
365 cco->ret = cco->drv->bdrv_create(cco->filename, cco->options);
366 }
367
368 int bdrv_create(BlockDriver *drv, const char* filename,
369 QEMUOptionParameter *options)
370 {
371 int ret;
372
373 Coroutine *co;
374 CreateCo cco = {
375 .drv = drv,
376 .filename = g_strdup(filename),
377 .options = options,
378 .ret = NOT_DONE,
379 };
380
381 if (!drv->bdrv_create) {
382 return -ENOTSUP;
383 }
384
385 if (qemu_in_coroutine()) {
386 /* Fast-path if already in coroutine context */
387 bdrv_create_co_entry(&cco);
388 } else {
389 co = qemu_coroutine_create(bdrv_create_co_entry);
390 qemu_coroutine_enter(co, &cco);
391 while (cco.ret == NOT_DONE) {
392 qemu_aio_wait();
393 }
394 }
395
396 ret = cco.ret;
397 g_free(cco.filename);
398
399 return ret;
400 }
401
402 int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
403 {
404 BlockDriver *drv;
405
406 drv = bdrv_find_protocol(filename);
407 if (drv == NULL) {
408 return -ENOENT;
409 }
410
411 return bdrv_create(drv, filename, options);
412 }
413
414 /*
415 * Create a uniquely-named empty temporary file.
416 * Return 0 upon success, otherwise a negative errno value.
417 */
418 int get_tmp_filename(char *filename, int size)
419 {
420 #ifdef _WIN32
421 char temp_dir[MAX_PATH];
422 /* GetTempFileName requires that its output buffer (4th param)
423 have length MAX_PATH or greater. */
424 assert(size >= MAX_PATH);
425 return (GetTempPath(MAX_PATH, temp_dir)
426 && GetTempFileName(temp_dir, "qem", 0, filename)
427 ? 0 : -GetLastError());
428 #else
429 int fd;
430 const char *tmpdir;
431 tmpdir = getenv("TMPDIR");
432 if (!tmpdir)
433 tmpdir = "/tmp";
434 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
435 return -EOVERFLOW;
436 }
437 fd = mkstemp(filename);
438 if (fd < 0) {
439 return -errno;
440 }
441 if (close(fd) != 0) {
442 unlink(filename);
443 return -errno;
444 }
445 return 0;
446 #endif
447 }
448
449 /*
450 * Detect host devices. By convention, /dev/cdrom[N] is always
451 * recognized as a host CDROM.
452 */
453 static BlockDriver *find_hdev_driver(const char *filename)
454 {
455 int score_max = 0, score;
456 BlockDriver *drv = NULL, *d;
457
458 QLIST_FOREACH(d, &bdrv_drivers, list) {
459 if (d->bdrv_probe_device) {
460 score = d->bdrv_probe_device(filename);
461 if (score > score_max) {
462 score_max = score;
463 drv = d;
464 }
465 }
466 }
467
468 return drv;
469 }
470
471 BlockDriver *bdrv_find_protocol(const char *filename)
472 {
473 BlockDriver *drv1;
474 char protocol[128];
475 int len;
476 const char *p;
477
478 /* TODO Drivers without bdrv_file_open must be specified explicitly */
479
480 /*
481 * XXX(hch): we really should not let host device detection
482 * override an explicit protocol specification, but moving this
483 * later breaks access to device names with colons in them.
484 * Thanks to the brain-dead persistent naming schemes on udev-
485 * based Linux systems those actually are quite common.
486 */
487 drv1 = find_hdev_driver(filename);
488 if (drv1) {
489 return drv1;
490 }
491
492 if (!path_has_protocol(filename)) {
493 return bdrv_find_format("file");
494 }
495 p = strchr(filename, ':');
496 assert(p != NULL);
497 len = p - filename;
498 if (len > sizeof(protocol) - 1)
499 len = sizeof(protocol) - 1;
500 memcpy(protocol, filename, len);
501 protocol[len] = '\0';
502 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
503 if (drv1->protocol_name &&
504 !strcmp(drv1->protocol_name, protocol)) {
505 return drv1;
506 }
507 }
508 return NULL;
509 }
510
511 static int find_image_format(const char *filename, BlockDriver **pdrv)
512 {
513 int ret, score, score_max;
514 BlockDriver *drv1, *drv;
515 uint8_t buf[2048];
516 BlockDriverState *bs;
517
518 ret = bdrv_file_open(&bs, filename, 0);
519 if (ret < 0) {
520 *pdrv = NULL;
521 return ret;
522 }
523
524 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
525 if (bs->sg || !bdrv_is_inserted(bs)) {
526 bdrv_delete(bs);
527 drv = bdrv_find_format("raw");
528 if (!drv) {
529 ret = -ENOENT;
530 }
531 *pdrv = drv;
532 return ret;
533 }
534
535 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
536 bdrv_delete(bs);
537 if (ret < 0) {
538 *pdrv = NULL;
539 return ret;
540 }
541
542 score_max = 0;
543 drv = NULL;
544 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
545 if (drv1->bdrv_probe) {
546 score = drv1->bdrv_probe(buf, ret, filename);
547 if (score > score_max) {
548 score_max = score;
549 drv = drv1;
550 }
551 }
552 }
553 if (!drv) {
554 ret = -ENOENT;
555 }
556 *pdrv = drv;
557 return ret;
558 }
559
560 /**
561 * Set the current 'total_sectors' value
562 */
563 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
564 {
565 BlockDriver *drv = bs->drv;
566
567 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
568 if (bs->sg)
569 return 0;
570
571 /* query actual device if possible, otherwise just trust the hint */
572 if (drv->bdrv_getlength) {
573 int64_t length = drv->bdrv_getlength(bs);
574 if (length < 0) {
575 return length;
576 }
577 hint = length >> BDRV_SECTOR_BITS;
578 }
579
580 bs->total_sectors = hint;
581 return 0;
582 }
583
584 /**
585 * Set open flags for a given cache mode
586 *
587 * Return 0 on success, -1 if the cache mode was invalid.
588 */
589 int bdrv_parse_cache_flags(const char *mode, int *flags)
590 {
591 *flags &= ~BDRV_O_CACHE_MASK;
592
593 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
594 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
595 } else if (!strcmp(mode, "directsync")) {
596 *flags |= BDRV_O_NOCACHE;
597 } else if (!strcmp(mode, "writeback")) {
598 *flags |= BDRV_O_CACHE_WB;
599 } else if (!strcmp(mode, "unsafe")) {
600 *flags |= BDRV_O_CACHE_WB;
601 *flags |= BDRV_O_NO_FLUSH;
602 } else if (!strcmp(mode, "writethrough")) {
603 /* this is the default */
604 } else {
605 return -1;
606 }
607
608 return 0;
609 }
610
611 /**
612 * The copy-on-read flag is actually a reference count so multiple users may
613 * use the feature without worrying about clobbering its previous state.
614 * Copy-on-read stays enabled until all users have called to disable it.
615 */
616 void bdrv_enable_copy_on_read(BlockDriverState *bs)
617 {
618 bs->copy_on_read++;
619 }
620
621 void bdrv_disable_copy_on_read(BlockDriverState *bs)
622 {
623 assert(bs->copy_on_read > 0);
624 bs->copy_on_read--;
625 }
626
627 /*
628 * Common part for opening disk images and files
629 */
630 static int bdrv_open_common(BlockDriverState *bs, const char *filename,
631 int flags, BlockDriver *drv)
632 {
633 int ret, open_flags;
634
635 assert(drv != NULL);
636 assert(bs->file == NULL);
637
638 trace_bdrv_open_common(bs, filename, flags, drv->format_name);
639
640 bs->open_flags = flags;
641 bs->buffer_alignment = 512;
642
643 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
644 if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) {
645 bdrv_enable_copy_on_read(bs);
646 }
647
648 pstrcpy(bs->filename, sizeof(bs->filename), filename);
649
650 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
651 return -ENOTSUP;
652 }
653
654 bs->drv = drv;
655 bs->opaque = g_malloc0(drv->instance_size);
656
657 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
658 open_flags = flags | BDRV_O_CACHE_WB;
659
660 /*
661 * Clear flags that are internal to the block layer before opening the
662 * image.
663 */
664 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
665
666 /*
667 * Snapshots should be writable.
668 */
669 if (bs->is_temporary) {
670 open_flags |= BDRV_O_RDWR;
671 }
672
673 bs->read_only = !(open_flags & BDRV_O_RDWR);
674
675 /* Open the image, either directly or using a protocol */
676 if (drv->bdrv_file_open) {
677 ret = drv->bdrv_file_open(bs, filename, open_flags);
678 } else {
679 ret = bdrv_file_open(&bs->file, filename, open_flags);
680 if (ret >= 0) {
681 ret = drv->bdrv_open(bs, open_flags);
682 }
683 }
684
685 if (ret < 0) {
686 goto free_and_fail;
687 }
688
689 ret = refresh_total_sectors(bs, bs->total_sectors);
690 if (ret < 0) {
691 goto free_and_fail;
692 }
693
694 #ifndef _WIN32
695 if (bs->is_temporary) {
696 unlink(filename);
697 }
698 #endif
699 return 0;
700
701 free_and_fail:
702 if (bs->file) {
703 bdrv_delete(bs->file);
704 bs->file = NULL;
705 }
706 g_free(bs->opaque);
707 bs->opaque = NULL;
708 bs->drv = NULL;
709 return ret;
710 }
711
712 /*
713 * Opens a file using a protocol (file, host_device, nbd, ...)
714 */
715 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
716 {
717 BlockDriverState *bs;
718 BlockDriver *drv;
719 int ret;
720
721 drv = bdrv_find_protocol(filename);
722 if (!drv) {
723 return -ENOENT;
724 }
725
726 bs = bdrv_new("");
727 ret = bdrv_open_common(bs, filename, flags, drv);
728 if (ret < 0) {
729 bdrv_delete(bs);
730 return ret;
731 }
732 bs->growable = 1;
733 *pbs = bs;
734 return 0;
735 }
736
737 /*
738 * Opens a disk image (raw, qcow2, vmdk, ...)
739 */
740 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
741 BlockDriver *drv)
742 {
743 int ret;
744 char tmp_filename[PATH_MAX];
745
746 if (flags & BDRV_O_SNAPSHOT) {
747 BlockDriverState *bs1;
748 int64_t total_size;
749 int is_protocol = 0;
750 BlockDriver *bdrv_qcow2;
751 QEMUOptionParameter *options;
752 char backing_filename[PATH_MAX];
753
754 /* if snapshot, we create a temporary backing file and open it
755 instead of opening 'filename' directly */
756
757 /* if there is a backing file, use it */
758 bs1 = bdrv_new("");
759 ret = bdrv_open(bs1, filename, 0, drv);
760 if (ret < 0) {
761 bdrv_delete(bs1);
762 return ret;
763 }
764 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
765
766 if (bs1->drv && bs1->drv->protocol_name)
767 is_protocol = 1;
768
769 bdrv_delete(bs1);
770
771 ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));
772 if (ret < 0) {
773 return ret;
774 }
775
776 /* Real path is meaningless for protocols */
777 if (is_protocol)
778 snprintf(backing_filename, sizeof(backing_filename),
779 "%s", filename);
780 else if (!realpath(filename, backing_filename))
781 return -errno;
782
783 bdrv_qcow2 = bdrv_find_format("qcow2");
784 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
785
786 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
787 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
788 if (drv) {
789 set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
790 drv->format_name);
791 }
792
793 ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
794 free_option_parameters(options);
795 if (ret < 0) {
796 return ret;
797 }
798
799 filename = tmp_filename;
800 drv = bdrv_qcow2;
801 bs->is_temporary = 1;
802 }
803
804 /* Find the right image format driver */
805 if (!drv) {
806 ret = find_image_format(filename, &drv);
807 }
808
809 if (!drv) {
810 goto unlink_and_fail;
811 }
812
813 if (flags & BDRV_O_RDWR) {
814 flags |= BDRV_O_ALLOW_RDWR;
815 }
816
817 /* Open the image */
818 ret = bdrv_open_common(bs, filename, flags, drv);
819 if (ret < 0) {
820 goto unlink_and_fail;
821 }
822
823 /* If there is a backing file, use it */
824 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
825 char backing_filename[PATH_MAX];
826 int back_flags;
827 BlockDriver *back_drv = NULL;
828
829 bs->backing_hd = bdrv_new("");
830 bdrv_get_full_backing_filename(bs, backing_filename,
831 sizeof(backing_filename));
832
833 if (bs->backing_format[0] != '\0') {
834 back_drv = bdrv_find_format(bs->backing_format);
835 }
836
837 /* backing files always opened read-only */
838 back_flags =
839 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
840
841 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
842 if (ret < 0) {
843 bdrv_close(bs);
844 return ret;
845 }
846 }
847
848 if (!bdrv_key_required(bs)) {
849 bdrv_dev_change_media_cb(bs, true);
850 }
851
852 /* throttling disk I/O limits */
853 if (bs->io_limits_enabled) {
854 bdrv_io_limits_enable(bs);
855 }
856
857 return 0;
858
859 unlink_and_fail:
860 if (bs->is_temporary) {
861 unlink(filename);
862 }
863 return ret;
864 }
865
866 typedef struct BlockReopenQueueEntry {
867 bool prepared;
868 BDRVReopenState state;
869 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
870 } BlockReopenQueueEntry;
871
872 /*
873 * Adds a BlockDriverState to a simple queue for an atomic, transactional
874 * reopen of multiple devices.
875 *
876 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
877 * already performed, or alternatively may be NULL a new BlockReopenQueue will
878 * be created and initialized. This newly created BlockReopenQueue should be
879 * passed back in for subsequent calls that are intended to be of the same
880 * atomic 'set'.
881 *
882 * bs is the BlockDriverState to add to the reopen queue.
883 *
884 * flags contains the open flags for the associated bs
885 *
886 * returns a pointer to bs_queue, which is either the newly allocated
887 * bs_queue, or the existing bs_queue being used.
888 *
889 */
890 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
891 BlockDriverState *bs, int flags)
892 {
893 assert(bs != NULL);
894
895 BlockReopenQueueEntry *bs_entry;
896 if (bs_queue == NULL) {
897 bs_queue = g_new0(BlockReopenQueue, 1);
898 QSIMPLEQ_INIT(bs_queue);
899 }
900
901 if (bs->file) {
902 bdrv_reopen_queue(bs_queue, bs->file, flags);
903 }
904
905 bs_entry = g_new0(BlockReopenQueueEntry, 1);
906 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
907
908 bs_entry->state.bs = bs;
909 bs_entry->state.flags = flags;
910
911 return bs_queue;
912 }
913
914 /*
915 * Reopen multiple BlockDriverStates atomically & transactionally.
916 *
917 * The queue passed in (bs_queue) must have been built up previous
918 * via bdrv_reopen_queue().
919 *
920 * Reopens all BDS specified in the queue, with the appropriate
921 * flags. All devices are prepared for reopen, and failure of any
922 * device will cause all device changes to be abandonded, and intermediate
923 * data cleaned up.
924 *
925 * If all devices prepare successfully, then the changes are committed
926 * to all devices.
927 *
928 */
929 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
930 {
931 int ret = -1;
932 BlockReopenQueueEntry *bs_entry, *next;
933 Error *local_err = NULL;
934
935 assert(bs_queue != NULL);
936
937 bdrv_drain_all();
938
939 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
940 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
941 error_propagate(errp, local_err);
942 goto cleanup;
943 }
944 bs_entry->prepared = true;
945 }
946
947 /* If we reach this point, we have success and just need to apply the
948 * changes
949 */
950 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
951 bdrv_reopen_commit(&bs_entry->state);
952 }
953
954 ret = 0;
955
956 cleanup:
957 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
958 if (ret && bs_entry->prepared) {
959 bdrv_reopen_abort(&bs_entry->state);
960 }
961 g_free(bs_entry);
962 }
963 g_free(bs_queue);
964 return ret;
965 }
966
967
968 /* Reopen a single BlockDriverState with the specified flags. */
969 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
970 {
971 int ret = -1;
972 Error *local_err = NULL;
973 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
974
975 ret = bdrv_reopen_multiple(queue, &local_err);
976 if (local_err != NULL) {
977 error_propagate(errp, local_err);
978 }
979 return ret;
980 }
981
982
983 /*
984 * Prepares a BlockDriverState for reopen. All changes are staged in the
985 * 'opaque' field of the BDRVReopenState, which is used and allocated by
986 * the block driver layer .bdrv_reopen_prepare()
987 *
988 * bs is the BlockDriverState to reopen
989 * flags are the new open flags
990 * queue is the reopen queue
991 *
992 * Returns 0 on success, non-zero on error. On error errp will be set
993 * as well.
994 *
995 * On failure, bdrv_reopen_abort() will be called to clean up any data.
996 * It is the responsibility of the caller to then call the abort() or
997 * commit() for any other BDS that have been left in a prepare() state
998 *
999 */
1000 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1001 Error **errp)
1002 {
1003 int ret = -1;
1004 Error *local_err = NULL;
1005 BlockDriver *drv;
1006
1007 assert(reopen_state != NULL);
1008 assert(reopen_state->bs->drv != NULL);
1009 drv = reopen_state->bs->drv;
1010
1011 /* if we are to stay read-only, do not allow permission change
1012 * to r/w */
1013 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1014 reopen_state->flags & BDRV_O_RDWR) {
1015 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1016 reopen_state->bs->device_name);
1017 goto error;
1018 }
1019
1020
1021 ret = bdrv_flush(reopen_state->bs);
1022 if (ret) {
1023 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1024 strerror(-ret));
1025 goto error;
1026 }
1027
1028 if (drv->bdrv_reopen_prepare) {
1029 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1030 if (ret) {
1031 if (local_err != NULL) {
1032 error_propagate(errp, local_err);
1033 } else {
1034 error_set(errp, QERR_OPEN_FILE_FAILED,
1035 reopen_state->bs->filename);
1036 }
1037 goto error;
1038 }
1039 } else {
1040 /* It is currently mandatory to have a bdrv_reopen_prepare()
1041 * handler for each supported drv. */
1042 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1043 drv->format_name, reopen_state->bs->device_name,
1044 "reopening of file");
1045 ret = -1;
1046 goto error;
1047 }
1048
1049 ret = 0;
1050
1051 error:
1052 return ret;
1053 }
1054
1055 /*
1056 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1057 * makes them final by swapping the staging BlockDriverState contents into
1058 * the active BlockDriverState contents.
1059 */
1060 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1061 {
1062 BlockDriver *drv;
1063
1064 assert(reopen_state != NULL);
1065 drv = reopen_state->bs->drv;
1066 assert(drv != NULL);
1067
1068 /* If there are any driver level actions to take */
1069 if (drv->bdrv_reopen_commit) {
1070 drv->bdrv_reopen_commit(reopen_state);
1071 }
1072
1073 /* set BDS specific flags now */
1074 reopen_state->bs->open_flags = reopen_state->flags;
1075 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1076 BDRV_O_CACHE_WB);
1077 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1078 }
1079
1080 /*
1081 * Abort the reopen, and delete and free the staged changes in
1082 * reopen_state
1083 */
1084 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1085 {
1086 BlockDriver *drv;
1087
1088 assert(reopen_state != NULL);
1089 drv = reopen_state->bs->drv;
1090 assert(drv != NULL);
1091
1092 if (drv->bdrv_reopen_abort) {
1093 drv->bdrv_reopen_abort(reopen_state);
1094 }
1095 }
1096
1097
1098 void bdrv_close(BlockDriverState *bs)
1099 {
1100 bdrv_flush(bs);
1101 if (bs->drv) {
1102 if (bs->job) {
1103 block_job_cancel_sync(bs->job);
1104 }
1105 bdrv_drain_all();
1106
1107 if (bs == bs_snapshots) {
1108 bs_snapshots = NULL;
1109 }
1110 if (bs->backing_hd) {
1111 bdrv_delete(bs->backing_hd);
1112 bs->backing_hd = NULL;
1113 }
1114 bs->drv->bdrv_close(bs);
1115 g_free(bs->opaque);
1116 #ifdef _WIN32
1117 if (bs->is_temporary) {
1118 unlink(bs->filename);
1119 }
1120 #endif
1121 bs->opaque = NULL;
1122 bs->drv = NULL;
1123 bs->copy_on_read = 0;
1124 bs->backing_file[0] = '\0';
1125 bs->backing_format[0] = '\0';
1126 bs->total_sectors = 0;
1127 bs->encrypted = 0;
1128 bs->valid_key = 0;
1129 bs->sg = 0;
1130 bs->growable = 0;
1131
1132 if (bs->file != NULL) {
1133 bdrv_delete(bs->file);
1134 bs->file = NULL;
1135 }
1136 }
1137
1138 bdrv_dev_change_media_cb(bs, false);
1139
1140 /*throttling disk I/O limits*/
1141 if (bs->io_limits_enabled) {
1142 bdrv_io_limits_disable(bs);
1143 }
1144 }
1145
1146 void bdrv_close_all(void)
1147 {
1148 BlockDriverState *bs;
1149
1150 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1151 bdrv_close(bs);
1152 }
1153 }
1154
1155 /*
1156 * Wait for pending requests to complete across all BlockDriverStates
1157 *
1158 * This function does not flush data to disk, use bdrv_flush_all() for that
1159 * after calling this function.
1160 *
1161 * Note that completion of an asynchronous I/O operation can trigger any
1162 * number of other I/O operations on other devices---for example a coroutine
1163 * can be arbitrarily complex and a constant flow of I/O can come until the
1164 * coroutine is complete. Because of this, it is not possible to have a
1165 * function to drain a single device's I/O queue.
1166 */
1167 void bdrv_drain_all(void)
1168 {
1169 BlockDriverState *bs;
1170 bool busy;
1171
1172 do {
1173 busy = qemu_aio_wait();
1174
1175 /* FIXME: We do not have timer support here, so this is effectively
1176 * a busy wait.
1177 */
1178 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1179 if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
1180 qemu_co_queue_restart_all(&bs->throttled_reqs);
1181 busy = true;
1182 }
1183 }
1184 } while (busy);
1185
1186 /* If requests are still pending there is a bug somewhere */
1187 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1188 assert(QLIST_EMPTY(&bs->tracked_requests));
1189 assert(qemu_co_queue_empty(&bs->throttled_reqs));
1190 }
1191 }
1192
1193 /* make a BlockDriverState anonymous by removing from bdrv_state list.
1194 Also, NULL terminate the device_name to prevent double remove */
1195 void bdrv_make_anon(BlockDriverState *bs)
1196 {
1197 if (bs->device_name[0] != '\0') {
1198 QTAILQ_REMOVE(&bdrv_states, bs, list);
1199 }
1200 bs->device_name[0] = '\0';
1201 }
1202
1203 static void bdrv_rebind(BlockDriverState *bs)
1204 {
1205 if (bs->drv && bs->drv->bdrv_rebind) {
1206 bs->drv->bdrv_rebind(bs);
1207 }
1208 }
1209
1210 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1211 BlockDriverState *bs_src)
1212 {
1213 /* move some fields that need to stay attached to the device */
1214 bs_dest->open_flags = bs_src->open_flags;
1215
1216 /* dev info */
1217 bs_dest->dev_ops = bs_src->dev_ops;
1218 bs_dest->dev_opaque = bs_src->dev_opaque;
1219 bs_dest->dev = bs_src->dev;
1220 bs_dest->buffer_alignment = bs_src->buffer_alignment;
1221 bs_dest->copy_on_read = bs_src->copy_on_read;
1222
1223 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1224
1225 /* i/o timing parameters */
1226 bs_dest->slice_time = bs_src->slice_time;
1227 bs_dest->slice_start = bs_src->slice_start;
1228 bs_dest->slice_end = bs_src->slice_end;
1229 bs_dest->io_limits = bs_src->io_limits;
1230 bs_dest->io_base = bs_src->io_base;
1231 bs_dest->throttled_reqs = bs_src->throttled_reqs;
1232 bs_dest->block_timer = bs_src->block_timer;
1233 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1234
1235 /* r/w error */
1236 bs_dest->on_read_error = bs_src->on_read_error;
1237 bs_dest->on_write_error = bs_src->on_write_error;
1238
1239 /* i/o status */
1240 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1241 bs_dest->iostatus = bs_src->iostatus;
1242
1243 /* dirty bitmap */
1244 bs_dest->dirty_count = bs_src->dirty_count;
1245 bs_dest->dirty_bitmap = bs_src->dirty_bitmap;
1246
1247 /* job */
1248 bs_dest->in_use = bs_src->in_use;
1249 bs_dest->job = bs_src->job;
1250
1251 /* keep the same entry in bdrv_states */
1252 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1253 bs_src->device_name);
1254 bs_dest->list = bs_src->list;
1255 }
1256
1257 /*
1258 * Swap bs contents for two image chains while they are live,
1259 * while keeping required fields on the BlockDriverState that is
1260 * actually attached to a device.
1261 *
1262 * This will modify the BlockDriverState fields, and swap contents
1263 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1264 *
1265 * bs_new is required to be anonymous.
1266 *
1267 * This function does not create any image files.
1268 */
1269 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
1270 {
1271 BlockDriverState tmp;
1272
1273 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1274 assert(bs_new->device_name[0] == '\0');
1275 assert(bs_new->dirty_bitmap == NULL);
1276 assert(bs_new->job == NULL);
1277 assert(bs_new->dev == NULL);
1278 assert(bs_new->in_use == 0);
1279 assert(bs_new->io_limits_enabled == false);
1280 assert(bs_new->block_timer == NULL);
1281
1282 tmp = *bs_new;
1283 *bs_new = *bs_old;
1284 *bs_old = tmp;
1285
1286 /* there are some fields that should not be swapped, move them back */
1287 bdrv_move_feature_fields(&tmp, bs_old);
1288 bdrv_move_feature_fields(bs_old, bs_new);
1289 bdrv_move_feature_fields(bs_new, &tmp);
1290
1291 /* bs_new shouldn't be in bdrv_states even after the swap! */
1292 assert(bs_new->device_name[0] == '\0');
1293
1294 /* Check a few fields that should remain attached to the device */
1295 assert(bs_new->dev == NULL);
1296 assert(bs_new->job == NULL);
1297 assert(bs_new->in_use == 0);
1298 assert(bs_new->io_limits_enabled == false);
1299 assert(bs_new->block_timer == NULL);
1300
1301 bdrv_rebind(bs_new);
1302 bdrv_rebind(bs_old);
1303 }
1304
1305 /*
1306 * Add new bs contents at the top of an image chain while the chain is
1307 * live, while keeping required fields on the top layer.
1308 *
1309 * This will modify the BlockDriverState fields, and swap contents
1310 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1311 *
1312 * bs_new is required to be anonymous.
1313 *
1314 * This function does not create any image files.
1315 */
1316 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
1317 {
1318 bdrv_swap(bs_new, bs_top);
1319
1320 /* The contents of 'tmp' will become bs_top, as we are
1321 * swapping bs_new and bs_top contents. */
1322 bs_top->backing_hd = bs_new;
1323 bs_top->open_flags &= ~BDRV_O_NO_BACKING;
1324 pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
1325 bs_new->filename);
1326 pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
1327 bs_new->drv ? bs_new->drv->format_name : "");
1328 }
1329
1330 void bdrv_delete(BlockDriverState *bs)
1331 {
1332 assert(!bs->dev);
1333 assert(!bs->job);
1334 assert(!bs->in_use);
1335
1336 /* remove from list, if necessary */
1337 bdrv_make_anon(bs);
1338
1339 bdrv_close(bs);
1340
1341 assert(bs != bs_snapshots);
1342 g_free(bs);
1343 }
1344
1345 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
1346 /* TODO change to DeviceState *dev when all users are qdevified */
1347 {
1348 if (bs->dev) {
1349 return -EBUSY;
1350 }
1351 bs->dev = dev;
1352 bdrv_iostatus_reset(bs);
1353 return 0;
1354 }
1355
1356 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1357 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
1358 {
1359 if (bdrv_attach_dev(bs, dev) < 0) {
1360 abort();
1361 }
1362 }
1363
1364 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
1365 /* TODO change to DeviceState *dev when all users are qdevified */
1366 {
1367 assert(bs->dev == dev);
1368 bs->dev = NULL;
1369 bs->dev_ops = NULL;
1370 bs->dev_opaque = NULL;
1371 bs->buffer_alignment = 512;
1372 }
1373
1374 /* TODO change to return DeviceState * when all users are qdevified */
1375 void *bdrv_get_attached_dev(BlockDriverState *bs)
1376 {
1377 return bs->dev;
1378 }
1379
1380 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
1381 void *opaque)
1382 {
1383 bs->dev_ops = ops;
1384 bs->dev_opaque = opaque;
1385 if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) {
1386 bs_snapshots = NULL;
1387 }
1388 }
1389
1390 void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
1391 enum MonitorEvent ev,
1392 BlockErrorAction action, bool is_read)
1393 {
1394 QObject *data;
1395 const char *action_str;
1396
1397 switch (action) {
1398 case BDRV_ACTION_REPORT:
1399 action_str = "report";
1400 break;
1401 case BDRV_ACTION_IGNORE:
1402 action_str = "ignore";
1403 break;
1404 case BDRV_ACTION_STOP:
1405 action_str = "stop";
1406 break;
1407 default:
1408 abort();
1409 }
1410
1411 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1412 bdrv->device_name,
1413 action_str,
1414 is_read ? "read" : "write");
1415 monitor_protocol_event(ev, data);
1416
1417 qobject_decref(data);
1418 }
1419
1420 static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
1421 {
1422 QObject *data;
1423
1424 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1425 bdrv_get_device_name(bs), ejected);
1426 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
1427
1428 qobject_decref(data);
1429 }
1430
1431 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
1432 {
1433 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
1434 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
1435 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
1436 if (tray_was_closed) {
1437 /* tray open */
1438 bdrv_emit_qmp_eject_event(bs, true);
1439 }
1440 if (load) {
1441 /* tray close */
1442 bdrv_emit_qmp_eject_event(bs, false);
1443 }
1444 }
1445 }
1446
1447 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
1448 {
1449 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
1450 }
1451
1452 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
1453 {
1454 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
1455 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
1456 }
1457 }
1458
1459 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
1460 {
1461 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
1462 return bs->dev_ops->is_tray_open(bs->dev_opaque);
1463 }
1464 return false;
1465 }
1466
1467 static void bdrv_dev_resize_cb(BlockDriverState *bs)
1468 {
1469 if (bs->dev_ops && bs->dev_ops->resize_cb) {
1470 bs->dev_ops->resize_cb(bs->dev_opaque);
1471 }
1472 }
1473
1474 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
1475 {
1476 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
1477 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
1478 }
1479 return false;
1480 }
1481
1482 /*
1483 * Run consistency checks on an image
1484 *
1485 * Returns 0 if the check could be completed (it doesn't mean that the image is
1486 * free of errors) or -errno when an internal error occurred. The results of the
1487 * check are stored in res.
1488 */
1489 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
1490 {
1491 if (bs->drv->bdrv_check == NULL) {
1492 return -ENOTSUP;
1493 }
1494
1495 memset(res, 0, sizeof(*res));
1496 return bs->drv->bdrv_check(bs, res, fix);
1497 }
1498
1499 #define COMMIT_BUF_SECTORS 2048
1500
1501 /* commit COW file into the raw image */
1502 int bdrv_commit(BlockDriverState *bs)
1503 {
1504 BlockDriver *drv = bs->drv;
1505 int64_t sector, total_sectors;
1506 int n, ro, open_flags;
1507 int ret = 0;
1508 uint8_t *buf;
1509 char filename[1024];
1510
1511 if (!drv)
1512 return -ENOMEDIUM;
1513
1514 if (!bs->backing_hd) {
1515 return -ENOTSUP;
1516 }
1517
1518 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
1519 return -EBUSY;
1520 }
1521
1522 ro = bs->backing_hd->read_only;
1523 strncpy(filename, bs->backing_hd->filename, sizeof(filename));
1524 open_flags = bs->backing_hd->open_flags;
1525
1526 if (ro) {
1527 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
1528 return -EACCES;
1529 }
1530 }
1531
1532 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
1533 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
1534
1535 for (sector = 0; sector < total_sectors; sector += n) {
1536 if (bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
1537
1538 if (bdrv_read(bs, sector, buf, n) != 0) {
1539 ret = -EIO;
1540 goto ro_cleanup;
1541 }
1542
1543 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
1544 ret = -EIO;
1545 goto ro_cleanup;
1546 }
1547 }
1548 }
1549
1550 if (drv->bdrv_make_empty) {
1551 ret = drv->bdrv_make_empty(bs);
1552 bdrv_flush(bs);
1553 }
1554
1555 /*
1556 * Make sure all data we wrote to the backing device is actually
1557 * stable on disk.
1558 */
1559 if (bs->backing_hd)
1560 bdrv_flush(bs->backing_hd);
1561
1562 ro_cleanup:
1563 g_free(buf);
1564
1565 if (ro) {
1566 /* ignoring error return here */
1567 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
1568 }
1569
1570 return ret;
1571 }
1572
1573 int bdrv_commit_all(void)
1574 {
1575 BlockDriverState *bs;
1576
1577 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1578 int ret = bdrv_commit(bs);
1579 if (ret < 0) {
1580 return ret;
1581 }
1582 }
1583 return 0;
1584 }
1585
1586 struct BdrvTrackedRequest {
1587 BlockDriverState *bs;
1588 int64_t sector_num;
1589 int nb_sectors;
1590 bool is_write;
1591 QLIST_ENTRY(BdrvTrackedRequest) list;
1592 Coroutine *co; /* owner, used for deadlock detection */
1593 CoQueue wait_queue; /* coroutines blocked on this request */
1594 };
1595
1596 /**
1597 * Remove an active request from the tracked requests list
1598 *
1599 * This function should be called when a tracked request is completing.
1600 */
1601 static void tracked_request_end(BdrvTrackedRequest *req)
1602 {
1603 QLIST_REMOVE(req, list);
1604 qemu_co_queue_restart_all(&req->wait_queue);
1605 }
1606
1607 /**
1608 * Add an active request to the tracked requests list
1609 */
1610 static void tracked_request_begin(BdrvTrackedRequest *req,
1611 BlockDriverState *bs,
1612 int64_t sector_num,
1613 int nb_sectors, bool is_write)
1614 {
1615 *req = (BdrvTrackedRequest){
1616 .bs = bs,
1617 .sector_num = sector_num,
1618 .nb_sectors = nb_sectors,
1619 .is_write = is_write,
1620 .co = qemu_coroutine_self(),
1621 };
1622
1623 qemu_co_queue_init(&req->wait_queue);
1624
1625 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
1626 }
1627
1628 /**
1629 * Round a region to cluster boundaries
1630 */
1631 static void round_to_clusters(BlockDriverState *bs,
1632 int64_t sector_num, int nb_sectors,
1633 int64_t *cluster_sector_num,
1634 int *cluster_nb_sectors)
1635 {
1636 BlockDriverInfo bdi;
1637
1638 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
1639 *cluster_sector_num = sector_num;
1640 *cluster_nb_sectors = nb_sectors;
1641 } else {
1642 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
1643 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
1644 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
1645 nb_sectors, c);
1646 }
1647 }
1648
1649 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
1650 int64_t sector_num, int nb_sectors) {
1651 /* aaaa bbbb */
1652 if (sector_num >= req->sector_num + req->nb_sectors) {
1653 return false;
1654 }
1655 /* bbbb aaaa */
1656 if (req->sector_num >= sector_num + nb_sectors) {
1657 return false;
1658 }
1659 return true;
1660 }
1661
1662 static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
1663 int64_t sector_num, int nb_sectors)
1664 {
1665 BdrvTrackedRequest *req;
1666 int64_t cluster_sector_num;
1667 int cluster_nb_sectors;
1668 bool retry;
1669
1670 /* If we touch the same cluster it counts as an overlap. This guarantees
1671 * that allocating writes will be serialized and not race with each other
1672 * for the same cluster. For example, in copy-on-read it ensures that the
1673 * CoR read and write operations are atomic and guest writes cannot
1674 * interleave between them.
1675 */
1676 round_to_clusters(bs, sector_num, nb_sectors,
1677 &cluster_sector_num, &cluster_nb_sectors);
1678
1679 do {
1680 retry = false;
1681 QLIST_FOREACH(req, &bs->tracked_requests, list) {
1682 if (tracked_request_overlaps(req, cluster_sector_num,
1683 cluster_nb_sectors)) {
1684 /* Hitting this means there was a reentrant request, for
1685 * example, a block driver issuing nested requests. This must
1686 * never happen since it means deadlock.
1687 */
1688 assert(qemu_coroutine_self() != req->co);
1689
1690 qemu_co_queue_wait(&req->wait_queue);
1691 retry = true;
1692 break;
1693 }
1694 }
1695 } while (retry);
1696 }
1697
1698 /*
1699 * Return values:
1700 * 0 - success
1701 * -EINVAL - backing format specified, but no file
1702 * -ENOSPC - can't update the backing file because no space is left in the
1703 * image file header
1704 * -ENOTSUP - format driver doesn't support changing the backing file
1705 */
1706 int bdrv_change_backing_file(BlockDriverState *bs,
1707 const char *backing_file, const char *backing_fmt)
1708 {
1709 BlockDriver *drv = bs->drv;
1710 int ret;
1711
1712 /* Backing file format doesn't make sense without a backing file */
1713 if (backing_fmt && !backing_file) {
1714 return -EINVAL;
1715 }
1716
1717 if (drv->bdrv_change_backing_file != NULL) {
1718 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
1719 } else {
1720 ret = -ENOTSUP;
1721 }
1722
1723 if (ret == 0) {
1724 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
1725 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
1726 }
1727 return ret;
1728 }
1729
1730 /*
1731 * Finds the image layer in the chain that has 'bs' as its backing file.
1732 *
1733 * active is the current topmost image.
1734 *
1735 * Returns NULL if bs is not found in active's image chain,
1736 * or if active == bs.
1737 */
1738 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
1739 BlockDriverState *bs)
1740 {
1741 BlockDriverState *overlay = NULL;
1742 BlockDriverState *intermediate;
1743
1744 assert(active != NULL);
1745 assert(bs != NULL);
1746
1747 /* if bs is the same as active, then by definition it has no overlay
1748 */
1749 if (active == bs) {
1750 return NULL;
1751 }
1752
1753 intermediate = active;
1754 while (intermediate->backing_hd) {
1755 if (intermediate->backing_hd == bs) {
1756 overlay = intermediate;
1757 break;
1758 }
1759 intermediate = intermediate->backing_hd;
1760 }
1761
1762 return overlay;
1763 }
1764
1765 typedef struct BlkIntermediateStates {
1766 BlockDriverState *bs;
1767 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
1768 } BlkIntermediateStates;
1769
1770
1771 /*
1772 * Drops images above 'base' up to and including 'top', and sets the image
1773 * above 'top' to have base as its backing file.
1774 *
1775 * Requires that the overlay to 'top' is opened r/w, so that the backing file
1776 * information in 'bs' can be properly updated.
1777 *
1778 * E.g., this will convert the following chain:
1779 * bottom <- base <- intermediate <- top <- active
1780 *
1781 * to
1782 *
1783 * bottom <- base <- active
1784 *
1785 * It is allowed for bottom==base, in which case it converts:
1786 *
1787 * base <- intermediate <- top <- active
1788 *
1789 * to
1790 *
1791 * base <- active
1792 *
1793 * Error conditions:
1794 * if active == top, that is considered an error
1795 *
1796 */
1797 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
1798 BlockDriverState *base)
1799 {
1800 BlockDriverState *intermediate;
1801 BlockDriverState *base_bs = NULL;
1802 BlockDriverState *new_top_bs = NULL;
1803 BlkIntermediateStates *intermediate_state, *next;
1804 int ret = -EIO;
1805
1806 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
1807 QSIMPLEQ_INIT(&states_to_delete);
1808
1809 if (!top->drv || !base->drv) {
1810 goto exit;
1811 }
1812
1813 new_top_bs = bdrv_find_overlay(active, top);
1814
1815 if (new_top_bs == NULL) {
1816 /* we could not find the image above 'top', this is an error */
1817 goto exit;
1818 }
1819
1820 /* special case of new_top_bs->backing_hd already pointing to base - nothing
1821 * to do, no intermediate images */
1822 if (new_top_bs->backing_hd == base) {
1823 ret = 0;
1824 goto exit;
1825 }
1826
1827 intermediate = top;
1828
1829 /* now we will go down through the list, and add each BDS we find
1830 * into our deletion queue, until we hit the 'base'
1831 */
1832 while (intermediate) {
1833 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
1834 intermediate_state->bs = intermediate;
1835 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
1836
1837 if (intermediate->backing_hd == base) {
1838 base_bs = intermediate->backing_hd;
1839 break;
1840 }
1841 intermediate = intermediate->backing_hd;
1842 }
1843 if (base_bs == NULL) {
1844 /* something went wrong, we did not end at the base. safely
1845 * unravel everything, and exit with error */
1846 goto exit;
1847 }
1848
1849 /* success - we can delete the intermediate states, and link top->base */
1850 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
1851 base_bs->drv ? base_bs->drv->format_name : "");
1852 if (ret) {
1853 goto exit;
1854 }
1855 new_top_bs->backing_hd = base_bs;
1856
1857
1858 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
1859 /* so that bdrv_close() does not recursively close the chain */
1860 intermediate_state->bs->backing_hd = NULL;
1861 bdrv_delete(intermediate_state->bs);
1862 }
1863 ret = 0;
1864
1865 exit:
1866 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
1867 g_free(intermediate_state);
1868 }
1869 return ret;
1870 }
1871
1872
1873 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
1874 size_t size)
1875 {
1876 int64_t len;
1877
1878 if (!bdrv_is_inserted(bs))
1879 return -ENOMEDIUM;
1880
1881 if (bs->growable)
1882 return 0;
1883
1884 len = bdrv_getlength(bs);
1885
1886 if (offset < 0)
1887 return -EIO;
1888
1889 if ((offset > len) || (len - offset < size))
1890 return -EIO;
1891
1892 return 0;
1893 }
1894
1895 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
1896 int nb_sectors)
1897 {
1898 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
1899 nb_sectors * BDRV_SECTOR_SIZE);
1900 }
1901
1902 typedef struct RwCo {
1903 BlockDriverState *bs;
1904 int64_t sector_num;
1905 int nb_sectors;
1906 QEMUIOVector *qiov;
1907 bool is_write;
1908 int ret;
1909 } RwCo;
1910
1911 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
1912 {
1913 RwCo *rwco = opaque;
1914
1915 if (!rwco->is_write) {
1916 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
1917 rwco->nb_sectors, rwco->qiov, 0);
1918 } else {
1919 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
1920 rwco->nb_sectors, rwco->qiov, 0);
1921 }
1922 }
1923
1924 /*
1925 * Process a synchronous request using coroutines
1926 */
1927 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
1928 int nb_sectors, bool is_write)
1929 {
1930 QEMUIOVector qiov;
1931 struct iovec iov = {
1932 .iov_base = (void *)buf,
1933 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
1934 };
1935 Coroutine *co;
1936 RwCo rwco = {
1937 .bs = bs,
1938 .sector_num = sector_num,
1939 .nb_sectors = nb_sectors,
1940 .qiov = &qiov,
1941 .is_write = is_write,
1942 .ret = NOT_DONE,
1943 };
1944
1945 qemu_iovec_init_external(&qiov, &iov, 1);
1946
1947 /**
1948 * In sync call context, when the vcpu is blocked, this throttling timer
1949 * will not fire; so the I/O throttling function has to be disabled here
1950 * if it has been enabled.
1951 */
1952 if (bs->io_limits_enabled) {
1953 fprintf(stderr, "Disabling I/O throttling on '%s' due "
1954 "to synchronous I/O.\n", bdrv_get_device_name(bs));
1955 bdrv_io_limits_disable(bs);
1956 }
1957
1958 if (qemu_in_coroutine()) {
1959 /* Fast-path if already in coroutine context */
1960 bdrv_rw_co_entry(&rwco);
1961 } else {
1962 co = qemu_coroutine_create(bdrv_rw_co_entry);
1963 qemu_coroutine_enter(co, &rwco);
1964 while (rwco.ret == NOT_DONE) {
1965 qemu_aio_wait();
1966 }
1967 }
1968 return rwco.ret;
1969 }
1970
1971 /* return < 0 if error. See bdrv_write() for the return codes */
1972 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
1973 uint8_t *buf, int nb_sectors)
1974 {
1975 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false);
1976 }
1977
1978 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
1979 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
1980 uint8_t *buf, int nb_sectors)
1981 {
1982 bool enabled;
1983 int ret;
1984
1985 enabled = bs->io_limits_enabled;
1986 bs->io_limits_enabled = false;
1987 ret = bdrv_read(bs, 0, buf, 1);
1988 bs->io_limits_enabled = enabled;
1989 return ret;
1990 }
1991
1992 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
1993
1994 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
1995 int nb_sectors, int dirty)
1996 {
1997 int64_t start, end;
1998 unsigned long val, idx, bit;
1999
2000 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
2001 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
2002
2003 for (; start <= end; start++) {
2004 idx = start / BITS_PER_LONG;
2005 bit = start % BITS_PER_LONG;
2006 val = bs->dirty_bitmap[idx];
2007 if (dirty) {
2008 if (!(val & (1UL << bit))) {
2009 bs->dirty_count++;
2010 val |= 1UL << bit;
2011 }
2012 } else {
2013 if (val & (1UL << bit)) {
2014 bs->dirty_count--;
2015 val &= ~(1UL << bit);
2016 }
2017 }
2018 bs->dirty_bitmap[idx] = val;
2019 }
2020 }
2021
2022 /* Return < 0 if error. Important errors are:
2023 -EIO generic I/O error (may happen for all errors)
2024 -ENOMEDIUM No media inserted.
2025 -EINVAL Invalid sector number or nb_sectors
2026 -EACCES Trying to write a read-only device
2027 */
2028 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2029 const uint8_t *buf, int nb_sectors)
2030 {
2031 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
2032 }
2033
2034 int bdrv_pread(BlockDriverState *bs, int64_t offset,
2035 void *buf, int count1)
2036 {
2037 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
2038 int len, nb_sectors, count;
2039 int64_t sector_num;
2040 int ret;
2041
2042 count = count1;
2043 /* first read to align to sector start */
2044 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
2045 if (len > count)
2046 len = count;
2047 sector_num = offset >> BDRV_SECTOR_BITS;
2048 if (len > 0) {
2049 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2050 return ret;
2051 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
2052 count -= len;
2053 if (count == 0)
2054 return count1;
2055 sector_num++;
2056 buf += len;
2057 }
2058
2059 /* read the sectors "in place" */
2060 nb_sectors = count >> BDRV_SECTOR_BITS;
2061 if (nb_sectors > 0) {
2062 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
2063 return ret;
2064 sector_num += nb_sectors;
2065 len = nb_sectors << BDRV_SECTOR_BITS;
2066 buf += len;
2067 count -= len;
2068 }
2069
2070 /* add data from the last sector */
2071 if (count > 0) {
2072 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2073 return ret;
2074 memcpy(buf, tmp_buf, count);
2075 }
2076 return count1;
2077 }
2078
2079 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2080 const void *buf, int count1)
2081 {
2082 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
2083 int len, nb_sectors, count;
2084 int64_t sector_num;
2085 int ret;
2086
2087 count = count1;
2088 /* first write to align to sector start */
2089 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
2090 if (len > count)
2091 len = count;
2092 sector_num = offset >> BDRV_SECTOR_BITS;
2093 if (len > 0) {
2094 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2095 return ret;
2096 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
2097 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2098 return ret;
2099 count -= len;
2100 if (count == 0)
2101 return count1;
2102 sector_num++;
2103 buf += len;
2104 }
2105
2106 /* write the sectors "in place" */
2107 nb_sectors = count >> BDRV_SECTOR_BITS;
2108 if (nb_sectors > 0) {
2109 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
2110 return ret;
2111 sector_num += nb_sectors;
2112 len = nb_sectors << BDRV_SECTOR_BITS;
2113 buf += len;
2114 count -= len;
2115 }
2116
2117 /* add data from the last sector */
2118 if (count > 0) {
2119 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2120 return ret;
2121 memcpy(tmp_buf, buf, count);
2122 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2123 return ret;
2124 }
2125 return count1;
2126 }
2127
2128 /*
2129 * Writes to the file and ensures that no writes are reordered across this
2130 * request (acts as a barrier)
2131 *
2132 * Returns 0 on success, -errno in error cases.
2133 */
2134 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2135 const void *buf, int count)
2136 {
2137 int ret;
2138
2139 ret = bdrv_pwrite(bs, offset, buf, count);
2140 if (ret < 0) {
2141 return ret;
2142 }
2143
2144 /* No flush needed for cache modes that already do it */
2145 if (bs->enable_write_cache) {
2146 bdrv_flush(bs);
2147 }
2148
2149 return 0;
2150 }
2151
2152 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2153 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2154 {
2155 /* Perform I/O through a temporary buffer so that users who scribble over
2156 * their read buffer while the operation is in progress do not end up
2157 * modifying the image file. This is critical for zero-copy guest I/O
2158 * where anything might happen inside guest memory.
2159 */
2160 void *bounce_buffer;
2161
2162 BlockDriver *drv = bs->drv;
2163 struct iovec iov;
2164 QEMUIOVector bounce_qiov;
2165 int64_t cluster_sector_num;
2166 int cluster_nb_sectors;
2167 size_t skip_bytes;
2168 int ret;
2169
2170 /* Cover entire cluster so no additional backing file I/O is required when
2171 * allocating cluster in the image file.
2172 */
2173 round_to_clusters(bs, sector_num, nb_sectors,
2174 &cluster_sector_num, &cluster_nb_sectors);
2175
2176 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2177 cluster_sector_num, cluster_nb_sectors);
2178
2179 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2180 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2181 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2182
2183 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2184 &bounce_qiov);
2185 if (ret < 0) {
2186 goto err;
2187 }
2188
2189 if (drv->bdrv_co_write_zeroes &&
2190 buffer_is_zero(bounce_buffer, iov.iov_len)) {
2191 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2192 cluster_nb_sectors);
2193 } else {
2194 /* This does not change the data on the disk, it is not necessary
2195 * to flush even in cache=writethrough mode.
2196 */
2197 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
2198 &bounce_qiov);
2199 }
2200
2201 if (ret < 0) {
2202 /* It might be okay to ignore write errors for guest requests. If this
2203 * is a deliberate copy-on-read then we don't want to ignore the error.
2204 * Simply report it in all cases.
2205 */
2206 goto err;
2207 }
2208
2209 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
2210 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2211 nb_sectors * BDRV_SECTOR_SIZE);
2212
2213 err:
2214 qemu_vfree(bounce_buffer);
2215 return ret;
2216 }
2217
2218 /*
2219 * Handle a read request in coroutine context
2220 */
2221 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
2222 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2223 BdrvRequestFlags flags)
2224 {
2225 BlockDriver *drv = bs->drv;
2226 BdrvTrackedRequest req;
2227 int ret;
2228
2229 if (!drv) {
2230 return -ENOMEDIUM;
2231 }
2232 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2233 return -EIO;
2234 }
2235
2236 /* throttling disk read I/O */
2237 if (bs->io_limits_enabled) {
2238 bdrv_io_limits_intercept(bs, false, nb_sectors);
2239 }
2240
2241 if (bs->copy_on_read) {
2242 flags |= BDRV_REQ_COPY_ON_READ;
2243 }
2244 if (flags & BDRV_REQ_COPY_ON_READ) {
2245 bs->copy_on_read_in_flight++;
2246 }
2247
2248 if (bs->copy_on_read_in_flight) {
2249 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2250 }
2251
2252 tracked_request_begin(&req, bs, sector_num, nb_sectors, false);
2253
2254 if (flags & BDRV_REQ_COPY_ON_READ) {
2255 int pnum;
2256
2257 ret = bdrv_co_is_allocated(bs, sector_num, nb_sectors, &pnum);
2258 if (ret < 0) {
2259 goto out;
2260 }
2261
2262 if (!ret || pnum != nb_sectors) {
2263 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
2264 goto out;
2265 }
2266 }
2267
2268 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
2269
2270 out:
2271 tracked_request_end(&req);
2272
2273 if (flags & BDRV_REQ_COPY_ON_READ) {
2274 bs->copy_on_read_in_flight--;
2275 }
2276
2277 return ret;
2278 }
2279
2280 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
2281 int nb_sectors, QEMUIOVector *qiov)
2282 {
2283 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
2284
2285 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
2286 }
2287
2288 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
2289 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2290 {
2291 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
2292
2293 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
2294 BDRV_REQ_COPY_ON_READ);
2295 }
2296
2297 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
2298 int64_t sector_num, int nb_sectors)
2299 {
2300 BlockDriver *drv = bs->drv;
2301 QEMUIOVector qiov;
2302 struct iovec iov;
2303 int ret;
2304
2305 /* TODO Emulate only part of misaligned requests instead of letting block
2306 * drivers return -ENOTSUP and emulate everything */
2307
2308 /* First try the efficient write zeroes operation */
2309 if (drv->bdrv_co_write_zeroes) {
2310 ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2311 if (ret != -ENOTSUP) {
2312 return ret;
2313 }
2314 }
2315
2316 /* Fall back to bounce buffer if write zeroes is unsupported */
2317 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2318 iov.iov_base = qemu_blockalign(bs, iov.iov_len);
2319 memset(iov.iov_base, 0, iov.iov_len);
2320 qemu_iovec_init_external(&qiov, &iov, 1);
2321
2322 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, &qiov);
2323
2324 qemu_vfree(iov.iov_base);
2325 return ret;
2326 }
2327
2328 /*
2329 * Handle a write request in coroutine context
2330 */
2331 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
2332 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2333 BdrvRequestFlags flags)
2334 {
2335 BlockDriver *drv = bs->drv;
2336 BdrvTrackedRequest req;
2337 int ret;
2338
2339 if (!bs->drv) {
2340 return -ENOMEDIUM;
2341 }
2342 if (bs->read_only) {
2343 return -EACCES;
2344 }
2345 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2346 return -EIO;
2347 }
2348
2349 /* throttling disk write I/O */
2350 if (bs->io_limits_enabled) {
2351 bdrv_io_limits_intercept(bs, true, nb_sectors);
2352 }
2353
2354 if (bs->copy_on_read_in_flight) {
2355 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2356 }
2357
2358 tracked_request_begin(&req, bs, sector_num, nb_sectors, true);
2359
2360 if (flags & BDRV_REQ_ZERO_WRITE) {
2361 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors);
2362 } else {
2363 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
2364 }
2365
2366 if (ret == 0 && !bs->enable_write_cache) {
2367 ret = bdrv_co_flush(bs);
2368 }
2369
2370 if (bs->dirty_bitmap) {
2371 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2372 }
2373
2374 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2375 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2376 }
2377
2378 tracked_request_end(&req);
2379
2380 return ret;
2381 }
2382
2383 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
2384 int nb_sectors, QEMUIOVector *qiov)
2385 {
2386 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
2387
2388 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
2389 }
2390
2391 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
2392 int64_t sector_num, int nb_sectors)
2393 {
2394 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2395
2396 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
2397 BDRV_REQ_ZERO_WRITE);
2398 }
2399
2400 /**
2401 * Truncate file to 'offset' bytes (needed only for file protocols)
2402 */
2403 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2404 {
2405 BlockDriver *drv = bs->drv;
2406 int ret;
2407 if (!drv)
2408 return -ENOMEDIUM;
2409 if (!drv->bdrv_truncate)
2410 return -ENOTSUP;
2411 if (bs->read_only)
2412 return -EACCES;
2413 if (bdrv_in_use(bs))
2414 return -EBUSY;
2415 ret = drv->bdrv_truncate(bs, offset);
2416 if (ret == 0) {
2417 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2418 bdrv_dev_resize_cb(bs);
2419 }
2420 return ret;
2421 }
2422
2423 /**
2424 * Length of a allocated file in bytes. Sparse files are counted by actual
2425 * allocated space. Return < 0 if error or unknown.
2426 */
2427 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2428 {
2429 BlockDriver *drv = bs->drv;
2430 if (!drv) {
2431 return -ENOMEDIUM;
2432 }
2433 if (drv->bdrv_get_allocated_file_size) {
2434 return drv->bdrv_get_allocated_file_size(bs);
2435 }
2436 if (bs->file) {
2437 return bdrv_get_allocated_file_size(bs->file);
2438 }
2439 return -ENOTSUP;
2440 }
2441
2442 /**
2443 * Length of a file in bytes. Return < 0 if error or unknown.
2444 */
2445 int64_t bdrv_getlength(BlockDriverState *bs)
2446 {
2447 BlockDriver *drv = bs->drv;
2448 if (!drv)
2449 return -ENOMEDIUM;
2450
2451 if (bs->growable || bdrv_dev_has_removable_media(bs)) {
2452 if (drv->bdrv_getlength) {
2453 return drv->bdrv_getlength(bs);
2454 }
2455 }
2456 return bs->total_sectors * BDRV_SECTOR_SIZE;
2457 }
2458
2459 /* return 0 as number of sectors if no device present or error */
2460 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2461 {
2462 int64_t length;
2463 length = bdrv_getlength(bs);
2464 if (length < 0)
2465 length = 0;
2466 else
2467 length = length >> BDRV_SECTOR_BITS;
2468 *nb_sectors_ptr = length;
2469 }
2470
2471 /* throttling disk io limits */
2472 void bdrv_set_io_limits(BlockDriverState *bs,
2473 BlockIOLimit *io_limits)
2474 {
2475 bs->io_limits = *io_limits;
2476 bs->io_limits_enabled = bdrv_io_limits_enabled(bs);
2477 }
2478
2479 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2480 BlockdevOnError on_write_error)
2481 {
2482 bs->on_read_error = on_read_error;
2483 bs->on_write_error = on_write_error;
2484 }
2485
2486 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2487 {
2488 return is_read ? bs->on_read_error : bs->on_write_error;
2489 }
2490
2491 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2492 {
2493 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2494
2495 switch (on_err) {
2496 case BLOCKDEV_ON_ERROR_ENOSPC:
2497 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
2498 case BLOCKDEV_ON_ERROR_STOP:
2499 return BDRV_ACTION_STOP;
2500 case BLOCKDEV_ON_ERROR_REPORT:
2501 return BDRV_ACTION_REPORT;
2502 case BLOCKDEV_ON_ERROR_IGNORE:
2503 return BDRV_ACTION_IGNORE;
2504 default:
2505 abort();
2506 }
2507 }
2508
2509 /* This is done by device models because, while the block layer knows
2510 * about the error, it does not know whether an operation comes from
2511 * the device or the block layer (from a job, for example).
2512 */
2513 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2514 bool is_read, int error)
2515 {
2516 assert(error >= 0);
2517 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
2518 if (action == BDRV_ACTION_STOP) {
2519 vm_stop(RUN_STATE_IO_ERROR);
2520 bdrv_iostatus_set_err(bs, error);
2521 }
2522 }
2523
2524 int bdrv_is_read_only(BlockDriverState *bs)
2525 {
2526 return bs->read_only;
2527 }
2528
2529 int bdrv_is_sg(BlockDriverState *bs)
2530 {
2531 return bs->sg;
2532 }
2533
2534 int bdrv_enable_write_cache(BlockDriverState *bs)
2535 {
2536 return bs->enable_write_cache;
2537 }
2538
2539 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2540 {
2541 bs->enable_write_cache = wce;
2542
2543 /* so a reopen() will preserve wce */
2544 if (wce) {
2545 bs->open_flags |= BDRV_O_CACHE_WB;
2546 } else {
2547 bs->open_flags &= ~BDRV_O_CACHE_WB;
2548 }
2549 }
2550
2551 int bdrv_is_encrypted(BlockDriverState *bs)
2552 {
2553 if (bs->backing_hd && bs->backing_hd->encrypted)
2554 return 1;
2555 return bs->encrypted;
2556 }
2557
2558 int bdrv_key_required(BlockDriverState *bs)
2559 {
2560 BlockDriverState *backing_hd = bs->backing_hd;
2561
2562 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2563 return 1;
2564 return (bs->encrypted && !bs->valid_key);
2565 }
2566
2567 int bdrv_set_key(BlockDriverState *bs, const char *key)
2568 {
2569 int ret;
2570 if (bs->backing_hd && bs->backing_hd->encrypted) {
2571 ret = bdrv_set_key(bs->backing_hd, key);
2572 if (ret < 0)
2573 return ret;
2574 if (!bs->encrypted)
2575 return 0;
2576 }
2577 if (!bs->encrypted) {
2578 return -EINVAL;
2579 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2580 return -ENOMEDIUM;
2581 }
2582 ret = bs->drv->bdrv_set_key(bs, key);
2583 if (ret < 0) {
2584 bs->valid_key = 0;
2585 } else if (!bs->valid_key) {
2586 bs->valid_key = 1;
2587 /* call the change callback now, we skipped it on open */
2588 bdrv_dev_change_media_cb(bs, true);
2589 }
2590 return ret;
2591 }
2592
2593 const char *bdrv_get_format_name(BlockDriverState *bs)
2594 {
2595 return bs->drv ? bs->drv->format_name : NULL;
2596 }
2597
2598 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2599 void *opaque)
2600 {
2601 BlockDriver *drv;
2602
2603 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2604 it(opaque, drv->format_name);
2605 }
2606 }
2607
2608 BlockDriverState *bdrv_find(const char *name)
2609 {
2610 BlockDriverState *bs;
2611
2612 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2613 if (!strcmp(name, bs->device_name)) {
2614 return bs;
2615 }
2616 }
2617 return NULL;
2618 }
2619
2620 BlockDriverState *bdrv_next(BlockDriverState *bs)
2621 {
2622 if (!bs) {
2623 return QTAILQ_FIRST(&bdrv_states);
2624 }
2625 return QTAILQ_NEXT(bs, list);
2626 }
2627
2628 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
2629 {
2630 BlockDriverState *bs;
2631
2632 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2633 it(opaque, bs);
2634 }
2635 }
2636
2637 const char *bdrv_get_device_name(BlockDriverState *bs)
2638 {
2639 return bs->device_name;
2640 }
2641
2642 int bdrv_get_flags(BlockDriverState *bs)
2643 {
2644 return bs->open_flags;
2645 }
2646
2647 void bdrv_flush_all(void)
2648 {
2649 BlockDriverState *bs;
2650
2651 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2652 bdrv_flush(bs);
2653 }
2654 }
2655
2656 int bdrv_has_zero_init(BlockDriverState *bs)
2657 {
2658 assert(bs->drv);
2659
2660 if (bs->drv->bdrv_has_zero_init) {
2661 return bs->drv->bdrv_has_zero_init(bs);
2662 }
2663
2664 return 1;
2665 }
2666
2667 typedef struct BdrvCoIsAllocatedData {
2668 BlockDriverState *bs;
2669 int64_t sector_num;
2670 int nb_sectors;
2671 int *pnum;
2672 int ret;
2673 bool done;
2674 } BdrvCoIsAllocatedData;
2675
2676 /*
2677 * Returns true iff the specified sector is present in the disk image. Drivers
2678 * not implementing the functionality are assumed to not support backing files,
2679 * hence all their sectors are reported as allocated.
2680 *
2681 * If 'sector_num' is beyond the end of the disk image the return value is 0
2682 * and 'pnum' is set to 0.
2683 *
2684 * 'pnum' is set to the number of sectors (including and immediately following
2685 * the specified sector) that are known to be in the same
2686 * allocated/unallocated state.
2687 *
2688 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2689 * beyond the end of the disk image it will be clamped.
2690 */
2691 int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
2692 int nb_sectors, int *pnum)
2693 {
2694 int64_t n;
2695
2696 if (sector_num >= bs->total_sectors) {
2697 *pnum = 0;
2698 return 0;
2699 }
2700
2701 n = bs->total_sectors - sector_num;
2702 if (n < nb_sectors) {
2703 nb_sectors = n;
2704 }
2705
2706 if (!bs->drv->bdrv_co_is_allocated) {
2707 *pnum = nb_sectors;
2708 return 1;
2709 }
2710
2711 return bs->drv->bdrv_co_is_allocated(bs, sector_num, nb_sectors, pnum);
2712 }
2713
2714 /* Coroutine wrapper for bdrv_is_allocated() */
2715 static void coroutine_fn bdrv_is_allocated_co_entry(void *opaque)
2716 {
2717 BdrvCoIsAllocatedData *data = opaque;
2718 BlockDriverState *bs = data->bs;
2719
2720 data->ret = bdrv_co_is_allocated(bs, data->sector_num, data->nb_sectors,
2721 data->pnum);
2722 data->done = true;
2723 }
2724
2725 /*
2726 * Synchronous wrapper around bdrv_co_is_allocated().
2727 *
2728 * See bdrv_co_is_allocated() for details.
2729 */
2730 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2731 int *pnum)
2732 {
2733 Coroutine *co;
2734 BdrvCoIsAllocatedData data = {
2735 .bs = bs,
2736 .sector_num = sector_num,
2737 .nb_sectors = nb_sectors,
2738 .pnum = pnum,
2739 .done = false,
2740 };
2741
2742 co = qemu_coroutine_create(bdrv_is_allocated_co_entry);
2743 qemu_coroutine_enter(co, &data);
2744 while (!data.done) {
2745 qemu_aio_wait();
2746 }
2747 return data.ret;
2748 }
2749
2750 /*
2751 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2752 *
2753 * Return true if the given sector is allocated in any image between
2754 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2755 * sector is allocated in any image of the chain. Return false otherwise.
2756 *
2757 * 'pnum' is set to the number of sectors (including and immediately following
2758 * the specified sector) that are known to be in the same
2759 * allocated/unallocated state.
2760 *
2761 */
2762 int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
2763 BlockDriverState *base,
2764 int64_t sector_num,
2765 int nb_sectors, int *pnum)
2766 {
2767 BlockDriverState *intermediate;
2768 int ret, n = nb_sectors;
2769
2770 intermediate = top;
2771 while (intermediate && intermediate != base) {
2772 int pnum_inter;
2773 ret = bdrv_co_is_allocated(intermediate, sector_num, nb_sectors,
2774 &pnum_inter);
2775 if (ret < 0) {
2776 return ret;
2777 } else if (ret) {
2778 *pnum = pnum_inter;
2779 return 1;
2780 }
2781
2782 /*
2783 * [sector_num, nb_sectors] is unallocated on top but intermediate
2784 * might have
2785 *
2786 * [sector_num+x, nr_sectors] allocated.
2787 */
2788 if (n > pnum_inter) {
2789 n = pnum_inter;
2790 }
2791
2792 intermediate = intermediate->backing_hd;
2793 }
2794
2795 *pnum = n;
2796 return 0;
2797 }
2798
2799 BlockInfoList *qmp_query_block(Error **errp)
2800 {
2801 BlockInfoList *head = NULL, *cur_item = NULL;
2802 BlockDriverState *bs;
2803
2804 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2805 BlockInfoList *info = g_malloc0(sizeof(*info));
2806
2807 info->value = g_malloc0(sizeof(*info->value));
2808 info->value->device = g_strdup(bs->device_name);
2809 info->value->type = g_strdup("unknown");
2810 info->value->locked = bdrv_dev_is_medium_locked(bs);
2811 info->value->removable = bdrv_dev_has_removable_media(bs);
2812
2813 if (bdrv_dev_has_removable_media(bs)) {
2814 info->value->has_tray_open = true;
2815 info->value->tray_open = bdrv_dev_is_tray_open(bs);
2816 }
2817
2818 if (bdrv_iostatus_is_enabled(bs)) {
2819 info->value->has_io_status = true;
2820 info->value->io_status = bs->iostatus;
2821 }
2822
2823 if (bs->drv) {
2824 info->value->has_inserted = true;
2825 info->value->inserted = g_malloc0(sizeof(*info->value->inserted));
2826 info->value->inserted->file = g_strdup(bs->filename);
2827 info->value->inserted->ro = bs->read_only;
2828 info->value->inserted->drv = g_strdup(bs->drv->format_name);
2829 info->value->inserted->encrypted = bs->encrypted;
2830 info->value->inserted->encryption_key_missing = bdrv_key_required(bs);
2831 if (bs->backing_file[0]) {
2832 info->value->inserted->has_backing_file = true;
2833 info->value->inserted->backing_file = g_strdup(bs->backing_file);
2834 }
2835
2836 info->value->inserted->backing_file_depth =
2837 bdrv_get_backing_file_depth(bs);
2838
2839 if (bs->io_limits_enabled) {
2840 info->value->inserted->bps =
2841 bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
2842 info->value->inserted->bps_rd =
2843 bs->io_limits.bps[BLOCK_IO_LIMIT_READ];
2844 info->value->inserted->bps_wr =
2845 bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE];
2846 info->value->inserted->iops =
2847 bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
2848 info->value->inserted->iops_rd =
2849 bs->io_limits.iops[BLOCK_IO_LIMIT_READ];
2850 info->value->inserted->iops_wr =
2851 bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE];
2852 }
2853 }
2854
2855 /* XXX: waiting for the qapi to support GSList */
2856 if (!cur_item) {
2857 head = cur_item = info;
2858 } else {
2859 cur_item->next = info;
2860 cur_item = info;
2861 }
2862 }
2863
2864 return head;
2865 }
2866
2867 /* Consider exposing this as a full fledged QMP command */
2868 static BlockStats *qmp_query_blockstat(const BlockDriverState *bs, Error **errp)
2869 {
2870 BlockStats *s;
2871
2872 s = g_malloc0(sizeof(*s));
2873
2874 if (bs->device_name[0]) {
2875 s->has_device = true;
2876 s->device = g_strdup(bs->device_name);
2877 }
2878
2879 s->stats = g_malloc0(sizeof(*s->stats));
2880 s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ];
2881 s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE];
2882 s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ];
2883 s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE];
2884 s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE;
2885 s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH];
2886 s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE];
2887 s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ];
2888 s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH];
2889
2890 if (bs->file) {
2891 s->has_parent = true;
2892 s->parent = qmp_query_blockstat(bs->file, NULL);
2893 }
2894
2895 return s;
2896 }
2897
2898 BlockStatsList *qmp_query_blockstats(Error **errp)
2899 {
2900 BlockStatsList *head = NULL, *cur_item = NULL;
2901 BlockDriverState *bs;
2902
2903 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2904 BlockStatsList *info = g_malloc0(sizeof(*info));
2905 info->value = qmp_query_blockstat(bs, NULL);
2906
2907 /* XXX: waiting for the qapi to support GSList */
2908 if (!cur_item) {
2909 head = cur_item = info;
2910 } else {
2911 cur_item->next = info;
2912 cur_item = info;
2913 }
2914 }
2915
2916 return head;
2917 }
2918
2919 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2920 {
2921 if (bs->backing_hd && bs->backing_hd->encrypted)
2922 return bs->backing_file;
2923 else if (bs->encrypted)
2924 return bs->filename;
2925 else
2926 return NULL;
2927 }
2928
2929 void bdrv_get_backing_filename(BlockDriverState *bs,
2930 char *filename, int filename_size)
2931 {
2932 pstrcpy(filename, filename_size, bs->backing_file);
2933 }
2934
2935 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
2936 const uint8_t *buf, int nb_sectors)
2937 {
2938 BlockDriver *drv = bs->drv;
2939 if (!drv)
2940 return -ENOMEDIUM;
2941 if (!drv->bdrv_write_compressed)
2942 return -ENOTSUP;
2943 if (bdrv_check_request(bs, sector_num, nb_sectors))
2944 return -EIO;
2945
2946 if (bs->dirty_bitmap) {
2947 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2948 }
2949
2950 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
2951 }
2952
2953 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2954 {
2955 BlockDriver *drv = bs->drv;
2956 if (!drv)
2957 return -ENOMEDIUM;
2958 if (!drv->bdrv_get_info)
2959 return -ENOTSUP;
2960 memset(bdi, 0, sizeof(*bdi));
2961 return drv->bdrv_get_info(bs, bdi);
2962 }
2963
2964 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
2965 int64_t pos, int size)
2966 {
2967 BlockDriver *drv = bs->drv;
2968 if (!drv)
2969 return -ENOMEDIUM;
2970 if (drv->bdrv_save_vmstate)
2971 return drv->bdrv_save_vmstate(bs, buf, pos, size);
2972 if (bs->file)
2973 return bdrv_save_vmstate(bs->file, buf, pos, size);
2974 return -ENOTSUP;
2975 }
2976
2977 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
2978 int64_t pos, int size)
2979 {
2980 BlockDriver *drv = bs->drv;
2981 if (!drv)
2982 return -ENOMEDIUM;
2983 if (drv->bdrv_load_vmstate)
2984 return drv->bdrv_load_vmstate(bs, buf, pos, size);
2985 if (bs->file)
2986 return bdrv_load_vmstate(bs->file, buf, pos, size);
2987 return -ENOTSUP;
2988 }
2989
2990 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2991 {
2992 BlockDriver *drv = bs->drv;
2993
2994 if (!drv || !drv->bdrv_debug_event) {
2995 return;
2996 }
2997
2998 drv->bdrv_debug_event(bs, event);
2999
3000 }
3001
3002 /**************************************************************/
3003 /* handling of snapshots */
3004
3005 int bdrv_can_snapshot(BlockDriverState *bs)
3006 {
3007 BlockDriver *drv = bs->drv;
3008 if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
3009 return 0;
3010 }
3011
3012 if (!drv->bdrv_snapshot_create) {
3013 if (bs->file != NULL) {
3014 return bdrv_can_snapshot(bs->file);
3015 }
3016 return 0;
3017 }
3018
3019 return 1;
3020 }
3021
3022 int bdrv_is_snapshot(BlockDriverState *bs)
3023 {
3024 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3025 }
3026
3027 BlockDriverState *bdrv_snapshots(void)
3028 {
3029 BlockDriverState *bs;
3030
3031 if (bs_snapshots) {
3032 return bs_snapshots;
3033 }
3034
3035 bs = NULL;
3036 while ((bs = bdrv_next(bs))) {
3037 if (bdrv_can_snapshot(bs)) {
3038 bs_snapshots = bs;
3039 return bs;
3040 }
3041 }
3042 return NULL;
3043 }
3044
3045 int bdrv_snapshot_create(BlockDriverState *bs,
3046 QEMUSnapshotInfo *sn_info)
3047 {
3048 BlockDriver *drv = bs->drv;
3049 if (!drv)
3050 return -ENOMEDIUM;
3051 if (drv->bdrv_snapshot_create)
3052 return drv->bdrv_snapshot_create(bs, sn_info);
3053 if (bs->file)
3054 return bdrv_snapshot_create(bs->file, sn_info);
3055 return -ENOTSUP;
3056 }
3057
3058 int bdrv_snapshot_goto(BlockDriverState *bs,
3059 const char *snapshot_id)
3060 {
3061 BlockDriver *drv = bs->drv;
3062 int ret, open_ret;
3063
3064 if (!drv)
3065 return -ENOMEDIUM;
3066 if (drv->bdrv_snapshot_goto)
3067 return drv->bdrv_snapshot_goto(bs, snapshot_id);
3068
3069 if (bs->file) {
3070 drv->bdrv_close(bs);
3071 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
3072 open_ret = drv->bdrv_open(bs, bs->open_flags);
3073 if (open_ret < 0) {
3074 bdrv_delete(bs->file);
3075 bs->drv = NULL;
3076 return open_ret;
3077 }
3078 return ret;
3079 }
3080
3081 return -ENOTSUP;
3082 }
3083
3084 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
3085 {
3086 BlockDriver *drv = bs->drv;
3087 if (!drv)
3088 return -ENOMEDIUM;
3089 if (drv->bdrv_snapshot_delete)
3090 return drv->bdrv_snapshot_delete(bs, snapshot_id);
3091 if (bs->file)
3092 return bdrv_snapshot_delete(bs->file, snapshot_id);
3093 return -ENOTSUP;
3094 }
3095
3096 int bdrv_snapshot_list(BlockDriverState *bs,
3097 QEMUSnapshotInfo **psn_info)
3098 {
3099 BlockDriver *drv = bs->drv;
3100 if (!drv)
3101 return -ENOMEDIUM;
3102 if (drv->bdrv_snapshot_list)
3103 return drv->bdrv_snapshot_list(bs, psn_info);
3104 if (bs->file)
3105 return bdrv_snapshot_list(bs->file, psn_info);
3106 return -ENOTSUP;
3107 }
3108
3109 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
3110 const char *snapshot_name)
3111 {
3112 BlockDriver *drv = bs->drv;
3113 if (!drv) {
3114 return -ENOMEDIUM;
3115 }
3116 if (!bs->read_only) {
3117 return -EINVAL;
3118 }
3119 if (drv->bdrv_snapshot_load_tmp) {
3120 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
3121 }
3122 return -ENOTSUP;
3123 }
3124
3125 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3126 const char *backing_file)
3127 {
3128 if (!bs->drv) {
3129 return NULL;
3130 }
3131
3132 if (bs->backing_hd) {
3133 if (strcmp(bs->backing_file, backing_file) == 0) {
3134 return bs->backing_hd;
3135 } else {
3136 return bdrv_find_backing_image(bs->backing_hd, backing_file);
3137 }
3138 }
3139
3140 return NULL;
3141 }
3142
3143 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3144 {
3145 if (!bs->drv) {
3146 return 0;
3147 }
3148
3149 if (!bs->backing_hd) {
3150 return 0;
3151 }
3152
3153 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3154 }
3155
3156 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3157 {
3158 BlockDriverState *curr_bs = NULL;
3159
3160 if (!bs) {
3161 return NULL;
3162 }
3163
3164 curr_bs = bs;
3165
3166 while (curr_bs->backing_hd) {
3167 curr_bs = curr_bs->backing_hd;
3168 }
3169 return curr_bs;
3170 }
3171
3172 #define NB_SUFFIXES 4
3173
3174 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
3175 {
3176 static const char suffixes[NB_SUFFIXES] = "KMGT";
3177 int64_t base;
3178 int i;
3179
3180 if (size <= 999) {
3181 snprintf(buf, buf_size, "%" PRId64, size);
3182 } else {
3183 base = 1024;
3184 for(i = 0; i < NB_SUFFIXES; i++) {
3185 if (size < (10 * base)) {
3186 snprintf(buf, buf_size, "%0.1f%c",
3187 (double)size / base,
3188 suffixes[i]);
3189 break;
3190 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
3191 snprintf(buf, buf_size, "%" PRId64 "%c",
3192 ((size + (base >> 1)) / base),
3193 suffixes[i]);
3194 break;
3195 }
3196 base = base * 1024;
3197 }
3198 }
3199 return buf;
3200 }
3201
3202 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
3203 {
3204 char buf1[128], date_buf[128], clock_buf[128];
3205 #ifdef _WIN32
3206 struct tm *ptm;
3207 #else
3208 struct tm tm;
3209 #endif
3210 time_t ti;
3211 int64_t secs;
3212
3213 if (!sn) {
3214 snprintf(buf, buf_size,
3215 "%-10s%-20s%7s%20s%15s",
3216 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3217 } else {
3218 ti = sn->date_sec;
3219 #ifdef _WIN32
3220 ptm = localtime(&ti);
3221 strftime(date_buf, sizeof(date_buf),
3222 "%Y-%m-%d %H:%M:%S", ptm);
3223 #else
3224 localtime_r(&ti, &tm);
3225 strftime(date_buf, sizeof(date_buf),
3226 "%Y-%m-%d %H:%M:%S", &tm);
3227 #endif
3228 secs = sn->vm_clock_nsec / 1000000000;
3229 snprintf(clock_buf, sizeof(clock_buf),
3230 "%02d:%02d:%02d.%03d",
3231 (int)(secs / 3600),
3232 (int)((secs / 60) % 60),
3233 (int)(secs % 60),
3234 (int)((sn->vm_clock_nsec / 1000000) % 1000));
3235 snprintf(buf, buf_size,
3236 "%-10s%-20s%7s%20s%15s",
3237 sn->id_str, sn->name,
3238 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
3239 date_buf,
3240 clock_buf);
3241 }
3242 return buf;
3243 }
3244
3245 /**************************************************************/
3246 /* async I/Os */
3247
3248 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
3249 QEMUIOVector *qiov, int nb_sectors,
3250 BlockDriverCompletionFunc *cb, void *opaque)
3251 {
3252 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
3253
3254 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
3255 cb, opaque, false);
3256 }
3257
3258 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
3259 QEMUIOVector *qiov, int nb_sectors,
3260 BlockDriverCompletionFunc *cb, void *opaque)
3261 {
3262 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
3263
3264 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
3265 cb, opaque, true);
3266 }
3267
3268
3269 typedef struct MultiwriteCB {
3270 int error;
3271 int num_requests;
3272 int num_callbacks;
3273 struct {
3274 BlockDriverCompletionFunc *cb;
3275 void *opaque;
3276 QEMUIOVector *free_qiov;
3277 } callbacks[];
3278 } MultiwriteCB;
3279
3280 static void multiwrite_user_cb(MultiwriteCB *mcb)
3281 {
3282 int i;
3283
3284 for (i = 0; i < mcb->num_callbacks; i++) {
3285 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
3286 if (mcb->callbacks[i].free_qiov) {
3287 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
3288 }
3289 g_free(mcb->callbacks[i].free_qiov);
3290 }
3291 }
3292
3293 static void multiwrite_cb(void *opaque, int ret)
3294 {
3295 MultiwriteCB *mcb = opaque;
3296
3297 trace_multiwrite_cb(mcb, ret);
3298
3299 if (ret < 0 && !mcb->error) {
3300 mcb->error = ret;
3301 }
3302
3303 mcb->num_requests--;
3304 if (mcb->num_requests == 0) {
3305 multiwrite_user_cb(mcb);
3306 g_free(mcb);
3307 }
3308 }
3309
3310 static int multiwrite_req_compare(const void *a, const void *b)
3311 {
3312 const BlockRequest *req1 = a, *req2 = b;
3313
3314 /*
3315 * Note that we can't simply subtract req2->sector from req1->sector
3316 * here as that could overflow the return value.
3317 */
3318 if (req1->sector > req2->sector) {
3319 return 1;
3320 } else if (req1->sector < req2->sector) {
3321 return -1;
3322 } else {
3323 return 0;
3324 }
3325 }
3326
3327 /*
3328 * Takes a bunch of requests and tries to merge them. Returns the number of
3329 * requests that remain after merging.
3330 */
3331 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
3332 int num_reqs, MultiwriteCB *mcb)
3333 {
3334 int i, outidx;
3335
3336 // Sort requests by start sector
3337 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
3338
3339 // Check if adjacent requests touch the same clusters. If so, combine them,
3340 // filling up gaps with zero sectors.
3341 outidx = 0;
3342 for (i = 1; i < num_reqs; i++) {
3343 int merge = 0;
3344 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
3345
3346 // Handle exactly sequential writes and overlapping writes.
3347 if (reqs[i].sector <= oldreq_last) {
3348 merge = 1;
3349 }
3350
3351 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
3352 merge = 0;
3353 }
3354
3355 if (merge) {
3356 size_t size;
3357 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
3358 qemu_iovec_init(qiov,
3359 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
3360
3361 // Add the first request to the merged one. If the requests are
3362 // overlapping, drop the last sectors of the first request.
3363 size = (reqs[i].sector - reqs[outidx].sector) << 9;
3364 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
3365
3366 // We should need to add any zeros between the two requests
3367 assert (reqs[i].sector <= oldreq_last);
3368
3369 // Add the second request
3370 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
3371
3372 reqs[outidx].nb_sectors = qiov->size >> 9;
3373 reqs[outidx].qiov = qiov;
3374
3375 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
3376 } else {
3377 outidx++;
3378 reqs[outidx].sector = reqs[i].sector;
3379 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
3380 reqs[outidx].qiov = reqs[i].qiov;
3381 }
3382 }
3383
3384 return outidx + 1;
3385 }
3386
3387 /*
3388 * Submit multiple AIO write requests at once.
3389 *
3390 * On success, the function returns 0 and all requests in the reqs array have
3391 * been submitted. In error case this function returns -1, and any of the
3392 * requests may or may not be submitted yet. In particular, this means that the
3393 * callback will be called for some of the requests, for others it won't. The
3394 * caller must check the error field of the BlockRequest to wait for the right
3395 * callbacks (if error != 0, no callback will be called).
3396 *
3397 * The implementation may modify the contents of the reqs array, e.g. to merge
3398 * requests. However, the fields opaque and error are left unmodified as they
3399 * are used to signal failure for a single request to the caller.
3400 */
3401 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
3402 {
3403 MultiwriteCB *mcb;
3404 int i;
3405
3406 /* don't submit writes if we don't have a medium */
3407 if (bs->drv == NULL) {
3408 for (i = 0; i < num_reqs; i++) {
3409 reqs[i].error = -ENOMEDIUM;
3410 }
3411 return -1;
3412 }
3413
3414 if (num_reqs == 0) {
3415 return 0;
3416 }
3417
3418 // Create MultiwriteCB structure
3419 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
3420 mcb->num_requests = 0;
3421 mcb->num_callbacks = num_reqs;
3422
3423 for (i = 0; i < num_reqs; i++) {
3424 mcb->callbacks[i].cb = reqs[i].cb;
3425 mcb->callbacks[i].opaque = reqs[i].opaque;
3426 }
3427
3428 // Check for mergable requests
3429 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
3430
3431 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
3432
3433 /* Run the aio requests. */
3434 mcb->num_requests = num_reqs;
3435 for (i = 0; i < num_reqs; i++) {
3436 bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
3437 reqs[i].nb_sectors, multiwrite_cb, mcb);
3438 }
3439
3440 return 0;
3441 }
3442
3443 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
3444 {
3445 acb->pool->cancel(acb);
3446 }
3447
3448 /* block I/O throttling */
3449 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
3450 bool is_write, double elapsed_time, uint64_t *wait)
3451 {
3452 uint64_t bps_limit = 0;
3453 double bytes_limit, bytes_base, bytes_res;
3454 double slice_time, wait_time;
3455
3456 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3457 bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
3458 } else if (bs->io_limits.bps[is_write]) {
3459 bps_limit = bs->io_limits.bps[is_write];
3460 } else {
3461 if (wait) {
3462 *wait = 0;
3463 }
3464
3465 return false;
3466 }
3467
3468 slice_time = bs->slice_end - bs->slice_start;
3469 slice_time /= (NANOSECONDS_PER_SECOND);
3470 bytes_limit = bps_limit * slice_time;
3471 bytes_base = bs->nr_bytes[is_write] - bs->io_base.bytes[is_write];
3472 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3473 bytes_base += bs->nr_bytes[!is_write] - bs->io_base.bytes[!is_write];
3474 }
3475
3476 /* bytes_base: the bytes of data which have been read/written; and
3477 * it is obtained from the history statistic info.
3478 * bytes_res: the remaining bytes of data which need to be read/written.
3479 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3480 * the total time for completing reading/writting all data.
3481 */
3482 bytes_res = (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
3483
3484 if (bytes_base + bytes_res <= bytes_limit) {
3485 if (wait) {
3486 *wait = 0;
3487 }
3488
3489 return false;
3490 }
3491
3492 /* Calc approx time to dispatch */
3493 wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time;
3494
3495 /* When the I/O rate at runtime exceeds the limits,
3496 * bs->slice_end need to be extended in order that the current statistic
3497 * info can be kept until the timer fire, so it is increased and tuned
3498 * based on the result of experiment.
3499 */
3500 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3501 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3502 if (wait) {
3503 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3504 }
3505
3506 return true;
3507 }
3508
3509 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
3510 double elapsed_time, uint64_t *wait)
3511 {
3512 uint64_t iops_limit = 0;
3513 double ios_limit, ios_base;
3514 double slice_time, wait_time;
3515
3516 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3517 iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
3518 } else if (bs->io_limits.iops[is_write]) {
3519 iops_limit = bs->io_limits.iops[is_write];
3520 } else {
3521 if (wait) {
3522 *wait = 0;
3523 }
3524
3525 return false;
3526 }
3527
3528 slice_time = bs->slice_end - bs->slice_start;
3529 slice_time /= (NANOSECONDS_PER_SECOND);
3530 ios_limit = iops_limit * slice_time;
3531 ios_base = bs->nr_ops[is_write] - bs->io_base.ios[is_write];
3532 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3533 ios_base += bs->nr_ops[!is_write] - bs->io_base.ios[!is_write];
3534 }
3535
3536 if (ios_base + 1 <= ios_limit) {
3537 if (wait) {
3538 *wait = 0;
3539 }
3540
3541 return false;
3542 }
3543
3544 /* Calc approx time to dispatch */
3545 wait_time = (ios_base + 1) / iops_limit;
3546 if (wait_time > elapsed_time) {
3547 wait_time = wait_time - elapsed_time;
3548 } else {
3549 wait_time = 0;
3550 }
3551
3552 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3553 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3554 if (wait) {
3555 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3556 }
3557
3558 return true;
3559 }
3560
3561 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
3562 bool is_write, int64_t *wait)
3563 {
3564 int64_t now, max_wait;
3565 uint64_t bps_wait = 0, iops_wait = 0;
3566 double elapsed_time;
3567 int bps_ret, iops_ret;
3568
3569 now = qemu_get_clock_ns(vm_clock);
3570 if ((bs->slice_start < now)
3571 && (bs->slice_end > now)) {
3572 bs->slice_end = now + bs->slice_time;
3573 } else {
3574 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME;
3575 bs->slice_start = now;
3576 bs->slice_end = now + bs->slice_time;
3577
3578 bs->io_base.bytes[is_write] = bs->nr_bytes[is_write];
3579 bs->io_base.bytes[!is_write] = bs->nr_bytes[!is_write];
3580
3581 bs->io_base.ios[is_write] = bs->nr_ops[is_write];
3582 bs->io_base.ios[!is_write] = bs->nr_ops[!is_write];
3583 }
3584
3585 elapsed_time = now - bs->slice_start;
3586 elapsed_time /= (NANOSECONDS_PER_SECOND);
3587
3588 bps_ret = bdrv_exceed_bps_limits(bs, nb_sectors,
3589 is_write, elapsed_time, &bps_wait);
3590 iops_ret = bdrv_exceed_iops_limits(bs, is_write,
3591 elapsed_time, &iops_wait);
3592 if (bps_ret || iops_ret) {
3593 max_wait = bps_wait > iops_wait ? bps_wait : iops_wait;
3594 if (wait) {
3595 *wait = max_wait;
3596 }
3597
3598 now = qemu_get_clock_ns(vm_clock);
3599 if (bs->slice_end < now + max_wait) {
3600 bs->slice_end = now + max_wait;
3601 }
3602
3603 return true;
3604 }
3605
3606 if (wait) {
3607 *wait = 0;
3608 }
3609
3610 return false;
3611 }
3612
3613 /**************************************************************/
3614 /* async block device emulation */
3615
3616 typedef struct BlockDriverAIOCBSync {
3617 BlockDriverAIOCB common;
3618 QEMUBH *bh;
3619 int ret;
3620 /* vector translation state */
3621 QEMUIOVector *qiov;
3622 uint8_t *bounce;
3623 int is_write;
3624 } BlockDriverAIOCBSync;
3625
3626 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
3627 {
3628 BlockDriverAIOCBSync *acb =
3629 container_of(blockacb, BlockDriverAIOCBSync, common);
3630 qemu_bh_delete(acb->bh);
3631 acb->bh = NULL;
3632 qemu_aio_release(acb);
3633 }
3634
3635 static AIOPool bdrv_em_aio_pool = {
3636 .aiocb_size = sizeof(BlockDriverAIOCBSync),
3637 .cancel = bdrv_aio_cancel_em,
3638 };
3639
3640 static void bdrv_aio_bh_cb(void *opaque)
3641 {
3642 BlockDriverAIOCBSync *acb = opaque;
3643
3644 if (!acb->is_write)
3645 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
3646 qemu_vfree(acb->bounce);
3647 acb->common.cb(acb->common.opaque, acb->ret);
3648 qemu_bh_delete(acb->bh);
3649 acb->bh = NULL;
3650 qemu_aio_release(acb);
3651 }
3652
3653 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
3654 int64_t sector_num,
3655 QEMUIOVector *qiov,
3656 int nb_sectors,
3657 BlockDriverCompletionFunc *cb,
3658 void *opaque,
3659 int is_write)
3660
3661 {
3662 BlockDriverAIOCBSync *acb;
3663
3664 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
3665 acb->is_write = is_write;
3666 acb->qiov = qiov;
3667 acb->bounce = qemu_blockalign(bs, qiov->size);
3668 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
3669
3670 if (is_write) {
3671 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
3672 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
3673 } else {
3674 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
3675 }
3676
3677 qemu_bh_schedule(acb->bh);
3678
3679 return &acb->common;
3680 }
3681
3682 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3683 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3684 BlockDriverCompletionFunc *cb, void *opaque)
3685 {
3686 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
3687 }
3688
3689 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3690 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3691 BlockDriverCompletionFunc *cb, void *opaque)
3692 {
3693 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
3694 }
3695
3696
3697 typedef struct BlockDriverAIOCBCoroutine {
3698 BlockDriverAIOCB common;
3699 BlockRequest req;
3700 bool is_write;
3701 QEMUBH* bh;
3702 } BlockDriverAIOCBCoroutine;
3703
3704 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
3705 {
3706 qemu_aio_flush();
3707 }
3708
3709 static AIOPool bdrv_em_co_aio_pool = {
3710 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
3711 .cancel = bdrv_aio_co_cancel_em,
3712 };
3713
3714 static void bdrv_co_em_bh(void *opaque)
3715 {
3716 BlockDriverAIOCBCoroutine *acb = opaque;
3717
3718 acb->common.cb(acb->common.opaque, acb->req.error);
3719 qemu_bh_delete(acb->bh);
3720 qemu_aio_release(acb);
3721 }
3722
3723 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3724 static void coroutine_fn bdrv_co_do_rw(void *opaque)
3725 {
3726 BlockDriverAIOCBCoroutine *acb = opaque;
3727 BlockDriverState *bs = acb->common.bs;
3728
3729 if (!acb->is_write) {
3730 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
3731 acb->req.nb_sectors, acb->req.qiov, 0);
3732 } else {
3733 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
3734 acb->req.nb_sectors, acb->req.qiov, 0);
3735 }
3736
3737 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3738 qemu_bh_schedule(acb->bh);
3739 }
3740
3741 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
3742 int64_t sector_num,
3743 QEMUIOVector *qiov,
3744 int nb_sectors,
3745 BlockDriverCompletionFunc *cb,
3746 void *opaque,
3747 bool is_write)
3748 {
3749 Coroutine *co;
3750 BlockDriverAIOCBCoroutine *acb;
3751
3752 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3753 acb->req.sector = sector_num;
3754 acb->req.nb_sectors = nb_sectors;
3755 acb->req.qiov = qiov;
3756 acb->is_write = is_write;
3757
3758 co = qemu_coroutine_create(bdrv_co_do_rw);
3759 qemu_coroutine_enter(co, acb);
3760
3761 return &acb->common;
3762 }
3763
3764 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
3765 {
3766 BlockDriverAIOCBCoroutine *acb = opaque;
3767 BlockDriverState *bs = acb->common.bs;
3768
3769 acb->req.error = bdrv_co_flush(bs);
3770 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3771 qemu_bh_schedule(acb->bh);
3772 }
3773
3774 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
3775 BlockDriverCompletionFunc *cb, void *opaque)
3776 {
3777 trace_bdrv_aio_flush(bs, opaque);
3778
3779 Coroutine *co;
3780 BlockDriverAIOCBCoroutine *acb;
3781
3782 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3783 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
3784 qemu_coroutine_enter(co, acb);
3785
3786 return &acb->common;
3787 }
3788
3789 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
3790 {
3791 BlockDriverAIOCBCoroutine *acb = opaque;
3792 BlockDriverState *bs = acb->common.bs;
3793
3794 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
3795 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3796 qemu_bh_schedule(acb->bh);
3797 }
3798
3799 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
3800 int64_t sector_num, int nb_sectors,
3801 BlockDriverCompletionFunc *cb, void *opaque)
3802 {
3803 Coroutine *co;
3804 BlockDriverAIOCBCoroutine *acb;
3805
3806 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
3807
3808 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3809 acb->req.sector = sector_num;
3810 acb->req.nb_sectors = nb_sectors;
3811 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
3812 qemu_coroutine_enter(co, acb);
3813
3814 return &acb->common;
3815 }
3816
3817 void bdrv_init(void)
3818 {
3819 module_call_init(MODULE_INIT_BLOCK);
3820 }
3821
3822 void bdrv_init_with_whitelist(void)
3823 {
3824 use_bdrv_whitelist = 1;
3825 bdrv_init();
3826 }
3827
3828 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
3829 BlockDriverCompletionFunc *cb, void *opaque)
3830 {
3831 BlockDriverAIOCB *acb;
3832
3833 if (pool->free_aiocb) {
3834 acb = pool->free_aiocb;
3835 pool->free_aiocb = acb->next;
3836 } else {
3837 acb = g_malloc0(pool->aiocb_size);
3838 acb->pool = pool;
3839 }
3840 acb->bs = bs;
3841 acb->cb = cb;
3842 acb->opaque = opaque;
3843 return acb;
3844 }
3845
3846 void qemu_aio_release(void *p)
3847 {
3848 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
3849 AIOPool *pool = acb->pool;
3850 acb->next = pool->free_aiocb;
3851 pool->free_aiocb = acb;
3852 }
3853
3854 /**************************************************************/
3855 /* Coroutine block device emulation */
3856
3857 typedef struct CoroutineIOCompletion {
3858 Coroutine *coroutine;
3859 int ret;
3860 } CoroutineIOCompletion;
3861
3862 static void bdrv_co_io_em_complete(void *opaque, int ret)
3863 {
3864 CoroutineIOCompletion *co = opaque;
3865
3866 co->ret = ret;
3867 qemu_coroutine_enter(co->coroutine, NULL);
3868 }
3869
3870 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
3871 int nb_sectors, QEMUIOVector *iov,
3872 bool is_write)
3873 {
3874 CoroutineIOCompletion co = {
3875 .coroutine = qemu_coroutine_self(),
3876 };
3877 BlockDriverAIOCB *acb;
3878
3879 if (is_write) {
3880 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
3881 bdrv_co_io_em_complete, &co);
3882 } else {
3883 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
3884 bdrv_co_io_em_complete, &co);
3885 }
3886
3887 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
3888 if (!acb) {
3889 return -EIO;
3890 }
3891 qemu_coroutine_yield();
3892
3893 return co.ret;
3894 }
3895
3896 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
3897 int64_t sector_num, int nb_sectors,
3898 QEMUIOVector *iov)
3899 {
3900 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
3901 }
3902
3903 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
3904 int64_t sector_num, int nb_sectors,
3905 QEMUIOVector *iov)
3906 {
3907 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
3908 }
3909
3910 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
3911 {
3912 RwCo *rwco = opaque;
3913
3914 rwco->ret = bdrv_co_flush(rwco->bs);
3915 }
3916
3917 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
3918 {
3919 int ret;
3920
3921 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
3922 return 0;
3923 }
3924
3925 /* Write back cached data to the OS even with cache=unsafe */
3926 if (bs->drv->bdrv_co_flush_to_os) {
3927 ret = bs->drv->bdrv_co_flush_to_os(bs);
3928 if (ret < 0) {
3929 return ret;
3930 }
3931 }
3932
3933 /* But don't actually force it to the disk with cache=unsafe */
3934 if (bs->open_flags & BDRV_O_NO_FLUSH) {
3935 goto flush_parent;
3936 }
3937
3938 if (bs->drv->bdrv_co_flush_to_disk) {
3939 ret = bs->drv->bdrv_co_flush_to_disk(bs);
3940 } else if (bs->drv->bdrv_aio_flush) {
3941 BlockDriverAIOCB *acb;
3942 CoroutineIOCompletion co = {
3943 .coroutine = qemu_coroutine_self(),
3944 };
3945
3946 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
3947 if (acb == NULL) {
3948 ret = -EIO;
3949 } else {
3950 qemu_coroutine_yield();
3951 ret = co.ret;
3952 }
3953 } else {
3954 /*
3955 * Some block drivers always operate in either writethrough or unsafe
3956 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
3957 * know how the server works (because the behaviour is hardcoded or
3958 * depends on server-side configuration), so we can't ensure that
3959 * everything is safe on disk. Returning an error doesn't work because
3960 * that would break guests even if the server operates in writethrough
3961 * mode.
3962 *
3963 * Let's hope the user knows what he's doing.
3964 */
3965 ret = 0;
3966 }
3967 if (ret < 0) {
3968 return ret;
3969 }
3970
3971 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
3972 * in the case of cache=unsafe, so there are no useless flushes.
3973 */
3974 flush_parent:
3975 return bdrv_co_flush(bs->file);
3976 }
3977
3978 void bdrv_invalidate_cache(BlockDriverState *bs)
3979 {
3980 if (bs->drv && bs->drv->bdrv_invalidate_cache) {
3981 bs->drv->bdrv_invalidate_cache(bs);
3982 }
3983 }
3984
3985 void bdrv_invalidate_cache_all(void)
3986 {
3987 BlockDriverState *bs;
3988
3989 QTAILQ_FOREACH(bs, &bdrv_states, list) {
3990 bdrv_invalidate_cache(bs);
3991 }
3992 }
3993
3994 void bdrv_clear_incoming_migration_all(void)
3995 {
3996 BlockDriverState *bs;
3997
3998 QTAILQ_FOREACH(bs, &bdrv_states, list) {
3999 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
4000 }
4001 }
4002
4003 int bdrv_flush(BlockDriverState *bs)
4004 {
4005 Coroutine *co;
4006 RwCo rwco = {
4007 .bs = bs,
4008 .ret = NOT_DONE,
4009 };
4010
4011 if (qemu_in_coroutine()) {
4012 /* Fast-path if already in coroutine context */
4013 bdrv_flush_co_entry(&rwco);
4014 } else {
4015 co = qemu_coroutine_create(bdrv_flush_co_entry);
4016 qemu_coroutine_enter(co, &rwco);
4017 while (rwco.ret == NOT_DONE) {
4018 qemu_aio_wait();
4019 }
4020 }
4021
4022 return rwco.ret;
4023 }
4024
4025 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
4026 {
4027 RwCo *rwco = opaque;
4028
4029 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
4030 }
4031
4032 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
4033 int nb_sectors)
4034 {
4035 if (!bs->drv) {
4036 return -ENOMEDIUM;
4037 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
4038 return -EIO;
4039 } else if (bs->read_only) {
4040 return -EROFS;
4041 } else if (bs->drv->bdrv_co_discard) {
4042 return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors);
4043 } else if (bs->drv->bdrv_aio_discard) {
4044 BlockDriverAIOCB *acb;
4045 CoroutineIOCompletion co = {
4046 .coroutine = qemu_coroutine_self(),
4047 };
4048
4049 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
4050 bdrv_co_io_em_complete, &co);
4051 if (acb == NULL) {
4052 return -EIO;
4053 } else {
4054 qemu_coroutine_yield();
4055 return co.ret;
4056 }
4057 } else {