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