block.c

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