block.c

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