]>
Commit | Line | Data |
---|---|---|
223d4670 TS |
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" | |
1de7afc9 | 25 | #include "qemu/timer.h" |
737e150e | 26 | #include "block/block_int.h" |
1de7afc9 | 27 | #include "qemu/module.h" |
fc4edb84 PB |
28 | #include "raw-aio.h" |
29 | #include "trace.h" | |
737e150e | 30 | #include "block/thread-pool.h" |
1de7afc9 | 31 | #include "qemu/iov.h" |
49dc768d | 32 | #include <windows.h> |
223d4670 TS |
33 | #include <winioctl.h> |
34 | ||
35 | #define FTYPE_FILE 0 | |
36 | #define FTYPE_CD 1 | |
37 | #define FTYPE_HARDDISK 2 | |
38 | ||
a2736526 PB |
39 | static QEMUWin32AIOState *aio; |
40 | ||
fc4edb84 PB |
41 | typedef struct RawWin32AIOData { |
42 | BlockDriverState *bs; | |
43 | HANDLE hfile; | |
44 | struct iovec *aio_iov; | |
45 | int aio_niov; | |
46 | size_t aio_nbytes; | |
47 | off64_t aio_offset; | |
48 | int aio_type; | |
49 | } RawWin32AIOData; | |
50 | ||
223d4670 TS |
51 | typedef struct BDRVRawState { |
52 | HANDLE hfile; | |
53 | int type; | |
54 | char drive_path[16]; /* format: "d:\" */ | |
a2736526 | 55 | QEMUWin32AIOState *aio; |
223d4670 TS |
56 | } BDRVRawState; |
57 | ||
fc4edb84 PB |
58 | /* |
59 | * Read/writes the data to/from a given linear buffer. | |
60 | * | |
61 | * Returns the number of bytes handles or -errno in case of an error. Short | |
62 | * reads are only returned if the end of the file is reached. | |
63 | */ | |
64 | static size_t handle_aiocb_rw(RawWin32AIOData *aiocb) | |
65 | { | |
66 | size_t offset = 0; | |
67 | int i; | |
68 | ||
69 | for (i = 0; i < aiocb->aio_niov; i++) { | |
70 | OVERLAPPED ov; | |
71 | DWORD ret, ret_count, len; | |
72 | ||
73 | memset(&ov, 0, sizeof(ov)); | |
74 | ov.Offset = (aiocb->aio_offset + offset); | |
75 | ov.OffsetHigh = (aiocb->aio_offset + offset) >> 32; | |
76 | len = aiocb->aio_iov[i].iov_len; | |
77 | if (aiocb->aio_type & QEMU_AIO_WRITE) { | |
78 | ret = WriteFile(aiocb->hfile, aiocb->aio_iov[i].iov_base, | |
79 | len, &ret_count, &ov); | |
80 | } else { | |
81 | ret = ReadFile(aiocb->hfile, aiocb->aio_iov[i].iov_base, | |
82 | len, &ret_count, &ov); | |
83 | } | |
84 | if (!ret) { | |
85 | ret_count = 0; | |
86 | } | |
87 | if (ret_count != len) { | |
56e023af | 88 | offset += ret_count; |
fc4edb84 PB |
89 | break; |
90 | } | |
91 | offset += len; | |
92 | } | |
93 | ||
94 | return offset; | |
95 | } | |
96 | ||
97 | static int aio_worker(void *arg) | |
98 | { | |
99 | RawWin32AIOData *aiocb = arg; | |
100 | ssize_t ret = 0; | |
101 | size_t count; | |
102 | ||
103 | switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) { | |
104 | case QEMU_AIO_READ: | |
105 | count = handle_aiocb_rw(aiocb); | |
106 | if (count < aiocb->aio_nbytes && aiocb->bs->growable) { | |
107 | /* A short read means that we have reached EOF. Pad the buffer | |
108 | * with zeros for bytes after EOF. */ | |
109 | iov_memset(aiocb->aio_iov, aiocb->aio_niov, count, | |
110 | 0, aiocb->aio_nbytes - count); | |
111 | ||
112 | count = aiocb->aio_nbytes; | |
113 | } | |
114 | if (count == aiocb->aio_nbytes) { | |
115 | ret = 0; | |
116 | } else { | |
117 | ret = -EINVAL; | |
118 | } | |
119 | break; | |
120 | case QEMU_AIO_WRITE: | |
121 | count = handle_aiocb_rw(aiocb); | |
122 | if (count == aiocb->aio_nbytes) { | |
123 | count = 0; | |
124 | } else { | |
125 | count = -EINVAL; | |
126 | } | |
127 | break; | |
128 | case QEMU_AIO_FLUSH: | |
129 | if (!FlushFileBuffers(aiocb->hfile)) { | |
130 | return -EIO; | |
131 | } | |
132 | break; | |
133 | default: | |
134 | fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type); | |
135 | ret = -EINVAL; | |
136 | break; | |
137 | } | |
138 | ||
139 | g_slice_free(RawWin32AIOData, aiocb); | |
140 | return ret; | |
141 | } | |
142 | ||
143 | static BlockDriverAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile, | |
144 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
145 | BlockDriverCompletionFunc *cb, void *opaque, int type) | |
146 | { | |
147 | RawWin32AIOData *acb = g_slice_new(RawWin32AIOData); | |
c4d9d196 | 148 | ThreadPool *pool; |
fc4edb84 PB |
149 | |
150 | acb->bs = bs; | |
151 | acb->hfile = hfile; | |
152 | acb->aio_type = type; | |
153 | ||
154 | if (qiov) { | |
155 | acb->aio_iov = qiov->iov; | |
156 | acb->aio_niov = qiov->niov; | |
157 | } | |
158 | acb->aio_nbytes = nb_sectors * 512; | |
159 | acb->aio_offset = sector_num * 512; | |
160 | ||
161 | trace_paio_submit(acb, opaque, sector_num, nb_sectors, type); | |
c4d9d196 SH |
162 | pool = aio_get_thread_pool(bdrv_get_aio_context(bs)); |
163 | return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque); | |
fc4edb84 PB |
164 | } |
165 | ||
223d4670 TS |
166 | int qemu_ftruncate64(int fd, int64_t length) |
167 | { | |
168 | LARGE_INTEGER li; | |
2c993ec2 | 169 | DWORD dw; |
223d4670 TS |
170 | LONG high; |
171 | HANDLE h; | |
172 | BOOL res; | |
173 | ||
174 | if ((GetVersion() & 0x80000000UL) && (length >> 32) != 0) | |
175 | return -1; | |
176 | ||
177 | h = (HANDLE)_get_osfhandle(fd); | |
178 | ||
179 | /* get current position, ftruncate do not change position */ | |
180 | li.HighPart = 0; | |
181 | li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT); | |
2c993ec2 | 182 | if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) { |
223d4670 | 183 | return -1; |
2c993ec2 | 184 | } |
223d4670 TS |
185 | |
186 | high = length >> 32; | |
2c993ec2 SW |
187 | dw = SetFilePointer(h, (DWORD) length, &high, FILE_BEGIN); |
188 | if (dw == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) { | |
223d4670 | 189 | return -1; |
2c993ec2 | 190 | } |
223d4670 TS |
191 | res = SetEndOfFile(h); |
192 | ||
193 | /* back to old position */ | |
194 | SetFilePointer(h, li.LowPart, &li.HighPart, FILE_BEGIN); | |
195 | return res ? 0 : -1; | |
196 | } | |
197 | ||
198 | static int set_sparse(int fd) | |
199 | { | |
200 | DWORD returned; | |
201 | return (int) DeviceIoControl((HANDLE)_get_osfhandle(fd), FSCTL_SET_SPARSE, | |
202 | NULL, 0, NULL, 0, &returned, NULL); | |
203 | } | |
204 | ||
6a8dc042 JC |
205 | static void raw_parse_flags(int flags, int *access_flags, DWORD *overlapped) |
206 | { | |
207 | assert(access_flags != NULL); | |
208 | assert(overlapped != NULL); | |
209 | ||
210 | if (flags & BDRV_O_RDWR) { | |
211 | *access_flags = GENERIC_READ | GENERIC_WRITE; | |
212 | } else { | |
213 | *access_flags = GENERIC_READ; | |
214 | } | |
215 | ||
216 | *overlapped = FILE_ATTRIBUTE_NORMAL; | |
a2736526 PB |
217 | if (flags & BDRV_O_NATIVE_AIO) { |
218 | *overlapped |= FILE_FLAG_OVERLAPPED; | |
219 | } | |
6a8dc042 JC |
220 | if (flags & BDRV_O_NOCACHE) { |
221 | *overlapped |= FILE_FLAG_NO_BUFFERING; | |
222 | } | |
6a8dc042 JC |
223 | } |
224 | ||
8a79380b KW |
225 | static QemuOptsList raw_runtime_opts = { |
226 | .name = "raw", | |
227 | .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head), | |
228 | .desc = { | |
229 | { | |
230 | .name = "filename", | |
231 | .type = QEMU_OPT_STRING, | |
232 | .help = "File name of the image", | |
233 | }, | |
234 | { /* end of list */ } | |
235 | }, | |
236 | }; | |
237 | ||
015a1036 MR |
238 | static int raw_open(BlockDriverState *bs, QDict *options, int flags, |
239 | Error **errp) | |
223d4670 TS |
240 | { |
241 | BDRVRawState *s = bs->opaque; | |
9a2d77ad | 242 | int access_flags; |
223d4670 | 243 | DWORD overlapped; |
8a79380b KW |
244 | QemuOpts *opts; |
245 | Error *local_err = NULL; | |
246 | const char *filename; | |
247 | int ret; | |
223d4670 TS |
248 | |
249 | s->type = FTYPE_FILE; | |
250 | ||
8a79380b KW |
251 | opts = qemu_opts_create_nofail(&raw_runtime_opts); |
252 | qemu_opts_absorb_qdict(opts, options, &local_err); | |
253 | if (error_is_set(&local_err)) { | |
254 | qerror_report_err(local_err); | |
255 | error_free(local_err); | |
256 | ret = -EINVAL; | |
257 | goto fail; | |
258 | } | |
259 | ||
260 | filename = qemu_opt_get(opts, "filename"); | |
261 | ||
6a8dc042 | 262 | raw_parse_flags(flags, &access_flags, &overlapped); |
8a79380b | 263 | |
a2736526 PB |
264 | if ((flags & BDRV_O_NATIVE_AIO) && aio == NULL) { |
265 | aio = win32_aio_init(); | |
266 | if (aio == NULL) { | |
8a79380b KW |
267 | ret = -EINVAL; |
268 | goto fail; | |
a2736526 PB |
269 | } |
270 | } | |
9a2d77ad | 271 | |
223d4670 TS |
272 | s->hfile = CreateFile(filename, access_flags, |
273 | FILE_SHARE_READ, NULL, | |
9a2d77ad | 274 | OPEN_EXISTING, overlapped, NULL); |
223d4670 TS |
275 | if (s->hfile == INVALID_HANDLE_VALUE) { |
276 | int err = GetLastError(); | |
277 | ||
8a79380b KW |
278 | if (err == ERROR_ACCESS_DENIED) { |
279 | ret = -EACCES; | |
280 | } else { | |
281 | ret = -EINVAL; | |
282 | } | |
283 | goto fail; | |
a2736526 PB |
284 | } |
285 | ||
286 | if (flags & BDRV_O_NATIVE_AIO) { | |
8a79380b | 287 | ret = win32_aio_attach(aio, s->hfile); |
a2736526 PB |
288 | if (ret < 0) { |
289 | CloseHandle(s->hfile); | |
8a79380b | 290 | goto fail; |
a2736526 PB |
291 | } |
292 | s->aio = aio; | |
223d4670 | 293 | } |
8a79380b KW |
294 | |
295 | ret = 0; | |
296 | fail: | |
297 | qemu_opts_del(opts); | |
298 | return ret; | |
223d4670 TS |
299 | } |
300 | ||
fc4edb84 PB |
301 | static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, |
302 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
303 | BlockDriverCompletionFunc *cb, void *opaque) | |
223d4670 TS |
304 | { |
305 | BDRVRawState *s = bs->opaque; | |
a2736526 PB |
306 | if (s->aio) { |
307 | return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov, | |
308 | nb_sectors, cb, opaque, QEMU_AIO_READ); | |
309 | } else { | |
310 | return paio_submit(bs, s->hfile, sector_num, qiov, nb_sectors, | |
311 | cb, opaque, QEMU_AIO_READ); | |
312 | } | |
223d4670 TS |
313 | } |
314 | ||
fc4edb84 PB |
315 | static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, |
316 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
317 | BlockDriverCompletionFunc *cb, void *opaque) | |
223d4670 TS |
318 | { |
319 | BDRVRawState *s = bs->opaque; | |
a2736526 PB |
320 | if (s->aio) { |
321 | return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov, | |
322 | nb_sectors, cb, opaque, QEMU_AIO_WRITE); | |
323 | } else { | |
324 | return paio_submit(bs, s->hfile, sector_num, qiov, nb_sectors, | |
325 | cb, opaque, QEMU_AIO_WRITE); | |
326 | } | |
223d4670 TS |
327 | } |
328 | ||
fc4edb84 PB |
329 | static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs, |
330 | BlockDriverCompletionFunc *cb, void *opaque) | |
223d4670 TS |
331 | { |
332 | BDRVRawState *s = bs->opaque; | |
fc4edb84 | 333 | return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH); |
223d4670 TS |
334 | } |
335 | ||
336 | static void raw_close(BlockDriverState *bs) | |
337 | { | |
338 | BDRVRawState *s = bs->opaque; | |
339 | CloseHandle(s->hfile); | |
340 | } | |
341 | ||
342 | static int raw_truncate(BlockDriverState *bs, int64_t offset) | |
343 | { | |
344 | BDRVRawState *s = bs->opaque; | |
b9e82a59 | 345 | LONG low, high; |
fbcad04d | 346 | DWORD dwPtrLow; |
223d4670 TS |
347 | |
348 | low = offset; | |
349 | high = offset >> 32; | |
fbcad04d FC |
350 | |
351 | /* | |
352 | * An error has occurred if the return value is INVALID_SET_FILE_POINTER | |
353 | * and GetLastError doesn't return NO_ERROR. | |
354 | */ | |
355 | dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN); | |
356 | if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) { | |
fccedc62 | 357 | fprintf(stderr, "SetFilePointer error: %lu\n", GetLastError()); |
fbcad04d FC |
358 | return -EIO; |
359 | } | |
360 | if (SetEndOfFile(s->hfile) == 0) { | |
fccedc62 | 361 | fprintf(stderr, "SetEndOfFile error: %lu\n", GetLastError()); |
223d4670 | 362 | return -EIO; |
fbcad04d | 363 | } |
223d4670 TS |
364 | return 0; |
365 | } | |
366 | ||
367 | static int64_t raw_getlength(BlockDriverState *bs) | |
368 | { | |
369 | BDRVRawState *s = bs->opaque; | |
370 | LARGE_INTEGER l; | |
371 | ULARGE_INTEGER available, total, total_free; | |
372 | DISK_GEOMETRY_EX dg; | |
373 | DWORD count; | |
374 | BOOL status; | |
375 | ||
376 | switch(s->type) { | |
377 | case FTYPE_FILE: | |
b9e82a59 | 378 | l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart); |
223d4670 TS |
379 | if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR) |
380 | return -EIO; | |
381 | break; | |
382 | case FTYPE_CD: | |
383 | if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free)) | |
384 | return -EIO; | |
385 | l.QuadPart = total.QuadPart; | |
386 | break; | |
387 | case FTYPE_HARDDISK: | |
388 | status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, | |
389 | NULL, 0, &dg, sizeof(dg), &count, NULL); | |
390 | if (status != 0) { | |
391 | l = dg.DiskSize; | |
392 | } | |
393 | break; | |
394 | default: | |
395 | return -EIO; | |
396 | } | |
397 | return l.QuadPart; | |
398 | } | |
399 | ||
4a1d5e1f FZ |
400 | static int64_t raw_get_allocated_file_size(BlockDriverState *bs) |
401 | { | |
402 | typedef DWORD (WINAPI * get_compressed_t)(const char *filename, | |
403 | DWORD * high); | |
404 | get_compressed_t get_compressed; | |
405 | struct _stati64 st; | |
406 | const char *filename = bs->filename; | |
407 | /* WinNT support GetCompressedFileSize to determine allocate size */ | |
408 | get_compressed = | |
409 | (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), | |
410 | "GetCompressedFileSizeA"); | |
411 | if (get_compressed) { | |
412 | DWORD high, low; | |
413 | low = get_compressed(filename, &high); | |
414 | if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) { | |
415 | return (((int64_t) high) << 32) + low; | |
416 | } | |
417 | } | |
418 | ||
419 | if (_stati64(filename, &st) < 0) { | |
420 | return -1; | |
421 | } | |
422 | return st.st_size; | |
423 | } | |
424 | ||
d5124c00 MR |
425 | static int raw_create(const char *filename, QEMUOptionParameter *options, |
426 | Error **errp) | |
223d4670 TS |
427 | { |
428 | int fd; | |
0e7e1989 | 429 | int64_t total_size = 0; |
223d4670 | 430 | |
0e7e1989 KW |
431 | /* Read out options */ |
432 | while (options && options->name) { | |
433 | if (!strcmp(options->name, BLOCK_OPT_SIZE)) { | |
434 | total_size = options->value.n / 512; | |
435 | } | |
436 | options++; | |
437 | } | |
223d4670 | 438 | |
6165f4d8 CB |
439 | fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, |
440 | 0644); | |
223d4670 TS |
441 | if (fd < 0) |
442 | return -EIO; | |
443 | set_sparse(fd); | |
444 | ftruncate(fd, total_size * 512); | |
2e1e79da | 445 | qemu_close(fd); |
223d4670 TS |
446 | return 0; |
447 | } | |
448 | ||
0e7e1989 | 449 | static QEMUOptionParameter raw_create_options[] = { |
db08adf5 KW |
450 | { |
451 | .name = BLOCK_OPT_SIZE, | |
452 | .type = OPT_SIZE, | |
453 | .help = "Virtual disk size" | |
454 | }, | |
0e7e1989 KW |
455 | { NULL } |
456 | }; | |
457 | ||
84a12e66 CH |
458 | static BlockDriver bdrv_file = { |
459 | .format_name = "file", | |
460 | .protocol_name = "file", | |
f1b2f712 | 461 | .instance_size = sizeof(BDRVRawState), |
030be321 | 462 | .bdrv_needs_filename = true, |
66f82cee | 463 | .bdrv_file_open = raw_open, |
f1b2f712 AL |
464 | .bdrv_close = raw_close, |
465 | .bdrv_create = raw_create, | |
3ac21627 | 466 | .bdrv_has_zero_init = bdrv_has_zero_init_1, |
c68b89ac | 467 | |
fc4edb84 PB |
468 | .bdrv_aio_readv = raw_aio_readv, |
469 | .bdrv_aio_writev = raw_aio_writev, | |
470 | .bdrv_aio_flush = raw_aio_flush, | |
c68b89ac | 471 | |
f1b2f712 AL |
472 | .bdrv_truncate = raw_truncate, |
473 | .bdrv_getlength = raw_getlength, | |
4a1d5e1f FZ |
474 | .bdrv_get_allocated_file_size |
475 | = raw_get_allocated_file_size, | |
0e7e1989 KW |
476 | |
477 | .create_options = raw_create_options, | |
223d4670 TS |
478 | }; |
479 | ||
480 | /***********************************************/ | |
481 | /* host device */ | |
482 | ||
483 | static int find_cdrom(char *cdrom_name, int cdrom_name_size) | |
484 | { | |
485 | char drives[256], *pdrv = drives; | |
486 | UINT type; | |
487 | ||
488 | memset(drives, 0, sizeof(drives)); | |
489 | GetLogicalDriveStrings(sizeof(drives), drives); | |
490 | while(pdrv[0] != '\0') { | |
491 | type = GetDriveType(pdrv); | |
492 | switch(type) { | |
493 | case DRIVE_CDROM: | |
494 | snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]); | |
495 | return 0; | |
496 | break; | |
497 | } | |
498 | pdrv += lstrlen(pdrv) + 1; | |
499 | } | |
500 | return -1; | |
501 | } | |
502 | ||
503 | static int find_device_type(BlockDriverState *bs, const char *filename) | |
504 | { | |
505 | BDRVRawState *s = bs->opaque; | |
506 | UINT type; | |
507 | const char *p; | |
508 | ||
509 | if (strstart(filename, "\\\\.\\", &p) || | |
510 | strstart(filename, "//./", &p)) { | |
511 | if (stristart(p, "PhysicalDrive", NULL)) | |
512 | return FTYPE_HARDDISK; | |
513 | snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]); | |
514 | type = GetDriveType(s->drive_path); | |
3060cd14 AL |
515 | switch (type) { |
516 | case DRIVE_REMOVABLE: | |
517 | case DRIVE_FIXED: | |
518 | return FTYPE_HARDDISK; | |
519 | case DRIVE_CDROM: | |
223d4670 | 520 | return FTYPE_CD; |
3060cd14 | 521 | default: |
223d4670 | 522 | return FTYPE_FILE; |
3060cd14 | 523 | } |
223d4670 TS |
524 | } else { |
525 | return FTYPE_FILE; | |
526 | } | |
527 | } | |
528 | ||
508c7cb3 CH |
529 | static int hdev_probe_device(const char *filename) |
530 | { | |
531 | if (strstart(filename, "/dev/cdrom", NULL)) | |
532 | return 100; | |
533 | if (is_windows_drive(filename)) | |
534 | return 100; | |
535 | return 0; | |
536 | } | |
537 | ||
015a1036 MR |
538 | static int hdev_open(BlockDriverState *bs, QDict *options, int flags, |
539 | Error **errp) | |
223d4670 TS |
540 | { |
541 | BDRVRawState *s = bs->opaque; | |
542 | int access_flags, create_flags; | |
68dc0364 | 543 | int ret = 0; |
223d4670 TS |
544 | DWORD overlapped; |
545 | char device_name[64]; | |
68dc0364 SW |
546 | |
547 | Error *local_err = NULL; | |
548 | const char *filename; | |
549 | ||
550 | QemuOpts *opts = qemu_opts_create_nofail(&raw_runtime_opts); | |
551 | qemu_opts_absorb_qdict(opts, options, &local_err); | |
552 | if (error_is_set(&local_err)) { | |
553 | qerror_report_err(local_err); | |
554 | error_free(local_err); | |
555 | ret = -EINVAL; | |
556 | goto done; | |
557 | } | |
558 | ||
559 | filename = qemu_opt_get(opts, "filename"); | |
223d4670 TS |
560 | |
561 | if (strstart(filename, "/dev/cdrom", NULL)) { | |
68dc0364 SW |
562 | if (find_cdrom(device_name, sizeof(device_name)) < 0) { |
563 | ret = -ENOENT; | |
564 | goto done; | |
565 | } | |
223d4670 TS |
566 | filename = device_name; |
567 | } else { | |
568 | /* transform drive letters into device name */ | |
569 | if (((filename[0] >= 'a' && filename[0] <= 'z') || | |
570 | (filename[0] >= 'A' && filename[0] <= 'Z')) && | |
571 | filename[1] == ':' && filename[2] == '\0') { | |
572 | snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]); | |
573 | filename = device_name; | |
574 | } | |
575 | } | |
576 | s->type = find_device_type(bs, filename); | |
577 | ||
6a8dc042 JC |
578 | raw_parse_flags(flags, &access_flags, &overlapped); |
579 | ||
223d4670 TS |
580 | create_flags = OPEN_EXISTING; |
581 | ||
223d4670 TS |
582 | s->hfile = CreateFile(filename, access_flags, |
583 | FILE_SHARE_READ, NULL, | |
584 | create_flags, overlapped, NULL); | |
585 | if (s->hfile == INVALID_HANDLE_VALUE) { | |
586 | int err = GetLastError(); | |
587 | ||
68dc0364 SW |
588 | if (err == ERROR_ACCESS_DENIED) { |
589 | ret = -EACCES; | |
590 | } else { | |
591 | ret = -1; | |
592 | } | |
593 | goto done; | |
223d4670 | 594 | } |
68dc0364 SW |
595 | |
596 | done: | |
597 | qemu_opts_del(opts); | |
598 | return ret; | |
223d4670 TS |
599 | } |
600 | ||
5efa9d5a | 601 | static BlockDriver bdrv_host_device = { |
e60f469c | 602 | .format_name = "host_device", |
84a12e66 | 603 | .protocol_name = "host_device", |
e60f469c | 604 | .instance_size = sizeof(BDRVRawState), |
030be321 | 605 | .bdrv_needs_filename = true, |
508c7cb3 | 606 | .bdrv_probe_device = hdev_probe_device, |
66f82cee | 607 | .bdrv_file_open = hdev_open, |
e60f469c | 608 | .bdrv_close = raw_close, |
223d4670 | 609 | |
fc4edb84 PB |
610 | .bdrv_aio_readv = raw_aio_readv, |
611 | .bdrv_aio_writev = raw_aio_writev, | |
612 | .bdrv_aio_flush = raw_aio_flush, | |
c68b89ac | 613 | |
e60f469c | 614 | .bdrv_getlength = raw_getlength, |
4a1d5e1f FZ |
615 | .bdrv_get_allocated_file_size |
616 | = raw_get_allocated_file_size, | |
223d4670 | 617 | }; |
5efa9d5a | 618 | |
84a12e66 | 619 | static void bdrv_file_init(void) |
5efa9d5a | 620 | { |
84a12e66 | 621 | bdrv_register(&bdrv_file); |
5efa9d5a AL |
622 | bdrv_register(&bdrv_host_device); |
623 | } | |
624 | ||
84a12e66 | 625 | block_init(bdrv_file_init); |