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 BdrvRequestFlags flags, 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(BlockDriver *drv, 592 const char *filename, 593 QemuOpts *opts, 594 Error **errp) 595 { 596 BlockdevCreateOptions options; 597 int64_t total_size = 0; 598 599 strstart(filename, "file:", &filename); 600 601 /* Read out options */ 602 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 603 BDRV_SECTOR_SIZE); 604 605 options = (BlockdevCreateOptions) { 606 .driver = BLOCKDEV_DRIVER_FILE, 607 .u.file = { 608 .filename = (char *) filename, 609 .size = total_size, 610 .has_preallocation = false, 611 .has_nocow = false, 612 }, 613 }; 614 return raw_co_create(&options, errp); 615 } 616 617 static QemuOptsList raw_create_opts = { 618 .name = "raw-create-opts", 619 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head), 620 .desc = { 621 { 622 .name = BLOCK_OPT_SIZE, 623 .type = QEMU_OPT_SIZE, 624 .help = "Virtual disk size" 625 }, 626 { /* end of list */ } 627 } 628 }; 629 630 BlockDriver bdrv_file = { 631 .format_name = "file", 632 .protocol_name = "file", 633 .instance_size = sizeof(BDRVRawState), 634 .bdrv_needs_filename = true, 635 .bdrv_parse_filename = raw_parse_filename, 636 .bdrv_file_open = raw_open, 637 .bdrv_refresh_limits = raw_probe_alignment, 638 .bdrv_close = raw_close, 639 .bdrv_co_create_opts = raw_co_create_opts, 640 .bdrv_has_zero_init = bdrv_has_zero_init_1, 641 .bdrv_has_zero_init_truncate = 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 qemu_opts_absorb_qdict(opts, options, &local_err); 741 if (local_err) { 742 error_propagate(errp, local_err); 743 ret = -EINVAL; 744 goto done; 745 } 746 747 filename = qemu_opt_get(opts, "filename"); 748 749 use_aio = get_aio_option(opts, flags, &local_err); 750 if (!local_err && use_aio) { 751 error_setg(&local_err, "AIO is not supported on Windows host devices"); 752 } 753 if (local_err) { 754 error_propagate(errp, local_err); 755 ret = -EINVAL; 756 goto done; 757 } 758 759 if (strstart(filename, "/dev/cdrom", NULL)) { 760 if (find_cdrom(device_name, sizeof(device_name)) < 0) { 761 error_setg(errp, "Could not open CD-ROM drive"); 762 ret = -ENOENT; 763 goto done; 764 } 765 filename = device_name; 766 } else { 767 /* transform drive letters into device name */ 768 if (((filename[0] >= 'a' && filename[0] <= 'z') || 769 (filename[0] >= 'A' && filename[0] <= 'Z')) && 770 filename[1] == ':' && filename[2] == '\0') { 771 snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]); 772 filename = device_name; 773 } 774 } 775 s->type = find_device_type(bs, filename); 776 777 raw_parse_flags(flags, use_aio, &access_flags, &overlapped); 778 779 create_flags = OPEN_EXISTING; 780 781 s->hfile = CreateFile(filename, access_flags, 782 FILE_SHARE_READ, NULL, 783 create_flags, overlapped, NULL); 784 if (s->hfile == INVALID_HANDLE_VALUE) { 785 int err = GetLastError(); 786 787 if (err == ERROR_ACCESS_DENIED) { 788 ret = -EACCES; 789 } else { 790 ret = -EINVAL; 791 } 792 error_setg_errno(errp, -ret, "Could not open device"); 793 goto done; 794 } 795 796 done: 797 qemu_opts_del(opts); 798 return ret; 799 } 800 801 static BlockDriver bdrv_host_device = { 802 .format_name = "host_device", 803 .protocol_name = "host_device", 804 .instance_size = sizeof(BDRVRawState), 805 .bdrv_needs_filename = true, 806 .bdrv_parse_filename = hdev_parse_filename, 807 .bdrv_probe_device = hdev_probe_device, 808 .bdrv_file_open = hdev_open, 809 .bdrv_close = raw_close, 810 .bdrv_refresh_limits = hdev_refresh_limits, 811 812 .bdrv_aio_preadv = raw_aio_preadv, 813 .bdrv_aio_pwritev = raw_aio_pwritev, 814 .bdrv_aio_flush = raw_aio_flush, 815 816 .bdrv_detach_aio_context = raw_detach_aio_context, 817 .bdrv_attach_aio_context = raw_attach_aio_context, 818 819 .bdrv_getlength = raw_getlength, 820 .has_variable_length = true, 821 822 .bdrv_get_allocated_file_size 823 = raw_get_allocated_file_size, 824 }; 825 826 static void bdrv_file_init(void) 827 { 828 bdrv_register(&bdrv_file); 829 bdrv_register(&bdrv_host_device); 830 } 831 832 block_init(bdrv_file_init); 833