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