]> git.proxmox.com Git - qemu.git/blame - block.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
block: parse cache mode flags in a single place
[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"
6d519a5f 26#include "trace.h"
376253ec 27#include "monitor.h"
ea2384d3 28#include "block_int.h"
5efa9d5a 29#include "module.h"
d15e5465 30#include "qemu-objects.h"
68485420 31#include "qemu-coroutine.h"
fc01f7e7 32
71e72a19 33#ifdef CONFIG_BSD
7674e7bf
FB		 34#include <sys/types.h>
35#include <sys/stat.h>
36#include <sys/ioctl.h>
72cf2d4f 37#include <sys/queue.h>
c5e97233 38#ifndef __DragonFly__
7674e7bf
FB		 39#include <sys/disk.h>
40#endif
c5e97233 41#endif
7674e7bf 42
49dc768d
AL		 43#ifdef _WIN32
44#include <windows.h>
45#endif
46
f141eafe
AL		 47static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
48 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
c87c0672 49 BlockDriverCompletionFunc *cb, void *opaque);
f141eafe
AL		 50static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
51 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
ce1a14dc 52 BlockDriverCompletionFunc *cb, void *opaque);
b2e12bc6
CH		 53static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
54 BlockDriverCompletionFunc *cb, void *opaque);
016f5cf6
AG		 55static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
56 BlockDriverCompletionFunc *cb, void *opaque);
5fafdf24 57static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
83f64091
FB		 58 uint8_t *buf, int nb_sectors);
59static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
60 const uint8_t *buf, int nb_sectors);
68485420
KW		 61static BlockDriverAIOCB *bdrv_co_aio_readv_em(BlockDriverState *bs,
62 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
63 BlockDriverCompletionFunc *cb, void *opaque);
64static BlockDriverAIOCB *bdrv_co_aio_writev_em(BlockDriverState *bs,
65 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
66 BlockDriverCompletionFunc *cb, void *opaque);
f9f05dc5
KW		 67static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
68 int64_t sector_num, int nb_sectors,
69 QEMUIOVector *iov);
70static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
71 int64_t sector_num, int nb_sectors,
72 QEMUIOVector *iov);
e7a8a783 73static int coroutine_fn bdrv_co_flush_em(BlockDriverState *bs);
ec530c81 74
1b7bdbc1
SH		 75static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
76 QTAILQ_HEAD_INITIALIZER(bdrv_states);
7ee930d0 77
8a22f02a
SH		 78static QLIST_HEAD(, BlockDriver) bdrv_drivers =
79 QLIST_HEAD_INITIALIZER(bdrv_drivers);
ea2384d3 80
f9092b10
MA		 81/* The device to use for VM snapshots */
82static BlockDriverState *bs_snapshots;
83
eb852011
MA		 84/* If non-zero, use only whitelisted block drivers */
85static int use_bdrv_whitelist;
86
9e0b22f4
SH		 87#ifdef _WIN32
88static int is_windows_drive_prefix(const char *filename)
89{
90 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
91 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
92 filename[1] == ':');
93}
94
95int is_windows_drive(const char *filename)
96{
97 if (is_windows_drive_prefix(filename) &&
98 filename[2] == '\0')
99 return 1;
100 if (strstart(filename, "\\\\.\\", NULL) ||
101 strstart(filename, "//./", NULL))
102 return 1;
103 return 0;
104}
105#endif
106
107/* check if the path starts with "<protocol>:" */
108static int path_has_protocol(const char *path)
109{
110#ifdef _WIN32
111 if (is_windows_drive(path) ||
112 is_windows_drive_prefix(path)) {
113 return 0;
114 }
115#endif
116
117 return strchr(path, ':') != NULL;
118}
119
83f64091 120int path_is_absolute(const char *path)
3b0d4f61 121{
83f64091 122 const char *p;
21664424
FB		 123#ifdef _WIN32
124 /* specific case for names like: "\\.\d:" */
125 if (*path == '/' || *path == '\\')
126 return 1;
127#endif
83f64091
FB		 128 p = strchr(path, ':');
129 if (p)
130 p++;
131 else
132 p = path;
3b9f94e1
FB		 133#ifdef _WIN32
134 return (*p == '/' || *p == '\\');
135#else
136 return (*p == '/');
137#endif
3b0d4f61
FB		 138}
139
83f64091
FB		 140/* if filename is absolute, just copy it to dest. Otherwise, build a
141 path to it by considering it is relative to base_path. URL are
142 supported. */
143void path_combine(char *dest, int dest_size,
144 const char *base_path,
145 const char *filename)
3b0d4f61 146{
83f64091
FB		 147 const char *p, *p1;
148 int len;
149
150 if (dest_size <= 0)
151 return;
152 if (path_is_absolute(filename)) {
153 pstrcpy(dest, dest_size, filename);
154 } else {
155 p = strchr(base_path, ':');
156 if (p)
157 p++;
158 else
159 p = base_path;
3b9f94e1
FB		 160 p1 = strrchr(base_path, '/');
161#ifdef _WIN32
162 {
163 const char *p2;
164 p2 = strrchr(base_path, '\\');
165 if (!p1 || p2 > p1)
166 p1 = p2;
167 }
168#endif
83f64091
FB		 169 if (p1)
170 p1++;
171 else
172 p1 = base_path;
173 if (p1 > p)
174 p = p1;
175 len = p - base_path;
176 if (len > dest_size - 1)
177 len = dest_size - 1;
178 memcpy(dest, base_path, len);
179 dest[len] = '\0';
180 pstrcat(dest, dest_size, filename);
3b0d4f61 181 }
3b0d4f61
FB		 182}
183
5efa9d5a 184void bdrv_register(BlockDriver *bdrv)
ea2384d3 185{
68485420
KW		 186 if (bdrv->bdrv_co_readv) {
187 /* Emulate AIO by coroutines, and sync by AIO */
188 bdrv->bdrv_aio_readv = bdrv_co_aio_readv_em;
189 bdrv->bdrv_aio_writev = bdrv_co_aio_writev_em;
190 bdrv->bdrv_read = bdrv_read_em;
191 bdrv->bdrv_write = bdrv_write_em;
f9f05dc5
KW		 192 } else {
193 bdrv->bdrv_co_readv = bdrv_co_readv_em;
194 bdrv->bdrv_co_writev = bdrv_co_writev_em;
195
196 if (!bdrv->bdrv_aio_readv) {
197 /* add AIO emulation layer */
198 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
199 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
200 } else if (!bdrv->bdrv_read) {
201 /* add synchronous IO emulation layer */
202 bdrv->bdrv_read = bdrv_read_em;
203 bdrv->bdrv_write = bdrv_write_em;
204 }
83f64091 205 }
b2e12bc6
CH		 206
207 if (!bdrv->bdrv_aio_flush)
208 bdrv->bdrv_aio_flush = bdrv_aio_flush_em;
209
8a22f02a 210 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
ea2384d3 211}
b338082b
FB		 212
213/* create a new block device (by default it is empty) */
214BlockDriverState *bdrv_new(const char *device_name)
215{
1b7bdbc1 216 BlockDriverState *bs;
b338082b 217
7267c094 218 bs = g_malloc0(sizeof(BlockDriverState));
b338082b 219 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
ea2384d3 220 if (device_name[0] != '\0') {
1b7bdbc1 221 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
ea2384d3 222 }
b338082b
FB		 223 return bs;
224}
225
ea2384d3
FB		 226BlockDriver *bdrv_find_format(const char *format_name)
227{
228 BlockDriver *drv1;
8a22f02a
SH		 229 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
230 if (!strcmp(drv1->format_name, format_name)) {
ea2384d3 231 return drv1;
8a22f02a 232 }
ea2384d3
FB		 233 }
234 return NULL;
235}
236
eb852011
MA		 237static int bdrv_is_whitelisted(BlockDriver *drv)
238{
239 static const char *whitelist[] = {
240 CONFIG_BDRV_WHITELIST
241 };
242 const char **p;
243
244 if (!whitelist[0])
245 return 1; /* no whitelist, anything goes */
246
247 for (p = whitelist; *p; p++) {
248 if (!strcmp(drv->format_name, *p)) {
249 return 1;
250 }
251 }
252 return 0;
253}
254
255BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
256{
257 BlockDriver *drv = bdrv_find_format(format_name);
258 return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
259}
260
0e7e1989
KW		 261int bdrv_create(BlockDriver *drv, const char* filename,
262 QEMUOptionParameter *options)
ea2384d3
FB		 263{
264 if (!drv->bdrv_create)
265 return -ENOTSUP;
0e7e1989
KW		 266
267 return drv->bdrv_create(filename, options);
ea2384d3
FB		 268}
269
84a12e66
CH		 270int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
271{
272 BlockDriver *drv;
273
b50cbabc 274 drv = bdrv_find_protocol(filename);
84a12e66 275 if (drv == NULL) {
16905d71 276 return -ENOENT;
84a12e66
CH		 277 }
278
279 return bdrv_create(drv, filename, options);
280}
281
d5249393 282#ifdef _WIN32
95389c86 283void get_tmp_filename(char *filename, int size)
d5249393 284{
3b9f94e1 285 char temp_dir[MAX_PATH];
3b46e624 286
3b9f94e1
FB		 287 GetTempPath(MAX_PATH, temp_dir);
288 GetTempFileName(temp_dir, "qem", 0, filename);
d5249393
FB		 289}
290#else
95389c86 291void get_tmp_filename(char *filename, int size)
fc01f7e7 292{
67b915a5 293 int fd;
7ccfb2eb 294 const char *tmpdir;
d5249393 295 /* XXX: race condition possible */
0badc1ee
AJ		 296 tmpdir = getenv("TMPDIR");
297 if (!tmpdir)
298 tmpdir = "/tmp";
299 snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
ea2384d3
FB		 300 fd = mkstemp(filename);
301 close(fd);
302}
d5249393 303#endif
fc01f7e7 304
84a12e66
CH		 305/*
306 * Detect host devices. By convention, /dev/cdrom[N] is always
307 * recognized as a host CDROM.
308 */
309static BlockDriver *find_hdev_driver(const char *filename)
310{
311 int score_max = 0, score;
312 BlockDriver *drv = NULL, *d;
313
314 QLIST_FOREACH(d, &bdrv_drivers, list) {
315 if (d->bdrv_probe_device) {
316 score = d->bdrv_probe_device(filename);
317 if (score > score_max) {
318 score_max = score;
319 drv = d;
320 }
321 }
322 }
323
324 return drv;
325}
326
b50cbabc 327BlockDriver *bdrv_find_protocol(const char *filename)
83f64091
FB		 328{
329 BlockDriver *drv1;
330 char protocol[128];
1cec71e3 331 int len;
83f64091 332 const char *p;
19cb3738 333
66f82cee
KW		 334 /* TODO Drivers without bdrv_file_open must be specified explicitly */
335
39508e7a
CH		 336 /*
337 * XXX(hch): we really should not let host device detection
338 * override an explicit protocol specification, but moving this
339 * later breaks access to device names with colons in them.
340 * Thanks to the brain-dead persistent naming schemes on udev-
341 * based Linux systems those actually are quite common.
342 */
343 drv1 = find_hdev_driver(filename);
344 if (drv1) {
345 return drv1;
346 }
347
9e0b22f4 348 if (!path_has_protocol(filename)) {
39508e7a 349 return bdrv_find_format("file");
84a12e66 350 }
9e0b22f4
SH		 351 p = strchr(filename, ':');
352 assert(p != NULL);
1cec71e3
AL		 353 len = p - filename;
354 if (len > sizeof(protocol) - 1)
355 len = sizeof(protocol) - 1;
356 memcpy(protocol, filename, len);
357 protocol[len] = '\0';
8a22f02a 358 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
5fafdf24 359 if (drv1->protocol_name &&
8a22f02a 360 !strcmp(drv1->protocol_name, protocol)) {
83f64091 361 return drv1;
8a22f02a 362 }
83f64091
FB		 363 }
364 return NULL;
365}
366
c98ac35d 367static int find_image_format(const char *filename, BlockDriver **pdrv)
f3a5d3f8
CH		 368{
369 int ret, score, score_max;
370 BlockDriver *drv1, *drv;
371 uint8_t buf[2048];
372 BlockDriverState *bs;
373
f5edb014 374 ret = bdrv_file_open(&bs, filename, 0);
c98ac35d
SW		 375 if (ret < 0) {
376 *pdrv = NULL;
377 return ret;
378 }
f8ea0b00 379
08a00559
KW		 380 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
381 if (bs->sg || !bdrv_is_inserted(bs)) {
1a396859 382 bdrv_delete(bs);
c98ac35d
SW		 383 drv = bdrv_find_format("raw");
384 if (!drv) {
385 ret = -ENOENT;
386 }
387 *pdrv = drv;
388 return ret;
1a396859 389 }
f8ea0b00 390
83f64091
FB		 391 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
392 bdrv_delete(bs);
393 if (ret < 0) {
c98ac35d
SW		 394 *pdrv = NULL;
395 return ret;
83f64091
FB		 396 }
397
ea2384d3 398 score_max = 0;
84a12e66 399 drv = NULL;
8a22f02a 400 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
83f64091
FB		 401 if (drv1->bdrv_probe) {
402 score = drv1->bdrv_probe(buf, ret, filename);
403 if (score > score_max) {
404 score_max = score;
405 drv = drv1;
406 }
0849bf08 407 }
fc01f7e7 408 }
c98ac35d
SW		 409 if (!drv) {
410 ret = -ENOENT;
411 }
412 *pdrv = drv;
413 return ret;
ea2384d3
FB		 414}
415
51762288
SH		 416/**
417 * Set the current 'total_sectors' value
418 */
419static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
420{
421 BlockDriver *drv = bs->drv;
422
396759ad
NB		 423 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
424 if (bs->sg)
425 return 0;
426
51762288
SH		 427 /* query actual device if possible, otherwise just trust the hint */
428 if (drv->bdrv_getlength) {
429 int64_t length = drv->bdrv_getlength(bs);
430 if (length < 0) {
431 return length;
432 }
433 hint = length >> BDRV_SECTOR_BITS;
434 }
435
436 bs->total_sectors = hint;
437 return 0;
438}
439
c3993cdc
SH		 440/**
441 * Set open flags for a given cache mode
442 *
443 * Return 0 on success, -1 if the cache mode was invalid.
444 */
445int bdrv_parse_cache_flags(const char *mode, int *flags)
446{
447 *flags &= ~BDRV_O_CACHE_MASK;
448
449 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
450 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
451 } else if (!strcmp(mode, "writeback")) {
452 *flags |= BDRV_O_CACHE_WB;
453 } else if (!strcmp(mode, "unsafe")) {
454 *flags |= BDRV_O_CACHE_WB;
455 *flags |= BDRV_O_NO_FLUSH;
456 } else if (!strcmp(mode, "writethrough")) {
457 /* this is the default */
458 } else {
459 return -1;
460 }
461
462 return 0;
463}
464
57915332
KW		 465/*
466 * Common part for opening disk images and files
467 */
468static int bdrv_open_common(BlockDriverState *bs, const char *filename,
469 int flags, BlockDriver *drv)
470{
471 int ret, open_flags;
472
473 assert(drv != NULL);
474
66f82cee 475 bs->file = NULL;
51762288 476 bs->total_sectors = 0;
57915332
KW		 477 bs->encrypted = 0;
478 bs->valid_key = 0;
479 bs->open_flags = flags;
480 /* buffer_alignment defaulted to 512, drivers can change this value */
481 bs->buffer_alignment = 512;
482
483 pstrcpy(bs->filename, sizeof(bs->filename), filename);
484
485 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
486 return -ENOTSUP;
487 }
488
489 bs->drv = drv;
7267c094 490 bs->opaque = g_malloc0(drv->instance_size);
57915332 491
a6599793 492 if (flags & BDRV_O_CACHE_WB)
57915332
KW		 493 bs->enable_write_cache = 1;
494
495 /*
496 * Clear flags that are internal to the block layer before opening the
497 * image.
498 */
499 open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
500
501 /*
ebabb67a 502 * Snapshots should be writable.
57915332
KW		 503 */
504 if (bs->is_temporary) {
505 open_flags |= BDRV_O_RDWR;
506 }
507
66f82cee
KW		 508 /* Open the image, either directly or using a protocol */
509 if (drv->bdrv_file_open) {
510 ret = drv->bdrv_file_open(bs, filename, open_flags);
511 } else {
512 ret = bdrv_file_open(&bs->file, filename, open_flags);
513 if (ret >= 0) {
514 ret = drv->bdrv_open(bs, open_flags);
515 }
516 }
517
57915332
KW		 518 if (ret < 0) {
519 goto free_and_fail;
520 }
521
522 bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
51762288
SH		 523
524 ret = refresh_total_sectors(bs, bs->total_sectors);
525 if (ret < 0) {
526 goto free_and_fail;
57915332 527 }
51762288 528
57915332
KW		 529#ifndef _WIN32
530 if (bs->is_temporary) {
531 unlink(filename);
532 }
533#endif
534 return 0;
535
536free_and_fail:
66f82cee
KW		 537 if (bs->file) {
538 bdrv_delete(bs->file);
539 bs->file = NULL;
540 }
7267c094 541 g_free(bs->opaque);
57915332
KW		 542 bs->opaque = NULL;
543 bs->drv = NULL;
544 return ret;
545}
546
b6ce07aa
KW		 547/*
548 * Opens a file using a protocol (file, host_device, nbd, ...)
549 */
83f64091 550int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
ea2384d3 551{
83f64091 552 BlockDriverState *bs;
6db95603 553 BlockDriver *drv;
83f64091
FB		 554 int ret;
555
b50cbabc 556 drv = bdrv_find_protocol(filename);
6db95603
CH		 557 if (!drv) {
558 return -ENOENT;
559 }
560
83f64091 561 bs = bdrv_new("");
b6ce07aa 562 ret = bdrv_open_common(bs, filename, flags, drv);
83f64091
FB		 563 if (ret < 0) {
564 bdrv_delete(bs);
565 return ret;
3b0d4f61 566 }
71d0770c 567 bs->growable = 1;
83f64091
FB		 568 *pbs = bs;
569 return 0;
570}
571
b6ce07aa
KW		 572/*
573 * Opens a disk image (raw, qcow2, vmdk, ...)
574 */
d6e9098e
KW		 575int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
576 BlockDriver *drv)
ea2384d3 577{
b6ce07aa 578 int ret;
712e7874 579
83f64091 580 if (flags & BDRV_O_SNAPSHOT) {
ea2384d3
FB		 581 BlockDriverState *bs1;
582 int64_t total_size;
7c96d46e 583 int is_protocol = 0;
91a073a9
KW		 584 BlockDriver *bdrv_qcow2;
585 QEMUOptionParameter *options;
b6ce07aa
KW		 586 char tmp_filename[PATH_MAX];
587 char backing_filename[PATH_MAX];
3b46e624 588
ea2384d3
FB		 589 /* if snapshot, we create a temporary backing file and open it
590 instead of opening 'filename' directly */
33e3963e 591
ea2384d3
FB		 592 /* if there is a backing file, use it */
593 bs1 = bdrv_new("");
d6e9098e 594 ret = bdrv_open(bs1, filename, 0, drv);
51d7c00c 595 if (ret < 0) {
ea2384d3 596 bdrv_delete(bs1);
51d7c00c 597 return ret;
ea2384d3 598 }
3e82990b 599 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
7c96d46e
AL		 600
601 if (bs1->drv && bs1->drv->protocol_name)
602 is_protocol = 1;
603
ea2384d3 604 bdrv_delete(bs1);
3b46e624 605
ea2384d3 606 get_tmp_filename(tmp_filename, sizeof(tmp_filename));
7c96d46e
AL		 607
608 /* Real path is meaningless for protocols */
609 if (is_protocol)
610 snprintf(backing_filename, sizeof(backing_filename),
611 "%s", filename);
114cdfa9
KS		 612 else if (!realpath(filename, backing_filename))
613 return -errno;
7c96d46e 614
91a073a9
KW		 615 bdrv_qcow2 = bdrv_find_format("qcow2");
616 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
617
3e82990b 618 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
91a073a9
KW		 619 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
620 if (drv) {
621 set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
622 drv->format_name);
623 }
624
625 ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
d748768c 626 free_option_parameters(options);
51d7c00c
AL		 627 if (ret < 0) {
628 return ret;
ea2384d3 629 }
91a073a9 630
ea2384d3 631 filename = tmp_filename;
91a073a9 632 drv = bdrv_qcow2;
ea2384d3
FB		 633 bs->is_temporary = 1;
634 }
712e7874 635
b6ce07aa 636 /* Find the right image format driver */
6db95603 637 if (!drv) {
c98ac35d 638 ret = find_image_format(filename, &drv);
51d7c00c 639 }
6987307c 640
51d7c00c 641 if (!drv) {
51d7c00c 642 goto unlink_and_fail;
ea2384d3 643 }
b6ce07aa
KW		 644
645 /* Open the image */
646 ret = bdrv_open_common(bs, filename, flags, drv);
647 if (ret < 0) {
6987307c
CH		 648 goto unlink_and_fail;
649 }
650
b6ce07aa
KW		 651 /* If there is a backing file, use it */
652 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
653 char backing_filename[PATH_MAX];
654 int back_flags;
655 BlockDriver *back_drv = NULL;
656
657 bs->backing_hd = bdrv_new("");
df2dbb4a
SH		 658
659 if (path_has_protocol(bs->backing_file)) {
660 pstrcpy(backing_filename, sizeof(backing_filename),
661 bs->backing_file);
662 } else {
663 path_combine(backing_filename, sizeof(backing_filename),
664 filename, bs->backing_file);
665 }
666
667 if (bs->backing_format[0] != '\0') {
b6ce07aa 668 back_drv = bdrv_find_format(bs->backing_format);
df2dbb4a 669 }
b6ce07aa
KW		 670
671 /* backing files always opened read-only */
672 back_flags =
673 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
674
675 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
676 if (ret < 0) {
677 bdrv_close(bs);
678 return ret;
679 }
680 if (bs->is_temporary) {
681 bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
682 } else {
683 /* base image inherits from "parent" */
684 bs->backing_hd->keep_read_only = bs->keep_read_only;
685 }
686 }
687
688 if (!bdrv_key_required(bs)) {
689 /* call the change callback */
690 bs->media_changed = 1;
691 if (bs->change_cb)
db97ee6a 692 bs->change_cb(bs->change_opaque, CHANGE_MEDIA);
b6ce07aa
KW		 693 }
694
695 return 0;
696
697unlink_and_fail:
698 if (bs->is_temporary) {
699 unlink(filename);
700 }
701 return ret;
702}
703
fc01f7e7
FB		 704void bdrv_close(BlockDriverState *bs)
705{
19cb3738 706 if (bs->drv) {
f9092b10
MA		 707 if (bs == bs_snapshots) {
708 bs_snapshots = NULL;
709 }
557df6ac 710 if (bs->backing_hd) {
ea2384d3 711 bdrv_delete(bs->backing_hd);
557df6ac
SH		 712 bs->backing_hd = NULL;
713 }
ea2384d3 714 bs->drv->bdrv_close(bs);
7267c094 715 g_free(bs->opaque);
ea2384d3
FB		 716#ifdef _WIN32
717 if (bs->is_temporary) {
718 unlink(bs->filename);
719 }
67b915a5 720#endif
ea2384d3
FB		 721 bs->opaque = NULL;
722 bs->drv = NULL;
b338082b 723
66f82cee
KW		 724 if (bs->file != NULL) {
725 bdrv_close(bs->file);
726 }
727
b338082b 728 /* call the change callback */
19cb3738 729 bs->media_changed = 1;
b338082b 730 if (bs->change_cb)
db97ee6a 731 bs->change_cb(bs->change_opaque, CHANGE_MEDIA);
b338082b
FB		 732 }
733}
734
2bc93fed
MK		 735void bdrv_close_all(void)
736{
737 BlockDriverState *bs;
738
739 QTAILQ_FOREACH(bs, &bdrv_states, list) {
740 bdrv_close(bs);
741 }
742}
743
d22b2f41
RH		 744/* make a BlockDriverState anonymous by removing from bdrv_state list.
745 Also, NULL terminate the device_name to prevent double remove */
746void bdrv_make_anon(BlockDriverState *bs)
747{
748 if (bs->device_name[0] != '\0') {
749 QTAILQ_REMOVE(&bdrv_states, bs, list);
750 }
751 bs->device_name[0] = '\0';
752}
753
b338082b
FB		 754void bdrv_delete(BlockDriverState *bs)
755{
18846dee
MA		 756 assert(!bs->peer);
757
1b7bdbc1 758 /* remove from list, if necessary */
d22b2f41 759 bdrv_make_anon(bs);
34c6f050 760
b338082b 761 bdrv_close(bs);
66f82cee
KW		 762 if (bs->file != NULL) {
763 bdrv_delete(bs->file);
764 }
765
f9092b10 766 assert(bs != bs_snapshots);
7267c094 767 g_free(bs);
fc01f7e7
FB		 768}
769
18846dee
MA		 770int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)
771{
772 if (bs->peer) {
773 return -EBUSY;
774 }
775 bs->peer = qdev;
776 return 0;
777}
778
779void bdrv_detach(BlockDriverState *bs, DeviceState *qdev)
780{
781 assert(bs->peer == qdev);
782 bs->peer = NULL;
a19712b0
MA		 783 bs->change_cb = NULL;
784 bs->change_opaque = NULL;
18846dee
MA		 785}
786
787DeviceState *bdrv_get_attached(BlockDriverState *bs)
788{
789 return bs->peer;
790}
791
e97fc193
AL		 792/*
793 * Run consistency checks on an image
794 *
e076f338 795 * Returns 0 if the check could be completed (it doesn't mean that the image is
a1c7273b 796 * free of errors) or -errno when an internal error occurred. The results of the
e076f338 797 * check are stored in res.
e97fc193 798 */
e076f338 799int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
e97fc193
AL		 800{
801 if (bs->drv->bdrv_check == NULL) {
802 return -ENOTSUP;
803 }
804
e076f338 805 memset(res, 0, sizeof(*res));
9ac228e0 806 return bs->drv->bdrv_check(bs, res);
e97fc193
AL		 807}
808
8a426614
KW		 809#define COMMIT_BUF_SECTORS 2048
810
33e3963e
FB		 811/* commit COW file into the raw image */
812int bdrv_commit(BlockDriverState *bs)
813{
19cb3738 814 BlockDriver *drv = bs->drv;
ee181196 815 BlockDriver *backing_drv;
8a426614
KW		 816 int64_t sector, total_sectors;
817 int n, ro, open_flags;
4dca4b63 818 int ret = 0, rw_ret = 0;
8a426614 819 uint8_t *buf;
4dca4b63
NS		 820 char filename[1024];
821 BlockDriverState *bs_rw, *bs_ro;
33e3963e 822
19cb3738
FB		 823 if (!drv)
824 return -ENOMEDIUM;
4dca4b63
NS		 825
826 if (!bs->backing_hd) {
827 return -ENOTSUP;
33e3963e
FB		 828 }
829
4dca4b63
NS		 830 if (bs->backing_hd->keep_read_only) {
831 return -EACCES;
832 }
ee181196
KW		 833
834 backing_drv = bs->backing_hd->drv;
4dca4b63
NS		 835 ro = bs->backing_hd->read_only;
836 strncpy(filename, bs->backing_hd->filename, sizeof(filename));
837 open_flags = bs->backing_hd->open_flags;
838
839 if (ro) {
840 /* re-open as RW */
841 bdrv_delete(bs->backing_hd);
842 bs->backing_hd = NULL;
843 bs_rw = bdrv_new("");
ee181196
KW		 844 rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR,
845 backing_drv);
4dca4b63
NS		 846 if (rw_ret < 0) {
847 bdrv_delete(bs_rw);
848 /* try to re-open read-only */
849 bs_ro = bdrv_new("");
ee181196
KW		 850 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
851 backing_drv);
4dca4b63
NS		 852 if (ret < 0) {
853 bdrv_delete(bs_ro);
854 /* drive not functional anymore */
855 bs->drv = NULL;
856 return ret;
857 }
858 bs->backing_hd = bs_ro;
859 return rw_ret;
860 }
861 bs->backing_hd = bs_rw;
ea2384d3 862 }
33e3963e 863
6ea44308 864 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
7267c094 865 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
8a426614
KW		 866
867 for (sector = 0; sector < total_sectors; sector += n) {
868 if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
869
870 if (bdrv_read(bs, sector, buf, n) != 0) {
871 ret = -EIO;
872 goto ro_cleanup;
873 }
874
875 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
876 ret = -EIO;
877 goto ro_cleanup;
878 }
ea2384d3 879 }
33e3963e 880 }
95389c86 881
1d44952f
CH		 882 if (drv->bdrv_make_empty) {
883 ret = drv->bdrv_make_empty(bs);
884 bdrv_flush(bs);
885 }
95389c86 886
3f5075ae
CH		 887 /*
888 * Make sure all data we wrote to the backing device is actually
889 * stable on disk.
890 */
891 if (bs->backing_hd)
892 bdrv_flush(bs->backing_hd);
4dca4b63
NS		 893
894ro_cleanup:
7267c094 895 g_free(buf);
4dca4b63
NS		 896
897 if (ro) {
898 /* re-open as RO */
899 bdrv_delete(bs->backing_hd);
900 bs->backing_hd = NULL;
901 bs_ro = bdrv_new("");
ee181196
KW		 902 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
903 backing_drv);
4dca4b63
NS		 904 if (ret < 0) {
905 bdrv_delete(bs_ro);
906 /* drive not functional anymore */
907 bs->drv = NULL;
908 return ret;
909 }
910 bs->backing_hd = bs_ro;
911 bs->backing_hd->keep_read_only = 0;
912 }
913
1d44952f 914 return ret;
33e3963e
FB		 915}
916
6ab4b5ab
MA		 917void bdrv_commit_all(void)
918{
919 BlockDriverState *bs;
920
921 QTAILQ_FOREACH(bs, &bdrv_states, list) {
922 bdrv_commit(bs);
923 }
924}
925
756e6736
KW		 926/*
927 * Return values:
928 * 0 - success
929 * -EINVAL - backing format specified, but no file
930 * -ENOSPC - can't update the backing file because no space is left in the
931 * image file header
932 * -ENOTSUP - format driver doesn't support changing the backing file
933 */
934int bdrv_change_backing_file(BlockDriverState *bs,
935 const char *backing_file, const char *backing_fmt)
936{
937 BlockDriver *drv = bs->drv;
938
939 if (drv->bdrv_change_backing_file != NULL) {
940 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
941 } else {
942 return -ENOTSUP;
943 }
944}
945
71d0770c
AL		 946static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
947 size_t size)
948{
949 int64_t len;
950
951 if (!bdrv_is_inserted(bs))
952 return -ENOMEDIUM;
953
954 if (bs->growable)
955 return 0;
956
957 len = bdrv_getlength(bs);
958
fbb7b4e0
KW		 959 if (offset < 0)
960 return -EIO;
961
962 if ((offset > len) || (len - offset < size))
71d0770c
AL		 963 return -EIO;
964
965 return 0;
966}
967
968static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
969 int nb_sectors)
970{
eb5a3165
JS		 971 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
972 nb_sectors * BDRV_SECTOR_SIZE);
71d0770c
AL		 973}
974
e7a8a783
KW		 975static inline bool bdrv_has_async_rw(BlockDriver *drv)
976{
977 return drv->bdrv_co_readv != bdrv_co_readv_em
978 || drv->bdrv_aio_readv != bdrv_aio_readv_em;
979}
980
981static inline bool bdrv_has_async_flush(BlockDriver *drv)
982{
983 return drv->bdrv_aio_flush != bdrv_aio_flush_em;
984}
985
19cb3738 986/* return < 0 if error. See bdrv_write() for the return codes */
5fafdf24 987int bdrv_read(BlockDriverState *bs, int64_t sector_num,
fc01f7e7
FB		 988 uint8_t *buf, int nb_sectors)
989{
ea2384d3
FB		 990 BlockDriver *drv = bs->drv;
991
19cb3738
FB		 992 if (!drv)
993 return -ENOMEDIUM;
e7a8a783
KW		 994
995 if (bdrv_has_async_rw(drv) && qemu_in_coroutine()) {
996 QEMUIOVector qiov;
997 struct iovec iov = {
998 .iov_base = (void *)buf,
999 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
1000 };
1001
1002 qemu_iovec_init_external(&qiov, &iov, 1);
1003 return bdrv_co_readv(bs, sector_num, nb_sectors, &qiov);
1004 }
1005
71d0770c
AL		 1006 if (bdrv_check_request(bs, sector_num, nb_sectors))
1007 return -EIO;
b338082b 1008
eda578e5 1009 return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
fc01f7e7
FB		 1010}
1011
7cd1e32a 1012static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
a55eb92c 1013 int nb_sectors, int dirty)
7cd1e32a 1014{
1015 int64_t start, end;
c6d22830 1016 unsigned long val, idx, bit;
a55eb92c 1017
6ea44308 1018 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
c6d22830 1019 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
a55eb92c
JK		 1020
1021 for (; start <= end; start++) {
c6d22830
JK		 1022 idx = start / (sizeof(unsigned long) * 8);
1023 bit = start % (sizeof(unsigned long) * 8);
1024 val = bs->dirty_bitmap[idx];
1025 if (dirty) {
6d59fec1 1026 if (!(val & (1UL << bit))) {
aaa0eb75 1027 bs->dirty_count++;
6d59fec1 1028 val |= 1UL << bit;
aaa0eb75 1029 }
c6d22830 1030 } else {
6d59fec1 1031 if (val & (1UL << bit)) {
aaa0eb75 1032 bs->dirty_count--;
6d59fec1 1033 val &= ~(1UL << bit);
aaa0eb75 1034 }
c6d22830
JK		 1035 }
1036 bs->dirty_bitmap[idx] = val;
7cd1e32a 1037 }
1038}
1039
5fafdf24 1040/* Return < 0 if error. Important errors are:
19cb3738
FB		 1041 -EIO generic I/O error (may happen for all errors)
1042 -ENOMEDIUM No media inserted.
1043 -EINVAL Invalid sector number or nb_sectors
1044 -EACCES Trying to write a read-only device
1045*/
5fafdf24 1046int bdrv_write(BlockDriverState *bs, int64_t sector_num,
fc01f7e7
FB		 1047 const uint8_t *buf, int nb_sectors)
1048{
83f64091 1049 BlockDriver *drv = bs->drv;
e7a8a783 1050
19cb3738
FB		 1051 if (!bs->drv)
1052 return -ENOMEDIUM;
e7a8a783
KW		 1053
1054 if (bdrv_has_async_rw(drv) && qemu_in_coroutine()) {
1055 QEMUIOVector qiov;
1056 struct iovec iov = {
1057 .iov_base = (void *)buf,
1058 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
1059 };
1060
1061 qemu_iovec_init_external(&qiov, &iov, 1);
1062 return bdrv_co_writev(bs, sector_num, nb_sectors, &qiov);
1063 }
1064
0849bf08 1065 if (bs->read_only)
19cb3738 1066 return -EACCES;
71d0770c
AL		 1067 if (bdrv_check_request(bs, sector_num, nb_sectors))
1068 return -EIO;
a55eb92c 1069
c6d22830 1070 if (bs->dirty_bitmap) {
7cd1e32a 1071 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1072 }
a55eb92c 1073
294cc35f
KW		 1074 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
1075 bs->wr_highest_sector = sector_num + nb_sectors - 1;
1076 }
1077
42fb2807 1078 return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
83f64091
FB		 1079}
1080
eda578e5
AL		 1081int bdrv_pread(BlockDriverState *bs, int64_t offset,
1082 void *buf, int count1)
83f64091 1083{
6ea44308 1084 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
83f64091
FB		 1085 int len, nb_sectors, count;
1086 int64_t sector_num;
9a8c4cce 1087 int ret;
83f64091
FB		 1088
1089 count = count1;
1090 /* first read to align to sector start */
6ea44308 1091 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
83f64091
FB		 1092 if (len > count)
1093 len = count;
6ea44308 1094 sector_num = offset >> BDRV_SECTOR_BITS;
83f64091 1095 if (len > 0) {
9a8c4cce
KW		 1096 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1097 return ret;
6ea44308 1098 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
83f64091
FB		 1099 count -= len;
1100 if (count == 0)
1101 return count1;
1102 sector_num++;
1103 buf += len;
1104 }
1105
1106 /* read the sectors "in place" */
6ea44308 1107 nb_sectors = count >> BDRV_SECTOR_BITS;
83f64091 1108 if (nb_sectors > 0) {
9a8c4cce
KW		 1109 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1110 return ret;
83f64091 1111 sector_num += nb_sectors;
6ea44308 1112 len = nb_sectors << BDRV_SECTOR_BITS;
83f64091
FB		 1113 buf += len;
1114 count -= len;
1115 }
1116
1117 /* add data from the last sector */
1118 if (count > 0) {
9a8c4cce
KW		 1119 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1120 return ret;
83f64091
FB		 1121 memcpy(buf, tmp_buf, count);
1122 }
1123 return count1;
1124}
1125
eda578e5
AL		 1126int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1127 const void *buf, int count1)
83f64091 1128{
6ea44308 1129 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
83f64091
FB		 1130 int len, nb_sectors, count;
1131 int64_t sector_num;
9a8c4cce 1132 int ret;
83f64091
FB		 1133
1134 count = count1;
1135 /* first write to align to sector start */
6ea44308 1136 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
83f64091
FB		 1137 if (len > count)
1138 len = count;
6ea44308 1139 sector_num = offset >> BDRV_SECTOR_BITS;
83f64091 1140 if (len > 0) {
9a8c4cce
KW		 1141 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1142 return ret;
6ea44308 1143 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
9a8c4cce
KW		 1144 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1145 return ret;
83f64091
FB		 1146 count -= len;
1147 if (count == 0)
1148 return count1;
1149 sector_num++;
1150 buf += len;
1151 }
1152
1153 /* write the sectors "in place" */
6ea44308 1154 nb_sectors = count >> BDRV_SECTOR_BITS;
83f64091 1155 if (nb_sectors > 0) {
9a8c4cce
KW		 1156 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1157 return ret;
83f64091 1158 sector_num += nb_sectors;
6ea44308 1159 len = nb_sectors << BDRV_SECTOR_BITS;
83f64091
FB		 1160 buf += len;
1161 count -= len;
1162 }
1163
1164 /* add data from the last sector */
1165 if (count > 0) {
9a8c4cce
KW		 1166 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1167 return ret;
83f64091 1168 memcpy(tmp_buf, buf, count);
9a8c4cce
KW		 1169 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1170 return ret;
83f64091
FB		 1171 }
1172 return count1;
1173}
83f64091 1174
f08145fe
KW		 1175/*
1176 * Writes to the file and ensures that no writes are reordered across this
1177 * request (acts as a barrier)
1178 *
1179 * Returns 0 on success, -errno in error cases.
1180 */
1181int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1182 const void *buf, int count)
1183{
1184 int ret;
1185
1186 ret = bdrv_pwrite(bs, offset, buf, count);
1187 if (ret < 0) {
1188 return ret;
1189 }
1190
1191 /* No flush needed for cache=writethrough, it uses O_DSYNC */
1192 if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) {
1193 bdrv_flush(bs);
1194 }
1195
1196 return 0;
1197}
1198
da1fa91d
KW		 1199int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
1200 int nb_sectors, QEMUIOVector *qiov)
1201{
1202 BlockDriver *drv = bs->drv;
1203
1204 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
1205
1206 if (!drv) {
1207 return -ENOMEDIUM;
1208 }
1209 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
1210 return -EIO;
1211 }
1212
1213 return drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
1214}
1215
1216int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
1217 int nb_sectors, QEMUIOVector *qiov)
1218{
1219 BlockDriver *drv = bs->drv;
1220
1221 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
1222
1223 if (!bs->drv) {
1224 return -ENOMEDIUM;
1225 }
1226 if (bs->read_only) {
1227 return -EACCES;
1228 }
1229 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
1230 return -EIO;
1231 }
1232
1233 if (bs->dirty_bitmap) {
1234 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1235 }
1236
1237 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
1238 bs->wr_highest_sector = sector_num + nb_sectors - 1;
1239 }
1240
1241 return drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
1242}
1243
83f64091
FB		 1244/**
1245 * Truncate file to 'offset' bytes (needed only for file protocols)
1246 */
1247int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1248{
1249 BlockDriver *drv = bs->drv;
51762288 1250 int ret;
83f64091 1251 if (!drv)
19cb3738 1252 return -ENOMEDIUM;
83f64091
FB		 1253 if (!drv->bdrv_truncate)
1254 return -ENOTSUP;
59f2689d
NS		 1255 if (bs->read_only)
1256 return -EACCES;
8591675f
MT		 1257 if (bdrv_in_use(bs))
1258 return -EBUSY;
51762288
SH		 1259 ret = drv->bdrv_truncate(bs, offset);
1260 if (ret == 0) {
1261 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
db97ee6a
CH		 1262 if (bs->change_cb) {
1263 bs->change_cb(bs->change_opaque, CHANGE_SIZE);
1264 }
51762288
SH		 1265 }
1266 return ret;
83f64091
FB		 1267}
1268
4a1d5e1f
FZ		 1269/**
1270 * Length of a allocated file in bytes. Sparse files are counted by actual
1271 * allocated space. Return < 0 if error or unknown.
1272 */
1273int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
1274{
1275 BlockDriver *drv = bs->drv;
1276 if (!drv) {
1277 return -ENOMEDIUM;
1278 }
1279 if (drv->bdrv_get_allocated_file_size) {
1280 return drv->bdrv_get_allocated_file_size(bs);
1281 }
1282 if (bs->file) {
1283 return bdrv_get_allocated_file_size(bs->file);
1284 }
1285 return -ENOTSUP;
1286}
1287
83f64091
FB		 1288/**
1289 * Length of a file in bytes. Return < 0 if error or unknown.
1290 */
1291int64_t bdrv_getlength(BlockDriverState *bs)
1292{
1293 BlockDriver *drv = bs->drv;
1294 if (!drv)
19cb3738 1295 return -ENOMEDIUM;
51762288 1296
46a4e4e6
SH		 1297 if (bs->growable || bs->removable) {
1298 if (drv->bdrv_getlength) {
1299 return drv->bdrv_getlength(bs);
1300 }
83f64091 1301 }
46a4e4e6 1302 return bs->total_sectors * BDRV_SECTOR_SIZE;
fc01f7e7
FB		 1303}
1304
19cb3738 1305/* return 0 as number of sectors if no device present or error */
96b8f136 1306void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
fc01f7e7 1307{
19cb3738
FB		 1308 int64_t length;
1309 length = bdrv_getlength(bs);
1310 if (length < 0)
1311 length = 0;
1312 else
6ea44308 1313 length = length >> BDRV_SECTOR_BITS;
19cb3738 1314 *nb_sectors_ptr = length;
fc01f7e7 1315}
cf98951b 1316
f3d54fc4
AL		 1317struct partition {
1318 uint8_t boot_ind; /* 0x80 - active */
1319 uint8_t head; /* starting head */
1320 uint8_t sector; /* starting sector */
1321 uint8_t cyl; /* starting cylinder */
1322 uint8_t sys_ind; /* What partition type */
1323 uint8_t end_head; /* end head */
1324 uint8_t end_sector; /* end sector */
1325 uint8_t end_cyl; /* end cylinder */
1326 uint32_t start_sect; /* starting sector counting from 0 */
1327 uint32_t nr_sects; /* nr of sectors in partition */
1328} __attribute__((packed));
1329
1330/* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1331static int guess_disk_lchs(BlockDriverState *bs,
1332 int *pcylinders, int *pheads, int *psectors)
1333{
eb5a3165 1334 uint8_t buf[BDRV_SECTOR_SIZE];
f3d54fc4
AL		 1335 int ret, i, heads, sectors, cylinders;
1336 struct partition *p;
1337 uint32_t nr_sects;
a38131b6 1338 uint64_t nb_sectors;
f3d54fc4
AL		 1339
1340 bdrv_get_geometry(bs, &nb_sectors);
1341
1342 ret = bdrv_read(bs, 0, buf, 1);
1343 if (ret < 0)
1344 return -1;
1345 /* test msdos magic */
1346 if (buf[510] != 0x55 || buf[511] != 0xaa)
1347 return -1;
1348 for(i = 0; i < 4; i++) {
1349 p = ((struct partition *)(buf + 0x1be)) + i;
1350 nr_sects = le32_to_cpu(p->nr_sects);
1351 if (nr_sects && p->end_head) {
1352 /* We make the assumption that the partition terminates on
1353 a cylinder boundary */
1354 heads = p->end_head + 1;
1355 sectors = p->end_sector & 63;
1356 if (sectors == 0)
1357 continue;
1358 cylinders = nb_sectors / (heads * sectors);
1359 if (cylinders < 1 || cylinders > 16383)
1360 continue;
1361 *pheads = heads;
1362 *psectors = sectors;
1363 *pcylinders = cylinders;
1364#if 0
1365 printf("guessed geometry: LCHS=%d %d %d\n",
1366 cylinders, heads, sectors);
1367#endif
1368 return 0;
1369 }
1370 }
1371 return -1;
1372}
1373
1374void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1375{
1376 int translation, lba_detected = 0;
1377 int cylinders, heads, secs;
a38131b6 1378 uint64_t nb_sectors;
f3d54fc4
AL		 1379
1380 /* if a geometry hint is available, use it */
1381 bdrv_get_geometry(bs, &nb_sectors);
1382 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1383 translation = bdrv_get_translation_hint(bs);
1384 if (cylinders != 0) {
1385 *pcyls = cylinders;
1386 *pheads = heads;
1387 *psecs = secs;
1388 } else {
1389 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1390 if (heads > 16) {
1391 /* if heads > 16, it means that a BIOS LBA
1392 translation was active, so the default
1393 hardware geometry is OK */
1394 lba_detected = 1;
1395 goto default_geometry;
1396 } else {
1397 *pcyls = cylinders;
1398 *pheads = heads;
1399 *psecs = secs;
1400 /* disable any translation to be in sync with
1401 the logical geometry */
1402 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
1403 bdrv_set_translation_hint(bs,
1404 BIOS_ATA_TRANSLATION_NONE);
1405 }
1406 }
1407 } else {
1408 default_geometry:
1409 /* if no geometry, use a standard physical disk geometry */
1410 cylinders = nb_sectors / (16 * 63);
1411
1412 if (cylinders > 16383)
1413 cylinders = 16383;
1414 else if (cylinders < 2)
1415 cylinders = 2;
1416 *pcyls = cylinders;
1417 *pheads = 16;
1418 *psecs = 63;
1419 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
1420 if ((*pcyls * *pheads) <= 131072) {
1421 bdrv_set_translation_hint(bs,
1422 BIOS_ATA_TRANSLATION_LARGE);
1423 } else {
1424 bdrv_set_translation_hint(bs,
1425 BIOS_ATA_TRANSLATION_LBA);
1426 }
1427 }
1428 }
1429 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1430 }
1431}
1432
5fafdf24 1433void bdrv_set_geometry_hint(BlockDriverState *bs,
b338082b
FB		 1434 int cyls, int heads, int secs)
1435{
1436 bs->cyls = cyls;
1437 bs->heads = heads;
1438 bs->secs = secs;
1439}
1440
46d4767d
FB		 1441void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1442{
1443 bs->translation = translation;
1444}
1445
5fafdf24 1446void bdrv_get_geometry_hint(BlockDriverState *bs,
b338082b
FB		 1447 int *pcyls, int *pheads, int *psecs)
1448{
1449 *pcyls = bs->cyls;
1450 *pheads = bs->heads;
1451 *psecs = bs->secs;
1452}
1453
5bbdbb46
BS		 1454/* Recognize floppy formats */
1455typedef struct FDFormat {
1456 FDriveType drive;
1457 uint8_t last_sect;
1458 uint8_t max_track;
1459 uint8_t max_head;
1460} FDFormat;
1461
1462static const FDFormat fd_formats[] = {
1463 /* First entry is default format */
1464 /* 1.44 MB 3"1/2 floppy disks */
1465 { FDRIVE_DRV_144, 18, 80, 1, },
1466 { FDRIVE_DRV_144, 20, 80, 1, },
1467 { FDRIVE_DRV_144, 21, 80, 1, },
1468 { FDRIVE_DRV_144, 21, 82, 1, },
1469 { FDRIVE_DRV_144, 21, 83, 1, },
1470 { FDRIVE_DRV_144, 22, 80, 1, },
1471 { FDRIVE_DRV_144, 23, 80, 1, },
1472 { FDRIVE_DRV_144, 24, 80, 1, },
1473 /* 2.88 MB 3"1/2 floppy disks */
1474 { FDRIVE_DRV_288, 36, 80, 1, },
1475 { FDRIVE_DRV_288, 39, 80, 1, },
1476 { FDRIVE_DRV_288, 40, 80, 1, },
1477 { FDRIVE_DRV_288, 44, 80, 1, },
1478 { FDRIVE_DRV_288, 48, 80, 1, },
1479 /* 720 kB 3"1/2 floppy disks */
1480 { FDRIVE_DRV_144, 9, 80, 1, },
1481 { FDRIVE_DRV_144, 10, 80, 1, },
1482 { FDRIVE_DRV_144, 10, 82, 1, },
1483 { FDRIVE_DRV_144, 10, 83, 1, },
1484 { FDRIVE_DRV_144, 13, 80, 1, },
1485 { FDRIVE_DRV_144, 14, 80, 1, },
1486 /* 1.2 MB 5"1/4 floppy disks */
1487 { FDRIVE_DRV_120, 15, 80, 1, },
1488 { FDRIVE_DRV_120, 18, 80, 1, },
1489 { FDRIVE_DRV_120, 18, 82, 1, },
1490 { FDRIVE_DRV_120, 18, 83, 1, },
1491 { FDRIVE_DRV_120, 20, 80, 1, },
1492 /* 720 kB 5"1/4 floppy disks */
1493 { FDRIVE_DRV_120, 9, 80, 1, },
1494 { FDRIVE_DRV_120, 11, 80, 1, },
1495 /* 360 kB 5"1/4 floppy disks */
1496 { FDRIVE_DRV_120, 9, 40, 1, },
1497 { FDRIVE_DRV_120, 9, 40, 0, },
1498 { FDRIVE_DRV_120, 10, 41, 1, },
1499 { FDRIVE_DRV_120, 10, 42, 1, },
1500 /* 320 kB 5"1/4 floppy disks */
1501 { FDRIVE_DRV_120, 8, 40, 1, },
1502 { FDRIVE_DRV_120, 8, 40, 0, },
1503 /* 360 kB must match 5"1/4 better than 3"1/2... */
1504 { FDRIVE_DRV_144, 9, 80, 0, },
1505 /* end */
1506 { FDRIVE_DRV_NONE, -1, -1, 0, },
1507};
1508
1509void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
1510 int *max_track, int *last_sect,
1511 FDriveType drive_in, FDriveType *drive)
1512{
1513 const FDFormat *parse;
1514 uint64_t nb_sectors, size;
1515 int i, first_match, match;
1516
1517 bdrv_get_geometry_hint(bs, nb_heads, max_track, last_sect);
1518 if (*nb_heads != 0 && *max_track != 0 && *last_sect != 0) {
1519 /* User defined disk */
1520 } else {
1521 bdrv_get_geometry(bs, &nb_sectors);
1522 match = -1;
1523 first_match = -1;
1524 for (i = 0; ; i++) {
1525 parse = &fd_formats[i];
1526 if (parse->drive == FDRIVE_DRV_NONE) {
1527 break;
1528 }
1529 if (drive_in == parse->drive ||
1530 drive_in == FDRIVE_DRV_NONE) {
1531 size = (parse->max_head + 1) * parse->max_track *
1532 parse->last_sect;
1533 if (nb_sectors == size) {
1534 match = i;
1535 break;
1536 }
1537 if (first_match == -1) {
1538 first_match = i;
1539 }
1540 }
1541 }
1542 if (match == -1) {
1543 if (first_match == -1) {
1544 match = 1;
1545 } else {
1546 match = first_match;
1547 }
1548 parse = &fd_formats[match];
1549 }
1550 *nb_heads = parse->max_head + 1;
1551 *max_track = parse->max_track;
1552 *last_sect = parse->last_sect;
1553 *drive = parse->drive;
1554 }
1555}
1556
46d4767d
FB		 1557int bdrv_get_translation_hint(BlockDriverState *bs)
1558{
1559 return bs->translation;
1560}
1561
abd7f68d
MA		 1562void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1563 BlockErrorAction on_write_error)
1564{
1565 bs->on_read_error = on_read_error;
1566 bs->on_write_error = on_write_error;
1567}
1568
1569BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
1570{
1571 return is_read ? bs->on_read_error : bs->on_write_error;
1572}
1573
7d0d6950
MA		 1574void bdrv_set_removable(BlockDriverState *bs, int removable)
1575{
1576 bs->removable = removable;
1577 if (removable && bs == bs_snapshots) {
1578 bs_snapshots = NULL;
1579 }
1580}
1581
b338082b
FB		 1582int bdrv_is_removable(BlockDriverState *bs)
1583{
1584 return bs->removable;
1585}
1586
1587int bdrv_is_read_only(BlockDriverState *bs)
1588{
1589 return bs->read_only;
1590}
1591
985a03b0
TS		 1592int bdrv_is_sg(BlockDriverState *bs)
1593{
1594 return bs->sg;
1595}
1596
e900a7b7
CH		 1597int bdrv_enable_write_cache(BlockDriverState *bs)
1598{
1599 return bs->enable_write_cache;
1600}
1601
19cb3738 1602/* XXX: no longer used */
5fafdf24 1603void bdrv_set_change_cb(BlockDriverState *bs,
db97ee6a
CH		 1604 void (*change_cb)(void *opaque, int reason),
1605 void *opaque)
b338082b
FB		 1606{
1607 bs->change_cb = change_cb;
1608 bs->change_opaque = opaque;
1609}
1610
ea2384d3
FB		 1611int bdrv_is_encrypted(BlockDriverState *bs)
1612{
1613 if (bs->backing_hd && bs->backing_hd->encrypted)
1614 return 1;
1615 return bs->encrypted;
1616}
1617
c0f4ce77
AL		 1618int bdrv_key_required(BlockDriverState *bs)
1619{
1620 BlockDriverState *backing_hd = bs->backing_hd;
1621
1622 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
1623 return 1;
1624 return (bs->encrypted && !bs->valid_key);
1625}
1626
ea2384d3
FB		 1627int bdrv_set_key(BlockDriverState *bs, const char *key)
1628{
1629 int ret;
1630 if (bs->backing_hd && bs->backing_hd->encrypted) {
1631 ret = bdrv_set_key(bs->backing_hd, key);
1632 if (ret < 0)
1633 return ret;
1634 if (!bs->encrypted)
1635 return 0;
1636 }
fd04a2ae
SH		 1637 if (!bs->encrypted) {
1638 return -EINVAL;
1639 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1640 return -ENOMEDIUM;
1641 }
c0f4ce77 1642 ret = bs->drv->bdrv_set_key(bs, key);
bb5fc20f
AL		 1643 if (ret < 0) {
1644 bs->valid_key = 0;
1645 } else if (!bs->valid_key) {
1646 bs->valid_key = 1;
1647 /* call the change callback now, we skipped it on open */
1648 bs->media_changed = 1;
1649 if (bs->change_cb)
db97ee6a 1650 bs->change_cb(bs->change_opaque, CHANGE_MEDIA);
bb5fc20f 1651 }
c0f4ce77 1652 return ret;
ea2384d3
FB		 1653}
1654
1655void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1656{
19cb3738 1657 if (!bs->drv) {
ea2384d3
FB		 1658 buf[0] = '\0';
1659 } else {
1660 pstrcpy(buf, buf_size, bs->drv->format_name);
1661 }
1662}
1663
5fafdf24 1664void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
ea2384d3
FB		 1665 void *opaque)
1666{
1667 BlockDriver *drv;
1668
8a22f02a 1669 QLIST_FOREACH(drv, &bdrv_drivers, list) {
ea2384d3
FB		 1670 it(opaque, drv->format_name);
1671 }
1672}
1673
b338082b
FB		 1674BlockDriverState *bdrv_find(const char *name)
1675{
1676 BlockDriverState *bs;
1677
1b7bdbc1
SH		 1678 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1679 if (!strcmp(name, bs->device_name)) {
b338082b 1680 return bs;
1b7bdbc1 1681 }
b338082b
FB		 1682 }
1683 return NULL;
1684}
1685
2f399b0a
MA		 1686BlockDriverState *bdrv_next(BlockDriverState *bs)
1687{
1688 if (!bs) {
1689 return QTAILQ_FIRST(&bdrv_states);
1690 }
1691 return QTAILQ_NEXT(bs, list);
1692}
1693
51de9760 1694void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
81d0912d
FB		 1695{
1696 BlockDriverState *bs;
1697
1b7bdbc1 1698 QTAILQ_FOREACH(bs, &bdrv_states, list) {
51de9760 1699 it(opaque, bs);
81d0912d
FB		 1700 }
1701}
1702
ea2384d3
FB		 1703const char *bdrv_get_device_name(BlockDriverState *bs)
1704{
1705 return bs->device_name;
1706}
1707
205ef796 1708int bdrv_flush(BlockDriverState *bs)
7a6cba61 1709{
016f5cf6 1710 if (bs->open_flags & BDRV_O_NO_FLUSH) {
205ef796
KW		 1711 return 0;
1712 }
1713
e7a8a783
KW		 1714 if (bs->drv && bdrv_has_async_flush(bs->drv) && qemu_in_coroutine()) {
1715 return bdrv_co_flush_em(bs);
1716 }
1717
205ef796
KW		 1718 if (bs->drv && bs->drv->bdrv_flush) {
1719 return bs->drv->bdrv_flush(bs);
016f5cf6
AG		 1720 }
1721
205ef796
KW		 1722 /*
1723 * Some block drivers always operate in either writethrough or unsafe mode
1724 * and don't support bdrv_flush therefore. Usually qemu doesn't know how
1725 * the server works (because the behaviour is hardcoded or depends on
1726 * server-side configuration), so we can't ensure that everything is safe
1727 * on disk. Returning an error doesn't work because that would break guests
1728 * even if the server operates in writethrough mode.
1729 *
1730 * Let's hope the user knows what he's doing.
1731 */
1732 return 0;
7a6cba61
PB		 1733}
1734
c6ca28d6
AL		 1735void bdrv_flush_all(void)
1736{
1737 BlockDriverState *bs;
1738
1b7bdbc1
SH		 1739 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1740 if (bs->drv && !bdrv_is_read_only(bs) &&
1741 (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) {
c6ca28d6 1742 bdrv_flush(bs);
1b7bdbc1
SH		 1743 }
1744 }
c6ca28d6
AL		 1745}
1746
f2feebbd
KW		 1747int bdrv_has_zero_init(BlockDriverState *bs)
1748{
1749 assert(bs->drv);
1750
336c1c12
KW		 1751 if (bs->drv->bdrv_has_zero_init) {
1752 return bs->drv->bdrv_has_zero_init(bs);
f2feebbd
KW		 1753 }
1754
1755 return 1;
1756}
1757
bb8bf76f
CH		 1758int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
1759{
1760 if (!bs->drv) {
1761 return -ENOMEDIUM;
1762 }
1763 if (!bs->drv->bdrv_discard) {
1764 return 0;
1765 }
1766 return bs->drv->bdrv_discard(bs, sector_num, nb_sectors);
1767}
1768
f58c7b35
TS		 1769/*
1770 * Returns true iff the specified sector is present in the disk image. Drivers
1771 * not implementing the functionality are assumed to not support backing files,
1772 * hence all their sectors are reported as allocated.
1773 *
1774 * 'pnum' is set to the number of sectors (including and immediately following
1775 * the specified sector) that are known to be in the same
1776 * allocated/unallocated state.
1777 *
1778 * 'nb_sectors' is the max value 'pnum' should be set to.
1779 */
1780int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1781 int *pnum)
1782{
1783 int64_t n;
1784 if (!bs->drv->bdrv_is_allocated) {
1785 if (sector_num >= bs->total_sectors) {
1786 *pnum = 0;
1787 return 0;
1788 }
1789 n = bs->total_sectors - sector_num;
1790 *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1791 return 1;
1792 }
1793 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1794}
1795
2582bfed
LC		 1796void bdrv_mon_event(const BlockDriverState *bdrv,
1797 BlockMonEventAction action, int is_read)
1798{
1799 QObject *data;
1800 const char *action_str;
1801
1802 switch (action) {
1803 case BDRV_ACTION_REPORT:
1804 action_str = "report";
1805 break;
1806 case BDRV_ACTION_IGNORE:
1807 action_str = "ignore";
1808 break;
1809 case BDRV_ACTION_STOP:
1810 action_str = "stop";
1811 break;
1812 default:
1813 abort();
1814 }
1815
1816 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1817 bdrv->device_name,
1818 action_str,
1819 is_read ? "read" : "write");
1820 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);
1821
1822 qobject_decref(data);
1823}
1824
d15e5465 1825static void bdrv_print_dict(QObject *obj, void *opaque)
b338082b 1826{
d15e5465
LC		 1827 QDict *bs_dict;
1828 Monitor *mon = opaque;
1829
1830 bs_dict = qobject_to_qdict(obj);
1831
d8aeeb31 1832 monitor_printf(mon, "%s: removable=%d",
d15e5465 1833 qdict_get_str(bs_dict, "device"),
d15e5465
LC		 1834 qdict_get_bool(bs_dict, "removable"));
1835
1836 if (qdict_get_bool(bs_dict, "removable")) {
1837 monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked"));
1838 }
1839
1840 if (qdict_haskey(bs_dict, "inserted")) {
1841 QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
1842
1843 monitor_printf(mon, " file=");
1844 monitor_print_filename(mon, qdict_get_str(qdict, "file"));
1845 if (qdict_haskey(qdict, "backing_file")) {
1846 monitor_printf(mon, " backing_file=");
1847 monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
1848 }
1849 monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
1850 qdict_get_bool(qdict, "ro"),
1851 qdict_get_str(qdict, "drv"),
1852 qdict_get_bool(qdict, "encrypted"));
1853 } else {
1854 monitor_printf(mon, " [not inserted]");
1855 }
1856
1857 monitor_printf(mon, "\n");
1858}
1859
1860void bdrv_info_print(Monitor *mon, const QObject *data)
1861{
1862 qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
1863}
1864
d15e5465
LC		 1865void bdrv_info(Monitor *mon, QObject **ret_data)
1866{
1867 QList *bs_list;
b338082b
FB		 1868 BlockDriverState *bs;
1869
d15e5465
LC		 1870 bs_list = qlist_new();
1871
1b7bdbc1 1872 QTAILQ_FOREACH(bs, &bdrv_states, list) {
d15e5465 1873 QObject *bs_obj;
d15e5465 1874
d8aeeb31 1875 bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': 'unknown', "
d15e5465 1876 "'removable': %i, 'locked': %i }",
d8aeeb31 1877 bs->device_name, bs->removable,
d15e5465 1878 bs->locked);
d15e5465 1879
19cb3738 1880 if (bs->drv) {
d15e5465
LC		 1881 QObject *obj;
1882 QDict *bs_dict = qobject_to_qdict(bs_obj);
1883
1884 obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
1885 "'encrypted': %i }",
1886 bs->filename, bs->read_only,
1887 bs->drv->format_name,
1888 bdrv_is_encrypted(bs));
fef30743 1889 if (bs->backing_file[0] != '\0') {
d15e5465
LC		 1890 QDict *qdict = qobject_to_qdict(obj);
1891 qdict_put(qdict, "backing_file",
1892 qstring_from_str(bs->backing_file));
376253ec 1893 }
d15e5465
LC		 1894
1895 qdict_put_obj(bs_dict, "inserted", obj);
b338082b 1896 }
d15e5465 1897 qlist_append_obj(bs_list, bs_obj);
b338082b 1898 }
d15e5465
LC		 1899
1900 *ret_data = QOBJECT(bs_list);
b338082b 1901}
a36e69dd 1902
218a536a 1903static void bdrv_stats_iter(QObject *data, void *opaque)
a36e69dd 1904{
218a536a
LC		 1905 QDict *qdict;
1906 Monitor *mon = opaque;
1907
1908 qdict = qobject_to_qdict(data);
1909 monitor_printf(mon, "%s:", qdict_get_str(qdict, "device"));
1910
1911 qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
1912 monitor_printf(mon, " rd_bytes=%" PRId64
1913 " wr_bytes=%" PRId64
1914 " rd_operations=%" PRId64
1915 " wr_operations=%" PRId64
1916 "\n",
1917 qdict_get_int(qdict, "rd_bytes"),
1918 qdict_get_int(qdict, "wr_bytes"),
1919 qdict_get_int(qdict, "rd_operations"),
1920 qdict_get_int(qdict, "wr_operations"));
1921}
1922
1923void bdrv_stats_print(Monitor *mon, const QObject *data)
1924{
1925 qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
1926}
1927
294cc35f
KW		 1928static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
1929{
1930 QObject *res;
1931 QDict *dict;
1932
1933 res = qobject_from_jsonf("{ 'stats': {"
1934 "'rd_bytes': %" PRId64 ","
1935 "'wr_bytes': %" PRId64 ","
1936 "'rd_operations': %" PRId64 ","
1937 "'wr_operations': %" PRId64 ","
1938 "'wr_highest_offset': %" PRId64
1939 "} }",
1940 bs->rd_bytes, bs->wr_bytes,
1941 bs->rd_ops, bs->wr_ops,
5ffbbc67
BS		 1942 bs->wr_highest_sector *
1943 (uint64_t)BDRV_SECTOR_SIZE);
294cc35f
KW		 1944 dict = qobject_to_qdict(res);
1945
1946 if (*bs->device_name) {
1947 qdict_put(dict, "device", qstring_from_str(bs->device_name));
1948 }
1949
1950 if (bs->file) {
1951 QObject *parent = bdrv_info_stats_bs(bs->file);
1952 qdict_put_obj(dict, "parent", parent);
1953 }
1954
1955 return res;
1956}
1957
218a536a
LC		 1958void bdrv_info_stats(Monitor *mon, QObject **ret_data)
1959{
1960 QObject *obj;
1961 QList *devices;
a36e69dd
TS		 1962 BlockDriverState *bs;
1963
218a536a
LC		 1964 devices = qlist_new();
1965
1b7bdbc1 1966 QTAILQ_FOREACH(bs, &bdrv_states, list) {
294cc35f 1967 obj = bdrv_info_stats_bs(bs);
218a536a 1968 qlist_append_obj(devices, obj);
a36e69dd 1969 }
218a536a
LC		 1970
1971 *ret_data = QOBJECT(devices);
a36e69dd 1972}
ea2384d3 1973
045df330
AL		 1974const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1975{
1976 if (bs->backing_hd && bs->backing_hd->encrypted)
1977 return bs->backing_file;
1978 else if (bs->encrypted)
1979 return bs->filename;
1980 else
1981 return NULL;
1982}
1983
5fafdf24 1984void bdrv_get_backing_filename(BlockDriverState *bs,
83f64091
FB		 1985 char *filename, int filename_size)
1986{
b783e409 1987 if (!bs->backing_file) {
83f64091
FB		 1988 pstrcpy(filename, filename_size, "");
1989 } else {
1990 pstrcpy(filename, filename_size, bs->backing_file);
1991 }
1992}
1993
5fafdf24 1994int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
faea38e7
FB		 1995 const uint8_t *buf, int nb_sectors)
1996{
1997 BlockDriver *drv = bs->drv;
1998 if (!drv)
19cb3738 1999 return -ENOMEDIUM;
faea38e7
FB		 2000 if (!drv->bdrv_write_compressed)
2001 return -ENOTSUP;
fbb7b4e0
KW		 2002 if (bdrv_check_request(bs, sector_num, nb_sectors))
2003 return -EIO;
a55eb92c 2004
c6d22830 2005 if (bs->dirty_bitmap) {
7cd1e32a 2006 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2007 }
a55eb92c 2008
faea38e7
FB		 2009 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
2010}
3b46e624 2011
faea38e7
FB		 2012int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2013{
2014 BlockDriver *drv = bs->drv;
2015 if (!drv)
19cb3738 2016 return -ENOMEDIUM;
faea38e7
FB		 2017 if (!drv->bdrv_get_info)
2018 return -ENOTSUP;
2019 memset(bdi, 0, sizeof(*bdi));
2020 return drv->bdrv_get_info(bs, bdi);
2021}
2022
45566e9c
CH		 2023int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
2024 int64_t pos, int size)
178e08a5
AL		 2025{
2026 BlockDriver *drv = bs->drv;
2027 if (!drv)
2028 return -ENOMEDIUM;
7cdb1f6d
MK		 2029 if (drv->bdrv_save_vmstate)
2030 return drv->bdrv_save_vmstate(bs, buf, pos, size);
2031 if (bs->file)
2032 return bdrv_save_vmstate(bs->file, buf, pos, size);
2033 return -ENOTSUP;
178e08a5
AL		 2034}
2035
45566e9c
CH		 2036int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
2037 int64_t pos, int size)
178e08a5
AL		 2038{
2039 BlockDriver *drv = bs->drv;
2040 if (!drv)
2041 return -ENOMEDIUM;
7cdb1f6d
MK		 2042 if (drv->bdrv_load_vmstate)
2043 return drv->bdrv_load_vmstate(bs, buf, pos, size);
2044 if (bs->file)
2045 return bdrv_load_vmstate(bs->file, buf, pos, size);
2046 return -ENOTSUP;
178e08a5
AL		 2047}
2048
8b9b0cc2
KW		 2049void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2050{
2051 BlockDriver *drv = bs->drv;
2052
2053 if (!drv || !drv->bdrv_debug_event) {
2054 return;
2055 }
2056
2057 return drv->bdrv_debug_event(bs, event);
2058
2059}
2060
faea38e7
FB		 2061/**************************************************************/
2062/* handling of snapshots */
2063
feeee5ac
MDCF		 2064int bdrv_can_snapshot(BlockDriverState *bs)
2065{
2066 BlockDriver *drv = bs->drv;
2067 if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
2068 return 0;
2069 }
2070
2071 if (!drv->bdrv_snapshot_create) {
2072 if (bs->file != NULL) {
2073 return bdrv_can_snapshot(bs->file);
2074 }
2075 return 0;
2076 }
2077
2078 return 1;
2079}
2080
199630b6
BS		 2081int bdrv_is_snapshot(BlockDriverState *bs)
2082{
2083 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
2084}
2085
f9092b10
MA		 2086BlockDriverState *bdrv_snapshots(void)
2087{
2088 BlockDriverState *bs;
2089
3ac906f7 2090 if (bs_snapshots) {
f9092b10 2091 return bs_snapshots;
3ac906f7 2092 }
f9092b10
MA		 2093
2094 bs = NULL;
2095 while ((bs = bdrv_next(bs))) {
2096 if (bdrv_can_snapshot(bs)) {
3ac906f7
MA		 2097 bs_snapshots = bs;
2098 return bs;
f9092b10
MA		 2099 }
2100 }
2101 return NULL;
f9092b10
MA		 2102}
2103
5fafdf24 2104int bdrv_snapshot_create(BlockDriverState *bs,
faea38e7
FB		 2105 QEMUSnapshotInfo *sn_info)
2106{
2107 BlockDriver *drv = bs->drv;
2108 if (!drv)
19cb3738 2109 return -ENOMEDIUM;
7cdb1f6d
MK		 2110 if (drv->bdrv_snapshot_create)
2111 return drv->bdrv_snapshot_create(bs, sn_info);
2112 if (bs->file)
2113 return bdrv_snapshot_create(bs->file, sn_info);
2114 return -ENOTSUP;
faea38e7
FB		 2115}
2116
5fafdf24 2117int bdrv_snapshot_goto(BlockDriverState *bs,
faea38e7
FB		 2118 const char *snapshot_id)
2119{
2120 BlockDriver *drv = bs->drv;
7cdb1f6d
MK		 2121 int ret, open_ret;
2122
faea38e7 2123 if (!drv)
19cb3738 2124 return -ENOMEDIUM;
7cdb1f6d
MK		 2125 if (drv->bdrv_snapshot_goto)
2126 return drv->bdrv_snapshot_goto(bs, snapshot_id);
2127
2128 if (bs->file) {
2129 drv->bdrv_close(bs);
2130 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
2131 open_ret = drv->bdrv_open(bs, bs->open_flags);
2132 if (open_ret < 0) {
2133 bdrv_delete(bs->file);
2134 bs->drv = NULL;
2135 return open_ret;
2136 }
2137 return ret;
2138 }
2139
2140 return -ENOTSUP;
faea38e7
FB		 2141}
2142
2143int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
2144{
2145 BlockDriver *drv = bs->drv;
2146 if (!drv)
19cb3738 2147 return -ENOMEDIUM;
7cdb1f6d
MK		 2148 if (drv->bdrv_snapshot_delete)
2149 return drv->bdrv_snapshot_delete(bs, snapshot_id);
2150 if (bs->file)
2151 return bdrv_snapshot_delete(bs->file, snapshot_id);
2152 return -ENOTSUP;
faea38e7
FB		 2153}
2154
5fafdf24 2155int bdrv_snapshot_list(BlockDriverState *bs,
faea38e7
FB		 2156 QEMUSnapshotInfo **psn_info)
2157{
2158 BlockDriver *drv = bs->drv;
2159 if (!drv)
19cb3738 2160 return -ENOMEDIUM;
7cdb1f6d
MK		 2161 if (drv->bdrv_snapshot_list)
2162 return drv->bdrv_snapshot_list(bs, psn_info);
2163 if (bs->file)
2164 return bdrv_snapshot_list(bs->file, psn_info);
2165 return -ENOTSUP;
faea38e7
FB		 2166}
2167
51ef6727 2168int bdrv_snapshot_load_tmp(BlockDriverState *bs,
2169 const char *snapshot_name)
2170{
2171 BlockDriver *drv = bs->drv;
2172 if (!drv) {
2173 return -ENOMEDIUM;
2174 }
2175 if (!bs->read_only) {
2176 return -EINVAL;
2177 }
2178 if (drv->bdrv_snapshot_load_tmp) {
2179 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
2180 }
2181 return -ENOTSUP;
2182}
2183
faea38e7
FB		 2184#define NB_SUFFIXES 4
2185
2186char *get_human_readable_size(char *buf, int buf_size, int64_t size)
2187{
2188 static const char suffixes[NB_SUFFIXES] = "KMGT";
2189 int64_t base;
2190 int i;
2191
2192 if (size <= 999) {
2193 snprintf(buf, buf_size, "%" PRId64, size);
2194 } else {
2195 base = 1024;
2196 for(i = 0; i < NB_SUFFIXES; i++) {
2197 if (size < (10 * base)) {
5fafdf24 2198 snprintf(buf, buf_size, "%0.1f%c",
faea38e7
FB		 2199 (double)size / base,
2200 suffixes[i]);
2201 break;
2202 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
5fafdf24 2203 snprintf(buf, buf_size, "%" PRId64 "%c",
faea38e7
FB		 2204 ((size + (base >> 1)) / base),
2205 suffixes[i]);
2206 break;
2207 }
2208 base = base * 1024;
2209 }
2210 }
2211 return buf;
2212}
2213
2214char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
2215{
2216 char buf1[128], date_buf[128], clock_buf[128];
3b9f94e1
FB		 2217#ifdef _WIN32
2218 struct tm *ptm;
2219#else
faea38e7 2220 struct tm tm;
3b9f94e1 2221#endif
faea38e7
FB		 2222 time_t ti;
2223 int64_t secs;
2224
2225 if (!sn) {
5fafdf24
TS		 2226 snprintf(buf, buf_size,
2227 "%-10s%-20s%7s%20s%15s",
faea38e7
FB		 2228 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
2229 } else {
2230 ti = sn->date_sec;
3b9f94e1
FB		 2231#ifdef _WIN32
2232 ptm = localtime(&ti);
2233 strftime(date_buf, sizeof(date_buf),
2234 "%Y-%m-%d %H:%M:%S", ptm);
2235#else
faea38e7
FB		 2236 localtime_r(&ti, &tm);
2237 strftime(date_buf, sizeof(date_buf),
2238 "%Y-%m-%d %H:%M:%S", &tm);
3b9f94e1 2239#endif
faea38e7
FB		 2240 secs = sn->vm_clock_nsec / 1000000000;
2241 snprintf(clock_buf, sizeof(clock_buf),
2242 "%02d:%02d:%02d.%03d",
2243 (int)(secs / 3600),
2244 (int)((secs / 60) % 60),
5fafdf24 2245 (int)(secs % 60),
faea38e7
FB		 2246 (int)((sn->vm_clock_nsec / 1000000) % 1000));
2247 snprintf(buf, buf_size,
5fafdf24 2248 "%-10s%-20s%7s%20s%15s",
faea38e7
FB		 2249 sn->id_str, sn->name,
2250 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
2251 date_buf,
2252 clock_buf);
2253 }
2254 return buf;
2255}
2256
83f64091 2257
ea2384d3 2258/**************************************************************/
83f64091 2259/* async I/Os */
ea2384d3 2260
3b69e4b9 2261BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
f141eafe 2262 QEMUIOVector *qiov, int nb_sectors,
3b69e4b9 2263 BlockDriverCompletionFunc *cb, void *opaque)
83f64091
FB		 2264{
2265 BlockDriver *drv = bs->drv;
a36e69dd 2266 BlockDriverAIOCB *ret;
83f64091 2267
bbf0a440
SH		 2268 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
2269
19cb3738 2270 if (!drv)
ce1a14dc 2271 return NULL;
71d0770c
AL		 2272 if (bdrv_check_request(bs, sector_num, nb_sectors))
2273 return NULL;
3b46e624 2274
f141eafe
AL		 2275 ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
2276 cb, opaque);
a36e69dd
TS		 2277
2278 if (ret) {
d62b5dea
RW		 2279 /* Update stats even though technically transfer has not happened. */
2280 bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2281 bs->rd_ops++;
a36e69dd
TS		 2282 }
2283
2284 return ret;
ea2384d3
FB		 2285}
2286
4dcafbb1
MT		 2287typedef struct BlockCompleteData {
2288 BlockDriverCompletionFunc *cb;
2289 void *opaque;
2290 BlockDriverState *bs;
2291 int64_t sector_num;
2292 int nb_sectors;
2293} BlockCompleteData;
2294
2295static void block_complete_cb(void *opaque, int ret)
2296{
2297 BlockCompleteData *b = opaque;
2298
2299 if (b->bs->dirty_bitmap) {
2300 set_dirty_bitmap(b->bs, b->sector_num, b->nb_sectors, 1);
2301 }
2302 b->cb(b->opaque, ret);
7267c094 2303 g_free(b);
4dcafbb1
MT		 2304}
2305
2306static BlockCompleteData *blk_dirty_cb_alloc(BlockDriverState *bs,
2307 int64_t sector_num,
2308 int nb_sectors,
2309 BlockDriverCompletionFunc *cb,
2310 void *opaque)
2311{
7267c094 2312 BlockCompleteData *blkdata = g_malloc0(sizeof(BlockCompleteData));
4dcafbb1
MT		 2313
2314 blkdata->bs = bs;
2315 blkdata->cb = cb;
2316 blkdata->opaque = opaque;
2317 blkdata->sector_num = sector_num;
2318 blkdata->nb_sectors = nb_sectors;
2319
2320 return blkdata;
2321}
2322
f141eafe
AL		 2323BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2324 QEMUIOVector *qiov, int nb_sectors,
2325 BlockDriverCompletionFunc *cb, void *opaque)
ea2384d3 2326{
83f64091 2327 BlockDriver *drv = bs->drv;
a36e69dd 2328 BlockDriverAIOCB *ret;
4dcafbb1 2329 BlockCompleteData *blk_cb_data;
ea2384d3 2330
bbf0a440
SH		 2331 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
2332
19cb3738 2333 if (!drv)
ce1a14dc 2334 return NULL;
83f64091 2335 if (bs->read_only)
ce1a14dc 2336 return NULL;
71d0770c
AL		 2337 if (bdrv_check_request(bs, sector_num, nb_sectors))
2338 return NULL;
83f64091 2339
c6d22830 2340 if (bs->dirty_bitmap) {
4dcafbb1
MT		 2341 blk_cb_data = blk_dirty_cb_alloc(bs, sector_num, nb_sectors, cb,
2342 opaque);
2343 cb = &block_complete_cb;
2344 opaque = blk_cb_data;
7cd1e32a 2345 }
a55eb92c 2346
f141eafe
AL		 2347 ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
2348 cb, opaque);
a36e69dd
TS		 2349
2350 if (ret) {
294cc35f
KW		 2351 /* Update stats even though technically transfer has not happened. */
2352 bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2353 bs->wr_ops ++;
2354 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2355 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2356 }
a36e69dd
TS		 2357 }
2358
2359 return ret;
83f64091
FB		 2360}
2361
40b4f539
KW		 2362
2363typedef struct MultiwriteCB {
2364 int error;
2365 int num_requests;
2366 int num_callbacks;
2367 struct {
2368 BlockDriverCompletionFunc *cb;
2369 void *opaque;
2370 QEMUIOVector *free_qiov;
2371 void *free_buf;
2372 } callbacks[];
2373} MultiwriteCB;
2374
2375static void multiwrite_user_cb(MultiwriteCB *mcb)
2376{
2377 int i;
2378
2379 for (i = 0; i < mcb->num_callbacks; i++) {
2380 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
1e1ea48d
SH		 2381 if (mcb->callbacks[i].free_qiov) {
2382 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
2383 }
7267c094 2384 g_free(mcb->callbacks[i].free_qiov);
f8a83245 2385 qemu_vfree(mcb->callbacks[i].free_buf);
40b4f539
KW		 2386 }
2387}
2388
2389static void multiwrite_cb(void *opaque, int ret)
2390{
2391 MultiwriteCB *mcb = opaque;
2392
6d519a5f
SH		 2393 trace_multiwrite_cb(mcb, ret);
2394
cb6d3ca0 2395 if (ret < 0 && !mcb->error) {
40b4f539 2396 mcb->error = ret;
40b4f539
KW		 2397 }
2398
2399 mcb->num_requests--;
2400 if (mcb->num_requests == 0) {
de189a1b 2401 multiwrite_user_cb(mcb);
7267c094 2402 g_free(mcb);
40b4f539
KW		 2403 }
2404}
2405
2406static int multiwrite_req_compare(const void *a, const void *b)
2407{
77be4366
CH		 2408 const BlockRequest *req1 = a, *req2 = b;
2409
2410 /*
2411 * Note that we can't simply subtract req2->sector from req1->sector
2412 * here as that could overflow the return value.
2413 */
2414 if (req1->sector > req2->sector) {
2415 return 1;
2416 } else if (req1->sector < req2->sector) {
2417 return -1;
2418 } else {
2419 return 0;
2420 }
40b4f539
KW		 2421}
2422
2423/*
2424 * Takes a bunch of requests and tries to merge them. Returns the number of
2425 * requests that remain after merging.
2426 */
2427static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2428 int num_reqs, MultiwriteCB *mcb)
2429{
2430 int i, outidx;
2431
2432 // Sort requests by start sector
2433 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
2434
2435 // Check if adjacent requests touch the same clusters. If so, combine them,
2436 // filling up gaps with zero sectors.
2437 outidx = 0;
2438 for (i = 1; i < num_reqs; i++) {
2439 int merge = 0;
2440 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
2441
2442 // This handles the cases that are valid for all block drivers, namely
2443 // exactly sequential writes and overlapping writes.
2444 if (reqs[i].sector <= oldreq_last) {
2445 merge = 1;
2446 }
2447
2448 // The block driver may decide that it makes sense to combine requests
2449 // even if there is a gap of some sectors between them. In this case,
2450 // the gap is filled with zeros (therefore only applicable for yet
2451 // unused space in format like qcow2).
2452 if (!merge && bs->drv->bdrv_merge_requests) {
2453 merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2454 }
2455
e2a305fb
CH		 2456 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2457 merge = 0;
2458 }
2459
40b4f539
KW		 2460 if (merge) {
2461 size_t size;
7267c094 2462 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
40b4f539
KW		 2463 qemu_iovec_init(qiov,
2464 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2465
2466 // Add the first request to the merged one. If the requests are
2467 // overlapping, drop the last sectors of the first request.
2468 size = (reqs[i].sector - reqs[outidx].sector) << 9;
2469 qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2470
2471 // We might need to add some zeros between the two requests
2472 if (reqs[i].sector > oldreq_last) {
2473 size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
2474 uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2475 memset(buf, 0, zero_bytes);
2476 qemu_iovec_add(qiov, buf, zero_bytes);
2477 mcb->callbacks[i].free_buf = buf;
2478 }
2479
2480 // Add the second request
2481 qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
2482
cbf1dff2 2483 reqs[outidx].nb_sectors = qiov->size >> 9;
40b4f539
KW		 2484 reqs[outidx].qiov = qiov;
2485
2486 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2487 } else {
2488 outidx++;
2489 reqs[outidx].sector = reqs[i].sector;
2490 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2491 reqs[outidx].qiov = reqs[i].qiov;
2492 }
2493 }
2494
2495 return outidx + 1;
2496}
2497
2498/*
2499 * Submit multiple AIO write requests at once.
2500 *
2501 * On success, the function returns 0 and all requests in the reqs array have
2502 * been submitted. In error case this function returns -1, and any of the
2503 * requests may or may not be submitted yet. In particular, this means that the
2504 * callback will be called for some of the requests, for others it won't. The
2505 * caller must check the error field of the BlockRequest to wait for the right
2506 * callbacks (if error != 0, no callback will be called).
2507 *
2508 * The implementation may modify the contents of the reqs array, e.g. to merge
2509 * requests. However, the fields opaque and error are left unmodified as they
2510 * are used to signal failure for a single request to the caller.
2511 */
2512int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2513{
2514 BlockDriverAIOCB *acb;
2515 MultiwriteCB *mcb;
2516 int i;
2517
301db7c2
RH		 2518 /* don't submit writes if we don't have a medium */
2519 if (bs->drv == NULL) {
2520 for (i = 0; i < num_reqs; i++) {
2521 reqs[i].error = -ENOMEDIUM;
2522 }
2523 return -1;
2524 }
2525
40b4f539
KW		 2526 if (num_reqs == 0) {
2527 return 0;
2528 }
2529
2530 // Create MultiwriteCB structure
7267c094 2531 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
40b4f539
KW		 2532 mcb->num_requests = 0;
2533 mcb->num_callbacks = num_reqs;
2534
2535 for (i = 0; i < num_reqs; i++) {
2536 mcb->callbacks[i].cb = reqs[i].cb;
2537 mcb->callbacks[i].opaque = reqs[i].opaque;
2538 }
2539
2540 // Check for mergable requests
2541 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2542
6d519a5f
SH		 2543 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
2544
453f9a16
KW		 2545 /*
2546 * Run the aio requests. As soon as one request can't be submitted
2547 * successfully, fail all requests that are not yet submitted (we must
2548 * return failure for all requests anyway)
2549 *
2550 * num_requests cannot be set to the right value immediately: If
2551 * bdrv_aio_writev fails for some request, num_requests would be too high
2552 * and therefore multiwrite_cb() would never recognize the multiwrite
2553 * request as completed. We also cannot use the loop variable i to set it
2554 * when the first request fails because the callback may already have been
2555 * called for previously submitted requests. Thus, num_requests must be
2556 * incremented for each request that is submitted.
2557 *
2558 * The problem that callbacks may be called early also means that we need
2559 * to take care that num_requests doesn't become 0 before all requests are
2560 * submitted - multiwrite_cb() would consider the multiwrite request
2561 * completed. A dummy request that is "completed" by a manual call to
2562 * multiwrite_cb() takes care of this.
2563 */
2564 mcb->num_requests = 1;
2565
6d519a5f 2566 // Run the aio requests
40b4f539 2567 for (i = 0; i < num_reqs; i++) {
453f9a16 2568 mcb->num_requests++;
40b4f539
KW		 2569 acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2570 reqs[i].nb_sectors, multiwrite_cb, mcb);
2571
2572 if (acb == NULL) {
2573 // We can only fail the whole thing if no request has been
2574 // submitted yet. Otherwise we'll wait for the submitted AIOs to
2575 // complete and report the error in the callback.
453f9a16 2576 if (i == 0) {
6d519a5f 2577 trace_bdrv_aio_multiwrite_earlyfail(mcb);
40b4f539
KW		 2578 goto fail;
2579 } else {
6d519a5f 2580 trace_bdrv_aio_multiwrite_latefail(mcb, i);
7eb58a6c 2581 multiwrite_cb(mcb, -EIO);
40b4f539
KW		 2582 break;
2583 }
40b4f539
KW		 2584 }
2585 }
2586
453f9a16
KW		 2587 /* Complete the dummy request */
2588 multiwrite_cb(mcb, 0);
2589
40b4f539
KW		 2590 return 0;
2591
2592fail:
453f9a16
KW		 2593 for (i = 0; i < mcb->num_callbacks; i++) {
2594 reqs[i].error = -EIO;
2595 }
7267c094 2596 g_free(mcb);
40b4f539
KW		 2597 return -1;
2598}
2599
b2e12bc6
CH		 2600BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2601 BlockDriverCompletionFunc *cb, void *opaque)
2602{
2603 BlockDriver *drv = bs->drv;
2604
a13aac04
SH		 2605 trace_bdrv_aio_flush(bs, opaque);
2606
016f5cf6
AG		 2607 if (bs->open_flags & BDRV_O_NO_FLUSH) {
2608 return bdrv_aio_noop_em(bs, cb, opaque);
2609 }
2610
b2e12bc6
CH		 2611 if (!drv)
2612 return NULL;
b2e12bc6
CH		 2613 return drv->bdrv_aio_flush(bs, cb, opaque);
2614}
2615
83f64091 2616void bdrv_aio_cancel(BlockDriverAIOCB *acb)
83f64091 2617{
6bbff9a0 2618 acb->pool->cancel(acb);
83f64091
FB		 2619}
2620
ce1a14dc 2621
83f64091
FB		 2622/**************************************************************/
2623/* async block device emulation */
2624
c16b5a2c
CH		 2625typedef struct BlockDriverAIOCBSync {
2626 BlockDriverAIOCB common;
2627 QEMUBH *bh;
2628 int ret;
2629 /* vector translation state */
2630 QEMUIOVector *qiov;
2631 uint8_t *bounce;
2632 int is_write;
2633} BlockDriverAIOCBSync;
2634
2635static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
2636{
b666d239
KW		 2637 BlockDriverAIOCBSync *acb =
2638 container_of(blockacb, BlockDriverAIOCBSync, common);
6a7ad299 2639 qemu_bh_delete(acb->bh);
36afc451 2640 acb->bh = NULL;
c16b5a2c
CH		 2641 qemu_aio_release(acb);
2642}
2643
2644static AIOPool bdrv_em_aio_pool = {
2645 .aiocb_size = sizeof(BlockDriverAIOCBSync),
2646 .cancel = bdrv_aio_cancel_em,
2647};
2648
ce1a14dc 2649static void bdrv_aio_bh_cb(void *opaque)
83f64091 2650{
ce1a14dc 2651 BlockDriverAIOCBSync *acb = opaque;
f141eafe 2652
f141eafe
AL		 2653 if (!acb->is_write)
2654 qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
ceb42de8 2655 qemu_vfree(acb->bounce);
ce1a14dc 2656 acb->common.cb(acb->common.opaque, acb->ret);
6a7ad299 2657 qemu_bh_delete(acb->bh);
36afc451 2658 acb->bh = NULL;
ce1a14dc 2659 qemu_aio_release(acb);
83f64091 2660}
beac80cd 2661
f141eafe
AL		 2662static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2663 int64_t sector_num,
2664 QEMUIOVector *qiov,
2665 int nb_sectors,
2666 BlockDriverCompletionFunc *cb,
2667 void *opaque,
2668 int is_write)
2669
83f64091 2670{
ce1a14dc 2671 BlockDriverAIOCBSync *acb;
ce1a14dc 2672
c16b5a2c 2673 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
f141eafe
AL		 2674 acb->is_write = is_write;
2675 acb->qiov = qiov;
e268ca52 2676 acb->bounce = qemu_blockalign(bs, qiov->size);
f141eafe 2677
ce1a14dc
PB		 2678 if (!acb->bh)
2679 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
f141eafe
AL		 2680
2681 if (is_write) {
2682 qemu_iovec_to_buffer(acb->qiov, acb->bounce);
2683 acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2684 } else {
2685 acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2686 }
2687
ce1a14dc 2688 qemu_bh_schedule(acb->bh);
f141eafe 2689
ce1a14dc 2690 return &acb->common;
beac80cd
FB		 2691}
2692
f141eafe
AL		 2693static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2694 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
ce1a14dc 2695 BlockDriverCompletionFunc *cb, void *opaque)
beac80cd 2696{
f141eafe
AL		 2697 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2698}
83f64091 2699
f141eafe
AL		 2700static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2701 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2702 BlockDriverCompletionFunc *cb, void *opaque)
2703{
2704 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
beac80cd 2705}
beac80cd 2706
68485420
KW		 2707
2708typedef struct BlockDriverAIOCBCoroutine {
2709 BlockDriverAIOCB common;
2710 BlockRequest req;
2711 bool is_write;
2712 QEMUBH* bh;
2713} BlockDriverAIOCBCoroutine;
2714
2715static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
2716{
2717 qemu_aio_flush();
2718}
2719
2720static AIOPool bdrv_em_co_aio_pool = {
2721 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
2722 .cancel = bdrv_aio_co_cancel_em,
2723};
2724
2725static void bdrv_co_rw_bh(void *opaque)
2726{
2727 BlockDriverAIOCBCoroutine *acb = opaque;
2728
2729 acb->common.cb(acb->common.opaque, acb->req.error);
2730 qemu_bh_delete(acb->bh);
2731 qemu_aio_release(acb);
2732}
2733
2734static void coroutine_fn bdrv_co_rw(void *opaque)
2735{
2736 BlockDriverAIOCBCoroutine *acb = opaque;
2737 BlockDriverState *bs = acb->common.bs;
2738
2739 if (!acb->is_write) {
2740 acb->req.error = bs->drv->bdrv_co_readv(bs, acb->req.sector,
2741 acb->req.nb_sectors, acb->req.qiov);
2742 } else {
2743 acb->req.error = bs->drv->bdrv_co_writev(bs, acb->req.sector,
2744 acb->req.nb_sectors, acb->req.qiov);
2745 }
2746
2747 acb->bh = qemu_bh_new(bdrv_co_rw_bh, acb);
2748 qemu_bh_schedule(acb->bh);
2749}
2750
2751static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
2752 int64_t sector_num,
2753 QEMUIOVector *qiov,
2754 int nb_sectors,
2755 BlockDriverCompletionFunc *cb,
2756 void *opaque,
2757 bool is_write)
2758{
2759 Coroutine *co;
2760 BlockDriverAIOCBCoroutine *acb;
2761
2762 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
2763 acb->req.sector = sector_num;
2764 acb->req.nb_sectors = nb_sectors;
2765 acb->req.qiov = qiov;
2766 acb->is_write = is_write;
2767
2768 co = qemu_coroutine_create(bdrv_co_rw);
2769 qemu_coroutine_enter(co, acb);
2770
2771 return &acb->common;
2772}
2773
2774static BlockDriverAIOCB *bdrv_co_aio_readv_em(BlockDriverState *bs,
2775 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2776 BlockDriverCompletionFunc *cb, void *opaque)
2777{
2778 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque,
2779 false);
2780}
2781
2782static BlockDriverAIOCB *bdrv_co_aio_writev_em(BlockDriverState *bs,
2783 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2784 BlockDriverCompletionFunc *cb, void *opaque)
2785{
2786 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque,
2787 true);
2788}
2789
b2e12bc6
CH		 2790static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2791 BlockDriverCompletionFunc *cb, void *opaque)
2792{
2793 BlockDriverAIOCBSync *acb;
2794
2795 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2796 acb->is_write = 1; /* don't bounce in the completion hadler */
2797 acb->qiov = NULL;
2798 acb->bounce = NULL;
2799 acb->ret = 0;
2800
2801 if (!acb->bh)
2802 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2803
2804 bdrv_flush(bs);
2805 qemu_bh_schedule(acb->bh);
2806 return &acb->common;
2807}
2808
016f5cf6
AG		 2809static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2810 BlockDriverCompletionFunc *cb, void *opaque)
2811{
2812 BlockDriverAIOCBSync *acb;
2813
2814 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2815 acb->is_write = 1; /* don't bounce in the completion handler */
2816 acb->qiov = NULL;
2817 acb->bounce = NULL;
2818 acb->ret = 0;
2819
2820 if (!acb->bh) {
2821 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2822 }
2823
2824 qemu_bh_schedule(acb->bh);
2825 return &acb->common;
2826}
2827
83f64091
FB		 2828/**************************************************************/
2829/* sync block device emulation */
ea2384d3 2830
83f64091
FB		 2831static void bdrv_rw_em_cb(void *opaque, int ret)
2832{
2833 *(int *)opaque = ret;
ea2384d3
FB		 2834}
2835
83f64091
FB		 2836#define NOT_DONE 0x7fffffff
2837
5fafdf24 2838static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
83f64091 2839 uint8_t *buf, int nb_sectors)
7a6cba61 2840{
ce1a14dc
PB		 2841 int async_ret;
2842 BlockDriverAIOCB *acb;
f141eafe
AL		 2843 struct iovec iov;
2844 QEMUIOVector qiov;
83f64091 2845
83f64091 2846 async_ret = NOT_DONE;
3f4cb3d3 2847 iov.iov_base = (void *)buf;
eb5a3165 2848 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
f141eafe
AL		 2849 qemu_iovec_init_external(&qiov, &iov, 1);
2850 acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2851 bdrv_rw_em_cb, &async_ret);
65d6b3d8
KW		 2852 if (acb == NULL) {
2853 async_ret = -1;
2854 goto fail;
2855 }
baf35cb9 2856
83f64091
FB		 2857 while (async_ret == NOT_DONE) {
2858 qemu_aio_wait();
2859 }
baf35cb9 2860
65d6b3d8
KW		 2861
2862fail:
83f64091 2863 return async_ret;
7a6cba61
PB		 2864}
2865
83f64091
FB		 2866static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2867 const uint8_t *buf, int nb_sectors)
2868{
ce1a14dc
PB		 2869 int async_ret;
2870 BlockDriverAIOCB *acb;
f141eafe
AL		 2871 struct iovec iov;
2872 QEMUIOVector qiov;
83f64091 2873
83f64091 2874 async_ret = NOT_DONE;
f141eafe 2875 iov.iov_base = (void *)buf;
eb5a3165 2876 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
f141eafe
AL		 2877 qemu_iovec_init_external(&qiov, &iov, 1);
2878 acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2879 bdrv_rw_em_cb, &async_ret);
65d6b3d8
KW		 2880 if (acb == NULL) {
2881 async_ret = -1;
2882 goto fail;
2883 }
83f64091
FB		 2884 while (async_ret == NOT_DONE) {
2885 qemu_aio_wait();
2886 }
65d6b3d8
KW		 2887
2888fail:
83f64091
FB		 2889 return async_ret;
2890}
ea2384d3
FB		 2891
2892void bdrv_init(void)
2893{
5efa9d5a 2894 module_call_init(MODULE_INIT_BLOCK);
ea2384d3 2895}
ce1a14dc 2896
eb852011
MA		 2897void bdrv_init_with_whitelist(void)
2898{
2899 use_bdrv_whitelist = 1;
2900 bdrv_init();
2901}
2902
c16b5a2c
CH		 2903void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2904 BlockDriverCompletionFunc *cb, void *opaque)
ce1a14dc 2905{
ce1a14dc
PB		 2906 BlockDriverAIOCB *acb;
2907
6bbff9a0
AL		 2908 if (pool->free_aiocb) {
2909 acb = pool->free_aiocb;
2910 pool->free_aiocb = acb->next;
ce1a14dc 2911 } else {
7267c094 2912 acb = g_malloc0(pool->aiocb_size);
6bbff9a0 2913 acb->pool = pool;
ce1a14dc
PB		 2914 }
2915 acb->bs = bs;
2916 acb->cb = cb;
2917 acb->opaque = opaque;
2918 return acb;
2919}
2920
2921void qemu_aio_release(void *p)
2922{
6bbff9a0
AL		 2923 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
2924 AIOPool *pool = acb->pool;
2925 acb->next = pool->free_aiocb;
2926 pool->free_aiocb = acb;
ce1a14dc 2927}
19cb3738 2928
f9f05dc5
KW		 2929/**************************************************************/
2930/* Coroutine block device emulation */
2931
2932typedef struct CoroutineIOCompletion {
2933 Coroutine *coroutine;
2934 int ret;
2935} CoroutineIOCompletion;
2936
2937static void bdrv_co_io_em_complete(void *opaque, int ret)
2938{
2939 CoroutineIOCompletion *co = opaque;
2940
2941 co->ret = ret;
2942 qemu_coroutine_enter(co->coroutine, NULL);
2943}
2944
2945static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
2946 int nb_sectors, QEMUIOVector *iov,
2947 bool is_write)
2948{
2949 CoroutineIOCompletion co = {
2950 .coroutine = qemu_coroutine_self(),
2951 };
2952 BlockDriverAIOCB *acb;
2953
2954 if (is_write) {
2955 acb = bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
2956 bdrv_co_io_em_complete, &co);
2957 } else {
2958 acb = bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
2959 bdrv_co_io_em_complete, &co);
2960 }
2961
2962 trace_bdrv_co_io(is_write, acb);
2963 if (!acb) {
2964 return -EIO;
2965 }
2966 qemu_coroutine_yield();
2967
2968 return co.ret;
2969}
2970
2971static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
2972 int64_t sector_num, int nb_sectors,
2973 QEMUIOVector *iov)
2974{
2975 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
2976}
2977
2978static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
2979 int64_t sector_num, int nb_sectors,
2980 QEMUIOVector *iov)
2981{
2982 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
2983}
2984
e7a8a783
KW		 2985static int coroutine_fn bdrv_co_flush_em(BlockDriverState *bs)
2986{
2987 CoroutineIOCompletion co = {
2988 .coroutine = qemu_coroutine_self(),
2989 };
2990 BlockDriverAIOCB *acb;
2991
2992 acb = bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
2993 if (!acb) {
2994 return -EIO;
2995 }
2996 qemu_coroutine_yield();
2997 return co.ret;
2998}
2999
19cb3738
FB		 3000/**************************************************************/
3001/* removable device support */
3002
3003/**
3004 * Return TRUE if the media is present
3005 */
3006int bdrv_is_inserted(BlockDriverState *bs)
3007{
3008 BlockDriver *drv = bs->drv;
3009 int ret;
3010 if (!drv)
3011 return 0;
3012 if (!drv->bdrv_is_inserted)
4be9762a 3013 return !bs->tray_open;
19cb3738
FB		 3014 ret = drv->bdrv_is_inserted(bs);
3015 return ret;
3016}
3017
3018/**
3019 * Return TRUE if the media changed since the last call to this
5fafdf24 3020 * function. It is currently only used for floppy disks
19cb3738
FB		 3021 */
3022int bdrv_media_changed(BlockDriverState *bs)
3023{
3024 BlockDriver *drv = bs->drv;
3025 int ret;
3026
3027 if (!drv || !drv->bdrv_media_changed)
3028 ret = -ENOTSUP;
3029 else
3030 ret = drv->bdrv_media_changed(bs);
3031 if (ret == -ENOTSUP)
3032 ret = bs->media_changed;
3033 bs->media_changed = 0;
3034 return ret;
3035}
3036
3037/**
3038 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3039 */
aea2a33c 3040int bdrv_eject(BlockDriverState *bs, int eject_flag)
19cb3738
FB		 3041{
3042 BlockDriver *drv = bs->drv;
19cb3738 3043
49aa46bb 3044 if (eject_flag && bs->locked) {
aea2a33c
MM		 3045 return -EBUSY;
3046 }
3047
822e1cd1
MA		 3048 if (drv && drv->bdrv_eject) {
3049 drv->bdrv_eject(bs, eject_flag);
19cb3738 3050 }
822e1cd1
MA		 3051 bs->tray_open = eject_flag;
3052 return 0;
19cb3738
FB		 3053}
3054
3055int bdrv_is_locked(BlockDriverState *bs)
3056{
3057 return bs->locked;
3058}
3059
3060/**
3061 * Lock or unlock the media (if it is locked, the user won't be able
3062 * to eject it manually).
3063 */
3064void bdrv_set_locked(BlockDriverState *bs, int locked)
3065{
3066 BlockDriver *drv = bs->drv;
3067
b8c6d095
SH		 3068 trace_bdrv_set_locked(bs, locked);
3069
19cb3738
FB		 3070 bs->locked = locked;
3071 if (drv && drv->bdrv_set_locked) {
3072 drv->bdrv_set_locked(bs, locked);
3073 }
3074}
985a03b0
TS		 3075
3076/* needed for generic scsi interface */
3077
3078int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
3079{
3080 BlockDriver *drv = bs->drv;
3081
3082 if (drv && drv->bdrv_ioctl)
3083 return drv->bdrv_ioctl(bs, req, buf);
3084 return -ENOTSUP;
3085}
7d780669 3086
221f715d
AL		 3087BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
3088 unsigned long int req, void *buf,
3089 BlockDriverCompletionFunc *cb, void *opaque)
7d780669 3090{
221f715d 3091 BlockDriver *drv = bs->drv;
7d780669 3092
221f715d
AL		 3093 if (drv && drv->bdrv_aio_ioctl)
3094 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
3095 return NULL;
7d780669 3096}
e268ca52 3097
7cd1e32a 3098
3099
e268ca52
AL		 3100void *qemu_blockalign(BlockDriverState *bs, size_t size)
3101{
3102 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
3103}
7cd1e32a 3104
3105void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
3106{
3107 int64_t bitmap_size;
a55eb92c 3108
aaa0eb75 3109 bs->dirty_count = 0;
a55eb92c 3110 if (enable) {
c6d22830
JK		 3111 if (!bs->dirty_bitmap) {
3112 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
3113 BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
3114 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
a55eb92c 3115
7267c094 3116 bs->dirty_bitmap = g_malloc0(bitmap_size);
a55eb92c 3117 }
7cd1e32a 3118 } else {
c6d22830 3119 if (bs->dirty_bitmap) {
7267c094 3120 g_free(bs->dirty_bitmap);
c6d22830 3121 bs->dirty_bitmap = NULL;
a55eb92c 3122 }
7cd1e32a 3123 }
3124}
3125
3126int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
3127{
6ea44308 3128 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
a55eb92c 3129
c6d22830
JK		 3130 if (bs->dirty_bitmap &&
3131 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
6d59fec1
MT		 3132 return !!(bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
3133 (1UL << (chunk % (sizeof(unsigned long) * 8))));
7cd1e32a 3134 } else {
3135 return 0;
3136 }
3137}
3138
a55eb92c
JK		 3139void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
3140 int nr_sectors)
7cd1e32a 3141{
3142 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
3143}
aaa0eb75
LS		 3144
3145int64_t bdrv_get_dirty_count(BlockDriverState *bs)
3146{
3147 return bs->dirty_count;
3148}
f88e1a42 3149
db593f25
MT		 3150void bdrv_set_in_use(BlockDriverState *bs, int in_use)
3151{
3152 assert(bs->in_use != in_use);
3153 bs->in_use = in_use;
3154}
3155
3156int bdrv_in_use(BlockDriverState *bs)
3157{
3158 return bs->in_use;
3159}
3160
f88e1a42
JS		 3161int bdrv_img_create(const char *filename, const char *fmt,
3162 const char *base_filename, const char *base_fmt,
3163 char *options, uint64_t img_size, int flags)
3164{
3165 QEMUOptionParameter *param = NULL, *create_options = NULL;
d220894e 3166 QEMUOptionParameter *backing_fmt, *backing_file, *size;
f88e1a42
JS		 3167 BlockDriverState *bs = NULL;
3168 BlockDriver *drv, *proto_drv;
96df67d1 3169 BlockDriver *backing_drv = NULL;
f88e1a42
JS		 3170 int ret = 0;
3171
3172 /* Find driver and parse its options */
3173 drv = bdrv_find_format(fmt);
3174 if (!drv) {
3175 error_report("Unknown file format '%s'", fmt);
4f70f249 3176 ret = -EINVAL;
f88e1a42
JS		 3177 goto out;
3178 }
3179
3180 proto_drv = bdrv_find_protocol(filename);
3181 if (!proto_drv) {
3182 error_report("Unknown protocol '%s'", filename);
4f70f249 3183 ret = -EINVAL;
f88e1a42
JS		 3184 goto out;
3185 }
3186
3187 create_options = append_option_parameters(create_options,
3188 drv->create_options);
3189 create_options = append_option_parameters(create_options,
3190 proto_drv->create_options);
3191
3192 /* Create parameter list with default values */
3193 param = parse_option_parameters("", create_options, param);
3194
3195 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
3196
3197 /* Parse -o options */
3198 if (options) {
3199 param = parse_option_parameters(options, create_options, param);
3200 if (param == NULL) {
3201 error_report("Invalid options for file format '%s'.", fmt);
4f70f249 3202 ret = -EINVAL;
f88e1a42
JS		 3203 goto out;
3204 }
3205 }
3206
3207 if (base_filename) {
3208 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
3209 base_filename)) {
3210 error_report("Backing file not supported for file format '%s'",
3211 fmt);
4f70f249 3212 ret = -EINVAL;
f88e1a42
JS		 3213 goto out;
3214 }
3215 }
3216
3217 if (base_fmt) {
3218 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
3219 error_report("Backing file format not supported for file "
3220 "format '%s'", fmt);
4f70f249 3221 ret = -EINVAL;
f88e1a42
JS		 3222 goto out;
3223 }
3224 }
3225
792da93a
JS		 3226 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
3227 if (backing_file && backing_file->value.s) {
3228 if (!strcmp(filename, backing_file->value.s)) {
3229 error_report("Error: Trying to create an image with the "
3230 "same filename as the backing file");
4f70f249 3231 ret = -EINVAL;
792da93a
JS		 3232 goto out;
3233 }
3234 }
3235
f88e1a42
JS		 3236 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
3237 if (backing_fmt && backing_fmt->value.s) {
96df67d1
SH		 3238 backing_drv = bdrv_find_format(backing_fmt->value.s);
3239 if (!backing_drv) {
f88e1a42
JS		 3240 error_report("Unknown backing file format '%s'",
3241 backing_fmt->value.s);
4f70f249 3242 ret = -EINVAL;
f88e1a42
JS		 3243 goto out;
3244 }
3245 }
3246
3247 // The size for the image must always be specified, with one exception:
3248 // If we are using a backing file, we can obtain the size from there
d220894e
KW		 3249 size = get_option_parameter(param, BLOCK_OPT_SIZE);
3250 if (size && size->value.n == -1) {
f88e1a42
JS		 3251 if (backing_file && backing_file->value.s) {
3252 uint64_t size;
f88e1a42
JS		 3253 char buf[32];
3254
f88e1a42
JS		 3255 bs = bdrv_new("");
3256
96df67d1 3257 ret = bdrv_open(bs, backing_file->value.s, flags, backing_drv);
f88e1a42 3258 if (ret < 0) {
96df67d1 3259 error_report("Could not open '%s'", backing_file->value.s);
f88e1a42
JS		 3260 goto out;
3261 }
3262 bdrv_get_geometry(bs, &size);
3263 size *= 512;
3264
3265 snprintf(buf, sizeof(buf), "%" PRId64, size);
3266 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
3267 } else {
3268 error_report("Image creation needs a size parameter");
4f70f249 3269 ret = -EINVAL;
f88e1a42
JS		 3270 goto out;
3271 }
3272 }
3273
3274 printf("Formatting '%s', fmt=%s ", filename, fmt);
3275 print_option_parameters(param);
3276 puts("");
3277
3278 ret = bdrv_create(drv, filename, param);
3279
3280 if (ret < 0) {
3281 if (ret == -ENOTSUP) {
3282 error_report("Formatting or formatting option not supported for "
3283 "file format '%s'", fmt);
3284 } else if (ret == -EFBIG) {
3285 error_report("The image size is too large for file format '%s'",
3286 fmt);
3287 } else {
3288 error_report("%s: error while creating %s: %s", filename, fmt,
3289 strerror(-ret));
3290 }
3291 }
3292
3293out:
3294 free_option_parameters(create_options);
3295 free_option_parameters(param);
3296
3297 if (bs) {
3298 bdrv_delete(bs);
3299 }
4f70f249
JS		 3300
3301 return ret;
f88e1a42 3302}
Qemu copy for testing