1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2014 Juniper Networks, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 #include <sys/errno.h>
31 #include <stdint.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 #include "endian.h"
37 #include "image.h"
38 #include "format.h"
39 #include "mkimg.h"
40
41 #define VMDK_IMAGE_ROUND 1048576
42 #define VMDK_MIN_GRAIN_SIZE 8192
43 #define VMDK_SECTOR_SIZE 512
44
45 struct vmdk_header {
46 uint32_t magic;
47 #define VMDK_MAGIC 0x564d444b
48 uint32_t version;
49 #define VMDK_VERSION 1
50 uint32_t flags;
51 #define VMDK_FLAGS_NL_TEST (1 << 0)
52 #define VMDK_FLAGS_RGT_USED (1 << 1)
53 #define VMDK_FLAGS_COMPRESSED (1 << 16)
54 #define VMDK_FLAGS_MARKERS (1 << 17)
55 uint64_t capacity;
56 uint64_t grain_size;
57 uint64_t desc_offset;
58 uint64_t desc_size;
59 uint32_t ngtes;
60 #define VMDK_NGTES 512
61 uint64_t rgd_offset;
62 uint64_t gd_offset;
63 uint64_t overhead;
64 uint8_t unclean;
65 uint32_t nl_test;
66 #define VMDK_NL_TEST 0x0a200d0a
67 uint16_t compress;
68 #define VMDK_COMPRESS_NONE 0
69 #define VMDK_COMPRESS_DEFLATE 1
70 char padding[433];
71 } __attribute__((__packed__));
72
73 static const char desc_fmt[] =
74 "# Disk DescriptorFile\n"
75 "version=%d\n"
76 "CID=%08x\n"
77 "parentCID=ffffffff\n"
78 "createType=\"monolithicSparse\"\n"
79 "# Extent description\n"
80 "RW %ju SPARSE \"%s\"\n"
81 "# The Disk Data Base\n"
82 "#DDB\n"
83 "ddb.adapterType = \"ide\"\n"
84 "ddb.geometry.cylinders = \"%u\"\n"
85 "ddb.geometry.heads = \"%u\"\n"
86 "ddb.geometry.sectors = \"%u\"\n";
87
88 static uint64_t grainsz;
89
90 static int
vmdk_resize(lba_t imgsz)91 vmdk_resize(lba_t imgsz)
92 {
93 uint64_t imagesz;
94
95 imagesz = imgsz * secsz;
96 imagesz = (imagesz + VMDK_IMAGE_ROUND - 1) & ~(VMDK_IMAGE_ROUND - 1);
97 grainsz = (blksz < VMDK_MIN_GRAIN_SIZE) ? VMDK_MIN_GRAIN_SIZE : blksz;
98
99 if (verbose)
100 fprintf(stderr, "VMDK: image size = %ju, grain size = %ju\n",
101 (uintmax_t)imagesz, (uintmax_t)grainsz);
102
103 grainsz /= VMDK_SECTOR_SIZE;
104 return (image_set_size(imagesz / secsz));
105 }
106
107 static int
vmdk_write(int fd)108 vmdk_write(int fd)
109 {
110 struct vmdk_header hdr;
111 uint32_t *gt, *gd, *rgd;
112 char *buf, *desc;
113 off_t cur, lim;
114 uint64_t imagesz;
115 lba_t blkofs, blkcnt;
116 size_t gdsz, gtsz;
117 uint32_t sec, cursec;
118 int error, desc_len, n, ngrains, ngts;
119
120 imagesz = (image_get_size() * secsz) / VMDK_SECTOR_SIZE;
121
122 memset(&hdr, 0, sizeof(hdr));
123 le32enc(&hdr.magic, VMDK_MAGIC);
124 le32enc(&hdr.version, VMDK_VERSION);
125 le32enc(&hdr.flags, VMDK_FLAGS_NL_TEST | VMDK_FLAGS_RGT_USED);
126 le64enc(&hdr.capacity, imagesz);
127 le64enc(&hdr.grain_size, grainsz);
128
129 n = asprintf(&desc, desc_fmt, 1 /*version*/, 0 /*CID*/,
130 (uintmax_t)imagesz /*size*/, "" /*name*/,
131 ncyls /*cylinders*/, nheads /*heads*/, nsecs /*sectors*/);
132 if (n == -1)
133 return (ENOMEM);
134
135 desc_len = (n + VMDK_SECTOR_SIZE - 1) & ~(VMDK_SECTOR_SIZE - 1);
136 desc = realloc(desc, desc_len);
137 memset(desc + n, 0, desc_len - n);
138
139 le64enc(&hdr.desc_offset, 1);
140 le64enc(&hdr.desc_size, desc_len / VMDK_SECTOR_SIZE);
141 le32enc(&hdr.ngtes, VMDK_NGTES);
142
143 sec = desc_len / VMDK_SECTOR_SIZE + 1;
144
145 ngrains = imagesz / grainsz;
146 ngts = (ngrains + VMDK_NGTES - 1) / VMDK_NGTES;
147 gdsz = (ngts * sizeof(uint32_t) + VMDK_SECTOR_SIZE - 1) &
148 ~(VMDK_SECTOR_SIZE - 1);
149
150 gd = calloc(1, gdsz);
151 if (gd == NULL) {
152 free(desc);
153 return (ENOMEM);
154 }
155 le64enc(&hdr.gd_offset, sec);
156 sec += gdsz / VMDK_SECTOR_SIZE;
157 for (n = 0; n < ngts; n++) {
158 le32enc(gd + n, sec);
159 sec += VMDK_NGTES * sizeof(uint32_t) / VMDK_SECTOR_SIZE;
160 }
161
162 rgd = calloc(1, gdsz);
163 if (rgd == NULL) {
164 free(gd);
165 free(desc);
166 return (ENOMEM);
167 }
168 le64enc(&hdr.rgd_offset, sec);
169 sec += gdsz / VMDK_SECTOR_SIZE;
170 for (n = 0; n < ngts; n++) {
171 le32enc(rgd + n, sec);
172 sec += VMDK_NGTES * sizeof(uint32_t) / VMDK_SECTOR_SIZE;
173 }
174
175 sec = (sec + grainsz - 1) & ~(grainsz - 1);
176
177 if (verbose)
178 fprintf(stderr, "VMDK: overhead = %ju\n",
179 (uintmax_t)(sec * VMDK_SECTOR_SIZE));
180
181 le64enc(&hdr.overhead, sec);
182 be32enc(&hdr.nl_test, VMDK_NL_TEST);
183
184 gt = calloc(ngts, VMDK_NGTES * sizeof(uint32_t));
185 if (gt == NULL) {
186 free(rgd);
187 free(gd);
188 free(desc);
189 return (ENOMEM);
190 }
191 gtsz = ngts * VMDK_NGTES * sizeof(uint32_t);
192
193 cursec = sec;
194 blkcnt = (grainsz * VMDK_SECTOR_SIZE) / secsz;
195 for (n = 0; n < ngrains; n++) {
196 blkofs = n * blkcnt;
197 if (image_data(blkofs, blkcnt)) {
198 le32enc(gt + n, cursec);
199 cursec += grainsz;
200 }
201 }
202
203 error = 0;
204 if (!error && sparse_write(fd, &hdr, VMDK_SECTOR_SIZE) < 0)
205 error = errno;
206 if (!error && sparse_write(fd, desc, desc_len) < 0)
207 error = errno;
208 if (!error && sparse_write(fd, gd, gdsz) < 0)
209 error = errno;
210 if (!error && sparse_write(fd, gt, gtsz) < 0)
211 error = errno;
212 if (!error && sparse_write(fd, rgd, gdsz) < 0)
213 error = errno;
214 if (!error && sparse_write(fd, gt, gtsz) < 0)
215 error = errno;
216 free(gt);
217 free(rgd);
218 free(gd);
219 free(desc);
220 if (error)
221 return (error);
222
223 cur = VMDK_SECTOR_SIZE + desc_len + (gdsz + gtsz) * 2;
224 lim = sec * VMDK_SECTOR_SIZE;
225 if (cur < lim) {
226 buf = calloc(1, VMDK_SECTOR_SIZE);
227 if (buf == NULL)
228 error = ENOMEM;
229 while (!error && cur < lim) {
230 if (sparse_write(fd, buf, VMDK_SECTOR_SIZE) < 0)
231 error = errno;
232 cur += VMDK_SECTOR_SIZE;
233 }
234 if (buf != NULL)
235 free(buf);
236 }
237 if (error)
238 return (error);
239
240 blkcnt = (grainsz * VMDK_SECTOR_SIZE) / secsz;
241 for (n = 0; n < ngrains; n++) {
242 blkofs = n * blkcnt;
243 if (image_data(blkofs, blkcnt)) {
244 error = image_copyout_region(fd, blkofs, blkcnt);
245 if (error)
246 return (error);
247 }
248 }
249 return (image_copyout_done(fd));
250 }
251
252 static struct mkimg_format vmdk_format = {
253 .name = "vmdk",
254 .description = "Virtual Machine Disk",
255 .resize = vmdk_resize,
256 .write = vmdk_write,
257 };
258
259 FORMAT_DEFINE(vmdk_format);
260