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