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     trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
1987
1988     if (!drv)
1989         return NULL;
1990     if (bdrv_check_request(bs, sector_num, nb_sectors))
1991         return NULL;
1992
1993     ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
1994                               cb, opaque);
1995
1996     if (ret) {
1997         /* Update stats even though technically transfer has not happened. */
1998         bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1999         bs->rd_ops ++;
2000     }
2001
2002     return ret;
2003 }
2004
2005 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2006                                   QEMUIOVector *qiov, int nb_sectors,
2007                                   BlockDriverCompletionFunc *cb, void *opaque)
2008 {
2009     BlockDriver *drv = bs->drv;
2010     BlockDriverAIOCB *ret;
2011
2012     trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
2013
2014     if (!drv)
2015         return NULL;
2016     if (bs->read_only)
2017         return NULL;
2018     if (bdrv_check_request(bs, sector_num, nb_sectors))
2019         return NULL;
2020
2021     if (bs->dirty_bitmap) {
2022         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2023     }
2024
2025     ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
2026                                cb, opaque);
2027
2028     if (ret) {
2029         /* Update stats even though technically transfer has not happened. */
2030         bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2031         bs->wr_ops ++;
2032         if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2033             bs->wr_highest_sector = sector_num + nb_sectors - 1;
2034         }
2035     }
2036
2037     return ret;
2038 }
2039
2040
2041 typedef struct MultiwriteCB {
2042     int error;
2043     int num_requests;
2044     int num_callbacks;
2045     struct {
2046         BlockDriverCompletionFunc *cb;
2047         void *opaque;
2048         QEMUIOVector *free_qiov;
2049         void *free_buf;
2050     } callbacks[];
2051 } MultiwriteCB;
2052
2053 static void multiwrite_user_cb(MultiwriteCB *mcb)
2054 {
2055     int i;
2056
2057     for (i = 0; i < mcb->num_callbacks; i++) {
2058         mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
2059         if (mcb->callbacks[i].free_qiov) {
2060             qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
2061         }
2062         qemu_free(mcb->callbacks[i].free_qiov);
2063         qemu_vfree(mcb->callbacks[i].free_buf);
2064     }
2065 }
2066
2067 static void multiwrite_cb(void *opaque, int ret)
2068 {
2069     MultiwriteCB *mcb = opaque;
2070
2071     trace_multiwrite_cb(mcb, ret);
2072
2073     if (ret < 0 && !mcb->error) {
2074         mcb->error = ret;
2075     }
2076
2077     mcb->num_requests--;
2078     if (mcb->num_requests == 0) {
2079         multiwrite_user_cb(mcb);
2080         qemu_free(mcb);
2081     }
2082 }
2083
2084 static int multiwrite_req_compare(const void *a, const void *b)
2085 {
2086     const BlockRequest *req1 = a, *req2 = b;
2087
2088     /*
2089      * Note that we can't simply subtract req2->sector from req1->sector
2090      * here as that could overflow the return value.
2091      */
2092     if (req1->sector > req2->sector) {
2093         return 1;
2094     } else if (req1->sector < req2->sector) {
2095         return -1;
2096     } else {
2097         return 0;
2098     }
2099 }
2100
2101 /*
2102  * Takes a bunch of requests and tries to merge them. Returns the number of
2103  * requests that remain after merging.
2104  */
2105 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2106     int num_reqs, MultiwriteCB *mcb)
2107 {
2108     int i, outidx;
2109
2110     // Sort requests by start sector
2111     qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
2112
2113     // Check if adjacent requests touch the same clusters. If so, combine them,
2114     // filling up gaps with zero sectors.
2115     outidx = 0;
2116     for (i = 1; i < num_reqs; i++) {
2117         int merge = 0;
2118         int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
2119
2120         // This handles the cases that are valid for all block drivers, namely
2121         // exactly sequential writes and overlapping writes.
2122         if (reqs[i].sector <= oldreq_last) {
2123             merge = 1;
2124         }
2125
2126         // The block driver may decide that it makes sense to combine requests
2127         // even if there is a gap of some sectors between them. In this case,
2128         // the gap is filled with zeros (therefore only applicable for yet
2129         // unused space in format like qcow2).
2130         if (!merge && bs->drv->bdrv_merge_requests) {
2131             merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2132         }
2133
2134         if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2135             merge = 0;
2136         }
2137
2138         if (merge) {
2139             size_t size;
2140             QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov));
2141             qemu_iovec_init(qiov,
2142                 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2143
2144             // Add the first request to the merged one. If the requests are
2145             // overlapping, drop the last sectors of the first request.
2146             size = (reqs[i].sector - reqs[outidx].sector) << 9;
2147             qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2148
2149             // We might need to add some zeros between the two requests
2150             if (reqs[i].sector > oldreq_last) {
2151                 size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
2152                 uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2153                 memset(buf, 0, zero_bytes);
2154                 qemu_iovec_add(qiov, buf, zero_bytes);
2155                 mcb->callbacks[i].free_buf = buf;
2156             }
2157
2158             // Add the second request
2159             qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
2160
2161             reqs[outidx].nb_sectors = qiov->size >> 9;
2162             reqs[outidx].qiov = qiov;
2163
2164             mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2165         } else {
2166             outidx++;
2167             reqs[outidx].sector     = reqs[i].sector;
2168             reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2169             reqs[outidx].qiov       = reqs[i].qiov;
2170         }
2171     }
2172
2173     return outidx + 1;
2174 }
2175
2176 /*
2177  * Submit multiple AIO write requests at once.
2178  *
2179  * On success, the function returns 0 and all requests in the reqs array have
2180  * been submitted. In error case this function returns -1, and any of the
2181  * requests may or may not be submitted yet. In particular, this means that the
2182  * callback will be called for some of the requests, for others it won't. The
2183  * caller must check the error field of the BlockRequest to wait for the right
2184  * callbacks (if error != 0, no callback will be called).
2185  *
2186  * The implementation may modify the contents of the reqs array, e.g. to merge
2187  * requests. However, the fields opaque and error are left unmodified as they
2188  * are used to signal failure for a single request to the caller.
2189  */
2190 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2191 {
2192     BlockDriverAIOCB *acb;
2193     MultiwriteCB *mcb;
2194     int i;
2195
2196     if (num_reqs == 0) {
2197         return 0;
2198     }
2199
2200     // Create MultiwriteCB structure
2201     mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
2202     mcb->num_requests = 0;
2203     mcb->num_callbacks = num_reqs;
2204
2205     for (i = 0; i < num_reqs; i++) {
2206         mcb->callbacks[i].cb = reqs[i].cb;
2207         mcb->callbacks[i].opaque = reqs[i].opaque;
2208     }
2209
2210     // Check for mergable requests
2211     num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2212
2213     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
2214
2215     /*
2216      * Run the aio requests. As soon as one request can't be submitted
2217      * successfully, fail all requests that are not yet submitted (we must
2218      * return failure for all requests anyway)
2219      *
2220      * num_requests cannot be set to the right value immediately: If
2221      * bdrv_aio_writev fails for some request, num_requests would be too high
2222      * and therefore multiwrite_cb() would never recognize the multiwrite
2223      * request as completed. We also cannot use the loop variable i to set it
2224      * when the first request fails because the callback may already have been
2225      * called for previously submitted requests. Thus, num_requests must be
2226      * incremented for each request that is submitted.
2227      *
2228      * The problem that callbacks may be called early also means that we need
2229      * to take care that num_requests doesn't become 0 before all requests are
2230      * submitted - multiwrite_cb() would consider the multiwrite request
2231      * completed. A dummy request that is "completed" by a manual call to
2232      * multiwrite_cb() takes care of this.
2233      */
2234     mcb->num_requests = 1;
2235
2236     // Run the aio requests
2237     for (i = 0; i < num_reqs; i++) {
2238         mcb->num_requests++;
2239         acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2240             reqs[i].nb_sectors, multiwrite_cb, mcb);
2241
2242         if (acb == NULL) {
2243             // We can only fail the whole thing if no request has been
2244             // submitted yet. Otherwise we'll wait for the submitted AIOs to
2245             // complete and report the error in the callback.
2246             if (i == 0) {
2247                 trace_bdrv_aio_multiwrite_earlyfail(mcb);
2248                 goto fail;
2249             } else {
2250                 trace_bdrv_aio_multiwrite_latefail(mcb, i);
2251                 multiwrite_cb(mcb, -EIO);
2252                 break;
2253             }
2254         }
2255     }
2256
2257     /* Complete the dummy request */
2258     multiwrite_cb(mcb, 0);
2259
2260     return 0;
2261
2262 fail:
2263     for (i = 0; i < mcb->num_callbacks; i++) {
2264         reqs[i].error = -EIO;
2265     }
2266     qemu_free(mcb);
2267     return -1;
2268 }
2269
2270 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2271         BlockDriverCompletionFunc *cb, void *opaque)
2272 {
2273     BlockDriver *drv = bs->drv;
2274
2275     if (bs->open_flags & BDRV_O_NO_FLUSH) {
2276         return bdrv_aio_noop_em(bs, cb, opaque);
2277     }
2278
2279     if (!drv)
2280         return NULL;
2281     return drv->bdrv_aio_flush(bs, cb, opaque);
2282 }
2283
2284 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
2285 {
2286     acb->pool->cancel(acb);
2287 }
2288
2289
2290 /**************************************************************/
2291 /* async block device emulation */
2292
2293 typedef struct BlockDriverAIOCBSync {
2294     BlockDriverAIOCB common;
2295     QEMUBH *bh;
2296     int ret;
2297     /* vector translation state */
2298     QEMUIOVector *qiov;
2299     uint8_t *bounce;
2300     int is_write;
2301 } BlockDriverAIOCBSync;
2302
2303 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
2304 {
2305     BlockDriverAIOCBSync *acb =
2306         container_of(blockacb, BlockDriverAIOCBSync, common);
2307     qemu_bh_delete(acb->bh);
2308     acb->bh = NULL;
2309     qemu_aio_release(acb);
2310 }
2311
2312 static AIOPool bdrv_em_aio_pool = {
2313     .aiocb_size         = sizeof(BlockDriverAIOCBSync),
2314     .cancel             = bdrv_aio_cancel_em,
2315 };
2316
2317 static void bdrv_aio_bh_cb(void *opaque)
2318 {
2319     BlockDriverAIOCBSync *acb = opaque;
2320
2321     if (!acb->is_write)
2322         qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
2323     qemu_vfree(acb->bounce);
2324     acb->common.cb(acb->common.opaque, acb->ret);
2325     qemu_bh_delete(acb->bh);
2326     acb->bh = NULL;
2327     qemu_aio_release(acb);
2328 }
2329
2330 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2331                                             int64_t sector_num,
2332                                             QEMUIOVector *qiov,
2333                                             int nb_sectors,
2334                                             BlockDriverCompletionFunc *cb,
2335                                             void *opaque,
2336                                             int is_write)
2337
2338 {
2339     BlockDriverAIOCBSync *acb;
2340
2341     acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2342     acb->is_write = is_write;
2343     acb->qiov = qiov;
2344     acb->bounce = qemu_blockalign(bs, qiov->size);
2345
2346     if (!acb->bh)
2347         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2348
2349     if (is_write) {
2350         qemu_iovec_to_buffer(acb->qiov, acb->bounce);
2351         acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2352     } else {
2353         acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2354     }
2355
2356     qemu_bh_schedule(acb->bh);
2357
2358     return &acb->common;
2359 }
2360
2361 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2362         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2363         BlockDriverCompletionFunc *cb, void *opaque)
2364 {
2365     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2366 }
2367
2368 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2369         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2370         BlockDriverCompletionFunc *cb, void *opaque)
2371 {
2372     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
2373 }
2374
2375 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2376         BlockDriverCompletionFunc *cb, void *opaque)
2377 {
2378     BlockDriverAIOCBSync *acb;
2379
2380     acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2381     acb->is_write = 1; /* don't bounce in the completion hadler */
2382     acb->qiov = NULL;
2383     acb->bounce = NULL;
2384     acb->ret = 0;
2385
2386     if (!acb->bh)
2387         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2388
2389     bdrv_flush(bs);
2390     qemu_bh_schedule(acb->bh);
2391     return &acb->common;
2392 }
2393
2394 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2395         BlockDriverCompletionFunc *cb, void *opaque)
2396 {
2397     BlockDriverAIOCBSync *acb;
2398
2399     acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2400     acb->is_write = 1; /* don't bounce in the completion handler */
2401     acb->qiov = NULL;
2402     acb->bounce = NULL;
2403     acb->ret = 0;
2404
2405     if (!acb->bh) {
2406         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2407     }
2408
2409     qemu_bh_schedule(acb->bh);
2410     return &acb->common;
2411 }
2412
2413 /**************************************************************/
2414 /* sync block device emulation */
2415
2416 static void bdrv_rw_em_cb(void *opaque, int ret)
2417 {
2418     *(int *)opaque = ret;
2419 }
2420
2421 #define NOT_DONE 0x7fffffff
2422
2423 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
2424                         uint8_t *buf, int nb_sectors)
2425 {
2426     int async_ret;
2427     BlockDriverAIOCB *acb;
2428     struct iovec iov;
2429     QEMUIOVector qiov;
2430
2431     async_context_push();
2432
2433     async_ret = NOT_DONE;
2434     iov.iov_base = (void *)buf;
2435     iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2436     qemu_iovec_init_external(&qiov, &iov, 1);
2437     acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2438         bdrv_rw_em_cb, &async_ret);
2439     if (acb == NULL) {
2440         async_ret = -1;
2441         goto fail;
2442     }
2443
2444     while (async_ret == NOT_DONE) {
2445         qemu_aio_wait();
2446     }
2447
2448
2449 fail:
2450     async_context_pop();
2451     return async_ret;
2452 }
2453
2454 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2455                          const uint8_t *buf, int nb_sectors)
2456 {
2457     int async_ret;
2458     BlockDriverAIOCB *acb;
2459     struct iovec iov;
2460     QEMUIOVector qiov;
2461
2462     async_context_push();
2463
2464     async_ret = NOT_DONE;
2465     iov.iov_base = (void *)buf;
2466     iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2467     qemu_iovec_init_external(&qiov, &iov, 1);
2468     acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2469         bdrv_rw_em_cb, &async_ret);
2470     if (acb == NULL) {
2471         async_ret = -1;
2472         goto fail;
2473     }
2474     while (async_ret == NOT_DONE) {
2475         qemu_aio_wait();
2476     }
2477
2478 fail:
2479     async_context_pop();
2480     return async_ret;
2481 }
2482
2483 void bdrv_init(void)
2484 {
2485     module_call_init(MODULE_INIT_BLOCK);
2486 }
2487
2488 void bdrv_init_with_whitelist(void)
2489 {
2490     use_bdrv_whitelist = 1;
2491     bdrv_init();
2492 }
2493
2494 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2495                    BlockDriverCompletionFunc *cb, void *opaque)
2496 {
2497     BlockDriverAIOCB *acb;
2498
2499     if (pool->free_aiocb) {
2500         acb = pool->free_aiocb;
2501         pool->free_aiocb = acb->next;
2502     } else {
2503         acb = qemu_mallocz(pool->aiocb_size);
2504         acb->pool = pool;
2505     }
2506     acb->bs = bs;
2507     acb->cb = cb;
2508     acb->opaque = opaque;
2509     return acb;
2510 }
2511
2512 void qemu_aio_release(void *p)
2513 {
2514     BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
2515     AIOPool *pool = acb->pool;
2516     acb->next = pool->free_aiocb;
2517     pool->free_aiocb = acb;
2518 }
2519
2520 /**************************************************************/
2521 /* removable device support */
2522
2523 /**
2524  * Return TRUE if the media is present
2525  */
2526 int bdrv_is_inserted(BlockDriverState *bs)
2527 {
2528     BlockDriver *drv = bs->drv;
2529     int ret;
2530     if (!drv)
2531         return 0;
2532     if (!drv->bdrv_is_inserted)
2533         return !bs->tray_open;
2534     ret = drv->bdrv_is_inserted(bs);
2535     return ret;
2536 }
2537
2538 /**
2539  * Return TRUE if the media changed since the last call to this
2540  * function. It is currently only used for floppy disks
2541  */
2542 int bdrv_media_changed(BlockDriverState *bs)
2543 {
2544     BlockDriver *drv = bs->drv;
2545     int ret;
2546
2547     if (!drv || !drv->bdrv_media_changed)
2548         ret = -ENOTSUP;
2549     else
2550         ret = drv->bdrv_media_changed(bs);
2551     if (ret == -ENOTSUP)
2552         ret = bs->media_changed;
2553     bs->media_changed = 0;
2554     return ret;
2555 }
2556
2557 /**
2558  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
2559  */
2560 int bdrv_eject(BlockDriverState *bs, int eject_flag)
2561 {
2562     BlockDriver *drv = bs->drv;
2563     int ret;
2564
2565     if (bs->locked) {
2566         return -EBUSY;
2567     }
2568
2569     if (!drv || !drv->bdrv_eject) {
2570         ret = -ENOTSUP;
2571     } else {
2572         ret = drv->bdrv_eject(bs, eject_flag);
2573     }
2574     if (ret == -ENOTSUP) {
2575         ret = 0;
2576     }
2577     if (ret >= 0) {
2578         bs->tray_open = eject_flag;
2579     }
2580
2581     return ret;
2582 }
2583
2584 int bdrv_is_locked(BlockDriverState *bs)
2585 {
2586     return bs->locked;
2587 }
2588
2589 /**
2590  * Lock or unlock the media (if it is locked, the user won't be able
2591  * to eject it manually).
2592  */
2593 void bdrv_set_locked(BlockDriverState *bs, int locked)
2594 {
2595     BlockDriver *drv = bs->drv;
2596
2597     bs->locked = locked;
2598     if (drv && drv->bdrv_set_locked) {
2599         drv->bdrv_set_locked(bs, locked);
2600     }
2601 }
2602
2603 /* needed for generic scsi interface */
2604
2605 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2606 {
2607     BlockDriver *drv = bs->drv;
2608
2609     if (drv && drv->bdrv_ioctl)
2610         return drv->bdrv_ioctl(bs, req, buf);
2611     return -ENOTSUP;
2612 }
2613
2614 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
2615         unsigned long int req, void *buf,
2616         BlockDriverCompletionFunc *cb, void *opaque)
2617 {
2618     BlockDriver *drv = bs->drv;
2619
2620     if (drv && drv->bdrv_aio_ioctl)
2621         return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
2622     return NULL;
2623 }
2624
2625
2626
2627 void *qemu_blockalign(BlockDriverState *bs, size_t size)
2628 {
2629     return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
2630 }
2631
2632 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
2633 {
2634     int64_t bitmap_size;
2635
2636     bs->dirty_count = 0;
2637     if (enable) {
2638         if (!bs->dirty_bitmap) {
2639             bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
2640                     BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
2641             bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
2642
2643             bs->dirty_bitmap = qemu_mallocz(bitmap_size);
2644         }
2645     } else {
2646         if (bs->dirty_bitmap) {
2647             qemu_free(bs->dirty_bitmap);
2648             bs->dirty_bitmap = NULL;
2649         }
2650     }
2651 }
2652
2653 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
2654 {
2655     int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
2656
2657     if (bs->dirty_bitmap &&
2658         (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
2659         return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
2660             (1 << (chunk % (sizeof(unsigned long) * 8)));
2661     } else {
2662         return 0;
2663     }
2664 }
2665
2666 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
2667                       int nr_sectors)
2668 {
2669     set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
2670 }
2671
2672 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
2673 {
2674     return bs->dirty_count;
2675 }