?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'kwolf/for-anthony' into staging
[qemu.git] / block.c
blob9873b57edd96f0763ebbfec6bd3c489f9c012a04
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 "qemu-objects.h"
31 #include "qemu-coroutine.h"
32
33 #ifdef CONFIG_BSD
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <sys/ioctl.h>
37 #include <sys/queue.h>
38 #ifndef __DragonFly__
39 #include <sys/disk.h>
40 #endif
41 #endif
42
43 #ifdef _WIN32
44 #include <windows.h>
45 #endif
46
47 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
48
49 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
50 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
51 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
52 BlockDriverCompletionFunc *cb, void *opaque);
53 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
54 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
55 BlockDriverCompletionFunc *cb, void *opaque);
56 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
57 BlockDriverCompletionFunc *cb, void *opaque);
58 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
59 BlockDriverCompletionFunc *cb, void *opaque);
60 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
61 int64_t sector_num, int nb_sectors,
62 QEMUIOVector *iov);
63 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
64 int64_t sector_num, int nb_sectors,
65 QEMUIOVector *iov);
66 static int coroutine_fn bdrv_co_flush_em(BlockDriverState *bs);
67 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
68 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
69 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
70 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
71 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
72 int64_t sector_num,
73 QEMUIOVector *qiov,
74 int nb_sectors,
75 BlockDriverCompletionFunc *cb,
76 void *opaque,
77 bool is_write);
78 static void coroutine_fn bdrv_co_do_rw(void *opaque);
79
80 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
81 QTAILQ_HEAD_INITIALIZER(bdrv_states);
82
83 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
84 QLIST_HEAD_INITIALIZER(bdrv_drivers);
85
86 /* The device to use for VM snapshots */
87 static BlockDriverState *bs_snapshots;
88
89 /* If non-zero, use only whitelisted block drivers */
90 static int use_bdrv_whitelist;
91
92 #ifdef _WIN32
93 static int is_windows_drive_prefix(const char *filename)
94 {
95 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
96 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
97 filename[1] == ':');
98 }
99
100 int is_windows_drive(const char *filename)
101 {
102 if (is_windows_drive_prefix(filename) &&
103 filename[2] == '\0')
104 return 1;
105 if (strstart(filename, "\\\\.\\", NULL) ||
106 strstart(filename, "//./", NULL))
107 return 1;
108 return 0;
109 }
110 #endif
111
112 /* check if the path starts with "<protocol>:" */
113 static int path_has_protocol(const char *path)
114 {
115 #ifdef _WIN32
116 if (is_windows_drive(path) ||
117 is_windows_drive_prefix(path)) {
118 return 0;
119 }
120 #endif
121
122 return strchr(path, ':') != NULL;
123 }
124
125 int path_is_absolute(const char *path)
126 {
127 const char *p;
128 #ifdef _WIN32
129 /* specific case for names like: "\\.\d:" */
130 if (*path == '/' || *path == '\\')
131 return 1;
132 #endif
133 p = strchr(path, ':');
134 if (p)
135 p++;
136 else
137 p = path;
138 #ifdef _WIN32
139 return (*p == '/' || *p == '\\');
140 #else
141 return (*p == '/');
142 #endif
143 }
144
145 /* if filename is absolute, just copy it to dest. Otherwise, build a
146 path to it by considering it is relative to base_path. URL are
147 supported. */
148 void path_combine(char *dest, int dest_size,
149 const char *base_path,
150 const char *filename)
151 {
152 const char *p, *p1;
153 int len;
154
155 if (dest_size <= 0)
156 return;
157 if (path_is_absolute(filename)) {
158 pstrcpy(dest, dest_size, filename);
159 } else {
160 p = strchr(base_path, ':');
161 if (p)
162 p++;
163 else
164 p = base_path;
165 p1 = strrchr(base_path, '/');
166 #ifdef _WIN32
167 {
168 const char *p2;
169 p2 = strrchr(base_path, '\\');
170 if (!p1 || p2 > p1)
171 p1 = p2;
172 }
173 #endif
174 if (p1)
175 p1++;
176 else
177 p1 = base_path;
178 if (p1 > p)
179 p = p1;
180 len = p - base_path;
181 if (len > dest_size - 1)
182 len = dest_size - 1;
183 memcpy(dest, base_path, len);
184 dest[len] = '\0';
185 pstrcat(dest, dest_size, filename);
186 }
187 }
188
189 void bdrv_register(BlockDriver *bdrv)
190 {
191 /* Block drivers without coroutine functions need emulation */
192 if (!bdrv->bdrv_co_readv) {
193 bdrv->bdrv_co_readv = bdrv_co_readv_em;
194 bdrv->bdrv_co_writev = bdrv_co_writev_em;
195
196 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
197 * the block driver lacks aio we need to emulate that too.
198 */
199 if (!bdrv->bdrv_aio_readv) {
200 /* add AIO emulation layer */
201 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
202 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
203 }
204 }
205
206 if (!bdrv->bdrv_aio_flush)
207 bdrv->bdrv_aio_flush = bdrv_aio_flush_em;
208
209 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
210 }
211
212 /* create a new block device (by default it is empty) */
213 BlockDriverState *bdrv_new(const char *device_name)
214 {
215 BlockDriverState *bs;
216
217 bs = g_malloc0(sizeof(BlockDriverState));
218 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
219 if (device_name[0] != '\0') {
220 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
221 }
222 bdrv_iostatus_disable(bs);
223 return bs;
224 }
225
226 BlockDriver *bdrv_find_format(const char *format_name)
227 {
228 BlockDriver *drv1;
229 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
230 if (!strcmp(drv1->format_name, format_name)) {
231 return drv1;
232 }
233 }
234 return NULL;
235 }
236
237 static int bdrv_is_whitelisted(BlockDriver *drv)
238 {
239 static const char *whitelist[] = {
240 CONFIG_BDRV_WHITELIST
241 };
242 const char **p;
243
244 if (!whitelist[0])
245 return 1; /* no whitelist, anything goes */
246
247 for (p = whitelist; *p; p++) {
248 if (!strcmp(drv->format_name, *p)) {
249 return 1;
250 }
251 }
252 return 0;
253 }
254
255 BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
256 {
257 BlockDriver *drv = bdrv_find_format(format_name);
258 return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
259 }
260
261 int bdrv_create(BlockDriver *drv, const char* filename,
262 QEMUOptionParameter *options)
263 {
264 if (!drv->bdrv_create)
265 return -ENOTSUP;
266
267 return drv->bdrv_create(filename, options);
268 }
269
270 int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
271 {
272 BlockDriver *drv;
273
274 drv = bdrv_find_protocol(filename);
275 if (drv == NULL) {
276 return -ENOENT;
277 }
278
279 return bdrv_create(drv, filename, options);
280 }
281
282 #ifdef _WIN32
283 void get_tmp_filename(char *filename, int size)
284 {
285 char temp_dir[MAX_PATH];
286
287 GetTempPath(MAX_PATH, temp_dir);
288 GetTempFileName(temp_dir, "qem", 0, filename);
289 }
290 #else
291 void get_tmp_filename(char *filename, int size)
292 {
293 int fd;
294 const char *tmpdir;
295 /* XXX: race condition possible */
296 tmpdir = getenv("TMPDIR");
297 if (!tmpdir)
298 tmpdir = "/tmp";
299 snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
300 fd = mkstemp(filename);
301 close(fd);
302 }
303 #endif
304
305 /*
306 * Detect host devices. By convention, /dev/cdrom[N] is always
307 * recognized as a host CDROM.
308 */
309 static BlockDriver *find_hdev_driver(const char *filename)
310 {
311 int score_max = 0, score;
312 BlockDriver *drv = NULL, *d;
313
314 QLIST_FOREACH(d, &bdrv_drivers, list) {
315 if (d->bdrv_probe_device) {
316 score = d->bdrv_probe_device(filename);
317 if (score > score_max) {
318 score_max = score;
319 drv = d;
320 }
321 }
322 }
323
324 return drv;
325 }
326
327 BlockDriver *bdrv_find_protocol(const char *filename)
328 {
329 BlockDriver *drv1;
330 char protocol[128];
331 int len;
332 const char *p;
333
334 /* TODO Drivers without bdrv_file_open must be specified explicitly */
335
336 /*
337 * XXX(hch): we really should not let host device detection
338 * override an explicit protocol specification, but moving this
339 * later breaks access to device names with colons in them.
340 * Thanks to the brain-dead persistent naming schemes on udev-
341 * based Linux systems those actually are quite common.
342 */
343 drv1 = find_hdev_driver(filename);
344 if (drv1) {
345 return drv1;
346 }
347
348 if (!path_has_protocol(filename)) {
349 return bdrv_find_format("file");
350 }
351 p = strchr(filename, ':');
352 assert(p != NULL);
353 len = p - filename;
354 if (len > sizeof(protocol) - 1)
355 len = sizeof(protocol) - 1;
356 memcpy(protocol, filename, len);
357 protocol[len] = '\0';
358 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
359 if (drv1->protocol_name &&
360 !strcmp(drv1->protocol_name, protocol)) {
361 return drv1;
362 }
363 }
364 return NULL;
365 }
366
367 static int find_image_format(const char *filename, BlockDriver **pdrv)
368 {
369 int ret, score, score_max;
370 BlockDriver *drv1, *drv;
371 uint8_t buf[2048];
372 BlockDriverState *bs;
373
374 ret = bdrv_file_open(&bs, filename, 0);
375 if (ret < 0) {
376 *pdrv = NULL;
377 return ret;
378 }
379
380 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
381 if (bs->sg || !bdrv_is_inserted(bs)) {
382 bdrv_delete(bs);
383 drv = bdrv_find_format("raw");
384 if (!drv) {
385 ret = -ENOENT;
386 }
387 *pdrv = drv;
388 return ret;
389 }
390
391 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
392 bdrv_delete(bs);
393 if (ret < 0) {
394 *pdrv = NULL;
395 return ret;
396 }
397
398 score_max = 0;
399 drv = NULL;
400 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
401 if (drv1->bdrv_probe) {
402 score = drv1->bdrv_probe(buf, ret, filename);
403 if (score > score_max) {
404 score_max = score;
405 drv = drv1;
406 }
407 }
408 }
409 if (!drv) {
410 ret = -ENOENT;
411 }
412 *pdrv = drv;
413 return ret;
414 }
415
416 /**
417 * Set the current 'total_sectors' value
418 */
419 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
420 {
421 BlockDriver *drv = bs->drv;
422
423 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
424 if (bs->sg)
425 return 0;
426
427 /* query actual device if possible, otherwise just trust the hint */
428 if (drv->bdrv_getlength) {
429 int64_t length = drv->bdrv_getlength(bs);
430 if (length < 0) {
431 return length;
432 }
433 hint = length >> BDRV_SECTOR_BITS;
434 }
435
436 bs->total_sectors = hint;
437 return 0;
438 }
439
440 /**
441 * Set open flags for a given cache mode
442 *
443 * Return 0 on success, -1 if the cache mode was invalid.
444 */
445 int bdrv_parse_cache_flags(const char *mode, int *flags)
446 {
447 *flags &= ~BDRV_O_CACHE_MASK;
448
449 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
450 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
451 } else if (!strcmp(mode, "directsync")) {
452 *flags |= BDRV_O_NOCACHE;
453 } else if (!strcmp(mode, "writeback")) {
454 *flags |= BDRV_O_CACHE_WB;
455 } else if (!strcmp(mode, "unsafe")) {
456 *flags |= BDRV_O_CACHE_WB;
457 *flags |= BDRV_O_NO_FLUSH;
458 } else if (!strcmp(mode, "writethrough")) {
459 /* this is the default */
460 } else {
461 return -1;
462 }
463
464 return 0;
465 }
466
467 /*
468 * Common part for opening disk images and files
469 */
470 static int bdrv_open_common(BlockDriverState *bs, const char *filename,
471 int flags, BlockDriver *drv)
472 {
473 int ret, open_flags;
474
475 assert(drv != NULL);
476
477 trace_bdrv_open_common(bs, filename, flags, drv->format_name);
478
479 bs->file = NULL;
480 bs->total_sectors = 0;
481 bs->encrypted = 0;
482 bs->valid_key = 0;
483 bs->open_flags = flags;
484 bs->buffer_alignment = 512;
485
486 pstrcpy(bs->filename, sizeof(bs->filename), filename);
487
488 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
489 return -ENOTSUP;
490 }
491
492 bs->drv = drv;
493 bs->opaque = g_malloc0(drv->instance_size);
494
495 if (flags & BDRV_O_CACHE_WB)
496 bs->enable_write_cache = 1;
497
498 /*
499 * Clear flags that are internal to the block layer before opening the
500 * image.
501 */
502 open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
503
504 /*
505 * Snapshots should be writable.
506 */
507 if (bs->is_temporary) {
508 open_flags |= BDRV_O_RDWR;
509 }
510
511 /* Open the image, either directly or using a protocol */
512 if (drv->bdrv_file_open) {
513 ret = drv->bdrv_file_open(bs, filename, open_flags);
514 } else {
515 ret = bdrv_file_open(&bs->file, filename, open_flags);
516 if (ret >= 0) {
517 ret = drv->bdrv_open(bs, open_flags);
518 }
519 }
520
521 if (ret < 0) {
522 goto free_and_fail;
523 }
524
525 bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
526
527 ret = refresh_total_sectors(bs, bs->total_sectors);
528 if (ret < 0) {
529 goto free_and_fail;
530 }
531
532 #ifndef _WIN32
533 if (bs->is_temporary) {
534 unlink(filename);
535 }
536 #endif
537 return 0;
538
539 free_and_fail:
540 if (bs->file) {
541 bdrv_delete(bs->file);
542 bs->file = NULL;
543 }
544 g_free(bs->opaque);
545 bs->opaque = NULL;
546 bs->drv = NULL;
547 return ret;
548 }
549
550 /*
551 * Opens a file using a protocol (file, host_device, nbd, ...)
552 */
553 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
554 {
555 BlockDriverState *bs;
556 BlockDriver *drv;
557 int ret;
558
559 drv = bdrv_find_protocol(filename);
560 if (!drv) {
561 return -ENOENT;
562 }
563
564 bs = bdrv_new("");
565 ret = bdrv_open_common(bs, filename, flags, drv);
566 if (ret < 0) {
567 bdrv_delete(bs);
568 return ret;
569 }
570 bs->growable = 1;
571 *pbs = bs;
572 return 0;
573 }
574
575 /*
576 * Opens a disk image (raw, qcow2, vmdk, ...)
577 */
578 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
579 BlockDriver *drv)
580 {
581 int ret;
582
583 if (flags & BDRV_O_SNAPSHOT) {
584 BlockDriverState *bs1;
585 int64_t total_size;
586 int is_protocol = 0;
587 BlockDriver *bdrv_qcow2;
588 QEMUOptionParameter *options;
589 char tmp_filename[PATH_MAX];
590 char backing_filename[PATH_MAX];
591
592 /* if snapshot, we create a temporary backing file and open it
593 instead of opening 'filename' directly */
594
595 /* if there is a backing file, use it */
596 bs1 = bdrv_new("");
597 ret = bdrv_open(bs1, filename, 0, drv);
598 if (ret < 0) {
599 bdrv_delete(bs1);
600 return ret;
601 }
602 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
603
604 if (bs1->drv && bs1->drv->protocol_name)
605 is_protocol = 1;
606
607 bdrv_delete(bs1);
608
609 get_tmp_filename(tmp_filename, sizeof(tmp_filename));
610
611 /* Real path is meaningless for protocols */
612 if (is_protocol)
613 snprintf(backing_filename, sizeof(backing_filename),
614 "%s", filename);
615 else if (!realpath(filename, backing_filename))
616 return -errno;
617
618 bdrv_qcow2 = bdrv_find_format("qcow2");
619 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
620
621 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
622 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
623 if (drv) {
624 set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
625 drv->format_name);
626 }
627
628 ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
629 free_option_parameters(options);
630 if (ret < 0) {
631 return ret;
632 }
633
634 filename = tmp_filename;
635 drv = bdrv_qcow2;
636 bs->is_temporary = 1;
637 }
638
639 /* Find the right image format driver */
640 if (!drv) {
641 ret = find_image_format(filename, &drv);
642 }
643
644 if (!drv) {
645 goto unlink_and_fail;
646 }
647
648 /* Open the image */
649 ret = bdrv_open_common(bs, filename, flags, drv);
650 if (ret < 0) {
651 goto unlink_and_fail;
652 }
653
654 /* If there is a backing file, use it */
655 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
656 char backing_filename[PATH_MAX];
657 int back_flags;
658 BlockDriver *back_drv = NULL;
659
660 bs->backing_hd = bdrv_new("");
661
662 if (path_has_protocol(bs->backing_file)) {
663 pstrcpy(backing_filename, sizeof(backing_filename),
664 bs->backing_file);
665 } else {
666 path_combine(backing_filename, sizeof(backing_filename),
667 filename, bs->backing_file);
668 }
669
670 if (bs->backing_format[0] != '\0') {
671 back_drv = bdrv_find_format(bs->backing_format);
672 }
673
674 /* backing files always opened read-only */
675 back_flags =
676 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
677
678 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
679 if (ret < 0) {
680 bdrv_close(bs);
681 return ret;
682 }
683 if (bs->is_temporary) {
684 bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
685 } else {
686 /* base image inherits from "parent" */
687 bs->backing_hd->keep_read_only = bs->keep_read_only;
688 }
689 }
690
691 if (!bdrv_key_required(bs)) {
692 bdrv_dev_change_media_cb(bs, true);
693 }
694
695 return 0;
696
697 unlink_and_fail:
698 if (bs->is_temporary) {
699 unlink(filename);
700 }
701 return ret;
702 }
703
704 void bdrv_close(BlockDriverState *bs)
705 {
706 if (bs->drv) {
707 if (bs == bs_snapshots) {
708 bs_snapshots = NULL;
709 }
710 if (bs->backing_hd) {
711 bdrv_delete(bs->backing_hd);
712 bs->backing_hd = NULL;
713 }
714 bs->drv->bdrv_close(bs);
715 g_free(bs->opaque);
716 #ifdef _WIN32
717 if (bs->is_temporary) {
718 unlink(bs->filename);
719 }
720 #endif
721 bs->opaque = NULL;
722 bs->drv = NULL;
723
724 if (bs->file != NULL) {
725 bdrv_close(bs->file);
726 }
727
728 bdrv_dev_change_media_cb(bs, false);
729 }
730 }
731
732 void bdrv_close_all(void)
733 {
734 BlockDriverState *bs;
735
736 QTAILQ_FOREACH(bs, &bdrv_states, list) {
737 bdrv_close(bs);
738 }
739 }
740
741 /* make a BlockDriverState anonymous by removing from bdrv_state list.
742 Also, NULL terminate the device_name to prevent double remove */
743 void bdrv_make_anon(BlockDriverState *bs)
744 {
745 if (bs->device_name[0] != '\0') {
746 QTAILQ_REMOVE(&bdrv_states, bs, list);
747 }
748 bs->device_name[0] = '\0';
749 }
750
751 void bdrv_delete(BlockDriverState *bs)
752 {
753 assert(!bs->dev);
754
755 /* remove from list, if necessary */
756 bdrv_make_anon(bs);
757
758 bdrv_close(bs);
759 if (bs->file != NULL) {
760 bdrv_delete(bs->file);
761 }
762
763 assert(bs != bs_snapshots);
764 g_free(bs);
765 }
766
767 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
768 /* TODO change to DeviceState *dev when all users are qdevified */
769 {
770 if (bs->dev) {
771 return -EBUSY;
772 }
773 bs->dev = dev;
774 bdrv_iostatus_reset(bs);
775 return 0;
776 }
777
778 /* TODO qdevified devices don't use this, remove when devices are qdevified */
779 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
780 {
781 if (bdrv_attach_dev(bs, dev) < 0) {
782 abort();
783 }
784 }
785
786 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
787 /* TODO change to DeviceState *dev when all users are qdevified */
788 {
789 assert(bs->dev == dev);
790 bs->dev = NULL;
791 bs->dev_ops = NULL;
792 bs->dev_opaque = NULL;
793 bs->buffer_alignment = 512;
794 }
795
796 /* TODO change to return DeviceState * when all users are qdevified */
797 void *bdrv_get_attached_dev(BlockDriverState *bs)
798 {
799 return bs->dev;
800 }
801
802 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
803 void *opaque)
804 {
805 bs->dev_ops = ops;
806 bs->dev_opaque = opaque;
807 if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) {
808 bs_snapshots = NULL;
809 }
810 }
811
812 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
813 {
814 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
815 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
816 }
817 }
818
819 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
820 {
821 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
822 }
823
824 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
825 {
826 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
827 return bs->dev_ops->is_tray_open(bs->dev_opaque);
828 }
829 return false;
830 }
831
832 static void bdrv_dev_resize_cb(BlockDriverState *bs)
833 {
834 if (bs->dev_ops && bs->dev_ops->resize_cb) {
835 bs->dev_ops->resize_cb(bs->dev_opaque);
836 }
837 }
838
839 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
840 {
841 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
842 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
843 }
844 return false;
845 }
846
847 /*
848 * Run consistency checks on an image
849 *
850 * Returns 0 if the check could be completed (it doesn't mean that the image is
851 * free of errors) or -errno when an internal error occurred. The results of the
852 * check are stored in res.
853 */
854 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
855 {
856 if (bs->drv->bdrv_check == NULL) {
857 return -ENOTSUP;
858 }
859
860 memset(res, 0, sizeof(*res));
861 return bs->drv->bdrv_check(bs, res);
862 }
863
864 #define COMMIT_BUF_SECTORS 2048
865
866 /* commit COW file into the raw image */
867 int bdrv_commit(BlockDriverState *bs)
868 {
869 BlockDriver *drv = bs->drv;
870 BlockDriver *backing_drv;
871 int64_t sector, total_sectors;
872 int n, ro, open_flags;
873 int ret = 0, rw_ret = 0;
874 uint8_t *buf;
875 char filename[1024];
876 BlockDriverState *bs_rw, *bs_ro;
877
878 if (!drv)
879 return -ENOMEDIUM;
880
881 if (!bs->backing_hd) {
882 return -ENOTSUP;
883 }
884
885 if (bs->backing_hd->keep_read_only) {
886 return -EACCES;
887 }
888
889 backing_drv = bs->backing_hd->drv;
890 ro = bs->backing_hd->read_only;
891 strncpy(filename, bs->backing_hd->filename, sizeof(filename));
892 open_flags = bs->backing_hd->open_flags;
893
894 if (ro) {
895 /* re-open as RW */
896 bdrv_delete(bs->backing_hd);
897 bs->backing_hd = NULL;
898 bs_rw = bdrv_new("");
899 rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR,
900 backing_drv);
901 if (rw_ret < 0) {
902 bdrv_delete(bs_rw);
903 /* try to re-open read-only */
904 bs_ro = bdrv_new("");
905 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
906 backing_drv);
907 if (ret < 0) {
908 bdrv_delete(bs_ro);
909 /* drive not functional anymore */
910 bs->drv = NULL;
911 return ret;
912 }
913 bs->backing_hd = bs_ro;
914 return rw_ret;
915 }
916 bs->backing_hd = bs_rw;
917 }
918
919 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
920 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
921
922 for (sector = 0; sector < total_sectors; sector += n) {
923 if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
924
925 if (bdrv_read(bs, sector, buf, n) != 0) {
926 ret = -EIO;
927 goto ro_cleanup;
928 }
929
930 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
931 ret = -EIO;
932 goto ro_cleanup;
933 }
934 }
935 }
936
937 if (drv->bdrv_make_empty) {
938 ret = drv->bdrv_make_empty(bs);
939 bdrv_flush(bs);
940 }
941
942 /*
943 * Make sure all data we wrote to the backing device is actually
944 * stable on disk.
945 */
946 if (bs->backing_hd)
947 bdrv_flush(bs->backing_hd);
948
949 ro_cleanup:
950 g_free(buf);
951
952 if (ro) {
953 /* re-open as RO */
954 bdrv_delete(bs->backing_hd);
955 bs->backing_hd = NULL;
956 bs_ro = bdrv_new("");
957 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
958 backing_drv);
959 if (ret < 0) {
960 bdrv_delete(bs_ro);
961 /* drive not functional anymore */
962 bs->drv = NULL;
963 return ret;
964 }
965 bs->backing_hd = bs_ro;
966 bs->backing_hd->keep_read_only = 0;
967 }
968
969 return ret;
970 }
971
972 void bdrv_commit_all(void)
973 {
974 BlockDriverState *bs;
975
976 QTAILQ_FOREACH(bs, &bdrv_states, list) {
977 bdrv_commit(bs);
978 }
979 }
980
981 /*
982 * Return values:
983 * 0 - success
984 * -EINVAL - backing format specified, but no file
985 * -ENOSPC - can't update the backing file because no space is left in the
986 * image file header
987 * -ENOTSUP - format driver doesn't support changing the backing file
988 */
989 int bdrv_change_backing_file(BlockDriverState *bs,
990 const char *backing_file, const char *backing_fmt)
991 {
992 BlockDriver *drv = bs->drv;
993
994 if (drv->bdrv_change_backing_file != NULL) {
995 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
996 } else {
997 return -ENOTSUP;
998 }
999 }
1000
1001 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
1002 size_t size)
1003 {
1004 int64_t len;
1005
1006 if (!bdrv_is_inserted(bs))
1007 return -ENOMEDIUM;
1008
1009 if (bs->growable)
1010 return 0;
1011
1012 len = bdrv_getlength(bs);
1013
1014 if (offset < 0)
1015 return -EIO;
1016
1017 if ((offset > len) || (len - offset < size))
1018 return -EIO;
1019
1020 return 0;
1021 }
1022
1023 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
1024 int nb_sectors)
1025 {
1026 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
1027 nb_sectors * BDRV_SECTOR_SIZE);
1028 }
1029
1030 static inline bool bdrv_has_async_flush(BlockDriver *drv)
1031 {
1032 return drv->bdrv_aio_flush != bdrv_aio_flush_em;
1033 }
1034
1035 typedef struct RwCo {
1036 BlockDriverState *bs;
1037 int64_t sector_num;
1038 int nb_sectors;
1039 QEMUIOVector *qiov;
1040 bool is_write;
1041 int ret;
1042 } RwCo;
1043
1044 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
1045 {
1046 RwCo *rwco = opaque;
1047
1048 if (!rwco->is_write) {
1049 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
1050 rwco->nb_sectors, rwco->qiov);
1051 } else {
1052 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
1053 rwco->nb_sectors, rwco->qiov);
1054 }
1055 }
1056
1057 /*
1058 * Process a synchronous request using coroutines
1059 */
1060 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
1061 int nb_sectors, bool is_write)
1062 {
1063 QEMUIOVector qiov;
1064 struct iovec iov = {
1065 .iov_base = (void *)buf,
1066 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
1067 };
1068 Coroutine *co;
1069 RwCo rwco = {
1070 .bs = bs,
1071 .sector_num = sector_num,
1072 .nb_sectors = nb_sectors,
1073 .qiov = &qiov,
1074 .is_write = is_write,
1075 .ret = NOT_DONE,
1076 };
1077
1078 qemu_iovec_init_external(&qiov, &iov, 1);
1079
1080 if (qemu_in_coroutine()) {
1081 /* Fast-path if already in coroutine context */
1082 bdrv_rw_co_entry(&rwco);
1083 } else {
1084 co = qemu_coroutine_create(bdrv_rw_co_entry);
1085 qemu_coroutine_enter(co, &rwco);
1086 while (rwco.ret == NOT_DONE) {
1087 qemu_aio_wait();
1088 }
1089 }
1090 return rwco.ret;
1091 }
1092
1093 /* return < 0 if error. See bdrv_write() for the return codes */
1094 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
1095 uint8_t *buf, int nb_sectors)
1096 {
1097 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false);
1098 }
1099
1100 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
1101 int nb_sectors, int dirty)
1102 {
1103 int64_t start, end;
1104 unsigned long val, idx, bit;
1105
1106 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
1107 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
1108
1109 for (; start <= end; start++) {
1110 idx = start / (sizeof(unsigned long) * 8);
1111 bit = start % (sizeof(unsigned long) * 8);
1112 val = bs->dirty_bitmap[idx];
1113 if (dirty) {
1114 if (!(val & (1UL << bit))) {
1115 bs->dirty_count++;
1116 val |= 1UL << bit;
1117 }
1118 } else {
1119 if (val & (1UL << bit)) {
1120 bs->dirty_count--;
1121 val &= ~(1UL << bit);
1122 }
1123 }
1124 bs->dirty_bitmap[idx] = val;
1125 }
1126 }
1127
1128 /* Return < 0 if error. Important errors are:
1129 -EIO generic I/O error (may happen for all errors)
1130 -ENOMEDIUM No media inserted.
1131 -EINVAL Invalid sector number or nb_sectors
1132 -EACCES Trying to write a read-only device
1133 */
1134 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
1135 const uint8_t *buf, int nb_sectors)
1136 {
1137 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
1138 }
1139
1140 int bdrv_pread(BlockDriverState *bs, int64_t offset,
1141 void *buf, int count1)
1142 {
1143 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1144 int len, nb_sectors, count;
1145 int64_t sector_num;
1146 int ret;
1147
1148 count = count1;
1149 /* first read to align to sector start */
1150 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1151 if (len > count)
1152 len = count;
1153 sector_num = offset >> BDRV_SECTOR_BITS;
1154 if (len > 0) {
1155 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1156 return ret;
1157 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
1158 count -= len;
1159 if (count == 0)
1160 return count1;
1161 sector_num++;
1162 buf += len;
1163 }
1164
1165 /* read the sectors "in place" */
1166 nb_sectors = count >> BDRV_SECTOR_BITS;
1167 if (nb_sectors > 0) {
1168 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1169 return ret;
1170 sector_num += nb_sectors;
1171 len = nb_sectors << BDRV_SECTOR_BITS;
1172 buf += len;
1173 count -= len;
1174 }
1175
1176 /* add data from the last sector */
1177 if (count > 0) {
1178 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1179 return ret;
1180 memcpy(buf, tmp_buf, count);
1181 }
1182 return count1;
1183 }
1184
1185 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1186 const void *buf, int count1)
1187 {
1188 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1189 int len, nb_sectors, count;
1190 int64_t sector_num;
1191 int ret;
1192
1193 count = count1;
1194 /* first write to align to sector start */
1195 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1196 if (len > count)
1197 len = count;
1198 sector_num = offset >> BDRV_SECTOR_BITS;
1199 if (len > 0) {
1200 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1201 return ret;
1202 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1203 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1204 return ret;
1205 count -= len;
1206 if (count == 0)
1207 return count1;
1208 sector_num++;
1209 buf += len;
1210 }
1211
1212 /* write the sectors "in place" */
1213 nb_sectors = count >> BDRV_SECTOR_BITS;
1214 if (nb_sectors > 0) {
1215 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1216 return ret;
1217 sector_num += nb_sectors;
1218 len = nb_sectors << BDRV_SECTOR_BITS;
1219 buf += len;
1220 count -= len;
1221 }
1222
1223 /* add data from the last sector */
1224 if (count > 0) {
1225 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1226 return ret;
1227 memcpy(tmp_buf, buf, count);
1228 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1229 return ret;
1230 }
1231 return count1;
1232 }
1233
1234 /*
1235 * Writes to the file and ensures that no writes are reordered across this
1236 * request (acts as a barrier)
1237 *
1238 * Returns 0 on success, -errno in error cases.
1239 */
1240 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1241 const void *buf, int count)
1242 {
1243 int ret;
1244
1245 ret = bdrv_pwrite(bs, offset, buf, count);
1246 if (ret < 0) {
1247 return ret;
1248 }
1249
1250 /* No flush needed for cache modes that use O_DSYNC */
1251 if ((bs->open_flags & BDRV_O_CACHE_WB) != 0) {
1252 bdrv_flush(bs);
1253 }
1254
1255 return 0;
1256 }
1257
1258 /*
1259 * Handle a read request in coroutine context
1260 */
1261 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
1262 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
1263 {
1264 BlockDriver *drv = bs->drv;
1265
1266 if (!drv) {
1267 return -ENOMEDIUM;
1268 }
1269 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
1270 return -EIO;
1271 }
1272
1273 return drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
1274 }
1275
1276 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
1277 int nb_sectors, QEMUIOVector *qiov)
1278 {
1279 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
1280
1281 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov);
1282 }
1283
1284 /*
1285 * Handle a write request in coroutine context
1286 */
1287 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
1288 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
1289 {
1290 BlockDriver *drv = bs->drv;
1291 int ret;
1292
1293 if (!bs->drv) {
1294 return -ENOMEDIUM;
1295 }
1296 if (bs->read_only) {
1297 return -EACCES;
1298 }
1299 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
1300 return -EIO;
1301 }
1302
1303 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
1304
1305 if (bs->dirty_bitmap) {
1306 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1307 }
1308
1309 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
1310 bs->wr_highest_sector = sector_num + nb_sectors - 1;
1311 }
1312
1313 return ret;
1314 }
1315
1316 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
1317 int nb_sectors, QEMUIOVector *qiov)
1318 {
1319 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
1320
1321 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov);
1322 }
1323
1324 /**
1325 * Truncate file to 'offset' bytes (needed only for file protocols)
1326 */
1327 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1328 {
1329 BlockDriver *drv = bs->drv;
1330 int ret;
1331 if (!drv)
1332 return -ENOMEDIUM;
1333 if (!drv->bdrv_truncate)
1334 return -ENOTSUP;
1335 if (bs->read_only)
1336 return -EACCES;
1337 if (bdrv_in_use(bs))
1338 return -EBUSY;
1339 ret = drv->bdrv_truncate(bs, offset);
1340 if (ret == 0) {
1341 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1342 bdrv_dev_resize_cb(bs);
1343 }
1344 return ret;
1345 }
1346
1347 /**
1348 * Length of a allocated file in bytes. Sparse files are counted by actual
1349 * allocated space. Return < 0 if error or unknown.
1350 */
1351 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
1352 {
1353 BlockDriver *drv = bs->drv;
1354 if (!drv) {
1355 return -ENOMEDIUM;
1356 }
1357 if (drv->bdrv_get_allocated_file_size) {
1358 return drv->bdrv_get_allocated_file_size(bs);
1359 }
1360 if (bs->file) {
1361 return bdrv_get_allocated_file_size(bs->file);
1362 }
1363 return -ENOTSUP;
1364 }
1365
1366 /**
1367 * Length of a file in bytes. Return < 0 if error or unknown.
1368 */
1369 int64_t bdrv_getlength(BlockDriverState *bs)
1370 {
1371 BlockDriver *drv = bs->drv;
1372 if (!drv)
1373 return -ENOMEDIUM;
1374
1375 if (bs->growable || bdrv_dev_has_removable_media(bs)) {
1376 if (drv->bdrv_getlength) {
1377 return drv->bdrv_getlength(bs);
1378 }
1379 }
1380 return bs->total_sectors * BDRV_SECTOR_SIZE;
1381 }
1382
1383 /* return 0 as number of sectors if no device present or error */
1384 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1385 {
1386 int64_t length;
1387 length = bdrv_getlength(bs);
1388 if (length < 0)
1389 length = 0;
1390 else
1391 length = length >> BDRV_SECTOR_BITS;
1392 *nb_sectors_ptr = length;
1393 }
1394
1395 struct partition {
1396 uint8_t boot_ind; /* 0x80 - active */
1397 uint8_t head; /* starting head */
1398 uint8_t sector; /* starting sector */
1399 uint8_t cyl; /* starting cylinder */
1400 uint8_t sys_ind; /* What partition type */
1401 uint8_t end_head; /* end head */
1402 uint8_t end_sector; /* end sector */
1403 uint8_t end_cyl; /* end cylinder */
1404 uint32_t start_sect; /* starting sector counting from 0 */
1405 uint32_t nr_sects; /* nr of sectors in partition */
1406 } QEMU_PACKED;
1407
1408 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1409 static int guess_disk_lchs(BlockDriverState *bs,
1410 int *pcylinders, int *pheads, int *psectors)
1411 {
1412 uint8_t buf[BDRV_SECTOR_SIZE];
1413 int ret, i, heads, sectors, cylinders;
1414 struct partition *p;
1415 uint32_t nr_sects;
1416 uint64_t nb_sectors;
1417
1418 bdrv_get_geometry(bs, &nb_sectors);
1419
1420 ret = bdrv_read(bs, 0, buf, 1);
1421 if (ret < 0)
1422 return -1;
1423 /* test msdos magic */
1424 if (buf[510] != 0x55 || buf[511] != 0xaa)
1425 return -1;
1426 for(i = 0; i < 4; i++) {
1427 p = ((struct partition *)(buf + 0x1be)) + i;
1428 nr_sects = le32_to_cpu(p->nr_sects);
1429 if (nr_sects && p->end_head) {
1430 /* We make the assumption that the partition terminates on
1431 a cylinder boundary */
1432 heads = p->end_head + 1;
1433 sectors = p->end_sector & 63;
1434 if (sectors == 0)
1435 continue;
1436 cylinders = nb_sectors / (heads * sectors);
1437 if (cylinders < 1 || cylinders > 16383)
1438 continue;
1439 *pheads = heads;
1440 *psectors = sectors;
1441 *pcylinders = cylinders;
1442 #if 0
1443 printf("guessed geometry: LCHS=%d %d %d\n",
1444 cylinders, heads, sectors);
1445 #endif
1446 return 0;
1447 }
1448 }
1449 return -1;
1450 }
1451
1452 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1453 {
1454 int translation, lba_detected = 0;
1455 int cylinders, heads, secs;
1456 uint64_t nb_sectors;
1457
1458 /* if a geometry hint is available, use it */
1459 bdrv_get_geometry(bs, &nb_sectors);
1460 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1461 translation = bdrv_get_translation_hint(bs);
1462 if (cylinders != 0) {
1463 *pcyls = cylinders;
1464 *pheads = heads;
1465 *psecs = secs;
1466 } else {
1467 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1468 if (heads > 16) {
1469 /* if heads > 16, it means that a BIOS LBA
1470 translation was active, so the default
1471 hardware geometry is OK */
1472 lba_detected = 1;
1473 goto default_geometry;
1474 } else {
1475 *pcyls = cylinders;
1476 *pheads = heads;
1477 *psecs = secs;
1478 /* disable any translation to be in sync with
1479 the logical geometry */
1480 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
1481 bdrv_set_translation_hint(bs,
1482 BIOS_ATA_TRANSLATION_NONE);
1483 }
1484 }
1485 } else {
1486 default_geometry:
1487 /* if no geometry, use a standard physical disk geometry */
1488 cylinders = nb_sectors / (16 * 63);
1489
1490 if (cylinders > 16383)
1491 cylinders = 16383;
1492 else if (cylinders < 2)
1493 cylinders = 2;
1494 *pcyls = cylinders;
1495 *pheads = 16;
1496 *psecs = 63;
1497 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
1498 if ((*pcyls * *pheads) <= 131072) {
1499 bdrv_set_translation_hint(bs,
1500 BIOS_ATA_TRANSLATION_LARGE);
1501 } else {
1502 bdrv_set_translation_hint(bs,
1503 BIOS_ATA_TRANSLATION_LBA);
1504 }
1505 }
1506 }
1507 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1508 }
1509 }
1510
1511 void bdrv_set_geometry_hint(BlockDriverState *bs,
1512 int cyls, int heads, int secs)
1513 {
1514 bs->cyls = cyls;
1515 bs->heads = heads;
1516 bs->secs = secs;
1517 }
1518
1519 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1520 {
1521 bs->translation = translation;
1522 }
1523
1524 void bdrv_get_geometry_hint(BlockDriverState *bs,
1525 int *pcyls, int *pheads, int *psecs)
1526 {
1527 *pcyls = bs->cyls;
1528 *pheads = bs->heads;
1529 *psecs = bs->secs;
1530 }
1531
1532 /* Recognize floppy formats */
1533 typedef struct FDFormat {
1534 FDriveType drive;
1535 uint8_t last_sect;
1536 uint8_t max_track;
1537 uint8_t max_head;
1538 } FDFormat;
1539
1540 static const FDFormat fd_formats[] = {
1541 /* First entry is default format */
1542 /* 1.44 MB 3"1/2 floppy disks */
1543 { FDRIVE_DRV_144, 18, 80, 1, },
1544 { FDRIVE_DRV_144, 20, 80, 1, },
1545 { FDRIVE_DRV_144, 21, 80, 1, },
1546 { FDRIVE_DRV_144, 21, 82, 1, },
1547 { FDRIVE_DRV_144, 21, 83, 1, },
1548 { FDRIVE_DRV_144, 22, 80, 1, },
1549 { FDRIVE_DRV_144, 23, 80, 1, },
1550 { FDRIVE_DRV_144, 24, 80, 1, },
1551 /* 2.88 MB 3"1/2 floppy disks */
1552 { FDRIVE_DRV_288, 36, 80, 1, },
1553 { FDRIVE_DRV_288, 39, 80, 1, },
1554 { FDRIVE_DRV_288, 40, 80, 1, },
1555 { FDRIVE_DRV_288, 44, 80, 1, },
1556 { FDRIVE_DRV_288, 48, 80, 1, },
1557 /* 720 kB 3"1/2 floppy disks */
1558 { FDRIVE_DRV_144, 9, 80, 1, },
1559 { FDRIVE_DRV_144, 10, 80, 1, },
1560 { FDRIVE_DRV_144, 10, 82, 1, },
1561 { FDRIVE_DRV_144, 10, 83, 1, },
1562 { FDRIVE_DRV_144, 13, 80, 1, },
1563 { FDRIVE_DRV_144, 14, 80, 1, },
1564 /* 1.2 MB 5"1/4 floppy disks */
1565 { FDRIVE_DRV_120, 15, 80, 1, },
1566 { FDRIVE_DRV_120, 18, 80, 1, },
1567 { FDRIVE_DRV_120, 18, 82, 1, },
1568 { FDRIVE_DRV_120, 18, 83, 1, },
1569 { FDRIVE_DRV_120, 20, 80, 1, },
1570 /* 720 kB 5"1/4 floppy disks */
1571 { FDRIVE_DRV_120, 9, 80, 1, },
1572 { FDRIVE_DRV_120, 11, 80, 1, },
1573 /* 360 kB 5"1/4 floppy disks */
1574 { FDRIVE_DRV_120, 9, 40, 1, },
1575 { FDRIVE_DRV_120, 9, 40, 0, },
1576 { FDRIVE_DRV_120, 10, 41, 1, },
1577 { FDRIVE_DRV_120, 10, 42, 1, },
1578 /* 320 kB 5"1/4 floppy disks */
1579 { FDRIVE_DRV_120, 8, 40, 1, },
1580 { FDRIVE_DRV_120, 8, 40, 0, },
1581 /* 360 kB must match 5"1/4 better than 3"1/2... */
1582 { FDRIVE_DRV_144, 9, 80, 0, },
1583 /* end */
1584 { FDRIVE_DRV_NONE, -1, -1, 0, },
1585 };
1586
1587 void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
1588 int *max_track, int *last_sect,
1589 FDriveType drive_in, FDriveType *drive)
1590 {
1591 const FDFormat *parse;
1592 uint64_t nb_sectors, size;
1593 int i, first_match, match;
1594
1595 bdrv_get_geometry_hint(bs, nb_heads, max_track, last_sect);
1596 if (*nb_heads != 0 && *max_track != 0 && *last_sect != 0) {
1597 /* User defined disk */
1598 } else {
1599 bdrv_get_geometry(bs, &nb_sectors);
1600 match = -1;
1601 first_match = -1;
1602 for (i = 0; ; i++) {
1603 parse = &fd_formats[i];
1604 if (parse->drive == FDRIVE_DRV_NONE) {
1605 break;
1606 }
1607 if (drive_in == parse->drive ||
1608 drive_in == FDRIVE_DRV_NONE) {
1609 size = (parse->max_head + 1) * parse->max_track *
1610 parse->last_sect;
1611 if (nb_sectors == size) {
1612 match = i;
1613 break;
1614 }
1615 if (first_match == -1) {
1616 first_match = i;
1617 }
1618 }
1619 }
1620 if (match == -1) {
1621 if (first_match == -1) {
1622 match = 1;
1623 } else {
1624 match = first_match;
1625 }
1626 parse = &fd_formats[match];
1627 }
1628 *nb_heads = parse->max_head + 1;
1629 *max_track = parse->max_track;
1630 *last_sect = parse->last_sect;
1631 *drive = parse->drive;
1632 }
1633 }
1634
1635 int bdrv_get_translation_hint(BlockDriverState *bs)
1636 {
1637 return bs->translation;
1638 }
1639
1640 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1641 BlockErrorAction on_write_error)
1642 {
1643 bs->on_read_error = on_read_error;
1644 bs->on_write_error = on_write_error;
1645 }
1646
1647 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
1648 {
1649 return is_read ? bs->on_read_error : bs->on_write_error;
1650 }
1651
1652 int bdrv_is_read_only(BlockDriverState *bs)
1653 {
1654 return bs->read_only;
1655 }
1656
1657 int bdrv_is_sg(BlockDriverState *bs)
1658 {
1659 return bs->sg;
1660 }
1661
1662 int bdrv_enable_write_cache(BlockDriverState *bs)
1663 {
1664 return bs->enable_write_cache;
1665 }
1666
1667 int bdrv_is_encrypted(BlockDriverState *bs)
1668 {
1669 if (bs->backing_hd && bs->backing_hd->encrypted)
1670 return 1;
1671 return bs->encrypted;
1672 }
1673
1674 int bdrv_key_required(BlockDriverState *bs)
1675 {
1676 BlockDriverState *backing_hd = bs->backing_hd;
1677
1678 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
1679 return 1;
1680 return (bs->encrypted && !bs->valid_key);
1681 }
1682
1683 int bdrv_set_key(BlockDriverState *bs, const char *key)
1684 {
1685 int ret;
1686 if (bs->backing_hd && bs->backing_hd->encrypted) {
1687 ret = bdrv_set_key(bs->backing_hd, key);
1688 if (ret < 0)
1689 return ret;
1690 if (!bs->encrypted)
1691 return 0;
1692 }
1693 if (!bs->encrypted) {
1694 return -EINVAL;
1695 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1696 return -ENOMEDIUM;
1697 }
1698 ret = bs->drv->bdrv_set_key(bs, key);
1699 if (ret < 0) {
1700 bs->valid_key = 0;
1701 } else if (!bs->valid_key) {
1702 bs->valid_key = 1;
1703 /* call the change callback now, we skipped it on open */
1704 bdrv_dev_change_media_cb(bs, true);
1705 }
1706 return ret;
1707 }
1708
1709 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1710 {
1711 if (!bs->drv) {
1712 buf[0] = '\0';
1713 } else {
1714 pstrcpy(buf, buf_size, bs->drv->format_name);
1715 }
1716 }
1717
1718 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
1719 void *opaque)
1720 {
1721 BlockDriver *drv;
1722
1723 QLIST_FOREACH(drv, &bdrv_drivers, list) {
1724 it(opaque, drv->format_name);
1725 }
1726 }
1727
1728 BlockDriverState *bdrv_find(const char *name)
1729 {
1730 BlockDriverState *bs;
1731
1732 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1733 if (!strcmp(name, bs->device_name)) {
1734 return bs;
1735 }
1736 }
1737 return NULL;
1738 }
1739
1740 BlockDriverState *bdrv_next(BlockDriverState *bs)
1741 {
1742 if (!bs) {
1743 return QTAILQ_FIRST(&bdrv_states);
1744 }
1745 return QTAILQ_NEXT(bs, list);
1746 }
1747
1748 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1749 {
1750 BlockDriverState *bs;
1751
1752 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1753 it(opaque, bs);
1754 }
1755 }
1756
1757 const char *bdrv_get_device_name(BlockDriverState *bs)
1758 {
1759 return bs->device_name;
1760 }
1761
1762 int bdrv_flush(BlockDriverState *bs)
1763 {
1764 if (bs->open_flags & BDRV_O_NO_FLUSH) {
1765 return 0;
1766 }
1767
1768 if (bs->drv && bdrv_has_async_flush(bs->drv) && qemu_in_coroutine()) {
1769 return bdrv_co_flush_em(bs);
1770 }
1771
1772 if (bs->drv && bs->drv->bdrv_flush) {
1773 return bs->drv->bdrv_flush(bs);
1774 }
1775
1776 /*
1777 * Some block drivers always operate in either writethrough or unsafe mode
1778 * and don't support bdrv_flush therefore. Usually qemu doesn't know how
1779 * the server works (because the behaviour is hardcoded or depends on
1780 * server-side configuration), so we can't ensure that everything is safe
1781 * on disk. Returning an error doesn't work because that would break guests
1782 * even if the server operates in writethrough mode.
1783 *
1784 * Let's hope the user knows what he's doing.
1785 */
1786 return 0;
1787 }
1788
1789 void bdrv_flush_all(void)
1790 {
1791 BlockDriverState *bs;
1792
1793 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1794 if (!bdrv_is_read_only(bs) && bdrv_is_inserted(bs)) {
1795 bdrv_flush(bs);
1796 }
1797 }
1798 }
1799
1800 int bdrv_has_zero_init(BlockDriverState *bs)
1801 {
1802 assert(bs->drv);
1803
1804 if (bs->drv->bdrv_has_zero_init) {
1805 return bs->drv->bdrv_has_zero_init(bs);
1806 }
1807
1808 return 1;
1809 }
1810
1811 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
1812 {
1813 if (!bs->drv) {
1814 return -ENOMEDIUM;
1815 }
1816 if (!bs->drv->bdrv_discard) {
1817 return 0;
1818 }
1819 return bs->drv->bdrv_discard(bs, sector_num, nb_sectors);
1820 }
1821
1822 /*
1823 * Returns true iff the specified sector is present in the disk image. Drivers
1824 * not implementing the functionality are assumed to not support backing files,
1825 * hence all their sectors are reported as allocated.
1826 *
1827 * 'pnum' is set to the number of sectors (including and immediately following
1828 * the specified sector) that are known to be in the same
1829 * allocated/unallocated state.
1830 *
1831 * 'nb_sectors' is the max value 'pnum' should be set to.
1832 */
1833 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1834 int *pnum)
1835 {
1836 int64_t n;
1837 if (!bs->drv->bdrv_is_allocated) {
1838 if (sector_num >= bs->total_sectors) {
1839 *pnum = 0;
1840 return 0;
1841 }
1842 n = bs->total_sectors - sector_num;
1843 *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1844 return 1;
1845 }
1846 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1847 }
1848
1849 void bdrv_mon_event(const BlockDriverState *bdrv,
1850 BlockMonEventAction action, int is_read)
1851 {
1852 QObject *data;
1853 const char *action_str;
1854
1855 switch (action) {
1856 case BDRV_ACTION_REPORT:
1857 action_str = "report";
1858 break;
1859 case BDRV_ACTION_IGNORE:
1860 action_str = "ignore";
1861 break;
1862 case BDRV_ACTION_STOP:
1863 action_str = "stop";
1864 break;
1865 default:
1866 abort();
1867 }
1868
1869 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1870 bdrv->device_name,
1871 action_str,
1872 is_read ? "read" : "write");
1873 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);
1874
1875 qobject_decref(data);
1876 }
1877
1878 static void bdrv_print_dict(QObject *obj, void *opaque)
1879 {
1880 QDict *bs_dict;
1881 Monitor *mon = opaque;
1882
1883 bs_dict = qobject_to_qdict(obj);
1884
1885 monitor_printf(mon, "%s: removable=%d",
1886 qdict_get_str(bs_dict, "device"),
1887 qdict_get_bool(bs_dict, "removable"));
1888
1889 if (qdict_get_bool(bs_dict, "removable")) {
1890 monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked"));
1891 monitor_printf(mon, " tray-open=%d",
1892 qdict_get_bool(bs_dict, "tray-open"));
1893 }
1894
1895 if (qdict_haskey(bs_dict, "io-status")) {
1896 monitor_printf(mon, " io-status=%s", qdict_get_str(bs_dict, "io-status"));
1897 }
1898
1899 if (qdict_haskey(bs_dict, "inserted")) {
1900 QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
1901
1902 monitor_printf(mon, " file=");
1903 monitor_print_filename(mon, qdict_get_str(qdict, "file"));
1904 if (qdict_haskey(qdict, "backing_file")) {
1905 monitor_printf(mon, " backing_file=");
1906 monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
1907 }
1908 monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
1909 qdict_get_bool(qdict, "ro"),
1910 qdict_get_str(qdict, "drv"),
1911 qdict_get_bool(qdict, "encrypted"));
1912 } else {
1913 monitor_printf(mon, " [not inserted]");
1914 }
1915
1916 monitor_printf(mon, "\n");
1917 }
1918
1919 void bdrv_info_print(Monitor *mon, const QObject *data)
1920 {
1921 qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
1922 }
1923
1924 static const char *const io_status_name[BDRV_IOS_MAX] = {
1925 [BDRV_IOS_OK] = "ok",
1926 [BDRV_IOS_FAILED] = "failed",
1927 [BDRV_IOS_ENOSPC] = "nospace",
1928 };
1929
1930 void bdrv_info(Monitor *mon, QObject **ret_data)
1931 {
1932 QList *bs_list;
1933 BlockDriverState *bs;
1934
1935 bs_list = qlist_new();
1936
1937 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1938 QObject *bs_obj;
1939 QDict *bs_dict;
1940
1941 bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': 'unknown', "
1942 "'removable': %i, 'locked': %i }",
1943 bs->device_name,
1944 bdrv_dev_has_removable_media(bs),
1945 bdrv_dev_is_medium_locked(bs));
1946 bs_dict = qobject_to_qdict(bs_obj);
1947
1948 if (bdrv_dev_has_removable_media(bs)) {
1949 qdict_put(bs_dict, "tray-open",
1950 qbool_from_int(bdrv_dev_is_tray_open(bs)));
1951 }
1952
1953 if (bdrv_iostatus_is_enabled(bs)) {
1954 qdict_put(bs_dict, "io-status",
1955 qstring_from_str(io_status_name[bs->iostatus]));
1956 }
1957
1958 if (bs->drv) {
1959 QObject *obj;
1960
1961 obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
1962 "'encrypted': %i }",
1963 bs->filename, bs->read_only,
1964 bs->drv->format_name,
1965 bdrv_is_encrypted(bs));
1966 if (bs->backing_file[0] != '\0') {
1967 QDict *qdict = qobject_to_qdict(obj);
1968 qdict_put(qdict, "backing_file",
1969 qstring_from_str(bs->backing_file));
1970 }
1971
1972 qdict_put_obj(bs_dict, "inserted", obj);
1973 }
1974 qlist_append_obj(bs_list, bs_obj);
1975 }
1976
1977 *ret_data = QOBJECT(bs_list);
1978 }
1979
1980 static void bdrv_stats_iter(QObject *data, void *opaque)
1981 {
1982 QDict *qdict;
1983 Monitor *mon = opaque;
1984
1985 qdict = qobject_to_qdict(data);
1986 monitor_printf(mon, "%s:", qdict_get_str(qdict, "device"));
1987
1988 qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
1989 monitor_printf(mon, " rd_bytes=%" PRId64
1990 " wr_bytes=%" PRId64
1991 " rd_operations=%" PRId64
1992 " wr_operations=%" PRId64
1993 " flush_operations=%" PRId64
1994 " wr_total_time_ns=%" PRId64
1995 " rd_total_time_ns=%" PRId64
1996 " flush_total_time_ns=%" PRId64
1997 "\n",
1998 qdict_get_int(qdict, "rd_bytes"),
1999 qdict_get_int(qdict, "wr_bytes"),
2000 qdict_get_int(qdict, "rd_operations"),
2001 qdict_get_int(qdict, "wr_operations"),
2002 qdict_get_int(qdict, "flush_operations"),
2003 qdict_get_int(qdict, "wr_total_time_ns"),
2004 qdict_get_int(qdict, "rd_total_time_ns"),
2005 qdict_get_int(qdict, "flush_total_time_ns"));
2006 }
2007
2008 void bdrv_stats_print(Monitor *mon, const QObject *data)
2009 {
2010 qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
2011 }
2012
2013 static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
2014 {
2015 QObject *res;
2016 QDict *dict;
2017
2018 res = qobject_from_jsonf("{ 'stats': {"
2019 "'rd_bytes': %" PRId64 ","
2020 "'wr_bytes': %" PRId64 ","
2021 "'rd_operations': %" PRId64 ","
2022 "'wr_operations': %" PRId64 ","
2023 "'wr_highest_offset': %" PRId64 ","
2024 "'flush_operations': %" PRId64 ","
2025 "'wr_total_time_ns': %" PRId64 ","
2026 "'rd_total_time_ns': %" PRId64 ","
2027 "'flush_total_time_ns': %" PRId64
2028 "} }",
2029 bs->nr_bytes[BDRV_ACCT_READ],
2030 bs->nr_bytes[BDRV_ACCT_WRITE],
2031 bs->nr_ops[BDRV_ACCT_READ],
2032 bs->nr_ops[BDRV_ACCT_WRITE],
2033 bs->wr_highest_sector *
2034 (uint64_t)BDRV_SECTOR_SIZE,
2035 bs->nr_ops[BDRV_ACCT_FLUSH],
2036 bs->total_time_ns[BDRV_ACCT_WRITE],
2037 bs->total_time_ns[BDRV_ACCT_READ],
2038 bs->total_time_ns[BDRV_ACCT_FLUSH]);
2039 dict = qobject_to_qdict(res);
2040
2041 if (*bs->device_name) {
2042 qdict_put(dict, "device", qstring_from_str(bs->device_name));
2043 }
2044
2045 if (bs->file) {
2046 QObject *parent = bdrv_info_stats_bs(bs->file);
2047 qdict_put_obj(dict, "parent", parent);
2048 }
2049
2050 return res;
2051 }
2052
2053 void bdrv_info_stats(Monitor *mon, QObject **ret_data)
2054 {
2055 QObject *obj;
2056 QList *devices;
2057 BlockDriverState *bs;
2058
2059 devices = qlist_new();
2060
2061 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2062 obj = bdrv_info_stats_bs(bs);
2063 qlist_append_obj(devices, obj);
2064 }
2065
2066 *ret_data = QOBJECT(devices);
2067 }
2068
2069 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2070 {
2071 if (bs->backing_hd && bs->backing_hd->encrypted)
2072 return bs->backing_file;
2073 else if (bs->encrypted)
2074 return bs->filename;
2075 else
2076 return NULL;
2077 }
2078
2079 void bdrv_get_backing_filename(BlockDriverState *bs,
2080 char *filename, int filename_size)
2081 {
2082 if (!bs->backing_file) {
2083 pstrcpy(filename, filename_size, "");
2084 } else {
2085 pstrcpy(filename, filename_size, bs->backing_file);
2086 }
2087 }
2088
2089 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
2090 const uint8_t *buf, int nb_sectors)
2091 {
2092 BlockDriver *drv = bs->drv;
2093 if (!drv)
2094 return -ENOMEDIUM;
2095 if (!drv->bdrv_write_compressed)
2096 return -ENOTSUP;
2097 if (bdrv_check_request(bs, sector_num, nb_sectors))
2098 return -EIO;
2099
2100 if (bs->dirty_bitmap) {
2101 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2102 }
2103
2104 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
2105 }
2106
2107 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2108 {
2109 BlockDriver *drv = bs->drv;
2110 if (!drv)
2111 return -ENOMEDIUM;
2112 if (!drv->bdrv_get_info)
2113 return -ENOTSUP;
2114 memset(bdi, 0, sizeof(*bdi));
2115 return drv->bdrv_get_info(bs, bdi);
2116 }
2117
2118 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
2119 int64_t pos, int size)
2120 {
2121 BlockDriver *drv = bs->drv;
2122 if (!drv)
2123 return -ENOMEDIUM;
2124 if (drv->bdrv_save_vmstate)
2125 return drv->bdrv_save_vmstate(bs, buf, pos, size);
2126 if (bs->file)
2127 return bdrv_save_vmstate(bs->file, buf, pos, size);
2128 return -ENOTSUP;
2129 }
2130
2131 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
2132 int64_t pos, int size)
2133 {
2134 BlockDriver *drv = bs->drv;
2135 if (!drv)
2136 return -ENOMEDIUM;
2137 if (drv->bdrv_load_vmstate)
2138 return drv->bdrv_load_vmstate(bs, buf, pos, size);
2139 if (bs->file)
2140 return bdrv_load_vmstate(bs->file, buf, pos, size);
2141 return -ENOTSUP;
2142 }
2143
2144 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2145 {
2146 BlockDriver *drv = bs->drv;
2147
2148 if (!drv || !drv->bdrv_debug_event) {
2149 return;
2150 }
2151
2152 return drv->bdrv_debug_event(bs, event);
2153
2154 }
2155
2156 /**************************************************************/
2157 /* handling of snapshots */
2158
2159 int bdrv_can_snapshot(BlockDriverState *bs)
2160 {
2161 BlockDriver *drv = bs->drv;
2162 if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2163 return 0;
2164 }
2165
2166 if (!drv->bdrv_snapshot_create) {
2167 if (bs->file != NULL) {
2168 return bdrv_can_snapshot(bs->file);
2169 }
2170 return 0;
2171 }
2172
2173 return 1;
2174 }
2175
2176 int bdrv_is_snapshot(BlockDriverState *bs)
2177 {
2178 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
2179 }
2180
2181 BlockDriverState *bdrv_snapshots(void)
2182 {
2183 BlockDriverState *bs;
2184
2185 if (bs_snapshots) {
2186 return bs_snapshots;
2187 }
2188
2189 bs = NULL;
2190 while ((bs = bdrv_next(bs))) {
2191 if (bdrv_can_snapshot(bs)) {
2192 bs_snapshots = bs;
2193 return bs;
2194 }
2195 }
2196 return NULL;
2197 }
2198
2199 int bdrv_snapshot_create(BlockDriverState *bs,
2200 QEMUSnapshotInfo *sn_info)
2201 {
2202 BlockDriver *drv = bs->drv;
2203 if (!drv)
2204 return -ENOMEDIUM;
2205 if (drv->bdrv_snapshot_create)
2206 return drv->bdrv_snapshot_create(bs, sn_info);
2207 if (bs->file)
2208 return bdrv_snapshot_create(bs->file, sn_info);
2209 return -ENOTSUP;
2210 }
2211
2212 int bdrv_snapshot_goto(BlockDriverState *bs,
2213 const char *snapshot_id)
2214 {
2215 BlockDriver *drv = bs->drv;
2216 int ret, open_ret;
2217
2218 if (!drv)
2219 return -ENOMEDIUM;
2220 if (drv->bdrv_snapshot_goto)
2221 return drv->bdrv_snapshot_goto(bs, snapshot_id);
2222
2223 if (bs->file) {
2224 drv->bdrv_close(bs);
2225 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
2226 open_ret = drv->bdrv_open(bs, bs->open_flags);
2227 if (open_ret < 0) {
2228 bdrv_delete(bs->file);
2229 bs->drv = NULL;
2230 return open_ret;
2231 }
2232 return ret;
2233 }
2234
2235 return -ENOTSUP;
2236 }
2237
2238 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
2239 {
2240 BlockDriver *drv = bs->drv;
2241 if (!drv)
2242 return -ENOMEDIUM;
2243 if (drv->bdrv_snapshot_delete)
2244 return drv->bdrv_snapshot_delete(bs, snapshot_id);
2245 if (bs->file)
2246 return bdrv_snapshot_delete(bs->file, snapshot_id);
2247 return -ENOTSUP;
2248 }
2249
2250 int bdrv_snapshot_list(BlockDriverState *bs,
2251 QEMUSnapshotInfo **psn_info)
2252 {
2253 BlockDriver *drv = bs->drv;
2254 if (!drv)
2255 return -ENOMEDIUM;
2256 if (drv->bdrv_snapshot_list)
2257 return drv->bdrv_snapshot_list(bs, psn_info);
2258 if (bs->file)
2259 return bdrv_snapshot_list(bs->file, psn_info);
2260 return -ENOTSUP;
2261 }
2262
2263 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
2264 const char *snapshot_name)
2265 {
2266 BlockDriver *drv = bs->drv;
2267 if (!drv) {
2268 return -ENOMEDIUM;
2269 }
2270 if (!bs->read_only) {
2271 return -EINVAL;
2272 }
2273 if (drv->bdrv_snapshot_load_tmp) {
2274 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
2275 }
2276 return -ENOTSUP;
2277 }
2278
2279 #define NB_SUFFIXES 4
2280
2281 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
2282 {
2283 static const char suffixes[NB_SUFFIXES] = "KMGT";
2284 int64_t base;
2285 int i;
2286
2287 if (size <= 999) {
2288 snprintf(buf, buf_size, "%" PRId64, size);
2289 } else {
2290 base = 1024;
2291 for(i = 0; i < NB_SUFFIXES; i++) {
2292 if (size < (10 * base)) {
2293 snprintf(buf, buf_size, "%0.1f%c",
2294 (double)size / base,
2295 suffixes[i]);
2296 break;
2297 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
2298 snprintf(buf, buf_size, "%" PRId64 "%c",
2299 ((size + (base >> 1)) / base),
2300 suffixes[i]);
2301 break;
2302 }
2303 base = base * 1024;
2304 }
2305 }
2306 return buf;
2307 }
2308
2309 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
2310 {
2311 char buf1[128], date_buf[128], clock_buf[128];
2312 #ifdef _WIN32
2313 struct tm *ptm;
2314 #else
2315 struct tm tm;
2316 #endif
2317 time_t ti;
2318 int64_t secs;
2319
2320 if (!sn) {
2321 snprintf(buf, buf_size,
2322 "%-10s%-20s%7s%20s%15s",
2323 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
2324 } else {
2325 ti = sn->date_sec;
2326 #ifdef _WIN32
2327 ptm = localtime(&ti);
2328 strftime(date_buf, sizeof(date_buf),
2329 "%Y-%m-%d %H:%M:%S", ptm);
2330 #else
2331 localtime_r(&ti, &tm);
2332 strftime(date_buf, sizeof(date_buf),
2333 "%Y-%m-%d %H:%M:%S", &tm);
2334 #endif
2335 secs = sn->vm_clock_nsec / 1000000000;
2336 snprintf(clock_buf, sizeof(clock_buf),
2337 "%02d:%02d:%02d.%03d",
2338 (int)(secs / 3600),
2339 (int)((secs / 60) % 60),
2340 (int)(secs % 60),
2341 (int)((sn->vm_clock_nsec / 1000000) % 1000));
2342 snprintf(buf, buf_size,
2343 "%-10s%-20s%7s%20s%15s",
2344 sn->id_str, sn->name,
2345 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
2346 date_buf,
2347 clock_buf);
2348 }
2349 return buf;
2350 }
2351
2352 /**************************************************************/
2353 /* async I/Os */
2354
2355 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
2356 QEMUIOVector *qiov, int nb_sectors,
2357 BlockDriverCompletionFunc *cb, void *opaque)
2358 {
2359 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
2360
2361 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
2362 cb, opaque, false);
2363 }
2364
2365 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2366 QEMUIOVector *qiov, int nb_sectors,
2367 BlockDriverCompletionFunc *cb, void *opaque)
2368 {
2369 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
2370
2371 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
2372 cb, opaque, true);
2373 }
2374
2375
2376 typedef struct MultiwriteCB {
2377 int error;
2378 int num_requests;
2379 int num_callbacks;
2380 struct {
2381 BlockDriverCompletionFunc *cb;
2382 void *opaque;
2383 QEMUIOVector *free_qiov;
2384 void *free_buf;
2385 } callbacks[];
2386 } MultiwriteCB;
2387
2388 static void multiwrite_user_cb(MultiwriteCB *mcb)
2389 {
2390 int i;
2391
2392 for (i = 0; i < mcb->num_callbacks; i++) {
2393 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
2394 if (mcb->callbacks[i].free_qiov) {
2395 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
2396 }
2397 g_free(mcb->callbacks[i].free_qiov);
2398 qemu_vfree(mcb->callbacks[i].free_buf);
2399 }
2400 }
2401
2402 static void multiwrite_cb(void *opaque, int ret)
2403 {
2404 MultiwriteCB *mcb = opaque;
2405
2406 trace_multiwrite_cb(mcb, ret);
2407
2408 if (ret < 0 && !mcb->error) {
2409 mcb->error = ret;
2410 }
2411
2412 mcb->num_requests--;
2413 if (mcb->num_requests == 0) {
2414 multiwrite_user_cb(mcb);
2415 g_free(mcb);
2416 }
2417 }
2418
2419 static int multiwrite_req_compare(const void *a, const void *b)
2420 {
2421 const BlockRequest *req1 = a, *req2 = b;
2422
2423 /*
2424 * Note that we can't simply subtract req2->sector from req1->sector
2425 * here as that could overflow the return value.
2426 */
2427 if (req1->sector > req2->sector) {
2428 return 1;
2429 } else if (req1->sector < req2->sector) {
2430 return -1;
2431 } else {
2432 return 0;
2433 }
2434 }
2435
2436 /*
2437 * Takes a bunch of requests and tries to merge them. Returns the number of
2438 * requests that remain after merging.
2439 */
2440 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2441 int num_reqs, MultiwriteCB *mcb)
2442 {
2443 int i, outidx;
2444
2445 // Sort requests by start sector
2446 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
2447
2448 // Check if adjacent requests touch the same clusters. If so, combine them,
2449 // filling up gaps with zero sectors.
2450 outidx = 0;
2451 for (i = 1; i < num_reqs; i++) {
2452 int merge = 0;
2453 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
2454
2455 // This handles the cases that are valid for all block drivers, namely
2456 // exactly sequential writes and overlapping writes.
2457 if (reqs[i].sector <= oldreq_last) {
2458 merge = 1;
2459 }
2460
2461 // The block driver may decide that it makes sense to combine requests
2462 // even if there is a gap of some sectors between them. In this case,
2463 // the gap is filled with zeros (therefore only applicable for yet
2464 // unused space in format like qcow2).
2465 if (!merge && bs->drv->bdrv_merge_requests) {
2466 merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2467 }
2468
2469 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2470 merge = 0;
2471 }
2472
2473 if (merge) {
2474 size_t size;
2475 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
2476 qemu_iovec_init(qiov,
2477 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2478
2479 // Add the first request to the merged one. If the requests are
2480 // overlapping, drop the last sectors of the first request.
2481 size = (reqs[i].sector - reqs[outidx].sector) << 9;
2482 qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2483
2484 // We might need to add some zeros between the two requests
2485 if (reqs[i].sector > oldreq_last) {
2486 size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
2487 uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2488 memset(buf, 0, zero_bytes);
2489 qemu_iovec_add(qiov, buf, zero_bytes);
2490 mcb->callbacks[i].free_buf = buf;
2491 }
2492
2493 // Add the second request
2494 qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
2495
2496 reqs[outidx].nb_sectors = qiov->size >> 9;
2497 reqs[outidx].qiov = qiov;
2498
2499 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2500 } else {
2501 outidx++;
2502 reqs[outidx].sector = reqs[i].sector;
2503 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2504 reqs[outidx].qiov = reqs[i].qiov;
2505 }
2506 }
2507
2508 return outidx + 1;
2509 }
2510
2511 /*
2512 * Submit multiple AIO write requests at once.
2513 *
2514 * On success, the function returns 0 and all requests in the reqs array have
2515 * been submitted. In error case this function returns -1, and any of the
2516 * requests may or may not be submitted yet. In particular, this means that the
2517 * callback will be called for some of the requests, for others it won't. The
2518 * caller must check the error field of the BlockRequest to wait for the right
2519 * callbacks (if error != 0, no callback will be called).
2520 *
2521 * The implementation may modify the contents of the reqs array, e.g. to merge
2522 * requests. However, the fields opaque and error are left unmodified as they
2523 * are used to signal failure for a single request to the caller.
2524 */
2525 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2526 {
2527 BlockDriverAIOCB *acb;
2528 MultiwriteCB *mcb;
2529 int i;
2530
2531 /* don't submit writes if we don't have a medium */
2532 if (bs->drv == NULL) {
2533 for (i = 0; i < num_reqs; i++) {
2534 reqs[i].error = -ENOMEDIUM;
2535 }
2536 return -1;
2537 }
2538
2539 if (num_reqs == 0) {
2540 return 0;
2541 }
2542
2543 // Create MultiwriteCB structure
2544 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
2545 mcb->num_requests = 0;
2546 mcb->num_callbacks = num_reqs;
2547
2548 for (i = 0; i < num_reqs; i++) {
2549 mcb->callbacks[i].cb = reqs[i].cb;
2550 mcb->callbacks[i].opaque = reqs[i].opaque;
2551 }
2552
2553 // Check for mergable requests
2554 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2555
2556 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
2557
2558 /*
2559 * Run the aio requests. As soon as one request can't be submitted
2560 * successfully, fail all requests that are not yet submitted (we must
2561 * return failure for all requests anyway)
2562 *
2563 * num_requests cannot be set to the right value immediately: If
2564 * bdrv_aio_writev fails for some request, num_requests would be too high
2565 * and therefore multiwrite_cb() would never recognize the multiwrite
2566 * request as completed. We also cannot use the loop variable i to set it
2567 * when the first request fails because the callback may already have been
2568 * called for previously submitted requests. Thus, num_requests must be
2569 * incremented for each request that is submitted.
2570 *
2571 * The problem that callbacks may be called early also means that we need
2572 * to take care that num_requests doesn't become 0 before all requests are
2573 * submitted - multiwrite_cb() would consider the multiwrite request
2574 * completed. A dummy request that is "completed" by a manual call to
2575 * multiwrite_cb() takes care of this.
2576 */
2577 mcb->num_requests = 1;
2578
2579 // Run the aio requests
2580 for (i = 0; i < num_reqs; i++) {
2581 mcb->num_requests++;
2582 acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2583 reqs[i].nb_sectors, multiwrite_cb, mcb);
2584
2585 if (acb == NULL) {
2586 // We can only fail the whole thing if no request has been
2587 // submitted yet. Otherwise we'll wait for the submitted AIOs to
2588 // complete and report the error in the callback.
2589 if (i == 0) {
2590 trace_bdrv_aio_multiwrite_earlyfail(mcb);
2591 goto fail;
2592 } else {
2593 trace_bdrv_aio_multiwrite_latefail(mcb, i);
2594 multiwrite_cb(mcb, -EIO);
2595 break;
2596 }
2597 }
2598 }
2599
2600 /* Complete the dummy request */
2601 multiwrite_cb(mcb, 0);
2602
2603 return 0;
2604
2605 fail:
2606 for (i = 0; i < mcb->num_callbacks; i++) {
2607 reqs[i].error = -EIO;
2608 }
2609 g_free(mcb);
2610 return -1;
2611 }
2612
2613 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2614 BlockDriverCompletionFunc *cb, void *opaque)
2615 {
2616 BlockDriver *drv = bs->drv;
2617
2618 trace_bdrv_aio_flush(bs, opaque);
2619
2620 if (bs->open_flags & BDRV_O_NO_FLUSH) {
2621 return bdrv_aio_noop_em(bs, cb, opaque);
2622 }
2623
2624 if (!drv)
2625 return NULL;
2626 return drv->bdrv_aio_flush(bs, cb, opaque);
2627 }
2628
2629 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
2630 {
2631 acb->pool->cancel(acb);
2632 }
2633
2634
2635 /**************************************************************/
2636 /* async block device emulation */
2637
2638 typedef struct BlockDriverAIOCBSync {
2639 BlockDriverAIOCB common;
2640 QEMUBH *bh;
2641 int ret;
2642 /* vector translation state */
2643 QEMUIOVector *qiov;
2644 uint8_t *bounce;
2645 int is_write;
2646 } BlockDriverAIOCBSync;
2647
2648 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
2649 {
2650 BlockDriverAIOCBSync *acb =
2651 container_of(blockacb, BlockDriverAIOCBSync, common);
2652 qemu_bh_delete(acb->bh);
2653 acb->bh = NULL;
2654 qemu_aio_release(acb);
2655 }
2656
2657 static AIOPool bdrv_em_aio_pool = {
2658 .aiocb_size = sizeof(BlockDriverAIOCBSync),
2659 .cancel = bdrv_aio_cancel_em,
2660 };
2661
2662 static void bdrv_aio_bh_cb(void *opaque)
2663 {
2664 BlockDriverAIOCBSync *acb = opaque;
2665
2666 if (!acb->is_write)
2667 qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
2668 qemu_vfree(acb->bounce);
2669 acb->common.cb(acb->common.opaque, acb->ret);
2670 qemu_bh_delete(acb->bh);
2671 acb->bh = NULL;
2672 qemu_aio_release(acb);
2673 }
2674
2675 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2676 int64_t sector_num,
2677 QEMUIOVector *qiov,
2678 int nb_sectors,
2679 BlockDriverCompletionFunc *cb,
2680 void *opaque,
2681 int is_write)
2682
2683 {
2684 BlockDriverAIOCBSync *acb;
2685
2686 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2687 acb->is_write = is_write;
2688 acb->qiov = qiov;
2689 acb->bounce = qemu_blockalign(bs, qiov->size);
2690
2691 if (!acb->bh)
2692 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2693
2694 if (is_write) {
2695 qemu_iovec_to_buffer(acb->qiov, acb->bounce);
2696 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2697 } else {
2698 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2699 }
2700
2701 qemu_bh_schedule(acb->bh);
2702
2703 return &acb->common;
2704 }
2705
2706 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2707 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2708 BlockDriverCompletionFunc *cb, void *opaque)
2709 {
2710 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2711 }
2712
2713 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2714 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2715 BlockDriverCompletionFunc *cb, void *opaque)
2716 {
2717 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
2718 }
2719
2720
2721 typedef struct BlockDriverAIOCBCoroutine {
2722 BlockDriverAIOCB common;
2723 BlockRequest req;
2724 bool is_write;
2725 QEMUBH* bh;
2726 } BlockDriverAIOCBCoroutine;
2727
2728 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
2729 {
2730 qemu_aio_flush();
2731 }
2732
2733 static AIOPool bdrv_em_co_aio_pool = {
2734 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
2735 .cancel = bdrv_aio_co_cancel_em,
2736 };
2737
2738 static void bdrv_co_rw_bh(void *opaque)
2739 {
2740 BlockDriverAIOCBCoroutine *acb = opaque;
2741
2742 acb->common.cb(acb->common.opaque, acb->req.error);
2743 qemu_bh_delete(acb->bh);
2744 qemu_aio_release(acb);
2745 }
2746
2747 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
2748 static void coroutine_fn bdrv_co_do_rw(void *opaque)
2749 {
2750 BlockDriverAIOCBCoroutine *acb = opaque;
2751 BlockDriverState *bs = acb->common.bs;
2752
2753 if (!acb->is_write) {
2754 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
2755 acb->req.nb_sectors, acb->req.qiov);
2756 } else {
2757 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
2758 acb->req.nb_sectors, acb->req.qiov);
2759 }
2760
2761 acb->bh = qemu_bh_new(bdrv_co_rw_bh, acb);
2762 qemu_bh_schedule(acb->bh);
2763 }
2764
2765 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
2766 int64_t sector_num,
2767 QEMUIOVector *qiov,
2768 int nb_sectors,
2769 BlockDriverCompletionFunc *cb,
2770 void *opaque,
2771 bool is_write)
2772 {
2773 Coroutine *co;
2774 BlockDriverAIOCBCoroutine *acb;
2775
2776 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
2777 acb->req.sector = sector_num;
2778 acb->req.nb_sectors = nb_sectors;
2779 acb->req.qiov = qiov;
2780 acb->is_write = is_write;
2781
2782 co = qemu_coroutine_create(bdrv_co_do_rw);
2783 qemu_coroutine_enter(co, acb);
2784
2785 return &acb->common;
2786 }
2787
2788 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2789 BlockDriverCompletionFunc *cb, void *opaque)
2790 {
2791 BlockDriverAIOCBSync *acb;
2792
2793 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2794 acb->is_write = 1; /* don't bounce in the completion hadler */
2795 acb->qiov = NULL;
2796 acb->bounce = NULL;
2797 acb->ret = 0;
2798
2799 if (!acb->bh)
2800 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2801
2802 bdrv_flush(bs);
2803 qemu_bh_schedule(acb->bh);
2804 return &acb->common;
2805 }
2806
2807 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2808 BlockDriverCompletionFunc *cb, void *opaque)
2809 {
2810 BlockDriverAIOCBSync *acb;
2811
2812 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2813 acb->is_write = 1; /* don't bounce in the completion handler */
2814 acb->qiov = NULL;
2815 acb->bounce = NULL;
2816 acb->ret = 0;
2817
2818 if (!acb->bh) {
2819 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2820 }
2821
2822 qemu_bh_schedule(acb->bh);
2823 return &acb->common;
2824 }
2825
2826 void bdrv_init(void)
2827 {
2828 module_call_init(MODULE_INIT_BLOCK);
2829 }
2830
2831 void bdrv_init_with_whitelist(void)
2832 {
2833 use_bdrv_whitelist = 1;
2834 bdrv_init();
2835 }
2836
2837 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2838 BlockDriverCompletionFunc *cb, void *opaque)
2839 {
2840 BlockDriverAIOCB *acb;
2841
2842 if (pool->free_aiocb) {
2843 acb = pool->free_aiocb;
2844 pool->free_aiocb = acb->next;
2845 } else {
2846 acb = g_malloc0(pool->aiocb_size);
2847 acb->pool = pool;
2848 }
2849 acb->bs = bs;
2850 acb->cb = cb;
2851 acb->opaque = opaque;
2852 return acb;
2853 }
2854
2855 void qemu_aio_release(void *p)
2856 {
2857 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
2858 AIOPool *pool = acb->pool;
2859 acb->next = pool->free_aiocb;
2860 pool->free_aiocb = acb;
2861 }
2862
2863 /**************************************************************/
2864 /* Coroutine block device emulation */
2865
2866 typedef struct CoroutineIOCompletion {
2867 Coroutine *coroutine;
2868 int ret;
2869 } CoroutineIOCompletion;
2870
2871 static void bdrv_co_io_em_complete(void *opaque, int ret)
2872 {
2873 CoroutineIOCompletion *co = opaque;
2874
2875 co->ret = ret;
2876 qemu_coroutine_enter(co->coroutine, NULL);
2877 }
2878
2879 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
2880 int nb_sectors, QEMUIOVector *iov,
2881 bool is_write)
2882 {
2883 CoroutineIOCompletion co = {
2884 .coroutine = qemu_coroutine_self(),
2885 };
2886 BlockDriverAIOCB *acb;
2887
2888 if (is_write) {
2889 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
2890 bdrv_co_io_em_complete, &co);
2891 } else {
2892 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
2893 bdrv_co_io_em_complete, &co);
2894 }
2895
2896 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
2897 if (!acb) {
2898 return -EIO;
2899 }
2900 qemu_coroutine_yield();
2901
2902 return co.ret;
2903 }
2904
2905 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
2906 int64_t sector_num, int nb_sectors,
2907 QEMUIOVector *iov)
2908 {
2909 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
2910 }
2911
2912 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
2913 int64_t sector_num, int nb_sectors,
2914 QEMUIOVector *iov)
2915 {
2916 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
2917 }
2918
2919 static int coroutine_fn bdrv_co_flush_em(BlockDriverState *bs)
2920 {
2921 CoroutineIOCompletion co = {
2922 .coroutine = qemu_coroutine_self(),
2923 };
2924 BlockDriverAIOCB *acb;
2925
2926 acb = bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
2927 if (!acb) {
2928 return -EIO;
2929 }
2930 qemu_coroutine_yield();
2931 return co.ret;
2932 }
2933
2934 /**************************************************************/
2935 /* removable device support */
2936
2937 /**
2938 * Return TRUE if the media is present
2939 */
2940 int bdrv_is_inserted(BlockDriverState *bs)
2941 {
2942 BlockDriver *drv = bs->drv;
2943
2944 if (!drv)
2945 return 0;
2946 if (!drv->bdrv_is_inserted)
2947 return 1;
2948 return drv->bdrv_is_inserted(bs);
2949 }
2950
2951 /**
2952 * Return whether the media changed since the last call to this
2953 * function, or -ENOTSUP if we don't know. Most drivers don't know.
2954 */
2955 int bdrv_media_changed(BlockDriverState *bs)
2956 {
2957 BlockDriver *drv = bs->drv;
2958
2959 if (drv && drv->bdrv_media_changed) {
2960 return drv->bdrv_media_changed(bs);
2961 }
2962 return -ENOTSUP;
2963 }
2964
2965 /**
2966 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
2967 */
2968 void bdrv_eject(BlockDriverState *bs, int eject_flag)
2969 {
2970 BlockDriver *drv = bs->drv;
2971
2972 if (drv && drv->bdrv_eject) {
2973 drv->bdrv_eject(bs, eject_flag);
2974 }
2975 }
2976
2977 /**
2978 * Lock or unlock the media (if it is locked, the user won't be able
2979 * to eject it manually).
2980 */
2981 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
2982 {
2983 BlockDriver *drv = bs->drv;
2984
2985 trace_bdrv_lock_medium(bs, locked);
2986
2987 if (drv && drv->bdrv_lock_medium) {
2988 drv->bdrv_lock_medium(bs, locked);
2989 }
2990 }
2991
2992 /* needed for generic scsi interface */
2993
2994 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2995 {
2996 BlockDriver *drv = bs->drv;
2997
2998 if (drv && drv->bdrv_ioctl)
2999 return drv->bdrv_ioctl(bs, req, buf);
3000 return -ENOTSUP;
3001 }
3002
3003 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
3004 unsigned long int req, void *buf,
3005 BlockDriverCompletionFunc *cb, void *opaque)
3006 {
3007 BlockDriver *drv = bs->drv;
3008
3009 if (drv && drv->bdrv_aio_ioctl)
3010 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
3011 return NULL;
3012 }
3013
3014 void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
3015 {
3016 bs->buffer_alignment = align;
3017 }
3018
3019 void *qemu_blockalign(BlockDriverState *bs, size_t size)
3020 {
3021 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
3022 }
3023
3024 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
3025 {
3026 int64_t bitmap_size;
3027
3028 bs->dirty_count = 0;
3029 if (enable) {
3030 if (!bs->dirty_bitmap) {
3031 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
3032 BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
3033 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
3034
3035 bs->dirty_bitmap = g_malloc0(bitmap_size);
3036 }
3037 } else {
3038 if (bs->dirty_bitmap) {
3039 g_free(bs->dirty_bitmap);
3040 bs->dirty_bitmap = NULL;
3041 }
3042 }
3043 }
3044
3045 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
3046 {
3047 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
3048
3049 if (bs->dirty_bitmap &&
3050 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
3051 return !!(bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
3052 (1UL << (chunk % (sizeof(unsigned long) * 8))));
3053 } else {
3054 return 0;
3055 }
3056 }
3057
3058 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
3059 int nr_sectors)
3060 {
3061 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
3062 }
3063
3064 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
3065 {
3066 return bs->dirty_count;
3067 }
3068
3069 void bdrv_set_in_use(BlockDriverState *bs, int in_use)
3070 {
3071 assert(bs->in_use != in_use);
3072 bs->in_use = in_use;
3073 }
3074
3075 int bdrv_in_use(BlockDriverState *bs)
3076 {
3077 return bs->in_use;
3078 }
3079
3080 void bdrv_iostatus_enable(BlockDriverState *bs)
3081 {
3082 bs->iostatus = BDRV_IOS_OK;
3083 }
3084
3085 /* The I/O status is only enabled if the drive explicitly
3086 * enables it _and_ the VM is configured to stop on errors */
3087 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3088 {
3089 return (bs->iostatus != BDRV_IOS_INVAL &&
3090 (bs->on_write_error == BLOCK_ERR_STOP_ENOSPC ||
3091 bs->on_write_error == BLOCK_ERR_STOP_ANY ||
3092 bs->on_read_error == BLOCK_ERR_STOP_ANY));
3093 }
3094
3095 void bdrv_iostatus_disable(BlockDriverState *bs)
3096 {
3097 bs->iostatus = BDRV_IOS_INVAL;
3098 }
3099
3100 void bdrv_iostatus_reset(BlockDriverState *bs)
3101 {
3102 if (bdrv_iostatus_is_enabled(bs)) {
3103 bs->iostatus = BDRV_IOS_OK;
3104 }
3105 }
3106
3107 /* XXX: Today this is set by device models because it makes the implementation
3108 quite simple. However, the block layer knows about the error, so it's
3109 possible to implement this without device models being involved */
3110 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3111 {
3112 if (bdrv_iostatus_is_enabled(bs) && bs->iostatus == BDRV_IOS_OK) {
3113 assert(error >= 0);
3114 bs->iostatus = error == ENOSPC ? BDRV_IOS_ENOSPC : BDRV_IOS_FAILED;
3115 }
3116 }
3117
3118 void
3119 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
3120 enum BlockAcctType type)
3121 {
3122 assert(type < BDRV_MAX_IOTYPE);
3123
3124 cookie->bytes = bytes;
3125 cookie->start_time_ns = get_clock();
3126 cookie->type = type;
3127 }
3128
3129 void
3130 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
3131 {
3132 assert(cookie->type < BDRV_MAX_IOTYPE);
3133
3134 bs->nr_bytes[cookie->type] += cookie->bytes;
3135 bs->nr_ops[cookie->type]++;
3136 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
3137 }
3138
3139 int bdrv_img_create(const char *filename, const char *fmt,
3140 const char *base_filename, const char *base_fmt,
3141 char *options, uint64_t img_size, int flags)
3142 {
3143 QEMUOptionParameter *param = NULL, *create_options = NULL;
3144 QEMUOptionParameter *backing_fmt, *backing_file, *size;
3145 BlockDriverState *bs = NULL;
3146 BlockDriver *drv, *proto_drv;
3147 BlockDriver *backing_drv = NULL;
3148 int ret = 0;
3149
3150 /* Find driver and parse its options */
3151 drv = bdrv_find_format(fmt);
3152 if (!drv) {
3153 error_report("Unknown file format '%s'", fmt);
3154 ret = -EINVAL;
3155 goto out;
3156 }
3157
3158 proto_drv = bdrv_find_protocol(filename);
3159 if (!proto_drv) {
3160 error_report("Unknown protocol '%s'", filename);
3161 ret = -EINVAL;
3162 goto out;
3163 }
3164
3165 create_options = append_option_parameters(create_options,
3166 drv->create_options);
3167 create_options = append_option_parameters(create_options,
3168 proto_drv->create_options);
3169
3170 /* Create parameter list with default values */
3171 param = parse_option_parameters("", create_options, param);
3172
3173 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
3174
3175 /* Parse -o options */
3176 if (options) {
3177 param = parse_option_parameters(options, create_options, param);
3178 if (param == NULL) {
3179 error_report("Invalid options for file format '%s'.", fmt);
3180 ret = -EINVAL;
3181 goto out;
3182 }
3183 }
3184
3185 if (base_filename) {
3186 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
3187 base_filename)) {
3188 error_report("Backing file not supported for file format '%s'",
3189 fmt);
3190 ret = -EINVAL;
3191 goto out;
3192 }
3193 }
3194
3195 if (base_fmt) {
3196 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
3197 error_report("Backing file format not supported for file "
3198 "format '%s'", fmt);
3199 ret = -EINVAL;
3200 goto out;
3201 }
3202 }
3203
3204 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
3205 if (backing_file && backing_file->value.s) {
3206 if (!strcmp(filename, backing_file->value.s)) {
3207 error_report("Error: Trying to create an image with the "
3208 "same filename as the backing file");
3209 ret = -EINVAL;
3210 goto out;
3211 }
3212 }
3213
3214 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
3215 if (backing_fmt && backing_fmt->value.s) {
3216 backing_drv = bdrv_find_format(backing_fmt->value.s);
3217 if (!backing_drv) {
3218 error_report("Unknown backing file format '%s'",
3219 backing_fmt->value.s);
3220 ret = -EINVAL;
3221 goto out;
3222 }
3223 }
3224
3225 // The size for the image must always be specified, with one exception:
3226 // If we are using a backing file, we can obtain the size from there
3227 size = get_option_parameter(param, BLOCK_OPT_SIZE);
3228 if (size && size->value.n == -1) {
3229 if (backing_file && backing_file->value.s) {
3230 uint64_t size;
3231 char buf[32];
3232
3233 bs = bdrv_new("");
3234
3235 ret = bdrv_open(bs, backing_file->value.s, flags, backing_drv);
3236 if (ret < 0) {
3237 error_report("Could not open '%s'", backing_file->value.s);
3238 goto out;
3239 }
3240 bdrv_get_geometry(bs, &size);
3241 size *= 512;
3242
3243 snprintf(buf, sizeof(buf), "%" PRId64, size);
3244 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
3245 } else {
3246 error_report("Image creation needs a size parameter");
3247 ret = -EINVAL;
3248 goto out;
3249 }
3250 }
3251
3252 printf("Formatting '%s', fmt=%s ", filename, fmt);
3253 print_option_parameters(param);
3254 puts("");
3255
3256 ret = bdrv_create(drv, filename, param);
3257
3258 if (ret < 0) {
3259 if (ret == -ENOTSUP) {
3260 error_report("Formatting or formatting option not supported for "
3261 "file format '%s'", fmt);
3262 } else if (ret == -EFBIG) {
3263 error_report("The image size is too large for file format '%s'",
3264 fmt);
3265 } else {
3266 error_report("%s: error while creating %s: %s", filename, fmt,
3267 strerror(-ret));
3268 }
3269 }
3270
3271 out:
3272 free_option_parameters(create_options);
3273 free_option_parameters(param);
3274
3275 if (bs) {
3276 bdrv_delete(bs);
3277 }
3278
3279 return ret;
3280 }
QEmu