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