block.c

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