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