1 /* 2 * Block driver for RAW files (win32) 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/osdep.h" 25 #include "qapi/error.h" 26 #include "qemu/cutils.h" 27 #include "block/block_int.h" 28 #include "qemu/module.h" 29 #include "block/raw-aio.h" 30 #include "trace.h" 31 #include "block/thread-pool.h" 32 #include "qemu/iov.h" 33 #include "qapi/qmp/qstring.h" 34 #include "qapi/util.h" 35 #include <windows.h> 36 #include <winioctl.h> 37 38 #define FTYPE_FILE 0 39 #define FTYPE_CD 1 40 #define FTYPE_HARDDISK 2 41 42 typedef struct RawWin32AIOData { 43 BlockDriverState *bs; 44 HANDLE hfile; 45 struct iovec *aio_iov; 46 int aio_niov; 47 size_t aio_nbytes; 48 off64_t aio_offset; 49 int aio_type; 50 } RawWin32AIOData; 51 52 typedef struct BDRVRawState { 53 HANDLE hfile; 54 int type; 55 char drive_path[16]; /* format: "d:\" */ 56 QEMUWin32AIOState *aio; 57 } BDRVRawState; 58 59 /* 60 * Read/writes the data to/from a given linear buffer. 61 * 62 * Returns the number of bytes handles or -errno in case of an error. Short 63 * reads are only returned if the end of the file is reached. 64 */ 65 static size_t handle_aiocb_rw(RawWin32AIOData *aiocb) 66 { 67 size_t offset = 0; 68 int i; 69 70 for (i = 0; i < aiocb->aio_niov; i++) { 71 OVERLAPPED ov; 72 DWORD ret, ret_count, len; 73 74 memset(&ov, 0, sizeof(ov)); 75 ov.Offset = (aiocb->aio_offset + offset); 76 ov.OffsetHigh = (aiocb->aio_offset + offset) >> 32; 77 len = aiocb->aio_iov[i].iov_len; 78 if (aiocb->aio_type & QEMU_AIO_WRITE) { 79 ret = WriteFile(aiocb->hfile, aiocb->aio_iov[i].iov_base, 80 len, &ret_count, &ov); 81 } else { 82 ret = ReadFile(aiocb->hfile, aiocb->aio_iov[i].iov_base, 83 len, &ret_count, &ov); 84 } 85 if (!ret) { 86 ret_count = 0; 87 } 88 if (ret_count != len) { 89 offset += ret_count; 90 break; 91 } 92 offset += len; 93 } 94 95 return offset; 96 } 97 98 static int aio_worker(void *arg) 99 { 100 RawWin32AIOData *aiocb = arg; 101 ssize_t ret = 0; 102 size_t count; 103 104 switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) { 105 case QEMU_AIO_READ: 106 count = handle_aiocb_rw(aiocb); 107 if (count < aiocb->aio_nbytes) { 108 /* A short read means that we have reached EOF. Pad the buffer 109 * with zeros for bytes after EOF. */ 110 iov_memset(aiocb->aio_iov, aiocb->aio_niov, count, 111 0, aiocb->aio_nbytes - count); 112 113 count = aiocb->aio_nbytes; 114 } 115 if (count == aiocb->aio_nbytes) { 116 ret = 0; 117 } else { 118 ret = -EINVAL; 119 } 120 break; 121 case QEMU_AIO_WRITE: 122 count = handle_aiocb_rw(aiocb); 123 if (count == aiocb->aio_nbytes) { 124 ret = 0; 125 } else { 126 ret = -EINVAL; 127 } 128 break; 129 case QEMU_AIO_FLUSH: 130 if (!FlushFileBuffers(aiocb->hfile)) { 131 return -EIO; 132 } 133 break; 134 default: 135 fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type); 136 ret = -EINVAL; 137 break; 138 } 139 140 g_free(aiocb); 141 return ret; 142 } 143 144 static BlockAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile, 145 int64_t offset, QEMUIOVector *qiov, int count, 146 BlockCompletionFunc *cb, void *opaque, int type) 147 { 148 RawWin32AIOData *acb = g_new(RawWin32AIOData, 1); 149 ThreadPool *pool; 150 151 acb->bs = bs; 152 acb->hfile = hfile; 153 acb->aio_type = type; 154 155 if (qiov) { 156 acb->aio_iov = qiov->iov; 157 acb->aio_niov = qiov->niov; 158 assert(qiov->size == count); 159 } 160 acb->aio_nbytes = count; 161 acb->aio_offset = offset; 162 163 trace_paio_submit(acb, opaque, offset, count, type); 164 pool = aio_get_thread_pool(bdrv_get_aio_context(bs)); 165 return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque); 166 } 167 168 int qemu_ftruncate64(int fd, int64_t length) 169 { 170 LARGE_INTEGER li; 171 DWORD dw; 172 LONG high; 173 HANDLE h; 174 BOOL res; 175 176 if ((GetVersion() & 0x80000000UL) && (length >> 32) != 0) 177 return -1; 178 179 h = (HANDLE)_get_osfhandle(fd); 180 181 /* get current position, ftruncate do not change position */ 182 li.HighPart = 0; 183 li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT); 184 if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) { 185 return -1; 186 } 187 188 high = length >> 32; 189 dw = SetFilePointer(h, (DWORD) length, &high, FILE_BEGIN); 190 if (dw == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) { 191 return -1; 192 } 193 res = SetEndOfFile(h); 194 195 /* back to old position */ 196 SetFilePointer(h, li.LowPart, &li.HighPart, FILE_BEGIN); 197 return res ? 0 : -1; 198 } 199 200 static int set_sparse(int fd) 201 { 202 DWORD returned; 203 return (int) DeviceIoControl((HANDLE)_get_osfhandle(fd), FSCTL_SET_SPARSE, 204 NULL, 0, NULL, 0, &returned, NULL); 205 } 206 207 static void raw_detach_aio_context(BlockDriverState *bs) 208 { 209 BDRVRawState *s = bs->opaque; 210 211 if (s->aio) { 212 win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs)); 213 } 214 } 215 216 static void raw_attach_aio_context(BlockDriverState *bs, 217 AioContext *new_context) 218 { 219 BDRVRawState *s = bs->opaque; 220 221 if (s->aio) { 222 win32_aio_attach_aio_context(s->aio, new_context); 223 } 224 } 225 226 static void raw_probe_alignment(BlockDriverState *bs, Error **errp) 227 { 228 BDRVRawState *s = bs->opaque; 229 DWORD sectorsPerCluster, freeClusters, totalClusters, count; 230 DISK_GEOMETRY_EX dg; 231 BOOL status; 232 233 if (s->type == FTYPE_CD) { 234 bs->bl.request_alignment = 2048; 235 return; 236 } 237 if (s->type == FTYPE_HARDDISK) { 238 status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, 239 NULL, 0, &dg, sizeof(dg), &count, NULL); 240 if (status != 0) { 241 bs->bl.request_alignment = dg.Geometry.BytesPerSector; 242 return; 243 } 244 /* try GetDiskFreeSpace too */ 245 } 246 247 if (s->drive_path[0]) { 248 GetDiskFreeSpace(s->drive_path, §orsPerCluster, 249 &dg.Geometry.BytesPerSector, 250 &freeClusters, &totalClusters); 251 bs->bl.request_alignment = dg.Geometry.BytesPerSector; 252 } 253 } 254 255 static void raw_parse_flags(int flags, bool use_aio, int *access_flags, 256 DWORD *overlapped) 257 { 258 assert(access_flags != NULL); 259 assert(overlapped != NULL); 260 261 if (flags & BDRV_O_RDWR) { 262 *access_flags = GENERIC_READ | GENERIC_WRITE; 263 } else { 264 *access_flags = GENERIC_READ; 265 } 266 267 *overlapped = FILE_ATTRIBUTE_NORMAL; 268 if (use_aio) { 269 *overlapped |= FILE_FLAG_OVERLAPPED; 270 } 271 if (flags & BDRV_O_NOCACHE) { 272 *overlapped |= FILE_FLAG_NO_BUFFERING; 273 } 274 } 275 276 static void raw_parse_filename(const char *filename, QDict *options, 277 Error **errp) 278 { 279 /* The filename does not have to be prefixed by the protocol name, since 280 * "file" is the default protocol; therefore, the return value of this 281 * function call can be ignored. */ 282 strstart(filename, "file:", &filename); 283 284 qdict_put_str(options, "filename", filename); 285 } 286 287 static QemuOptsList raw_runtime_opts = { 288 .name = "raw", 289 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head), 290 .desc = { 291 { 292 .name = "filename", 293 .type = QEMU_OPT_STRING, 294 .help = "File name of the image", 295 }, 296 { 297 .name = "aio", 298 .type = QEMU_OPT_STRING, 299 .help = "host AIO implementation (threads, native)", 300 }, 301 { /* end of list */ } 302 }, 303 }; 304 305 static bool get_aio_option(QemuOpts *opts, int flags, Error **errp) 306 { 307 BlockdevAioOptions aio, aio_default; 308 309 aio_default = (flags & BDRV_O_NATIVE_AIO) ? BLOCKDEV_AIO_OPTIONS_NATIVE 310 : BLOCKDEV_AIO_OPTIONS_THREADS; 311 aio = qapi_enum_parse(BlockdevAioOptions_lookup, qemu_opt_get(opts, "aio"), 312 BLOCKDEV_AIO_OPTIONS__MAX, aio_default, errp); 313 314 switch (aio) { 315 case BLOCKDEV_AIO_OPTIONS_NATIVE: 316 return true; 317 case BLOCKDEV_AIO_OPTIONS_THREADS: 318 return false; 319 default: 320 error_setg(errp, "Invalid AIO option"); 321 } 322 return false; 323 } 324 325 static int raw_open(BlockDriverState *bs, QDict *options, int flags, 326 Error **errp) 327 { 328 BDRVRawState *s = bs->opaque; 329 int access_flags; 330 DWORD overlapped; 331 QemuOpts *opts; 332 Error *local_err = NULL; 333 const char *filename; 334 bool use_aio; 335 int ret; 336 337 s->type = FTYPE_FILE; 338 339 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort); 340 qemu_opts_absorb_qdict(opts, options, &local_err); 341 if (local_err) { 342 error_propagate(errp, local_err); 343 ret = -EINVAL; 344 goto fail; 345 } 346 347 if (qdict_get_try_bool(options, "locking", false)) { 348 error_setg(errp, "locking=on is not supported on Windows"); 349 ret = -EINVAL; 350 goto fail; 351 } 352 353 filename = qemu_opt_get(opts, "filename"); 354 355 use_aio = get_aio_option(opts, flags, &local_err); 356 if (local_err) { 357 error_propagate(errp, local_err); 358 ret = -EINVAL; 359 goto fail; 360 } 361 362 raw_parse_flags(flags, use_aio, &access_flags, &overlapped); 363 364 if (filename[0] && filename[1] == ':') { 365 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", filename[0]); 366 } else if (filename[0] == '\\' && filename[1] == '\\') { 367 s->drive_path[0] = 0; 368 } else { 369 /* Relative path. */ 370 char buf[MAX_PATH]; 371 GetCurrentDirectory(MAX_PATH, buf); 372 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", buf[0]); 373 } 374 375 s->hfile = CreateFile(filename, access_flags, 376 FILE_SHARE_READ, NULL, 377 OPEN_EXISTING, overlapped, NULL); 378 if (s->hfile == INVALID_HANDLE_VALUE) { 379 int err = GetLastError(); 380 381 error_setg_win32(errp, err, "Could not open '%s'", filename); 382 if (err == ERROR_ACCESS_DENIED) { 383 ret = -EACCES; 384 } else { 385 ret = -EINVAL; 386 } 387 goto fail; 388 } 389 390 if (use_aio) { 391 s->aio = win32_aio_init(); 392 if (s->aio == NULL) { 393 CloseHandle(s->hfile); 394 error_setg(errp, "Could not initialize AIO"); 395 ret = -EINVAL; 396 goto fail; 397 } 398 399 ret = win32_aio_attach(s->aio, s->hfile); 400 if (ret < 0) { 401 win32_aio_cleanup(s->aio); 402 CloseHandle(s->hfile); 403 error_setg_errno(errp, -ret, "Could not enable AIO"); 404 goto fail; 405 } 406 407 win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs)); 408 } 409 410 ret = 0; 411 fail: 412 qemu_opts_del(opts); 413 return ret; 414 } 415 416 static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, 417 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 418 BlockCompletionFunc *cb, void *opaque) 419 { 420 BDRVRawState *s = bs->opaque; 421 if (s->aio) { 422 return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov, 423 nb_sectors, cb, opaque, QEMU_AIO_READ); 424 } else { 425 return paio_submit(bs, s->hfile, sector_num << BDRV_SECTOR_BITS, qiov, 426 nb_sectors << BDRV_SECTOR_BITS, 427 cb, opaque, QEMU_AIO_READ); 428 } 429 } 430 431 static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, 432 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 433 BlockCompletionFunc *cb, void *opaque) 434 { 435 BDRVRawState *s = bs->opaque; 436 if (s->aio) { 437 return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov, 438 nb_sectors, cb, opaque, QEMU_AIO_WRITE); 439 } else { 440 return paio_submit(bs, s->hfile, sector_num << BDRV_SECTOR_BITS, qiov, 441 nb_sectors << BDRV_SECTOR_BITS, 442 cb, opaque, QEMU_AIO_WRITE); 443 } 444 } 445 446 static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, 447 BlockCompletionFunc *cb, void *opaque) 448 { 449 BDRVRawState *s = bs->opaque; 450 return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH); 451 } 452 453 static void raw_close(BlockDriverState *bs) 454 { 455 BDRVRawState *s = bs->opaque; 456 457 if (s->aio) { 458 win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs)); 459 win32_aio_cleanup(s->aio); 460 s->aio = NULL; 461 } 462 463 CloseHandle(s->hfile); 464 if (bs->open_flags & BDRV_O_TEMPORARY) { 465 unlink(bs->filename); 466 } 467 } 468 469 static int raw_truncate(BlockDriverState *bs, int64_t offset, Error **errp) 470 { 471 BDRVRawState *s = bs->opaque; 472 LONG low, high; 473 DWORD dwPtrLow; 474 475 low = offset; 476 high = offset >> 32; 477 478 /* 479 * An error has occurred if the return value is INVALID_SET_FILE_POINTER 480 * and GetLastError doesn't return NO_ERROR. 481 */ 482 dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN); 483 if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) { 484 error_setg_win32(errp, GetLastError(), "SetFilePointer error"); 485 return -EIO; 486 } 487 if (SetEndOfFile(s->hfile) == 0) { 488 error_setg_win32(errp, GetLastError(), "SetEndOfFile error"); 489 return -EIO; 490 } 491 return 0; 492 } 493 494 static int64_t raw_getlength(BlockDriverState *bs) 495 { 496 BDRVRawState *s = bs->opaque; 497 LARGE_INTEGER l; 498 ULARGE_INTEGER available, total, total_free; 499 DISK_GEOMETRY_EX dg; 500 DWORD count; 501 BOOL status; 502 503 switch(s->type) { 504 case FTYPE_FILE: 505 l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart); 506 if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR) 507 return -EIO; 508 break; 509 case FTYPE_CD: 510 if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free)) 511 return -EIO; 512 l.QuadPart = total.QuadPart; 513 break; 514 case FTYPE_HARDDISK: 515 status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, 516 NULL, 0, &dg, sizeof(dg), &count, NULL); 517 if (status != 0) { 518 l = dg.DiskSize; 519 } 520 break; 521 default: 522 return -EIO; 523 } 524 return l.QuadPart; 525 } 526 527 static int64_t raw_get_allocated_file_size(BlockDriverState *bs) 528 { 529 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, 530 DWORD * high); 531 get_compressed_t get_compressed; 532 struct _stati64 st; 533 const char *filename = bs->filename; 534 /* WinNT support GetCompressedFileSize to determine allocate size */ 535 get_compressed = 536 (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), 537 "GetCompressedFileSizeA"); 538 if (get_compressed) { 539 DWORD high, low; 540 low = get_compressed(filename, &high); 541 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) { 542 return (((int64_t) high) << 32) + low; 543 } 544 } 545 546 if (_stati64(filename, &st) < 0) { 547 return -1; 548 } 549 return st.st_size; 550 } 551 552 static int raw_create(const char *filename, QemuOpts *opts, Error **errp) 553 { 554 int fd; 555 int64_t total_size = 0; 556 557 strstart(filename, "file:", &filename); 558 559 /* Read out options */ 560 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 561 BDRV_SECTOR_SIZE); 562 563 fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 564 0644); 565 if (fd < 0) { 566 error_setg_errno(errp, errno, "Could not create file"); 567 return -EIO; 568 } 569 set_sparse(fd); 570 ftruncate(fd, total_size); 571 qemu_close(fd); 572 return 0; 573 } 574 575 576 static QemuOptsList raw_create_opts = { 577 .name = "raw-create-opts", 578 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head), 579 .desc = { 580 { 581 .name = BLOCK_OPT_SIZE, 582 .type = QEMU_OPT_SIZE, 583 .help = "Virtual disk size" 584 }, 585 { /* end of list */ } 586 } 587 }; 588 589 BlockDriver bdrv_file = { 590 .format_name = "file", 591 .protocol_name = "file", 592 .instance_size = sizeof(BDRVRawState), 593 .bdrv_needs_filename = true, 594 .bdrv_parse_filename = raw_parse_filename, 595 .bdrv_file_open = raw_open, 596 .bdrv_refresh_limits = raw_probe_alignment, 597 .bdrv_close = raw_close, 598 .bdrv_create = raw_create, 599 .bdrv_has_zero_init = bdrv_has_zero_init_1, 600 601 .bdrv_aio_readv = raw_aio_readv, 602 .bdrv_aio_writev = raw_aio_writev, 603 .bdrv_aio_flush = raw_aio_flush, 604 605 .bdrv_truncate = raw_truncate, 606 .bdrv_getlength = raw_getlength, 607 .bdrv_get_allocated_file_size 608 = raw_get_allocated_file_size, 609 610 .create_opts = &raw_create_opts, 611 }; 612 613 /***********************************************/ 614 /* host device */ 615 616 static int find_cdrom(char *cdrom_name, int cdrom_name_size) 617 { 618 char drives[256], *pdrv = drives; 619 UINT type; 620 621 memset(drives, 0, sizeof(drives)); 622 GetLogicalDriveStrings(sizeof(drives), drives); 623 while(pdrv[0] != '\0') { 624 type = GetDriveType(pdrv); 625 switch(type) { 626 case DRIVE_CDROM: 627 snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]); 628 return 0; 629 break; 630 } 631 pdrv += lstrlen(pdrv) + 1; 632 } 633 return -1; 634 } 635 636 static int find_device_type(BlockDriverState *bs, const char *filename) 637 { 638 BDRVRawState *s = bs->opaque; 639 UINT type; 640 const char *p; 641 642 if (strstart(filename, "\\\\.\\", &p) || 643 strstart(filename, "//./", &p)) { 644 if (stristart(p, "PhysicalDrive", NULL)) 645 return FTYPE_HARDDISK; 646 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]); 647 type = GetDriveType(s->drive_path); 648 switch (type) { 649 case DRIVE_REMOVABLE: 650 case DRIVE_FIXED: 651 return FTYPE_HARDDISK; 652 case DRIVE_CDROM: 653 return FTYPE_CD; 654 default: 655 return FTYPE_FILE; 656 } 657 } else { 658 return FTYPE_FILE; 659 } 660 } 661 662 static int hdev_probe_device(const char *filename) 663 { 664 if (strstart(filename, "/dev/cdrom", NULL)) 665 return 100; 666 if (is_windows_drive(filename)) 667 return 100; 668 return 0; 669 } 670 671 static void hdev_parse_filename(const char *filename, QDict *options, 672 Error **errp) 673 { 674 /* The prefix is optional, just as for "file". */ 675 strstart(filename, "host_device:", &filename); 676 677 qdict_put_str(options, "filename", filename); 678 } 679 680 static int hdev_open(BlockDriverState *bs, QDict *options, int flags, 681 Error **errp) 682 { 683 BDRVRawState *s = bs->opaque; 684 int access_flags, create_flags; 685 int ret = 0; 686 DWORD overlapped; 687 char device_name[64]; 688 689 Error *local_err = NULL; 690 const char *filename; 691 bool use_aio; 692 693 QemuOpts *opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, 694 &error_abort); 695 qemu_opts_absorb_qdict(opts, options, &local_err); 696 if (local_err) { 697 error_propagate(errp, local_err); 698 ret = -EINVAL; 699 goto done; 700 } 701 702 filename = qemu_opt_get(opts, "filename"); 703 704 use_aio = get_aio_option(opts, flags, &local_err); 705 if (!local_err && use_aio) { 706 error_setg(&local_err, "AIO is not supported on Windows host devices"); 707 } 708 if (local_err) { 709 error_propagate(errp, local_err); 710 ret = -EINVAL; 711 goto done; 712 } 713 714 if (strstart(filename, "/dev/cdrom", NULL)) { 715 if (find_cdrom(device_name, sizeof(device_name)) < 0) { 716 error_setg(errp, "Could not open CD-ROM drive"); 717 ret = -ENOENT; 718 goto done; 719 } 720 filename = device_name; 721 } else { 722 /* transform drive letters into device name */ 723 if (((filename[0] >= 'a' && filename[0] <= 'z') || 724 (filename[0] >= 'A' && filename[0] <= 'Z')) && 725 filename[1] == ':' && filename[2] == '\0') { 726 snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]); 727 filename = device_name; 728 } 729 } 730 s->type = find_device_type(bs, filename); 731 732 raw_parse_flags(flags, use_aio, &access_flags, &overlapped); 733 734 create_flags = OPEN_EXISTING; 735 736 s->hfile = CreateFile(filename, access_flags, 737 FILE_SHARE_READ, NULL, 738 create_flags, overlapped, NULL); 739 if (s->hfile == INVALID_HANDLE_VALUE) { 740 int err = GetLastError(); 741 742 if (err == ERROR_ACCESS_DENIED) { 743 ret = -EACCES; 744 } else { 745 ret = -EINVAL; 746 } 747 error_setg_errno(errp, -ret, "Could not open device"); 748 goto done; 749 } 750 751 done: 752 qemu_opts_del(opts); 753 return ret; 754 } 755 756 static BlockDriver bdrv_host_device = { 757 .format_name = "host_device", 758 .protocol_name = "host_device", 759 .instance_size = sizeof(BDRVRawState), 760 .bdrv_needs_filename = true, 761 .bdrv_parse_filename = hdev_parse_filename, 762 .bdrv_probe_device = hdev_probe_device, 763 .bdrv_file_open = hdev_open, 764 .bdrv_close = raw_close, 765 766 .bdrv_aio_readv = raw_aio_readv, 767 .bdrv_aio_writev = raw_aio_writev, 768 .bdrv_aio_flush = raw_aio_flush, 769 770 .bdrv_detach_aio_context = raw_detach_aio_context, 771 .bdrv_attach_aio_context = raw_attach_aio_context, 772 773 .bdrv_getlength = raw_getlength, 774 .has_variable_length = true, 775 776 .bdrv_get_allocated_file_size 777 = raw_get_allocated_file_size, 778 }; 779 780 static void bdrv_file_init(void) 781 { 782 bdrv_register(&bdrv_file); 783 bdrv_register(&bdrv_host_device); 784 } 785 786 block_init(bdrv_file_init); 787