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