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