diff --git a/usr.bin/mkimg/mkimg.1 b/usr.bin/mkimg/mkimg.1
index ae48904eb16c..d3e6285d110f 100644
--- a/usr.bin/mkimg/mkimg.1
+++ b/usr.bin/mkimg/mkimg.1
@@ -1,418 +1,432 @@
 .\" Copyright (c) 2013, 2014 Juniper Networks, Inc.
 .\" All rights reserved.
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
 .\" are met:
 .\"
 .\" 1. Redistributions of source code must retain the above copyright
 .\"    notice, this list of conditions and the following disclaimer.
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 .\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 .\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 .\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 .\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 .\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 .\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 .\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 .\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 .\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 .\"
-.Dd June 25, 2025
+.Dd December 30, 2025
 .Dt MKIMG 1
 .Os
 .Sh NAME
 .Nm mkimg
 .Nd "utility to make disk images"
 .Sh SYNOPSIS
 .Nm
 .Op Fl H Ar heads
 .Op Fl P Ar blksz
 .Op Fl S Ar secsz
 .Op Fl T Ar tracksz
 .Op Fl b Ar bootcode
 .Op Fl c Ar min_capacity
 .Op Fl C Ar max_capacity
 .Op Fl -capacity Ar capacity
 .Op Fl f Ar format
+.Op Fl h
 .Op Fl o Ar outfile
 .Op Fl a Ar active
 .Op Fl t Ar timestamp
 .Op Fl v
 .Op Fl y
 .Op Fl s Ar scheme Op Fl p Ar partition ...
 .Nm
 .Fl -formats | Fl -schemes | Fl -version
 .Sh DESCRIPTION
 The
 .Nm
 utility creates a disk image from the raw partition contents specified with
 the
 .Ar partition
 argument(s) and using the partitioning scheme specified with the
 .Ar scheme
 argument.
 The disk image is written to
 .Ar stdout
 by default or the file specified with the
 .Ar outfile
 argument.
 The image file is a raw disk image by default, but the format of the
 image file can be specified with the
 .Ar format
 argument.
 Most formats require seekable output, except of raw disk image.
 .Pp
 The disk image can be made bootable by specifying the scheme-specific boot
 block contents with the
 .Ar bootcode
 argument and,
 depending on the scheme,
 with a boot partition.
 The contents of such a boot partition is provided like any other partition
 and the
 .Nm
 utility does not treat it any differently from other partitions.
 .Pp
 Some partitioning schemes need a disk geometry and for those the
 .Nm
 utility accepts the
 .Ar tracksz
 and
 .Ar heads
 arguments, specifying the number of sectors per track and the number of
 heads per cylinder (resp.)
 .Pp
 Both the logical and physical sector size can be specified and for that the
 .Nm
 utility
 accepts the
 .Ar secsz
 and
 .Ar blksz
 arguments.
 The
 .Ar secsz
 argument is used to specify the logical sector size.
 This is the sector size reported by a disk when queried for its capacity.
 Modern disks use a larger sector size internally,
 referred to as block size by the
 .Nm
 utility and this can be specified by the
 .Ar blksz
 argument.
 The
 .Nm
 utility will use the (physical) block size to determine the start of
 partitions and to round the size of the disk image.
 .Pp
 The
 .Fl c
 option can be used to specify a minimal capacity for the disk image.
 Use this option without the
 .Fl s
 and
 .Fl p
 options to create an empty disk image with the given (virtual) size.
 An empty partition table can be written to the disk when specifying a
 partitioning scheme with the
 .Fl s
 option, but without specifying any partitions.
 When the size required for all the partitions is larger than the
 given capacity, then the disk image will be larger than the capacity
 given.
 .Pp
 The
 .Fl C
 option specifies a maximum capacity for the disk image.
 If the combined sizes of the given partitions exceed the size given with
 .Fl C ,
 image creation fails.
 .Pp
 The
 .Fl -capacity
 option is a shorthand to specify the minimum and maximum capacity at the
 same time.
 .Pp
 The
 .Fl t
 option causes any timestamps embedded in the output file to be set to the
 given time, specified in seconds since the epoch.
 .Pp
 The
