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