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