+.Fl h
+option prints a usage message and exits.
+.Pp
+The
 .Fl v
 option increases the level of output that the
 .Nm
 utility prints.
 .Pp
 The
 .Fl y
 option is used for testing purposes only and is not to be used in production.
 When present, the
 .Nm
 utility will generate predictable values for Universally Unique Identifiers
 (UUIDs) and time stamps so that consecutive runs of the
 .Nm
 utility will create images that are identical.
 .Pp
 The
 .Ar active
 option marks a partition as active, if the partitioning
 scheme supports it.
 Currently, only the
 .Ar mbr
 scheme supports this concept.
 By default,
 .Nm
 will only mark the first partition as active when boot code is
 specified.
 Use the
 .Ar active
 option to override the active partition.
 The number specified corresponds to the number after the 's' in the
 partition's
 .Xr geom 8
 name.
 No partitions are marked active when the value is 0.
 .Pp
 A set of long options exist to query about the
 .Nm
 utility itself.
 Options in this set should be given by themselves because the
 .Nm
 utility exits immediately after providing the requested information.
 The version of the
 .Nm
 utility is printed when the
 .Fl -version
 option is given.
 The list of supported output formats is printed when the
 .Fl -formats
 option is given and the list of supported partitioning schemes is printed
 when the
 .Fl -schemes
 option is given.
 Both the format and scheme lists a space-separated lists for easy handling
 in scripts.
 .Pp
 For a more descriptive list of supported partitioning schemes or supported
 output format, or for a detailed description of how to specify partitions,
 run the
 .Nm
 utility without any arguments.
 This will print a usage message with all the necessary details.
 .Sh DISK FORMATS
 The
 .Nm
 utility supports a number of output file formats.
 A short description of these is given below.
 .Ss QCOW and QCOW2
 QCOW stands for "QEMU Copy On Write".
 It's a sparse file format akin to VHD and VMDK and QCOW represents the
 first version.
 QCOW2 represents version 2 of the file format.
 Version 2 is not backward compatible with version 1 and adds support for
 snapshots among other things.
 The QCOW file formats are natively supported by QEMU and Xen.
 To write QCOW, specify
 .Fl f Ar qcow
 on the command line.
 To write version 2 QCOW, specify
 .Fl f Ar qcow2
 on the command line.
 The preferred file extension is ".qcow" and ".qcow2" for QCOW and QCOW2
 (resp.), but ".qcow" is sometimes used for version 2 files as well.
 .Ss RAW file format
 This file format is a sector by sector representation of an actual disk.
 There is no extra information that describes or relates to the format itself.
 The size of the file is the size of the (virtual) disk.
 This file format is suitable for being copied onto a disk with utilities
 like
 .Nm dd .
 To write a raw disk file, either omit the
 .Fl f
 option, or specify
 .Fl f Ar raw
 on the command line.
 The preferred file extension is one of ".img" or ".raw", but there's no
 real convention for it.
 .Ss Dynamic VHD and Fixed VHD
 Microsoft's "Virtual Hard Disk" file formats.
 The dynamic format is a sparse format akin to QCOW and VMDK.
 The fixed format is effectively a raw format with a footer appended to the
 file and as such it's often indistinguishable from the raw format.
 The fixed file format has been added to support Microsoft's Azure platform
 and due to inconsistencies in interpretation of the footer is not compatible
 with utilities like
 .Nm qemu
 when it is specifically instructed to interpreted the file as a VHD file.
 By default
 .Nm qemu
 will treat the file as a raw disk file, which mostly works fine.
 To have
 .Nm
 create a dynamic VHD file, specify
 .Fl f Ar vhd
 on the command line.
 To create a fixed VHD file for use by Azure, specify
 .Fl f Ar vhdf
 on the command line.
 The preferred file extension is ".vhd".
 .Ss Dynamic VHDX
 Microsoft's "Virtual Hard Disk v2" file formats, the
 successor to VHD.
 VHDX is the required format for the 2nd generation Hyper-V VMs.
 To have
 .Nm
 create a dynamic VHDX file, specify
 .Fl f Ar vhdx
 on the command line.
 The preferred file extension is ".vhdx".
 .Ss VMDK
 VMware's "Virtual Machine Disk" file format.
 It's a sparse file format akin to QCOW and VHD and supported by many
 virtualization solutions.
 To create a VMDK file, specify
 .Fl f Ar vmdk
 on the command line.
 The preferred file extension is ".vmdk".
 .Pp
 Not all virtualization solutions support all file formats, but often those
 virtualization environments have utilities to convert from one format to
 another.
 Note however that conversion may require that the virtual disk size is
 changed to match the constraints of the output format and this may invalidate
 the contents of the disk image.
 For example, the GUID Partition Table (GPT) scheme has a header in the last
 sector on the disk.
 When changing the disk size, the GPT must be changed so that the last header
 is moved accordingly.
 This is typically not part of the conversion process.
 If possible, use an output format specifically for the environment in which
 the file is intended to be used.
 .Sh PARTITION SPECIFICATION
 An option
 .Fl p
 may be used multiple times to specify a list of created partition entries.
 A specification that is a single dash indicates an unused partition entry.
 Otherwise, a partition specification has the following format:
 .Bd -literal -offset indent
-<type> ':' <kind> <contents>
+<type>[/<label>]::<size>[:[+]<offset>]
+<type>[/<label>]:=<file>[:[+]<offset>]
+<type>[/<label>]:-<cmd>
+-
 .Ed
 .Bl -tag -width indent
 .It Cm type
 the partition type alias (f.e.: freebsd-swap)
