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