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