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