usr.bin/mkimg/mkimg.c

   1 /*-
   2  * Copyright (c) 2013,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/stat.h>
  31 #include <errno.h>
  32 #include <err.h>
  33 #include <fcntl.h>
  34 #include <getopt.h>
  35 #include <libutil.h>
  36 #include <limits.h>
  37 #include <stdint.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <sysexits.h>
  42 #include <unistd.h>
  43
  44 #include "image.h"
  45 #include "format.h"
  46 #include "mkimg.h"
  47 #include "scheme.h"
  48
  49 #define LONGOPT_FORMATS 0x01000001
  50 #define LONGOPT_SCHEMES 0x01000002
  51 #define LONGOPT_VERSION 0x01000003
  52
  53 static struct option longopts[] = {
  54         { "formats", no_argument, NULL, LONGOPT_FORMATS },
  55         { "schemes", no_argument, NULL, LONGOPT_SCHEMES },
  56         { "version", no_argument, NULL, LONGOPT_VERSION },
  57         { NULL, 0, NULL, 0 }
  58 };
  59
  60 static uint64_t capacity;
  61
  62 struct partlisthead partlist = TAILQ_HEAD_INITIALIZER(partlist);
  63 u_int nparts = 0;
  64
  65 u_int unit_testing;
  66 u_int verbose;
  67
  68 u_int ncyls = 0;
  69 u_int nheads = 1;
  70 u_int nsecs = 1;
  71 u_int secsz = 512;
  72 u_int blksz = 0;
  73 uint32_t active_partition = 0;
  74
  75 static void
  76 print_formats(int usage)
  77 {
  78         struct mkimg_format *f;
  79         const char *sep;
  80
  81         if (usage) {
  82                 fprintf(stderr, "    formats:\n");
  83                 f = NULL;
  84                 while ((f = format_iterate(f)) != NULL) {
  85                         fprintf(stderr, "\t%s\t-  %s\n", f->name,
  86                             f->description);
  87                 }
  88         } else {
  89                 sep = "";
  90                 f = NULL;
  91                 while ((f = format_iterate(f)) != NULL) {
  92                         printf("%s%s", sep, f->name);
  93                         sep = " ";
  94                 }
  95                 putchar('\n');
  96         }
  97 }
  98
  99 static void
 100 print_schemes(int usage)
 101 {
 102         struct mkimg_scheme *s;
 103         const char *sep;
 104
 105         if (usage) {
 106                 fprintf(stderr, "    schemes:\n");
 107                 s = NULL;
 108                 while ((s = scheme_iterate(s)) != NULL) {
 109                         fprintf(stderr, "\t%s\t-  %s\n", s->name,
 110                             s->description);
 111                 }
 112         } else {
 113                 sep = "";
 114                 s = NULL;
 115                 while ((s = scheme_iterate(s)) != NULL) {
 116                         printf("%s%s", sep, s->name);
 117                         sep = " ";
 118                 }
 119                 putchar('\n');
 120         }
 121 }
 122
 123 static void
 124 print_version(void)
 125 {
 126         u_int width;
 127
 128 #ifdef __LP64__
 129         width = 64;
 130 #else
 131         width = 32;
 132 #endif
 133         printf("mkimg %u (%u-bit)\n", MKIMG_VERSION, width);
 134 }
 135
 136 static void
 137 usage(const char *why)
 138 {
 139
 140         warnx("error: %s", why);
 141         fputc('\n', stderr);
 142         fprintf(stderr, "usage: %s <options>\n", getprogname());
 143
 144         fprintf(stderr, "    options:\n");
 145         fprintf(stderr, "\t--formats\t-  list image formats\n");
 146         fprintf(stderr, "\t--schemes\t-  list partition schemes\n");
 147         fprintf(stderr, "\t--version\t-  show version information\n");
 148         fputc('\n', stderr);
 149         fprintf(stderr, "\t-a <num>\t-  mark num'th partion as active\n");
 150         fprintf(stderr, "\t-b <file>\t-  file containing boot code\n");
 151         fprintf(stderr, "\t-c <num>\t-  capacity (in bytes) of the disk\n");
 152         fprintf(stderr, "\t-f <format>\n");
 153         fprintf(stderr, "\t-o <file>\t-  file to write image into\n");
 154         fprintf(stderr, "\t-p <partition>\n");
 155         fprintf(stderr, "\t-s <scheme>\n");
 156         fprintf(stderr, "\t-v\t\t-  increase verbosity\n");
 157         fprintf(stderr, "\t-y\t\t-  [developers] enable unit test\n");
 158         fprintf(stderr, "\t-H <num>\t-  number of heads to simulate\n");
 159         fprintf(stderr, "\t-P <num>\t-  physical sector size\n");
 160         fprintf(stderr, "\t-S <num>\t-  logical sector size\n");
 161         fprintf(stderr, "\t-T <num>\t-  number of tracks to simulate\n");
 162         fputc('\n', stderr);
 163         print_formats(1);
 164         fputc('\n', stderr);
 165         print_schemes(1);
 166         fputc('\n', stderr);
 167         fprintf(stderr, "    partition specification:\n");
 168         fprintf(stderr, "\t<t>[/<l>]::<size>\t-  empty partition of given "
 169             "size\n");
 170         fprintf(stderr, "\t<t>[/<l>]:=<file>\t-  partition content and size "
 171             "are determined\n\t\t\t\t   by the named file\n");
 172         fprintf(stderr, "\t<t>[/<l>]:-<cmd>\t-  partition content and size "
 173             "are taken from\n\t\t\t\t   the output of the command to run\n");
 174         fprintf(stderr, "\t-\t\t\t-  unused partition entry\n");
 175         fprintf(stderr, "\t    where:\n");
 176         fprintf(stderr, "\t\t<t>\t-  scheme neutral partition type\n");
 177         fprintf(stderr, "\t\t<l>\t-  optional scheme-dependent partition "
 178             "label\n");
 179
 180         exit(EX_USAGE);
 181 }
 182
 183 static int
 184 parse_uint32(uint32_t *valp, uint32_t min, uint32_t max, const char *arg)
 185 {
 186         uint64_t val;
 187
 188         if (expand_number(arg, &val) == -1)
 189                 return (errno);
 190         if (val > UINT_MAX || val < (uint64_t)min || val > (uint64_t)max)
 191                 return (EINVAL);
 192         *valp = (uint32_t)val;
 193         return (0);
 194 }
 195
 196 static int
 197 parse_uint64(uint64_t *valp, uint64_t min, uint64_t max, const char *arg)
 198 {
 199         uint64_t val;
 200
 201         if (expand_number(arg, &val) == -1)
 202                 return (errno);
 203         if (val < min || val > max)
 204                 return (EINVAL);
 205         *valp = val;
 206         return (0);
 207 }
 208
 209 static int
 210 pwr_of_two(u_int nr)
 211 {
 212
 213         return (((nr & (nr - 1)) == 0) ? 1 : 0);
 214 }
 215
 216 /*
 217  * A partition specification has the following format:
 218  *      <type> ':' <kind> <contents>
 219  * where:
 220  *      type      the partition type alias
 221  *      kind      the interpretation of the contents specification
 222  *                ':'   contents holds the size of an empty partition
 223  *                '='   contents holds the name of a file to read
 224  *                '-'   contents holds a command to run; the output of
 225  *                      which is the contents of the partition.
 226  *      contents  the specification of a partition's contents
 227  *
 228  * A specification that is a single dash indicates an unused partition
 229  * entry.
 230  */
 231 static int
 232 parse_part(const char *spec)
 233 {
 234         struct part *part;
 235         char *sep;
 236         size_t len;
 237         int error;
 238
 239         if (strcmp(spec, "-") == 0) {
 240                 nparts++;
 241                 return (0);
 242         }
 243
 244         part = calloc(1, sizeof(struct part));
 245         if (part == NULL)
 246                 return (ENOMEM);
 247
 248         sep = strchr(spec, ':');
 249         if (sep == NULL) {
 250                 error = EINVAL;
 251                 goto errout;
 252         }
 253         len = sep - spec + 1;
 254         if (len < 2) {
 255                 error = EINVAL;
 256                 goto errout;
 257         }
 258         part->alias = malloc(len);
 259         if (part->alias == NULL) {
 260                 error = ENOMEM;
 261                 goto errout;
 262         }
 263         strlcpy(part->alias, spec, len);
 264         spec = sep + 1;
 265
 266         switch (*spec) {
 267         case ':':
 268                 part->kind = PART_KIND_SIZE;
 269                 break;
 270         case '=':
 271                 part->kind = PART_KIND_FILE;
 272                 break;
 273         case '-':
 274                 part->kind = PART_KIND_PIPE;
 275                 break;
 276         default:
 277                 error = EINVAL;
 278                 goto errout;
 279         }
 280         spec++;
 281
 282         part->contents = strdup(spec);
 283         if (part->contents == NULL) {
 284                 error = ENOMEM;
 285                 goto errout;
 286         }
 287
 288         spec = part->alias;
 289         sep = strchr(spec, '/');
 290         if (sep != NULL) {
 291                 *sep++ = '\0';
 292                 if (strlen(part->alias) == 0 || strlen(sep) == 0) {
 293                         error = EINVAL;
 294                         goto errout;
 295                 }
 296                 part->label = strdup(sep);
 297                 if (part->label == NULL) {
 298                         error = ENOMEM;
 299                         goto errout;
 300                 }
 301         }
 302
 303         part->index = nparts;
 304         TAILQ_INSERT_TAIL(&partlist, part, link);
 305         nparts++;
 306         return (0);
 307
 308  errout:
 309         if (part->alias != NULL)
 310                 free(part->alias);
 311         free(part);
 312         return (error);
 313 }
 314
 315 #if defined(SPARSE_WRITE)
 316 ssize_t
 317 sparse_write(int fd, const void *ptr, size_t sz)
 318 {
 319         const char *buf, *p;
 320         off_t ofs;
 321         size_t len;
 322         ssize_t wr, wrsz;
 323
 324         buf = ptr;
 325         wrsz = 0;
 326         p = memchr(buf, 0, sz);
 327         while (sz > 0) {
 328                 len = (p != NULL) ? (size_t)(p - buf) : sz;
 329                 if (len > 0) {
 330                         len = (len + secsz - 1) & ~(secsz - 1);
 331                         if (len > sz)
 332                                 len = sz;
 333                         wr = write(fd, buf, len);
 334                         if (wr < 0)
 335                                 return (-1);
 336                 } else {
 337                         while (len < sz && *p++ == '\0')
 338                                 len++;
 339                         if (len < sz)
 340                                 len &= ~(secsz - 1);
 341                         if (len == 0)
 342                                 continue;
 343                         ofs = lseek(fd, len, SEEK_CUR);
 344                         if (ofs < 0)
 345                                 return (-1);
 346                         wr = len;
 347                 }
 348                 buf += wr;
 349                 sz -= wr;
 350                 wrsz += wr;
 351                 p = memchr(buf, 0, sz);
 352         }
 353         return (wrsz);
 354 }
 355 #endif /* SPARSE_WRITE */
 356
 357 void
 358 mkimg_chs(lba_t lba, u_int maxcyl, u_int *cylp, u_int *hdp, u_int *secp)
 359 {
 360         u_int hd, sec;
 361
 362         *cylp = *hdp = *secp = ~0U;
 363         if (nsecs == 1 || nheads == 1)
 364                 return;
 365
 366         sec = lba % nsecs + 1;
 367         lba /= nsecs;
 368         hd = lba % nheads;
 369         lba /= nheads;
 370         if (lba > maxcyl)
 371                 return;
 372
 373         *cylp = lba;
 374         *hdp = hd;
 375         *secp = sec;
 376 }
 377
 378 static int
 379 capacity_resize(lba_t end)
 380 {
 381         lba_t capsz;
 382
 383         capsz = (capacity + secsz - 1) / secsz;
 384         if (end >= capsz)
 385                 return (0);
 386         return (image_set_size(capsz));
 387 }
 388
 389 static void
 390 mkimg(void)
 391 {
 392         FILE *fp;
 393         struct part *part;
 394         lba_t block;
 395         off_t bytesize;
 396         int error, fd;
 397
 398         /* First check partition information */
 399         TAILQ_FOREACH(part, &partlist, link) {
 400                 error = scheme_check_part(part);
 401                 if (error)
 402                         errc(EX_DATAERR, error, "partition %d", part->index+1);
 403         }
 404
 405         block = scheme_metadata(SCHEME_META_IMG_START, 0);
 406         TAILQ_FOREACH(part, &partlist, link) {
 407                 block = scheme_metadata(SCHEME_META_PART_BEFORE, block);
 408                 if (verbose)
 409                         fprintf(stderr, "partition %d: starting block %llu "
 410                             "... ", part->index + 1, (long long)block);
 411                 part->block = block;
 412                 switch (part->kind) {
 413                 case PART_KIND_SIZE:
 414                         if (expand_number(part->contents, &bytesize) == -1)
 415                                 error = errno;
 416                         break;
 417                 case PART_KIND_FILE:
 418                         fd = open(part->contents, O_RDONLY, 0);
 419                         if (fd != -1) {
 420                                 error = image_copyin(block, fd, &bytesize);
 421                                 close(fd);
 422                         } else
 423                                 error = errno;
 424                         break;
 425                 case PART_KIND_PIPE:
 426                         fp = popen(part->contents, "r");
 427                         if (fp != NULL) {
 428                                 fd = fileno(fp);
 429                                 error = image_copyin(block, fd, &bytesize);
 430                                 pclose(fp);
 431                         } else
 432                                 error = errno;
 433                         break;
 434                 }
 435                 if (error)
 436                         errc(EX_IOERR, error, "partition %d", part->index + 1);
 437                 part->size = (bytesize + secsz - 1) / secsz;
 438                 if (verbose) {
 439                         bytesize = part->size * secsz;
 440                         fprintf(stderr, "size %llu bytes (%llu blocks)\n",
 441                              (long long)bytesize, (long long)part->size);
 442                 }
 443                 block = scheme_metadata(SCHEME_META_PART_AFTER,
 444                     part->block + part->size);
 445         }
 446
 447         block = scheme_metadata(SCHEME_META_IMG_END, block);
 448         error = image_set_size(block);
 449         if (!error) {
 450                 error = capacity_resize(block);
 451                 block = image_get_size();
 452         }
 453         if (!error) {
 454                 error = format_resize(block);
 455                 block = image_get_size();
 456         }
 457         if (error)
 458                 errc(EX_IOERR, error, "image sizing");
 459         ncyls = block / (nsecs * nheads);
 460         error = scheme_write(block);
 461         if (error)
 462                 errc(EX_IOERR, error, "writing metadata");
 463 }
 464
 465 int
 466 main(int argc, char *argv[])
 467 {
 468         int bcfd, outfd;
 469         int c, error;
 470
 471         bcfd = -1;
 472         outfd = 1;      /* Write to stdout by default */
 473         while ((c = getopt_long(argc, argv, "a:b:c:f:o:p:s:vyH:P:S:T:",
 474             longopts, NULL)) != -1) {
 475                 switch (c) {
 476                 case 'a':       /* ACTIVE PARTITION, if supported */
 477                         error = parse_uint32(&active_partition, 1, 100, optarg);
 478                         if (error)
 479                                 errc(EX_DATAERR, error, "Partition ordinal");
 480                         break;
 481                 case 'b':       /* BOOT CODE */
 482                         if (bcfd != -1)
 483                                 usage("multiple bootcode given");
 484                         bcfd = open(optarg, O_RDONLY, 0);
 485                         if (bcfd == -1)
 486                                 err(EX_UNAVAILABLE, "%s", optarg);
 487                         break;
 488                 case 'c':       /* CAPACITY */
 489                         error = parse_uint64(&capacity, 1, INT64_MAX, optarg);
 490                         if (error)
 491                                 errc(EX_DATAERR, error, "capacity in bytes");
 492                         break;
 493                 case 'f':       /* OUTPUT FORMAT */
 494                         if (format_selected() != NULL)
 495                                 usage("multiple formats given");
 496                         error = format_select(optarg);
 497                         if (error)
 498                                 errc(EX_DATAERR, error, "format");
 499                         break;
 500                 case 'o':       /* OUTPUT FILE */
 501                         if (outfd != 1)
 502                                 usage("multiple output files given");
 503                         outfd = open(optarg, O_WRONLY | O_CREAT | O_TRUNC,
 504                             S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
 505                         if (outfd == -1)
 506                                 err(EX_CANTCREAT, "%s", optarg);
 507                         break;
 508                 case 'p':       /* PARTITION */
 509                         error = parse_part(optarg);
 510                         if (error)
 511                                 errc(EX_DATAERR, error, "partition");
 512                         break;
 513                 case 's':       /* SCHEME */
 514                         if (scheme_selected() != NULL)
 515                                 usage("multiple schemes given");
 516                         error = scheme_select(optarg);
 517                         if (error)
 518                                 errc(EX_DATAERR, error, "scheme");
 519                         break;
 520                 case 'y':
 521                         unit_testing++;
 522                         break;
 523                 case 'v':
 524                         verbose++;
 525                         break;
 526                 case 'H':       /* GEOMETRY: HEADS */
 527                         error = parse_uint32(&nheads, 1, 255, optarg);
 528                         if (error)
 529                                 errc(EX_DATAERR, error, "number of heads");
 530                         break;
 531                 case 'P':       /* GEOMETRY: PHYSICAL SECTOR SIZE */
 532                         error = parse_uint32(&blksz, 512, INT_MAX+1U, optarg);
 533                         if (error == 0 && !pwr_of_two(blksz))
 534                                 error = EINVAL;
 535                         if (error)
 536                                 errc(EX_DATAERR, error, "physical sector size");
 537                         break;
 538                 case 'S':       /* GEOMETRY: LOGICAL SECTOR SIZE */
 539                         error = parse_uint32(&secsz, 512, INT_MAX+1U, optarg);
 540                         if (error == 0 && !pwr_of_two(secsz))
 541                                 error = EINVAL;
 542                         if (error)
 543                                 errc(EX_DATAERR, error, "logical sector size");
 544                         break;
 545                 case 'T':       /* GEOMETRY: TRACK SIZE */
 546                         error = parse_uint32(&nsecs, 1, 63, optarg);
 547                         if (error)
 548                                 errc(EX_DATAERR, error, "track size");
 549                         break;
 550                 case LONGOPT_FORMATS:
 551                         print_formats(0);
 552                         exit(EX_OK);
 553                         /*NOTREACHED*/
 554                 case LONGOPT_SCHEMES:
 555                         print_schemes(0);
 556                         exit(EX_OK);
 557                         /*NOTREACHED*/
 558                 case LONGOPT_VERSION:
 559                         print_version();
 560                         exit(EX_OK);
 561                         /*NOTREACHED*/
 562                 default:
 563                         usage("unknown option");
 564                 }
 565         }
 566
 567         if (argc > optind)
 568                 usage("trailing arguments");
 569         if (scheme_selected() == NULL && nparts > 0)
 570                 usage("no scheme");
 571         if (nparts == 0 && capacity == 0)
 572                 usage("no partitions");
 573
 574         if (secsz > blksz) {
 575                 if (blksz != 0)
 576                         errx(EX_DATAERR, "the physical block size cannot "
 577                             "be smaller than the sector size");
 578                 blksz = secsz;
 579         }
 580
 581         if (secsz > scheme_max_secsz())
 582                 errx(EX_DATAERR, "maximum sector size supported is %u; "
 583                     "size specified is %u", scheme_max_secsz(), secsz);
 584
 585         if (nparts > scheme_max_parts())
 586                 errx(EX_DATAERR, "%d partitions supported; %d given",
 587                     scheme_max_parts(), nparts);
 588
 589         if (format_selected() == NULL)
 590                 format_select("raw");
 591
 592         if (bcfd != -1) {
 593                 error = scheme_bootcode(bcfd);
 594                 close(bcfd);
 595                 if (error)
 596                         errc(EX_DATAERR, error, "boot code");
 597         }
 598
 599         if (verbose) {
 600                 fprintf(stderr, "Logical sector size: %u\n", secsz);
 601                 fprintf(stderr, "Physical block size: %u\n", blksz);
 602                 fprintf(stderr, "Sectors per track:   %u\n", nsecs);
 603                 fprintf(stderr, "Number of heads:     %u\n", nheads);
 604                 fputc('\n', stderr);
 605                 if (scheme_selected())
 606                         fprintf(stderr, "Partitioning scheme: %s\n",
 607                             scheme_selected()->name);
 608                 fprintf(stderr, "Output file format:  %s\n",
 609                     format_selected()->name);
 610                 fputc('\n', stderr);
 611         }
 612
 613         error = image_init();
 614         if (error)
 615                 errc(EX_OSERR, error, "cannot initialize");
 616
 617         mkimg();
 618
 619         if (verbose) {
 620                 fputc('\n', stderr);
 621                 fprintf(stderr, "Number of cylinders: %u\n", ncyls);
 622         }
 623
 624         error = format_write(outfd);
 625         if (error)
 626                 errc(EX_IOERR, error, "writing image");
 627
 628         return (0);
 629 }