git: ce05cad71c23 - stable/12 - zfsboot: cstyle cleanup

From: Kyle Evans <kevans_at_FreeBSD.org>
Date: Fri, 08 Oct 2021 06:10:46 UTC
The branch stable/12 has been updated by kevans:

URL: https://cgit.FreeBSD.org/src/commit/?id=ce05cad71c235a8dd4ee787648080ee5d11792b0

commit ce05cad71c235a8dd4ee787648080ee5d11792b0
Author:     Toomas Soome <tsoome@FreeBSD.org>
AuthorDate: 2020-06-14 20:57:24 +0000
Commit:     Kyle Evans <kevans@FreeBSD.org>
CommitDate: 2021-10-08 02:42:46 +0000

    zfsboot: cstyle cleanup
    
    No functional changes intended.
    
    (cherry picked from commit dfdeb45425cf025ce32c517ec3f85a8dd9fdff54)
---
 stand/i386/zfsboot/zfsboot.c | 1317 +++++++++++++++++++++---------------------
 1 file changed, 673 insertions(+), 644 deletions(-)

diff --git a/stand/i386/zfsboot/zfsboot.c b/stand/i386/zfsboot/zfsboot.c
index 03edb08409c6..a51c69267fbc 100644
--- a/stand/i386/zfsboot/zfsboot.c
+++ b/stand/i386/zfsboot/zfsboot.c
@@ -48,20 +48,20 @@ __FBSDID("$FreeBSD$");
 
 #include "libzfs.h"
 
-#define ARGS			0x900
-#define NOPT			14
-#define NDEV			3
+#define	ARGS			0x900
+#define	NOPT			14
+#define	NDEV			3
 
-#define BIOS_NUMDRIVES		0x475
-#define DRV_HARD		0x80
-#define DRV_MASK		0x7f
+#define	BIOS_NUMDRIVES		0x475
+#define	DRV_HARD		0x80
+#define	DRV_MASK		0x7f
 
-#define TYPE_AD			0
-#define TYPE_DA			1
-#define TYPE_MAXHARD		TYPE_DA
-#define TYPE_FD			2
+#define	TYPE_AD			0
+#define	TYPE_DA			1
+#define	TYPE_MAXHARD		TYPE_DA
+#define	TYPE_FD			2
 
-#define DEV_GELIBOOT_BSIZE	4096
+#define	DEV_GELIBOOT_BSIZE	4096
 
 extern uint32_t _end;
 
@@ -97,12 +97,12 @@ uint32_t opts;
  * If no loader is found, try to load a kernel directly instead.
  */
 static const struct string {
-    const char *p;
-    size_t len;
+	const char *p;
+	size_t len;
 } loadpath[] = {
-    { PATH_LOADER_ZFS, sizeof(PATH_LOADER_ZFS) },
-    { PATH_LOADER, sizeof(PATH_LOADER) },
-    { PATH_KERNEL, sizeof(PATH_KERNEL) },
+	{ PATH_LOADER_ZFS, sizeof(PATH_LOADER_ZFS) },
+	{ PATH_LOADER, sizeof(PATH_LOADER) },
+	{ PATH_KERNEL, sizeof(PATH_KERNEL) },
 };
 
 static const unsigned char dev_maj[NDEV] = {30, 4, 2};
@@ -130,7 +130,7 @@ static char *heap_next;
 static char *heap_end;
 
 /* Buffers that must not span a 64k boundary. */
