1 | /* |
2 | * Block driver for Connectix / Microsoft Virtual PC images |
3 | * |
4 | * Copyright (c) 2005 Alex Beregszaszi |
5 | * Copyright (c) 2009 Kevin Wolf <kwolf@suse.de> |
6 | * |
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: |
13 | * |
14 | * The above copyright notice and this permission notice shall be included in |
15 | * all copies or substantial portions of the Software. |
16 | * |
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 |
23 | * THE SOFTWARE. |
24 | */ |
25 | |
26 | #include "qemu/osdep.h" |
27 | #include "qapi/error.h" |
28 | #include "block/block_int.h" |
29 | #include "block/qdict.h" |
30 | #include "sysemu/block-backend.h" |
31 | #include "qemu/module.h" |
32 | #include "qemu/option.h" |
33 | #include "migration/blocker.h" |
34 | #include "qemu/bswap.h" |
35 | #include "qemu/uuid.h" |
36 | #include "qapi/qmp/qdict.h" |
37 | #include "qapi/qobject-input-visitor.h" |
38 | #include "qapi/qapi-visit-block-core.h" |
39 | |
40 | /**************************************************************/ |
41 | |
42 | #define 512 |
43 | |
44 | //#define CACHE |
45 | |
46 | enum vhd_type { |
47 | VHD_FIXED = 2, |
48 | VHD_DYNAMIC = 3, |
49 | VHD_DIFFERENCING = 4, |
50 | }; |
51 | |
52 | /* Seconds since Jan 1, 2000 0:00:00 (UTC) */ |
53 | #define VHD_TIMESTAMP_BASE 946684800 |
54 | |
55 | #define VHD_CHS_MAX_C 65535LL |
56 | #define VHD_CHS_MAX_H 16 |
57 | #define VHD_CHS_MAX_S 255 |
58 | |
59 | #define VHD_MAX_SECTORS 0xff000000 /* 2040 GiB max image size */ |
60 | #define VHD_MAX_GEOMETRY (VHD_CHS_MAX_C * VHD_CHS_MAX_H * VHD_CHS_MAX_S) |
61 | |
62 | #define VPC_OPT_FORCE_SIZE "force_size" |
63 | |
64 | /* always big-endian */ |
65 | typedef struct { |
66 | char [8]; /* "conectix" */ |
67 | uint32_t ; |
68 | uint32_t ; |
69 | |
70 | /* Offset of next header structure, 0xFFFFFFFF if none */ |
71 | uint64_t ; |
72 | |
73 | /* Seconds since Jan 1, 2000 0:00:00 (UTC) */ |
74 | uint32_t ; |
75 | |
76 | char [4]; /* e.g., "vpc " */ |
77 | uint16_t ; |
78 | uint16_t ; |
79 | char [4]; /* "Wi2k" */ |
80 | |
81 | uint64_t ; |
82 | uint64_t ; |
83 | |
84 | uint16_t ; |
85 | uint8_t ; |
86 | uint8_t ; |
87 | |
88 | uint32_t ; |
89 | |
90 | /* Checksum of the Hard Disk Footer ("one's complement of the sum of all |
91 | the bytes in the footer without the checksum field") */ |
92 | uint32_t ; |
93 | |
94 | /* UUID used to identify a parent hard disk (backing file) */ |
95 | QemuUUID ; |
96 | |
97 | uint8_t ; |
98 | } QEMU_PACKED ; |
99 | |
100 | typedef struct { |
101 | char [8]; /* "cxsparse" */ |
102 | |
103 | /* Offset of next header structure, 0xFFFFFFFF if none */ |
104 | uint64_t ; |
105 | |
106 | /* Offset of the Block Allocation Table (BAT) */ |
107 | uint64_t ; |
108 | |
109 | uint32_t ; |
110 | uint32_t ; /* 32bit/entry */ |
111 | |
112 | /* 2 MB by default, must be a power of two */ |
113 | uint32_t ; |
114 | |
115 | uint32_t ; |
116 | uint8_t [16]; |
117 | uint32_t ; |
118 | uint32_t ; |
119 | |
120 | /* Backing file name (in UTF-16) */ |
121 | uint8_t [512]; |
122 | |
123 | struct { |
124 | uint32_t ; |
125 | uint32_t ; |
126 | uint32_t ; |
127 | uint32_t ; |
128 | uint64_t ; |
129 | } [8]; |
130 | } QEMU_PACKED ; |
131 | |
132 | typedef struct BDRVVPCState { |
133 | CoMutex lock; |
134 | uint8_t [HEADER_SIZE]; |
135 | uint64_t free_data_block_offset; |
136 | int max_table_entries; |
137 | uint32_t *pagetable; |
138 | uint64_t bat_offset; |
139 | uint64_t last_bitmap_offset; |
140 | |
141 | uint32_t block_size; |
142 | uint32_t bitmap_size; |
143 | bool force_use_chs; |
144 | bool force_use_sz; |
145 | |
146 | #ifdef CACHE |
147 | uint8_t *pageentry_u8; |
148 | uint32_t *pageentry_u32; |
149 | uint16_t *pageentry_u16; |
150 | |
151 | uint64_t last_bitmap; |
152 | #endif |
153 | |
154 | Error *migration_blocker; |
155 | } BDRVVPCState; |
156 | |
157 | #define VPC_OPT_SIZE_CALC "force_size_calc" |
158 | static QemuOptsList vpc_runtime_opts = { |
159 | .name = "vpc-runtime-opts" , |
160 | .head = QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts.head), |
161 | .desc = { |
162 | { |
163 | .name = VPC_OPT_SIZE_CALC, |
164 | .type = QEMU_OPT_STRING, |
165 | .help = "Force disk size calculation to use either CHS geometry, " |
166 | "or use the disk current_size specified in the VHD footer. " |
167 | "{chs, current_size}" |
168 | }, |
169 | { /* end of list */ } |
170 | } |
171 | }; |
172 | |
173 | static QemuOptsList vpc_create_opts; |
174 | |
175 | static uint32_t vpc_checksum(uint8_t* buf, size_t size) |
176 | { |
177 | uint32_t res = 0; |
178 | int i; |
179 | |
180 | for (i = 0; i < size; i++) |
181 | res += buf[i]; |
182 | |
183 | return ~res; |
184 | } |
185 | |
186 | |
187 | static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename) |
188 | { |
189 | if (buf_size >= 8 && !strncmp((char *)buf, "conectix" , 8)) |
190 | return 100; |
191 | return 0; |
192 | } |
193 | |
194 | static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts, |
195 | Error **errp) |
196 | { |
197 | BDRVVPCState *s = bs->opaque; |
198 | const char *size_calc; |
199 | |
200 | size_calc = qemu_opt_get(opts, VPC_OPT_SIZE_CALC); |
201 | |
202 | if (!size_calc) { |
203 | /* no override, use autodetect only */ |
204 | } else if (!strcmp(size_calc, "current_size" )) { |
205 | s->force_use_sz = true; |
206 | } else if (!strcmp(size_calc, "chs" )) { |
207 | s->force_use_chs = true; |
208 | } else { |
209 | error_setg(errp, "Invalid size calculation mode: '%s'" , size_calc); |
210 | } |
211 | } |
212 | |
213 | static int vpc_open(BlockDriverState *bs, QDict *options, int flags, |
214 | Error **errp) |
215 | { |
216 | BDRVVPCState *s = bs->opaque; |
217 | int i; |
218 | VHDFooter *; |
219 | VHDDynDiskHeader *; |
220 | QemuOpts *opts = NULL; |
221 | Error *local_err = NULL; |
222 | bool use_chs; |
223 | uint8_t buf[HEADER_SIZE]; |
224 | uint32_t checksum; |
225 | uint64_t computed_size; |
226 | uint64_t pagetable_size; |
227 | int disk_type = VHD_DYNAMIC; |
228 | int ret; |
229 | int64_t bs_size; |
230 | |
231 | bs->file = bdrv_open_child(NULL, options, "file" , bs, &child_file, |
232 | false, errp); |
233 | if (!bs->file) { |
234 | return -EINVAL; |
235 | } |
236 | |
237 | opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort); |
238 | qemu_opts_absorb_qdict(opts, options, &local_err); |
239 | if (local_err) { |
240 | error_propagate(errp, local_err); |
241 | ret = -EINVAL; |
242 | goto fail; |
243 | } |
244 | |
245 | vpc_parse_options(bs, opts, &local_err); |
246 | if (local_err) { |
247 | error_propagate(errp, local_err); |
248 | ret = -EINVAL; |
249 | goto fail; |
250 | } |
251 | |
252 | ret = bdrv_pread(bs->file, 0, s->footer_buf, HEADER_SIZE); |
253 | if (ret < 0) { |
254 | error_setg(errp, "Unable to read VHD header" ); |
255 | goto fail; |
256 | } |
257 | |
258 | footer = (VHDFooter *) s->footer_buf; |
259 | if (strncmp(footer->creator, "conectix" , 8)) { |
260 | int64_t offset = bdrv_getlength(bs->file->bs); |
261 | if (offset < 0) { |
262 | ret = offset; |
263 | error_setg(errp, "Invalid file size" ); |
264 | goto fail; |
265 | } else if (offset < HEADER_SIZE) { |
266 | ret = -EINVAL; |
267 | error_setg(errp, "File too small for a VHD header" ); |
268 | goto fail; |
269 | } |
270 | |
271 | /* If a fixed disk, the footer is found only at the end of the file */ |
272 | ret = bdrv_pread(bs->file, offset-HEADER_SIZE, s->footer_buf, |
273 | HEADER_SIZE); |
274 | if (ret < 0) { |
275 | goto fail; |
276 | } |
277 | if (strncmp(footer->creator, "conectix" , 8)) { |
278 | error_setg(errp, "invalid VPC image" ); |
279 | ret = -EINVAL; |
280 | goto fail; |
281 | } |
282 | disk_type = VHD_FIXED; |
283 | } |
284 | |
285 | checksum = be32_to_cpu(footer->checksum); |
286 | footer->checksum = 0; |
287 | if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum) { |
288 | error_setg(errp, "Incorrect header checksum" ); |
289 | ret = -EINVAL; |
290 | goto fail; |
291 | } |
292 | |
293 | /* Write 'checksum' back to footer, or else will leave it with zero. */ |
294 | footer->checksum = cpu_to_be32(checksum); |
295 | |
296 | /* The visible size of a image in Virtual PC depends on the geometry |
297 | rather than on the size stored in the footer (the size in the footer |
298 | is too large usually) */ |
299 | bs->total_sectors = (int64_t) |
300 | be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl; |
301 | |
302 | /* Microsoft Virtual PC and Microsoft Hyper-V produce and read |
303 | * VHD image sizes differently. VPC will rely on CHS geometry, |
304 | * while Hyper-V and disk2vhd use the size specified in the footer. |
305 | * |
306 | * We use a couple of approaches to try and determine the correct method: |
307 | * look at the Creator App field, and look for images that have CHS |
308 | * geometry that is the maximum value. |
309 | * |
310 | * If the CHS geometry is the maximum CHS geometry, then we assume that |
311 | * the size is the footer->current_size to avoid truncation. Otherwise, |
312 | * we follow the table based on footer->creator_app: |
313 | * |
314 | * Known creator apps: |
315 | * 'vpc ' : CHS Virtual PC (uses disk geometry) |
316 | * 'qemu' : CHS QEMU (uses disk geometry) |
317 | * 'qem2' : current_size QEMU (uses current_size) |
318 | * 'win ' : current_size Hyper-V |
319 | * 'd2v ' : current_size Disk2vhd |
320 | * 'tap\0' : current_size XenServer |
321 | * 'CTXS' : current_size XenConverter |
322 | * |
323 | * The user can override the table values via drive options, however |
324 | * even with an override we will still use current_size for images |
325 | * that have CHS geometry of the maximum size. |
326 | */ |
327 | use_chs = (!!strncmp(footer->creator_app, "win " , 4) && |
328 | !!strncmp(footer->creator_app, "qem2" , 4) && |
329 | !!strncmp(footer->creator_app, "d2v " , 4) && |
330 | !!strncmp(footer->creator_app, "CTXS" , 4) && |
331 | !!memcmp(footer->creator_app, "tap" , 4)) || s->force_use_chs; |
332 | |
333 | if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) { |
334 | bs->total_sectors = be64_to_cpu(footer->current_size) / |
335 | BDRV_SECTOR_SIZE; |
336 | } |
337 | |
338 | /* Allow a maximum disk size of 2040 GiB */ |
339 | if (bs->total_sectors > VHD_MAX_SECTORS) { |
340 | ret = -EFBIG; |
341 | goto fail; |
342 | } |
343 | |
344 | if (disk_type == VHD_DYNAMIC) { |
345 | ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset), buf, |
346 | HEADER_SIZE); |
347 | if (ret < 0) { |
348 | error_setg(errp, "Error reading dynamic VHD header" ); |
349 | goto fail; |
350 | } |
351 | |
352 | dyndisk_header = (VHDDynDiskHeader *) buf; |
353 | |
354 | if (strncmp(dyndisk_header->magic, "cxsparse" , 8)) { |
355 | error_setg(errp, "Invalid header magic" ); |
356 | ret = -EINVAL; |
357 | goto fail; |
358 | } |
359 | |
360 | s->block_size = be32_to_cpu(dyndisk_header->block_size); |
361 | if (!is_power_of_2(s->block_size) || s->block_size < BDRV_SECTOR_SIZE) { |
362 | error_setg(errp, "Invalid block size %" PRIu32, s->block_size); |
363 | ret = -EINVAL; |
364 | goto fail; |
365 | } |
366 | s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511; |
367 | |
368 | s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries); |
369 | |
370 | if ((bs->total_sectors * 512) / s->block_size > 0xffffffffU) { |
371 | error_setg(errp, "Too many blocks" ); |
372 | ret = -EINVAL; |
373 | goto fail; |
374 | } |
375 | |
376 | computed_size = (uint64_t) s->max_table_entries * s->block_size; |
377 | if (computed_size < bs->total_sectors * 512) { |
378 | error_setg(errp, "Page table too small" ); |
379 | ret = -EINVAL; |
380 | goto fail; |
381 | } |
382 | |
383 | if (s->max_table_entries > SIZE_MAX / 4 || |
384 | s->max_table_entries > (int) INT_MAX / 4) { |
385 | error_setg(errp, "Max Table Entries too large (%" PRId32 ")" , |
386 | s->max_table_entries); |
387 | ret = -EINVAL; |
388 | goto fail; |
389 | } |
390 | |
391 | pagetable_size = (uint64_t) s->max_table_entries * 4; |
392 | |
393 | s->pagetable = qemu_try_blockalign(bs->file->bs, pagetable_size); |
394 | if (s->pagetable == NULL) { |
395 | error_setg(errp, "Unable to allocate memory for page table" ); |
396 | ret = -ENOMEM; |
397 | goto fail; |
398 | } |
399 | |
400 | s->bat_offset = be64_to_cpu(dyndisk_header->table_offset); |
401 | |
402 | ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable, |
403 | pagetable_size); |
404 | if (ret < 0) { |
405 | error_setg(errp, "Error reading pagetable" ); |
406 | goto fail; |
407 | } |
408 | |
409 | s->free_data_block_offset = |
410 | ROUND_UP(s->bat_offset + pagetable_size, 512); |
411 | |
412 | for (i = 0; i < s->max_table_entries; i++) { |
413 | be32_to_cpus(&s->pagetable[i]); |
414 | if (s->pagetable[i] != 0xFFFFFFFF) { |
415 | int64_t next = (512 * (int64_t) s->pagetable[i]) + |
416 | s->bitmap_size + s->block_size; |
417 | |
418 | if (next > s->free_data_block_offset) { |
419 | s->free_data_block_offset = next; |
420 | } |
421 | } |
422 | } |
423 | |
424 | bs_size = bdrv_getlength(bs->file->bs); |
425 | if (bs_size < 0) { |
426 | error_setg_errno(errp, -bs_size, "Unable to learn image size" ); |
427 | ret = bs_size; |
428 | goto fail; |
429 | } |
430 | if (s->free_data_block_offset > bs_size) { |
431 | error_setg(errp, "block-vpc: free_data_block_offset points after " |
432 | "the end of file. The image has been truncated." ); |
433 | ret = -EINVAL; |
434 | goto fail; |
435 | } |
436 | |
437 | s->last_bitmap_offset = (int64_t) -1; |
438 | |
439 | #ifdef CACHE |
440 | s->pageentry_u8 = g_malloc(512); |
441 | s->pageentry_u32 = s->pageentry_u8; |
442 | s->pageentry_u16 = s->pageentry_u8; |
443 | s->last_pagetable = -1; |
444 | #endif |
445 | } |
446 | |
447 | /* Disable migration when VHD images are used */ |
448 | error_setg(&s->migration_blocker, "The vpc format used by node '%s' " |
449 | "does not support live migration" , |
450 | bdrv_get_device_or_node_name(bs)); |
451 | ret = migrate_add_blocker(s->migration_blocker, &local_err); |
452 | if (local_err) { |
453 | error_propagate(errp, local_err); |
454 | error_free(s->migration_blocker); |
455 | goto fail; |
456 | } |
457 | |
458 | qemu_co_mutex_init(&s->lock); |
459 | qemu_opts_del(opts); |
460 | |
461 | return 0; |
462 | |
463 | fail: |
464 | qemu_opts_del(opts); |
465 | qemu_vfree(s->pagetable); |
466 | #ifdef CACHE |
467 | g_free(s->pageentry_u8); |
468 | #endif |
469 | return ret; |
470 | } |
471 | |
472 | static int vpc_reopen_prepare(BDRVReopenState *state, |
473 | BlockReopenQueue *queue, Error **errp) |
474 | { |
475 | return 0; |
476 | } |
477 | |
478 | /* |
479 | * Returns the absolute byte offset of the given sector in the image file. |
480 | * If the sector is not allocated, -1 is returned instead. |
481 | * If an error occurred trying to write an updated block bitmap back to |
482 | * the file, -2 is returned, and the error value is written to *err. |
483 | * This can only happen for a write operation. |
484 | * |
485 | * The parameter write must be 1 if the offset will be used for a write |
486 | * operation (the block bitmaps is updated then), 0 otherwise. |
487 | * If write is true then err must not be NULL. |
488 | */ |
489 | static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset, |
490 | bool write, int *err) |
491 | { |
492 | BDRVVPCState *s = bs->opaque; |
493 | uint64_t bitmap_offset, block_offset; |
494 | uint32_t pagetable_index, offset_in_block; |
495 | |
496 | assert(!(write && err == NULL)); |
497 | |
498 | pagetable_index = offset / s->block_size; |
499 | offset_in_block = offset % s->block_size; |
500 | |
501 | if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff) |
502 | return -1; /* not allocated */ |
503 | |
504 | bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index]; |
505 | block_offset = bitmap_offset + s->bitmap_size + offset_in_block; |
506 | |
507 | /* We must ensure that we don't write to any sectors which are marked as |
508 | unused in the bitmap. We get away with setting all bits in the block |
509 | bitmap each time we write to a new block. This might cause Virtual PC to |
510 | miss sparse read optimization, but it's not a problem in terms of |
511 | correctness. */ |
512 | if (write && (s->last_bitmap_offset != bitmap_offset)) { |
513 | uint8_t bitmap[s->bitmap_size]; |
514 | int r; |
515 | |
516 | s->last_bitmap_offset = bitmap_offset; |
517 | memset(bitmap, 0xff, s->bitmap_size); |
518 | r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size); |
519 | if (r < 0) { |
520 | *err = r; |
521 | return -2; |
522 | } |
523 | } |
524 | |
525 | return block_offset; |
526 | } |
527 | |
528 | /* |
529 | * Writes the footer to the end of the image file. This is needed when the |
530 | * file grows as it overwrites the old footer |
531 | * |
532 | * Returns 0 on success and < 0 on error |
533 | */ |
534 | static int (BlockDriverState* bs) |
535 | { |
536 | int ret; |
537 | BDRVVPCState *s = bs->opaque; |
538 | int64_t offset = s->free_data_block_offset; |
539 | |
540 | ret = bdrv_pwrite_sync(bs->file, offset, s->footer_buf, HEADER_SIZE); |
541 | if (ret < 0) |
542 | return ret; |
543 | |
544 | return 0; |
545 | } |
546 | |
547 | /* |
548 | * Allocates a new block. This involves writing a new footer and updating |
549 | * the Block Allocation Table to use the space at the old end of the image |
550 | * file (overwriting the old footer) |
551 | * |
552 | * Returns the sectors' offset in the image file on success and < 0 on error |
553 | */ |
554 | static int64_t alloc_block(BlockDriverState* bs, int64_t offset) |
555 | { |
556 | BDRVVPCState *s = bs->opaque; |
557 | int64_t bat_offset; |
558 | uint32_t index, bat_value; |
559 | int ret; |
560 | uint8_t bitmap[s->bitmap_size]; |
561 | |
562 | /* Check if sector_num is valid */ |
563 | if ((offset < 0) || (offset > bs->total_sectors * BDRV_SECTOR_SIZE)) { |
564 | return -EINVAL; |
565 | } |
566 | |
567 | /* Write entry into in-memory BAT */ |
568 | index = offset / s->block_size; |
569 | assert(s->pagetable[index] == 0xFFFFFFFF); |
570 | s->pagetable[index] = s->free_data_block_offset / 512; |
571 | |
572 | /* Initialize the block's bitmap */ |
573 | memset(bitmap, 0xff, s->bitmap_size); |
574 | ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap, |
575 | s->bitmap_size); |
576 | if (ret < 0) { |
577 | return ret; |
578 | } |
579 | |
580 | /* Write new footer (the old one will be overwritten) */ |
581 | s->free_data_block_offset += s->block_size + s->bitmap_size; |
582 | ret = rewrite_footer(bs); |
583 | if (ret < 0) |
584 | goto fail; |
585 | |
586 | /* Write BAT entry to disk */ |
587 | bat_offset = s->bat_offset + (4 * index); |
588 | bat_value = cpu_to_be32(s->pagetable[index]); |
589 | ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4); |
590 | if (ret < 0) |
591 | goto fail; |
592 | |
593 | return get_image_offset(bs, offset, false, NULL); |
594 | |
595 | fail: |
596 | s->free_data_block_offset -= (s->block_size + s->bitmap_size); |
597 | return ret; |
598 | } |
599 | |
600 | static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) |
601 | { |
602 | BDRVVPCState *s = (BDRVVPCState *)bs->opaque; |
603 | VHDFooter * = (VHDFooter *) s->footer_buf; |
604 | |
605 | if (be32_to_cpu(footer->type) != VHD_FIXED) { |
606 | bdi->cluster_size = s->block_size; |
607 | } |
608 | |
609 | bdi->unallocated_blocks_are_zero = true; |
610 | return 0; |
611 | } |
612 | |
613 | static int coroutine_fn |
614 | vpc_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes, |
615 | QEMUIOVector *qiov, int flags) |
616 | { |
617 | BDRVVPCState *s = bs->opaque; |
618 | int ret; |
619 | int64_t image_offset; |
620 | int64_t n_bytes; |
621 | int64_t bytes_done = 0; |
622 | VHDFooter * = (VHDFooter *) s->footer_buf; |
623 | QEMUIOVector local_qiov; |
624 | |
625 | if (be32_to_cpu(footer->type) == VHD_FIXED) { |
626 | return bdrv_co_preadv(bs->file, offset, bytes, qiov, 0); |
627 | } |
628 | |
629 | qemu_co_mutex_lock(&s->lock); |
630 | qemu_iovec_init(&local_qiov, qiov->niov); |
631 | |
632 | while (bytes > 0) { |
633 | image_offset = get_image_offset(bs, offset, false, NULL); |
634 | n_bytes = MIN(bytes, s->block_size - (offset % s->block_size)); |
635 | |
636 | if (image_offset == -1) { |
637 | qemu_iovec_memset(qiov, bytes_done, 0, n_bytes); |
638 | } else { |
639 | qemu_iovec_reset(&local_qiov); |
640 | qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes); |
641 | |
642 | qemu_co_mutex_unlock(&s->lock); |
643 | ret = bdrv_co_preadv(bs->file, image_offset, n_bytes, |
644 | &local_qiov, 0); |
645 | qemu_co_mutex_lock(&s->lock); |
646 | if (ret < 0) { |
647 | goto fail; |
648 | } |
649 | } |
650 | |
651 | bytes -= n_bytes; |
652 | offset += n_bytes; |
653 | bytes_done += n_bytes; |
654 | } |
655 | |
656 | ret = 0; |
657 | fail: |
658 | qemu_iovec_destroy(&local_qiov); |
659 | qemu_co_mutex_unlock(&s->lock); |
660 | |
661 | return ret; |
662 | } |
663 | |
664 | static int coroutine_fn |
665 | vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes, |
666 | QEMUIOVector *qiov, int flags) |
667 | { |
668 | BDRVVPCState *s = bs->opaque; |
669 | int64_t image_offset; |
670 | int64_t n_bytes; |
671 | int64_t bytes_done = 0; |
672 | int ret = 0; |
673 | VHDFooter * = (VHDFooter *) s->footer_buf; |
674 | QEMUIOVector local_qiov; |
675 | |
676 | if (be32_to_cpu(footer->type) == VHD_FIXED) { |
677 | return bdrv_co_pwritev(bs->file, offset, bytes, qiov, 0); |
678 | } |
679 | |
680 | qemu_co_mutex_lock(&s->lock); |
681 | qemu_iovec_init(&local_qiov, qiov->niov); |
682 | |
683 | while (bytes > 0) { |
684 | image_offset = get_image_offset(bs, offset, true, &ret); |
685 | if (image_offset == -2) { |
686 | /* Failed to write block bitmap: can't proceed with write */ |
687 | goto fail; |
688 | } |
689 | n_bytes = MIN(bytes, s->block_size - (offset % s->block_size)); |
690 | |
691 | if (image_offset == -1) { |
692 | image_offset = alloc_block(bs, offset); |
693 | if (image_offset < 0) { |
694 | ret = image_offset; |
695 | goto fail; |
696 | } |
697 | } |
698 | |
699 | qemu_iovec_reset(&local_qiov); |
700 | qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes); |
701 | |
702 | qemu_co_mutex_unlock(&s->lock); |
703 | ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes, |
704 | &local_qiov, 0); |
705 | qemu_co_mutex_lock(&s->lock); |
706 | if (ret < 0) { |
707 | goto fail; |
708 | } |
709 | |
710 | bytes -= n_bytes; |
711 | offset += n_bytes; |
712 | bytes_done += n_bytes; |
713 | } |
714 | |
715 | ret = 0; |
716 | fail: |
717 | qemu_iovec_destroy(&local_qiov); |
718 | qemu_co_mutex_unlock(&s->lock); |
719 | |
720 | return ret; |
721 | } |
722 | |
723 | static int coroutine_fn vpc_co_block_status(BlockDriverState *bs, |
724 | bool want_zero, |
725 | int64_t offset, int64_t bytes, |
726 | int64_t *pnum, int64_t *map, |
727 | BlockDriverState **file) |
728 | { |
729 | BDRVVPCState *s = bs->opaque; |
730 | VHDFooter * = (VHDFooter*) s->footer_buf; |
731 | int64_t image_offset; |
732 | bool allocated; |
733 | int ret; |
734 | int64_t n; |
735 | |
736 | if (be32_to_cpu(footer->type) == VHD_FIXED) { |
737 | *pnum = bytes; |
738 | *map = offset; |
739 | *file = bs->file->bs; |
740 | return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_RECURSE; |
741 | } |
742 | |
743 | qemu_co_mutex_lock(&s->lock); |
744 | |
745 | image_offset = get_image_offset(bs, offset, false, NULL); |
746 | allocated = (image_offset != -1); |
747 | *pnum = 0; |
748 | ret = 0; |
749 | |
750 | do { |
751 | /* All sectors in a block are contiguous (without using the bitmap) */ |
752 | n = ROUND_UP(offset + 1, s->block_size) - offset; |
753 | n = MIN(n, bytes); |
754 | |
755 | *pnum += n; |
756 | offset += n; |
757 | bytes -= n; |
758 | /* *pnum can't be greater than one block for allocated |
759 | * sectors since there is always a bitmap in between. */ |
760 | if (allocated) { |
761 | *file = bs->file->bs; |
762 | *map = image_offset; |
763 | ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID; |
764 | break; |
765 | } |
766 | if (bytes == 0) { |
767 | break; |
768 | } |
769 | image_offset = get_image_offset(bs, offset, false, NULL); |
770 | } while (image_offset == -1); |
771 | |
772 | qemu_co_mutex_unlock(&s->lock); |
773 | return ret; |
774 | } |
775 | |
776 | /* |
777 | * Calculates the number of cylinders, heads and sectors per cylinder |
778 | * based on a given number of sectors. This is the algorithm described |
779 | * in the VHD specification. |
780 | * |
781 | * Note that the geometry doesn't always exactly match total_sectors but |
782 | * may round it down. |
783 | * |
784 | * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override |
785 | * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB) |
786 | * and instead allow up to 255 heads. |
787 | */ |
788 | static int calculate_geometry(int64_t total_sectors, uint16_t* cyls, |
789 | uint8_t* heads, uint8_t* secs_per_cyl) |
790 | { |
791 | uint32_t cyls_times_heads; |
792 | |
793 | total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY); |
794 | |
795 | if (total_sectors >= 65535LL * 16 * 63) { |
796 | *secs_per_cyl = 255; |
797 | *heads = 16; |
798 | cyls_times_heads = total_sectors / *secs_per_cyl; |
799 | } else { |
800 | *secs_per_cyl = 17; |
801 | cyls_times_heads = total_sectors / *secs_per_cyl; |
802 | *heads = DIV_ROUND_UP(cyls_times_heads, 1024); |
803 | |
804 | if (*heads < 4) { |
805 | *heads = 4; |
806 | } |
807 | |
808 | if (cyls_times_heads >= (*heads * 1024) || *heads > 16) { |
809 | *secs_per_cyl = 31; |
810 | *heads = 16; |
811 | cyls_times_heads = total_sectors / *secs_per_cyl; |
812 | } |
813 | |
814 | if (cyls_times_heads >= (*heads * 1024)) { |
815 | *secs_per_cyl = 63; |
816 | *heads = 16; |
817 | cyls_times_heads = total_sectors / *secs_per_cyl; |
818 | } |
819 | } |
820 | |
821 | *cyls = cyls_times_heads / *heads; |
822 | |
823 | return 0; |
824 | } |
825 | |
826 | static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf, |
827 | int64_t total_sectors) |
828 | { |
829 | VHDDynDiskHeader * = |
830 | (VHDDynDiskHeader *) buf; |
831 | size_t block_size, num_bat_entries; |
832 | int i; |
833 | int ret; |
834 | int64_t offset = 0; |
835 | |
836 | /* Write the footer (twice: at the beginning and at the end) */ |
837 | block_size = 0x200000; |
838 | num_bat_entries = (total_sectors + block_size / 512) / (block_size / 512); |
839 | |
840 | ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0); |
841 | if (ret < 0) { |
842 | goto fail; |
843 | } |
844 | |
845 | offset = 1536 + ((num_bat_entries * 4 + 511) & ~511); |
846 | ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0); |
847 | if (ret < 0) { |
848 | goto fail; |
849 | } |
850 | |
851 | /* Write the initial BAT */ |
852 | offset = 3 * 512; |
853 | |
854 | memset(buf, 0xFF, 512); |
855 | for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) { |
856 | ret = blk_pwrite(blk, offset, buf, 512, 0); |
857 | if (ret < 0) { |
858 | goto fail; |
859 | } |
860 | offset += 512; |
861 | } |
862 | |
863 | /* Prepare the Dynamic Disk Header */ |
864 | memset(buf, 0, 1024); |
865 | |
866 | memcpy(dyndisk_header->magic, "cxsparse" , 8); |
867 | |
868 | /* |
869 | * Note: The spec is actually wrong here for data_offset, it says |
870 | * 0xFFFFFFFF, but MS tools expect all 64 bits to be set. |
871 | */ |
872 | dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL); |
873 | dyndisk_header->table_offset = cpu_to_be64(3 * 512); |
874 | dyndisk_header->version = cpu_to_be32(0x00010000); |
875 | dyndisk_header->block_size = cpu_to_be32(block_size); |
876 | dyndisk_header->max_table_entries = cpu_to_be32(num_bat_entries); |
877 | |
878 | dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024)); |
879 | |
880 | /* Write the header */ |
881 | offset = 512; |
882 | |
883 | ret = blk_pwrite(blk, offset, buf, 1024, 0); |
884 | if (ret < 0) { |
885 | goto fail; |
886 | } |
887 | |
888 | fail: |
889 | return ret; |
890 | } |
891 | |
892 | static int create_fixed_disk(BlockBackend *blk, uint8_t *buf, |
893 | int64_t total_size, Error **errp) |
894 | { |
895 | int ret; |
896 | |
897 | /* Add footer to total size */ |
898 | total_size += HEADER_SIZE; |
899 | |
900 | ret = blk_truncate(blk, total_size, PREALLOC_MODE_OFF, errp); |
901 | if (ret < 0) { |
902 | return ret; |
903 | } |
904 | |
905 | ret = blk_pwrite(blk, total_size - HEADER_SIZE, buf, HEADER_SIZE, 0); |
906 | if (ret < 0) { |
907 | error_setg_errno(errp, -ret, "Unable to write VHD header" ); |
908 | return ret; |
909 | } |
910 | |
911 | return ret; |
912 | } |
913 | |
914 | static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts, |
915 | uint16_t *out_cyls, |
916 | uint8_t *out_heads, |
917 | uint8_t *out_secs_per_cyl, |
918 | int64_t *out_total_sectors, |
919 | Error **errp) |
920 | { |
921 | int64_t total_size = vpc_opts->size; |
922 | uint16_t cyls = 0; |
923 | uint8_t heads = 0; |
924 | uint8_t secs_per_cyl = 0; |
925 | int64_t total_sectors; |
926 | int i; |
927 | |
928 | /* |
929 | * Calculate matching total_size and geometry. Increase the number of |
930 | * sectors requested until we get enough (or fail). This ensures that |
931 | * qemu-img convert doesn't truncate images, but rather rounds up. |
932 | * |
933 | * If the image size can't be represented by a spec conformant CHS geometry, |
934 | * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use |
935 | * the image size from the VHD footer to calculate total_sectors. |
936 | */ |
937 | if (vpc_opts->force_size) { |
938 | /* This will force the use of total_size for sector count, below */ |
939 | cyls = VHD_CHS_MAX_C; |
940 | heads = VHD_CHS_MAX_H; |
941 | secs_per_cyl = VHD_CHS_MAX_S; |
942 | } else { |
943 | total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE); |
944 | for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) { |
945 | calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl); |
946 | } |
947 | } |
948 | |
949 | if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) { |
950 | total_sectors = total_size / BDRV_SECTOR_SIZE; |
951 | /* Allow a maximum disk size of 2040 GiB */ |
952 | if (total_sectors > VHD_MAX_SECTORS) { |
953 | error_setg(errp, "Disk size is too large, max size is 2040 GiB" ); |
954 | return -EFBIG; |
955 | } |
956 | } else { |
957 | total_sectors = (int64_t) cyls * heads * secs_per_cyl; |
958 | } |
959 | |
960 | *out_total_sectors = total_sectors; |
961 | if (out_cyls) { |
962 | *out_cyls = cyls; |
963 | *out_heads = heads; |
964 | *out_secs_per_cyl = secs_per_cyl; |
965 | } |
966 | |
967 | return 0; |
968 | } |
969 | |
970 | static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts, |
971 | Error **errp) |
972 | { |
973 | BlockdevCreateOptionsVpc *vpc_opts; |
974 | BlockBackend *blk = NULL; |
975 | BlockDriverState *bs = NULL; |
976 | |
977 | uint8_t buf[1024]; |
978 | VHDFooter * = (VHDFooter *) buf; |
979 | uint16_t cyls = 0; |
980 | uint8_t heads = 0; |
981 | uint8_t secs_per_cyl = 0; |
982 | int64_t total_sectors; |
983 | int64_t total_size; |
984 | int disk_type; |
985 | int ret = -EIO; |
986 | QemuUUID uuid; |
987 | |
988 | assert(opts->driver == BLOCKDEV_DRIVER_VPC); |
989 | vpc_opts = &opts->u.vpc; |
990 | |
991 | /* Validate options and set default values */ |
992 | total_size = vpc_opts->size; |
993 | |
994 | if (!vpc_opts->has_subformat) { |
995 | vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC; |
996 | } |
997 | switch (vpc_opts->subformat) { |
998 | case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC: |
999 | disk_type = VHD_DYNAMIC; |
1000 | break; |
1001 | case BLOCKDEV_VPC_SUBFORMAT_FIXED: |
1002 | disk_type = VHD_FIXED; |
1003 | break; |
1004 | default: |
1005 | g_assert_not_reached(); |
1006 | } |
1007 | |
1008 | /* Create BlockBackend to write to the image */ |
1009 | bs = bdrv_open_blockdev_ref(vpc_opts->file, errp); |
1010 | if (bs == NULL) { |
1011 | return -EIO; |
1012 | } |
1013 | |
1014 | blk = blk_new(bdrv_get_aio_context(bs), |
1015 | BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL); |
1016 | ret = blk_insert_bs(blk, bs, errp); |
1017 | if (ret < 0) { |
1018 | goto out; |
1019 | } |
1020 | blk_set_allow_write_beyond_eof(blk, true); |
1021 | |
1022 | /* Get geometry and check that it matches the image size*/ |
1023 | ret = calculate_rounded_image_size(vpc_opts, &cyls, &heads, &secs_per_cyl, |
1024 | &total_sectors, errp); |
1025 | if (ret < 0) { |
1026 | goto out; |
1027 | } |
1028 | |
1029 | if (total_size != total_sectors * BDRV_SECTOR_SIZE) { |
1030 | error_setg(errp, "The requested image size cannot be represented in " |
1031 | "CHS geometry" ); |
1032 | error_append_hint(errp, "Try size=%llu or force-size=on (the " |
1033 | "latter makes the image incompatible with " |
1034 | "Virtual PC)" , |
1035 | total_sectors * BDRV_SECTOR_SIZE); |
1036 | ret = -EINVAL; |
1037 | goto out; |
1038 | } |
1039 | |
1040 | /* Prepare the Hard Disk Footer */ |
1041 | memset(buf, 0, 1024); |
1042 | |
1043 | memcpy(footer->creator, "conectix" , 8); |
1044 | if (vpc_opts->force_size) { |
1045 | memcpy(footer->creator_app, "qem2" , 4); |
1046 | } else { |
1047 | memcpy(footer->creator_app, "qemu" , 4); |
1048 | } |
1049 | memcpy(footer->creator_os, "Wi2k" , 4); |
1050 | |
1051 | footer->features = cpu_to_be32(0x02); |
1052 | footer->version = cpu_to_be32(0x00010000); |
1053 | if (disk_type == VHD_DYNAMIC) { |
1054 | footer->data_offset = cpu_to_be64(HEADER_SIZE); |
1055 | } else { |
1056 | footer->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL); |
1057 | } |
1058 | footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE); |
1059 | |
1060 | /* Version of Virtual PC 2007 */ |
1061 | footer->major = cpu_to_be16(0x0005); |
1062 | footer->minor = cpu_to_be16(0x0003); |
1063 | footer->orig_size = cpu_to_be64(total_size); |
1064 | footer->current_size = cpu_to_be64(total_size); |
1065 | footer->cyls = cpu_to_be16(cyls); |
1066 | footer->heads = heads; |
1067 | footer->secs_per_cyl = secs_per_cyl; |
1068 | |
1069 | footer->type = cpu_to_be32(disk_type); |
1070 | |
1071 | qemu_uuid_generate(&uuid); |
1072 | footer->uuid = uuid; |
1073 | |
1074 | footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE)); |
1075 | |
1076 | if (disk_type == VHD_DYNAMIC) { |
1077 | ret = create_dynamic_disk(blk, buf, total_sectors); |
1078 | if (ret < 0) { |
1079 | error_setg(errp, "Unable to create or write VHD header" ); |
1080 | } |
1081 | } else { |
1082 | ret = create_fixed_disk(blk, buf, total_size, errp); |
1083 | } |
1084 | |
1085 | out: |
1086 | blk_unref(blk); |
1087 | bdrv_unref(bs); |
1088 | return ret; |
1089 | } |
1090 | |
1091 | static int coroutine_fn vpc_co_create_opts(const char *filename, |
1092 | QemuOpts *opts, Error **errp) |
1093 | { |
1094 | BlockdevCreateOptions *create_options = NULL; |
1095 | QDict *qdict; |
1096 | Visitor *v; |
1097 | BlockDriverState *bs = NULL; |
1098 | Error *local_err = NULL; |
1099 | int ret; |
1100 | |
1101 | static const QDictRenames opt_renames[] = { |
1102 | { VPC_OPT_FORCE_SIZE, "force-size" }, |
1103 | { NULL, NULL }, |
1104 | }; |
1105 | |
1106 | /* Parse options and convert legacy syntax */ |
1107 | qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vpc_create_opts, true); |
1108 | |
1109 | if (!qdict_rename_keys(qdict, opt_renames, errp)) { |
1110 | ret = -EINVAL; |
1111 | goto fail; |
1112 | } |
1113 | |
1114 | /* Create and open the file (protocol layer) */ |
1115 | ret = bdrv_create_file(filename, opts, &local_err); |
1116 | if (ret < 0) { |
1117 | error_propagate(errp, local_err); |
1118 | goto fail; |
1119 | } |
1120 | |
1121 | bs = bdrv_open(filename, NULL, NULL, |
1122 | BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp); |
1123 | if (bs == NULL) { |
1124 | ret = -EIO; |
1125 | goto fail; |
1126 | } |
1127 | |
1128 | /* Now get the QAPI type BlockdevCreateOptions */ |
1129 | qdict_put_str(qdict, "driver" , "vpc" ); |
1130 | qdict_put_str(qdict, "file" , bs->node_name); |
1131 | |
1132 | v = qobject_input_visitor_new_flat_confused(qdict, errp); |
1133 | if (!v) { |
1134 | ret = -EINVAL; |
1135 | goto fail; |
1136 | } |
1137 | |
1138 | visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err); |
1139 | visit_free(v); |
1140 | |
1141 | if (local_err) { |
1142 | error_propagate(errp, local_err); |
1143 | ret = -EINVAL; |
1144 | goto fail; |
1145 | } |
1146 | |
1147 | /* Silently round up size */ |
1148 | assert(create_options->driver == BLOCKDEV_DRIVER_VPC); |
1149 | create_options->u.vpc.size = |
1150 | ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE); |
1151 | |
1152 | if (!create_options->u.vpc.force_size) { |
1153 | int64_t total_sectors; |
1154 | ret = calculate_rounded_image_size(&create_options->u.vpc, NULL, NULL, |
1155 | NULL, &total_sectors, errp); |
1156 | if (ret < 0) { |
1157 | goto fail; |
1158 | } |
1159 | |
1160 | create_options->u.vpc.size = total_sectors * BDRV_SECTOR_SIZE; |
1161 | } |
1162 | |
1163 | |
1164 | /* Create the vpc image (format layer) */ |
1165 | ret = vpc_co_create(create_options, errp); |
1166 | |
1167 | fail: |
1168 | qobject_unref(qdict); |
1169 | bdrv_unref(bs); |
1170 | qapi_free_BlockdevCreateOptions(create_options); |
1171 | return ret; |
1172 | } |
1173 | |
1174 | |
1175 | static int vpc_has_zero_init(BlockDriverState *bs) |
1176 | { |
1177 | BDRVVPCState *s = bs->opaque; |
1178 | VHDFooter * = (VHDFooter *) s->footer_buf; |
1179 | |
1180 | if (be32_to_cpu(footer->type) == VHD_FIXED) { |
1181 | return bdrv_has_zero_init(bs->file->bs); |
1182 | } else { |
1183 | return 1; |
1184 | } |
1185 | } |
1186 | |
1187 | static void vpc_close(BlockDriverState *bs) |
1188 | { |
1189 | BDRVVPCState *s = bs->opaque; |
1190 | qemu_vfree(s->pagetable); |
1191 | #ifdef CACHE |
1192 | g_free(s->pageentry_u8); |
1193 | #endif |
1194 | |
1195 | migrate_del_blocker(s->migration_blocker); |
1196 | error_free(s->migration_blocker); |
1197 | } |
1198 | |
1199 | static QemuOptsList vpc_create_opts = { |
1200 | .name = "vpc-create-opts" , |
1201 | .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head), |
1202 | .desc = { |
1203 | { |
1204 | .name = BLOCK_OPT_SIZE, |
1205 | .type = QEMU_OPT_SIZE, |
1206 | .help = "Virtual disk size" |
1207 | }, |
1208 | { |
1209 | .name = BLOCK_OPT_SUBFMT, |
1210 | .type = QEMU_OPT_STRING, |
1211 | .help = |
1212 | "Type of virtual hard disk format. Supported formats are " |
1213 | "{dynamic (default) | fixed} " |
1214 | }, |
1215 | { |
1216 | .name = VPC_OPT_FORCE_SIZE, |
1217 | .type = QEMU_OPT_BOOL, |
1218 | .help = "Force disk size calculation to use the actual size " |
1219 | "specified, rather than using the nearest CHS-based " |
1220 | "calculation" |
1221 | }, |
1222 | { /* end of list */ } |
1223 | } |
1224 | }; |
1225 | |
1226 | static const char *const vpc_strong_runtime_opts[] = { |
1227 | VPC_OPT_SIZE_CALC, |
1228 | |
1229 | NULL |
1230 | }; |
1231 | |
1232 | static BlockDriver bdrv_vpc = { |
1233 | .format_name = "vpc" , |
1234 | .instance_size = sizeof(BDRVVPCState), |
1235 | |
1236 | .bdrv_probe = vpc_probe, |
1237 | .bdrv_open = vpc_open, |
1238 | .bdrv_close = vpc_close, |
1239 | .bdrv_reopen_prepare = vpc_reopen_prepare, |
1240 | .bdrv_child_perm = bdrv_format_default_perms, |
1241 | .bdrv_co_create = vpc_co_create, |
1242 | .bdrv_co_create_opts = vpc_co_create_opts, |
1243 | |
1244 | .bdrv_co_preadv = vpc_co_preadv, |
1245 | .bdrv_co_pwritev = vpc_co_pwritev, |
1246 | .bdrv_co_block_status = vpc_co_block_status, |
1247 | |
1248 | .bdrv_get_info = vpc_get_info, |
1249 | |
1250 | .create_opts = &vpc_create_opts, |
1251 | .bdrv_has_zero_init = vpc_has_zero_init, |
1252 | .strong_runtime_opts = vpc_strong_runtime_opts, |
1253 | }; |
1254 | |
1255 | static void bdrv_vpc_init(void) |
1256 | { |
1257 | bdrv_register(&bdrv_vpc); |
1258 | } |
1259 | |
1260 | block_init(bdrv_vpc_init); |
1261 | |