-that may be optionally followed by a '/' separator
-and a label for partitioning schemes that feature partition labels
 (see the
 .Sx EXAMPLES
 Section below)
-.It Cm kind
-the interpretation of the contents specification:
-.Bl -tag -width indent
-.It Cm ':'
-contents holds the size of an empty partition,
-a number that may be suffixed with one of K, M, G, T, P or E
-(either upper or lower case) following the SI power of two convention
-(see also
+.It Cm label
+an optional label for partitioning schemes that support labels
+.It Cm size
+the size of an empty partition, a number that may be suffixed with one of
+K, M, G, T, P or E (either upper or lower case) following the SI power of
+two convention (see also
 .Xr expand_number 3 )
-.It Cm '='
-contents holds the name of a file to read
-.It Cm '-'
-contents holds a command to run; the output of which is the contents
-of the partition.
+.It Cm file
+the name of a file to read; the partition size is determined by the file
+.It Cm cmd
+a command to run; the output of which is the contents of the partition.
 Multi-word strings should be quoted according to the shell rules.
-.El
-.It Cm contents
-the specification of a partition's contents
+.It Cm offset
+an optional byte offset for the
+.Cm size
+and
+.Cm file
+forms.
+If prefixed with
+.Ql + ,
+it is relative to the end of the previous partition; otherwise it is an
+absolute offset from the start of the image.
+The value follows the same numeric conventions as
+.Cm size .
+.It Cm -
+an unused partition entry.
 .El
 .Sh ENVIRONMENT
 .Bl -tag -width "TMPDIR" -compact
 .It Ev TMPDIR
 Directory to put temporary files in; default is
 .Pa /tmp .
 .El
 .Sh EXAMPLES
 To create a bootable disk image that is partitioned using the GPT scheme and
 containing a root file system that was previously created using
 .Xr makefs 8
 and also containing a swap partition, run the
 .Nm
 utility as follows:
 .Dl % mkimg -s gpt -b /boot/pmbr -p freebsd-boot:=/boot/gptboot \
 -p freebsd-ufs:=root-file-system.ufs -p freebsd-swap::1G \
 -o gpt.img
 .Pp
 The command line given above results in a raw image file.
 This is because no output format was given.
 To create a VMDK image for example, add the
 .Fl f Ar vmdk
 argument to the
 .Nm
 utility and name the output file accordingly.
 .Pp
 A nested partitioning scheme is created by running the
 .Nm
 utility twice.
 The output of the first will be fed as the contents of a partition to the
 second.
 This can be done using a temporary file, like so:
 .Dl % mkimg -s bsd -b /boot/boot -p freebsd-ufs:=root-file-system.ufs \
 -p freebsd-swap::1G -o /tmp/bsd.img
 .Dl % mkimg -s mbr -b /boot/mbr -p freebsd:=/tmp/bsd.img -o mbr-bsd.img
 .Pp
 Alternatively, the
 .Nm
 utility can be run in a cascaded fashion, whereby the output of the
 first is fed directly into the second.
 To do this, run the
 .Nm
 utility as follows:
 .Dl % mkimg -s mbr -b /boot/mbr -p freebsd:-'mkimg -s bsd -b /boot/boot \
 -p freebsd-ufs:=root-file-system.ufs -p freebsd-swap::1G' -o mbr-bsd.img
 .Pp
 To accommodate the need to have partitions named or numbered in a certain
 way, the
 .Nm
 utility allows for the specification of empty partitions.
 For example, to create an image that is compatible with partition layouts
 found in
 .Pa /etc/disktab ,
 the 'd' partition often needs to be skipped.
 This is accomplished by inserting an unused partition after the first 2
 partition specifications.
 It is worth noting at this time that the BSD scheme will automatically
 skip the 'c' partition by virtue of it referring to the entire disk.
 To create an image that is compatible with the qp120at disk, use the
 .Nm
 utility as follows:
 .Dl % mkimg -s bsd -b /boot/boot -p freebsd-ufs:=root-file-system.ufs \
 -p freebsd-swap::20M -p- -p- -p- -p- -p freebsd-ufs:=usr-file-system.ufs \
 -o bsd.img
 .Pp
 For partitioning schemes that feature partition labels, the
 .Nm
 utility supports assigning labels to the partitions specified.
 In the following example the file system partition is labeled as 'backup':
 .Dl % mkimg -s gpt -p freebsd-ufs/backup:=file-system.ufs -o gpt.img
 .Sh SEE ALSO
 .Xr dd 1 ,
 .Xr expand_number 3 ,
 .Xr gpart 8 ,
 .Xr makefs 8 ,
 .Xr mdconfig 8 ,
 .Xr newfs 8
 .Sh HISTORY
 The
 .Nm
 utility first appeared in
 .Fx 10.1 .
 .Sh AUTHORS
 The
 .Nm
 utility and manpage were written by
 .An Marcel Moolenaar Aq Mt marcel@FreeBSD.org .
diff --git a/usr.bin/mkimg/mkimg.c b/usr.bin/mkimg/mkimg.c
index 80c79777575e..556df3c9684b 100644
--- a/usr.bin/mkimg/mkimg.c
+++ b/usr.bin/mkimg/mkimg.c
@@ -1,761 +1,764 @@
 /*-
  * Copyright (c) 2013,2014 Juniper Networks, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <err.h>
 #include <fcntl.h>
 #include <getopt.h>
 #include <libutil.h>
 #include <limits.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 
 #include "image.h"
 #include "format.h"
 #include "mkimg.h"
 #include "scheme.h"
 
 #define	LONGOPT_FORMATS		0x01000001
 #define	LONGOPT_SCHEMES		0x01000002
 #define	LONGOPT_VERSION		0x01000003
 #define	LONGOPT_CAPACITY	0x01000004
 
 static struct option longopts[] = {
 	{ "formats", no_argument, NULL, LONGOPT_FORMATS },
 	{ "schemes", no_argument, NULL, LONGOPT_SCHEMES },
 	{ "version", no_argument, NULL, LONGOPT_VERSION },
 	{ "capacity", required_argument, NULL, LONGOPT_CAPACITY },
 	{ NULL, 0, NULL, 0 }
 };
 
 static uint64_t min_capacity = 0;
 static uint64_t max_capacity = 0;
 
 /* Fixed timestamp for reproducible builds. */
 time_t timestamp = (time_t)-1;
 
 struct partlisthead partlist = TAILQ_HEAD_INITIALIZER(partlist);
 u_int nparts = 0;
 
 u_int unit_testing;
 u_int verbose;
 
 u_int ncyls = 0;
 u_int nheads = 1;
 u_int nsecs = 1;
 u_int secsz = 512;
 u_int blksz = 0;
 uint32_t active_partition = 0;
 
 static void
 print_formats(int usage)
 {
 	struct mkimg_format *f;
 	const char *sep;
 
 	if (usage) {
 		fprintf(stderr, "    formats:\n");
 		f = NULL;
 		while ((f = format_iterate(f)) != NULL) {
 			fprintf(stderr, "\t%s\t-  %s\n", f->name,
 			    f->description);
 		}
 	} else {
 		sep = "";
 		f = NULL;
 		while ((f = format_iterate(f)) != NULL) {
 			printf("%s%s", sep, f->name);
 			sep = " ";
 		}
 		putchar('\n');
 	}
 }
 
 static void
 print_schemes(int usage)
 {
 	struct mkimg_scheme *s;
 	const char *sep;
 
 	if (usage) {
 		fprintf(stderr, "    schemes:\n");
 		s = NULL;
 		while ((s = scheme_iterate(s)) != NULL) {
 			fprintf(stderr, "\t%s\t-  %s\n", s->name,
 			    s->description);
 		}
 	} else {
 		sep = "";
 		s = NULL;
 		while ((s = scheme_iterate(s)) != NULL) {
 			printf("%s%s", sep, s->name);
 			sep = " ";
 		}
 		putchar('\n');
 	}
 }
 
 static void
 print_version(void)
 {
 	u_int width;
 
 #ifdef __LP64__
 	width = 64;
 #else
 	width = 32;
 #endif
 	printf("mkimg %u (%u-bit)\n", MKIMG_VERSION, width);
 }
 
 static void
 usage(const char *why)
 {
 
 	warnx("error: %s", why);
 	fputc('\n', stderr);
 	fprintf(stderr, "usage: %s <options>\n", getprogname());
 
 	fprintf(stderr, "    options:\n");
 	fprintf(stderr, "\t--formats\t-  list image formats\n");
 	fprintf(stderr, "\t--schemes\t-  list partition schemes\n");
 	fprintf(stderr, "\t--version\t-  show version information\n");
+	fprintf(stderr, "\t--capacity\t-  minimum and maximum capacity (in bytes)\n");
 	fputc('\n', stderr);
 	fprintf(stderr, "\t-a <num>\t-  mark num'th partition as active\n");
 	fprintf(stderr, "\t-b <file>\t-  file containing boot code\n");
 	fprintf(stderr, "\t-c <num>\t-  minimum capacity (in bytes) of the disk\n");
 	fprintf(stderr, "\t-C <num>\t-  maximum capacity (in bytes) of the disk\n");
 	fprintf(stderr, "\t-f <format>\n");
+	fprintf(stderr, "\t-h\t\t-  show this usage information\n");
 	fprintf(stderr, "\t-o <file>\t-  file to write image into\n");
 	fprintf(stderr, "\t-p <partition>\n");
 	fprintf(stderr, "\t-s <scheme>\n");
+	fprintf(stderr, "\t-t <num>\t-  set timestamp (seconds since epoch)\n");
 	fprintf(stderr, "\t-v\t\t-  increase verbosity\n");
 	fprintf(stderr, "\t-y\t\t-  [developers] enable unit test\n");
 	fprintf(stderr, "\t-H <num>\t-  number of heads to simulate\n");
 	fprintf(stderr, "\t-P <num>\t-  physical sector size\n");
 	fprintf(stderr, "\t-S <num>\t-  logical sector size\n");
 	fprintf(stderr, "\t-T <num>\t-  number of tracks to simulate\n");
 	fputc('\n', stderr);
 	print_formats(1);
 	fputc('\n', stderr);
 	print_schemes(1);
 	fputc('\n', stderr);
 	fprintf(stderr, "    partition specification:\n");
 	fprintf(stderr, "\t<t>[/<l>]::<size>[:[+]<offset>]\t-  "
 	    "empty partition of given size and\n\t\t\t\t\t"
 	    "   optional relative or absolute offset\n");
 	fprintf(stderr, "\t<t>[/<l>]:=<file>[:[+]offset]\t-  partition "
 	    "content and size are\n\t\t\t\t\t"
 	    "   determined by the named file and\n"
 	    "\t\t\t\t\t   optional relative or absolute offset\n");
 	fprintf(stderr, "\t<t>[/<l>]:-<cmd>\t\t-  partition content and size "
 	    "are taken\n\t\t\t\t\t   from the output of the command to run\n");
 	fprintf(stderr, "\t-\t\t\t\t-  unused partition entry\n");
 	fprintf(stderr, "\t    where:\n");
 	fprintf(stderr, "\t\t<t>\t-  scheme neutral partition type\n");
 	fprintf(stderr, "\t\t<l>\t-  optional scheme-dependent partition "
 	    "label\n");
 
 	exit(EX_USAGE);
 }
 
 static int
 parse_uint32(uint32_t *valp, uint32_t min, uint32_t max, const char *arg)
 {
 	uint64_t val;
 
 	if (expand_number(arg, &val) == -1)
 		return (errno);
 	if (val > UINT_MAX || val < (uint64_t)min || val > (uint64_t)max)
 		return (EINVAL);
 	*valp = (uint32_t)val;
 	return (0);
 }
 
 static int
 parse_uint64(uint64_t *valp, uint64_t min, uint64_t max, const char *arg)
 {
 	uint64_t val;
 
 	if (expand_number(arg, &val) == -1)
 		return (errno);
 	if (val < min || val > max)
 		return (EINVAL);
 	*valp = val;
 	return (0);
 }
 
 static int
 pwr_of_two(u_int nr)
 {
 
 	return (((nr & (nr - 1)) == 0) ? 1 : 0);
 }
 
 /*
  * A partition specification has the following format:
  *	<type> ':' <kind> <contents>
  * where:
  *	type	  the partition type alias
  *	kind	  the interpretation of the contents specification
  *		  ':'   contents holds the size of an empty partition
  *		  '='   contents holds the name of a file to read
  *		  '-'   contents holds a command to run; the output of
  *			which is the contents of the partition.
  *	contents  the specification of a partition's contents
  *
  * A specification that is a single dash indicates an unused partition
  * entry.
  */
 static int
 parse_part(const char *spec)
 {
 	struct part *part;
 	char *sep;
 	size_t len;
 	int error;
 
 	if (strcmp(spec, "-") == 0) {
 		nparts++;
 		return (0);
 	}
 
 	part = calloc(1, sizeof(struct part));
 	if (part == NULL)
 		return (ENOMEM);
 
 	sep = strchr(spec, ':');
 	if (sep == NULL) {
 		error = EINVAL;
 		goto errout;
 	}
 	len = sep - spec + 1;
 	if (len < 2) {
 		error = EINVAL;
 		goto errout;
 	}
 	part->alias = malloc(len);
 	if (part->alias == NULL) {
 		error = ENOMEM;
 		goto errout;
 	}
 	strlcpy(part->alias, spec, len);
 	spec = sep + 1;
 
 	switch (*spec) {
 	case ':':
 		part->kind = PART_KIND_SIZE;
 		break;
 	case '=':
 		part->kind = PART_KIND_FILE;
 		break;
 	case '-':
 		part->kind = PART_KIND_PIPE;
 		break;
 	default:
 		error = EINVAL;
 		goto errout;
 	}
 	spec++;
 
 	part->contents = strdup(spec);
 	if (part->contents == NULL) {
 		error = ENOMEM;
 		goto errout;
 	}
 
 	spec = part->alias;
 	sep = strchr(spec, '/');
 	if (sep != NULL) {
 		*sep++ = '\0';
 		if (strlen(part->alias) == 0 || strlen(sep) == 0) {
 			error = EINVAL;
 			goto errout;
 		}
 		part->label = strdup(sep);
 		if (part->label == NULL) {
 			error = ENOMEM;
 			goto errout;
 		}
 	}
 
 	part->index = nparts;
 	TAILQ_INSERT_TAIL(&partlist, part, link);
 	nparts++;
 	return (0);
 
  errout:
 	if (part->alias != NULL)
 		free(part->alias);
 	free(part);
 	return (error);
 }
 
 #if defined(SPARSE_WRITE)
 ssize_t
 sparse_write(int fd, const void *ptr, size_t sz)
 {
 	const char *buf, *p;
 	off_t ofs;
 	size_t len;
 	ssize_t wr, wrsz;
 
 	buf = ptr;
 	wrsz = 0;
 	p = memchr(buf, 0, sz);
 	while (sz > 0) {
 		len = (p != NULL) ? (size_t)(p - buf) : sz;
 		if (len > 0) {
 			len = (len + secsz - 1) & ~(secsz - 1);
 			if (len > sz)
 				len = sz;
 			wr = write(fd, buf, len);
 			if (wr < 0)
 				return (-1);
 		} else {
 			while (len < sz && *p++ == '\0')
 				len++;
 			if (len < sz)
 				len &= ~(secsz - 1);
 			if (len == 0)
 				continue;
 			ofs = lseek(fd, len, SEEK_CUR);
 			if (ofs < 0)
 				return (-1);
 			wr = len;
 		}
 		buf += wr;
 		sz -= wr;
 		wrsz += wr;
 		p = memchr(buf, 0, sz);
 	}
 	return (wrsz);
 }
 #endif /* SPARSE_WRITE */
 
 void
 mkimg_chs(lba_t lba, u_int maxcyl, u_int *cylp, u_int *hdp, u_int *secp)
 {
 	u_int hd, sec;
 
 	*cylp = *hdp = *secp = ~0U;
 	if (nsecs == 1 || nheads == 1)
 		return;
 
 	sec = lba % nsecs + 1;
 	lba /= nsecs;
 	hd = lba % nheads;
 	lba /= nheads;
 	if (lba > maxcyl)
 		return;
 
 	*cylp = lba;
 	*hdp = hd;
 	*secp = sec;
 }
 
 static int
 capacity_resize(lba_t end)
 {
 	lba_t min_capsz, max_capsz;
 
 	min_capsz = (min_capacity + secsz - 1) / secsz;
 	max_capsz = (max_capacity + secsz - 1) / secsz;
 
 	if (max_capsz != 0 && end > max_capsz)
 		return (ENOSPC);
 	if (end >= min_capsz)
 		return (0);
 
 	return (image_set_size(min_capsz));
 }
 
 static void
 mkimg_validate(void)
 {
 	struct part *part, *part2;
 	lba_t start, end, start2, end2;
 	int i, j;
 
 	i = 0;
 
 	TAILQ_FOREACH(part, &partlist, link) {
 		start = part->block;
 		end = part->block + part->size;
 		j = i + 1;
 		part2 = TAILQ_NEXT(part, link);
 		if (part2 == NULL)
 			break;
 
 		TAILQ_FOREACH_FROM(part2, &partlist, link) {
 			start2 = part2->block;
 			end2 = part2->block + part2->size;
 
 			if ((start >= start2 && start < end2) ||
 			    (end > start2 && end <= end2)) {
 				errx(1, "partition %d overlaps partition %d",
 				    i, j);
 			}
 
 			j++;
 		}
 
 		i++;
 	}
 }
 
 static void
 mkimg(void)
 {
 	FILE *fp;
 	struct part *part;
 	lba_t block, blkoffset;
 	uint64_t bytesize, byteoffset;
 	char *size, *offset;
 	bool abs_offset;
 	int error, fd;
 
 	/* First check partition information */
 	TAILQ_FOREACH(part, &partlist, link) {
 		error = scheme_check_part(part);
 		if (error)
 			errc(EX_DATAERR, error, "partition %d", part->index+1);
 	}
 
 	block = scheme_metadata(SCHEME_META_IMG_START, 0);
 	abs_offset = false;
 	TAILQ_FOREACH(part, &partlist, link) {
 		byteoffset = blkoffset = 0;
 		abs_offset = false;
 
 		/* Look for an offset. Set size too if we can. */
 		switch (part->kind) {
 		case PART_KIND_SIZE:
 		case PART_KIND_FILE:
 			offset = part->contents;
 			size = strsep(&offset, ":");
 			if (part->kind == PART_KIND_SIZE &&
 			    expand_number(size, &bytesize) == -1)
 				error = errno;
 			if (offset != NULL) {
 				if (*offset != '+')
 					abs_offset = true;
 				else
 					offset++;
 				if (expand_number(offset, &byteoffset) == -1)
 					error = errno;
 			}
 			break;
 		}
 
 		/* Work out exactly where the partition starts. */
 		blkoffset = (byteoffset + secsz - 1) / secsz;
 		if (abs_offset)
 			block = scheme_metadata(SCHEME_META_PART_ABSOLUTE,
 			    blkoffset);
 		else
 			block = scheme_metadata(SCHEME_META_PART_BEFORE,
 			    block + blkoffset);
 		part->block = block;
 
 		if (verbose)
 			fprintf(stderr, "partition %d: starting block %llu "
 			    "... ", part->index + 1, (long long)part->block);
 
 		/* Pull in partition contents, set size if we haven't yet. */
 		switch (part->kind) {
 		case PART_KIND_FILE:
 			fd = open(part->contents, O_RDONLY, 0);
 			if (fd != -1) {
 				error = image_copyin(block, fd, &bytesize);
 				close(fd);
 			} else
 				error = errno;
 			break;
 		case PART_KIND_PIPE:
 			fp = popen(part->contents, "r");
 			if (fp != NULL) {
 				fd = fileno(fp);
 				error = image_copyin(block, fd, &bytesize);
 				pclose(fp);
 			} else
 				error = errno;
 			break;
 		}
 		if (error)
 			errc(EX_IOERR, error, "partition %d", part->index + 1);
 		part->size = (bytesize + secsz - 1) / secsz;
 		if (verbose) {
 			bytesize = part->size * secsz;
 			fprintf(stderr, "size %llu bytes (%llu blocks)\n",
 			     (long long)bytesize, (long long)part->size);
 			if (abs_offset) {
 				fprintf(stderr,
 				    "    location %llu bytes (%llu blocks)\n",
 				    (long long)byteoffset,
 				    (long long)blkoffset);
 			} else if (blkoffset > 0) {
 				fprintf(stderr,
 				    "    offset %llu bytes (%llu blocks)\n",
 				    (long long)byteoffset,
 				    (long long)blkoffset);
 			}
 		}
 		block = scheme_metadata(SCHEME_META_PART_AFTER,
 		    part->block + part->size);
 	}
 
 	mkimg_validate();
 
 	block = scheme_metadata(SCHEME_META_IMG_END, block);
 	error = image_set_size(block);
 	if (!error) {
 		error = capacity_resize(block);
 		block = image_get_size();
 	}
 	if (!error) {
 		error = format_resize(block);
 		block = image_get_size();
 	}
 	if (error)
 		errc(EX_IOERR, error, "image sizing");
 	ncyls = block / (nsecs * nheads);
 	error = scheme_write(block);
 	if (error)
 		errc(EX_IOERR, error, "writing metadata");
 }
 
 int
 main(int argc, char *argv[])
 {
 	const char *format_name;
 	int bcfd, outfd;
 	int c, error;
 
 	bcfd = -1;
 	outfd = 1;	/* Write to stdout by default */
 	while ((c = getopt_long(argc, argv, "a:b:c:C:f:o:p:s:t:vyH:P:S:T:",
 	    longopts, NULL)) != -1) {
 		switch (c) {
 		case 'a':	/* ACTIVE PARTITION, if supported */
 			error = parse_uint32(&active_partition, 1, 100, optarg);
 			if (error)
 				errc(EX_DATAERR, error, "Partition ordinal");
 			break;
 		case 'b':	/* BOOT CODE */
 			if (bcfd != -1)
 				usage("multiple bootcode given");
 			bcfd = open(optarg, O_RDONLY, 0);
 			if (bcfd == -1)
 				err(EX_UNAVAILABLE, "%s", optarg);
 			break;
 		case 'c':	/* MINIMUM CAPACITY */
 			error = parse_uint64(&min_capacity, 1, INT64_MAX, optarg);
 			if (error)
 				errc(EX_DATAERR, error, "minimum capacity in bytes");
 			break;
 		case 'C':	/* MAXIMUM CAPACITY */
 			error = parse_uint64(&max_capacity, 1, INT64_MAX, optarg);
 			if (error)
 				errc(EX_DATAERR, error, "maximum capacity in bytes");
 			break;
 		case 'f':	/* OUTPUT FORMAT */
 			if (format_selected() != NULL)
 				usage("multiple formats given");
 			error = format_select(optarg);
 			if (error)
 				errc(EX_DATAERR, error, "format");
 			break;
 		case 'o':	/* OUTPUT FILE */
 			if (outfd != 1)
 				usage("multiple output files given");
 			outfd = open(optarg, O_WRONLY | O_CREAT | O_TRUNC,
 			    S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
 			if (outfd == -1)
 				err(EX_CANTCREAT, "%s", optarg);
 			break;
 		case 'p':	/* PARTITION */
 			error = parse_part(optarg);
 			if (error)
 				errc(EX_DATAERR, error, "partition");
 			break;
 		case 's':	/* SCHEME */
 			if (scheme_selected() != NULL)
 				usage("multiple schemes given");
 			error = scheme_select(optarg);
 			if (error)
 				errc(EX_DATAERR, error, "scheme");
 			break;
 		case 't': {
 			char *ep;
 			long long val;
 
 			errno = 0;
 			val = strtoll(optarg, &ep, 0);
 			if (ep == optarg || *ep != '\0')
 				errno = EINVAL;
 			if (errno != 0)
 				errc(EX_DATAERR, errno, "timestamp");
 			timestamp = (time_t)val;
 			break;
 		}
 		case 'y':
 			unit_testing++;
 			break;
 		case 'v':
 			verbose++;
 			break;
 		case 'H':	/* GEOMETRY: HEADS */
 			error = parse_uint32(&nheads, 1, 255, optarg);
 			if (error)
 				errc(EX_DATAERR, error, "number of heads");
 			break;
 		case 'P':	/* GEOMETRY: PHYSICAL SECTOR SIZE */
 			error = parse_uint32(&blksz, 512, INT_MAX+1U, optarg);
 			if (error == 0 && !pwr_of_two(blksz))
 				error = EINVAL;
 			if (error)
 				errc(EX_DATAERR, error, "physical sector size");
 			break;
 		case 'S':	/* GEOMETRY: LOGICAL SECTOR SIZE */
 			error = parse_uint32(&secsz, 512, INT_MAX+1U, optarg);
 			if (error == 0 && !pwr_of_two(secsz))
 				error = EINVAL;
 			if (error)
 				errc(EX_DATAERR, error, "logical sector size");
 			break;
 		case 'T':	/* GEOMETRY: TRACK SIZE */
 			error = parse_uint32(&nsecs, 1, 63, optarg);
 			if (error)
 				errc(EX_DATAERR, error, "track size");
 			break;
 		case LONGOPT_FORMATS:
 			print_formats(0);
 			exit(EX_OK);
 			/*NOTREACHED*/
 		case LONGOPT_SCHEMES:
 			print_schemes(0);
 			exit(EX_OK);
 			/*NOTREACHED*/
 		case LONGOPT_VERSION:
 			print_version();
 			exit(EX_OK);
 			/*NOTREACHED*/
 		case LONGOPT_CAPACITY:
 			error = parse_uint64(&min_capacity, 1, INT64_MAX, optarg);
 			if (error)
 				errc(EX_DATAERR, error, "capacity in bytes");
 			max_capacity = min_capacity;
 			break;
 		default:
 			usage("unknown option");
 		}
 	}
 
 	if (argc > optind)
 		usage("trailing arguments");
 	if (scheme_selected() == NULL && nparts > 0)
 		usage("no scheme");
 	if (nparts == 0 && min_capacity == 0)
 		usage("no partitions");
 	if (max_capacity != 0 && min_capacity > max_capacity)
 		usage("minimum capacity cannot be larger than the maximum one");
 
 	if (secsz > blksz) {
 		if (blksz != 0)
 			errx(EX_DATAERR, "the physical block size cannot "
 			    "be smaller than the sector size");
 		blksz = secsz;
 	}
 
 	if (secsz > scheme_max_secsz())
 		errx(EX_DATAERR, "maximum sector size supported is %u; "
 		    "size specified is %u", scheme_max_secsz(), secsz);
 
 	if (nparts > scheme_max_parts())
 		errx(EX_DATAERR, "%d partitions supported; %d given",
 		    scheme_max_parts(), nparts);
 
 	if (format_selected() == NULL)
 		format_select("raw");
 
 	if (bcfd != -1) {
 		error = scheme_bootcode(bcfd);
 		close(bcfd);
 		if (error)
 			errc(EX_DATAERR, error, "boot code");
 	}
 
 	format_name = format_selected()->name;
 	if (verbose) {
 		fprintf(stderr, "Logical sector size: %u\n", secsz);
 		fprintf(stderr, "Physical block size: %u\n", blksz);
 		fprintf(stderr, "Sectors per track:   %u\n", nsecs);
 		fprintf(stderr, "Number of heads:     %u\n", nheads);
 		fputc('\n', stderr);
 		if (scheme_selected())
 			fprintf(stderr, "Partitioning scheme: %s\n",
 			    scheme_selected()->name);
 		fprintf(stderr, "Output file format:  %s\n",
 		    format_name);
 		fputc('\n', stderr);
 	}
 
 #if defined(SPARSE_WRITE)
 	/*
 	 * sparse_write() fails if output is not seekable so fail early
 	 * not wasting some load unless output format is raw
 	 */
 	if (strcmp("raw", format_name) &&
 	    lseek(outfd, (off_t)0, SEEK_CUR) == -1 && errno == ESPIPE)
 		errx(EX_USAGE, "%s: output must be seekable", format_name);
 #endif
 
 	error = image_init();
 	if (error)
 		errc(EX_OSERR, error, "cannot initialize");
 
 	mkimg();
 
 	if (verbose) {
 		fputc('\n', stderr);
 		fprintf(stderr, "Number of cylinders: %u\n", ncyls);
 	}
 
 	error = format_write(outfd);
 	if (error)
 		errc(EX_IOERR, error, "writing image");
 
 	return (0);
 }