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 ret = 0; 412 fail: 413 qemu_opts_del(opts); 414 return ret; 415 } 416 417 static BlockAIOCB *raw_aio_preadv(BlockDriverState *bs, 418 uint64_t offset, uint64_t bytes, 419 QEMUIOVector *qiov, int flags, 420 BlockCompletionFunc *cb, void *opaque) 421 { 422 BDRVRawState *s = bs->opaque; 423 if (s->aio) { 424 return win32_aio_submit(bs, s->aio, s->hfile, offset, bytes, qiov, 425 cb, opaque, QEMU_AIO_READ); 426 } else { 427 return paio_submit(bs, s->hfile, offset, qiov, bytes, 428 cb, opaque, QEMU_AIO_READ); 429 } 430 } 431 432 static BlockAIOCB *raw_aio_pwritev(BlockDriverState *bs, 433 uint64_t offset, uint64_t bytes, 434 QEMUIOVector *qiov, int flags, 435 BlockCompletionFunc *cb, void *opaque) 436 { 437 BDRVRawState *s = bs->opaque; 438 if (s->aio) { 439 return win32_aio_submit(bs, s->aio, s->hfile, offset, bytes, qiov, 440 cb, opaque, QEMU_AIO_WRITE); 441 } else { 442 return paio_submit(bs, s->hfile, offset, qiov, bytes, 443 cb, opaque, QEMU_AIO_WRITE); 444 } 445 } 446 447 static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, 448 BlockCompletionFunc *cb, void *opaque) 449 { 450 BDRVRawState *s = bs->opaque; 451 return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH); 452 } 453 454 static void raw_close(BlockDriverState *bs) 455 { 456 BDRVRawState *s = bs->opaque; 457 458 if (s->aio) { 459 win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs)); 460 win32_aio_cleanup(s->aio); 461 s->aio = NULL; 462 } 463 464 CloseHandle(s->hfile); 465 if (bs->open_flags & BDRV_O_TEMPORARY) { 466 unlink(bs->filename); 467 } 468 } 469 470 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, 471 bool exact, PreallocMode prealloc, 472 Error **errp) 473 { 474 BDRVRawState *s = bs->opaque; 475 LONG low, high; 476 DWORD dwPtrLow; 477 478 if (prealloc != PREALLOC_MODE_OFF) { 479 error_setg(errp, "Unsupported preallocation mode '%s'", 480 PreallocMode_str(prealloc)); 481 return -ENOTSUP; 482 } 483 484 low = offset; 485 high = offset >> 32; 486 487 /* 488 * An error has occurred if the return value is INVALID_SET_FILE_POINTER 489 * and GetLastError doesn't return NO_ERROR. 490 */ 491 dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN); 492 if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) { 493 error_setg_win32(errp, GetLastError(), "SetFilePointer error"); 494 return -EIO; 495 } 496 if (SetEndOfFile(s->hfile) == 0) { 497 error_setg_win32(errp, GetLastError(), "SetEndOfFile error"); 498 return -EIO; 499 } 500 return 0; 501 } 502 503 static int64_t raw_getlength(BlockDriverState *bs) 504 { 505 BDRVRawState *s = bs->opaque; 506 LARGE_INTEGER l; 507 ULARGE_INTEGER available, total, total_free; 508 DISK_GEOMETRY_EX dg; 509 DWORD count; 510 BOOL status; 511 512 switch(s->type) { 513 case FTYPE_FILE: 514 l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart); 515 if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR) 516 return -EIO; 517 break; 518 case FTYPE_CD: 519 if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free)) 520 return -EIO; 521 l.QuadPart = total.QuadPart; 522 break; 523 case FTYPE_HARDDISK: 524 status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, 525 NULL, 0, &dg, sizeof(dg), &count, NULL); 526 if (status != 0) { 527 l = dg.DiskSize; 528 } 529 break; 530 default: 531 return -EIO; 532 } 533 return l.QuadPart; 534 } 535 536 static int64_t raw_get_allocated_file_size(BlockDriverState *bs) 537 { 538 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, 539 DWORD * high); 540 get_compressed_t get_compressed; 541 struct _stati64 st; 542 const char *filename = bs->filename; 543 /* WinNT support GetCompressedFileSize to determine allocate size */ 544 get_compressed = 545 (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), 546 "GetCompressedFileSizeA"); 547 if (get_compressed) { 548 DWORD high, low; 549 low = get_compressed(filename, &high); 550 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) { 551 return (((int64_t) high) << 32) + low; 552 } 553 } 554 555 if (_stati64(filename, &st) < 0) { 556 return -1; 557 } 558 return st.st_size; 559 } 560 561 static int raw_co_create(BlockdevCreateOptions *options, Error **errp) 562 { 563 BlockdevCreateOptionsFile *file_opts; 564 int fd; 565 566 assert(options->driver == BLOCKDEV_DRIVER_FILE); 567 file_opts = &options->u.file; 568 569 if (file_opts->has_preallocation) { 570 error_setg(errp, "Preallocation is not supported on Windows"); 571 return -EINVAL; 572 } 573 if (file_opts->has_nocow) { 574 error_setg(errp, "nocow is not supported on Windows"); 575 return -EINVAL; 576 } 577 578 fd = qemu_open(file_opts->filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 579 0644); 580 if (fd < 0) { 581 error_setg_errno(errp, errno, "Could not create file"); 582 return -EIO; 583 } 584 set_sparse(fd); 585 ftruncate(fd, file_opts->size); 586 qemu_close(fd); 587 588 return 0; 589 } 590 591 static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts, 592 Error **errp) 593 { 594 BlockdevCreateOptions options; 595 int64_t total_size = 0; 596 597 strstart(filename, "file:", &filename); 598 599 /* Read out options */ 600 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 601 BDRV_SECTOR_SIZE); 602 603 options = (BlockdevCreateOptions) { 604 .driver = BLOCKDEV_DRIVER_FILE, 605 .u.file = { 606 .filename = (char *) filename, 607 .size = total_size, 608 .has_preallocation = false, 609 .has_nocow = false, 610 }, 611 }; 612 return raw_co_create(&options, errp); 613 } 614 615 static QemuOptsList raw_create_opts = { 616 .name = "raw-create-opts", 617 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head), 618 .desc = { 619 { 620 .name = BLOCK_OPT_SIZE, 621 .type = QEMU_OPT_SIZE, 622 .help = "Virtual disk size" 623 }, 624 { /* end of list */ } 625 } 626 }; 627 628 BlockDriver bdrv_file = { 629 .format_name = "file", 630 .protocol_name = "file", 631 .instance_size = sizeof(BDRVRawState), 632 .bdrv_needs_filename = true, 633 .bdrv_parse_filename = raw_parse_filename, 634 .bdrv_file_open = raw_open, 635 .bdrv_refresh_limits = raw_probe_alignment, 636 .bdrv_close = raw_close, 637 .bdrv_co_create_opts = raw_co_create_opts, 638 .bdrv_has_zero_init = bdrv_has_zero_init_1, 639 .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1, 640 641 .bdrv_aio_preadv = raw_aio_preadv, 642 .bdrv_aio_pwritev = raw_aio_pwritev, 643 .bdrv_aio_flush = raw_aio_flush, 644 645 .bdrv_co_truncate = raw_co_truncate, 646 .bdrv_getlength = raw_getlength, 647 .bdrv_get_allocated_file_size 648 = raw_get_allocated_file_size, 649 650 .create_opts = &raw_create_opts, 651 }; 652 653 /***********************************************/ 654 /* host device */ 655 656 static int find_cdrom(char *cdrom_name, int cdrom_name_size) 657 { 658 char drives[256], *pdrv = drives; 659 UINT type; 660 661 memset(drives, 0, sizeof(drives)); 662 GetLogicalDriveStrings(sizeof(drives), drives); 663 while(pdrv[0] != '\0') { 664 type = GetDriveType(pdrv); 665 switch(type) { 666 case DRIVE_CDROM: 667 snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]); 668 return 0; 669 break; 670 } 671 pdrv += lstrlen(pdrv) + 1; 672 } 673 return -1; 674 } 675 676 static int find_device_type(BlockDriverState *bs, const char *filename) 677 { 678 BDRVRawState *s = bs->opaque; 679 UINT type; 680 const char *p; 681 682 if (strstart(filename, "\\\\.\\", &p) || 683 strstart(filename, "//./", &p)) { 684 if (stristart(p, "PhysicalDrive", NULL)) 685 return FTYPE_HARDDISK; 686 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]); 687 type = GetDriveType(s->drive_path); 688 switch (type) { 689 case DRIVE_REMOVABLE: 690 case DRIVE_FIXED: 691 return FTYPE_HARDDISK; 692 case DRIVE_CDROM: 693 return FTYPE_CD; 694 default: 695 return FTYPE_FILE; 696 } 697 } else { 698 return FTYPE_FILE; 699 } 700 } 701 702 static int hdev_probe_device(const char *filename) 703 { 704 if (strstart(filename, "/dev/cdrom", NULL)) 705 return 100; 706 if (is_windows_drive(filename)) 707 return 100; 708 return 0; 709 } 710 711 static void hdev_parse_filename(const char *filename, QDict *options, 712 Error **errp) 713 { 714 bdrv_parse_filename_strip_prefix(filename, "host_device:", options); 715 } 716 717 static void hdev_refresh_limits(BlockDriverState *bs, Error **errp) 718 { 719 /* XXX Does Windows support AIO on less than 512-byte alignment? */ 720 bs->bl.request_alignment = 512; 721 } 722 723 static int hdev_open(BlockDriverState *bs, QDict *options, int flags, 724 Error **errp) 725 { 726 BDRVRawState *s = bs->opaque; 727 int access_flags, create_flags; 728 int ret = 0; 729 DWORD overlapped; 730 char device_name[64]; 731 732 Error *local_err = NULL; 733 const char *filename; 734 bool use_aio; 735 736 QemuOpts *opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, 737 &error_abort); 738 qemu_opts_absorb_qdict(opts, options, &local_err); 739 if (local_err) { 740 error_propagate(errp, local_err); 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