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 "block/block_int.h"
28#include "qemu/module.h"
29#include "block/raw-aio.h"
30#include "trace.h"
31#include "block/thread-pool.h"
32#include "qemu/iov.h"
33#include "qapi/qmp/qstring.h"
34#include "qapi/util.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, bool use_aio, int *access_flags,
256 DWORD *overlapped)
257{
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;
268 if (use_aio) {
269 *overlapped |= FILE_FLAG_OVERLAPPED;
270 }
271 if (flags & BDRV_O_NOCACHE) {
272 *overlapped |= FILE_FLAG_NO_BUFFERING;
273 }
274}
275
276static void raw_parse_filename(const char *filename, QDict *options,
277 Error **errp)
278{
279 bdrv_parse_filename_strip_prefix(filename, "file:", options);
280}
281
282static 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 },
291 {
292 .name = "aio",
293 .type = QEMU_OPT_STRING,
294 .help = "host AIO implementation (threads, native)",
295 },
296 { }
297 },
298};
299
300static 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
320static int raw_open(BlockDriverState *bs, QDict *options, int flags,
321 Error **errp)
322{
323 BDRVRawState *s = bs->opaque;
324 int access_flags;
325 DWORD overlapped;
326 QemuOpts *opts;
327 Error *local_err = NULL;
328 const char *filename;
329 bool use_aio;
330 int ret;
331
332 s->type = FTYPE_FILE;
333
334 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
335 qemu_opts_absorb_qdict(opts, options, &local_err);
336 if (local_err) {
337 error_propagate(errp, local_err);
338 ret = -EINVAL;
339 goto fail;
340 }
341
342 if (qdict_get_try_bool(options, "locking", false)) {
343 error_setg(errp, "locking=on is not supported on Windows");
344 ret = -EINVAL;
345 goto fail;
346 }
347
348 filename = qemu_opt_get(opts, "filename");
349
350 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);
358
359 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
365 char buf[MAX_PATH];
366 GetCurrentDirectory(MAX_PATH, buf);
367 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", buf[0]);
368 }
369
370 s->hfile = CreateFile(filename, access_flags,
371 FILE_SHARE_READ, NULL,
372 OPEN_EXISTING, overlapped, NULL);
373 if (s->hfile == INVALID_HANDLE_VALUE) {
374 int err = GetLastError();
375
376 error_setg_win32(errp, err, "Could not open '%s'", filename);
377 if (err == ERROR_ACCESS_DENIED) {
378 ret = -EACCES;
379 } else {
380 ret = -EINVAL;
381 }
382 goto fail;
383 }
384
385 if (use_aio) {
386 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);
395 if (ret < 0) {
396 win32_aio_cleanup(s->aio);
397 CloseHandle(s->hfile);
398 error_setg_errno(errp, -ret, "Could not enable AIO");
399 goto fail;
400 }
401
402 win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs));
403 }
404
405 ret = 0;
406fail:
407 qemu_opts_del(opts);
408 return ret;
409}
410
411static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
412 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
413 BlockCompletionFunc *cb, void *opaque)
414{
415 BDRVRawState *s = bs->opaque;
416 if (s->aio) {
417 return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov,
418 nb_sectors, cb, opaque, QEMU_AIO_READ);
419 } else {
420 return paio_submit(bs, s->hfile, sector_num << BDRV_SECTOR_BITS, qiov,
421 nb_sectors << BDRV_SECTOR_BITS,
422 cb, opaque, QEMU_AIO_READ);
423 }
424}
425
426static BlockAIOCB *raw_aio_writev(BlockDriverState *bs,
427 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
428 BlockCompletionFunc *cb, void *opaque)
429{
430 BDRVRawState *s = bs->opaque;
431 if (s->aio) {
432 return win32_aio_submit(bs, s->aio, s->hfile, sector_num, qiov,
433 nb_sectors, cb, opaque, QEMU_AIO_WRITE);
434 } else {
435 return paio_submit(bs, s->hfile, sector_num << BDRV_SECTOR_BITS, qiov,
436 nb_sectors << BDRV_SECTOR_BITS,
437 cb, opaque, QEMU_AIO_WRITE);
438 }
439}
440
441static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
442 BlockCompletionFunc *cb, void *opaque)
443{
444 BDRVRawState *s = bs->opaque;
445 return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
446}
447
448static void raw_close(BlockDriverState *bs)
449{
450 BDRVRawState *s = bs->opaque;
451
452 if (s->aio) {
453 win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs));
454 win32_aio_cleanup(s->aio);
455 s->aio = NULL;
456 }
457
458 CloseHandle(s->hfile);
459 if (bs->open_flags & BDRV_O_TEMPORARY) {
460 unlink(bs->filename);
461 }
462}
463
464static int raw_truncate(BlockDriverState *bs, int64_t offset,
465 PreallocMode prealloc, Error **errp)
466{
467 BDRVRawState *s = bs->opaque;
468 LONG low, high;
469 DWORD dwPtrLow;
470
471 if (prealloc != PREALLOC_MODE_OFF) {
472 error_setg(errp, "Unsupported preallocation mode '%s'",
473 PreallocMode_lookup[prealloc]);
474 return -ENOTSUP;
475 }
476
477 low = offset;
478 high = offset >> 32;
479
480
481
482
483
484 dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN);
485 if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
486 error_setg_win32(errp, GetLastError(), "SetFilePointer error");
487 return -EIO;
488 }
489 if (SetEndOfFile(s->hfile) == 0) {
490 error_setg_win32(errp, GetLastError(), "SetEndOfFile error");
491 return -EIO;
492 }
493 return 0;
494}
495
496static int64_t raw_getlength(BlockDriverState *bs)
497{
498 BDRVRawState *s = bs->opaque;
499 LARGE_INTEGER l;
500 ULARGE_INTEGER available, total, total_free;
501 DISK_GEOMETRY_EX dg;
502 DWORD count;
503 BOOL status;
504
505 switch(s->type) {
506 case FTYPE_FILE:
507 l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart);
508 if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR)
509 return -EIO;
510 break;
511 case FTYPE_CD:
512 if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free))
513 return -EIO;
514 l.QuadPart = total.QuadPart;
515 break;
516 case FTYPE_HARDDISK:
517 status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
518 NULL, 0, &dg, sizeof(dg), &count, NULL);
519 if (status != 0) {
520 l = dg.DiskSize;
521 }
522 break;
523 default:
524 return -EIO;
525 }
526 return l.QuadPart;
527}
528
529static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
530{
531 typedef DWORD (WINAPI * get_compressed_t)(const char *filename,
532 DWORD * high);
533 get_compressed_t get_compressed;
534 struct _stati64 st;
535 const char *filename = bs->filename;
536
537 get_compressed =
538 (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"),
539 "GetCompressedFileSizeA");
540 if (get_compressed) {
541 DWORD high, low;
542 low = get_compressed(filename, &high);
543 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) {
544 return (((int64_t) high) << 32) + low;
545 }
546 }
547
548 if (_stati64(filename, &st) < 0) {
549 return -1;
550 }
551 return st.st_size;
552}
553
554static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
555{
556 int fd;
557 int64_t total_size = 0;
558
559 strstart(filename, "file:", &filename);
560
561
562 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
563 BDRV_SECTOR_SIZE);
564
565 fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
566 0644);
567 if (fd < 0) {
568 error_setg_errno(errp, errno, "Could not create file");
569 return -EIO;
570 }
571 set_sparse(fd);
572 ftruncate(fd, total_size);
573 qemu_close(fd);
574 return 0;
575}
576
577
578static QemuOptsList raw_create_opts = {
579 .name = "raw-create-opts",
580 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
581 .desc = {
582 {
583 .name = BLOCK_OPT_SIZE,
584 .type = QEMU_OPT_SIZE,
585 .help = "Virtual disk size"
586 },
587 { }
588 }
589};
590
591BlockDriver bdrv_file = {
592 .format_name = "file",
593 .protocol_name = "file",
594 .instance_size = sizeof(BDRVRawState),
595 .bdrv_needs_filename = true,
596 .bdrv_parse_filename = raw_parse_filename,
597 .bdrv_file_open = raw_open,
598 .bdrv_refresh_limits = raw_probe_alignment,
599 .bdrv_close = raw_close,
600 .bdrv_create = raw_create,
601 .bdrv_has_zero_init = bdrv_has_zero_init_1,
602
603 .bdrv_aio_readv = raw_aio_readv,
604 .bdrv_aio_writev = raw_aio_writev,
605 .bdrv_aio_flush = raw_aio_flush,
606
607 .bdrv_truncate = raw_truncate,
608 .bdrv_getlength = raw_getlength,
609 .bdrv_get_allocated_file_size
610 = raw_get_allocated_file_size,
611
612 .create_opts = &raw_create_opts,
613};
614
615
616
617
618static int find_cdrom(char *cdrom_name, int cdrom_name_size)
619{
620 char drives[256], *pdrv = drives;
621 UINT type;
622
623 memset(drives, 0, sizeof(drives));
624 GetLogicalDriveStrings(sizeof(drives), drives);
625 while(pdrv[0] != '\0') {
626 type = GetDriveType(pdrv);
627 switch(type) {
628 case DRIVE_CDROM:
629 snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]);
630 return 0;
631 break;
632 }
633 pdrv += lstrlen(pdrv) + 1;
634 }
635 return -1;
636}
637
638static int find_device_type(BlockDriverState *bs, const char *filename)
639{
640 BDRVRawState *s = bs->opaque;
641 UINT type;
642 const char *p;
643
644 if (strstart(filename, "\\\\.\\", &p) ||
645 strstart(filename, "//./", &p)) {
646 if (stristart(p, "PhysicalDrive", NULL))
647 return FTYPE_HARDDISK;
648 snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]);
649 type = GetDriveType(s->drive_path);
650 switch (type) {
651 case DRIVE_REMOVABLE:
652 case DRIVE_FIXED:
653 return FTYPE_HARDDISK;
654 case DRIVE_CDROM:
655 return FTYPE_CD;
656 default:
657 return FTYPE_FILE;
658 }
659 } else {
660 return FTYPE_FILE;
661 }
662}
663
664static int hdev_probe_device(const char *filename)
665{
666 if (strstart(filename, "/dev/cdrom", NULL))
667 return 100;
668 if (is_windows_drive(filename))
669 return 100;
670 return 0;
671}
672
673static void hdev_parse_filename(const char *filename, QDict *options,
674 Error **errp)
675{
676 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
677}
678
679static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
680 Error **errp)
681{
682 BDRVRawState *s = bs->opaque;
683 int access_flags, create_flags;
684 int ret = 0;
685 DWORD overlapped;
686 char device_name[64];
687
688 Error *local_err = NULL;
689 const char *filename;
690 bool use_aio;
691
692 QemuOpts *opts = qemu_opts_create(&raw_runtime_opts, NULL, 0,
693 &error_abort);
694 qemu_opts_absorb_qdict(opts, options, &local_err);
695 if (local_err) {
696 error_propagate(errp, local_err);
697 ret = -EINVAL;
698 goto done;
699 }
700
701 filename = qemu_opt_get(opts, "filename");
702
703 use_aio = get_aio_option(opts, flags, &local_err);
704 if (!local_err && use_aio) {
705 error_setg(&local_err, "AIO is not supported on Windows host devices");
706 }
707 if (local_err) {
708 error_propagate(errp, local_err);
709 ret = -EINVAL;
710 goto done;
711 }
712
713 if (strstart(filename, "/dev/cdrom", NULL)) {
714 if (find_cdrom(device_name, sizeof(device_name)) < 0) {
715 error_setg(errp, "Could not open CD-ROM drive");
716 ret = -ENOENT;
717 goto done;
718 }
719 filename = device_name;
720 } else {
721
722 if (((filename[0] >= 'a' && filename[0] <= 'z') ||
723 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
724 filename[1] == ':' && filename[2] == '\0') {
725 snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]);
726 filename = device_name;
727 }
728 }
729 s->type = find_device_type(bs, filename);
730
731 raw_parse_flags(flags, use_aio, &access_flags, &overlapped);
732
733 create_flags = OPEN_EXISTING;
734
735 s->hfile = CreateFile(filename, access_flags,
736 FILE_SHARE_READ, NULL,
737 create_flags, overlapped, NULL);
738 if (s->hfile == INVALID_HANDLE_VALUE) {
739 int err = GetLastError();
740
741 if (err == ERROR_ACCESS_DENIED) {
742 ret = -EACCES;
743 } else {
744 ret = -EINVAL;
745 }
746 error_setg_errno(errp, -ret, "Could not open device");
747 goto done;
748 }
749
750done:
751 qemu_opts_del(opts);
752 return ret;
753}
754
755static BlockDriver bdrv_host_device = {
756 .format_name = "host_device",
757 .protocol_name = "host_device",
758 .instance_size = sizeof(BDRVRawState),
759 .bdrv_needs_filename = true,
760 .bdrv_parse_filename = hdev_parse_filename,
761 .bdrv_probe_device = hdev_probe_device,
762 .bdrv_file_open = hdev_open,
763 .bdrv_close = raw_close,
764
765 .bdrv_aio_readv = raw_aio_readv,
766 .bdrv_aio_writev = raw_aio_writev,
767 .bdrv_aio_flush = raw_aio_flush,
768
769 .bdrv_detach_aio_context = raw_detach_aio_context,
770 .bdrv_attach_aio_context = raw_attach_aio_context,
771
772 .bdrv_getlength = raw_getlength,
773 .has_variable_length = true,
774
775 .bdrv_get_allocated_file_size
776 = raw_get_allocated_file_size,
777};
778
779static void bdrv_file_init(void)
780{
781 bdrv_register(&bdrv_file);
782 bdrv_register(&bdrv_host_device);
783}
784
785block_init(bdrv_file_init);
786
