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/linker_set.h>
31 #include <sys/queue.h>
33 #include <sys/types.h>
52 #define LONGOPT_FORMATS 0x01000001
53 #define LONGOPT_SCHEMES 0x01000002
54 #define LONGOPT_VERSION 0x01000003
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 },
63 static uint64_t capacity;
65 struct partlisthead partlist = STAILQ_HEAD_INITIALIZER(partlist);
78 print_formats(int usage)
80 struct mkimg_format *f, **f_iter;
84 fprintf(stderr, " formats:\n");
85 SET_FOREACH(f_iter, formats) {
87 fprintf(stderr, "\t%s\t- %s\n", f->name,
92 SET_FOREACH(f_iter, formats) {
94 printf("%s%s", sep, f->name);
102 print_schemes(int usage)
104 struct mkimg_scheme *s, **s_iter;
108 fprintf(stderr, " schemes:\n");
109 SET_FOREACH(s_iter, schemes) {
111 fprintf(stderr, "\t%s\t- %s\n", s->name,
116 SET_FOREACH(s_iter, schemes) {
118 printf("%s%s", sep, s->name);
135 printf("mkimg %u (%u-bit)\n", MKIMG_VERSION, width);
139 usage(const char *why)
142 warnx("error: %s", why);
144 fprintf(stderr, "usage: %s <options>\n", getprogname());
146 fprintf(stderr, " options:\n");
147 fprintf(stderr, "\t--formats\t- list image formats\n");
148 fprintf(stderr, "\t--schemes\t- list partition schemes\n");
149 fprintf(stderr, "\t--version\t- show version information\n");
151 fprintf(stderr, "\t-b <file>\t- file containing boot code\n");
152 fprintf(stderr, "\t-c <num>\t- capacity (in bytes) of the disk\n");
153 fprintf(stderr, "\t-f <format>\n");
154 fprintf(stderr, "\t-o <file>\t- file to write image into\n");
155 fprintf(stderr, "\t-p <partition>\n");
156 fprintf(stderr, "\t-s <scheme>\n");
157 fprintf(stderr, "\t-v\t\t- increase verbosity\n");
158 fprintf(stderr, "\t-y\t\t- [developers] enable unit test\n");
159 fprintf(stderr, "\t-H <num>\t- number of heads to simulate\n");
160 fprintf(stderr, "\t-P <num>\t- physical sector size\n");
161 fprintf(stderr, "\t-S <num>\t- logical sector size\n");
162 fprintf(stderr, "\t-T <num>\t- number of tracks to simulate\n");
168 fprintf(stderr, " partition specification:\n");
169 fprintf(stderr, "\t<t>[/<l>]::<size>\t- empty partition of given "
171 fprintf(stderr, "\t<t>[/<l>]:=<file>\t- partition content and size "
172 "are determined\n\t\t\t\t by the named file\n");
173 fprintf(stderr, "\t<t>[/<l>]:-<cmd>\t- partition content and size "
174 "are taken from\n\t\t\t\t the output of the command to run\n");
175 fprintf(stderr, "\t-\t\t\t- unused partition entry\n");
176 fprintf(stderr, "\t where:\n");
177 fprintf(stderr, "\t\t<t>\t- scheme neutral partition type\n");
178 fprintf(stderr, "\t\t<l>\t- optional scheme-dependent partition "
185 parse_uint32(uint32_t *valp, uint32_t min, uint32_t max, const char *arg)
189 if (expand_number(arg, &val) == -1)
191 if (val > UINT_MAX || val < (uint64_t)min || val > (uint64_t)max)
193 *valp = (uint32_t)val;
198 parse_uint64(uint64_t *valp, uint64_t min, uint64_t max, const char *arg)
202 if (expand_number(arg, &val) == -1)
204 if (val < min || val > max)
214 return (((nr & (nr - 1)) == 0) ? 1 : 0);
218 * A partition specification has the following format:
219 * <type> ':' <kind> <contents>
221 * type the partition type alias
222 * kind the interpretation of the contents specification
223 * ':' contents holds the size of an empty partition
224 * '=' contents holds the name of a file to read
225 * '-' contents holds a command to run; the output of
226 * which is the contents of the partition.
227 * contents the specification of a partition's contents
229 * A specification that is a single dash indicates an unused partition
233 parse_part(const char *spec)
240 if (strcmp(spec, "-") == 0) {
245 part = calloc(1, sizeof(struct part));
249 sep = strchr(spec, ':');
254 len = sep - spec + 1;
259 part->alias = malloc(len);
260 if (part->alias == NULL) {
264 strlcpy(part->alias, spec, len);
269 part->kind = PART_KIND_SIZE;
272 part->kind = PART_KIND_FILE;
275 part->kind = PART_KIND_PIPE;
283 part->contents = strdup(spec);
284 if (part->contents == NULL) {
290 sep = strchr(spec, '/');
293 if (strlen(part->alias) == 0 || strlen(sep) == 0) {
297 part->label = strdup(sep);
298 if (part->label == NULL) {
304 part->index = nparts;
305 STAILQ_INSERT_TAIL(&partlist, part, link);
310 if (part->alias != NULL)
316 #if defined(SPARSE_WRITE)
318 sparse_write(int fd, const void *ptr, size_t sz)
327 p = memchr(buf, 0, sz);
329 len = (p != NULL) ? (size_t)(p - buf) : sz;
331 len = (len + secsz - 1) & ~(secsz - 1);
334 wr = write(fd, buf, len);
338 while (len < sz && *p++ == '\0')
344 ofs = lseek(fd, len, SEEK_CUR);
352 p = memchr(buf, 0, sz);
356 #endif /* SPARSE_WRITE */
359 mkimg_chs(lba_t lba, u_int maxcyl, u_int *cylp, u_int *hdp, u_int *secp)
363 *cylp = *hdp = *secp = ~0U;
364 if (nsecs == 1 || nheads == 1)
367 sec = lba % nsecs + 1;
380 mkimg_uuid(struct uuid *uuid)
382 static uint8_t gen[sizeof(struct uuid)];
390 for (i = 0; i < sizeof(gen); i++)
392 memcpy(uuid, gen, sizeof(uuid_t));
396 capacity_resize(lba_t end)
400 capsz = (capacity + secsz - 1) / secsz;
403 return (image_set_size(capsz));
415 /* First check partition information */
416 STAILQ_FOREACH(part, &partlist, link) {
417 error = scheme_check_part(part);
419 errc(EX_DATAERR, error, "partition %d", part->index+1);
422 block = scheme_metadata(SCHEME_META_IMG_START, 0);
423 STAILQ_FOREACH(part, &partlist, link) {
424 block = scheme_metadata(SCHEME_META_PART_BEFORE, block);
426 fprintf(stderr, "partition %d: starting block %llu "
427 "... ", part->index + 1, (long long)block);
429 switch (part->kind) {
431 if (expand_number(part->contents, &bytesize) == -1)
435 fd = open(part->contents, O_RDONLY, 0);
437 error = image_copyin(block, fd, &bytesize);
443 fp = popen(part->contents, "r");
446 error = image_copyin(block, fd, &bytesize);
453 errc(EX_IOERR, error, "partition %d", part->index + 1);
454 part->size = (bytesize + secsz - 1) / secsz;
456 bytesize = part->size * secsz;
457 fprintf(stderr, "size %llu bytes (%llu blocks)\n",
458 (long long)bytesize, (long long)part->size);
460 block = scheme_metadata(SCHEME_META_PART_AFTER,
461 part->block + part->size);
464 block = scheme_metadata(SCHEME_META_IMG_END, block);
465 error = image_set_size(block);
467 error = capacity_resize(block);
469 error = format_resize(block);
471 errc(EX_IOERR, error, "image sizing");
472 block = image_get_size();
473 ncyls = block / (nsecs * nheads);
474 error = scheme_write(block);
476 errc(EX_IOERR, error, "writing metadata");
480 main(int argc, char *argv[])
486 outfd = 1; /* Write to stdout by default */
487 while ((c = getopt_long(argc, argv, "b:c:f:o:p:s:vyH:P:S:T:",
488 longopts, NULL)) != -1) {
490 case 'b': /* BOOT CODE */
492 usage("multiple bootcode given");
493 bcfd = open(optarg, O_RDONLY, 0);
495 err(EX_UNAVAILABLE, "%s", optarg);
497 case 'c': /* CAPACITY */
498 error = parse_uint64(&capacity, 1, OFF_MAX, optarg);
500 errc(EX_DATAERR, error, "capacity in bytes");
502 case 'f': /* OUTPUT FORMAT */
503 if (format_selected() != NULL)
504 usage("multiple formats given");
505 error = format_select(optarg);
507 errc(EX_DATAERR, error, "format");
509 case 'o': /* OUTPUT FILE */
511 usage("multiple output files given");
512 outfd = open(optarg, O_WRONLY | O_CREAT | O_TRUNC,
513 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
515 err(EX_CANTCREAT, "%s", optarg);
517 case 'p': /* PARTITION */
518 error = parse_part(optarg);
520 errc(EX_DATAERR, error, "partition");
522 case 's': /* SCHEME */
523 if (scheme_selected() != NULL)
524 usage("multiple schemes given");
525 error = scheme_select(optarg);
527 errc(EX_DATAERR, error, "scheme");
535 case 'H': /* GEOMETRY: HEADS */
536 error = parse_uint32(&nheads, 1, 255, optarg);
538 errc(EX_DATAERR, error, "number of heads");
540 case 'P': /* GEOMETRY: PHYSICAL SECTOR SIZE */
541 error = parse_uint32(&blksz, 512, INT_MAX+1U, optarg);
542 if (error == 0 && !pwr_of_two(blksz))
545 errc(EX_DATAERR, error, "physical sector size");
547 case 'S': /* GEOMETRY: LOGICAL SECTOR SIZE */
548 error = parse_uint32(&secsz, 512, INT_MAX+1U, optarg);
549 if (error == 0 && !pwr_of_two(secsz))
552 errc(EX_DATAERR, error, "logical sector size");
554 case 'T': /* GEOMETRY: TRACK SIZE */
555 error = parse_uint32(&nsecs, 1, 63, optarg);
557 errc(EX_DATAERR, error, "track size");
559 case LONGOPT_FORMATS:
563 case LONGOPT_SCHEMES:
567 case LONGOPT_VERSION:
572 usage("unknown option");
577 usage("trailing arguments");
578 if (scheme_selected() == NULL && nparts > 0)
580 if (nparts == 0 && capacity == 0)
581 usage("no partitions");
585 errx(EX_DATAERR, "the physical block size cannot "
586 "be smaller than the sector size");
590 if (secsz > scheme_max_secsz())
591 errx(EX_DATAERR, "maximum sector size supported is %u; "
592 "size specified is %u", scheme_max_secsz(), secsz);
594 if (nparts > scheme_max_parts())
595 errx(EX_DATAERR, "%d partitions supported; %d given",
596 scheme_max_parts(), nparts);
598 if (format_selected() == NULL)
599 format_select("raw");
602 error = scheme_bootcode(bcfd);
605 errc(EX_DATAERR, error, "boot code");
609 fprintf(stderr, "Logical sector size: %u\n", secsz);
610 fprintf(stderr, "Physical block size: %u\n", blksz);
611 fprintf(stderr, "Sectors per track: %u\n", nsecs);
612 fprintf(stderr, "Number of heads: %u\n", nheads);
614 if (scheme_selected())
615 fprintf(stderr, "Partitioning scheme: %s\n",
616 scheme_selected()->name);
617 fprintf(stderr, "Output file format: %s\n",
618 format_selected()->name);
622 error = image_init();
624 errc(EX_OSERR, error, "cannot initialize");
630 fprintf(stderr, "Number of cylinders: %u\n", ncyls);
633 error = format_write(outfd);
635 errc(EX_IOERR, error, "writing image");