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