]> git.proxmox.com Git - mirror_qemu.git/blame - block.c
qtest: Assure that init_socket()'s listen() does not fail
[mirror_qemu.git] / block.c
CommitLineData
fc01f7e7
FB
1/*
2 * QEMU System Emulator block driver
5fafdf24 3 *
fc01f7e7 4 * Copyright (c) 2003 Fabrice Bellard
5fafdf24 5 *
fc01f7e7
FB
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
3990d09a 24#include "config-host.h"
faf07963 25#include "qemu-common.h"
6d519a5f 26#include "trace.h"
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"
c13163fb 35#include "block/qapi.h"
b2023818 36#include "qmp-commands.h"
1de7afc9 37#include "qemu/timer.h"
fc01f7e7 38
71e72a19 39#ifdef CONFIG_BSD
7674e7bf
FB
40#include <sys/types.h>
41#include <sys/stat.h>
42#include <sys/ioctl.h>
72cf2d4f 43#include <sys/queue.h>
c5e97233 44#ifndef __DragonFly__
7674e7bf
FB
45#include <sys/disk.h>
46#endif
c5e97233 47#endif
7674e7bf 48
49dc768d
AL
49#ifdef _WIN32
50#include <windows.h>
51#endif
52
e4654d2d
FZ
53struct BdrvDirtyBitmap {
54 HBitmap *bitmap;
55 QLIST_ENTRY(BdrvDirtyBitmap) list;
56};
57
1c9805a3
SH
58#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
59
7d4b4ba5 60static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
f141eafe
AL
61static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
62 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
c87c0672 63 BlockDriverCompletionFunc *cb, void *opaque);
f141eafe
AL
64static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
65 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
ce1a14dc 66 BlockDriverCompletionFunc *cb, void *opaque);
f9f05dc5
KW
67static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
68 int64_t sector_num, int nb_sectors,
69 QEMUIOVector *iov);
70static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
71 int64_t sector_num, int nb_sectors,
72 QEMUIOVector *iov);
775aa8b6
KW
73static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
74 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
470c0504 75 BdrvRequestFlags flags);
775aa8b6
KW
76static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
77 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
f08f2dda 78 BdrvRequestFlags flags);
b2a61371
SH
79static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
80 int64_t sector_num,
81 QEMUIOVector *qiov,
82 int nb_sectors,
d20d9b7c 83 BdrvRequestFlags flags,
b2a61371
SH
84 BlockDriverCompletionFunc *cb,
85 void *opaque,
8c5873d6 86 bool is_write);
b2a61371 87static void coroutine_fn bdrv_co_do_rw(void *opaque);
621f0589 88static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
aa7bfbff 89 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
ec530c81 90
1b7bdbc1
SH
91static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
92 QTAILQ_HEAD_INITIALIZER(bdrv_states);
7ee930d0 93
dc364f4c
BC
94static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
95 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
96
8a22f02a
SH
97static QLIST_HEAD(, BlockDriver) bdrv_drivers =
98 QLIST_HEAD_INITIALIZER(bdrv_drivers);
ea2384d3 99
eb852011
MA
100/* If non-zero, use only whitelisted block drivers */
101static int use_bdrv_whitelist;
102
9e0b22f4
SH
103#ifdef _WIN32
104static int is_windows_drive_prefix(const char *filename)
105{
106 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
107 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
108 filename[1] == ':');
109}
110
111int is_windows_drive(const char *filename)
112{
113 if (is_windows_drive_prefix(filename) &&
114 filename[2] == '\0')
115 return 1;
116 if (strstart(filename, "\\\\.\\", NULL) ||
117 strstart(filename, "//./", NULL))
118 return 1;
119 return 0;
120}
121#endif
122
0563e191 123/* throttling disk I/O limits */
cc0681c4
BC
124void bdrv_set_io_limits(BlockDriverState *bs,
125 ThrottleConfig *cfg)
98f90dba 126{
cc0681c4 127 int i;
98f90dba 128
cc0681c4 129 throttle_config(&bs->throttle_state, cfg);
98f90dba 130
cc0681c4
BC
131 for (i = 0; i < 2; i++) {
132 qemu_co_enter_next(&bs->throttled_reqs[i]);
98f90dba 133 }
cc0681c4
BC
134}
135
136/* this function drain all the throttled IOs */
137static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
138{
139 bool drained = false;
140 bool enabled = bs->io_limits_enabled;
141 int i;
142
143 bs->io_limits_enabled = false;
144
145 for (i = 0; i < 2; i++) {
146 while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
147 drained = true;
148 }
149 }
150
151 bs->io_limits_enabled = enabled;
98f90dba 152
cc0681c4 153 return drained;
98f90dba
ZYW
154}
155
cc0681c4 156void bdrv_io_limits_disable(BlockDriverState *bs)
0563e191 157{
cc0681c4 158 bs->io_limits_enabled = false;
0563e191 159
cc0681c4
BC
160 bdrv_start_throttled_reqs(bs);
161
162 throttle_destroy(&bs->throttle_state);
0563e191
ZYW
163}
164
cc0681c4 165static void bdrv_throttle_read_timer_cb(void *opaque)
0563e191 166{
cc0681c4
BC
167 BlockDriverState *bs = opaque;
168 qemu_co_enter_next(&bs->throttled_reqs[0]);
0563e191
ZYW
169}
170
cc0681c4 171static void bdrv_throttle_write_timer_cb(void *opaque)
0563e191 172{
cc0681c4
BC
173 BlockDriverState *bs = opaque;
174 qemu_co_enter_next(&bs->throttled_reqs[1]);
0563e191
ZYW
175}
176
cc0681c4
BC
177/* should be called before bdrv_set_io_limits if a limit is set */
178void bdrv_io_limits_enable(BlockDriverState *bs)
179{
180 assert(!bs->io_limits_enabled);
181 throttle_init(&bs->throttle_state,
182 QEMU_CLOCK_VIRTUAL,
183 bdrv_throttle_read_timer_cb,
184 bdrv_throttle_write_timer_cb,
185 bs);
186 bs->io_limits_enabled = true;
187}
188
189/* This function makes an IO wait if needed
190 *
191 * @nb_sectors: the number of sectors of the IO
192 * @is_write: is the IO a write
193 */
98f90dba 194static void bdrv_io_limits_intercept(BlockDriverState *bs,
d5103588 195 unsigned int bytes,
cc0681c4 196 bool is_write)
98f90dba 197{
cc0681c4
BC
198 /* does this io must wait */
199 bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
98f90dba 200
cc0681c4
BC
201 /* if must wait or any request of this type throttled queue the IO */
202 if (must_wait ||
203 !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
204 qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
98f90dba
ZYW
205 }
206
cc0681c4 207 /* the IO will be executed, do the accounting */
d5103588
KW
208 throttle_account(&bs->throttle_state, is_write, bytes);
209
98f90dba 210
cc0681c4
BC
211 /* if the next request must wait -> do nothing */
212 if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
213 return;
98f90dba
ZYW
214 }
215
cc0681c4
BC
216 /* else queue next request for execution */
217 qemu_co_queue_next(&bs->throttled_reqs[is_write]);
98f90dba
ZYW
218}
219
339064d5
KW
220size_t bdrv_opt_mem_align(BlockDriverState *bs)
221{
222 if (!bs || !bs->drv) {
223 /* 4k should be on the safe side */
224 return 4096;
225 }
226
227 return bs->bl.opt_mem_alignment;
228}
229
9e0b22f4
SH
230/* check if the path starts with "<protocol>:" */
231static int path_has_protocol(const char *path)
232{
947995c0
PB
233 const char *p;
234
9e0b22f4
SH
235#ifdef _WIN32
236 if (is_windows_drive(path) ||
237 is_windows_drive_prefix(path)) {
238 return 0;
239 }
947995c0
PB
240 p = path + strcspn(path, ":/\\");
241#else
242 p = path + strcspn(path, ":/");
9e0b22f4
SH
243#endif
244
947995c0 245 return *p == ':';
9e0b22f4
SH
246}
247
83f64091 248int path_is_absolute(const char *path)
3b0d4f61 249{
21664424
FB
250#ifdef _WIN32
251 /* specific case for names like: "\\.\d:" */
f53f4da9 252 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
21664424 253 return 1;
f53f4da9
PB
254 }
255 return (*path == '/' || *path == '\\');
3b9f94e1 256#else
f53f4da9 257 return (*path == '/');
3b9f94e1 258#endif
3b0d4f61
FB
259}
260
83f64091
FB
261/* if filename is absolute, just copy it to dest. Otherwise, build a
262 path to it by considering it is relative to base_path. URL are
263 supported. */
264void path_combine(char *dest, int dest_size,
265 const char *base_path,
266 const char *filename)
3b0d4f61 267{
83f64091
FB
268 const char *p, *p1;
269 int len;
270
271 if (dest_size <= 0)
272 return;
273 if (path_is_absolute(filename)) {
274 pstrcpy(dest, dest_size, filename);
275 } else {
276 p = strchr(base_path, ':');
277 if (p)
278 p++;
279 else
280 p = base_path;
3b9f94e1
FB
281 p1 = strrchr(base_path, '/');
282#ifdef _WIN32
283 {
284 const char *p2;
285 p2 = strrchr(base_path, '\\');
286 if (!p1 || p2 > p1)
287 p1 = p2;
288 }
289#endif
83f64091
FB
290 if (p1)
291 p1++;
292 else
293 p1 = base_path;
294 if (p1 > p)
295 p = p1;
296 len = p - base_path;
297 if (len > dest_size - 1)
298 len = dest_size - 1;
299 memcpy(dest, base_path, len);
300 dest[len] = '\0';
301 pstrcat(dest, dest_size, filename);
3b0d4f61 302 }
3b0d4f61
FB
303}
304
dc5a1371
PB
305void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
306{
307 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
308 pstrcpy(dest, sz, bs->backing_file);
309 } else {
310 path_combine(dest, sz, bs->filename, bs->backing_file);
311 }
312}
313
5efa9d5a 314void bdrv_register(BlockDriver *bdrv)
ea2384d3 315{
8c5873d6
SH
316 /* Block drivers without coroutine functions need emulation */
317 if (!bdrv->bdrv_co_readv) {
f9f05dc5
KW
318 bdrv->bdrv_co_readv = bdrv_co_readv_em;
319 bdrv->bdrv_co_writev = bdrv_co_writev_em;
320
f8c35c1d
SH
321 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
322 * the block driver lacks aio we need to emulate that too.
323 */
f9f05dc5
KW
324 if (!bdrv->bdrv_aio_readv) {
325 /* add AIO emulation layer */
326 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
327 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
f9f05dc5 328 }
83f64091 329 }
b2e12bc6 330
8a22f02a 331 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
ea2384d3 332}
b338082b
FB
333
334/* create a new block device (by default it is empty) */
98522f63 335BlockDriverState *bdrv_new(const char *device_name, Error **errp)
b338082b 336{
1b7bdbc1 337 BlockDriverState *bs;
b338082b 338
f2d953ec
KW
339 if (bdrv_find(device_name)) {
340 error_setg(errp, "Device with id '%s' already exists",
341 device_name);
342 return NULL;
343 }
344 if (bdrv_find_node(device_name)) {
345 error_setg(errp, "Device with node-name '%s' already exists",
346 device_name);
347 return NULL;
348 }
349
7267c094 350 bs = g_malloc0(sizeof(BlockDriverState));
e4654d2d 351 QLIST_INIT(&bs->dirty_bitmaps);
b338082b 352 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
ea2384d3 353 if (device_name[0] != '\0') {
dc364f4c 354 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
ea2384d3 355 }
28a7282a 356 bdrv_iostatus_disable(bs);
d7d512f6 357 notifier_list_init(&bs->close_notifiers);
d616b224 358 notifier_with_return_list_init(&bs->before_write_notifiers);
cc0681c4
BC
359 qemu_co_queue_init(&bs->throttled_reqs[0]);
360 qemu_co_queue_init(&bs->throttled_reqs[1]);
9fcb0251 361 bs->refcnt = 1;
d7d512f6 362
b338082b
FB
363 return bs;
364}
365
d7d512f6
PB
366void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
367{
368 notifier_list_add(&bs->close_notifiers, notify);
369}
370
ea2384d3
FB
371BlockDriver *bdrv_find_format(const char *format_name)
372{
373 BlockDriver *drv1;
8a22f02a
SH
374 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
375 if (!strcmp(drv1->format_name, format_name)) {
ea2384d3 376 return drv1;
8a22f02a 377 }
ea2384d3
FB
378 }
379 return NULL;
380}
381
b64ec4e4 382static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
eb852011 383{
b64ec4e4
FZ
384 static const char *whitelist_rw[] = {
385 CONFIG_BDRV_RW_WHITELIST
386 };
387 static const char *whitelist_ro[] = {
388 CONFIG_BDRV_RO_WHITELIST
eb852011
MA
389 };
390 const char **p;
391
b64ec4e4 392 if (!whitelist_rw[0] && !whitelist_ro[0]) {
eb852011 393 return 1; /* no whitelist, anything goes */
b64ec4e4 394 }
eb852011 395
b64ec4e4 396 for (p = whitelist_rw; *p; p++) {
eb852011
MA
397 if (!strcmp(drv->format_name, *p)) {
398 return 1;
399 }
400 }
b64ec4e4
FZ
401 if (read_only) {
402 for (p = whitelist_ro; *p; p++) {
403 if (!strcmp(drv->format_name, *p)) {
404 return 1;
405 }
406 }
407 }
eb852011
MA
408 return 0;
409}
410
b64ec4e4
FZ
411BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
412 bool read_only)
eb852011
MA
413{
414 BlockDriver *drv = bdrv_find_format(format_name);
b64ec4e4 415 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
eb852011
MA
416}
417
5b7e1542
ZYW
418typedef struct CreateCo {
419 BlockDriver *drv;
420 char *filename;
421 QEMUOptionParameter *options;
422 int ret;
cc84d90f 423 Error *err;
5b7e1542
ZYW
424} CreateCo;
425
426static void coroutine_fn bdrv_create_co_entry(void *opaque)
427{
cc84d90f
HR
428 Error *local_err = NULL;
429 int ret;
430
5b7e1542
ZYW
431 CreateCo *cco = opaque;
432 assert(cco->drv);
433
cc84d90f 434 ret = cco->drv->bdrv_create(cco->filename, cco->options, &local_err);
84d18f06 435 if (local_err) {
cc84d90f
HR
436 error_propagate(&cco->err, local_err);
437 }
438 cco->ret = ret;
5b7e1542
ZYW
439}
440
0e7e1989 441int bdrv_create(BlockDriver *drv, const char* filename,
cc84d90f 442 QEMUOptionParameter *options, Error **errp)
ea2384d3 443{
5b7e1542
ZYW
444 int ret;
445
446 Coroutine *co;
447 CreateCo cco = {
448 .drv = drv,
449 .filename = g_strdup(filename),
450 .options = options,
451 .ret = NOT_DONE,
cc84d90f 452 .err = NULL,
5b7e1542
ZYW
453 };
454
455 if (!drv->bdrv_create) {
cc84d90f 456 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
80168bff
LC
457 ret = -ENOTSUP;
458 goto out;
5b7e1542
ZYW
459 }
460
461 if (qemu_in_coroutine()) {
462 /* Fast-path if already in coroutine context */
463 bdrv_create_co_entry(&cco);
464 } else {
465 co = qemu_coroutine_create(bdrv_create_co_entry);
466 qemu_coroutine_enter(co, &cco);
467 while (cco.ret == NOT_DONE) {
468 qemu_aio_wait();
469 }
470 }
471
472 ret = cco.ret;
cc84d90f 473 if (ret < 0) {
84d18f06 474 if (cco.err) {
cc84d90f
HR
475 error_propagate(errp, cco.err);
476 } else {
477 error_setg_errno(errp, -ret, "Could not create image");
478 }
479 }
0e7e1989 480
80168bff
LC
481out:
482 g_free(cco.filename);
5b7e1542 483 return ret;
ea2384d3
FB
484}
485
cc84d90f
HR
486int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
487 Error **errp)
84a12e66
CH
488{
489 BlockDriver *drv;
cc84d90f
HR
490 Error *local_err = NULL;
491 int ret;
84a12e66 492
98289620 493 drv = bdrv_find_protocol(filename, true);
84a12e66 494 if (drv == NULL) {
cc84d90f 495 error_setg(errp, "Could not find protocol for file '%s'", filename);
16905d71 496 return -ENOENT;
84a12e66
CH
497 }
498
cc84d90f 499 ret = bdrv_create(drv, filename, options, &local_err);
84d18f06 500 if (local_err) {
cc84d90f
HR
501 error_propagate(errp, local_err);
502 }
503 return ret;
84a12e66
CH
504}
505
355ef4ac 506int bdrv_refresh_limits(BlockDriverState *bs)
d34682cd
KW
507{
508 BlockDriver *drv = bs->drv;
509
510 memset(&bs->bl, 0, sizeof(bs->bl));
511
466ad822
KW
512 if (!drv) {
513 return 0;
514 }
515
516 /* Take some limits from the children as a default */
517 if (bs->file) {
518 bdrv_refresh_limits(bs->file);
519 bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
339064d5
KW
520 bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
521 } else {
522 bs->bl.opt_mem_alignment = 512;
466ad822
KW
523 }
524
525 if (bs->backing_hd) {
526 bdrv_refresh_limits(bs->backing_hd);
527 bs->bl.opt_transfer_length =
528 MAX(bs->bl.opt_transfer_length,
529 bs->backing_hd->bl.opt_transfer_length);
339064d5
KW
530 bs->bl.opt_mem_alignment =
531 MAX(bs->bl.opt_mem_alignment,
532 bs->backing_hd->bl.opt_mem_alignment);
466ad822
KW
533 }
534
535 /* Then let the driver override it */
536 if (drv->bdrv_refresh_limits) {
d34682cd
KW
537 return drv->bdrv_refresh_limits(bs);
538 }
539
540 return 0;
541}
542
eba25057
JM
543/*
544 * Create a uniquely-named empty temporary file.
545 * Return 0 upon success, otherwise a negative errno value.
546 */
547int get_tmp_filename(char *filename, int size)
d5249393 548{
eba25057 549#ifdef _WIN32
3b9f94e1 550 char temp_dir[MAX_PATH];
eba25057
JM
551 /* GetTempFileName requires that its output buffer (4th param)
552 have length MAX_PATH or greater. */
553 assert(size >= MAX_PATH);
554 return (GetTempPath(MAX_PATH, temp_dir)
555 && GetTempFileName(temp_dir, "qem", 0, filename)
556 ? 0 : -GetLastError());
d5249393 557#else
67b915a5 558 int fd;
7ccfb2eb 559 const char *tmpdir;
0badc1ee 560 tmpdir = getenv("TMPDIR");
69bef793
AS
561 if (!tmpdir) {
562 tmpdir = "/var/tmp";
563 }
eba25057
JM
564 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
565 return -EOVERFLOW;
566 }
ea2384d3 567 fd = mkstemp(filename);
fe235a06
DH
568 if (fd < 0) {
569 return -errno;
570 }
571 if (close(fd) != 0) {
572 unlink(filename);
eba25057
JM
573 return -errno;
574 }
575 return 0;
d5249393 576#endif
eba25057 577}
fc01f7e7 578
84a12e66
CH
579/*
580 * Detect host devices. By convention, /dev/cdrom[N] is always
581 * recognized as a host CDROM.
582 */
583static BlockDriver *find_hdev_driver(const char *filename)
584{
585 int score_max = 0, score;
586 BlockDriver *drv = NULL, *d;
587
588 QLIST_FOREACH(d, &bdrv_drivers, list) {
589 if (d->bdrv_probe_device) {
590 score = d->bdrv_probe_device(filename);
591 if (score > score_max) {
592 score_max = score;
593 drv = d;
594 }
595 }
596 }
597
598 return drv;
599}
600
98289620
KW
601BlockDriver *bdrv_find_protocol(const char *filename,
602 bool allow_protocol_prefix)
83f64091
FB
603{
604 BlockDriver *drv1;
605 char protocol[128];
1cec71e3 606 int len;
83f64091 607 const char *p;
19cb3738 608
66f82cee
KW
609 /* TODO Drivers without bdrv_file_open must be specified explicitly */
610
39508e7a
CH
611 /*
612 * XXX(hch): we really should not let host device detection
613 * override an explicit protocol specification, but moving this
614 * later breaks access to device names with colons in them.
615 * Thanks to the brain-dead persistent naming schemes on udev-
616 * based Linux systems those actually are quite common.
617 */
618 drv1 = find_hdev_driver(filename);
619 if (drv1) {
620 return drv1;
621 }
622
98289620 623 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
39508e7a 624 return bdrv_find_format("file");
84a12e66 625 }
98289620 626
9e0b22f4
SH
627 p = strchr(filename, ':');
628 assert(p != NULL);
1cec71e3
AL
629 len = p - filename;
630 if (len > sizeof(protocol) - 1)
631 len = sizeof(protocol) - 1;
632 memcpy(protocol, filename, len);
633 protocol[len] = '\0';
8a22f02a 634 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
5fafdf24 635 if (drv1->protocol_name &&
8a22f02a 636 !strcmp(drv1->protocol_name, protocol)) {
83f64091 637 return drv1;
8a22f02a 638 }
83f64091
FB
639 }
640 return NULL;
641}
642
f500a6d3 643static int find_image_format(BlockDriverState *bs, const char *filename,
34b5d2c6 644 BlockDriver **pdrv, Error **errp)
f3a5d3f8 645{
f500a6d3 646 int score, score_max;
f3a5d3f8
CH
647 BlockDriver *drv1, *drv;
648 uint8_t buf[2048];
f500a6d3 649 int ret = 0;
f8ea0b00 650
08a00559 651 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
8e895599 652 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
c98ac35d
SW
653 drv = bdrv_find_format("raw");
654 if (!drv) {
34b5d2c6 655 error_setg(errp, "Could not find raw image format");
c98ac35d
SW
656 ret = -ENOENT;
657 }
658 *pdrv = drv;
659 return ret;
1a396859 660 }
f8ea0b00 661
83f64091 662 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
83f64091 663 if (ret < 0) {
34b5d2c6
HR
664 error_setg_errno(errp, -ret, "Could not read image for determining its "
665 "format");
c98ac35d
SW
666 *pdrv = NULL;
667 return ret;
83f64091
FB
668 }
669
ea2384d3 670 score_max = 0;
84a12e66 671 drv = NULL;
8a22f02a 672 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
83f64091
FB
673 if (drv1->bdrv_probe) {
674 score = drv1->bdrv_probe(buf, ret, filename);
675 if (score > score_max) {
676 score_max = score;
677 drv = drv1;
678 }
0849bf08 679 }
fc01f7e7 680 }
c98ac35d 681 if (!drv) {
34b5d2c6
HR
682 error_setg(errp, "Could not determine image format: No compatible "
683 "driver found");
c98ac35d
SW
684 ret = -ENOENT;
685 }
686 *pdrv = drv;
687 return ret;
ea2384d3
FB
688}
689
51762288
SH
690/**
691 * Set the current 'total_sectors' value
692 */
693static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
694{
695 BlockDriver *drv = bs->drv;
696
396759ad
NB
697 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
698 if (bs->sg)
699 return 0;
700
51762288
SH
701 /* query actual device if possible, otherwise just trust the hint */
702 if (drv->bdrv_getlength) {
703 int64_t length = drv->bdrv_getlength(bs);
704 if (length < 0) {
705 return length;
706 }
7e382003 707 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
51762288
SH
708 }
709
710 bs->total_sectors = hint;
711 return 0;
712}
713
9e8f1835
PB
714/**
715 * Set open flags for a given discard mode
716 *
717 * Return 0 on success, -1 if the discard mode was invalid.
718 */
719int bdrv_parse_discard_flags(const char *mode, int *flags)
720{
721 *flags &= ~BDRV_O_UNMAP;
722
723 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
724 /* do nothing */
725 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
726 *flags |= BDRV_O_UNMAP;
727 } else {
728 return -1;
729 }
730
731 return 0;
732}
733
c3993cdc
SH
734/**
735 * Set open flags for a given cache mode
736 *
737 * Return 0 on success, -1 if the cache mode was invalid.
738 */
739int bdrv_parse_cache_flags(const char *mode, int *flags)
740{
741 *flags &= ~BDRV_O_CACHE_MASK;
742
743 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
744 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
92196b2f
SH
745 } else if (!strcmp(mode, "directsync")) {
746 *flags |= BDRV_O_NOCACHE;
c3993cdc
SH
747 } else if (!strcmp(mode, "writeback")) {
748 *flags |= BDRV_O_CACHE_WB;
749 } else if (!strcmp(mode, "unsafe")) {
750 *flags |= BDRV_O_CACHE_WB;
751 *flags |= BDRV_O_NO_FLUSH;
752 } else if (!strcmp(mode, "writethrough")) {
753 /* this is the default */
754 } else {
755 return -1;
756 }
757
758 return 0;
759}
760
53fec9d3
SH
761/**
762 * The copy-on-read flag is actually a reference count so multiple users may
763 * use the feature without worrying about clobbering its previous state.
764 * Copy-on-read stays enabled until all users have called to disable it.
765 */
766void bdrv_enable_copy_on_read(BlockDriverState *bs)
767{
768 bs->copy_on_read++;
769}
770
771void bdrv_disable_copy_on_read(BlockDriverState *bs)
772{
773 assert(bs->copy_on_read > 0);
774 bs->copy_on_read--;
775}
776
0b50cc88
KW
777/*
778 * Returns the flags that bs->file should get, based on the given flags for
779 * the parent BDS
780 */
781static int bdrv_inherited_flags(int flags)
782{
783 /* Enable protocol handling, disable format probing for bs->file */
784 flags |= BDRV_O_PROTOCOL;
785
786 /* Our block drivers take care to send flushes and respect unmap policy,
787 * so we can enable both unconditionally on lower layers. */
788 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
789
790 /* The backing file of a temporary snapshot is read-only */
791 if (flags & BDRV_O_SNAPSHOT) {
792 flags &= ~BDRV_O_RDWR;
793 }
794
795 /* Clear flags that only apply to the top layer */
5669b44d 796 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
0b50cc88
KW
797
798 return flags;
799}
800
317fc44e
KW
801/*
802 * Returns the flags that bs->backing_hd should get, based on the given flags
803 * for the parent BDS
804 */
805static int bdrv_backing_flags(int flags)
806{
807 /* backing files always opened read-only */
808 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
809
810 /* snapshot=on is handled on the top layer */
8bfea15d 811 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
317fc44e
KW
812
813 return flags;
814}
815
7b272452
KW
816static int bdrv_open_flags(BlockDriverState *bs, int flags)
817{
818 int open_flags = flags | BDRV_O_CACHE_WB;
819
b998875d
KW
820 /* The backing file of a temporary snapshot is read-only */
821 if (flags & BDRV_O_SNAPSHOT) {
822 open_flags &= ~BDRV_O_RDWR;
823 }
824
7b272452
KW
825 /*
826 * Clear flags that are internal to the block layer before opening the
827 * image.
828 */
829 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
830
831 /*
832 * Snapshots should be writable.
833 */
8bfea15d 834 if (flags & BDRV_O_TEMPORARY) {
7b272452
KW
835 open_flags |= BDRV_O_RDWR;
836 }
837
838 return open_flags;
839}
840
636ea370
KW
841static void bdrv_assign_node_name(BlockDriverState *bs,
842 const char *node_name,
843 Error **errp)
6913c0c2
BC
844{
845 if (!node_name) {
636ea370 846 return;
6913c0c2
BC
847 }
848
849 /* empty string node name is invalid */
850 if (node_name[0] == '\0') {
851 error_setg(errp, "Empty node name");
636ea370 852 return;
6913c0c2
BC
853 }
854
0c5e94ee
BC
855 /* takes care of avoiding namespaces collisions */
856 if (bdrv_find(node_name)) {
857 error_setg(errp, "node-name=%s is conflicting with a device id",
858 node_name);
636ea370 859 return;
0c5e94ee
BC
860 }
861
6913c0c2
BC
862 /* takes care of avoiding duplicates node names */
863 if (bdrv_find_node(node_name)) {
864 error_setg(errp, "Duplicate node name");
636ea370 865 return;
6913c0c2
BC
866 }
867
868 /* copy node name into the bs and insert it into the graph list */
869 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
870 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
6913c0c2
BC
871}
872
57915332
KW
873/*
874 * Common part for opening disk images and files
b6ad491a
KW
875 *
876 * Removes all processed options from *options.
57915332 877 */
f500a6d3 878static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
34b5d2c6 879 QDict *options, int flags, BlockDriver *drv, Error **errp)
57915332
KW
880{
881 int ret, open_flags;
035fccdf 882 const char *filename;
6913c0c2 883 const char *node_name = NULL;
34b5d2c6 884 Error *local_err = NULL;
57915332
KW
885
886 assert(drv != NULL);
6405875c 887 assert(bs->file == NULL);
707ff828 888 assert(options != NULL && bs->options != options);
57915332 889
45673671
KW
890 if (file != NULL) {
891 filename = file->filename;
892 } else {
893 filename = qdict_get_try_str(options, "filename");
894 }
895
765003db
KW
896 if (drv->bdrv_needs_filename && !filename) {
897 error_setg(errp, "The '%s' block driver requires a file name",
898 drv->format_name);
899 return -EINVAL;
900 }
901
45673671 902 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
28dcee10 903
6913c0c2 904 node_name = qdict_get_try_str(options, "node-name");
636ea370 905 bdrv_assign_node_name(bs, node_name, &local_err);
0fb6395c 906 if (local_err) {
636ea370
KW
907 error_propagate(errp, local_err);
908 return -EINVAL;
6913c0c2
BC
909 }
910 qdict_del(options, "node-name");
911
5d186eb0
KW
912 /* bdrv_open() with directly using a protocol as drv. This layer is already
913 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
914 * and return immediately. */
915 if (file != NULL && drv->bdrv_file_open) {
916 bdrv_swap(file, bs);
917 return 0;
918 }
919
57915332 920 bs->open_flags = flags;
1b7fd729 921 bs->guest_block_size = 512;
c25f53b0 922 bs->request_alignment = 512;
0d51b4de 923 bs->zero_beyond_eof = true;
b64ec4e4
FZ
924 open_flags = bdrv_open_flags(bs, flags);
925 bs->read_only = !(open_flags & BDRV_O_RDWR);
926
927 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
8f94a6e4
KW
928 error_setg(errp,
929 !bs->read_only && bdrv_is_whitelisted(drv, true)
930 ? "Driver '%s' can only be used for read-only devices"
931 : "Driver '%s' is not whitelisted",
932 drv->format_name);
b64ec4e4
FZ
933 return -ENOTSUP;
934 }
57915332 935
53fec9d3 936 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
0ebd24e0
KW
937 if (flags & BDRV_O_COPY_ON_READ) {
938 if (!bs->read_only) {
939 bdrv_enable_copy_on_read(bs);
940 } else {
941 error_setg(errp, "Can't use copy-on-read on read-only device");
942 return -EINVAL;
943 }
53fec9d3
SH
944 }
945
c2ad1b0c
KW
946 if (filename != NULL) {
947 pstrcpy(bs->filename, sizeof(bs->filename), filename);
948 } else {
949 bs->filename[0] = '\0';
950 }
57915332 951
57915332 952 bs->drv = drv;
7267c094 953 bs->opaque = g_malloc0(drv->instance_size);
57915332 954
03f541bd 955 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
e7c63796 956
66f82cee
KW
957 /* Open the image, either directly or using a protocol */
958 if (drv->bdrv_file_open) {
5d186eb0 959 assert(file == NULL);
030be321 960 assert(!drv->bdrv_needs_filename || filename != NULL);
34b5d2c6 961 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
f500a6d3 962 } else {
2af5ef70 963 if (file == NULL) {
34b5d2c6
HR
964 error_setg(errp, "Can't use '%s' as a block driver for the "
965 "protocol level", drv->format_name);
2af5ef70
KW
966 ret = -EINVAL;
967 goto free_and_fail;
968 }
f500a6d3 969 bs->file = file;
34b5d2c6 970 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
66f82cee
KW
971 }
972
57915332 973 if (ret < 0) {
84d18f06 974 if (local_err) {
34b5d2c6 975 error_propagate(errp, local_err);
2fa9aa59
DH
976 } else if (bs->filename[0]) {
977 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
34b5d2c6
HR
978 } else {
979 error_setg_errno(errp, -ret, "Could not open image");
980 }
57915332
KW
981 goto free_and_fail;
982 }
983
51762288
SH
984 ret = refresh_total_sectors(bs, bs->total_sectors);
985 if (ret < 0) {
34b5d2c6 986 error_setg_errno(errp, -ret, "Could not refresh total sector count");
51762288 987 goto free_and_fail;
57915332 988 }
51762288 989
d34682cd 990 bdrv_refresh_limits(bs);
c25f53b0 991 assert(bdrv_opt_mem_align(bs) != 0);
47ea2de2 992 assert((bs->request_alignment != 0) || bs->sg);
57915332
KW
993 return 0;
994
995free_and_fail:
f500a6d3 996 bs->file = NULL;
7267c094 997 g_free(bs->opaque);
57915332
KW
998 bs->opaque = NULL;
999 bs->drv = NULL;
1000 return ret;
1001}
1002
b6ce07aa
KW
1003/*
1004 * Opens a file using a protocol (file, host_device, nbd, ...)
787e4a85 1005 *
5acd9d81
HR
1006 * options is an indirect pointer to a QDict of options to pass to the block
1007 * drivers, or pointer to NULL for an empty set of options. If this function
1008 * takes ownership of the QDict reference, it will set *options to NULL;
1009 * otherwise, it will contain unused/unrecognized options after this function
1010 * returns. Then, the caller is responsible for freeing it. If it intends to
1011 * reuse the QDict, QINCREF() should be called beforehand.
b6ce07aa 1012 */
d4446eae 1013static int bdrv_file_open(BlockDriverState *bs, const char *filename,
5acd9d81 1014 QDict **options, int flags, Error **errp)
ea2384d3 1015{
6db95603 1016 BlockDriver *drv;
c2ad1b0c 1017 const char *drvname;
e3fa4bfa 1018 bool parse_filename = false;
34b5d2c6 1019 Error *local_err = NULL;
83f64091
FB
1020 int ret;
1021
035fccdf
KW
1022 /* Fetch the file name from the options QDict if necessary */
1023 if (!filename) {
5acd9d81
HR
1024 filename = qdict_get_try_str(*options, "filename");
1025 } else if (filename && !qdict_haskey(*options, "filename")) {
1026 qdict_put(*options, "filename", qstring_from_str(filename));
e3fa4bfa 1027 parse_filename = true;
035fccdf 1028 } else {
34b5d2c6
HR
1029 error_setg(errp, "Can't specify 'file' and 'filename' options at the "
1030 "same time");
035fccdf
KW
1031 ret = -EINVAL;
1032 goto fail;
1033 }
1034
c2ad1b0c 1035 /* Find the right block driver */
5acd9d81 1036 drvname = qdict_get_try_str(*options, "driver");
c2ad1b0c 1037 if (drvname) {
8f94a6e4 1038 drv = bdrv_find_format(drvname);
34b5d2c6
HR
1039 if (!drv) {
1040 error_setg(errp, "Unknown driver '%s'", drvname);
1041 }
5acd9d81 1042 qdict_del(*options, "driver");
c2ad1b0c 1043 } else if (filename) {
e3fa4bfa 1044 drv = bdrv_find_protocol(filename, parse_filename);
98289620 1045 if (!drv) {
34b5d2c6 1046 error_setg(errp, "Unknown protocol");
98289620 1047 }
c2ad1b0c 1048 } else {
34b5d2c6 1049 error_setg(errp, "Must specify either driver or file");
c2ad1b0c
KW
1050 drv = NULL;
1051 }
1052
1053 if (!drv) {
34b5d2c6 1054 /* errp has been set already */
c2ad1b0c
KW
1055 ret = -ENOENT;
1056 goto fail;
1057 }
1058
1059 /* Parse the filename and open it */
e3fa4bfa 1060 if (drv->bdrv_parse_filename && parse_filename) {
5acd9d81 1061 drv->bdrv_parse_filename(filename, *options, &local_err);
84d18f06 1062 if (local_err) {
34b5d2c6 1063 error_propagate(errp, local_err);
6963a30d
KW
1064 ret = -EINVAL;
1065 goto fail;
1066 }
cd5d031e
HR
1067
1068 if (!drv->bdrv_needs_filename) {
1069 qdict_del(*options, "filename");
1070 } else {
1071 filename = qdict_get_str(*options, "filename");
1072 }
6963a30d
KW
1073 }
1074
505d7583 1075 if (!drv->bdrv_file_open) {
5acd9d81
HR
1076 ret = bdrv_open(&bs, filename, NULL, *options, flags, drv, &local_err);
1077 *options = NULL;
505d7583 1078 } else {
5acd9d81 1079 ret = bdrv_open_common(bs, NULL, *options, flags, drv, &local_err);
505d7583 1080 }
83f64091 1081 if (ret < 0) {
34b5d2c6 1082 error_propagate(errp, local_err);
707ff828
KW
1083 goto fail;
1084 }
1085
71d0770c 1086 bs->growable = 1;
83f64091 1087 return 0;
707ff828
KW
1088
1089fail:
707ff828 1090 return ret;
83f64091
FB
1091}
1092
31ca6d07
KW
1093/*
1094 * Opens the backing file for a BlockDriverState if not yet open
1095 *
1096 * options is a QDict of options to pass to the block drivers, or NULL for an
1097 * empty set of options. The reference to the QDict is transferred to this
1098 * function (even on failure), so if the caller intends to reuse the dictionary,
1099 * it needs to use QINCREF() before calling bdrv_file_open.
1100 */
34b5d2c6 1101int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
9156df12 1102{
1ba4b6a5 1103 char *backing_filename = g_malloc0(PATH_MAX);
317fc44e 1104 int ret = 0;
9156df12 1105 BlockDriver *back_drv = NULL;
34b5d2c6 1106 Error *local_err = NULL;
9156df12
PB
1107
1108 if (bs->backing_hd != NULL) {
31ca6d07 1109 QDECREF(options);
1ba4b6a5 1110 goto free_exit;
9156df12
PB
1111 }
1112
31ca6d07
KW
1113 /* NULL means an empty set of options */
1114 if (options == NULL) {
1115 options = qdict_new();
1116 }
1117
9156df12 1118 bs->open_flags &= ~BDRV_O_NO_BACKING;
1cb6f506
KW
1119 if (qdict_haskey(options, "file.filename")) {
1120 backing_filename[0] = '\0';
1121 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
31ca6d07 1122 QDECREF(options);
1ba4b6a5 1123 goto free_exit;
dbecebdd 1124 } else {
1ba4b6a5 1125 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
9156df12
PB
1126 }
1127
9156df12
PB
1128 if (bs->backing_format[0] != '\0') {
1129 back_drv = bdrv_find_format(bs->backing_format);
1130 }
1131
f67503e5
HR
1132 assert(bs->backing_hd == NULL);
1133 ret = bdrv_open(&bs->backing_hd,
ddf5636d 1134 *backing_filename ? backing_filename : NULL, NULL, options,
317fc44e 1135 bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
9156df12 1136 if (ret < 0) {
9156df12
PB
1137 bs->backing_hd = NULL;
1138 bs->open_flags |= BDRV_O_NO_BACKING;
b04b6b6e
FZ
1139 error_setg(errp, "Could not open backing file: %s",
1140 error_get_pretty(local_err));
1141 error_free(local_err);
1ba4b6a5 1142 goto free_exit;
9156df12 1143 }
d80ac658
PF
1144
1145 if (bs->backing_hd->file) {
1146 pstrcpy(bs->backing_file, sizeof(bs->backing_file),
1147 bs->backing_hd->file->filename);
1148 }
1149
d34682cd
KW
1150 /* Recalculate the BlockLimits with the backing file */
1151 bdrv_refresh_limits(bs);
1152
1ba4b6a5
BC
1153free_exit:
1154 g_free(backing_filename);
1155 return ret;
9156df12
PB
1156}
1157
da557aac
HR
1158/*
1159 * Opens a disk image whose options are given as BlockdevRef in another block
1160 * device's options.
1161 *
da557aac
HR
1162 * If allow_none is true, no image will be opened if filename is false and no
1163 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1164 *
1165 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1166 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1167 * itself, all options starting with "${bdref_key}." are considered part of the
1168 * BlockdevRef.
1169 *
1170 * The BlockdevRef will be removed from the options QDict.
f67503e5
HR
1171 *
1172 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
da557aac
HR
1173 */
1174int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1175 QDict *options, const char *bdref_key, int flags,
f7d9fd8c 1176 bool allow_none, Error **errp)
da557aac
HR
1177{
1178 QDict *image_options;
1179 int ret;
1180 char *bdref_key_dot;
1181 const char *reference;
1182
f67503e5
HR
1183 assert(pbs);
1184 assert(*pbs == NULL);
1185
da557aac
HR
1186 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1187 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1188 g_free(bdref_key_dot);
1189
1190 reference = qdict_get_try_str(options, bdref_key);
1191 if (!filename && !reference && !qdict_size(image_options)) {
1192 if (allow_none) {
1193 ret = 0;
1194 } else {
1195 error_setg(errp, "A block device must be specified for \"%s\"",
1196 bdref_key);
1197 ret = -EINVAL;
1198 }
1199 goto done;
1200 }
1201
f7d9fd8c 1202 ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
da557aac
HR
1203
1204done:
1205 qdict_del(options, bdref_key);
1206 return ret;
1207}
1208
b998875d
KW
1209void bdrv_append_temp_snapshot(BlockDriverState *bs, Error **errp)
1210{
1211 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1ba4b6a5 1212 char *tmp_filename = g_malloc0(PATH_MAX + 1);
b998875d
KW
1213 int64_t total_size;
1214 BlockDriver *bdrv_qcow2;
1215 QEMUOptionParameter *create_options;
1216 QDict *snapshot_options;
1217 BlockDriverState *bs_snapshot;
1218 Error *local_err;
1219 int ret;
1220
1221 /* if snapshot, we create a temporary backing file and open it
1222 instead of opening 'filename' directly */
1223
1224 /* Get the required size from the image */
f187743a
KW
1225 total_size = bdrv_getlength(bs);
1226 if (total_size < 0) {
1227 error_setg_errno(errp, -total_size, "Could not get image size");
1ba4b6a5 1228 goto out;
f187743a
KW
1229 }
1230 total_size &= BDRV_SECTOR_MASK;
b998875d
KW
1231
1232 /* Create the temporary image */
1ba4b6a5 1233 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
b998875d
KW
1234 if (ret < 0) {
1235 error_setg_errno(errp, -ret, "Could not get temporary filename");
1ba4b6a5 1236 goto out;
b998875d
KW
1237 }
1238
1239 bdrv_qcow2 = bdrv_find_format("qcow2");
1240 create_options = parse_option_parameters("", bdrv_qcow2->create_options,
1241 NULL);
1242
1243 set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
1244
1245 ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);
1246 free_option_parameters(create_options);
1247 if (ret < 0) {
1248 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1249 "'%s': %s", tmp_filename,
1250 error_get_pretty(local_err));
1251 error_free(local_err);
1ba4b6a5 1252 goto out;
b998875d
KW
1253 }
1254
1255 /* Prepare a new options QDict for the temporary file */
1256 snapshot_options = qdict_new();
1257 qdict_put(snapshot_options, "file.driver",
1258 qstring_from_str("file"));
1259 qdict_put(snapshot_options, "file.filename",
1260 qstring_from_str(tmp_filename));
1261
98522f63 1262 bs_snapshot = bdrv_new("", &error_abort);
b998875d
KW
1263
1264 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
8bfea15d
KW
1265 (bs->open_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY,
1266 bdrv_qcow2, &local_err);
b998875d
KW
1267 if (ret < 0) {
1268 error_propagate(errp, local_err);
1ba4b6a5 1269 goto out;
b998875d
KW
1270 }
1271
1272 bdrv_append(bs_snapshot, bs);
1ba4b6a5
BC
1273
1274out:
1275 g_free(tmp_filename);
b998875d
KW
1276}
1277
b6ce07aa
KW
1278/*
1279 * Opens a disk image (raw, qcow2, vmdk, ...)
de9c0cec
KW
1280 *
1281 * options is a QDict of options to pass to the block drivers, or NULL for an
1282 * empty set of options. The reference to the QDict belongs to the block layer
1283 * after the call (even on failure), so if the caller intends to reuse the
1284 * dictionary, it needs to use QINCREF() before calling bdrv_open.
f67503e5
HR
1285 *
1286 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1287 * If it is not NULL, the referenced BDS will be reused.
ddf5636d
HR
1288 *
1289 * The reference parameter may be used to specify an existing block device which
1290 * should be opened. If specified, neither options nor a filename may be given,
1291 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
b6ce07aa 1292 */
ddf5636d
HR
1293int bdrv_open(BlockDriverState **pbs, const char *filename,
1294 const char *reference, QDict *options, int flags,
1295 BlockDriver *drv, Error **errp)
ea2384d3 1296{
b6ce07aa 1297 int ret;
f67503e5 1298 BlockDriverState *file = NULL, *bs;
74fe54f2 1299 const char *drvname;
34b5d2c6 1300 Error *local_err = NULL;
712e7874 1301
f67503e5
HR
1302 assert(pbs);
1303
ddf5636d
HR
1304 if (reference) {
1305 bool options_non_empty = options ? qdict_size(options) : false;
1306 QDECREF(options);
1307
1308 if (*pbs) {
1309 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1310 "another block device");
1311 return -EINVAL;
1312 }
1313
1314 if (filename || options_non_empty) {
1315 error_setg(errp, "Cannot reference an existing block device with "
1316 "additional options or a new filename");
1317 return -EINVAL;
1318 }
1319
1320 bs = bdrv_lookup_bs(reference, reference, errp);
1321 if (!bs) {
1322 return -ENODEV;
1323 }
1324 bdrv_ref(bs);
1325 *pbs = bs;
1326 return 0;
1327 }
1328
f67503e5
HR
1329 if (*pbs) {
1330 bs = *pbs;
1331 } else {
98522f63 1332 bs = bdrv_new("", &error_abort);
f67503e5
HR
1333 }
1334
de9c0cec
KW
1335 /* NULL means an empty set of options */
1336 if (options == NULL) {
1337 options = qdict_new();
1338 }
1339
1340 bs->options = options;
b6ad491a 1341 options = qdict_clone_shallow(options);
de9c0cec 1342
5469a2a6
HR
1343 if (flags & BDRV_O_PROTOCOL) {
1344 assert(!drv);
5acd9d81 1345 ret = bdrv_file_open(bs, filename, &options, flags & ~BDRV_O_PROTOCOL,
5469a2a6 1346 &local_err);
5469a2a6 1347 if (!ret) {
eb909c7f 1348 drv = bs->drv;
5acd9d81 1349 goto done;
5469a2a6
HR
1350 } else if (bs->drv) {
1351 goto close_and_fail;
1352 } else {
1353 goto fail;
1354 }
1355 }
1356
f500a6d3
KW
1357 /* Open image file without format layer */
1358 if (flags & BDRV_O_RDWR) {
1359 flags |= BDRV_O_ALLOW_RDWR;
1360 }
1361
f67503e5 1362 assert(file == NULL);
054963f8 1363 ret = bdrv_open_image(&file, filename, options, "file",
0b50cc88
KW
1364 bdrv_inherited_flags(flags),
1365 true, &local_err);
054963f8 1366 if (ret < 0) {
8bfea15d 1367 goto fail;
f500a6d3
KW
1368 }
1369
b6ce07aa 1370 /* Find the right image format driver */
74fe54f2
KW
1371 drvname = qdict_get_try_str(options, "driver");
1372 if (drvname) {
8f94a6e4 1373 drv = bdrv_find_format(drvname);
74fe54f2 1374 qdict_del(options, "driver");
06d22aa3
KW
1375 if (!drv) {
1376 error_setg(errp, "Invalid driver: '%s'", drvname);
1377 ret = -EINVAL;
8bfea15d 1378 goto fail;
06d22aa3 1379 }
74fe54f2
KW
1380 }
1381
6db95603 1382 if (!drv) {
2a05cbe4
HR
1383 if (file) {
1384 ret = find_image_format(file, filename, &drv, &local_err);
1385 } else {
1386 error_setg(errp, "Must specify either driver or file");
1387 ret = -EINVAL;
8bfea15d 1388 goto fail;
2a05cbe4 1389 }
51d7c00c 1390 }
6987307c 1391
51d7c00c 1392 if (!drv) {
8bfea15d 1393 goto fail;
ea2384d3 1394 }
b6ce07aa
KW
1395
1396 /* Open the image */
34b5d2c6 1397 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
b6ce07aa 1398 if (ret < 0) {
8bfea15d 1399 goto fail;
6987307c
CH
1400 }
1401
2a05cbe4 1402 if (file && (bs->file != file)) {
4f6fd349 1403 bdrv_unref(file);
f500a6d3
KW
1404 file = NULL;
1405 }
1406
b6ce07aa 1407 /* If there is a backing file, use it */
9156df12 1408 if ((flags & BDRV_O_NO_BACKING) == 0) {
31ca6d07
KW
1409 QDict *backing_options;
1410
5726d872 1411 qdict_extract_subqdict(options, &backing_options, "backing.");
34b5d2c6 1412 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
b6ce07aa 1413 if (ret < 0) {
b6ad491a 1414 goto close_and_fail;
b6ce07aa 1415 }
b6ce07aa
KW
1416 }
1417
b998875d
KW
1418 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1419 * temporary snapshot afterwards. */
1420 if (flags & BDRV_O_SNAPSHOT) {
1421 bdrv_append_temp_snapshot(bs, &local_err);
1422 if (local_err) {
1423 error_propagate(errp, local_err);
1424 goto close_and_fail;
1425 }
1426 }
1427
1428
5acd9d81 1429done:
b6ad491a 1430 /* Check if any unknown options were used */
5acd9d81 1431 if (options && (qdict_size(options) != 0)) {
b6ad491a 1432 const QDictEntry *entry = qdict_first(options);
5acd9d81
HR
1433 if (flags & BDRV_O_PROTOCOL) {
1434 error_setg(errp, "Block protocol '%s' doesn't support the option "
1435 "'%s'", drv->format_name, entry->key);
1436 } else {
1437 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1438 "support the option '%s'", drv->format_name,
1439 bs->device_name, entry->key);
1440 }
b6ad491a
KW
1441
1442 ret = -EINVAL;
1443 goto close_and_fail;
1444 }
b6ad491a 1445
b6ce07aa 1446 if (!bdrv_key_required(bs)) {
7d4b4ba5 1447 bdrv_dev_change_media_cb(bs, true);
c3adb58f
MA
1448 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1449 && !runstate_check(RUN_STATE_INMIGRATE)
1450 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1451 error_setg(errp,
1452 "Guest must be stopped for opening of encrypted image");
1453 ret = -EBUSY;
1454 goto close_and_fail;
b6ce07aa
KW
1455 }
1456
c3adb58f 1457 QDECREF(options);
f67503e5 1458 *pbs = bs;
b6ce07aa
KW
1459 return 0;
1460
8bfea15d 1461fail:
f500a6d3 1462 if (file != NULL) {
4f6fd349 1463 bdrv_unref(file);
f500a6d3 1464 }
de9c0cec 1465 QDECREF(bs->options);
b6ad491a 1466 QDECREF(options);
de9c0cec 1467 bs->options = NULL;
f67503e5
HR
1468 if (!*pbs) {
1469 /* If *pbs is NULL, a new BDS has been created in this function and
1470 needs to be freed now. Otherwise, it does not need to be closed,
1471 since it has not really been opened yet. */
1472 bdrv_unref(bs);
1473 }
84d18f06 1474 if (local_err) {
34b5d2c6
HR
1475 error_propagate(errp, local_err);
1476 }
b6ad491a 1477 return ret;
de9c0cec 1478
b6ad491a 1479close_and_fail:
f67503e5
HR
1480 /* See fail path, but now the BDS has to be always closed */
1481 if (*pbs) {
1482 bdrv_close(bs);
1483 } else {
1484 bdrv_unref(bs);
1485 }
b6ad491a 1486 QDECREF(options);
84d18f06 1487 if (local_err) {
34b5d2c6
HR
1488 error_propagate(errp, local_err);
1489 }
b6ce07aa
KW
1490 return ret;
1491}
1492
e971aa12
JC
1493typedef struct BlockReopenQueueEntry {
1494 bool prepared;
1495 BDRVReopenState state;
1496 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1497} BlockReopenQueueEntry;
1498
1499/*
1500 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1501 * reopen of multiple devices.
1502 *
1503 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1504 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1505 * be created and initialized. This newly created BlockReopenQueue should be
1506 * passed back in for subsequent calls that are intended to be of the same
1507 * atomic 'set'.
1508 *
1509 * bs is the BlockDriverState to add to the reopen queue.
1510 *
1511 * flags contains the open flags for the associated bs
1512 *
1513 * returns a pointer to bs_queue, which is either the newly allocated
1514 * bs_queue, or the existing bs_queue being used.
1515 *
1516 */
1517BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1518 BlockDriverState *bs, int flags)
1519{
1520 assert(bs != NULL);
1521
1522 BlockReopenQueueEntry *bs_entry;
1523 if (bs_queue == NULL) {
1524 bs_queue = g_new0(BlockReopenQueue, 1);
1525 QSIMPLEQ_INIT(bs_queue);
1526 }
1527
f1f25a2e
KW
1528 /* bdrv_open() masks this flag out */
1529 flags &= ~BDRV_O_PROTOCOL;
1530
e971aa12 1531 if (bs->file) {
f1f25a2e 1532 bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
e971aa12
JC
1533 }
1534
1535 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1536 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1537
1538 bs_entry->state.bs = bs;
1539 bs_entry->state.flags = flags;
1540
1541 return bs_queue;
1542}
1543
1544/*
1545 * Reopen multiple BlockDriverStates atomically & transactionally.
1546 *
1547 * The queue passed in (bs_queue) must have been built up previous
1548 * via bdrv_reopen_queue().
1549 *
1550 * Reopens all BDS specified in the queue, with the appropriate
1551 * flags. All devices are prepared for reopen, and failure of any
1552 * device will cause all device changes to be abandonded, and intermediate
1553 * data cleaned up.
1554 *
1555 * If all devices prepare successfully, then the changes are committed
1556 * to all devices.
1557 *
1558 */
1559int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1560{
1561 int ret = -1;
1562 BlockReopenQueueEntry *bs_entry, *next;
1563 Error *local_err = NULL;
1564
1565 assert(bs_queue != NULL);
1566
1567 bdrv_drain_all();
1568
1569 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1570 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1571 error_propagate(errp, local_err);
1572 goto cleanup;
1573 }
1574 bs_entry->prepared = true;
1575 }
1576
1577 /* If we reach this point, we have success and just need to apply the
1578 * changes
1579 */
1580 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1581 bdrv_reopen_commit(&bs_entry->state);
1582 }
1583
1584 ret = 0;
1585
1586cleanup:
1587 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1588 if (ret && bs_entry->prepared) {
1589 bdrv_reopen_abort(&bs_entry->state);
1590 }
1591 g_free(bs_entry);
1592 }
1593 g_free(bs_queue);
1594 return ret;
1595}
1596
1597
1598/* Reopen a single BlockDriverState with the specified flags. */
1599int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1600{
1601 int ret = -1;
1602 Error *local_err = NULL;
1603 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1604
1605 ret = bdrv_reopen_multiple(queue, &local_err);
1606 if (local_err != NULL) {
1607 error_propagate(errp, local_err);
1608 }
1609 return ret;
1610}
1611
1612
1613/*
1614 * Prepares a BlockDriverState for reopen. All changes are staged in the
1615 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1616 * the block driver layer .bdrv_reopen_prepare()
1617 *
1618 * bs is the BlockDriverState to reopen
1619 * flags are the new open flags
1620 * queue is the reopen queue
1621 *
1622 * Returns 0 on success, non-zero on error. On error errp will be set
1623 * as well.
1624 *
1625 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1626 * It is the responsibility of the caller to then call the abort() or
1627 * commit() for any other BDS that have been left in a prepare() state
1628 *
1629 */
1630int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1631 Error **errp)
1632{
1633 int ret = -1;
1634 Error *local_err = NULL;
1635 BlockDriver *drv;
1636
1637 assert(reopen_state != NULL);
1638 assert(reopen_state->bs->drv != NULL);
1639 drv = reopen_state->bs->drv;
1640
1641 /* if we are to stay read-only, do not allow permission change
1642 * to r/w */
1643 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1644 reopen_state->flags & BDRV_O_RDWR) {
1645 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1646 reopen_state->bs->device_name);
1647 goto error;
1648 }
1649
1650
1651 ret = bdrv_flush(reopen_state->bs);
1652 if (ret) {
1653 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1654 strerror(-ret));
1655 goto error;
1656 }
1657
1658 if (drv->bdrv_reopen_prepare) {
1659 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1660 if (ret) {
1661 if (local_err != NULL) {
1662 error_propagate(errp, local_err);
1663 } else {
d8b6895f
LC
1664 error_setg(errp, "failed while preparing to reopen image '%s'",
1665 reopen_state->bs->filename);
e971aa12
JC
1666 }
1667 goto error;
1668 }
1669 } else {
1670 /* It is currently mandatory to have a bdrv_reopen_prepare()
1671 * handler for each supported drv. */
1672 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1673 drv->format_name, reopen_state->bs->device_name,
1674 "reopening of file");
1675 ret = -1;
1676 goto error;
1677 }
1678
1679 ret = 0;
1680
1681error:
1682 return ret;
1683}
1684
1685/*
1686 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1687 * makes them final by swapping the staging BlockDriverState contents into
1688 * the active BlockDriverState contents.
1689 */
1690void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1691{
1692 BlockDriver *drv;
1693
1694 assert(reopen_state != NULL);
1695 drv = reopen_state->bs->drv;
1696 assert(drv != NULL);
1697
1698 /* If there are any driver level actions to take */
1699 if (drv->bdrv_reopen_commit) {
1700 drv->bdrv_reopen_commit(reopen_state);
1701 }
1702
1703 /* set BDS specific flags now */
1704 reopen_state->bs->open_flags = reopen_state->flags;
1705 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1706 BDRV_O_CACHE_WB);
1707 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
355ef4ac
KW
1708
1709 bdrv_refresh_limits(reopen_state->bs);
e971aa12
JC
1710}
1711
1712/*
1713 * Abort the reopen, and delete and free the staged changes in
1714 * reopen_state
1715 */
1716void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1717{
1718 BlockDriver *drv;
1719
1720 assert(reopen_state != NULL);
1721 drv = reopen_state->bs->drv;
1722 assert(drv != NULL);
1723
1724 if (drv->bdrv_reopen_abort) {
1725 drv->bdrv_reopen_abort(reopen_state);
1726 }
1727}
1728
1729
fc01f7e7
FB
1730void bdrv_close(BlockDriverState *bs)
1731{
3cbc002c
PB
1732 if (bs->job) {
1733 block_job_cancel_sync(bs->job);
1734 }
58fda173
SH
1735 bdrv_drain_all(); /* complete I/O */
1736 bdrv_flush(bs);
1737 bdrv_drain_all(); /* in case flush left pending I/O */
d7d512f6 1738 notifier_list_notify(&bs->close_notifiers, bs);
7094f12f 1739
3cbc002c 1740 if (bs->drv) {
557df6ac 1741 if (bs->backing_hd) {
4f6fd349 1742 bdrv_unref(bs->backing_hd);
557df6ac
SH
1743 bs->backing_hd = NULL;
1744 }
ea2384d3 1745 bs->drv->bdrv_close(bs);
7267c094 1746 g_free(bs->opaque);
ea2384d3
FB
1747 bs->opaque = NULL;
1748 bs->drv = NULL;
53fec9d3 1749 bs->copy_on_read = 0;
a275fa42
PB
1750 bs->backing_file[0] = '\0';
1751 bs->backing_format[0] = '\0';
6405875c
PB
1752 bs->total_sectors = 0;
1753 bs->encrypted = 0;
1754 bs->valid_key = 0;
1755 bs->sg = 0;
1756 bs->growable = 0;
0d51b4de 1757 bs->zero_beyond_eof = false;
de9c0cec
KW
1758 QDECREF(bs->options);
1759 bs->options = NULL;
b338082b 1760
66f82cee 1761 if (bs->file != NULL) {
4f6fd349 1762 bdrv_unref(bs->file);
0ac9377d 1763 bs->file = NULL;
66f82cee 1764 }
b338082b 1765 }
98f90dba 1766
9ca11154
PH
1767 bdrv_dev_change_media_cb(bs, false);
1768
98f90dba
ZYW
1769 /*throttling disk I/O limits*/
1770 if (bs->io_limits_enabled) {
1771 bdrv_io_limits_disable(bs);
1772 }
b338082b
FB
1773}
1774
2bc93fed
MK
1775void bdrv_close_all(void)
1776{
1777 BlockDriverState *bs;
1778
dc364f4c 1779 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2bc93fed
MK
1780 bdrv_close(bs);
1781 }
1782}
1783
88266f5a
SH
1784/* Check if any requests are in-flight (including throttled requests) */
1785static bool bdrv_requests_pending(BlockDriverState *bs)
1786{
1787 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1788 return true;
1789 }
cc0681c4
BC
1790 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1791 return true;
1792 }
1793 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
88266f5a
SH
1794 return true;
1795 }
1796 if (bs->file && bdrv_requests_pending(bs->file)) {
1797 return true;
1798 }
1799 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1800 return true;
1801 }
1802 return false;
1803}
1804
1805static bool bdrv_requests_pending_all(void)
1806{
1807 BlockDriverState *bs;
dc364f4c 1808 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
88266f5a
SH
1809 if (bdrv_requests_pending(bs)) {
1810 return true;
1811 }
1812 }
1813 return false;
1814}
1815
922453bc
SH
1816/*
1817 * Wait for pending requests to complete across all BlockDriverStates
1818 *
1819 * This function does not flush data to disk, use bdrv_flush_all() for that
1820 * after calling this function.
4c355d53
ZYW
1821 *
1822 * Note that completion of an asynchronous I/O operation can trigger any
1823 * number of other I/O operations on other devices---for example a coroutine
1824 * can be arbitrarily complex and a constant flow of I/O can come until the
1825 * coroutine is complete. Because of this, it is not possible to have a
1826 * function to drain a single device's I/O queue.
922453bc
SH
1827 */
1828void bdrv_drain_all(void)
1829{
88266f5a
SH
1830 /* Always run first iteration so any pending completion BHs run */
1831 bool busy = true;
922453bc
SH
1832 BlockDriverState *bs;
1833
88266f5a 1834 while (busy) {
dc364f4c 1835 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
0b06ef3b 1836 bdrv_start_throttled_reqs(bs);
4c355d53 1837 }
922453bc 1838
88266f5a
SH
1839 busy = bdrv_requests_pending_all();
1840 busy |= aio_poll(qemu_get_aio_context(), busy);
922453bc
SH
1841 }
1842}
1843
dc364f4c
BC
1844/* make a BlockDriverState anonymous by removing from bdrv_state and
1845 * graph_bdrv_state list.
d22b2f41
RH
1846 Also, NULL terminate the device_name to prevent double remove */
1847void bdrv_make_anon(BlockDriverState *bs)
1848{
1849 if (bs->device_name[0] != '\0') {
dc364f4c 1850 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
d22b2f41
RH
1851 }
1852 bs->device_name[0] = '\0';
dc364f4c
BC
1853 if (bs->node_name[0] != '\0') {
1854 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1855 }
1856 bs->node_name[0] = '\0';
d22b2f41
RH
1857}
1858
e023b2e2
PB
1859static void bdrv_rebind(BlockDriverState *bs)
1860{
1861 if (bs->drv && bs->drv->bdrv_rebind) {
1862 bs->drv->bdrv_rebind(bs);
1863 }
1864}
1865
4ddc07ca
PB
1866static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1867 BlockDriverState *bs_src)
8802d1fd 1868{
4ddc07ca 1869 /* move some fields that need to stay attached to the device */
8802d1fd
JC
1870
1871 /* dev info */
4ddc07ca
PB
1872 bs_dest->dev_ops = bs_src->dev_ops;
1873 bs_dest->dev_opaque = bs_src->dev_opaque;
1874 bs_dest->dev = bs_src->dev;
1b7fd729 1875 bs_dest->guest_block_size = bs_src->guest_block_size;
4ddc07ca 1876 bs_dest->copy_on_read = bs_src->copy_on_read;
8802d1fd 1877
4ddc07ca 1878 bs_dest->enable_write_cache = bs_src->enable_write_cache;
c4a248a1 1879
cc0681c4
BC
1880 /* i/o throttled req */
1881 memcpy(&bs_dest->throttle_state,
1882 &bs_src->throttle_state,
1883 sizeof(ThrottleState));
1884 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1885 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
4ddc07ca 1886 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
8802d1fd 1887
8802d1fd 1888 /* r/w error */
4ddc07ca
PB
1889 bs_dest->on_read_error = bs_src->on_read_error;
1890 bs_dest->on_write_error = bs_src->on_write_error;
8802d1fd
JC
1891
1892 /* i/o status */
4ddc07ca
PB
1893 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1894 bs_dest->iostatus = bs_src->iostatus;
8802d1fd 1895
a9fc4408 1896 /* dirty bitmap */
e4654d2d 1897 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
a9fc4408 1898
9fcb0251
FZ
1899 /* reference count */
1900 bs_dest->refcnt = bs_src->refcnt;
1901
a9fc4408 1902 /* job */
4ddc07ca
PB
1903 bs_dest->in_use = bs_src->in_use;
1904 bs_dest->job = bs_src->job;
a9fc4408 1905
8802d1fd 1906 /* keep the same entry in bdrv_states */
4ddc07ca
PB
1907 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1908 bs_src->device_name);
dc364f4c 1909 bs_dest->device_list = bs_src->device_list;
4ddc07ca 1910}
8802d1fd 1911
4ddc07ca
PB
1912/*
1913 * Swap bs contents for two image chains while they are live,
1914 * while keeping required fields on the BlockDriverState that is
1915 * actually attached to a device.
1916 *
1917 * This will modify the BlockDriverState fields, and swap contents
1918 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1919 *
1920 * bs_new is required to be anonymous.
1921 *
1922 * This function does not create any image files.
1923 */
1924void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
1925{
1926 BlockDriverState tmp;
f6801b83 1927
90ce8a06
BC
1928 /* The code needs to swap the node_name but simply swapping node_list won't
1929 * work so first remove the nodes from the graph list, do the swap then
1930 * insert them back if needed.
1931 */
1932 if (bs_new->node_name[0] != '\0') {
1933 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
1934 }
1935 if (bs_old->node_name[0] != '\0') {
1936 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
1937 }
1938
4ddc07ca
PB
1939 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1940 assert(bs_new->device_name[0] == '\0');
e4654d2d 1941 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
4ddc07ca
PB
1942 assert(bs_new->job == NULL);
1943 assert(bs_new->dev == NULL);
1944 assert(bs_new->in_use == 0);
1945 assert(bs_new->io_limits_enabled == false);
cc0681c4 1946 assert(!throttle_have_timer(&bs_new->throttle_state));
8802d1fd 1947
4ddc07ca
PB
1948 tmp = *bs_new;
1949 *bs_new = *bs_old;
1950 *bs_old = tmp;
a9fc4408 1951
4ddc07ca
PB
1952 /* there are some fields that should not be swapped, move them back */
1953 bdrv_move_feature_fields(&tmp, bs_old);
1954 bdrv_move_feature_fields(bs_old, bs_new);
1955 bdrv_move_feature_fields(bs_new, &tmp);
8802d1fd 1956
4ddc07ca
PB
1957 /* bs_new shouldn't be in bdrv_states even after the swap! */
1958 assert(bs_new->device_name[0] == '\0');
1959
1960 /* Check a few fields that should remain attached to the device */
1961 assert(bs_new->dev == NULL);
1962 assert(bs_new->job == NULL);
1963 assert(bs_new->in_use == 0);
1964 assert(bs_new->io_limits_enabled == false);
cc0681c4 1965 assert(!throttle_have_timer(&bs_new->throttle_state));
e023b2e2 1966
90ce8a06
BC
1967 /* insert the nodes back into the graph node list if needed */
1968 if (bs_new->node_name[0] != '\0') {
1969 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
1970 }
1971 if (bs_old->node_name[0] != '\0') {
1972 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
1973 }
1974
e023b2e2 1975 bdrv_rebind(bs_new);
4ddc07ca
PB
1976 bdrv_rebind(bs_old);
1977}
1978
1979/*
1980 * Add new bs contents at the top of an image chain while the chain is
1981 * live, while keeping required fields on the top layer.
1982 *
1983 * This will modify the BlockDriverState fields, and swap contents
1984 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1985 *
1986 * bs_new is required to be anonymous.
1987 *
1988 * This function does not create any image files.
1989 */
1990void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
1991{
1992 bdrv_swap(bs_new, bs_top);
1993
1994 /* The contents of 'tmp' will become bs_top, as we are
1995 * swapping bs_new and bs_top contents. */
1996 bs_top->backing_hd = bs_new;
1997 bs_top->open_flags &= ~BDRV_O_NO_BACKING;
1998 pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
1999 bs_new->filename);
2000 pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
2001 bs_new->drv ? bs_new->drv->format_name : "");
8802d1fd
JC
2002}
2003
4f6fd349 2004static void bdrv_delete(BlockDriverState *bs)
b338082b 2005{
fa879d62 2006 assert(!bs->dev);
3e914655
PB
2007 assert(!bs->job);
2008 assert(!bs->in_use);
4f6fd349 2009 assert(!bs->refcnt);
e4654d2d 2010 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
18846dee 2011
e1b5c52e
SH
2012 bdrv_close(bs);
2013
1b7bdbc1 2014 /* remove from list, if necessary */
d22b2f41 2015 bdrv_make_anon(bs);
34c6f050 2016
7267c094 2017 g_free(bs);
fc01f7e7
FB
2018}
2019
fa879d62
MA
2020int bdrv_attach_dev(BlockDriverState *bs, void *dev)
2021/* TODO change to DeviceState *dev when all users are qdevified */
18846dee 2022{
fa879d62 2023 if (bs->dev) {
18846dee
MA
2024 return -EBUSY;
2025 }
fa879d62 2026 bs->dev = dev;
28a7282a 2027 bdrv_iostatus_reset(bs);
18846dee
MA
2028 return 0;
2029}
2030
fa879d62
MA
2031/* TODO qdevified devices don't use this, remove when devices are qdevified */
2032void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
18846dee 2033{
fa879d62
MA
2034 if (bdrv_attach_dev(bs, dev) < 0) {
2035 abort();
2036 }
2037}
2038
2039void bdrv_detach_dev(BlockDriverState *bs, void *dev)
2040/* TODO change to DeviceState *dev when all users are qdevified */
2041{
2042 assert(bs->dev == dev);
2043 bs->dev = NULL;
0e49de52
MA
2044 bs->dev_ops = NULL;
2045 bs->dev_opaque = NULL;
1b7fd729 2046 bs->guest_block_size = 512;
18846dee
MA
2047}
2048
fa879d62
MA
2049/* TODO change to return DeviceState * when all users are qdevified */
2050void *bdrv_get_attached_dev(BlockDriverState *bs)
18846dee 2051{
fa879d62 2052 return bs->dev;
18846dee
MA
2053}
2054
0e49de52
MA
2055void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
2056 void *opaque)
2057{
2058 bs->dev_ops = ops;
2059 bs->dev_opaque = opaque;
2060}
2061
32c81a4a
PB
2062void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
2063 enum MonitorEvent ev,
2064 BlockErrorAction action, bool is_read)
329c0a48
LC
2065{
2066 QObject *data;
2067 const char *action_str;
2068
2069 switch (action) {
2070 case BDRV_ACTION_REPORT:
2071 action_str = "report";
2072 break;
2073 case BDRV_ACTION_IGNORE:
2074 action_str = "ignore";
2075 break;
2076 case BDRV_ACTION_STOP:
2077 action_str = "stop";
2078 break;
2079 default:
2080 abort();
2081 }
2082
2083 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
2084 bdrv->device_name,
2085 action_str,
2086 is_read ? "read" : "write");
32c81a4a 2087 monitor_protocol_event(ev, data);
329c0a48
LC
2088
2089 qobject_decref(data);
2090}
2091
6f382ed2
LC
2092static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
2093{
2094 QObject *data;
2095
2096 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
2097 bdrv_get_device_name(bs), ejected);
2098 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
2099
2100 qobject_decref(data);
2101}
2102
7d4b4ba5 2103static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
0e49de52 2104{
145feb17 2105 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
6f382ed2 2106 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
7d4b4ba5 2107 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
6f382ed2
LC
2108 if (tray_was_closed) {
2109 /* tray open */
2110 bdrv_emit_qmp_eject_event(bs, true);
2111 }
2112 if (load) {
2113 /* tray close */
2114 bdrv_emit_qmp_eject_event(bs, false);
2115 }
145feb17
MA
2116 }
2117}
2118
2c6942fa
MA
2119bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2120{
2121 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2122}
2123
025ccaa7
PB
2124void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2125{
2126 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2127 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2128 }
2129}
2130
e4def80b
MA
2131bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2132{
2133 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2134 return bs->dev_ops->is_tray_open(bs->dev_opaque);
2135 }
2136 return false;
2137}
2138
145feb17
MA
2139static void bdrv_dev_resize_cb(BlockDriverState *bs)
2140{
2141 if (bs->dev_ops && bs->dev_ops->resize_cb) {
2142 bs->dev_ops->resize_cb(bs->dev_opaque);
0e49de52
MA
2143 }
2144}
2145
f107639a
MA
2146bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2147{
2148 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2149 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2150 }
2151 return false;
2152}
2153
e97fc193
AL
2154/*
2155 * Run consistency checks on an image
2156 *
e076f338 2157 * Returns 0 if the check could be completed (it doesn't mean that the image is
a1c7273b 2158 * free of errors) or -errno when an internal error occurred. The results of the
e076f338 2159 * check are stored in res.
e97fc193 2160 */
4534ff54 2161int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
e97fc193
AL
2162{
2163 if (bs->drv->bdrv_check == NULL) {
2164 return -ENOTSUP;
2165 }
2166
e076f338 2167 memset(res, 0, sizeof(*res));
4534ff54 2168 return bs->drv->bdrv_check(bs, res, fix);
e97fc193
AL
2169}
2170
8a426614
KW
2171#define COMMIT_BUF_SECTORS 2048
2172
33e3963e
FB
2173/* commit COW file into the raw image */
2174int bdrv_commit(BlockDriverState *bs)
2175{
19cb3738 2176 BlockDriver *drv = bs->drv;
72706ea4 2177 int64_t sector, total_sectors, length, backing_length;
8a426614 2178 int n, ro, open_flags;
0bce597d 2179 int ret = 0;
72706ea4 2180 uint8_t *buf = NULL;
c2cba3d9 2181 char filename[PATH_MAX];
33e3963e 2182
19cb3738
FB
2183 if (!drv)
2184 return -ENOMEDIUM;
4dca4b63
NS
2185
2186 if (!bs->backing_hd) {
2187 return -ENOTSUP;
33e3963e
FB
2188 }
2189
2d3735d3
SH
2190 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
2191 return -EBUSY;
2192 }
2193
4dca4b63 2194 ro = bs->backing_hd->read_only;
c2cba3d9
JM
2195 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2196 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
4dca4b63
NS
2197 open_flags = bs->backing_hd->open_flags;
2198
2199 if (ro) {
0bce597d
JC
2200 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2201 return -EACCES;
4dca4b63 2202 }
ea2384d3 2203 }
33e3963e 2204
72706ea4
JC
2205 length = bdrv_getlength(bs);
2206 if (length < 0) {
2207 ret = length;
2208 goto ro_cleanup;
2209 }
2210
2211 backing_length = bdrv_getlength(bs->backing_hd);
2212 if (backing_length < 0) {
2213 ret = backing_length;
2214 goto ro_cleanup;
2215 }
2216
2217 /* If our top snapshot is larger than the backing file image,
2218 * grow the backing file image if possible. If not possible,
2219 * we must return an error */
2220 if (length > backing_length) {
2221 ret = bdrv_truncate(bs->backing_hd, length);
2222 if (ret < 0) {
2223 goto ro_cleanup;
2224 }
2225 }
2226
2227 total_sectors = length >> BDRV_SECTOR_BITS;
7267c094 2228 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
8a426614
KW
2229
2230 for (sector = 0; sector < total_sectors; sector += n) {
d663640c
PB
2231 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2232 if (ret < 0) {
2233 goto ro_cleanup;
2234 }
2235 if (ret) {
dabfa6cc
KW
2236 ret = bdrv_read(bs, sector, buf, n);
2237 if (ret < 0) {
8a426614
KW
2238 goto ro_cleanup;
2239 }
2240
dabfa6cc
KW
2241 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2242 if (ret < 0) {
8a426614
KW
2243 goto ro_cleanup;
2244 }
ea2384d3 2245 }
33e3963e 2246 }
95389c86 2247
1d44952f
CH
2248 if (drv->bdrv_make_empty) {
2249 ret = drv->bdrv_make_empty(bs);
dabfa6cc
KW
2250 if (ret < 0) {
2251 goto ro_cleanup;
2252 }
1d44952f
CH
2253 bdrv_flush(bs);
2254 }
95389c86 2255
3f5075ae
CH
2256 /*
2257 * Make sure all data we wrote to the backing device is actually
2258 * stable on disk.
2259 */
dabfa6cc 2260 if (bs->backing_hd) {
3f5075ae 2261 bdrv_flush(bs->backing_hd);
dabfa6cc 2262 }
4dca4b63 2263
dabfa6cc 2264 ret = 0;
4dca4b63 2265ro_cleanup:
7267c094 2266 g_free(buf);
4dca4b63
NS
2267
2268 if (ro) {
0bce597d
JC
2269 /* ignoring error return here */
2270 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
4dca4b63
NS
2271 }
2272
1d44952f 2273 return ret;
33e3963e
FB
2274}
2275
e8877497 2276int bdrv_commit_all(void)
6ab4b5ab
MA
2277{
2278 BlockDriverState *bs;
2279
dc364f4c 2280 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
272d2d8e
JC
2281 if (bs->drv && bs->backing_hd) {
2282 int ret = bdrv_commit(bs);
2283 if (ret < 0) {
2284 return ret;
2285 }
e8877497 2286 }
6ab4b5ab 2287 }
e8877497 2288 return 0;
6ab4b5ab
MA
2289}
2290
dbffbdcf
SH
2291/**
2292 * Remove an active request from the tracked requests list
2293 *
2294 * This function should be called when a tracked request is completing.
2295 */
2296static void tracked_request_end(BdrvTrackedRequest *req)
2297{
2dbafdc0
KW
2298 if (req->serialising) {
2299 req->bs->serialising_in_flight--;
2300 }
2301
dbffbdcf 2302 QLIST_REMOVE(req, list);
f4658285 2303 qemu_co_queue_restart_all(&req->wait_queue);
dbffbdcf
SH
2304}
2305
2306/**
2307 * Add an active request to the tracked requests list
2308 */
2309static void tracked_request_begin(BdrvTrackedRequest *req,
2310 BlockDriverState *bs,
793ed47a
KW
2311 int64_t offset,
2312 unsigned int bytes, bool is_write)
dbffbdcf
SH
2313{
2314 *req = (BdrvTrackedRequest){
2315 .bs = bs,
2dbafdc0
KW
2316 .offset = offset,
2317 .bytes = bytes,
2318 .is_write = is_write,
2319 .co = qemu_coroutine_self(),
2320 .serialising = false,
7327145f
KW
2321 .overlap_offset = offset,
2322 .overlap_bytes = bytes,
dbffbdcf
SH
2323 };
2324
f4658285
SH
2325 qemu_co_queue_init(&req->wait_queue);
2326
dbffbdcf
SH
2327 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2328}
2329
e96126ff 2330static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2dbafdc0 2331{
7327145f 2332 int64_t overlap_offset = req->offset & ~(align - 1);
e96126ff
KW
2333 unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2334 - overlap_offset;
7327145f 2335
2dbafdc0
KW
2336 if (!req->serialising) {
2337 req->bs->serialising_in_flight++;
2338 req->serialising = true;
2339 }
7327145f
KW
2340
2341 req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2342 req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2dbafdc0
KW
2343}
2344
d83947ac
SH
2345/**
2346 * Round a region to cluster boundaries
2347 */
343bded4
PB
2348void bdrv_round_to_clusters(BlockDriverState *bs,
2349 int64_t sector_num, int nb_sectors,
2350 int64_t *cluster_sector_num,
2351 int *cluster_nb_sectors)
d83947ac
SH
2352{
2353 BlockDriverInfo bdi;
2354
2355 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2356 *cluster_sector_num = sector_num;
2357 *cluster_nb_sectors = nb_sectors;
2358 } else {
2359 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2360 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2361 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2362 nb_sectors, c);
2363 }
2364}
2365
7327145f 2366static int bdrv_get_cluster_size(BlockDriverState *bs)
793ed47a
KW
2367{
2368 BlockDriverInfo bdi;
7327145f 2369 int ret;
793ed47a 2370
7327145f
KW
2371 ret = bdrv_get_info(bs, &bdi);
2372 if (ret < 0 || bdi.cluster_size == 0) {
2373 return bs->request_alignment;
793ed47a 2374 } else {
7327145f 2375 return bdi.cluster_size;
793ed47a
KW
2376 }
2377}
2378
f4658285 2379static bool tracked_request_overlaps(BdrvTrackedRequest *req,
793ed47a
KW
2380 int64_t offset, unsigned int bytes)
2381{
d83947ac 2382 /* aaaa bbbb */
7327145f 2383 if (offset >= req->overlap_offset + req->overlap_bytes) {
d83947ac
SH
2384 return false;
2385 }
2386 /* bbbb aaaa */
7327145f 2387 if (req->overlap_offset >= offset + bytes) {
d83947ac
SH
2388 return false;
2389 }
2390 return true;
f4658285
SH
2391}
2392
28de2dcd 2393static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
f4658285 2394{
2dbafdc0 2395 BlockDriverState *bs = self->bs;
f4658285
SH
2396 BdrvTrackedRequest *req;
2397 bool retry;
28de2dcd 2398 bool waited = false;
f4658285 2399
2dbafdc0 2400 if (!bs->serialising_in_flight) {
28de2dcd 2401 return false;
2dbafdc0
KW
2402 }
2403
f4658285
SH
2404 do {
2405 retry = false;
2406 QLIST_FOREACH(req, &bs->tracked_requests, list) {
2dbafdc0 2407 if (req == self || (!req->serialising && !self->serialising)) {
65afd211
KW
2408 continue;
2409 }
7327145f
KW
2410 if (tracked_request_overlaps(req, self->overlap_offset,
2411 self->overlap_bytes))
2412 {
5f8b6491
SH
2413 /* Hitting this means there was a reentrant request, for
2414 * example, a block driver issuing nested requests. This must
2415 * never happen since it means deadlock.
2416 */
2417 assert(qemu_coroutine_self() != req->co);
2418
6460440f
KW
2419 /* If the request is already (indirectly) waiting for us, or
2420 * will wait for us as soon as it wakes up, then just go on
2421 * (instead of producing a deadlock in the former case). */
2422 if (!req->waiting_for) {
2423 self->waiting_for = req;
2424 qemu_co_queue_wait(&req->wait_queue);
2425 self->waiting_for = NULL;
2426 retry = true;
28de2dcd 2427 waited = true;
6460440f
KW
2428 break;
2429 }
f4658285
SH
2430 }
2431 }
2432 } while (retry);
28de2dcd
KW
2433
2434 return waited;
f4658285
SH
2435}
2436
756e6736
KW
2437/*
2438 * Return values:
2439 * 0 - success
2440 * -EINVAL - backing format specified, but no file
2441 * -ENOSPC - can't update the backing file because no space is left in the
2442 * image file header
2443 * -ENOTSUP - format driver doesn't support changing the backing file
2444 */
2445int bdrv_change_backing_file(BlockDriverState *bs,
2446 const char *backing_file, const char *backing_fmt)
2447{
2448 BlockDriver *drv = bs->drv;
469ef350 2449 int ret;
756e6736 2450
5f377794
PB
2451 /* Backing file format doesn't make sense without a backing file */
2452 if (backing_fmt && !backing_file) {
2453 return -EINVAL;
2454 }
2455
756e6736 2456 if (drv->bdrv_change_backing_file != NULL) {
469ef350 2457 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
756e6736 2458 } else {
469ef350 2459 ret = -ENOTSUP;
756e6736 2460 }
469ef350
PB
2461
2462 if (ret == 0) {
2463 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2464 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2465 }
2466 return ret;
756e6736
KW
2467}
2468
6ebdcee2
JC
2469/*
2470 * Finds the image layer in the chain that has 'bs' as its backing file.
2471 *
2472 * active is the current topmost image.
2473 *
2474 * Returns NULL if bs is not found in active's image chain,
2475 * or if active == bs.
2476 */
2477BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2478 BlockDriverState *bs)
2479{
2480 BlockDriverState *overlay = NULL;
2481 BlockDriverState *intermediate;
2482
2483 assert(active != NULL);
2484 assert(bs != NULL);
2485
2486 /* if bs is the same as active, then by definition it has no overlay
2487 */
2488 if (active == bs) {
2489 return NULL;
2490 }
2491
2492 intermediate = active;
2493 while (intermediate->backing_hd) {
2494 if (intermediate->backing_hd == bs) {
2495 overlay = intermediate;
2496 break;
2497 }
2498 intermediate = intermediate->backing_hd;
2499 }
2500
2501 return overlay;
2502}
2503
2504typedef struct BlkIntermediateStates {
2505 BlockDriverState *bs;
2506 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2507} BlkIntermediateStates;
2508
2509
2510/*
2511 * Drops images above 'base' up to and including 'top', and sets the image
2512 * above 'top' to have base as its backing file.
2513 *
2514 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2515 * information in 'bs' can be properly updated.
2516 *
2517 * E.g., this will convert the following chain:
2518 * bottom <- base <- intermediate <- top <- active
2519 *
2520 * to
2521 *
2522 * bottom <- base <- active
2523 *
2524 * It is allowed for bottom==base, in which case it converts:
2525 *
2526 * base <- intermediate <- top <- active
2527 *
2528 * to
2529 *
2530 * base <- active
2531 *
2532 * Error conditions:
2533 * if active == top, that is considered an error
2534 *
2535 */
2536int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2537 BlockDriverState *base)
2538{
2539 BlockDriverState *intermediate;
2540 BlockDriverState *base_bs = NULL;
2541 BlockDriverState *new_top_bs = NULL;
2542 BlkIntermediateStates *intermediate_state, *next;
2543 int ret = -EIO;
2544
2545 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2546 QSIMPLEQ_INIT(&states_to_delete);
2547
2548 if (!top->drv || !base->drv) {
2549 goto exit;
2550 }
2551
2552 new_top_bs = bdrv_find_overlay(active, top);
2553
2554 if (new_top_bs == NULL) {
2555 /* we could not find the image above 'top', this is an error */
2556 goto exit;
2557 }
2558
2559 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2560 * to do, no intermediate images */
2561 if (new_top_bs->backing_hd == base) {
2562 ret = 0;
2563 goto exit;
2564 }
2565
2566 intermediate = top;
2567
2568 /* now we will go down through the list, and add each BDS we find
2569 * into our deletion queue, until we hit the 'base'
2570 */
2571 while (intermediate) {
2572 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2573 intermediate_state->bs = intermediate;
2574 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2575
2576 if (intermediate->backing_hd == base) {
2577 base_bs = intermediate->backing_hd;
2578 break;
2579 }
2580 intermediate = intermediate->backing_hd;
2581 }
2582 if (base_bs == NULL) {
2583 /* something went wrong, we did not end at the base. safely
2584 * unravel everything, and exit with error */
2585 goto exit;
2586 }
2587
2588 /* success - we can delete the intermediate states, and link top->base */
2589 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2590 base_bs->drv ? base_bs->drv->format_name : "");
2591 if (ret) {
2592 goto exit;
2593 }
2594 new_top_bs->backing_hd = base_bs;
2595
355ef4ac 2596 bdrv_refresh_limits(new_top_bs);
6ebdcee2
JC
2597
2598 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2599 /* so that bdrv_close() does not recursively close the chain */
2600 intermediate_state->bs->backing_hd = NULL;
4f6fd349 2601 bdrv_unref(intermediate_state->bs);
6ebdcee2
JC
2602 }
2603 ret = 0;
2604
2605exit:
2606 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2607 g_free(intermediate_state);
2608 }
2609 return ret;
2610}
2611
2612
71d0770c
AL
2613static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2614 size_t size)
2615{
2616 int64_t len;
2617
1dd3a447
KW
2618 if (size > INT_MAX) {
2619 return -EIO;
2620 }
2621
71d0770c
AL
2622 if (!bdrv_is_inserted(bs))
2623 return -ENOMEDIUM;
2624
2625 if (bs->growable)
2626 return 0;
2627
2628 len = bdrv_getlength(bs);
2629
fbb7b4e0
KW
2630 if (offset < 0)
2631 return -EIO;
2632
2633 if ((offset > len) || (len - offset < size))
71d0770c
AL
2634 return -EIO;
2635
2636 return 0;
2637}
2638
2639static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2640 int nb_sectors)
2641{
54db38a4 2642 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
8f4754ed
KW
2643 return -EIO;
2644 }
2645
eb5a3165
JS
2646 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2647 nb_sectors * BDRV_SECTOR_SIZE);
71d0770c
AL
2648}
2649
1c9805a3
SH
2650typedef struct RwCo {
2651 BlockDriverState *bs;
775aa8b6 2652 int64_t offset;
1c9805a3
SH
2653 QEMUIOVector *qiov;
2654 bool is_write;
2655 int ret;
4105eaaa 2656 BdrvRequestFlags flags;
1c9805a3
SH
2657} RwCo;
2658
2659static void coroutine_fn bdrv_rw_co_entry(void *opaque)
fc01f7e7 2660{
1c9805a3 2661 RwCo *rwco = opaque;
ea2384d3 2662
1c9805a3 2663 if (!rwco->is_write) {
775aa8b6
KW
2664 rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2665 rwco->qiov->size, rwco->qiov,
4105eaaa 2666 rwco->flags);
775aa8b6
KW
2667 } else {
2668 rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2669 rwco->qiov->size, rwco->qiov,
2670 rwco->flags);
1c9805a3
SH
2671 }
2672}
e7a8a783 2673
1c9805a3 2674/*
8d3b1a2d 2675 * Process a vectored synchronous request using coroutines
1c9805a3 2676 */
775aa8b6
KW
2677static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2678 QEMUIOVector *qiov, bool is_write,
2679 BdrvRequestFlags flags)
1c9805a3 2680{
1c9805a3
SH
2681 Coroutine *co;
2682 RwCo rwco = {
2683 .bs = bs,
775aa8b6 2684 .offset = offset,
8d3b1a2d 2685 .qiov = qiov,
1c9805a3
SH
2686 .is_write = is_write,
2687 .ret = NOT_DONE,
4105eaaa 2688 .flags = flags,
1c9805a3 2689 };
e7a8a783 2690
498e386c
ZYW
2691 /**
2692 * In sync call context, when the vcpu is blocked, this throttling timer
2693 * will not fire; so the I/O throttling function has to be disabled here
2694 * if it has been enabled.
2695 */
2696 if (bs->io_limits_enabled) {
2697 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2698 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2699 bdrv_io_limits_disable(bs);
2700 }
2701
1c9805a3
SH
2702 if (qemu_in_coroutine()) {
2703 /* Fast-path if already in coroutine context */
2704 bdrv_rw_co_entry(&rwco);
2705 } else {
2706 co = qemu_coroutine_create(bdrv_rw_co_entry);
2707 qemu_coroutine_enter(co, &rwco);
2708 while (rwco.ret == NOT_DONE) {
2709 qemu_aio_wait();
2710 }
2711 }
2712 return rwco.ret;
2713}
b338082b 2714
8d3b1a2d
KW
2715/*
2716 * Process a synchronous request using coroutines
2717 */
2718static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
4105eaaa 2719 int nb_sectors, bool is_write, BdrvRequestFlags flags)
8d3b1a2d
KW
2720{
2721 QEMUIOVector qiov;
2722 struct iovec iov = {
2723 .iov_base = (void *)buf,
2724 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2725 };
2726
da15ee51
KW
2727 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2728 return -EINVAL;
2729 }
2730
8d3b1a2d 2731 qemu_iovec_init_external(&qiov, &iov, 1);
775aa8b6
KW
2732 return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2733 &qiov, is_write, flags);
8d3b1a2d
KW
2734}
2735
1c9805a3
SH
2736/* return < 0 if error. See bdrv_write() for the return codes */
2737int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2738 uint8_t *buf, int nb_sectors)
2739{
4105eaaa 2740 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
fc01f7e7
FB
2741}
2742
07d27a44
MA
2743/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2744int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2745 uint8_t *buf, int nb_sectors)
2746{
2747 bool enabled;
2748 int ret;
2749
2750 enabled = bs->io_limits_enabled;
2751 bs->io_limits_enabled = false;
4e7395e8 2752 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
07d27a44
MA
2753 bs->io_limits_enabled = enabled;
2754 return ret;
2755}
2756
5fafdf24 2757/* Return < 0 if error. Important errors are:
19cb3738
FB
2758 -EIO generic I/O error (may happen for all errors)
2759 -ENOMEDIUM No media inserted.
2760 -EINVAL Invalid sector number or nb_sectors
2761 -EACCES Trying to write a read-only device
2762*/
5fafdf24 2763int bdrv_write(BlockDriverState *bs, int64_t sector_num,
fc01f7e7
FB
2764 const uint8_t *buf, int nb_sectors)
2765{
4105eaaa 2766 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
83f64091
FB
2767}
2768
aa7bfbff
PL
2769int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2770 int nb_sectors, BdrvRequestFlags flags)
4105eaaa
PL
2771{
2772 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
aa7bfbff 2773 BDRV_REQ_ZERO_WRITE | flags);
8d3b1a2d
KW
2774}
2775
d75cbb5e
PL
2776/*
2777 * Completely zero out a block device with the help of bdrv_write_zeroes.
2778 * The operation is sped up by checking the block status and only writing
2779 * zeroes to the device if they currently do not return zeroes. Optional
2780 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2781 *
2782 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2783 */
2784int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2785{
9ce10c0b 2786 int64_t target_size;
d75cbb5e
PL
2787 int64_t ret, nb_sectors, sector_num = 0;
2788 int n;
2789
9ce10c0b
KW
2790 target_size = bdrv_getlength(bs);
2791 if (target_size < 0) {
2792 return target_size;
2793 }
2794 target_size /= BDRV_SECTOR_SIZE;
2795
d75cbb5e
PL
2796 for (;;) {
2797 nb_sectors = target_size - sector_num;
2798 if (nb_sectors <= 0) {
2799 return 0;
2800 }
2801 if (nb_sectors > INT_MAX) {
2802 nb_sectors = INT_MAX;
2803 }
2804 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
3d94ce60
PL
2805 if (ret < 0) {
2806 error_report("error getting block status at sector %" PRId64 ": %s",
2807 sector_num, strerror(-ret));
2808 return ret;
2809 }
d75cbb5e
PL
2810 if (ret & BDRV_BLOCK_ZERO) {
2811 sector_num += n;
2812 continue;
2813 }
2814 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2815 if (ret < 0) {
2816 error_report("error writing zeroes at sector %" PRId64 ": %s",
2817 sector_num, strerror(-ret));
2818 return ret;
2819 }
2820 sector_num += n;
2821 }
2822}
2823
a3ef6571 2824int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
83f64091 2825{
a3ef6571
KW
2826 QEMUIOVector qiov;
2827 struct iovec iov = {
2828 .iov_base = (void *)buf,
2829 .iov_len = bytes,
2830 };
9a8c4cce 2831 int ret;
83f64091 2832
a3ef6571
KW
2833 if (bytes < 0) {
2834 return -EINVAL;
83f64091
FB
2835 }
2836
a3ef6571
KW
2837 qemu_iovec_init_external(&qiov, &iov, 1);
2838 ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2839 if (ret < 0) {
2840 return ret;
83f64091 2841 }
a3ef6571
KW
2842
2843 return bytes;
83f64091
FB
2844}
2845
8d3b1a2d 2846int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
83f64091 2847{
9a8c4cce 2848 int ret;
83f64091 2849
8407d5d7
KW
2850 ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2851 if (ret < 0) {
2852 return ret;
83f64091
FB
2853 }
2854
8d3b1a2d
KW
2855 return qiov->size;
2856}
2857
2858int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
8407d5d7 2859 const void *buf, int bytes)
8d3b1a2d
KW
2860{
2861 QEMUIOVector qiov;
2862 struct iovec iov = {
2863 .iov_base = (void *) buf,
8407d5d7 2864 .iov_len = bytes,
8d3b1a2d
KW
2865 };
2866
8407d5d7
KW
2867 if (bytes < 0) {
2868 return -EINVAL;
2869 }
2870
8d3b1a2d
KW
2871 qemu_iovec_init_external(&qiov, &iov, 1);
2872 return bdrv_pwritev(bs, offset, &qiov);
83f64091 2873}
83f64091 2874
f08145fe
KW
2875/*
2876 * Writes to the file and ensures that no writes are reordered across this
2877 * request (acts as a barrier)
2878 *
2879 * Returns 0 on success, -errno in error cases.
2880 */
2881int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2882 const void *buf, int count)
2883{
2884 int ret;
2885
2886 ret = bdrv_pwrite(bs, offset, buf, count);
2887 if (ret < 0) {
2888 return ret;
2889 }
2890
f05fa4ad
PB
2891 /* No flush needed for cache modes that already do it */
2892 if (bs->enable_write_cache) {
f08145fe
KW
2893 bdrv_flush(bs);
2894 }
2895
2896 return 0;
2897}
2898
470c0504 2899static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
ab185921
SH
2900 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2901{
2902 /* Perform I/O through a temporary buffer so that users who scribble over
2903 * their read buffer while the operation is in progress do not end up
2904 * modifying the image file. This is critical for zero-copy guest I/O
2905 * where anything might happen inside guest memory.
2906 */
2907 void *bounce_buffer;
2908
79c053bd 2909 BlockDriver *drv = bs->drv;
ab185921
SH
2910 struct iovec iov;
2911 QEMUIOVector bounce_qiov;
2912 int64_t cluster_sector_num;
2913 int cluster_nb_sectors;
2914 size_t skip_bytes;
2915 int ret;
2916
2917 /* Cover entire cluster so no additional backing file I/O is required when
2918 * allocating cluster in the image file.
2919 */
343bded4
PB
2920 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2921 &cluster_sector_num, &cluster_nb_sectors);
ab185921 2922
470c0504
SH
2923 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2924 cluster_sector_num, cluster_nb_sectors);
ab185921
SH
2925
2926 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2927 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2928 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2929
79c053bd
SH
2930 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2931 &bounce_qiov);
ab185921
SH
2932 if (ret < 0) {
2933 goto err;
2934 }
2935
79c053bd
SH
2936 if (drv->bdrv_co_write_zeroes &&
2937 buffer_is_zero(bounce_buffer, iov.iov_len)) {
621f0589 2938 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
aa7bfbff 2939 cluster_nb_sectors, 0);
79c053bd 2940 } else {
f05fa4ad
PB
2941 /* This does not change the data on the disk, it is not necessary
2942 * to flush even in cache=writethrough mode.
2943 */
79c053bd 2944 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
ab185921 2945 &bounce_qiov);
79c053bd
SH
2946 }
2947
ab185921
SH
2948 if (ret < 0) {
2949 /* It might be okay to ignore write errors for guest requests. If this
2950 * is a deliberate copy-on-read then we don't want to ignore the error.
2951 * Simply report it in all cases.
2952 */
2953 goto err;
2954 }
2955
2956 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
03396148
MT
2957 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2958 nb_sectors * BDRV_SECTOR_SIZE);
ab185921
SH
2959
2960err:
2961 qemu_vfree(bounce_buffer);
2962 return ret;
2963}
2964
c5fbe571 2965/*
d0c7f642
KW
2966 * Forwards an already correctly aligned request to the BlockDriver. This
2967 * handles copy on read and zeroing after EOF; any other features must be
2968 * implemented by the caller.
c5fbe571 2969 */
d0c7f642 2970static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
65afd211 2971 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
ec746e10 2972 int64_t align, QEMUIOVector *qiov, int flags)
da1fa91d
KW
2973{
2974 BlockDriver *drv = bs->drv;
dbffbdcf 2975 int ret;
da1fa91d 2976
d0c7f642
KW
2977 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
2978 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
da1fa91d 2979
d0c7f642
KW
2980 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
2981 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
2982
2983 /* Handle Copy on Read and associated serialisation */
470c0504 2984 if (flags & BDRV_REQ_COPY_ON_READ) {
7327145f
KW
2985 /* If we touch the same cluster it counts as an overlap. This
2986 * guarantees that allocating writes will be serialized and not race
2987 * with each other for the same cluster. For example, in copy-on-read
2988 * it ensures that the CoR read and write operations are atomic and
2989 * guest writes cannot interleave between them. */
2990 mark_request_serialising(req, bdrv_get_cluster_size(bs));
470c0504
SH
2991 }
2992
2dbafdc0 2993 wait_serialising_requests(req);
f4658285 2994
470c0504 2995 if (flags & BDRV_REQ_COPY_ON_READ) {
ab185921
SH
2996 int pnum;
2997
bdad13b9 2998 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
ab185921
SH
2999 if (ret < 0) {
3000 goto out;
3001 }
3002
3003 if (!ret || pnum != nb_sectors) {
470c0504 3004 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
ab185921
SH
3005 goto out;
3006 }
3007 }
3008
d0c7f642 3009 /* Forward the request to the BlockDriver */
893a8f62
MK
3010 if (!(bs->zero_beyond_eof && bs->growable)) {
3011 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3012 } else {
3013 /* Read zeros after EOF of growable BDSes */
3014 int64_t len, total_sectors, max_nb_sectors;
3015
3016 len = bdrv_getlength(bs);
3017 if (len < 0) {
3018 ret = len;
3019 goto out;
3020 }
3021
d055a1fe 3022 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
5f5bcd80
KW
3023 max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3024 align >> BDRV_SECTOR_BITS);
893a8f62
MK
3025 if (max_nb_sectors > 0) {
3026 ret = drv->bdrv_co_readv(bs, sector_num,
3027 MIN(nb_sectors, max_nb_sectors), qiov);
3028 } else {
3029 ret = 0;
3030 }
3031
3032 /* Reading beyond end of file is supposed to produce zeroes */
3033 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3034 uint64_t offset = MAX(0, total_sectors - sector_num);
3035 uint64_t bytes = (sector_num + nb_sectors - offset) *
3036 BDRV_SECTOR_SIZE;
3037 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3038 }
3039 }
ab185921
SH
3040
3041out:
dbffbdcf 3042 return ret;
da1fa91d
KW
3043}
3044
d0c7f642
KW
3045/*
3046 * Handle a read request in coroutine context
3047 */
1b0288ae
KW
3048static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3049 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
d0c7f642
KW
3050 BdrvRequestFlags flags)
3051{
3052 BlockDriver *drv = bs->drv;
65afd211
KW
3053 BdrvTrackedRequest req;
3054
1b0288ae
KW
3055 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3056 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3057 uint8_t *head_buf = NULL;
3058 uint8_t *tail_buf = NULL;
3059 QEMUIOVector local_qiov;
3060 bool use_local_qiov = false;
d0c7f642
KW
3061 int ret;
3062
3063 if (!drv) {
3064 return -ENOMEDIUM;
3065 }
1b0288ae 3066 if (bdrv_check_byte_request(bs, offset, bytes)) {
d0c7f642
KW
3067 return -EIO;
3068 }
3069
3070 if (bs->copy_on_read) {
3071 flags |= BDRV_REQ_COPY_ON_READ;
3072 }
3073
3074 /* throttling disk I/O */
3075 if (bs->io_limits_enabled) {
d5103588 3076 bdrv_io_limits_intercept(bs, bytes, false);
1b0288ae
KW
3077 }
3078
3079 /* Align read if necessary by padding qiov */
3080 if (offset & (align - 1)) {
3081 head_buf = qemu_blockalign(bs, align);
3082 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3083 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3084 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3085 use_local_qiov = true;
3086
3087 bytes += offset & (align - 1);
3088 offset = offset & ~(align - 1);
3089 }
3090
3091 if ((offset + bytes) & (align - 1)) {
3092 if (!use_local_qiov) {
3093 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3094 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3095 use_local_qiov = true;
3096 }
3097 tail_buf = qemu_blockalign(bs, align);
3098 qemu_iovec_add(&local_qiov, tail_buf,
3099 align - ((offset + bytes) & (align - 1)));
3100
3101 bytes = ROUND_UP(bytes, align);
3102 }
3103
65afd211 3104 tracked_request_begin(&req, bs, offset, bytes, false);
ec746e10 3105 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
1b0288ae
KW
3106 use_local_qiov ? &local_qiov : qiov,
3107 flags);
65afd211 3108 tracked_request_end(&req);
1b0288ae
KW
3109
3110 if (use_local_qiov) {
3111 qemu_iovec_destroy(&local_qiov);
3112 qemu_vfree(head_buf);
3113 qemu_vfree(tail_buf);
d0c7f642
KW
3114 }
3115
d0c7f642
KW
3116 return ret;
3117}
3118
1b0288ae
KW
3119static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3120 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3121 BdrvRequestFlags flags)
3122{
3123 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3124 return -EINVAL;
3125 }
3126
3127 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3128 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3129}
3130
c5fbe571 3131int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
da1fa91d
KW
3132 int nb_sectors, QEMUIOVector *qiov)
3133{
c5fbe571 3134 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
da1fa91d 3135
470c0504
SH
3136 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3137}
3138
3139int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3140 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3141{
3142 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3143
3144 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3145 BDRV_REQ_COPY_ON_READ);
c5fbe571
SH
3146}
3147
c31cb707
PL
3148/* if no limit is specified in the BlockLimits use a default
3149 * of 32768 512-byte sectors (16 MiB) per request.
3150 */
3151#define MAX_WRITE_ZEROES_DEFAULT 32768
3152
f08f2dda 3153static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
aa7bfbff 3154 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
f08f2dda
SH
3155{
3156 BlockDriver *drv = bs->drv;
3157 QEMUIOVector qiov;
c31cb707
PL
3158 struct iovec iov = {0};
3159 int ret = 0;
f08f2dda 3160
c31cb707
PL
3161 int max_write_zeroes = bs->bl.max_write_zeroes ?
3162 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
621f0589 3163
c31cb707
PL
3164 while (nb_sectors > 0 && !ret) {
3165 int num = nb_sectors;
3166
b8d71c09
PB
3167 /* Align request. Block drivers can expect the "bulk" of the request
3168 * to be aligned.
3169 */
3170 if (bs->bl.write_zeroes_alignment
3171 && num > bs->bl.write_zeroes_alignment) {
3172 if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3173 /* Make a small request up to the first aligned sector. */
c31cb707 3174 num = bs->bl.write_zeroes_alignment;
b8d71c09
PB
3175 num -= sector_num % bs->bl.write_zeroes_alignment;
3176 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3177 /* Shorten the request to the last aligned sector. num cannot
3178 * underflow because num > bs->bl.write_zeroes_alignment.
3179 */
3180 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
c31cb707 3181 }
621f0589 3182 }
f08f2dda 3183
c31cb707
PL
3184 /* limit request size */
3185 if (num > max_write_zeroes) {
3186 num = max_write_zeroes;
3187 }
3188
3189 ret = -ENOTSUP;
3190 /* First try the efficient write zeroes operation */
3191 if (drv->bdrv_co_write_zeroes) {
3192 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3193 }
3194
3195 if (ret == -ENOTSUP) {
3196 /* Fall back to bounce buffer if write zeroes is unsupported */
3197 iov.iov_len = num * BDRV_SECTOR_SIZE;
3198 if (iov.iov_base == NULL) {
b8d71c09
PB
3199 iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE);
3200 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
c31cb707
PL
3201 }
3202 qemu_iovec_init_external(&qiov, &iov, 1);
f08f2dda 3203
c31cb707 3204 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
b8d71c09
PB
3205
3206 /* Keep bounce buffer around if it is big enough for all
3207 * all future requests.
3208 */
3209 if (num < max_write_zeroes) {
3210 qemu_vfree(iov.iov_base);
3211 iov.iov_base = NULL;
3212 }
c31cb707
PL
3213 }
3214
3215 sector_num += num;
3216 nb_sectors -= num;
3217 }
f08f2dda
SH
3218
3219 qemu_vfree(iov.iov_base);
3220 return ret;
3221}
3222
c5fbe571 3223/*
b404f720 3224 * Forwards an already correctly aligned write request to the BlockDriver.
c5fbe571 3225 */
b404f720 3226static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
65afd211
KW
3227 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3228 QEMUIOVector *qiov, int flags)
c5fbe571
SH
3229{
3230 BlockDriver *drv = bs->drv;
28de2dcd 3231 bool waited;
6b7cb247 3232 int ret;
da1fa91d 3233
b404f720
KW
3234 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3235 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
f4658285 3236
b404f720
KW
3237 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3238 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
cc0681c4 3239
28de2dcd
KW
3240 waited = wait_serialising_requests(req);
3241 assert(!waited || !req->serialising);
af91f9a7
KW
3242 assert(req->overlap_offset <= offset);
3243 assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
244eadef 3244
65afd211 3245 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
d616b224
SH
3246
3247 if (ret < 0) {
3248 /* Do nothing, write notifier decided to fail this request */
3249 } else if (flags & BDRV_REQ_ZERO_WRITE) {
9e1cb96d 3250 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
aa7bfbff 3251 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
f08f2dda 3252 } else {
9e1cb96d 3253 BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
f08f2dda
SH
3254 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3255 }
9e1cb96d 3256 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
6b7cb247 3257
f05fa4ad
PB
3258 if (ret == 0 && !bs->enable_write_cache) {
3259 ret = bdrv_co_flush(bs);
3260 }
3261
e4654d2d 3262 bdrv_set_dirty(bs, sector_num, nb_sectors);
da1fa91d
KW
3263
3264 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3265 bs->wr_highest_sector = sector_num + nb_sectors - 1;
3266 }
df2a6f29
PB
3267 if (bs->growable && ret >= 0) {
3268 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3269 }
da1fa91d 3270
6b7cb247 3271 return ret;
da1fa91d
KW
3272}
3273
b404f720
KW
3274/*
3275 * Handle a write request in coroutine context
3276 */
6601553e
KW
3277static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3278 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
b404f720
KW
3279 BdrvRequestFlags flags)
3280{
65afd211 3281 BdrvTrackedRequest req;
3b8242e0
KW
3282 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3283 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3284 uint8_t *head_buf = NULL;
3285 uint8_t *tail_buf = NULL;
3286 QEMUIOVector local_qiov;
3287 bool use_local_qiov = false;
b404f720
KW
3288 int ret;
3289
3290 if (!bs->drv) {
3291 return -ENOMEDIUM;
3292 }
3293 if (bs->read_only) {
3294 return -EACCES;
3295 }
6601553e 3296 if (bdrv_check_byte_request(bs, offset, bytes)) {
b404f720
KW
3297 return -EIO;
3298 }
3299
b404f720
KW
3300 /* throttling disk I/O */
3301 if (bs->io_limits_enabled) {
d5103588 3302 bdrv_io_limits_intercept(bs, bytes, true);
b404f720
KW
3303 }
3304
3b8242e0
KW
3305 /*
3306 * Align write if necessary by performing a read-modify-write cycle.
3307 * Pad qiov with the read parts and be sure to have a tracked request not
3308 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3309 */
65afd211 3310 tracked_request_begin(&req, bs, offset, bytes, true);
3b8242e0
KW
3311
3312 if (offset & (align - 1)) {
3313 QEMUIOVector head_qiov;
3314 struct iovec head_iov;
3315
3316 mark_request_serialising(&req, align);
3317 wait_serialising_requests(&req);
3318
3319 head_buf = qemu_blockalign(bs, align);
3320 head_iov = (struct iovec) {
3321 .iov_base = head_buf,
3322 .iov_len = align,
3323 };
3324 qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3325
9e1cb96d 3326 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3b8242e0
KW
3327 ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3328 align, &head_qiov, 0);
3329 if (ret < 0) {
3330 goto fail;
3331 }
9e1cb96d 3332 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3b8242e0
KW
3333
3334 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3335 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3336 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3337 use_local_qiov = true;
3338
3339 bytes += offset & (align - 1);
3340 offset = offset & ~(align - 1);
3341 }
3342
3343 if ((offset + bytes) & (align - 1)) {
3344 QEMUIOVector tail_qiov;
3345 struct iovec tail_iov;
3346 size_t tail_bytes;
28de2dcd 3347 bool waited;
3b8242e0
KW
3348
3349 mark_request_serialising(&req, align);
28de2dcd
KW
3350 waited = wait_serialising_requests(&req);
3351 assert(!waited || !use_local_qiov);
3b8242e0
KW
3352
3353 tail_buf = qemu_blockalign(bs, align);
3354 tail_iov = (struct iovec) {
3355 .iov_base = tail_buf,
3356 .iov_len = align,
3357 };
3358 qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3359
9e1cb96d 3360 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3b8242e0
KW
3361 ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3362 align, &tail_qiov, 0);
3363 if (ret < 0) {
3364 goto fail;
3365 }
9e1cb96d 3366 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3b8242e0
KW
3367
3368 if (!use_local_qiov) {
3369 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3370 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3371 use_local_qiov = true;
3372 }
3373
3374 tail_bytes = (offset + bytes) & (align - 1);
3375 qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3376
3377 bytes = ROUND_UP(bytes, align);
3378 }
3379
3380 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3381 use_local_qiov ? &local_qiov : qiov,
3382 flags);
3383
3384fail:
65afd211 3385 tracked_request_end(&req);
b404f720 3386
3b8242e0
KW
3387 if (use_local_qiov) {
3388 qemu_iovec_destroy(&local_qiov);
3b8242e0 3389 }
99c4a85c
KW
3390 qemu_vfree(head_buf);
3391 qemu_vfree(tail_buf);
3b8242e0 3392
b404f720
KW
3393 return ret;
3394}
3395
6601553e
KW
3396static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3397 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3398 BdrvRequestFlags flags)
3399{
3400 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3401 return -EINVAL;
3402 }
3403
3404 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3405 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3406}
3407
c5fbe571
SH
3408int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3409 int nb_sectors, QEMUIOVector *qiov)
3410{
3411 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3412
f08f2dda
SH
3413 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3414}
3415
3416int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
aa7bfbff
PL
3417 int64_t sector_num, int nb_sectors,
3418 BdrvRequestFlags flags)
f08f2dda 3419{
94d6ff21 3420 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
f08f2dda 3421
d32f35cb
PL
3422 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3423 flags &= ~BDRV_REQ_MAY_UNMAP;
3424 }
3425
f08f2dda 3426 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
aa7bfbff 3427 BDRV_REQ_ZERO_WRITE | flags);
c5fbe571
SH
3428}
3429
83f64091
FB
3430/**
3431 * Truncate file to 'offset' bytes (needed only for file protocols)
3432 */
3433int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3434{
3435 BlockDriver *drv = bs->drv;
51762288 3436 int ret;
83f64091 3437 if (!drv)
19cb3738 3438 return -ENOMEDIUM;
83f64091
FB
3439 if (!drv->bdrv_truncate)
3440 return -ENOTSUP;
59f2689d
NS
3441 if (bs->read_only)
3442 return -EACCES;
8591675f
MT
3443 if (bdrv_in_use(bs))
3444 return -EBUSY;
51762288
SH
3445 ret = drv->bdrv_truncate(bs, offset);
3446 if (ret == 0) {
3447 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
145feb17 3448 bdrv_dev_resize_cb(bs);
51762288
SH
3449 }
3450 return ret;
83f64091
FB
3451}
3452
4a1d5e1f
FZ
3453/**
3454 * Length of a allocated file in bytes. Sparse files are counted by actual
3455 * allocated space. Return < 0 if error or unknown.
3456 */
3457int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3458{
3459 BlockDriver *drv = bs->drv;
3460 if (!drv) {
3461 return -ENOMEDIUM;
3462 }
3463 if (drv->bdrv_get_allocated_file_size) {
3464 return drv->bdrv_get_allocated_file_size(bs);
3465 }
3466 if (bs->file) {
3467 return bdrv_get_allocated_file_size(bs->file);
3468 }
3469 return -ENOTSUP;
3470}
3471
83f64091
FB
3472/**
3473 * Length of a file in bytes. Return < 0 if error or unknown.
3474 */
3475int64_t bdrv_getlength(BlockDriverState *bs)
3476{
3477 BlockDriver *drv = bs->drv;
3478 if (!drv)
19cb3738 3479 return -ENOMEDIUM;
51762288 3480
b94a2610
KW
3481 if (drv->has_variable_length) {
3482 int ret = refresh_total_sectors(bs, bs->total_sectors);
3483 if (ret < 0) {
3484 return ret;
46a4e4e6 3485 }
83f64091 3486 }
46a4e4e6 3487 return bs->total_sectors * BDRV_SECTOR_SIZE;
fc01f7e7
FB
3488}
3489
19cb3738 3490/* return 0 as number of sectors if no device present or error */
96b8f136 3491void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
fc01f7e7 3492{
19cb3738
FB
3493 int64_t length;
3494 length = bdrv_getlength(bs);
3495 if (length < 0)
3496 length = 0;
3497 else
6ea44308 3498 length = length >> BDRV_SECTOR_BITS;
19cb3738 3499 *nb_sectors_ptr = length;
fc01f7e7 3500}
cf98951b 3501
ff06f5f3
PB
3502void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3503 BlockdevOnError on_write_error)
abd7f68d
MA
3504{
3505 bs->on_read_error = on_read_error;
3506 bs->on_write_error = on_write_error;
3507}
3508
1ceee0d5 3509BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
abd7f68d
MA
3510{
3511 return is_read ? bs->on_read_error : bs->on_write_error;
3512}
3513
3e1caa5f
PB
3514BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3515{
3516 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3517
3518 switch (on_err) {
3519 case BLOCKDEV_ON_ERROR_ENOSPC:
3520 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
3521 case BLOCKDEV_ON_ERROR_STOP:
3522 return BDRV_ACTION_STOP;
3523 case BLOCKDEV_ON_ERROR_REPORT:
3524 return BDRV_ACTION_REPORT;
3525 case BLOCKDEV_ON_ERROR_IGNORE:
3526 return BDRV_ACTION_IGNORE;
3527 default:
3528 abort();
3529 }
3530}
3531
3532/* This is done by device models because, while the block layer knows
3533 * about the error, it does not know whether an operation comes from
3534 * the device or the block layer (from a job, for example).
3535 */
3536void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3537 bool is_read, int error)
3538{
3539 assert(error >= 0);
32c81a4a 3540 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
3e1caa5f
PB
3541 if (action == BDRV_ACTION_STOP) {
3542 vm_stop(RUN_STATE_IO_ERROR);
3543 bdrv_iostatus_set_err(bs, error);
3544 }
3545}
3546
b338082b
FB
3547int bdrv_is_read_only(BlockDriverState *bs)
3548{
3549 return bs->read_only;
3550}
3551
985a03b0
TS
3552int bdrv_is_sg(BlockDriverState *bs)
3553{
3554 return bs->sg;
3555}
3556
e900a7b7
CH
3557int bdrv_enable_write_cache(BlockDriverState *bs)
3558{
3559 return bs->enable_write_cache;
3560}
3561
425b0148
PB
3562void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3563{
3564 bs->enable_write_cache = wce;
55b110f2
JC
3565
3566 /* so a reopen() will preserve wce */
3567 if (wce) {
3568 bs->open_flags |= BDRV_O_CACHE_WB;
3569 } else {
3570 bs->open_flags &= ~BDRV_O_CACHE_WB;
3571 }
425b0148
PB
3572}
3573
ea2384d3
FB
3574int bdrv_is_encrypted(BlockDriverState *bs)
3575{
3576 if (bs->backing_hd && bs->backing_hd->encrypted)
3577 return 1;
3578 return bs->encrypted;
3579}
3580
c0f4ce77
AL
3581int bdrv_key_required(BlockDriverState *bs)
3582{
3583 BlockDriverState *backing_hd = bs->backing_hd;
3584
3585 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3586 return 1;
3587 return (bs->encrypted && !bs->valid_key);
3588}
3589
ea2384d3
FB
3590int bdrv_set_key(BlockDriverState *bs, const char *key)
3591{
3592 int ret;
3593 if (bs->backing_hd && bs->backing_hd->encrypted) {
3594 ret = bdrv_set_key(bs->backing_hd, key);
3595 if (ret < 0)
3596 return ret;
3597 if (!bs->encrypted)
3598 return 0;
3599 }
fd04a2ae
SH
3600 if (!bs->encrypted) {
3601 return -EINVAL;
3602 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3603 return -ENOMEDIUM;
3604 }
c0f4ce77 3605 ret = bs->drv->bdrv_set_key(bs, key);
bb5fc20f
AL
3606 if (ret < 0) {
3607 bs->valid_key = 0;
3608 } else if (!bs->valid_key) {
3609 bs->valid_key = 1;
3610 /* call the change callback now, we skipped it on open */
7d4b4ba5 3611 bdrv_dev_change_media_cb(bs, true);
bb5fc20f 3612 }
c0f4ce77 3613 return ret;
ea2384d3
FB
3614}
3615
f8d6bba1 3616const char *bdrv_get_format_name(BlockDriverState *bs)
ea2384d3 3617{
f8d6bba1 3618 return bs->drv ? bs->drv->format_name : NULL;
ea2384d3
FB
3619}
3620
5fafdf24 3621void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
ea2384d3
FB
3622 void *opaque)
3623{
3624 BlockDriver *drv;
e855e4fb
JC
3625 int count = 0;
3626 const char **formats = NULL;
ea2384d3 3627
8a22f02a 3628 QLIST_FOREACH(drv, &bdrv_drivers, list) {
e855e4fb
JC
3629 if (drv->format_name) {
3630 bool found = false;
3631 int i = count;
3632 while (formats && i && !found) {
3633 found = !strcmp(formats[--i], drv->format_name);
3634 }
3635
3636 if (!found) {
3637 formats = g_realloc(formats, (count + 1) * sizeof(char *));
3638 formats[count++] = drv->format_name;
3639 it(opaque, drv->format_name);
3640 }
3641 }
ea2384d3 3642 }
e855e4fb 3643 g_free(formats);
ea2384d3
FB
3644}
3645
dc364f4c 3646/* This function is to find block backend bs */
b338082b
FB
3647BlockDriverState *bdrv_find(const char *name)
3648{
3649 BlockDriverState *bs;
3650
dc364f4c 3651 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1b7bdbc1 3652 if (!strcmp(name, bs->device_name)) {
b338082b 3653 return bs;
1b7bdbc1 3654 }
b338082b
FB
3655 }
3656 return NULL;
3657}
3658
dc364f4c
BC
3659/* This function is to find a node in the bs graph */
3660BlockDriverState *bdrv_find_node(const char *node_name)
3661{
3662 BlockDriverState *bs;
3663
3664 assert(node_name);
3665
3666 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3667 if (!strcmp(node_name, bs->node_name)) {
3668 return bs;
3669 }
3670 }
3671 return NULL;
3672}
3673
c13163fb
BC
3674/* Put this QMP function here so it can access the static graph_bdrv_states. */
3675BlockDeviceInfoList *bdrv_named_nodes_list(void)
3676{
3677 BlockDeviceInfoList *list, *entry;
3678 BlockDriverState *bs;
3679
3680 list = NULL;
3681 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3682 entry = g_malloc0(sizeof(*entry));
3683 entry->value = bdrv_block_device_info(bs);
3684 entry->next = list;
3685 list = entry;
3686 }
3687
3688 return list;
3689}
3690
12d3ba82
BC
3691BlockDriverState *bdrv_lookup_bs(const char *device,
3692 const char *node_name,
3693 Error **errp)
3694{
3695 BlockDriverState *bs = NULL;
3696
12d3ba82
BC
3697 if (device) {
3698 bs = bdrv_find(device);
3699
dd67fa50
BC
3700 if (bs) {
3701 return bs;
12d3ba82 3702 }
12d3ba82
BC
3703 }
3704
dd67fa50
BC
3705 if (node_name) {
3706 bs = bdrv_find_node(node_name);
12d3ba82 3707
dd67fa50
BC
3708 if (bs) {
3709 return bs;
3710 }
12d3ba82
BC
3711 }
3712
dd67fa50
BC
3713 error_setg(errp, "Cannot find device=%s nor node_name=%s",
3714 device ? device : "",
3715 node_name ? node_name : "");
3716 return NULL;
12d3ba82
BC
3717}
3718
2f399b0a
MA
3719BlockDriverState *bdrv_next(BlockDriverState *bs)
3720{
3721 if (!bs) {
3722 return QTAILQ_FIRST(&bdrv_states);
3723 }
dc364f4c 3724 return QTAILQ_NEXT(bs, device_list);
2f399b0a
MA
3725}
3726
51de9760 3727void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
81d0912d
FB
3728{
3729 BlockDriverState *bs;
3730
dc364f4c 3731 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
51de9760 3732 it(opaque, bs);
81d0912d
FB
3733 }
3734}
3735
ea2384d3
FB
3736const char *bdrv_get_device_name(BlockDriverState *bs)
3737{
3738 return bs->device_name;
3739}
3740
c8433287
MA
3741int bdrv_get_flags(BlockDriverState *bs)
3742{
3743 return bs->open_flags;
3744}
3745
f0f0fdfe 3746int bdrv_flush_all(void)
c6ca28d6
AL
3747{
3748 BlockDriverState *bs;
f0f0fdfe 3749 int result = 0;
c6ca28d6 3750
dc364f4c 3751 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
f0f0fdfe
KW
3752 int ret = bdrv_flush(bs);
3753 if (ret < 0 && !result) {
3754 result = ret;
3755 }
1b7bdbc1 3756 }
f0f0fdfe
KW
3757
3758 return result;
c6ca28d6
AL
3759}
3760
3ac21627
PL
3761int bdrv_has_zero_init_1(BlockDriverState *bs)
3762{
3763 return 1;
3764}
3765
f2feebbd
KW
3766int bdrv_has_zero_init(BlockDriverState *bs)
3767{
3768 assert(bs->drv);
3769
11212d8f
PB
3770 /* If BS is a copy on write image, it is initialized to
3771 the contents of the base image, which may not be zeroes. */
3772 if (bs->backing_hd) {
3773 return 0;
3774 }
336c1c12
KW
3775 if (bs->drv->bdrv_has_zero_init) {
3776 return bs->drv->bdrv_has_zero_init(bs);
f2feebbd
KW
3777 }
3778
3ac21627
PL
3779 /* safe default */
3780 return 0;
f2feebbd
KW
3781}
3782
4ce78691
PL
3783bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3784{
3785 BlockDriverInfo bdi;
3786
3787 if (bs->backing_hd) {
3788 return false;
3789 }
3790
3791 if (bdrv_get_info(bs, &bdi) == 0) {
3792 return bdi.unallocated_blocks_are_zero;
3793 }
3794
3795 return false;
3796}
3797
3798bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3799{
3800 BlockDriverInfo bdi;
3801
3802 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3803 return false;
3804 }
3805
3806 if (bdrv_get_info(bs, &bdi) == 0) {
3807 return bdi.can_write_zeroes_with_unmap;
3808 }
3809
3810 return false;
3811}
3812
b6b8a333 3813typedef struct BdrvCoGetBlockStatusData {
376ae3f1 3814 BlockDriverState *bs;
b35b2bba 3815 BlockDriverState *base;
376ae3f1
SH
3816 int64_t sector_num;
3817 int nb_sectors;
3818 int *pnum;
b6b8a333 3819 int64_t ret;
376ae3f1 3820 bool done;
b6b8a333 3821} BdrvCoGetBlockStatusData;
376ae3f1 3822
f58c7b35
TS
3823/*
3824 * Returns true iff the specified sector is present in the disk image. Drivers
3825 * not implementing the functionality are assumed to not support backing files,
3826 * hence all their sectors are reported as allocated.
3827 *
bd9533e3
SH
3828 * If 'sector_num' is beyond the end of the disk image the return value is 0
3829 * and 'pnum' is set to 0.
3830 *
f58c7b35
TS
3831 * 'pnum' is set to the number of sectors (including and immediately following
3832 * the specified sector) that are known to be in the same
3833 * allocated/unallocated state.
3834 *
bd9533e3
SH
3835 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3836 * beyond the end of the disk image it will be clamped.
f58c7b35 3837 */
b6b8a333
PB
3838static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3839 int64_t sector_num,
3840 int nb_sectors, int *pnum)
f58c7b35 3841{
617ccb46 3842 int64_t length;
bd9533e3 3843 int64_t n;
5daa74a6 3844 int64_t ret, ret2;
bd9533e3 3845
617ccb46
PB
3846 length = bdrv_getlength(bs);
3847 if (length < 0) {
3848 return length;
3849 }
3850
3851 if (sector_num >= (length >> BDRV_SECTOR_BITS)) {
bd9533e3
SH
3852 *pnum = 0;
3853 return 0;
3854 }
3855
3856 n = bs->total_sectors - sector_num;
3857 if (n < nb_sectors) {
3858 nb_sectors = n;
3859 }
3860
b6b8a333 3861 if (!bs->drv->bdrv_co_get_block_status) {
bd9533e3 3862 *pnum = nb_sectors;
918e92d7
PB
3863 ret = BDRV_BLOCK_DATA;
3864 if (bs->drv->protocol_name) {
3865 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
3866 }
3867 return ret;
f58c7b35 3868 }
6aebab14 3869
415b5b01
PB
3870 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
3871 if (ret < 0) {
3e0a233d 3872 *pnum = 0;
415b5b01
PB
3873 return ret;
3874 }
3875
92bc50a5
PL
3876 if (ret & BDRV_BLOCK_RAW) {
3877 assert(ret & BDRV_BLOCK_OFFSET_VALID);
3878 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3879 *pnum, pnum);
3880 }
3881
c3d86884
PL
3882 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
3883 if (bdrv_unallocated_blocks_are_zero(bs)) {
f0ad5712 3884 ret |= BDRV_BLOCK_ZERO;
1f9db224 3885 } else if (bs->backing_hd) {
f0ad5712
PB
3886 BlockDriverState *bs2 = bs->backing_hd;
3887 int64_t length2 = bdrv_getlength(bs2);
3888 if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {
3889 ret |= BDRV_BLOCK_ZERO;
3890 }
3891 }
415b5b01 3892 }
5daa74a6
PB
3893
3894 if (bs->file &&
3895 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
3896 (ret & BDRV_BLOCK_OFFSET_VALID)) {
3897 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3898 *pnum, pnum);
3899 if (ret2 >= 0) {
3900 /* Ignore errors. This is just providing extra information, it
3901 * is useful but not necessary.
3902 */
3903 ret |= (ret2 & BDRV_BLOCK_ZERO);
3904 }
3905 }
3906
415b5b01 3907 return ret;
060f51c9
SH
3908}
3909
b6b8a333
PB
3910/* Coroutine wrapper for bdrv_get_block_status() */
3911static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
060f51c9 3912{
b6b8a333 3913 BdrvCoGetBlockStatusData *data = opaque;
060f51c9
SH
3914 BlockDriverState *bs = data->bs;
3915
b6b8a333
PB
3916 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
3917 data->pnum);
060f51c9
SH
3918 data->done = true;
3919}
3920
3921/*
b6b8a333 3922 * Synchronous wrapper around bdrv_co_get_block_status().
060f51c9 3923 *
b6b8a333 3924 * See bdrv_co_get_block_status() for details.
060f51c9 3925 */
b6b8a333
PB
3926int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
3927 int nb_sectors, int *pnum)
060f51c9 3928{
6aebab14 3929 Coroutine *co;
b6b8a333 3930 BdrvCoGetBlockStatusData data = {
6aebab14
SH
3931 .bs = bs,
3932 .sector_num = sector_num,
3933 .nb_sectors = nb_sectors,
3934 .pnum = pnum,
3935 .done = false,
3936 };
3937
bdad13b9
PB
3938 if (qemu_in_coroutine()) {
3939 /* Fast-path if already in coroutine context */
b6b8a333 3940 bdrv_get_block_status_co_entry(&data);
bdad13b9 3941 } else {
b6b8a333 3942 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
bdad13b9
PB
3943 qemu_coroutine_enter(co, &data);
3944 while (!data.done) {
3945 qemu_aio_wait();
3946 }
6aebab14
SH
3947 }
3948 return data.ret;
f58c7b35
TS
3949}
3950
b6b8a333
PB
3951int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
3952 int nb_sectors, int *pnum)
3953{
4333bb71
PB
3954 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
3955 if (ret < 0) {
3956 return ret;
3957 }
3958 return
3959 (ret & BDRV_BLOCK_DATA) ||
3960 ((ret & BDRV_BLOCK_ZERO) && !bdrv_has_zero_init(bs));
b6b8a333
PB
3961}
3962
188a7bbf
PB
3963/*
3964 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
3965 *
3966 * Return true if the given sector is allocated in any image between
3967 * BASE and TOP (inclusive). BASE can be NULL to check if the given
3968 * sector is allocated in any image of the chain. Return false otherwise.
3969 *
3970 * 'pnum' is set to the number of sectors (including and immediately following
3971 * the specified sector) that are known to be in the same
3972 * allocated/unallocated state.
3973 *
3974 */
4f578637
PB
3975int bdrv_is_allocated_above(BlockDriverState *top,
3976 BlockDriverState *base,
3977 int64_t sector_num,
3978 int nb_sectors, int *pnum)
188a7bbf
PB
3979{
3980 BlockDriverState *intermediate;
3981 int ret, n = nb_sectors;
3982
3983 intermediate = top;
3984 while (intermediate && intermediate != base) {
3985 int pnum_inter;
bdad13b9
PB
3986 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
3987 &pnum_inter);
188a7bbf
PB
3988 if (ret < 0) {
3989 return ret;
3990 } else if (ret) {
3991 *pnum = pnum_inter;
3992 return 1;
3993 }
3994
3995 /*
3996 * [sector_num, nb_sectors] is unallocated on top but intermediate
3997 * might have
3998 *
3999 * [sector_num+x, nr_sectors] allocated.
4000 */
63ba17d3
VI
4001 if (n > pnum_inter &&
4002 (intermediate == top ||
4003 sector_num + pnum_inter < intermediate->total_sectors)) {
188a7bbf
PB
4004 n = pnum_inter;
4005 }
4006
4007 intermediate = intermediate->backing_hd;
4008 }
4009
4010 *pnum = n;
4011 return 0;
4012}
4013
045df330
AL
4014const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4015{
4016 if (bs->backing_hd && bs->backing_hd->encrypted)
4017 return bs->backing_file;
4018 else if (bs->encrypted)
4019 return bs->filename;
4020 else
4021 return NULL;
4022}
4023
5fafdf24 4024void bdrv_get_backing_filename(BlockDriverState *bs,
83f64091
FB
4025 char *filename, int filename_size)
4026{
3574c608 4027 pstrcpy(filename, filename_size, bs->backing_file);
83f64091
FB
4028}
4029
5fafdf24 4030int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
faea38e7
FB
4031 const uint8_t *buf, int nb_sectors)
4032{
4033 BlockDriver *drv = bs->drv;
4034 if (!drv)
19cb3738 4035 return -ENOMEDIUM;
faea38e7
FB
4036 if (!drv->bdrv_write_compressed)
4037 return -ENOTSUP;
fbb7b4e0
KW
4038 if (bdrv_check_request(bs, sector_num, nb_sectors))
4039 return -EIO;
a55eb92c 4040
e4654d2d 4041 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
a55eb92c 4042
faea38e7
FB
4043 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4044}
3b46e624 4045
faea38e7
FB
4046int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4047{
4048 BlockDriver *drv = bs->drv;
4049 if (!drv)
19cb3738 4050 return -ENOMEDIUM;
faea38e7
FB
4051 if (!drv->bdrv_get_info)
4052 return -ENOTSUP;
4053 memset(bdi, 0, sizeof(*bdi));
4054 return drv->bdrv_get_info(bs, bdi);
4055}
4056
eae041fe
HR
4057ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4058{
4059 BlockDriver *drv = bs->drv;
4060 if (drv && drv->bdrv_get_specific_info) {
4061 return drv->bdrv_get_specific_info(bs);
4062 }
4063 return NULL;
4064}
4065
45566e9c
CH
4066int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4067 int64_t pos, int size)
cf8074b3
KW
4068{
4069 QEMUIOVector qiov;
4070 struct iovec iov = {
4071 .iov_base = (void *) buf,
4072 .iov_len = size,
4073 };
4074
4075 qemu_iovec_init_external(&qiov, &iov, 1);
4076 return bdrv_writev_vmstate(bs, &qiov, pos);
4077}
4078
4079int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
178e08a5
AL
4080{
4081 BlockDriver *drv = bs->drv;
cf8074b3
KW
4082
4083 if (!drv) {
178e08a5 4084 return -ENOMEDIUM;
cf8074b3
KW
4085 } else if (drv->bdrv_save_vmstate) {
4086 return drv->bdrv_save_vmstate(bs, qiov, pos);
4087 } else if (bs->file) {
4088 return bdrv_writev_vmstate(bs->file, qiov, pos);
4089 }
4090
7cdb1f6d 4091 return -ENOTSUP;
178e08a5
AL
4092}
4093
45566e9c
CH
4094int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4095 int64_t pos, int size)
178e08a5
AL
4096{
4097 BlockDriver *drv = bs->drv;
4098 if (!drv)
4099 return -ENOMEDIUM;
7cdb1f6d
MK
4100 if (drv->bdrv_load_vmstate)
4101 return drv->bdrv_load_vmstate(bs, buf, pos, size);
4102 if (bs->file)
4103 return bdrv_load_vmstate(bs->file, buf, pos, size);
4104 return -ENOTSUP;
178e08a5
AL
4105}
4106
8b9b0cc2
KW
4107void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4108{
bf736fe3 4109 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
8b9b0cc2
KW
4110 return;
4111 }
4112
bf736fe3 4113 bs->drv->bdrv_debug_event(bs, event);
41c695c7
KW
4114}
4115
4116int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4117 const char *tag)
4118{
4119 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4120 bs = bs->file;
4121 }
4122
4123 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4124 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4125 }
4126
4127 return -ENOTSUP;
4128}
4129
4cc70e93
FZ
4130int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4131{
4132 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4133 bs = bs->file;
4134 }
4135
4136 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4137 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4138 }
4139
4140 return -ENOTSUP;
4141}
4142
41c695c7
KW
4143int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4144{
938789ea 4145 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
41c695c7
KW
4146 bs = bs->file;
4147 }
8b9b0cc2 4148
41c695c7
KW
4149 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4150 return bs->drv->bdrv_debug_resume(bs, tag);
4151 }
4152
4153 return -ENOTSUP;
4154}
4155
4156bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4157{
4158 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4159 bs = bs->file;
4160 }
4161
4162 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4163 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4164 }
4165
4166 return false;
8b9b0cc2
KW
4167}
4168
199630b6
BS
4169int bdrv_is_snapshot(BlockDriverState *bs)
4170{
4171 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4172}
4173
b1b1d783
JC
4174/* backing_file can either be relative, or absolute, or a protocol. If it is
4175 * relative, it must be relative to the chain. So, passing in bs->filename
4176 * from a BDS as backing_file should not be done, as that may be relative to
4177 * the CWD rather than the chain. */
e8a6bb9c
MT
4178BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4179 const char *backing_file)
4180{
b1b1d783
JC
4181 char *filename_full = NULL;
4182 char *backing_file_full = NULL;
4183 char *filename_tmp = NULL;
4184 int is_protocol = 0;
4185 BlockDriverState *curr_bs = NULL;
4186 BlockDriverState *retval = NULL;
4187
4188 if (!bs || !bs->drv || !backing_file) {
e8a6bb9c
MT
4189 return NULL;
4190 }
4191
b1b1d783
JC
4192 filename_full = g_malloc(PATH_MAX);
4193 backing_file_full = g_malloc(PATH_MAX);
4194 filename_tmp = g_malloc(PATH_MAX);
4195
4196 is_protocol = path_has_protocol(backing_file);
4197
4198 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4199
4200 /* If either of the filename paths is actually a protocol, then
4201 * compare unmodified paths; otherwise make paths relative */
4202 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4203 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4204 retval = curr_bs->backing_hd;
4205 break;
4206 }
e8a6bb9c 4207 } else {
b1b1d783
JC
4208 /* If not an absolute filename path, make it relative to the current
4209 * image's filename path */
4210 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4211 backing_file);
4212
4213 /* We are going to compare absolute pathnames */
4214 if (!realpath(filename_tmp, filename_full)) {
4215 continue;
4216 }
4217
4218 /* We need to make sure the backing filename we are comparing against
4219 * is relative to the current image filename (or absolute) */
4220 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4221 curr_bs->backing_file);
4222
4223 if (!realpath(filename_tmp, backing_file_full)) {
4224 continue;
4225 }
4226
4227 if (strcmp(backing_file_full, filename_full) == 0) {
4228 retval = curr_bs->backing_hd;
4229 break;
4230 }
e8a6bb9c
MT
4231 }
4232 }
4233
b1b1d783
JC
4234 g_free(filename_full);
4235 g_free(backing_file_full);
4236 g_free(filename_tmp);
4237 return retval;
e8a6bb9c
MT
4238}
4239
f198fd1c
BC
4240int bdrv_get_backing_file_depth(BlockDriverState *bs)
4241{
4242 if (!bs->drv) {
4243 return 0;
4244 }
4245
4246 if (!bs->backing_hd) {
4247 return 0;
4248 }
4249
4250 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4251}
4252
79fac568
JC
4253BlockDriverState *bdrv_find_base(BlockDriverState *bs)
4254{
4255 BlockDriverState *curr_bs = NULL;
4256
4257 if (!bs) {
4258 return NULL;
4259 }
4260
4261 curr_bs = bs;
4262
4263 while (curr_bs->backing_hd) {
4264 curr_bs = curr_bs->backing_hd;
4265 }
4266 return curr_bs;
4267}
4268
ea2384d3 4269/**************************************************************/
83f64091 4270/* async I/Os */
ea2384d3 4271
3b69e4b9 4272BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
f141eafe 4273 QEMUIOVector *qiov, int nb_sectors,
3b69e4b9 4274 BlockDriverCompletionFunc *cb, void *opaque)
83f64091 4275{
bbf0a440
SH
4276 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4277
d20d9b7c 4278 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
8c5873d6 4279 cb, opaque, false);
ea2384d3
FB
4280}
4281
f141eafe
AL
4282BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4283 QEMUIOVector *qiov, int nb_sectors,
4284 BlockDriverCompletionFunc *cb, void *opaque)
ea2384d3 4285{
bbf0a440
SH
4286 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4287
d20d9b7c 4288 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
8c5873d6 4289 cb, opaque, true);
83f64091
FB
4290}
4291
d5ef94d4
PB
4292BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4293 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4294 BlockDriverCompletionFunc *cb, void *opaque)
4295{
4296 trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4297
4298 return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4299 BDRV_REQ_ZERO_WRITE | flags,
4300 cb, opaque, true);
4301}
4302
40b4f539
KW
4303
4304typedef struct MultiwriteCB {
4305 int error;
4306 int num_requests;
4307 int num_callbacks;
4308 struct {
4309 BlockDriverCompletionFunc *cb;
4310 void *opaque;
4311 QEMUIOVector *free_qiov;
40b4f539
KW
4312 } callbacks[];
4313} MultiwriteCB;
4314
4315static void multiwrite_user_cb(MultiwriteCB *mcb)
4316{
4317 int i;
4318
4319 for (i = 0; i < mcb->num_callbacks; i++) {
4320 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
1e1ea48d
SH
4321 if (mcb->callbacks[i].free_qiov) {
4322 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4323 }
7267c094 4324 g_free(mcb->callbacks[i].free_qiov);
40b4f539
KW
4325 }
4326}
4327
4328static void multiwrite_cb(void *opaque, int ret)
4329{
4330 MultiwriteCB *mcb = opaque;
4331
6d519a5f
SH
4332 trace_multiwrite_cb(mcb, ret);
4333
cb6d3ca0 4334 if (ret < 0 && !mcb->error) {
40b4f539 4335 mcb->error = ret;
40b4f539
KW
4336 }
4337
4338 mcb->num_requests--;
4339 if (mcb->num_requests == 0) {
de189a1b 4340 multiwrite_user_cb(mcb);
7267c094 4341 g_free(mcb);
40b4f539
KW
4342 }
4343}
4344
4345static int multiwrite_req_compare(const void *a, const void *b)
4346{
77be4366
CH
4347 const BlockRequest *req1 = a, *req2 = b;
4348
4349 /*
4350 * Note that we can't simply subtract req2->sector from req1->sector
4351 * here as that could overflow the return value.
4352 */
4353 if (req1->sector > req2->sector) {
4354 return 1;
4355 } else if (req1->sector < req2->sector) {
4356 return -1;
4357 } else {
4358 return 0;
4359 }
40b4f539
KW
4360}
4361
4362/*
4363 * Takes a bunch of requests and tries to merge them. Returns the number of
4364 * requests that remain after merging.
4365 */
4366static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4367 int num_reqs, MultiwriteCB *mcb)
4368{
4369 int i, outidx;
4370
4371 // Sort requests by start sector
4372 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4373
4374 // Check if adjacent requests touch the same clusters. If so, combine them,
4375 // filling up gaps with zero sectors.
4376 outidx = 0;
4377 for (i = 1; i < num_reqs; i++) {
4378 int merge = 0;
4379 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4380
b6a127a1 4381 // Handle exactly sequential writes and overlapping writes.
40b4f539
KW
4382 if (reqs[i].sector <= oldreq_last) {
4383 merge = 1;
4384 }
4385
e2a305fb
CH
4386 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4387 merge = 0;
4388 }
4389
40b4f539
KW
4390 if (merge) {
4391 size_t size;
7267c094 4392 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
40b4f539
KW
4393 qemu_iovec_init(qiov,
4394 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4395
4396 // Add the first request to the merged one. If the requests are
4397 // overlapping, drop the last sectors of the first request.
4398 size = (reqs[i].sector - reqs[outidx].sector) << 9;
1b093c48 4399 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
40b4f539 4400
b6a127a1
PB
4401 // We should need to add any zeros between the two requests
4402 assert (reqs[i].sector <= oldreq_last);
40b4f539
KW
4403
4404 // Add the second request
1b093c48 4405 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
40b4f539 4406
cbf1dff2 4407 reqs[outidx].nb_sectors = qiov->size >> 9;
40b4f539
KW
4408 reqs[outidx].qiov = qiov;
4409
4410 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4411 } else {
4412 outidx++;
4413 reqs[outidx].sector = reqs[i].sector;
4414 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4415 reqs[outidx].qiov = reqs[i].qiov;
4416 }
4417 }
4418
4419 return outidx + 1;
4420}
4421
4422/*
4423 * Submit multiple AIO write requests at once.
4424 *
4425 * On success, the function returns 0 and all requests in the reqs array have
4426 * been submitted. In error case this function returns -1, and any of the
4427 * requests may or may not be submitted yet. In particular, this means that the
4428 * callback will be called for some of the requests, for others it won't. The
4429 * caller must check the error field of the BlockRequest to wait for the right
4430 * callbacks (if error != 0, no callback will be called).
4431 *
4432 * The implementation may modify the contents of the reqs array, e.g. to merge
4433 * requests. However, the fields opaque and error are left unmodified as they
4434 * are used to signal failure for a single request to the caller.
4435 */
4436int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4437{
40b4f539
KW
4438 MultiwriteCB *mcb;
4439 int i;
4440
301db7c2
RH
4441 /* don't submit writes if we don't have a medium */
4442 if (bs->drv == NULL) {
4443 for (i = 0; i < num_reqs; i++) {
4444 reqs[i].error = -ENOMEDIUM;
4445 }
4446 return -1;
4447 }
4448
40b4f539
KW
4449 if (num_reqs == 0) {
4450 return 0;
4451 }
4452
4453 // Create MultiwriteCB structure
7267c094 4454 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
40b4f539
KW
4455 mcb->num_requests = 0;
4456 mcb->num_callbacks = num_reqs;
4457
4458 for (i = 0; i < num_reqs; i++) {
4459 mcb->callbacks[i].cb = reqs[i].cb;
4460 mcb->callbacks[i].opaque = reqs[i].opaque;
4461 }
4462
4463 // Check for mergable requests
4464 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4465
6d519a5f
SH
4466 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4467
df9309fb
PB
4468 /* Run the aio requests. */
4469 mcb->num_requests = num_reqs;
40b4f539 4470 for (i = 0; i < num_reqs; i++) {
d20d9b7c
PB
4471 bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4472 reqs[i].nb_sectors, reqs[i].flags,
4473 multiwrite_cb, mcb,
4474 true);
40b4f539
KW
4475 }
4476
4477 return 0;
40b4f539
KW
4478}
4479
83f64091 4480void bdrv_aio_cancel(BlockDriverAIOCB *acb)
83f64091 4481{
d7331bed 4482 acb->aiocb_info->cancel(acb);
83f64091
FB
4483}
4484
4485/**************************************************************/
4486/* async block device emulation */
4487
c16b5a2c
CH
4488typedef struct BlockDriverAIOCBSync {
4489 BlockDriverAIOCB common;
4490 QEMUBH *bh;
4491 int ret;
4492 /* vector translation state */
4493 QEMUIOVector *qiov;
4494 uint8_t *bounce;
4495 int is_write;
4496} BlockDriverAIOCBSync;
4497
4498static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4499{
b666d239
KW
4500 BlockDriverAIOCBSync *acb =
4501 container_of(blockacb, BlockDriverAIOCBSync, common);
6a7ad299 4502 qemu_bh_delete(acb->bh);
36afc451 4503 acb->bh = NULL;
c16b5a2c
CH
4504 qemu_aio_release(acb);
4505}
4506
d7331bed 4507static const AIOCBInfo bdrv_em_aiocb_info = {
c16b5a2c
CH
4508 .aiocb_size = sizeof(BlockDriverAIOCBSync),
4509 .cancel = bdrv_aio_cancel_em,
4510};
4511
ce1a14dc 4512static void bdrv_aio_bh_cb(void *opaque)
83f64091 4513{
ce1a14dc 4514 BlockDriverAIOCBSync *acb = opaque;
f141eafe 4515
f141eafe 4516 if (!acb->is_write)
03396148 4517 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
ceb42de8 4518 qemu_vfree(acb->bounce);
ce1a14dc 4519 acb->common.cb(acb->common.opaque, acb->ret);
6a7ad299 4520 qemu_bh_delete(acb->bh);
36afc451 4521 acb->bh = NULL;
ce1a14dc 4522 qemu_aio_release(acb);
83f64091 4523}
beac80cd 4524
f141eafe
AL
4525static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4526 int64_t sector_num,
4527 QEMUIOVector *qiov,
4528 int nb_sectors,
4529 BlockDriverCompletionFunc *cb,
4530 void *opaque,
4531 int is_write)
4532
83f64091 4533{
ce1a14dc 4534 BlockDriverAIOCBSync *acb;
ce1a14dc 4535
d7331bed 4536 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
f141eafe
AL
4537 acb->is_write = is_write;
4538 acb->qiov = qiov;
e268ca52 4539 acb->bounce = qemu_blockalign(bs, qiov->size);
3f3aace8 4540 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
f141eafe
AL
4541
4542 if (is_write) {
d5e6b161 4543 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
1ed20acf 4544 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
f141eafe 4545 } else {
1ed20acf 4546 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
f141eafe
AL
4547 }
4548
ce1a14dc 4549 qemu_bh_schedule(acb->bh);
f141eafe 4550
ce1a14dc 4551 return &acb->common;
beac80cd
FB
4552}
4553
f141eafe
AL
4554static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4555 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
ce1a14dc 4556 BlockDriverCompletionFunc *cb, void *opaque)
beac80cd 4557{
f141eafe
AL
4558 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
4559}
83f64091 4560
f141eafe
AL
4561static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4562 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4563 BlockDriverCompletionFunc *cb, void *opaque)
4564{
4565 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
beac80cd 4566}
beac80cd 4567
68485420
KW
4568
4569typedef struct BlockDriverAIOCBCoroutine {
4570 BlockDriverAIOCB common;
4571 BlockRequest req;
4572 bool is_write;
d318aea9 4573 bool *done;
68485420
KW
4574 QEMUBH* bh;
4575} BlockDriverAIOCBCoroutine;
4576
4577static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4578{
d318aea9
KW
4579 BlockDriverAIOCBCoroutine *acb =
4580 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4581 bool done = false;
4582
4583 acb->done = &done;
4584 while (!done) {
4585 qemu_aio_wait();
4586 }
68485420
KW
4587}
4588
d7331bed 4589static const AIOCBInfo bdrv_em_co_aiocb_info = {
68485420
KW
4590 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
4591 .cancel = bdrv_aio_co_cancel_em,
4592};
4593
35246a68 4594static void bdrv_co_em_bh(void *opaque)
68485420
KW
4595{
4596 BlockDriverAIOCBCoroutine *acb = opaque;
4597
4598 acb->common.cb(acb->common.opaque, acb->req.error);
d318aea9
KW
4599
4600 if (acb->done) {
4601 *acb->done = true;
4602 }
4603
68485420
KW
4604 qemu_bh_delete(acb->bh);
4605 qemu_aio_release(acb);
4606}
4607
b2a61371
SH
4608/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4609static void coroutine_fn bdrv_co_do_rw(void *opaque)
4610{
4611 BlockDriverAIOCBCoroutine *acb = opaque;
4612 BlockDriverState *bs = acb->common.bs;
4613
4614 if (!acb->is_write) {
4615 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
d20d9b7c 4616 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
b2a61371
SH
4617 } else {
4618 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
d20d9b7c 4619 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
b2a61371
SH
4620 }
4621
35246a68 4622 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
b2a61371
SH
4623 qemu_bh_schedule(acb->bh);
4624}
4625
68485420
KW
4626static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4627 int64_t sector_num,
4628 QEMUIOVector *qiov,
4629 int nb_sectors,
d20d9b7c 4630 BdrvRequestFlags flags,
68485420
KW
4631 BlockDriverCompletionFunc *cb,
4632 void *opaque,
8c5873d6 4633 bool is_write)
68485420
KW
4634{
4635 Coroutine *co;
4636 BlockDriverAIOCBCoroutine *acb;
4637
d7331bed 4638 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
68485420
KW
4639 acb->req.sector = sector_num;
4640 acb->req.nb_sectors = nb_sectors;
4641 acb->req.qiov = qiov;
d20d9b7c 4642 acb->req.flags = flags;
68485420 4643 acb->is_write = is_write;
d318aea9 4644 acb->done = NULL;
68485420 4645
8c5873d6 4646 co = qemu_coroutine_create(bdrv_co_do_rw);
68485420
KW
4647 qemu_coroutine_enter(co, acb);
4648
4649 return &acb->common;
4650}
4651
07f07615 4652static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
b2e12bc6 4653{
07f07615
PB
4654 BlockDriverAIOCBCoroutine *acb = opaque;
4655 BlockDriverState *bs = acb->common.bs;
b2e12bc6 4656
07f07615
PB
4657 acb->req.error = bdrv_co_flush(bs);
4658 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
b2e12bc6 4659 qemu_bh_schedule(acb->bh);
b2e12bc6
CH
4660}
4661
07f07615 4662BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
016f5cf6
AG
4663 BlockDriverCompletionFunc *cb, void *opaque)
4664{
07f07615 4665 trace_bdrv_aio_flush(bs, opaque);
016f5cf6 4666
07f07615
PB
4667 Coroutine *co;
4668 BlockDriverAIOCBCoroutine *acb;
016f5cf6 4669
d7331bed 4670 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
d318aea9
KW
4671 acb->done = NULL;
4672
07f07615
PB
4673 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4674 qemu_coroutine_enter(co, acb);
016f5cf6 4675
016f5cf6
AG
4676 return &acb->common;
4677}
4678
4265d620
PB
4679static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4680{
4681 BlockDriverAIOCBCoroutine *acb = opaque;
4682 BlockDriverState *bs = acb->common.bs;
4683
4684 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4685 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
4686 qemu_bh_schedule(acb->bh);
4687}
4688
4689BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4690 int64_t sector_num, int nb_sectors,
4691 BlockDriverCompletionFunc *cb, void *opaque)
4692{
4693 Coroutine *co;
4694 BlockDriverAIOCBCoroutine *acb;
4695
4696 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4697
d7331bed 4698 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4265d620
PB
4699 acb->req.sector = sector_num;
4700 acb->req.nb_sectors = nb_sectors;
d318aea9 4701 acb->done = NULL;
4265d620
PB
4702 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4703 qemu_coroutine_enter(co, acb);
4704
4705 return &acb->common;
4706}
4707
ea2384d3
FB
4708void bdrv_init(void)
4709{
5efa9d5a 4710 module_call_init(MODULE_INIT_BLOCK);
ea2384d3 4711}
ce1a14dc 4712
eb852011
MA
4713void bdrv_init_with_whitelist(void)
4714{
4715 use_bdrv_whitelist = 1;
4716 bdrv_init();
4717}
4718
d7331bed 4719void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
c16b5a2c 4720 BlockDriverCompletionFunc *cb, void *opaque)
ce1a14dc 4721{
ce1a14dc
PB
4722 BlockDriverAIOCB *acb;
4723
d7331bed
SH
4724 acb = g_slice_alloc(aiocb_info->aiocb_size);
4725 acb->aiocb_info = aiocb_info;
ce1a14dc
PB
4726 acb->bs = bs;
4727 acb->cb = cb;
4728 acb->opaque = opaque;
4729 return acb;
4730}
4731
4732void qemu_aio_release(void *p)
4733{
d37c975f 4734 BlockDriverAIOCB *acb = p;
d7331bed 4735 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
ce1a14dc 4736}
19cb3738 4737
f9f05dc5
KW
4738/**************************************************************/
4739/* Coroutine block device emulation */
4740
4741typedef struct CoroutineIOCompletion {
4742 Coroutine *coroutine;
4743 int ret;
4744} CoroutineIOCompletion;
4745
4746static void bdrv_co_io_em_complete(void *opaque, int ret)
4747{
4748 CoroutineIOCompletion *co = opaque;
4749
4750 co->ret = ret;
4751 qemu_coroutine_enter(co->coroutine, NULL);
4752}
4753
4754static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4755 int nb_sectors, QEMUIOVector *iov,
4756 bool is_write)
4757{
4758 CoroutineIOCompletion co = {
4759 .coroutine = qemu_coroutine_self(),
4760 };
4761 BlockDriverAIOCB *acb;
4762
4763 if (is_write) {
a652d160
SH
4764 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4765 bdrv_co_io_em_complete, &co);
f9f05dc5 4766 } else {
a652d160
SH
4767 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4768 bdrv_co_io_em_complete, &co);
f9f05dc5
KW
4769 }
4770
59370aaa 4771 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
f9f05dc5
KW
4772 if (!acb) {
4773 return -EIO;
4774 }
4775 qemu_coroutine_yield();
4776
4777 return co.ret;
4778}
4779
4780static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4781 int64_t sector_num, int nb_sectors,
4782 QEMUIOVector *iov)
4783{
4784 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4785}
4786
4787static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4788 int64_t sector_num, int nb_sectors,
4789 QEMUIOVector *iov)
4790{
4791 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4792}
4793
07f07615 4794static void coroutine_fn bdrv_flush_co_entry(void *opaque)
e7a8a783 4795{
07f07615
PB
4796 RwCo *rwco = opaque;
4797
4798 rwco->ret = bdrv_co_flush(rwco->bs);
4799}
4800
4801int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4802{
eb489bb1
KW
4803 int ret;
4804
29cdb251 4805 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
07f07615 4806 return 0;
eb489bb1
KW
4807 }
4808
ca716364 4809 /* Write back cached data to the OS even with cache=unsafe */
bf736fe3 4810 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
eb489bb1
KW
4811 if (bs->drv->bdrv_co_flush_to_os) {
4812 ret = bs->drv->bdrv_co_flush_to_os(bs);
4813 if (ret < 0) {
4814 return ret;
4815 }
4816 }
4817
ca716364
KW
4818 /* But don't actually force it to the disk with cache=unsafe */
4819 if (bs->open_flags & BDRV_O_NO_FLUSH) {
d4c82329 4820 goto flush_parent;
ca716364
KW
4821 }
4822
bf736fe3 4823 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
eb489bb1 4824 if (bs->drv->bdrv_co_flush_to_disk) {
29cdb251 4825 ret = bs->drv->bdrv_co_flush_to_disk(bs);
07f07615
PB
4826 } else if (bs->drv->bdrv_aio_flush) {
4827 BlockDriverAIOCB *acb;
4828 CoroutineIOCompletion co = {
4829 .coroutine = qemu_coroutine_self(),
4830 };
4831
4832 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4833 if (acb == NULL) {
29cdb251 4834 ret = -EIO;
07f07615
PB
4835 } else {
4836 qemu_coroutine_yield();
29cdb251 4837 ret = co.ret;
07f07615 4838 }
07f07615
PB
4839 } else {
4840 /*
4841 * Some block drivers always operate in either writethrough or unsafe
4842 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4843 * know how the server works (because the behaviour is hardcoded or
4844 * depends on server-side configuration), so we can't ensure that
4845 * everything is safe on disk. Returning an error doesn't work because
4846 * that would break guests even if the server operates in writethrough
4847 * mode.
4848 *
4849 * Let's hope the user knows what he's doing.
4850 */
29cdb251 4851 ret = 0;
07f07615 4852 }
29cdb251
PB
4853 if (ret < 0) {
4854 return ret;
4855 }
4856
4857 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4858 * in the case of cache=unsafe, so there are no useless flushes.
4859 */
d4c82329 4860flush_parent:
29cdb251 4861 return bdrv_co_flush(bs->file);
07f07615
PB
4862}
4863
5a8a30db 4864void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
0f15423c 4865{
5a8a30db
KW
4866 Error *local_err = NULL;
4867 int ret;
4868
3456a8d1
KW
4869 if (!bs->drv) {
4870 return;
4871 }
4872
4873 if (bs->drv->bdrv_invalidate_cache) {
5a8a30db 4874 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3456a8d1 4875 } else if (bs->file) {
5a8a30db
KW
4876 bdrv_invalidate_cache(bs->file, &local_err);
4877 }
4878 if (local_err) {
4879 error_propagate(errp, local_err);
4880 return;
0f15423c 4881 }
3456a8d1 4882
5a8a30db
KW
4883 ret = refresh_total_sectors(bs, bs->total_sectors);
4884 if (ret < 0) {
4885 error_setg_errno(errp, -ret, "Could not refresh total sector count");
4886 return;
4887 }
0f15423c
AL
4888}
4889
5a8a30db 4890void bdrv_invalidate_cache_all(Error **errp)
0f15423c
AL
4891{
4892 BlockDriverState *bs;
5a8a30db 4893 Error *local_err = NULL;
0f15423c 4894
dc364f4c 4895 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5a8a30db
KW
4896 bdrv_invalidate_cache(bs, &local_err);
4897 if (local_err) {
4898 error_propagate(errp, local_err);
4899 return;
4900 }
0f15423c
AL
4901 }
4902}
4903
07789269
BC
4904void bdrv_clear_incoming_migration_all(void)
4905{
4906 BlockDriverState *bs;
4907
dc364f4c 4908 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
07789269
BC
4909 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
4910 }
4911}
4912
07f07615
PB
4913int bdrv_flush(BlockDriverState *bs)
4914{
4915 Coroutine *co;
4916 RwCo rwco = {
4917 .bs = bs,
4918 .ret = NOT_DONE,
e7a8a783 4919 };
e7a8a783 4920
07f07615
PB
4921 if (qemu_in_coroutine()) {
4922 /* Fast-path if already in coroutine context */
4923 bdrv_flush_co_entry(&rwco);
4924 } else {
4925 co = qemu_coroutine_create(bdrv_flush_co_entry);
4926 qemu_coroutine_enter(co, &rwco);
4927 while (rwco.ret == NOT_DONE) {
4928 qemu_aio_wait();
4929 }
e7a8a783 4930 }
07f07615
PB
4931
4932 return rwco.ret;
e7a8a783
KW
4933}
4934
775aa8b6
KW
4935typedef struct DiscardCo {
4936 BlockDriverState *bs;
4937 int64_t sector_num;
4938 int nb_sectors;
4939 int ret;
4940} DiscardCo;
4265d620
PB
4941static void coroutine_fn bdrv_discard_co_entry(void *opaque)
4942{
775aa8b6 4943 DiscardCo *rwco = opaque;
4265d620
PB
4944
4945 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
4946}
4947
6f14da52
PL
4948/* if no limit is specified in the BlockLimits use a default
4949 * of 32768 512-byte sectors (16 MiB) per request.
4950 */
4951#define MAX_DISCARD_DEFAULT 32768
4952
4265d620
PB
4953int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
4954 int nb_sectors)
4955{
d51e9fe5
PB
4956 int max_discard;
4957
4265d620
PB
4958 if (!bs->drv) {
4959 return -ENOMEDIUM;
4960 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
4961 return -EIO;
4962 } else if (bs->read_only) {
4963 return -EROFS;
df702c9b
PB
4964 }
4965
e4654d2d 4966 bdrv_reset_dirty(bs, sector_num, nb_sectors);
df702c9b 4967
9e8f1835
PB
4968 /* Do nothing if disabled. */
4969 if (!(bs->open_flags & BDRV_O_UNMAP)) {
4970 return 0;
4971 }
4972
d51e9fe5
PB
4973 if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
4974 return 0;
4975 }
6f14da52 4976
d51e9fe5
PB
4977 max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT;
4978 while (nb_sectors > 0) {
4979 int ret;
4980 int num = nb_sectors;
6f14da52 4981
d51e9fe5
PB
4982 /* align request */
4983 if (bs->bl.discard_alignment &&
4984 num >= bs->bl.discard_alignment &&
4985 sector_num % bs->bl.discard_alignment) {
4986 if (num > bs->bl.discard_alignment) {
4987 num = bs->bl.discard_alignment;
6f14da52 4988 }
d51e9fe5
PB
4989 num -= sector_num % bs->bl.discard_alignment;
4990 }
6f14da52 4991
d51e9fe5
PB
4992 /* limit request size */
4993 if (num > max_discard) {
4994 num = max_discard;
4995 }
6f14da52 4996
d51e9fe5 4997 if (bs->drv->bdrv_co_discard) {
6f14da52 4998 ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
d51e9fe5
PB
4999 } else {
5000 BlockDriverAIOCB *acb;
5001 CoroutineIOCompletion co = {
5002 .coroutine = qemu_coroutine_self(),
5003 };
5004
5005 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5006 bdrv_co_io_em_complete, &co);
5007 if (acb == NULL) {
5008 return -EIO;
5009 } else {
5010 qemu_coroutine_yield();
5011 ret = co.ret;
6f14da52 5012 }
6f14da52 5013 }
7ce21016 5014 if (ret && ret != -ENOTSUP) {
d51e9fe5 5015 return ret;
4265d620 5016 }
d51e9fe5
PB
5017
5018 sector_num += num;
5019 nb_sectors -= num;
4265d620 5020 }
d51e9fe5 5021 return 0;
4265d620
PB
5022}
5023
5024int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5025{
5026 Coroutine *co;
775aa8b6 5027 DiscardCo rwco = {
4265d620
PB
5028 .bs = bs,
5029 .sector_num = sector_num,
5030 .nb_sectors = nb_sectors,
5031 .ret = NOT_DONE,
5032 };
5033
5034 if (qemu_in_coroutine()) {
5035 /* Fast-path if already in coroutine context */
5036 bdrv_discard_co_entry(&rwco);
5037 } else {
5038 co = qemu_coroutine_create(bdrv_discard_co_entry);
5039 qemu_coroutine_enter(co, &rwco);
5040 while (rwco.ret == NOT_DONE) {
5041 qemu_aio_wait();
5042 }
5043 }
5044
5045 return rwco.ret;
5046}
5047
19cb3738
FB
5048/**************************************************************/
5049/* removable device support */
5050
5051/**
5052 * Return TRUE if the media is present
5053 */
5054int bdrv_is_inserted(BlockDriverState *bs)
5055{
5056 BlockDriver *drv = bs->drv;
a1aff5bf 5057
19cb3738
FB
5058 if (!drv)
5059 return 0;
5060 if (!drv->bdrv_is_inserted)
a1aff5bf
MA
5061 return 1;
5062 return drv->bdrv_is_inserted(bs);
19cb3738
FB
5063}
5064
5065/**
8e49ca46
MA
5066 * Return whether the media changed since the last call to this
5067 * function, or -ENOTSUP if we don't know. Most drivers don't know.
19cb3738
FB
5068 */
5069int bdrv_media_changed(BlockDriverState *bs)
5070{
5071 BlockDriver *drv = bs->drv;
19cb3738 5072
8e49ca46
MA
5073 if (drv && drv->bdrv_media_changed) {
5074 return drv->bdrv_media_changed(bs);
5075 }
5076 return -ENOTSUP;
19cb3738
FB
5077}
5078
5079/**
5080 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5081 */
f36f3949 5082void bdrv_eject(BlockDriverState *bs, bool eject_flag)
19cb3738
FB
5083{
5084 BlockDriver *drv = bs->drv;
19cb3738 5085
822e1cd1
MA
5086 if (drv && drv->bdrv_eject) {
5087 drv->bdrv_eject(bs, eject_flag);
19cb3738 5088 }
6f382ed2
LC
5089
5090 if (bs->device_name[0] != '\0') {
5091 bdrv_emit_qmp_eject_event(bs, eject_flag);
5092 }
19cb3738
FB
5093}
5094
19cb3738
FB
5095/**
5096 * Lock or unlock the media (if it is locked, the user won't be able
5097 * to eject it manually).
5098 */
025e849a 5099void bdrv_lock_medium(BlockDriverState *bs, bool locked)
19cb3738
FB
5100{
5101 BlockDriver *drv = bs->drv;
5102
025e849a 5103 trace_bdrv_lock_medium(bs, locked);
b8c6d095 5104
025e849a
MA
5105 if (drv && drv->bdrv_lock_medium) {
5106 drv->bdrv_lock_medium(bs, locked);
19cb3738
FB
5107 }
5108}
985a03b0
TS
5109
5110/* needed for generic scsi interface */
5111
5112int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5113{
5114 BlockDriver *drv = bs->drv;
5115
5116 if (drv && drv->bdrv_ioctl)
5117 return drv->bdrv_ioctl(bs, req, buf);
5118 return -ENOTSUP;
5119}
7d780669 5120
221f715d
AL
5121BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5122 unsigned long int req, void *buf,
5123 BlockDriverCompletionFunc *cb, void *opaque)
7d780669 5124{
221f715d 5125 BlockDriver *drv = bs->drv;
7d780669 5126
221f715d
AL
5127 if (drv && drv->bdrv_aio_ioctl)
5128 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5129 return NULL;
7d780669 5130}
e268ca52 5131
1b7fd729 5132void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
7b6f9300 5133{
1b7fd729 5134 bs->guest_block_size = align;
7b6f9300 5135}
7cd1e32a 5136
e268ca52
AL
5137void *qemu_blockalign(BlockDriverState *bs, size_t size)
5138{
339064d5 5139 return qemu_memalign(bdrv_opt_mem_align(bs), size);
e268ca52 5140}
7cd1e32a 5141
c53b1c51
SH
5142/*
5143 * Check if all memory in this vector is sector aligned.
5144 */
5145bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5146{
5147 int i;
339064d5 5148 size_t alignment = bdrv_opt_mem_align(bs);
c53b1c51
SH
5149
5150 for (i = 0; i < qiov->niov; i++) {
339064d5 5151 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
c53b1c51 5152 return false;
1ff735bd 5153 }
339064d5 5154 if (qiov->iov[i].iov_len % alignment) {
1ff735bd 5155 return false;
c53b1c51
SH
5156 }
5157 }
5158
5159 return true;
5160}
5161
b8afb520
FZ
5162BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5163 Error **errp)
7cd1e32a
LS
5164{
5165 int64_t bitmap_size;
e4654d2d 5166 BdrvDirtyBitmap *bitmap;
a55eb92c 5167
50717e94
PB
5168 assert((granularity & (granularity - 1)) == 0);
5169
e4654d2d
FZ
5170 granularity >>= BDRV_SECTOR_BITS;
5171 assert(granularity);
b8afb520
FZ
5172 bitmap_size = bdrv_getlength(bs);
5173 if (bitmap_size < 0) {
5174 error_setg_errno(errp, -bitmap_size, "could not get length of device");
5175 errno = -bitmap_size;
5176 return NULL;
5177 }
5178 bitmap_size >>= BDRV_SECTOR_BITS;
e4654d2d
FZ
5179 bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
5180 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5181 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5182 return bitmap;
5183}
5184
5185void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5186{
5187 BdrvDirtyBitmap *bm, *next;
5188 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5189 if (bm == bitmap) {
5190 QLIST_REMOVE(bitmap, list);
5191 hbitmap_free(bitmap->bitmap);
5192 g_free(bitmap);
5193 return;
a55eb92c 5194 }
7cd1e32a
LS
5195 }
5196}
5197
21b56835
FZ
5198BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5199{
5200 BdrvDirtyBitmap *bm;
5201 BlockDirtyInfoList *list = NULL;
5202 BlockDirtyInfoList **plist = &list;
5203
5204 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5205 BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
5206 BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
5207 info->count = bdrv_get_dirty_count(bs, bm);
5208 info->granularity =
5209 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5210 entry->value = info;
5211 *plist = entry;
5212 plist = &entry->next;
5213 }
5214
5215 return list;
5216}
5217
e4654d2d 5218int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
7cd1e32a 5219{
e4654d2d
FZ
5220 if (bitmap) {
5221 return hbitmap_get(bitmap->bitmap, sector);
7cd1e32a
LS
5222 } else {
5223 return 0;
5224 }
5225}
5226
e4654d2d
FZ
5227void bdrv_dirty_iter_init(BlockDriverState *bs,
5228 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
1755da16 5229{
e4654d2d 5230 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
1755da16
PB
5231}
5232
5233void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5234 int nr_sectors)
5235{
e4654d2d
FZ
5236 BdrvDirtyBitmap *bitmap;
5237 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5238 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
5239 }
1755da16
PB
5240}
5241
e4654d2d 5242void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
7cd1e32a 5243{
e4654d2d
FZ
5244 BdrvDirtyBitmap *bitmap;
5245 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5246 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5247 }
7cd1e32a 5248}
aaa0eb75 5249
e4654d2d 5250int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
aaa0eb75 5251{
e4654d2d 5252 return hbitmap_count(bitmap->bitmap);
aaa0eb75 5253}
f88e1a42 5254
9fcb0251
FZ
5255/* Get a reference to bs */
5256void bdrv_ref(BlockDriverState *bs)
5257{
5258 bs->refcnt++;
5259}
5260
5261/* Release a previously grabbed reference to bs.
5262 * If after releasing, reference count is zero, the BlockDriverState is
5263 * deleted. */
5264void bdrv_unref(BlockDriverState *bs)
5265{
5266 assert(bs->refcnt > 0);
5267 if (--bs->refcnt == 0) {
5268 bdrv_delete(bs);
5269 }
5270}
5271
db593f25
MT
5272void bdrv_set_in_use(BlockDriverState *bs, int in_use)
5273{
5274 assert(bs->in_use != in_use);
5275 bs->in_use = in_use;
5276}
5277
5278int bdrv_in_use(BlockDriverState *bs)
5279{
5280 return bs->in_use;
5281}
5282
28a7282a
LC
5283void bdrv_iostatus_enable(BlockDriverState *bs)
5284{
d6bf279e 5285 bs->iostatus_enabled = true;
58e21ef5 5286 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
28a7282a
LC
5287}
5288
5289/* The I/O status is only enabled if the drive explicitly
5290 * enables it _and_ the VM is configured to stop on errors */
5291bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5292{
d6bf279e 5293 return (bs->iostatus_enabled &&
92aa5c6d
PB
5294 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5295 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
5296 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
28a7282a
LC
5297}
5298
5299void bdrv_iostatus_disable(BlockDriverState *bs)
5300{
d6bf279e 5301 bs->iostatus_enabled = false;
28a7282a
LC
5302}
5303
5304void bdrv_iostatus_reset(BlockDriverState *bs)
5305{
5306 if (bdrv_iostatus_is_enabled(bs)) {
58e21ef5 5307 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3bd293c3
PB
5308 if (bs->job) {
5309 block_job_iostatus_reset(bs->job);
5310 }
28a7282a
LC
5311 }
5312}
5313
28a7282a
LC
5314void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5315{
3e1caa5f
PB
5316 assert(bdrv_iostatus_is_enabled(bs));
5317 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
58e21ef5
LC
5318 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5319 BLOCK_DEVICE_IO_STATUS_FAILED;
28a7282a
LC
5320 }
5321}
5322
a597e79c
CH
5323void
5324bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5325 enum BlockAcctType type)
5326{
5327 assert(type < BDRV_MAX_IOTYPE);
5328
5329 cookie->bytes = bytes;
c488c7f6 5330 cookie->start_time_ns = get_clock();
a597e79c
CH
5331 cookie->type = type;
5332}
5333
5334void
5335bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5336{
5337 assert(cookie->type < BDRV_MAX_IOTYPE);
5338
5339 bs->nr_bytes[cookie->type] += cookie->bytes;
5340 bs->nr_ops[cookie->type]++;
c488c7f6 5341 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
a597e79c
CH
5342}
5343
d92ada22
LC
5344void bdrv_img_create(const char *filename, const char *fmt,
5345 const char *base_filename, const char *base_fmt,
f382d43a
MR
5346 char *options, uint64_t img_size, int flags,
5347 Error **errp, bool quiet)
f88e1a42
JS
5348{
5349 QEMUOptionParameter *param = NULL, *create_options = NULL;
d220894e 5350 QEMUOptionParameter *backing_fmt, *backing_file, *size;
f88e1a42 5351 BlockDriver *drv, *proto_drv;
96df67d1 5352 BlockDriver *backing_drv = NULL;
cc84d90f 5353 Error *local_err = NULL;
f88e1a42
JS
5354 int ret = 0;
5355
5356 /* Find driver and parse its options */
5357 drv = bdrv_find_format(fmt);
5358 if (!drv) {
71c79813 5359 error_setg(errp, "Unknown file format '%s'", fmt);
d92ada22 5360 return;
f88e1a42
JS
5361 }
5362
98289620 5363 proto_drv = bdrv_find_protocol(filename, true);
f88e1a42 5364 if (!proto_drv) {
71c79813 5365 error_setg(errp, "Unknown protocol '%s'", filename);
d92ada22 5366 return;
f88e1a42
JS
5367 }
5368
5369 create_options = append_option_parameters(create_options,
5370 drv->create_options);
5371 create_options = append_option_parameters(create_options,
5372 proto_drv->create_options);
5373
5374 /* Create parameter list with default values */
5375 param = parse_option_parameters("", create_options, param);
5376
5377 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
5378
5379 /* Parse -o options */
5380 if (options) {
5381 param = parse_option_parameters(options, create_options, param);
5382 if (param == NULL) {
71c79813 5383 error_setg(errp, "Invalid options for file format '%s'.", fmt);
f88e1a42
JS
5384 goto out;
5385 }
5386 }
5387
5388 if (base_filename) {
5389 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
5390 base_filename)) {
71c79813
LC
5391 error_setg(errp, "Backing file not supported for file format '%s'",
5392 fmt);
f88e1a42
JS
5393 goto out;
5394 }
5395 }
5396
5397 if (base_fmt) {
5398 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
71c79813
LC
5399 error_setg(errp, "Backing file format not supported for file "
5400 "format '%s'", fmt);
f88e1a42
JS
5401 goto out;
5402 }
5403 }
5404
792da93a
JS
5405 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
5406 if (backing_file && backing_file->value.s) {
5407 if (!strcmp(filename, backing_file->value.s)) {
71c79813
LC
5408 error_setg(errp, "Error: Trying to create an image with the "
5409 "same filename as the backing file");
792da93a
JS
5410 goto out;
5411 }
5412 }
5413
f88e1a42
JS
5414 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
5415 if (backing_fmt && backing_fmt->value.s) {
96df67d1
SH
5416 backing_drv = bdrv_find_format(backing_fmt->value.s);
5417 if (!backing_drv) {
71c79813
LC
5418 error_setg(errp, "Unknown backing file format '%s'",
5419 backing_fmt->value.s);
f88e1a42
JS
5420 goto out;
5421 }
5422 }
5423
5424 // The size for the image must always be specified, with one exception:
5425 // If we are using a backing file, we can obtain the size from there
d220894e
KW
5426 size = get_option_parameter(param, BLOCK_OPT_SIZE);
5427 if (size && size->value.n == -1) {
f88e1a42 5428 if (backing_file && backing_file->value.s) {
66f6b814 5429 BlockDriverState *bs;
f88e1a42 5430 uint64_t size;
f88e1a42 5431 char buf[32];
63090dac
PB
5432 int back_flags;
5433
5434 /* backing files always opened read-only */
5435 back_flags =
5436 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
f88e1a42 5437
f67503e5 5438 bs = NULL;
ddf5636d 5439 ret = bdrv_open(&bs, backing_file->value.s, NULL, NULL, back_flags,
cc84d90f 5440 backing_drv, &local_err);
f88e1a42 5441 if (ret < 0) {
cc84d90f
HR
5442 error_setg_errno(errp, -ret, "Could not open '%s': %s",
5443 backing_file->value.s,
5444 error_get_pretty(local_err));
5445 error_free(local_err);
5446 local_err = NULL;
f88e1a42
JS
5447 goto out;
5448 }
5449 bdrv_get_geometry(bs, &size);
5450 size *= 512;
5451
5452 snprintf(buf, sizeof(buf), "%" PRId64, size);
5453 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
66f6b814
HR
5454
5455 bdrv_unref(bs);
f88e1a42 5456 } else {
71c79813 5457 error_setg(errp, "Image creation needs a size parameter");
f88e1a42
JS
5458 goto out;
5459 }
5460 }
5461
f382d43a
MR
5462 if (!quiet) {
5463 printf("Formatting '%s', fmt=%s ", filename, fmt);
5464 print_option_parameters(param);
5465 puts("");
5466 }
cc84d90f
HR
5467 ret = bdrv_create(drv, filename, param, &local_err);
5468 if (ret == -EFBIG) {
5469 /* This is generally a better message than whatever the driver would
5470 * deliver (especially because of the cluster_size_hint), since that
5471 * is most probably not much different from "image too large". */
5472 const char *cluster_size_hint = "";
5473 if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
5474 cluster_size_hint = " (try using a larger cluster size)";
f88e1a42 5475 }
cc84d90f
HR
5476 error_setg(errp, "The image size is too large for file format '%s'"
5477 "%s", fmt, cluster_size_hint);
5478 error_free(local_err);
5479 local_err = NULL;
f88e1a42
JS
5480 }
5481
5482out:
5483 free_option_parameters(create_options);
5484 free_option_parameters(param);
5485
84d18f06 5486 if (local_err) {
cc84d90f
HR
5487 error_propagate(errp, local_err);
5488 }
f88e1a42 5489}
85d126f3
SH
5490
5491AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5492{
5493 /* Currently BlockDriverState always uses the main loop AioContext */
5494 return qemu_get_aio_context();
5495}
d616b224
SH
5496
5497void bdrv_add_before_write_notifier(BlockDriverState *bs,
5498 NotifierWithReturn *notifier)
5499{
5500 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5501}
6f176b48
HR
5502
5503int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options)
5504{
5505 if (bs->drv->bdrv_amend_options == NULL) {
5506 return -ENOTSUP;
5507 }
5508 return bs->drv->bdrv_amend_options(bs, options);
5509}
f6186f49 5510
b5042a36
BC
5511/* This function will be called by the bdrv_recurse_is_first_non_filter method
5512 * of block filter and by bdrv_is_first_non_filter.
5513 * It is used to test if the given bs is the candidate or recurse more in the
5514 * node graph.
212a5a8f 5515 */
b5042a36 5516bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
212a5a8f 5517 BlockDriverState *candidate)
f6186f49 5518{
b5042a36
BC
5519 /* return false if basic checks fails */
5520 if (!bs || !bs->drv) {
212a5a8f 5521 return false;
f6186f49
BC
5522 }
5523
b5042a36
BC
5524 /* the code reached a non block filter driver -> check if the bs is
5525 * the same as the candidate. It's the recursion termination condition.
5526 */
5527 if (!bs->drv->is_filter) {
5528 return bs == candidate;
212a5a8f 5529 }
b5042a36 5530 /* Down this path the driver is a block filter driver */
212a5a8f 5531
b5042a36
BC
5532 /* If the block filter recursion method is defined use it to recurse down
5533 * the node graph.
5534 */
5535 if (bs->drv->bdrv_recurse_is_first_non_filter) {
212a5a8f 5536 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
f6186f49
BC
5537 }
5538
b5042a36
BC
5539 /* the driver is a block filter but don't allow to recurse -> return false
5540 */
5541 return false;
f6186f49
BC
5542}
5543
212a5a8f
BC
5544/* This function checks if the candidate is the first non filter bs down it's
5545 * bs chain. Since we don't have pointers to parents it explore all bs chains
5546 * from the top. Some filters can choose not to pass down the recursion.
5547 */
5548bool bdrv_is_first_non_filter(BlockDriverState *candidate)
f6186f49 5549{
212a5a8f
BC
5550 BlockDriverState *bs;
5551
5552 /* walk down the bs forest recursively */
5553 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5554 bool perm;
5555
b5042a36 5556 /* try to recurse in this top level bs */
e6dc8a1f 5557 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
212a5a8f
BC
5558
5559 /* candidate is the first non filter */
5560 if (perm) {
5561 return true;
5562 }
5563 }
5564
5565 return false;
f6186f49 5566}