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