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