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