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