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