![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to raw-win32.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / block|
Return to raw-win32.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / block |
1.1 root 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: #include "qemu-common.h"
25: #include "qemu-timer.h"
26: #include "block_int.h"
27: #include "module.h"
28: #include <windows.h>
29: #include <winioctl.h>
30:
31: #define FTYPE_FILE 0
32: #define FTYPE_CD 1
33: #define FTYPE_HARDDISK 2
34:
35: typedef struct BDRVRawState {
36: HANDLE hfile;
37: int type;
38: char drive_path[16]; /* format: "d:\" */
39: } BDRVRawState;
40:
41: int qemu_ftruncate64(int fd, int64_t length)
42: {
43: LARGE_INTEGER li;
44: LONG high;
45: HANDLE h;
46: BOOL res;
47:
48: if ((GetVersion() & 0x80000000UL) && (length >> 32) != 0)
49: return -1;
50:
51: h = (HANDLE)_get_osfhandle(fd);
52:
53: /* get current position, ftruncate do not change position */
54: li.HighPart = 0;
55: li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT);
56: if (li.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR)
57: return -1;
58:
59: high = length >> 32;
60: if (!SetFilePointer(h, (DWORD) length, &high, FILE_BEGIN))
61: return -1;
62: res = SetEndOfFile(h);
63:
64: /* back to old position */
65: SetFilePointer(h, li.LowPart, &li.HighPart, FILE_BEGIN);
66: return res ? 0 : -1;
67: }
68:
69: static int set_sparse(int fd)
70: {
71: DWORD returned;
72: return (int) DeviceIoControl((HANDLE)_get_osfhandle(fd), FSCTL_SET_SPARSE,
73: NULL, 0, NULL, 0, &returned, NULL);
74: }
75:
76: static int raw_open(BlockDriverState *bs, const char *filename, int flags)
77: {
78: BDRVRawState *s = bs->opaque;
1.1.1.2 root 79: int access_flags;
1.1 root 80: DWORD overlapped;
81:
82: s->type = FTYPE_FILE;
83:
1.1.1.2 root 84: if (flags & BDRV_O_RDWR) {
1.1 root 85: access_flags = GENERIC_READ | GENERIC_WRITE;
86: } else {
87: access_flags = GENERIC_READ;
88: }
1.1.1.2 root 89:
1.1 root 90: overlapped = FILE_ATTRIBUTE_NORMAL;
1.1.1.4 ! root 91: if (flags & BDRV_O_NOCACHE)
! 92: overlapped |= FILE_FLAG_NO_BUFFERING;
! 93: if (!(flags & BDRV_O_CACHE_WB))
1.1 root 94: overlapped |= FILE_FLAG_WRITE_THROUGH;
95: s->hfile = CreateFile(filename, access_flags,
96: FILE_SHARE_READ, NULL,
1.1.1.2 root 97: OPEN_EXISTING, overlapped, NULL);
1.1 root 98: if (s->hfile == INVALID_HANDLE_VALUE) {
99: int err = GetLastError();
100:
101: if (err == ERROR_ACCESS_DENIED)
102: return -EACCES;
103: return -1;
104: }
105: return 0;
106: }
107:
108: static int raw_read(BlockDriverState *bs, int64_t sector_num,
109: uint8_t *buf, int nb_sectors)
110: {
111: BDRVRawState *s = bs->opaque;
112: OVERLAPPED ov;
113: DWORD ret_count;
114: int ret;
115: int64_t offset = sector_num * 512;
116: int count = nb_sectors * 512;
117:
118: memset(&ov, 0, sizeof(ov));
119: ov.Offset = offset;
120: ov.OffsetHigh = offset >> 32;
121: ret = ReadFile(s->hfile, buf, count, &ret_count, &ov);
122: if (!ret)
123: return ret_count;
124: if (ret_count == count)
125: ret_count = 0;
126: return ret_count;
127: }
128:
129: static int raw_write(BlockDriverState *bs, int64_t sector_num,
130: const uint8_t *buf, int nb_sectors)
131: {
132: BDRVRawState *s = bs->opaque;
133: OVERLAPPED ov;
134: DWORD ret_count;
135: int ret;
136: int64_t offset = sector_num * 512;
137: int count = nb_sectors * 512;
138:
139: memset(&ov, 0, sizeof(ov));
140: ov.Offset = offset;
141: ov.OffsetHigh = offset >> 32;
142: ret = WriteFile(s->hfile, buf, count, &ret_count, &ov);
143: if (!ret)
144: return ret_count;
145: if (ret_count == count)
146: ret_count = 0;
147: return ret_count;
148: }
149:
1.1.1.3 root 150: static int raw_flush(BlockDriverState *bs)
1.1 root 151: {
152: BDRVRawState *s = bs->opaque;
1.1.1.3 root 153: int ret;
154:
155: ret = FlushFileBuffers(s->hfile);
156: if (ret == 0) {
157: return -EIO;
158: }
159:
160: return 0;
1.1 root 161: }
162:
163: static void raw_close(BlockDriverState *bs)
164: {
165: BDRVRawState *s = bs->opaque;
166: CloseHandle(s->hfile);
167: }
168:
169: static int raw_truncate(BlockDriverState *bs, int64_t offset)
170: {
171: BDRVRawState *s = bs->opaque;
172: LONG low, high;
173:
174: low = offset;
175: high = offset >> 32;
176: if (!SetFilePointer(s->hfile, low, &high, FILE_BEGIN))
177: return -EIO;
178: if (!SetEndOfFile(s->hfile))
179: return -EIO;
180: return 0;
181: }
182:
183: static int64_t raw_getlength(BlockDriverState *bs)
184: {
185: BDRVRawState *s = bs->opaque;
186: LARGE_INTEGER l;
187: ULARGE_INTEGER available, total, total_free;
188: DISK_GEOMETRY_EX dg;
189: DWORD count;
190: BOOL status;
191:
192: switch(s->type) {
193: case FTYPE_FILE:
194: l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart);
195: if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR)
196: return -EIO;
197: break;
198: case FTYPE_CD:
199: if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free))
200: return -EIO;
201: l.QuadPart = total.QuadPart;
202: break;
203: case FTYPE_HARDDISK:
204: status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
205: NULL, 0, &dg, sizeof(dg), &count, NULL);
206: if (status != 0) {
207: l = dg.DiskSize;
208: }
209: break;
210: default:
211: return -EIO;
212: }
213: return l.QuadPart;
214: }
215:
1.1.1.4 ! root 216: static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
! 217: {
! 218: typedef DWORD (WINAPI * get_compressed_t)(const char *filename,
! 219: DWORD * high);
! 220: get_compressed_t get_compressed;
! 221: struct _stati64 st;
! 222: const char *filename = bs->filename;
! 223: /* WinNT support GetCompressedFileSize to determine allocate size */
! 224: get_compressed =
! 225: (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"),
! 226: "GetCompressedFileSizeA");
! 227: if (get_compressed) {
! 228: DWORD high, low;
! 229: low = get_compressed(filename, &high);
! 230: if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) {
! 231: return (((int64_t) high) << 32) + low;
! 232: }
! 233: }
! 234:
! 235: if (_stati64(filename, &st) < 0) {
! 236: return -1;
! 237: }
! 238: return st.st_size;
! 239: }
! 240:
1.1 root 241: static int raw_create(const char *filename, QEMUOptionParameter *options)
242: {
243: int fd;
244: int64_t total_size = 0;
245:
246: /* Read out options */
247: while (options && options->name) {
248: if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
249: total_size = options->value.n / 512;
250: }
251: options++;
252: }
253:
254: fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
255: 0644);
256: if (fd < 0)
257: return -EIO;
258: set_sparse(fd);
259: ftruncate(fd, total_size * 512);
260: close(fd);
261: return 0;
262: }
263:
264: static QEMUOptionParameter raw_create_options[] = {
265: {
266: .name = BLOCK_OPT_SIZE,
267: .type = OPT_SIZE,
268: .help = "Virtual disk size"
269: },
270: { NULL }
271: };
272:
1.1.1.2 root 273: static BlockDriver bdrv_file = {
274: .format_name = "file",
275: .protocol_name = "file",
1.1 root 276: .instance_size = sizeof(BDRVRawState),
1.1.1.2 root 277: .bdrv_file_open = raw_open,
1.1 root 278: .bdrv_close = raw_close,
279: .bdrv_create = raw_create,
280: .bdrv_flush = raw_flush,
281: .bdrv_read = raw_read,
282: .bdrv_write = raw_write,
283: .bdrv_truncate = raw_truncate,
284: .bdrv_getlength = raw_getlength,
1.1.1.4 ! root 285: .bdrv_get_allocated_file_size
! 286: = raw_get_allocated_file_size,
1.1 root 287:
288: .create_options = raw_create_options,
289: };
290:
291: /***********************************************/
292: /* host device */
293:
294: static int find_cdrom(char *cdrom_name, int cdrom_name_size)
295: {
296: char drives[256], *pdrv = drives;
297: UINT type;
298:
299: memset(drives, 0, sizeof(drives));
300: GetLogicalDriveStrings(sizeof(drives), drives);
301: while(pdrv[0] != '\0') {
302: type = GetDriveType(pdrv);
303: switch(type) {
304: case DRIVE_CDROM:
305: snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]);
306: return 0;
307: break;
308: }
309: pdrv += lstrlen(pdrv) + 1;
310: }
311: return -1;
312: }
313:
314: static int find_device_type(BlockDriverState *bs, const char *filename)
315: {
316: BDRVRawState *s = bs->opaque;
317: UINT type;
318: const char *p;
319:
320: if (strstart(filename, "\\\\.\\", &p) ||
321: strstart(filename, "//./", &p)) {
322: if (stristart(p, "PhysicalDrive", NULL))
323: return FTYPE_HARDDISK;
324: snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]);
325: type = GetDriveType(s->drive_path);
326: switch (type) {
327: case DRIVE_REMOVABLE:
328: case DRIVE_FIXED:
329: return FTYPE_HARDDISK;
330: case DRIVE_CDROM:
331: return FTYPE_CD;
332: default:
333: return FTYPE_FILE;
334: }
335: } else {
336: return FTYPE_FILE;
337: }
338: }
339:
340: static int hdev_probe_device(const char *filename)
341: {
342: if (strstart(filename, "/dev/cdrom", NULL))
343: return 100;
344: if (is_windows_drive(filename))
345: return 100;
346: return 0;
347: }
348:
349: static int hdev_open(BlockDriverState *bs, const char *filename, int flags)
350: {
351: BDRVRawState *s = bs->opaque;
352: int access_flags, create_flags;
353: DWORD overlapped;
354: char device_name[64];
355:
356: if (strstart(filename, "/dev/cdrom", NULL)) {
357: if (find_cdrom(device_name, sizeof(device_name)) < 0)
358: return -ENOENT;
359: filename = device_name;
360: } else {
361: /* transform drive letters into device name */
362: if (((filename[0] >= 'a' && filename[0] <= 'z') ||
363: (filename[0] >= 'A' && filename[0] <= 'Z')) &&
364: filename[1] == ':' && filename[2] == '\0') {
365: snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]);
366: filename = device_name;
367: }
368: }
369: s->type = find_device_type(bs, filename);
370:
1.1.1.2 root 371: if (flags & BDRV_O_RDWR) {
1.1 root 372: access_flags = GENERIC_READ | GENERIC_WRITE;
373: } else {
374: access_flags = GENERIC_READ;
375: }
376: create_flags = OPEN_EXISTING;
377:
378: overlapped = FILE_ATTRIBUTE_NORMAL;
1.1.1.4 ! root 379: if (flags & BDRV_O_NOCACHE)
! 380: overlapped |= FILE_FLAG_NO_BUFFERING;
! 381: if (!(flags & BDRV_O_CACHE_WB))
1.1 root 382: overlapped |= FILE_FLAG_WRITE_THROUGH;
383: s->hfile = CreateFile(filename, access_flags,
384: FILE_SHARE_READ, NULL,
385: create_flags, overlapped, NULL);
386: if (s->hfile == INVALID_HANDLE_VALUE) {
387: int err = GetLastError();
388:
389: if (err == ERROR_ACCESS_DENIED)
390: return -EACCES;
391: return -1;
392: }
393: return 0;
394: }
395:
396: #if 0
397: /***********************************************/
398: /* removable device additional commands */
399:
400: static int raw_is_inserted(BlockDriverState *bs)
401: {
402: return 1;
403: }
404:
405: static int raw_media_changed(BlockDriverState *bs)
406: {
407: return -ENOTSUP;
408: }
409:
410: static int raw_eject(BlockDriverState *bs, int eject_flag)
411: {
412: DWORD ret_count;
413:
414: if (s->type == FTYPE_FILE)
415: return -ENOTSUP;
416: if (eject_flag) {
417: DeviceIoControl(s->hfile, IOCTL_STORAGE_EJECT_MEDIA,
418: NULL, 0, NULL, 0, &lpBytesReturned, NULL);
419: } else {
420: DeviceIoControl(s->hfile, IOCTL_STORAGE_LOAD_MEDIA,
421: NULL, 0, NULL, 0, &lpBytesReturned, NULL);
422: }
423: }
424:
425: static int raw_set_locked(BlockDriverState *bs, int locked)
426: {
427: return -ENOTSUP;
428: }
429: #endif
430:
1.1.1.2 root 431: static int hdev_has_zero_init(BlockDriverState *bs)
432: {
433: return 0;
434: }
435:
1.1 root 436: static BlockDriver bdrv_host_device = {
437: .format_name = "host_device",
1.1.1.2 root 438: .protocol_name = "host_device",
1.1 root 439: .instance_size = sizeof(BDRVRawState),
440: .bdrv_probe_device = hdev_probe_device,
1.1.1.2 root 441: .bdrv_file_open = hdev_open,
1.1 root 442: .bdrv_close = raw_close,
443: .bdrv_flush = raw_flush,
1.1.1.2 root 444: .bdrv_has_zero_init = hdev_has_zero_init,
1.1 root 445:
446: .bdrv_read = raw_read,
447: .bdrv_write = raw_write,
448: .bdrv_getlength = raw_getlength,
1.1.1.4 ! root 449: .bdrv_get_allocated_file_size
! 450: = raw_get_allocated_file_size,
1.1 root 451: };
452:
1.1.1.2 root 453: static void bdrv_file_init(void)
1.1 root 454: {
1.1.1.2 root 455: bdrv_register(&bdrv_file);
1.1 root 456: bdrv_register(&bdrv_host_device);
457: }
458:
1.1.1.2 root 459: block_init(bdrv_file_init);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.