Add the simple vdm/vdit dumper I wrote 3 years ago. Turn it into something

a bit worthwhile (yet crude), and give it the ability to initialize the boot
area, instead of having installboot do it - we will need the boot area set up
before attempting to invoke disklabel on the root disk.

5 files changed, 712 insertions, 46 deletions

diff --git a/sys/arch/aviion/stand/Makefile b/sys/arch/aviion/stand/Makefile
index 2fc4fcacf31..f0aff770184 100644
--- a/sys/arch/aviion/stand/Makefile
+++ b/sys/arch/aviion/stand/Makefile
@@ -1,6 +1,6 @@
-#	$OpenBSD: Makefile,v 1.4 2013/09/29 17:51:34 miod Exp $
+#	$OpenBSD: Makefile,v 1.5 2013/10/01 20:32:29 miod Exp $
 
-SUBDIR= a2coff installboot
+SUBDIR= a2coff installboot vdmtool
 
 .if ${MACHINE} == "aviion"
 SUBDIR+=	libprom libsa libz
diff --git a/sys/arch/aviion/stand/installboot/installboot.c b/sys/arch/aviion/stand/installboot/installboot.c
index 2b165150a7e..a6fba2d789f 100644
--- a/sys/arch/aviion/stand/installboot/installboot.c
+++ b/sys/arch/aviion/stand/installboot/installboot.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: installboot.c,v 1.2 2013/09/29 21:30:49 jmc Exp $	*/
+/*	$OpenBSD: installboot.c,v 1.3 2013/10/01 20:32:30 miod Exp $	*/
 
 /*
  * Copyright (c) 2013 Miodrag Vallat.
@@ -31,7 +31,6 @@ char	*boot, *dev;
 
 void	analyze_label_sector(uint8_t *, struct vdm_label **,
 	    struct vdm_boot_info **);
-void	initialize_boot_area(int);
 void	read_sector(int, uint32_t, void *);
 void	usage(void);
 void	write_sector(int, uint32_t, void *);
@@ -90,32 +89,17 @@ main(int argc, char *argv[])
 
 	/*
 	 * Figure out the boot area span.
-	 * If there is no VDM boot area, set up one.
 	 */
 
 	read_sector(devfd, VDM_LABEL_SECTOR, buf);
 	analyze_label_sector(buf, &dl, &bi);
 
