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