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