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.h"
  28 #include "block_int.h"
  29 #include "module.h"
  30 #include "qjson.h"
  31 #include "qemu-coroutine.h"
  32 #include "qmp-commands.h"
  33 #include "qemu-timer.h"
  34
  35 #ifdef CONFIG_BSD
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <sys/ioctl.h>
  39 #include <sys/queue.h>
  40 #ifndef __DragonFly__
  41 #include <sys/disk.h>
  42 #endif
  43 #endif
  44
  45 #ifdef _WIN32
  46 #include <windows.h>
  47 #endif
  48
  49 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
  50
  51 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
  52 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
  53         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
  54         BlockDriverCompletionFunc *cb, void *opaque);
  55 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
  56         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
  57         BlockDriverCompletionFunc *cb, void *opaque);
  58 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
  59                                          int64_t sector_num, int nb_sectors,
  60                                          QEMUIOVector *iov);
  61 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
  62                                          int64_t sector_num, int nb_sectors,
  63                                          QEMUIOVector *iov);
  64 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
  65     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
  66 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
  67     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
  68 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
  69                                                int64_t sector_num,
  70                                                QEMUIOVector *qiov,
  71                                                int nb_sectors,
  72                                                BlockDriverCompletionFunc *cb,
  73                                                void *opaque,
  74                                                bool is_write);
  75 static void coroutine_fn bdrv_co_do_rw(void *opaque);
  76
  77 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
  78         bool is_write, double elapsed_time, uint64_t *wait);
  79 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
  80         double elapsed_time, uint64_t *wait);
  81 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
  82         bool is_write, int64_t *wait);
  83
  84 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
  85     QTAILQ_HEAD_INITIALIZER(bdrv_states);
  86
  87 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
  88     QLIST_HEAD_INITIALIZER(bdrv_drivers);
  89
  90 /* The device to use for VM snapshots */
  91 static BlockDriverState *bs_snapshots;
  92
  93 /* If non-zero, use only whitelisted block drivers */
  94 static int use_bdrv_whitelist;
  95
  96 #ifdef _WIN32
  97 static int is_windows_drive_prefix(const char *filename)
  98 {
  99     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
 100              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
 101             filename[1] == ':');
 102 }
 103
 104 int is_windows_drive(const char *filename)
 105 {
 106     if (is_windows_drive_prefix(filename) &&
 107         filename[2] == '\0')
 108         return 1;
 109     if (strstart(filename, "\\\\.\\", NULL) ||
 110         strstart(filename, "//./", NULL))
 111         return 1;
 112     return 0;
 113 }
 114 #endif
 115
 116 /* throttling disk I/O limits */
 117 void bdrv_io_limits_disable(BlockDriverState *bs)
 118 {
 119     bs->io_limits_enabled = false;
 120
 121     while (qemu_co_queue_next(&bs->throttled_reqs));
 122
 123     if (bs->block_timer) {
 124         qemu_del_timer(bs->block_timer);
 125         qemu_free_timer(bs->block_timer);
 126         bs->block_timer = NULL;
 127     }
 128
 129     bs->slice_start = 0;
 130     bs->slice_end   = 0;
 131     bs->slice_time  = 0;
 132     memset(&bs->io_base, 0, sizeof(bs->io_base));
 133 }
 134
 135 static void bdrv_block_timer(void *opaque)
 136 {
 137     BlockDriverState *bs = opaque;
 138
 139     qemu_co_queue_next(&bs->throttled_reqs);
 140 }
 141
 142 void bdrv_io_limits_enable(BlockDriverState *bs)
 143 {
 144     qemu_co_queue_init(&bs->throttled_reqs);
 145     bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs);
 146     bs->slice_time  = 5 * BLOCK_IO_SLICE_TIME;
 147     bs->slice_start = qemu_get_clock_ns(vm_clock);
 148     bs->slice_end   = bs->slice_start + bs->slice_time;
 149     memset(&bs->io_base, 0, sizeof(bs->io_base));
 150     bs->io_limits_enabled = true;
 151 }
 152
 153 bool bdrv_io_limits_enabled(BlockDriverState *bs)
 154 {
 155     BlockIOLimit *io_limits = &bs->io_limits;
 156     return io_limits->bps[BLOCK_IO_LIMIT_READ]
 157          || io_limits->bps[BLOCK_IO_LIMIT_WRITE]
 158          || io_limits->bps[BLOCK_IO_LIMIT_TOTAL]
 159          || io_limits->iops[BLOCK_IO_LIMIT_READ]
 160          || io_limits->iops[BLOCK_IO_LIMIT_WRITE]
 161          || io_limits->iops[BLOCK_IO_LIMIT_TOTAL];
 162 }
 163
 164 static void bdrv_io_limits_intercept(BlockDriverState *bs,
 165                                      bool is_write, int nb_sectors)
 166 {
 167     int64_t wait_time = -1;
 168
 169     if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
 170         qemu_co_queue_wait(&bs->throttled_reqs);
 171     }
 172
 173     /* In fact, we hope to keep each request's timing, in FIFO mode. The next
 174      * throttled requests will not be dequeued until the current request is
 175      * allowed to be serviced. So if the current request still exceeds the
 176      * limits, it will be inserted to the head. All requests followed it will
 177      * be still in throttled_reqs queue.
 178      */
 179
 180     while (bdrv_exceed_io_limits(bs, nb_sectors, is_write, &wait_time)) {
 181         qemu_mod_timer(bs->block_timer,
 182                        wait_time + qemu_get_clock_ns(vm_clock));
 183         qemu_co_queue_wait_insert_head(&bs->throttled_reqs);
 184     }
 185
 186     qemu_co_queue_next(&bs->throttled_reqs);
 187 }
 188
 189 /* check if the path starts with "<protocol>:" */
 190 static int path_has_protocol(const char *path)
 191 {
 192 #ifdef _WIN32
 193     if (is_windows_drive(path) ||
 194         is_windows_drive_prefix(path)) {
 195         return 0;
 196     }
 197 #endif
 198
 199     return strchr(path, ':') != NULL;
 200 }
 201
 202 int path_is_absolute(const char *path)
 203 {
 204     const char *p;
 205 #ifdef _WIN32
 206     /* specific case for names like: "\\.\d:" */
 207     if (*path == '/' || *path == '\\')
 208         return 1;
 209 #endif
 210     p = strchr(path, ':');
 211     if (p)
 212         p++;
 213     else
 214         p = path;
 215 #ifdef _WIN32
 216     return (*p == '/' || *p == '\\');
 217 #else
 218     return (*p == '/');
 219 #endif
 220 }
 221
 222 /* if filename is absolute, just copy it to dest. Otherwise, build a
 223    path to it by considering it is relative to base_path. URL are
 224    supported. */
 225 void path_combine(char *dest, int dest_size,
 226                   const char *base_path,
 227                   const char *filename)
 228 {
 229     const char *p, *p1;
 230     int len;
 231
 232     if (dest_size <= 0)
 233         return;
 234     if (path_is_absolute(filename)) {
 235         pstrcpy(dest, dest_size, filename);
 236     } else {
 237         p = strchr(base_path, ':');
 238         if (p)
 239             p++;
 240         else
 241             p = base_path;
 242         p1 = strrchr(base_path, '/');
 243 #ifdef _WIN32
 244         {
 245             const char *p2;
 246             p2 = strrchr(base_path, '\\');
 247             if (!p1 || p2 > p1)
 248                 p1 = p2;
 249         }
 250 #endif
 251         if (p1)
 252             p1++;
 253         else
 254             p1 = base_path;
 255         if (p1 > p)
 256             p = p1;
 257         len = p - base_path;
 258         if (len > dest_size - 1)
 259             len = dest_size - 1;
 260         memcpy(dest, base_path, len);
 261         dest[len] = '\0';
 262         pstrcat(dest, dest_size, filename);
 263     }
 264 }
 265
 266 void bdrv_register(BlockDriver *bdrv)
 267 {
 268     /* Block drivers without coroutine functions need emulation */
 269     if (!bdrv->bdrv_co_readv) {
 270         bdrv->bdrv_co_readv = bdrv_co_readv_em;
 271         bdrv->bdrv_co_writev = bdrv_co_writev_em;
 272
 273         /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
 274          * the block driver lacks aio we need to emulate that too.
 275          */
 276         if (!bdrv->bdrv_aio_readv) {
 277             /* add AIO emulation layer */
 278             bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
 279             bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
 280         }
 281     }
 282
 283     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
 284 }
 285
 286 /* create a new block device (by default it is empty) */
 287 BlockDriverState *bdrv_new(const char *device_name)
 288 {
 289     BlockDriverState *bs;
 290
 291     bs = g_malloc0(sizeof(BlockDriverState));
 292     pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
 293     if (device_name[0] != '\0') {
 294         QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
 295     }
 296     bdrv_iostatus_disable(bs);
 297     return bs;
 298 }
 299
 300 BlockDriver *bdrv_find_format(const char *format_name)
 301 {
 302     BlockDriver *drv1;
 303     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 304         if (!strcmp(drv1->format_name, format_name)) {
 305             return drv1;
 306         }
 307     }
 308     return NULL;
 309 }
 310
 311 static int bdrv_is_whitelisted(BlockDriver *drv)
 312 {
 313     static const char *whitelist[] = {
 314         CONFIG_BDRV_WHITELIST
 315     };
 316     const char **p;
 317
 318     if (!whitelist[0])
 319         return 1;               /* no whitelist, anything goes */
 320
 321     for (p = whitelist; *p; p++) {
 322         if (!strcmp(drv->format_name, *p)) {
 323             return 1;
 324         }
 325     }
 326     return 0;
 327 }
 328
 329 BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
 330 {
 331     BlockDriver *drv = bdrv_find_format(format_name);
 332     return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
 333 }
 334
 335 int bdrv_create(BlockDriver *drv, const char* filename,
 336     QEMUOptionParameter *options)
 337 {
 338     if (!drv->bdrv_create)
 339         return -ENOTSUP;
 340
 341     return drv->bdrv_create(filename, options);
 342 }
 343
 344 int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
 345 {
 346     BlockDriver *drv;
 347
 348     drv = bdrv_find_protocol(filename);
 349     if (drv == NULL) {
 350         return -ENOENT;
 351     }
 352
 353     return bdrv_create(drv, filename, options);
 354 }
 355
 356 #ifdef _WIN32
 357 void get_tmp_filename(char *filename, int size)
 358 {
 359     char temp_dir[MAX_PATH];
 360
 361     GetTempPath(MAX_PATH, temp_dir);
 362     GetTempFileName(temp_dir, "qem", 0, filename);
 363 }
 364 #else
 365 void get_tmp_filename(char *filename, int size)
 366 {
 367     int fd;
 368     const char *tmpdir;
 369     /* XXX: race condition possible */
 370     tmpdir = getenv("TMPDIR");
 371     if (!tmpdir)
 372         tmpdir = "/tmp";
 373     snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
 374     fd = mkstemp(filename);
 375     close(fd);
 376 }
 377 #endif
 378
 379 /*
 380  * Detect host devices. By convention, /dev/cdrom[N] is always
 381  * recognized as a host CDROM.
 382  */
 383 static BlockDriver *find_hdev_driver(const char *filename)
 384 {
 385     int score_max = 0, score;
 386     BlockDriver *drv = NULL, *d;
 387
 388     QLIST_FOREACH(d, &bdrv_drivers, list) {
 389         if (d->bdrv_probe_device) {
 390             score = d->bdrv_probe_device(filename);
 391             if (score > score_max) {
 392                 score_max = score;
 393                 drv = d;
 394             }
 395         }
 396     }
 397
 398     return drv;
 399 }
 400
 401 BlockDriver *bdrv_find_protocol(const char *filename)
 402 {
 403     BlockDriver *drv1;
 404     char protocol[128];
 405     int len;
 406     const char *p;
 407
 408     /* TODO Drivers without bdrv_file_open must be specified explicitly */
 409
 410     /*
 411      * XXX(hch): we really should not let host device detection
 412      * override an explicit protocol specification, but moving this
 413      * later breaks access to device names with colons in them.
 414      * Thanks to the brain-dead persistent naming schemes on udev-
 415      * based Linux systems those actually are quite common.
 416      */
 417     drv1 = find_hdev_driver(filename);
 418     if (drv1) {
 419         return drv1;
 420     }
 421
 422     if (!path_has_protocol(filename)) {
 423         return bdrv_find_format("file");
 424     }
 425     p = strchr(filename, ':');
 426     assert(p != NULL);
 427     len = p - filename;
 428     if (len > sizeof(protocol) - 1)
 429         len = sizeof(protocol) - 1;
 430     memcpy(protocol, filename, len);
 431     protocol[len] = '\0';
 432     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 433         if (drv1->protocol_name &&
 434             !strcmp(drv1->protocol_name, protocol)) {
 435             return drv1;
 436         }
 437     }
 438     return NULL;
 439 }
 440
 441 static int find_image_format(const char *filename, BlockDriver **pdrv)
 442 {
 443     int ret, score, score_max;
 444     BlockDriver *drv1, *drv;
 445     uint8_t buf[2048];
 446     BlockDriverState *bs;
 447
 448     ret = bdrv_file_open(&bs, filename, 0);
 449     if (ret < 0) {
 450         *pdrv = NULL;
 451         return ret;
 452     }
 453
 454     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
 455     if (bs->sg || !bdrv_is_inserted(bs)) {
 456         bdrv_delete(bs);
 457         drv = bdrv_find_format("raw");
 458         if (!drv) {
 459             ret = -ENOENT;
 460         }
 461         *pdrv = drv;
 462         return ret;
 463     }
 464
 465     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
 466     bdrv_delete(bs);
 467     if (ret < 0) {
 468         *pdrv = NULL;
 469         return ret;
 470     }
 471
 472     score_max = 0;
 473     drv = NULL;
 474     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 475         if (drv1->bdrv_probe) {
 476             score = drv1->bdrv_probe(buf, ret, filename);
 477             if (score > score_max) {
 478                 score_max = score;
 479                 drv = drv1;
 480             }
 481         }
 482     }
 483     if (!drv) {
 484         ret = -ENOENT;
 485     }
 486     *pdrv = drv;
 487     return ret;
 488 }
 489
 490 /**
 491  * Set the current 'total_sectors' value
 492  */
 493 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
 494 {
 495     BlockDriver *drv = bs->drv;
 496
 497     /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
 498     if (bs->sg)
 499         return 0;
 500
 501     /* query actual device if possible, otherwise just trust the hint */
 502     if (drv->bdrv_getlength) {
 503         int64_t length = drv->bdrv_getlength(bs);
 504         if (length < 0) {
 505             return length;
 506         }
 507         hint = length >> BDRV_SECTOR_BITS;
 508     }
 509
 510     bs->total_sectors = hint;
 511     return 0;
 512 }
 513
 514 /**
 515  * Set open flags for a given cache mode
 516  *
 517  * Return 0 on success, -1 if the cache mode was invalid.
 518  */
 519 int bdrv_parse_cache_flags(const char *mode, int *flags)
 520 {
 521     *flags &= ~BDRV_O_CACHE_MASK;
 522
 523     if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
 524         *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
 525     } else if (!strcmp(mode, "directsync")) {
 526         *flags |= BDRV_O_NOCACHE;
 527     } else if (!strcmp(mode, "writeback")) {
 528         *flags |= BDRV_O_CACHE_WB;
 529     } else if (!strcmp(mode, "unsafe")) {
 530         *flags |= BDRV_O_CACHE_WB;
 531         *flags |= BDRV_O_NO_FLUSH;
 532     } else if (!strcmp(mode, "writethrough")) {
 533         /* this is the default */
 534     } else {
 535         return -1;
 536     }
 537
 538     return 0;
 539 }
 540
 541 /**
 542  * The copy-on-read flag is actually a reference count so multiple users may
 543  * use the feature without worrying about clobbering its previous state.
 544  * Copy-on-read stays enabled until all users have called to disable it.
 545  */
 546 void bdrv_enable_copy_on_read(BlockDriverState *bs)
 547 {
 548     bs->copy_on_read++;
 549 }
 550
 551 void bdrv_disable_copy_on_read(BlockDriverState *bs)
 552 {
 553     assert(bs->copy_on_read > 0);
 554     bs->copy_on_read--;
 555 }
 556
 557 /*
 558  * Common part for opening disk images and files
 559  */
 560 static int bdrv_open_common(BlockDriverState *bs, const char *filename,
 561     int flags, BlockDriver *drv)
 562 {
 563     int ret, open_flags;
 564
 565     assert(drv != NULL);
 566
 567     trace_bdrv_open_common(bs, filename, flags, drv->format_name);
 568
 569     bs->file = NULL;
 570     bs->total_sectors = 0;
 571     bs->encrypted = 0;
 572     bs->valid_key = 0;
 573     bs->sg = 0;
 574     bs->open_flags = flags;
 575     bs->growable = 0;
 576     bs->buffer_alignment = 512;
 577
 578     assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
 579     if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) {
 580         bdrv_enable_copy_on_read(bs);
 581     }
 582
 583     pstrcpy(bs->filename, sizeof(bs->filename), filename);
 584     bs->backing_file[0] = '\0';
 585
 586     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
 587         return -ENOTSUP;
 588     }
 589
 590     bs->drv = drv;
 591     bs->opaque = g_malloc0(drv->instance_size);
 592
 593     bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
 594
 595     /*
 596      * Clear flags that are internal to the block layer before opening the
 597      * image.
 598      */
 599     open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
 600
 601     /*
 602      * Snapshots should be writable.
 603      */
 604     if (bs->is_temporary) {
 605         open_flags |= BDRV_O_RDWR;
 606     }
 607
 608     bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
 609
 610     /* Open the image, either directly or using a protocol */
 611     if (drv->bdrv_file_open) {
 612         ret = drv->bdrv_file_open(bs, filename, open_flags);
 613     } else {
 614         ret = bdrv_file_open(&bs->file, filename, open_flags);
 615         if (ret >= 0) {
 616             ret = drv->bdrv_open(bs, open_flags);
 617         }
 618     }
 619
 620     if (ret < 0) {
 621         goto free_and_fail;
 622     }
 623
 624     ret = refresh_total_sectors(bs, bs->total_sectors);
 625     if (ret < 0) {
 626         goto free_and_fail;
 627     }
 628
 629 #ifndef _WIN32
 630     if (bs->is_temporary) {
 631         unlink(filename);
 632     }
 633 #endif
 634     return 0;
 635
 636 free_and_fail:
 637     if (bs->file) {
 638         bdrv_delete(bs->file);
 639         bs->file = NULL;
 640     }
 641     g_free(bs->opaque);
 642     bs->opaque = NULL;
 643     bs->drv = NULL;
 644     return ret;
 645 }
 646
 647 /*
 648  * Opens a file using a protocol (file, host_device, nbd, ...)
 649  */
 650 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
 651 {
 652     BlockDriverState *bs;
 653     BlockDriver *drv;
 654     int ret;
 655
 656     drv = bdrv_find_protocol(filename);
 657     if (!drv) {
 658         return -ENOENT;
 659     }
 660
 661     bs = bdrv_new("");
 662     ret = bdrv_open_common(bs, filename, flags, drv);
 663     if (ret < 0) {
 664         bdrv_delete(bs);
 665         return ret;
 666     }
 667     bs->growable = 1;
 668     *pbs = bs;
 669     return 0;
 670 }
 671
 672 /*
 673  * Opens a disk image (raw, qcow2, vmdk, ...)
 674  */
 675 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
 676               BlockDriver *drv)
 677 {
 678     int ret;
 679     char tmp_filename[PATH_MAX];
 680
 681     if (flags & BDRV_O_SNAPSHOT) {
 682         BlockDriverState *bs1;
 683         int64_t total_size;
 684         int is_protocol = 0;
 685         BlockDriver *bdrv_qcow2;
 686         QEMUOptionParameter *options;
 687         char backing_filename[PATH_MAX];
 688
 689         /* if snapshot, we create a temporary backing file and open it
 690            instead of opening 'filename' directly */
 691
 692         /* if there is a backing file, use it */
 693         bs1 = bdrv_new("");
 694         ret = bdrv_open(bs1, filename, 0, drv);
 695         if (ret < 0) {
 696             bdrv_delete(bs1);
 697             return ret;
 698         }
 699         total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
 700
 701         if (bs1->drv && bs1->drv->protocol_name)
 702             is_protocol = 1;
 703
 704         bdrv_delete(bs1);
 705
 706         get_tmp_filename(tmp_filename, sizeof(tmp_filename));
 707
 708         /* Real path is meaningless for protocols */
 709         if (is_protocol)
 710             snprintf(backing_filename, sizeof(backing_filename),
 711                      "%s", filename);
 712         else if (!realpath(filename, backing_filename))
 713             return -errno;
 714
 715         bdrv_qcow2 = bdrv_find_format("qcow2");
 716         options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
 717
 718         set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
 719         set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
 720         if (drv) {
 721             set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
 722                 drv->format_name);
 723         }
 724
 725         ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
 726         free_option_parameters(options);
 727         if (ret < 0) {
 728             return ret;
 729         }
 730
 731         filename = tmp_filename;
 732         drv = bdrv_qcow2;
 733         bs->is_temporary = 1;
 734     }
 735
 736     /* Find the right image format driver */
 737     if (!drv) {
 738         ret = find_image_format(filename, &drv);
 739     }
 740
 741     if (!drv) {
 742         goto unlink_and_fail;
 743     }
 744
 745     /* Open the image */
 746     ret = bdrv_open_common(bs, filename, flags, drv);
 747     if (ret < 0) {
 748         goto unlink_and_fail;
 749     }
 750
 751     /* If there is a backing file, use it */
 752     if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
 753         char backing_filename[PATH_MAX];
 754         int back_flags;
 755         BlockDriver *back_drv = NULL;
 756
 757         bs->backing_hd = bdrv_new("");
 758
 759         if (path_has_protocol(bs->backing_file)) {
 760             pstrcpy(backing_filename, sizeof(backing_filename),
 761                     bs->backing_file);
 762         } else {
 763             path_combine(backing_filename, sizeof(backing_filename),
 764                          filename, bs->backing_file);
 765         }
 766
 767         if (bs->backing_format[0] != '\0') {
 768             back_drv = bdrv_find_format(bs->backing_format);
 769         }
 770
 771         /* backing files always opened read-only */
 772         back_flags =
 773             flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
 774
 775         ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
 776         if (ret < 0) {
 777             bdrv_close(bs);
 778             return ret;
 779         }
 780         if (bs->is_temporary) {
 781             bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
 782         } else {
 783             /* base image inherits from "parent" */
 784             bs->backing_hd->keep_read_only = bs->keep_read_only;
 785         }
 786     }
 787
 788     if (!bdrv_key_required(bs)) {
 789         bdrv_dev_change_media_cb(bs, true);
 790     }
 791
 792     /* throttling disk I/O limits */
 793     if (bs->io_limits_enabled) {
 794         bdrv_io_limits_enable(bs);
 795     }
 796
 797     return 0;
 798
 799 unlink_and_fail:
 800     if (bs->is_temporary) {
 801         unlink(filename);
 802     }
 803     return ret;
 804 }
 805
 806 void bdrv_close(BlockDriverState *bs)
 807 {
 808     if (bs->drv) {
 809         if (bs == bs_snapshots) {
 810             bs_snapshots = NULL;
 811         }
 812         if (bs->backing_hd) {
 813             bdrv_delete(bs->backing_hd);
 814             bs->backing_hd = NULL;
 815         }
 816         bs->drv->bdrv_close(bs);
 817         g_free(bs->opaque);
 818 #ifdef _WIN32
 819         if (bs->is_temporary) {
 820             unlink(bs->filename);
 821         }
 822 #endif
 823         bs->opaque = NULL;
 824         bs->drv = NULL;
 825         bs->copy_on_read = 0;
 826
 827         if (bs->file != NULL) {
 828             bdrv_close(bs->file);
 829         }
 830
 831         bdrv_dev_change_media_cb(bs, false);
 832     }
 833
 834     /*throttling disk I/O limits*/
 835     if (bs->io_limits_enabled) {
 836         bdrv_io_limits_disable(bs);
 837     }
 838 }
 839
 840 void bdrv_close_all(void)
 841 {
 842     BlockDriverState *bs;
 843
 844     QTAILQ_FOREACH(bs, &bdrv_states, list) {
 845         bdrv_close(bs);
 846     }
 847 }
 848
 849 /* make a BlockDriverState anonymous by removing from bdrv_state list.
 850    Also, NULL terminate the device_name to prevent double remove */
 851 void bdrv_make_anon(BlockDriverState *bs)
 852 {
 853     if (bs->device_name[0] != '\0') {
 854         QTAILQ_REMOVE(&bdrv_states, bs, list);
 855     }
 856     bs->device_name[0] = '\0';
 857 }
 858
 859 void bdrv_delete(BlockDriverState *bs)
 860 {
 861     assert(!bs->dev);
 862
 863     /* remove from list, if necessary */
 864     bdrv_make_anon(bs);
 865
 866     bdrv_close(bs);
 867     if (bs->file != NULL) {
 868         bdrv_delete(bs->file);
 869     }
 870
 871     assert(bs != bs_snapshots);
 872     g_free(bs);
 873 }
 874
 875 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
 876 /* TODO change to DeviceState *dev when all users are qdevified */
 877 {
 878     if (bs->dev) {
 879         return -EBUSY;
 880     }
 881     bs->dev = dev;
 882     bdrv_iostatus_reset(bs);
 883     return 0;
 884 }
 885
 886 /* TODO qdevified devices don't use this, remove when devices are qdevified */
 887 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
 888 {
 889     if (bdrv_attach_dev(bs, dev) < 0) {
 890         abort();
 891     }
 892 }
 893
 894 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
 895 /* TODO change to DeviceState *dev when all users are qdevified */
 896 {
 897     assert(bs->dev == dev);
 898     bs->dev = NULL;
 899     bs->dev_ops = NULL;
 900     bs->dev_opaque = NULL;
 901     bs->buffer_alignment = 512;
 902 }
 903
 904 /* TODO change to return DeviceState * when all users are qdevified */
 905 void *bdrv_get_attached_dev(BlockDriverState *bs)
 906 {
 907     return bs->dev;
 908 }
 909
 910 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
 911                       void *opaque)
 912 {
 913     bs->dev_ops = ops;
 914     bs->dev_opaque = opaque;
 915     if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) {
 916         bs_snapshots = NULL;
 917     }
 918 }
 919
 920 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
 921 {
 922     if (bs->dev_ops && bs->dev_ops->change_media_cb) {
 923         bs->dev_ops->change_media_cb(bs->dev_opaque, load);
 924     }
 925 }
 926
 927 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
 928 {
 929     return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
 930 }
 931
 932 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
 933 {
 934     if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
 935         bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
 936     }
 937 }
 938
 939 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
 940 {
 941     if (bs->dev_ops && bs->dev_ops->is_tray_open) {
 942         return bs->dev_ops->is_tray_open(bs->dev_opaque);
 943     }
 944     return false;
 945 }
 946
 947 static void bdrv_dev_resize_cb(BlockDriverState *bs)
 948 {
 949     if (bs->dev_ops && bs->dev_ops->resize_cb) {
 950         bs->dev_ops->resize_cb(bs->dev_opaque);
 951     }
 952 }
 953
 954 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
 955 {
 956     if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
 957         return bs->dev_ops->is_medium_locked(bs->dev_opaque);
 958     }
 959     return false;
 960 }
 961
 962 /*
 963  * Run consistency checks on an image
 964  *
 965  * Returns 0 if the check could be completed (it doesn't mean that the image is
 966  * free of errors) or -errno when an internal error occurred. The results of the
 967  * check are stored in res.
 968  */
 969 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
 970 {
 971     if (bs->drv->bdrv_check == NULL) {
 972         return -ENOTSUP;
 973     }
 974
 975     memset(res, 0, sizeof(*res));
 976     return bs->drv->bdrv_check(bs, res);
 977 }
 978
 979 #define COMMIT_BUF_SECTORS 2048
 980
 981 /* commit COW file into the raw image */
 982 int bdrv_commit(BlockDriverState *bs)
 983 {
 984     BlockDriver *drv = bs->drv;
 985     BlockDriver *backing_drv;
 986     int64_t sector, total_sectors;
 987     int n, ro, open_flags;
 988     int ret = 0, rw_ret = 0;
 989     uint8_t *buf;
 990     char filename[1024];
 991     BlockDriverState *bs_rw, *bs_ro;
 992
 993     if (!drv)
 994         return -ENOMEDIUM;
 995
 996     if (!bs->backing_hd) {
 997         return -ENOTSUP;
 998     }
 999
1000     if (bs->backing_hd->keep_read_only) {
1001         return -EACCES;
1002     }
1003
1004     backing_drv = bs->backing_hd->drv;
1005     ro = bs->backing_hd->read_only;
1006     strncpy(filename, bs->backing_hd->filename, sizeof(filename));
1007     open_flags =  bs->backing_hd->open_flags;
1008
1009     if (ro) {
1010         /* re-open as RW */
1011         bdrv_delete(bs->backing_hd);
1012         bs->backing_hd = NULL;
1013         bs_rw = bdrv_new("");
1014         rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR,
1015             backing_drv);
1016         if (rw_ret < 0) {
1017             bdrv_delete(bs_rw);
1018             /* try to re-open read-only */
1019             bs_ro = bdrv_new("");
1020             ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
1021                 backing_drv);
1022             if (ret < 0) {
1023                 bdrv_delete(bs_ro);
1024                 /* drive not functional anymore */
1025                 bs->drv = NULL;
1026                 return ret;
1027             }
1028             bs->backing_hd = bs_ro;
1029             return rw_ret;
1030         }
1031         bs->backing_hd = bs_rw;
1032     }
1033
1034     total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
1035     buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
1036
1037     for (sector = 0; sector < total_sectors; sector += n) {
1038         if (bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
1039
1040             if (bdrv_read(bs, sector, buf, n) != 0) {
1041                 ret = -EIO;
1042                 goto ro_cleanup;
1043             }
1044
1045             if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
1046                 ret = -EIO;
1047                 goto ro_cleanup;
1048             }
1049         }
1050     }
1051
1052     if (drv->bdrv_make_empty) {
1053         ret = drv->bdrv_make_empty(bs);
1054         bdrv_flush(bs);
1055     }
1056
1057     /*
1058      * Make sure all data we wrote to the backing device is actually
1059      * stable on disk.
1060      */
1061     if (bs->backing_hd)
1062         bdrv_flush(bs->backing_hd);
1063
1064 ro_cleanup:
1065     g_free(buf);
1066
1067     if (ro) {
1068         /* re-open as RO */
1069         bdrv_delete(bs->backing_hd);
1070         bs->backing_hd = NULL;
1071         bs_ro = bdrv_new("");
1072         ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
1073             backing_drv);
1074         if (ret < 0) {
1075             bdrv_delete(bs_ro);
1076             /* drive not functional anymore */
1077             bs->drv = NULL;
1078             return ret;
1079         }
1080         bs->backing_hd = bs_ro;
1081         bs->backing_hd->keep_read_only = 0;
1082     }
1083
1084     return ret;
1085 }
1086
1087 void bdrv_commit_all(void)
1088 {
1089     BlockDriverState *bs;
1090
1091     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1092         bdrv_commit(bs);
1093     }
1094 }
1095
1096 struct BdrvTrackedRequest {
1097     BlockDriverState *bs;
1098     int64_t sector_num;
1099     int nb_sectors;
1100     bool is_write;
1101     QLIST_ENTRY(BdrvTrackedRequest) list;
1102     CoQueue wait_queue; /* coroutines blocked on this request */
1103 };
1104
1105 /**
1106  * Remove an active request from the tracked requests list
1107  *
1108  * This function should be called when a tracked request is completing.
1109  */
1110 static void tracked_request_end(BdrvTrackedRequest *req)
1111 {
1112     QLIST_REMOVE(req, list);
1113     qemu_co_queue_restart_all(&req->wait_queue);
1114 }
1115
1116 /**
1117  * Add an active request to the tracked requests list
1118  */
1119 static void tracked_request_begin(BdrvTrackedRequest *req,
1120                                   BlockDriverState *bs,
1121                                   int64_t sector_num,
1122                                   int nb_sectors, bool is_write)
1123 {
1124     *req = (BdrvTrackedRequest){
1125         .bs = bs,
1126         .sector_num = sector_num,
1127         .nb_sectors = nb_sectors,
1128         .is_write = is_write,
1129     };
1130
1131     qemu_co_queue_init(&req->wait_queue);
1132
1133     QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
1134 }
1135
1136 /**
1137  * Round a region to cluster boundaries
1138  */
1139 static void round_to_clusters(BlockDriverState *bs,
1140                               int64_t sector_num, int nb_sectors,
1141                               int64_t *cluster_sector_num,
1142                               int *cluster_nb_sectors)
1143 {
1144     BlockDriverInfo bdi;
1145
1146     if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
1147         *cluster_sector_num = sector_num;
1148         *cluster_nb_sectors = nb_sectors;
1149     } else {
1150         int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
1151         *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
1152         *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
1153                                             nb_sectors, c);
1154     }
1155 }
1156
1157 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
1158                                      int64_t sector_num, int nb_sectors) {
1159     /*        aaaa   bbbb */
1160     if (sector_num >= req->sector_num + req->nb_sectors) {
1161         return false;
1162     }
1163     /* bbbb   aaaa        */
1164     if (req->sector_num >= sector_num + nb_sectors) {
1165         return false;
1166     }
1167     return true;
1168 }
1169
1170 static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
1171         int64_t sector_num, int nb_sectors)
1172 {
1173     BdrvTrackedRequest *req;
1174     int64_t cluster_sector_num;
1175     int cluster_nb_sectors;
1176     bool retry;
1177
1178     /* If we touch the same cluster it counts as an overlap.  This guarantees
1179      * that allocating writes will be serialized and not race with each other
1180      * for the same cluster.  For example, in copy-on-read it ensures that the
1181      * CoR read and write operations are atomic and guest writes cannot
1182      * interleave between them.
1183      */
1184     round_to_clusters(bs, sector_num, nb_sectors,
1185                       &cluster_sector_num, &cluster_nb_sectors);
1186
1187     do {
1188         retry = false;
1189         QLIST_FOREACH(req, &bs->tracked_requests, list) {
1190             if (tracked_request_overlaps(req, cluster_sector_num,
1191                                          cluster_nb_sectors)) {
1192                 qemu_co_queue_wait(&req->wait_queue);
1193                 retry = true;
1194                 break;
1195             }
1196         }
1197     } while (retry);
1198 }
1199
1200 /*
1201  * Return values:
1202  * 0        - success
1203  * -EINVAL  - backing format specified, but no file
1204  * -ENOSPC  - can't update the backing file because no space is left in the
1205  *            image file header
1206  * -ENOTSUP - format driver doesn't support changing the backing file
1207  */
1208 int bdrv_change_backing_file(BlockDriverState *bs,
1209     const char *backing_file, const char *backing_fmt)
1210 {
1211     BlockDriver *drv = bs->drv;
1212
1213     if (drv->bdrv_change_backing_file != NULL) {
1214         return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
1215     } else {
1216         return -ENOTSUP;
1217     }
1218 }
1219
1220 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
1221                                    size_t size)
1222 {
1223     int64_t len;
1224
1225     if (!bdrv_is_inserted(bs))
1226         return -ENOMEDIUM;
1227
1228     if (bs->growable)
1229         return 0;
1230
1231     len = bdrv_getlength(bs);
1232
1233     if (offset < 0)
1234         return -EIO;
1235
1236     if ((offset > len) || (len - offset < size))
1237         return -EIO;
1238
1239     return 0;
1240 }
1241
1242 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
1243                               int nb_sectors)
1244 {
1245     return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
1246                                    nb_sectors * BDRV_SECTOR_SIZE);
1247 }
1248
1249 typedef struct RwCo {
1250     BlockDriverState *bs;
1251     int64_t sector_num;
1252     int nb_sectors;
1253     QEMUIOVector *qiov;
1254     bool is_write;
1255     int ret;
1256 } RwCo;
1257
1258 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
1259 {
1260     RwCo *rwco = opaque;
1261
1262     if (!rwco->is_write) {
1263         rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
1264                                      rwco->nb_sectors, rwco->qiov);
1265     } else {
1266         rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
1267                                       rwco->nb_sectors, rwco->qiov);
1268     }
1269 }
1270
1271 /*
1272  * Process a synchronous request using coroutines
1273  */
1274 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
1275                       int nb_sectors, bool is_write)
1276 {
1277     QEMUIOVector qiov;
1278     struct iovec iov = {
1279         .iov_base = (void *)buf,
1280         .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
1281     };
1282     Coroutine *co;
1283     RwCo rwco = {
1284         .bs = bs,
1285         .sector_num = sector_num,
1286         .nb_sectors = nb_sectors,
1287         .qiov = &qiov,
1288         .is_write = is_write,
1289         .ret = NOT_DONE,
1290     };
1291
1292     qemu_iovec_init_external(&qiov, &iov, 1);
1293
1294     if (qemu_in_coroutine()) {
1295         /* Fast-path if already in coroutine context */
1296         bdrv_rw_co_entry(&rwco);
1297     } else {
1298         co = qemu_coroutine_create(bdrv_rw_co_entry);
1299         qemu_coroutine_enter(co, &rwco);
1300         while (rwco.ret == NOT_DONE) {
1301             qemu_aio_wait();
1302         }
1303     }
1304     return rwco.ret;
1305 }
1306
1307 /* return < 0 if error. See bdrv_write() for the return codes */
1308 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
1309               uint8_t *buf, int nb_sectors)
1310 {
1311     return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false);
1312 }
1313
1314 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
1315                              int nb_sectors, int dirty)
1316 {
1317     int64_t start, end;
1318     unsigned long val, idx, bit;
1319
1320     start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
1321     end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
1322
1323     for (; start <= end; start++) {
1324         idx = start / (sizeof(unsigned long) * 8);
1325         bit = start % (sizeof(unsigned long) * 8);
1326         val = bs->dirty_bitmap[idx];
1327         if (dirty) {
1328             if (!(val & (1UL << bit))) {
1329                 bs->dirty_count++;
1330                 val |= 1UL << bit;
1331             }
1332         } else {
1333             if (val & (1UL << bit)) {
1334                 bs->dirty_count--;
1335                 val &= ~(1UL << bit);
1336             }
1337         }
1338         bs->dirty_bitmap[idx] = val;
1339     }
1340 }
1341
1342 /* Return < 0 if error. Important errors are:
1343   -EIO         generic I/O error (may happen for all errors)
1344   -ENOMEDIUM   No media inserted.
1345   -EINVAL      Invalid sector number or nb_sectors
1346   -EACCES      Trying to write a read-only device
1347 */
1348 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
1349                const uint8_t *buf, int nb_sectors)
1350 {
1351     return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
1352 }
1353
1354 int bdrv_pread(BlockDriverState *bs, int64_t offset,
1355                void *buf, int count1)
1356 {
1357     uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1358     int len, nb_sectors, count;
1359     int64_t sector_num;
1360     int ret;
1361
1362     count = count1;
1363     /* first read to align to sector start */
1364     len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1365     if (len > count)
1366         len = count;
1367     sector_num = offset >> BDRV_SECTOR_BITS;
1368     if (len > 0) {
1369         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1370             return ret;
1371         memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
1372         count -= len;
1373         if (count == 0)
1374             return count1;
1375         sector_num++;
1376         buf += len;
1377     }
1378
1379     /* read the sectors "in place" */
1380     nb_sectors = count >> BDRV_SECTOR_BITS;
1381     if (nb_sectors > 0) {
1382         if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1383             return ret;
1384         sector_num += nb_sectors;
1385         len = nb_sectors << BDRV_SECTOR_BITS;
1386         buf += len;
1387         count -= len;
1388     }
1389
1390     /* add data from the last sector */
1391     if (count > 0) {
1392         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1393             return ret;
1394         memcpy(buf, tmp_buf, count);
1395     }
1396     return count1;
1397 }
1398
1399 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1400                 const void *buf, int count1)
1401 {
1402     uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1403     int len, nb_sectors, count;
1404     int64_t sector_num;
1405     int ret;
1406
1407     count = count1;
1408     /* first write to align to sector start */
1409     len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1410     if (len > count)
1411         len = count;
1412     sector_num = offset >> BDRV_SECTOR_BITS;
1413     if (len > 0) {
1414         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1415             return ret;
1416         memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1417         if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1418             return ret;
1419         count -= len;
1420         if (count == 0)
1421             return count1;
1422         sector_num++;
1423         buf += len;
1424     }
1425
1426     /* write the sectors "in place" */
1427     nb_sectors = count >> BDRV_SECTOR_BITS;
1428     if (nb_sectors > 0) {
1429         if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1430             return ret;
1431         sector_num += nb_sectors;
1432         len = nb_sectors << BDRV_SECTOR_BITS;
1433         buf += len;
1434         count -= len;
1435     }
1436
1437     /* add data from the last sector */
1438     if (count > 0) {
1439         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1440             return ret;
1441         memcpy(tmp_buf, buf, count);
1442         if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1443             return ret;
1444     }
1445     return count1;
1446 }
1447
1448 /*
1449  * Writes to the file and ensures that no writes are reordered across this
1450  * request (acts as a barrier)
1451  *
1452  * Returns 0 on success, -errno in error cases.
1453  */
1454 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1455     const void *buf, int count)
1456 {
1457     int ret;
1458
1459     ret = bdrv_pwrite(bs, offset, buf, count);
1460     if (ret < 0) {
1461         return ret;
1462     }
1463
1464     /* No flush needed for cache modes that use O_DSYNC */
1465     if ((bs->open_flags & BDRV_O_CACHE_WB) != 0) {
1466         bdrv_flush(bs);
1467     }
1468
1469     return 0;
1470 }
1471
1472 static int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
1473         int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
1474 {
1475     /* Perform I/O through a temporary buffer so that users who scribble over
1476      * their read buffer while the operation is in progress do not end up
1477      * modifying the image file.  This is critical for zero-copy guest I/O
1478      * where anything might happen inside guest memory.
1479      */
1480     void *bounce_buffer;
1481
1482     struct iovec iov;
1483     QEMUIOVector bounce_qiov;
1484     int64_t cluster_sector_num;
1485     int cluster_nb_sectors;
1486     size_t skip_bytes;
1487     int ret;
1488
1489     /* Cover entire cluster so no additional backing file I/O is required when
1490      * allocating cluster in the image file.
1491      */
1492     round_to_clusters(bs, sector_num, nb_sectors,
1493                       &cluster_sector_num, &cluster_nb_sectors);
1494
1495     trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors,
1496                                 cluster_sector_num, cluster_nb_sectors);
1497
1498     iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
1499     iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
1500     qemu_iovec_init_external(&bounce_qiov, &iov, 1);
1501
1502     ret = bs->drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
1503                                  &bounce_qiov);
1504     if (ret < 0) {
1505         goto err;
1506     }
1507
1508     ret = bs->drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
1509                                   &bounce_qiov);
1510     if (ret < 0) {
1511         /* It might be okay to ignore write errors for guest requests.  If this
1512          * is a deliberate copy-on-read then we don't want to ignore the error.
1513          * Simply report it in all cases.
1514          */
1515         goto err;
1516     }
1517
1518     skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
1519     qemu_iovec_from_buffer(qiov, bounce_buffer + skip_bytes,
1520                            nb_sectors * BDRV_SECTOR_SIZE);
1521
1522 err:
1523     qemu_vfree(bounce_buffer);
1524     return ret;
1525 }
1526
1527 /*
1528  * Handle a read request in coroutine context
1529  */
1530 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
1531     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
1532 {
1533     BlockDriver *drv = bs->drv;
1534     BdrvTrackedRequest req;
1535     int ret;
1536
1537     if (!drv) {
1538         return -ENOMEDIUM;
1539     }
1540     if (bdrv_check_request(bs, sector_num, nb_sectors)) {
1541         return -EIO;
1542     }
1543
1544     /* throttling disk read I/O */
1545     if (bs->io_limits_enabled) {
1546         bdrv_io_limits_intercept(bs, false, nb_sectors);
1547     }
1548
1549     if (bs->copy_on_read) {
1550         wait_for_overlapping_requests(bs, sector_num, nb_sectors);
1551     }
1552
1553     tracked_request_begin(&req, bs, sector_num, nb_sectors, false);
1554
1555     if (bs->copy_on_read) {
1556         int pnum;
1557
1558         ret = bdrv_co_is_allocated(bs, sector_num, nb_sectors, &pnum);
1559         if (ret < 0) {
1560             goto out;
1561         }
1562
1563         if (!ret || pnum != nb_sectors) {
1564             ret = bdrv_co_copy_on_readv(bs, sector_num, nb_sectors, qiov);
1565             goto out;
1566         }
1567     }
1568
1569     ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
1570
1571 out:
1572     tracked_request_end(&req);
1573     return ret;
1574 }
1575
1576 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
1577     int nb_sectors, QEMUIOVector *qiov)
1578 {
1579     trace_bdrv_co_readv(bs, sector_num, nb_sectors);
1580
1581     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov);
1582 }
1583
1584 /*
1585  * Handle a write request in coroutine context
1586  */
1587 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
1588     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
1589 {
1590     BlockDriver *drv = bs->drv;
1591     BdrvTrackedRequest req;
1592     int ret;
1593
1594     if (!bs->drv) {
1595         return -ENOMEDIUM;
1596     }
1597     if (bs->read_only) {
1598         return -EACCES;
1599     }
1600     if (bdrv_check_request(bs, sector_num, nb_sectors)) {
1601         return -EIO;
1602     }
1603
1604     /* throttling disk write I/O */
1605     if (bs->io_limits_enabled) {
1606         bdrv_io_limits_intercept(bs, true, nb_sectors);
1607     }
1608
1609     if (bs->copy_on_read) {
1610         wait_for_overlapping_requests(bs, sector_num, nb_sectors);
1611     }
1612
1613     tracked_request_begin(&req, bs, sector_num, nb_sectors, true);
1614
1615     ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
1616
1617     if (bs->dirty_bitmap) {
1618         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1619     }
1620
1621     if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
1622         bs->wr_highest_sector = sector_num + nb_sectors - 1;
1623     }
1624
1625     tracked_request_end(&req);
1626
1627     return ret;
1628 }
1629
1630 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
1631     int nb_sectors, QEMUIOVector *qiov)
1632 {
1633     trace_bdrv_co_writev(bs, sector_num, nb_sectors);
1634
1635     return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov);
1636 }
1637
1638 /**
1639  * Truncate file to 'offset' bytes (needed only for file protocols)
1640  */
1641 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1642 {
1643     BlockDriver *drv = bs->drv;
1644     int ret;
1645     if (!drv)
1646         return -ENOMEDIUM;
1647     if (!drv->bdrv_truncate)
1648         return -ENOTSUP;
1649     if (bs->read_only)
1650         return -EACCES;
1651     if (bdrv_in_use(bs))
1652         return -EBUSY;
1653     ret = drv->bdrv_truncate(bs, offset);
1654     if (ret == 0) {
1655         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1656         bdrv_dev_resize_cb(bs);
1657     }
1658     return ret;
1659 }
1660
1661 /**
1662  * Length of a allocated file in bytes. Sparse files are counted by actual
1663  * allocated space. Return < 0 if error or unknown.
1664  */
1665 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
1666 {
1667     BlockDriver *drv = bs->drv;
1668     if (!drv) {
1669         return -ENOMEDIUM;
1670     }
1671     if (drv->bdrv_get_allocated_file_size) {
1672         return drv->bdrv_get_allocated_file_size(bs);
1673     }
1674     if (bs->file) {
1675         return bdrv_get_allocated_file_size(bs->file);
1676     }
1677     return -ENOTSUP;
1678 }
1679
1680 /**
1681  * Length of a file in bytes. Return < 0 if error or unknown.
1682  */
1683 int64_t bdrv_getlength(BlockDriverState *bs)
1684 {
1685     BlockDriver *drv = bs->drv;
1686     if (!drv)
1687         return -ENOMEDIUM;
1688
1689     if (bs->growable || bdrv_dev_has_removable_media(bs)) {
1690         if (drv->bdrv_getlength) {
1691             return drv->bdrv_getlength(bs);
1692         }
1693     }
1694     return bs->total_sectors * BDRV_SECTOR_SIZE;
1695 }
1696
1697 /* return 0 as number of sectors if no device present or error */
1698 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1699 {
1700     int64_t length;
1701     length = bdrv_getlength(bs);
1702     if (length < 0)
1703         length = 0;
1704     else
1705         length = length >> BDRV_SECTOR_BITS;
1706     *nb_sectors_ptr = length;
1707 }
1708
1709 struct partition {
1710         uint8_t boot_ind;           /* 0x80 - active */
1711         uint8_t head;               /* starting head */
1712         uint8_t sector;             /* starting sector */
1713         uint8_t cyl;                /* starting cylinder */
1714         uint8_t sys_ind;            /* What partition type */
1715         uint8_t end_head;           /* end head */
1716         uint8_t end_sector;         /* end sector */
1717         uint8_t end_cyl;            /* end cylinder */
1718         uint32_t start_sect;        /* starting sector counting from 0 */
1719         uint32_t nr_sects;          /* nr of sectors in partition */
1720 } QEMU_PACKED;
1721
1722 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1723 static int guess_disk_lchs(BlockDriverState *bs,
1724                            int *pcylinders, int *pheads, int *psectors)
1725 {
1726     uint8_t buf[BDRV_SECTOR_SIZE];
1727     int ret, i, heads, sectors, cylinders;
1728     struct partition *p;
1729     uint32_t nr_sects;
1730     uint64_t nb_sectors;
1731
1732     bdrv_get_geometry(bs, &nb_sectors);
1733
1734     ret = bdrv_read(bs, 0, buf, 1);
1735     if (ret < 0)
1736         return -1;
1737     /* test msdos magic */
1738     if (buf[510] != 0x55 || buf[511] != 0xaa)
1739         return -1;
1740     for(i = 0; i < 4; i++) {
1741         p = ((struct partition *)(buf + 0x1be)) + i;
1742         nr_sects = le32_to_cpu(p->nr_sects);
1743         if (nr_sects && p->end_head) {
1744             /* We make the assumption that the partition terminates on
1745                a cylinder boundary */
1746             heads = p->end_head + 1;
1747             sectors = p->end_sector & 63;
1748             if (sectors == 0)
1749                 continue;
1750             cylinders = nb_sectors / (heads * sectors);
1751             if (cylinders < 1 || cylinders > 16383)
1752                 continue;
1753             *pheads = heads;
1754             *psectors = sectors;
1755             *pcylinders = cylinders;
1756 #if 0
1757             printf("guessed geometry: LCHS=%d %d %d\n",
1758                    cylinders, heads, sectors);
1759 #endif
1760             return 0;
1761         }
1762     }
1763     return -1;
1764 }
1765
1766 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1767 {
1768     int translation, lba_detected = 0;
1769     int cylinders, heads, secs;
1770     uint64_t nb_sectors;
1771
1772     /* if a geometry hint is available, use it */
1773     bdrv_get_geometry(bs, &nb_sectors);
1774     bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1775     translation = bdrv_get_translation_hint(bs);
1776     if (cylinders != 0) {
1777         *pcyls = cylinders;
1778         *pheads = heads;
1779         *psecs = secs;
1780     } else {
1781         if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1782             if (heads > 16) {
1783                 /* if heads > 16, it means that a BIOS LBA
1784                    translation was active, so the default
1785                    hardware geometry is OK */
1786                 lba_detected = 1;
1787                 goto default_geometry;
1788             } else {
1789                 *pcyls = cylinders;
1790                 *pheads = heads;
1791                 *psecs = secs;
1792                 /* disable any translation to be in sync with
1793                    the logical geometry */
1794                 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
1795                     bdrv_set_translation_hint(bs,
1796                                               BIOS_ATA_TRANSLATION_NONE);
1797                 }
1798             }
1799         } else {
1800         default_geometry:
1801             /* if no geometry, use a standard physical disk geometry */
1802             cylinders = nb_sectors / (16 * 63);
1803
1804             if (cylinders > 16383)
1805                 cylinders = 16383;
1806             else if (cylinders < 2)
1807                 cylinders = 2;
1808             *pcyls = cylinders;
1809             *pheads = 16;
1810             *psecs = 63;
1811             if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
1812                 if ((*pcyls * *pheads) <= 131072) {
1813                     bdrv_set_translation_hint(bs,
1814                                               BIOS_ATA_TRANSLATION_LARGE);
1815                 } else {
1816                     bdrv_set_translation_hint(bs,
1817                                               BIOS_ATA_TRANSLATION_LBA);
1818                 }
1819             }
1820         }
1821         bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1822     }
1823 }
1824
1825 void bdrv_set_geometry_hint(BlockDriverState *bs,
1826                             int cyls, int heads, int secs)
1827 {
1828     bs->cyls = cyls;
1829     bs->heads = heads;
1830     bs->secs = secs;
1831 }
1832
1833 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1834 {
1835     bs->translation = translation;
1836 }
1837
1838 void bdrv_get_geometry_hint(BlockDriverState *bs,
1839                             int *pcyls, int *pheads, int *psecs)
1840 {
1841     *pcyls = bs->cyls;
1842     *pheads = bs->heads;
1843     *psecs = bs->secs;
1844 }
1845
1846 /* throttling disk io limits */
1847 void bdrv_set_io_limits(BlockDriverState *bs,
1848                         BlockIOLimit *io_limits)
1849 {
1850     bs->io_limits = *io_limits;
1851     bs->io_limits_enabled = bdrv_io_limits_enabled(bs);
1852 }
1853
1854 /* Recognize floppy formats */
1855 typedef struct FDFormat {
1856     FDriveType drive;
1857     uint8_t last_sect;
1858     uint8_t max_track;
1859     uint8_t max_head;
1860 } FDFormat;
1861
1862 static const FDFormat fd_formats[] = {
1863     /* First entry is default format */
1864     /* 1.44 MB 3"1/2 floppy disks */
1865     { FDRIVE_DRV_144, 18, 80, 1, },
1866     { FDRIVE_DRV_144, 20, 80, 1, },
1867     { FDRIVE_DRV_144, 21, 80, 1, },
1868     { FDRIVE_DRV_144, 21, 82, 1, },
1869     { FDRIVE_DRV_144, 21, 83, 1, },
1870     { FDRIVE_DRV_144, 22, 80, 1, },
1871     { FDRIVE_DRV_144, 23, 80, 1, },
1872     { FDRIVE_DRV_144, 24, 80, 1, },
1873     /* 2.88 MB 3"1/2 floppy disks */
1874     { FDRIVE_DRV_288, 36, 80, 1, },
1875     { FDRIVE_DRV_288, 39, 80, 1, },
1876     { FDRIVE_DRV_288, 40, 80, 1, },
1877     { FDRIVE_DRV_288, 44, 80, 1, },
1878     { FDRIVE_DRV_288, 48, 80, 1, },
1879     /* 720 kB 3"1/2 floppy disks */
1880     { FDRIVE_DRV_144,  9, 80, 1, },
1881     { FDRIVE_DRV_144, 10, 80, 1, },
1882     { FDRIVE_DRV_144, 10, 82, 1, },
1883     { FDRIVE_DRV_144, 10, 83, 1, },
1884     { FDRIVE_DRV_144, 13, 80, 1, },
1885     { FDRIVE_DRV_144, 14, 80, 1, },
1886     /* 1.2 MB 5"1/4 floppy disks */
1887     { FDRIVE_DRV_120, 15, 80, 1, },
1888     { FDRIVE_DRV_120, 18, 80, 1, },
1889     { FDRIVE_DRV_120, 18, 82, 1, },
1890     { FDRIVE_DRV_120, 18, 83, 1, },
1891     { FDRIVE_DRV_120, 20, 80, 1, },
1892     /* 720 kB 5"1/4 floppy disks */
1893     { FDRIVE_DRV_120,  9, 80, 1, },
1894     { FDRIVE_DRV_120, 11, 80, 1, },
1895     /* 360 kB 5"1/4 floppy disks */
1896     { FDRIVE_DRV_120,  9, 40, 1, },
1897     { FDRIVE_DRV_120,  9, 40, 0, },
1898     { FDRIVE_DRV_120, 10, 41, 1, },
1899     { FDRIVE_DRV_120, 10, 42, 1, },
1900     /* 320 kB 5"1/4 floppy disks */
1901     { FDRIVE_DRV_120,  8, 40, 1, },
1902     { FDRIVE_DRV_120,  8, 40, 0, },
1903     /* 360 kB must match 5"1/4 better than 3"1/2... */
1904     { FDRIVE_DRV_144,  9, 80, 0, },
1905     /* end */
1906     { FDRIVE_DRV_NONE, -1, -1, 0, },
1907 };
1908
1909 void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
1910                                    int *max_track, int *last_sect,
1911                                    FDriveType drive_in, FDriveType *drive)
1912 {
1913     const FDFormat *parse;
1914     uint64_t nb_sectors, size;
1915     int i, first_match, match;
1916
1917     bdrv_get_geometry_hint(bs, nb_heads, max_track, last_sect);
1918     if (*nb_heads != 0 && *max_track != 0 && *last_sect != 0) {
1919         /* User defined disk */
1920     } else {
1921         bdrv_get_geometry(bs, &nb_sectors);
1922         match = -1;
1923         first_match = -1;
1924         for (i = 0; ; i++) {
1925             parse = &fd_formats[i];
1926             if (parse->drive == FDRIVE_DRV_NONE) {
1927                 break;
1928             }
1929             if (drive_in == parse->drive ||
1930                 drive_in == FDRIVE_DRV_NONE) {
1931                 size = (parse->max_head + 1) * parse->max_track *
1932                     parse->last_sect;
1933                 if (nb_sectors == size) {
1934                     match = i;
1935                     break;
1936                 }
1937                 if (first_match == -1) {
1938                     first_match = i;
1939                 }
1940             }
1941         }
1942         if (match == -1) {
1943             if (first_match == -1) {
1944                 match = 1;
1945             } else {
1946                 match = first_match;
1947             }
1948             parse = &fd_formats[match];
1949         }
1950         *nb_heads = parse->max_head + 1;
1951         *max_track = parse->max_track;
1952         *last_sect = parse->last_sect;
1953         *drive = parse->drive;
1954     }
1955 }
1956
1957 int bdrv_get_translation_hint(BlockDriverState *bs)
1958 {
1959     return bs->translation;
1960 }
1961
1962 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1963                        BlockErrorAction on_write_error)
1964 {
1965     bs->on_read_error = on_read_error;
1966     bs->on_write_error = on_write_error;
1967 }
1968
1969 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
1970 {
1971     return is_read ? bs->on_read_error : bs->on_write_error;
1972 }
1973
1974 int bdrv_is_read_only(BlockDriverState *bs)
1975 {
1976     return bs->read_only;
1977 }
1978
1979 int bdrv_is_sg(BlockDriverState *bs)
1980 {
1981     return bs->sg;
1982 }
1983
1984 int bdrv_enable_write_cache(BlockDriverState *bs)
1985 {
1986     return bs->enable_write_cache;
1987 }
1988
1989 int bdrv_is_encrypted(BlockDriverState *bs)
1990 {
1991     if (bs->backing_hd && bs->backing_hd->encrypted)
1992         return 1;
1993     return bs->encrypted;
1994 }
1995
1996 int bdrv_key_required(BlockDriverState *bs)
1997 {
1998     BlockDriverState *backing_hd = bs->backing_hd;
1999
2000     if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2001         return 1;
2002     return (bs->encrypted && !bs->valid_key);
2003 }
2004
2005 int bdrv_set_key(BlockDriverState *bs, const char *key)
2006 {
2007     int ret;
2008     if (bs->backing_hd && bs->backing_hd->encrypted) {
2009         ret = bdrv_set_key(bs->backing_hd, key);
2010         if (ret < 0)
2011             return ret;
2012         if (!bs->encrypted)
2013             return 0;
2014     }
2015     if (!bs->encrypted) {
2016         return -EINVAL;
2017     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2018         return -ENOMEDIUM;
2019     }
2020     ret = bs->drv->bdrv_set_key(bs, key);
2021     if (ret < 0) {
2022         bs->valid_key = 0;
2023     } else if (!bs->valid_key) {
2024         bs->valid_key = 1;
2025         /* call the change callback now, we skipped it on open */
2026         bdrv_dev_change_media_cb(bs, true);
2027     }
2028     return ret;
2029 }
2030
2031 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
2032 {
2033     if (!bs->drv) {
2034         buf[0] = '\0';
2035     } else {
2036         pstrcpy(buf, buf_size, bs->drv->format_name);
2037     }
2038 }
2039
2040 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2041                          void *opaque)
2042 {
2043     BlockDriver *drv;
2044
2045     QLIST_FOREACH(drv, &bdrv_drivers, list) {
2046         it(opaque, drv->format_name);
2047     }
2048 }
2049
2050 BlockDriverState *bdrv_find(const char *name)
2051 {
2052     BlockDriverState *bs;
2053
2054     QTAILQ_FOREACH(bs, &bdrv_states, list) {
2055         if (!strcmp(name, bs->device_name)) {
2056             return bs;
2057         }
2058     }
2059     return NULL;
2060 }
2061
2062 BlockDriverState *bdrv_next(BlockDriverState *bs)
2063 {
2064     if (!bs) {
2065         return QTAILQ_FIRST(&bdrv_states);
2066     }
2067     return QTAILQ_NEXT(bs, list);
2068 }
2069
2070 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
2071 {
2072     BlockDriverState *bs;
2073
2074     QTAILQ_FOREACH(bs, &bdrv_states, list) {
2075         it(opaque, bs);
2076     }
2077 }
2078
2079 const char *bdrv_get_device_name(BlockDriverState *bs)
2080 {
2081     return bs->device_name;
2082 }
2083
2084 void bdrv_flush_all(void)
2085 {
2086     BlockDriverState *bs;
2087
2088     QTAILQ_FOREACH(bs, &bdrv_states, list) {
2089         if (!bdrv_is_read_only(bs) && bdrv_is_inserted(bs)) {
2090             bdrv_flush(bs);
2091         }
2092     }
2093 }
2094
2095 int bdrv_has_zero_init(BlockDriverState *bs)
2096 {
2097     assert(bs->drv);
2098
2099     if (bs->drv->bdrv_has_zero_init) {
2100         return bs->drv->bdrv_has_zero_init(bs);
2101     }
2102
2103     return 1;
2104 }
2105
2106 typedef struct BdrvCoIsAllocatedData {
2107     BlockDriverState *bs;
2108     int64_t sector_num;
2109     int nb_sectors;
2110     int *pnum;
2111     int ret;
2112     bool done;
2113 } BdrvCoIsAllocatedData;
2114
2115 /*
2116  * Returns true iff the specified sector is present in the disk image. Drivers
2117  * not implementing the functionality are assumed to not support backing files,
2118  * hence all their sectors are reported as allocated.
2119  *
2120  * 'pnum' is set to the number of sectors (including and immediately following
2121  * the specified sector) that are known to be in the same
2122  * allocated/unallocated state.
2123  *
2124  * 'nb_sectors' is the max value 'pnum' should be set to.
2125  */
2126 int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
2127                                       int nb_sectors, int *pnum)
2128 {
2129     if (!bs->drv->bdrv_co_is_allocated) {
2130         int64_t n;
2131         if (sector_num >= bs->total_sectors) {
2132             *pnum = 0;
2133             return 0;
2134         }
2135         n = bs->total_sectors - sector_num;
2136         *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
2137         return 1;
2138     }
2139
2140     return bs->drv->bdrv_co_is_allocated(bs, sector_num, nb_sectors, pnum);
2141 }
2142
2143 /* Coroutine wrapper for bdrv_is_allocated() */
2144 static void coroutine_fn bdrv_is_allocated_co_entry(void *opaque)
2145 {
2146     BdrvCoIsAllocatedData *data = opaque;
2147     BlockDriverState *bs = data->bs;
2148
2149     data->ret = bdrv_co_is_allocated(bs, data->sector_num, data->nb_sectors,
2150                                      data->pnum);
2151     data->done = true;
2152 }
2153
2154 /*
2155  * Synchronous wrapper around bdrv_co_is_allocated().
2156  *
2157  * See bdrv_co_is_allocated() for details.
2158  */
2159 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2160                       int *pnum)
2161 {
2162     Coroutine *co;
2163     BdrvCoIsAllocatedData data = {
2164         .bs = bs,
2165         .sector_num = sector_num,
2166         .nb_sectors = nb_sectors,
2167         .pnum = pnum,
2168         .done = false,
2169     };
2170
2171     co = qemu_coroutine_create(bdrv_is_allocated_co_entry);
2172     qemu_coroutine_enter(co, &data);
2173     while (!data.done) {
2174         qemu_aio_wait();
2175     }
2176     return data.ret;
2177 }
2178
2179 void bdrv_mon_event(const BlockDriverState *bdrv,
2180                     BlockMonEventAction action, int is_read)
2181 {
2182     QObject *data;
2183     const char *action_str;
2184
2185     switch (action) {
2186     case BDRV_ACTION_REPORT:
2187         action_str = "report";
2188         break;
2189     case BDRV_ACTION_IGNORE:
2190         action_str = "ignore";
2191         break;
2192     case BDRV_ACTION_STOP:
2193         action_str = "stop";
2194         break;
2195     default:
2196         abort();
2197     }
2198
2199     data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
2200                               bdrv->device_name,
2201                               action_str,
2202                               is_read ? "read" : "write");
2203     monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);
2204
2205     qobject_decref(data);
2206 }
2207
2208 BlockInfoList *qmp_query_block(Error **errp)
2209 {
2210     BlockInfoList *head = NULL, *cur_item = NULL;
2211     BlockDriverState *bs;
2212
2213     QTAILQ_FOREACH(bs, &bdrv_states, list) {
2214         BlockInfoList *info = g_malloc0(sizeof(*info));
2215
2216         info->value = g_malloc0(sizeof(*info->value));
2217         info->value->device = g_strdup(bs->device_name);
2218         info->value->type = g_strdup("unknown");
2219         info->value->locked = bdrv_dev_is_medium_locked(bs);
2220         info->value->removable = bdrv_dev_has_removable_media(bs);
2221
2222         if (bdrv_dev_has_removable_media(bs)) {
2223             info->value->has_tray_open = true;
2224             info->value->tray_open = bdrv_dev_is_tray_open(bs);
2225         }
2226
2227         if (bdrv_iostatus_is_enabled(bs)) {
2228             info->value->has_io_status = true;
2229             info->value->io_status = bs->iostatus;
2230         }
2231
2232         if (bs->drv) {
2233             info->value->has_inserted = true;
2234             info->value->inserted = g_malloc0(sizeof(*info->value->inserted));
2235             info->value->inserted->file = g_strdup(bs->filename);
2236             info->value->inserted->ro = bs->read_only;
2237             info->value->inserted->drv = g_strdup(bs->drv->format_name);
2238             info->value->inserted->encrypted = bs->encrypted;
2239             if (bs->backing_file[0]) {
2240                 info->value->inserted->has_backing_file = true;
2241                 info->value->inserted->backing_file = g_strdup(bs->backing_file);
2242             }
2243
2244             if (bs->io_limits_enabled) {
2245                 info->value->inserted->bps =
2246                                bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
2247                 info->value->inserted->bps_rd =
2248                                bs->io_limits.bps[BLOCK_IO_LIMIT_READ];
2249                 info->value->inserted->bps_wr =
2250                                bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE];
2251                 info->value->inserted->iops =
2252                                bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
2253                 info->value->inserted->iops_rd =
2254                                bs->io_limits.iops[BLOCK_IO_LIMIT_READ];
2255                 info->value->inserted->iops_wr =
2256                                bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE];
2257             }
2258         }
2259
2260         /* XXX: waiting for the qapi to support GSList */
2261         if (!cur_item) {
2262             head = cur_item = info;
2263         } else {
2264             cur_item->next = info;
2265             cur_item = info;
2266         }
2267     }
2268
2269     return head;
2270 }
2271
2272 /* Consider exposing this as a full fledged QMP command */
2273 static BlockStats *qmp_query_blockstat(const BlockDriverState *bs, Error **errp)
2274 {
2275     BlockStats *s;
2276
2277     s = g_malloc0(sizeof(*s));
2278
2279     if (bs->device_name[0]) {
2280         s->has_device = true;
2281         s->device = g_strdup(bs->device_name);
2282     }
2283
2284     s->stats = g_malloc0(sizeof(*s->stats));
2285     s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ];
2286     s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE];
2287     s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ];
2288     s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE];
2289     s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE;
2290     s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH];
2291     s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE];
2292     s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ];
2293     s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH];
2294
2295     if (bs->file) {
2296         s->has_parent = true;
2297         s->parent = qmp_query_blockstat(bs->file, NULL);
2298     }
2299
2300     return s;
2301 }
2302
2303 BlockStatsList *qmp_query_blockstats(Error **errp)
2304 {
2305     BlockStatsList *head = NULL, *cur_item = NULL;
2306     BlockDriverState *bs;
2307
2308     QTAILQ_FOREACH(bs, &bdrv_states, list) {
2309         BlockStatsList *info = g_malloc0(sizeof(*info));
2310         info->value = qmp_query_blockstat(bs, NULL);
2311
2312         /* XXX: waiting for the qapi to support GSList */
2313         if (!cur_item) {
2314             head = cur_item = info;
2315         } else {
2316             cur_item->next = info;
2317             cur_item = info;
2318         }
2319     }
2320
2321     return head;
2322 }
2323
2324 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2325 {
2326     if (bs->backing_hd && bs->backing_hd->encrypted)
2327         return bs->backing_file;
2328     else if (bs->encrypted)
2329         return bs->filename;
2330     else
2331         return NULL;
2332 }
2333
2334 void bdrv_get_backing_filename(BlockDriverState *bs,
2335                                char *filename, int filename_size)
2336 {
2337     pstrcpy(filename, filename_size, bs->backing_file);
2338 }
2339
2340 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
2341                           const uint8_t *buf, int nb_sectors)
2342 {
2343     BlockDriver *drv = bs->drv;
2344     if (!drv)
2345         return -ENOMEDIUM;
2346     if (!drv->bdrv_write_compressed)
2347         return -ENOTSUP;
2348     if (bdrv_check_request(bs, sector_num, nb_sectors))
2349         return -EIO;
2350
2351     if (bs->dirty_bitmap) {
2352         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2353     }
2354
2355     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
2356 }
2357
2358 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2359 {
2360     BlockDriver *drv = bs->drv;
2361     if (!drv)
2362         return -ENOMEDIUM;
2363     if (!drv->bdrv_get_info)
2364         return -ENOTSUP;
2365     memset(bdi, 0, sizeof(*bdi));
2366     return drv->bdrv_get_info(bs, bdi);
2367 }
2368
2369 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
2370                       int64_t pos, int size)
2371 {
2372     BlockDriver *drv = bs->drv;
2373     if (!drv)
2374         return -ENOMEDIUM;
2375     if (drv->bdrv_save_vmstate)
2376         return drv->bdrv_save_vmstate(bs, buf, pos, size);
2377     if (bs->file)
2378         return bdrv_save_vmstate(bs->file, buf, pos, size);
2379     return -ENOTSUP;
2380 }
2381
2382 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
2383                       int64_t pos, int size)
2384 {
2385     BlockDriver *drv = bs->drv;
2386     if (!drv)
2387         return -ENOMEDIUM;
2388     if (drv->bdrv_load_vmstate)
2389         return drv->bdrv_load_vmstate(bs, buf, pos, size);
2390     if (bs->file)
2391         return bdrv_load_vmstate(bs->file, buf, pos, size);
2392     return -ENOTSUP;
2393 }
2394
2395 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2396 {
2397     BlockDriver *drv = bs->drv;
2398
2399     if (!drv || !drv->bdrv_debug_event) {
2400         return;
2401     }
2402
2403     return drv->bdrv_debug_event(bs, event);
2404
2405 }
2406
2407 /**************************************************************/
2408 /* handling of snapshots */
2409
2410 int bdrv_can_snapshot(BlockDriverState *bs)
2411 {
2412     BlockDriver *drv = bs->drv;
2413     if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2414         return 0;
2415     }
2416
2417     if (!drv->bdrv_snapshot_create) {
2418         if (bs->file != NULL) {
2419             return bdrv_can_snapshot(bs->file);
2420         }
2421         return 0;
2422     }
2423
2424     return 1;
2425 }
2426
2427 int bdrv_is_snapshot(BlockDriverState *bs)
2428 {
2429     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
2430 }
2431
2432 BlockDriverState *bdrv_snapshots(void)
2433 {
2434     BlockDriverState *bs;
2435
2436     if (bs_snapshots) {
2437         return bs_snapshots;
2438     }
2439
2440     bs = NULL;
2441     while ((bs = bdrv_next(bs))) {
2442         if (bdrv_can_snapshot(bs)) {
2443             bs_snapshots = bs;
2444             return bs;
2445         }
2446     }
2447     return NULL;
2448 }
2449
2450 int bdrv_snapshot_create(BlockDriverState *bs,
2451                          QEMUSnapshotInfo *sn_info)
2452 {
2453     BlockDriver *drv = bs->drv;
2454     if (!drv)
2455         return -ENOMEDIUM;
2456     if (drv->bdrv_snapshot_create)
2457         return drv->bdrv_snapshot_create(bs, sn_info);
2458     if (bs->file)
2459         return bdrv_snapshot_create(bs->file, sn_info);
2460     return -ENOTSUP;
2461 }
2462
2463 int bdrv_snapshot_goto(BlockDriverState *bs,
2464                        const char *snapshot_id)
2465 {
2466     BlockDriver *drv = bs->drv;
2467     int ret, open_ret;
2468
2469     if (!drv)
2470         return -ENOMEDIUM;
2471     if (drv->bdrv_snapshot_goto)
2472         return drv->bdrv_snapshot_goto(bs, snapshot_id);
2473
2474     if (bs->file) {
2475         drv->bdrv_close(bs);
2476         ret = bdrv_snapshot_goto(bs->file, snapshot_id);
2477         open_ret = drv->bdrv_open(bs, bs->open_flags);
2478         if (open_ret < 0) {
2479             bdrv_delete(bs->file);
2480             bs->drv = NULL;
2481             return open_ret;
2482         }
2483         return ret;
2484     }
2485
2486     return -ENOTSUP;
2487 }
2488
2489 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
2490 {
2491     BlockDriver *drv = bs->drv;
2492     if (!drv)
2493         return -ENOMEDIUM;
2494     if (drv->bdrv_snapshot_delete)
2495         return drv->bdrv_snapshot_delete(bs, snapshot_id);
2496     if (bs->file)
2497         return bdrv_snapshot_delete(bs->file, snapshot_id);
2498     return -ENOTSUP;
2499 }
2500
2501 int bdrv_snapshot_list(BlockDriverState *bs,
2502                        QEMUSnapshotInfo **psn_info)
2503 {
2504     BlockDriver *drv = bs->drv;
2505     if (!drv)
2506         return -ENOMEDIUM;
2507     if (drv->bdrv_snapshot_list)
2508         return drv->bdrv_snapshot_list(bs, psn_info);
2509     if (bs->file)
2510         return bdrv_snapshot_list(bs->file, psn_info);
2511     return -ENOTSUP;
2512 }
2513
2514 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
2515         const char *snapshot_name)
2516 {
2517     BlockDriver *drv = bs->drv;
2518     if (!drv) {
2519         return -ENOMEDIUM;
2520     }
2521     if (!bs->read_only) {
2522         return -EINVAL;
2523     }
2524     if (drv->bdrv_snapshot_load_tmp) {
2525         return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
2526     }
2527     return -ENOTSUP;
2528 }
2529
2530 #define NB_SUFFIXES 4
2531
2532 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
2533 {
2534     static const char suffixes[NB_SUFFIXES] = "KMGT";
2535     int64_t base;
2536     int i;
2537
2538     if (size <= 999) {
2539         snprintf(buf, buf_size, "%" PRId64, size);
2540     } else {
2541         base = 1024;
2542         for(i = 0; i < NB_SUFFIXES; i++) {
2543             if (size < (10 * base)) {
2544                 snprintf(buf, buf_size, "%0.1f%c",
2545                          (double)size / base,
2546                          suffixes[i]);
2547                 break;
2548             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
2549                 snprintf(buf, buf_size, "%" PRId64 "%c",
2550                          ((size + (base >> 1)) / base),
2551                          suffixes[i]);
2552                 break;
2553             }
2554             base = base * 1024;
2555         }
2556     }
2557     return buf;
2558 }
2559
2560 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
2561 {
2562     char buf1[128], date_buf[128], clock_buf[128];
2563 #ifdef _WIN32
2564     struct tm *ptm;
2565 #else
2566     struct tm tm;
2567 #endif
2568     time_t ti;
2569     int64_t secs;
2570
2571     if (!sn) {
2572         snprintf(buf, buf_size,
2573                  "%-10s%-20s%7s%20s%15s",
2574                  "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
2575     } else {
2576         ti = sn->date_sec;
2577 #ifdef _WIN32
2578         ptm = localtime(&ti);
2579         strftime(date_buf, sizeof(date_buf),
2580                  "%Y-%m-%d %H:%M:%S", ptm);
2581 #else
2582         localtime_r(&ti, &tm);
2583         strftime(date_buf, sizeof(date_buf),
2584                  "%Y-%m-%d %H:%M:%S", &tm);
2585 #endif
2586         secs = sn->vm_clock_nsec / 1000000000;
2587         snprintf(clock_buf, sizeof(clock_buf),
2588                  "%02d:%02d:%02d.%03d",
2589                  (int)(secs / 3600),
2590                  (int)((secs / 60) % 60),
2591                  (int)(secs % 60),
2592                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
2593         snprintf(buf, buf_size,
2594                  "%-10s%-20s%7s%20s%15s",
2595                  sn->id_str, sn->name,
2596                  get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
2597                  date_buf,
2598                  clock_buf);
2599     }
2600     return buf;
2601 }
2602
2603 /**************************************************************/
2604 /* async I/Os */
2605
2606 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
2607                                  QEMUIOVector *qiov, int nb_sectors,
2608                                  BlockDriverCompletionFunc *cb, void *opaque)
2609 {
2610     trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
2611
2612     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
2613                                  cb, opaque, false);
2614 }
2615
2616 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2617                                   QEMUIOVector *qiov, int nb_sectors,
2618                                   BlockDriverCompletionFunc *cb, void *opaque)
2619 {
2620     trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
2621
2622     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
2623                                  cb, opaque, true);
2624 }
2625
2626
2627 typedef struct MultiwriteCB {
2628     int error;
2629     int num_requests;
2630     int num_callbacks;
2631     struct {
2632         BlockDriverCompletionFunc *cb;
2633         void *opaque;
2634         QEMUIOVector *free_qiov;
2635         void *free_buf;
2636     } callbacks[];
2637 } MultiwriteCB;
2638
2639 static void multiwrite_user_cb(MultiwriteCB *mcb)
2640 {
2641     int i;
2642
2643     for (i = 0; i < mcb->num_callbacks; i++) {
2644         mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
2645         if (mcb->callbacks[i].free_qiov) {
2646             qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
2647         }
2648         g_free(mcb->callbacks[i].free_qiov);
2649         qemu_vfree(mcb->callbacks[i].free_buf);
2650     }
2651 }
2652
2653 static void multiwrite_cb(void *opaque, int ret)
2654 {
2655     MultiwriteCB *mcb = opaque;
2656
2657     trace_multiwrite_cb(mcb, ret);
2658
2659     if (ret < 0 && !mcb->error) {
2660         mcb->error = ret;
2661     }
2662
2663     mcb->num_requests--;
2664     if (mcb->num_requests == 0) {
2665         multiwrite_user_cb(mcb);
2666         g_free(mcb);
2667     }
2668 }
2669
2670 static int multiwrite_req_compare(const void *a, const void *b)
2671 {
2672     const BlockRequest *req1 = a, *req2 = b;
2673
2674     /*
2675      * Note that we can't simply subtract req2->sector from req1->sector
2676      * here as that could overflow the return value.
2677      */
2678     if (req1->sector > req2->sector) {
2679         return 1;
2680     } else if (req1->sector < req2->sector) {
2681         return -1;
2682     } else {
2683         return 0;
2684     }
2685 }
2686
2687 /*
2688  * Takes a bunch of requests and tries to merge them. Returns the number of
2689  * requests that remain after merging.
2690  */
2691 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2692     int num_reqs, MultiwriteCB *mcb)
2693 {
2694     int i, outidx;
2695
2696     // Sort requests by start sector
2697     qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
2698
2699     // Check if adjacent requests touch the same clusters. If so, combine them,
2700     // filling up gaps with zero sectors.
2701     outidx = 0;
2702     for (i = 1; i < num_reqs; i++) {
2703         int merge = 0;
2704         int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
2705
2706         // This handles the cases that are valid for all block drivers, namely
2707         // exactly sequential writes and overlapping writes.
2708         if (reqs[i].sector <= oldreq_last) {
2709             merge = 1;
2710         }
2711
2712         // The block driver may decide that it makes sense to combine requests
2713         // even if there is a gap of some sectors between them. In this case,
2714         // the gap is filled with zeros (therefore only applicable for yet
2715         // unused space in format like qcow2).
2716         if (!merge && bs->drv->bdrv_merge_requests) {
2717             merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2718         }
2719
2720         if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2721             merge = 0;
2722         }
2723
2724         if (merge) {
2725             size_t size;
2726             QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
2727             qemu_iovec_init(qiov,
2728                 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2729
2730             // Add the first request to the merged one. If the requests are
2731             // overlapping, drop the last sectors of the first request.
2732             size = (reqs[i].sector - reqs[outidx].sector) << 9;
2733             qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2734
2735             // We might need to add some zeros between the two requests
2736             if (reqs[i].sector > oldreq_last) {
2737                 size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
2738                 uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2739                 memset(buf, 0, zero_bytes);
2740                 qemu_iovec_add(qiov, buf, zero_bytes);
2741                 mcb->callbacks[i].free_buf = buf;
2742             }
2743
2744             // Add the second request
2745             qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
2746
2747             reqs[outidx].nb_sectors = qiov->size >> 9;
2748             reqs[outidx].qiov = qiov;
2749
2750             mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2751         } else {
2752             outidx++;
2753             reqs[outidx].sector     = reqs[i].sector;
2754             reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2755             reqs[outidx].qiov       = reqs[i].qiov;
2756         }
2757     }
2758
2759     return outidx + 1;
2760 }
2761
2762 /*
2763  * Submit multiple AIO write requests at once.
2764  *
2765  * On success, the function returns 0 and all requests in the reqs array have
2766  * been submitted. In error case this function returns -1, and any of the
2767  * requests may or may not be submitted yet. In particular, this means that the
2768  * callback will be called for some of the requests, for others it won't. The
2769  * caller must check the error field of the BlockRequest to wait for the right
2770  * callbacks (if error != 0, no callback will be called).
2771  *
2772  * The implementation may modify the contents of the reqs array, e.g. to merge
2773  * requests. However, the fields opaque and error are left unmodified as they
2774  * are used to signal failure for a single request to the caller.
2775  */
2776 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2777 {
2778     BlockDriverAIOCB *acb;
2779     MultiwriteCB *mcb;
2780     int i;
2781
2782     /* don't submit writes if we don't have a medium */
2783     if (bs->drv == NULL) {
2784         for (i = 0; i < num_reqs; i++) {
2785             reqs[i].error = -ENOMEDIUM;
2786         }
2787         return -1;
2788     }
2789
2790     if (num_reqs == 0) {
2791         return 0;
2792     }
2793
2794     // Create MultiwriteCB structure
2795     mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
2796     mcb->num_requests = 0;
2797     mcb->num_callbacks = num_reqs;
2798
2799     for (i = 0; i < num_reqs; i++) {
2800         mcb->callbacks[i].cb = reqs[i].cb;
2801         mcb->callbacks[i].opaque = reqs[i].opaque;
2802     }
2803
2804     // Check for mergable requests
2805     num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2806
2807     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
2808
2809     /*
2810      * Run the aio requests. As soon as one request can't be submitted
2811      * successfully, fail all requests that are not yet submitted (we must
2812      * return failure for all requests anyway)
2813      *
2814      * num_requests cannot be set to the right value immediately: If
2815      * bdrv_aio_writev fails for some request, num_requests would be too high
2816      * and therefore multiwrite_cb() would never recognize the multiwrite
2817      * request as completed. We also cannot use the loop variable i to set it
2818      * when the first request fails because the callback may already have been
2819      * called for previously submitted requests. Thus, num_requests must be
2820      * incremented for each request that is submitted.
2821      *
2822      * The problem that callbacks may be called early also means that we need
2823      * to take care that num_requests doesn't become 0 before all requests are
2824      * submitted - multiwrite_cb() would consider the multiwrite request
2825      * completed. A dummy request that is "completed" by a manual call to
2826      * multiwrite_cb() takes care of this.
2827      */
2828     mcb->num_requests = 1;
2829
2830     // Run the aio requests
2831     for (i = 0; i < num_reqs; i++) {
2832         mcb->num_requests++;
2833         acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2834             reqs[i].nb_sectors, multiwrite_cb, mcb);
2835
2836         if (acb == NULL) {
2837             // We can only fail the whole thing if no request has been
2838             // submitted yet. Otherwise we'll wait for the submitted AIOs to
2839             // complete and report the error in the callback.
2840             if (i == 0) {
2841                 trace_bdrv_aio_multiwrite_earlyfail(mcb);
2842                 goto fail;
2843             } else {
2844                 trace_bdrv_aio_multiwrite_latefail(mcb, i);
2845                 multiwrite_cb(mcb, -EIO);
2846                 break;
2847             }
2848         }
2849     }
2850
2851     /* Complete the dummy request */
2852     multiwrite_cb(mcb, 0);
2853
2854     return 0;
2855
2856 fail:
2857     for (i = 0; i < mcb->num_callbacks; i++) {
2858         reqs[i].error = -EIO;
2859     }
2860     g_free(mcb);
2861     return -1;
2862 }
2863
2864 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
2865 {
2866     acb->pool->cancel(acb);
2867 }
2868
2869 /* block I/O throttling */
2870 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
2871                  bool is_write, double elapsed_time, uint64_t *wait)
2872 {
2873     uint64_t bps_limit = 0;
2874     double   bytes_limit, bytes_base, bytes_res;
2875     double   slice_time, wait_time;
2876
2877     if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
2878         bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
2879     } else if (bs->io_limits.bps[is_write]) {
2880         bps_limit = bs->io_limits.bps[is_write];
2881     } else {
2882         if (wait) {
2883             *wait = 0;
2884         }
2885
2886         return false;
2887     }
2888
2889     slice_time = bs->slice_end - bs->slice_start;
2890     slice_time /= (NANOSECONDS_PER_SECOND);
2891     bytes_limit = bps_limit * slice_time;
2892     bytes_base  = bs->nr_bytes[is_write] - bs->io_base.bytes[is_write];
2893     if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
2894         bytes_base += bs->nr_bytes[!is_write] - bs->io_base.bytes[!is_write];
2895     }
2896
2897     /* bytes_base: the bytes of data which have been read/written; and
2898      *             it is obtained from the history statistic info.
2899      * bytes_res: the remaining bytes of data which need to be read/written.
2900      * (bytes_base + bytes_res) / bps_limit: used to calcuate
2901      *             the total time for completing reading/writting all data.
2902      */
2903     bytes_res   = (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2904
2905     if (bytes_base + bytes_res <= bytes_limit) {
2906         if (wait) {
2907             *wait = 0;
2908         }
2909
2910         return false;
2911     }
2912
2913     /* Calc approx time to dispatch */
2914     wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time;
2915
2916     /* When the I/O rate at runtime exceeds the limits,
2917      * bs->slice_end need to be extended in order that the current statistic
2918      * info can be kept until the timer fire, so it is increased and tuned
2919      * based on the result of experiment.
2920      */
2921     bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
2922     bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
2923     if (wait) {
2924         *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
2925     }
2926
2927     return true;
2928 }
2929
2930 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
2931                              double elapsed_time, uint64_t *wait)
2932 {
2933     uint64_t iops_limit = 0;
2934     double   ios_limit, ios_base;
2935     double   slice_time, wait_time;
2936
2937     if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
2938         iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
2939     } else if (bs->io_limits.iops[is_write]) {
2940         iops_limit = bs->io_limits.iops[is_write];
2941     } else {
2942         if (wait) {
2943             *wait = 0;
2944         }
2945
2946         return false;
2947     }
2948
2949     slice_time = bs->slice_end - bs->slice_start;
2950     slice_time /= (NANOSECONDS_PER_SECOND);
2951     ios_limit  = iops_limit * slice_time;
2952     ios_base   = bs->nr_ops[is_write] - bs->io_base.ios[is_write];
2953     if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
2954         ios_base += bs->nr_ops[!is_write] - bs->io_base.ios[!is_write];
2955     }
2956
2957     if (ios_base + 1 <= ios_limit) {
2958         if (wait) {
2959             *wait = 0;
2960         }
2961
2962         return false;
2963     }
2964
2965     /* Calc approx time to dispatch */
2966     wait_time = (ios_base + 1) / iops_limit;
2967     if (wait_time > elapsed_time) {
2968         wait_time = wait_time - elapsed_time;
2969     } else {
2970         wait_time = 0;
2971     }
2972
2973     bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
2974     bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
2975     if (wait) {
2976         *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
2977     }
2978
2979     return true;
2980 }
2981
2982 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
2983                            bool is_write, int64_t *wait)
2984 {
2985     int64_t  now, max_wait;
2986     uint64_t bps_wait = 0, iops_wait = 0;
2987     double   elapsed_time;
2988     int      bps_ret, iops_ret;
2989
2990     now = qemu_get_clock_ns(vm_clock);
2991     if ((bs->slice_start < now)
2992         && (bs->slice_end > now)) {
2993         bs->slice_end = now + bs->slice_time;
2994     } else {
2995         bs->slice_time  =  5 * BLOCK_IO_SLICE_TIME;
2996         bs->slice_start = now;
2997         bs->slice_end   = now + bs->slice_time;
2998
2999         bs->io_base.bytes[is_write]  = bs->nr_bytes[is_write];
3000         bs->io_base.bytes[!is_write] = bs->nr_bytes[!is_write];
3001
3002         bs->io_base.ios[is_write]    = bs->nr_ops[is_write];
3003         bs->io_base.ios[!is_write]   = bs->nr_ops[!is_write];
3004     }
3005
3006     elapsed_time  = now - bs->slice_start;
3007     elapsed_time  /= (NANOSECONDS_PER_SECOND);
3008
3009     bps_ret  = bdrv_exceed_bps_limits(bs, nb_sectors,
3010                                       is_write, elapsed_time, &bps_wait);
3011     iops_ret = bdrv_exceed_iops_limits(bs, is_write,
3012                                       elapsed_time, &iops_wait);
3013     if (bps_ret || iops_ret) {
3014         max_wait = bps_wait > iops_wait ? bps_wait : iops_wait;
3015         if (wait) {
3016             *wait = max_wait;
3017         }
3018
3019         now = qemu_get_clock_ns(vm_clock);
3020         if (bs->slice_end < now + max_wait) {
3021             bs->slice_end = now + max_wait;
3022         }
3023
3024         return true;
3025     }
3026
3027     if (wait) {
3028         *wait = 0;
3029     }
3030
3031     return false;
3032 }
3033
3034 /**************************************************************/
3035 /* async block device emulation */
3036
3037 typedef struct BlockDriverAIOCBSync {
3038     BlockDriverAIOCB common;
3039     QEMUBH *bh;
3040     int ret;
3041     /* vector translation state */
3042     QEMUIOVector *qiov;
3043     uint8_t *bounce;
3044     int is_write;
3045 } BlockDriverAIOCBSync;
3046
3047 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
3048 {
3049     BlockDriverAIOCBSync *acb =
3050         container_of(blockacb, BlockDriverAIOCBSync, common);
3051     qemu_bh_delete(acb->bh);
3052     acb->bh = NULL;
3053     qemu_aio_release(acb);
3054 }
3055
3056 static AIOPool bdrv_em_aio_pool = {
3057     .aiocb_size         = sizeof(BlockDriverAIOCBSync),
3058     .cancel             = bdrv_aio_cancel_em,
3059 };
3060
3061 static void bdrv_aio_bh_cb(void *opaque)
3062 {
3063     BlockDriverAIOCBSync *acb = opaque;
3064
3065     if (!acb->is_write)
3066         qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
3067     qemu_vfree(acb->bounce);
3068     acb->common.cb(acb->common.opaque, acb->ret);
3069     qemu_bh_delete(acb->bh);
3070     acb->bh = NULL;
3071     qemu_aio_release(acb);
3072 }
3073
3074 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
3075                                             int64_t sector_num,
3076                                             QEMUIOVector *qiov,
3077                                             int nb_sectors,
3078                                             BlockDriverCompletionFunc *cb,
3079                                             void *opaque,
3080                                             int is_write)
3081
3082 {
3083     BlockDriverAIOCBSync *acb;
3084
3085     acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
3086     acb->is_write = is_write;
3087     acb->qiov = qiov;
3088     acb->bounce = qemu_blockalign(bs, qiov->size);
3089
3090     if (!acb->bh)
3091         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
3092
3093     if (is_write) {
3094         qemu_iovec_to_buffer(acb->qiov, acb->bounce);
3095         acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
3096     } else {
3097         acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
3098     }
3099
3100     qemu_bh_schedule(acb->bh);
3101
3102     return &acb->common;
3103 }
3104
3105 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3106         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3107         BlockDriverCompletionFunc *cb, void *opaque)
3108 {
3109     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
3110 }
3111
3112 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3113         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3114         BlockDriverCompletionFunc *cb, void *opaque)
3115 {
3116     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
3117 }
3118
3119
3120 typedef struct BlockDriverAIOCBCoroutine {
3121     BlockDriverAIOCB common;
3122     BlockRequest req;
3123     bool is_write;
3124     QEMUBH* bh;
3125 } BlockDriverAIOCBCoroutine;
3126
3127 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
3128 {
3129     qemu_aio_flush();
3130 }
3131
3132 static AIOPool bdrv_em_co_aio_pool = {
3133     .aiocb_size         = sizeof(BlockDriverAIOCBCoroutine),
3134     .cancel             = bdrv_aio_co_cancel_em,
3135 };
3136
3137 static void bdrv_co_em_bh(void *opaque)
3138 {
3139     BlockDriverAIOCBCoroutine *acb = opaque;
3140
3141     acb->common.cb(acb->common.opaque, acb->req.error);
3142     qemu_bh_delete(acb->bh);
3143     qemu_aio_release(acb);
3144 }
3145
3146 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3147 static void coroutine_fn bdrv_co_do_rw(void *opaque)
3148 {
3149     BlockDriverAIOCBCoroutine *acb = opaque;
3150     BlockDriverState *bs = acb->common.bs;
3151
3152     if (!acb->is_write) {
3153         acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
3154             acb->req.nb_sectors, acb->req.qiov);
3155     } else {
3156         acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
3157             acb->req.nb_sectors, acb->req.qiov);
3158     }
3159
3160     acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3161     qemu_bh_schedule(acb->bh);
3162 }
3163
3164 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
3165                                                int64_t sector_num,
3166                                                QEMUIOVector *qiov,
3167                                                int nb_sectors,
3168                                                BlockDriverCompletionFunc *cb,
3169                                                void *opaque,
3170                                                bool is_write)
3171 {
3172     Coroutine *co;
3173     BlockDriverAIOCBCoroutine *acb;
3174
3175     acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3176     acb->req.sector = sector_num;
3177     acb->req.nb_sectors = nb_sectors;
3178     acb->req.qiov = qiov;
3179     acb->is_write = is_write;
3180
3181     co = qemu_coroutine_create(bdrv_co_do_rw);
3182     qemu_coroutine_enter(co, acb);
3183
3184     return &acb->common;
3185 }
3186
3187 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
3188 {
3189     BlockDriverAIOCBCoroutine *acb = opaque;
3190     BlockDriverState *bs = acb->common.bs;
3191
3192     acb->req.error = bdrv_co_flush(bs);
3193     acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3194     qemu_bh_schedule(acb->bh);
3195 }
3196
3197 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
3198         BlockDriverCompletionFunc *cb, void *opaque)
3199 {
3200     trace_bdrv_aio_flush(bs, opaque);
3201
3202     Coroutine *co;
3203     BlockDriverAIOCBCoroutine *acb;
3204
3205     acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3206     co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
3207     qemu_coroutine_enter(co, acb);
3208
3209     return &acb->common;
3210 }
3211
3212 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
3213 {
3214     BlockDriverAIOCBCoroutine *acb = opaque;
3215     BlockDriverState *bs = acb->common.bs;
3216
3217     acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
3218     acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3219     qemu_bh_schedule(acb->bh);
3220 }
3221
3222 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
3223         int64_t sector_num, int nb_sectors,
3224         BlockDriverCompletionFunc *cb, void *opaque)
3225 {
3226     Coroutine *co;
3227     BlockDriverAIOCBCoroutine *acb;
3228
3229     trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
3230
3231     acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque);
3232     acb->req.sector = sector_num;
3233     acb->req.nb_sectors = nb_sectors;
3234     co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
3235     qemu_coroutine_enter(co, acb);
3236
3237     return &acb->common;
3238 }
3239
3240 void bdrv_init(void)
3241 {
3242     module_call_init(MODULE_INIT_BLOCK);
3243 }
3244
3245 void bdrv_init_with_whitelist(void)
3246 {
3247     use_bdrv_whitelist = 1;
3248     bdrv_init();
3249 }
3250
3251 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
3252                    BlockDriverCompletionFunc *cb, void *opaque)
3253 {
3254     BlockDriverAIOCB *acb;
3255
3256     if (pool->free_aiocb) {
3257         acb = pool->free_aiocb;
3258         pool->free_aiocb = acb->next;
3259     } else {
3260         acb = g_malloc0(pool->aiocb_size);
3261         acb->pool = pool;
3262     }
3263     acb->bs = bs;
3264     acb->cb = cb;
3265     acb->opaque = opaque;
3266     return acb;
3267 }
3268
3269 void qemu_aio_release(void *p)
3270 {
3271     BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
3272     AIOPool *pool = acb->pool;
3273     acb->next = pool->free_aiocb;
3274     pool->free_aiocb = acb;
3275 }
3276
3277 /**************************************************************/
3278 /* Coroutine block device emulation */
3279
3280 typedef struct CoroutineIOCompletion {
3281     Coroutine *coroutine;
3282     int ret;
3283 } CoroutineIOCompletion;
3284
3285 static void bdrv_co_io_em_complete(void *opaque, int ret)
3286 {
3287     CoroutineIOCompletion *co = opaque;
3288
3289     co->ret = ret;
3290     qemu_coroutine_enter(co->coroutine, NULL);
3291 }
3292
3293 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
3294                                       int nb_sectors, QEMUIOVector *iov,
3295                                       bool is_write)
3296 {
3297     CoroutineIOCompletion co = {
3298         .coroutine = qemu_coroutine_self(),
3299     };
3300     BlockDriverAIOCB *acb;
3301
3302     if (is_write) {
3303         acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
3304                                        bdrv_co_io_em_complete, &co);
3305     } else {
3306         acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
3307                                       bdrv_co_io_em_complete, &co);
3308     }
3309
3310     trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
3311     if (!acb) {
3312         return -EIO;
3313     }
3314     qemu_coroutine_yield();
3315
3316     return co.ret;
3317 }
3318
3319 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
3320                                          int64_t sector_num, int nb_sectors,
3321                                          QEMUIOVector *iov)
3322 {
3323     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
3324 }
3325
3326 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
3327                                          int64_t sector_num, int nb_sectors,
3328                                          QEMUIOVector *iov)
3329 {
3330     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
3331 }
3332
3333 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
3334 {
3335     RwCo *rwco = opaque;
3336
3337     rwco->ret = bdrv_co_flush(rwco->bs);
3338 }
3339
3340 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
3341 {
3342     int ret;
3343
3344     if (!bs->drv) {
3345         return 0;
3346     }
3347
3348     /* Write back cached data to the OS even with cache=unsafe */
3349     if (bs->drv->bdrv_co_flush_to_os) {
3350         ret = bs->drv->bdrv_co_flush_to_os(bs);
3351         if (ret < 0) {
3352             return ret;
3353         }
3354     }
3355
3356     /* But don't actually force it to the disk with cache=unsafe */
3357     if (bs->open_flags & BDRV_O_NO_FLUSH) {
3358         return 0;
3359     }
3360
3361     if (bs->drv->bdrv_co_flush_to_disk) {
3362         return bs->drv->bdrv_co_flush_to_disk(bs);
3363     } else if (bs->drv->bdrv_aio_flush) {
3364         BlockDriverAIOCB *acb;
3365         CoroutineIOCompletion co = {
3366             .coroutine = qemu_coroutine_self(),
3367         };
3368
3369         acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
3370         if (acb == NULL) {
3371             return -EIO;
3372         } else {
3373             qemu_coroutine_yield();
3374             return co.ret;
3375         }
3376     } else {
3377         /*
3378          * Some block drivers always operate in either writethrough or unsafe
3379          * mode and don't support bdrv_flush therefore. Usually qemu doesn't
3380          * know how the server works (because the behaviour is hardcoded or
3381          * depends on server-side configuration), so we can't ensure that
3382          * everything is safe on disk. Returning an error doesn't work because
3383          * that would break guests even if the server operates in writethrough
3384          * mode.
3385          *
3386          * Let's hope the user knows what he's doing.
3387          */
3388         return 0;
3389     }
3390 }
3391
3392 void bdrv_invalidate_cache(BlockDriverState *bs)
3393 {
3394     if (bs->drv && bs->drv->bdrv_invalidate_cache) {
3395         bs->drv->bdrv_invalidate_cache(bs);
3396     }
3397 }
3398
3399 void bdrv_invalidate_cache_all(void)
3400 {
3401     BlockDriverState *bs;
3402
3403     QTAILQ_FOREACH(bs, &bdrv_states, list) {
3404         bdrv_invalidate_cache(bs);
3405     }
3406 }
3407
3408 int bdrv_flush(BlockDriverState *bs)
3409 {
3410     Coroutine *co;
3411     RwCo rwco = {
3412         .bs = bs,
3413         .ret = NOT_DONE,
3414     };
3415
3416     if (qemu_in_coroutine()) {
3417         /* Fast-path if already in coroutine context */
3418         bdrv_flush_co_entry(&rwco);
3419     } else {
3420         co = qemu_coroutine_create(bdrv_flush_co_entry);
3421         qemu_coroutine_enter(co, &rwco);
3422         while (rwco.ret == NOT_DONE) {
3423             qemu_aio_wait();
3424         }
3425     }
3426
3427     return rwco.ret;
3428 }
3429
3430 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
3431 {
3432     RwCo *rwco = opaque;
3433
3434     rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
3435 }
3436
3437 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
3438                                  int nb_sectors)
3439 {
3440     if (!bs->drv) {
3441         return -ENOMEDIUM;
3442     } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
3443         return -EIO;
3444     } else if (bs->read_only) {
3445         return -EROFS;
3446     } else if (bs->drv->bdrv_co_discard) {
3447         return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors);
3448     } else if (bs->drv->bdrv_aio_discard) {
3449         BlockDriverAIOCB *acb;
3450         CoroutineIOCompletion co = {
3451             .coroutine = qemu_coroutine_self(),
3452         };
3453
3454         acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
3455                                         bdrv_co_io_em_complete, &co);
3456         if (acb == NULL) {
3457             return -EIO;
3458         } else {
3459             qemu_coroutine_yield();
3460             return co.ret;
3461         }
3462     } else {
3463         return 0;
3464     }
3465 }
3466
3467 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
3468 {
3469     Coroutine *co;
3470     RwCo rwco = {
3471         .bs = bs,
3472         .sector_num = sector_num,
3473         .nb_sectors = nb_sectors,
3474         .ret = NOT_DONE,
3475     };
3476
3477     if (qemu_in_coroutine()) {
3478         /* Fast-path if already in coroutine context */
3479         bdrv_discard_co_entry(&rwco);
3480     } else {
3481         co = qemu_coroutine_create(bdrv_discard_co_entry);
3482         qemu_coroutine_enter(co, &rwco);
3483         while (rwco.ret == NOT_DONE) {
3484             qemu_aio_wait();
3485         }
3486     }
3487
3488     return rwco.ret;
3489 }
3490
3491 /**************************************************************/
3492 /* removable device support */
3493
3494 /**
3495  * Return TRUE if the media is present
3496  */
3497 int bdrv_is_inserted(BlockDriverState *bs)
3498 {
3499     BlockDriver *drv = bs->drv;
3500
3501     if (!drv)
3502         return 0;
3503     if (!drv->bdrv_is_inserted)
3504         return 1;
3505     return drv->bdrv_is_inserted(bs);
3506 }
3507
3508 /**
3509  * Return whether the media changed since the last call to this
3510  * function, or -ENOTSUP if we don't know.  Most drivers don't know.
3511  */
3512 int bdrv_media_changed(BlockDriverState *bs)
3513 {
3514     BlockDriver *drv = bs->drv;
3515
3516     if (drv && drv->bdrv_media_changed) {
3517         return drv->bdrv_media_changed(bs);
3518     }
3519     return -ENOTSUP;
3520 }
3521
3522 /**
3523  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3524  */
3525 void bdrv_eject(BlockDriverState *bs, int eject_flag)
3526 {
3527     BlockDriver *drv = bs->drv;
3528
3529     if (drv && drv->bdrv_eject) {
3530         drv->bdrv_eject(bs, eject_flag);
3531     }
3532 }
3533
3534 /**
3535  * Lock or unlock the media (if it is locked, the user won't be able
3536  * to eject it manually).
3537  */
3538 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3539 {
3540     BlockDriver *drv = bs->drv;
3541
3542     trace_bdrv_lock_medium(bs, locked);
3543
3544     if (drv && drv->bdrv_lock_medium) {
3545         drv->bdrv_lock_medium(bs, locked);
3546     }
3547 }
3548
3549 /* needed for generic scsi interface */
3550
3551 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
3552 {
3553     BlockDriver *drv = bs->drv;
3554
3555     if (drv && drv->bdrv_ioctl)
3556         return drv->bdrv_ioctl(bs, req, buf);
3557     return -ENOTSUP;
3558 }
3559
3560 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
3561         unsigned long int req, void *buf,
3562         BlockDriverCompletionFunc *cb, void *opaque)
3563 {
3564     BlockDriver *drv = bs->drv;
3565
3566     if (drv && drv->bdrv_aio_ioctl)
3567         return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
3568     return NULL;
3569 }
3570
3571 void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
3572 {
3573     bs->buffer_alignment = align;
3574 }
3575
3576 void *qemu_blockalign(BlockDriverState *bs, size_t size)
3577 {
3578     return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
3579 }
3580
3581 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
3582 {
3583     int64_t bitmap_size;
3584
3585     bs->dirty_count = 0;
3586     if (enable) {
3587         if (!bs->dirty_bitmap) {
3588             bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
3589                     BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
3590             bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
3591
3592             bs->dirty_bitmap = g_malloc0(bitmap_size);
3593         }
3594     } else {
3595         if (bs->dirty_bitmap) {
3596             g_free(bs->dirty_bitmap);
3597             bs->dirty_bitmap = NULL;
3598         }
3599     }
3600 }
3601
3602 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
3603 {
3604     int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
3605
3606     if (bs->dirty_bitmap &&
3607         (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
3608         return !!(bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
3609             (1UL << (chunk % (sizeof(unsigned long) * 8))));
3610     } else {
3611         return 0;
3612     }
3613 }
3614
3615 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
3616                       int nr_sectors)
3617 {
3618     set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
3619 }
3620
3621 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
3622 {
3623     return bs->dirty_count;
3624 }
3625
3626 void bdrv_set_in_use(BlockDriverState *bs, int in_use)
3627 {
3628     assert(bs->in_use != in_use);
3629     bs->in_use = in_use;
3630 }
3631
3632 int bdrv_in_use(BlockDriverState *bs)
3633 {
3634     return bs->in_use;
3635 }
3636
3637 void bdrv_iostatus_enable(BlockDriverState *bs)
3638 {
3639     bs->iostatus_enabled = true;
3640     bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3641 }
3642
3643 /* The I/O status is only enabled if the drive explicitly
3644  * enables it _and_ the VM is configured to stop on errors */
3645 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3646 {
3647     return (bs->iostatus_enabled &&
3648            (bs->on_write_error == BLOCK_ERR_STOP_ENOSPC ||
3649             bs->on_write_error == BLOCK_ERR_STOP_ANY    ||
3650             bs->on_read_error == BLOCK_ERR_STOP_ANY));
3651 }
3652
3653 void bdrv_iostatus_disable(BlockDriverState *bs)
3654 {
3655     bs->iostatus_enabled = false;
3656 }
3657
3658 void bdrv_iostatus_reset(BlockDriverState *bs)
3659 {
3660     if (bdrv_iostatus_is_enabled(bs)) {
3661         bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3662     }
3663 }
3664
3665 /* XXX: Today this is set by device models because it makes the implementation
3666    quite simple. However, the block layer knows about the error, so it's
3667    possible to implement this without device models being involved */
3668 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3669 {
3670     if (bdrv_iostatus_is_enabled(bs) &&
3671         bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3672         assert(error >= 0);
3673         bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3674                                          BLOCK_DEVICE_IO_STATUS_FAILED;
3675     }
3676 }
3677
3678 void
3679 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
3680         enum BlockAcctType type)
3681 {
3682     assert(type < BDRV_MAX_IOTYPE);
3683
3684     cookie->bytes = bytes;
3685     cookie->start_time_ns = get_clock();
3686     cookie->type = type;
3687 }
3688
3689 void
3690 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
3691 {
3692     assert(cookie->type < BDRV_MAX_IOTYPE);
3693
3694     bs->nr_bytes[cookie->type] += cookie->bytes;
3695     bs->nr_ops[cookie->type]++;
3696     bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
3697 }
3698
3699 int bdrv_img_create(const char *filename, const char *fmt,
3700                     const char *base_filename, const char *base_fmt,
3701                     char *options, uint64_t img_size, int flags)
3702 {
3703     QEMUOptionParameter *param = NULL, *create_options = NULL;
3704     QEMUOptionParameter *backing_fmt, *backing_file, *size;
3705     BlockDriverState *bs = NULL;
3706     BlockDriver *drv, *proto_drv;
3707     BlockDriver *backing_drv = NULL;
3708     int ret = 0;
3709
3710     /* Find driver and parse its options */
3711     drv = bdrv_find_format(fmt);
3712     if (!drv) {
3713         error_report("Unknown file format '%s'", fmt);
3714         ret = -EINVAL;
3715         goto out;
3716     }
3717
3718     proto_drv = bdrv_find_protocol(filename);
3719     if (!proto_drv) {
3720         error_report("Unknown protocol '%s'", filename);
3721         ret = -EINVAL;
3722         goto out;
3723     }
3724
3725     create_options = append_option_parameters(create_options,
3726                                               drv->create_options);
3727     create_options = append_option_parameters(create_options,
3728                                               proto_drv->create_options);
3729
3730     /* Create parameter list with default values */
3731     param = parse_option_parameters("", create_options, param);
3732
3733     set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
3734
3735     /* Parse -o options */
3736     if (options) {
3737         param = parse_option_parameters(options, create_options, param);
3738         if (param == NULL) {
3739             error_report("Invalid options for file format '%s'.", fmt);
3740             ret = -EINVAL;
3741             goto out;
3742         }
3743     }
3744
3745     if (base_filename) {
3746         if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
3747                                  base_filename)) {
3748             error_report("Backing file not supported for file format '%s'",
3749                          fmt);
3750             ret = -EINVAL;
3751             goto out;
3752         }
3753     }
3754
3755     if (base_fmt) {
3756         if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
3757             error_report("Backing file format not supported for file "
3758                          "format '%s'", fmt);
3759             ret = -EINVAL;
3760             goto out;
3761         }
3762     }
3763
3764     backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
3765     if (backing_file && backing_file->value.s) {
3766         if (!strcmp(filename, backing_file->value.s)) {
3767             error_report("Error: Trying to create an image with the "
3768                          "same filename as the backing file");
3769             ret = -EINVAL;
3770             goto out;
3771         }
3772     }
3773
3774     backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
3775     if (backing_fmt && backing_fmt->value.s) {
3776         backing_drv = bdrv_find_format(backing_fmt->value.s);
3777         if (!backing_drv) {
3778             error_report("Unknown backing file format '%s'",
3779                          backing_fmt->value.s);
3780             ret = -EINVAL;
3781             goto out;
3782         }
3783     }
3784
3785     // The size for the image must always be specified, with one exception:
3786     // If we are using a backing file, we can obtain the size from there
3787     size = get_option_parameter(param, BLOCK_OPT_SIZE);
3788     if (size && size->value.n == -1) {
3789         if (backing_file && backing_file->value.s) {
3790             uint64_t size;
3791             char buf[32];
3792
3793             bs = bdrv_new("");
3794
3795             ret = bdrv_open(bs, backing_file->value.s, flags, backing_drv);
3796             if (ret < 0) {
3797                 error_report("Could not open '%s'", backing_file->value.s);
3798                 goto out;
3799             }
3800             bdrv_get_geometry(bs, &size);
3801             size *= 512;
3802
3803             snprintf(buf, sizeof(buf), "%" PRId64, size);
3804             set_option_parameter(param, BLOCK_OPT_SIZE, buf);
3805         } else {
3806             error_report("Image creation needs a size parameter");
3807             ret = -EINVAL;
3808             goto out;
3809         }
3810     }
3811
3812     printf("Formatting '%s', fmt=%s ", filename, fmt);
3813     print_option_parameters(param);
3814     puts("");
3815
3816     ret = bdrv_create(drv, filename, param);
3817
3818     if (ret < 0) {
3819         if (ret == -ENOTSUP) {
3820             error_report("Formatting or formatting option not supported for "
3821                          "file format '%s'", fmt);
3822         } else if (ret == -EFBIG) {
3823             error_report("The image size is too large for file format '%s'",
3824                          fmt);
3825         } else {
3826             error_report("%s: error while creating %s: %s", filename, fmt,
3827                          strerror(-ret));
3828         }
3829     }
3830
3831 out:
3832     free_option_parameters(create_options);
3833     free_option_parameters(param);
3834
3835     if (bs) {
3836         bdrv_delete(bs);
3837     }
3838
3839     return ret;
3840 }