-	if (bi == NULL) {
-		if (verbose)
-			printf("no boot area found\n");
-		if (nowrite)
-			return 0;
-		if (verbose)
-			printf("creating boot area\n");
-		initialize_boot_area(devfd);
-
-		read_sector(devfd, VDM_LABEL_SECTOR, buf);
-		analyze_label_sector(buf, &dl, &bi);
-	}
-
 	if (bi != NULL) {
 		if (verbose)
 			printf("boot area: sectors %u-%u\n",
 			   bi->boot_start, bi->boot_start + bi->boot_size - 1);
 	} else {
-		/* should not happen */
-		return 1;
+		errx(1, "no boot area found on %s", dev);
 	}
 
 	/*
@@ -196,29 +180,3 @@ analyze_label_sector(uint8_t *sector, struct vdm_label **dl,
 	*dl = l;
 	*dbi = bi;
 }
-
-/*
- * Build a minimal VDM label and boot area.
- * Allows you to shoot yourself in the foot, badly.
- */
-void
-initialize_boot_area(int fd)
-{
-	struct vdm_label dl;
-	struct vdm_boot_info bi;
-
-	memset(buf, 0, sizeof buf);
-	memset(&dl, 0, sizeof dl);
-	memset(&bi, 0, sizeof bi);
-
-	dl.signature = htobe32(VDM_LABEL_SIGNATURE);
-	bi.signature = htobe32(VDM_LABEL_SIGNATURE);
-	bi.boot_start = htobe32(LABELSECTOR + 1);
-	bi.boot_size = htobe32(VDM_BOOT_DEFAULT_SIZE);
-	bi.version = htobe32(VDM_BOOT_INFO_VERSION);
-
-	memcpy(buf + VDM_LABEL_OFFSET_ALT, &dl, sizeof dl);
-	memcpy(buf + VDM_BLOCK_SIZE - sizeof bi, &bi, sizeof bi);
-
-	write_sector(fd, VDM_LABEL_SECTOR, buf);
-}
diff --git a/sys/arch/aviion/stand/vdmtool/Makefile b/sys/arch/aviion/stand/vdmtool/Makefile
new file mode 100644
index 00000000000..38a67c43af8
--- /dev/null
+++ b/sys/arch/aviion/stand/vdmtool/Makefile
@@ -0,0 +1,16 @@
+#	$OpenBSD: Makefile,v 1.1 2013/10/01 20:32:30 miod Exp $
+
+MAN=		vdmtool.8
+MANSUBDIR=	aviion
+
+.if ${MACHINE} == "aviion"
+PROG=		vdmtool
+BINDIR=		/usr/mdec
+DPADD=		${LIBUTIL}
+LDADD=		-lutil
+LDSTATIC=	-static
+.else
+NOPROG=
+.endif
+
+.include <bsd.prog.mk>
diff --git a/sys/arch/aviion/stand/vdmtool/vdmtool.8 b/sys/arch/aviion/stand/vdmtool/vdmtool.8
new file mode 100644
index 00000000000..d7ba7c0b905
--- /dev/null
+++ b/sys/arch/aviion/stand/vdmtool/vdmtool.8
@@ -0,0 +1,51 @@
+.\"	$OpenBSD: vdmtool.8,v 1.1 2013/10/01 20:32:30 miod Exp $
+.\"
+.\" Copyright (c) 2013 Miodrag Vallat.
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd $Mdocdate: October 1 2013 $
+.Dt VDMTOOL 8 aviion
+.Os
+.Sh NAME
+.Nm vdmtool
+.Nd display or initialize DG/UX disk volume information
+.Sh SYNOPSIS
+.Nm vdmtool
+.Op Fl iv
+.Ar rawdev
+.Sh DESCRIPTION
+.Nm vdmtool
+displays
+.\" rather crude
+information about the DG/UX volume information found on a disk.
+It may also be used to setup a "boot area" on a new disk, to turn it into
+a bootable device.
+.Pp
+The options are as follows:
+.Bl -tag -width rawdev
+.It Fl i
+Do not display volume information, but initialize a "boot area" instead.
+This will overwrite the first sector of the disk with a valid boot area
+descriptor, which declares the first 251KB of the disk as a boot area.
+.It Fl v
+Be more verbose, printing out VDIT sector information, as well as any
+unparsed byte in the VDIT structures.
+.It Ar rawdev
+The name of the raw disk device to operate upon.
+It may be abbreviated into a form recognizable by
+.Xr opendev 3 .
+.El
+.Sh SEE ALSO
+.Xr disklabel 8 ,
+.Xr installboot 8
diff --git a/sys/arch/aviion/stand/vdmtool/vdmtool.c b/sys/arch/aviion/stand/vdmtool/vdmtool.c
new file mode 100644
index 00000000000..899a8c76454
--- /dev/null
+++ b/sys/arch/aviion/stand/vdmtool/vdmtool.c
@@ -0,0 +1,641 @@
+/*	$OpenBSD: vdmtool.c,v 1.1 2013/10/01 20:32:30 miod Exp $	*/
+
+/*
+ * Copyright (c) 2013 Miodrag Vallat.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <unistd.h>
+#include <err.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <util.h>
+#include <sys/disklabel.h>
+
+void	initialize(int);
+void	report(int);
+void	usage(void);
+
+int	verbose;
+
+#define	VDM_BLOCK_SIZE	0x200
+
+void
+usage()
+{
+	fprintf(stderr, "usage: vdmtool [-i] [-v] <device>\n");
+	exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+	int c;
+	int fd;
+	int iflag = 0;
+	int exitcode = 0;
+	char *realpath;
+
+	while ((c = getopt(argc, argv, "iqv")) != -1) {
+		switch (c) {
+		case 'i':
+			iflag = 1;
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		default:
+			usage();
+		}
+	}
+
+	if (argc - optind != 1)
+		usage();
+
+	fd = opendev(argv[optind], iflag ? O_RDWR : O_RDONLY, OPENDEV_PART,
+	    &realpath);
+	if (fd < 0)
+		err(1, "open(%s)", realpath);
+
+	if (iflag)
+		initialize(fd);
+	else
+		report(fd);
+
+	close(fd);
+	exit(exitcode);
+}
+
+void
+read_sector(int fd, uint32_t secno, void *buf)
+{
+	if (lseek(fd, (off_t)secno * VDM_BLOCK_SIZE, SEEK_SET) == -1)
+		err(1, "lseek");
+
+	if (read(fd, buf, VDM_BLOCK_SIZE) != VDM_BLOCK_SIZE)
+		err(1, "read(%d,%08x)", fd, secno);
+}
+
+void
+write_sector(int fd, uint32_t secno, void *buf)
+{
+	if (lseek(fd, (off_t)secno * VDM_BLOCK_SIZE, SEEK_SET) == -1)
+		err(1, "lseek");
+
+	if (write(fd, buf, VDM_BLOCK_SIZE) != VDM_BLOCK_SIZE)
+		err(1, "write(%d,%08x)", fd, secno);
+}
+
+void
+analyze_label_sector(uint8_t *sector, struct vdm_label **dl,
+    struct vdm_boot_info **dbi)
+{
+	struct vdm_label *l;
+	struct vdm_boot_info *bi;
+
+	l = (struct vdm_label *)(sector + VDM_LABEL_OFFSET);
+	if (betoh32(l->signature) != VDM_LABEL_SIGNATURE) {
+		l = (struct vdm_label *)(sector + VDM_LABEL_OFFSET_ALT);
+		if (betoh32(l->signature) != VDM_LABEL_SIGNATURE)
+			l = NULL;
+	}
+
+	if (l != NULL) {
+		bi = (struct vdm_boot_info *)
+		    (sector + VDM_BLOCK_SIZE - sizeof *bi);
+		if (betoh32(bi->signature) != VDM_LABEL_SIGNATURE)
+			bi = NULL;
+	} else
+		bi = NULL;
+
+	*dl = l;
+	*dbi = bi;
+}
+
+uint32_t
+get_vdit_size(int fd, uint32_t secno)
+{
+	uint8_t sector[VDM_BLOCK_SIZE];
+	struct vdit_block_header *hdr;
+	uint32_t cursize = 0;
+	int kind = VDIT_BLOCK_HEAD_BE;
+
+	for (;;) {
+		read_sector(fd, secno, sector);
+		hdr = (struct vdit_block_header *)sector;
+		if (VDM_ID_KIND(&hdr->id) != kind) {
+			printf("unexpected VDIT block kind "
+			    "on sector %08x: %02x\n",
+			    secno, VDM_ID_KIND(&hdr->id));
+			return 0;
+		}
+
+		if (verbose)
+			printf("sector %08x: vdit frag type %02x, length %04x, "
+			    "next frag at %08x\n",
+			    secno, VDM_ID_KIND(&hdr->id),
+			    betoh16(hdr->chunksz), secno);
+
+		cursize += betoh16(hdr->chunksz);
+		if (betoh32(hdr->nextblk) == VDM_NO_BLK_NUMBER)
+			break;
+
+		secno = betoh32(hdr->nextblk);
+		kind = VDIT_PORTION_HEADER_BLOCK;
+	}
+
+	return cursize;
+}
+
+vdit_id_t	subdriver_vdmphys_id;
+vdit_id_t	subdriver_vdmpart_id;
+vdit_id_t	subdriver_vdmaggr_id;
+vdit_id_t	subdriver_vdmremap_id;
+
+void
+register_subdriver(uint8_t *buf)
+{
+	struct vdit_subdriver_entry entry;
+	vdit_id_t id, *regid;
+
+	memcpy(&entry, buf, sizeof entry);
+	entry.version = betoh16(entry.version);
+	memcpy(&id, &entry.subdriver_id, sizeof id);
+	id = betoh32(id);
+
+	if (strcmp(entry.name, VDM_SUBDRIVER_VDMPHYS) == 0)
+		regid = &subdriver_vdmphys_id;
+	else if (strcmp(entry.name, VDM_SUBDRIVER_VDMPART) == 0)
+		regid = &subdriver_vdmpart_id;
+	else if (strcmp(entry.name, VDM_SUBDRIVER_VDMAGGR) == 0)
+		regid = &subdriver_vdmaggr_id;
+	else if (strcmp(entry.name, VDM_SUBDRIVER_VDMREMAP) == 0)
+		regid = &subdriver_vdmremap_id;
+	else
+		regid = NULL;
+
+	if (regid != NULL) {
+		if (*regid != 0)
+			printf("WARNING: subdriver \"%s\" overriden\n",
+			    entry.name);
+		*regid = id;
+	}
+}
+
+void
+print_vdit_instance_id(struct vdit_instance_id *buf, const char *descr)
+{
+	struct vdit_instance_id instance;
+
+	memcpy(&instance, buf, sizeof instance);
+	instance.generation_timestamp = betoh32(instance.generation_timestamp);
+	instance.system_id = betoh32(instance.system_id);
+	if (instance.generation_timestamp != 0 || instance.system_id != 0 ||
+	    verbose)
+		printf("%s id %08x:%08x",
+		    descr, instance.generation_timestamp, instance.system_id);
+}
+
+uint32_t
+print_vdit_boot_info(uint8_t *buf, uint32_t size)
+{
+	struct vdit_boot_info_entry entry;
+
+	if (size < sizeof entry) {
+		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
+		    size, sizeof entry);
+		return 0;
+	}
+
+	memcpy(&entry, buf, sizeof entry);
+	entry.version = betoh16(entry.version);
+	printf("\tboot info: version %02x", entry.version);
+	print_vdit_instance_id(&entry.default_swap, " default swap");
+	print_vdit_instance_id(&entry.default_root, " default root");
+	printf("\n");
+
+	return size - sizeof entry;
+}
+
+uint32_t
+print_vdit_subdriver_info(uint8_t *buf, uint32_t size)
+{
+	struct vdit_subdriver_entry entry;
+	vdit_id_t id;
+
+	if (size < sizeof entry) {
+		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
+		    size, sizeof entry);
+		return 0;
+	}
+
+	memcpy(&entry, buf, sizeof entry);
+	entry.version = betoh16(entry.version);
+	printf("\tsubdriver: version %02x", entry.version);
+	memcpy(&id, &entry.subdriver_id, sizeof id);
+	id = betoh32(id);
+	printf(" id %08x name \"%s\"\n", id, entry.name);
+
+	return size - sizeof entry;
+}
+
+uint32_t
+print_vdmphys_instance(uint8_t *buf, uint32_t size)
+{
+	struct vdit_vdmphys_instance entry;
+
+	if (size < sizeof entry) {
+		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
+		    size, sizeof entry);
+		return 0;
+	}
+
+	memcpy(&entry, buf, sizeof entry);
+	entry.version = betoh16(entry.version);
+	entry.mode = betoh16(entry.mode);
+	printf("\tvdmphys: version %02x mode %02x\n",
+	    entry.version, entry.mode);
+
+	return size - sizeof entry;
+}
+
+uint32_t
+print_vdmpart_instance(uint8_t *buf, uint32_t size)
+{
+	struct vdit_vdmpart_instance entry;
+
+	if (size < sizeof entry) {
+		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
+		    size, sizeof entry);
+		return 0;
+	}
+
+	memcpy(&entry, buf, sizeof entry);
+	entry.version = betoh16(entry.version);
+	entry.start_blkno = betoh32(entry.start_blkno);
+	entry.size = betoh32(entry.size);
+	printf("\tvdmpart: version %02x", entry.version);
+	print_vdit_instance_id(&entry.child_instance, " child");
+	printf("\n");
+	printf("\t\tstarting block %08x size %08x",
+	    entry.start_blkno, entry.size);
+	print_vdit_instance_id(&entry.remap_instance, " remap");
+	printf("\n");
+
+	return size - sizeof entry;
+}
+
+uint32_t
+print_vdmaggr_instance(uint8_t *buf, uint32_t size)
+{
+	struct vdit_vdmaggr_instance entry;
+	struct vdit_instance_id *aggr;
+	uint32_t aggrsize;
+	uint stripe;
+
+	if (size < sizeof entry) {
+		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
+		    size, sizeof entry);
+		return 0;
+	}
+
+	memcpy(&entry, buf, sizeof entry);
+	entry.version = betoh16(entry.version);
+	entry.aggr_count = betoh16(entry.aggr_count);
+	entry.stripe_size = betoh32(entry.stripe_size);
+	printf("\tvdmaggr: version %02x count %02x stripe size %08x\n",
+	    entry.version, entry.aggr_count, entry.stripe_size);
+
+	aggrsize = entry.aggr_count * sizeof(struct vdit_instance_id) +
+	    sizeof entry;
+	if (size < aggrsize) {
+		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02x)\n",
+		    size, aggrsize);
+		return 0;
+	}
+
+	aggr = (struct vdit_instance_id *)(buf + sizeof entry);
+	for (stripe = 0; stripe < entry.aggr_count; stripe++) {
+		printf("\t\tstripe %u", stripe);
+		print_vdit_instance_id(aggr++, "");
+		printf("\n");
+	}
+
+	return size - aggrsize;
+}
+
+uint32_t
+print_vdmremap_instance(uint8_t *buf, uint32_t size)
+{
+	struct vdit_vdmremap_instance entry;
+
+	if (size < sizeof entry) {
+		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
+		    size, sizeof entry);
+		return 0;
+	}
+
+	memcpy(&entry, buf, sizeof entry);
+	entry.version = betoh16(entry.version);
+	printf("\tvdmremap: version %02x", entry.version);
+	print_vdit_instance_id(&entry.primary_remap_table,
+	    " primary remap table");
+	printf("\n");
+	print_vdit_instance_id(&entry.secondary_remap_table,
+	    "\t\tsecondary remap table");
+	printf("\n");
+	print_vdit_instance_id(&entry.remap_area, "\t\tremap area");
+	printf("\n");
+
+	return size - sizeof entry;
+}
+
+uint32_t
+print_vdit_instance_info(uint8_t *buf, uint32_t size)
+{
+	struct vdit_instance_entry entry;
+	vdit_id_t id;
+
+	if (size < sizeof entry) {
+		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
+		    size, sizeof entry);
+		return 0;
+	}
+
+	memcpy(&entry, buf, sizeof entry);
+	entry.version = betoh16(entry.version);
+	printf("\tinstance: version %02x name \"%s\"\n",
+	    entry.version, entry.name);
+	memcpy(&id, &entry.subdriver_id, sizeof id);
+	id = betoh32(id);
+	printf("\t\tsubdriver id %08x", id);
+	print_vdit_instance_id(&entry.instance_id, "");
+	printf(" export %d\n", entry.exported);
+
+	if (id == subdriver_vdmphys_id)
+		return print_vdmphys_instance(buf, size);
+	if (id == subdriver_vdmpart_id)
+		return print_vdmpart_instance(buf, size);
+	if (id == subdriver_vdmaggr_id)
+		return print_vdmaggr_instance(buf, size);
+	if (id == subdriver_vdmremap_id)
+		return print_vdmremap_instance(buf, size);
+
+	return size - sizeof entry;
+}
+
+uint8_t *
+print_vdit_entry(uint8_t *buf)
+{
+	struct vdit_entry_header hdr;
+	uint32_t remaining, cnt;
+	uint8_t *rembuf;
+
+	memcpy(&hdr, buf, sizeof hdr);
+	hdr.type = betoh16(hdr.type);
+	hdr.size = betoh16(hdr.size);
+
+	printf("vdit entry: type %02x size %02x\n", hdr.type, hdr.size);
+	if (hdr.type == VDIT_ENTRY_SENTINEL)
+		return NULL;
+
+	remaining = hdr.size - sizeof hdr;
+
+	switch (hdr.type) {
+	case VDIT_ENTRY_UNUSED:
+		remaining = 0;	/* don't print anything */
+		break;
+	case VDIT_ENTRY_BOOT_INFO:
+		remaining = print_vdit_boot_info(buf + sizeof hdr, remaining);
+		break;
+	case VDIT_ENTRY_SUBDRIVER_INFO:
+		register_subdriver(buf + sizeof hdr);
+		remaining = print_vdit_subdriver_info(buf + sizeof hdr,
+		    remaining);
+		break;
+	case VDIT_ENTRY_INSTANCE:
+		remaining = print_vdit_instance_info(buf + sizeof hdr,
+		    remaining);
+		break;
+	}
+
+	if (remaining == 4) {
+		/* timestamp */
+		remaining -= 4;
+	}
+
+	if (remaining != 0 && verbose) {
+		printf("\t%02x bytes unparsed", remaining);
+		rembuf = buf + hdr.size - remaining;
+		cnt = 0;
+		while (remaining-- != 0) {
+			if (cnt % 16 == 0)
+				printf("\n    ");
+			printf("%02x ", *rembuf++);
+			cnt++;
+		}
+		printf("\n");
+	}
+
+	return buf + hdr.size;
+}
+
+uint8_t *
+append_vdit_sector(uint32_t secno, uint8_t *buf, uint8_t *sector, int kind)
+{
+	struct vdit_block_header *hdr;
+
+	hdr = (struct vdit_block_header *)sector;
+	if (VDM_ID_KIND(&hdr->id) != kind) {
+		printf("unexpected block kind on sector %08x: %02x\n",
+		    secno, VDM_ID_KIND(&hdr->id));
+		return NULL;
+	}
+
+#ifdef DEBUG
+	printf("sector %08x: vdit block %08x\n",
+	    secno, VDM_ID_BLKNO(&hdr->id));
+#endif
+
+	memcpy(buf, sector + sizeof *hdr, VDM_BLOCK_SIZE - (sizeof *hdr));
+	return buf + VDM_BLOCK_SIZE - (sizeof *hdr);
+}
+
+uint8_t *
+append_vdit_portion(int fd, uint32_t secno, uint8_t *buf, uint8_t *sector,
+    int kind)
+{
+	struct vdit_block_header *hdr;
+	u_int chunksz;
+
+	hdr = (struct vdit_block_header *)sector;
+	if (VDM_ID_KIND(&hdr->id) != kind) {
+		printf("unexpected block kind on sector %08x: %02x\n",
+		    secno, VDM_ID_KIND(&hdr->id));
+		return NULL;
+	}
+
+	/* store first sector of the portion */
+	chunksz = betoh16(hdr->chunksz);
+	buf = append_vdit_sector(secno, buf, sector, kind);
+	chunksz--;
+	secno++;
+
+	/* do the others */
+	while (chunksz-- != 0) {
+		read_sector(fd, secno, sector);
+		buf = append_vdit_sector(secno, buf, sector, VDIT_BLOCK);
+		if (buf == NULL)
+			return NULL;
+		secno++;
+	}
+
+	return buf;
+}
+
+uint8_t *
+read_vdit(int fd, uint32_t secno, size_t *vditsize)
+{
+	uint8_t sector[VDM_BLOCK_SIZE];
+	struct vdit_block_header hdr;
+	uint32_t vdit_size;
+	uint8_t *buf, *curbuf;
+	int first = 1;
+
+	vdit_size = get_vdit_size(fd, secno);
+#ifdef DEBUG
+	printf("vdit size: %02x sectors\n", vdit_size);
+#endif
+
+	buf = (uint8_t *)malloc(VDM_BLOCK_SIZE * vdit_size);
+	if (buf == NULL)
+		err(1, "malloc");
+	memset(buf, 0, VDM_BLOCK_SIZE * vdit_size);
+
+	curbuf = buf;
+	for (;;) {
+		/* read first sector of portion */
+		read_sector(fd, secno, sector);
+		memcpy(&hdr, sector, sizeof hdr);
+
+		curbuf = append_vdit_portion(fd, secno, curbuf, sector,
+		    first ? VDIT_BLOCK_HEAD_BE : VDIT_PORTION_HEADER_BLOCK);
+		if (curbuf == NULL) {
+			free(buf);
+			return NULL;
+		}
+		first = 0;
+
+		if (hdr.nextblk == VDM_NO_BLK_NUMBER)
+			break;
+
+		secno = betoh32(hdr.nextblk);
+	}
+
+	if (verbose)
+		printf("vdit final size: 0x%zx bytes\n", curbuf - buf);
+
+	*vditsize = curbuf - buf;
+	return buf;
+}
+
+void
+report(int fd)
+{
+	uint8_t *vdit, *vdit2, *tmpvdit;
+	size_t vditsize, vditsize2;
+	struct vdm_label *dl;
+	struct vdm_boot_info *bi;
+	struct disklabel *lp;
+	uint8_t sector[VDM_BLOCK_SIZE];
+	struct vdit_block_header *hdr;
+
+	read_sector(fd, VDM_LABEL_SECTOR, sector);
+	analyze_label_sector(sector, &dl, &bi);
+
+	if (dl == NULL)
+		return;
+
+	printf("label version %04x\n", betoh16(dl->version));
+
+	if (bi != NULL)
+		printf("disk boot info: start %08x size %08x version %08x\n",
+		    betoh32(bi->boot_start),
+		    betoh32(bi->boot_size), betoh32(bi->version));
+
+	read_sector(fd, VDIT_SECTOR, sector);
+	hdr = (struct vdit_block_header *)sector;
+	if (VDM_ID_KIND(&hdr->id) != VDIT_BLOCK_HEAD_BE) {
+		lp = (struct disklabel *)(sector + LABELOFFSET);
+		if (lp->d_magic == DISKMAGIC && lp->d_magic2 == DISKMAGIC) {
+			if (verbose)
+				printf("no VDIT but a native OpenBSD label\n");
+			return;
+		}
+		errx(3, "unexpected block kind on sector %08x: %02x",
+		    1, VDM_ID_KIND(&hdr->id));
+	}
+
+	vdit = read_vdit(fd, 1, &vditsize);
+	if (vdit != NULL) {
+		tmpvdit = vdit;
+		while (tmpvdit != NULL)
+			tmpvdit = print_vdit_entry(tmpvdit);
+
+		vdit2 = read_vdit(fd, betoh32(hdr->secondary_vdit), &vditsize2);
+		if (vdit2 == NULL)
+			printf("can't read backup VDIT\n");
+		else {
+			if (vditsize2 < vditsize) {
+				printf("WARNING: backup VDIT is smaller "
+				    "than main VDIT!\n");
+				vditsize = vditsize2;
+			}
+			if (memcmp(vdit, vdit2, vditsize) != 0)
+				printf("VDIT and backup VDIT differ!\n");
+			free(vdit2);
+		}
+
+		free(vdit);
+	}
+}
+
+/*
+ * Build a minimal VDM label and boot area.
+ * Allows you to shoot yourself in the foot, badly.
+ */
+void
+initialize(int fd)
+{
+	uint8_t sector[VDM_BLOCK_SIZE];
+	struct vdm_label dl;
+	struct vdm_boot_info bi;
+
+	memset(sector, 0, sizeof sector);
+	memset(&dl, 0, sizeof dl);
+	memset(&bi, 0, sizeof bi);
+
+	dl.signature = htobe32(VDM_LABEL_SIGNATURE);
+	bi.signature = htobe32(VDM_LABEL_SIGNATURE);
+	bi.boot_start = htobe32(8);
+	bi.boot_size = htobe32(VDM_BOOT_DEFAULT_SIZE);
+	bi.version = htobe32(VDM_BOOT_INFO_VERSION);
+
+	memcpy(sector + VDM_LABEL_OFFSET_ALT, &dl, sizeof dl);
+	memcpy(sector + VDM_BLOCK_SIZE - sizeof bi, &bi, sizeof bi);
+
+	write_sector(fd, VDM_LABEL_SECTOR, sector);
+}