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