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