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