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
24 #include "qemu-common.h"
25 #include "qemu-timer.h"
26 #include "block_int.h"
33 #define FTYPE_HARDDISK 2
35 typedef struct BDRVRawState
{
38 char drive_path
[16]; /* format: "d:\" */
41 int qemu_ftruncate64(int fd
, int64_t length
)
48 if ((GetVersion() & 0x80000000UL
) && (length
>> 32) != 0)
51 h
= (HANDLE
)_get_osfhandle(fd
);
53 /* get current position, ftruncate do not change position */
55 li
.LowPart
= SetFilePointer (h
, 0, &li
.HighPart
, FILE_CURRENT
);
56 if (li
.LowPart
== 0xffffffffUL
&& GetLastError() != NO_ERROR
)
60 if (!SetFilePointer(h
, (DWORD
) length
, &high
, FILE_BEGIN
))
62 res
= SetEndOfFile(h
);
64 /* back to old position */
65 SetFilePointer(h
, li
.LowPart
, &li
.HighPart
, FILE_BEGIN
);
69 static int set_sparse(int fd
)
72 return (int) DeviceIoControl((HANDLE
)_get_osfhandle(fd
), FSCTL_SET_SPARSE
,
73 NULL
, 0, NULL
, 0, &returned
, NULL
);
76 static int raw_open(BlockDriverState
*bs
, const char *filename
, int flags
)
78 BDRVRawState
*s
= bs
->opaque
;
84 if (flags
& BDRV_O_RDWR
) {
85 access_flags
= GENERIC_READ
| GENERIC_WRITE
;
87 access_flags
= GENERIC_READ
;
90 overlapped
= FILE_ATTRIBUTE_NORMAL
;
91 if ((flags
& BDRV_O_NOCACHE
))
92 overlapped
|= FILE_FLAG_NO_BUFFERING
| FILE_FLAG_WRITE_THROUGH
;
93 else if (!(flags
& BDRV_O_CACHE_WB
))
94 overlapped
|= FILE_FLAG_WRITE_THROUGH
;
95 s
->hfile
= CreateFile(filename
, access_flags
,
96 FILE_SHARE_READ
, NULL
,
97 OPEN_EXISTING
, overlapped
, NULL
);
98 if (s
->hfile
== INVALID_HANDLE_VALUE
) {
99 int err
= GetLastError();
101 if (err
== ERROR_ACCESS_DENIED
)
108 static int raw_read(BlockDriverState
*bs
, int64_t sector_num
,
109 uint8_t *buf
, int nb_sectors
)
111 BDRVRawState
*s
= bs
->opaque
;
115 int64_t offset
= sector_num
* 512;
116 int count
= nb_sectors
* 512;
118 memset(&ov
, 0, sizeof(ov
));
120 ov
.OffsetHigh
= offset
>> 32;
121 ret
= ReadFile(s
->hfile
, buf
, count
, &ret_count
, &ov
);
124 if (ret_count
== count
)
129 static int raw_write(BlockDriverState
*bs
, int64_t sector_num
,
130 const uint8_t *buf
, int nb_sectors
)
132 BDRVRawState
*s
= bs
->opaque
;
136 int64_t offset
= sector_num
* 512;
137 int count
= nb_sectors
* 512;
139 memset(&ov
, 0, sizeof(ov
));
141 ov
.OffsetHigh
= offset
>> 32;
142 ret
= WriteFile(s
->hfile
, buf
, count
, &ret_count
, &ov
);
145 if (ret_count
== count
)
150 static void raw_flush(BlockDriverState
*bs
)
152 BDRVRawState
*s
= bs
->opaque
;
153 FlushFileBuffers(s
->hfile
);
156 static void raw_close(BlockDriverState
*bs
)
158 BDRVRawState
*s
= bs
->opaque
;
159 CloseHandle(s
->hfile
);
162 static int raw_truncate(BlockDriverState
*bs
, int64_t offset
)
164 BDRVRawState
*s
= bs
->opaque
;
169 if (!SetFilePointer(s
->hfile
, low
, &high
, FILE_BEGIN
))
171 if (!SetEndOfFile(s
->hfile
))
176 static int64_t raw_getlength(BlockDriverState
*bs
)
178 BDRVRawState
*s
= bs
->opaque
;
180 ULARGE_INTEGER available
, total
, total_free
;
187 l
.LowPart
= GetFileSize(s
->hfile
, (PDWORD
)&l
.HighPart
);
188 if (l
.LowPart
== 0xffffffffUL
&& GetLastError() != NO_ERROR
)
192 if (!GetDiskFreeSpaceEx(s
->drive_path
, &available
, &total
, &total_free
))
194 l
.QuadPart
= total
.QuadPart
;
197 status
= DeviceIoControl(s
->hfile
, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX
,
198 NULL
, 0, &dg
, sizeof(dg
), &count
, NULL
);
209 static int raw_create(const char *filename
, QEMUOptionParameter
*options
)
212 int64_t total_size
= 0;
214 /* Read out options */
215 while (options
&& options
->name
) {
216 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
217 total_size
= options
->value
.n
/ 512;
222 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
,
227 ftruncate(fd
, total_size
* 512);
232 static QEMUOptionParameter raw_create_options
[] = {
234 .name
= BLOCK_OPT_SIZE
,
236 .help
= "Virtual disk size"
241 static BlockDriver bdrv_file
= {
242 .format_name
= "file",
243 .protocol_name
= "file",
244 .instance_size
= sizeof(BDRVRawState
),
245 .bdrv_file_open
= raw_open
,
246 .bdrv_close
= raw_close
,
247 .bdrv_create
= raw_create
,
248 .bdrv_flush
= raw_flush
,
249 .bdrv_read
= raw_read
,
250 .bdrv_write
= raw_write
,
251 .bdrv_truncate
= raw_truncate
,
252 .bdrv_getlength
= raw_getlength
,
254 .create_options
= raw_create_options
,
257 /***********************************************/
260 static int find_cdrom(char *cdrom_name
, int cdrom_name_size
)
262 char drives
[256], *pdrv
= drives
;
265 memset(drives
, 0, sizeof(drives
));
266 GetLogicalDriveStrings(sizeof(drives
), drives
);
267 while(pdrv
[0] != '\0') {
268 type
= GetDriveType(pdrv
);
271 snprintf(cdrom_name
, cdrom_name_size
, "\\\\.\\%c:", pdrv
[0]);
275 pdrv
+= lstrlen(pdrv
) + 1;
280 static int find_device_type(BlockDriverState
*bs
, const char *filename
)
282 BDRVRawState
*s
= bs
->opaque
;
286 if (strstart(filename
, "\\\\.\\", &p
) ||
287 strstart(filename
, "//./", &p
)) {
288 if (stristart(p
, "PhysicalDrive", NULL
))
289 return FTYPE_HARDDISK
;
290 snprintf(s
->drive_path
, sizeof(s
->drive_path
), "%c:\\", p
[0]);
291 type
= GetDriveType(s
->drive_path
);
293 case DRIVE_REMOVABLE
:
295 return FTYPE_HARDDISK
;
306 static int hdev_probe_device(const char *filename
)
308 if (strstart(filename
, "/dev/cdrom", NULL
))
310 if (is_windows_drive(filename
))
315 static int hdev_open(BlockDriverState
*bs
, const char *filename
, int flags
)
317 BDRVRawState
*s
= bs
->opaque
;
318 int access_flags
, create_flags
;
320 char device_name
[64];
322 if (strstart(filename
, "/dev/cdrom", NULL
)) {
323 if (find_cdrom(device_name
, sizeof(device_name
)) < 0)
325 filename
= device_name
;
327 /* transform drive letters into device name */
328 if (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
329 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
330 filename
[1] == ':' && filename
[2] == '\0') {
331 snprintf(device_name
, sizeof(device_name
), "\\\\.\\%c:", filename
[0]);
332 filename
= device_name
;
335 s
->type
= find_device_type(bs
, filename
);
337 if (flags
& BDRV_O_RDWR
) {
338 access_flags
= GENERIC_READ
| GENERIC_WRITE
;
340 access_flags
= GENERIC_READ
;
342 create_flags
= OPEN_EXISTING
;
344 overlapped
= FILE_ATTRIBUTE_NORMAL
;
345 if ((flags
& BDRV_O_NOCACHE
))
346 overlapped
|= FILE_FLAG_NO_BUFFERING
| FILE_FLAG_WRITE_THROUGH
;
347 else if (!(flags
& BDRV_O_CACHE_WB
))
348 overlapped
|= FILE_FLAG_WRITE_THROUGH
;
349 s
->hfile
= CreateFile(filename
, access_flags
,
350 FILE_SHARE_READ
, NULL
,
351 create_flags
, overlapped
, NULL
);
352 if (s
->hfile
== INVALID_HANDLE_VALUE
) {
353 int err
= GetLastError();
355 if (err
== ERROR_ACCESS_DENIED
)
363 /***********************************************/
364 /* removable device additional commands */
366 static int raw_is_inserted(BlockDriverState
*bs
)
371 static int raw_media_changed(BlockDriverState
*bs
)
376 static int raw_eject(BlockDriverState
*bs
, int eject_flag
)
380 if (s
->type
== FTYPE_FILE
)
383 DeviceIoControl(s
->hfile
, IOCTL_STORAGE_EJECT_MEDIA
,
384 NULL
, 0, NULL
, 0, &lpBytesReturned
, NULL
);
386 DeviceIoControl(s
->hfile
, IOCTL_STORAGE_LOAD_MEDIA
,
387 NULL
, 0, NULL
, 0, &lpBytesReturned
, NULL
);
391 static int raw_set_locked(BlockDriverState
*bs
, int locked
)
397 static int hdev_has_zero_init(BlockDriverState
*bs
)
402 static BlockDriver bdrv_host_device
= {
403 .format_name
= "host_device",
404 .protocol_name
= "host_device",
405 .instance_size
= sizeof(BDRVRawState
),
406 .bdrv_probe_device
= hdev_probe_device
,
407 .bdrv_file_open
= hdev_open
,
408 .bdrv_close
= raw_close
,
409 .bdrv_flush
= raw_flush
,
410 .bdrv_has_zero_init
= hdev_has_zero_init
,
412 .bdrv_read
= raw_read
,
413 .bdrv_write
= raw_write
,
414 .bdrv_getlength
= raw_getlength
,
417 static void bdrv_file_init(void)
419 bdrv_register(&bdrv_file
);
420 bdrv_register(&bdrv_host_device
);
423 block_init(bdrv_file_init
);