-#define READ_BUF_SIZE		8192
+#define	READ_BUF_SIZE		8192
 struct dmadat {
 	char rdbuf[READ_BUF_SIZE];	/* for reading large things */
 	char secbuf[READ_BUF_SIZE];	/* for MBR/disklabel */
@@ -150,9 +150,9 @@ static char gelipw[GELI_PW_MAXLEN];
 #endif
 
 struct zfsdsk {
-	struct dsk       dsk;
+	struct dsk	dsk;
 #ifdef LOADER_GELI_SUPPORT
-	struct geli_dev *gdev;
+	struct geli_dev	*gdev;
 #endif
 };
 
@@ -162,7 +162,8 @@ struct zfsdsk {
  * Read from a dnode (which must be from a ZPL filesystem).
  */
 static int
-zfs_read(spa_t *spa, const dnode_phys_t *dnode, off_t *offp, void *start, size_t size)
+zfs_read(spa_t *spa, const dnode_phys_t *dnode, off_t *offp, void *start,
+    size_t size)
 {
 	const znode_phys_t *zp = (const znode_phys_t *) dnode->dn_bonus;
 	size_t n;
@@ -198,10 +199,10 @@ vdev_read(void *xvdev, void *priv, off_t off, void *buf, size_t bytes)
 	daddr_t lba, alignlba;
 	off_t diff;
 	unsigned int nb, alignnb;
-	struct zfsdsk *zdsk = (struct zfsdsk *) priv;
+	struct zfsdsk *zdsk = priv;
 
 	if ((off & (DEV_BSIZE - 1)) || (bytes & (DEV_BSIZE - 1)))
-		return -1;
+		return (-1);
 
 	p = buf;
 	lba = off / DEV_BSIZE;
@@ -242,12 +243,13 @@ vdev_read(void *xvdev, void *priv, off_t off, void *buf, size_t bytes)
 		}
 
 		if (drvread(&zdsk->dsk, dmadat->rdbuf, alignlba, alignnb))
-			return -1;
+			return (-1);
 #ifdef LOADER_GELI_SUPPORT
 		/* decrypt */
 		if (zdsk->gdev != NULL) {
-			if (geli_read(zdsk->gdev, ((alignlba - zdsk->dsk.start) *
-			    DEV_BSIZE), dmadat->rdbuf, alignnb * DEV_BSIZE))
+			if (geli_read(zdsk->gdev,
+			    ((alignlba - zdsk->dsk.start) * DEV_BSIZE),
+			    dmadat->rdbuf, alignnb * DEV_BSIZE))
 				return (-1);
 		}
 #endif
@@ -260,13 +262,13 @@ vdev_read(void *xvdev, void *priv, off_t off, void *buf, size_t bytes)
 		diff = 0;
 	}
 
-	return 0;
+	return (0);
 }
 /* Match the signature exactly due to signature madness */
 static int
 vdev_read2(vdev_t *vdev, void *priv, off_t off, void *buf, size_t bytes)
 {
-	return vdev_read(vdev, priv, off, buf, bytes);
+	return (vdev_read(vdev, priv, off, buf, bytes));
 }
 
 
@@ -276,10 +278,10 @@ vdev_write(vdev_t *vdev, void *priv, off_t off, void *buf, size_t bytes)
 	char *p;
 	daddr_t lba;
 	unsigned int nb;
-	struct zfsdsk *zdsk = (struct zfsdsk *) priv;
+	struct zfsdsk *zdsk = priv;
 
 	if ((off & (DEV_BSIZE - 1)) || (bytes & (DEV_BSIZE - 1)))
-		return -1;
+		return (-1);
 
 	p = buf;
 	lba = off / DEV_BSIZE;
@@ -290,23 +292,23 @@ vdev_write(vdev_t *vdev, void *priv, off_t off, void *buf, size_t bytes)
 			nb = READ_BUF_SIZE / DEV_BSIZE;
 		memcpy(dmadat->rdbuf, p, nb * DEV_BSIZE);
 		if (drvwrite(&zdsk->dsk, dmadat->rdbuf, lba, nb))
-			return -1;
+			return (-1);
 		p += nb * DEV_BSIZE;
 		lba += nb;
 		bytes -= nb * DEV_BSIZE;
 	}
 
-	return 0;
+	return (0);
 }
 
 static int
 xfsread(const dnode_phys_t *dnode, off_t *offp, void *buf, size_t nbyte)
 {
-    if ((size_t)zfs_read(spa, dnode, offp, buf, nbyte) != nbyte) {
-	printf("Invalid format\n");
-	return -1;
-    }
-    return 0;
+	if ((size_t)zfs_read(spa, dnode, offp, buf, nbyte) != nbyte) {
+		printf("Invalid format\n");
+		return (-1);
+	}
+	return (0);
 }
 
 /*
@@ -369,87 +371,93 @@ vdev_clear_pad2(vdev_t *vdev)
 static void
 bios_getmem(void)
 {
-    uint64_t size;
+	uint64_t size;
+
+	/* Parse system memory map */
+	v86.ebx = 0;
+	do {
+		v86.ctl = V86_FLAGS;
+		v86.addr = 0x15;		/* int 0x15 function 0xe820 */
+		v86.eax = 0xe820;
+		v86.ecx = sizeof(struct bios_smap);
+		v86.edx = SMAP_SIG;
+		v86.es = VTOPSEG(&smap);
+		v86.edi = VTOPOFF(&smap);
+		v86int();
+		if (V86_CY(v86.efl) || (v86.eax != SMAP_SIG))
+			break;
+		/* look for a low-memory segment that's large enough */
+		if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) &&
+		    (smap.length >= (512 * 1024)))
+			bios_basemem = smap.length;
+		/* look for the first segment in 'extended' memory */
+		if ((smap.type == SMAP_TYPE_MEMORY) &&
+		    (smap.base == 0x100000)) {
+			bios_extmem = smap.length;
+		}
 
