2 * Block driver for the VMDK format
4 * Copyright (c) 2004 Fabrice Bellard
5 * Copyright (c) 2005 Filip Navara
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #include "qemu-common.h"
27 #include "block_int.h"
30 #define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D')
31 #define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V')
36 uint32_t disk_sectors
;
38 uint32_t l1dir_offset
;
40 uint32_t file_sectors
;
43 uint32_t sectors_per_track
;
53 int32_t num_gtes_per_gte
;
59 } __attribute__((packed
)) VMDK4Header
;
61 #define L2_CACHE_SIZE 16
63 typedef struct BDRVVmdkState
{
65 int64_t l1_table_offset
;
66 int64_t l1_backup_table_offset
;
68 uint32_t *l1_backup_table
;
70 uint32_t l1_entry_sectors
;
74 uint32_t l2_cache_offsets
[L2_CACHE_SIZE
];
75 uint32_t l2_cache_counts
[L2_CACHE_SIZE
];
77 unsigned int cluster_sectors
;
82 typedef struct VmdkMetaData
{
84 unsigned int l1_index
;
85 unsigned int l2_index
;
86 unsigned int l2_offset
;
90 static int vmdk_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
96 magic
= be32_to_cpu(*(uint32_t *)buf
);
97 if (magic
== VMDK3_MAGIC
||
106 #define SECTOR_SIZE 512
107 #define DESC_SIZE 20*SECTOR_SIZE // 20 sectors of 512 bytes each
108 #define HEADER_SIZE 512 // first sector of 512 bytes
110 static uint32_t vmdk_read_cid(BlockDriverState
*bs
, int parent
)
112 BDRVVmdkState
*s
= bs
->opaque
;
113 char desc
[DESC_SIZE
];
115 const char *p_name
, *cid_str
;
118 /* the descriptor offset = 0x200 */
119 if (bdrv_pread(s
->hd
, 0x200, desc
, DESC_SIZE
) != DESC_SIZE
)
123 cid_str
= "parentCID";
124 cid_str_size
= sizeof("parentCID");
127 cid_str_size
= sizeof("CID");
130 if ((p_name
= strstr(desc
,cid_str
)) != NULL
) {
131 p_name
+= cid_str_size
;
132 sscanf(p_name
,"%x",&cid
);
138 static int vmdk_write_cid(BlockDriverState
*bs
, uint32_t cid
)
140 BDRVVmdkState
*s
= bs
->opaque
;
141 char desc
[DESC_SIZE
], tmp_desc
[DESC_SIZE
];
142 char *p_name
, *tmp_str
;
144 /* the descriptor offset = 0x200 */
145 if (bdrv_pread(s
->hd
, 0x200, desc
, DESC_SIZE
) != DESC_SIZE
)
148 tmp_str
= strstr(desc
,"parentCID");
149 pstrcpy(tmp_desc
, sizeof(tmp_desc
), tmp_str
);
150 if ((p_name
= strstr(desc
,"CID")) != NULL
) {
151 p_name
+= sizeof("CID");
152 snprintf(p_name
, sizeof(desc
) - (p_name
- desc
), "%x\n", cid
);
153 pstrcat(desc
, sizeof(desc
), tmp_desc
);
156 if (bdrv_pwrite(s
->hd
, 0x200, desc
, DESC_SIZE
) != DESC_SIZE
)
161 static int vmdk_is_cid_valid(BlockDriverState
*bs
)
164 BDRVVmdkState
*s
= bs
->opaque
;
165 BlockDriverState
*p_bs
= bs
->backing_hd
;
169 cur_pcid
= vmdk_read_cid(p_bs
,0);
170 if (s
->parent_cid
!= cur_pcid
)
179 static int vmdk_snapshot_create(const char *filename
, const char *backing_file
)
184 char *p_name
, *gd_buf
, *rgd_buf
;
185 const char *real_filename
, *temp_str
;
187 uint32_t gde_entries
, gd_size
;
188 int64_t gd_offset
, rgd_offset
, capacity
, gt_size
;
189 char p_desc
[DESC_SIZE
], s_desc
[DESC_SIZE
], hdr
[HEADER_SIZE
];
190 static const char desc_template
[] =
191 "# Disk DescriptorFile\n"
195 "createType=\"monolithicSparse\"\n"
196 "parentFileNameHint=\"%s\"\n"
198 "# Extent description\n"
199 "RW %u SPARSE \"%s\"\n"
201 "# The Disk Data Base \n"
205 snp_fd
= open(filename
, O_RDWR
| O_CREAT
| O_TRUNC
| O_BINARY
| O_LARGEFILE
, 0644);
208 p_fd
= open(backing_file
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
214 /* read the header */
215 if (lseek(p_fd
, 0x0, SEEK_SET
) == -1) {
219 if (read(p_fd
, hdr
, HEADER_SIZE
) != HEADER_SIZE
) {
224 /* write the header */
225 if (lseek(snp_fd
, 0x0, SEEK_SET
) == -1) {
229 if (write(snp_fd
, hdr
, HEADER_SIZE
) == -1) {
234 memset(&header
, 0, sizeof(header
));
235 memcpy(&header
,&hdr
[4], sizeof(header
)); // skip the VMDK4_MAGIC
237 if (ftruncate(snp_fd
, header
.grain_offset
<< 9)) {
241 /* the descriptor offset = 0x200 */
242 if (lseek(p_fd
, 0x200, SEEK_SET
) == -1) {
246 if (read(p_fd
, p_desc
, DESC_SIZE
) != DESC_SIZE
) {
251 if ((p_name
= strstr(p_desc
,"CID")) != NULL
) {
252 p_name
+= sizeof("CID");
253 sscanf(p_name
,"%x",&p_cid
);
256 real_filename
= filename
;
257 if ((temp_str
= strrchr(real_filename
, '\\')) != NULL
)
258 real_filename
= temp_str
+ 1;
259 if ((temp_str
= strrchr(real_filename
, '/')) != NULL
)
260 real_filename
= temp_str
+ 1;
261 if ((temp_str
= strrchr(real_filename
, ':')) != NULL
)
262 real_filename
= temp_str
+ 1;
264 snprintf(s_desc
, sizeof(s_desc
), desc_template
, p_cid
, p_cid
, backing_file
,
265 (uint32_t)header
.capacity
, real_filename
);
267 /* write the descriptor */
268 if (lseek(snp_fd
, 0x200, SEEK_SET
) == -1) {
272 if (write(snp_fd
, s_desc
, strlen(s_desc
)) == -1) {
277 gd_offset
= header
.gd_offset
* SECTOR_SIZE
; // offset of GD table
278 rgd_offset
= header
.rgd_offset
* SECTOR_SIZE
; // offset of RGD table
279 capacity
= header
.capacity
* SECTOR_SIZE
; // Extent size
281 * Each GDE span 32M disk, means:
282 * 512 GTE per GT, each GTE points to grain
284 gt_size
= (int64_t)header
.num_gtes_per_gte
* header
.granularity
* SECTOR_SIZE
;
289 gde_entries
= (uint32_t)(capacity
/ gt_size
); // number of gde/rgde
290 gd_size
= gde_entries
* sizeof(uint32_t);
293 rgd_buf
= qemu_malloc(gd_size
);
294 if (lseek(p_fd
, rgd_offset
, SEEK_SET
) == -1) {
298 if (read(p_fd
, rgd_buf
, gd_size
) != gd_size
) {
302 if (lseek(snp_fd
, rgd_offset
, SEEK_SET
) == -1) {
306 if (write(snp_fd
, rgd_buf
, gd_size
) == -1) {
312 gd_buf
= qemu_malloc(gd_size
);
313 if (lseek(p_fd
, gd_offset
, SEEK_SET
) == -1) {
317 if (read(p_fd
, gd_buf
, gd_size
) != gd_size
) {
321 if (lseek(snp_fd
, gd_offset
, SEEK_SET
) == -1) {
325 if (write(snp_fd
, gd_buf
, gd_size
) == -1) {
341 static void vmdk_parent_close(BlockDriverState
*bs
)
344 bdrv_close(bs
->backing_hd
);
347 static int parent_open
= 0;
348 static int vmdk_parent_open(BlockDriverState
*bs
, const char * filename
)
350 BDRVVmdkState
*s
= bs
->opaque
;
352 char desc
[DESC_SIZE
];
353 char parent_img_name
[1024];
355 /* the descriptor offset = 0x200 */
356 if (bdrv_pread(s
->hd
, 0x200, desc
, DESC_SIZE
) != DESC_SIZE
)
359 if ((p_name
= strstr(desc
,"parentFileNameHint")) != NULL
) {
361 struct stat file_buf
;
363 p_name
+= sizeof("parentFileNameHint") + 1;
364 if ((end_name
= strchr(p_name
,'\"')) == NULL
)
366 if ((end_name
- p_name
) > sizeof (bs
->backing_file
) - 1)
369 pstrcpy(bs
->backing_file
, end_name
- p_name
+ 1, p_name
);
370 if (stat(bs
->backing_file
, &file_buf
) != 0) {
371 path_combine(parent_img_name
, sizeof(parent_img_name
),
372 filename
, bs
->backing_file
);
374 pstrcpy(parent_img_name
, sizeof(parent_img_name
),
378 bs
->backing_hd
= bdrv_new("");
379 if (!bs
->backing_hd
) {
385 if (bdrv_open(bs
->backing_hd
, parent_img_name
, 0, NULL
) < 0)
393 static int vmdk_open(BlockDriverState
*bs
, const char *filename
, int flags
)
395 BDRVVmdkState
*s
= bs
->opaque
;
400 /* Parent must be opened as RO, no RDWR. */
404 ret
= bdrv_file_open(&s
->hd
, filename
, flags
);
407 if (bdrv_pread(s
->hd
, 0, &magic
, sizeof(magic
)) != sizeof(magic
))
410 magic
= be32_to_cpu(magic
);
411 if (magic
== VMDK3_MAGIC
) {
414 if (bdrv_pread(s
->hd
, sizeof(magic
), &header
, sizeof(header
)) != sizeof(header
))
416 s
->cluster_sectors
= le32_to_cpu(header
.granularity
);
419 bs
->total_sectors
= le32_to_cpu(header
.disk_sectors
);
420 s
->l1_table_offset
= le32_to_cpu(header
.l1dir_offset
) << 9;
421 s
->l1_backup_table_offset
= 0;
422 s
->l1_entry_sectors
= s
->l2_size
* s
->cluster_sectors
;
423 } else if (magic
== VMDK4_MAGIC
) {
426 if (bdrv_pread(s
->hd
, sizeof(magic
), &header
, sizeof(header
)) != sizeof(header
))
428 bs
->total_sectors
= le64_to_cpu(header
.capacity
);
429 s
->cluster_sectors
= le64_to_cpu(header
.granularity
);
430 s
->l2_size
= le32_to_cpu(header
.num_gtes_per_gte
);
431 s
->l1_entry_sectors
= s
->l2_size
* s
->cluster_sectors
;
432 if (s
->l1_entry_sectors
<= 0)
434 s
->l1_size
= (bs
->total_sectors
+ s
->l1_entry_sectors
- 1)
435 / s
->l1_entry_sectors
;
436 s
->l1_table_offset
= le64_to_cpu(header
.rgd_offset
) << 9;
437 s
->l1_backup_table_offset
= le64_to_cpu(header
.gd_offset
) << 9;
444 // try to open parent images, if exist
445 if (vmdk_parent_open(bs
, filename
) != 0)
447 // write the CID once after the image creation
448 s
->parent_cid
= vmdk_read_cid(bs
,1);
453 /* read the L1 table */
454 l1_size
= s
->l1_size
* sizeof(uint32_t);
455 s
->l1_table
= qemu_malloc(l1_size
);
456 if (bdrv_pread(s
->hd
, s
->l1_table_offset
, s
->l1_table
, l1_size
) != l1_size
)
458 for(i
= 0; i
< s
->l1_size
; i
++) {
459 le32_to_cpus(&s
->l1_table
[i
]);
462 if (s
->l1_backup_table_offset
) {
463 s
->l1_backup_table
= qemu_malloc(l1_size
);
464 if (bdrv_pread(s
->hd
, s
->l1_backup_table_offset
, s
->l1_backup_table
, l1_size
) != l1_size
)
466 for(i
= 0; i
< s
->l1_size
; i
++) {
467 le32_to_cpus(&s
->l1_backup_table
[i
]);
471 s
->l2_cache
= qemu_malloc(s
->l2_size
* L2_CACHE_SIZE
* sizeof(uint32_t));
474 qemu_free(s
->l1_backup_table
);
475 qemu_free(s
->l1_table
);
476 qemu_free(s
->l2_cache
);
481 static uint64_t get_cluster_offset(BlockDriverState
*bs
, VmdkMetaData
*m_data
,
482 uint64_t offset
, int allocate
);
484 static int get_whole_cluster(BlockDriverState
*bs
, uint64_t cluster_offset
,
485 uint64_t offset
, int allocate
)
487 BDRVVmdkState
*s
= bs
->opaque
;
488 uint8_t whole_grain
[s
->cluster_sectors
*512]; // 128 sectors * 512 bytes each = grain size 64KB
490 // we will be here if it's first write on non-exist grain(cluster).
491 // try to read from parent image, if exist
492 if (bs
->backing_hd
) {
495 if (!vmdk_is_cid_valid(bs
))
498 ret
= bdrv_read(bs
->backing_hd
, offset
>> 9, whole_grain
,
504 //Write grain only into the active image
505 ret
= bdrv_write(s
->hd
, cluster_offset
, whole_grain
,
514 static int vmdk_L2update(BlockDriverState
*bs
, VmdkMetaData
*m_data
)
516 BDRVVmdkState
*s
= bs
->opaque
;
518 /* update L2 table */
519 if (bdrv_pwrite(s
->hd
, ((int64_t)m_data
->l2_offset
* 512) + (m_data
->l2_index
* sizeof(m_data
->offset
)),
520 &(m_data
->offset
), sizeof(m_data
->offset
)) != sizeof(m_data
->offset
))
522 /* update backup L2 table */
523 if (s
->l1_backup_table_offset
!= 0) {
524 m_data
->l2_offset
= s
->l1_backup_table
[m_data
->l1_index
];
525 if (bdrv_pwrite(s
->hd
, ((int64_t)m_data
->l2_offset
* 512) + (m_data
->l2_index
* sizeof(m_data
->offset
)),
526 &(m_data
->offset
), sizeof(m_data
->offset
)) != sizeof(m_data
->offset
))
533 static uint64_t get_cluster_offset(BlockDriverState
*bs
, VmdkMetaData
*m_data
,
534 uint64_t offset
, int allocate
)
536 BDRVVmdkState
*s
= bs
->opaque
;
537 unsigned int l1_index
, l2_offset
, l2_index
;
539 uint32_t min_count
, *l2_table
, tmp
= 0;
540 uint64_t cluster_offset
;
545 l1_index
= (offset
>> 9) / s
->l1_entry_sectors
;
546 if (l1_index
>= s
->l1_size
)
548 l2_offset
= s
->l1_table
[l1_index
];
551 for(i
= 0; i
< L2_CACHE_SIZE
; i
++) {
552 if (l2_offset
== s
->l2_cache_offsets
[i
]) {
553 /* increment the hit count */
554 if (++s
->l2_cache_counts
[i
] == 0xffffffff) {
555 for(j
= 0; j
< L2_CACHE_SIZE
; j
++) {
556 s
->l2_cache_counts
[j
] >>= 1;
559 l2_table
= s
->l2_cache
+ (i
* s
->l2_size
);
563 /* not found: load a new entry in the least used one */
565 min_count
= 0xffffffff;
566 for(i
= 0; i
< L2_CACHE_SIZE
; i
++) {
567 if (s
->l2_cache_counts
[i
] < min_count
) {
568 min_count
= s
->l2_cache_counts
[i
];
572 l2_table
= s
->l2_cache
+ (min_index
* s
->l2_size
);
573 if (bdrv_pread(s
->hd
, (int64_t)l2_offset
* 512, l2_table
, s
->l2_size
* sizeof(uint32_t)) !=
574 s
->l2_size
* sizeof(uint32_t))
577 s
->l2_cache_offsets
[min_index
] = l2_offset
;
578 s
->l2_cache_counts
[min_index
] = 1;
580 l2_index
= ((offset
>> 9) / s
->cluster_sectors
) % s
->l2_size
;
581 cluster_offset
= le32_to_cpu(l2_table
[l2_index
]);
583 if (!cluster_offset
) {
586 // Avoid the L2 tables update for the images that have snapshots.
588 cluster_offset
= bdrv_getlength(s
->hd
);
589 bdrv_truncate(s
->hd
, cluster_offset
+ (s
->cluster_sectors
<< 9));
591 cluster_offset
>>= 9;
592 tmp
= cpu_to_le32(cluster_offset
);
593 l2_table
[l2_index
] = tmp
;
595 /* First of all we write grain itself, to avoid race condition
596 * that may to corrupt the image.
597 * This problem may occur because of insufficient space on host disk
598 * or inappropriate VM shutdown.
600 if (get_whole_cluster(bs
, cluster_offset
, offset
, allocate
) == -1)
604 m_data
->offset
= tmp
;
605 m_data
->l1_index
= l1_index
;
606 m_data
->l2_index
= l2_index
;
607 m_data
->l2_offset
= l2_offset
;
611 cluster_offset
<<= 9;
612 return cluster_offset
;
615 static int vmdk_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
616 int nb_sectors
, int *pnum
)
618 BDRVVmdkState
*s
= bs
->opaque
;
619 int index_in_cluster
, n
;
620 uint64_t cluster_offset
;
622 cluster_offset
= get_cluster_offset(bs
, NULL
, sector_num
<< 9, 0);
623 index_in_cluster
= sector_num
% s
->cluster_sectors
;
624 n
= s
->cluster_sectors
- index_in_cluster
;
628 return (cluster_offset
!= 0);
631 static int vmdk_read(BlockDriverState
*bs
, int64_t sector_num
,
632 uint8_t *buf
, int nb_sectors
)
634 BDRVVmdkState
*s
= bs
->opaque
;
635 int index_in_cluster
, n
, ret
;
636 uint64_t cluster_offset
;
638 while (nb_sectors
> 0) {
639 cluster_offset
= get_cluster_offset(bs
, NULL
, sector_num
<< 9, 0);
640 index_in_cluster
= sector_num
% s
->cluster_sectors
;
641 n
= s
->cluster_sectors
- index_in_cluster
;
644 if (!cluster_offset
) {
645 // try to read from parent image, if exist
646 if (bs
->backing_hd
) {
647 if (!vmdk_is_cid_valid(bs
))
649 ret
= bdrv_read(bs
->backing_hd
, sector_num
, buf
, n
);
653 memset(buf
, 0, 512 * n
);
656 if(bdrv_pread(s
->hd
, cluster_offset
+ index_in_cluster
* 512, buf
, n
* 512) != n
* 512)
666 static int vmdk_write(BlockDriverState
*bs
, int64_t sector_num
,
667 const uint8_t *buf
, int nb_sectors
)
669 BDRVVmdkState
*s
= bs
->opaque
;
671 int index_in_cluster
, n
;
672 uint64_t cluster_offset
;
673 static int cid_update
= 0;
675 if (sector_num
> bs
->total_sectors
) {
677 "(VMDK) Wrong offset: sector_num=0x%" PRIx64
678 " total_sectors=0x%" PRIx64
"\n",
679 sector_num
, bs
->total_sectors
);
683 while (nb_sectors
> 0) {
684 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
685 n
= s
->cluster_sectors
- index_in_cluster
;
688 cluster_offset
= get_cluster_offset(bs
, &m_data
, sector_num
<< 9, 1);
692 if (bdrv_pwrite(s
->hd
, cluster_offset
+ index_in_cluster
* 512, buf
, n
* 512) != n
* 512)
695 /* update L2 tables */
696 if (vmdk_L2update(bs
, &m_data
) == -1)
703 // update CID on the first write every time the virtual disk is opened
705 vmdk_write_cid(bs
, time(NULL
));
712 static int vmdk_create(const char *filename
, QEMUOptionParameter
*options
)
716 uint32_t tmp
, magic
, grains
, gd_size
, gt_size
, gt_count
;
717 static const char desc_template
[] =
718 "# Disk DescriptorFile\n"
721 "parentCID=ffffffff\n"
722 "createType=\"monolithicSparse\"\n"
724 "# Extent description\n"
725 "RW %" PRId64
" SPARSE \"%s\"\n"
727 "# The Disk Data Base \n"
730 "ddb.virtualHWVersion = \"%d\"\n"
731 "ddb.geometry.cylinders = \"%" PRId64
"\"\n"
732 "ddb.geometry.heads = \"16\"\n"
733 "ddb.geometry.sectors = \"63\"\n"
734 "ddb.adapterType = \"ide\"\n";
736 const char *real_filename
, *temp_str
;
737 int64_t total_size
= 0;
738 const char *backing_file
= NULL
;
743 while (options
&& options
->name
) {
744 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
745 total_size
= options
->value
.n
/ 512;
746 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FILE
)) {
747 backing_file
= options
->value
.s
;
748 } else if (!strcmp(options
->name
, BLOCK_OPT_COMPAT6
)) {
749 flags
|= options
->value
.n
? BLOCK_FLAG_COMPAT6
: 0;
754 /* XXX: add support for backing file */
756 return vmdk_snapshot_create(filename
, backing_file
);
759 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
| O_LARGEFILE
,
763 magic
= cpu_to_be32(VMDK4_MAGIC
);
764 memset(&header
, 0, sizeof(header
));
765 header
.version
= cpu_to_le32(1);
766 header
.flags
= cpu_to_le32(3); /* ?? */
767 header
.capacity
= cpu_to_le64(total_size
);
768 header
.granularity
= cpu_to_le64(128);
769 header
.num_gtes_per_gte
= cpu_to_le32(512);
771 grains
= (total_size
+ header
.granularity
- 1) / header
.granularity
;
772 gt_size
= ((header
.num_gtes_per_gte
* sizeof(uint32_t)) + 511) >> 9;
773 gt_count
= (grains
+ header
.num_gtes_per_gte
- 1) / header
.num_gtes_per_gte
;
774 gd_size
= (gt_count
* sizeof(uint32_t) + 511) >> 9;
776 header
.desc_offset
= 1;
777 header
.desc_size
= 20;
778 header
.rgd_offset
= header
.desc_offset
+ header
.desc_size
;
779 header
.gd_offset
= header
.rgd_offset
+ gd_size
+ (gt_size
* gt_count
);
780 header
.grain_offset
=
781 ((header
.gd_offset
+ gd_size
+ (gt_size
* gt_count
) +
782 header
.granularity
- 1) / header
.granularity
) *
785 header
.desc_offset
= cpu_to_le64(header
.desc_offset
);
786 header
.desc_size
= cpu_to_le64(header
.desc_size
);
787 header
.rgd_offset
= cpu_to_le64(header
.rgd_offset
);
788 header
.gd_offset
= cpu_to_le64(header
.gd_offset
);
789 header
.grain_offset
= cpu_to_le64(header
.grain_offset
);
791 header
.check_bytes
[0] = 0xa;
792 header
.check_bytes
[1] = 0x20;
793 header
.check_bytes
[2] = 0xd;
794 header
.check_bytes
[3] = 0xa;
796 /* write all the data */
797 ret
= qemu_write_full(fd
, &magic
, sizeof(magic
));
798 if (ret
!= sizeof(magic
)) {
802 ret
= qemu_write_full(fd
, &header
, sizeof(header
));
803 if (ret
!= sizeof(header
)) {
808 ret
= ftruncate(fd
, header
.grain_offset
<< 9);
814 /* write grain directory */
815 lseek(fd
, le64_to_cpu(header
.rgd_offset
) << 9, SEEK_SET
);
816 for (i
= 0, tmp
= header
.rgd_offset
+ gd_size
;
817 i
< gt_count
; i
++, tmp
+= gt_size
) {
818 ret
= qemu_write_full(fd
, &tmp
, sizeof(tmp
));
819 if (ret
!= sizeof(tmp
)) {
825 /* write backup grain directory */
826 lseek(fd
, le64_to_cpu(header
.gd_offset
) << 9, SEEK_SET
);
827 for (i
= 0, tmp
= header
.gd_offset
+ gd_size
;
828 i
< gt_count
; i
++, tmp
+= gt_size
) {
829 ret
= qemu_write_full(fd
, &tmp
, sizeof(tmp
));
830 if (ret
!= sizeof(tmp
)) {
836 /* compose the descriptor */
837 real_filename
= filename
;
838 if ((temp_str
= strrchr(real_filename
, '\\')) != NULL
)
839 real_filename
= temp_str
+ 1;
840 if ((temp_str
= strrchr(real_filename
, '/')) != NULL
)
841 real_filename
= temp_str
+ 1;
842 if ((temp_str
= strrchr(real_filename
, ':')) != NULL
)
843 real_filename
= temp_str
+ 1;
844 snprintf(desc
, sizeof(desc
), desc_template
, (unsigned int)time(NULL
),
845 total_size
, real_filename
,
846 (flags
& BLOCK_FLAG_COMPAT6
? 6 : 4),
847 total_size
/ (int64_t)(63 * 16));
849 /* write the descriptor */
850 lseek(fd
, le64_to_cpu(header
.desc_offset
) << 9, SEEK_SET
);
851 ret
= qemu_write_full(fd
, desc
, strlen(desc
));
852 if (ret
!= strlen(desc
)) {
863 static void vmdk_close(BlockDriverState
*bs
)
865 BDRVVmdkState
*s
= bs
->opaque
;
867 qemu_free(s
->l1_table
);
868 qemu_free(s
->l2_cache
);
869 // try to close parent image, if exist
870 vmdk_parent_close(s
->hd
);
874 static void vmdk_flush(BlockDriverState
*bs
)
876 BDRVVmdkState
*s
= bs
->opaque
;
881 static QEMUOptionParameter vmdk_create_options
[] = {
883 .name
= BLOCK_OPT_SIZE
,
885 .help
= "Virtual disk size"
888 .name
= BLOCK_OPT_BACKING_FILE
,
890 .help
= "File name of a base image"
893 .name
= BLOCK_OPT_COMPAT6
,
895 .help
= "VMDK version 6 image"
900 static BlockDriver bdrv_vmdk
= {
901 .format_name
= "vmdk",
902 .instance_size
= sizeof(BDRVVmdkState
),
903 .bdrv_probe
= vmdk_probe
,
904 .bdrv_file_open
= vmdk_open
,
905 .bdrv_read
= vmdk_read
,
906 .bdrv_write
= vmdk_write
,
907 .bdrv_close
= vmdk_close
,
908 .bdrv_create
= vmdk_create
,
909 .bdrv_flush
= vmdk_flush
,
910 .bdrv_is_allocated
= vmdk_is_allocated
,
912 .create_options
= vmdk_create_options
,
915 static void bdrv_vmdk_init(void)
917 bdrv_register(&bdrv_vmdk
);
920 block_init(bdrv_vmdk_init
);