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