-    /* Parse system memory map */
-    v86.ebx = 0;
-    do {
-	v86.ctl = V86_FLAGS;
-	v86.addr = 0x15;		/* int 0x15 function 0xe820*/
-	v86.eax = 0xe820;
-	v86.ecx = sizeof(struct bios_smap);
-	v86.edx = SMAP_SIG;
-	v86.es = VTOPSEG(&smap);
-	v86.edi = VTOPOFF(&smap);
-	v86int();
-	if (V86_CY(v86.efl) || (v86.eax != SMAP_SIG))
-	    break;
-	/* look for a low-memory segment that's large enough */
-	if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) &&
-	    (smap.length >= (512 * 1024)))
-	    bios_basemem = smap.length;
-	/* look for the first segment in 'extended' memory */
-	if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0x100000)) {
-	    bios_extmem = smap.length;
+		/*
+		 * Look for the largest segment in 'extended' memory beyond
+		 * 1MB but below 4GB.
+		 */
+		if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base > 0x100000) &&
+		    (smap.base < 0x100000000ull)) {
+			size = smap.length;
+
+			/*
+			 * If this segment crosses the 4GB boundary,
+			 * truncate it.
+			 */
+			if (smap.base + size > 0x100000000ull)
+				size = 0x100000000ull - smap.base;
+
+			if (size > high_heap_size) {
+				high_heap_size = size;
+				high_heap_base = smap.base;
+			}
+		}
+	} while (v86.ebx != 0);
+
+	/* Fall back to the old compatibility function for base memory */
+	if (bios_basemem == 0) {
+		v86.ctl = 0;
+		v86.addr = 0x12;		/* int 0x12 */
+		v86int();
+
+		bios_basemem = (v86.eax & 0xffff) * 1024;
 	}
 
 	/*
-	 * Look for the largest segment in 'extended' memory beyond
-	 * 1MB but below 4GB.
+	 * Fall back through several compatibility functions for extended
+	 * memory.
 	 */
-	if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base > 0x100000) &&
-	    (smap.base < 0x100000000ull)) {
-	    size = smap.length;
-
-	    /*
-	     * If this segment crosses the 4GB boundary, truncate it.
-	     */
-	    if (smap.base + size > 0x100000000ull)
-		size = 0x100000000ull - smap.base;
-
-	    if (size > high_heap_size) {
-		high_heap_size = size;
-		high_heap_base = smap.base;
-	    }
+	if (bios_extmem == 0) {
+		v86.ctl = V86_FLAGS;
+		v86.addr = 0x15;		/* int 0x15 function 0xe801 */
+		v86.eax = 0xe801;
+		v86int();
+		if (!V86_CY(v86.efl)) {
+			bios_extmem = ((v86.ecx & 0xffff) +
+			    ((v86.edx & 0xffff) * 64)) * 1024;
+		}
+	}
+	if (bios_extmem == 0) {
+		v86.ctl = 0;
+		v86.addr = 0x15;		/* int 0x15 function 0x88 */
+		v86.eax = 0x8800;
+		v86int();
+		bios_extmem = (v86.eax & 0xffff) * 1024;
 	}
-    } while (v86.ebx != 0);
-
-    /* Fall back to the old compatibility function for base memory */
-    if (bios_basemem == 0) {
-	v86.ctl = 0;
-	v86.addr = 0x12;		/* int 0x12 */
-	v86int();
-	
-	bios_basemem = (v86.eax & 0xffff) * 1024;
-    }
 
-    /* Fall back through several compatibility functions for extended memory */
-    if (bios_extmem == 0) {
-	v86.ctl = V86_FLAGS;
-	v86.addr = 0x15;		/* int 0x15 function 0xe801*/
-	v86.eax = 0xe801;
-	v86int();
-	if (!V86_CY(v86.efl)) {
-	    bios_extmem = ((v86.ecx & 0xffff) + ((v86.edx & 0xffff) * 64)) * 1024;
+	/*
+	 * If we have extended memory and did not find a suitable heap
+	 * region in the SMAP, use the last 3MB of 'extended' memory as a
+	 * high heap candidate.
+	 */
+	if (bios_extmem >= HEAP_MIN && high_heap_size < HEAP_MIN) {
+		high_heap_size = HEAP_MIN;
+		high_heap_base = bios_extmem + 0x100000 - HEAP_MIN;
 	}
-    }
-    if (bios_extmem == 0) {
-	v86.ctl = 0;
-	v86.addr = 0x15;		/* int 0x15 function 0x88*/
-	v86.eax = 0x8800;
-	v86int();
-	bios_extmem = (v86.eax & 0xffff) * 1024;
-    }
-
-    /*
-     * If we have extended memory and did not find a suitable heap
-     * region in the SMAP, use the last 3MB of 'extended' memory as a
-     * high heap candidate.
-     */
-    if (bios_extmem >= HEAP_MIN && high_heap_size < HEAP_MIN) {
-	high_heap_size = HEAP_MIN;
-	high_heap_base = bios_extmem + 0x100000 - HEAP_MIN;
-    }
 }
 
 /*
@@ -458,20 +466,20 @@ bios_getmem(void)
 static int
 int13probe(int drive)
 {
-    v86.ctl = V86_FLAGS;
-    v86.addr = 0x13;
-    v86.eax = 0x800;
-    v86.edx = drive;
-    v86int();
-    
-    if (!V86_CY(v86.efl) &&				/* carry clear */
-	((v86.edx & 0xff) != (drive & DRV_MASK))) {	/* unit # OK */
-	if ((v86.ecx & 0x3f) == 0) {			/* absurd sector size */
-		return(0);				/* skip device */
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x13;
+	v86.eax = 0x800;
+	v86.edx = drive;
+	v86int();
+
+	if (!V86_CY(v86.efl) &&				/* carry clear */
+	    ((v86.edx & 0xff) != (drive & DRV_MASK))) {	/* unit # OK */
+		if ((v86.ecx & 0x3f) == 0) {		/* absurd sector size */
+			return (0);			/* skip device */
+		}
+		return (1);
 	}
-	return (1);
-    }
-    return(0);
+	return (0);
 }
 
 /*
@@ -481,11 +489,11 @@ int13probe(int drive)
 static struct zfsdsk *
 copy_dsk(struct zfsdsk *zdsk)
 {
-    struct zfsdsk *newdsk;
+	struct zfsdsk *newdsk;
 
-    newdsk = malloc(sizeof(struct zfsdsk));
-    *newdsk = *zdsk;
-    return (newdsk);
+	newdsk = malloc(sizeof(struct zfsdsk));
+	*newdsk = *zdsk;
+	return (newdsk);
 }
 
 /*
@@ -560,8 +568,8 @@ drvsize_ext(struct zfsdsk *zdsk)
 	v86.edx = dskp->drive;
 	v86.ebx = 0x55aa;
 	v86int();
-	if (V86_CY(v86.efl) ||  /* carry set */
-	    (v86.ebx & 0xffff) != 0xaa55 || /* signature */
+	if (V86_CY(v86.efl) ||			/* carry set */
+	    (v86.ebx & 0xffff) != 0xaa55 ||	/* signature */
 	    (v86.ecx & EDD_INTERFACE_FIXED_DISK) == 0)
 		return (size);
 
