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