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 #ifdef _BSD
  26 /* include native header before sys-queue.h */
  27 #include <sys/queue.h>
  28 #endif
  29
  30 #include "qemu-common.h"
  31 #include "console.h"
  32 #include "block_int.h"
  33
  34 #ifdef _BSD
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/disk.h>
  39 #endif
  40
  41 #define SECTOR_BITS 9
  42 #define SECTOR_SIZE (1 << SECTOR_BITS)
  43
  44 typedef struct BlockDriverAIOCBSync {
  45     BlockDriverAIOCB common;
  46     QEMUBH *bh;
  47     int ret;
  48 } BlockDriverAIOCBSync;
  49
  50 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
  51         int64_t sector_num, uint8_t *buf, int nb_sectors,
  52         BlockDriverCompletionFunc *cb, void *opaque);
  53 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
  54         int64_t sector_num, const uint8_t *buf, int nb_sectors,
  55         BlockDriverCompletionFunc *cb, void *opaque);
  56 static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
  57 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
  58                         uint8_t *buf, int nb_sectors);
  59 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
  60                          const uint8_t *buf, int nb_sectors);
  61
  62 BlockDriverState *bdrv_first;
  63
  64 static BlockDriver *first_drv;
  65
  66 int path_is_absolute(const char *path)
  67 {
  68     const char *p;
  69 #ifdef _WIN32
  70     /* specific case for names like: "\\.\d:" */
  71     if (*path == '/' || *path == '\\')
  72         return 1;
  73 #endif
  74     p = strchr(path, ':');
  75     if (p)
  76         p++;
  77     else
  78         p = path;
  79 #ifdef _WIN32
  80     return (*p == '/' || *p == '\\');
  81 #else
  82     return (*p == '/');
  83 #endif
  84 }
  85
  86 /* if filename is absolute, just copy it to dest. Otherwise, build a
  87    path to it by considering it is relative to base_path. URL are
  88    supported. */
  89 void path_combine(char *dest, int dest_size,
  90                   const char *base_path,
  91                   const char *filename)
  92 {
  93     const char *p, *p1;
  94     int len;
  95
  96     if (dest_size <= 0)
  97         return;
  98     if (path_is_absolute(filename)) {
  99         pstrcpy(dest, dest_size, filename);
 100     } else {
 101         p = strchr(base_path, ':');
 102         if (p)
 103             p++;
 104         else
 105             p = base_path;
 106         p1 = strrchr(base_path, '/');
 107 #ifdef _WIN32
 108         {
 109             const char *p2;
 110             p2 = strrchr(base_path, '\\');
 111             if (!p1 || p2 > p1)
 112                 p1 = p2;
 113         }
 114 #endif
 115         if (p1)
 116             p1++;
 117         else
 118             p1 = base_path;
 119         if (p1 > p)
 120             p = p1;
 121         len = p - base_path;
 122         if (len > dest_size - 1)
 123             len = dest_size - 1;
 124         memcpy(dest, base_path, len);
 125         dest[len] = '\0';
 126         pstrcat(dest, dest_size, filename);
 127     }
 128 }
 129
 130
 131 static void bdrv_register(BlockDriver *bdrv)
 132 {
 133     if (!bdrv->bdrv_aio_read) {
 134         /* add AIO emulation layer */
 135         bdrv->bdrv_aio_read = bdrv_aio_read_em;
 136         bdrv->bdrv_aio_write = bdrv_aio_write_em;
 137         bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;
 138         bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
 139     } else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) {
 140         /* add synchronous IO emulation layer */
 141         bdrv->bdrv_read = bdrv_read_em;
 142         bdrv->bdrv_write = bdrv_write_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 int bdrv_create(BlockDriver *drv,
 176                 const char *filename, int64_t size_in_sectors,
 177                 const char *backing_file, int flags)
 178 {
 179     if (!drv->bdrv_create)
 180         return -ENOTSUP;
 181     return drv->bdrv_create(filename, size_in_sectors, backing_file, flags);
 182 }
 183
 184 #ifdef _WIN32
 185 void get_tmp_filename(char *filename, int size)
 186 {
 187     char temp_dir[MAX_PATH];
 188
 189     GetTempPath(MAX_PATH, temp_dir);
 190     GetTempFileName(temp_dir, "qem", 0, filename);
 191 }
 192 #else
 193 void get_tmp_filename(char *filename, int size)
 194 {
 195     int fd;
 196     const char *tmpdir;
 197     /* XXX: race condition possible */
 198     tmpdir = getenv("TMPDIR");
 199     if (!tmpdir)
 200         tmpdir = "/tmp";
 201     snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
 202     fd = mkstemp(filename);
 203     close(fd);
 204 }
 205 #endif
 206
 207 #ifdef _WIN32
 208 static int is_windows_drive_prefix(const char *filename)
 209 {
 210     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
 211              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
 212             filename[1] == ':');
 213 }
 214
 215 static int is_windows_drive(const char *filename)
 216 {
 217     if (is_windows_drive_prefix(filename) &&
 218         filename[2] == '\0')
 219         return 1;
 220     if (strstart(filename, "\\\\.\\", NULL) ||
 221         strstart(filename, "//./", NULL))
 222         return 1;
 223     return 0;
 224 }
 225 #endif
 226
 227 static BlockDriver *find_protocol(const char *filename)
 228 {
 229     BlockDriver *drv1;
 230     char protocol[128];
 231     int len;
 232     const char *p;
 233
 234 #ifdef _WIN32
 235     if (is_windows_drive(filename) ||
 236         is_windows_drive_prefix(filename))
 237         return &bdrv_raw;
 238 #endif
 239     p = strchr(filename, ':');
 240     if (!p)
 241         return &bdrv_raw;
 242     len = p - filename;
 243     if (len > sizeof(protocol) - 1)
 244         len = sizeof(protocol) - 1;
 245     memcpy(protocol, filename, len);
 246     protocol[len] = '\0';
 247     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
 248         if (drv1->protocol_name &&
 249             !strcmp(drv1->protocol_name, protocol))
 250             return drv1;
 251     }
 252     return NULL;
 253 }
 254
 255 /* XXX: force raw format if block or character device ? It would
 256    simplify the BSD case */
 257 static BlockDriver *find_image_format(const char *filename)
 258 {
 259     int ret, score, score_max;
 260     BlockDriver *drv1, *drv;
 261     uint8_t buf[2048];
 262     BlockDriverState *bs;
 263
 264     /* detect host devices. By convention, /dev/cdrom[N] is always
 265        recognized as a host CDROM */
 266     if (strstart(filename, "/dev/cdrom", NULL))
 267         return &bdrv_host_device;
 268 #ifdef _WIN32
 269     if (is_windows_drive(filename))
 270         return &bdrv_host_device;
 271 #else
 272     {
 273         struct stat st;
 274         if (stat(filename, &st) >= 0 &&
 275             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
 276             return &bdrv_host_device;
 277         }
 278     }
 279 #endif
 280
 281     drv = find_protocol(filename);
 282     /* no need to test disk image formats for vvfat */
 283     if (drv == &bdrv_vvfat)
 284         return drv;
 285
 286     ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);
 287     if (ret < 0)
 288         return NULL;
 289     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
 290     bdrv_delete(bs);
 291     if (ret < 0) {
 292         return NULL;
 293     }
 294
 295     score_max = 0;
 296     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
 297         if (drv1->bdrv_probe) {
 298             score = drv1->bdrv_probe(buf, ret, filename);
 299             if (score > score_max) {
 300                 score_max = score;
 301                 drv = drv1;
 302             }
 303         }
 304     }
 305     return drv;
 306 }
 307
 308 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
 309 {
 310     BlockDriverState *bs;
 311     int ret;
 312
 313     bs = bdrv_new("");
 314     ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
 315     if (ret < 0) {
 316         bdrv_delete(bs);
 317         return ret;
 318     }
 319     bs->growable = 1;
 320     *pbs = bs;
 321     return 0;
 322 }
 323
 324 int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
 325 {
 326     return bdrv_open2(bs, filename, flags, NULL);
 327 }
 328
 329 int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
 330                BlockDriver *drv)
 331 {
 332     int ret, open_flags;
 333     char tmp_filename[PATH_MAX];
 334     char backing_filename[PATH_MAX];
 335
 336     bs->read_only = 0;
 337     bs->is_temporary = 0;
 338     bs->encrypted = 0;
 339
 340     if (flags & BDRV_O_SNAPSHOT) {
 341         BlockDriverState *bs1;
 342         int64_t total_size;
 343         int is_protocol = 0;
 344
 345         /* if snapshot, we create a temporary backing file and open it
 346            instead of opening 'filename' directly */
 347
 348         /* if there is a backing file, use it */
 349         bs1 = bdrv_new("");
 350         ret = bdrv_open(bs1, filename, 0);
 351         if (ret < 0) {
 352             bdrv_delete(bs1);
 353             return ret;
 354         }
 355         total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
 356
 357         if (bs1->drv && bs1->drv->protocol_name)
 358             is_protocol = 1;
 359
 360         bdrv_delete(bs1);
 361
 362         get_tmp_filename(tmp_filename, sizeof(tmp_filename));
 363
 364         /* Real path is meaningless for protocols */
 365         if (is_protocol)
 366             snprintf(backing_filename, sizeof(backing_filename),
 367                      "%s", filename);
 368         else
 369             realpath(filename, backing_filename);
 370
 371         ret = bdrv_create(&bdrv_qcow2, tmp_filename,
 372                           total_size, backing_filename, 0);
 373         if (ret < 0) {
 374             return ret;
 375         }
 376         filename = tmp_filename;
 377         bs->is_temporary = 1;
 378     }
 379
 380     pstrcpy(bs->filename, sizeof(bs->filename), filename);
 381     if (flags & BDRV_O_FILE) {
 382         drv = find_protocol(filename);
 383     } else if (!drv) {
 384         drv = find_image_format(filename);
 385     }
 386     if (!drv) {
 387         ret = -ENOENT;
 388         goto unlink_and_fail;
 389     }
 390     bs->drv = drv;
 391     bs->opaque = qemu_mallocz(drv->instance_size);
 392     /* Note: for compatibility, we open disk image files as RDWR, and
 393        RDONLY as fallback */
 394     if (!(flags & BDRV_O_FILE))
 395         open_flags = BDRV_O_RDWR | (flags & BDRV_O_CACHE_MASK);
 396     else
 397         open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
 398     ret = drv->bdrv_open(bs, filename, open_flags);
 399     if ((ret == -EACCES || ret == -EPERM) && !(flags & BDRV_O_FILE)) {
 400         ret = drv->bdrv_open(bs, filename, open_flags & ~BDRV_O_RDWR);
 401         bs->read_only = 1;
 402     }
 403     if (ret < 0) {
 404         qemu_free(bs->opaque);
 405         bs->opaque = NULL;
 406         bs->drv = NULL;
 407     unlink_and_fail:
 408         if (bs->is_temporary)
 409             unlink(filename);
 410         return ret;
 411     }
 412     if (drv->bdrv_getlength) {
 413         bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
 414     }
 415 #ifndef _WIN32
 416     if (bs->is_temporary) {
 417         unlink(filename);
 418     }
 419 #endif
 420     if (bs->backing_file[0] != '\0') {
 421         /* if there is a backing file, use it */
 422         bs->backing_hd = bdrv_new("");
 423         path_combine(backing_filename, sizeof(backing_filename),
 424                      filename, bs->backing_file);
 425         ret = bdrv_open(bs->backing_hd, backing_filename, open_flags);
 426         if (ret < 0) {
 427             bdrv_close(bs);
 428             return ret;
 429         }
 430     }
 431
 432     /* call the change callback */
 433     bs->media_changed = 1;
 434     if (bs->change_cb)
 435         bs->change_cb(bs->change_opaque);
 436
 437     return 0;
 438 }
 439
 440 void bdrv_close(BlockDriverState *bs)
 441 {
 442     if (bs->drv) {
 443         if (bs->backing_hd)
 444             bdrv_delete(bs->backing_hd);
 445         bs->drv->bdrv_close(bs);
 446         qemu_free(bs->opaque);
 447 #ifdef _WIN32
 448         if (bs->is_temporary) {
 449             unlink(bs->filename);
 450         }
 451 #endif
 452         bs->opaque = NULL;
 453         bs->drv = NULL;
 454
 455         /* call the change callback */
 456         bs->media_changed = 1;
 457         if (bs->change_cb)
 458             bs->change_cb(bs->change_opaque);
 459     }
 460 }
 461
 462 void bdrv_delete(BlockDriverState *bs)
 463 {
 464     BlockDriverState **pbs;
 465
 466     pbs = &bdrv_first;
 467     while (*pbs != bs && *pbs != NULL)
 468         pbs = &(*pbs)->next;
 469     if (*pbs == bs)
 470         *pbs = bs->next;
 471
 472     bdrv_close(bs);
 473     qemu_free(bs);
 474 }
 475
 476 /* commit COW file into the raw image */
 477 int bdrv_commit(BlockDriverState *bs)
 478 {
 479     BlockDriver *drv = bs->drv;
 480     int64_t i, total_sectors;
 481     int n, j;
 482     unsigned char sector[512];
 483
 484     if (!drv)
 485         return -ENOMEDIUM;
 486
 487     if (bs->read_only) {
 488         return -EACCES;
 489     }
 490
 491     if (!bs->backing_hd) {
 492         return -ENOTSUP;
 493     }
 494
 495     total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
 496     for (i = 0; i < total_sectors;) {
 497         if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
 498             for(j = 0; j < n; j++) {
 499                 if (bdrv_read(bs, i, sector, 1) != 0) {
 500                     return -EIO;
 501                 }
 502
 503                 if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
 504                     return -EIO;
 505                 }
 506                 i++;
 507             }
 508         } else {
 509             i += n;
 510         }
 511     }
 512
 513     if (drv->bdrv_make_empty)
 514         return drv->bdrv_make_empty(bs);
 515
 516     return 0;
 517 }
 518
 519 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
 520                                    size_t size)
 521 {
 522     int64_t len;
 523
 524     if (!bdrv_is_inserted(bs))
 525         return -ENOMEDIUM;
 526
 527     if (bs->growable)
 528         return 0;
 529
 530     len = bdrv_getlength(bs);
 531
 532     if ((offset + size) > len)
 533         return -EIO;
 534
 535     return 0;
 536 }
 537
 538 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
 539                               int nb_sectors)
 540 {
 541     int64_t offset;
 542
 543     /* Deal with byte accesses */
 544     if (sector_num < 0)
 545         offset = -sector_num;
 546     else
 547         offset = sector_num * 512;
 548
 549     return bdrv_check_byte_request(bs, offset, nb_sectors * 512);
 550 }
 551
 552 /* return < 0 if error. See bdrv_write() for the return codes */
 553 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
 554               uint8_t *buf, int nb_sectors)
 555 {
 556     BlockDriver *drv = bs->drv;
 557
 558     if (!drv)
 559         return -ENOMEDIUM;
 560     if (bdrv_check_request(bs, sector_num, nb_sectors))
 561         return -EIO;
 562
 563     if (drv->bdrv_pread) {
 564         int ret, len;
 565         len = nb_sectors * 512;
 566         ret = drv->bdrv_pread(bs, sector_num * 512, buf, len);
 567         if (ret < 0)
 568             return ret;
 569         else if (ret != len)
 570             return -EINVAL;
 571         else {
 572             bs->rd_bytes += (unsigned) len;
 573             bs->rd_ops ++;
 574             return 0;
 575         }
 576     } else {
 577         return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
 578     }
 579 }
 580
 581 /* Return < 0 if error. Important errors are:
 582   -EIO         generic I/O error (may happen for all errors)
 583   -ENOMEDIUM   No media inserted.
 584   -EINVAL      Invalid sector number or nb_sectors
 585   -EACCES      Trying to write a read-only device
 586 */
 587 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
 588                const uint8_t *buf, int nb_sectors)
 589 {
 590     BlockDriver *drv = bs->drv;
 591     if (!bs->drv)
 592         return -ENOMEDIUM;
 593     if (bs->read_only)
 594         return -EACCES;
 595     if (bdrv_check_request(bs, sector_num, nb_sectors))
 596         return -EIO;
 597
 598     if (drv->bdrv_pwrite) {
 599         int ret, len, count = 0;
 600         len = nb_sectors * 512;
 601         do {
 602             ret = drv->bdrv_pwrite(bs, sector_num * 512, buf, len - count);
 603             if (ret < 0) {
 604                 printf("bdrv_write ret=%d\n", ret);
 605                 return ret;
 606             }
 607             count += ret;
 608             buf += ret;
 609         } while (count != len);
 610         bs->wr_bytes += (unsigned) len;
 611         bs->wr_ops ++;
 612         return 0;
 613     }
 614     return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
 615 }
 616
 617 static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,
 618                          uint8_t *buf, int count1)
 619 {
 620     uint8_t tmp_buf[SECTOR_SIZE];
 621     int len, nb_sectors, count;
 622     int64_t sector_num;
 623
 624     count = count1;
 625     /* first read to align to sector start */
 626     len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
 627     if (len > count)
 628         len = count;
 629     sector_num = offset >> SECTOR_BITS;
 630     if (len > 0) {
 631         if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
 632             return -EIO;
 633         memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len);
 634         count -= len;
 635         if (count == 0)
 636             return count1;
 637         sector_num++;
 638         buf += len;
 639     }
 640
 641     /* read the sectors "in place" */
 642     nb_sectors = count >> SECTOR_BITS;
 643     if (nb_sectors > 0) {
 644         if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0)
 645             return -EIO;
 646         sector_num += nb_sectors;
 647         len = nb_sectors << SECTOR_BITS;
 648         buf += len;
 649         count -= len;
 650     }
 651
 652     /* add data from the last sector */
 653     if (count > 0) {
 654         if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
 655             return -EIO;
 656         memcpy(buf, tmp_buf, count);
 657     }
 658     return count1;
 659 }
 660
 661 static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,
 662                           const uint8_t *buf, int count1)
 663 {
 664     uint8_t tmp_buf[SECTOR_SIZE];
 665     int len, nb_sectors, count;
 666     int64_t sector_num;
 667
 668     count = count1;
 669     /* first write to align to sector start */
 670     len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
 671     if (len > count)
 672         len = count;
 673     sector_num = offset >> SECTOR_BITS;
 674     if (len > 0) {
 675         if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
 676             return -EIO;
 677         memcpy(tmp_buf + (offset & (SECTOR_SIZE - 1)), buf, len);
 678         if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
 679             return -EIO;
 680         count -= len;
 681         if (count == 0)
 682             return count1;
 683         sector_num++;
 684         buf += len;
 685     }
 686
 687     /* write the sectors "in place" */
 688     nb_sectors = count >> SECTOR_BITS;
 689     if (nb_sectors > 0) {
 690         if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0)
 691             return -EIO;
 692         sector_num += nb_sectors;
 693         len = nb_sectors << SECTOR_BITS;
 694         buf += len;
 695         count -= len;
 696     }
 697
 698     /* add data from the last sector */
 699     if (count > 0) {
 700         if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
 701             return -EIO;
 702         memcpy(tmp_buf, buf, count);
 703         if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
 704             return -EIO;
 705     }
 706     return count1;
 707 }
 708
 709 /**
 710  * Read with byte offsets (needed only for file protocols)
 711  */
 712 int bdrv_pread(BlockDriverState *bs, int64_t offset,
 713                void *buf1, int count1)
 714 {
 715     BlockDriver *drv = bs->drv;
 716
 717     if (!drv)
 718         return -ENOMEDIUM;
 719     if (bdrv_check_byte_request(bs, offset, count1))
 720         return -EIO;
 721
 722     if (!drv->bdrv_pread)
 723         return bdrv_pread_em(bs, offset, buf1, count1);
 724     return drv->bdrv_pread(bs, offset, buf1, count1);
 725 }
 726
 727 /**
 728  * Write with byte offsets (needed only for file protocols)
 729  */
 730 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
 731                 const void *buf1, int count1)
 732 {
 733     BlockDriver *drv = bs->drv;
 734
 735     if (!drv)
 736         return -ENOMEDIUM;
 737     if (bdrv_check_byte_request(bs, offset, count1))
 738         return -EIO;
 739
 740     if (!drv->bdrv_pwrite)
 741         return bdrv_pwrite_em(bs, offset, buf1, count1);
 742     return drv->bdrv_pwrite(bs, offset, buf1, count1);
 743 }
 744
 745 /**
 746  * Truncate file to 'offset' bytes (needed only for file protocols)
 747  */
 748 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
 749 {
 750     BlockDriver *drv = bs->drv;
 751     if (!drv)
 752         return -ENOMEDIUM;
 753     if (!drv->bdrv_truncate)
 754         return -ENOTSUP;
 755     return drv->bdrv_truncate(bs, offset);
 756 }
 757
 758 /**
 759  * Length of a file in bytes. Return < 0 if error or unknown.
 760  */
 761 int64_t bdrv_getlength(BlockDriverState *bs)
 762 {
 763     BlockDriver *drv = bs->drv;
 764     if (!drv)
 765         return -ENOMEDIUM;
 766     if (!drv->bdrv_getlength) {
 767         /* legacy mode */
 768         return bs->total_sectors * SECTOR_SIZE;
 769     }
 770     return drv->bdrv_getlength(bs);
 771 }
 772
 773 /* return 0 as number of sectors if no device present or error */
 774 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
 775 {
 776     int64_t length;
 777     length = bdrv_getlength(bs);
 778     if (length < 0)
 779         length = 0;
 780     else
 781         length = length >> SECTOR_BITS;
 782     *nb_sectors_ptr = length;
 783 }
 784
 785 struct partition {
 786         uint8_t boot_ind;           /* 0x80 - active */
 787         uint8_t head;               /* starting head */
 788         uint8_t sector;             /* starting sector */
 789         uint8_t cyl;                /* starting cylinder */
 790         uint8_t sys_ind;            /* What partition type */
 791         uint8_t end_head;           /* end head */
 792         uint8_t end_sector;         /* end sector */
 793         uint8_t end_cyl;            /* end cylinder */
 794         uint32_t start_sect;        /* starting sector counting from 0 */
 795         uint32_t nr_sects;          /* nr of sectors in partition */
 796 } __attribute__((packed));
 797
 798 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
 799 static int guess_disk_lchs(BlockDriverState *bs,
 800                            int *pcylinders, int *pheads, int *psectors)
 801 {
 802     uint8_t buf[512];
 803     int ret, i, heads, sectors, cylinders;
 804     struct partition *p;
 805     uint32_t nr_sects;
 806     uint64_t nb_sectors;
 807
 808     bdrv_get_geometry(bs, &nb_sectors);
 809
 810     ret = bdrv_read(bs, 0, buf, 1);
 811     if (ret < 0)
 812         return -1;
 813     /* test msdos magic */
 814     if (buf[510] != 0x55 || buf[511] != 0xaa)
 815         return -1;
 816     for(i = 0; i < 4; i++) {
 817         p = ((struct partition *)(buf + 0x1be)) + i;
 818         nr_sects = le32_to_cpu(p->nr_sects);
 819         if (nr_sects && p->end_head) {
 820             /* We make the assumption that the partition terminates on
 821                a cylinder boundary */
 822             heads = p->end_head + 1;
 823             sectors = p->end_sector & 63;
 824             if (sectors == 0)
 825                 continue;
 826             cylinders = nb_sectors / (heads * sectors);
 827             if (cylinders < 1 || cylinders > 16383)
 828                 continue;
 829             *pheads = heads;
 830             *psectors = sectors;
 831             *pcylinders = cylinders;
 832 #if 0
 833             printf("guessed geometry: LCHS=%d %d %d\n",
 834                    cylinders, heads, sectors);
 835 #endif
 836             return 0;
 837         }
 838     }
 839     return -1;
 840 }
 841
 842 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
 843 {
 844     int translation, lba_detected = 0;
 845     int cylinders, heads, secs;
 846     uint64_t nb_sectors;
 847
 848     /* if a geometry hint is available, use it */
 849     bdrv_get_geometry(bs, &nb_sectors);
 850     bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
 851     translation = bdrv_get_translation_hint(bs);
 852     if (cylinders != 0) {
 853         *pcyls = cylinders;
 854         *pheads = heads;
 855         *psecs = secs;
 856     } else {
 857         if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
 858             if (heads > 16) {
 859                 /* if heads > 16, it means that a BIOS LBA
 860                    translation was active, so the default
 861                    hardware geometry is OK */
 862                 lba_detected = 1;
 863                 goto default_geometry;
 864             } else {
 865                 *pcyls = cylinders;
 866                 *pheads = heads;
 867                 *psecs = secs;
 868                 /* disable any translation to be in sync with
 869                    the logical geometry */
 870                 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
 871                     bdrv_set_translation_hint(bs,
 872                                               BIOS_ATA_TRANSLATION_NONE);
 873                 }
 874             }
 875         } else {
 876         default_geometry:
 877             /* if no geometry, use a standard physical disk geometry */
 878             cylinders = nb_sectors / (16 * 63);
 879
 880             if (cylinders > 16383)
 881                 cylinders = 16383;
 882             else if (cylinders < 2)
 883                 cylinders = 2;
 884             *pcyls = cylinders;
 885             *pheads = 16;
 886             *psecs = 63;
 887             if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
 888                 if ((*pcyls * *pheads) <= 131072) {
 889                     bdrv_set_translation_hint(bs,
 890                                               BIOS_ATA_TRANSLATION_LARGE);
 891                 } else {
 892                     bdrv_set_translation_hint(bs,
 893                                               BIOS_ATA_TRANSLATION_LBA);
 894                 }
 895             }
 896         }
 897         bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
 898     }
 899 }
 900
 901 void bdrv_set_geometry_hint(BlockDriverState *bs,
 902                             int cyls, int heads, int secs)
 903 {
 904     bs->cyls = cyls;
 905     bs->heads = heads;
 906     bs->secs = secs;
 907 }
 908
 909 void bdrv_set_type_hint(BlockDriverState *bs, int type)
 910 {
 911     bs->type = type;
 912     bs->removable = ((type == BDRV_TYPE_CDROM ||
 913                       type == BDRV_TYPE_FLOPPY));
 914 }
 915
 916 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
 917 {
 918     bs->translation = translation;
 919 }
 920
 921 void bdrv_get_geometry_hint(BlockDriverState *bs,
 922                             int *pcyls, int *pheads, int *psecs)
 923 {
 924     *pcyls = bs->cyls;
 925     *pheads = bs->heads;
 926     *psecs = bs->secs;
 927 }
 928
 929 int bdrv_get_type_hint(BlockDriverState *bs)
 930 {
 931     return bs->type;
 932 }
 933
 934 int bdrv_get_translation_hint(BlockDriverState *bs)
 935 {
 936     return bs->translation;
 937 }
 938
 939 int bdrv_is_removable(BlockDriverState *bs)
 940 {
 941     return bs->removable;
 942 }
 943
 944 int bdrv_is_read_only(BlockDriverState *bs)
 945 {
 946     return bs->read_only;
 947 }
 948
 949 int bdrv_is_sg(BlockDriverState *bs)
 950 {
 951     return bs->sg;
 952 }
 953
 954 /* XXX: no longer used */
 955 void bdrv_set_change_cb(BlockDriverState *bs,
 956                         void (*change_cb)(void *opaque), void *opaque)
 957 {
 958     bs->change_cb = change_cb;
 959     bs->change_opaque = opaque;
 960 }
 961
 962 int bdrv_is_encrypted(BlockDriverState *bs)
 963 {
 964     if (bs->backing_hd && bs->backing_hd->encrypted)
 965         return 1;
 966     return bs->encrypted;
 967 }
 968
 969 int bdrv_set_key(BlockDriverState *bs, const char *key)
 970 {
 971     int ret;
 972     if (bs->backing_hd && bs->backing_hd->encrypted) {
 973         ret = bdrv_set_key(bs->backing_hd, key);
 974         if (ret < 0)
 975             return ret;
 976         if (!bs->encrypted)
 977             return 0;
 978     }
 979     if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key)
 980         return -1;
 981     return bs->drv->bdrv_set_key(bs, key);
 982 }
 983
 984 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
 985 {
 986     if (!bs->drv) {
 987         buf[0] = '\0';
 988     } else {
 989         pstrcpy(buf, buf_size, bs->drv->format_name);
 990     }
 991 }
 992
 993 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
 994                          void *opaque)
 995 {
 996     BlockDriver *drv;
 997
 998     for (drv = first_drv; drv != NULL; drv = drv->next) {
 999         it(opaque, drv->format_name);
1000     }
1001 }
1002
1003 BlockDriverState *bdrv_find(const char *name)
1004 {
1005     BlockDriverState *bs;
1006
1007     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1008         if (!strcmp(name, bs->device_name))
1009             return bs;
1010     }
1011     return NULL;
1012 }
1013
1014 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1015 {
1016     BlockDriverState *bs;
1017
1018     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1019         it(opaque, bs);
1020     }
1021 }
1022
1023 const char *bdrv_get_device_name(BlockDriverState *bs)
1024 {
1025     return bs->device_name;
1026 }
1027
1028 void bdrv_flush(BlockDriverState *bs)
1029 {
1030     if (bs->drv->bdrv_flush)
1031         bs->drv->bdrv_flush(bs);
1032     if (bs->backing_hd)
1033         bdrv_flush(bs->backing_hd);
1034 }
1035
1036 void bdrv_flush_all(void)
1037 {
1038     BlockDriverState *bs;
1039
1040     for (bs = bdrv_first; bs != NULL; bs = bs->next)
1041         if (bs->drv && !bdrv_is_read_only(bs) &&
1042             (!bdrv_is_removable(bs) || bdrv_is_inserted(bs)))
1043             bdrv_flush(bs);
1044 }
1045
1046 /*
1047  * Returns true iff the specified sector is present in the disk image. Drivers
1048  * not implementing the functionality are assumed to not support backing files,
1049  * hence all their sectors are reported as allocated.
1050  *
1051  * 'pnum' is set to the number of sectors (including and immediately following
1052  * the specified sector) that are known to be in the same
1053  * allocated/unallocated state.
1054  *
1055  * 'nb_sectors' is the max value 'pnum' should be set to.
1056  */
1057 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1058         int *pnum)
1059 {
1060     int64_t n;
1061     if (!bs->drv->bdrv_is_allocated) {
1062         if (sector_num >= bs->total_sectors) {
1063             *pnum = 0;
1064             return 0;
1065         }
1066         n = bs->total_sectors - sector_num;
1067         *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1068         return 1;
1069     }
1070     return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1071 }
1072
1073 void bdrv_info(void)
1074 {
1075     BlockDriverState *bs;
1076
1077     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1078         term_printf("%s:", bs->device_name);
1079         term_printf(" type=");
1080         switch(bs->type) {
1081         case BDRV_TYPE_HD:
1082             term_printf("hd");
1083             break;
1084         case BDRV_TYPE_CDROM:
1085             term_printf("cdrom");
1086             break;
1087         case BDRV_TYPE_FLOPPY:
1088             term_printf("floppy");
1089             break;
1090         }
1091         term_printf(" removable=%d", bs->removable);
1092         if (bs->removable) {
1093             term_printf(" locked=%d", bs->locked);
1094         }
1095         if (bs->drv) {
1096             term_printf(" file=");
1097             term_print_filename(bs->filename);
1098             if (bs->backing_file[0] != '\0') {
1099                 term_printf(" backing_file=");
1100                 term_print_filename(bs->backing_file);
1101             }
1102             term_printf(" ro=%d", bs->read_only);
1103             term_printf(" drv=%s", bs->drv->format_name);
1104             if (bs->encrypted)
1105                 term_printf(" encrypted");
1106         } else {
1107             term_printf(" [not inserted]");
1108         }
1109         term_printf("\n");
1110     }
1111 }
1112
1113 /* The "info blockstats" command. */
1114 void bdrv_info_stats (void)
1115 {
1116     BlockDriverState *bs;
1117     BlockDriverInfo bdi;
1118
1119     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1120         term_printf ("%s:"
1121                      " rd_bytes=%" PRIu64
1122                      " wr_bytes=%" PRIu64
1123                      " rd_operations=%" PRIu64
1124                      " wr_operations=%" PRIu64
1125                      ,
1126                      bs->device_name,
1127                      bs->rd_bytes, bs->wr_bytes,
1128                      bs->rd_ops, bs->wr_ops);
1129         if (bdrv_get_info(bs, &bdi) == 0)
1130             term_printf(" high=%" PRId64
1131                         " bytes_free=%" PRId64,
1132                         bdi.highest_alloc, bdi.num_free_bytes);
1133         term_printf("\n");
1134     }
1135 }
1136
1137 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1138 {
1139     if (bs->backing_hd && bs->backing_hd->encrypted)
1140         return bs->backing_file;
1141     else if (bs->encrypted)
1142         return bs->filename;
1143     else
1144         return NULL;
1145 }
1146
1147 void bdrv_get_backing_filename(BlockDriverState *bs,
1148                                char *filename, int filename_size)
1149 {
1150     if (!bs->backing_hd) {
1151         pstrcpy(filename, filename_size, "");
1152     } else {
1153         pstrcpy(filename, filename_size, bs->backing_file);
1154     }
1155 }
1156
1157 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1158                           const uint8_t *buf, int nb_sectors)
1159 {
1160     BlockDriver *drv = bs->drv;
1161     if (!drv)
1162         return -ENOMEDIUM;
1163     if (!drv->bdrv_write_compressed)
1164         return -ENOTSUP;
1165     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1166 }
1167
1168 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1169 {
1170     BlockDriver *drv = bs->drv;
1171     if (!drv)
1172         return -ENOMEDIUM;
1173     if (!drv->bdrv_get_info)
1174         return -ENOTSUP;
1175     memset(bdi, 0, sizeof(*bdi));
1176     return drv->bdrv_get_info(bs, bdi);
1177 }
1178
1179 /**************************************************************/
1180 /* handling of snapshots */
1181
1182 int bdrv_snapshot_create(BlockDriverState *bs,
1183                          QEMUSnapshotInfo *sn_info)
1184 {
1185     BlockDriver *drv = bs->drv;
1186     if (!drv)
1187         return -ENOMEDIUM;
1188     if (!drv->bdrv_snapshot_create)
1189         return -ENOTSUP;
1190     return drv->bdrv_snapshot_create(bs, sn_info);
1191 }
1192
1193 int bdrv_snapshot_goto(BlockDriverState *bs,
1194                        const char *snapshot_id)
1195 {
1196     BlockDriver *drv = bs->drv;
1197     if (!drv)
1198         return -ENOMEDIUM;
1199     if (!drv->bdrv_snapshot_goto)
1200         return -ENOTSUP;
1201     return drv->bdrv_snapshot_goto(bs, snapshot_id);
1202 }
1203
1204 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1205 {
1206     BlockDriver *drv = bs->drv;
1207     if (!drv)
1208         return -ENOMEDIUM;
1209     if (!drv->bdrv_snapshot_delete)
1210         return -ENOTSUP;
1211     return drv->bdrv_snapshot_delete(bs, snapshot_id);
1212 }
1213
1214 int bdrv_snapshot_list(BlockDriverState *bs,
1215                        QEMUSnapshotInfo **psn_info)
1216 {
1217     BlockDriver *drv = bs->drv;
1218     if (!drv)
1219         return -ENOMEDIUM;
1220     if (!drv->bdrv_snapshot_list)
1221         return -ENOTSUP;
1222     return drv->bdrv_snapshot_list(bs, psn_info);
1223 }
1224
1225 #define NB_SUFFIXES 4
1226
1227 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
1228 {
1229     static const char suffixes[NB_SUFFIXES] = "KMGT";
1230     int64_t base;
1231     int i;
1232
1233     if (size <= 999) {
1234         snprintf(buf, buf_size, "%" PRId64, size);
1235     } else {
1236         base = 1024;
1237         for(i = 0; i < NB_SUFFIXES; i++) {
1238             if (size < (10 * base)) {
1239                 snprintf(buf, buf_size, "%0.1f%c",
1240                          (double)size / base,
1241                          suffixes[i]);
1242                 break;
1243             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1244                 snprintf(buf, buf_size, "%" PRId64 "%c",
1245                          ((size + (base >> 1)) / base),
1246                          suffixes[i]);
1247                 break;
1248             }
1249             base = base * 1024;
1250         }
1251     }
1252     return buf;
1253 }
1254
1255 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1256 {
1257     char buf1[128], date_buf[128], clock_buf[128];
1258 #ifdef _WIN32
1259     struct tm *ptm;
1260 #else
1261     struct tm tm;
1262 #endif
1263     time_t ti;
1264     int64_t secs;
1265
1266     if (!sn) {
1267         snprintf(buf, buf_size,
1268                  "%-10s%-20s%7s%20s%15s",
1269                  "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1270     } else {
1271         ti = sn->date_sec;
1272 #ifdef _WIN32
1273         ptm = localtime(&ti);
1274         strftime(date_buf, sizeof(date_buf),
1275                  "%Y-%m-%d %H:%M:%S", ptm);
1276 #else
1277         localtime_r(&ti, &tm);
1278         strftime(date_buf, sizeof(date_buf),
1279                  "%Y-%m-%d %H:%M:%S", &tm);
1280 #endif
1281         secs = sn->vm_clock_nsec / 1000000000;
1282         snprintf(clock_buf, sizeof(clock_buf),
1283                  "%02d:%02d:%02d.%03d",
1284                  (int)(secs / 3600),
1285                  (int)((secs / 60) % 60),
1286                  (int)(secs % 60),
1287                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
1288         snprintf(buf, buf_size,
1289                  "%-10s%-20s%7s%20s%15s",
1290                  sn->id_str, sn->name,
1291                  get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1292                  date_buf,
1293                  clock_buf);
1294     }
1295     return buf;
1296 }
1297
1298
1299 /**************************************************************/
1300 /* async I/Os */
1301
1302 typedef struct VectorTranslationState {
1303     QEMUIOVector *iov;
1304     uint8_t *bounce;
1305     int is_write;
1306     BlockDriverAIOCB *aiocb;
1307     BlockDriverAIOCB *this_aiocb;
1308 } VectorTranslationState;
1309
1310 static void bdrv_aio_rw_vector_cb(void *opaque, int ret)
1311 {
1312     VectorTranslationState *s = opaque;
1313
1314     if (!s->is_write) {
1315         qemu_iovec_from_buffer(s->iov, s->bounce, s->iov->size);
1316     }
1317     qemu_vfree(s->bounce);
1318     s->this_aiocb->cb(s->this_aiocb->opaque, ret);
1319     qemu_aio_release(s->this_aiocb);
1320 }
1321
1322 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
1323                                             int64_t sector_num,
1324                                             QEMUIOVector *iov,
1325                                             int nb_sectors,
1326                                             BlockDriverCompletionFunc *cb,
1327                                             void *opaque,
1328                                             int is_write)
1329
1330 {
1331     VectorTranslationState *s = qemu_mallocz(sizeof(*s));
1332     BlockDriverAIOCB *aiocb = qemu_aio_get(bs, cb, opaque);
1333
1334     s->this_aiocb = aiocb;
1335     s->iov = iov;
1336     s->bounce = qemu_memalign(512, nb_sectors * 512);
1337     s->is_write = is_write;
1338     if (is_write) {
1339         qemu_iovec_to_buffer(s->iov, s->bounce);
1340         s->aiocb = bdrv_aio_write(bs, sector_num, s->bounce, nb_sectors,
1341                                   bdrv_aio_rw_vector_cb, s);
1342     } else {
1343         s->aiocb = bdrv_aio_read(bs, sector_num, s->bounce, nb_sectors,
1344                                  bdrv_aio_rw_vector_cb, s);
1345     }
1346     return aiocb;
1347 }
1348
1349 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1350                                  QEMUIOVector *iov, int nb_sectors,
1351                                  BlockDriverCompletionFunc *cb, void *opaque)
1352 {
1353     if (bdrv_check_request(bs, sector_num, nb_sectors))
1354         return NULL;
1355
1356     return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
1357                               cb, opaque, 0);
1358 }
1359
1360 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
1361                                   QEMUIOVector *iov, int nb_sectors,
1362                                   BlockDriverCompletionFunc *cb, void *opaque)
1363 {
1364     if (bdrv_check_request(bs, sector_num, nb_sectors))
1365         return NULL;
1366
1367     return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
1368                               cb, opaque, 1);
1369 }
1370
1371 BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
1372                                 uint8_t *buf, int nb_sectors,
1373                                 BlockDriverCompletionFunc *cb, void *opaque)
1374 {
1375     BlockDriver *drv = bs->drv;
1376     BlockDriverAIOCB *ret;
1377
1378     if (!drv)
1379         return NULL;
1380     if (bdrv_check_request(bs, sector_num, nb_sectors))
1381         return NULL;
1382
1383     ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);
1384
1385     if (ret) {
1386         /* Update stats even though technically transfer has not happened. */
1387         bs->rd_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
1388         bs->rd_ops ++;
1389     }
1390
1391     return ret;
1392 }
1393
1394 BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
1395                                  const uint8_t *buf, int nb_sectors,
1396                                  BlockDriverCompletionFunc *cb, void *opaque)
1397 {
1398     BlockDriver *drv = bs->drv;
1399     BlockDriverAIOCB *ret;
1400
1401     if (!drv)
1402         return NULL;
1403     if (bs->read_only)
1404         return NULL;
1405     if (bdrv_check_request(bs, sector_num, nb_sectors))
1406         return NULL;
1407
1408     ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
1409
1410     if (ret) {
1411         /* Update stats even though technically transfer has not happened. */
1412         bs->wr_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
1413         bs->wr_ops ++;
1414     }
1415
1416     return ret;
1417 }
1418
1419 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
1420 {
1421     BlockDriver *drv = acb->bs->drv;
1422
1423     if (acb->cb == bdrv_aio_rw_vector_cb) {
1424         VectorTranslationState *s = acb->opaque;
1425         acb = s->aiocb;
1426     }
1427
1428     drv->bdrv_aio_cancel(acb);
1429 }
1430
1431
1432 /**************************************************************/
1433 /* async block device emulation */
1434
1435 static void bdrv_aio_bh_cb(void *opaque)
1436 {
1437     BlockDriverAIOCBSync *acb = opaque;
1438     acb->common.cb(acb->common.opaque, acb->ret);
1439     qemu_aio_release(acb);
1440 }
1441
1442 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
1443         int64_t sector_num, uint8_t *buf, int nb_sectors,
1444         BlockDriverCompletionFunc *cb, void *opaque)
1445 {
1446     BlockDriverAIOCBSync *acb;
1447     int ret;
1448
1449     acb = qemu_aio_get(bs, cb, opaque);
1450     if (!acb->bh)
1451         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1452     ret = bdrv_read(bs, sector_num, buf, nb_sectors);
1453     acb->ret = ret;
1454     qemu_bh_schedule(acb->bh);
1455     return &acb->common;
1456 }
1457
1458 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
1459         int64_t sector_num, const uint8_t *buf, int nb_sectors,
1460         BlockDriverCompletionFunc *cb, void *opaque)
1461 {
1462     BlockDriverAIOCBSync *acb;
1463     int ret;
1464
1465     acb = qemu_aio_get(bs, cb, opaque);
1466     if (!acb->bh)
1467         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1468     ret = bdrv_write(bs, sector_num, buf, nb_sectors);
1469     acb->ret = ret;
1470     qemu_bh_schedule(acb->bh);
1471     return &acb->common;
1472 }
1473
1474 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
1475 {
1476     BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
1477     qemu_bh_cancel(acb->bh);
1478     qemu_aio_release(acb);
1479 }
1480
1481 /**************************************************************/
1482 /* sync block device emulation */
1483
1484 static void bdrv_rw_em_cb(void *opaque, int ret)
1485 {
1486     *(int *)opaque = ret;
1487 }
1488
1489 #define NOT_DONE 0x7fffffff
1490
1491 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
1492                         uint8_t *buf, int nb_sectors)
1493 {
1494     int async_ret;
1495     BlockDriverAIOCB *acb;
1496
1497     async_ret = NOT_DONE;
1498     acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,
1499                         bdrv_rw_em_cb, &async_ret);
1500     if (acb == NULL)
1501         return -1;
1502
1503     while (async_ret == NOT_DONE) {
1504         qemu_aio_wait();
1505     }
1506
1507     return async_ret;
1508 }
1509
1510 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
1511                          const uint8_t *buf, int nb_sectors)
1512 {
1513     int async_ret;
1514     BlockDriverAIOCB *acb;
1515
1516     async_ret = NOT_DONE;
1517     acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
1518                          bdrv_rw_em_cb, &async_ret);
1519     if (acb == NULL)
1520         return -1;
1521     while (async_ret == NOT_DONE) {
1522         qemu_aio_wait();
1523     }
1524     return async_ret;
1525 }
1526
1527 void bdrv_init(void)
1528 {
1529     bdrv_register(&bdrv_raw);
1530     bdrv_register(&bdrv_host_device);
1531 #ifndef _WIN32
1532     bdrv_register(&bdrv_cow);
1533 #endif
1534     bdrv_register(&bdrv_qcow);
1535     bdrv_register(&bdrv_vmdk);
1536     bdrv_register(&bdrv_cloop);
1537     bdrv_register(&bdrv_dmg);
1538     bdrv_register(&bdrv_bochs);
1539     bdrv_register(&bdrv_vpc);
1540     bdrv_register(&bdrv_vvfat);
1541     bdrv_register(&bdrv_qcow2);
1542     bdrv_register(&bdrv_parallels);
1543     bdrv_register(&bdrv_nbd);
1544 }
1545
1546 void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
1547                    void *opaque)
1548 {
1549     BlockDriver *drv;
1550     BlockDriverAIOCB *acb;
1551
1552     drv = bs->drv;
1553     if (drv->free_aiocb) {
1554         acb = drv->free_aiocb;
1555         drv->free_aiocb = acb->next;
1556     } else {
1557         acb = qemu_mallocz(drv->aiocb_size);
1558     }
1559     acb->bs = bs;
1560     acb->cb = cb;
1561     acb->opaque = opaque;
1562     return acb;
1563 }
1564
1565 void qemu_aio_release(void *p)
1566 {
1567     BlockDriverAIOCB *acb = p;
1568     BlockDriver *drv = acb->bs->drv;
1569     acb->next = drv->free_aiocb;
1570     drv->free_aiocb = acb;
1571 }
1572
1573 /**************************************************************/
1574 /* removable device support */
1575
1576 /**
1577  * Return TRUE if the media is present
1578  */
1579 int bdrv_is_inserted(BlockDriverState *bs)
1580 {
1581     BlockDriver *drv = bs->drv;
1582     int ret;
1583     if (!drv)
1584         return 0;
1585     if (!drv->bdrv_is_inserted)
1586         return 1;
1587     ret = drv->bdrv_is_inserted(bs);
1588     return ret;
1589 }
1590
1591 /**
1592  * Return TRUE if the media changed since the last call to this
1593  * function. It is currently only used for floppy disks
1594  */
1595 int bdrv_media_changed(BlockDriverState *bs)
1596 {
1597     BlockDriver *drv = bs->drv;
1598     int ret;
1599
1600     if (!drv || !drv->bdrv_media_changed)
1601         ret = -ENOTSUP;
1602     else
1603         ret = drv->bdrv_media_changed(bs);
1604     if (ret == -ENOTSUP)
1605         ret = bs->media_changed;
1606     bs->media_changed = 0;
1607     return ret;
1608 }
1609
1610 /**
1611  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
1612  */
1613 void bdrv_eject(BlockDriverState *bs, int eject_flag)
1614 {
1615     BlockDriver *drv = bs->drv;
1616     int ret;
1617
1618     if (!drv || !drv->bdrv_eject) {
1619         ret = -ENOTSUP;
1620     } else {
1621         ret = drv->bdrv_eject(bs, eject_flag);
1622     }
1623     if (ret == -ENOTSUP) {
1624         if (eject_flag)
1625             bdrv_close(bs);
1626     }
1627 }
1628
1629 int bdrv_is_locked(BlockDriverState *bs)
1630 {
1631     return bs->locked;
1632 }
1633
1634 /**
1635  * Lock or unlock the media (if it is locked, the user won't be able
1636  * to eject it manually).
1637  */
1638 void bdrv_set_locked(BlockDriverState *bs, int locked)
1639 {
1640     BlockDriver *drv = bs->drv;
1641
1642     bs->locked = locked;
1643     if (drv && drv->bdrv_set_locked) {
1644         drv->bdrv_set_locked(bs, locked);
1645     }
1646 }
1647
1648 /* needed for generic scsi interface */
1649
1650 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1651 {
1652     BlockDriver *drv = bs->drv;
1653
1654     if (drv && drv->bdrv_ioctl)
1655         return drv->bdrv_ioctl(bs, req, buf);
1656     return -ENOTSUP;
1657 }