@@ -593,598 +601,619 @@ static void
 probe_drive(struct zfsdsk *zdsk)
 {
 #ifdef GPT
-    struct gpt_hdr hdr;
-    struct gpt_ent *ent;
-    unsigned part, entries_per_sec;
-    daddr_t slba;
+	struct gpt_hdr hdr;
+	struct gpt_ent *ent;
+	unsigned part, entries_per_sec;
+	daddr_t slba;
 #endif
 #if defined(GPT) || defined(LOADER_GELI_SUPPORT)
-    daddr_t elba;
+	daddr_t elba;
 #endif
 
-    struct dos_partition *dp;
-    char *sec;
-    unsigned i;
+	struct dos_partition *dp;
+	char *sec;
+	unsigned i;
 
 #ifdef LOADER_GELI_SUPPORT
-    /*
-     * Taste the disk, if it is GELI encrypted, decrypt it then dig out the
-     * partition table and probe each slice/partition in turn for a vdev or
-     * GELI encrypted vdev.
-     */
-    elba = drvsize_ext(zdsk);
-    if (elba > 0) {
-	elba--;
-    }
-    zdsk->gdev = geli_taste(vdev_read, zdsk, elba, "disk%u:0:");
-    if ((zdsk->gdev != NULL) && (geli_havekey(zdsk->gdev) == 0))
-	    geli_passphrase(zdsk->gdev, gelipw);
+	/*
+	 * Taste the disk, if it is GELI encrypted, decrypt it then dig out the
+	 * partition table and probe each slice/partition in turn for a vdev or
+	 * GELI encrypted vdev.
+	 */
+	elba = drvsize_ext(zdsk);
+	if (elba > 0) {
+		elba--;
+	}
+	zdsk->gdev = geli_taste(vdev_read, zdsk, elba, "disk%u:0:");
+	if ((zdsk->gdev != NULL) && (geli_havekey(zdsk->gdev) == 0))
+		geli_passphrase(zdsk->gdev, gelipw);
 #endif /* LOADER_GELI_SUPPORT */
 
-    sec = dmadat->secbuf;
-    zdsk->dsk.start = 0;
+	sec = dmadat->secbuf;
+	zdsk->dsk.start = 0;
 
 #ifdef GPT
-    /*
-     * First check for GPT.
-     */
-    if (drvread(&zdsk->dsk, sec, 1, 1)) {
-	return;
-    }
-    memcpy(&hdr, sec, sizeof(hdr));
-    if (memcmp(hdr.hdr_sig, GPT_HDR_SIG, sizeof(hdr.hdr_sig)) != 0 ||
-	hdr.hdr_lba_self != 1 || hdr.hdr_revision < 0x00010000 ||
-	hdr.hdr_entsz < sizeof(*ent) || DEV_BSIZE % hdr.hdr_entsz != 0) {
-	goto trymbr;
-    }
-
-    /*
-     * Probe all GPT partitions for the presence of ZFS pools. We
-     * return the spa_t for the first we find (if requested). This
-     * will have the effect of booting from the first pool on the
-     * disk.
-     *
-     * If no vdev is found, GELI decrypting the device and try again
-     */
-    entries_per_sec = DEV_BSIZE / hdr.hdr_entsz;
-    slba = hdr.hdr_lba_table;
-    elba = slba + hdr.hdr_entries / entries_per_sec;
-    while (slba < elba) {
-	zdsk->dsk.start = 0;
-	if (drvread(&zdsk->dsk, sec, slba, 1))
-	    return;
-	for (part = 0; part < entries_per_sec; part++) {
-	    ent = (struct gpt_ent *)(sec + part * hdr.hdr_entsz);
-	    if (memcmp(&ent->ent_type, &freebsd_zfs_uuid,
-		     sizeof(uuid_t)) == 0) {
-		zdsk->dsk.start = ent->ent_lba_start;
-		zdsk->dsk.size = ent->ent_lba_end - ent->ent_lba_start + 1;
-		zdsk->dsk.slice = part + 1;
-		zdsk->dsk.part = 255;
-		if (vdev_probe(vdev_read2, zdsk, NULL) == 0) {
-		    /*
-		     * This slice had a vdev. We need a new dsk
-		     * structure now since the vdev now owns this one.
-		     */
-		    zdsk = copy_dsk(zdsk);
-		}
+	/*
+	 * First check for GPT.
+	 */
+	if (drvread(&zdsk->dsk, sec, 1, 1)) {
+		return;
+	}
+	memcpy(&hdr, sec, sizeof(hdr));
+	if (memcmp(hdr.hdr_sig, GPT_HDR_SIG, sizeof(hdr.hdr_sig)) != 0 ||
+	    hdr.hdr_lba_self != 1 || hdr.hdr_revision < 0x00010000 ||
+	    hdr.hdr_entsz < sizeof(*ent) || DEV_BSIZE % hdr.hdr_entsz != 0) {
+		goto trymbr;
+	}
+
+	/*
+	 * Probe all GPT partitions for the presence of ZFS pools. We
+	 * return the spa_t for the first we find (if requested). This
+	 * will have the effect of booting from the first pool on the
+	 * disk.
+	 *
+	 * If no vdev is found, GELI decrypting the device and try again
+	 */
+	entries_per_sec = DEV_BSIZE / hdr.hdr_entsz;
+	slba = hdr.hdr_lba_table;
+	elba = slba + hdr.hdr_entries / entries_per_sec;
+	while (slba < elba) {
+		zdsk->dsk.start = 0;
+		if (drvread(&zdsk->dsk, sec, slba, 1))
+			return;
+		for (part = 0; part < entries_per_sec; part++) {
+			ent = (struct gpt_ent *)(sec + part * hdr.hdr_entsz);
+			if (memcmp(&ent->ent_type, &freebsd_zfs_uuid,
+			    sizeof(uuid_t)) == 0) {
+				zdsk->dsk.start = ent->ent_lba_start;
+				zdsk->dsk.size =
+				    ent->ent_lba_end - ent->ent_lba_start + 1;
+				zdsk->dsk.slice = part + 1;
+				zdsk->dsk.part = 255;
+				if (vdev_probe(vdev_read2, zdsk, NULL) == 0) {
+					/*
+					 * This slice had a vdev. We need a new
+					 * dsk structure now since the vdev now
+					 * owns this one.
+					 */
+					zdsk = copy_dsk(zdsk);
+				}
 #ifdef LOADER_GELI_SUPPORT
-		else if ((zdsk->gdev = geli_taste(vdev_read, zdsk,
-		    ent->ent_lba_end - ent->ent_lba_start, "disk%up%u:",
-		    zdsk->dsk.unit, zdsk->dsk.slice)) != NULL) {
-		    if (geli_havekey(zdsk->gdev) == 0 ||
-			geli_passphrase(zdsk->gdev, gelipw) == 0) {
-			/*
-			 * This slice has GELI, check it for ZFS.
-			 */
-			if (vdev_probe(vdev_read2, zdsk, NULL) == 0) {
-			    /*
-			     * This slice had a vdev. We need a new dsk
-			     * structure now since the vdev now owns this one.
-			     */
-			    zdsk = copy_dsk(zdsk);
+				else if ((zdsk->gdev = geli_taste(vdev_read,
+				    zdsk, ent->ent_lba_end - ent->ent_lba_start,
+				    "disk%up%u:", zdsk->dsk.unit,
+				    zdsk->dsk.slice)) != NULL) {
+					if (geli_havekey(zdsk->gdev) == 0 ||
+					    geli_passphrase(zdsk->gdev, gelipw)
+					    == 0) {
+						/*
+						 * This slice has GELI,
+						 * check it for ZFS.
+						 */
+						if (vdev_probe(vdev_read2,
+						    zdsk, NULL) == 0) {
+							/*
+							 * This slice had a
+							 * vdev. We need a new
+							 * dsk structure now
+							 * since the vdev now
+							 * owns this one.
+							 */
+							zdsk = copy_dsk(zdsk);
+						}
+						break;
+					}
+				}
+#endif /* LOADER_GELI_SUPPORT */
 			}
-			break;
-		    }
 		}
-#endif /* LOADER_GELI_SUPPORT */
-	    }
+		slba++;
 	}
-	slba++;
-    }
-    return;
+	return;
 trymbr:
 #endif /* GPT */
 
-    if (drvread(&zdsk->dsk, sec, DOSBBSECTOR, 1))
-	return;
-    dp = (void *)(sec + DOSPARTOFF);
-
-    for (i = 0; i < NDOSPART; i++) {
-	if (!dp[i].dp_typ)
-	    continue;
-	zdsk->dsk.start = dp[i].dp_start;
-	zdsk->dsk.size = dp[i].dp_size;
-	zdsk->dsk.slice = i + 1;
-	if (vdev_probe(vdev_read2, zdsk, NULL) == 0) {
-	    zdsk = copy_dsk(zdsk);
-	}
-#ifdef LOADER_GELI_SUPPORT
-	else if ((zdsk->gdev = geli_taste(vdev_read, zdsk, dp[i].dp_size -
-		 dp[i].dp_start, "disk%us%u:")) != NULL) {
-	    if (geli_havekey(zdsk->gdev) == 0 ||
-		geli_passphrase(zdsk->gdev, gelipw) == 0) {
-		/*
-		 * This slice has GELI, check it for ZFS.
-		 */
+	if (drvread(&zdsk->dsk, sec, DOSBBSECTOR, 1))
+		return;
+	dp = (void *)(sec + DOSPARTOFF);
+
+	for (i = 0; i < NDOSPART; i++) {
+		if (!dp[i].dp_typ)
+			continue;
+		zdsk->dsk.start = dp[i].dp_start;
+		zdsk->dsk.size = dp[i].dp_size;
+		zdsk->dsk.slice = i + 1;
 		if (vdev_probe(vdev_read2, zdsk, NULL) == 0) {
-		    /*
-		     * This slice had a vdev. We need a new dsk
-		     * structure now since the vdev now owns this one.
-		     */
-		    zdsk = copy_dsk(zdsk);
+			zdsk = copy_dsk(zdsk);
+		}
+#ifdef LOADER_GELI_SUPPORT
+		else if ((zdsk->gdev = geli_taste(vdev_read, zdsk,
+		    dp[i].dp_size - dp[i].dp_start, "disk%us%u:")) != NULL) {
+			if (geli_havekey(zdsk->gdev) == 0 ||
+			    geli_passphrase(zdsk->gdev, gelipw) == 0) {
+				/*
+				 * This slice has GELI, check it for ZFS.
+				 */
+				if (vdev_probe(vdev_read2, zdsk, NULL) == 0) {
+					/*
+					 * This slice had a vdev. We need a new
+					 * dsk structure now since the vdev now
+					 * owns this one.
+					 */
+					zdsk = copy_dsk(zdsk);
+				}
+				break;
+			}
 		}
-		break;
-	    }
-	}
 #endif /* LOADER_GELI_SUPPORT */
-    }
+	}
 }
 
 int
 main(void)
 {
-    dnode_phys_t dn;
-    off_t off;
-    struct zfsdsk *zdsk;
-    int autoboot, i;
-    int nextboot;
-    int rc;
-
-    dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
-
-    bios_getmem();
-
-    if (high_heap_size > 0) {
-	heap_end = PTOV(high_heap_base + high_heap_size);
-	heap_next = PTOV(high_heap_base);
-    } else {
-	heap_next = (char *)dmadat + sizeof(*dmadat);
-	heap_end = (char *)PTOV(bios_basemem);
-    }
-    setheap(heap_next, heap_end);
-
-    zdsk = calloc(1, sizeof(struct zfsdsk));
-    zdsk->dsk.drive = *(uint8_t *)PTOV(ARGS);
-    zdsk->dsk.type = zdsk->dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
-    zdsk->dsk.unit = zdsk->dsk.drive & DRV_MASK;
-    zdsk->dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1;
-    zdsk->dsk.part = 0;
-    zdsk->dsk.start = 0;
-    zdsk->dsk.size = drvsize_ext(zdsk);
-
-    bootinfo.bi_version = BOOTINFO_VERSION;
-    bootinfo.bi_size = sizeof(bootinfo);
-    bootinfo.bi_basemem = bios_basemem / 1024;
-    bootinfo.bi_extmem = bios_extmem / 1024;
-    bootinfo.bi_memsizes_valid++;
-    bootinfo.bi_bios_dev = zdsk->dsk.drive;
-
-    bootdev = MAKEBOOTDEV(dev_maj[zdsk->dsk.type],
-			  zdsk->dsk.slice, zdsk->dsk.unit, zdsk->dsk.part);
-
-    /* Process configuration file */
-
-    autoboot = 1;
-
-    zfs_init();
-
-    /*
-     * Probe the boot drive first - we will try to boot from whatever
-     * pool we find on that drive.
-     */
-    probe_drive(zdsk);
-
-    /*
-     * Probe the rest of the drives that the bios knows about. This
-     * will find any other available pools and it may fill in missing
-     * vdevs for the boot pool.
-     */
-#ifndef VIRTUALBOX
-    for (i = 0; i < *(unsigned char *)PTOV(BIOS_NUMDRIVES); i++)
-#else
-    for (i = 0; i < MAXBDDEV; i++)
-#endif
-    {
-	if ((i | DRV_HARD) == *(uint8_t *)PTOV(ARGS))
-	    continue;
+	dnode_phys_t dn;
+	off_t off;
+	struct zfsdsk *zdsk;
+	int autoboot, i;
+	int nextboot;
+	int rc;
+
+	dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
 
-	if (!int13probe(i | DRV_HARD))
-	    break;
+	bios_getmem();
+
+	if (high_heap_size > 0) {
+		heap_end = PTOV(high_heap_base + high_heap_size);
+		heap_next = PTOV(high_heap_base);
+	} else {
+		heap_next = (char *)dmadat + sizeof(*dmadat);
+		heap_end = (char *)PTOV(bios_basemem);
+	}
+	setheap(heap_next, heap_end);
 
 	zdsk = calloc(1, sizeof(struct zfsdsk));
-	zdsk->dsk.drive = i | DRV_HARD;
-	zdsk->dsk.type = zdsk->dsk.drive & TYPE_AD;
-	zdsk->dsk.unit = i;
-	zdsk->dsk.slice = 0;
+	zdsk->dsk.drive = *(uint8_t *)PTOV(ARGS);
+	zdsk->dsk.type = zdsk->dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
+	zdsk->dsk.unit = zdsk->dsk.drive & DRV_MASK;
+	zdsk->dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1;
 	zdsk->dsk.part = 0;
 	zdsk->dsk.start = 0;
 	zdsk->dsk.size = drvsize_ext(zdsk);
+
+	bootinfo.bi_version = BOOTINFO_VERSION;
+	bootinfo.bi_size = sizeof(bootinfo);
+	bootinfo.bi_basemem = bios_basemem / 1024;
+	bootinfo.bi_extmem = bios_extmem / 1024;
+	bootinfo.bi_memsizes_valid++;
+	bootinfo.bi_bios_dev = zdsk->dsk.drive;
+
+	bootdev = MAKEBOOTDEV(dev_maj[zdsk->dsk.type],
+	    zdsk->dsk.slice, zdsk->dsk.unit, zdsk->dsk.part);
+
+	/* Process configuration file */
+
+	autoboot = 1;
+
+	zfs_init();
+
+	/*
+	 * Probe the boot drive first - we will try to boot from whatever
+	 * pool we find on that drive.
+	 */
 	probe_drive(zdsk);
-    }
-
-    /*
-     * The first discovered pool, if any, is the pool.
-     */
-    spa = spa_get_primary();
-    if (!spa) {
-	printf("%s: No ZFS pools located, can't boot\n", BOOTPROG);
-	for (;;)
-	    ;
-    }
-
-    primary_spa = spa;
-    primary_vdev = spa_get_primary_vdev(spa);
-
-    nextboot = 0;
-    rc  = vdev_read_pad2(primary_vdev, cmd, sizeof(cmd));
-    if (vdev_clear_pad2(primary_vdev))
-	printf("failed to clear pad2 area of primary vdev\n");
-    if (rc == 0) {
+
+	/*
+	 * Probe the rest of the drives that the bios knows about. This
+	 * will find any other available pools and it may fill in missing
+	 * vdevs for the boot pool.
+	 */
+#ifndef VIRTUALBOX
+	for (i = 0; i < *(unsigned char *)PTOV(BIOS_NUMDRIVES); i++)
+#else
+	for (i = 0; i < MAXBDDEV; i++)
+#endif
+	{
+		if ((i | DRV_HARD) == *(uint8_t *)PTOV(ARGS))
+			continue;
+
+		if (!int13probe(i | DRV_HARD))
+			break;
+
+		zdsk = calloc(1, sizeof(struct zfsdsk));
+		zdsk->dsk.drive = i | DRV_HARD;
+		zdsk->dsk.type = zdsk->dsk.drive & TYPE_AD;
+		zdsk->dsk.unit = i;
+		zdsk->dsk.slice = 0;
+		zdsk->dsk.part = 0;
+		zdsk->dsk.start = 0;
+		zdsk->dsk.size = drvsize_ext(zdsk);
+		probe_drive(zdsk);
+	}
+
+	/*
+	 * The first discovered pool, if any, is the pool.
+	 */
+	spa = spa_get_primary();
+	if (!spa) {
+		printf("%s: No ZFS pools located, can't boot\n", BOOTPROG);
+		for (;;)
+			;
+	}
+
+	primary_spa = spa;
+	primary_vdev = spa_get_primary_vdev(spa);
+
+	nextboot = 0;
+	rc = vdev_read_pad2(primary_vdev, cmd, sizeof(cmd));
+	if (vdev_clear_pad2(primary_vdev))
+		printf("failed to clear pad2 area of primary vdev\n");
+	if (rc == 0) {
+		if (*cmd) {
+			/*
+			 * We could find an old-style ZFS Boot Block header
+			 * here. Simply ignore it.
+			 */
+			if (*(uint64_t *)cmd != 0x2f5b007b10c) {
+				/*
+				 * Note that parse() is destructive to cmd[]
+				 * and we also want to honor RBX_QUIET option
+				 * that could be present in cmd[].
+				 */
+				nextboot = 1;
+				memcpy(cmddup, cmd, sizeof(cmd));
+				if (parse_cmd()) {
+					printf("failed to parse pad2 area of "
+					    "primary vdev\n");
+					reboot();
+				}
+				if (!OPT_CHECK(RBX_QUIET))
+					printf("zfs nextboot: %s\n", cmddup);
+			}
+			/* Do not process this command twice */
+			*cmd = 0;
+		}
+	} else
+		printf("failed to read pad2 area of primary vdev\n");
+
+	/* Mount ZFS only if it's not already mounted via nextboot parsing. */
+	if (zfsmount.spa == NULL &&
+	    (zfs_spa_init(spa) != 0 || zfs_mount(spa, 0, &zfsmount) != 0)) {
+		printf("%s: failed to mount default pool %s\n",
+		    BOOTPROG, spa->spa_name);
+		autoboot = 0;
+	} else if (zfs_lookup(&zfsmount, PATH_CONFIG, &dn) == 0 ||
+	    zfs_lookup(&zfsmount, PATH_DOTCONFIG, &dn) == 0) {
+		off = 0;
+		zfs_read(spa, &dn, &off, cmd, sizeof(cmd));
+	}
+
 	if (*cmd) {
-	    /*
-	     * We could find an old-style ZFS Boot Block header here.
-	     * Simply ignore it.
-	     */
-	    if (*(uint64_t *)cmd != 0x2f5b007b10c) {
 		/*
-		 * Note that parse() is destructive to cmd[] and we also want
-		 * to honor RBX_QUIET option that could be present in cmd[].
+		 * Note that parse_cmd() is destructive to cmd[] and we also
+		 * want to honor RBX_QUIET option that could be present in
+		 * cmd[].
 		 */
-		nextboot = 1;
 		memcpy(cmddup, cmd, sizeof(cmd));
-		if (parse_cmd()) {
-		    printf("failed to parse pad2 area of primary vdev\n");
-		    reboot();
-		}
+		if (parse_cmd())
+			autoboot = 0;
 		if (!OPT_CHECK(RBX_QUIET))
-		    printf("zfs nextboot: %s\n", cmddup);
-	    }
-	    /* Do not process this command twice */
-	    *cmd = 0;
+			printf("%s: %s\n", PATH_CONFIG, cmddup);
+		/* Do not process this command twice */
+		*cmd = 0;
 	}
-    } else
-	printf("failed to read pad2 area of primary vdev\n");
-
-    /* Mount ZFS only if it's not already mounted via nextboot parsing. */
-    if (zfsmount.spa == NULL &&
-	(zfs_spa_init(spa) != 0 || zfs_mount(spa, 0, &zfsmount) != 0)) {
-	printf("%s: failed to mount default pool %s\n",
-	    BOOTPROG, spa->spa_name);
-	autoboot = 0;
-    } else if (zfs_lookup(&zfsmount, PATH_CONFIG, &dn) == 0 ||
-        zfs_lookup(&zfsmount, PATH_DOTCONFIG, &dn) == 0) {
-	off = 0;
-	zfs_read(spa, &dn, &off, cmd, sizeof(cmd));
-    }
 
-    if (*cmd) {
-	/*
-	 * Note that parse_cmd() is destructive to cmd[] and we also want
-	 * to honor RBX_QUIET option that could be present in cmd[].
-	 */
-	memcpy(cmddup, cmd, sizeof(cmd));
-	if (parse_cmd())
-	    autoboot = 0;
-	if (!OPT_CHECK(RBX_QUIET))
-	    printf("%s: %s\n", PATH_CONFIG, cmddup);
-	/* Do not process this command twice */
-	*cmd = 0;
-    }
-
-    /* Do not risk waiting at the prompt forever. */
-    if (nextboot && !autoboot)
-	reboot();
-
-    if (autoboot && !*kname) {
-	/*
-	 * Iterate through the list of loader and kernel paths, trying to load.
-	 * If interrupted by a keypress, or in case of failure, drop the user
-	 * to the boot2 prompt.
*** 571 LINES SKIPPED ***