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