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