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