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 "qemu-objects.h"
  31
  32 #ifdef CONFIG_BSD
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/queue.h>
  37 #ifndef __DragonFly__
  38 #include <sys/disk.h>
  39 #endif
  40 #endif
  41
  42 #ifdef _WIN32
  43 #include <windows.h>
  44 #endif
  45
  46 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
  47         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
  48         BlockDriverCompletionFunc *cb, void *opaque);
  49 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
  50         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
  51         BlockDriverCompletionFunc *cb, void *opaque);
  52 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
  53         BlockDriverCompletionFunc *cb, void *opaque);
  54 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
  55         BlockDriverCompletionFunc *cb, void *opaque);
  56 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
  57                         uint8_t *buf, int nb_sectors);
  58 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
  59                          const uint8_t *buf, int nb_sectors);
  60
  61 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
  62     QTAILQ_HEAD_INITIALIZER(bdrv_states);
  63
  64 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
  65     QLIST_HEAD_INITIALIZER(bdrv_drivers);
  66
  67 /* The device to use for VM snapshots */
  68 static BlockDriverState *bs_snapshots;
  69
  70 /* If non-zero, use only whitelisted block drivers */
  71 static int use_bdrv_whitelist;
  72
  73 int path_is_absolute(const char *path)
  74 {
  75     const char *p;
  76 #ifdef _WIN32
  77     /* specific case for names like: "\\.\d:" */
  78     if (*path == '/' || *path == '\\')
  79         return 1;
  80 #endif
  81     p = strchr(path, ':');
  82     if (p)
  83         p++;
  84     else
  85         p = path;
  86 #ifdef _WIN32
  87     return (*p == '/' || *p == '\\');
  88 #else
  89     return (*p == '/');
  90 #endif
  91 }
  92
  93 /* if filename is absolute, just copy it to dest. Otherwise, build a
  94    path to it by considering it is relative to base_path. URL are
  95    supported. */
  96 void path_combine(char *dest, int dest_size,
  97                   const char *base_path,
  98                   const char *filename)
  99 {
 100     const char *p, *p1;
 101     int len;
 102
 103     if (dest_size <= 0)
 104         return;
 105     if (path_is_absolute(filename)) {
 106         pstrcpy(dest, dest_size, filename);
 107     } else {
 108         p = strchr(base_path, ':');
 109         if (p)
 110             p++;
 111         else
 112             p = base_path;
 113         p1 = strrchr(base_path, '/');
 114 #ifdef _WIN32
 115         {
 116             const char *p2;
 117             p2 = strrchr(base_path, '\\');
 118             if (!p1 || p2 > p1)
 119                 p1 = p2;
 120         }
 121 #endif
 122         if (p1)
 123             p1++;
 124         else
 125             p1 = base_path;
 126         if (p1 > p)
 127             p = p1;
 128         len = p - base_path;
 129         if (len > dest_size - 1)
 130             len = dest_size - 1;
 131         memcpy(dest, base_path, len);
 132         dest[len] = '\0';
 133         pstrcat(dest, dest_size, filename);
 134     }
 135 }
 136
 137 void bdrv_register(BlockDriver *bdrv)
 138 {
 139     if (!bdrv->bdrv_aio_readv) {
 140         /* add AIO emulation layer */
 141         bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
 142         bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
 143     } else if (!bdrv->bdrv_read) {
 144         /* add synchronous IO emulation layer */
 145         bdrv->bdrv_read = bdrv_read_em;
 146         bdrv->bdrv_write = bdrv_write_em;
 147     }
 148
 149     if (!bdrv->bdrv_aio_flush)
 150         bdrv->bdrv_aio_flush = bdrv_aio_flush_em;
 151
 152     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
 153 }
 154
 155 /* create a new block device (by default it is empty) */
 156 BlockDriverState *bdrv_new(const char *device_name)
 157 {
 158     BlockDriverState *bs;
 159
 160     bs = qemu_mallocz(sizeof(BlockDriverState));
 161     pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
 162     if (device_name[0] != '\0') {
 163         QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
 164     }
 165     return bs;
 166 }
 167
 168 BlockDriver *bdrv_find_format(const char *format_name)
 169 {
 170     BlockDriver *drv1;
 171     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 172         if (!strcmp(drv1->format_name, format_name)) {
 173             return drv1;
 174         }
 175     }
 176     return NULL;
 177 }
 178
 179 static int bdrv_is_whitelisted(BlockDriver *drv)
 180 {
 181     static const char *whitelist[] = {
 182         CONFIG_BDRV_WHITELIST
 183     };
 184     const char **p;
 185
 186     if (!whitelist[0])
 187         return 1;               /* no whitelist, anything goes */
 188
 189     for (p = whitelist; *p; p++) {
 190         if (!strcmp(drv->format_name, *p)) {
 191             return 1;
 192         }
 193     }
 194     return 0;
 195 }
 196
 197 BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
 198 {
 199     BlockDriver *drv = bdrv_find_format(format_name);
 200     return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
 201 }
 202
 203 int bdrv_create(BlockDriver *drv, const char* filename,
 204     QEMUOptionParameter *options)
 205 {
 206     if (!drv->bdrv_create)
 207         return -ENOTSUP;
 208
 209     return drv->bdrv_create(filename, options);
 210 }
 211
 212 int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
 213 {
 214     BlockDriver *drv;
 215
 216     drv = bdrv_find_protocol(filename);
 217     if (drv == NULL) {
 218         drv = bdrv_find_format("file");
 219     }
 220
 221     return bdrv_create(drv, filename, options);
 222 }
 223
 224 #ifdef _WIN32
 225 void get_tmp_filename(char *filename, int size)
 226 {
 227     char temp_dir[MAX_PATH];
 228
 229     GetTempPath(MAX_PATH, temp_dir);
 230     GetTempFileName(temp_dir, "qem", 0, filename);
 231 }
 232 #else
 233 void get_tmp_filename(char *filename, int size)
 234 {
 235     int fd;
 236     const char *tmpdir;
 237     /* XXX: race condition possible */
 238     tmpdir = getenv("TMPDIR");
 239     if (!tmpdir)
 240         tmpdir = "/tmp";
 241     snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
 242     fd = mkstemp(filename);
 243     close(fd);
 244 }
 245 #endif
 246
 247 #ifdef _WIN32
 248 static int is_windows_drive_prefix(const char *filename)
 249 {
 250     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
 251              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
 252             filename[1] == ':');
 253 }
 254
 255 int is_windows_drive(const char *filename)
 256 {
 257     if (is_windows_drive_prefix(filename) &&
 258         filename[2] == '\0')
 259         return 1;
 260     if (strstart(filename, "\\\\.\\", NULL) ||
 261         strstart(filename, "//./", NULL))
 262         return 1;
 263     return 0;
 264 }
 265 #endif
 266
 267 /*
 268  * Detect host devices. By convention, /dev/cdrom[N] is always
 269  * recognized as a host CDROM.
 270  */
 271 static BlockDriver *find_hdev_driver(const char *filename)
 272 {
 273     int score_max = 0, score;
 274     BlockDriver *drv = NULL, *d;
 275
 276     QLIST_FOREACH(d, &bdrv_drivers, list) {
 277         if (d->bdrv_probe_device) {
 278             score = d->bdrv_probe_device(filename);
 279             if (score > score_max) {
 280                 score_max = score;
 281                 drv = d;
 282             }
 283         }
 284     }
 285
 286     return drv;
 287 }
 288
 289 BlockDriver *bdrv_find_protocol(const char *filename)
 290 {
 291     BlockDriver *drv1;
 292     char protocol[128];
 293     int len;
 294     const char *p;
 295
 296     /* TODO Drivers without bdrv_file_open must be specified explicitly */
 297
 298     /*
 299      * XXX(hch): we really should not let host device detection
 300      * override an explicit protocol specification, but moving this
 301      * later breaks access to device names with colons in them.
 302      * Thanks to the brain-dead persistent naming schemes on udev-
 303      * based Linux systems those actually are quite common.
 304      */
 305     drv1 = find_hdev_driver(filename);
 306     if (drv1) {
 307         return drv1;
 308     }
 309
 310 #ifdef _WIN32
 311      if (is_windows_drive(filename) ||
 312          is_windows_drive_prefix(filename))
 313          return bdrv_find_format("file");
 314 #endif
 315
 316     p = strchr(filename, ':');
 317     if (!p) {
 318         return bdrv_find_format("file");
 319     }
 320     len = p - filename;
 321     if (len > sizeof(protocol) - 1)
 322         len = sizeof(protocol) - 1;
 323     memcpy(protocol, filename, len);
 324     protocol[len] = '\0';
 325     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 326         if (drv1->protocol_name &&
 327             !strcmp(drv1->protocol_name, protocol)) {
 328             return drv1;
 329         }
 330     }
 331     return NULL;
 332 }
 333
 334 static int find_image_format(const char *filename, BlockDriver **pdrv)
 335 {
 336     int ret, score, score_max;
 337     BlockDriver *drv1, *drv;
 338     uint8_t buf[2048];
 339     BlockDriverState *bs;
 340
 341     ret = bdrv_file_open(&bs, filename, 0);
 342     if (ret < 0) {
 343         *pdrv = NULL;
 344         return ret;
 345     }
 346
 347     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
 348     if (bs->sg || !bdrv_is_inserted(bs)) {
 349         bdrv_delete(bs);
 350         drv = bdrv_find_format("raw");
 351         if (!drv) {
 352             ret = -ENOENT;
 353         }
 354         *pdrv = drv;
 355         return ret;
 356     }
 357
 358     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
 359     bdrv_delete(bs);
 360     if (ret < 0) {
 361         *pdrv = NULL;
 362         return ret;
 363     }
 364
 365     score_max = 0;
 366     drv = NULL;
 367     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 368         if (drv1->bdrv_probe) {
 369             score = drv1->bdrv_probe(buf, ret, filename);
 370             if (score > score_max) {
 371                 score_max = score;
 372                 drv = drv1;
 373             }
 374         }
 375     }
 376     if (!drv) {
 377         ret = -ENOENT;
 378     }
 379     *pdrv = drv;
 380     return ret;
 381 }
 382
 383 /**
 384  * Set the current 'total_sectors' value
 385  */
 386 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
 387 {
 388     BlockDriver *drv = bs->drv;
 389
 390     /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
 391     if (bs->sg)
 392         return 0;
 393
 394     /* query actual device if possible, otherwise just trust the hint */
 395     if (drv->bdrv_getlength) {
 396         int64_t length = drv->bdrv_getlength(bs);
 397         if (length < 0) {
 398             return length;
 399         }
 400         hint = length >> BDRV_SECTOR_BITS;
 401     }
 402
 403     bs->total_sectors = hint;
 404     return 0;
 405 }
 406
 407 /*
 408  * Common part for opening disk images and files
 409  */
 410 static int bdrv_open_common(BlockDriverState *bs, const char *filename,
 411     int flags, BlockDriver *drv)
 412 {
 413     int ret, open_flags;
 414
 415     assert(drv != NULL);
 416
 417     bs->file = NULL;
 418     bs->total_sectors = 0;
 419     bs->encrypted = 0;
 420     bs->valid_key = 0;
 421     bs->open_flags = flags;
 422     /* buffer_alignment defaulted to 512, drivers can change this value */
 423     bs->buffer_alignment = 512;
 424
 425     pstrcpy(bs->filename, sizeof(bs->filename), filename);
 426
 427     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
 428         return -ENOTSUP;
 429     }
 430
 431     bs->drv = drv;
 432     bs->opaque = qemu_mallocz(drv->instance_size);
 433
 434     /*
 435      * Yes, BDRV_O_NOCACHE aka O_DIRECT means we have to present a
 436      * write cache to the guest.  We do need the fdatasync to flush
 437      * out transactions for block allocations, and we maybe have a
 438      * volatile write cache in our backing device to deal with.
 439      */
 440     if (flags & (BDRV_O_CACHE_WB|BDRV_O_NOCACHE))
 441         bs->enable_write_cache = 1;
 442
 443     /*
 444      * Clear flags that are internal to the block layer before opening the
 445      * image.
 446      */
 447     open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
 448
 449     /*
 450      * Snapshots should be writeable.
 451      */
 452     if (bs->is_temporary) {
 453         open_flags |= BDRV_O_RDWR;
 454     }
 455
 456     /* Open the image, either directly or using a protocol */
 457     if (drv->bdrv_file_open) {
 458         ret = drv->bdrv_file_open(bs, filename, open_flags);
 459     } else {
 460         ret = bdrv_file_open(&bs->file, filename, open_flags);
 461         if (ret >= 0) {
 462             ret = drv->bdrv_open(bs, open_flags);
 463         }
 464     }
 465
 466     if (ret < 0) {
 467         goto free_and_fail;
 468     }
 469
 470     bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
 471
 472     ret = refresh_total_sectors(bs, bs->total_sectors);
 473     if (ret < 0) {
 474         goto free_and_fail;
 475     }
 476
 477 #ifndef _WIN32
 478     if (bs->is_temporary) {
 479         unlink(filename);
 480     }
 481 #endif
 482     return 0;
 483
 484 free_and_fail:
 485     if (bs->file) {
 486         bdrv_delete(bs->file);
 487         bs->file = NULL;
 488     }
 489     qemu_free(bs->opaque);
 490     bs->opaque = NULL;
 491     bs->drv = NULL;
 492     return ret;
 493 }
 494
 495 /*
 496  * Opens a file using a protocol (file, host_device, nbd, ...)
 497  */
 498 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
 499 {
 500     BlockDriverState *bs;
 501     BlockDriver *drv;
 502     int ret;
 503
 504     drv = bdrv_find_protocol(filename);
 505     if (!drv) {
 506         return -ENOENT;
 507     }
 508
 509     bs = bdrv_new("");
 510     ret = bdrv_open_common(bs, filename, flags, drv);
 511     if (ret < 0) {
 512         bdrv_delete(bs);
 513         return ret;
 514     }
 515     bs->growable = 1;
 516     *pbs = bs;
 517     return 0;
 518 }
 519
 520 /*
 521  * Opens a disk image (raw, qcow2, vmdk, ...)
 522  */
 523 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
 524               BlockDriver *drv)
 525 {
 526     int ret;
 527
 528     if (flags & BDRV_O_SNAPSHOT) {
 529         BlockDriverState *bs1;
 530         int64_t total_size;
 531         int is_protocol = 0;
 532         BlockDriver *bdrv_qcow2;
 533         QEMUOptionParameter *options;
 534         char tmp_filename[PATH_MAX];
 535         char backing_filename[PATH_MAX];
 536
 537         /* if snapshot, we create a temporary backing file and open it
 538            instead of opening 'filename' directly */
 539
 540         /* if there is a backing file, use it */
 541         bs1 = bdrv_new("");
 542         ret = bdrv_open(bs1, filename, 0, drv);
 543         if (ret < 0) {
 544             bdrv_delete(bs1);
 545             return ret;
 546         }
 547         total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
 548
 549         if (bs1->drv && bs1->drv->protocol_name)
 550             is_protocol = 1;
 551
 552         bdrv_delete(bs1);
 553
 554         get_tmp_filename(tmp_filename, sizeof(tmp_filename));
 555
 556         /* Real path is meaningless for protocols */
 557         if (is_protocol)
 558             snprintf(backing_filename, sizeof(backing_filename),
 559                      "%s", filename);
 560         else if (!realpath(filename, backing_filename))
 561             return -errno;
 562
 563         bdrv_qcow2 = bdrv_find_format("qcow2");
 564         options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
 565
 566         set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
 567         set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
 568         if (drv) {
 569             set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
 570                 drv->format_name);
 571         }
 572
 573         ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
 574         free_option_parameters(options);
 575         if (ret < 0) {
 576             return ret;
 577         }
 578
 579         filename = tmp_filename;
 580         drv = bdrv_qcow2;
 581         bs->is_temporary = 1;
 582     }
 583
 584     /* Find the right image format driver */
 585     if (!drv) {
 586         ret = find_image_format(filename, &drv);
 587     }
 588
 589     if (!drv) {
 590         goto unlink_and_fail;
 591     }
 592
 593     /* Open the image */
 594     ret = bdrv_open_common(bs, filename, flags, drv);
 595     if (ret < 0) {
 596         goto unlink_and_fail;
 597     }
 598
 599     /* If there is a backing file, use it */
 600     if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
 601         char backing_filename[PATH_MAX];
 602         int back_flags;
 603         BlockDriver *back_drv = NULL;
 604
 605         bs->backing_hd = bdrv_new("");
 606         path_combine(backing_filename, sizeof(backing_filename),
 607                      filename, bs->backing_file);
 608         if (bs->backing_format[0] != '\0')
 609             back_drv = bdrv_find_format(bs->backing_format);
 610
 611         /* backing files always opened read-only */
 612         back_flags =
 613             flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
 614
 615         ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
 616         if (ret < 0) {
 617             bdrv_close(bs);
 618             return ret;
 619         }
 620         if (bs->is_temporary) {
 621             bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
 622         } else {
 623             /* base image inherits from "parent" */
 624             bs->backing_hd->keep_read_only = bs->keep_read_only;
 625         }
 626     }
 627
 628     if (!bdrv_key_required(bs)) {
 629         /* call the change callback */
 630         bs->media_changed = 1;
 631         if (bs->change_cb)
 632             bs->change_cb(bs->change_opaque);
 633     }
 634
 635     return 0;
 636
 637 unlink_and_fail:
 638     if (bs->is_temporary) {
 639         unlink(filename);
 640     }
 641     return ret;
 642 }
 643
 644 void bdrv_close(BlockDriverState *bs)
 645 {
 646     if (bs->drv) {
 647         if (bs == bs_snapshots) {
 648             bs_snapshots = NULL;
 649         }
 650         if (bs->backing_hd) {
 651             bdrv_delete(bs->backing_hd);
 652             bs->backing_hd = NULL;
 653         }
 654         bs->drv->bdrv_close(bs);
 655         qemu_free(bs->opaque);
 656 #ifdef _WIN32
 657         if (bs->is_temporary) {
 658             unlink(bs->filename);
 659         }
 660 #endif
 661         bs->opaque = NULL;
 662         bs->drv = NULL;
 663
 664         if (bs->file != NULL) {
 665             bdrv_close(bs->file);
 666         }
 667
 668         /* call the change callback */
 669         bs->media_changed = 1;
 670         if (bs->change_cb)
 671             bs->change_cb(bs->change_opaque);
 672     }
 673 }
 674
 675 void bdrv_close_all(void)
 676 {
 677     BlockDriverState *bs;
 678
 679     QTAILQ_FOREACH(bs, &bdrv_states, list) {
 680         bdrv_close(bs);
 681     }
 682 }
 683
 684 void bdrv_delete(BlockDriverState *bs)
 685 {
 686     assert(!bs->peer);
 687
 688     /* remove from list, if necessary */
 689     if (bs->device_name[0] != '\0') {
 690         QTAILQ_REMOVE(&bdrv_states, bs, list);
 691     }
 692
 693     bdrv_close(bs);
 694     if (bs->file != NULL) {
 695         bdrv_delete(bs->file);
 696     }
 697
 698     assert(bs != bs_snapshots);
 699     qemu_free(bs);
 700 }
 701
 702 int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)
 703 {
 704     if (bs->peer) {
 705         return -EBUSY;
 706     }
 707     bs->peer = qdev;
 708     return 0;
 709 }
 710
 711 void bdrv_detach(BlockDriverState *bs, DeviceState *qdev)
 712 {
 713     assert(bs->peer == qdev);
 714     bs->peer = NULL;
 715 }
 716
 717 DeviceState *bdrv_get_attached(BlockDriverState *bs)
 718 {
 719     return bs->peer;
 720 }
 721
 722 /*
 723  * Run consistency checks on an image
 724  *
 725  * Returns 0 if the check could be completed (it doesn't mean that the image is
 726  * free of errors) or -errno when an internal error occured. The results of the
 727  * check are stored in res.
 728  */
 729 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
 730 {
 731     if (bs->drv->bdrv_check == NULL) {
 732         return -ENOTSUP;
 733     }
 734
 735     memset(res, 0, sizeof(*res));
 736     return bs->drv->bdrv_check(bs, res);
 737 }
 738
 739 #define COMMIT_BUF_SECTORS 2048
 740
 741 /* commit COW file into the raw image */
 742 int bdrv_commit(BlockDriverState *bs)
 743 {
 744     BlockDriver *drv = bs->drv;
 745     BlockDriver *backing_drv;
 746     int64_t sector, total_sectors;
 747     int n, ro, open_flags;
 748     int ret = 0, rw_ret = 0;
 749     uint8_t *buf;
 750     char filename[1024];
 751     BlockDriverState *bs_rw, *bs_ro;
 752
 753     if (!drv)
 754         return -ENOMEDIUM;
 755
 756     if (!bs->backing_hd) {
 757         return -ENOTSUP;
 758     }
 759
 760     if (bs->backing_hd->keep_read_only) {
 761         return -EACCES;
 762     }
 763
 764     backing_drv = bs->backing_hd->drv;
 765     ro = bs->backing_hd->read_only;
 766     strncpy(filename, bs->backing_hd->filename, sizeof(filename));
 767     open_flags =  bs->backing_hd->open_flags;
 768
 769     if (ro) {
 770         /* re-open as RW */
 771         bdrv_delete(bs->backing_hd);
 772         bs->backing_hd = NULL;
 773         bs_rw = bdrv_new("");
 774         rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR,
 775             backing_drv);
 776         if (rw_ret < 0) {
 777             bdrv_delete(bs_rw);
 778             /* try to re-open read-only */
 779             bs_ro = bdrv_new("");
 780             ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
 781                 backing_drv);
 782             if (ret < 0) {
 783                 bdrv_delete(bs_ro);
 784                 /* drive not functional anymore */
 785                 bs->drv = NULL;
 786                 return ret;
 787             }
 788             bs->backing_hd = bs_ro;
 789             return rw_ret;
 790         }
 791         bs->backing_hd = bs_rw;
 792     }
 793
 794     total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
 795     buf = qemu_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
 796
 797     for (sector = 0; sector < total_sectors; sector += n) {
 798         if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
 799
 800             if (bdrv_read(bs, sector, buf, n) != 0) {
 801                 ret = -EIO;
 802                 goto ro_cleanup;
 803             }
 804
 805             if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
 806                 ret = -EIO;
 807                 goto ro_cleanup;
 808             }
 809         }
 810     }
 811
 812     if (drv->bdrv_make_empty) {
 813         ret = drv->bdrv_make_empty(bs);
 814         bdrv_flush(bs);
 815     }
 816
 817     /*
 818      * Make sure all data we wrote to the backing device is actually
 819      * stable on disk.
 820      */
 821     if (bs->backing_hd)
 822         bdrv_flush(bs->backing_hd);
 823
 824 ro_cleanup:
 825     qemu_free(buf);
 826
 827     if (ro) {
 828         /* re-open as RO */
 829         bdrv_delete(bs->backing_hd);
 830         bs->backing_hd = NULL;
 831         bs_ro = bdrv_new("");
 832         ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
 833             backing_drv);
 834         if (ret < 0) {
 835             bdrv_delete(bs_ro);
 836             /* drive not functional anymore */
 837             bs->drv = NULL;
 838             return ret;
 839         }
 840         bs->backing_hd = bs_ro;
 841         bs->backing_hd->keep_read_only = 0;
 842     }
 843
 844     return ret;
 845 }
 846
 847 void bdrv_commit_all(void)
 848 {
 849     BlockDriverState *bs;
 850
 851     QTAILQ_FOREACH(bs, &bdrv_states, list) {
 852         bdrv_commit(bs);
 853     }
 854 }
 855
 856 /*
 857  * Return values:
 858  * 0        - success
 859  * -EINVAL  - backing format specified, but no file
 860  * -ENOSPC  - can't update the backing file because no space is left in the
 861  *            image file header
 862  * -ENOTSUP - format driver doesn't support changing the backing file
 863  */
 864 int bdrv_change_backing_file(BlockDriverState *bs,
 865     const char *backing_file, const char *backing_fmt)
 866 {
 867     BlockDriver *drv = bs->drv;
 868
 869     if (drv->bdrv_change_backing_file != NULL) {
 870         return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
 871     } else {
 872         return -ENOTSUP;
 873     }
 874 }
 875
 876 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
 877                                    size_t size)
 878 {
 879     int64_t len;
 880
 881     if (!bdrv_is_inserted(bs))
 882         return -ENOMEDIUM;
 883
 884     if (bs->growable)
 885         return 0;
 886
 887     len = bdrv_getlength(bs);
 888
 889     if (offset < 0)
 890         return -EIO;
 891
 892     if ((offset > len) || (len - offset < size))
 893         return -EIO;
 894
 895     return 0;
 896 }
 897
 898 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
 899                               int nb_sectors)
 900 {
 901     return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
 902                                    nb_sectors * BDRV_SECTOR_SIZE);
 903 }
 904
 905 /* return < 0 if error. See bdrv_write() for the return codes */
 906 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
 907               uint8_t *buf, int nb_sectors)
 908 {
 909     BlockDriver *drv = bs->drv;
 910
 911     if (!drv)
 912         return -ENOMEDIUM;
 913     if (bdrv_check_request(bs, sector_num, nb_sectors))
 914         return -EIO;
 915
 916     return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
 917 }
 918
 919 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
 920                              int nb_sectors, int dirty)
 921 {
 922     int64_t start, end;
 923     unsigned long val, idx, bit;
 924
 925     start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
 926     end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
 927
 928     for (; start <= end; start++) {
 929         idx = start / (sizeof(unsigned long) * 8);
 930         bit = start % (sizeof(unsigned long) * 8);
 931         val = bs->dirty_bitmap[idx];
 932         if (dirty) {
 933             if (!(val & (1 << bit))) {
 934                 bs->dirty_count++;
 935                 val |= 1 << bit;
 936             }
 937         } else {
 938             if (val & (1 << bit)) {
 939                 bs->dirty_count--;
 940                 val &= ~(1 << bit);
 941             }
 942         }
 943         bs->dirty_bitmap[idx] = val;
 944     }
 945 }
 946
 947 /* Return < 0 if error. Important errors are:
 948   -EIO         generic I/O error (may happen for all errors)
 949   -ENOMEDIUM   No media inserted.
 950   -EINVAL      Invalid sector number or nb_sectors
 951   -EACCES      Trying to write a read-only device
 952 */
 953 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
 954                const uint8_t *buf, int nb_sectors)
 955 {
 956     BlockDriver *drv = bs->drv;
 957     if (!bs->drv)
 958         return -ENOMEDIUM;
 959     if (bs->read_only)
 960         return -EACCES;
 961     if (bdrv_check_request(bs, sector_num, nb_sectors))
 962         return -EIO;
 963
 964     if (bs->dirty_bitmap) {
 965         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
 966     }
 967
 968     if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
 969         bs->wr_highest_sector = sector_num + nb_sectors - 1;
 970     }
 971
 972     return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
 973 }
 974
 975 int bdrv_pread(BlockDriverState *bs, int64_t offset,
 976                void *buf, int count1)
 977 {
 978     uint8_t tmp_buf[BDRV_SECTOR_SIZE];
 979     int len, nb_sectors, count;
 980     int64_t sector_num;
 981     int ret;
 982
 983     count = count1;
 984     /* first read to align to sector start */
 985     len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
 986     if (len > count)
 987         len = count;
 988     sector_num = offset >> BDRV_SECTOR_BITS;
 989     if (len > 0) {
 990         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
 991             return ret;
 992         memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
 993         count -= len;
 994         if (count == 0)
 995             return count1;
 996         sector_num++;
 997         buf += len;
 998     }
 999
1000     /* read the sectors "in place" */
1001     nb_sectors = count >> BDRV_SECTOR_BITS;
1002     if (nb_sectors > 0) {
1003         if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1004             return ret;
1005         sector_num += nb_sectors;
1006         len = nb_sectors << BDRV_SECTOR_BITS;
1007         buf += len;
1008         count -= len;
1009     }
1010
1011     /* add data from the last sector */
1012     if (count > 0) {
1013         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1014             return ret;
1015         memcpy(buf, tmp_buf, count);
1016     }
1017     return count1;
1018 }
1019
1020 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1021                 const void *buf, int count1)
1022 {
1023     uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1024     int len, nb_sectors, count;
1025     int64_t sector_num;
1026     int ret;
1027
1028     count = count1;
1029     /* first write to align to sector start */
1030     len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1031     if (len > count)
1032         len = count;
1033     sector_num = offset >> BDRV_SECTOR_BITS;
1034     if (len > 0) {
1035         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1036             return ret;
1037         memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1038         if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1039             return ret;
1040         count -= len;
1041         if (count == 0)
1042             return count1;
1043         sector_num++;
1044         buf += len;
1045     }
1046
1047     /* write the sectors "in place" */
1048     nb_sectors = count >> BDRV_SECTOR_BITS;
1049     if (nb_sectors > 0) {
1050         if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1051             return ret;
1052         sector_num += nb_sectors;
1053         len = nb_sectors << BDRV_SECTOR_BITS;
1054         buf += len;
1055         count -= len;
1056     }
1057
1058     /* add data from the last sector */
1059     if (count > 0) {
1060         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1061             return ret;
1062         memcpy(tmp_buf, buf, count);
1063         if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1064             return ret;
1065     }
1066     return count1;
1067 }
1068
1069 /*
1070  * Writes to the file and ensures that no writes are reordered across this
1071  * request (acts as a barrier)
1072  *
1073  * Returns 0 on success, -errno in error cases.
1074  */
1075 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1076     const void *buf, int count)
1077 {
1078     int ret;
1079
1080     ret = bdrv_pwrite(bs, offset, buf, count);
1081     if (ret < 0) {
1082         return ret;
1083     }
1084
1085     /* No flush needed for cache=writethrough, it uses O_DSYNC */
1086     if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) {
1087         bdrv_flush(bs);
1088     }
1089
1090     return 0;
1091 }
1092
1093 /*
1094  * Writes to the file and ensures that no writes are reordered across this
1095  * request (acts as a barrier)
1096  *
1097  * Returns 0 on success, -errno in error cases.
1098  */
1099 int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num,
1100     const uint8_t *buf, int nb_sectors)
1101 {
1102     return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num,
1103         buf, BDRV_SECTOR_SIZE * nb_sectors);
1104 }
1105
1106 /**
1107  * Truncate file to 'offset' bytes (needed only for file protocols)
1108  */
1109 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1110 {
1111     BlockDriver *drv = bs->drv;
1112     int ret;
1113     if (!drv)
1114         return -ENOMEDIUM;
1115     if (!drv->bdrv_truncate)
1116         return -ENOTSUP;
1117     if (bs->read_only)
1118         return -EACCES;
1119     ret = drv->bdrv_truncate(bs, offset);
1120     if (ret == 0) {
1121         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1122     }
1123     return ret;
1124 }
1125
1126 /**
1127  * Length of a file in bytes. Return < 0 if error or unknown.
1128  */
1129 int64_t bdrv_getlength(BlockDriverState *bs)
1130 {
1131     BlockDriver *drv = bs->drv;
1132     if (!drv)
1133         return -ENOMEDIUM;
1134
1135     /* Fixed size devices use the total_sectors value for speed instead of
1136        issuing a length query (like lseek) on each call.  Also, legacy block
1137        drivers don't provide a bdrv_getlength function and must use
1138        total_sectors. */
1139     if (!bs->growable || !drv->bdrv_getlength) {
1140         return bs->total_sectors * BDRV_SECTOR_SIZE;
1141     }
1142     return drv->bdrv_getlength(bs);
1143 }
1144
1145 /* return 0 as number of sectors if no device present or error */
1146 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1147 {
1148     int64_t length;
1149     length = bdrv_getlength(bs);
1150     if (length < 0)
1151         length = 0;
1152     else
1153         length = length >> BDRV_SECTOR_BITS;
1154     *nb_sectors_ptr = length;
1155 }
1156
1157 struct partition {
1158         uint8_t boot_ind;           /* 0x80 - active */
1159         uint8_t head;               /* starting head */
1160         uint8_t sector;             /* starting sector */
1161         uint8_t cyl;                /* starting cylinder */
1162         uint8_t sys_ind;            /* What partition type */
1163         uint8_t end_head;           /* end head */
1164         uint8_t end_sector;         /* end sector */
1165         uint8_t end_cyl;            /* end cylinder */
1166         uint32_t start_sect;        /* starting sector counting from 0 */
1167         uint32_t nr_sects;          /* nr of sectors in partition */
1168 } __attribute__((packed));
1169
1170 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1171 static int guess_disk_lchs(BlockDriverState *bs,
1172                            int *pcylinders, int *pheads, int *psectors)
1173 {
1174     uint8_t buf[BDRV_SECTOR_SIZE];
1175     int ret, i, heads, sectors, cylinders;
1176     struct partition *p;
1177     uint32_t nr_sects;
1178     uint64_t nb_sectors;
1179
1180     bdrv_get_geometry(bs, &nb_sectors);
1181
1182     ret = bdrv_read(bs, 0, buf, 1);
1183     if (ret < 0)
1184         return -1;
1185     /* test msdos magic */
1186     if (buf[510] != 0x55 || buf[511] != 0xaa)
1187         return -1;
1188     for(i = 0; i < 4; i++) {
1189         p = ((struct partition *)(buf + 0x1be)) + i;
1190         nr_sects = le32_to_cpu(p->nr_sects);
1191         if (nr_sects && p->end_head) {
1192             /* We make the assumption that the partition terminates on
1193                a cylinder boundary */
1194             heads = p->end_head + 1;
1195             sectors = p->end_sector & 63;
1196             if (sectors == 0)
1197                 continue;
1198             cylinders = nb_sectors / (heads * sectors);
1199             if (cylinders < 1 || cylinders > 16383)
1200                 continue;
1201             *pheads = heads;
1202             *psectors = sectors;
1203             *pcylinders = cylinders;
1204 #if 0
1205             printf("guessed geometry: LCHS=%d %d %d\n",
1206                    cylinders, heads, sectors);
1207 #endif
1208             return 0;
1209         }
1210     }
1211     return -1;
1212 }
1213
1214 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1215 {
1216     int translation, lba_detected = 0;
1217     int cylinders, heads, secs;
1218     uint64_t nb_sectors;
1219
1220     /* if a geometry hint is available, use it */
1221     bdrv_get_geometry(bs, &nb_sectors);
1222     bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1223     translation = bdrv_get_translation_hint(bs);
1224     if (cylinders != 0) {
1225         *pcyls = cylinders;
1226         *pheads = heads;
1227         *psecs = secs;
1228     } else {
1229         if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1230             if (heads > 16) {
1231                 /* if heads > 16, it means that a BIOS LBA
1232                    translation was active, so the default
1233                    hardware geometry is OK */
1234                 lba_detected = 1;
1235                 goto default_geometry;
1236             } else {
1237                 *pcyls = cylinders;
1238                 *pheads = heads;
1239                 *psecs = secs;
1240                 /* disable any translation to be in sync with
1241                    the logical geometry */
1242                 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
1243                     bdrv_set_translation_hint(bs,
1244                                               BIOS_ATA_TRANSLATION_NONE);
1245                 }
1246             }
1247         } else {
1248         default_geometry:
1249             /* if no geometry, use a standard physical disk geometry */
1250             cylinders = nb_sectors / (16 * 63);
1251
1252             if (cylinders > 16383)
1253                 cylinders = 16383;
1254             else if (cylinders < 2)
1255                 cylinders = 2;
1256             *pcyls = cylinders;
1257             *pheads = 16;
1258             *psecs = 63;
1259             if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
1260                 if ((*pcyls * *pheads) <= 131072) {
1261                     bdrv_set_translation_hint(bs,
1262                                               BIOS_ATA_TRANSLATION_LARGE);
1263                 } else {
1264                     bdrv_set_translation_hint(bs,
1265                                               BIOS_ATA_TRANSLATION_LBA);
1266                 }
1267             }
1268         }
1269         bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1270     }
1271 }
1272
1273 void bdrv_set_geometry_hint(BlockDriverState *bs,
1274                             int cyls, int heads, int secs)
1275 {
1276     bs->cyls = cyls;
1277     bs->heads = heads;
1278     bs->secs = secs;
1279 }
1280
1281 void bdrv_set_type_hint(BlockDriverState *bs, int type)
1282 {
1283     bs->type = type;
1284     bs->removable = ((type == BDRV_TYPE_CDROM ||
1285                       type == BDRV_TYPE_FLOPPY));
1286 }
1287
1288 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1289 {
1290     bs->translation = translation;
1291 }
1292
1293 void bdrv_get_geometry_hint(BlockDriverState *bs,
1294                             int *pcyls, int *pheads, int *psecs)
1295 {
1296     *pcyls = bs->cyls;
1297     *pheads = bs->heads;
1298     *psecs = bs->secs;
1299 }
1300
1301 int bdrv_get_type_hint(BlockDriverState *bs)
1302 {
1303     return bs->type;
1304 }
1305
1306 int bdrv_get_translation_hint(BlockDriverState *bs)
1307 {
1308     return bs->translation;
1309 }
1310
1311 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1312                        BlockErrorAction on_write_error)
1313 {
1314     bs->on_read_error = on_read_error;
1315     bs->on_write_error = on_write_error;
1316 }
1317
1318 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
1319 {
1320     return is_read ? bs->on_read_error : bs->on_write_error;
1321 }
1322
1323 void bdrv_set_removable(BlockDriverState *bs, int removable)
1324 {
1325     bs->removable = removable;
1326     if (removable && bs == bs_snapshots) {
1327         bs_snapshots = NULL;
1328     }
1329 }
1330
1331 int bdrv_is_removable(BlockDriverState *bs)
1332 {
1333     return bs->removable;
1334 }
1335
1336 int bdrv_is_read_only(BlockDriverState *bs)
1337 {
1338     return bs->read_only;
1339 }
1340
1341 int bdrv_is_sg(BlockDriverState *bs)
1342 {
1343     return bs->sg;
1344 }
1345
1346 int bdrv_enable_write_cache(BlockDriverState *bs)
1347 {
1348     return bs->enable_write_cache;
1349 }
1350
1351 /* XXX: no longer used */
1352 void bdrv_set_change_cb(BlockDriverState *bs,
1353                         void (*change_cb)(void *opaque), void *opaque)
1354 {
1355     bs->change_cb = change_cb;
1356     bs->change_opaque = opaque;
1357 }
1358
1359 int bdrv_is_encrypted(BlockDriverState *bs)
1360 {
1361     if (bs->backing_hd && bs->backing_hd->encrypted)
1362         return 1;
1363     return bs->encrypted;
1364 }
1365
1366 int bdrv_key_required(BlockDriverState *bs)
1367 {
1368     BlockDriverState *backing_hd = bs->backing_hd;
1369
1370     if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
1371         return 1;
1372     return (bs->encrypted && !bs->valid_key);
1373 }
1374
1375 int bdrv_set_key(BlockDriverState *bs, const char *key)
1376 {
1377     int ret;
1378     if (bs->backing_hd && bs->backing_hd->encrypted) {
1379         ret = bdrv_set_key(bs->backing_hd, key);
1380         if (ret < 0)
1381             return ret;
1382         if (!bs->encrypted)
1383             return 0;
1384     }
1385     if (!bs->encrypted) {
1386         return -EINVAL;
1387     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1388         return -ENOMEDIUM;
1389     }
1390     ret = bs->drv->bdrv_set_key(bs, key);
1391     if (ret < 0) {
1392         bs->valid_key = 0;
1393     } else if (!bs->valid_key) {
1394         bs->valid_key = 1;
1395         /* call the change callback now, we skipped it on open */
1396         bs->media_changed = 1;
1397         if (bs->change_cb)
1398             bs->change_cb(bs->change_opaque);
1399     }
1400     return ret;
1401 }
1402
1403 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1404 {
1405     if (!bs->drv) {
1406         buf[0] = '\0';
1407     } else {
1408         pstrcpy(buf, buf_size, bs->drv->format_name);
1409     }
1410 }
1411
1412 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
1413                          void *opaque)
1414 {
1415     BlockDriver *drv;
1416
1417     QLIST_FOREACH(drv, &bdrv_drivers, list) {
1418         it(opaque, drv->format_name);
1419     }
1420 }
1421
1422 BlockDriverState *bdrv_find(const char *name)
1423 {
1424     BlockDriverState *bs;
1425
1426     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1427         if (!strcmp(name, bs->device_name)) {
1428             return bs;
1429         }
1430     }
1431     return NULL;
1432 }
1433
1434 BlockDriverState *bdrv_next(BlockDriverState *bs)
1435 {
1436     if (!bs) {
1437         return QTAILQ_FIRST(&bdrv_states);
1438     }
1439     return QTAILQ_NEXT(bs, list);
1440 }
1441
1442 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1443 {
1444     BlockDriverState *bs;
1445
1446     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1447         it(opaque, bs);
1448     }
1449 }
1450
1451 const char *bdrv_get_device_name(BlockDriverState *bs)
1452 {
1453     return bs->device_name;
1454 }
1455
1456 void bdrv_flush(BlockDriverState *bs)
1457 {
1458     if (bs->open_flags & BDRV_O_NO_FLUSH) {
1459         return;
1460     }
1461
1462     if (bs->drv && bs->drv->bdrv_flush)
1463         bs->drv->bdrv_flush(bs);
1464 }
1465
1466 void bdrv_flush_all(void)
1467 {
1468     BlockDriverState *bs;
1469
1470     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1471         if (bs->drv && !bdrv_is_read_only(bs) &&
1472             (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) {
1473             bdrv_flush(bs);
1474         }
1475     }
1476 }
1477
1478 int bdrv_has_zero_init(BlockDriverState *bs)
1479 {
1480     assert(bs->drv);
1481
1482     if (bs->drv->bdrv_has_zero_init) {
1483         return bs->drv->bdrv_has_zero_init(bs);
1484     }
1485
1486     return 1;
1487 }
1488
1489 /*
1490  * Returns true iff the specified sector is present in the disk image. Drivers
1491  * not implementing the functionality are assumed to not support backing files,
1492  * hence all their sectors are reported as allocated.
1493  *
1494  * 'pnum' is set to the number of sectors (including and immediately following
1495  * the specified sector) that are known to be in the same
1496  * allocated/unallocated state.
1497  *
1498  * 'nb_sectors' is the max value 'pnum' should be set to.
1499  */
1500 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1501         int *pnum)
1502 {
1503     int64_t n;
1504     if (!bs->drv->bdrv_is_allocated) {
1505         if (sector_num >= bs->total_sectors) {
1506             *pnum = 0;
1507             return 0;
1508         }
1509         n = bs->total_sectors - sector_num;
1510         *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1511         return 1;
1512     }
1513     return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1514 }
1515
1516 void bdrv_mon_event(const BlockDriverState *bdrv,
1517                     BlockMonEventAction action, int is_read)
1518 {
1519     QObject *data;
1520     const char *action_str;
1521
1522     switch (action) {
1523     case BDRV_ACTION_REPORT:
1524         action_str = "report";
1525         break;
1526     case BDRV_ACTION_IGNORE:
1527         action_str = "ignore";
1528         break;
1529     case BDRV_ACTION_STOP:
1530         action_str = "stop";
1531         break;
1532     default:
1533         abort();
1534     }
1535
1536     data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1537                               bdrv->device_name,
1538                               action_str,
1539                               is_read ? "read" : "write");
1540     monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);
1541
1542     qobject_decref(data);
1543 }
1544
1545 static void bdrv_print_dict(QObject *obj, void *opaque)
1546 {
1547     QDict *bs_dict;
1548     Monitor *mon = opaque;
1549
1550     bs_dict = qobject_to_qdict(obj);
1551
1552     monitor_printf(mon, "%s: type=%s removable=%d",
1553                         qdict_get_str(bs_dict, "device"),
1554                         qdict_get_str(bs_dict, "type"),
1555                         qdict_get_bool(bs_dict, "removable"));
1556
1557     if (qdict_get_bool(bs_dict, "removable")) {
1558         monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked"));
1559     }
1560
1561     if (qdict_haskey(bs_dict, "inserted")) {
1562         QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
1563
1564         monitor_printf(mon, " file=");
1565         monitor_print_filename(mon, qdict_get_str(qdict, "file"));
1566         if (qdict_haskey(qdict, "backing_file")) {
1567             monitor_printf(mon, " backing_file=");
1568             monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
1569         }
1570         monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
1571                             qdict_get_bool(qdict, "ro"),
1572                             qdict_get_str(qdict, "drv"),
1573                             qdict_get_bool(qdict, "encrypted"));
1574     } else {
1575         monitor_printf(mon, " [not inserted]");
1576     }
1577
1578     monitor_printf(mon, "\n");
1579 }
1580
1581 void bdrv_info_print(Monitor *mon, const QObject *data)
1582 {
1583     qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
1584 }
1585
1586 void bdrv_info(Monitor *mon, QObject **ret_data)
1587 {
1588     QList *bs_list;
1589     BlockDriverState *bs;
1590
1591     bs_list = qlist_new();
1592
1593     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1594         QObject *bs_obj;
1595         const char *type = "unknown";
1596
1597         switch(bs->type) {
1598         case BDRV_TYPE_HD:
1599             type = "hd";
1600             break;
1601         case BDRV_TYPE_CDROM:
1602             type = "cdrom";
1603             break;
1604         case BDRV_TYPE_FLOPPY:
1605             type = "floppy";
1606             break;
1607         }
1608
1609         bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, "
1610                                     "'removable': %i, 'locked': %i }",
1611                                     bs->device_name, type, bs->removable,
1612                                     bs->locked);
1613
1614         if (bs->drv) {
1615             QObject *obj;
1616             QDict *bs_dict = qobject_to_qdict(bs_obj);
1617
1618             obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
1619                                      "'encrypted': %i }",
1620                                      bs->filename, bs->read_only,
1621                                      bs->drv->format_name,
1622                                      bdrv_is_encrypted(bs));
1623             if (bs->backing_file[0] != '\0') {
1624                 QDict *qdict = qobject_to_qdict(obj);
1625                 qdict_put(qdict, "backing_file",
1626                           qstring_from_str(bs->backing_file));
1627             }
1628
1629             qdict_put_obj(bs_dict, "inserted", obj);
1630         }
1631         qlist_append_obj(bs_list, bs_obj);
1632     }
1633
1634     *ret_data = QOBJECT(bs_list);
1635 }
1636
1637 static void bdrv_stats_iter(QObject *data, void *opaque)
1638 {
1639     QDict *qdict;
1640     Monitor *mon = opaque;
1641
1642     qdict = qobject_to_qdict(data);
1643     monitor_printf(mon, "%s:", qdict_get_str(qdict, "device"));
1644
1645     qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
1646     monitor_printf(mon, " rd_bytes=%" PRId64
1647                         " wr_bytes=%" PRId64
1648                         " rd_operations=%" PRId64
1649                         " wr_operations=%" PRId64
1650                         "\n",
1651                         qdict_get_int(qdict, "rd_bytes"),
1652                         qdict_get_int(qdict, "wr_bytes"),
1653                         qdict_get_int(qdict, "rd_operations"),
1654                         qdict_get_int(qdict, "wr_operations"));
1655 }
1656
1657 void bdrv_stats_print(Monitor *mon, const QObject *data)
1658 {
1659     qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
1660 }
1661
1662 static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
1663 {
1664     QObject *res;
1665     QDict *dict;
1666
1667     res = qobject_from_jsonf("{ 'stats': {"
1668                              "'rd_bytes': %" PRId64 ","
1669                              "'wr_bytes': %" PRId64 ","
1670                              "'rd_operations': %" PRId64 ","
1671                              "'wr_operations': %" PRId64 ","
1672                              "'wr_highest_offset': %" PRId64
1673                              "} }",
1674                              bs->rd_bytes, bs->wr_bytes,
1675                              bs->rd_ops, bs->wr_ops,
1676                              bs->wr_highest_sector *
1677                              (uint64_t)BDRV_SECTOR_SIZE);
1678     dict  = qobject_to_qdict(res);
1679
1680     if (*bs->device_name) {
1681         qdict_put(dict, "device", qstring_from_str(bs->device_name));
1682     }
1683
1684     if (bs->file) {
1685         QObject *parent = bdrv_info_stats_bs(bs->file);
1686         qdict_put_obj(dict, "parent", parent);
1687     }
1688
1689     return res;
1690 }
1691
1692 void bdrv_info_stats(Monitor *mon, QObject **ret_data)
1693 {
1694     QObject *obj;
1695     QList *devices;
1696     BlockDriverState *bs;
1697
1698     devices = qlist_new();
1699
1700     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1701         obj = bdrv_info_stats_bs(bs);
1702         qlist_append_obj(devices, obj);
1703     }
1704
1705     *ret_data = QOBJECT(devices);
1706 }
1707
1708 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1709 {
1710     if (bs->backing_hd && bs->backing_hd->encrypted)
1711         return bs->backing_file;
1712     else if (bs->encrypted)
1713         return bs->filename;
1714     else
1715         return NULL;
1716 }
1717
1718 void bdrv_get_backing_filename(BlockDriverState *bs,
1719                                char *filename, int filename_size)
1720 {
1721     if (!bs->backing_file) {
1722         pstrcpy(filename, filename_size, "");
1723     } else {
1724         pstrcpy(filename, filename_size, bs->backing_file);
1725     }
1726 }
1727
1728 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1729                           const uint8_t *buf, int nb_sectors)
1730 {
1731     BlockDriver *drv = bs->drv;
1732     if (!drv)
1733         return -ENOMEDIUM;
1734     if (!drv->bdrv_write_compressed)
1735         return -ENOTSUP;
1736     if (bdrv_check_request(bs, sector_num, nb_sectors))
1737         return -EIO;
1738
1739     if (bs->dirty_bitmap) {
1740         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1741     }
1742
1743     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1744 }
1745
1746 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1747 {
1748     BlockDriver *drv = bs->drv;
1749     if (!drv)
1750         return -ENOMEDIUM;
1751     if (!drv->bdrv_get_info)
1752         return -ENOTSUP;
1753     memset(bdi, 0, sizeof(*bdi));
1754     return drv->bdrv_get_info(bs, bdi);
1755 }
1756
1757 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1758                       int64_t pos, int size)
1759 {
1760     BlockDriver *drv = bs->drv;
1761     if (!drv)
1762         return -ENOMEDIUM;
1763     if (drv->bdrv_save_vmstate)
1764         return drv->bdrv_save_vmstate(bs, buf, pos, size);
1765     if (bs->file)
1766         return bdrv_save_vmstate(bs->file, buf, pos, size);
1767     return -ENOTSUP;
1768 }
1769
1770 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
1771                       int64_t pos, int size)
1772 {
1773     BlockDriver *drv = bs->drv;
1774     if (!drv)
1775         return -ENOMEDIUM;
1776     if (drv->bdrv_load_vmstate)
1777         return drv->bdrv_load_vmstate(bs, buf, pos, size);
1778     if (bs->file)
1779         return bdrv_load_vmstate(bs->file, buf, pos, size);
1780     return -ENOTSUP;
1781 }
1782
1783 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
1784 {
1785     BlockDriver *drv = bs->drv;
1786
1787     if (!drv || !drv->bdrv_debug_event) {
1788         return;
1789     }
1790
1791     return drv->bdrv_debug_event(bs, event);
1792
1793 }
1794
1795 /**************************************************************/
1796 /* handling of snapshots */
1797
1798 int bdrv_can_snapshot(BlockDriverState *bs)
1799 {
1800     BlockDriver *drv = bs->drv;
1801     if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
1802         return 0;
1803     }
1804
1805     if (!drv->bdrv_snapshot_create) {
1806         if (bs->file != NULL) {
1807             return bdrv_can_snapshot(bs->file);
1808         }
1809         return 0;
1810     }
1811
1812     return 1;
1813 }
1814
1815 int bdrv_is_snapshot(BlockDriverState *bs)
1816 {
1817     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
1818 }
1819
1820 BlockDriverState *bdrv_snapshots(void)
1821 {
1822     BlockDriverState *bs;
1823
1824     if (bs_snapshots) {
1825         return bs_snapshots;
1826     }
1827
1828     bs = NULL;
1829     while ((bs = bdrv_next(bs))) {
1830         if (bdrv_can_snapshot(bs)) {
1831             bs_snapshots = bs;
1832             return bs;
1833         }
1834     }
1835     return NULL;
1836 }
1837
1838 int bdrv_snapshot_create(BlockDriverState *bs,
1839                          QEMUSnapshotInfo *sn_info)
1840 {
1841     BlockDriver *drv = bs->drv;
1842     if (!drv)
1843         return -ENOMEDIUM;
1844     if (drv->bdrv_snapshot_create)
1845         return drv->bdrv_snapshot_create(bs, sn_info);
1846     if (bs->file)
1847         return bdrv_snapshot_create(bs->file, sn_info);
1848     return -ENOTSUP;
1849 }
1850
1851 int bdrv_snapshot_goto(BlockDriverState *bs,
1852                        const char *snapshot_id)
1853 {
1854     BlockDriver *drv = bs->drv;
1855     int ret, open_ret;
1856
1857     if (!drv)
1858         return -ENOMEDIUM;
1859     if (drv->bdrv_snapshot_goto)
1860         return drv->bdrv_snapshot_goto(bs, snapshot_id);
1861
1862     if (bs->file) {
1863         drv->bdrv_close(bs);
1864         ret = bdrv_snapshot_goto(bs->file, snapshot_id);
1865         open_ret = drv->bdrv_open(bs, bs->open_flags);
1866         if (open_ret < 0) {
1867             bdrv_delete(bs->file);
1868             bs->drv = NULL;
1869             return open_ret;
1870         }
1871         return ret;
1872     }
1873
1874     return -ENOTSUP;
1875 }
1876
1877 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1878 {
1879     BlockDriver *drv = bs->drv;
1880     if (!drv)
1881         return -ENOMEDIUM;
1882     if (drv->bdrv_snapshot_delete)
1883         return drv->bdrv_snapshot_delete(bs, snapshot_id);
1884     if (bs->file)
1885         return bdrv_snapshot_delete(bs->file, snapshot_id);
1886     return -ENOTSUP;
1887 }
1888
1889 int bdrv_snapshot_list(BlockDriverState *bs,
1890                        QEMUSnapshotInfo **psn_info)
1891 {
1892     BlockDriver *drv = bs->drv;
1893     if (!drv)
1894         return -ENOMEDIUM;
1895     if (drv->bdrv_snapshot_list)
1896         return drv->bdrv_snapshot_list(bs, psn_info);
1897     if (bs->file)
1898         return bdrv_snapshot_list(bs->file, psn_info);
1899     return -ENOTSUP;
1900 }
1901
1902 #define NB_SUFFIXES 4
1903
1904 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
1905 {
1906     static const char suffixes[NB_SUFFIXES] = "KMGT";
1907     int64_t base;
1908     int i;
1909
1910     if (size <= 999) {
1911         snprintf(buf, buf_size, "%" PRId64, size);
1912     } else {
1913         base = 1024;
1914         for(i = 0; i < NB_SUFFIXES; i++) {
1915             if (size < (10 * base)) {
1916                 snprintf(buf, buf_size, "%0.1f%c",
1917                          (double)size / base,
1918                          suffixes[i]);
1919                 break;
1920             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1921                 snprintf(buf, buf_size, "%" PRId64 "%c",
1922                          ((size + (base >> 1)) / base),
1923                          suffixes[i]);
1924                 break;
1925             }
1926             base = base * 1024;
1927         }
1928     }
1929     return buf;
1930 }
1931
1932 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1933 {
1934     char buf1[128], date_buf[128], clock_buf[128];
1935 #ifdef _WIN32
1936     struct tm *ptm;
1937 #else
1938     struct tm tm;
1939 #endif
1940     time_t ti;
1941     int64_t secs;
1942
1943     if (!sn) {
1944         snprintf(buf, buf_size,
1945                  "%-10s%-20s%7s%20s%15s",
1946                  "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1947     } else {
1948         ti = sn->date_sec;
1949 #ifdef _WIN32
1950         ptm = localtime(&ti);
1951         strftime(date_buf, sizeof(date_buf),
1952                  "%Y-%m-%d %H:%M:%S", ptm);
1953 #else
1954         localtime_r(&ti, &tm);
1955         strftime(date_buf, sizeof(date_buf),
1956                  "%Y-%m-%d %H:%M:%S", &tm);
1957 #endif
1958         secs = sn->vm_clock_nsec / 1000000000;
1959         snprintf(clock_buf, sizeof(clock_buf),
1960                  "%02d:%02d:%02d.%03d",
1961                  (int)(secs / 3600),
1962                  (int)((secs / 60) % 60),
1963                  (int)(secs % 60),
1964                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
1965         snprintf(buf, buf_size,
1966                  "%-10s%-20s%7s%20s%15s",
1967                  sn->id_str, sn->name,
1968                  get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1969                  date_buf,
1970                  clock_buf);
1971     }
1972     return buf;
1973 }
1974
1975
1976 /**************************************************************/
1977 /* async I/Os */
1978
1979 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1980                                  QEMUIOVector *qiov, int nb_sectors,
1981                                  BlockDriverCompletionFunc *cb, void *opaque)
1982 {
1983     BlockDriver *drv = bs->drv;
1984     BlockDriverAIOCB *ret;
1985
1986     if (!drv)
1987         return NULL;
1988     if (bdrv_check_request(bs, sector_num, nb_sectors))
1989         return NULL;
1990
1991     ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
1992                               cb, opaque);
1993
1994     if (ret) {
1995         /* Update stats even though technically transfer has not happened. */
1996         bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1997         bs->rd_ops ++;
1998     }
1999
2000     return ret;
2001 }
2002
2003 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2004                                   QEMUIOVector *qiov, int nb_sectors,
2005                                   BlockDriverCompletionFunc *cb, void *opaque)
2006 {
2007     BlockDriver *drv = bs->drv;
2008     BlockDriverAIOCB *ret;
2009
2010     if (!drv)
2011         return NULL;
2012     if (bs->read_only)
2013         return NULL;
2014     if (bdrv_check_request(bs, sector_num, nb_sectors))
2015         return NULL;
2016
2017     if (bs->dirty_bitmap) {
2018         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2019     }
2020
2021     ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
2022                                cb, opaque);
2023
2024     if (ret) {
2025         /* Update stats even though technically transfer has not happened. */
2026         bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2027         bs->wr_ops ++;
2028         if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2029             bs->wr_highest_sector = sector_num + nb_sectors - 1;
2030         }
2031     }
2032
2033     return ret;
2034 }
2035
2036
2037 typedef struct MultiwriteCB {
2038     int error;
2039     int num_requests;
2040     int num_callbacks;
2041     struct {
2042         BlockDriverCompletionFunc *cb;
2043         void *opaque;
2044         QEMUIOVector *free_qiov;
2045         void *free_buf;
2046     } callbacks[];
2047 } MultiwriteCB;
2048
2049 static void multiwrite_user_cb(MultiwriteCB *mcb)
2050 {
2051     int i;
2052
2053     for (i = 0; i < mcb->num_callbacks; i++) {
2054         mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
2055         if (mcb->callbacks[i].free_qiov) {
2056             qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
2057         }
2058         qemu_free(mcb->callbacks[i].free_qiov);
2059         qemu_vfree(mcb->callbacks[i].free_buf);
2060     }
2061 }
2062
2063 static void multiwrite_cb(void *opaque, int ret)
2064 {
2065     MultiwriteCB *mcb = opaque;
2066
2067     trace_multiwrite_cb(mcb, ret);
2068
2069     if (ret < 0 && !mcb->error) {
2070         mcb->error = ret;
2071     }
2072
2073     mcb->num_requests--;
2074     if (mcb->num_requests == 0) {
2075         multiwrite_user_cb(mcb);
2076         qemu_free(mcb);
2077     }
2078 }
2079
2080 static int multiwrite_req_compare(const void *a, const void *b)
2081 {
2082     const BlockRequest *req1 = a, *req2 = b;
2083
2084     /*
2085      * Note that we can't simply subtract req2->sector from req1->sector
2086      * here as that could overflow the return value.
2087      */
2088     if (req1->sector > req2->sector) {
2089         return 1;
2090     } else if (req1->sector < req2->sector) {
2091         return -1;
2092     } else {
2093         return 0;
2094     }
2095 }
2096
2097 /*
2098  * Takes a bunch of requests and tries to merge them. Returns the number of
2099  * requests that remain after merging.
2100  */
2101 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2102     int num_reqs, MultiwriteCB *mcb)
2103 {
2104     int i, outidx;
2105
2106     // Sort requests by start sector
2107     qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
2108
2109     // Check if adjacent requests touch the same clusters. If so, combine them,
2110     // filling up gaps with zero sectors.
2111     outidx = 0;
2112     for (i = 1; i < num_reqs; i++) {
2113         int merge = 0;
2114         int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
2115
2116         // This handles the cases that are valid for all block drivers, namely
2117         // exactly sequential writes and overlapping writes.
2118         if (reqs[i].sector <= oldreq_last) {
2119             merge = 1;
2120         }
2121
2122         // The block driver may decide that it makes sense to combine requests
2123         // even if there is a gap of some sectors between them. In this case,
2124         // the gap is filled with zeros (therefore only applicable for yet
2125         // unused space in format like qcow2).
2126         if (!merge && bs->drv->bdrv_merge_requests) {
2127             merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2128         }
2129
2130         if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2131             merge = 0;
2132         }
2133
2134         if (merge) {
2135             size_t size;
2136             QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov));
2137             qemu_iovec_init(qiov,
2138                 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2139
2140             // Add the first request to the merged one. If the requests are
2141             // overlapping, drop the last sectors of the first request.
2142             size = (reqs[i].sector - reqs[outidx].sector) << 9;
2143             qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2144
2145             // We might need to add some zeros between the two requests
2146             if (reqs[i].sector > oldreq_last) {
2147                 size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
2148                 uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2149                 memset(buf, 0, zero_bytes);
2150                 qemu_iovec_add(qiov, buf, zero_bytes);
2151                 mcb->callbacks[i].free_buf = buf;
2152             }
2153
2154             // Add the second request
2155             qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
2156
2157             reqs[outidx].nb_sectors = qiov->size >> 9;
2158             reqs[outidx].qiov = qiov;
2159
2160             mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2161         } else {
2162             outidx++;
2163             reqs[outidx].sector     = reqs[i].sector;
2164             reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2165             reqs[outidx].qiov       = reqs[i].qiov;
2166         }
2167     }
2168
2169     return outidx + 1;
2170 }
2171
2172 /*
2173  * Submit multiple AIO write requests at once.
2174  *
2175  * On success, the function returns 0 and all requests in the reqs array have
2176  * been submitted. In error case this function returns -1, and any of the
2177  * requests may or may not be submitted yet. In particular, this means that the
2178  * callback will be called for some of the requests, for others it won't. The
2179  * caller must check the error field of the BlockRequest to wait for the right
2180  * callbacks (if error != 0, no callback will be called).
2181  *
2182  * The implementation may modify the contents of the reqs array, e.g. to merge
2183  * requests. However, the fields opaque and error are left unmodified as they
2184  * are used to signal failure for a single request to the caller.
2185  */
2186 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2187 {
2188     BlockDriverAIOCB *acb;
2189     MultiwriteCB *mcb;
2190     int i;
2191
2192     if (num_reqs == 0) {
2193         return 0;
2194     }
2195
2196     // Create MultiwriteCB structure
2197     mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
2198     mcb->num_requests = 0;
2199     mcb->num_callbacks = num_reqs;
2200
2201     for (i = 0; i < num_reqs; i++) {
2202         mcb->callbacks[i].cb = reqs[i].cb;
2203         mcb->callbacks[i].opaque = reqs[i].opaque;
2204     }
2205
2206     // Check for mergable requests
2207     num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2208
2209     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
2210
2211     /*
2212      * Run the aio requests. As soon as one request can't be submitted
2213      * successfully, fail all requests that are not yet submitted (we must
2214      * return failure for all requests anyway)
2215      *
2216      * num_requests cannot be set to the right value immediately: If
2217      * bdrv_aio_writev fails for some request, num_requests would be too high
2218      * and therefore multiwrite_cb() would never recognize the multiwrite
2219      * request as completed. We also cannot use the loop variable i to set it
2220      * when the first request fails because the callback may already have been
2221      * called for previously submitted requests. Thus, num_requests must be
2222      * incremented for each request that is submitted.
2223      *
2224      * The problem that callbacks may be called early also means that we need
2225      * to take care that num_requests doesn't become 0 before all requests are
2226      * submitted - multiwrite_cb() would consider the multiwrite request
2227      * completed. A dummy request that is "completed" by a manual call to
2228      * multiwrite_cb() takes care of this.
2229      */
2230     mcb->num_requests = 1;
2231
2232     // Run the aio requests
2233     for (i = 0; i < num_reqs; i++) {
2234         mcb->num_requests++;
2235         acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2236             reqs[i].nb_sectors, multiwrite_cb, mcb);
2237
2238         if (acb == NULL) {
2239             // We can only fail the whole thing if no request has been
2240             // submitted yet. Otherwise we'll wait for the submitted AIOs to
2241             // complete and report the error in the callback.
2242             if (i == 0) {
2243                 trace_bdrv_aio_multiwrite_earlyfail(mcb);
2244                 goto fail;
2245             } else {
2246                 trace_bdrv_aio_multiwrite_latefail(mcb, i);
2247                 multiwrite_cb(mcb, -EIO);
2248                 break;
2249             }
2250         }
2251     }
2252
2253     /* Complete the dummy request */
2254     multiwrite_cb(mcb, 0);
2255
2256     return 0;
2257
2258 fail:
2259     for (i = 0; i < mcb->num_callbacks; i++) {
2260         reqs[i].error = -EIO;
2261     }
2262     qemu_free(mcb);
2263     return -1;
2264 }
2265
2266 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2267         BlockDriverCompletionFunc *cb, void *opaque)
2268 {
2269     BlockDriver *drv = bs->drv;
2270
2271     if (bs->open_flags & BDRV_O_NO_FLUSH) {
2272         return bdrv_aio_noop_em(bs, cb, opaque);
2273     }
2274
2275     if (!drv)
2276         return NULL;
2277     return drv->bdrv_aio_flush(bs, cb, opaque);
2278 }
2279
2280 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
2281 {
2282     acb->pool->cancel(acb);
2283 }
2284
2285
2286 /**************************************************************/
2287 /* async block device emulation */
2288
2289 typedef struct BlockDriverAIOCBSync {
2290     BlockDriverAIOCB common;
2291     QEMUBH *bh;
2292     int ret;
2293     /* vector translation state */
2294     QEMUIOVector *qiov;
2295     uint8_t *bounce;
2296     int is_write;
2297 } BlockDriverAIOCBSync;
2298
2299 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
2300 {
2301     BlockDriverAIOCBSync *acb =
2302         container_of(blockacb, BlockDriverAIOCBSync, common);
2303     qemu_bh_delete(acb->bh);
2304     acb->bh = NULL;
2305     qemu_aio_release(acb);
2306 }
2307
2308 static AIOPool bdrv_em_aio_pool = {
2309     .aiocb_size         = sizeof(BlockDriverAIOCBSync),
2310     .cancel             = bdrv_aio_cancel_em,
2311 };
2312
2313 static void bdrv_aio_bh_cb(void *opaque)
2314 {
2315     BlockDriverAIOCBSync *acb = opaque;
2316
2317     if (!acb->is_write)
2318         qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
2319     qemu_vfree(acb->bounce);
2320     acb->common.cb(acb->common.opaque, acb->ret);
2321     qemu_bh_delete(acb->bh);
2322     acb->bh = NULL;
2323     qemu_aio_release(acb);
2324 }
2325
2326 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2327                                             int64_t sector_num,
2328                                             QEMUIOVector *qiov,
2329                                             int nb_sectors,
2330                                             BlockDriverCompletionFunc *cb,
2331                                             void *opaque,
2332                                             int is_write)
2333
2334 {
2335     BlockDriverAIOCBSync *acb;
2336
2337     acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2338     acb->is_write = is_write;
2339     acb->qiov = qiov;
2340     acb->bounce = qemu_blockalign(bs, qiov->size);
2341
2342     if (!acb->bh)
2343         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2344
2345     if (is_write) {
2346         qemu_iovec_to_buffer(acb->qiov, acb->bounce);
2347         acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2348     } else {
2349         acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2350     }
2351
2352     qemu_bh_schedule(acb->bh);
2353
2354     return &acb->common;
2355 }
2356
2357 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2358         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2359         BlockDriverCompletionFunc *cb, void *opaque)
2360 {
2361     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2362 }
2363
2364 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2365         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2366         BlockDriverCompletionFunc *cb, void *opaque)
2367 {
2368     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
2369 }
2370
2371 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2372         BlockDriverCompletionFunc *cb, void *opaque)
2373 {
2374     BlockDriverAIOCBSync *acb;
2375
2376     acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2377     acb->is_write = 1; /* don't bounce in the completion hadler */
2378     acb->qiov = NULL;
2379     acb->bounce = NULL;
2380     acb->ret = 0;
2381
2382     if (!acb->bh)
2383         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2384
2385     bdrv_flush(bs);
2386     qemu_bh_schedule(acb->bh);
2387     return &acb->common;
2388 }
2389
2390 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2391         BlockDriverCompletionFunc *cb, void *opaque)
2392 {
2393     BlockDriverAIOCBSync *acb;
2394
2395     acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2396     acb->is_write = 1; /* don't bounce in the completion handler */
2397     acb->qiov = NULL;
2398     acb->bounce = NULL;
2399     acb->ret = 0;
2400
2401     if (!acb->bh) {
2402         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2403     }
2404
2405     qemu_bh_schedule(acb->bh);
2406     return &acb->common;
2407 }
2408
2409 /**************************************************************/
2410 /* sync block device emulation */
2411
2412 static void bdrv_rw_em_cb(void *opaque, int ret)
2413 {
2414     *(int *)opaque = ret;
2415 }
2416
2417 #define NOT_DONE 0x7fffffff
2418
2419 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
2420                         uint8_t *buf, int nb_sectors)
2421 {
2422     int async_ret;
2423     BlockDriverAIOCB *acb;
2424     struct iovec iov;
2425     QEMUIOVector qiov;
2426
2427     async_context_push();
2428
2429     async_ret = NOT_DONE;
2430     iov.iov_base = (void *)buf;
2431     iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2432     qemu_iovec_init_external(&qiov, &iov, 1);
2433     acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2434         bdrv_rw_em_cb, &async_ret);
2435     if (acb == NULL) {
2436         async_ret = -1;
2437         goto fail;
2438     }
2439
2440     while (async_ret == NOT_DONE) {
2441         qemu_aio_wait();
2442     }
2443
2444
2445 fail:
2446     async_context_pop();
2447     return async_ret;
2448 }
2449
2450 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2451                          const uint8_t *buf, int nb_sectors)
2452 {
2453     int async_ret;
2454     BlockDriverAIOCB *acb;
2455     struct iovec iov;
2456     QEMUIOVector qiov;
2457
2458     async_context_push();
2459
2460     async_ret = NOT_DONE;
2461     iov.iov_base = (void *)buf;
2462     iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2463     qemu_iovec_init_external(&qiov, &iov, 1);
2464     acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2465         bdrv_rw_em_cb, &async_ret);
2466     if (acb == NULL) {
2467         async_ret = -1;
2468         goto fail;
2469     }
2470     while (async_ret == NOT_DONE) {
2471         qemu_aio_wait();
2472     }
2473
2474 fail:
2475     async_context_pop();
2476     return async_ret;
2477 }
2478
2479 void bdrv_init(void)
2480 {
2481     module_call_init(MODULE_INIT_BLOCK);
2482 }
2483
2484 void bdrv_init_with_whitelist(void)
2485 {
2486     use_bdrv_whitelist = 1;
2487     bdrv_init();
2488 }
2489
2490 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2491                    BlockDriverCompletionFunc *cb, void *opaque)
2492 {
2493     BlockDriverAIOCB *acb;
2494
2495     if (pool->free_aiocb) {
2496         acb = pool->free_aiocb;
2497         pool->free_aiocb = acb->next;
2498     } else {
2499         acb = qemu_mallocz(pool->aiocb_size);
2500         acb->pool = pool;
2501     }
2502     acb->bs = bs;
2503     acb->cb = cb;
2504     acb->opaque = opaque;
2505     return acb;
2506 }
2507
2508 void qemu_aio_release(void *p)
2509 {
2510     BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
2511     AIOPool *pool = acb->pool;
2512     acb->next = pool->free_aiocb;
2513     pool->free_aiocb = acb;
2514 }
2515
2516 /**************************************************************/
2517 /* removable device support */
2518
2519 /**
2520  * Return TRUE if the media is present
2521  */
2522 int bdrv_is_inserted(BlockDriverState *bs)
2523 {
2524     BlockDriver *drv = bs->drv;
2525     int ret;
2526     if (!drv)
2527         return 0;
2528     if (!drv->bdrv_is_inserted)
2529         return !bs->tray_open;
2530     ret = drv->bdrv_is_inserted(bs);
2531     return ret;
2532 }
2533
2534 /**
2535  * Return TRUE if the media changed since the last call to this
2536  * function. It is currently only used for floppy disks
2537  */
2538 int bdrv_media_changed(BlockDriverState *bs)
2539 {
2540     BlockDriver *drv = bs->drv;
2541     int ret;
2542
2543     if (!drv || !drv->bdrv_media_changed)
2544         ret = -ENOTSUP;
2545     else
2546         ret = drv->bdrv_media_changed(bs);
2547     if (ret == -ENOTSUP)
2548         ret = bs->media_changed;
2549     bs->media_changed = 0;
2550     return ret;
2551 }
2552
2553 /**
2554  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
2555  */
2556 int bdrv_eject(BlockDriverState *bs, int eject_flag)
2557 {
2558     BlockDriver *drv = bs->drv;
2559     int ret;
2560
2561     if (bs->locked) {
2562         return -EBUSY;
2563     }
2564
2565     if (!drv || !drv->bdrv_eject) {
2566         ret = -ENOTSUP;
2567     } else {
2568         ret = drv->bdrv_eject(bs, eject_flag);
2569     }
2570     if (ret == -ENOTSUP) {
2571         ret = 0;
2572     }
2573     if (ret >= 0) {
2574         bs->tray_open = eject_flag;
2575     }
2576
2577     return ret;
2578 }
2579
2580 int bdrv_is_locked(BlockDriverState *bs)
2581 {
2582     return bs->locked;
2583 }
2584
2585 /**
2586  * Lock or unlock the media (if it is locked, the user won't be able
2587  * to eject it manually).
2588  */
2589 void bdrv_set_locked(BlockDriverState *bs, int locked)
2590 {
2591     BlockDriver *drv = bs->drv;
2592
2593     bs->locked = locked;
2594     if (drv && drv->bdrv_set_locked) {
2595         drv->bdrv_set_locked(bs, locked);
2596     }
2597 }
2598
2599 /* needed for generic scsi interface */
2600
2601 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2602 {
2603     BlockDriver *drv = bs->drv;
2604
2605     if (drv && drv->bdrv_ioctl)
2606         return drv->bdrv_ioctl(bs, req, buf);
2607     return -ENOTSUP;
2608 }
2609
2610 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
2611         unsigned long int req, void *buf,
2612         BlockDriverCompletionFunc *cb, void *opaque)
2613 {
2614     BlockDriver *drv = bs->drv;
2615
2616     if (drv && drv->bdrv_aio_ioctl)
2617         return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
2618     return NULL;
2619 }
2620
2621
2622
2623 void *qemu_blockalign(BlockDriverState *bs, size_t size)
2624 {
2625     return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
2626 }
2627
2628 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
2629 {
2630     int64_t bitmap_size;
2631
2632     bs->dirty_count = 0;
2633     if (enable) {
2634         if (!bs->dirty_bitmap) {
2635             bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
2636                     BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
2637             bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
2638
2639             bs->dirty_bitmap = qemu_mallocz(bitmap_size);
2640         }
2641     } else {
2642         if (bs->dirty_bitmap) {
2643             qemu_free(bs->dirty_bitmap);
2644             bs->dirty_bitmap = NULL;
2645         }
2646     }
2647 }
2648
2649 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
2650 {
2651     int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
2652
2653     if (bs->dirty_bitmap &&
2654         (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
2655         return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
2656             (1 << (chunk % (sizeof(unsigned long) * 8)));
2657     } else {
2658         return 0;
2659     }
2660 }
2661
2662 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
2663                       int nr_sectors)
2664 {
2665     set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
2666 }
2667
2668 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
2669 {
2670     return bs->dirty_count;
2671 }