?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
QMP: Teach basic capability negotiation to python example
[qemu.git] / block.c
blobe71a771e06a43ff8ab8c1cc697ba086fb0ad8ea3
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 "monitor.h"
27 #include "block_int.h"
28 #include "module.h"
29 #include "qemu-objects.h"
30
31 #ifdef CONFIG_BSD
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <sys/ioctl.h>
35 #include <sys/queue.h>
36 #ifndef __DragonFly__
37 #include <sys/disk.h>
38 #endif
39 #endif
40
41 #ifdef _WIN32
42 #include <windows.h>
43 #endif
44
45 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
46 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
47 BlockDriverCompletionFunc *cb, void *opaque);
48 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
49 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
50 BlockDriverCompletionFunc *cb, void *opaque);
51 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
52 BlockDriverCompletionFunc *cb, void *opaque);
53 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
54 BlockDriverCompletionFunc *cb, void *opaque);
55 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
56 uint8_t *buf, int nb_sectors);
57 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
58 const uint8_t *buf, int nb_sectors);
59
60 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
61 QTAILQ_HEAD_INITIALIZER(bdrv_states);
62
63 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
64 QLIST_HEAD_INITIALIZER(bdrv_drivers);
65
66 /* If non-zero, use only whitelisted block drivers */
67 static int use_bdrv_whitelist;
68
69 int path_is_absolute(const char *path)
70 {
71 const char *p;
72 #ifdef _WIN32
73 /* specific case for names like: "\\.\d:" */
74 if (*path == '/' || *path == '\\')
75 return 1;
76 #endif
77 p = strchr(path, ':');
78 if (p)
79 p++;
80 else
81 p = path;
82 #ifdef _WIN32
83 return (*p == '/' || *p == '\\');
84 #else
85 return (*p == '/');
86 #endif
87 }
88
89 /* if filename is absolute, just copy it to dest. Otherwise, build a
90 path to it by considering it is relative to base_path. URL are
91 supported. */
92 void path_combine(char *dest, int dest_size,
93 const char *base_path,
94 const char *filename)
95 {
96 const char *p, *p1;
97 int len;
98
99 if (dest_size <= 0)
100 return;
101 if (path_is_absolute(filename)) {
102 pstrcpy(dest, dest_size, filename);
103 } else {
104 p = strchr(base_path, ':');
105 if (p)
106 p++;
107 else
108 p = base_path;
109 p1 = strrchr(base_path, '/');
110 #ifdef _WIN32
111 {
112 const char *p2;
113 p2 = strrchr(base_path, '\\');
114 if (!p1 || p2 > p1)
115 p1 = p2;
116 }
117 #endif
118 if (p1)
119 p1++;
120 else
121 p1 = base_path;
122 if (p1 > p)
123 p = p1;
124 len = p - base_path;
125 if (len > dest_size - 1)
126 len = dest_size - 1;
127 memcpy(dest, base_path, len);
128 dest[len] = '\0';
129 pstrcat(dest, dest_size, filename);
130 }
131 }
132
133 void bdrv_register(BlockDriver *bdrv)
134 {
135 if (!bdrv->bdrv_aio_readv) {
136 /* add AIO emulation layer */
137 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
138 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
139 } else if (!bdrv->bdrv_read) {
140 /* add synchronous IO emulation layer */
141 bdrv->bdrv_read = bdrv_read_em;
142 bdrv->bdrv_write = bdrv_write_em;
143 }
144
145 if (!bdrv->bdrv_aio_flush)
146 bdrv->bdrv_aio_flush = bdrv_aio_flush_em;
147
148 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
149 }
150
151 /* create a new block device (by default it is empty) */
152 BlockDriverState *bdrv_new(const char *device_name)
153 {
154 BlockDriverState *bs;
155
156 bs = qemu_mallocz(sizeof(BlockDriverState));
157 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
158 if (device_name[0] != '\0') {
159 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
160 }
161 return bs;
162 }
163
164 BlockDriver *bdrv_find_format(const char *format_name)
165 {
166 BlockDriver *drv1;
167 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
168 if (!strcmp(drv1->format_name, format_name)) {
169 return drv1;
170 }
171 }
172 return NULL;
173 }
174
175 static int bdrv_is_whitelisted(BlockDriver *drv)
176 {
177 static const char *whitelist[] = {
178 CONFIG_BDRV_WHITELIST
179 };
180 const char **p;
181
182 if (!whitelist[0])
183 return 1; /* no whitelist, anything goes */
184
185 for (p = whitelist; *p; p++) {
186 if (!strcmp(drv->format_name, *p)) {
187 return 1;
188 }
189 }
190 return 0;
191 }
192
193 BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
194 {
195 BlockDriver *drv = bdrv_find_format(format_name);
196 return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
197 }
198
199 int bdrv_create(BlockDriver *drv, const char* filename,
200 QEMUOptionParameter *options)
201 {
202 if (!drv->bdrv_create)
203 return -ENOTSUP;
204
205 return drv->bdrv_create(filename, options);
206 }
207
208 int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
209 {
210 BlockDriver *drv;
211
212 drv = bdrv_find_protocol(filename);
213 if (drv == NULL) {
214 drv = bdrv_find_format("file");
215 }
216
217 return bdrv_create(drv, filename, options);
218 }
219
220 #ifdef _WIN32
221 void get_tmp_filename(char *filename, int size)
222 {
223 char temp_dir[MAX_PATH];
224
225 GetTempPath(MAX_PATH, temp_dir);
226 GetTempFileName(temp_dir, "qem", 0, filename);
227 }
228 #else
229 void get_tmp_filename(char *filename, int size)
230 {
231 int fd;
232 const char *tmpdir;
233 /* XXX: race condition possible */
234 tmpdir = getenv("TMPDIR");
235 if (!tmpdir)
236 tmpdir = "/tmp";
237 snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
238 fd = mkstemp(filename);
239 close(fd);
240 }
241 #endif
242
243 #ifdef _WIN32
244 static int is_windows_drive_prefix(const char *filename)
245 {
246 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
247 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
248 filename[1] == ':');
249 }
250
251 int is_windows_drive(const char *filename)
252 {
253 if (is_windows_drive_prefix(filename) &&
254 filename[2] == '\0')
255 return 1;
256 if (strstart(filename, "\\\\.\\", NULL) ||
257 strstart(filename, "//./", NULL))
258 return 1;
259 return 0;
260 }
261 #endif
262
263 /*
264 * Detect host devices. By convention, /dev/cdrom[N] is always
265 * recognized as a host CDROM.
266 */
267 static BlockDriver *find_hdev_driver(const char *filename)
268 {
269 int score_max = 0, score;
270 BlockDriver *drv = NULL, *d;
271
272 QLIST_FOREACH(d, &bdrv_drivers, list) {
273 if (d->bdrv_probe_device) {
274 score = d->bdrv_probe_device(filename);
275 if (score > score_max) {
276 score_max = score;
277 drv = d;
278 }
279 }
280 }
281
282 return drv;
283 }
284
285 BlockDriver *bdrv_find_protocol(const char *filename)
286 {
287 BlockDriver *drv1;
288 char protocol[128];
289 int len;
290 const char *p;
291 int is_drive;
292
293 /* TODO Drivers without bdrv_file_open must be specified explicitly */
294
295 #ifdef _WIN32
296 is_drive = is_windows_drive(filename) ||
297 is_windows_drive_prefix(filename);
298 #else
299 is_drive = 0;
300 #endif
301 p = strchr(filename, ':');
302 if (!p || is_drive) {
303 drv1 = find_hdev_driver(filename);
304 if (!drv1) {
305 drv1 = bdrv_find_format("file");
306 }
307 return drv1;
308 }
309 len = p - filename;
310 if (len > sizeof(protocol) - 1)
311 len = sizeof(protocol) - 1;
312 memcpy(protocol, filename, len);
313 protocol[len] = '\0';
314 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
315 if (drv1->protocol_name &&
316 !strcmp(drv1->protocol_name, protocol)) {
317 return drv1;
318 }
319 }
320 return NULL;
321 }
322
323 static BlockDriver *find_image_format(const char *filename)
324 {
325 int ret, score, score_max;
326 BlockDriver *drv1, *drv;
327 uint8_t buf[2048];
328 BlockDriverState *bs;
329
330 ret = bdrv_file_open(&bs, filename, 0);
331 if (ret < 0)
332 return NULL;
333
334 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
335 if (bs->sg || !bdrv_is_inserted(bs)) {
336 bdrv_delete(bs);
337 return bdrv_find_format("raw");
338 }
339
340 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
341 bdrv_delete(bs);
342 if (ret < 0) {
343 return NULL;
344 }
345
346 score_max = 0;
347 drv = NULL;
348 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
349 if (drv1->bdrv_probe) {
350 score = drv1->bdrv_probe(buf, ret, filename);
351 if (score > score_max) {
352 score_max = score;
353 drv = drv1;
354 }
355 }
356 }
357 return drv;
358 }
359
360 /**
361 * Set the current 'total_sectors' value
362 */
363 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
364 {
365 BlockDriver *drv = bs->drv;
366
367 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
368 if (bs->sg)
369 return 0;
370
371 /* query actual device if possible, otherwise just trust the hint */
372 if (drv->bdrv_getlength) {
373 int64_t length = drv->bdrv_getlength(bs);
374 if (length < 0) {
375 return length;
376 }
377 hint = length >> BDRV_SECTOR_BITS;
378 }
379
380 bs->total_sectors = hint;
381 return 0;
382 }
383
384 /*
385 * Common part for opening disk images and files
386 */
387 static int bdrv_open_common(BlockDriverState *bs, const char *filename,
388 int flags, BlockDriver *drv)
389 {
390 int ret, open_flags;
391
392 assert(drv != NULL);
393
394 bs->file = NULL;
395 bs->total_sectors = 0;
396 bs->is_temporary = 0;
397 bs->encrypted = 0;
398 bs->valid_key = 0;
399 bs->open_flags = flags;
400 /* buffer_alignment defaulted to 512, drivers can change this value */
401 bs->buffer_alignment = 512;
402
403 pstrcpy(bs->filename, sizeof(bs->filename), filename);
404
405 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
406 return -ENOTSUP;
407 }
408
409 bs->drv = drv;
410 bs->opaque = qemu_mallocz(drv->instance_size);
411
412 /*
413 * Yes, BDRV_O_NOCACHE aka O_DIRECT means we have to present a
414 * write cache to the guest. We do need the fdatasync to flush
415 * out transactions for block allocations, and we maybe have a
416 * volatile write cache in our backing device to deal with.
417 */
418 if (flags & (BDRV_O_CACHE_WB|BDRV_O_NOCACHE))
419 bs->enable_write_cache = 1;
420
421 /*
422 * Clear flags that are internal to the block layer before opening the
423 * image.
424 */
425 open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
426
427 /*
428 * Snapshots should be writeable.
429 */
430 if (bs->is_temporary) {
431 open_flags |= BDRV_O_RDWR;
432 }
433
434 /* Open the image, either directly or using a protocol */
435 if (drv->bdrv_file_open) {
436 ret = drv->bdrv_file_open(bs, filename, open_flags);
437 } else {
438 ret = bdrv_file_open(&bs->file, filename, open_flags);
439 if (ret >= 0) {
440 ret = drv->bdrv_open(bs, open_flags);
441 }
442 }
443
444 if (ret < 0) {
445 goto free_and_fail;
446 }
447
448 bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
449
450 ret = refresh_total_sectors(bs, bs->total_sectors);
451 if (ret < 0) {
452 goto free_and_fail;
453 }
454
455 #ifndef _WIN32
456 if (bs->is_temporary) {
457 unlink(filename);
458 }
459 #endif
460 return 0;
461
462 free_and_fail:
463 if (bs->file) {
464 bdrv_delete(bs->file);
465 bs->file = NULL;
466 }
467 qemu_free(bs->opaque);
468 bs->opaque = NULL;
469 bs->drv = NULL;
470 return ret;
471 }
472
473 /*
474 * Opens a file using a protocol (file, host_device, nbd, ...)
475 */
476 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
477 {
478 BlockDriverState *bs;
479 BlockDriver *drv;
480 int ret;
481
482 drv = bdrv_find_protocol(filename);
483 if (!drv) {
484 return -ENOENT;
485 }
486
487 bs = bdrv_new("");
488 ret = bdrv_open_common(bs, filename, flags, drv);
489 if (ret < 0) {
490 bdrv_delete(bs);
491 return ret;
492 }
493 bs->growable = 1;
494 *pbs = bs;
495 return 0;
496 }
497
498 /*
499 * Opens a disk image (raw, qcow2, vmdk, ...)
500 */
501 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
502 BlockDriver *drv)
503 {
504 int ret;
505
506 if (flags & BDRV_O_SNAPSHOT) {
507 BlockDriverState *bs1;
508 int64_t total_size;
509 int is_protocol = 0;
510 BlockDriver *bdrv_qcow2;
511 QEMUOptionParameter *options;
512 char tmp_filename[PATH_MAX];
513 char backing_filename[PATH_MAX];
514
515 /* if snapshot, we create a temporary backing file and open it
516 instead of opening 'filename' directly */
517
518 /* if there is a backing file, use it */
519 bs1 = bdrv_new("");
520 ret = bdrv_open(bs1, filename, 0, drv);
521 if (ret < 0) {
522 bdrv_delete(bs1);
523 return ret;
524 }
525 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
526
527 if (bs1->drv && bs1->drv->protocol_name)
528 is_protocol = 1;
529
530 bdrv_delete(bs1);
531
532 get_tmp_filename(tmp_filename, sizeof(tmp_filename));
533
534 /* Real path is meaningless for protocols */
535 if (is_protocol)
536 snprintf(backing_filename, sizeof(backing_filename),
537 "%s", filename);
538 else if (!realpath(filename, backing_filename))
539 return -errno;
540
541 bdrv_qcow2 = bdrv_find_format("qcow2");
542 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
543
544 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
545 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
546 if (drv) {
547 set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
548 drv->format_name);
549 }
550
551 ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
552 free_option_parameters(options);
553 if (ret < 0) {
554 return ret;
555 }
556
557 filename = tmp_filename;
558 drv = bdrv_qcow2;
559 bs->is_temporary = 1;
560 }
561
562 /* Find the right image format driver */
563 if (!drv) {
564 drv = find_image_format(filename);
565 }
566
567 if (!drv) {
568 ret = -ENOENT;
569 goto unlink_and_fail;
570 }
571
572 /* Open the image */
573 ret = bdrv_open_common(bs, filename, flags, drv);
574 if (ret < 0) {
575 goto unlink_and_fail;
576 }
577
578 /* If there is a backing file, use it */
579 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
580 char backing_filename[PATH_MAX];
581 int back_flags;
582 BlockDriver *back_drv = NULL;
583
584 bs->backing_hd = bdrv_new("");
585 path_combine(backing_filename, sizeof(backing_filename),
586 filename, bs->backing_file);
587 if (bs->backing_format[0] != '\0')
588 back_drv = bdrv_find_format(bs->backing_format);
589
590 /* backing files always opened read-only */
591 back_flags =
592 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
593
594 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
595 if (ret < 0) {
596 bdrv_close(bs);
597 return ret;
598 }
599 if (bs->is_temporary) {
600 bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
601 } else {
602 /* base image inherits from "parent" */
603 bs->backing_hd->keep_read_only = bs->keep_read_only;
604 }
605 }
606
607 if (!bdrv_key_required(bs)) {
608 /* call the change callback */
609 bs->media_changed = 1;
610 if (bs->change_cb)
611 bs->change_cb(bs->change_opaque);
612 }
613
614 return 0;
615
616 unlink_and_fail:
617 if (bs->is_temporary) {
618 unlink(filename);
619 }
620 return ret;
621 }
622
623 void bdrv_close(BlockDriverState *bs)
624 {
625 if (bs->drv) {
626 if (bs->backing_hd) {
627 bdrv_delete(bs->backing_hd);
628 bs->backing_hd = NULL;
629 }
630 bs->drv->bdrv_close(bs);
631 qemu_free(bs->opaque);
632 #ifdef _WIN32
633 if (bs->is_temporary) {
634 unlink(bs->filename);
635 }
636 #endif
637 bs->opaque = NULL;
638 bs->drv = NULL;
639
640 if (bs->file != NULL) {
641 bdrv_close(bs->file);
642 }
643
644 /* call the change callback */
645 bs->media_changed = 1;
646 if (bs->change_cb)
647 bs->change_cb(bs->change_opaque);
648 }
649 }
650
651 void bdrv_close_all(void)
652 {
653 BlockDriverState *bs;
654
655 QTAILQ_FOREACH(bs, &bdrv_states, list) {
656 bdrv_close(bs);
657 }
658 }
659
660 void bdrv_delete(BlockDriverState *bs)
661 {
662 /* remove from list, if necessary */
663 if (bs->device_name[0] != '\0') {
664 QTAILQ_REMOVE(&bdrv_states, bs, list);
665 }
666
667 bdrv_close(bs);
668 if (bs->file != NULL) {
669 bdrv_delete(bs->file);
670 }
671
672 qemu_free(bs);
673 }
674
675 /*
676 * Run consistency checks on an image
677 *
678 * Returns the number of errors or -errno when an internal error occurs
679 */
680 int bdrv_check(BlockDriverState *bs)
681 {
682 if (bs->drv->bdrv_check == NULL) {
683 return -ENOTSUP;
684 }
685
686 return bs->drv->bdrv_check(bs);
687 }
688
689 /* commit COW file into the raw image */
690 int bdrv_commit(BlockDriverState *bs)
691 {
692 BlockDriver *drv = bs->drv;
693 int64_t i, total_sectors;
694 int n, j, ro, open_flags;
695 int ret = 0, rw_ret = 0;
696 unsigned char sector[BDRV_SECTOR_SIZE];
697 char filename[1024];
698 BlockDriverState *bs_rw, *bs_ro;
699
700 if (!drv)
701 return -ENOMEDIUM;
702
703 if (!bs->backing_hd) {
704 return -ENOTSUP;
705 }
706
707 if (bs->backing_hd->keep_read_only) {
708 return -EACCES;
709 }
710
711 ro = bs->backing_hd->read_only;
712 strncpy(filename, bs->backing_hd->filename, sizeof(filename));
713 open_flags = bs->backing_hd->open_flags;
714
715 if (ro) {
716 /* re-open as RW */
717 bdrv_delete(bs->backing_hd);
718 bs->backing_hd = NULL;
719 bs_rw = bdrv_new("");
720 rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR, drv);
721 if (rw_ret < 0) {
722 bdrv_delete(bs_rw);
723 /* try to re-open read-only */
724 bs_ro = bdrv_new("");
725 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, drv);
726 if (ret < 0) {
727 bdrv_delete(bs_ro);
728 /* drive not functional anymore */
729 bs->drv = NULL;
730 return ret;
731 }
732 bs->backing_hd = bs_ro;
733 return rw_ret;
734 }
735 bs->backing_hd = bs_rw;
736 }
737
738 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
739 for (i = 0; i < total_sectors;) {
740 if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
741 for(j = 0; j < n; j++) {
742 if (bdrv_read(bs, i, sector, 1) != 0) {
743 ret = -EIO;
744 goto ro_cleanup;
745 }
746
747 if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
748 ret = -EIO;
749 goto ro_cleanup;
750 }
751 i++;
752 }
753 } else {
754 i += n;
755 }
756 }
757
758 if (drv->bdrv_make_empty) {
759 ret = drv->bdrv_make_empty(bs);
760 bdrv_flush(bs);
761 }
762
763 /*
764 * Make sure all data we wrote to the backing device is actually
765 * stable on disk.
766 */
767 if (bs->backing_hd)
768 bdrv_flush(bs->backing_hd);
769
770 ro_cleanup:
771
772 if (ro) {
773 /* re-open as RO */
774 bdrv_delete(bs->backing_hd);
775 bs->backing_hd = NULL;
776 bs_ro = bdrv_new("");
777 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, drv);
778 if (ret < 0) {
779 bdrv_delete(bs_ro);
780 /* drive not functional anymore */
781 bs->drv = NULL;
782 return ret;
783 }
784 bs->backing_hd = bs_ro;
785 bs->backing_hd->keep_read_only = 0;
786 }
787
788 return ret;
789 }
790
791 void bdrv_commit_all(void)
792 {
793 BlockDriverState *bs;
794
795 QTAILQ_FOREACH(bs, &bdrv_states, list) {
796 bdrv_commit(bs);
797 }
798 }
799
800 /*
801 * Return values:
802 * 0 - success
803 * -EINVAL - backing format specified, but no file
804 * -ENOSPC - can't update the backing file because no space is left in the
805 * image file header
806 * -ENOTSUP - format driver doesn't support changing the backing file
807 */
808 int bdrv_change_backing_file(BlockDriverState *bs,
809 const char *backing_file, const char *backing_fmt)
810 {
811 BlockDriver *drv = bs->drv;
812
813 if (drv->bdrv_change_backing_file != NULL) {
814 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
815 } else {
816 return -ENOTSUP;
817 }
818 }
819
820 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
821 size_t size)
822 {
823 int64_t len;
824
825 if (!bdrv_is_inserted(bs))
826 return -ENOMEDIUM;
827
828 if (bs->growable)
829 return 0;
830
831 len = bdrv_getlength(bs);
832
833 if (offset < 0)
834 return -EIO;
835
836 if ((offset > len) || (len - offset < size))
837 return -EIO;
838
839 return 0;
840 }
841
842 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
843 int nb_sectors)
844 {
845 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
846 nb_sectors * BDRV_SECTOR_SIZE);
847 }
848
849 /* return < 0 if error. See bdrv_write() for the return codes */
850 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
851 uint8_t *buf, int nb_sectors)
852 {
853 BlockDriver *drv = bs->drv;
854
855 if (!drv)
856 return -ENOMEDIUM;
857 if (bdrv_check_request(bs, sector_num, nb_sectors))
858 return -EIO;
859
860 return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
861 }
862
863 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
864 int nb_sectors, int dirty)
865 {
866 int64_t start, end;
867 unsigned long val, idx, bit;
868
869 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
870 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
871
872 for (; start <= end; start++) {
873 idx = start / (sizeof(unsigned long) * 8);
874 bit = start % (sizeof(unsigned long) * 8);
875 val = bs->dirty_bitmap[idx];
876 if (dirty) {
877 if (!(val & (1 << bit))) {
878 bs->dirty_count++;
879 val |= 1 << bit;
880 }
881 } else {
882 if (val & (1 << bit)) {
883 bs->dirty_count--;
884 val &= ~(1 << bit);
885 }
886 }
887 bs->dirty_bitmap[idx] = val;
888 }
889 }
890
891 /* Return < 0 if error. Important errors are:
892 -EIO generic I/O error (may happen for all errors)
893 -ENOMEDIUM No media inserted.
894 -EINVAL Invalid sector number or nb_sectors
895 -EACCES Trying to write a read-only device
896 */
897 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
898 const uint8_t *buf, int nb_sectors)
899 {
900 BlockDriver *drv = bs->drv;
901 if (!bs->drv)
902 return -ENOMEDIUM;
903 if (bs->read_only)
904 return -EACCES;
905 if (bdrv_check_request(bs, sector_num, nb_sectors))
906 return -EIO;
907
908 if (bs->dirty_bitmap) {
909 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
910 }
911
912 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
913 bs->wr_highest_sector = sector_num + nb_sectors - 1;
914 }
915
916 return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
917 }
918
919 int bdrv_pread(BlockDriverState *bs, int64_t offset,
920 void *buf, int count1)
921 {
922 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
923 int len, nb_sectors, count;
924 int64_t sector_num;
925 int ret;
926
927 count = count1;
928 /* first read to align to sector start */
929 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
930 if (len > count)
931 len = count;
932 sector_num = offset >> BDRV_SECTOR_BITS;
933 if (len > 0) {
934 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
935 return ret;
936 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
937 count -= len;
938 if (count == 0)
939 return count1;
940 sector_num++;
941 buf += len;
942 }
943
944 /* read the sectors "in place" */
945 nb_sectors = count >> BDRV_SECTOR_BITS;
946 if (nb_sectors > 0) {
947 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
948 return ret;
949 sector_num += nb_sectors;
950 len = nb_sectors << BDRV_SECTOR_BITS;
951 buf += len;
952 count -= len;
953 }
954
955 /* add data from the last sector */
956 if (count > 0) {
957 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
958 return ret;
959 memcpy(buf, tmp_buf, count);
960 }
961 return count1;
962 }
963
964 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
965 const void *buf, int count1)
966 {
967 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
968 int len, nb_sectors, count;
969 int64_t sector_num;
970 int ret;
971
972 count = count1;
973 /* first write to align to sector start */
974 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
975 if (len > count)
976 len = count;
977 sector_num = offset >> BDRV_SECTOR_BITS;
978 if (len > 0) {
979 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
980 return ret;
981 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
982 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
983 return ret;
984 count -= len;
985 if (count == 0)
986 return count1;
987 sector_num++;
988 buf += len;
989 }
990
991 /* write the sectors "in place" */
992 nb_sectors = count >> BDRV_SECTOR_BITS;
993 if (nb_sectors > 0) {
994 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
995 return ret;
996 sector_num += nb_sectors;
997 len = nb_sectors << BDRV_SECTOR_BITS;
998 buf += len;
999 count -= len;
1000 }
1001
1002 /* add data from the last sector */
1003 if (count > 0) {
1004 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1005 return ret;
1006 memcpy(tmp_buf, buf, count);
1007 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1008 return ret;
1009 }
1010 return count1;
1011 }
1012
1013 /*
1014 * Writes to the file and ensures that no writes are reordered across this
1015 * request (acts as a barrier)
1016 *
1017 * Returns 0 on success, -errno in error cases.
1018 */
1019 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1020 const void *buf, int count)
1021 {
1022 int ret;
1023
1024 ret = bdrv_pwrite(bs, offset, buf, count);
1025 if (ret < 0) {
1026 return ret;
1027 }
1028
1029 /* No flush needed for cache=writethrough, it uses O_DSYNC */
1030 if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) {
1031 bdrv_flush(bs);
1032 }
1033
1034 return 0;
1035 }
1036
1037 /*
1038 * Writes to the file and ensures that no writes are reordered across this
1039 * request (acts as a barrier)
1040 *
1041 * Returns 0 on success, -errno in error cases.
1042 */
1043 int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num,
1044 const uint8_t *buf, int nb_sectors)
1045 {
1046 return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num,
1047 buf, BDRV_SECTOR_SIZE * nb_sectors);
1048 }
1049
1050 /**
1051 * Truncate file to 'offset' bytes (needed only for file protocols)
1052 */
1053 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1054 {
1055 BlockDriver *drv = bs->drv;
1056 int ret;
1057 if (!drv)
1058 return -ENOMEDIUM;
1059 if (!drv->bdrv_truncate)
1060 return -ENOTSUP;
1061 if (bs->read_only)
1062 return -EACCES;
1063 ret = drv->bdrv_truncate(bs, offset);
1064 if (ret == 0) {
1065 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1066 }
1067 return ret;
1068 }
1069
1070 /**
1071 * Length of a file in bytes. Return < 0 if error or unknown.
1072 */
1073 int64_t bdrv_getlength(BlockDriverState *bs)
1074 {
1075 BlockDriver *drv = bs->drv;
1076 if (!drv)
1077 return -ENOMEDIUM;
1078
1079 /* Fixed size devices use the total_sectors value for speed instead of
1080 issuing a length query (like lseek) on each call. Also, legacy block
1081 drivers don't provide a bdrv_getlength function and must use
1082 total_sectors. */
1083 if (!bs->growable || !drv->bdrv_getlength) {
1084 return bs->total_sectors * BDRV_SECTOR_SIZE;
1085 }
1086 return drv->bdrv_getlength(bs);
1087 }
1088
1089 /* return 0 as number of sectors if no device present or error */
1090 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1091 {
1092 int64_t length;
1093 length = bdrv_getlength(bs);
1094 if (length < 0)
1095 length = 0;
1096 else
1097 length = length >> BDRV_SECTOR_BITS;
1098 *nb_sectors_ptr = length;
1099 }
1100
1101 struct partition {
1102 uint8_t boot_ind; /* 0x80 - active */
1103 uint8_t head; /* starting head */
1104 uint8_t sector; /* starting sector */
1105 uint8_t cyl; /* starting cylinder */
1106 uint8_t sys_ind; /* What partition type */
1107 uint8_t end_head; /* end head */
1108 uint8_t end_sector; /* end sector */
1109 uint8_t end_cyl; /* end cylinder */
1110 uint32_t start_sect; /* starting sector counting from 0 */
1111 uint32_t nr_sects; /* nr of sectors in partition */
1112 } __attribute__((packed));
1113
1114 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1115 static int guess_disk_lchs(BlockDriverState *bs,
1116 int *pcylinders, int *pheads, int *psectors)
1117 {
1118 uint8_t buf[BDRV_SECTOR_SIZE];
1119 int ret, i, heads, sectors, cylinders;
1120 struct partition *p;
1121 uint32_t nr_sects;
1122 uint64_t nb_sectors;
1123
1124 bdrv_get_geometry(bs, &nb_sectors);
1125
1126 ret = bdrv_read(bs, 0, buf, 1);
1127 if (ret < 0)
1128 return -1;
1129 /* test msdos magic */
1130 if (buf[510] != 0x55 || buf[511] != 0xaa)
1131 return -1;
1132 for(i = 0; i < 4; i++) {
1133 p = ((struct partition *)(buf + 0x1be)) + i;
1134 nr_sects = le32_to_cpu(p->nr_sects);
1135 if (nr_sects && p->end_head) {
1136 /* We make the assumption that the partition terminates on
1137 a cylinder boundary */
1138 heads = p->end_head + 1;
1139 sectors = p->end_sector & 63;
1140 if (sectors == 0)
1141 continue;
1142 cylinders = nb_sectors / (heads * sectors);
1143 if (cylinders < 1 || cylinders > 16383)
1144 continue;
1145 *pheads = heads;
1146 *psectors = sectors;
1147 *pcylinders = cylinders;
1148 #if 0
1149 printf("guessed geometry: LCHS=%d %d %d\n",
1150 cylinders, heads, sectors);
1151 #endif
1152 return 0;
1153 }
1154 }
1155 return -1;
1156 }
1157
1158 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1159 {
1160 int translation, lba_detected = 0;
1161 int cylinders, heads, secs;
1162 uint64_t nb_sectors;
1163
1164 /* if a geometry hint is available, use it */
1165 bdrv_get_geometry(bs, &nb_sectors);
1166 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1167 translation = bdrv_get_translation_hint(bs);
1168 if (cylinders != 0) {
1169 *pcyls = cylinders;
1170 *pheads = heads;
1171 *psecs = secs;
1172 } else {
1173 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1174 if (heads > 16) {
1175 /* if heads > 16, it means that a BIOS LBA
1176 translation was active, so the default
1177 hardware geometry is OK */
1178 lba_detected = 1;
1179 goto default_geometry;
1180 } else {
1181 *pcyls = cylinders;
1182 *pheads = heads;
1183 *psecs = secs;
1184 /* disable any translation to be in sync with
1185 the logical geometry */
1186 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
1187 bdrv_set_translation_hint(bs,
1188 BIOS_ATA_TRANSLATION_NONE);
1189 }
1190 }
1191 } else {
1192 default_geometry:
1193 /* if no geometry, use a standard physical disk geometry */
1194 cylinders = nb_sectors / (16 * 63);
1195
1196 if (cylinders > 16383)
1197 cylinders = 16383;
1198 else if (cylinders < 2)
1199 cylinders = 2;
1200 *pcyls = cylinders;
1201 *pheads = 16;
1202 *psecs = 63;
1203 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
1204 if ((*pcyls * *pheads) <= 131072) {
1205 bdrv_set_translation_hint(bs,
1206 BIOS_ATA_TRANSLATION_LARGE);
1207 } else {
1208 bdrv_set_translation_hint(bs,
1209 BIOS_ATA_TRANSLATION_LBA);
1210 }
1211 }
1212 }
1213 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1214 }
1215 }
1216
1217 void bdrv_set_geometry_hint(BlockDriverState *bs,
1218 int cyls, int heads, int secs)
1219 {
1220 bs->cyls = cyls;
1221 bs->heads = heads;
1222 bs->secs = secs;
1223 }
1224
1225 void bdrv_set_type_hint(BlockDriverState *bs, int type)
1226 {
1227 bs->type = type;
1228 bs->removable = ((type == BDRV_TYPE_CDROM ||
1229 type == BDRV_TYPE_FLOPPY));
1230 }
1231
1232 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1233 {
1234 bs->translation = translation;
1235 }
1236
1237 void bdrv_get_geometry_hint(BlockDriverState *bs,
1238 int *pcyls, int *pheads, int *psecs)
1239 {
1240 *pcyls = bs->cyls;
1241 *pheads = bs->heads;
1242 *psecs = bs->secs;
1243 }
1244
1245 int bdrv_get_type_hint(BlockDriverState *bs)
1246 {
1247 return bs->type;
1248 }
1249
1250 int bdrv_get_translation_hint(BlockDriverState *bs)
1251 {
1252 return bs->translation;
1253 }
1254
1255 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1256 BlockErrorAction on_write_error)
1257 {
1258 bs->on_read_error = on_read_error;
1259 bs->on_write_error = on_write_error;
1260 }
1261
1262 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
1263 {
1264 return is_read ? bs->on_read_error : bs->on_write_error;
1265 }
1266
1267 int bdrv_is_removable(BlockDriverState *bs)
1268 {
1269 return bs->removable;
1270 }
1271
1272 int bdrv_is_read_only(BlockDriverState *bs)
1273 {
1274 return bs->read_only;
1275 }
1276
1277 int bdrv_is_sg(BlockDriverState *bs)
1278 {
1279 return bs->sg;
1280 }
1281
1282 int bdrv_enable_write_cache(BlockDriverState *bs)
1283 {
1284 return bs->enable_write_cache;
1285 }
1286
1287 /* XXX: no longer used */
1288 void bdrv_set_change_cb(BlockDriverState *bs,
1289 void (*change_cb)(void *opaque), void *opaque)
1290 {
1291 bs->change_cb = change_cb;
1292 bs->change_opaque = opaque;
1293 }
1294
1295 int bdrv_is_encrypted(BlockDriverState *bs)
1296 {
1297 if (bs->backing_hd && bs->backing_hd->encrypted)
1298 return 1;
1299 return bs->encrypted;
1300 }
1301
1302 int bdrv_key_required(BlockDriverState *bs)
1303 {
1304 BlockDriverState *backing_hd = bs->backing_hd;
1305
1306 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
1307 return 1;
1308 return (bs->encrypted && !bs->valid_key);
1309 }
1310
1311 int bdrv_set_key(BlockDriverState *bs, const char *key)
1312 {
1313 int ret;
1314 if (bs->backing_hd && bs->backing_hd->encrypted) {
1315 ret = bdrv_set_key(bs->backing_hd, key);
1316 if (ret < 0)
1317 return ret;
1318 if (!bs->encrypted)
1319 return 0;
1320 }
1321 if (!bs->encrypted) {
1322 return -EINVAL;
1323 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1324 return -ENOMEDIUM;
1325 }
1326 ret = bs->drv->bdrv_set_key(bs, key);
1327 if (ret < 0) {
1328 bs->valid_key = 0;
1329 } else if (!bs->valid_key) {
1330 bs->valid_key = 1;
1331 /* call the change callback now, we skipped it on open */
1332 bs->media_changed = 1;
1333 if (bs->change_cb)
1334 bs->change_cb(bs->change_opaque);
1335 }
1336 return ret;
1337 }
1338
1339 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1340 {
1341 if (!bs->drv) {
1342 buf[0] = '\0';
1343 } else {
1344 pstrcpy(buf, buf_size, bs->drv->format_name);
1345 }
1346 }
1347
1348 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
1349 void *opaque)
1350 {
1351 BlockDriver *drv;
1352
1353 QLIST_FOREACH(drv, &bdrv_drivers, list) {
1354 it(opaque, drv->format_name);
1355 }
1356 }
1357
1358 BlockDriverState *bdrv_find(const char *name)
1359 {
1360 BlockDriverState *bs;
1361
1362 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1363 if (!strcmp(name, bs->device_name)) {
1364 return bs;
1365 }
1366 }
1367 return NULL;
1368 }
1369
1370 BlockDriverState *bdrv_next(BlockDriverState *bs)
1371 {
1372 if (!bs) {
1373 return QTAILQ_FIRST(&bdrv_states);
1374 }
1375 return QTAILQ_NEXT(bs, list);
1376 }
1377
1378 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1379 {
1380 BlockDriverState *bs;
1381
1382 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1383 it(opaque, bs);
1384 }
1385 }
1386
1387 const char *bdrv_get_device_name(BlockDriverState *bs)
1388 {
1389 return bs->device_name;
1390 }
1391
1392 void bdrv_flush(BlockDriverState *bs)
1393 {
1394 if (bs->open_flags & BDRV_O_NO_FLUSH) {
1395 return;
1396 }
1397
1398 if (bs->drv && bs->drv->bdrv_flush)
1399 bs->drv->bdrv_flush(bs);
1400 }
1401
1402 void bdrv_flush_all(void)
1403 {
1404 BlockDriverState *bs;
1405
1406 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1407 if (bs->drv && !bdrv_is_read_only(bs) &&
1408 (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) {
1409 bdrv_flush(bs);
1410 }
1411 }
1412 }
1413
1414 int bdrv_has_zero_init(BlockDriverState *bs)
1415 {
1416 assert(bs->drv);
1417
1418 if (bs->drv->no_zero_init) {
1419 return 0;
1420 } else if (bs->file) {
1421 return bdrv_has_zero_init(bs->file);
1422 }
1423
1424 return 1;
1425 }
1426
1427 /*
1428 * Returns true iff the specified sector is present in the disk image. Drivers
1429 * not implementing the functionality are assumed to not support backing files,
1430 * hence all their sectors are reported as allocated.
1431 *
1432 * 'pnum' is set to the number of sectors (including and immediately following
1433 * the specified sector) that are known to be in the same
1434 * allocated/unallocated state.
1435 *
1436 * 'nb_sectors' is the max value 'pnum' should be set to.
1437 */
1438 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1439 int *pnum)
1440 {
1441 int64_t n;
1442 if (!bs->drv->bdrv_is_allocated) {
1443 if (sector_num >= bs->total_sectors) {
1444 *pnum = 0;
1445 return 0;
1446 }
1447 n = bs->total_sectors - sector_num;
1448 *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1449 return 1;
1450 }
1451 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1452 }
1453
1454 void bdrv_mon_event(const BlockDriverState *bdrv,
1455 BlockMonEventAction action, int is_read)
1456 {
1457 QObject *data;
1458 const char *action_str;
1459
1460 switch (action) {
1461 case BDRV_ACTION_REPORT:
1462 action_str = "report";
1463 break;
1464 case BDRV_ACTION_IGNORE:
1465 action_str = "ignore";
1466 break;
1467 case BDRV_ACTION_STOP:
1468 action_str = "stop";
1469 break;
1470 default:
1471 abort();
1472 }
1473
1474 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1475 bdrv->device_name,
1476 action_str,
1477 is_read ? "read" : "write");
1478 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);
1479
1480 qobject_decref(data);
1481 }
1482
1483 static void bdrv_print_dict(QObject *obj, void *opaque)
1484 {
1485 QDict *bs_dict;
1486 Monitor *mon = opaque;
1487
1488 bs_dict = qobject_to_qdict(obj);
1489
1490 monitor_printf(mon, "%s: type=%s removable=%d",
1491 qdict_get_str(bs_dict, "device"),
1492 qdict_get_str(bs_dict, "type"),
1493 qdict_get_bool(bs_dict, "removable"));
1494
1495 if (qdict_get_bool(bs_dict, "removable")) {
1496 monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked"));
1497 }
1498
1499 if (qdict_haskey(bs_dict, "inserted")) {
1500 QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
1501
1502 monitor_printf(mon, " file=");
1503 monitor_print_filename(mon, qdict_get_str(qdict, "file"));
1504 if (qdict_haskey(qdict, "backing_file")) {
1505 monitor_printf(mon, " backing_file=");
1506 monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
1507 }
1508 monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
1509 qdict_get_bool(qdict, "ro"),
1510 qdict_get_str(qdict, "drv"),
1511 qdict_get_bool(qdict, "encrypted"));
1512 } else {
1513 monitor_printf(mon, " [not inserted]");
1514 }
1515
1516 monitor_printf(mon, "\n");
1517 }
1518
1519 void bdrv_info_print(Monitor *mon, const QObject *data)
1520 {
1521 qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
1522 }
1523
1524 void bdrv_info(Monitor *mon, QObject **ret_data)
1525 {
1526 QList *bs_list;
1527 BlockDriverState *bs;
1528
1529 bs_list = qlist_new();
1530
1531 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1532 QObject *bs_obj;
1533 const char *type = "unknown";
1534
1535 switch(bs->type) {
1536 case BDRV_TYPE_HD:
1537 type = "hd";
1538 break;
1539 case BDRV_TYPE_CDROM:
1540 type = "cdrom";
1541 break;
1542 case BDRV_TYPE_FLOPPY:
1543 type = "floppy";
1544 break;
1545 }
1546
1547 bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, "
1548 "'removable': %i, 'locked': %i }",
1549 bs->device_name, type, bs->removable,
1550 bs->locked);
1551
1552 if (bs->drv) {
1553 QObject *obj;
1554 QDict *bs_dict = qobject_to_qdict(bs_obj);
1555
1556 obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
1557 "'encrypted': %i }",
1558 bs->filename, bs->read_only,
1559 bs->drv->format_name,
1560 bdrv_is_encrypted(bs));
1561 if (bs->backing_file[0] != '\0') {
1562 QDict *qdict = qobject_to_qdict(obj);
1563 qdict_put(qdict, "backing_file",
1564 qstring_from_str(bs->backing_file));
1565 }
1566
1567 qdict_put_obj(bs_dict, "inserted", obj);
1568 }
1569 qlist_append_obj(bs_list, bs_obj);
1570 }
1571
1572 *ret_data = QOBJECT(bs_list);
1573 }
1574
1575 static void bdrv_stats_iter(QObject *data, void *opaque)
1576 {
1577 QDict *qdict;
1578 Monitor *mon = opaque;
1579
1580 qdict = qobject_to_qdict(data);
1581 monitor_printf(mon, "%s:", qdict_get_str(qdict, "device"));
1582
1583 qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
1584 monitor_printf(mon, " rd_bytes=%" PRId64
1585 " wr_bytes=%" PRId64
1586 " rd_operations=%" PRId64
1587 " wr_operations=%" PRId64
1588 "\n",
1589 qdict_get_int(qdict, "rd_bytes"),
1590 qdict_get_int(qdict, "wr_bytes"),
1591 qdict_get_int(qdict, "rd_operations"),
1592 qdict_get_int(qdict, "wr_operations"));
1593 }
1594
1595 void bdrv_stats_print(Monitor *mon, const QObject *data)
1596 {
1597 qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
1598 }
1599
1600 static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
1601 {
1602 QObject *res;
1603 QDict *dict;
1604
1605 res = qobject_from_jsonf("{ 'stats': {"
1606 "'rd_bytes': %" PRId64 ","
1607 "'wr_bytes': %" PRId64 ","
1608 "'rd_operations': %" PRId64 ","
1609 "'wr_operations': %" PRId64 ","
1610 "'wr_highest_offset': %" PRId64
1611 "} }",
1612 bs->rd_bytes, bs->wr_bytes,
1613 bs->rd_ops, bs->wr_ops,
1614 bs->wr_highest_sector *
1615 (uint64_t)BDRV_SECTOR_SIZE);
1616 dict = qobject_to_qdict(res);
1617
1618 if (*bs->device_name) {
1619 qdict_put(dict, "device", qstring_from_str(bs->device_name));
1620 }
1621
1622 if (bs->file) {
1623 QObject *parent = bdrv_info_stats_bs(bs->file);
1624 qdict_put_obj(dict, "parent", parent);
1625 }
1626
1627 return res;
1628 }
1629
1630 void bdrv_info_stats(Monitor *mon, QObject **ret_data)
1631 {
1632 QObject *obj;
1633 QList *devices;
1634 BlockDriverState *bs;
1635
1636 devices = qlist_new();
1637
1638 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1639 obj = bdrv_info_stats_bs(bs);
1640 qlist_append_obj(devices, obj);
1641 }
1642
1643 *ret_data = QOBJECT(devices);
1644 }
1645
1646 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1647 {
1648 if (bs->backing_hd && bs->backing_hd->encrypted)
1649 return bs->backing_file;
1650 else if (bs->encrypted)
1651 return bs->filename;
1652 else
1653 return NULL;
1654 }
1655
1656 void bdrv_get_backing_filename(BlockDriverState *bs,
1657 char *filename, int filename_size)
1658 {
1659 if (!bs->backing_file) {
1660 pstrcpy(filename, filename_size, "");
1661 } else {
1662 pstrcpy(filename, filename_size, bs->backing_file);
1663 }
1664 }
1665
1666 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1667 const uint8_t *buf, int nb_sectors)
1668 {
1669 BlockDriver *drv = bs->drv;
1670 if (!drv)
1671 return -ENOMEDIUM;
1672 if (!drv->bdrv_write_compressed)
1673 return -ENOTSUP;
1674 if (bdrv_check_request(bs, sector_num, nb_sectors))
1675 return -EIO;
1676
1677 if (bs->dirty_bitmap) {
1678 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1679 }
1680
1681 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1682 }
1683
1684 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1685 {
1686 BlockDriver *drv = bs->drv;
1687 if (!drv)
1688 return -ENOMEDIUM;
1689 if (!drv->bdrv_get_info)
1690 return -ENOTSUP;
1691 memset(bdi, 0, sizeof(*bdi));
1692 return drv->bdrv_get_info(bs, bdi);
1693 }
1694
1695 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1696 int64_t pos, int size)
1697 {
1698 BlockDriver *drv = bs->drv;
1699 if (!drv)
1700 return -ENOMEDIUM;
1701 if (drv->bdrv_save_vmstate)
1702 return drv->bdrv_save_vmstate(bs, buf, pos, size);
1703 if (bs->file)
1704 return bdrv_save_vmstate(bs->file, buf, pos, size);
1705 return -ENOTSUP;
1706 }
1707
1708 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
1709 int64_t pos, int size)
1710 {
1711 BlockDriver *drv = bs->drv;
1712 if (!drv)
1713 return -ENOMEDIUM;
1714 if (drv->bdrv_load_vmstate)
1715 return drv->bdrv_load_vmstate(bs, buf, pos, size);
1716 if (bs->file)
1717 return bdrv_load_vmstate(bs->file, buf, pos, size);
1718 return -ENOTSUP;
1719 }
1720
1721 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
1722 {
1723 BlockDriver *drv = bs->drv;
1724
1725 if (!drv || !drv->bdrv_debug_event) {
1726 return;
1727 }
1728
1729 return drv->bdrv_debug_event(bs, event);
1730
1731 }
1732
1733 /**************************************************************/
1734 /* handling of snapshots */
1735
1736 int bdrv_can_snapshot(BlockDriverState *bs)
1737 {
1738 BlockDriver *drv = bs->drv;
1739 if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
1740 return 0;
1741 }
1742
1743 if (!drv->bdrv_snapshot_create) {
1744 if (bs->file != NULL) {
1745 return bdrv_can_snapshot(bs->file);
1746 }
1747 return 0;
1748 }
1749
1750 return 1;
1751 }
1752
1753 int bdrv_snapshot_create(BlockDriverState *bs,
1754 QEMUSnapshotInfo *sn_info)
1755 {
1756 BlockDriver *drv = bs->drv;
1757 if (!drv)
1758 return -ENOMEDIUM;
1759 if (drv->bdrv_snapshot_create)
1760 return drv->bdrv_snapshot_create(bs, sn_info);
1761 if (bs->file)
1762 return bdrv_snapshot_create(bs->file, sn_info);
1763 return -ENOTSUP;
1764 }
1765
1766 int bdrv_snapshot_goto(BlockDriverState *bs,
1767 const char *snapshot_id)
1768 {
1769 BlockDriver *drv = bs->drv;
1770 int ret, open_ret;
1771
1772 if (!drv)
1773 return -ENOMEDIUM;
1774 if (drv->bdrv_snapshot_goto)
1775 return drv->bdrv_snapshot_goto(bs, snapshot_id);
1776
1777 if (bs->file) {
1778 drv->bdrv_close(bs);
1779 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
1780 open_ret = drv->bdrv_open(bs, bs->open_flags);
1781 if (open_ret < 0) {
1782 bdrv_delete(bs->file);
1783 bs->drv = NULL;
1784 return open_ret;
1785 }
1786 return ret;
1787 }
1788
1789 return -ENOTSUP;
1790 }
1791
1792 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1793 {
1794 BlockDriver *drv = bs->drv;
1795 if (!drv)
1796 return -ENOMEDIUM;
1797 if (drv->bdrv_snapshot_delete)
1798 return drv->bdrv_snapshot_delete(bs, snapshot_id);
1799 if (bs->file)
1800 return bdrv_snapshot_delete(bs->file, snapshot_id);
1801 return -ENOTSUP;
1802 }
1803
1804 int bdrv_snapshot_list(BlockDriverState *bs,
1805 QEMUSnapshotInfo **psn_info)
1806 {
1807 BlockDriver *drv = bs->drv;
1808 if (!drv)
1809 return -ENOMEDIUM;
1810 if (drv->bdrv_snapshot_list)
1811 return drv->bdrv_snapshot_list(bs, psn_info);
1812 if (bs->file)
1813 return bdrv_snapshot_list(bs->file, psn_info);
1814 return -ENOTSUP;
1815 }
1816
1817 #define NB_SUFFIXES 4
1818
1819 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
1820 {
1821 static const char suffixes[NB_SUFFIXES] = "KMGT";
1822 int64_t base;
1823 int i;
1824
1825 if (size <= 999) {
1826 snprintf(buf, buf_size, "%" PRId64, size);
1827 } else {
1828 base = 1024;
1829 for(i = 0; i < NB_SUFFIXES; i++) {
1830 if (size < (10 * base)) {
1831 snprintf(buf, buf_size, "%0.1f%c",
1832 (double)size / base,
1833 suffixes[i]);
1834 break;
1835 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1836 snprintf(buf, buf_size, "%" PRId64 "%c",
1837 ((size + (base >> 1)) / base),
1838 suffixes[i]);
1839 break;
1840 }
1841 base = base * 1024;
1842 }
1843 }
1844 return buf;
1845 }
1846
1847 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1848 {
1849 char buf1[128], date_buf[128], clock_buf[128];
1850 #ifdef _WIN32
1851 struct tm *ptm;
1852 #else
1853 struct tm tm;
1854 #endif
1855 time_t ti;
1856 int64_t secs;
1857
1858 if (!sn) {
1859 snprintf(buf, buf_size,
1860 "%-10s%-20s%7s%20s%15s",
1861 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1862 } else {
1863 ti = sn->date_sec;
1864 #ifdef _WIN32
1865 ptm = localtime(&ti);
1866 strftime(date_buf, sizeof(date_buf),
1867 "%Y-%m-%d %H:%M:%S", ptm);
1868 #else
1869 localtime_r(&ti, &tm);
1870 strftime(date_buf, sizeof(date_buf),
1871 "%Y-%m-%d %H:%M:%S", &tm);
1872 #endif
1873 secs = sn->vm_clock_nsec / 1000000000;
1874 snprintf(clock_buf, sizeof(clock_buf),
1875 "%02d:%02d:%02d.%03d",
1876 (int)(secs / 3600),
1877 (int)((secs / 60) % 60),
1878 (int)(secs % 60),
1879 (int)((sn->vm_clock_nsec / 1000000) % 1000));
1880 snprintf(buf, buf_size,
1881 "%-10s%-20s%7s%20s%15s",
1882 sn->id_str, sn->name,
1883 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1884 date_buf,
1885 clock_buf);
1886 }
1887 return buf;
1888 }
1889
1890
1891 /**************************************************************/
1892 /* async I/Os */
1893
1894 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1895 QEMUIOVector *qiov, int nb_sectors,
1896 BlockDriverCompletionFunc *cb, void *opaque)
1897 {
1898 BlockDriver *drv = bs->drv;
1899 BlockDriverAIOCB *ret;
1900
1901 if (!drv)
1902 return NULL;
1903 if (bdrv_check_request(bs, sector_num, nb_sectors))
1904 return NULL;
1905
1906 ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
1907 cb, opaque);
1908
1909 if (ret) {
1910 /* Update stats even though technically transfer has not happened. */
1911 bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1912 bs->rd_ops ++;
1913 }
1914
1915 return ret;
1916 }
1917
1918 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
1919 QEMUIOVector *qiov, int nb_sectors,
1920 BlockDriverCompletionFunc *cb, void *opaque)
1921 {
1922 BlockDriver *drv = bs->drv;
1923 BlockDriverAIOCB *ret;
1924
1925 if (!drv)
1926 return NULL;
1927 if (bs->read_only)
1928 return NULL;
1929 if (bdrv_check_request(bs, sector_num, nb_sectors))
1930 return NULL;
1931
1932 if (bs->dirty_bitmap) {
1933 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1934 }
1935
1936 ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
1937 cb, opaque);
1938
1939 if (ret) {
1940 /* Update stats even though technically transfer has not happened. */
1941 bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1942 bs->wr_ops ++;
1943 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
1944 bs->wr_highest_sector = sector_num + nb_sectors - 1;
1945 }
1946 }
1947
1948 return ret;
1949 }
1950
1951
1952 typedef struct MultiwriteCB {
1953 int error;
1954 int num_requests;
1955 int num_callbacks;
1956 struct {
1957 BlockDriverCompletionFunc *cb;
1958 void *opaque;
1959 QEMUIOVector *free_qiov;
1960 void *free_buf;
1961 } callbacks[];
1962 } MultiwriteCB;
1963
1964 static void multiwrite_user_cb(MultiwriteCB *mcb)
1965 {
1966 int i;
1967
1968 for (i = 0; i < mcb->num_callbacks; i++) {
1969 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
1970 if (mcb->callbacks[i].free_qiov) {
1971 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
1972 }
1973 qemu_free(mcb->callbacks[i].free_qiov);
1974 qemu_vfree(mcb->callbacks[i].free_buf);
1975 }
1976 }
1977
1978 static void multiwrite_cb(void *opaque, int ret)
1979 {
1980 MultiwriteCB *mcb = opaque;
1981
1982 if (ret < 0 && !mcb->error) {
1983 mcb->error = ret;
1984 multiwrite_user_cb(mcb);
1985 }
1986
1987 mcb->num_requests--;
1988 if (mcb->num_requests == 0) {
1989 if (mcb->error == 0) {
1990 multiwrite_user_cb(mcb);
1991 }
1992 qemu_free(mcb);
1993 }
1994 }
1995
1996 static int multiwrite_req_compare(const void *a, const void *b)
1997 {
1998 const BlockRequest *req1 = a, *req2 = b;
1999
2000 /*
2001 * Note that we can't simply subtract req2->sector from req1->sector
2002 * here as that could overflow the return value.
2003 */
2004 if (req1->sector > req2->sector) {
2005 return 1;
2006 } else if (req1->sector < req2->sector) {
2007 return -1;
2008 } else {
2009 return 0;
2010 }
2011 }
2012
2013 /*
2014 * Takes a bunch of requests and tries to merge them. Returns the number of
2015 * requests that remain after merging.
2016 */
2017 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2018 int num_reqs, MultiwriteCB *mcb)
2019 {
2020 int i, outidx;
2021
2022 // Sort requests by start sector
2023 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
2024
2025 // Check if adjacent requests touch the same clusters. If so, combine them,
2026 // filling up gaps with zero sectors.
2027 outidx = 0;
2028 for (i = 1; i < num_reqs; i++) {
2029 int merge = 0;
2030 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
2031
2032 // This handles the cases that are valid for all block drivers, namely
2033 // exactly sequential writes and overlapping writes.
2034 if (reqs[i].sector <= oldreq_last) {
2035 merge = 1;
2036 }
2037
2038 // The block driver may decide that it makes sense to combine requests
2039 // even if there is a gap of some sectors between them. In this case,
2040 // the gap is filled with zeros (therefore only applicable for yet
2041 // unused space in format like qcow2).
2042 if (!merge && bs->drv->bdrv_merge_requests) {
2043 merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2044 }
2045
2046 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2047 merge = 0;
2048 }
2049
2050 if (merge) {
2051 size_t size;
2052 QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov));
2053 qemu_iovec_init(qiov,
2054 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2055
2056 // Add the first request to the merged one. If the requests are
2057 // overlapping, drop the last sectors of the first request.
2058 size = (reqs[i].sector - reqs[outidx].sector) << 9;
2059 qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2060
2061 // We might need to add some zeros between the two requests
2062 if (reqs[i].sector > oldreq_last) {
2063 size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
2064 uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2065 memset(buf, 0, zero_bytes);
2066 qemu_iovec_add(qiov, buf, zero_bytes);
2067 mcb->callbacks[i].free_buf = buf;
2068 }
2069
2070 // Add the second request
2071 qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
2072
2073 reqs[outidx].nb_sectors = qiov->size >> 9;
2074 reqs[outidx].qiov = qiov;
2075
2076 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2077 } else {
2078 outidx++;
2079 reqs[outidx].sector = reqs[i].sector;
2080 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2081 reqs[outidx].qiov = reqs[i].qiov;
2082 }
2083 }
2084
2085 return outidx + 1;
2086 }
2087
2088 /*
2089 * Submit multiple AIO write requests at once.
2090 *
2091 * On success, the function returns 0 and all requests in the reqs array have
2092 * been submitted. In error case this function returns -1, and any of the
2093 * requests may or may not be submitted yet. In particular, this means that the
2094 * callback will be called for some of the requests, for others it won't. The
2095 * caller must check the error field of the BlockRequest to wait for the right
2096 * callbacks (if error != 0, no callback will be called).
2097 *
2098 * The implementation may modify the contents of the reqs array, e.g. to merge
2099 * requests. However, the fields opaque and error are left unmodified as they
2100 * are used to signal failure for a single request to the caller.
2101 */
2102 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2103 {
2104 BlockDriverAIOCB *acb;
2105 MultiwriteCB *mcb;
2106 int i;
2107
2108 if (num_reqs == 0) {
2109 return 0;
2110 }
2111
2112 // Create MultiwriteCB structure
2113 mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
2114 mcb->num_requests = 0;
2115 mcb->num_callbacks = num_reqs;
2116
2117 for (i = 0; i < num_reqs; i++) {
2118 mcb->callbacks[i].cb = reqs[i].cb;
2119 mcb->callbacks[i].opaque = reqs[i].opaque;
2120 }
2121
2122 // Check for mergable requests
2123 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2124
2125 // Run the aio requests
2126 for (i = 0; i < num_reqs; i++) {
2127 acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2128 reqs[i].nb_sectors, multiwrite_cb, mcb);
2129
2130 if (acb == NULL) {
2131 // We can only fail the whole thing if no request has been
2132 // submitted yet. Otherwise we'll wait for the submitted AIOs to
2133 // complete and report the error in the callback.
2134 if (mcb->num_requests == 0) {
2135 reqs[i].error = -EIO;
2136 goto fail;
2137 } else {
2138 mcb->num_requests++;
2139 multiwrite_cb(mcb, -EIO);
2140 break;
2141 }
2142 } else {
2143 mcb->num_requests++;
2144 }
2145 }
2146
2147 return 0;
2148
2149 fail:
2150 qemu_free(mcb);
2151 return -1;
2152 }
2153
2154 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2155 BlockDriverCompletionFunc *cb, void *opaque)
2156 {
2157 BlockDriver *drv = bs->drv;
2158
2159 if (bs->open_flags & BDRV_O_NO_FLUSH) {
2160 return bdrv_aio_noop_em(bs, cb, opaque);
2161 }
2162
2163 if (!drv)
2164 return NULL;
2165 return drv->bdrv_aio_flush(bs, cb, opaque);
2166 }
2167
2168 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
2169 {
2170 acb->pool->cancel(acb);
2171 }
2172
2173
2174 /**************************************************************/
2175 /* async block device emulation */
2176
2177 typedef struct BlockDriverAIOCBSync {
2178 BlockDriverAIOCB common;
2179 QEMUBH *bh;
2180 int ret;
2181 /* vector translation state */
2182 QEMUIOVector *qiov;
2183 uint8_t *bounce;
2184 int is_write;
2185 } BlockDriverAIOCBSync;
2186
2187 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
2188 {
2189 BlockDriverAIOCBSync *acb =
2190 container_of(blockacb, BlockDriverAIOCBSync, common);
2191 qemu_bh_delete(acb->bh);
2192 acb->bh = NULL;
2193 qemu_aio_release(acb);
2194 }
2195
2196 static AIOPool bdrv_em_aio_pool = {
2197 .aiocb_size = sizeof(BlockDriverAIOCBSync),
2198 .cancel = bdrv_aio_cancel_em,
2199 };
2200
2201 static void bdrv_aio_bh_cb(void *opaque)
2202 {
2203 BlockDriverAIOCBSync *acb = opaque;
2204
2205 if (!acb->is_write)
2206 qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
2207 qemu_vfree(acb->bounce);
2208 acb->common.cb(acb->common.opaque, acb->ret);
2209 qemu_bh_delete(acb->bh);
2210 acb->bh = NULL;
2211 qemu_aio_release(acb);
2212 }
2213
2214 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2215 int64_t sector_num,
2216 QEMUIOVector *qiov,
2217 int nb_sectors,
2218 BlockDriverCompletionFunc *cb,
2219 void *opaque,
2220 int is_write)
2221
2222 {
2223 BlockDriverAIOCBSync *acb;
2224
2225 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2226 acb->is_write = is_write;
2227 acb->qiov = qiov;
2228 acb->bounce = qemu_blockalign(bs, qiov->size);
2229
2230 if (!acb->bh)
2231 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2232
2233 if (is_write) {
2234 qemu_iovec_to_buffer(acb->qiov, acb->bounce);
2235 acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2236 } else {
2237 acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2238 }
2239
2240 qemu_bh_schedule(acb->bh);
2241
2242 return &acb->common;
2243 }
2244
2245 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2246 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2247 BlockDriverCompletionFunc *cb, void *opaque)
2248 {
2249 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2250 }
2251
2252 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2253 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2254 BlockDriverCompletionFunc *cb, void *opaque)
2255 {
2256 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
2257 }
2258
2259 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2260 BlockDriverCompletionFunc *cb, void *opaque)
2261 {
2262 BlockDriverAIOCBSync *acb;
2263
2264 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2265 acb->is_write = 1; /* don't bounce in the completion hadler */
2266 acb->qiov = NULL;
2267 acb->bounce = NULL;
2268 acb->ret = 0;
2269
2270 if (!acb->bh)
2271 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2272
2273 bdrv_flush(bs);
2274 qemu_bh_schedule(acb->bh);
2275 return &acb->common;
2276 }
2277
2278 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2279 BlockDriverCompletionFunc *cb, void *opaque)
2280 {
2281 BlockDriverAIOCBSync *acb;
2282
2283 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2284 acb->is_write = 1; /* don't bounce in the completion handler */
2285 acb->qiov = NULL;
2286 acb->bounce = NULL;
2287 acb->ret = 0;
2288
2289 if (!acb->bh) {
2290 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2291 }
2292
2293 qemu_bh_schedule(acb->bh);
2294 return &acb->common;
2295 }
2296
2297 /**************************************************************/
2298 /* sync block device emulation */
2299
2300 static void bdrv_rw_em_cb(void *opaque, int ret)
2301 {
2302 *(int *)opaque = ret;
2303 }
2304
2305 #define NOT_DONE 0x7fffffff
2306
2307 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
2308 uint8_t *buf, int nb_sectors)
2309 {
2310 int async_ret;
2311 BlockDriverAIOCB *acb;
2312 struct iovec iov;
2313 QEMUIOVector qiov;
2314
2315 async_context_push();
2316
2317 async_ret = NOT_DONE;
2318 iov.iov_base = (void *)buf;
2319 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2320 qemu_iovec_init_external(&qiov, &iov, 1);
2321 acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2322 bdrv_rw_em_cb, &async_ret);
2323 if (acb == NULL) {
2324 async_ret = -1;
2325 goto fail;
2326 }
2327
2328 while (async_ret == NOT_DONE) {
2329 qemu_aio_wait();
2330 }
2331
2332
2333 fail:
2334 async_context_pop();
2335 return async_ret;
2336 }
2337
2338 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2339 const uint8_t *buf, int nb_sectors)
2340 {
2341 int async_ret;
2342 BlockDriverAIOCB *acb;
2343 struct iovec iov;
2344 QEMUIOVector qiov;
2345
2346 async_context_push();
2347
2348 async_ret = NOT_DONE;
2349 iov.iov_base = (void *)buf;
2350 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2351 qemu_iovec_init_external(&qiov, &iov, 1);
2352 acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2353 bdrv_rw_em_cb, &async_ret);
2354 if (acb == NULL) {
2355 async_ret = -1;
2356 goto fail;
2357 }
2358 while (async_ret == NOT_DONE) {
2359 qemu_aio_wait();
2360 }
2361
2362 fail:
2363 async_context_pop();
2364 return async_ret;
2365 }
2366
2367 void bdrv_init(void)
2368 {
2369 module_call_init(MODULE_INIT_BLOCK);
2370 }
2371
2372 void bdrv_init_with_whitelist(void)
2373 {
2374 use_bdrv_whitelist = 1;
2375 bdrv_init();
2376 }
2377
2378 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2379 BlockDriverCompletionFunc *cb, void *opaque)
2380 {
2381 BlockDriverAIOCB *acb;
2382
2383 if (pool->free_aiocb) {
2384 acb = pool->free_aiocb;
2385 pool->free_aiocb = acb->next;
2386 } else {
2387 acb = qemu_mallocz(pool->aiocb_size);
2388 acb->pool = pool;
2389 }
2390 acb->bs = bs;
2391 acb->cb = cb;
2392 acb->opaque = opaque;
2393 return acb;
2394 }
2395
2396 void qemu_aio_release(void *p)
2397 {
2398 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
2399 AIOPool *pool = acb->pool;
2400 acb->next = pool->free_aiocb;
2401 pool->free_aiocb = acb;
2402 }
2403
2404 /**************************************************************/
2405 /* removable device support */
2406
2407 /**
2408 * Return TRUE if the media is present
2409 */
2410 int bdrv_is_inserted(BlockDriverState *bs)
2411 {
2412 BlockDriver *drv = bs->drv;
2413 int ret;
2414 if (!drv)
2415 return 0;
2416 if (!drv->bdrv_is_inserted)
2417 return 1;
2418 ret = drv->bdrv_is_inserted(bs);
2419 return ret;
2420 }
2421
2422 /**
2423 * Return TRUE if the media changed since the last call to this
2424 * function. It is currently only used for floppy disks
2425 */
2426 int bdrv_media_changed(BlockDriverState *bs)
2427 {
2428 BlockDriver *drv = bs->drv;
2429 int ret;
2430
2431 if (!drv || !drv->bdrv_media_changed)
2432 ret = -ENOTSUP;
2433 else
2434 ret = drv->bdrv_media_changed(bs);
2435 if (ret == -ENOTSUP)
2436 ret = bs->media_changed;
2437 bs->media_changed = 0;
2438 return ret;
2439 }
2440
2441 /**
2442 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
2443 */
2444 int bdrv_eject(BlockDriverState *bs, int eject_flag)
2445 {
2446 BlockDriver *drv = bs->drv;
2447 int ret;
2448
2449 if (bs->locked) {
2450 return -EBUSY;
2451 }
2452
2453 if (!drv || !drv->bdrv_eject) {
2454 ret = -ENOTSUP;
2455 } else {
2456 ret = drv->bdrv_eject(bs, eject_flag);
2457 }
2458 if (ret == -ENOTSUP) {
2459 if (eject_flag)
2460 bdrv_close(bs);
2461 ret = 0;
2462 }
2463
2464 return ret;
2465 }
2466
2467 int bdrv_is_locked(BlockDriverState *bs)
2468 {
2469 return bs->locked;
2470 }
2471
2472 /**
2473 * Lock or unlock the media (if it is locked, the user won't be able
2474 * to eject it manually).
2475 */
2476 void bdrv_set_locked(BlockDriverState *bs, int locked)
2477 {
2478 BlockDriver *drv = bs->drv;
2479
2480 bs->locked = locked;
2481 if (drv && drv->bdrv_set_locked) {
2482 drv->bdrv_set_locked(bs, locked);
2483 }
2484 }
2485
2486 /* needed for generic scsi interface */
2487
2488 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2489 {
2490 BlockDriver *drv = bs->drv;
2491
2492 if (drv && drv->bdrv_ioctl)
2493 return drv->bdrv_ioctl(bs, req, buf);
2494 return -ENOTSUP;
2495 }
2496
2497 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
2498 unsigned long int req, void *buf,
2499 BlockDriverCompletionFunc *cb, void *opaque)
2500 {
2501 BlockDriver *drv = bs->drv;
2502
2503 if (drv && drv->bdrv_aio_ioctl)
2504 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
2505 return NULL;
2506 }
2507
2508
2509
2510 void *qemu_blockalign(BlockDriverState *bs, size_t size)
2511 {
2512 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
2513 }
2514
2515 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
2516 {
2517 int64_t bitmap_size;
2518
2519 bs->dirty_count = 0;
2520 if (enable) {
2521 if (!bs->dirty_bitmap) {
2522 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
2523 BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
2524 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
2525
2526 bs->dirty_bitmap = qemu_mallocz(bitmap_size);
2527 }
2528 } else {
2529 if (bs->dirty_bitmap) {
2530 qemu_free(bs->dirty_bitmap);
2531 bs->dirty_bitmap = NULL;
2532 }
2533 }
2534 }
2535
2536 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
2537 {
2538 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
2539
2540 if (bs->dirty_bitmap &&
2541 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
2542 return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
2543 (1 << (chunk % (sizeof(unsigned long) * 8)));
2544 } else {
2545 return 0;
2546 }
2547 }
2548
2549 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
2550 int nr_sectors)
2551 {
2552 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
2553 }
2554
2555 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
2556 {
2557 return bs->dirty_count;
2558 }
QEmu