plugins/partitioning/partitioning.c

   1 /* nbdkit
   2  * Copyright (C) 2018-2020 Red Hat Inc.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  * * Redistributions in binary form must reproduce the above copyright
  12  * notice, this list of conditions and the following disclaimer in the
  13  * documentation and/or other materials provided with the distribution.
  14  *
  15  * * Neither the name of Red Hat nor the names of its contributors may be
  16  * used to endorse or promote products derived from this software without
  17  * specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  22  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  26  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  27  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  28  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  29  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <config.h>
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <stdbool.h>
  38 #include <stdint.h>
  39 #include <inttypes.h>
  40 #include <string.h>
  41 #include <unistd.h>
  42 #include <fcntl.h>
  43 #include <assert.h>
  44 #include <errno.h>
  45 #include <time.h>
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48
  49 #include <nbdkit-plugin.h>
  50
  51 #include "byte-swapping.h"
  52 #include "isaligned.h"
  53 #include "iszero.h"
  54 #include "rounding.h"
  55
  56 #include "random.h"
  57 #include "regions.h"
  58 #include "virtual-disk.h"
  59
  60 #ifndef HAVE_FDATASYNC
  61 #define fdatasync fsync
  62 #endif
  63
  64 /* Debug flag: -D partitioning.regions=1: Print the regions table. */
  65 int partitioning_debug_regions;
  66
  67 /* alignment, mbr_id, type_guid set on the command line for
  68  * following partitions.
  69  */
  70 unsigned long alignment = DEFAULT_ALIGNMENT;
  71 uint8_t mbr_id = DEFAULT_MBR_ID;
  72 char type_guid[16]; /* initialized by partitioning_load function below */
  73
  74 /* partition-type parameter. */
  75 int parttype = PARTTYPE_UNSET;
  76
  77 /* Files supplied on the command line. */
  78 struct file *files = NULL;
  79 size_t nr_files = 0;
  80
  81 /* Virtual disk layout. */
  82 struct regions regions;
  83
  84 /* Primary and secondary partition tables and extended boot records.
  85  * Secondary PT is only used for GPT.  EBR array of sectors is only
  86  * used for MBR with > 4 partitions and has length equal to nr_files-3.
  87  */
  88 unsigned char *primary = NULL, *secondary = NULL, **ebr = NULL;
  89
  90 /* Used to generate random unique partition GUIDs for GPT. */
  91 static struct random_state random_state;
  92
  93 static void
  94 partitioning_load (void)
  95 {
  96   init_regions (&regions);
  97   parse_guid (DEFAULT_TYPE_GUID, type_guid);
  98   xsrandom (time (NULL), &random_state);
  99 }
 100
 101 static void
 102 partitioning_unload (void)
 103 {
 104   size_t i;
 105
 106   for (i = 0; i < nr_files; ++i)
 107     close (files[i].fd);
 108   free (files);
 109
 110   /* We don't need to free regions.regions[].u.data because it points
 111    * to primary, secondary or ebr which we free here.
 112    */
 113   free_regions (&regions);
 114
 115   free (primary);
 116   free (secondary);
 117   if (ebr) {
 118     for (i = 0; i < nr_files-3; ++i)
 119       free (ebr[i]);
 120     free (ebr);
 121   }
 122 }
 123
 124 static int
 125 partitioning_config (const char *key, const char *value)
 126 {
 127   struct file *p;
 128   struct file file;
 129   size_t i;
 130   int err;
 131
 132   if (strcmp (key, "file") == 0) {
 133     file.filename = value;
 134     file.alignment = alignment;
 135     file.mbr_id = mbr_id;
 136     memcpy (file.type_guid, type_guid, sizeof type_guid);
 137
 138     file.fd = open (file.filename, O_RDWR);
 139     if (file.fd == -1) {
 140       nbdkit_error ("%s: %m", file.filename);
 141       return -1;
 142     }
 143     if (fstat (file.fd, &file.statbuf) == -1) {
 144       err = errno;
 145       close (file.fd);
 146       errno = err;
 147       nbdkit_error ("%s: stat: %m", file.filename);
 148       return -1;
 149     }
 150
 151     if (file.statbuf.st_size == 0) {
 152       nbdkit_error ("%s: zero length partitions are not allowed",
 153                     file.filename);
 154       return -1;
 155     }
 156
 157     /* Create a random GUID used as "Unique partition GUID".  However
 158      * this doesn't follow GUID conventions so in theory could make an
 159      * invalid value.  This is only used by GPT, and we store it in
 160      * the file structure because it must be the same across primary
 161      * and secondary PT entries.
 162      */
 163     for (i = 0; i < 16; ++i)
 164       file.guid[i] = xrandom (&random_state) & 0xff;
 165
 166     p = realloc (files, (nr_files+1) * sizeof (struct file));
 167     if (p == NULL) {
 168       err = errno;
 169       close (file.fd);
 170       errno = err;
 171       nbdkit_error ("realloc: %m");
 172       return -1;
 173     }
 174     files = p;
 175     files[nr_files] = file;
 176     nr_files++;
 177   }
 178   else if (strcmp (key, "partition-type") == 0) {
 179     if (strcasecmp (value, "mbr") == 0 || strcasecmp (value, "dos") == 0)
 180       parttype = PARTTYPE_MBR;
 181     else if (strcasecmp (value, "gpt") == 0)
 182       parttype = PARTTYPE_GPT;
 183     else {
 184       nbdkit_error ("unknown partition-type: %s", value);
 185       return -1;
 186     }
 187   }
 188   else if (strcmp (key, "alignment") == 0) {
 189     int64_t r;
 190
 191     r = nbdkit_parse_size (value);
 192     if (r == -1)
 193       return -1;
 194
 195     if (!(r >= SECTOR_SIZE && r <= MAX_ALIGNMENT)) {
 196       nbdkit_error ("partition alignment %" PRIi64 " should be "
 197                     ">= sector size %" PRIu64 " and "
 198                     "<= maximum alignment %" PRIu64,
 199                     r, SECTOR_SIZE, MAX_ALIGNMENT);
 200       return -1;
 201     }
 202     if (!IS_ALIGNED (r, SECTOR_SIZE)) {
 203       nbdkit_error ("partition alignment %" PRIi64 " should be "
 204                     "a multiple of sector size %" PRIu64,
 205                     r, SECTOR_SIZE);
 206       return -1;
 207     }
 208
 209     alignment = r;
 210   }
 211   else if (strcmp (key, "mbr-id") == 0) {
 212     if (strcasecmp (value, "default") == 0)
 213       mbr_id = DEFAULT_MBR_ID;
 214     else if (nbdkit_parse_uint8_t ("mbr-id", value, &mbr_id) == -1)
 215       return -1;
 216   }
 217   else if (strcmp (key, "type-guid") == 0) {
 218     if (strcasecmp (value, "default") == 0)
 219       parse_guid (DEFAULT_TYPE_GUID, type_guid);
 220     else if (parse_guid (value, type_guid) == -1) {
 221       nbdkit_error ("could not validate GUID: %s", value);
 222       return -1;
 223     }
 224   }
 225   else {
 226     nbdkit_error ("unknown parameter '%s'", key);
 227     return -1;
 228   }
 229
 230   return 0;
 231 }
 232
 233 static int
 234 partitioning_config_complete (void)
 235 {
 236   size_t i;
 237   uint64_t total_size;
 238   bool needs_gpt;
 239
 240   /* Not enough / too many files? */
 241   if (nr_files == 0) {
 242     nbdkit_error ("at least one file= parameter must be supplied");
 243     return -1;
 244   }
 245
 246   total_size = 0;
 247   for (i = 0; i < nr_files; ++i)
 248     total_size += files[i].statbuf.st_size;
 249   needs_gpt = total_size > MAX_MBR_DISK_SIZE;
 250
 251   /* Choose default parttype if not set. */
 252   if (parttype == PARTTYPE_UNSET) {
 253     if (needs_gpt || nr_files > 4) {
 254       parttype = PARTTYPE_GPT;
 255       nbdkit_debug ("picking partition type GPT");
 256     }
 257     else {
 258       parttype = PARTTYPE_MBR;
 259       nbdkit_debug ("picking partition type MBR");
 260     }
 261   }
 262   else if (parttype == PARTTYPE_MBR && needs_gpt) {
 263     nbdkit_error ("MBR partition table type supports "
 264                   "a maximum virtual disk size of about 2 TB, "
 265                   "but you requested %zu partition(s) "
 266                   "and a total size of %" PRIu64 " bytes (> %" PRIu64 ").  "
 267                   "Try using: partition-type=gpt",
 268                   nr_files, total_size, (uint64_t) MAX_MBR_DISK_SIZE);
 269     return -1;
 270   }
 271
 272   return create_virtual_disk_layout ();
 273 }
 274
 275 #define partitioning_config_help \
 276   "file=<FILENAME>  (required) File(s) containing partitions\n" \
 277   "partition-type=mbr|gpt      Partition type"
 278
 279 /* Create the per-connection handle. */
 280 static void *
 281 partitioning_open (int readonly)
 282 {
 283   return NBDKIT_HANDLE_NOT_NEEDED;
 284 }
 285
 286 #define THREAD_MODEL NBDKIT_THREAD_MODEL_PARALLEL
 287
 288 /* Get the disk size. */
 289 static int64_t
 290 partitioning_get_size (void *handle)
 291 {
 292   return virtual_size (&regions);
 293 }
 294
 295 /* Serves the same data over multiple connections. */
 296 static int
 297 partitioning_can_multi_conn (void *handle)
 298 {
 299   return 1;
 300 }
 301
 302 /* Cache. */
 303 static int
 304 partitioning_can_cache (void *handle)
 305 {
 306   /* Let nbdkit call pread to populate the file system cache. */
 307   return NBDKIT_CACHE_EMULATE;
 308 }
 309
 310 /* Initial state. */
 311 static int
 312 partitioning_init_sparse (void *handle)
 313 {
 314   /* region_zero regions mean we are sparse, even if we don't yet
 315    * support .extents
 316    */
 317   return 1;
 318 }
 319
 320 /* Read data. */
 321 static int
 322 partitioning_pread (void *handle, void *buf, uint32_t count, uint64_t offset)
 323 {
 324   while (count > 0) {
 325     const struct region *region = find_region (&regions, offset);
 326     size_t i, len;
 327     ssize_t r;
 328
 329     /* Length to end of region. */
 330     len = region->end - offset + 1;
 331     if (len > count)
 332       len = count;
 333
 334     switch (region->type) {
 335     case region_file:
 336       i = region->u.i;
 337       assert (i < nr_files);
 338       r = pread (files[i].fd, buf, len, offset - region->start);
 339       if (r == -1) {
 340         nbdkit_error ("pread: %s: %m", files[i].filename);
 341         return -1;
 342       }
 343       if (r == 0) {
 344         nbdkit_error ("pread: %s: unexpected end of file", files[i].filename);
 345         return -1;
 346       }
 347       len = r;
 348       break;
 349
 350     case region_data:
 351       memcpy (buf, &region->u.data[offset - region->start], len);
 352       break;
 353
 354     case region_zero:
 355       memset (buf, 0, len);
 356       break;
 357     }
 358
 359     count -= len;
 360     buf += len;
 361     offset += len;
 362   }
 363
 364   return 0;
 365 }
 366
 367 /* Write data. */
 368 static int
 369 partitioning_pwrite (void *handle,
 370                      const void *buf, uint32_t count, uint64_t offset)
 371 {
 372   while (count > 0) {
 373     const struct region *region = find_region (&regions, offset);
 374     size_t i, len;
 375     ssize_t r;
 376
 377     /* Length to end of region. */
 378     len = region->end - offset + 1;
 379     if (len > count)
 380       len = count;
 381
 382     switch (region->type) {
 383     case region_file:
 384       i = region->u.i;
 385       assert (i < nr_files);
 386       r = pwrite (files[i].fd, buf, len, offset - region->start);
 387       if (r == -1) {
 388         nbdkit_error ("pwrite: %s: %m", files[i].filename);
 389         return -1;
 390       }
 391       len = r;
 392       break;
 393
 394     case region_data:
 395       /* You can only write same data as already present. */
 396       if (memcmp (&region->u.data[offset - region->start], buf, len) != 0) {
 397         nbdkit_error ("attempt to change partition table of virtual disk");
 398         errno = EIO;
 399         return -1;
 400       }
 401       break;
 402
 403     case region_zero:
 404       /* You can only write zeroes. */
 405       if (!is_zero (buf, len)) {
 406         nbdkit_error ("write non-zeroes to padding region");
 407         errno = EIO;
 408         return -1;
 409       }
 410       break;
 411     }
 412
 413     count -= len;
 414     buf += len;
 415     offset += len;
 416   }
 417
 418   return 0;
 419 }
 420
 421 /* Flush. */
 422 static int
 423 partitioning_flush (void *handle)
 424 {
 425   size_t i;
 426
 427   for (i = 0; i < nr_files; ++i) {
 428     if (fdatasync (files[i].fd) == -1) {
 429       nbdkit_error ("fdatasync: %m");
 430       return -1;
 431     }
 432   }
 433
 434   return 0;
 435 }
 436
 437 static struct nbdkit_plugin plugin = {
 438   .name              = "partitioning",
 439   .version           = PACKAGE_VERSION,
 440   .load              = partitioning_load,
 441   .unload            = partitioning_unload,
 442   .config            = partitioning_config,
 443   .config_complete   = partitioning_config_complete,
 444   .config_help       = partitioning_config_help,
 445   .magic_config_key = "file",
 446   .open              = partitioning_open,
 447   .get_size          = partitioning_get_size,
 448   .can_multi_conn    = partitioning_can_multi_conn,
 449   .can_cache         = partitioning_can_cache,
 450   .init_sparse       = partitioning_init_sparse,
 451   .pread             = partitioning_pread,
 452   .pwrite            = partitioning_pwrite,
 453   .flush             = partitioning_flush,
 454   /* In this plugin, errno is preserved properly along error return
 455    * paths from failed system calls.
 456    */
 457   .errno_is_preserved = 1,
 458 };
 459
 460 NBDKIT_REGISTER_PLUGIN(plugin)