2 * Copyright (c) 2013,2014 Juniper Networks, Inc.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
51 #define LONGOPT_FORMATS 0x01000001
52 #define LONGOPT_SCHEMES 0x01000002
53 #define LONGOPT_VERSION 0x01000003
54 #define LONGOPT_CAPACITY 0x01000004
56 static struct option longopts[] = {
57 { "formats", no_argument, NULL, LONGOPT_FORMATS },
58 { "schemes", no_argument, NULL, LONGOPT_SCHEMES },
59 { "version", no_argument, NULL, LONGOPT_VERSION },
60 { "capacity", required_argument, NULL, LONGOPT_CAPACITY },
64 static uint64_t min_capacity = 0;
65 static uint64_t max_capacity = 0;
67 struct partlisthead partlist = TAILQ_HEAD_INITIALIZER(partlist);
78 uint32_t active_partition = 0;
81 print_formats(int usage)
83 struct mkimg_format *f;
87 fprintf(stderr, " formats:\n");
89 while ((f = format_iterate(f)) != NULL) {
90 fprintf(stderr, "\t%s\t- %s\n", f->name,
96 while ((f = format_iterate(f)) != NULL) {
97 printf("%s%s", sep, f->name);
105 print_schemes(int usage)
107 struct mkimg_scheme *s;
111 fprintf(stderr, " schemes:\n");
113 while ((s = scheme_iterate(s)) != NULL) {
114 fprintf(stderr, "\t%s\t- %s\n", s->name,
120 while ((s = scheme_iterate(s)) != NULL) {
121 printf("%s%s", sep, s->name);
138 printf("mkimg %u (%u-bit)\n", MKIMG_VERSION, width);
142 usage(const char *why)
145 warnx("error: %s", why);
147 fprintf(stderr, "usage: %s <options>\n", getprogname());
149 fprintf(stderr, " options:\n");
150 fprintf(stderr, "\t--formats\t- list image formats\n");
151 fprintf(stderr, "\t--schemes\t- list partition schemes\n");
152 fprintf(stderr, "\t--version\t- show version information\n");
154 fprintf(stderr, "\t-a <num>\t- mark num'th partition as active\n");
155 fprintf(stderr, "\t-b <file>\t- file containing boot code\n");
156 fprintf(stderr, "\t-c <num>\t- minimum capacity (in bytes) of the disk\n");
157 fprintf(stderr, "\t-C <num>\t- maximum capacity (in bytes) of the disk\n");
158 fprintf(stderr, "\t-f <format>\n");
159 fprintf(stderr, "\t-o <file>\t- file to write image into\n");
160 fprintf(stderr, "\t-p <partition>\n");
161 fprintf(stderr, "\t-s <scheme>\n");
162 fprintf(stderr, "\t-v\t\t- increase verbosity\n");
163 fprintf(stderr, "\t-y\t\t- [developers] enable unit test\n");
164 fprintf(stderr, "\t-H <num>\t- number of heads to simulate\n");
165 fprintf(stderr, "\t-P <num>\t- physical sector size\n");
166 fprintf(stderr, "\t-S <num>\t- logical sector size\n");
167 fprintf(stderr, "\t-T <num>\t- number of tracks to simulate\n");
173 fprintf(stderr, " partition specification:\n");
174 fprintf(stderr, "\t<t>[/<l>]::<size>[:[+]<offset>]\t- "
175 "empty partition of given size and\n\t\t\t\t\t"
176 " optional relative or absolute offset\n");
177 fprintf(stderr, "\t<t>[/<l>]:=<file>[:[+]offset]\t- partition "
178 "content and size are\n\t\t\t\t\t"
179 " determined by the named file and\n"
180 "\t\t\t\t\t optional relative or absolute offset\n");
181 fprintf(stderr, "\t<t>[/<l>]:-<cmd>\t\t- partition content and size "
182 "are taken\n\t\t\t\t\t from the output of the command to run\n");
183 fprintf(stderr, "\t-\t\t\t\t- unused partition entry\n");
184 fprintf(stderr, "\t where:\n");
185 fprintf(stderr, "\t\t<t>\t- scheme neutral partition type\n");
186 fprintf(stderr, "\t\t<l>\t- optional scheme-dependent partition "
193 parse_uint32(uint32_t *valp, uint32_t min, uint32_t max, const char *arg)
197 if (expand_number(arg, &val) == -1)
199 if (val > UINT_MAX || val < (uint64_t)min || val > (uint64_t)max)
201 *valp = (uint32_t)val;
206 parse_uint64(uint64_t *valp, uint64_t min, uint64_t max, const char *arg)
210 if (expand_number(arg, &val) == -1)
212 if (val < min || val > max)
222 return (((nr & (nr - 1)) == 0) ? 1 : 0);
226 * A partition specification has the following format:
227 * <type> ':' <kind> <contents>
229 * type the partition type alias
230 * kind the interpretation of the contents specification
231 * ':' contents holds the size of an empty partition
232 * '=' contents holds the name of a file to read
233 * '-' contents holds a command to run; the output of
234 * which is the contents of the partition.
235 * contents the specification of a partition's contents
237 * A specification that is a single dash indicates an unused partition
241 parse_part(const char *spec)
248 if (strcmp(spec, "-") == 0) {
253 part = calloc(1, sizeof(struct part));
257 sep = strchr(spec, ':');
262 len = sep - spec + 1;
267 part->alias = malloc(len);
268 if (part->alias == NULL) {
272 strlcpy(part->alias, spec, len);
277 part->kind = PART_KIND_SIZE;
280 part->kind = PART_KIND_FILE;
283 part->kind = PART_KIND_PIPE;
291 part->contents = strdup(spec);
292 if (part->contents == NULL) {
298 sep = strchr(spec, '/');
301 if (strlen(part->alias) == 0 || strlen(sep) == 0) {
305 part->label = strdup(sep);
306 if (part->label == NULL) {
312 part->index = nparts;
313 TAILQ_INSERT_TAIL(&partlist, part, link);
318 if (part->alias != NULL)
324 #if defined(SPARSE_WRITE)
326 sparse_write(int fd, const void *ptr, size_t sz)
335 p = memchr(buf, 0, sz);
337 len = (p != NULL) ? (size_t)(p - buf) : sz;
339 len = (len + secsz - 1) & ~(secsz - 1);
342 wr = write(fd, buf, len);
346 while (len < sz && *p++ == '\0')
352 ofs = lseek(fd, len, SEEK_CUR);
360 p = memchr(buf, 0, sz);
364 #endif /* SPARSE_WRITE */
367 mkimg_chs(lba_t lba, u_int maxcyl, u_int *cylp, u_int *hdp, u_int *secp)
371 *cylp = *hdp = *secp = ~0U;
372 if (nsecs == 1 || nheads == 1)
375 sec = lba % nsecs + 1;
388 capacity_resize(lba_t end)
390 lba_t min_capsz, max_capsz;
392 min_capsz = (min_capacity + secsz - 1) / secsz;
393 max_capsz = (max_capacity + secsz - 1) / secsz;
395 if (max_capsz != 0 && end > max_capsz)
397 if (end >= min_capsz)
400 return (image_set_size(min_capsz));
406 struct part *part, *part2;
407 lba_t start, end, start2, end2;
412 TAILQ_FOREACH(part, &partlist, link) {
414 end = part->block + part->size;
416 part2 = TAILQ_NEXT(part, link);
420 TAILQ_FOREACH_FROM(part2, &partlist, link) {
421 start2 = part2->block;
422 end2 = part2->block + part2->size;
424 if ((start >= start2 && start < end2) ||
425 (end > start2 && end <= end2)) {
426 errx(1, "partition %d overlaps partition %d",
442 lba_t block, blkoffset;
443 uint64_t bytesize, byteoffset;
448 /* First check partition information */
449 TAILQ_FOREACH(part, &partlist, link) {
450 error = scheme_check_part(part);
452 errc(EX_DATAERR, error, "partition %d", part->index+1);
455 block = scheme_metadata(SCHEME_META_IMG_START, 0);
457 TAILQ_FOREACH(part, &partlist, link) {
458 byteoffset = blkoffset = 0;
461 /* Look for an offset. Set size too if we can. */
462 switch (part->kind) {
465 offset = part->contents;
466 size = strsep(&offset, ":");
467 if (part->kind == PART_KIND_SIZE &&
468 expand_number(size, &bytesize) == -1)
470 if (offset != NULL) {
475 if (expand_number(offset, &byteoffset) == -1)
481 /* Work out exactly where the partition starts. */
482 blkoffset = (byteoffset + secsz - 1) / secsz;
484 block = scheme_metadata(SCHEME_META_PART_ABSOLUTE,
487 block = scheme_metadata(SCHEME_META_PART_BEFORE,
492 fprintf(stderr, "partition %d: starting block %llu "
493 "... ", part->index + 1, (long long)part->block);
495 /* Pull in partition contents, set size if we haven't yet. */
496 switch (part->kind) {
498 fd = open(part->contents, O_RDONLY, 0);
500 error = image_copyin(block, fd, &bytesize);
506 fp = popen(part->contents, "r");
509 error = image_copyin(block, fd, &bytesize);
516 errc(EX_IOERR, error, "partition %d", part->index + 1);
517 part->size = (bytesize + secsz - 1) / secsz;
519 bytesize = part->size * secsz;
520 fprintf(stderr, "size %llu bytes (%llu blocks)\n",
521 (long long)bytesize, (long long)part->size);
524 " location %llu bytes (%llu blocks)\n",
525 (long long)byteoffset,
526 (long long)blkoffset);
527 } else if (blkoffset > 0) {
529 " offset %llu bytes (%llu blocks)\n",
530 (long long)byteoffset,
531 (long long)blkoffset);
534 block = scheme_metadata(SCHEME_META_PART_AFTER,
535 part->block + part->size);
540 block = scheme_metadata(SCHEME_META_IMG_END, block);
541 error = image_set_size(block);
543 error = capacity_resize(block);
544 block = image_get_size();
547 error = format_resize(block);
548 block = image_get_size();
551 errc(EX_IOERR, error, "image sizing");
552 ncyls = block / (nsecs * nheads);
553 error = scheme_write(block);
555 errc(EX_IOERR, error, "writing metadata");
559 main(int argc, char *argv[])
565 outfd = 1; /* Write to stdout by default */
566 while ((c = getopt_long(argc, argv, "a:b:c:C:f:o:p:s:vyH:P:S:T:",
567 longopts, NULL)) != -1) {
569 case 'a': /* ACTIVE PARTITION, if supported */
570 error = parse_uint32(&active_partition, 1, 100, optarg);
572 errc(EX_DATAERR, error, "Partition ordinal");
574 case 'b': /* BOOT CODE */
576 usage("multiple bootcode given");
577 bcfd = open(optarg, O_RDONLY, 0);
579 err(EX_UNAVAILABLE, "%s", optarg);
581 case 'c': /* MINIMUM CAPACITY */
582 error = parse_uint64(&min_capacity, 1, INT64_MAX, optarg);
584 errc(EX_DATAERR, error, "minimum capacity in bytes");
586 case 'C': /* MAXIMUM CAPACITY */
587 error = parse_uint64(&max_capacity, 1, INT64_MAX, optarg);
589 errc(EX_DATAERR, error, "maximum capacity in bytes");
591 case 'f': /* OUTPUT FORMAT */
592 if (format_selected() != NULL)
593 usage("multiple formats given");
594 error = format_select(optarg);
596 errc(EX_DATAERR, error, "format");
598 case 'o': /* OUTPUT FILE */
600 usage("multiple output files given");
601 outfd = open(optarg, O_WRONLY | O_CREAT | O_TRUNC,
602 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
604 err(EX_CANTCREAT, "%s", optarg);
606 case 'p': /* PARTITION */
607 error = parse_part(optarg);
609 errc(EX_DATAERR, error, "partition");
611 case 's': /* SCHEME */
612 if (scheme_selected() != NULL)
613 usage("multiple schemes given");
614 error = scheme_select(optarg);
616 errc(EX_DATAERR, error, "scheme");
624 case 'H': /* GEOMETRY: HEADS */
625 error = parse_uint32(&nheads, 1, 255, optarg);
627 errc(EX_DATAERR, error, "number of heads");
629 case 'P': /* GEOMETRY: PHYSICAL SECTOR SIZE */
630 error = parse_uint32(&blksz, 512, INT_MAX+1U, optarg);
631 if (error == 0 && !pwr_of_two(blksz))
634 errc(EX_DATAERR, error, "physical sector size");
636 case 'S': /* GEOMETRY: LOGICAL SECTOR SIZE */
637 error = parse_uint32(&secsz, 512, INT_MAX+1U, optarg);
638 if (error == 0 && !pwr_of_two(secsz))
641 errc(EX_DATAERR, error, "logical sector size");
643 case 'T': /* GEOMETRY: TRACK SIZE */
644 error = parse_uint32(&nsecs, 1, 63, optarg);
646 errc(EX_DATAERR, error, "track size");
648 case LONGOPT_FORMATS:
652 case LONGOPT_SCHEMES:
656 case LONGOPT_VERSION:
660 case LONGOPT_CAPACITY:
661 error = parse_uint64(&min_capacity, 1, INT64_MAX, optarg);
663 errc(EX_DATAERR, error, "capacity in bytes");
664 max_capacity = min_capacity;
667 usage("unknown option");
672 usage("trailing arguments");
673 if (scheme_selected() == NULL && nparts > 0)
675 if (nparts == 0 && min_capacity == 0)
676 usage("no partitions");
677 if (max_capacity != 0 && min_capacity > max_capacity)
678 usage("minimum capacity cannot be larger than the maximum one");
682 errx(EX_DATAERR, "the physical block size cannot "
683 "be smaller than the sector size");
687 if (secsz > scheme_max_secsz())
688 errx(EX_DATAERR, "maximum sector size supported is %u; "
689 "size specified is %u", scheme_max_secsz(), secsz);
691 if (nparts > scheme_max_parts())
692 errx(EX_DATAERR, "%d partitions supported; %d given",
693 scheme_max_parts(), nparts);
695 if (format_selected() == NULL)
696 format_select("raw");
699 error = scheme_bootcode(bcfd);
702 errc(EX_DATAERR, error, "boot code");
706 fprintf(stderr, "Logical sector size: %u\n", secsz);
707 fprintf(stderr, "Physical block size: %u\n", blksz);
708 fprintf(stderr, "Sectors per track: %u\n", nsecs);
709 fprintf(stderr, "Number of heads: %u\n", nheads);
711 if (scheme_selected())
712 fprintf(stderr, "Partitioning scheme: %s\n",
713 scheme_selected()->name);
714 fprintf(stderr, "Output file format: %s\n",
715 format_selected()->name);
719 error = image_init();
721 errc(EX_OSERR, error, "cannot initialize");
727 fprintf(stderr, "Number of cylinders: %u\n", ncyls);
730 error = format_write(outfd);
732 errc(EX_IOERR, error, "writing image");