blob: ef2910b03f41b5eb6c50906784927e70bb3f782a [file] [log] [blame]
ths223d4672007-12-15 17:28:36 +00001/*
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 */
Peter Maydell80c71a22016-01-18 18:01:42 +000024#include "qemu/osdep.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010025#include "qapi/error.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020026#include "qemu/cutils.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010027#include "block/block_int.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010028#include "qemu/module.h"
Paolo Bonzini0187f5c2016-07-04 18:33:20 +020029#include "block/raw-aio.h"
Paolo Bonzinifc4edb82012-06-09 04:48:28 +020030#include "trace.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010031#include "block/thread-pool.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010032#include "qemu/iov.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010033#include "qapi/qmp/qstring.h"
Kevin Wolf0a4279d2016-09-08 15:09:01 +020034#include "qapi/util.h"
aliguori49dc7682009-03-08 16:26:59 +000035#include <windows.h>
ths223d4672007-12-15 17:28:36 +000036#include <winioctl.h>
37
38#define FTYPE_FILE 0
39#define FTYPE_CD 1
40#define FTYPE_HARDDISK 2
41
Paolo Bonzinifc4edb82012-06-09 04:48:28 +020042typedef struct RawWin32AIOData {
43 BlockDriverState *bs;
44 HANDLE hfile;
45 struct iovec *aio_iov;
46 int aio_niov;
47 size_t aio_nbytes;
48 off64_t aio_offset;
49 int aio_type;
50} RawWin32AIOData;
51
ths223d4672007-12-15 17:28:36 +000052typedef struct BDRVRawState {
53 HANDLE hfile;
54 int type;
55 char drive_path[16]; /* format: "d:\" */
Paolo Bonzinia2736522012-10-26 11:43:58 +020056 QEMUWin32AIOState *aio;
ths223d4672007-12-15 17:28:36 +000057} BDRVRawState;
58
Paolo Bonzinifc4edb82012-06-09 04:48:28 +020059/*
60 * Read/writes the data to/from a given linear buffer.
61 *
62 * Returns the number of bytes handles or -errno in case of an error. Short
63 * reads are only returned if the end of the file is reached.
64 */
65static size_t handle_aiocb_rw(RawWin32AIOData *aiocb)
66{
67 size_t offset = 0;
68 int i;
69
70 for (i = 0; i < aiocb->aio_niov; i++) {
71 OVERLAPPED ov;
72 DWORD ret, ret_count, len;
73
74 memset(&ov, 0, sizeof(ov));
75 ov.Offset = (aiocb->aio_offset + offset);
76 ov.OffsetHigh = (aiocb->aio_offset + offset) >> 32;
77 len = aiocb->aio_iov[i].iov_len;
78 if (aiocb->aio_type & QEMU_AIO_WRITE) {
79 ret = WriteFile(aiocb->hfile, aiocb->aio_iov[i].iov_base,
80 len, &ret_count, &ov);
81 } else {
82 ret = ReadFile(aiocb->hfile, aiocb->aio_iov[i].iov_base,
83 len, &ret_count, &ov);
84 }
85 if (!ret) {
86 ret_count = 0;
87 }
88 if (ret_count != len) {
Tal Kain56e023a2013-09-09 11:14:55 +020089 offset += ret_count;
Paolo Bonzinifc4edb82012-06-09 04:48:28 +020090 break;
91 }
92 offset += len;
93 }
94
95 return offset;
96}
97
98static int aio_worker(void *arg)
99{
100 RawWin32AIOData *aiocb = arg;
101 ssize_t ret = 0;
102 size_t count;
103
104 switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
105 case QEMU_AIO_READ:
106 count = handle_aiocb_rw(aiocb);
Max Reitzc0191e72015-02-05 13:58:24 -0500107 if (count < aiocb->aio_nbytes) {
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200108 /* A short read means that we have reached EOF. Pad the buffer
109 * with zeros for bytes after EOF. */
110 iov_memset(aiocb->aio_iov, aiocb->aio_niov, count,
111 0, aiocb->aio_nbytes - count);
112
113 count = aiocb->aio_nbytes;
114 }
115 if (count == aiocb->aio_nbytes) {
116 ret = 0;
117 } else {
118 ret = -EINVAL;
119 }
120 break;
121 case QEMU_AIO_WRITE:
122 count = handle_aiocb_rw(aiocb);
123 if (count == aiocb->aio_nbytes) {
Kevin Wolf5d555032015-09-23 14:58:21 +0200124 ret = 0;
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200125 } else {
Kevin Wolf5d555032015-09-23 14:58:21 +0200126 ret = -EINVAL;
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200127 }
128 break;
129 case QEMU_AIO_FLUSH:
130 if (!FlushFileBuffers(aiocb->hfile)) {
131 return -EIO;
132 }
133 break;
134 default:
135 fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
136 ret = -EINVAL;
137 break;
138 }
139
Paolo Bonzinic84b3192015-10-01 13:04:39 +0200140 g_free(aiocb);
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200141 return ret;
142}
143
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200144static BlockAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile,
Eric Blake36e3b2e2016-07-15 17:22:55 -0600145 int64_t offset, QEMUIOVector *qiov, int count,
Markus Armbruster097310b2014-10-07 13:59:15 +0200146 BlockCompletionFunc *cb, void *opaque, int type)
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200147{
Paolo Bonzinic84b3192015-10-01 13:04:39 +0200148 RawWin32AIOData *acb = g_new(RawWin32AIOData, 1);
Stefan Hajnoczic4d9d192013-03-07 13:41:49 +0100149 ThreadPool *pool;
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200150
151 acb->bs = bs;
152 acb->hfile = hfile;
153 acb->aio_type = type;
154
155 if (qiov) {
156 acb->aio_iov = qiov->iov;
157 acb->aio_niov = qiov->niov;
Eric Blake36e3b2e2016-07-15 17:22:55 -0600158 assert(qiov->size == count);
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200159 }
Eric Blake36e3b2e2016-07-15 17:22:55 -0600160 acb->aio_nbytes = count;
161 acb->aio_offset = offset;
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200162
Eric Blake36e3b2e2016-07-15 17:22:55 -0600163 trace_paio_submit(acb, opaque, offset, count, type);
Stefan Hajnoczic4d9d192013-03-07 13:41:49 +0100164 pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
165 return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200166}
167
ths223d4672007-12-15 17:28:36 +0000168int qemu_ftruncate64(int fd, int64_t length)
169{
170 LARGE_INTEGER li;
Stefan Weil2c993ec2011-08-20 12:10:05 +0200171 DWORD dw;
ths223d4672007-12-15 17:28:36 +0000172 LONG high;
173 HANDLE h;
174 BOOL res;
175
176 if ((GetVersion() & 0x80000000UL) && (length >> 32) != 0)
177 return -1;
178
179 h = (HANDLE)_get_osfhandle(fd);
180
181 /* get current position, ftruncate do not change position */
182 li.HighPart = 0;
183 li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT);
Stefan Weil2c993ec2011-08-20 12:10:05 +0200184 if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
ths223d4672007-12-15 17:28:36 +0000185 return -1;
Stefan Weil2c993ec2011-08-20 12:10:05 +0200186 }
ths223d4672007-12-15 17:28:36 +0000187
188 high = length >> 32;
Stefan Weil2c993ec2011-08-20 12:10:05 +0200189 dw = SetFilePointer(h, (DWORD) length, &high, FILE_BEGIN);
190 if (dw == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
ths223d4672007-12-15 17:28:36 +0000191 return -1;
Stefan Weil2c993ec2011-08-20 12:10:05 +0200192 }
ths223d4672007-12-15 17:28:36 +0000193 res = SetEndOfFile(h);
194
195 /* back to old position */
196 SetFilePointer(h, li.LowPart, &li.HighPart, FILE_BEGIN);
197 return res ? 0 : -1;
198}
199
200static int set_sparse(int fd)
201{
202 DWORD returned;
203 return (int) DeviceIoControl((HANDLE)_get_osfhandle(fd), FSCTL_SET_SPARSE,
204 NULL, 0, NULL, 0, &returned, NULL);
205}
206
Stefan Hajnoczi85ebd382014-05-08 16:34:50 +0200207static void raw_detach_aio_context(BlockDriverState *bs)
208{
209 BDRVRawState *s = bs->opaque;
210
211 if (s->aio) {
212 win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs));
213 }
214}
215
216static void raw_attach_aio_context(BlockDriverState *bs,
217 AioContext *new_context)
218{
219 BDRVRawState *s = bs->opaque;
220
221 if (s->aio) {
222 win32_aio_attach_aio_context(s->aio, new_context);
223 }
224}
225
Eric Blake2914a1d2016-06-23 16:37:16 -0600226static void raw_probe_alignment(BlockDriverState *bs, Error **errp)
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100227{
228 BDRVRawState *s = bs->opaque;
229 DWORD sectorsPerCluster, freeClusters, totalClusters, count;
230 DISK_GEOMETRY_EX dg;
231 BOOL status;
232
233 if (s->type == FTYPE_CD) {
Eric Blakea5b8dd22016-06-23 16:37:24 -0600234 bs->bl.request_alignment = 2048;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100235 return;
236 }
237 if (s->type == FTYPE_HARDDISK) {
238 status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
239 NULL, 0, &dg, sizeof(dg), &count, NULL);
240 if (status != 0) {
Eric Blakea5b8dd22016-06-23 16:37:24 -0600241 bs->bl.request_alignment = dg.Geometry.BytesPerSector;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100242 return;
243 }
244 /* try GetDiskFreeSpace too */
245 }
246
247 if (s->drive_path[0]) {
248 GetDiskFreeSpace(s->drive_path, &sectorsPerCluster,
249 &dg.Geometry.BytesPerSector,
250 &freeClusters, &totalClusters);
Eric Blakea5b8dd22016-06-23 16:37:24 -0600251 bs->bl.request_alignment = dg.Geometry.BytesPerSector;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100252 }
253}
254
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200255static void raw_parse_flags(int flags, bool use_aio, int *access_flags,
256 DWORD *overlapped)
Jeff Cody6a8dc042012-09-20 15:13:21 -0400257{
258 assert(access_flags != NULL);
259 assert(overlapped != NULL);
260
261 if (flags & BDRV_O_RDWR) {
262 *access_flags = GENERIC_READ | GENERIC_WRITE;
263 } else {
264 *access_flags = GENERIC_READ;
265 }
266
267 *overlapped = FILE_ATTRIBUTE_NORMAL;
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200268 if (use_aio) {
Paolo Bonzinia2736522012-10-26 11:43:58 +0200269 *overlapped |= FILE_FLAG_OVERLAPPED;
270 }
Jeff Cody6a8dc042012-09-20 15:13:21 -0400271 if (flags & BDRV_O_NOCACHE) {
272 *overlapped |= FILE_FLAG_NO_BUFFERING;
273 }
Jeff Cody6a8dc042012-09-20 15:13:21 -0400274}
275
Max Reitz7dc74db2014-03-05 22:41:39 +0100276static void raw_parse_filename(const char *filename, QDict *options,
277 Error **errp)
278{
Max Reitz03c320d2017-05-22 21:52:16 +0200279 bdrv_parse_filename_strip_prefix(filename, "file:", options);
Max Reitz7dc74db2014-03-05 22:41:39 +0100280}
281
Kevin Wolf8a793802013-04-10 11:34:56 +0200282static QemuOptsList raw_runtime_opts = {
283 .name = "raw",
284 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
285 .desc = {
286 {
287 .name = "filename",
288 .type = QEMU_OPT_STRING,
289 .help = "File name of the image",
290 },
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200291 {
292 .name = "aio",
293 .type = QEMU_OPT_STRING,
294 .help = "host AIO implementation (threads, native)",
295 },
Kevin Wolf8a793802013-04-10 11:34:56 +0200296 { /* end of list */ }
297 },
298};
299
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200300static bool get_aio_option(QemuOpts *opts, int flags, Error **errp)
301{
302 BlockdevAioOptions aio, aio_default;
303
304 aio_default = (flags & BDRV_O_NATIVE_AIO) ? BLOCKDEV_AIO_OPTIONS_NATIVE
305 : BLOCKDEV_AIO_OPTIONS_THREADS;
306 aio = qapi_enum_parse(BlockdevAioOptions_lookup, qemu_opt_get(opts, "aio"),
307 BLOCKDEV_AIO_OPTIONS__MAX, aio_default, errp);
308
309 switch (aio) {
310 case BLOCKDEV_AIO_OPTIONS_NATIVE:
311 return true;
312 case BLOCKDEV_AIO_OPTIONS_THREADS:
313 return false;
314 default:
315 error_setg(errp, "Invalid AIO option");
316 }
317 return false;
318}
319
Max Reitz015a1032013-09-05 14:22:29 +0200320static int raw_open(BlockDriverState *bs, QDict *options, int flags,
321 Error **errp)
ths223d4672007-12-15 17:28:36 +0000322{
323 BDRVRawState *s = bs->opaque;
Christoph Hellwig9a2d77a2010-01-20 18:13:42 +0100324 int access_flags;
ths223d4672007-12-15 17:28:36 +0000325 DWORD overlapped;
Kevin Wolf8a793802013-04-10 11:34:56 +0200326 QemuOpts *opts;
327 Error *local_err = NULL;
328 const char *filename;
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200329 bool use_aio;
Kevin Wolf8a793802013-04-10 11:34:56 +0200330 int ret;
ths223d4672007-12-15 17:28:36 +0000331
332 s->type = FTYPE_FILE;
333
Peter Crosthwaite87ea75d2014-01-01 18:49:17 -0800334 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
Kevin Wolf8a793802013-04-10 11:34:56 +0200335 qemu_opts_absorb_qdict(opts, options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100336 if (local_err) {
Max Reitzc6252b72013-10-10 15:44:02 +0200337 error_propagate(errp, local_err);
Kevin Wolf8a793802013-04-10 11:34:56 +0200338 ret = -EINVAL;
339 goto fail;
340 }
341
Fam Zheng1c3a5552017-05-03 00:35:51 +0800342 if (qdict_get_try_bool(options, "locking", false)) {
343 error_setg(errp, "locking=on is not supported on Windows");
Gerd Hoffmanncdece042017-05-16 09:42:55 +0200344 ret = -EINVAL;
Fam Zheng1c3a5552017-05-03 00:35:51 +0800345 goto fail;
346 }
347
Kevin Wolf8a793802013-04-10 11:34:56 +0200348 filename = qemu_opt_get(opts, "filename");
349
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200350 use_aio = get_aio_option(opts, flags, &local_err);
351 if (local_err) {
352 error_propagate(errp, local_err);
353 ret = -EINVAL;
354 goto fail;
355 }
356
357 raw_parse_flags(flags, use_aio, &access_flags, &overlapped);
Kevin Wolf8a793802013-04-10 11:34:56 +0200358
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100359 if (filename[0] && filename[1] == ':') {
360 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", filename[0]);
361 } else if (filename[0] == '\\' && filename[1] == '\\') {
362 s->drive_path[0] = 0;
363 } else {
364 /* Relative path. */
365 char buf[MAX_PATH];
366 GetCurrentDirectory(MAX_PATH, buf);
367 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", buf[0]);
368 }
369
ths223d4672007-12-15 17:28:36 +0000370 s->hfile = CreateFile(filename, access_flags,
371 FILE_SHARE_READ, NULL,
Christoph Hellwig9a2d77a2010-01-20 18:13:42 +0100372 OPEN_EXISTING, overlapped, NULL);
ths223d4672007-12-15 17:28:36 +0000373 if (s->hfile == INVALID_HANDLE_VALUE) {
374 int err = GetLastError();
375
Halil Pasic09237752016-10-11 16:12:35 +0200376 error_setg_win32(errp, err, "Could not open '%s'", filename);
Kevin Wolf8a793802013-04-10 11:34:56 +0200377 if (err == ERROR_ACCESS_DENIED) {
378 ret = -EACCES;
379 } else {
380 ret = -EINVAL;
381 }
382 goto fail;
Paolo Bonzinia2736522012-10-26 11:43:58 +0200383 }
384
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200385 if (use_aio) {
Stefan Hajnoczi99cc5982014-05-08 16:34:49 +0200386 s->aio = win32_aio_init();
387 if (s->aio == NULL) {
388 CloseHandle(s->hfile);
389 error_setg(errp, "Could not initialize AIO");
390 ret = -EINVAL;
391 goto fail;
392 }
393
394 ret = win32_aio_attach(s->aio, s->hfile);
Paolo Bonzinia2736522012-10-26 11:43:58 +0200395 if (ret < 0) {
Stefan Hajnoczi99cc5982014-05-08 16:34:49 +0200396 win32_aio_cleanup(s->aio);
Paolo Bonzinia2736522012-10-26 11:43:58 +0200397 CloseHandle(s->hfile);
Max Reitzc6252b72013-10-10 15:44:02 +0200398 error_setg_errno(errp, -ret, "Could not enable AIO");
Kevin Wolf8a793802013-04-10 11:34:56 +0200399 goto fail;
Paolo Bonzinia2736522012-10-26 11:43:58 +0200400 }
Stefan Hajnoczi85ebd382014-05-08 16:34:50 +0200401
402 win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs));
ths223d4672007-12-15 17:28:36 +0000403 }
Kevin Wolf8a793802013-04-10 11:34:56 +0200404
405 ret = 0;
406fail:
407 qemu_opts_del(opts);
408 return ret;
ths223d4672007-12-15 17:28:36 +0000409}
410
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200411static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200412 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
Markus Armbruster097310b2014-10-07 13:59:15 +0200413 BlockCompletionFunc *cb, void *opaque)
ths223d4672007-12-15 17:28:36 +0000414{
415 BDRVRawState *s = bs->opaque;
Paolo Bonzinia2736522012-10-26 11:43:58 +0200416 if (s->aio) {
417 return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov,
Eric Blake36e3b2e2016-07-15 17:22:55 -0600418 nb_sectors, cb, opaque, QEMU_AIO_READ);
Paolo Bonzinia2736522012-10-26 11:43:58 +0200419 } else {
Eric Blake36e3b2e2016-07-15 17:22:55 -0600420 return paio_submit(bs, s->hfile, sector_num << BDRV_SECTOR_BITS, qiov,
421 nb_sectors << BDRV_SECTOR_BITS,
Paolo Bonzinia2736522012-10-26 11:43:58 +0200422 cb, opaque, QEMU_AIO_READ);
423 }
ths223d4672007-12-15 17:28:36 +0000424}
425
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200426static BlockAIOCB *raw_aio_writev(BlockDriverState *bs,
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200427 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
Markus Armbruster097310b2014-10-07 13:59:15 +0200428 BlockCompletionFunc *cb, void *opaque)
ths223d4672007-12-15 17:28:36 +0000429{
430 BDRVRawState *s = bs->opaque;
Paolo Bonzinia2736522012-10-26 11:43:58 +0200431 if (s->aio) {
432 return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov,
Eric Blake36e3b2e2016-07-15 17:22:55 -0600433 nb_sectors, cb, opaque, QEMU_AIO_WRITE);
Paolo Bonzinia2736522012-10-26 11:43:58 +0200434 } else {
Eric Blake36e3b2e2016-07-15 17:22:55 -0600435 return paio_submit(bs, s->hfile, sector_num << BDRV_SECTOR_BITS, qiov,
436 nb_sectors << BDRV_SECTOR_BITS,
Paolo Bonzinia2736522012-10-26 11:43:58 +0200437 cb, opaque, QEMU_AIO_WRITE);
438 }
ths223d4672007-12-15 17:28:36 +0000439}
440
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200441static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
Markus Armbruster097310b2014-10-07 13:59:15 +0200442 BlockCompletionFunc *cb, void *opaque)
ths223d4672007-12-15 17:28:36 +0000443{
444 BDRVRawState *s = bs->opaque;
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200445 return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
ths223d4672007-12-15 17:28:36 +0000446}
447
448static void raw_close(BlockDriverState *bs)
449{
450 BDRVRawState *s = bs->opaque;
Stefan Hajnoczi99cc5982014-05-08 16:34:49 +0200451
452 if (s->aio) {
Stefan Hajnoczi85ebd382014-05-08 16:34:50 +0200453 win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs));
Stefan Hajnoczi99cc5982014-05-08 16:34:49 +0200454 win32_aio_cleanup(s->aio);
455 s->aio = NULL;
456 }
457
ths223d4672007-12-15 17:28:36 +0000458 CloseHandle(s->hfile);
Kevin Wolf8bfea152014-04-11 19:16:36 +0200459 if (bs->open_flags & BDRV_O_TEMPORARY) {
460 unlink(bs->filename);
461 }
ths223d4672007-12-15 17:28:36 +0000462}
463
Max Reitz4bff28b2017-03-28 22:51:28 +0200464static int raw_truncate(BlockDriverState *bs, int64_t offset, Error **errp)
ths223d4672007-12-15 17:28:36 +0000465{
466 BDRVRawState *s = bs->opaque;
blueswir1b9e82a52009-04-05 18:03:31 +0000467 LONG low, high;
Fabien Chouteaufbcad042012-12-10 12:56:22 +0100468 DWORD dwPtrLow;
ths223d4672007-12-15 17:28:36 +0000469
470 low = offset;
471 high = offset >> 32;
Fabien Chouteaufbcad042012-12-10 12:56:22 +0100472
473 /*
474 * An error has occurred if the return value is INVALID_SET_FILE_POINTER
475 * and GetLastError doesn't return NO_ERROR.
476 */
477 dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN);
478 if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
Max Reitz4bff28b2017-03-28 22:51:28 +0200479 error_setg_win32(errp, GetLastError(), "SetFilePointer error");
ths223d4672007-12-15 17:28:36 +0000480 return -EIO;
Fabien Chouteaufbcad042012-12-10 12:56:22 +0100481 }
482 if (SetEndOfFile(s->hfile) == 0) {
Max Reitz4bff28b2017-03-28 22:51:28 +0200483 error_setg_win32(errp, GetLastError(), "SetEndOfFile error");
Fabien Chouteaufbcad042012-12-10 12:56:22 +0100484 return -EIO;
485 }
ths223d4672007-12-15 17:28:36 +0000486 return 0;
487}
488
489static int64_t raw_getlength(BlockDriverState *bs)
490{
491 BDRVRawState *s = bs->opaque;
492 LARGE_INTEGER l;
493 ULARGE_INTEGER available, total, total_free;
494 DISK_GEOMETRY_EX dg;
495 DWORD count;
496 BOOL status;
497
498 switch(s->type) {
499 case FTYPE_FILE:
blueswir1b9e82a52009-04-05 18:03:31 +0000500 l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart);
ths223d4672007-12-15 17:28:36 +0000501 if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR)
502 return -EIO;
503 break;
504 case FTYPE_CD:
505 if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free))
506 return -EIO;
507 l.QuadPart = total.QuadPart;
508 break;
509 case FTYPE_HARDDISK:
510 status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
511 NULL, 0, &dg, sizeof(dg), &count, NULL);
512 if (status != 0) {
513 l = dg.DiskSize;
514 }
515 break;
516 default:
517 return -EIO;
518 }
519 return l.QuadPart;
520}
521
Fam Zheng4a1d5e12011-07-12 19:56:39 +0800522static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
523{
524 typedef DWORD (WINAPI * get_compressed_t)(const char *filename,
525 DWORD * high);
526 get_compressed_t get_compressed;
527 struct _stati64 st;
528 const char *filename = bs->filename;
529 /* WinNT support GetCompressedFileSize to determine allocate size */
530 get_compressed =
531 (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"),
532 "GetCompressedFileSizeA");
533 if (get_compressed) {
534 DWORD high, low;
535 low = get_compressed(filename, &high);
536 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) {
537 return (((int64_t) high) << 32) + low;
538 }
539 }
540
541 if (_stati64(filename, &st) < 0) {
542 return -1;
543 }
544 return st.st_size;
545}
546
Chunyan Liuddef7692014-06-05 17:21:02 +0800547static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
ths223d4672007-12-15 17:28:36 +0000548{
549 int fd;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200550 int64_t total_size = 0;
ths223d4672007-12-15 17:28:36 +0000551
Max Reitzd5546c52014-03-05 22:41:40 +0100552 strstart(filename, "file:", &filename);
553
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200554 /* Read out options */
Hu Tao180e9522014-09-10 17:05:46 +0800555 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
556 BDRV_SECTOR_SIZE);
ths223d4672007-12-15 17:28:36 +0000557
Corey Bryant6165f4d2012-08-14 16:43:45 -0400558 fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
559 0644);
Max Reitzc6252b72013-10-10 15:44:02 +0200560 if (fd < 0) {
561 error_setg_errno(errp, errno, "Could not create file");
ths223d4672007-12-15 17:28:36 +0000562 return -EIO;
Max Reitzc6252b72013-10-10 15:44:02 +0200563 }
ths223d4672007-12-15 17:28:36 +0000564 set_sparse(fd);
Hu Tao180e9522014-09-10 17:05:46 +0800565 ftruncate(fd, total_size);
Corey Bryant2e1e79d2012-08-14 16:43:46 -0400566 qemu_close(fd);
ths223d4672007-12-15 17:28:36 +0000567 return 0;
568}
569
Chunyan Liuddef7692014-06-05 17:21:02 +0800570
571static QemuOptsList raw_create_opts = {
572 .name = "raw-create-opts",
573 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
574 .desc = {
575 {
576 .name = BLOCK_OPT_SIZE,
577 .type = QEMU_OPT_SIZE,
578 .help = "Virtual disk size"
579 },
580 { /* end of list */ }
581 }
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200582};
583
Max Reitz5f535a92014-12-02 18:32:41 +0100584BlockDriver bdrv_file = {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200585 .format_name = "file",
586 .protocol_name = "file",
aliguorif1b2f712009-04-07 18:23:51 +0000587 .instance_size = sizeof(BDRVRawState),
BenoƮt Canet030be322013-09-24 17:07:04 +0200588 .bdrv_needs_filename = true,
Max Reitz7dc74db2014-03-05 22:41:39 +0100589 .bdrv_parse_filename = raw_parse_filename,
Chunyan Liuddef7692014-06-05 17:21:02 +0800590 .bdrv_file_open = raw_open,
Eric Blake2914a1d2016-06-23 16:37:16 -0600591 .bdrv_refresh_limits = raw_probe_alignment,
Chunyan Liuddef7692014-06-05 17:21:02 +0800592 .bdrv_close = raw_close,
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800593 .bdrv_create = raw_create,
Peter Lieven3ac21622013-06-28 12:47:42 +0200594 .bdrv_has_zero_init = bdrv_has_zero_init_1,
Kevin Wolfc68b89a2011-11-10 17:25:44 +0100595
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200596 .bdrv_aio_readv = raw_aio_readv,
597 .bdrv_aio_writev = raw_aio_writev,
598 .bdrv_aio_flush = raw_aio_flush,
Kevin Wolfc68b89a2011-11-10 17:25:44 +0100599
aliguorif1b2f712009-04-07 18:23:51 +0000600 .bdrv_truncate = raw_truncate,
601 .bdrv_getlength = raw_getlength,
Fam Zheng4a1d5e12011-07-12 19:56:39 +0800602 .bdrv_get_allocated_file_size
603 = raw_get_allocated_file_size,
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200604
Chunyan Liuddef7692014-06-05 17:21:02 +0800605 .create_opts = &raw_create_opts,
ths223d4672007-12-15 17:28:36 +0000606};
607
608/***********************************************/
609/* host device */
610
611static int find_cdrom(char *cdrom_name, int cdrom_name_size)
612{
613 char drives[256], *pdrv = drives;
614 UINT type;
615
616 memset(drives, 0, sizeof(drives));
617 GetLogicalDriveStrings(sizeof(drives), drives);
618 while(pdrv[0] != '\0') {
619 type = GetDriveType(pdrv);
620 switch(type) {
621 case DRIVE_CDROM:
622 snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]);
623 return 0;
624 break;
625 }
626 pdrv += lstrlen(pdrv) + 1;
627 }
628 return -1;
629}
630
631static int find_device_type(BlockDriverState *bs, const char *filename)
632{
633 BDRVRawState *s = bs->opaque;
634 UINT type;
635 const char *p;
636
637 if (strstart(filename, "\\\\.\\", &p) ||
638 strstart(filename, "//./", &p)) {
639 if (stristart(p, "PhysicalDrive", NULL))
640 return FTYPE_HARDDISK;
641 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]);
642 type = GetDriveType(s->drive_path);
aliguori3060cd12009-04-07 01:24:53 +0000643 switch (type) {
644 case DRIVE_REMOVABLE:
645 case DRIVE_FIXED:
646 return FTYPE_HARDDISK;
647 case DRIVE_CDROM:
ths223d4672007-12-15 17:28:36 +0000648 return FTYPE_CD;
aliguori3060cd12009-04-07 01:24:53 +0000649 default:
ths223d4672007-12-15 17:28:36 +0000650 return FTYPE_FILE;
aliguori3060cd12009-04-07 01:24:53 +0000651 }
ths223d4672007-12-15 17:28:36 +0000652 } else {
653 return FTYPE_FILE;
654 }
655}
656
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200657static int hdev_probe_device(const char *filename)
658{
659 if (strstart(filename, "/dev/cdrom", NULL))
660 return 100;
661 if (is_windows_drive(filename))
662 return 100;
663 return 0;
664}
665
Max Reitz57ed25b2014-03-08 00:39:45 +0100666static void hdev_parse_filename(const char *filename, QDict *options,
667 Error **errp)
668{
Max Reitz03c320d2017-05-22 21:52:16 +0200669 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
Max Reitz57ed25b2014-03-08 00:39:45 +0100670}
671
Max Reitz015a1032013-09-05 14:22:29 +0200672static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
673 Error **errp)
ths223d4672007-12-15 17:28:36 +0000674{
675 BDRVRawState *s = bs->opaque;
676 int access_flags, create_flags;
Stefan Weil68dc0362013-09-01 22:59:25 +0200677 int ret = 0;
ths223d4672007-12-15 17:28:36 +0000678 DWORD overlapped;
679 char device_name[64];
Stefan Weil68dc0362013-09-01 22:59:25 +0200680
681 Error *local_err = NULL;
682 const char *filename;
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200683 bool use_aio;
Stefan Weil68dc0362013-09-01 22:59:25 +0200684
Peter Crosthwaite87ea75d2014-01-01 18:49:17 -0800685 QemuOpts *opts = qemu_opts_create(&raw_runtime_opts, NULL, 0,
686 &error_abort);
Stefan Weil68dc0362013-09-01 22:59:25 +0200687 qemu_opts_absorb_qdict(opts, options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100688 if (local_err) {
Max Reitzc6252b72013-10-10 15:44:02 +0200689 error_propagate(errp, local_err);
Stefan Weil68dc0362013-09-01 22:59:25 +0200690 ret = -EINVAL;
691 goto done;
692 }
693
694 filename = qemu_opt_get(opts, "filename");
ths223d4672007-12-15 17:28:36 +0000695
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200696 use_aio = get_aio_option(opts, flags, &local_err);
697 if (!local_err && use_aio) {
698 error_setg(&local_err, "AIO is not supported on Windows host devices");
699 }
700 if (local_err) {
701 error_propagate(errp, local_err);
702 ret = -EINVAL;
703 goto done;
704 }
705
ths223d4672007-12-15 17:28:36 +0000706 if (strstart(filename, "/dev/cdrom", NULL)) {
Stefan Weil68dc0362013-09-01 22:59:25 +0200707 if (find_cdrom(device_name, sizeof(device_name)) < 0) {
Max Reitzc6252b72013-10-10 15:44:02 +0200708 error_setg(errp, "Could not open CD-ROM drive");
Stefan Weil68dc0362013-09-01 22:59:25 +0200709 ret = -ENOENT;
710 goto done;
711 }
ths223d4672007-12-15 17:28:36 +0000712 filename = device_name;
713 } else {
714 /* transform drive letters into device name */
715 if (((filename[0] >= 'a' && filename[0] <= 'z') ||
716 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
717 filename[1] == ':' && filename[2] == '\0') {
718 snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]);
719 filename = device_name;
720 }
721 }
722 s->type = find_device_type(bs, filename);
723
Kevin Wolf0a4279d2016-09-08 15:09:01 +0200724 raw_parse_flags(flags, use_aio, &access_flags, &overlapped);
Jeff Cody6a8dc042012-09-20 15:13:21 -0400725
ths223d4672007-12-15 17:28:36 +0000726 create_flags = OPEN_EXISTING;
727
ths223d4672007-12-15 17:28:36 +0000728 s->hfile = CreateFile(filename, access_flags,
729 FILE_SHARE_READ, NULL,
730 create_flags, overlapped, NULL);
731 if (s->hfile == INVALID_HANDLE_VALUE) {
732 int err = GetLastError();
733
Stefan Weil68dc0362013-09-01 22:59:25 +0200734 if (err == ERROR_ACCESS_DENIED) {
735 ret = -EACCES;
736 } else {
Max Reitz45d57f62013-10-11 14:30:16 +0200737 ret = -EINVAL;
Stefan Weil68dc0362013-09-01 22:59:25 +0200738 }
Max Reitz45d57f62013-10-11 14:30:16 +0200739 error_setg_errno(errp, -ret, "Could not open device");
Stefan Weil68dc0362013-09-01 22:59:25 +0200740 goto done;
ths223d4672007-12-15 17:28:36 +0000741 }
Stefan Weil68dc0362013-09-01 22:59:25 +0200742
743done:
744 qemu_opts_del(opts);
745 return ret;
ths223d4672007-12-15 17:28:36 +0000746}
747
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500748static BlockDriver bdrv_host_device = {
aurel32e60f4692009-03-07 22:00:29 +0000749 .format_name = "host_device",
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200750 .protocol_name = "host_device",
aurel32e60f4692009-03-07 22:00:29 +0000751 .instance_size = sizeof(BDRVRawState),
BenoƮt Canet030be322013-09-24 17:07:04 +0200752 .bdrv_needs_filename = true,
Max Reitz57ed25b2014-03-08 00:39:45 +0100753 .bdrv_parse_filename = hdev_parse_filename,
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200754 .bdrv_probe_device = hdev_probe_device,
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200755 .bdrv_file_open = hdev_open,
aurel32e60f4692009-03-07 22:00:29 +0000756 .bdrv_close = raw_close,
ths223d4672007-12-15 17:28:36 +0000757
Paolo Bonzinifc4edb82012-06-09 04:48:28 +0200758 .bdrv_aio_readv = raw_aio_readv,
759 .bdrv_aio_writev = raw_aio_writev,
760 .bdrv_aio_flush = raw_aio_flush,
Kevin Wolfc68b89a2011-11-10 17:25:44 +0100761
Stefan Hajnoczi85ebd382014-05-08 16:34:50 +0200762 .bdrv_detach_aio_context = raw_detach_aio_context,
763 .bdrv_attach_aio_context = raw_attach_aio_context,
764
Kevin Wolfb94a2612013-10-29 12:18:58 +0100765 .bdrv_getlength = raw_getlength,
766 .has_variable_length = true,
767
Fam Zheng4a1d5e12011-07-12 19:56:39 +0800768 .bdrv_get_allocated_file_size
769 = raw_get_allocated_file_size,
ths223d4672007-12-15 17:28:36 +0000770};
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500771
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200772static void bdrv_file_init(void)
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500773{
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200774 bdrv_register(&bdrv_file);
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500775 bdrv_register(&bdrv_host_device);
776}
777
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200778block_init(bdrv_file_init);