2 * Block driver for RAW files (win32)
4 * Copyright (c) 2006 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
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"
33 #include "block/thread-pool.h"
35 #include "qapi/qmp/qdict.h"
36 #include "qapi/qmp/qstring.h"
42 #define FTYPE_HARDDISK 2
44 typedef struct RawWin32AIOData
{
47 struct iovec
*aio_iov
;
54 typedef struct BDRVRawState
{
57 char drive_path
[16]; /* format: "d:\" */
58 QEMUWin32AIOState
*aio
;
62 * Read/writes the data to/from a given linear buffer.
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.
67 static size_t handle_aiocb_rw(RawWin32AIOData
*aiocb
)
72 for (i
= 0; i
< aiocb
->aio_niov
; i
++) {
74 DWORD ret
, ret_count
, len
;
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
);
84 ret
= ReadFile(aiocb
->hfile
, aiocb
->aio_iov
[i
].iov_base
,
85 len
, &ret_count
, &ov
);
90 if (ret_count
!= len
) {
100 static int aio_worker(void *arg
)
102 RawWin32AIOData
*aiocb
= arg
;
106 switch (aiocb
->aio_type
& QEMU_AIO_TYPE_MASK
) {
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
);
115 count
= aiocb
->aio_nbytes
;
117 if (count
== aiocb
->aio_nbytes
) {
124 count
= handle_aiocb_rw(aiocb
);
125 if (count
== aiocb
->aio_nbytes
) {
132 if (!FlushFileBuffers(aiocb
->hfile
)) {
137 fprintf(stderr
, "invalid aio request (0x%x)\n", aiocb
->aio_type
);
146 static BlockAIOCB
*paio_submit(BlockDriverState
*bs
, HANDLE hfile
,
147 int64_t offset
, QEMUIOVector
*qiov
, int count
,
148 BlockCompletionFunc
*cb
, void *opaque
, int type
)
150 RawWin32AIOData
*acb
= g_new(RawWin32AIOData
, 1);
155 acb
->aio_type
= type
;
158 acb
->aio_iov
= qiov
->iov
;
159 acb
->aio_niov
= qiov
->niov
;
160 assert(qiov
->size
== count
);
162 acb
->aio_nbytes
= count
;
163 acb
->aio_offset
= offset
;
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
);
170 int qemu_ftruncate64(int fd
, int64_t length
)
178 if ((GetVersion() & 0x80000000UL
) && (length
>> 32) != 0)
181 h
= (HANDLE
)_get_osfhandle(fd
);
183 /* get current position, ftruncate do not change position */
185 li
.LowPart
= SetFilePointer (h
, 0, &li
.HighPart
, FILE_CURRENT
);
186 if (li
.LowPart
== INVALID_SET_FILE_POINTER
&& GetLastError() != NO_ERROR
) {
191 dw
= SetFilePointer(h
, (DWORD
) length
, &high
, FILE_BEGIN
);
192 if (dw
== INVALID_SET_FILE_POINTER
&& GetLastError() != NO_ERROR
) {
195 res
= SetEndOfFile(h
);
197 /* back to old position */
198 SetFilePointer(h
, li
.LowPart
, &li
.HighPart
, FILE_BEGIN
);
202 static int set_sparse(int fd
)
205 return (int) DeviceIoControl((HANDLE
)_get_osfhandle(fd
), FSCTL_SET_SPARSE
,
206 NULL
, 0, NULL
, 0, &returned
, NULL
);
209 static void raw_detach_aio_context(BlockDriverState
*bs
)
211 BDRVRawState
*s
= bs
->opaque
;
214 win32_aio_detach_aio_context(s
->aio
, bdrv_get_aio_context(bs
));
218 static void raw_attach_aio_context(BlockDriverState
*bs
,
219 AioContext
*new_context
)
221 BDRVRawState
*s
= bs
->opaque
;
224 win32_aio_attach_aio_context(s
->aio
, new_context
);
228 static void raw_probe_alignment(BlockDriverState
*bs
, Error
**errp
)
230 BDRVRawState
*s
= bs
->opaque
;
231 DWORD sectorsPerCluster
, freeClusters
, totalClusters
, count
;
235 if (s
->type
== FTYPE_CD
) {
236 bs
->bl
.request_alignment
= 2048;
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
);
243 bs
->bl
.request_alignment
= dg
.Geometry
.BytesPerSector
;
246 /* try GetDiskFreeSpace too */
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
;
257 /* XXX Does Windows support AIO on less than 512-byte alignment? */
258 bs
->bl
.request_alignment
= 512;
261 static void raw_parse_flags(int flags
, bool use_aio
, int *access_flags
,
264 assert(access_flags
!= NULL
);
265 assert(overlapped
!= NULL
);
267 if (flags
& BDRV_O_RDWR
) {
268 *access_flags
= GENERIC_READ
| GENERIC_WRITE
;
270 *access_flags
= GENERIC_READ
;
273 *overlapped
= FILE_ATTRIBUTE_NORMAL
;
275 *overlapped
|= FILE_FLAG_OVERLAPPED
;
277 if (flags
& BDRV_O_NOCACHE
) {
278 *overlapped
|= FILE_FLAG_NO_BUFFERING
;
282 static void raw_parse_filename(const char *filename
, QDict
*options
,
285 bdrv_parse_filename_strip_prefix(filename
, "file:", options
);
288 static QemuOptsList raw_runtime_opts
= {
290 .head
= QTAILQ_HEAD_INITIALIZER(raw_runtime_opts
.head
),
294 .type
= QEMU_OPT_STRING
,
295 .help
= "File name of the image",
299 .type
= QEMU_OPT_STRING
,
300 .help
= "host AIO implementation (threads, native)",
302 { /* end of list */ }
306 static bool get_aio_option(QemuOpts
*opts
, int flags
, Error
**errp
)
308 BlockdevAioOptions aio
, aio_default
;
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"),
316 case BLOCKDEV_AIO_OPTIONS_NATIVE
:
318 case BLOCKDEV_AIO_OPTIONS_THREADS
:
321 error_setg(errp
, "Invalid AIO option");
326 static int raw_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
329 BDRVRawState
*s
= bs
->opaque
;
333 Error
*local_err
= NULL
;
334 const char *filename
;
338 s
->type
= FTYPE_FILE
;
340 opts
= qemu_opts_create(&raw_runtime_opts
, NULL
, 0, &error_abort
);
341 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
343 error_propagate(errp
, local_err
);
348 if (qdict_get_try_bool(options
, "locking", false)) {
349 error_setg(errp
, "locking=on is not supported on Windows");
354 filename
= qemu_opt_get(opts
, "filename");
356 use_aio
= get_aio_option(opts
, flags
, &local_err
);
358 error_propagate(errp
, local_err
);
363 raw_parse_flags(flags
, use_aio
, &access_flags
, &overlapped
);
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;
372 GetCurrentDirectory(MAX_PATH
, buf
);
373 snprintf(s
->drive_path
, sizeof(s
->drive_path
), "%c:\\", buf
[0]);
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();
382 error_setg_win32(errp
, err
, "Could not open '%s'", filename
);
383 if (err
== ERROR_ACCESS_DENIED
) {
392 s
->aio
= win32_aio_init();
393 if (s
->aio
== NULL
) {
394 CloseHandle(s
->hfile
);
395 error_setg(errp
, "Could not initialize AIO");
400 ret
= win32_aio_attach(s
->aio
, s
->hfile
);
402 win32_aio_cleanup(s
->aio
);
403 CloseHandle(s
->hfile
);
404 error_setg_errno(errp
, -ret
, "Could not enable AIO");
408 win32_aio_attach_aio_context(s
->aio
, bdrv_get_aio_context(bs
));
411 /* When extending regular files, we get zeros from the OS */
412 bs
->supported_truncate_flags
= BDRV_REQ_ZERO_WRITE
;
420 static BlockAIOCB
*raw_aio_preadv(BlockDriverState
*bs
,
421 uint64_t offset
, uint64_t bytes
,
422 QEMUIOVector
*qiov
, int flags
,
423 BlockCompletionFunc
*cb
, void *opaque
)
425 BDRVRawState
*s
= bs
->opaque
;
427 return win32_aio_submit(bs
, s
->aio
, s
->hfile
, offset
, bytes
, qiov
,
428 cb
, opaque
, QEMU_AIO_READ
);
430 return paio_submit(bs
, s
->hfile
, offset
, qiov
, bytes
,
431 cb
, opaque
, QEMU_AIO_READ
);
435 static BlockAIOCB
*raw_aio_pwritev(BlockDriverState
*bs
,
436 uint64_t offset
, uint64_t bytes
,
437 QEMUIOVector
*qiov
, int flags
,
438 BlockCompletionFunc
*cb
, void *opaque
)
440 BDRVRawState
*s
= bs
->opaque
;
442 return win32_aio_submit(bs
, s
->aio
, s
->hfile
, offset
, bytes
, qiov
,
443 cb
, opaque
, QEMU_AIO_WRITE
);
445 return paio_submit(bs
, s
->hfile
, offset
, qiov
, bytes
,
446 cb
, opaque
, QEMU_AIO_WRITE
);
450 static BlockAIOCB
*raw_aio_flush(BlockDriverState
*bs
,
451 BlockCompletionFunc
*cb
, void *opaque
)
453 BDRVRawState
*s
= bs
->opaque
;
454 return paio_submit(bs
, s
->hfile
, 0, NULL
, 0, cb
, opaque
, QEMU_AIO_FLUSH
);
457 static void raw_close(BlockDriverState
*bs
)
459 BDRVRawState
*s
= bs
->opaque
;
462 win32_aio_detach_aio_context(s
->aio
, bdrv_get_aio_context(bs
));
463 win32_aio_cleanup(s
->aio
);
467 CloseHandle(s
->hfile
);
468 if (bs
->open_flags
& BDRV_O_TEMPORARY
) {
469 unlink(bs
->filename
);
473 static int coroutine_fn
raw_co_truncate(BlockDriverState
*bs
, int64_t offset
,
474 bool exact
, PreallocMode prealloc
,
475 BdrvRequestFlags flags
, Error
**errp
)
477 BDRVRawState
*s
= bs
->opaque
;
481 if (prealloc
!= PREALLOC_MODE_OFF
) {
482 error_setg(errp
, "Unsupported preallocation mode '%s'",
483 PreallocMode_str(prealloc
));
491 * An error has occurred if the return value is INVALID_SET_FILE_POINTER
492 * and GetLastError doesn't return NO_ERROR.
494 dwPtrLow
= SetFilePointer(s
->hfile
, low
, &high
, FILE_BEGIN
);
495 if (dwPtrLow
== INVALID_SET_FILE_POINTER
&& GetLastError() != NO_ERROR
) {
496 error_setg_win32(errp
, GetLastError(), "SetFilePointer error");
499 if (SetEndOfFile(s
->hfile
) == 0) {
500 error_setg_win32(errp
, GetLastError(), "SetEndOfFile error");
506 static int64_t raw_getlength(BlockDriverState
*bs
)
508 BDRVRawState
*s
= bs
->opaque
;
510 ULARGE_INTEGER available
, total
, total_free
;
517 l
.LowPart
= GetFileSize(s
->hfile
, (PDWORD
)&l
.HighPart
);
518 if (l
.LowPart
== 0xffffffffUL
&& GetLastError() != NO_ERROR
)
522 if (!GetDiskFreeSpaceEx(s
->drive_path
, &available
, &total
, &total_free
))
524 l
.QuadPart
= total
.QuadPart
;
527 status
= DeviceIoControl(s
->hfile
, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX
,
528 NULL
, 0, &dg
, sizeof(dg
), &count
, NULL
);
539 static int64_t raw_get_allocated_file_size(BlockDriverState
*bs
)
541 typedef DWORD (WINAPI
* get_compressed_t
)(const char *filename
,
543 get_compressed_t get_compressed
;
545 const char *filename
= bs
->filename
;
546 /* WinNT support GetCompressedFileSize to determine allocate size */
548 (get_compressed_t
) GetProcAddress(GetModuleHandle("kernel32"),
549 "GetCompressedFileSizeA");
550 if (get_compressed
) {
552 low
= get_compressed(filename
, &high
);
553 if (low
!= 0xFFFFFFFFlu
|| GetLastError() == NO_ERROR
) {
554 return (((int64_t) high
) << 32) + low
;
558 if (_stati64(filename
, &st
) < 0) {
564 static int raw_co_create(BlockdevCreateOptions
*options
, Error
**errp
)
566 BlockdevCreateOptionsFile
*file_opts
;
569 assert(options
->driver
== BLOCKDEV_DRIVER_FILE
);
570 file_opts
= &options
->u
.file
;
572 if (file_opts
->has_preallocation
) {
573 error_setg(errp
, "Preallocation is not supported on Windows");
576 if (file_opts
->has_nocow
) {
577 error_setg(errp
, "nocow is not supported on Windows");
581 fd
= qemu_open(file_opts
->filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
,
584 error_setg_errno(errp
, errno
, "Could not create file");
588 ftruncate(fd
, file_opts
->size
);
594 static int coroutine_fn
raw_co_create_opts(BlockDriver
*drv
,
595 const char *filename
,
599 BlockdevCreateOptions options
;
600 int64_t total_size
= 0;
602 strstart(filename
, "file:", &filename
);
604 /* Read out options */
605 total_size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
608 options
= (BlockdevCreateOptions
) {
609 .driver
= BLOCKDEV_DRIVER_FILE
,
611 .filename
= (char *) filename
,
613 .has_preallocation
= false,
617 return raw_co_create(&options
, errp
);
620 static QemuOptsList raw_create_opts
= {
621 .name
= "raw-create-opts",
622 .head
= QTAILQ_HEAD_INITIALIZER(raw_create_opts
.head
),
625 .name
= BLOCK_OPT_SIZE
,
626 .type
= QEMU_OPT_SIZE
,
627 .help
= "Virtual disk size"
629 { /* end of list */ }
633 BlockDriver bdrv_file
= {
634 .format_name
= "file",
635 .protocol_name
= "file",
636 .instance_size
= sizeof(BDRVRawState
),
637 .bdrv_needs_filename
= true,
638 .bdrv_parse_filename
= raw_parse_filename
,
639 .bdrv_file_open
= raw_open
,
640 .bdrv_refresh_limits
= raw_probe_alignment
,
641 .bdrv_close
= raw_close
,
642 .bdrv_co_create_opts
= raw_co_create_opts
,
643 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
645 .bdrv_aio_preadv
= raw_aio_preadv
,
646 .bdrv_aio_pwritev
= raw_aio_pwritev
,
647 .bdrv_aio_flush
= raw_aio_flush
,
649 .bdrv_co_truncate
= raw_co_truncate
,
650 .bdrv_getlength
= raw_getlength
,
651 .bdrv_get_allocated_file_size
652 = raw_get_allocated_file_size
,
654 .create_opts
= &raw_create_opts
,
657 /***********************************************/
660 static int find_cdrom(char *cdrom_name
, int cdrom_name_size
)
662 char drives
[256], *pdrv
= drives
;
665 memset(drives
, 0, sizeof(drives
));
666 GetLogicalDriveStrings(sizeof(drives
), drives
);
667 while(pdrv
[0] != '\0') {
668 type
= GetDriveType(pdrv
);
671 snprintf(cdrom_name
, cdrom_name_size
, "\\\\.\\%c:", pdrv
[0]);
675 pdrv
+= lstrlen(pdrv
) + 1;
680 static int find_device_type(BlockDriverState
*bs
, const char *filename
)
682 BDRVRawState
*s
= bs
->opaque
;
686 if (strstart(filename
, "\\\\.\\", &p
) ||
687 strstart(filename
, "//./", &p
)) {
688 if (stristart(p
, "PhysicalDrive", NULL
))
689 return FTYPE_HARDDISK
;
690 snprintf(s
->drive_path
, sizeof(s
->drive_path
), "%c:\\", p
[0]);
691 type
= GetDriveType(s
->drive_path
);
693 case DRIVE_REMOVABLE
:
695 return FTYPE_HARDDISK
;
706 static int hdev_probe_device(const char *filename
)
708 if (strstart(filename
, "/dev/cdrom", NULL
))
710 if (is_windows_drive(filename
))
715 static void hdev_parse_filename(const char *filename
, QDict
*options
,
718 bdrv_parse_filename_strip_prefix(filename
, "host_device:", options
);
721 static void hdev_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
723 /* XXX Does Windows support AIO on less than 512-byte alignment? */
724 bs
->bl
.request_alignment
= 512;
727 static int hdev_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
730 BDRVRawState
*s
= bs
->opaque
;
731 int access_flags
, create_flags
;
734 char device_name
[64];
736 Error
*local_err
= NULL
;
737 const char *filename
;
740 QemuOpts
*opts
= qemu_opts_create(&raw_runtime_opts
, NULL
, 0,
742 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
744 error_propagate(errp
, local_err
);
749 filename
= qemu_opt_get(opts
, "filename");
751 use_aio
= get_aio_option(opts
, flags
, &local_err
);
752 if (!local_err
&& use_aio
) {
753 error_setg(&local_err
, "AIO is not supported on Windows host devices");
756 error_propagate(errp
, local_err
);
761 if (strstart(filename
, "/dev/cdrom", NULL
)) {
762 if (find_cdrom(device_name
, sizeof(device_name
)) < 0) {
763 error_setg(errp
, "Could not open CD-ROM drive");
767 filename
= device_name
;
769 /* transform drive letters into device name */
770 if (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
771 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
772 filename
[1] == ':' && filename
[2] == '\0') {
773 snprintf(device_name
, sizeof(device_name
), "\\\\.\\%c:", filename
[0]);
774 filename
= device_name
;
777 s
->type
= find_device_type(bs
, filename
);
779 raw_parse_flags(flags
, use_aio
, &access_flags
, &overlapped
);
781 create_flags
= OPEN_EXISTING
;
783 s
->hfile
= CreateFile(filename
, access_flags
,
784 FILE_SHARE_READ
, NULL
,
785 create_flags
, overlapped
, NULL
);
786 if (s
->hfile
== INVALID_HANDLE_VALUE
) {
787 int err
= GetLastError();
789 if (err
== ERROR_ACCESS_DENIED
) {
794 error_setg_errno(errp
, -ret
, "Could not open device");
803 static BlockDriver bdrv_host_device
= {
804 .format_name
= "host_device",
805 .protocol_name
= "host_device",
806 .instance_size
= sizeof(BDRVRawState
),
807 .bdrv_needs_filename
= true,
808 .bdrv_parse_filename
= hdev_parse_filename
,
809 .bdrv_probe_device
= hdev_probe_device
,
810 .bdrv_file_open
= hdev_open
,
811 .bdrv_close
= raw_close
,
812 .bdrv_refresh_limits
= hdev_refresh_limits
,
814 .bdrv_aio_preadv
= raw_aio_preadv
,
815 .bdrv_aio_pwritev
= raw_aio_pwritev
,
816 .bdrv_aio_flush
= raw_aio_flush
,
818 .bdrv_detach_aio_context
= raw_detach_aio_context
,
819 .bdrv_attach_aio_context
= raw_attach_aio_context
,
821 .bdrv_getlength
= raw_getlength
,
822 .has_variable_length
= true,
824 .bdrv_get_allocated_file_size
825 = raw_get_allocated_file_size
,
828 static void bdrv_file_init(void)
830 bdrv_register(&bdrv_file
);
831 bdrv_register(&bdrv_host_device
);
834 block_init(bdrv_file_init
);