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