usb-bsd: convert to QOM
[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 coroutine_fn vmdk_co_is_allocated(BlockDriverState *bs,
865 int64_t sector_num, 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 qemu_co_mutex_lock(&s->lock);
877 ret = get_cluster_offset(bs, extent, NULL,
878 sector_num * 512, 0, &offset);
879 qemu_co_mutex_unlock(&s->lock);
880 /* get_cluster_offset returning 0 means success */
881 ret = !ret;
882
883 index_in_cluster = sector_num % extent->cluster_sectors;
884 n = extent->cluster_sectors - index_in_cluster;
885 if (n > nb_sectors) {
886 n = nb_sectors;
887 }
888 *pnum = n;
889 return ret;
890 }
891
892 static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
893 int64_t offset_in_cluster, const uint8_t *buf,
894 int nb_sectors, int64_t sector_num)
895 {
896 int ret;
897 VmdkGrainMarker *data = NULL;
898 uLongf buf_len;
899 const uint8_t *write_buf = buf;
900 int write_len = nb_sectors * 512;
901
902 if (extent->compressed) {
903 if (!extent->has_marker) {
904 ret = -EINVAL;
905 goto out;
906 }
907 buf_len = (extent->cluster_sectors << 9) * 2;
908 data = g_malloc(buf_len + sizeof(VmdkGrainMarker));
909 if (compress(data->data, &buf_len, buf, nb_sectors << 9) != Z_OK ||
910 buf_len == 0) {
911 ret = -EINVAL;
912 goto out;
913 }
914 data->lba = sector_num;
915 data->size = buf_len;
916 write_buf = (uint8_t *)data;
917 write_len = buf_len + sizeof(VmdkGrainMarker);
918 }
919 ret = bdrv_pwrite(extent->file,
920 cluster_offset + offset_in_cluster,
921 write_buf,
922 write_len);
923 if (ret != write_len) {
924 ret = ret < 0 ? ret : -EIO;
925 goto out;
926 }
927 ret = 0;
928 out:
929 g_free(data);
930 return ret;
931 }
932
933 static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
934 int64_t offset_in_cluster, uint8_t *buf,
935 int nb_sectors)
936 {
937 int ret;
938 int cluster_bytes, buf_bytes;
939 uint8_t *cluster_buf, *compressed_data;
940 uint8_t *uncomp_buf;
941 uint32_t data_len;
942 VmdkGrainMarker *marker;
943 uLongf buf_len;
944
945
946 if (!extent->compressed) {
947 ret = bdrv_pread(extent->file,
948 cluster_offset + offset_in_cluster,
949 buf, nb_sectors * 512);
950 if (ret == nb_sectors * 512) {
951 return 0;
952 } else {
953 return -EIO;
954 }
955 }
956 cluster_bytes = extent->cluster_sectors * 512;
957 /* Read two clusters in case GrainMarker + compressed data > one cluster */
958 buf_bytes = cluster_bytes * 2;
959 cluster_buf = g_malloc(buf_bytes);
960 uncomp_buf = g_malloc(cluster_bytes);
961 ret = bdrv_pread(extent->file,
962 cluster_offset,
963 cluster_buf, buf_bytes);
964 if (ret < 0) {
965 goto out;
966 }
967 compressed_data = cluster_buf;
968 buf_len = cluster_bytes;
969 data_len = cluster_bytes;
970 if (extent->has_marker) {
971 marker = (VmdkGrainMarker *)cluster_buf;
972 compressed_data = marker->data;
973 data_len = le32_to_cpu(marker->size);
974 }
975 if (!data_len || data_len > buf_bytes) {
976 ret = -EINVAL;
977 goto out;
978 }
979 ret = uncompress(uncomp_buf, &buf_len, compressed_data, data_len);
980 if (ret != Z_OK) {
981 ret = -EINVAL;
982 goto out;
983
984 }
985 if (offset_in_cluster < 0 ||
986 offset_in_cluster + nb_sectors * 512 > buf_len) {
987 ret = -EINVAL;
988 goto out;
989 }
990 memcpy(buf, uncomp_buf + offset_in_cluster, nb_sectors * 512);
991 ret = 0;
992
993 out:
994 g_free(uncomp_buf);
995 g_free(cluster_buf);
996 return ret;
997 }
998
999 static int vmdk_read(BlockDriverState *bs, int64_t sector_num,
1000 uint8_t *buf, int nb_sectors)
1001 {
1002 BDRVVmdkState *s = bs->opaque;
1003 int ret;
1004 uint64_t n, index_in_cluster;
1005 VmdkExtent *extent = NULL;
1006 uint64_t cluster_offset;
1007
1008 while (nb_sectors > 0) {
1009 extent = find_extent(s, sector_num, extent);
1010 if (!extent) {
1011 return -EIO;
1012 }
1013 ret = get_cluster_offset(
1014 bs, extent, NULL,
1015 sector_num << 9, 0, &cluster_offset);
1016 index_in_cluster = sector_num % extent->cluster_sectors;
1017 n = extent->cluster_sectors - index_in_cluster;
1018 if (n > nb_sectors) {
1019 n = nb_sectors;
1020 }
1021 if (ret) {
1022 /* if not allocated, try to read from parent image, if exist */
1023 if (bs->backing_hd) {
1024 if (!vmdk_is_cid_valid(bs)) {
1025 return -EINVAL;
1026 }
1027 ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
1028 if (ret < 0) {
1029 return ret;
1030 }
1031 } else {
1032 memset(buf, 0, 512 * n);
1033 }
1034 } else {
1035 ret = vmdk_read_extent(extent,
1036 cluster_offset, index_in_cluster * 512,
1037 buf, n);
1038 if (ret) {
1039 return ret;
1040 }
1041 }
1042 nb_sectors -= n;
1043 sector_num += n;
1044 buf += n * 512;
1045 }
1046 return 0;
1047 }
1048
1049 static coroutine_fn int vmdk_co_read(BlockDriverState *bs, int64_t sector_num,
1050 uint8_t *buf, int nb_sectors)
1051 {
1052 int ret;
1053 BDRVVmdkState *s = bs->opaque;
1054 qemu_co_mutex_lock(&s->lock);
1055 ret = vmdk_read(bs, sector_num, buf, nb_sectors);
1056 qemu_co_mutex_unlock(&s->lock);
1057 return ret;
1058 }
1059
1060 static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
1061 const uint8_t *buf, int nb_sectors)
1062 {
1063 BDRVVmdkState *s = bs->opaque;
1064 VmdkExtent *extent = NULL;
1065 int n, ret;
1066 int64_t index_in_cluster;
1067 uint64_t cluster_offset;
1068 VmdkMetaData m_data;
1069
1070 if (sector_num > bs->total_sectors) {
1071 fprintf(stderr,
1072 "(VMDK) Wrong offset: sector_num=0x%" PRIx64
1073 " total_sectors=0x%" PRIx64 "\n",
1074 sector_num, bs->total_sectors);
1075 return -EIO;
1076 }
1077
1078 while (nb_sectors > 0) {
1079 extent = find_extent(s, sector_num, extent);
1080 if (!extent) {
1081 return -EIO;
1082 }
1083 ret = get_cluster_offset(
1084 bs,
1085 extent,
1086 &m_data,
1087 sector_num << 9, !extent->compressed,
1088 &cluster_offset);
1089 if (extent->compressed) {
1090 if (ret == 0) {
1091 /* Refuse write to allocated cluster for streamOptimized */
1092 fprintf(stderr,
1093 "VMDK: can't write to allocated cluster"
1094 " for streamOptimized\n");
1095 return -EIO;
1096 } else {
1097 /* allocate */
1098 ret = get_cluster_offset(
1099 bs,
1100 extent,
1101 &m_data,
1102 sector_num << 9, 1,
1103 &cluster_offset);
1104 }
1105 }
1106 if (ret) {
1107 return -EINVAL;
1108 }
1109 index_in_cluster = sector_num % extent->cluster_sectors;
1110 n = extent->cluster_sectors - index_in_cluster;
1111 if (n > nb_sectors) {
1112 n = nb_sectors;
1113 }
1114
1115 ret = vmdk_write_extent(extent,
1116 cluster_offset, index_in_cluster * 512,
1117 buf, n, sector_num);
1118 if (ret) {
1119 return ret;
1120 }
1121 if (m_data.valid) {
1122 /* update L2 tables */
1123 if (vmdk_L2update(extent, &m_data) == -1) {
1124 return -EIO;
1125 }
1126 }
1127 nb_sectors -= n;
1128 sector_num += n;
1129 buf += n * 512;
1130
1131 /* update CID on the first write every time the virtual disk is
1132 * opened */
1133 if (!s->cid_updated) {
1134 ret = vmdk_write_cid(bs, time(NULL));
1135 if (ret < 0) {
1136 return ret;
1137 }
1138 s->cid_updated = true;
1139 }
1140 }
1141 return 0;
1142 }
1143
1144 static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num,
1145 const uint8_t *buf, int nb_sectors)
1146 {
1147 int ret;
1148 BDRVVmdkState *s = bs->opaque;
1149 qemu_co_mutex_lock(&s->lock);
1150 ret = vmdk_write(bs, sector_num, buf, nb_sectors);
1151 qemu_co_mutex_unlock(&s->lock);
1152 return ret;
1153 }
1154
1155
1156 static int vmdk_create_extent(const char *filename, int64_t filesize,
1157 bool flat, bool compress)
1158 {
1159 int ret, i;
1160 int fd = 0;
1161 VMDK4Header header;
1162 uint32_t tmp, magic, grains, gd_size, gt_size, gt_count;
1163
1164 fd = open(
1165 filename,
1166 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
1167 0644);
1168 if (fd < 0) {
1169 return -errno;
1170 }
1171 if (flat) {
1172 ret = ftruncate(fd, filesize);
1173 if (ret < 0) {
1174 ret = -errno;
1175 }
1176 goto exit;
1177 }
1178 magic = cpu_to_be32(VMDK4_MAGIC);
1179 memset(&header, 0, sizeof(header));
1180 header.version = 1;
1181 header.flags =
1182 3 | (compress ? VMDK4_FLAG_COMPRESS | VMDK4_FLAG_MARKER : 0);
1183 header.compressAlgorithm = compress ? VMDK4_COMPRESSION_DEFLATE : 0;
1184 header.capacity = filesize / 512;
1185 header.granularity = 128;
1186 header.num_gtes_per_gte = 512;
1187
1188 grains = (filesize / 512 + header.granularity - 1) / header.granularity;
1189 gt_size = ((header.num_gtes_per_gte * sizeof(uint32_t)) + 511) >> 9;
1190 gt_count =
1191 (grains + header.num_gtes_per_gte - 1) / header.num_gtes_per_gte;
1192 gd_size = (gt_count * sizeof(uint32_t) + 511) >> 9;
1193
1194 header.desc_offset = 1;
1195 header.desc_size = 20;
1196 header.rgd_offset = header.desc_offset + header.desc_size;
1197 header.gd_offset = header.rgd_offset + gd_size + (gt_size * gt_count);
1198 header.grain_offset =
1199 ((header.gd_offset + gd_size + (gt_size * gt_count) +
1200 header.granularity - 1) / header.granularity) *
1201 header.granularity;
1202 /* swap endianness for all header fields */
1203 header.version = cpu_to_le32(header.version);
1204 header.flags = cpu_to_le32(header.flags);
1205 header.capacity = cpu_to_le64(header.capacity);
1206 header.granularity = cpu_to_le64(header.granularity);
1207 header.num_gtes_per_gte = cpu_to_le32(header.num_gtes_per_gte);
1208 header.desc_offset = cpu_to_le64(header.desc_offset);
1209 header.desc_size = cpu_to_le64(header.desc_size);
1210 header.rgd_offset = cpu_to_le64(header.rgd_offset);
1211 header.gd_offset = cpu_to_le64(header.gd_offset);
1212 header.grain_offset = cpu_to_le64(header.grain_offset);
1213 header.compressAlgorithm = cpu_to_le16(header.compressAlgorithm);
1214
1215 header.check_bytes[0] = 0xa;
1216 header.check_bytes[1] = 0x20;
1217 header.check_bytes[2] = 0xd;
1218 header.check_bytes[3] = 0xa;
1219
1220 /* write all the data */
1221 ret = qemu_write_full(fd, &magic, sizeof(magic));
1222 if (ret != sizeof(magic)) {
1223 ret = -errno;
1224 goto exit;
1225 }
1226 ret = qemu_write_full(fd, &header, sizeof(header));
1227 if (ret != sizeof(header)) {
1228 ret = -errno;
1229 goto exit;
1230 }
1231
1232 ret = ftruncate(fd, le64_to_cpu(header.grain_offset) << 9);
1233 if (ret < 0) {
1234 ret = -errno;
1235 goto exit;
1236 }
1237
1238 /* write grain directory */
1239 lseek(fd, le64_to_cpu(header.rgd_offset) << 9, SEEK_SET);
1240 for (i = 0, tmp = le64_to_cpu(header.rgd_offset) + gd_size;
1241 i < gt_count; i++, tmp += gt_size) {
1242 ret = qemu_write_full(fd, &tmp, sizeof(tmp));
1243 if (ret != sizeof(tmp)) {
1244 ret = -errno;
1245 goto exit;
1246 }
1247 }
1248
1249 /* write backup grain directory */
1250 lseek(fd, le64_to_cpu(header.gd_offset) << 9, SEEK_SET);
1251 for (i = 0, tmp = le64_to_cpu(header.gd_offset) + gd_size;
1252 i < gt_count; i++, tmp += gt_size) {
1253 ret = qemu_write_full(fd, &tmp, sizeof(tmp));
1254 if (ret != sizeof(tmp)) {
1255 ret = -errno;
1256 goto exit;
1257 }
1258 }
1259
1260 ret = 0;
1261 exit:
1262 close(fd);
1263 return ret;
1264 }
1265
1266 static int filename_decompose(const char *filename, char *path, char *prefix,
1267 char *postfix, size_t buf_len)
1268 {
1269 const char *p, *q;
1270
1271 if (filename == NULL || !strlen(filename)) {
1272 fprintf(stderr, "Vmdk: no filename provided.\n");
1273 return -1;
1274 }
1275 p = strrchr(filename, '/');
1276 if (p == NULL) {
1277 p = strrchr(filename, '\\');
1278 }
1279 if (p == NULL) {
1280 p = strrchr(filename, ':');
1281 }
1282 if (p != NULL) {
1283 p++;
1284 if (p - filename >= buf_len) {
1285 return -1;
1286 }
1287 pstrcpy(path, p - filename + 1, filename);
1288 } else {
1289 p = filename;
1290 path[0] = '\0';
1291 }
1292 q = strrchr(p, '.');
1293 if (q == NULL) {
1294 pstrcpy(prefix, buf_len, p);
1295 postfix[0] = '\0';
1296 } else {
1297 if (q - p >= buf_len) {
1298 return -1;
1299 }
1300 pstrcpy(prefix, q - p + 1, p);
1301 pstrcpy(postfix, buf_len, q);
1302 }
1303 return 0;
1304 }
1305
1306 static int relative_path(char *dest, int dest_size,
1307 const char *base, const char *target)
1308 {
1309 int i = 0;
1310 int n = 0;
1311 const char *p, *q;
1312 #ifdef _WIN32
1313 const char *sep = "\\";
1314 #else
1315 const char *sep = "/";
1316 #endif
1317
1318 if (!(dest && base && target)) {
1319 return -1;
1320 }
1321 if (path_is_absolute(target)) {
1322 dest[dest_size - 1] = '\0';
1323 strncpy(dest, target, dest_size - 1);
1324 return 0;
1325 }
1326 while (base[i] == target[i]) {
1327 i++;
1328 }
1329 p = &base[i];
1330 q = &target[i];
1331 while (*p) {
1332 if (*p == *sep) {
1333 n++;
1334 }
1335 p++;
1336 }
1337 dest[0] = '\0';
1338 for (; n; n--) {
1339 pstrcat(dest, dest_size, "..");
1340 pstrcat(dest, dest_size, sep);
1341 }
1342 pstrcat(dest, dest_size, q);
1343 return 0;
1344 }
1345
1346 static int vmdk_create(const char *filename, QEMUOptionParameter *options)
1347 {
1348 int fd, idx = 0;
1349 char desc[BUF_SIZE];
1350 int64_t total_size = 0, filesize;
1351 const char *backing_file = NULL;
1352 const char *fmt = NULL;
1353 int flags = 0;
1354 int ret = 0;
1355 bool flat, split, compress;
1356 char ext_desc_lines[BUF_SIZE] = "";
1357 char path[PATH_MAX], prefix[PATH_MAX], postfix[PATH_MAX];
1358 const int64_t split_size = 0x80000000; /* VMDK has constant split size */
1359 const char *desc_extent_line;
1360 char parent_desc_line[BUF_SIZE] = "";
1361 uint32_t parent_cid = 0xffffffff;
1362 const char desc_template[] =
1363 "# Disk DescriptorFile\n"
1364 "version=1\n"
1365 "CID=%x\n"
1366 "parentCID=%x\n"
1367 "createType=\"%s\"\n"
1368 "%s"
1369 "\n"
1370 "# Extent description\n"
1371 "%s"
1372 "\n"
1373 "# The Disk Data Base\n"
1374 "#DDB\n"
1375 "\n"
1376 "ddb.virtualHWVersion = \"%d\"\n"
1377 "ddb.geometry.cylinders = \"%" PRId64 "\"\n"
1378 "ddb.geometry.heads = \"16\"\n"
1379 "ddb.geometry.sectors = \"63\"\n"
1380 "ddb.adapterType = \"ide\"\n";
1381
1382 if (filename_decompose(filename, path, prefix, postfix, PATH_MAX)) {
1383 return -EINVAL;
1384 }
1385 /* Read out options */
1386 while (options && options->name) {
1387 if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1388 total_size = options->value.n;
1389 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
1390 backing_file = options->value.s;
1391 } else if (!strcmp(options->name, BLOCK_OPT_COMPAT6)) {
1392 flags |= options->value.n ? BLOCK_FLAG_COMPAT6 : 0;
1393 } else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) {
1394 fmt = options->value.s;
1395 }
1396 options++;
1397 }
1398 if (!fmt) {
1399 /* Default format to monolithicSparse */
1400 fmt = "monolithicSparse";
1401 } else if (strcmp(fmt, "monolithicFlat") &&
1402 strcmp(fmt, "monolithicSparse") &&
1403 strcmp(fmt, "twoGbMaxExtentSparse") &&
1404 strcmp(fmt, "twoGbMaxExtentFlat") &&
1405 strcmp(fmt, "streamOptimized")) {
1406 fprintf(stderr, "VMDK: Unknown subformat: %s\n", fmt);
1407 return -EINVAL;
1408 }
1409 split = !(strcmp(fmt, "twoGbMaxExtentFlat") &&
1410 strcmp(fmt, "twoGbMaxExtentSparse"));
1411 flat = !(strcmp(fmt, "monolithicFlat") &&
1412 strcmp(fmt, "twoGbMaxExtentFlat"));
1413 compress = !strcmp(fmt, "streamOptimized");
1414 if (flat) {
1415 desc_extent_line = "RW %lld FLAT \"%s\" 0\n";
1416 } else {
1417 desc_extent_line = "RW %lld SPARSE \"%s\"\n";
1418 }
1419 if (flat && backing_file) {
1420 /* not supporting backing file for flat image */
1421 return -ENOTSUP;
1422 }
1423 if (backing_file) {
1424 char parent_filename[PATH_MAX];
1425 BlockDriverState *bs = bdrv_new("");
1426 ret = bdrv_open(bs, backing_file, 0, NULL);
1427 if (ret != 0) {
1428 bdrv_delete(bs);
1429 return ret;
1430 }
1431 if (strcmp(bs->drv->format_name, "vmdk")) {
1432 bdrv_delete(bs);
1433 return -EINVAL;
1434 }
1435 parent_cid = vmdk_read_cid(bs, 0);
1436 bdrv_delete(bs);
1437 relative_path(parent_filename, sizeof(parent_filename),
1438 filename, backing_file);
1439 snprintf(parent_desc_line, sizeof(parent_desc_line),
1440 "parentFileNameHint=\"%s\"", parent_filename);
1441 }
1442
1443 /* Create extents */
1444 filesize = total_size;
1445 while (filesize > 0) {
1446 char desc_line[BUF_SIZE];
1447 char ext_filename[PATH_MAX];
1448 char desc_filename[PATH_MAX];
1449 int64_t size = filesize;
1450
1451 if (split && size > split_size) {
1452 size = split_size;
1453 }
1454 if (split) {
1455 snprintf(desc_filename, sizeof(desc_filename), "%s-%c%03d%s",
1456 prefix, flat ? 'f' : 's', ++idx, postfix);
1457 } else if (flat) {
1458 snprintf(desc_filename, sizeof(desc_filename), "%s-flat%s",
1459 prefix, postfix);
1460 } else {
1461 snprintf(desc_filename, sizeof(desc_filename), "%s%s",
1462 prefix, postfix);
1463 }
1464 snprintf(ext_filename, sizeof(ext_filename), "%s%s",
1465 path, desc_filename);
1466
1467 if (vmdk_create_extent(ext_filename, size, flat, compress)) {
1468 return -EINVAL;
1469 }
1470 filesize -= size;
1471
1472 /* Format description line */
1473 snprintf(desc_line, sizeof(desc_line),
1474 desc_extent_line, size / 512, desc_filename);
1475 pstrcat(ext_desc_lines, sizeof(ext_desc_lines), desc_line);
1476 }
1477 /* generate descriptor file */
1478 snprintf(desc, sizeof(desc), desc_template,
1479 (unsigned int)time(NULL),
1480 parent_cid,
1481 fmt,
1482 parent_desc_line,
1483 ext_desc_lines,
1484 (flags & BLOCK_FLAG_COMPAT6 ? 6 : 4),
1485 total_size / (int64_t)(63 * 16 * 512));
1486 if (split || flat) {
1487 fd = open(
1488 filename,
1489 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
1490 0644);
1491 } else {
1492 fd = open(
1493 filename,
1494 O_WRONLY | O_BINARY | O_LARGEFILE,
1495 0644);
1496 }
1497 if (fd < 0) {
1498 return -errno;
1499 }
1500 /* the descriptor offset = 0x200 */
1501 if (!split && !flat && 0x200 != lseek(fd, 0x200, SEEK_SET)) {
1502 ret = -errno;
1503 goto exit;
1504 }
1505 ret = qemu_write_full(fd, desc, strlen(desc));
1506 if (ret != strlen(desc)) {
1507 ret = -errno;
1508 goto exit;
1509 }
1510 ret = 0;
1511 exit:
1512 close(fd);
1513 return ret;
1514 }
1515
1516 static void vmdk_close(BlockDriverState *bs)
1517 {
1518 BDRVVmdkState *s = bs->opaque;
1519
1520 vmdk_free_extents(bs);
1521
1522 migrate_del_blocker(s->migration_blocker);
1523 error_free(s->migration_blocker);
1524 }
1525
1526 static coroutine_fn int vmdk_co_flush(BlockDriverState *bs)
1527 {
1528 int i, ret, err;
1529 BDRVVmdkState *s = bs->opaque;
1530
1531 ret = bdrv_co_flush(bs->file);
1532 for (i = 0; i < s->num_extents; i++) {
1533 err = bdrv_co_flush(s->extents[i].file);
1534 if (err < 0) {
1535 ret = err;
1536 }
1537 }
1538 return ret;
1539 }
1540
1541 static int64_t vmdk_get_allocated_file_size(BlockDriverState *bs)
1542 {
1543 int i;
1544 int64_t ret = 0;
1545 int64_t r;
1546 BDRVVmdkState *s = bs->opaque;
1547
1548 ret = bdrv_get_allocated_file_size(bs->file);
1549 if (ret < 0) {
1550 return ret;
1551 }
1552 for (i = 0; i < s->num_extents; i++) {
1553 if (s->extents[i].file == bs->file) {
1554 continue;
1555 }
1556 r = bdrv_get_allocated_file_size(s->extents[i].file);
1557 if (r < 0) {
1558 return r;
1559 }
1560 ret += r;
1561 }
1562 return ret;
1563 }
1564
1565 static QEMUOptionParameter vmdk_create_options[] = {
1566 {
1567 .name = BLOCK_OPT_SIZE,
1568 .type = OPT_SIZE,
1569 .help = "Virtual disk size"
1570 },
1571 {
1572 .name = BLOCK_OPT_BACKING_FILE,
1573 .type = OPT_STRING,
1574 .help = "File name of a base image"
1575 },
1576 {
1577 .name = BLOCK_OPT_COMPAT6,
1578 .type = OPT_FLAG,
1579 .help = "VMDK version 6 image"
1580 },
1581 {
1582 .name = BLOCK_OPT_SUBFMT,
1583 .type = OPT_STRING,
1584 .help =
1585 "VMDK flat extent format, can be one of "
1586 "{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
1587 },
1588 { NULL }
1589 };
1590
1591 static BlockDriver bdrv_vmdk = {
1592 .format_name = "vmdk",
1593 .instance_size = sizeof(BDRVVmdkState),
1594 .bdrv_probe = vmdk_probe,
1595 .bdrv_open = vmdk_open,
1596 .bdrv_read = vmdk_co_read,
1597 .bdrv_write = vmdk_co_write,
1598 .bdrv_close = vmdk_close,
1599 .bdrv_create = vmdk_create,
1600 .bdrv_co_flush_to_disk = vmdk_co_flush,
1601 .bdrv_co_is_allocated = vmdk_co_is_allocated,
1602 .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size,
1603
1604 .create_options = vmdk_create_options,
1605 };
1606
1607 static void bdrv_vmdk_init(void)
1608 {
1609 bdrv_register(&bdrv_vmdk);
1610 }
1611
1612 block_init(bdrv_vmdk_init);