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 "vl.h"
  25 #include "block_int.h"
  26
  27 #ifdef _BSD
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/ioctl.h>
  31 #include <sys/queue.h>
  32 #include <sys/disk.h>
  33 #endif
  34
  35 #ifdef CONFIG_COCOA
  36 #include <paths.h>
  37 #include <sys/param.h>
  38 #include <IOKit/IOKitLib.h>
  39 #include <IOKit/IOBSD.h>
  40 #include <IOKit/storage/IOMediaBSDClient.h>
  41 #include <IOKit/storage/IOMedia.h>
  42 #include <IOKit/storage/IOCDMedia.h>
  43 //#include <IOKit/storage/IOCDTypes.h>
  44 #include <CoreFoundation/CoreFoundation.h>
  45 #endif
  46
  47 static BlockDriverState *bdrv_first;
  48 static BlockDriver *first_drv;
  49
  50 #ifdef CONFIG_COCOA
  51 static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
  52 static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize );
  53
  54 kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
  55 {
  56     kern_return_t       kernResult;
  57     mach_port_t     masterPort;
  58     CFMutableDictionaryRef  classesToMatch;
  59
  60     kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
  61     if ( KERN_SUCCESS != kernResult ) {
  62         printf( "IOMasterPort returned %d\n", kernResult );
  63     }
  64
  65     classesToMatch = IOServiceMatching( kIOCDMediaClass );
  66     if ( classesToMatch == NULL ) {
  67         printf( "IOServiceMatching returned a NULL dictionary.\n" );
  68     } else {
  69     CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
  70     }
  71     kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
  72     if ( KERN_SUCCESS != kernResult )
  73     {
  74         printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
  75     }
  76
  77     return kernResult;
  78 }
  79
  80 kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize )
  81 {
  82     io_object_t     nextMedia;
  83     kern_return_t   kernResult = KERN_FAILURE;
  84     *bsdPath = '\0';
  85     nextMedia = IOIteratorNext( mediaIterator );
  86     if ( nextMedia )
  87     {
  88         CFTypeRef   bsdPathAsCFString;
  89     bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
  90         if ( bsdPathAsCFString ) {
  91             size_t devPathLength;
  92             strcpy( bsdPath, _PATH_DEV );
  93             strcat( bsdPath, "r" );
  94             devPathLength = strlen( bsdPath );
  95             if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
  96                 kernResult = KERN_SUCCESS;
  97             }
  98             CFRelease( bsdPathAsCFString );
  99         }
 100         IOObjectRelease( nextMedia );
 101     }
 102
 103     return kernResult;
 104 }
 105
 106 #endif
 107
 108 void bdrv_register(BlockDriver *bdrv)
 109 {
 110     bdrv->next = first_drv;
 111     first_drv = bdrv;
 112 }
 113
 114 /* create a new block device (by default it is empty) */
 115 BlockDriverState *bdrv_new(const char *device_name)
 116 {
 117     BlockDriverState **pbs, *bs;
 118
 119     bs = qemu_mallocz(sizeof(BlockDriverState));
 120     if(!bs)
 121         return NULL;
 122     pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
 123     if (device_name[0] != '\0') {
 124         /* insert at the end */
 125         pbs = &bdrv_first;
 126         while (*pbs != NULL)
 127             pbs = &(*pbs)->next;
 128         *pbs = bs;
 129     }
 130     return bs;
 131 }
 132
 133 BlockDriver *bdrv_find_format(const char *format_name)
 134 {
 135     BlockDriver *drv1;
 136     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
 137         if (!strcmp(drv1->format_name, format_name))
 138             return drv1;
 139     }
 140     return NULL;
 141 }
 142
 143 int bdrv_create(BlockDriver *drv,
 144                 const char *filename, int64_t size_in_sectors,
 145                 const char *backing_file, int flags)
 146 {
 147     if (!drv->bdrv_create)
 148         return -ENOTSUP;
 149     return drv->bdrv_create(filename, size_in_sectors, backing_file, flags);
 150 }
 151
 152 #ifdef _WIN32
 153 static void get_tmp_filename(char *filename, int size)
 154 {
 155     /* XXX: find a better function */
 156     tmpnam(filename);
 157 }
 158 #else
 159 static void get_tmp_filename(char *filename, int size)
 160 {
 161     int fd;
 162     /* XXX: race condition possible */
 163     pstrcpy(filename, size, "/tmp/vl.XXXXXX");
 164     fd = mkstemp(filename);
 165     close(fd);
 166 }
 167 #endif
 168
 169 /* XXX: force raw format if block or character device ? It would
 170    simplify the BSD case */
 171 static BlockDriver *find_image_format(const char *filename)
 172 {
 173     int fd, ret, score, score_max;
 174     BlockDriver *drv1, *drv;
 175     uint8_t *buf;
 176     size_t bufsize = 1024;
 177
 178     fd = open(filename, O_RDONLY | O_BINARY | O_LARGEFILE);
 179     if (fd < 0) {
 180         buf = NULL;
 181         ret = 0;
 182     } else {
 183 #ifdef DIOCGSECTORSIZE
 184         {
 185             unsigned int sectorsize = 512;
 186             if (!ioctl(fd, DIOCGSECTORSIZE, &sectorsize) &&
 187                 sectorsize > bufsize)
 188                 bufsize = sectorsize;
 189         }
 190 #endif
 191 #ifdef CONFIG_COCOA
 192         u_int32_t   blockSize = 512;
 193         if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {
 194             bufsize = blockSize;
 195         }
 196 #endif
 197         buf = qemu_malloc(bufsize);
 198         if (!buf)
 199             return NULL;
 200         ret = read(fd, buf, bufsize);
 201         if (ret < 0) {
 202             close(fd);
 203             qemu_free(buf);
 204             return NULL;
 205         }
 206         close(fd);
 207     }
 208
 209     drv = NULL;
 210     score_max = 0;
 211     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
 212         score = drv1->bdrv_probe(buf, ret, filename);
 213         if (score > score_max) {
 214             score_max = score;
 215             drv = drv1;
 216         }
 217     }
 218     qemu_free(buf);
 219     return drv;
 220 }
 221
 222 int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot)
 223 {
 224 #ifdef CONFIG_COCOA
 225     if ( strncmp( filename, "/dev/cdrom", 10 ) == 0 ) {
 226         kern_return_t kernResult;
 227         io_iterator_t mediaIterator;
 228         char bsdPath[ MAXPATHLEN ];
 229         int fd;
 230
 231         kernResult = FindEjectableCDMedia( &mediaIterator );
 232         kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
 233
 234         if ( bsdPath[ 0 ] != '\0' ) {
 235             strcat(bsdPath,"s0");
 236             /* some CDs don't have a partition 0 */
 237             fd = open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
 238             if (fd < 0) {
 239                 bsdPath[strlen(bsdPath)-1] = '1';
 240             } else {
 241                 close(fd);
 242             }
 243             filename = bsdPath;
 244         }
 245
 246         if ( mediaIterator )
 247             IOObjectRelease( mediaIterator );
 248     }
 249 #endif
 250     return bdrv_open2(bs, filename, snapshot, NULL);
 251 }
 252
 253 int bdrv_open2(BlockDriverState *bs, const char *filename, int snapshot,
 254                BlockDriver *drv)
 255 {
 256     int ret;
 257     char tmp_filename[1024];
 258
 259     bs->read_only = 0;
 260     bs->is_temporary = 0;
 261     bs->encrypted = 0;
 262
 263     if (snapshot) {
 264         BlockDriverState *bs1;
 265         int64_t total_size;
 266
 267         /* if snapshot, we create a temporary backing file and open it
 268            instead of opening 'filename' directly */
 269
 270         /* if there is a backing file, use it */
 271         bs1 = bdrv_new("");
 272         if (!bs1) {
 273             return -1;
 274         }
 275         if (bdrv_open(bs1, filename, 0) < 0) {
 276             bdrv_delete(bs1);
 277             return -1;
 278         }
 279         total_size = bs1->total_sectors;
 280         bdrv_delete(bs1);
 281
 282         get_tmp_filename(tmp_filename, sizeof(tmp_filename));
 283         /* XXX: use cow for linux as it is more efficient ? */
 284         if (bdrv_create(&bdrv_qcow, tmp_filename,
 285                         total_size, filename, 0) < 0) {
 286             return -1;
 287         }
 288         filename = tmp_filename;
 289         bs->is_temporary = 1;
 290     }
 291
 292     pstrcpy(bs->filename, sizeof(bs->filename), filename);
 293     if (!drv) {
 294         drv = find_image_format(filename);
 295         if (!drv)
 296             return -1;
 297     }
 298     bs->drv = drv;
 299     bs->opaque = qemu_mallocz(drv->instance_size);
 300     if (bs->opaque == NULL && drv->instance_size > 0)
 301         return -1;
 302
 303     ret = drv->bdrv_open(bs, filename);
 304     if (ret < 0) {
 305         qemu_free(bs->opaque);
 306         return -1;
 307     }
 308 #ifndef _WIN32
 309     if (bs->is_temporary) {
 310         unlink(filename);
 311     }
 312 #endif
 313     if (bs->backing_file[0] != '\0' && drv->bdrv_is_allocated) {
 314         /* if there is a backing file, use it */
 315         bs->backing_hd = bdrv_new("");
 316         if (!bs->backing_hd) {
 317         fail:
 318             bdrv_close(bs);
 319             return -1;
 320         }
 321         if (bdrv_open(bs->backing_hd, bs->backing_file, 0) < 0)
 322             goto fail;
 323     }
 324
 325     bs->inserted = 1;
 326
 327     /* call the change callback */
 328     if (bs->change_cb)
 329         bs->change_cb(bs->change_opaque);
 330
 331     return 0;
 332 }
 333
 334 void bdrv_close(BlockDriverState *bs)
 335 {
 336     if (bs->inserted) {
 337         if (bs->backing_hd)
 338             bdrv_delete(bs->backing_hd);
 339         bs->drv->bdrv_close(bs);
 340         qemu_free(bs->opaque);
 341 #ifdef _WIN32
 342         if (bs->is_temporary) {
 343             unlink(bs->filename);
 344         }
 345 #endif
 346         bs->opaque = NULL;
 347         bs->drv = NULL;
 348         bs->inserted = 0;
 349
 350         /* call the change callback */
 351         if (bs->change_cb)
 352             bs->change_cb(bs->change_opaque);
 353     }
 354 }
 355
 356 void bdrv_delete(BlockDriverState *bs)
 357 {
 358     /* XXX: remove the driver list */
 359     bdrv_close(bs);
 360     qemu_free(bs);
 361 }
 362
 363 /* commit COW file into the raw image */
 364 int bdrv_commit(BlockDriverState *bs)
 365 {
 366     int64_t i;
 367     int n, j;
 368     unsigned char sector[512];
 369
 370     if (!bs->inserted)
 371         return -ENOENT;
 372
 373     if (bs->read_only) {
 374         return -EACCES;
 375     }
 376
 377     if (!bs->backing_hd) {
 378         return -ENOTSUP;
 379     }
 380
 381     for (i = 0; i < bs->total_sectors;) {
 382         if (bs->drv->bdrv_is_allocated(bs, i, 65536, &n)) {
 383             for(j = 0; j < n; j++) {
 384                 if (bdrv_read(bs, i, sector, 1) != 0) {
 385                     return -EIO;
 386                 }
 387
 388                 if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
 389                     return -EIO;
 390                 }
 391                 i++;
 392             }
 393         } else {
 394             i += n;
 395         }
 396     }
 397     return 0;
 398 }
 399
 400 /* return -1 if error */
 401 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
 402               uint8_t *buf, int nb_sectors)
 403 {
 404     int ret, n;
 405     BlockDriver *drv = bs->drv;
 406
 407     if (!bs->inserted)
 408         return -1;
 409
 410     while (nb_sectors > 0) {
 411         if (sector_num == 0 && bs->boot_sector_enabled) {
 412             memcpy(buf, bs->boot_sector_data, 512);
 413             n = 1;
 414         } else if (bs->backing_hd) {
 415             if (drv->bdrv_is_allocated(bs, sector_num, nb_sectors, &n)) {
 416                 ret = drv->bdrv_read(bs, sector_num, buf, n);
 417                 if (ret < 0)
 418                     return -1;
 419             } else {
 420                 /* read from the base image */
 421                 ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
 422                 if (ret < 0)
 423                     return -1;
 424             }
 425         } else {
 426             ret = drv->bdrv_read(bs, sector_num, buf, nb_sectors);
 427             if (ret < 0)
 428                 return -1;
 429             /* no need to loop */
 430             break;
 431         }
 432         nb_sectors -= n;
 433         sector_num += n;
 434         buf += n * 512;
 435     }
 436     return 0;
 437 }
 438
 439 /* return -1 if error */
 440 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
 441                const uint8_t *buf, int nb_sectors)
 442 {
 443     if (!bs->inserted)
 444         return -1;
 445     if (bs->read_only)
 446         return -1;
 447     if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
 448         memcpy(bs->boot_sector_data, buf, 512);
 449     }
 450     return bs->drv->bdrv_write(bs, sector_num, buf, nb_sectors);
 451 }
 452
 453 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr)
 454 {
 455     *nb_sectors_ptr = bs->total_sectors;
 456 }
 457
 458 /* force a given boot sector. */
 459 void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size)
 460 {
 461     bs->boot_sector_enabled = 1;
 462     if (size > 512)
 463         size = 512;
 464     memcpy(bs->boot_sector_data, data, size);
 465     memset(bs->boot_sector_data + size, 0, 512 - size);
 466 }
 467
 468 void bdrv_set_geometry_hint(BlockDriverState *bs,
 469                             int cyls, int heads, int secs)
 470 {
 471     bs->cyls = cyls;
 472     bs->heads = heads;
 473     bs->secs = secs;
 474 }
 475
 476 void bdrv_set_type_hint(BlockDriverState *bs, int type)
 477 {
 478     bs->type = type;
 479     bs->removable = ((type == BDRV_TYPE_CDROM ||
 480                       type == BDRV_TYPE_FLOPPY));
 481 }
 482
 483 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
 484 {
 485     bs->translation = translation;
 486 }
 487
 488 void bdrv_get_geometry_hint(BlockDriverState *bs,
 489                             int *pcyls, int *pheads, int *psecs)
 490 {
 491     *pcyls = bs->cyls;
 492     *pheads = bs->heads;
 493     *psecs = bs->secs;
 494 }
 495
 496 int bdrv_get_type_hint(BlockDriverState *bs)
 497 {
 498     return bs->type;
 499 }
 500
 501 int bdrv_get_translation_hint(BlockDriverState *bs)
 502 {
 503     return bs->translation;
 504 }
 505
 506 int bdrv_is_removable(BlockDriverState *bs)
 507 {
 508     return bs->removable;
 509 }
 510
 511 int bdrv_is_read_only(BlockDriverState *bs)
 512 {
 513     return bs->read_only;
 514 }
 515
 516 int bdrv_is_inserted(BlockDriverState *bs)
 517 {
 518     return bs->inserted;
 519 }
 520
 521 int bdrv_is_locked(BlockDriverState *bs)
 522 {
 523     return bs->locked;
 524 }
 525
 526 void bdrv_set_locked(BlockDriverState *bs, int locked)
 527 {
 528     bs->locked = locked;
 529 }
 530
 531 void bdrv_set_change_cb(BlockDriverState *bs,
 532                         void (*change_cb)(void *opaque), void *opaque)
 533 {
 534     bs->change_cb = change_cb;
 535     bs->change_opaque = opaque;
 536 }
 537
 538 int bdrv_is_encrypted(BlockDriverState *bs)
 539 {
 540     if (bs->backing_hd && bs->backing_hd->encrypted)
 541         return 1;
 542     return bs->encrypted;
 543 }
 544
 545 int bdrv_set_key(BlockDriverState *bs, const char *key)
 546 {
 547     int ret;
 548     if (bs->backing_hd && bs->backing_hd->encrypted) {
 549         ret = bdrv_set_key(bs->backing_hd, key);
 550         if (ret < 0)
 551             return ret;
 552         if (!bs->encrypted)
 553             return 0;
 554     }
 555     if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key)
 556         return -1;
 557     return bs->drv->bdrv_set_key(bs, key);
 558 }
 559
 560 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
 561 {
 562     if (!bs->inserted || !bs->drv) {
 563         buf[0] = '\0';
 564     } else {
 565         pstrcpy(buf, buf_size, bs->drv->format_name);
 566     }
 567 }
 568
 569 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
 570                          void *opaque)
 571 {
 572     BlockDriver *drv;
 573
 574     for (drv = first_drv; drv != NULL; drv = drv->next) {
 575         it(opaque, drv->format_name);
 576     }
 577 }
 578
 579 BlockDriverState *bdrv_find(const char *name)
 580 {
 581     BlockDriverState *bs;
 582
 583     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
 584         if (!strcmp(name, bs->device_name))
 585             return bs;
 586     }
 587     return NULL;
 588 }
 589
 590 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque)
 591 {
 592     BlockDriverState *bs;
 593
 594     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
 595         it(opaque, bs->device_name);
 596     }
 597 }
 598
 599 const char *bdrv_get_device_name(BlockDriverState *bs)
 600 {
 601     return bs->device_name;
 602 }
 603
 604 void bdrv_info(void)
 605 {
 606     BlockDriverState *bs;
 607
 608     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
 609         term_printf("%s:", bs->device_name);
 610         term_printf(" type=");
 611         switch(bs->type) {
 612         case BDRV_TYPE_HD:
 613             term_printf("hd");
 614             break;
 615         case BDRV_TYPE_CDROM:
 616             term_printf("cdrom");
 617             break;
 618         case BDRV_TYPE_FLOPPY:
 619             term_printf("floppy");
 620             break;
 621         }
 622         term_printf(" removable=%d", bs->removable);
 623         if (bs->removable) {
 624             term_printf(" locked=%d", bs->locked);
 625         }
 626         if (bs->inserted) {
 627             term_printf(" file=%s", bs->filename);
 628             if (bs->backing_file[0] != '\0')
 629                 term_printf(" backing_file=%s", bs->backing_file);
 630             term_printf(" ro=%d", bs->read_only);
 631             term_printf(" drv=%s", bs->drv->format_name);
 632             if (bs->encrypted)
 633                 term_printf(" encrypted");
 634         } else {
 635             term_printf(" [not inserted]");
 636         }
 637         term_printf("\n");
 638     }
 639 }
 640
 641
 642 /**************************************************************/
 643 /* RAW block driver */
 644
 645 typedef struct BDRVRawState {
 646     int fd;
 647 } BDRVRawState;
 648
 649 static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
 650 {
 651     return 1; /* maybe */
 652 }
 653
 654 static int raw_open(BlockDriverState *bs, const char *filename)
 655 {
 656     BDRVRawState *s = bs->opaque;
 657     int fd;
 658     int64_t size;
 659 #ifdef _BSD
 660     struct stat sb;
 661 #endif
 662
 663     fd = open(filename, O_RDWR | O_BINARY | O_LARGEFILE);
 664     if (fd < 0) {
 665         fd = open(filename, O_RDONLY | O_BINARY | O_LARGEFILE);
 666         if (fd < 0)
 667             return -1;
 668         bs->read_only = 1;
 669     }
 670 #ifdef _BSD
 671     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
 672 #ifdef DIOCGMEDIASIZE
 673         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
 674 #endif
 675 #ifdef CONFIG_COCOA
 676         size = LONG_LONG_MAX;
 677 #else
 678         size = lseek(fd, 0LL, SEEK_END);
 679 #endif
 680     } else
 681 #endif
 682     {
 683         size = lseek(fd, 0, SEEK_END);
 684     }
 685 #ifdef _WIN32
 686     /* On Windows hosts it can happen that we're unable to get file size
 687        for CD-ROM raw device (it's inherent limitation of the CDFS driver). */
 688     if (size == -1)
 689         size = LONG_LONG_MAX;
 690 #endif
 691     bs->total_sectors = size / 512;
 692     s->fd = fd;
 693     return 0;
 694 }
 695
 696 static int raw_read(BlockDriverState *bs, int64_t sector_num,
 697                     uint8_t *buf, int nb_sectors)
 698 {
 699     BDRVRawState *s = bs->opaque;
 700     int ret;
 701
 702     lseek(s->fd, sector_num * 512, SEEK_SET);
 703     ret = read(s->fd, buf, nb_sectors * 512);
 704     if (ret != nb_sectors * 512)
 705         return -1;
 706     return 0;
 707 }
 708
 709 static int raw_write(BlockDriverState *bs, int64_t sector_num,
 710                      const uint8_t *buf, int nb_sectors)
 711 {
 712     BDRVRawState *s = bs->opaque;
 713     int ret;
 714
 715     lseek(s->fd, sector_num * 512, SEEK_SET);
 716     ret = write(s->fd, buf, nb_sectors * 512);
 717     if (ret != nb_sectors * 512)
 718         return -1;
 719     return 0;
 720 }
 721
 722 static void raw_close(BlockDriverState *bs)
 723 {
 724     BDRVRawState *s = bs->opaque;
 725     close(s->fd);
 726 }
 727
 728 static int raw_create(const char *filename, int64_t total_size,
 729                       const char *backing_file, int flags)
 730 {
 731     int fd;
 732
 733     if (flags || backing_file)
 734         return -ENOTSUP;
 735
 736     fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
 737               0644);
 738     if (fd < 0)
 739         return -EIO;
 740     ftruncate(fd, total_size * 512);
 741     close(fd);
 742     return 0;
 743 }
 744
 745 BlockDriver bdrv_raw = {
 746     "raw",
 747     sizeof(BDRVRawState),
 748     raw_probe,
 749     raw_open,
 750     raw_read,
 751     raw_write,
 752     raw_close,
 753     raw_create,
 754 };
 755
 756 void bdrv_init(void)
 757 {
 758     bdrv_register(&bdrv_raw);
 759 #ifndef _WIN32
 760     bdrv_register(&bdrv_cow);
 761 #endif
 762     bdrv_register(&bdrv_qcow);
 763     bdrv_register(&bdrv_vmdk);
 764     bdrv_register(&bdrv_cloop);
 765     bdrv_register(&bdrv_dmg);
 766     bdrv_register(&bdrv_bochs);
 767     bdrv_register(&bdrv_vpc);
 768     bdrv_register(&bdrv_vvfat);
 769 }