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 if (!qemu_opts_absorb_qdict(opts, options, errp)) { 342 ret = -EINVAL; 343 goto fail; 344 } 345 346 if (qdict_get_try_bool(options, "locking", false)) { 347 error_setg(errp, "locking=on is not supported on Windows"); 348 ret = -EINVAL; 349 goto fail; 350 } 351 352 filename = qemu_opt_get(opts, "filename"); 353 354 use_aio = get_aio_option(opts, flags, &local_err); 355 if (local_err) { 356 error_propagate(errp, local_err); 357 ret = -EINVAL; 358 goto fail; 359 } 360 361 raw_parse_flags(flags, use_aio, &access_flags, &overlapped); 362 363 if (filename[0] && filename[1] == ':') { 364 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", filename[0]); 365 } else if (filename[0] == '\\' && filename[1] == '\\') { 366 s->drive_path[0] = 0; 367 } else { 368 /* Relative path. */ 369 char buf[MAX_PATH]; 370 GetCurrentDirectory(MAX_PATH, buf); 371 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", buf[0]); 372 } 373 374 s->hfile = CreateFile(filename, access_flags, 375 FILE_SHARE_READ, NULL, 376 OPEN_EXISTING, overlapped, NULL); 377 if (s->hfile == INVALID_HANDLE_VALUE) { 378 int err = GetLastError(); 379 380 error_setg_win32(errp, err, "Could not open '%s'", filename); 381 if (err == ERROR_ACCESS_DENIED) { 382 ret = -EACCES; 383 } else { 384 ret = -EINVAL; 385 } 386 goto fail; 387 } 388 389 if (use_aio) { 390 s->aio = win32_aio_init(); 391 if (s->aio == NULL) { 392 CloseHandle(s->hfile); 393 error_setg(errp, "Could not initialize AIO"); 394 ret = -EINVAL; 395 goto fail; 396 } 397 398 ret = win32_aio_attach(s->aio, s->hfile); 399 if (ret < 0) { 400 win32_aio_cleanup(s->aio); 401 CloseHandle(s->hfile); 402 error_setg_errno(errp, -ret, "Could not enable AIO"); 403 goto fail; 404 } 405 406 win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs)); 407 } 408 409 /* When extending regular files, we get zeros from the OS */ 410 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; 411 412 ret = 0; 413 fail: 414 qemu_opts_del(opts); 415 return ret; 416 } 417 418 static BlockAIOCB *raw_aio_preadv(BlockDriverState *bs, 419 uint64_t offset, uint64_t bytes, 420 QEMUIOVector *qiov, int flags, 421 BlockCompletionFunc *cb, void *opaque) 422 { 423 BDRVRawState *s = bs->opaque; 424 if (s->aio) { 425 return win32_aio_submit(bs, s->aio, s->hfile, offset, bytes, qiov, 426 cb, opaque, QEMU_AIO_READ); 427 } else { 428 return paio_submit(bs, s->hfile, offset, qiov, bytes, 429 cb, opaque, QEMU_AIO_READ); 430 } 431 } 432 433 static BlockAIOCB *raw_aio_pwritev(BlockDriverState *bs, 434 uint64_t offset, uint64_t bytes, 435 QEMUIOVector *qiov, int flags, 436 BlockCompletionFunc *cb, void *opaque) 437 { 438 BDRVRawState *s = bs->opaque; 439 if (s->aio) { 440 return win32_aio_submit(bs, s->aio, s->hfile, offset, bytes, qiov, 441 cb, opaque, QEMU_AIO_WRITE); 442 } else { 443 return paio_submit(bs, s->hfile, offset, qiov, bytes, 444 cb, opaque, QEMU_AIO_WRITE); 445 } 446 } 447 448 static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, 449 BlockCompletionFunc *cb, void *opaque) 450 { 451 BDRVRawState *s = bs->opaque; 452 return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH); 453 } 454 455 static void raw_close(BlockDriverState *bs) 456 { 457 BDRVRawState *s = bs->opaque; 458 459 if (s->aio) { 460 win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs)); 461 win32_aio_cleanup(s->aio); 462 s->aio = NULL; 463 } 464 465 CloseHandle(s->hfile); 466 if (bs->open_flags & BDRV_O_TEMPORARY) { 467 unlink(bs->filename); 468 } 469 } 470 471 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, 472 bool exact, PreallocMode prealloc, 473 BdrvRequestFlags flags, Error **errp) 474 { 475 BDRVRawState *s = bs->opaque; 476 LONG low, high; 477 DWORD dwPtrLow; 478 479 if (prealloc != PREALLOC_MODE_OFF) { 480 error_setg(errp, "Unsupported preallocation mode '%s'", 481 PreallocMode_str(prealloc)); 482 return -ENOTSUP; 483 } 484 485 low = offset; 486 high = offset >> 32; 487 488 /* 489 * An error has occurred if the return value is INVALID_SET_FILE_POINTER 490 * and GetLastError doesn't return NO_ERROR. 491 */ 492 dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN); 493 if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) { 494 error_setg_win32(errp, GetLastError(), "SetFilePointer error"); 495 return -EIO; 496 } 497 if (SetEndOfFile(s->hfile) == 0) { 498 error_setg_win32(errp, GetLastError(), "SetEndOfFile error"); 499 return -EIO; 500 } 501 return 0; 502 } 503 504 static int64_t raw_getlength(BlockDriverState *bs) 505 { 506 BDRVRawState *s = bs->opaque; 507 LARGE_INTEGER l; 508 ULARGE_INTEGER available, total, total_free; 509 DISK_GEOMETRY_EX dg; 510 DWORD count; 511 BOOL status; 512 513 switch(s->type) { 514 case FTYPE_FILE: 515 l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart); 516 if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR) 517 return -EIO; 518 break; 519 case FTYPE_CD: 520 if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free)) 521 return -EIO; 522 l.QuadPart = total.QuadPart; 523 break; 524 case FTYPE_HARDDISK: 525 status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, 526 NULL, 0, &dg, sizeof(dg), &count, NULL); 527 if (status != 0) { 528 l = dg.DiskSize; 529 } 530 break; 531 default: 532 return -EIO; 533 } 534 return l.QuadPart; 535 } 536 537 static int64_t raw_get_allocated_file_size(BlockDriverState *bs) 538 { 539 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, 540 DWORD * high); 541 get_compressed_t get_compressed; 542 struct _stati64 st; 543 const char *filename = bs->filename; 544 /* WinNT support GetCompressedFileSize to determine allocate size */ 545 get_compressed = 546 (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), 547 "GetCompressedFileSizeA"); 548 if (get_compressed) { 549 DWORD high, low; 550 low = get_compressed(filename, &high); 551 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) { 552 return (((int64_t) high) << 32) + low; 553 } 554 } 555 556 if (_stati64(filename, &st) < 0) { 557 return -1; 558 } 559 return st.st_size; 560 } 561 562 static int raw_co_create(BlockdevCreateOptions *options, Error **errp) 563 { 564 BlockdevCreateOptionsFile *file_opts; 565 int fd; 566 567 assert(options->driver == BLOCKDEV_DRIVER_FILE); 568 file_opts = &options->u.file; 569 570 if (file_opts->has_preallocation) { 571 error_setg(errp, "Preallocation is not supported on Windows"); 572 return -EINVAL; 573 } 574 if (file_opts->has_nocow) { 575 error_setg(errp, "nocow is not supported on Windows"); 576 return -EINVAL; 577 } 578 579 fd = qemu_open(file_opts->filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 580 0644); 581 if (fd < 0) { 582 error_setg_errno(errp, errno, "Could not create file"); 583 return -EIO; 584 } 585 set_sparse(fd); 586 ftruncate(fd, file_opts->size); 587 qemu_close(fd); 588 589 return 0; 590 } 591 592 static int coroutine_fn raw_co_create_opts(BlockDriver *drv, 593 const char *filename, 594 QemuOpts *opts, 595 Error **errp) 596 { 597 BlockdevCreateOptions options; 598 int64_t total_size = 0; 599 600 strstart(filename, "file:", &filename); 601 602 /* Read out options */ 603 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 604 BDRV_SECTOR_SIZE); 605 606 options = (BlockdevCreateOptions) { 607 .driver = BLOCKDEV_DRIVER_FILE, 608 .u.file = { 609 .filename = (char *) filename, 610 .size = total_size, 611 .has_preallocation = false, 612 .has_nocow = false, 613 }, 614 }; 615 return raw_co_create(&options, errp); 616 } 617 618 static QemuOptsList raw_create_opts = { 619 .name = "raw-create-opts", 620 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head), 621 .desc = { 622 { 623 .name = BLOCK_OPT_SIZE, 624 .type = QEMU_OPT_SIZE, 625 .help = "Virtual disk size" 626 }, 627 { /* end of list */ } 628 } 629 }; 630 631 BlockDriver bdrv_file = { 632 .format_name = "file", 633 .protocol_name = "file", 634 .instance_size = sizeof(BDRVRawState), 635 .bdrv_needs_filename = true, 636 .bdrv_parse_filename = raw_parse_filename, 637 .bdrv_file_open = raw_open, 638 .bdrv_refresh_limits = raw_probe_alignment, 639 .bdrv_close = raw_close, 640 .bdrv_co_create_opts = raw_co_create_opts, 641 .bdrv_has_zero_init = bdrv_has_zero_init_1, 642 643 .bdrv_aio_preadv = raw_aio_preadv, 644 .bdrv_aio_pwritev = raw_aio_pwritev, 645 .bdrv_aio_flush = raw_aio_flush, 646 647 .bdrv_co_truncate = raw_co_truncate, 648 .bdrv_getlength = raw_getlength, 649 .bdrv_get_allocated_file_size 650 = raw_get_allocated_file_size, 651 652 .create_opts = &raw_create_opts, 653 }; 654 655 /***********************************************/ 656 /* host device */ 657 658 static int find_cdrom(char *cdrom_name, int cdrom_name_size) 659 { 660 char drives[256], *pdrv = drives; 661 UINT type; 662 663 memset(drives, 0, sizeof(drives)); 664 GetLogicalDriveStrings(sizeof(drives), drives); 665 while(pdrv[0] != '\0') { 666 type = GetDriveType(pdrv); 667 switch(type) { 668 case DRIVE_CDROM: 669 snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]); 670 return 0; 671 break; 672 } 673 pdrv += lstrlen(pdrv) + 1; 674 } 675 return -1; 676 } 677 678 static int find_device_type(BlockDriverState *bs, const char *filename) 679 { 680 BDRVRawState *s = bs->opaque; 681 UINT type; 682 const char *p; 683 684 if (strstart(filename, "\\\\.\\", &p) || 685 strstart(filename, "//./", &p)) { 686 if (stristart(p, "PhysicalDrive", NULL)) 687 return FTYPE_HARDDISK; 688 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]); 689 type = GetDriveType(s->drive_path); 690 switch (type) { 691 case DRIVE_REMOVABLE: 692 case DRIVE_FIXED: 693 return FTYPE_HARDDISK; 694 case DRIVE_CDROM: 695 return FTYPE_CD; 696 default: 697 return FTYPE_FILE; 698 } 699 } else { 700 return FTYPE_FILE; 701 } 702 } 703 704 static int hdev_probe_device(const char *filename) 705 { 706 if (strstart(filename, "/dev/cdrom", NULL)) 707 return 100; 708 if (is_windows_drive(filename)) 709 return 100; 710 return 0; 711 } 712 713 static void hdev_parse_filename(const char *filename, QDict *options, 714 Error **errp) 715 { 716 bdrv_parse_filename_strip_prefix(filename, "host_device:", options); 717 } 718 719 static void hdev_refresh_limits(BlockDriverState *bs, Error **errp) 720 { 721 /* XXX Does Windows support AIO on less than 512-byte alignment? */ 722 bs->bl.request_alignment = 512; 723 } 724 725 static int hdev_open(BlockDriverState *bs, QDict *options, int flags, 726 Error **errp) 727 { 728 BDRVRawState *s = bs->opaque; 729 int access_flags, create_flags; 730 int ret = 0; 731 DWORD overlapped; 732 char device_name[64]; 733 734 Error *local_err = NULL; 735 const char *filename; 736 bool use_aio; 737 738 QemuOpts *opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, 739 &error_abort); 740 if (!qemu_opts_absorb_qdict(opts, options, errp)) { 741 ret = -EINVAL; 742 goto done; 743 } 744 745 filename = qemu_opt_get(opts, "filename"); 746 747 use_aio = get_aio_option(opts, flags, &local_err); 748 if (!local_err && use_aio) { 749 error_setg(&local_err, "AIO is not supported on Windows host devices"); 750 } 751 if (local_err) { 752 error_propagate(errp, local_err); 753 ret = -EINVAL; 754 goto done; 755 } 756 757 if (strstart(filename, "/dev/cdrom", NULL)) { 758 if (find_cdrom(device_name, sizeof(device_name)) < 0) { 759 error_setg(errp, "Could not open CD-ROM drive"); 760 ret = -ENOENT; 761 goto done; 762 } 763 filename = device_name; 764 } else { 765 /* transform drive letters into device name */ 766 if (((filename[0] >= 'a' && filename[0] <= 'z') || 767 (filename[0] >= 'A' && filename[0] <= 'Z')) && 768 filename[1] == ':' && filename[2] == '\0') { 769 snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]); 770 filename = device_name; 771 } 772 } 773 s->type = find_device_type(bs, filename); 774 775 raw_parse_flags(flags, use_aio, &access_flags, &overlapped); 776 777 create_flags = OPEN_EXISTING; 778 779 s->hfile = CreateFile(filename, access_flags, 780 FILE_SHARE_READ, NULL, 781 create_flags, overlapped, NULL); 782 if (s->hfile == INVALID_HANDLE_VALUE) { 783 int err = GetLastError(); 784 785 if (err == ERROR_ACCESS_DENIED) { 786 ret = -EACCES; 787 } else { 788 ret = -EINVAL; 789 } 790 error_setg_errno(errp, -ret, "Could not open device"); 791 goto done; 792 } 793 794 done: 795 qemu_opts_del(opts); 796 return ret; 797 } 798 799 static BlockDriver bdrv_host_device = { 800 .format_name = "host_device", 801 .protocol_name = "host_device", 802 .instance_size = sizeof(BDRVRawState), 803 .bdrv_needs_filename = true, 804 .bdrv_parse_filename = hdev_parse_filename, 805 .bdrv_probe_device = hdev_probe_device, 806 .bdrv_file_open = hdev_open, 807 .bdrv_close = raw_close, 808 .bdrv_refresh_limits = hdev_refresh_limits, 809 810 .bdrv_aio_preadv = raw_aio_preadv, 811 .bdrv_aio_pwritev = raw_aio_pwritev, 812 .bdrv_aio_flush = raw_aio_flush, 813 814 .bdrv_detach_aio_context = raw_detach_aio_context, 815 .bdrv_attach_aio_context = raw_attach_aio_context, 816 817 .bdrv_getlength = raw_getlength, 818 .has_variable_length = true, 819 820 .bdrv_get_allocated_file_size 821 = raw_get_allocated_file_size, 822 }; 823 824 static void bdrv_file_init(void) 825 { 826 bdrv_register(&bdrv_file); 827 bdrv_register(&bdrv_host_device); 828 } 829 830 block_init(bdrv_file_init); 831