]> git.proxmox.com Git - qemu.git/blob - block/vmdk.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
vmdk: Add migration blocker
[qemu.git] / block / vmdk.c
1 /*
2 * Block driver for the VMDK format
3 *
4 * Copyright (c) 2004 Fabrice Bellard
5 * Copyright (c) 2005 Filip Navara
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-common.h"
27 #include "block_int.h"
28 #include "module.h"
29 #include "migration.h"
30 #include <zlib.h>
31
32 #define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D')
33 #define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V')
34 #define VMDK4_COMPRESSION_DEFLATE 1
35 #define VMDK4_FLAG_RGD (1 << 1)
36 #define VMDK4_FLAG_COMPRESS (1 << 16)
37 #define VMDK4_FLAG_MARKER (1 << 17)
38
39 typedef struct {
40 uint32_t version;
41 uint32_t flags;
42 uint32_t disk_sectors;
43 uint32_t granularity;
44 uint32_t l1dir_offset;
45 uint32_t l1dir_size;
46 uint32_t file_sectors;
47 uint32_t cylinders;
48 uint32_t heads;
49 uint32_t sectors_per_track;
50 } VMDK3Header;
51
52 typedef struct {
53 uint32_t version;
54 uint32_t flags;
55 int64_t capacity;
56 int64_t granularity;
57 int64_t desc_offset;
58 int64_t desc_size;
59 int32_t num_gtes_per_gte;
60 int64_t gd_offset;
61 int64_t rgd_offset;
62 int64_t grain_offset;
63 char filler[1];
64 char check_bytes[4];
65 uint16_t compressAlgorithm;
66 } QEMU_PACKED VMDK4Header;
67
68 #define L2_CACHE_SIZE 16
69
70 typedef struct VmdkExtent {
71 BlockDriverState *file;
72 bool flat;
73 bool compressed;
74 bool has_marker;
75 int64_t sectors;
76 int64_t end_sector;
77 int64_t flat_start_offset;
78 int64_t l1_table_offset;
79 int64_t l1_backup_table_offset;
80 uint32_t *l1_table;
81 uint32_t *l1_backup_table;
82 unsigned int l1_size;
83 uint32_t l1_entry_sectors;
84
85 unsigned int l2_size;
86 uint32_t *l2_cache;
87 uint32_t l2_cache_offsets[L2_CACHE_SIZE];
88 uint32_t l2_cache_counts[L2_CACHE_SIZE];
89
90 unsigned int cluster_sectors;
91 } VmdkExtent;
92
93 typedef struct BDRVVmdkState {
94 CoMutex lock;
95 int desc_offset;
96 bool cid_updated;
97 uint32_t parent_cid;
98 int num_extents;
99 /* Extent array with num_extents entries, ascend ordered by address */
100 VmdkExtent *extents;
101 Error *migration_blocker;
102 } BDRVVmdkState;
103
104 typedef struct VmdkMetaData {
105 uint32_t offset;
106 unsigned int l1_index;
107 unsigned int l2_index;
108 unsigned int l2_offset;
109 int valid;
110 } VmdkMetaData;
111
112 typedef struct VmdkGrainMarker {
113 uint64_t lba;
114 uint32_t size;
115 uint8_t data[0];
116 } VmdkGrainMarker;
117
118 static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename)
119 {
120 uint32_t magic;
121
122 if (buf_size < 4) {
123 return 0;
124 }
125 magic = be32_to_cpu(*(uint32_t *)buf);
126 if (magic == VMDK3_MAGIC ||
127 magic == VMDK4_MAGIC) {
128 return 100;
129 } else {
130 const char *p = (const char *)buf;
131 const char *end = p + buf_size;
132 while (p < end) {
133 if (*p == '#') {
134 /* skip comment line */
135 while (p < end && *p != '\n') {
136 p++;
137 }
138 p++;
139 continue;
140 }
141 if (*p == ' ') {
142 while (p < end && *p == ' ') {
143 p++;
144 }
145 /* skip '\r' if windows line endings used. */
146 if (p < end && *p == '\r') {
147 p++;
148 }
149 /* only accept blank lines before 'version=' line */
150 if (p == end || *p != '\n') {
151 return 0;
152 }
153 p++;
154 continue;
155 }
156 if (end - p >= strlen("version=X\n")) {
157 if (strncmp("version=1\n", p, strlen("version=1\n")) == 0 ||
158 strncmp("version=2\n", p, strlen("version=2\n")) == 0) {
159 return 100;
160 }
161 }
162 if (end - p >= strlen("version=X\r\n")) {
163 if (strncmp("version=1\r\n", p, strlen("version=1\r\n")) == 0 ||
164 strncmp("version=2\r\n", p, strlen("version=2\r\n")) == 0) {
165 return 100;
166 }
167 }
168 return 0;
169 }
170 return 0;
171 }
172 }
173
174 #define CHECK_CID 1
175
176 #define SECTOR_SIZE 512
177 #define DESC_SIZE (20 * SECTOR_SIZE) /* 20 sectors of 512 bytes each */
178 #define BUF_SIZE 4096
179 #define HEADER_SIZE 512 /* first sector of 512 bytes */
180
181 static void vmdk_free_extents(BlockDriverState *bs)
182 {
183 int i;
184 BDRVVmdkState *s = bs->opaque;
185 VmdkExtent *e;
186
187 for (i = 0; i < s->num_extents; i++) {
188 e = &s->extents[i];
189 g_free(e->l1_table);
190 g_free(e->l2_cache);
191 g_free(e->l1_backup_table);
192 if (e->file != bs->file) {
193 bdrv_delete(e->file);
194 }
195 }
196 g_free(s->extents);
197 }
198
199 static void vmdk_free_last_extent(BlockDriverState *bs)
200 {
201 BDRVVmdkState *s = bs->opaque;
202
203 if (s->num_extents == 0) {
204 return;
205 }
206 s->num_extents--;
207 s->extents = g_realloc(s->extents, s->num_extents * sizeof(VmdkExtent));
208 }
209
210 static uint32_t vmdk_read_cid(BlockDriverState *bs, int parent)
211 {
212 char desc[DESC_SIZE];
213 uint32_t cid = 0xffffffff;
214 const char *p_name, *cid_str;
215 size_t cid_str_size;
216 BDRVVmdkState *s = bs->opaque;
217 int ret;
218
219 ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
220 if (ret < 0) {
221 return 0;
222 }
223
224 if (parent) {
225 cid_str = "parentCID";
226 cid_str_size = sizeof("parentCID");
227 } else {
228 cid_str = "CID";
229 cid_str_size = sizeof("CID");
230 }
231
232 desc[DESC_SIZE - 1] = '\0';
233 p_name = strstr(desc, cid_str);
234 if (p_name != NULL) {
235 p_name += cid_str_size;
236 sscanf(p_name, "%x", &cid);
237 }
238
239 return cid;
240 }
241
242 static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
243 {
244 char desc[DESC_SIZE], tmp_desc[DESC_SIZE];
245 char *p_name, *tmp_str;
246 BDRVVmdkState *s = bs->opaque;
247 int ret;
248
249 ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
250 if (ret < 0) {
251 return ret;
252 }
253
254 desc[DESC_SIZE - 1] = '\0';
255 tmp_str = strstr(desc, "parentCID");
256 if (tmp_str == NULL) {
257 return -EINVAL;
258 }
259
260 pstrcpy(tmp_desc, sizeof(tmp_desc), tmp_str);
261 p_name = strstr(desc, "CID");
262 if (p_name != NULL) {
263 p_name += sizeof("CID");
264 snprintf(p_name, sizeof(desc) - (p_name - desc), "%x\n", cid);
265 pstrcat(desc, sizeof(desc), tmp_desc);
266 }
267
268 ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE);
269 if (ret < 0) {
270 return ret;
271 }
272
273 return 0;
274 }
275
276 static int vmdk_is_cid_valid(BlockDriverState *bs)
277 {
278 #ifdef CHECK_CID
279 BDRVVmdkState *s = bs->opaque;
280 BlockDriverState *p_bs = bs->backing_hd;
281 uint32_t cur_pcid;
282
283 if (p_bs) {
284 cur_pcid = vmdk_read_cid(p_bs, 0);
285 if (s->parent_cid != cur_pcid) {
286 /* CID not valid */
287 return 0;
288 }
289 }
290 #endif
291 /* CID valid */
292 return 1;
293 }
294
295 static int vmdk_parent_open(BlockDriverState *bs)
296 {
297 char *p_name;
298 char desc[DESC_SIZE + 1];
299 BDRVVmdkState *s = bs->opaque;
300 int ret;
301
302 desc[DESC_SIZE] = '\0';
303 ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
304 if (ret < 0) {
305 return ret;
306 }
307
308 p_name = strstr(desc, "parentFileNameHint");
309 if (p_name != NULL) {
310 char *end_name;
311
312 p_name += sizeof("parentFileNameHint") + 1;
313 end_name = strchr(p_name, '\"');
314 if (end_name == NULL) {
315 return -EINVAL;
316 }
317 if ((end_name - p_name) > sizeof(bs->backing_file) - 1) {
318 return -EINVAL;
319 }
320
321 pstrcpy(bs->backing_file, end_name - p_name + 1, p_name);
322 }
323
324 return 0;
325 }
326
327 /* Create and append extent to the extent array. Return the added VmdkExtent
328 * address. return NULL if allocation failed. */
329 static VmdkExtent *vmdk_add_extent(BlockDriverState *bs,
330 BlockDriverState *file, bool flat, int64_t sectors,
331 int64_t l1_offset, int64_t l1_backup_offset,
332 uint32_t l1_size,
333 int l2_size, unsigned int cluster_sectors)
334 {
335 VmdkExtent *extent;
336 BDRVVmdkState *s = bs->opaque;
337
338 s->extents = g_realloc(s->extents,
339 (s->num_extents + 1) * sizeof(VmdkExtent));
340 extent = &s->extents[s->num_extents];
341 s->num_extents++;
342
343 memset(extent, 0, sizeof(VmdkExtent));
344 extent->file = file;
345 extent->flat = flat;
346 extent->sectors = sectors;
347 extent->l1_table_offset = l1_offset;
348 extent->l1_backup_table_offset = l1_backup_offset;
349 extent->l1_size = l1_size;
350 extent->l1_entry_sectors = l2_size * cluster_sectors;
351 extent->l2_size = l2_size;
352 extent->cluster_sectors = cluster_sectors;
353
354 if (s->num_extents > 1) {
355 extent->end_sector = (*(extent - 1)).end_sector + extent->sectors;
356 } else {
357 extent->end_sector = extent->sectors;
358 }
359 bs->total_sectors = extent->end_sector;
360 return extent;
361 }
362
363 static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent)
364 {
365 int ret;
366 int l1_size, i;
367
368 /* read the L1 table */
369 l1_size = extent->l1_size * sizeof(uint32_t);
370 extent->l1_table = g_malloc(l1_size);
371 ret = bdrv_pread(extent->file,
372 extent->l1_table_offset,
373 extent->l1_table,
374 l1_size);
375 if (ret < 0) {
376 goto fail_l1;
377 }
378 for (i = 0; i < extent->l1_size; i++) {
379 le32_to_cpus(&extent->l1_table[i]);
380 }
381
382 if (extent->l1_backup_table_offset) {
383 extent->l1_backup_table = g_malloc(l1_size);
384 ret = bdrv_pread(extent->file,
385 extent->l1_backup_table_offset,
386 extent->l1_backup_table,
387 l1_size);
388 if (ret < 0) {
389 goto fail_l1b;
390 }
391 for (i = 0; i < extent->l1_size; i++) {
392 le32_to_cpus(&extent->l1_backup_table[i]);
393 }
394 }
395
396 extent->l2_cache =
397 g_malloc(extent->l2_size * L2_CACHE_SIZE * sizeof(uint32_t));
398 return 0;
399 fail_l1b:
400 g_free(extent->l1_backup_table);
401 fail_l1:
402 g_free(extent->l1_table);
403 return ret;
404 }
405
406 static int vmdk_open_vmdk3(BlockDriverState *bs,
407 BlockDriverState *file,
408 int flags)
409 {
410 int ret;
411 uint32_t magic;
412 VMDK3Header header;
413 VmdkExtent *extent;
414
415 ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
416 if (ret < 0) {
417 return ret;
418 }
419 extent = vmdk_add_extent(bs,
420 bs->file, false,
421 le32_to_cpu(header.disk_sectors),
422 le32_to_cpu(header.l1dir_offset) << 9,
423 0, 1 << 6, 1 << 9,
424 le32_to_cpu(header.granularity));
425 ret = vmdk_init_tables(bs, extent);
426 if (ret) {
427 /* free extent allocated by vmdk_add_extent */
428 vmdk_free_last_extent(bs);
429 }
430 return ret;
431 }
432
433 static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
434 int64_t desc_offset);
435
436 static int vmdk_open_vmdk4(BlockDriverState *bs,
437 BlockDriverState *file,
438 int flags)
439 {
440 int ret;
441 uint32_t magic;
442 uint32_t l1_size, l1_entry_sectors;
443 VMDK4Header header;
444 VmdkExtent *extent;
445 int64_t l1_backup_offset = 0;
446
447 ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
448 if (ret < 0) {
449 return ret;
450 }
451 if (header.capacity == 0 && header.desc_offset) {
452 return vmdk_open_desc_file(bs, flags, header.desc_offset << 9);
453 }
454 l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gte)
455 * le64_to_cpu(header.granularity);
456 if (l1_entry_sectors <= 0) {
457 return -EINVAL;
458 }
459 l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)
460 / l1_entry_sectors;
461 if (le32_to_cpu(header.flags) & VMDK4_FLAG_RGD) {
462 l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9;
463 }
464 extent = vmdk_add_extent(bs, file, false,
465 le64_to_cpu(header.capacity),
466 le64_to_cpu(header.gd_offset) << 9,
467 l1_backup_offset,
468 l1_size,
469 le32_to_cpu(header.num_gtes_per_gte),
470 le64_to_cpu(header.granularity));
471 extent->compressed =
472 le16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE;
473 extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER;
474 ret = vmdk_init_tables(bs, extent);
475 if (ret) {
476 /* free extent allocated by vmdk_add_extent */
477 vmdk_free_last_extent(bs);
478 }
479 return ret;
480 }
481
482 /* find an option value out of descriptor file */
483 static int vmdk_parse_description(const char *desc, const char *opt_name,
484 char *buf, int buf_size)
485 {
486 char *opt_pos, *opt_end;
487 const char *end = desc + strlen(desc);
488
489 opt_pos = strstr(desc, opt_name);
490 if (!opt_pos) {
491 return -1;
492 }
493 /* Skip "=\"" following opt_name */
494 opt_pos += strlen(opt_name) + 2;
495 if (opt_pos >= end) {
496 return -1;
497 }
498 opt_end = opt_pos;
499 while (opt_end < end && *opt_end != '"') {
500 opt_end++;
501 }
502 if (opt_end == end || buf_size < opt_end - opt_pos + 1) {
503 return -1;
504 }
505 pstrcpy(buf, opt_end - opt_pos + 1, opt_pos);
506 return 0;
507 }
508
509 /* Open an extent file and append to bs array */
510 static int vmdk_open_sparse(BlockDriverState *bs,
511 BlockDriverState *file,
512 int flags)
513 {
514 uint32_t magic;
515
516 if (bdrv_pread(file, 0, &magic, sizeof(magic)) != sizeof(magic)) {
517 return -EIO;
518 }
519
520 magic = be32_to_cpu(magic);
521 switch (magic) {
522 case VMDK3_MAGIC:
523 return vmdk_open_vmdk3(bs, file, flags);
524 break;
525 case VMDK4_MAGIC:
526 return vmdk_open_vmdk4(bs, file, flags);
527 break;
528 default:
529 return -EINVAL;
530 break;
531 }
532 }
533
534 static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
535 const char *desc_file_path)
536 {
537 int ret;
538 char access[11];
539 char type[11];
540 char fname[512];
541 const char *p = desc;
542 int64_t sectors = 0;
543 int64_t flat_offset;
544 char extent_path[PATH_MAX];
545 BlockDriverState *extent_file;
546
547 while (*p) {
548 /* parse extent line:
549 * RW [size in sectors] FLAT "file-name.vmdk" OFFSET
550 * or
551 * RW [size in sectors] SPARSE "file-name.vmdk"
552 */
553 flat_offset = -1;
554 ret = sscanf(p, "%10s %" SCNd64 " %10s %511s %" SCNd64,
555 access, &sectors, type, fname, &flat_offset);
556 if (ret < 4 || strcmp(access, "RW")) {
557 goto next_line;
558 } else if (!strcmp(type, "FLAT")) {
559 if (ret != 5 || flat_offset < 0) {
560 return -EINVAL;
561 }
562 } else if (ret != 4) {
563 return -EINVAL;
564 }
565
566 /* trim the quotation marks around */
567 if (fname[0] == '"') {
568 memmove(fname, fname + 1, strlen(fname));
569 if (strlen(fname) <= 1 || fname[strlen(fname) - 1] != '"') {
570 return -EINVAL;
571 }
572 fname[strlen(fname) - 1] = '\0';
573 }
574 if (sectors <= 0 ||
575 (strcmp(type, "FLAT") && strcmp(type, "SPARSE")) ||
576 (strcmp(access, "RW"))) {
577 goto next_line;
578 }
579
580 path_combine(extent_path, sizeof(extent_path),
581 desc_file_path, fname);
582 ret = bdrv_file_open(&extent_file, extent_path, bs->open_flags);
583 if (ret) {
584 return ret;
585 }
586
587 /* save to extents array */
588 if (!strcmp(type, "FLAT")) {
589 /* FLAT extent */
590 VmdkExtent *extent;
591
592 extent = vmdk_add_extent(bs, extent_file, true, sectors,
593 0, 0, 0, 0, sectors);
594 extent->flat_start_offset = flat_offset << 9;
595 } else if (!strcmp(type, "SPARSE")) {
596 /* SPARSE extent */
597 ret = vmdk_open_sparse(bs, extent_file, bs->open_flags);
598 if (ret) {
599 bdrv_delete(extent_file);
600 return ret;
601 }
602 } else {
603 fprintf(stderr,
604 "VMDK: Not supported extent type \"%s\""".\n", type);
605 return -ENOTSUP;
606 }
607 next_line:
608 /* move to next line */
609 while (*p && *p != '\n') {
610 p++;
611 }
612 p++;
613 }
614 return 0;
615 }
616
617 static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
618 int64_t desc_offset)
619 {
620 int ret;
621 char buf[2048];
622 char ct[128];
623 BDRVVmdkState *s = bs->opaque;
624
625 ret = bdrv_pread(bs->file, desc_offset, buf, sizeof(buf));
626 if (ret < 0) {
627 return ret;
628 }
629 buf[2047] = '\0';
630 if (vmdk_parse_description(buf, "createType", ct, sizeof(ct))) {
631 return -EINVAL;
632 }
633 if (strcmp(ct, "monolithicFlat") &&
634 strcmp(ct, "twoGbMaxExtentSparse") &&
635 strcmp(ct, "twoGbMaxExtentFlat")) {
636 fprintf(stderr,
637 "VMDK: Not supported image type \"%s\""".\n", ct);
638 return -ENOTSUP;
639 }
640 s->desc_offset = 0;
641 return vmdk_parse_extents(buf, bs, bs->file->filename);
642 }
643
644 static int vmdk_open(BlockDriverState *bs, int flags)
645 {
646 int ret;
647 BDRVVmdkState *s = bs->opaque;
648
649 if (vmdk_open_sparse(bs, bs->file, flags) == 0) {
650 s->desc_offset = 0x200;
651 } else {
652 ret = vmdk_open_desc_file(bs, flags, 0);
653 if (ret) {
654 goto fail;
655 }
656 }
657 /* try to open parent images, if exist */
658 ret = vmdk_parent_open(bs);
659 if (ret) {
660 goto fail;
661 }
662 s->parent_cid = vmdk_read_cid(bs, 1);
663 qemu_co_mutex_init(&s->lock);
664
665 /* Disable migration when VMDK images are used */
666 error_set(&s->migration_blocker,
667 QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
668 "vmdk", bs->device_name, "live migration");
669 migrate_add_blocker(s->migration_blocker);
670
671 return 0;
672
673 fail:
674 vmdk_free_extents(bs);
675 return ret;
676 }
677
678 static int get_whole_cluster(BlockDriverState *bs,
679 VmdkExtent *extent,
680 uint64_t cluster_offset,
681 uint64_t offset,
682 bool allocate)
683 {
684 /* 128 sectors * 512 bytes each = grain size 64KB */
685 uint8_t whole_grain[extent->cluster_sectors * 512];
686
687 /* we will be here if it's first write on non-exist grain(cluster).
688 * try to read from parent image, if exist */
689 if (bs->backing_hd) {
690 int ret;
691
692 if (!vmdk_is_cid_valid(bs)) {
693 return -1;
694 }
695
696 /* floor offset to cluster */
697 offset -= offset % (extent->cluster_sectors * 512);
698 ret = bdrv_read(bs->backing_hd, offset >> 9, whole_grain,
699 extent->cluster_sectors);
700 if (ret < 0) {
701 return -1;
702 }
703
704 /* Write grain only into the active image */
705 ret = bdrv_write(extent->file, cluster_offset, whole_grain,
706 extent->cluster_sectors);
707 if (ret < 0) {
708 return -1;
709 }
710 }
711 return 0;
712 }
713
714 static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data)
715 {
716 /* update L2 table */
717 if (bdrv_pwrite_sync(
718 extent->file,
719 ((int64_t)m_data->l2_offset * 512)
720 + (m_data->l2_index * sizeof(m_data->offset)),
721 &(m_data->offset),
722 sizeof(m_data->offset)
723 ) < 0) {
724 return -1;
725 }
726 /* update backup L2 table */
727 if (extent->l1_backup_table_offset != 0) {
728 m_data->l2_offset = extent->l1_backup_table[m_data->l1_index];
729 if (bdrv_pwrite_sync(
730 extent->file,
731 ((int64_t)m_data->l2_offset * 512)
732 + (m_data->l2_index * sizeof(m_data->offset)),
733 &(m_data->offset), sizeof(m_data->offset)
734 ) < 0) {
735 return -1;
736 }
737 }
738
739 return 0;
740 }
741
742 static int get_cluster_offset(BlockDriverState *bs,
743 VmdkExtent *extent,
744 VmdkMetaData *m_data,
745 uint64_t offset,
746 int allocate,
747 uint64_t *cluster_offset)
748 {
749 unsigned int l1_index, l2_offset, l2_index;
750 int min_index, i, j;
751 uint32_t min_count, *l2_table, tmp = 0;
752
753 if (m_data) {
754 m_data->valid = 0;
755 }
756 if (extent->flat) {
757 *cluster_offset = extent->flat_start_offset;
758 return 0;
759 }
760
761 offset -= (extent->end_sector - extent->sectors) * SECTOR_SIZE;
762 l1_index = (offset >> 9) / extent->l1_entry_sectors;
763 if (l1_index >= extent->l1_size) {
764 return -1;
765 }
766 l2_offset = extent->l1_table[l1_index];
767 if (!l2_offset) {
768 return -1;
769 }
770 for (i = 0; i < L2_CACHE_SIZE; i++) {
771 if (l2_offset == extent->l2_cache_offsets[i]) {
772 /* increment the hit count */
773 if (++extent->l2_cache_counts[i] == 0xffffffff) {
774 for (j = 0; j < L2_CACHE_SIZE; j++) {
775 extent->l2_cache_counts[j] >>= 1;
776 }
777 }
778 l2_table = extent->l2_cache + (i * extent->l2_size);
779 goto found;
780 }
781 }
782 /* not found: load a new entry in the least used one */
783 min_index = 0;
784 min_count = 0xffffffff;
785 for (i = 0; i < L2_CACHE_SIZE; i++) {
786 if (extent->l2_cache_counts[i] < min_count) {
787 min_count = extent->l2_cache_counts[i];
788 min_index = i;
789 }
790 }
791 l2_table = extent->l2_cache + (min_index * extent->l2_size);
792 if (bdrv_pread(
793 extent->file,
794 (int64_t)l2_offset * 512,
795 l2_table,
796 extent->l2_size * sizeof(uint32_t)
797 ) != extent->l2_size * sizeof(uint32_t)) {
798 return -1;
799 }
800
801 extent->l2_cache_offsets[min_index] = l2_offset;
802 extent->l2_cache_counts[min_index] = 1;
803 found:
804 l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size;
805 *cluster_offset = le32_to_cpu(l2_table[l2_index]);
806
807 if (!*cluster_offset) {
808 if (!allocate) {
809 return -1;
810 }
811
812 /* Avoid the L2 tables update for the images that have snapshots. */
813 *cluster_offset = bdrv_getlength(extent->file);
814 if (!extent->compressed) {
815 bdrv_truncate(
816 extent->file,
817 *cluster_offset + (extent->cluster_sectors << 9)
818 );
819 }
820
821 *cluster_offset >>= 9;
822 tmp = cpu_to_le32(*cluster_offset);
823 l2_table[l2_index] = tmp;
824
825 /* First of all we write grain itself, to avoid race condition
826 * that may to corrupt the image.
827 * This problem may occur because of insufficient space on host disk
828 * or inappropriate VM shutdown.
829 */
830 if (get_whole_cluster(
831 bs, extent, *cluster_offset, offset, allocate) == -1) {
832 return -1;
833 }
834
835 if (m_data) {
836 m_data->offset = tmp;
837 m_data->l1_index = l1_index;
838 m_data->l2_index = l2_index;
839 m_data->l2_offset = l2_offset;
840 m_data->valid = 1;
841 }
842 }
843 *cluster_offset <<= 9;
844 return 0;
845 }
846
847 static VmdkExtent *find_extent(BDRVVmdkState *s,
848 int64_t sector_num, VmdkExtent *start_hint)
849 {
850 VmdkExtent *extent = start_hint;
851
852 if (!extent) {
853 extent = &s->extents[0];
854 }
855 while (extent < &s->extents[s->num_extents]) {
856 if (sector_num < extent->end_sector) {
857 return extent;
858 }
859 extent++;
860 }
861 return NULL;
862 }
863
864 static int vmdk_is_allocated(BlockDriverState *bs, int64_t sector_num,
865 int nb_sectors, int *pnum)
866 {
867 BDRVVmdkState *s = bs->opaque;
868 int64_t index_in_cluster, n, ret;
869 uint64_t offset;
870 VmdkExtent *extent;
871
872 extent = find_extent(s, sector_num, NULL);
873 if (!extent) {
874 return 0;
875 }
876 ret = get_cluster_offset(bs, extent, NULL,
877 sector_num * 512, 0, &offset);
878 /* get_cluster_offset returning 0 means success */
879 ret = !ret;
880
881 index_in_cluster = sector_num % extent->cluster_sectors;
882 n = extent->cluster_sectors - index_in_cluster;
883 if (n > nb_sectors) {
884 n = nb_sectors;
885 }
886 *pnum = n;
887 return ret;
888 }
889
890 static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
891 int64_t offset_in_cluster, const uint8_t *buf,
892 int nb_sectors, int64_t sector_num)
893 {
894 int ret;
895 VmdkGrainMarker *data = NULL;
896 uLongf buf_len;
897 const uint8_t *write_buf = buf;
898 int write_len = nb_sectors * 512;
899
900 if (extent->compressed) {
901 if (!extent->has_marker) {
902 ret = -EINVAL;
903 goto out;
904 }
905 buf_len = (extent->cluster_sectors << 9) * 2;
906 data = g_malloc(buf_len + sizeof(VmdkGrainMarker));
907 if (compress(data->data, &buf_len, buf, nb_sectors << 9) != Z_OK ||
908 buf_len == 0) {
909 ret = -EINVAL;
910 goto out;
911 }
912 data->lba = sector_num;
913 data->size = buf_len;
914 write_buf = (uint8_t *)data;
915 write_len = buf_len + sizeof(VmdkGrainMarker);
916 }
917 ret = bdrv_pwrite(extent->file,
918 cluster_offset + offset_in_cluster,
919 write_buf,
920 write_len);
921 if (ret != write_len) {
922 ret = ret < 0 ? ret : -EIO;
923 goto out;
924 }
925 ret = 0;
926 out:
927 g_free(data);
928 return ret;
929 }
930
931 static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
932 int64_t offset_in_cluster, uint8_t *buf,
933 int nb_sectors)
934 {
935 int ret;
936 int cluster_bytes, buf_bytes;
937 uint8_t *cluster_buf, *compressed_data;
938 uint8_t *uncomp_buf;
939 uint32_t data_len;
940 VmdkGrainMarker *marker;
941 uLongf buf_len;
942
943
944 if (!extent->compressed) {
945 ret = bdrv_pread(extent->file,
946 cluster_offset + offset_in_cluster,
947 buf, nb_sectors * 512);
948 if (ret == nb_sectors * 512) {
949 return 0;
950 } else {
951 return -EIO;
952 }
953 }
954 cluster_bytes = extent->cluster_sectors * 512;
955 /* Read two clusters in case GrainMarker + compressed data > one cluster */
956 buf_bytes = cluster_bytes * 2;
957 cluster_buf = g_malloc(buf_bytes);
958 uncomp_buf = g_malloc(cluster_bytes);
959 ret = bdrv_pread(extent->file,
960 cluster_offset,
961 cluster_buf, buf_bytes);
962 if (ret < 0) {
963 goto out;
964 }
965 compressed_data = cluster_buf;
966 buf_len = cluster_bytes;
967 data_len = cluster_bytes;
968 if (extent->has_marker) {
969 marker = (VmdkGrainMarker *)cluster_buf;
970 compressed_data = marker->data;
971 data_len = le32_to_cpu(marker->size);
972 }
973 if (!data_len || data_len > buf_bytes) {
974 ret = -EINVAL;
975 goto out;
976 }
977 ret = uncompress(uncomp_buf, &buf_len, compressed_data, data_len);
978 if (ret != Z_OK) {
979 ret = -EINVAL;
980 goto out;
981
982 }
983 if (offset_in_cluster < 0 ||
984 offset_in_cluster + nb_sectors * 512 > buf_len) {
985 ret = -EINVAL;
986 goto out;
987 }
988 memcpy(buf, uncomp_buf + offset_in_cluster, nb_sectors * 512);
989 ret = 0;
990
991 out:
992 g_free(uncomp_buf);
993 g_free(cluster_buf);
994 return ret;
995 }
996
997 static int vmdk_read(BlockDriverState *bs, int64_t sector_num,
998 uint8_t *buf, int nb_sectors)
999 {
1000 BDRVVmdkState *s = bs->opaque;
1001 int ret;
1002 uint64_t n, index_in_cluster;
1003 VmdkExtent *extent = NULL;
1004 uint64_t cluster_offset;
1005
1006 while (nb_sectors > 0) {
1007 extent = find_extent(s, sector_num, extent);
1008 if (!extent) {
1009 return -EIO;
1010 }
1011 ret = get_cluster_offset(
1012 bs, extent, NULL,
1013 sector_num << 9, 0, &cluster_offset);
1014 index_in_cluster = sector_num % extent->cluster_sectors;
1015 n = extent->cluster_sectors - index_in_cluster;
1016 if (n > nb_sectors) {
1017 n = nb_sectors;
1018 }
1019 if (ret) {
1020 /* if not allocated, try to read from parent image, if exist */
1021 if (bs->backing_hd) {
1022 if (!vmdk_is_cid_valid(bs)) {
1023 return -EINVAL;
1024 }
1025 ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
1026 if (ret < 0) {
1027 return ret;
1028 }
1029 } else {
1030 memset(buf, 0, 512 * n);
1031 }
1032 } else {
1033 ret = vmdk_read_extent(extent,
1034 cluster_offset, index_in_cluster * 512,
1035 buf, n);
1036 if (ret) {
1037 return ret;
1038 }
1039 }
1040 nb_sectors -= n;
1041 sector_num += n;
1042 buf += n * 512;
1043 }
1044 return 0;
1045 }
1046
1047 static coroutine_fn int vmdk_co_read(BlockDriverState *bs, int64_t sector_num,
1048 uint8_t *buf, int nb_sectors)
1049 {
1050 int ret;
1051 BDRVVmdkState *s = bs->opaque;
1052 qemu_co_mutex_lock(&s->lock);
1053 ret = vmdk_read(bs, sector_num, buf, nb_sectors);
1054 qemu_co_mutex_unlock(&s->lock);
1055 return ret;
1056 }
1057
1058 static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
1059 const uint8_t *buf, int nb_sectors)
1060 {
1061 BDRVVmdkState *s = bs->opaque;
1062 VmdkExtent *extent = NULL;
1063 int n, ret;
1064 int64_t index_in_cluster;
1065 uint64_t cluster_offset;
1066 VmdkMetaData m_data;
1067
1068 if (sector_num > bs->total_sectors) {
1069 fprintf(stderr,
1070 "(VMDK) Wrong offset: sector_num=0x%" PRIx64
1071 " total_sectors=0x%" PRIx64 "\n",
1072 sector_num, bs->total_sectors);
1073 return -EIO;
1074 }
1075
1076 while (nb_sectors > 0) {
1077 extent = find_extent(s, sector_num, extent);
1078 if (!extent) {
1079 return -EIO;
1080 }
1081 ret = get_cluster_offset(
1082 bs,
1083 extent,
1084 &m_data,
1085 sector_num << 9, !extent->compressed,
1086 &cluster_offset);
1087 if (extent->compressed) {
1088 if (ret == 0) {
1089 /* Refuse write to allocated cluster for streamOptimized */
1090 fprintf(stderr,
1091 "VMDK: can't write to allocated cluster"
1092 " for streamOptimized\n");
1093 return -EIO;
1094 } else {
1095 /* allocate */
1096 ret = get_cluster_offset(
1097 bs,
1098 extent,
1099 &m_data,
1100 sector_num << 9, 1,
1101 &cluster_offset);
1102 }
1103 }
1104 if (ret) {
1105 return -EINVAL;
1106 }
1107 index_in_cluster = sector_num % extent->cluster_sectors;
1108 n = extent->cluster_sectors - index_in_cluster;
1109 if (n > nb_sectors) {
1110 n = nb_sectors;
1111 }
1112
1113 ret = vmdk_write_extent(extent,
1114 cluster_offset, index_in_cluster * 512,
1115 buf, n, sector_num);
1116 if (ret) {
1117 return ret;
1118 }
1119 if (m_data.valid) {
1120 /* update L2 tables */
1121 if (vmdk_L2update(extent, &m_data) == -1) {
1122 return -EIO;
1123 }
1124 }
1125 nb_sectors -= n;
1126 sector_num += n;
1127 buf += n * 512;
1128
1129 /* update CID on the first write every time the virtual disk is
1130 * opened */
1131 if (!s->cid_updated) {
1132 ret = vmdk_write_cid(bs, time(NULL));
1133 if (ret < 0) {
1134 return ret;
1135 }
1136 s->cid_updated = true;
1137 }
1138 }
1139 return 0;
1140 }
1141
1142 static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num,
1143 const uint8_t *buf, int nb_sectors)
1144 {
1145 int ret;
1146 BDRVVmdkState *s = bs->opaque;
1147 qemu_co_mutex_lock(&s->lock);
1148 ret = vmdk_write(bs, sector_num, buf, nb_sectors);
1149 qemu_co_mutex_unlock(&s->lock);
1150 return ret;
1151 }
1152
1153
1154 static int vmdk_create_extent(const char *filename, int64_t filesize,
1155 bool flat, bool compress)
1156 {
1157 int ret, i;
1158 int fd = 0;
1159 VMDK4Header header;
1160 uint32_t tmp, magic, grains, gd_size, gt_size, gt_count;
1161
1162 fd = open(
1163 filename,
1164 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
1165 0644);
1166 if (fd < 0) {
1167 return -errno;
1168 }
1169 if (flat) {
1170 ret = ftruncate(fd, filesize);
1171 if (ret < 0) {
1172 ret = -errno;
1173 }
1174 goto exit;
1175 }
1176 magic = cpu_to_be32(VMDK4_MAGIC);
1177 memset(&header, 0, sizeof(header));
1178 header.version = 1;
1179 header.flags =
1180 3 | (compress ? VMDK4_FLAG_COMPRESS | VMDK4_FLAG_MARKER : 0);
1181 header.compressAlgorithm = compress ? VMDK4_COMPRESSION_DEFLATE : 0;
1182 header.capacity = filesize / 512;
1183 header.granularity = 128;
1184 header.num_gtes_per_gte = 512;
1185
1186 grains = (filesize / 512 + header.granularity - 1) / header.granularity;
1187 gt_size = ((header.num_gtes_per_gte * sizeof(uint32_t)) + 511) >> 9;
1188 gt_count =
1189 (grains + header.num_gtes_per_gte - 1) / header.num_gtes_per_gte;
1190 gd_size = (gt_count * sizeof(uint32_t) + 511) >> 9;
1191
1192 header.desc_offset = 1;
1193 header.desc_size = 20;
1194 header.rgd_offset = header.desc_offset + header.desc_size;
1195 header.gd_offset = header.rgd_offset + gd_size + (gt_size * gt_count);
1196 header.grain_offset =
1197 ((header.gd_offset + gd_size + (gt_size * gt_count) +
1198 header.granularity - 1) / header.granularity) *
1199 header.granularity;
1200 /* swap endianness for all header fields */
1201 header.version = cpu_to_le32(header.version);
1202 header.flags = cpu_to_le32(header.flags);
1203 header.capacity = cpu_to_le64(header.capacity);
1204 header.granularity = cpu_to_le64(header.granularity);
1205 header.num_gtes_per_gte = cpu_to_le32(header.num_gtes_per_gte);
1206 header.desc_offset = cpu_to_le64(header.desc_offset);
1207 header.desc_size = cpu_to_le64(header.desc_size);
1208 header.rgd_offset = cpu_to_le64(header.rgd_offset);
1209 header.gd_offset = cpu_to_le64(header.gd_offset);
1210 header.grain_offset = cpu_to_le64(header.grain_offset);
1211 header.compressAlgorithm = cpu_to_le16(header.compressAlgorithm);
1212
1213 header.check_bytes[0] = 0xa;
1214 header.check_bytes[1] = 0x20;
1215 header.check_bytes[2] = 0xd;
1216 header.check_bytes[3] = 0xa;
1217
1218 /* write all the data */
1219 ret = qemu_write_full(fd, &magic, sizeof(magic));
1220 if (ret != sizeof(magic)) {
1221 ret = -errno;
1222 goto exit;
1223 }
1224 ret = qemu_write_full(fd, &header, sizeof(header));
1225 if (ret != sizeof(header)) {
1226 ret = -errno;
1227 goto exit;
1228 }
1229
1230 ret = ftruncate(fd, le64_to_cpu(header.grain_offset) << 9);
1231 if (ret < 0) {
1232 ret = -errno;
1233 goto exit;
1234 }
1235
1236 /* write grain directory */
1237 lseek(fd, le64_to_cpu(header.rgd_offset) << 9, SEEK_SET);
1238 for (i = 0, tmp = le64_to_cpu(header.rgd_offset) + gd_size;
1239 i < gt_count; i++, tmp += gt_size) {
1240 ret = qemu_write_full(fd, &tmp, sizeof(tmp));
1241 if (ret != sizeof(tmp)) {
1242 ret = -errno;
1243 goto exit;
1244 }
1245 }
1246
1247 /* write backup grain directory */
1248 lseek(fd, le64_to_cpu(header.gd_offset) << 9, SEEK_SET);
1249 for (i = 0, tmp = le64_to_cpu(header.gd_offset) + gd_size;
1250 i < gt_count; i++, tmp += gt_size) {
1251 ret = qemu_write_full(fd, &tmp, sizeof(tmp));
1252 if (ret != sizeof(tmp)) {
1253 ret = -errno;
1254 goto exit;
1255 }
1256 }
1257
1258 ret = 0;
1259 exit:
1260 close(fd);
1261 return ret;
1262 }
1263
1264 static int filename_decompose(const char *filename, char *path, char *prefix,
1265 char *postfix, size_t buf_len)
1266 {
1267 const char *p, *q;
1268
1269 if (filename == NULL || !strlen(filename)) {
1270 fprintf(stderr, "Vmdk: no filename provided.\n");
1271 return -1;
1272 }
1273 p = strrchr(filename, '/');
1274 if (p == NULL) {
1275 p = strrchr(filename, '\\');
1276 }
1277 if (p == NULL) {
1278 p = strrchr(filename, ':');
1279 }
1280 if (p != NULL) {
1281 p++;
1282 if (p - filename >= buf_len) {
1283 return -1;
1284 }
1285 pstrcpy(path, p - filename + 1, filename);
1286 } else {
1287 p = filename;
1288 path[0] = '\0';
1289 }
1290 q = strrchr(p, '.');
1291 if (q == NULL) {
1292 pstrcpy(prefix, buf_len, p);
1293 postfix[0] = '\0';
1294 } else {
1295 if (q - p >= buf_len) {
1296 return -1;
1297 }
1298 pstrcpy(prefix, q - p + 1, p);
1299 pstrcpy(postfix, buf_len, q);
1300 }
1301 return 0;
1302 }
1303
1304 static int relative_path(char *dest, int dest_size,
1305 const char *base, const char *target)
1306 {
1307 int i = 0;
1308 int n = 0;
1309 const char *p, *q;
1310 #ifdef _WIN32
1311 const char *sep = "\\";
1312 #else
1313 const char *sep = "/";
1314 #endif
1315
1316 if (!(dest && base && target)) {
1317 return -1;
1318 }
1319 if (path_is_absolute(target)) {
1320 dest[dest_size - 1] = '\0';
1321 strncpy(dest, target, dest_size - 1);
1322 return 0;
1323 }
1324 while (base[i] == target[i]) {
1325 i++;
1326 }
1327 p = &base[i];
1328 q = &target[i];
1329 while (*p) {
1330 if (*p == *sep) {
1331 n++;
1332 }
1333 p++;
1334 }
1335 dest[0] = '\0';
1336 for (; n; n--) {
1337 pstrcat(dest, dest_size, "..");
1338 pstrcat(dest, dest_size, sep);
1339 }
1340 pstrcat(dest, dest_size, q);
1341 return 0;
1342 }
1343
1344 static int vmdk_create(const char *filename, QEMUOptionParameter *options)
1345 {
1346 int fd, idx = 0;
1347 char desc[BUF_SIZE];
1348 int64_t total_size = 0, filesize;
1349 const char *backing_file = NULL;
1350 const char *fmt = NULL;
1351 int flags = 0;
1352 int ret = 0;
1353 bool flat, split, compress;
1354 char ext_desc_lines[BUF_SIZE] = "";
1355 char path[PATH_MAX], prefix[PATH_MAX], postfix[PATH_MAX];
1356 const int64_t split_size = 0x80000000; /* VMDK has constant split size */
1357 const char *desc_extent_line;
1358 char parent_desc_line[BUF_SIZE] = "";
1359 uint32_t parent_cid = 0xffffffff;
1360 const char desc_template[] =
1361 "# Disk DescriptorFile\n"
1362 "version=1\n"
1363 "CID=%x\n"
1364 "parentCID=%x\n"
1365 "createType=\"%s\"\n"
1366 "%s"
1367 "\n"
1368 "# Extent description\n"
1369 "%s"
1370 "\n"
1371 "# The Disk Data Base\n"
1372 "#DDB\n"
1373 "\n"
1374 "ddb.virtualHWVersion = \"%d\"\n"
1375 "ddb.geometry.cylinders = \"%" PRId64 "\"\n"
1376 "ddb.geometry.heads = \"16\"\n"
1377 "ddb.geometry.sectors = \"63\"\n"
1378 "ddb.adapterType = \"ide\"\n";
1379
1380 if (filename_decompose(filename, path, prefix, postfix, PATH_MAX)) {
1381 return -EINVAL;
1382 }
1383 /* Read out options */
1384 while (options && options->name) {
1385 if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1386 total_size = options->value.n;
1387 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
1388 backing_file = options->value.s;
1389 } else if (!strcmp(options->name, BLOCK_OPT_COMPAT6)) {
1390 flags |= options->value.n ? BLOCK_FLAG_COMPAT6 : 0;
1391 } else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) {
1392 fmt = options->value.s;
1393 }
1394 options++;
1395 }
1396 if (!fmt) {
1397 /* Default format to monolithicSparse */
1398 fmt = "monolithicSparse";
1399 } else if (strcmp(fmt, "monolithicFlat") &&
1400 strcmp(fmt, "monolithicSparse") &&
1401 strcmp(fmt, "twoGbMaxExtentSparse") &&
1402 strcmp(fmt, "twoGbMaxExtentFlat") &&
1403 strcmp(fmt, "streamOptimized")) {
1404 fprintf(stderr, "VMDK: Unknown subformat: %s\n", fmt);
1405 return -EINVAL;
1406 }
1407 split = !(strcmp(fmt, "twoGbMaxExtentFlat") &&
1408 strcmp(fmt, "twoGbMaxExtentSparse"));
1409 flat = !(strcmp(fmt, "monolithicFlat") &&
1410 strcmp(fmt, "twoGbMaxExtentFlat"));
1411 compress = !strcmp(fmt, "streamOptimized");
1412 if (flat) {
1413 desc_extent_line = "RW %lld FLAT \"%s\" 0\n";
1414 } else {
1415 desc_extent_line = "RW %lld SPARSE \"%s\"\n";
1416 }
1417 if (flat && backing_file) {
1418 /* not supporting backing file for flat image */
1419 return -ENOTSUP;
1420 }
1421 if (backing_file) {
1422 char parent_filename[PATH_MAX];
1423 BlockDriverState *bs = bdrv_new("");
1424 ret = bdrv_open(bs, backing_file, 0, NULL);
1425 if (ret != 0) {
1426 bdrv_delete(bs);
1427 return ret;
1428 }
1429 if (strcmp(bs->drv->format_name, "vmdk")) {
1430 bdrv_delete(bs);
1431 return -EINVAL;
1432 }
1433 parent_cid = vmdk_read_cid(bs, 0);
1434 bdrv_delete(bs);
1435 relative_path(parent_filename, sizeof(parent_filename),
1436 filename, backing_file);
1437 snprintf(parent_desc_line, sizeof(parent_desc_line),
1438 "parentFileNameHint=\"%s\"", parent_filename);
1439 }
1440
1441 /* Create extents */
1442 filesize = total_size;
1443 while (filesize > 0) {
1444 char desc_line[BUF_SIZE];
1445 char ext_filename[PATH_MAX];
1446 char desc_filename[PATH_MAX];
1447 int64_t size = filesize;
1448
1449 if (split && size > split_size) {
1450 size = split_size;
1451 }
1452 if (split) {
1453 snprintf(desc_filename, sizeof(desc_filename), "%s-%c%03d%s",
1454 prefix, flat ? 'f' : 's', ++idx, postfix);
1455 } else if (flat) {
1456 snprintf(desc_filename, sizeof(desc_filename), "%s-flat%s",
1457 prefix, postfix);
1458 } else {
1459 snprintf(desc_filename, sizeof(desc_filename), "%s%s",
1460 prefix, postfix);
1461 }
1462 snprintf(ext_filename, sizeof(ext_filename), "%s%s",
1463 path, desc_filename);
1464
1465 if (vmdk_create_extent(ext_filename, size, flat, compress)) {
1466 return -EINVAL;
1467 }
1468 filesize -= size;
1469
1470 /* Format description line */
1471 snprintf(desc_line, sizeof(desc_line),
1472 desc_extent_line, size / 512, desc_filename);
1473 pstrcat(ext_desc_lines, sizeof(ext_desc_lines), desc_line);
1474 }
1475 /* generate descriptor file */
1476 snprintf(desc, sizeof(desc), desc_template,
1477 (unsigned int)time(NULL),
1478 parent_cid,
1479 fmt,
1480 parent_desc_line,
1481 ext_desc_lines,
1482 (flags & BLOCK_FLAG_COMPAT6 ? 6 : 4),
1483 total_size / (int64_t)(63 * 16 * 512));
1484 if (split || flat) {
1485 fd = open(
1486 filename,
1487 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
1488 0644);
1489 } else {
1490 fd = open(
1491 filename,
1492 O_WRONLY | O_BINARY | O_LARGEFILE,
1493 0644);
1494 }
1495 if (fd < 0) {
1496 return -errno;
1497 }
1498 /* the descriptor offset = 0x200 */
1499 if (!split && !flat && 0x200 != lseek(fd, 0x200, SEEK_SET)) {
1500 ret = -errno;
1501 goto exit;
1502 }
1503 ret = qemu_write_full(fd, desc, strlen(desc));
1504 if (ret != strlen(desc)) {
1505 ret = -errno;
1506 goto exit;
1507 }
1508 ret = 0;
1509 exit:
1510 close(fd);
1511 return ret;
1512 }
1513
1514 static void vmdk_close(BlockDriverState *bs)
1515 {
1516 BDRVVmdkState *s = bs->opaque;
1517
1518 vmdk_free_extents(bs);
1519
1520 migrate_del_blocker(s->migration_blocker);
1521 error_free(s->migration_blocker);
1522 }
1523
1524 static coroutine_fn int vmdk_co_flush(BlockDriverState *bs)
1525 {
1526 int i, ret, err;
1527 BDRVVmdkState *s = bs->opaque;
1528
1529 ret = bdrv_co_flush(bs->file);
1530 for (i = 0; i < s->num_extents; i++) {
1531 err = bdrv_co_flush(s->extents[i].file);
1532 if (err < 0) {
1533 ret = err;
1534 }
1535 }
1536 return ret;
1537 }
1538
1539 static int64_t vmdk_get_allocated_file_size(BlockDriverState *bs)
1540 {
1541 int i;
1542 int64_t ret = 0;
1543 int64_t r;
1544 BDRVVmdkState *s = bs->opaque;
1545
1546 ret = bdrv_get_allocated_file_size(bs->file);
1547 if (ret < 0) {
1548 return ret;
1549 }
1550 for (i = 0; i < s->num_extents; i++) {
1551 if (s->extents[i].file == bs->file) {
1552 continue;
1553 }
1554 r = bdrv_get_allocated_file_size(s->extents[i].file);
1555 if (r < 0) {
1556 return r;
1557 }
1558 ret += r;
1559 }
1560 return ret;
1561 }
1562
1563 static QEMUOptionParameter vmdk_create_options[] = {
1564 {
1565 .name = BLOCK_OPT_SIZE,
1566 .type = OPT_SIZE,
1567 .help = "Virtual disk size"
1568 },
1569 {
1570 .name = BLOCK_OPT_BACKING_FILE,
1571 .type = OPT_STRING,
1572 .help = "File name of a base image"
1573 },
1574 {
1575 .name = BLOCK_OPT_COMPAT6,
1576 .type = OPT_FLAG,
1577 .help = "VMDK version 6 image"
1578 },
1579 {
1580 .name = BLOCK_OPT_SUBFMT,
1581 .type = OPT_STRING,
1582 .help =
1583 "VMDK flat extent format, can be one of "
1584 "{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
1585 },
1586 { NULL }
1587 };
1588
1589 static BlockDriver bdrv_vmdk = {
1590 .format_name = "vmdk",
1591 .instance_size = sizeof(BDRVVmdkState),
1592 .bdrv_probe = vmdk_probe,
1593 .bdrv_open = vmdk_open,
1594 .bdrv_read = vmdk_co_read,
1595 .bdrv_write = vmdk_co_write,
1596 .bdrv_close = vmdk_close,
1597 .bdrv_create = vmdk_create,
1598 .bdrv_co_flush_to_disk = vmdk_co_flush,
1599 .bdrv_is_allocated = vmdk_is_allocated,
1600 .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size,
1601
1602 .create_options = vmdk_create_options,
1603 };
1604
1605 static void bdrv_vmdk_init(void)
1606 {
1607 bdrv_register(&bdrv_vmdk);
1608 }
1609
1610 block_init(bdrv_vmdk_init);
Qemu copy for testing