2 * Block driver for Connectix / Microsoft Virtual PC images
4 * Copyright (c) 2005 Alex Beregszaszi
5 * Copyright (c) 2009 Kevin Wolf <kwolf@suse.de>
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu-common.h"
26 #include "block/block_int.h"
27 #include "qemu/module.h"
28 #include "migration/migration.h"
29 #if defined(CONFIG_UUID)
30 #include <uuid/uuid.h>
33 /**************************************************************/
35 #define HEADER_SIZE 512
37 #define VHD_SECTOR_SIZE 512
47 // Seconds since Jan 1, 2000 0:00:00 (UTC)
48 #define VHD_TIMESTAMP_BASE 946684800
52 char creator
[8]; // "conectix"
56 // Offset of next header structure, 0xFFFFFFFF if none
59 // Seconds since Jan 1, 2000 0:00:00 (UTC)
62 char creator_app
[4]; // "vpc "
65 char creator_os
[4]; // "Wi2k"
76 // Checksum of the Hard Disk Footer ("one's complement of the sum of all
77 // the bytes in the footer without the checksum field")
80 // UUID used to identify a parent hard disk (backing file)
83 uint8_t in_saved_state
;
86 struct vhd_dyndisk_header
{
87 char magic
[8]; // "cxsparse"
89 // Offset of next header structure, 0xFFFFFFFF if none
92 // Offset of the Block Allocation Table (BAT)
93 uint64_t table_offset
;
96 uint32_t max_table_entries
; // 32bit/entry
98 // 2 MB by default, must be a power of two
102 uint8_t parent_uuid
[16];
103 uint32_t parent_timestamp
;
106 // Backing file name (in UTF-16)
107 uint8_t parent_name
[512];
112 uint32_t data_length
;
114 uint64_t data_offset
;
118 typedef struct BDRVVPCState
{
120 uint8_t footer_buf
[HEADER_SIZE
];
121 uint64_t free_data_block_offset
;
122 int max_table_entries
;
125 uint64_t last_bitmap_offset
;
128 uint32_t bitmap_size
;
131 uint8_t *pageentry_u8
;
132 uint32_t *pageentry_u32
;
133 uint16_t *pageentry_u16
;
135 uint64_t last_bitmap
;
138 Error
*migration_blocker
;
141 static uint32_t vpc_checksum(uint8_t* buf
, size_t size
)
146 for (i
= 0; i
< size
; i
++)
153 static int vpc_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
155 if (buf_size
>= 8 && !strncmp((char *)buf
, "conectix", 8))
160 static int vpc_open(BlockDriverState
*bs
, int flags
)
162 BDRVVPCState
*s
= bs
->opaque
;
164 struct vhd_footer
* footer
;
165 struct vhd_dyndisk_header
* dyndisk_header
;
166 uint8_t buf
[HEADER_SIZE
];
168 int disk_type
= VHD_DYNAMIC
;
171 ret
= bdrv_pread(bs
->file
, 0, s
->footer_buf
, HEADER_SIZE
);
176 footer
= (struct vhd_footer
*) s
->footer_buf
;
177 if (strncmp(footer
->creator
, "conectix", 8)) {
178 int64_t offset
= bdrv_getlength(bs
->file
);
182 } else if (offset
< HEADER_SIZE
) {
187 /* If a fixed disk, the footer is found only at the end of the file */
188 ret
= bdrv_pread(bs
->file
, offset
-HEADER_SIZE
, s
->footer_buf
,
193 if (strncmp(footer
->creator
, "conectix", 8)) {
197 disk_type
= VHD_FIXED
;
200 checksum
= be32_to_cpu(footer
->checksum
);
201 footer
->checksum
= 0;
202 if (vpc_checksum(s
->footer_buf
, HEADER_SIZE
) != checksum
)
203 fprintf(stderr
, "block-vpc: The header checksum of '%s' is "
204 "incorrect.\n", bs
->filename
);
206 /* Write 'checksum' back to footer, or else will leave it with zero. */
207 footer
->checksum
= be32_to_cpu(checksum
);
209 /* The visible size of a image in Virtual PC depends on the guest:
210 * QEMU and other emulators report the real size (here in sectors).
211 * All modern operating systems use this real size.
212 * Very old operating systems use CHS values to calculate the total size.
213 * This calculated size is usually smaller than the real size.
215 bs
->total_sectors
= be64_to_cpu(footer
->size
) / VHD_SECTOR_SIZE
;
217 /* Allow a maximum disk size of approximately 2 TB */
218 if (bs
->total_sectors
>= 65535LL * 255 * 255) {
223 if (disk_type
== VHD_DYNAMIC
) {
224 ret
= bdrv_pread(bs
->file
, be64_to_cpu(footer
->data_offset
), buf
,
230 dyndisk_header
= (struct vhd_dyndisk_header
*) buf
;
232 if (strncmp(dyndisk_header
->magic
, "cxsparse", 8)) {
237 s
->block_size
= be32_to_cpu(dyndisk_header
->block_size
);
238 s
->bitmap_size
= ((s
->block_size
/ (8 * 512)) + 511) & ~511;
240 s
->max_table_entries
= be32_to_cpu(dyndisk_header
->max_table_entries
);
241 s
->pagetable
= g_malloc(s
->max_table_entries
* 4);
243 s
->bat_offset
= be64_to_cpu(dyndisk_header
->table_offset
);
245 ret
= bdrv_pread(bs
->file
, s
->bat_offset
, s
->pagetable
,
246 s
->max_table_entries
* 4);
251 s
->free_data_block_offset
=
252 (s
->bat_offset
+ (s
->max_table_entries
* 4) + 511) & ~511;
254 for (i
= 0; i
< s
->max_table_entries
; i
++) {
255 be32_to_cpus(&s
->pagetable
[i
]);
256 if (s
->pagetable
[i
] != 0xFFFFFFFF) {
257 int64_t next
= (512 * (int64_t) s
->pagetable
[i
]) +
258 s
->bitmap_size
+ s
->block_size
;
260 if (next
> s
->free_data_block_offset
) {
261 s
->free_data_block_offset
= next
;
266 s
->last_bitmap_offset
= (int64_t) -1;
269 s
->pageentry_u8
= g_malloc(512);
270 s
->pageentry_u32
= s
->pageentry_u8
;
271 s
->pageentry_u16
= s
->pageentry_u8
;
272 s
->last_pagetable
= -1;
276 qemu_co_mutex_init(&s
->lock
);
278 /* Disable migration when VHD images are used */
279 error_set(&s
->migration_blocker
,
280 QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
281 "vpc", bs
->device_name
, "live migration");
282 migrate_add_blocker(s
->migration_blocker
);
287 g_free(s
->pagetable
);
289 g_free(s
->pageentry_u8
);
294 static int vpc_reopen_prepare(BDRVReopenState
*state
,
295 BlockReopenQueue
*queue
, Error
**errp
)
301 * Returns the absolute byte offset of the given sector in the image file.
302 * If the sector is not allocated, -1 is returned instead.
304 * The parameter write must be 1 if the offset will be used for a write
305 * operation (the block bitmaps is updated then), 0 otherwise.
307 static inline int64_t get_sector_offset(BlockDriverState
*bs
,
308 int64_t sector_num
, int write
)
310 BDRVVPCState
*s
= bs
->opaque
;
311 uint64_t offset
= sector_num
* 512;
312 uint64_t bitmap_offset
, block_offset
;
313 uint32_t pagetable_index
, pageentry_index
;
315 pagetable_index
= offset
/ s
->block_size
;
316 pageentry_index
= (offset
% s
->block_size
) / 512;
318 if (pagetable_index
>= s
->max_table_entries
|| s
->pagetable
[pagetable_index
] == 0xffffffff)
319 return -1; // not allocated
321 bitmap_offset
= 512 * (uint64_t) s
->pagetable
[pagetable_index
];
322 block_offset
= bitmap_offset
+ s
->bitmap_size
+ (512 * pageentry_index
);
324 // We must ensure that we don't write to any sectors which are marked as
325 // unused in the bitmap. We get away with setting all bits in the block
326 // bitmap each time we write to a new block. This might cause Virtual PC to
327 // miss sparse read optimization, but it's not a problem in terms of
329 if (write
&& (s
->last_bitmap_offset
!= bitmap_offset
)) {
330 uint8_t bitmap
[s
->bitmap_size
];
332 s
->last_bitmap_offset
= bitmap_offset
;
333 memset(bitmap
, 0xff, s
->bitmap_size
);
334 bdrv_pwrite_sync(bs
->file
, bitmap_offset
, bitmap
, s
->bitmap_size
);
337 // printf("sector: %" PRIx64 ", index: %x, offset: %x, bioff: %" PRIx64 ", bloff: %" PRIx64 "\n",
338 // sector_num, pagetable_index, pageentry_index,
339 // bitmap_offset, block_offset);
341 // disabled by reason
344 if (bitmap_offset
!= s
->last_bitmap
)
346 lseek(s
->fd
, bitmap_offset
, SEEK_SET
);
348 s
->last_bitmap
= bitmap_offset
;
350 // Scary! Bitmap is stored as big endian 32bit entries,
351 // while we used to look it up byte by byte
352 read(s
->fd
, s
->pageentry_u8
, 512);
353 for (i
= 0; i
< 128; i
++)
354 be32_to_cpus(&s
->pageentry_u32
[i
]);
357 if ((s
->pageentry_u8
[pageentry_index
/ 8] >> (pageentry_index
% 8)) & 1)
360 lseek(s
->fd
, bitmap_offset
+ (pageentry_index
/ 8), SEEK_SET
);
362 read(s
->fd
, &bitmap_entry
, 1);
364 if ((bitmap_entry
>> (pageentry_index
% 8)) & 1)
365 return -1; // not allocated
373 * Writes the footer to the end of the image file. This is needed when the
374 * file grows as it overwrites the old footer
376 * Returns 0 on success and < 0 on error
378 static int rewrite_footer(BlockDriverState
* bs
)
381 BDRVVPCState
*s
= bs
->opaque
;
382 int64_t offset
= s
->free_data_block_offset
;
384 ret
= bdrv_pwrite_sync(bs
->file
, offset
, s
->footer_buf
, HEADER_SIZE
);
392 * Allocates a new block. This involves writing a new footer and updating
393 * the Block Allocation Table to use the space at the old end of the image
394 * file (overwriting the old footer)
396 * Returns the sectors' offset in the image file on success and < 0 on error
398 static int64_t alloc_block(BlockDriverState
* bs
, int64_t sector_num
)
400 BDRVVPCState
*s
= bs
->opaque
;
402 uint32_t index
, bat_value
;
404 uint8_t bitmap
[s
->bitmap_size
];
406 // Check if sector_num is valid
407 if ((sector_num
< 0) || (sector_num
> bs
->total_sectors
))
410 // Write entry into in-memory BAT
411 index
= (sector_num
* 512) / s
->block_size
;
412 if (s
->pagetable
[index
] != 0xFFFFFFFF)
415 s
->pagetable
[index
] = s
->free_data_block_offset
/ 512;
417 // Initialize the block's bitmap
418 memset(bitmap
, 0xff, s
->bitmap_size
);
419 ret
= bdrv_pwrite_sync(bs
->file
, s
->free_data_block_offset
, bitmap
,
425 // Write new footer (the old one will be overwritten)
426 s
->free_data_block_offset
+= s
->block_size
+ s
->bitmap_size
;
427 ret
= rewrite_footer(bs
);
431 // Write BAT entry to disk
432 bat_offset
= s
->bat_offset
+ (4 * index
);
433 bat_value
= be32_to_cpu(s
->pagetable
[index
]);
434 ret
= bdrv_pwrite_sync(bs
->file
, bat_offset
, &bat_value
, 4);
438 return get_sector_offset(bs
, sector_num
, 0);
441 s
->free_data_block_offset
-= (s
->block_size
+ s
->bitmap_size
);
445 static int vpc_read(BlockDriverState
*bs
, int64_t sector_num
,
446 uint8_t *buf
, int nb_sectors
)
448 BDRVVPCState
*s
= bs
->opaque
;
451 int64_t sectors
, sectors_per_block
;
452 struct vhd_footer
*footer
= (struct vhd_footer
*) s
->footer_buf
;
454 if (cpu_to_be32(footer
->type
) == VHD_FIXED
) {
455 return bdrv_read(bs
->file
, sector_num
, buf
, nb_sectors
);
457 while (nb_sectors
> 0) {
458 offset
= get_sector_offset(bs
, sector_num
, 0);
460 sectors_per_block
= s
->block_size
>> BDRV_SECTOR_BITS
;
461 sectors
= sectors_per_block
- (sector_num
% sectors_per_block
);
462 if (sectors
> nb_sectors
) {
463 sectors
= nb_sectors
;
467 memset(buf
, 0, sectors
* BDRV_SECTOR_SIZE
);
469 ret
= bdrv_pread(bs
->file
, offset
, buf
,
470 sectors
* BDRV_SECTOR_SIZE
);
471 if (ret
!= sectors
* BDRV_SECTOR_SIZE
) {
476 nb_sectors
-= sectors
;
477 sector_num
+= sectors
;
478 buf
+= sectors
* BDRV_SECTOR_SIZE
;
483 static coroutine_fn
int vpc_co_read(BlockDriverState
*bs
, int64_t sector_num
,
484 uint8_t *buf
, int nb_sectors
)
487 BDRVVPCState
*s
= bs
->opaque
;
488 qemu_co_mutex_lock(&s
->lock
);
489 ret
= vpc_read(bs
, sector_num
, buf
, nb_sectors
);
490 qemu_co_mutex_unlock(&s
->lock
);
494 static int vpc_write(BlockDriverState
*bs
, int64_t sector_num
,
495 const uint8_t *buf
, int nb_sectors
)
497 BDRVVPCState
*s
= bs
->opaque
;
499 int64_t sectors
, sectors_per_block
;
501 struct vhd_footer
*footer
= (struct vhd_footer
*) s
->footer_buf
;
503 if (cpu_to_be32(footer
->type
) == VHD_FIXED
) {
504 return bdrv_write(bs
->file
, sector_num
, buf
, nb_sectors
);
506 while (nb_sectors
> 0) {
507 offset
= get_sector_offset(bs
, sector_num
, 1);
509 sectors_per_block
= s
->block_size
>> BDRV_SECTOR_BITS
;
510 sectors
= sectors_per_block
- (sector_num
% sectors_per_block
);
511 if (sectors
> nb_sectors
) {
512 sectors
= nb_sectors
;
516 offset
= alloc_block(bs
, sector_num
);
521 ret
= bdrv_pwrite(bs
->file
, offset
, buf
, sectors
* BDRV_SECTOR_SIZE
);
522 if (ret
!= sectors
* BDRV_SECTOR_SIZE
) {
526 nb_sectors
-= sectors
;
527 sector_num
+= sectors
;
528 buf
+= sectors
* BDRV_SECTOR_SIZE
;
534 static coroutine_fn
int vpc_co_write(BlockDriverState
*bs
, int64_t sector_num
,
535 const uint8_t *buf
, int nb_sectors
)
538 BDRVVPCState
*s
= bs
->opaque
;
539 qemu_co_mutex_lock(&s
->lock
);
540 ret
= vpc_write(bs
, sector_num
, buf
, nb_sectors
);
541 qemu_co_mutex_unlock(&s
->lock
);
546 * Calculates the number of cylinders, heads and sectors per cylinder
547 * based on a given number of sectors. This is the algorithm described
548 * in the VHD specification.
550 * Note that the geometry doesn't always exactly match total_sectors but
553 * Returns 0 on success, -EFBIG if the size is larger than ~2 TB. Override
554 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
555 * and instead allow up to 255 heads.
557 static int calculate_geometry(int64_t total_sectors
, uint16_t* cyls
,
558 uint8_t* heads
, uint8_t* secs_per_cyl
)
560 uint32_t cyls_times_heads
;
562 /* Allow a maximum disk size of approximately 2 TB */
563 if (total_sectors
> 65535LL * 255 * 255) {
567 if (total_sectors
> 65535 * 16 * 63) {
569 if (total_sectors
> 65535 * 16 * 255) {
574 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
577 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
578 *heads
= (cyls_times_heads
+ 1023) / 1024;
583 if (cyls_times_heads
>= (*heads
* 1024) || *heads
> 16) {
586 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
589 if (cyls_times_heads
>= (*heads
* 1024)) {
592 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
596 *cyls
= cyls_times_heads
/ *heads
;
601 static int create_dynamic_disk(int fd
, uint8_t *buf
, int64_t total_sectors
)
603 struct vhd_dyndisk_header
* dyndisk_header
=
604 (struct vhd_dyndisk_header
*) buf
;
605 size_t block_size
, num_bat_entries
;
609 // Write the footer (twice: at the beginning and at the end)
610 block_size
= 0x200000;
611 num_bat_entries
= (total_sectors
+ block_size
/ 512) / (block_size
/ 512);
613 if (write(fd
, buf
, HEADER_SIZE
) != HEADER_SIZE
) {
617 if (lseek(fd
, 1536 + ((num_bat_entries
* 4 + 511) & ~511), SEEK_SET
) < 0) {
620 if (write(fd
, buf
, HEADER_SIZE
) != HEADER_SIZE
) {
624 // Write the initial BAT
625 if (lseek(fd
, 3 * 512, SEEK_SET
) < 0) {
629 memset(buf
, 0xFF, 512);
630 for (i
= 0; i
< (num_bat_entries
* 4 + 511) / 512; i
++) {
631 if (write(fd
, buf
, 512) != 512) {
636 // Prepare the Dynamic Disk Header
637 memset(buf
, 0, 1024);
639 memcpy(dyndisk_header
->magic
, "cxsparse", 8);
642 * Note: The spec is actually wrong here for data_offset, it says
643 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
645 dyndisk_header
->data_offset
= be64_to_cpu(0xFFFFFFFFFFFFFFFFULL
);
646 dyndisk_header
->table_offset
= be64_to_cpu(3 * 512);
647 dyndisk_header
->version
= be32_to_cpu(0x00010000);
648 dyndisk_header
->block_size
= be32_to_cpu(block_size
);
649 dyndisk_header
->max_table_entries
= be32_to_cpu(num_bat_entries
);
651 dyndisk_header
->checksum
= be32_to_cpu(vpc_checksum(buf
, 1024));
654 if (lseek(fd
, 512, SEEK_SET
) < 0) {
658 if (write(fd
, buf
, 1024) != 1024) {
667 static int create_fixed_disk(int fd
, uint8_t *buf
, int64_t total_size
)
671 /* Add footer to total size */
673 if (ftruncate(fd
, total_size
) != 0) {
677 if (lseek(fd
, -512, SEEK_END
) < 0) {
680 if (write(fd
, buf
, HEADER_SIZE
) != HEADER_SIZE
) {
690 static int vpc_create(const char *filename
, QEMUOptionParameter
*options
)
693 struct vhd_footer
*footer
= (struct vhd_footer
*) buf
;
694 QEMUOptionParameter
*disk_type_param
;
698 uint8_t secs_per_cyl
= 0;
699 int64_t total_sectors
;
704 /* Read out options */
705 total_size
= get_option_parameter(options
, BLOCK_OPT_SIZE
)->value
.n
;
707 disk_type_param
= get_option_parameter(options
, BLOCK_OPT_SUBFMT
);
708 if (disk_type_param
&& disk_type_param
->value
.s
) {
709 if (!strcmp(disk_type_param
->value
.s
, "dynamic")) {
710 disk_type
= VHD_DYNAMIC
;
711 } else if (!strcmp(disk_type_param
->value
.s
, "fixed")) {
712 disk_type
= VHD_FIXED
;
717 disk_type
= VHD_DYNAMIC
;
720 /* Create the file */
721 fd
= qemu_open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, 0644);
727 * Calculate matching total_size and geometry. Increase the number of
728 * sectors requested until we get enough (or fail). This ensures that
729 * qemu-img convert doesn't truncate images, but rather rounds up.
731 total_sectors
= total_size
/ BDRV_SECTOR_SIZE
;
732 for (i
= 0; total_sectors
> (int64_t)cyls
* heads
* secs_per_cyl
; i
++) {
733 if (calculate_geometry(total_sectors
+ i
, &cyls
, &heads
,
741 total_sectors
= (int64_t) cyls
* heads
* secs_per_cyl
;
743 /* Prepare the Hard Disk Footer */
744 memset(buf
, 0, 1024);
746 memcpy(footer
->creator
, "conectix", 8);
747 /* TODO Check if "qemu" creator_app is ok for VPC */
748 memcpy(footer
->creator_app
, "qemu", 4);
749 memcpy(footer
->creator_os
, "Wi2k", 4);
751 footer
->features
= be32_to_cpu(0x02);
752 footer
->version
= be32_to_cpu(0x00010000);
753 if (disk_type
== VHD_DYNAMIC
) {
754 footer
->data_offset
= be64_to_cpu(HEADER_SIZE
);
756 footer
->data_offset
= be64_to_cpu(0xFFFFFFFFFFFFFFFFULL
);
758 footer
->timestamp
= be32_to_cpu(time(NULL
) - VHD_TIMESTAMP_BASE
);
760 /* Version of Virtual PC 2007 */
761 footer
->major
= be16_to_cpu(0x0005);
762 footer
->minor
= be16_to_cpu(0x0003);
763 if (disk_type
== VHD_DYNAMIC
) {
764 footer
->orig_size
= be64_to_cpu(total_sectors
* 512);
765 footer
->size
= be64_to_cpu(total_sectors
* 512);
767 footer
->orig_size
= be64_to_cpu(total_size
);
768 footer
->size
= be64_to_cpu(total_size
);
770 footer
->cyls
= be16_to_cpu(cyls
);
771 footer
->heads
= heads
;
772 footer
->secs_per_cyl
= secs_per_cyl
;
774 footer
->type
= be32_to_cpu(disk_type
);
776 #if defined(CONFIG_UUID)
777 uuid_generate(footer
->uuid
);
780 footer
->checksum
= be32_to_cpu(vpc_checksum(buf
, HEADER_SIZE
));
782 if (disk_type
== VHD_DYNAMIC
) {
783 ret
= create_dynamic_disk(fd
, buf
, total_sectors
);
785 ret
= create_fixed_disk(fd
, buf
, total_size
);
793 static void vpc_close(BlockDriverState
*bs
)
795 BDRVVPCState
*s
= bs
->opaque
;
796 g_free(s
->pagetable
);
798 g_free(s
->pageentry_u8
);
801 migrate_del_blocker(s
->migration_blocker
);
802 error_free(s
->migration_blocker
);
805 static QEMUOptionParameter vpc_create_options
[] = {
807 .name
= BLOCK_OPT_SIZE
,
809 .help
= "Virtual disk size"
812 .name
= BLOCK_OPT_SUBFMT
,
815 "Type of virtual hard disk format. Supported formats are "
816 "{dynamic (default) | fixed} "
821 static BlockDriver bdrv_vpc
= {
822 .format_name
= "vpc",
823 .instance_size
= sizeof(BDRVVPCState
),
825 .bdrv_probe
= vpc_probe
,
826 .bdrv_open
= vpc_open
,
827 .bdrv_close
= vpc_close
,
828 .bdrv_reopen_prepare
= vpc_reopen_prepare
,
829 .bdrv_create
= vpc_create
,
831 .bdrv_read
= vpc_co_read
,
832 .bdrv_write
= vpc_co_write
,
834 .create_options
= vpc_create_options
,
837 static void bdrv_vpc_init(void)
839 bdrv_register(&bdrv_vpc
);
842 block_init(bdrv_vpc_init
);