1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "qapi/error.h"
26#include "qemu/cutils.h"
27#include "qemu/timer.h"
28#include "block/block_int.h"
29#include "qemu/module.h"
30#include "block/raw-aio.h"
31#include "trace.h"
32#include "block/thread-pool.h"
33#include "qemu/iov.h"
34#include "qapi/qmp/qstring.h"
35#include <windows.h>
36#include <winioctl.h>
37
38#define FTYPE_FILE 0
39#define FTYPE_CD 1
40#define FTYPE_HARDDISK 2
41
42typedef 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
52typedef struct BDRVRawState {
53 HANDLE hfile;
54 int type;
55 char drive_path[16];
56 QEMUWin32AIOState *aio;
57} BDRVRawState;
58
59
60
61
62
63
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) {
89 offset += ret_count;
90 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);
107 if (count < aiocb->aio_nbytes) {
108
109
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) {
124 ret = 0;
125 } else {
126 ret = -EINVAL;
127 }
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
140 g_free(aiocb);
141 return ret;
142}
143
144static BlockAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile,
145 int64_t offset, QEMUIOVector *qiov, int count,
146 BlockCompletionFunc *cb, void *opaque, int type)
147{
148 RawWin32AIOData *acb = g_new(RawWin32AIOData, 1);
149 ThreadPool *pool;
150
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;
158 assert(qiov->size == count);
159 }
160 acb->aio_nbytes = count;
161 acb->aio_offset = offset;
162
163 trace_paio_submit(acb, opaque, offset, count, type);
164 pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
165 return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
166}
167
168int qemu_ftruncate64(int fd, int64_t length)
169{
170 LARGE_INTEGER li;
171 DWORD dw;
172 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
182 li.HighPart = 0;
183 li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT);
184 if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
185 return -1;
186 }
187
188 high = length >> 32;
189 dw = SetFilePointer(h, (DWORD) length, &high, FILE_BEGIN);
190 if (dw == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
191 return -1;
192 }
193 res = SetEndOfFile(h);
194
195
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
207static 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
226static void raw_probe_alignment(BlockDriverState *bs, Error **errp)
227{
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) {
234 bs->bl.request_alignment = 2048;
235 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) {
241 bs->bl.request_alignment = dg.Geometry.BytesPerSector;
242 return;
243 }
244
245 }
246
247 if (s->drive_path[0]) {
248 GetDiskFreeSpace(s->drive_path, §orsPerCluster,
249 &dg.Geometry.BytesPerSector,
250 &freeClusters, &totalClusters);
251 bs->bl.request_alignment = dg.Geometry.BytesPerSector;
252 }
253}
254
255static void raw_parse_flags(int flags, int *access_flags, DWORD *overlapped)
256{
257 assert(access_flags != NULL);
258 assert(overlapped != NULL);
259
260 if (flags & BDRV_O_RDWR) {
261 *access_flags = GENERIC_READ | GENERIC_WRITE;
262 } else {
263 *access_flags = GENERIC_READ;
264 }
265
266 *overlapped = FILE_ATTRIBUTE_NORMAL;
267 if (flags & BDRV_O_NATIVE_AIO) {
268 *overlapped |= FILE_FLAG_OVERLAPPED;
269 }
270 if (flags & BDRV_O_NOCACHE) {
271 *overlapped |= FILE_FLAG_NO_BUFFERING;
272 }
273}
274
275static void raw_parse_filename(const char *filename, QDict *options,
276 Error **errp)
277{
278
279
280
281 strstart(filename, "file:", &filename);
282
283 qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
284}
285
286static QemuOptsList raw_runtime_opts = {
287 .name = "raw",
288 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
289 .desc = {
290 {
291 .name = "filename",
292 .type = QEMU_OPT_STRING,
293 .help = "File name of the image",
294 },
295 { }
296 },
297};
298
299static int raw_open(BlockDriverState *bs, QDict *options, int flags,
300 Error **errp)
301{
302 BDRVRawState *s = bs->opaque;
303 int access_flags;
304 DWORD overlapped;
305 QemuOpts *opts;
306 Error *local_err = NULL;
307 const char *filename;
308 int ret;
309
310 s->type = FTYPE_FILE;
311
312 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
313 qemu_opts_absorb_qdict(opts, options, &local_err);
314 if (local_err) {
315 error_propagate(errp, local_err);
316 ret = -EINVAL;
317 goto fail;
318 }
319
320 filename = qemu_opt_get(opts, "filename");
321
322 raw_parse_flags(flags, &access_flags, &overlapped);
323
324 if (filename[0] && filename[1] == ':') {
325 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", filename[0]);
326 } else if (filename[0] == '\\' && filename[1] == '\\') {
327 s->drive_path[0] = 0;
328 } else {
329
330 char buf[MAX_PATH];
331 GetCurrentDirectory(MAX_PATH, buf);
332 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", buf[0]);
333 }
334
335 s->hfile = CreateFile(filename, access_flags,
336 FILE_SHARE_READ, NULL,
337 OPEN_EXISTING, overlapped, NULL);
338 if (s->hfile == INVALID_HANDLE_VALUE) {
339 int err = GetLastError();
340
341 if (err == ERROR_ACCESS_DENIED) {
342 ret = -EACCES;
343 } else {
344 ret = -EINVAL;
345 }
346 goto fail;
347 }
348
349 if (flags & BDRV_O_NATIVE_AIO) {
350 s->aio = win32_aio_init();
351 if (s->aio == NULL) {
352 CloseHandle(s->hfile);
353 error_setg(errp, "Could not initialize AIO");
354 ret = -EINVAL;
355 goto fail;
356 }
357
358 ret = win32_aio_attach(s->aio, s->hfile);
359 if (ret < 0) {
360 win32_aio_cleanup(s->aio);
361 CloseHandle(s->hfile);
362 error_setg_errno(errp, -ret, "Could not enable AIO");
363 goto fail;
364 }
365
366 win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs));
367 }
368
369 ret = 0;
370fail:
371 qemu_opts_del(opts);
372 return ret;
373}
374
375static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
376 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
377 BlockCompletionFunc *cb, void *opaque)
378{
379 BDRVRawState *s = bs->opaque;
380 if (s->aio) {
381 return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov,
382 nb_sectors, cb, opaque, QEMU_AIO_READ);
383 } else {
384 return paio_submit(bs, s->hfile, sector_num << BDRV_SECTOR_BITS, qiov,
385 nb_sectors << BDRV_SECTOR_BITS,
386 cb, opaque, QEMU_AIO_READ);
387 }
388}
389
390static BlockAIOCB *raw_aio_writev(BlockDriverState *bs,
391 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
392 BlockCompletionFunc *cb, void *opaque)
393{
394 BDRVRawState *s = bs->opaque;
395 if (s->aio) {
396 return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov,
397 nb_sectors, cb, opaque, QEMU_AIO_WRITE);
398 } else {
399 return paio_submit(bs, s->hfile, sector_num << BDRV_SECTOR_BITS, qiov,
400 nb_sectors << BDRV_SECTOR_BITS,
401 cb, opaque, QEMU_AIO_WRITE);
402 }
403}
404
405static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
406 BlockCompletionFunc *cb, void *opaque)
407{
408 BDRVRawState *s = bs->opaque;
409 return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
410}
411
412static void raw_close(BlockDriverState *bs)
413{
414 BDRVRawState *s = bs->opaque;
415
416 if (s->aio) {
417 win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs));
418 win32_aio_cleanup(s->aio);
419 s->aio = NULL;
420 }
421
422 CloseHandle(s->hfile);
423 if (bs->open_flags & BDRV_O_TEMPORARY) {
424 unlink(bs->filename);
425 }
426}
427
428static int raw_truncate(BlockDriverState *bs, int64_t offset)
429{
430 BDRVRawState *s = bs->opaque;
431 LONG low, high;
432 DWORD dwPtrLow;
433
434 low = offset;
435 high = offset >> 32;
436
437
438
439
440
441 dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN);
442 if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
443 fprintf(stderr, "SetFilePointer error: %lu\n", GetLastError());
444 return -EIO;
445 }
446 if (SetEndOfFile(s->hfile) == 0) {
447 fprintf(stderr, "SetEndOfFile error: %lu\n", GetLastError());
448 return -EIO;
449 }
450 return 0;
451}
452
453static int64_t raw_getlength(BlockDriverState *bs)
454{
455 BDRVRawState *s = bs->opaque;
456 LARGE_INTEGER l;
457 ULARGE_INTEGER available, total, total_free;
458 DISK_GEOMETRY_EX dg;
459 DWORD count;
460 BOOL status;
461
462 switch(s->type) {
463 case FTYPE_FILE:
464 l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart);
465 if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR)
466 return -EIO;
467 break;
468 case FTYPE_CD:
469 if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free))
470 return -EIO;
471 l.QuadPart = total.QuadPart;
472 break;
473 case FTYPE_HARDDISK:
474 status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
475 NULL, 0, &dg, sizeof(dg), &count, NULL);
476 if (status != 0) {
477 l = dg.DiskSize;
478 }
479 break;
480 default:
481 return -EIO;
482 }
483 return l.QuadPart;
484}
485
486static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
487{
488 typedef DWORD (WINAPI * get_compressed_t)(const char *filename,
489 DWORD * high);
490 get_compressed_t get_compressed;
491 struct _stati64 st;
492 const char *filename = bs->filename;
493
494 get_compressed =
495 (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"),
496 "GetCompressedFileSizeA");
497 if (get_compressed) {
498 DWORD high, low;
499 low = get_compressed(filename, &high);
500 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) {
501 return (((int64_t) high) << 32) + low;
502 }
503 }
504
505 if (_stati64(filename, &st) < 0) {
506 return -1;
507 }
508 return st.st_size;
509}
510
511static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
512{
513 int fd;
514 int64_t total_size = 0;
515
516 strstart(filename, "file:", &filename);
517
518
519 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
520 BDRV_SECTOR_SIZE);
521
522 fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
523 0644);
524 if (fd < 0) {
525 error_setg_errno(errp, errno, "Could not create file");
526 return -EIO;
527 }
528 set_sparse(fd);
529 ftruncate(fd, total_size);
530 qemu_close(fd);
531 return 0;
532}
533
534
535static QemuOptsList raw_create_opts = {
536 .name = "raw-create-opts",
537 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
538 .desc = {
539 {
540 .name = BLOCK_OPT_SIZE,
541 .type = QEMU_OPT_SIZE,
542 .help = "Virtual disk size"
543 },
544 { }
545 }
546};
547
548BlockDriver bdrv_file = {
549 .format_name = "file",
550 .protocol_name = "file",
551 .instance_size = sizeof(BDRVRawState),
552 .bdrv_needs_filename = true,
553 .bdrv_parse_filename = raw_parse_filename,
554 .bdrv_file_open = raw_open,
555 .bdrv_refresh_limits = raw_probe_alignment,
556 .bdrv_close = raw_close,
557 .bdrv_create = raw_create,
558 .bdrv_has_zero_init = bdrv_has_zero_init_1,
559
560 .bdrv_aio_readv = raw_aio_readv,
561 .bdrv_aio_writev = raw_aio_writev,
562 .bdrv_aio_flush = raw_aio_flush,
563
564 .bdrv_truncate = raw_truncate,
565 .bdrv_getlength = raw_getlength,
566 .bdrv_get_allocated_file_size
567 = raw_get_allocated_file_size,
568
569 .create_opts = &raw_create_opts,
570};
571
572
573
574
575static int find_cdrom(char *cdrom_name, int cdrom_name_size)
576{
577 char drives[256], *pdrv = drives;
578 UINT type;
579
580 memset(drives, 0, sizeof(drives));
581 GetLogicalDriveStrings(sizeof(drives), drives);
582 while(pdrv[0] != '\0') {
583 type = GetDriveType(pdrv);
584 switch(type) {
585 case DRIVE_CDROM:
586 snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]);
587 return 0;
588 break;
589 }
590 pdrv += lstrlen(pdrv) + 1;
591 }
592 return -1;
593}
594
595static int find_device_type(BlockDriverState *bs, const char *filename)
596{
597 BDRVRawState *s = bs->opaque;
598 UINT type;
599 const char *p;
600
601 if (strstart(filename, "\\\\.\\", &p) ||
602 strstart(filename, "//./", &p)) {
603 if (stristart(p, "PhysicalDrive", NULL))
604 return FTYPE_HARDDISK;
605 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]);
606 type = GetDriveType(s->drive_path);
607 switch (type) {
608 case DRIVE_REMOVABLE:
609 case DRIVE_FIXED:
610 return FTYPE_HARDDISK;
611 case DRIVE_CDROM:
612 return FTYPE_CD;
613 default:
614 return FTYPE_FILE;
615 }
616 } else {
617 return FTYPE_FILE;
618 }
619}
620
621static int hdev_probe_device(const char *filename)
622{
623 if (strstart(filename, "/dev/cdrom", NULL))
624 return 100;
625 if (is_windows_drive(filename))
626 return 100;
627 return 0;
628}
629
630static void hdev_parse_filename(const char *filename, QDict *options,
631 Error **errp)
632{
633
634 strstart(filename, "host_device:", &filename);
635
636 qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
637}
638
639static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
640 Error **errp)
641{
642 BDRVRawState *s = bs->opaque;
643 int access_flags, create_flags;
644 int ret = 0;
645 DWORD overlapped;
646 char device_name[64];
647
648 Error *local_err = NULL;
649 const char *filename;
650
651 QemuOpts *opts = qemu_opts_create(&raw_runtime_opts, NULL, 0,
652 &error_abort);
653 qemu_opts_absorb_qdict(opts, options, &local_err);
654 if (local_err) {
655 error_propagate(errp, local_err);
656 ret = -EINVAL;
657 goto done;
658 }
659
660 filename = qemu_opt_get(opts, "filename");
661
662 if (strstart(filename, "/dev/cdrom", NULL)) {
663 if (find_cdrom(device_name, sizeof(device_name)) < 0) {
664 error_setg(errp, "Could not open CD-ROM drive");
665 ret = -ENOENT;
666 goto done;
667 }
668 filename = device_name;
669 } else {
670
671 if (((filename[0] >= 'a' && filename[0] <= 'z') ||
672 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
673 filename[1] == ':' && filename[2] == '\0') {
674 snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]);
675 filename = device_name;
676 }
677 }
678 s->type = find_device_type(bs, filename);
679
680 raw_parse_flags(flags, &access_flags, &overlapped);
681
682 create_flags = OPEN_EXISTING;
683
684 s->hfile = CreateFile(filename, access_flags,
685 FILE_SHARE_READ, NULL,
686 create_flags, overlapped, NULL);
687 if (s->hfile == INVALID_HANDLE_VALUE) {
688 int err = GetLastError();
689
690 if (err == ERROR_ACCESS_DENIED) {
691 ret = -EACCES;
692 } else {
693 ret = -EINVAL;
694 }
695 error_setg_errno(errp, -ret, "Could not open device");
696 goto done;
697 }
698
699done:
700 qemu_opts_del(opts);
701 return ret;
702}
703
704static BlockDriver bdrv_host_device = {
705 .format_name = "host_device",
706 .protocol_name = "host_device",
707 .instance_size = sizeof(BDRVRawState),
708 .bdrv_needs_filename = true,
709 .bdrv_parse_filename = hdev_parse_filename,
710 .bdrv_probe_device = hdev_probe_device,
711 .bdrv_file_open = hdev_open,
712 .bdrv_close = raw_close,
713
714 .bdrv_aio_readv = raw_aio_readv,
715 .bdrv_aio_writev = raw_aio_writev,
716 .bdrv_aio_flush = raw_aio_flush,
717
718 .bdrv_detach_aio_context = raw_detach_aio_context,
719 .bdrv_attach_aio_context = raw_attach_aio_context,
720
721 .bdrv_getlength = raw_getlength,
722 .has_variable_length = true,
723
724 .bdrv_get_allocated_file_size
725 = raw_get_allocated_file_size,
726};
727
728static void bdrv_file_init(void)
729{
730 bdrv_register(&bdrv_file);
731 bdrv_register(&bdrv_host_device);
732}
733
734block_init(bdrv_file_init);
735