usr.bin/mkimg/vmdk.c

   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 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/types.h>
  31 #include <sys/apm.h>
  32 #include <sys/endian.h>
  33 #include <sys/errno.h>
  34 #include <stdint.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39
  40 #include "image.h"
  41 #include "format.h"
  42 #include "mkimg.h"
  43
  44 #define VMDK_IMAGE_ROUND        1048576
  45 #define VMDK_MIN_GRAIN_SIZE     8192
  46 #define VMDK_SECTOR_SIZE        512
  47
  48 struct vmdk_header {
  49         uint32_t        magic;
  50 #define VMDK_MAGIC              0x564d444b
  51         uint32_t        version;
  52 #define VMDK_VERSION            1
  53         uint32_t        flags;
  54 #define VMDK_FLAGS_NL_TEST      (1 << 0)
  55 #define VMDK_FLAGS_RGT_USED     (1 << 1)
  56 #define VMDK_FLAGS_COMPRESSED   (1 << 16)
  57 #define VMDK_FLAGS_MARKERS      (1 << 17)
  58         uint64_t        capacity;
  59         uint64_t        grain_size;
  60         uint64_t        desc_offset;
  61         uint64_t        desc_size;
  62         uint32_t        ngtes;
  63 #define VMDK_NGTES              512
  64         uint64_t        rgd_offset;
  65         uint64_t        gd_offset;
  66         uint64_t        overhead;
  67         uint8_t         unclean;
  68         uint32_t        nl_test;
  69 #define VMDK_NL_TEST            0x0a200d0a
  70         uint16_t        compress;
  71 #define VMDK_COMPRESS_NONE      0
  72 #define VMDK_COMPRESS_DEFLATE   1
  73         char            padding[433];
  74 } __attribute__((__packed__));
  75
  76 static const char desc_fmt[] =
  77     "# Disk DescriptorFile\n"
  78     "version=%d\n"
  79     "CID=%08x\n"
  80     "parentCID=ffffffff\n"
  81     "createType=\"monolithicSparse\"\n"
  82     "# Extent description\n"
  83     "RW %ju SPARSE \"%s\"\n"
  84     "# The Disk Data Base\n"
  85     "#DDB\n"
  86     "ddb.adapterType = \"ide\"\n"
  87     "ddb.geometry.cylinders = \"%u\"\n"
  88     "ddb.geometry.heads = \"%u\"\n"
  89     "ddb.geometry.sectors = \"%u\"\n";
  90
  91 static uint64_t grainsz;
  92
  93 static int
  94 vmdk_resize(lba_t imgsz)
  95 {
  96         uint64_t imagesz;
  97
  98         imagesz = imgsz * secsz;
  99         imagesz = (imagesz + VMDK_IMAGE_ROUND - 1) & ~(VMDK_IMAGE_ROUND - 1);
 100         grainsz = (blksz < VMDK_MIN_GRAIN_SIZE) ? VMDK_MIN_GRAIN_SIZE : blksz;
 101
 102         if (verbose)
 103                 fprintf(stderr, "VMDK: image size = %ju, grain size = %ju\n",
 104                     (uintmax_t)imagesz, (uintmax_t)grainsz);
 105
 106         grainsz /= VMDK_SECTOR_SIZE;
 107         return (image_set_size(imagesz / secsz));
 108 }
 109
 110 static int
 111 vmdk_write(int fd)
 112 {
 113         struct vmdk_header hdr;
 114         uint32_t *gt, *gd;
 115         char *buf, *desc;
 116         off_t cur, lim;
 117         uint64_t imagesz;
 118         size_t gdsz, gtsz;
 119         uint32_t sec;
 120         int error, desc_len, n, ngrains, ngts;
 121
 122         imagesz = (image_get_size() * secsz) / VMDK_SECTOR_SIZE;
 123
 124         memset(&hdr, 0, sizeof(hdr));
 125         le32enc(&hdr.magic, VMDK_MAGIC);
 126         le32enc(&hdr.version, VMDK_VERSION);
 127         le32enc(&hdr.flags, VMDK_FLAGS_NL_TEST | VMDK_FLAGS_RGT_USED);
 128         le64enc(&hdr.capacity, imagesz);
 129         le64enc(&hdr.grain_size, grainsz);
 130
 131         n = asprintf(&desc, desc_fmt, 1 /*version*/, 0 /*CID*/,
 132             (uintmax_t)imagesz /*size*/, "" /*name*/,
 133             ncyls /*cylinders*/, nheads /*heads*/, nsecs /*sectors*/);
 134         if (n == -1)
 135                 return (ENOMEM);
 136
 137         desc_len = (n + VMDK_SECTOR_SIZE - 1) & ~(VMDK_SECTOR_SIZE - 1);
 138         desc = realloc(desc, desc_len);
 139         memset(desc + n, 0, desc_len - n);
 140
 141         le64enc(&hdr.desc_offset, 1);
 142         le64enc(&hdr.desc_size, desc_len / VMDK_SECTOR_SIZE);
 143         le32enc(&hdr.ngtes, VMDK_NGTES);
 144
 145         sec = desc_len / VMDK_SECTOR_SIZE + 1;
 146         le64enc(&hdr.rgd_offset, sec);
 147         le64enc(&hdr.gd_offset, sec);
 148
 149         ngrains = imagesz / grainsz;
 150         ngts = (ngrains + VMDK_NGTES - 1) / VMDK_NGTES;
 151         gdsz = (ngts * sizeof(uint32_t) + VMDK_SECTOR_SIZE - 1) &
 152             ~(VMDK_SECTOR_SIZE - 1);
 153         gd = calloc(gdsz, 1);
 154         if (gd == NULL) {
 155                 free(desc);
 156                 return (ENOMEM);
 157         }
 158
 159         sec += gdsz / VMDK_SECTOR_SIZE;
 160         for (n = 0; n < ngts; n++) {
 161                 le32enc(gd + n, sec);
 162                 sec += VMDK_NGTES * sizeof(uint32_t) / VMDK_SECTOR_SIZE;
 163         }
 164
 165         sec = (sec + grainsz - 1) & ~(grainsz - 1);
 166
 167         if (verbose)
 168                 fprintf(stderr, "VMDK: overhead = %ju\n",
 169                     (uintmax_t)(sec * VMDK_SECTOR_SIZE));
 170
 171         le64enc(&hdr.overhead, sec);
 172         be32enc(&hdr.nl_test, VMDK_NL_TEST);
 173
 174         gtsz = ngts * VMDK_NGTES * sizeof(uint32_t);
 175         gt = calloc(gtsz, 1);
 176         if (gt == NULL) {
 177                 free(gd);
 178                 free(desc);
 179                 return (ENOMEM);
 180         }
 181
 182         for (n = 0; n < ngrains; n++)
 183                 le32enc(gt + n, sec + n * grainsz);
 184
 185         error = 0;
 186         if (!error && sparse_write(fd, &hdr, VMDK_SECTOR_SIZE) < 0)
 187                 error = errno;
 188         if (!error && sparse_write(fd, desc, desc_len) < 0)
 189                 error = errno;
 190         if (!error && sparse_write(fd, gd, gdsz) < 0)
 191                 error = errno;
 192         if (!error && sparse_write(fd, gt, gtsz) < 0)
 193                 error = errno;
 194         free(gt);
 195         free(gd);
 196         free(desc);
 197         if (error)
 198                 return (error);
 199
 200         cur = VMDK_SECTOR_SIZE + desc_len + gdsz + gtsz;
 201         lim = sec * VMDK_SECTOR_SIZE;
 202         if (cur < lim) {
 203                 buf = calloc(VMDK_SECTOR_SIZE, 1);
 204                 if (buf == NULL)
 205                         error = ENOMEM;
 206                 while (!error && cur < lim) {
 207                         if (sparse_write(fd, buf, VMDK_SECTOR_SIZE) < 0)
 208                                 error = errno;
 209                         cur += VMDK_SECTOR_SIZE;
 210                 }
 211                 if (buf != NULL)
 212                         free(buf);
 213         }
 214         if (!error)
 215                 error = image_copyout(fd);
 216         return (error);
 217 }
 218
 219 static struct mkimg_format vmdk_format = {
 220         .name = "vmdk",
 221         .description = "Virtual Machine Disk",
 222         .resize = vmdk_resize,
 223         .write = vmdk_write,
 224 };
 225
 226 FORMAT_DEFINE(vmdk_format);