1/* 2 * Block driver for RAW files (posix) 3 * 4 * Copyright (c) 2006 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 "qemu-common.h" 25#include "qemu-timer.h" 26#include "qemu-char.h" 27#include "block_int.h" 28#include "module.h" 29#ifdef CONFIG_AIO 30#include "posix-aio-compat.h" 31#endif 32 33#ifdef CONFIG_COCOA 34#include <paths.h> 35#include <sys/param.h> 36#include <IOKit/IOKitLib.h> 37#include <IOKit/IOBSD.h> 38#include <IOKit/storage/IOMediaBSDClient.h> 39#include <IOKit/storage/IOMedia.h> 40#include <IOKit/storage/IOCDMedia.h> 41//#include <IOKit/storage/IOCDTypes.h> 42#include <CoreFoundation/CoreFoundation.h> 43#endif 44 45#ifdef __sun__ 46#define _POSIX_PTHREAD_SEMANTICS 1 47#include <signal.h> 48#include <sys/dkio.h> 49#endif 50#ifdef __linux__ 51#include <sys/ioctl.h> 52#include <linux/cdrom.h> 53#include <linux/fd.h> 54#endif 55#ifdef __FreeBSD__ 56#include <signal.h> 57#include <sys/disk.h> 58#include <sys/cdio.h> 59#endif 60 61#ifdef __OpenBSD__ 62#include <sys/ioctl.h> 63#include <sys/disklabel.h> 64#include <sys/dkio.h> 65#endif 66 67#ifdef __DragonFly__ 68#include <sys/ioctl.h> 69#include <sys/diskslice.h> 70#endif 71 72//#define DEBUG_FLOPPY 73 74//#define DEBUG_BLOCK 75#if defined(DEBUG_BLOCK) 76#define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \ 77 { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0) 78#else 79#define DEBUG_BLOCK_PRINT(formatCstr, ...) 80#endif 81 82/* OS X does not have O_DSYNC */ 83#ifndef O_DSYNC 84#define O_DSYNC O_SYNC 85#endif 86 87/* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */ 88#ifndef O_DIRECT 89#define O_DIRECT O_DSYNC 90#endif 91 92#define FTYPE_FILE 0 93#define FTYPE_CD 1 94#define FTYPE_FD 2 95 96#define ALIGNED_BUFFER_SIZE (32 * 512) 97 98/* if the FD is not accessed during that time (in ms), we try to 99 reopen it to see if the disk has been changed */ 100#define FD_OPEN_TIMEOUT 1000 101 102typedef struct BDRVRawState { 103 int fd; 104 int type; 105 unsigned int lseek_err_cnt; 106 int open_flags; 107#if defined(__linux__) 108 /* linux floppy specific */ 109 int64_t fd_open_time; 110 int64_t fd_error_time; 111 int fd_got_error; 112 int fd_media_changed; 113#endif 114 uint8_t* aligned_buf; 115} BDRVRawState; 116 117static int posix_aio_init(void); 118 119static int fd_open(BlockDriverState *bs); 120 121#if defined(__FreeBSD__) 122static int cdrom_reopen(BlockDriverState *bs); 123#endif 124 125static int raw_open_common(BlockDriverState *bs, const char *filename, 126 int bdrv_flags, int open_flags) 127{ 128 BDRVRawState *s = bs->opaque; 129 int fd, ret; 130 131 posix_aio_init(); 132 133 s->lseek_err_cnt = 0; 134 135 s->open_flags = open_flags | O_BINARY; 136 s->open_flags &= ~O_ACCMODE; 137 if ((bdrv_flags & BDRV_O_ACCESS) == BDRV_O_RDWR) { 138 s->open_flags |= O_RDWR; 139 } else { 140 s->open_flags |= O_RDONLY; 141 bs->read_only = 1; 142 } 143 144 /* Use O_DSYNC for write-through caching, no flags for write-back caching, 145 * and O_DIRECT for no caching. */ 146 if ((bdrv_flags & BDRV_O_NOCACHE)) 147 s->open_flags |= O_DIRECT; 148 else if (!(bdrv_flags & BDRV_O_CACHE_WB)) 149 s->open_flags |= O_DSYNC; 150 151 s->fd = -1; 152 fd = open(filename, s->open_flags, 0644); 153 if (fd < 0) { 154 ret = -errno; 155 if (ret == -EROFS) 156 ret = -EACCES; 157 return ret; 158 } 159 s->fd = fd; 160 s->aligned_buf = NULL; 161 if ((bdrv_flags & BDRV_O_NOCACHE)) { 162 s->aligned_buf = qemu_blockalign(bs, ALIGNED_BUFFER_SIZE); 163 if (s->aligned_buf == NULL) { 164 ret = -errno; 165 close(fd); 166 return ret; 167 } 168 } 169 return 0; 170} 171 172static int raw_open(BlockDriverState *bs, const char *filename, int flags) 173{ 174 BDRVRawState *s = bs->opaque; 175 int open_flags = 0; 176 177 s->type = FTYPE_FILE; 178 if (flags & BDRV_O_CREAT) 179 open_flags = O_CREAT | O_TRUNC; 180 181 return raw_open_common(bs, filename, flags, open_flags); 182} 183 184/* XXX: use host sector size if necessary with: 185#ifdef DIOCGSECTORSIZE 186 { 187 unsigned int sectorsize = 512; 188 if (!ioctl(fd, DIOCGSECTORSIZE, §orsize) && 189 sectorsize > bufsize) 190 bufsize = sectorsize; 191 } 192#endif 193#ifdef CONFIG_COCOA 194 u_int32_t blockSize = 512; 195 if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) { 196 bufsize = blockSize; 197 } 198#endif 199*/ 200 201/* 202 * offset and count are in bytes, but must be multiples of 512 for files 203 * opened with O_DIRECT. buf must be aligned to 512 bytes then. 204 * 205 * This function may be called without alignment if the caller ensures 206 * that O_DIRECT is not in effect. 207 */ 208static int raw_pread_aligned(BlockDriverState *bs, int64_t offset, 209 uint8_t *buf, int count) 210{ 211 BDRVRawState *s = bs->opaque; 212 int ret; 213 214 ret = fd_open(bs); 215 if (ret < 0) 216 return ret; 217 218 if (offset >= 0 && lseek(s->fd, offset, SEEK_SET) == (off_t)-1) { 219 ++(s->lseek_err_cnt); 220 if(s->lseek_err_cnt <= 10) { 221 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64 222 "] lseek failed : %d = %s\n", 223 s->fd, bs->filename, offset, buf, count, 224 bs->total_sectors, errno, strerror(errno)); 225 } 226 return -1; 227 } 228 s->lseek_err_cnt=0; 229 230 ret = read(s->fd, buf, count); 231 if (ret == count) 232 goto label__raw_read__success; 233 234 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64 235 "] read failed %d : %d = %s\n", 236 s->fd, bs->filename, offset, buf, count, 237 bs->total_sectors, ret, errno, strerror(errno)); 238 239 /* Try harder for CDrom. */ 240 if (bs->type == BDRV_TYPE_CDROM) { 241 lseek(s->fd, offset, SEEK_SET); 242 ret = read(s->fd, buf, count); 243 if (ret == count) 244 goto label__raw_read__success; 245 lseek(s->fd, offset, SEEK_SET); 246 ret = read(s->fd, buf, count); 247 if (ret == count) 248 goto label__raw_read__success; 249 250 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64 251 "] retry read failed %d : %d = %s\n", 252 s->fd, bs->filename, offset, buf, count, 253 bs->total_sectors, ret, errno, strerror(errno)); 254 } 255 256label__raw_read__success: 257 258 return (ret < 0) ? -errno : ret; 259} 260 261/* 262 * offset and count are in bytes, but must be multiples of 512 for files 263 * opened with O_DIRECT. buf must be aligned to 512 bytes then. 264 * 265 * This function may be called without alignment if the caller ensures 266 * that O_DIRECT is not in effect. 267 */ 268static int raw_pwrite_aligned(BlockDriverState *bs, int64_t offset, 269 const uint8_t *buf, int count) 270{ 271 BDRVRawState *s = bs->opaque; 272 int ret; 273 274 ret = fd_open(bs); 275 if (ret < 0) 276 return -errno; 277 278 if (offset >= 0 && lseek(s->fd, offset, SEEK_SET) == (off_t)-1) { 279 ++(s->lseek_err_cnt); 280 if(s->lseek_err_cnt) { 281 DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64 ", %p, %d) [%" 282 PRId64 "] lseek failed : %d = %s\n", 283 s->fd, bs->filename, offset, buf, count, 284 bs->total_sectors, errno, strerror(errno)); 285 } 286 return -EIO; 287 } 288 s->lseek_err_cnt = 0; 289 290 ret = write(s->fd, buf, count); 291 if (ret == count) 292 goto label__raw_write__success; 293 294 DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64 ", %p, %d) [%" PRId64 295 "] write failed %d : %d = %s\n", 296 s->fd, bs->filename, offset, buf, count, 297 bs->total_sectors, ret, errno, strerror(errno)); 298 299label__raw_write__success: 300 301 return (ret < 0) ? -errno : ret; 302} 303 304 305/* 306 * offset and count are in bytes and possibly not aligned. For files opened 307 * with O_DIRECT, necessary alignments are ensured before calling 308 * raw_pread_aligned to do the actual read. 309 */ 310static int raw_pread(BlockDriverState *bs, int64_t offset, 311 uint8_t *buf, int count) 312{ 313 BDRVRawState *s = bs->opaque; 314 int size, ret, shift, sum; 315 316 sum = 0; 317 318 if (s->aligned_buf != NULL) { 319 320 if (offset & 0x1ff) { 321 /* align offset on a 512 bytes boundary */ 322 323 shift = offset & 0x1ff; 324 size = (shift + count + 0x1ff) & ~0x1ff; 325 if (size > ALIGNED_BUFFER_SIZE) 326 size = ALIGNED_BUFFER_SIZE; 327 ret = raw_pread_aligned(bs, offset - shift, s->aligned_buf, size); 328 if (ret < 0) 329 return ret; 330 331 size = 512 - shift; 332 if (size > count) 333 size = count; 334 memcpy(buf, s->aligned_buf + shift, size); 335 336 buf += size; 337 offset += size; 338 count -= size; 339 sum += size; 340 341 if (count == 0) 342 return sum; 343 } 344 if (count & 0x1ff || (uintptr_t) buf & 0x1ff) { 345 346 /* read on aligned buffer */ 347 348 while (count) { 349 350 size = (count + 0x1ff) & ~0x1ff; 351 if (size > ALIGNED_BUFFER_SIZE) 352 size = ALIGNED_BUFFER_SIZE; 353 354 ret = raw_pread_aligned(bs, offset, s->aligned_buf, size); 355 if (ret < 0) 356 return ret; 357 358 size = ret; 359 if (size > count) 360 size = count; 361 362 memcpy(buf, s->aligned_buf, size); 363 364 buf += size; 365 offset += size; 366 count -= size; 367 sum += size; 368 } 369 370 return sum; 371 } 372 } 373 374 return raw_pread_aligned(bs, offset, buf, count) + sum; 375} 376 377static int raw_read(BlockDriverState *bs, int64_t sector_num, 378 uint8_t *buf, int nb_sectors) 379{ 380 int ret; 381 382 ret = raw_pread(bs, sector_num * 512, buf, nb_sectors * 512); 383 if (ret == (nb_sectors * 512)) 384 ret = 0; 385 return ret; 386} 387 388/* 389 * offset and count are in bytes and possibly not aligned. For files opened 390 * with O_DIRECT, necessary alignments are ensured before calling 391 * raw_pwrite_aligned to do the actual write. 392 */ 393static int raw_pwrite(BlockDriverState *bs, int64_t offset, 394 const uint8_t *buf, int count) 395{ 396 BDRVRawState *s = bs->opaque; 397 int size, ret, shift, sum; 398 399 sum = 0; 400 401 if (s->aligned_buf != NULL) { 402 403 if (offset & 0x1ff) { 404 /* align offset on a 512 bytes boundary */ 405 shift = offset & 0x1ff; 406 ret = raw_pread_aligned(bs, offset - shift, s->aligned_buf, 512); 407 if (ret < 0) 408 return ret; 409 410 size = 512 - shift; 411 if (size > count) 412 size = count; 413 memcpy(s->aligned_buf + shift, buf, size); 414 415 ret = raw_pwrite_aligned(bs, offset - shift, s->aligned_buf, 512); 416 if (ret < 0) 417 return ret; 418 419 buf += size; 420 offset += size; 421 count -= size; 422 sum += size; 423 424 if (count == 0) 425 return sum; 426 } 427 if (count & 0x1ff || (uintptr_t) buf & 0x1ff) { 428 429 while ((size = (count & ~0x1ff)) != 0) { 430 431 if (size > ALIGNED_BUFFER_SIZE) 432 size = ALIGNED_BUFFER_SIZE; 433 434 memcpy(s->aligned_buf, buf, size); 435 436 ret = raw_pwrite_aligned(bs, offset, s->aligned_buf, size); 437 if (ret < 0) 438 return ret; 439 440 buf += ret; 441 offset += ret; 442 count -= ret; 443 sum += ret; 444 } 445 /* here, count < 512 because (count & ~0x1ff) == 0 */ 446 if (count) { 447 ret = raw_pread_aligned(bs, offset, s->aligned_buf, 512); 448 if (ret < 0) 449 return ret; 450 memcpy(s->aligned_buf, buf, count); 451 452 ret = raw_pwrite_aligned(bs, offset, s->aligned_buf, 512); 453 if (ret < 0) 454 return ret; 455 if (count < ret) 456 ret = count; 457 458 sum += ret; 459 } 460 return sum; 461 } 462 } 463 return raw_pwrite_aligned(bs, offset, buf, count) + sum; 464} 465 466static int raw_write(BlockDriverState *bs, int64_t sector_num, 467 const uint8_t *buf, int nb_sectors) 468{ 469 int ret; 470 ret = raw_pwrite(bs, sector_num * 512, buf, nb_sectors * 512); 471 if (ret == (nb_sectors * 512)) 472 ret = 0; 473 return ret; 474} 475 476#ifdef CONFIG_AIO 477/***********************************************************/ 478/* Unix AIO using POSIX AIO */ 479 480typedef struct RawAIOCB { 481 BlockDriverAIOCB common; 482 struct qemu_paiocb aiocb; 483 struct RawAIOCB *next; 484 int ret; 485} RawAIOCB; 486 487typedef struct PosixAioState 488{ 489 int rfd, wfd; 490 RawAIOCB *first_aio; 491} PosixAioState; 492 493static void posix_aio_read(void *opaque) 494{ 495 PosixAioState *s = opaque; 496 RawAIOCB *acb, **pacb; 497 int ret; 498 ssize_t len; 499 500 /* read all bytes from signal pipe */ 501 for (;;) { 502 char bytes[16]; 503 504 len = read(s->rfd, bytes, sizeof(bytes)); 505 if (len == -1 && errno == EINTR) 506 continue; /* try again */ 507 if (len == sizeof(bytes)) 508 continue; /* more to read */ 509 break; 510 } 511 512 for(;;) { 513 pacb = &s->first_aio; 514 for(;;) { 515 acb = *pacb; 516 if (!acb) 517 goto the_end; 518 ret = qemu_paio_error(&acb->aiocb); 519 if (ret == ECANCELED) { 520 /* remove the request */ 521 *pacb = acb->next; 522 qemu_aio_release(acb); 523 } else if (ret != EINPROGRESS) { 524 /* end of aio */ 525 if (ret == 0) { 526 ret = qemu_paio_return(&acb->aiocb); 527 if (ret == acb->aiocb.aio_nbytes) 528 ret = 0; 529 else 530 ret = -EINVAL; 531 } else { 532 ret = -ret; 533 } 534 /* remove the request */ 535 *pacb = acb->next; 536 /* call the callback */ 537 acb->common.cb(acb->common.opaque, ret); 538 qemu_aio_release(acb); 539 break; 540 } else { 541 pacb = &acb->next; 542 } 543 } 544 } 545 the_end: ; 546} 547 548static int posix_aio_flush(void *opaque) 549{ 550 PosixAioState *s = opaque; 551 return !!s->first_aio; 552} 553 554static PosixAioState *posix_aio_state; 555 556static void aio_signal_handler(int signum) 557{ 558 if (posix_aio_state) { 559 char byte = 0; 560 561 write(posix_aio_state->wfd, &byte, sizeof(byte)); 562 } 563 564 qemu_service_io(); 565} 566 567static int posix_aio_init(void) 568{ 569 struct sigaction act; 570 PosixAioState *s; 571 int fds[2]; 572 struct qemu_paioinit ai; 573 574 if (posix_aio_state) 575 return 0; 576 577 s = qemu_malloc(sizeof(PosixAioState)); 578 579 sigfillset(&act.sa_mask); 580 act.sa_flags = 0; /* do not restart syscalls to interrupt select() */ 581 act.sa_handler = aio_signal_handler; 582 sigaction(SIGUSR2, &act, NULL); 583 584 s->first_aio = NULL; 585 if (pipe(fds) == -1) { 586 fprintf(stderr, "failed to create pipe\n"); 587 return -errno; 588 } 589 590 s->rfd = fds[0]; 591 s->wfd = fds[1]; 592 593 fcntl(s->rfd, F_SETFL, O_NONBLOCK); 594 fcntl(s->wfd, F_SETFL, O_NONBLOCK); 595 596 qemu_aio_set_fd_handler(s->rfd, posix_aio_read, NULL, posix_aio_flush, s); 597 598 memset(&ai, 0, sizeof(ai)); 599 ai.aio_threads = 64; 600 ai.aio_num = 64; 601 qemu_paio_init(&ai); 602 603 posix_aio_state = s; 604 605 return 0; 606} 607 608static void raw_aio_remove(RawAIOCB *acb) 609{ 610 RawAIOCB **pacb; 611 612 /* remove the callback from the queue */ 613 pacb = &posix_aio_state->first_aio; 614 for(;;) { 615 if (*pacb == NULL) { 616 fprintf(stderr, "raw_aio_remove: aio request not found!\n"); 617 break; 618 } else if (*pacb == acb) { 619 *pacb = acb->next; 620 qemu_aio_release(acb); 621 break; 622 } 623 pacb = &(*pacb)->next; 624 } 625} 626 627static void raw_aio_cancel(BlockDriverAIOCB *blockacb) 628{ 629 int ret; 630 RawAIOCB *acb = (RawAIOCB *)blockacb; 631 632 ret = qemu_paio_cancel(acb->aiocb.aio_fildes, &acb->aiocb); 633 if (ret == QEMU_PAIO_NOTCANCELED) { 634 /* fail safe: if the aio could not be canceled, we wait for 635 it */ 636 while (qemu_paio_error(&acb->aiocb) == EINPROGRESS); 637 } 638 639 raw_aio_remove(acb); 640} 641 642static AIOPool raw_aio_pool = { 643 .aiocb_size = sizeof(RawAIOCB), 644 .cancel = raw_aio_cancel, 645}; 646 647static RawAIOCB *raw_aio_setup(BlockDriverState *bs, int64_t sector_num, 648 QEMUIOVector *qiov, int nb_sectors, 649 BlockDriverCompletionFunc *cb, void *opaque) 650{ 651 BDRVRawState *s = bs->opaque; 652 RawAIOCB *acb; 653 654 if (fd_open(bs) < 0) 655 return NULL; 656 657 acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque); 658 if (!acb) 659 return NULL; 660 acb->aiocb.aio_fildes = s->fd; 661 acb->aiocb.ev_signo = SIGUSR2; 662 acb->aiocb.aio_iov = qiov->iov; 663 acb->aiocb.aio_niov = qiov->niov; 664 acb->aiocb.aio_nbytes = nb_sectors * 512; 665 acb->aiocb.aio_offset = sector_num * 512; 666 acb->aiocb.aio_flags = 0; 667 668 /* 669 * If O_DIRECT is used the buffer needs to be aligned on a sector 670 * boundary. Tell the low level code to ensure that in case it's 671 * not done yet. 672 */ 673 if (s->aligned_buf) 674 acb->aiocb.aio_flags |= QEMU_AIO_SECTOR_ALIGNED; 675 676 acb->next = posix_aio_state->first_aio; 677 posix_aio_state->first_aio = acb; 678 return acb; 679} 680 681static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, 682 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 683 BlockDriverCompletionFunc *cb, void *opaque) 684{ 685 RawAIOCB *acb; 686 687 acb = raw_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque); 688 if (!acb) 689 return NULL; 690 if (qemu_paio_read(&acb->aiocb) < 0) { 691 raw_aio_remove(acb); 692 return NULL; 693 } 694 return &acb->common; 695} 696 697static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, 698 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 699 BlockDriverCompletionFunc *cb, void *opaque) 700{ 701 RawAIOCB *acb; 702 703 acb = raw_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque); 704 if (!acb) 705 return NULL; 706 if (qemu_paio_write(&acb->aiocb) < 0) { 707 raw_aio_remove(acb); 708 return NULL; 709 } 710 return &acb->common; 711} 712#else /* CONFIG_AIO */ 713static int posix_aio_init(void) 714{ 715 return 0; 716} 717#endif /* CONFIG_AIO */ 718 719 720static void raw_close(BlockDriverState *bs) 721{ 722 BDRVRawState *s = bs->opaque; 723 if (s->fd >= 0) { 724 close(s->fd); 725 s->fd = -1; 726 if (s->aligned_buf != NULL) 727 qemu_free(s->aligned_buf); 728 } 729} 730 731static int raw_truncate(BlockDriverState *bs, int64_t offset) 732{ 733 BDRVRawState *s = bs->opaque; 734 if (s->type != FTYPE_FILE) 735 return -ENOTSUP; 736 if (ftruncate(s->fd, offset) < 0) 737 return -errno; 738 return 0; 739} 740 741#ifdef __OpenBSD__ 742static int64_t raw_getlength(BlockDriverState *bs) 743{ 744 BDRVRawState *s = bs->opaque; 745 int fd = s->fd; 746 struct stat st; 747 748 if (fstat(fd, &st)) 749 return -1; 750 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { 751 struct disklabel dl; 752 753 if (ioctl(fd, DIOCGDINFO, &dl)) 754 return -1; 755 return (uint64_t)dl.d_secsize * 756 dl.d_partitions[DISKPART(st.st_rdev)].p_size; 757 } else 758 return st.st_size; 759} 760#else /* !__OpenBSD__ */ 761static int64_t raw_getlength(BlockDriverState *bs) 762{ 763 BDRVRawState *s = bs->opaque; 764 int fd = s->fd; 765 int64_t size; 766#ifdef CONFIG_BSD 767 struct stat sb; 768#ifdef __FreeBSD__ 769 int reopened = 0; 770#endif 771#endif 772#ifdef __sun__ 773 struct dk_minfo minfo; 774 int rv; 775#endif 776 int ret; 777 778 ret = fd_open(bs); 779 if (ret < 0) 780 return ret; 781 782#ifdef CONFIG_BSD 783#ifdef __FreeBSD__ 784again: 785#endif 786 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) { 787#ifdef DIOCGMEDIASIZE 788 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size)) 789#elif defined(DIOCGPART) 790 { 791 struct partinfo pi; 792 if (ioctl(fd, DIOCGPART, &pi) == 0) 793 size = pi.media_size; 794 else 795 size = 0; 796 } 797 if (size == 0) 798#endif 799#ifdef CONFIG_COCOA 800 size = LONG_LONG_MAX; 801#else 802 size = lseek(fd, 0LL, SEEK_END); 803#endif 804#ifdef __FreeBSD__ 805 switch(s->type) { 806 case FTYPE_CD: 807 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */ 808 if (size == 2048LL * (unsigned)-1) 809 size = 0; 810 /* XXX no disc? maybe we need to reopen... */ 811 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) { 812 reopened = 1; 813 goto again; 814 } 815 } 816#endif 817 } else 818#endif 819#ifdef __sun__ 820 /* 821 * use the DKIOCGMEDIAINFO ioctl to read the size. 822 */ 823 rv = ioctl ( fd, DKIOCGMEDIAINFO, &minfo ); 824 if ( rv != -1 ) { 825 size = minfo.dki_lbsize * minfo.dki_capacity; 826 } else /* there are reports that lseek on some devices 827 fails, but irc discussion said that contingency 828 on contingency was overkill */ 829#endif 830 { 831 size = lseek(fd, 0, SEEK_END); 832 } 833 return size; 834} 835#endif 836 837static int raw_create(const char *filename, QEMUOptionParameter *options) 838{ 839 int fd; 840 int64_t total_size = 0; 841 842 /* Read out options */ 843 while (options && options->name) { 844 if (!strcmp(options->name, BLOCK_OPT_SIZE)) { 845 total_size = options->value.n / 512; 846 } 847 options++; 848 } 849 850 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 851 0644); 852 if (fd < 0) 853 return -EIO; 854 ftruncate(fd, total_size * 512); 855 close(fd); 856 return 0; 857} 858 859static void raw_flush(BlockDriverState *bs) 860{ 861 BDRVRawState *s = bs->opaque; 862 fsync(s->fd); 863} 864 865 866static QEMUOptionParameter raw_create_options[] = { 867 { 868 .name = BLOCK_OPT_SIZE, 869 .type = OPT_SIZE, 870 .help = "Virtual disk size" 871 }, 872 { NULL } 873}; 874 875static BlockDriver bdrv_raw = { 876 .format_name = "raw", 877 .instance_size = sizeof(BDRVRawState), 878 .bdrv_probe = NULL, /* no probe for protocols */ 879 .bdrv_open = raw_open, 880 .bdrv_read = raw_read, 881 .bdrv_write = raw_write, 882 .bdrv_close = raw_close, 883 .bdrv_create = raw_create, 884 .bdrv_flush = raw_flush, 885 886#ifdef CONFIG_AIO 887 .bdrv_aio_readv = raw_aio_readv, 888 .bdrv_aio_writev = raw_aio_writev, 889#endif 890 891 .bdrv_truncate = raw_truncate, 892 .bdrv_getlength = raw_getlength, 893 894 .create_options = raw_create_options, 895}; 896 897/***********************************************/ 898/* host device */ 899 900#ifdef CONFIG_COCOA 901static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator ); 902static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize ); 903 904kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator ) 905{ 906 kern_return_t kernResult; 907 mach_port_t masterPort; 908 CFMutableDictionaryRef classesToMatch; 909 910 kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort ); 911 if ( KERN_SUCCESS != kernResult ) { 912 printf( "IOMasterPort returned %d\n", kernResult ); 913 } 914 915 classesToMatch = IOServiceMatching( kIOCDMediaClass ); 916 if ( classesToMatch == NULL ) { 917 printf( "IOServiceMatching returned a NULL dictionary.\n" ); 918 } else { 919 CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue ); 920 } 921 kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator ); 922 if ( KERN_SUCCESS != kernResult ) 923 { 924 printf( "IOServiceGetMatchingServices returned %d\n", kernResult ); 925 } 926 927 return kernResult; 928} 929 930kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize ) 931{ 932 io_object_t nextMedia; 933 kern_return_t kernResult = KERN_FAILURE; 934 *bsdPath = '\0'; 935 nextMedia = IOIteratorNext( mediaIterator ); 936 if ( nextMedia ) 937 { 938 CFTypeRef bsdPathAsCFString; 939 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 ); 940 if ( bsdPathAsCFString ) { 941 size_t devPathLength; 942 strcpy( bsdPath, _PATH_DEV ); 943 strcat( bsdPath, "r" ); 944 devPathLength = strlen( bsdPath ); 945 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) { 946 kernResult = KERN_SUCCESS; 947 } 948 CFRelease( bsdPathAsCFString ); 949 } 950 IOObjectRelease( nextMedia ); 951 } 952 953 return kernResult; 954} 955 956#endif 957 958static int hdev_probe_device(const char *filename) 959{ 960 struct stat st; 961 962 /* allow a dedicated CD-ROM driver to match with a higher priority */ 963 if (strstart(filename, "/dev/cdrom", NULL)) 964 return 50; 965 966 if (stat(filename, &st) >= 0 && 967 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) { 968 return 100; 969 } 970 971 return 0; 972} 973 974static int hdev_open(BlockDriverState *bs, const char *filename, int flags) 975{ 976 BDRVRawState *s = bs->opaque; 977 978#ifdef CONFIG_COCOA 979 if (strstart(filename, "/dev/cdrom", NULL)) { 980 kern_return_t kernResult; 981 io_iterator_t mediaIterator; 982 char bsdPath[ MAXPATHLEN ]; 983 int fd; 984 985 kernResult = FindEjectableCDMedia( &mediaIterator ); 986 kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) ); 987 988 if ( bsdPath[ 0 ] != '\0' ) { 989 strcat(bsdPath,"s0"); 990 /* some CDs don't have a partition 0 */ 991 fd = open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE); 992 if (fd < 0) { 993 bsdPath[strlen(bsdPath)-1] = '1'; 994 } else { 995 close(fd); 996 } 997 filename = bsdPath; 998 } 999 1000 if ( mediaIterator ) 1001 IOObjectRelease( mediaIterator ); 1002 } 1003#endif 1004 1005 s->type = FTYPE_FILE; 1006#if defined(__linux__) && defined(CONFIG_AIO) 1007 if (strstart(filename, "/dev/sg", NULL)) { 1008 bs->sg = 1; 1009 } 1010#endif 1011 1012 return raw_open_common(bs, filename, flags, 0); 1013} 1014 1015#if defined(__linux__) 1016/* Note: we do not have a reliable method to detect if the floppy is 1017 present. The current method is to try to open the floppy at every 1018 I/O and to keep it opened during a few hundreds of ms. */ 1019static int fd_open(BlockDriverState *bs) 1020{ 1021 BDRVRawState *s = bs->opaque; 1022 int last_media_present; 1023 1024 if (s->type != FTYPE_FD) 1025 return 0; 1026 last_media_present = (s->fd >= 0); 1027 if (s->fd >= 0 && 1028 (qemu_get_clock(rt_clock) - s->fd_open_time) >= FD_OPEN_TIMEOUT) { 1029 close(s->fd); 1030 s->fd = -1; 1031#ifdef DEBUG_FLOPPY 1032 printf("Floppy closed\n"); 1033#endif 1034 } 1035 if (s->fd < 0) { 1036 if (s->fd_got_error && 1037 (qemu_get_clock(rt_clock) - s->fd_error_time) < FD_OPEN_TIMEOUT) { 1038#ifdef DEBUG_FLOPPY 1039 printf("No floppy (open delayed)\n"); 1040#endif 1041 return -EIO; 1042 } 1043 s->fd = open(bs->filename, s->open_flags & ~O_NONBLOCK); 1044 if (s->fd < 0) { 1045 s->fd_error_time = qemu_get_clock(rt_clock); 1046 s->fd_got_error = 1; 1047 if (last_media_present) 1048 s->fd_media_changed = 1; 1049#ifdef DEBUG_FLOPPY 1050 printf("No floppy\n"); 1051#endif 1052 return -EIO; 1053 } 1054#ifdef DEBUG_FLOPPY 1055 printf("Floppy opened\n"); 1056#endif 1057 } 1058 if (!last_media_present) 1059 s->fd_media_changed = 1; 1060 s->fd_open_time = qemu_get_clock(rt_clock); 1061 s->fd_got_error = 0; 1062 return 0; 1063} 1064 1065static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) 1066{ 1067 BDRVRawState *s = bs->opaque; 1068 1069 return ioctl(s->fd, req, buf); 1070} 1071 1072#ifdef CONFIG_AIO 1073static BlockDriverAIOCB *hdev_aio_ioctl(BlockDriverState *bs, 1074 unsigned long int req, void *buf, 1075 BlockDriverCompletionFunc *cb, void *opaque) 1076{ 1077 BDRVRawState *s = bs->opaque; 1078 RawAIOCB *acb; 1079 1080 if (fd_open(bs) < 0) 1081 return NULL; 1082 1083 acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque); 1084 if (!acb) 1085 return NULL; 1086 acb->aiocb.aio_fildes = s->fd; 1087 acb->aiocb.ev_signo = SIGUSR2; 1088 acb->aiocb.aio_offset = 0; 1089 acb->aiocb.aio_flags = 0; 1090 1091 acb->next = posix_aio_state->first_aio; 1092 posix_aio_state->first_aio = acb; 1093 1094 acb->aiocb.aio_ioctl_buf = buf; 1095 acb->aiocb.aio_ioctl_cmd = req; 1096 if (qemu_paio_ioctl(&acb->aiocb) < 0) { 1097 raw_aio_remove(acb); 1098 return NULL; 1099 } 1100 1101 return &acb->common; 1102} 1103#endif 1104 1105#elif defined(__FreeBSD__) 1106static int fd_open(BlockDriverState *bs) 1107{ 1108 BDRVRawState *s = bs->opaque; 1109 1110 /* this is just to ensure s->fd is sane (its called by io ops) */ 1111 if (s->fd >= 0) 1112 return 0; 1113 return -EIO; 1114} 1115#else /* !linux && !FreeBSD */ 1116 1117static int fd_open(BlockDriverState *bs) 1118{ 1119 return 0; 1120} 1121 1122#endif /* !linux && !FreeBSD */ 1123 1124static int hdev_create(const char *filename, QEMUOptionParameter *options) 1125{ 1126 int fd; 1127 int ret = 0; 1128 struct stat stat_buf; 1129 int64_t total_size = 0; 1130 1131 /* Read out options */ 1132 while (options && options->name) { 1133 if (!strcmp(options->name, "size")) { 1134 total_size = options->value.n / 512; 1135 } 1136 options++; 1137 } 1138 1139 fd = open(filename, O_WRONLY | O_BINARY); 1140 if (fd < 0) 1141 return -EIO; 1142 1143 if (fstat(fd, &stat_buf) < 0) 1144 ret = -EIO; 1145 else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) 1146 ret = -EIO; 1147 else if (lseek(fd, 0, SEEK_END) < total_size * 512) 1148 ret = -ENOSPC; 1149 1150 close(fd); 1151 return ret; 1152} 1153 1154static BlockDriver bdrv_host_device = { 1155 .format_name = "host_device", 1156 .instance_size = sizeof(BDRVRawState), 1157 .bdrv_probe_device = hdev_probe_device, 1158 .bdrv_open = hdev_open, 1159 .bdrv_close = raw_close, 1160 .bdrv_create = hdev_create, 1161 .bdrv_flush = raw_flush, 1162 1163#ifdef CONFIG_AIO 1164 .bdrv_aio_readv = raw_aio_readv, 1165 .bdrv_aio_writev = raw_aio_writev, 1166#endif 1167 1168 .bdrv_read = raw_read, 1169 .bdrv_write = raw_write, 1170 .bdrv_getlength = raw_getlength, 1171 1172 /* generic scsi device */ 1173#ifdef __linux__ 1174 .bdrv_ioctl = hdev_ioctl, 1175#ifdef CONFIG_AIO 1176 .bdrv_aio_ioctl = hdev_aio_ioctl, 1177#endif 1178#endif 1179}; 1180 1181#ifdef __linux__ 1182static int floppy_open(BlockDriverState *bs, const char *filename, int flags) 1183{ 1184 BDRVRawState *s = bs->opaque; 1185 int ret; 1186 1187 posix_aio_init(); 1188 1189 s->type = FTYPE_FD; 1190 1191 /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */ 1192 ret = raw_open_common(bs, filename, flags, O_NONBLOCK); 1193 if (ret) 1194 return ret; 1195 1196 /* close fd so that we can reopen it as needed */ 1197 close(s->fd); 1198 s->fd = -1; 1199 s->fd_media_changed = 1; 1200 1201 return 0; 1202} 1203 1204static int floppy_probe_device(const char *filename) 1205{ 1206 if (strstart(filename, "/dev/fd", NULL)) 1207 return 100; 1208 return 0; 1209} 1210 1211 1212static int floppy_is_inserted(BlockDriverState *bs) 1213{ 1214 return fd_open(bs) >= 0; 1215} 1216 1217static int floppy_media_changed(BlockDriverState *bs) 1218{ 1219 BDRVRawState *s = bs->opaque; 1220 int ret; 1221 1222 /* 1223 * XXX: we do not have a true media changed indication. 1224 * It does not work if the floppy is changed without trying to read it. 1225 */ 1226 fd_open(bs); 1227 ret = s->fd_media_changed; 1228 s->fd_media_changed = 0; 1229#ifdef DEBUG_FLOPPY 1230 printf("Floppy changed=%d\n", ret); 1231#endif 1232 return ret; 1233} 1234 1235static int floppy_eject(BlockDriverState *bs, int eject_flag) 1236{ 1237 BDRVRawState *s = bs->opaque; 1238 int fd; 1239 1240 if (s->fd >= 0) { 1241 close(s->fd); 1242 s->fd = -1; 1243 } 1244 fd = open(bs->filename, s->open_flags | O_NONBLOCK); 1245 if (fd >= 0) { 1246 if (ioctl(fd, FDEJECT, 0) < 0) 1247 perror("FDEJECT"); 1248 close(fd); 1249 } 1250 1251 return 0; 1252} 1253 1254static BlockDriver bdrv_host_floppy = { 1255 .format_name = "host_floppy", 1256 .instance_size = sizeof(BDRVRawState), 1257 .bdrv_probe_device = floppy_probe_device, 1258 .bdrv_open = floppy_open, 1259 .bdrv_close = raw_close, 1260 .bdrv_create = hdev_create, 1261 .bdrv_flush = raw_flush, 1262 1263#ifdef CONFIG_AIO 1264 .bdrv_aio_readv = raw_aio_readv, 1265 .bdrv_aio_writev = raw_aio_writev, 1266#endif 1267 1268 .bdrv_read = raw_read, 1269 .bdrv_write = raw_write, 1270 .bdrv_getlength = raw_getlength, 1271 1272 /* removable device support */ 1273 .bdrv_is_inserted = floppy_is_inserted, 1274 .bdrv_media_changed = floppy_media_changed, 1275 .bdrv_eject = floppy_eject, 1276}; 1277 1278static int cdrom_open(BlockDriverState *bs, const char *filename, int flags) 1279{ 1280 BDRVRawState *s = bs->opaque; 1281 1282 s->type = FTYPE_CD; 1283 1284 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */ 1285 return raw_open_common(bs, filename, flags, O_NONBLOCK); 1286} 1287 1288static int cdrom_probe_device(const char *filename) 1289{ 1290 if (strstart(filename, "/dev/cd", NULL)) 1291 return 100; 1292 return 0; 1293} 1294 1295static int cdrom_is_inserted(BlockDriverState *bs) 1296{ 1297 BDRVRawState *s = bs->opaque; 1298 int ret; 1299 1300 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT); 1301 if (ret == CDS_DISC_OK) 1302 return 1; 1303 return 0; 1304} 1305 1306static int cdrom_eject(BlockDriverState *bs, int eject_flag) 1307{ 1308 BDRVRawState *s = bs->opaque; 1309 1310 if (eject_flag) { 1311 if (ioctl(s->fd, CDROMEJECT, NULL) < 0) 1312 perror("CDROMEJECT"); 1313 } else { 1314 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0) 1315 perror("CDROMEJECT"); 1316 } 1317 1318 return 0; 1319} 1320 1321static int cdrom_set_locked(BlockDriverState *bs, int locked) 1322{ 1323 BDRVRawState *s = bs->opaque; 1324 1325 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) { 1326 /* 1327 * Note: an error can happen if the distribution automatically 1328 * mounts the CD-ROM 1329 */ 1330 /* perror("CDROM_LOCKDOOR"); */ 1331 } 1332 1333 return 0; 1334} 1335 1336static BlockDriver bdrv_host_cdrom = { 1337 .format_name = "host_cdrom", 1338 .instance_size = sizeof(BDRVRawState), 1339 .bdrv_probe_device = cdrom_probe_device, 1340 .bdrv_open = cdrom_open, 1341 .bdrv_close = raw_close, 1342 .bdrv_create = hdev_create, 1343 .bdrv_flush = raw_flush, 1344 1345#ifdef CONFIG_AIO 1346 .bdrv_aio_readv = raw_aio_readv, 1347 .bdrv_aio_writev = raw_aio_writev, 1348#endif 1349 1350 .bdrv_read = raw_read, 1351 .bdrv_write = raw_write, 1352 .bdrv_getlength = raw_getlength, 1353 1354 /* removable device support */ 1355 .bdrv_is_inserted = cdrom_is_inserted, 1356 .bdrv_eject = cdrom_eject, 1357 .bdrv_set_locked = cdrom_set_locked, 1358 1359 /* generic scsi device */ 1360 .bdrv_ioctl = hdev_ioctl, 1361#ifdef CONFIG_AIO 1362 .bdrv_aio_ioctl = hdev_aio_ioctl, 1363#endif 1364}; 1365#endif /* __linux__ */ 1366 1367#ifdef __FreeBSD__ 1368static int cdrom_open(BlockDriverState *bs, const char *filename, int flags) 1369{ 1370 BDRVRawState *s = bs->opaque; 1371 int ret; 1372 1373 s->type = FTYPE_CD; 1374 1375 ret = raw_open_common(bs, filename, flags, 0); 1376 if (ret) 1377 return ret; 1378 1379 /* make sure the door isnt locked at this time */ 1380 ioctl(s->fd, CDIOCALLOW); 1381 return 0; 1382} 1383 1384static int cdrom_probe_device(const char *filename) 1385{ 1386 if (strstart(filename, "/dev/cd", NULL) || 1387 strstart(filename, "/dev/acd", NULL)) 1388 return 100; 1389 return 0; 1390} 1391 1392static int cdrom_reopen(BlockDriverState *bs) 1393{ 1394 BDRVRawState *s = bs->opaque; 1395 int fd; 1396 1397 /* 1398 * Force reread of possibly changed/newly loaded disc, 1399 * FreeBSD seems to not notice sometimes... 1400 */ 1401 if (s->fd >= 0) 1402 close(s->fd); 1403 fd = open(bs->filename, s->open_flags, 0644); 1404 if (fd < 0) { 1405 s->fd = -1; 1406 return -EIO; 1407 } 1408 s->fd = fd; 1409 1410 /* make sure the door isnt locked at this time */ 1411 ioctl(s->fd, CDIOCALLOW); 1412 return 0; 1413} 1414 1415static int cdrom_is_inserted(BlockDriverState *bs) 1416{ 1417 return raw_getlength(bs) > 0; 1418} 1419 1420static int cdrom_eject(BlockDriverState *bs, int eject_flag) 1421{ 1422 BDRVRawState *s = bs->opaque; 1423 1424 if (s->fd < 0) 1425 return -ENOTSUP; 1426 1427 (void) ioctl(s->fd, CDIOCALLOW); 1428 1429 if (eject_flag) { 1430 if (ioctl(s->fd, CDIOCEJECT) < 0) 1431 perror("CDIOCEJECT"); 1432 } else { 1433 if (ioctl(s->fd, CDIOCCLOSE) < 0) 1434 perror("CDIOCCLOSE"); 1435 } 1436 1437 if (cdrom_reopen(bs) < 0) 1438 return -ENOTSUP; 1439 return 0; 1440} 1441 1442static int cdrom_set_locked(BlockDriverState *bs, int locked) 1443{ 1444 BDRVRawState *s = bs->opaque; 1445 1446 if (s->fd < 0) 1447 return -ENOTSUP; 1448 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) { 1449 /* 1450 * Note: an error can happen if the distribution automatically 1451 * mounts the CD-ROM 1452 */ 1453 /* perror("CDROM_LOCKDOOR"); */ 1454 } 1455 1456 return 0; 1457} 1458 1459static BlockDriver bdrv_host_cdrom = { 1460 .format_name = "host_cdrom", 1461 .instance_size = sizeof(BDRVRawState), 1462 .bdrv_probe_device = cdrom_probe_device, 1463 .bdrv_open = cdrom_open, 1464 .bdrv_close = raw_close, 1465 .bdrv_create = hdev_create, 1466 .bdrv_flush = raw_flush, 1467 1468#ifdef CONFIG_AIO 1469 .bdrv_aio_readv = raw_aio_readv, 1470 .bdrv_aio_writev = raw_aio_writev, 1471#endif 1472 1473 .bdrv_read = raw_read, 1474 .bdrv_write = raw_write, 1475 .bdrv_getlength = raw_getlength, 1476 1477 /* removable device support */ 1478 .bdrv_is_inserted = cdrom_is_inserted, 1479 .bdrv_eject = cdrom_eject, 1480 .bdrv_set_locked = cdrom_set_locked, 1481}; 1482#endif /* __FreeBSD__ */ 1483 1484static void bdrv_raw_init(void) 1485{ 1486 /* 1487 * Register all the drivers. Note that order is important, the driver 1488 * registered last will get probed first. 1489 */ 1490 bdrv_register(&bdrv_raw); 1491 bdrv_register(&bdrv_host_device); 1492#ifdef __linux__ 1493 bdrv_register(&bdrv_host_floppy); 1494 bdrv_register(&bdrv_host_cdrom); 1495#endif 1496#ifdef __FreeBSD__ 1497 bdrv_register(&bdrv_host_cdrom); 1498#endif 1499} 1500 1501block_init(bdrv_raw_init); 1502