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