 @@ -1,1606 +1,1606 @@
-/*	$NetBSD: fdisk.c,v 1.136 2011/12/02 03:04:11 christos Exp $ */
+/*	$NetBSD: fdisk.c,v 1.137 2011/12/02 04:05:20 enami Exp $ */
 /*
  * Mach Operating System
  * Copyright (c) 1992 Carnegie Mellon University
  * All Rights Reserved.
+ *
  * Permission to use, copy, modify and distribute this software and its
  * documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
  * Carnegie Mellon requests users of this software to return to
+ *
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie Mellon
  * the rights to redistribute these changes.
  */
 /*
  * 14-Dec-89  Robert Baron (rvb) at Carnegie-Mellon University
  *	Copyright (c) 1989	Robert. V. Baron
  *	Created.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: fdisk.c,v 1.136 2011/12/02 03:04:11 christos Exp $");
+__RCSID("$NetBSD: fdisk.c,v 1.137 2011/12/02 04:05:20 enami Exp $");
 #endif /* not lint */
 #define MBRPTYPENAMES
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <ctype.h>
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <paths.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <vis.h>
 #if !HAVE_NBTOOL_CONFIG_H
 #include <sys/disklabel.h>
 #include <sys/disklabel_gpt.h>
 #include <sys/bootblock.h>
 #include <sys/ioctl.h>
 #include <sys/sysctl.h>
 #include <disktab.h>
 #include <util.h>
 #include <zlib.h>
 #else
 #include <nbinclude/sys/disklabel.h>
 #include <nbinclude/sys/disklabel_gpt.h>
 #include <nbinclude/sys/bootblock.h>
 #include "../../include/disktab.h"
 /* We enforce -F, so none of these possibly undefined items can be needed */
 #define opendisk(path, fl, buf, buflen, cooked) (-1)
 #ifndef DIOCGDEFLABEL
 #define DIOCGDEFLABEL 0
 #endif
 #ifndef DIOCGDINFO
 #define DIOCGDINFO 0
 #endif
 #ifndef DIOCWLABEL
 #define DIOCWLABEL 0
 #endif
 #endif /* HAVE_NBTOOL_CONFIG_H */
 #define	DEFAULT_BOOTDIR		"/usr/mdec"
 #define	LE_MBR_MAGIC		htole16(MBR_MAGIC)
 #define	LE_MBR_BS_MAGIC		htole16(MBR_BS_MAGIC)
 #if defined(__i386__) || defined(__x86_64__)
 #if !HAVE_NBTOOL_CONFIG_H
 #include <machine/cpu.h>
 #endif /* !HAVE_NBTOOL_CONFIG_H */
 #define BOOTSEL
 #endif
 #ifdef BOOTSEL
 #define	DEFAULT_BOOTCODE	"mbr"
 #define	DEFAULT_BOOTSELCODE	"mbr_bootsel"
 #define	DEFAULT_BOOTEXTCODE	"mbr_ext"
 /* Scan values for the various keys we use, as returned by the BIOS */
 #define	SCAN_ENTER	0x1c
 #define	SCAN_F1		0x3b
 #define	SCAN_1		0x2
 #define	MAX_BIOS_DISKS	16	/* Going beyond F12 is hard though! */
 /* We same the dflt 'boot partition' as a disk block, with some magic values. */
 #define DEFAULT_ACTIVE	(~(daddr_t)0)
 #define	DEFAULT_DISK(n)	(DEFAULT_ACTIVE - MAX_BIOS_DISKS + (n))
 #endif
 #define GPT_TYPE(offs) ((offs) == GPT_HDR_BLKNO ?  "primary" : "secondary")
 #ifndef PRIdaddr
 #define PRIdaddr PRId64
 #endif
 #ifndef _PATH_DEFDISK
 #define _PATH_DEFDISK	"/dev/rwd0d"
 #endif
 struct {
 	struct mbr_sector *ptn;		/* array of pbrs */
 	daddr_t		base;		/* first sector of ext. ptn */
 	daddr_t		limit;		/* last sector of ext. ptn */
 	int		num_ptn;	/* number of contained partitions */
 	int		ptn_id;		/* entry in mbr */
 	int		is_corrupt;	/* 1 if extended chain illegal */
 } ext;
 #define LBUF 100
 static char lbuf[LBUF];
 static const char *disk = _PATH_DEFDISK;
 static struct disklabel disklabel;		/* disk parameters */
 static struct mbr_sector mboot;
 static const char *boot_dir = DEFAULT_BOOTDIR;
 static char *boot_path = NULL;			/* name of file we actually opened */
 #ifdef BOOTSEL
 #define BOOTSEL_OPTIONS	"B"
 #else
 #define BOOTSEL_OPTIONS
 #define change_part(e, p, id, st, sz, bm) change__part(e, p, id, st, sz)
 #endif
 #define OPTIONS	BOOTSEL_OPTIONS "0123FSafiluvA:b:c:E:r:s:w:"
 /*
  * Disk geometry and partition alignment.
+ *
  * Modern disks do not have a fixed geomery and will always give a 'faked'
  * geometry that matches the ATA standard - max 16 heads and 256 sec/track.
  * The ATA geometry allows access to 2^28 sectors (as does LBA mode).
+ *
  * The BIOS calls originally used an 8bit register for cylinder, head and
  * sector. Later 2 bits were stolen from the sector number and added to
  * cylinder number. The BIOS will translate this faked geometry either to
  * the geometry reported by the disk, or do LBA reads (possibly LBA48).
  * BIOS CHS reads have all sorts of limits, but 2^24 is absolute.
  * For historic reasons the BIOS geometry is the called the dos geometry!
+ *
  * If you know the disks real geometry it is usually worth aligning
  * disk partitions to cylinder boundaries (certainly traditional!).
  * For 'mbr' disks this has always been done with the BIOS geometry.
  * The first track (typically 63 sectors) is reserved because the first
  * sector is used for boot code. Similarly the data partition in an
  * extended partition will start one track in. If an extended partition
  * starts at the beginning of the disk you lose 2 tracks.
+ *
  * However non-magnetic media in particular has physical sectors that are
  * not the same size as those reported, so has to do read modify write
  * sequences for misaligned transfers. The alignment of partitions to
  * cylinder boundaries makes this happen all the time.
+ *
  * It is thus sensible to align partitions on a sensible sector boundary.
  * For instance 1MB (2048 sectors).
  * Common code can do this by using a geometry with 1 head and 2048
  * sectors per track.
  */
 /* Disks reported geometry and overall size from device driver */
 static unsigned int cylinders, sectors, heads;
 static daddr_t disksectors;
 #define cylindersectors (heads * sectors)
 /* Geometry from the BIOS */
 static unsigned int dos_cylinders;
 static unsigned int dos_heads;
 static unsigned int dos_sectors;
 static daddr_t dos_disksectors;
 #define dos_cylindersectors (dos_heads * dos_sectors)
 #define dos_totalsectors (dos_heads * dos_sectors * dos_cylinders)
 #define DOSSECT(s,c)	(((s) & 0x3f) | (((c) >> 2) & 0xc0))
 #define DOSCYL(c)	((c) & 0xff)
 #define SEC_IN_1M (1024 * 1024 / 512)
 #define SEC_TO_MB(sec) ((unsigned int)(((sec) + SEC_IN_1M / 2) / SEC_IN_1M))
 #define SEC_TO_CYL(sec) (((sec) + dos_cylindersectors/2) / dos_cylindersectors)
 #define MAXCYL		1024	/* Usual limit is 1023 */
 #define	MAXHEAD		256	/* Usual limit is 255 */
 #define	MAXSECTOR	63
 static int partition = -1;
 /* Alignment of partition, and offset if first sector unusable */
 static unsigned int ptn_alignment;	/* default dos_cylindersectors */
 static unsigned int ptn_0_offset;	/* default dos_sectors */
 static int fd = -1, wfd = -1, *rfd = &fd;
 static char *disk_file = NULL;
 static char *disk_type = NULL;
 static int a_flag;		/* set active partition */
 static int i_flag;		/* init bootcode */
 static int I_flag;		/* ignore errors */
 static int u_flag;		/* update partition data */
 static int v_flag;		/* more verbose */
 static int sh_flag;		/* Output data as shell defines */
 static int f_flag;		/* force --not interactive */
 static int s_flag;		/* set id,offset,size */
 static int b_flag;		/* Set cyl, heads, secs (as c/h/s) */
 static int B_flag;		/* Edit/install bootselect code */
 static int E_flag;		/* extended partition number */
 static int b_cyl, b_head, b_sec;  /* b_flag values. */
 #if !HAVE_NBTOOL_CONFIG_H
 static int F_flag = 0;
 #else
 /* Tool - force 'file' mode to avoid unsupported functions and ioctls */
 static int F_flag = 1;
 #endif
 static struct gpt_hdr gpt1, gpt2;	/* GUID partition tables */
 static struct mbr_sector bootcode[8192 / sizeof (struct mbr_sector)];
 static int bootsize;		/* actual size of bootcode */
 static int boot_installed;	/* 1 if we've copied code into the mbr */
 #if (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H
 #define USE_DISKLIST
 static struct disklist *dl;
 #endif
 #define KNOWN_SYSIDS	(sizeof(mbr_ptypes)/sizeof(mbr_ptypes[0]))
 __dead static void	usage(void);
 static void	print_s0(int);
 static void	print_part(struct mbr_sector *, int, daddr_t);
 static void	print_mbr_partition(struct mbr_sector *, int, daddr_t, daddr_t, int);
 static void	print_pbr(daddr_t, int, uint8_t);
 static int	is_all_zero(const unsigned char *, size_t);
 static void	printvis(int, const char *, const char *, size_t);
 static int	read_boot(const char *, void *, size_t, int);
 static void	init_sector0(int);
 static void	intuit_translated_geometry(void);
 static void	get_bios_geometry(void);
 static void	get_extended_ptn(void);
 static void	get_ptn_alignmemt(void);
 #if defined(USE_DISKLIST)
 static void	get_diskname(const char *, char *, size_t);
 #endif
 static int	change_part(int, int, int, daddr_t, daddr_t, char *);
 static void	print_geometry(void);
 static int	first_active(void);
 static void	change_active(int);
 static void	change_bios_geometry(void);
 static void	dos(int, unsigned char *, unsigned char *, unsigned char *);
 static int	open_disk(int);
 static int	read_disk(daddr_t, void *);
 static int	write_disk(daddr_t, void *);
 static int	get_params(void);
 static int	read_s0(daddr_t, struct mbr_sector *);
 static int	write_mbr(void);
 static int	read_gpt(daddr_t, struct gpt_hdr *);
 static int	delete_gpt(struct gpt_hdr *);
 static int	yesno(const char *, ...);
 static int64_t	decimal(const char *, int64_t, int, int64_t, int64_t);
 #define DEC_SEC		1		/* asking for a sector number */
 #define	DEC_RND		2		/* round to end of first track */
 #define	DEC_RND_0	4		/* convert 0 to size of a track */
 #define DEC_RND_DOWN	8		/* subtract 1 track */
 #define DEC_RND_DOWN_2	16		/* subtract 2 tracks */
 static int	ptn_id(const char *, int *);
 static int	type_match(const void *, const void *);
 static const char *get_type(int);
 static int	get_mapping(int, unsigned int *, unsigned int *, unsigned int *, unsigned long *);
 #ifdef BOOTSEL
 static daddr_t	configure_bootsel(daddr_t);
 static void	install_bootsel(int);
 static daddr_t	get_default_boot(void);
 static void	set_default_boot(daddr_t);
 static void	string(const char *, int, char *);
 #endif
 static void
 initvar_disk(const char **diskp)
+{
 #if !HAVE_NBTOOL_CONFIG_H
 	int mib[2];
 	size_t len;
 	char *root_device;
 	mib[0] = CTL_KERN;
 	mib[1] = KERN_ROOT_DEVICE;
 	if (sysctl(mib, 2, NULL, &len, NULL, 0) == -1 ||
 	    (root_device = malloc(len)) == NULL ||
 	    sysctl(mib, 2, root_device, &len, NULL, 0) == -1)
 		return;
 	*diskp = root_device;
 #endif /* HAVE_NBTOOL_CONFIG_H */
+}
 int
 main(int argc, char *argv[])
+{
 	struct stat sb;
 	int ch;
 	size_t len;
 	char *cp;
 	int n;
 #ifdef BOOTSEL
 	daddr_t default_ptn;		/* start sector of default ptn */
 	char *cbootmenu = 0;
 #endif
 	int csysid;	/* For the s_flag. */
 	unsigned int cstart, csize;
 	a_flag = u_flag = sh_flag = f_flag = s_flag = b_flag = 0;
 	i_flag = B_flag = 0;
 	v_flag = 0;
 	E_flag = 0;
 	csysid = cstart = csize = 0;
 	while ((ch = getopt(argc, argv, OPTIONS)) != -1) {
 		switch (ch) {
 		case '0':
 			partition = 0;
 			break;
 		case '1':
 			partition = 1;
 			break;
 		case '2':
 			partition = 2;
 			break;
 		case '3':
 			partition = 3;
 			break;
 		case 'E':	/* Extended partition number */
 			E_flag = 1;
 			partition = strtoul(optarg, &cp, 0);
 			if (*cp || partition < 0)
 				errx(1, "Bad partition number -E %s.", optarg);
 			break;
 #ifdef BOOTSEL
 		case 'B':	/* Bootselect parameters */
 			B_flag = 1;
 			break;
 #endif
 		case 'F':	/* device argument is really a file */
 			F_flag = 1;
 			break;
 		case 'S':	/* Output as shell variables */
 			sh_flag = 1;
 			break;
 		case 'a':	/* Set active partition */
 			a_flag = 1;
 			break;
 		case 'f':	/* Non interactive */
 			f_flag = 1;
 			break;
 		case 'i':	/* Always update bootcode */
 			i_flag = 1;
 			break;
 		case 'I':	/* Ignore errors */
 			I_flag = 1;
 			break;
 		case 'l':	/* List known partition types */
 			for (len = 0; len < KNOWN_SYSIDS; len++)
 				printf("%03d %s\n", mbr_ptypes[len].id,
 				    mbr_ptypes[len].name);
 			return 0;
 		case 'u':	/* Update partition details */
 			u_flag = 1;
 			break;
 		case 'v':	/* Be verbose */
 			v_flag++;
 			break;
 		case 's':	/* Partition details */
 			s_flag = 1;
 			if (sscanf(optarg, "%d/%u/%u%n", &csysid, &cstart,
 			    &csize, &n) == 3) {
 				if (optarg[n] == 0)
 					break;
 #ifdef BOOTSEL
 				if (optarg[n] == '/') {
 					cbootmenu = optarg + n + 1;
 					break;
+				}
 #endif
+			}
 			errx(1, "Bad argument to the -s flag.");
 			break;
 		case 'b':	/* BIOS geometry */
 			b_flag = 1;
 			if (sscanf(optarg, "%d/%d/%d%n", &b_cyl, &b_head,
 			    &b_sec, &n) != 3 || optarg[n] != 0)
 				errx(1, "Bad argument to the -b flag.");
 			if (b_cyl > MAXCYL)
 				b_cyl = MAXCYL;
 			break;
 		case 'A':	/* Partition alignment[/offset] */
 			if (sscanf(optarg, "%u%n/%u%n", &ptn_alignment,
 				    &n, &ptn_0_offset, &n) < 1
 			    || optarg[n] != 0
 			    || ptn_0_offset > ptn_alignment)
 				errx(1, "Bad argument to the -A flag.");
 			if (ptn_0_offset == 0)
 				ptn_0_offset = ptn_alignment;
 			break;
 		case 'c':	/* file/directory containing boot code */
 			if (strchr(optarg, '/') != NULL &&
 			    stat(optarg, &sb) == 0 &&
 			    (sb.st_mode & S_IFMT) == S_IFDIR) {
 				boot_dir = optarg;
 				break;
+			}
 			bootsize = read_boot(optarg, bootcode,
 						sizeof bootcode, 1);
 			i_flag = 1;
 			break;
 		case 'r':	/* read data from disk_file (not raw disk) */
 			rfd = &wfd;
 			/* FALLTHROUGH */
 		case 'w':	/* write data to disk_file */
 			disk_file = optarg;
 			break;
 		case 't':
 			if (setdisktab(optarg) == -1)
 				errx(EXIT_FAILURE, "bad disktab");
 			break;
 		case 'T':
 			disk_type = optarg;
 			break;
 		default:
 			usage();
+		}
+	}
 	argc -= optind;
 	argv += optind;
 	if (disk_type != NULL && getdiskbyname(disk_type) == NULL)
 		errx(EXIT_FAILURE, "bad disktype");
 	if (sh_flag && (a_flag || i_flag || u_flag || f_flag || s_flag))
 		usage();
 	if (B_flag && f_flag) {
 		warnx("Bootselector may only be configured interactively");
 		usage();
+	}
 	if (f_flag && u_flag && !s_flag) {
 		warnx("Partition data not specified");
 		usage();
+	}
 	if (s_flag && partition == -1) {
 		warnx("-s flag requires a partition selected.");
 		usage();
+	}
 	if (argc > 1)
 		usage();
 	if (argc > 0)
 		disk = argv[0];
 	else if (!F_flag) {
 		/* Default to boot device */
 		initvar_disk(&disk);
+	}
 	if (!F_flag && stat(disk, &sb) == 0 && S_ISREG(sb.st_mode))
 		F_flag = 1;
 	if (open_disk(B_flag || a_flag || i_flag || u_flag) < 0)
 		exit(1);
 	if (read_s0(0, &mboot))
 		/* must have been a blank disk */
 		init_sector0(1);
 	read_gpt(GPT_HDR_BLKNO, &gpt1);
 	read_gpt(disksectors - 1, &gpt2);
 	if (b_flag) {
 		dos_cylinders = b_cyl;
 		dos_heads = b_head;
 		dos_sectors = b_sec;
 	} else {
 		get_bios_geometry();
+	}
 	if (ptn_alignment == 0)
 		get_ptn_alignmemt();
 	get_extended_ptn();
 #ifdef BOOTSEL
 	default_ptn = get_default_boot();
 #endif
 	if (E_flag && !u_flag && partition >= ext.num_ptn)
 		errx(1, "Extended partition %d is not defined.", partition);
 	/* Do the update stuff! */
 	if (u_flag) {
 		if (!f_flag && !b_flag)
 			change_bios_geometry();
 		if (s_flag)
 			change_part(E_flag, partition, csysid, cstart, csize,
 				cbootmenu);
 		else {
 			int part = partition, chg_ext = E_flag, prompt = 1;
 			do {
 				if (prompt) {
 					printf("\n");
 					print_s0(partition);
+				}
 				if (partition == -1)
 					part = ptn_id(
 				    "Which partition do you want to change?",
 							&chg_ext);
 				if (part < 0)
 					break;
 				prompt = change_part(chg_ext, part, 0, 0, 0, 0);
 			} while (partition == -1);
+		}
 	} else {
 		if (!i_flag && !B_flag) {
 			print_geometry();
 			print_s0(partition);
+		}
+	}
 	if (a_flag && !E_flag)
 		change_active(partition);
 #ifdef BOOTSEL
 	if (B_flag || u_flag || i_flag)
 		/* Ensure the mbr code supports this configuration */
 		install_bootsel(0);
 	if (B_flag)
 		default_ptn = configure_bootsel(default_ptn);
 	set_default_boot(default_ptn);
 #else
 	if (i_flag)
 		init_sector0(0);
 #endif
 	if (u_flag || a_flag || i_flag || B_flag) {
 		if (!f_flag) {
 			printf("\nWe haven't written the MBR back to disk "
 			       "yet.  This is your last chance.\n");
 			if (u_flag)
 				print_s0(-1);
 			if (gpt1.hdr_size != 0 || gpt2.hdr_size != 0)
 				printf("\nWARNING: The disk is carrying "
 				       "GUID Partition Tables.\n"
 				       "         If you continue, "
 				       "GPT headers will be deleted.\n\n");
 			if (yesno("Should we write new partition table?")) {
 				delete_gpt(&gpt1);
 				delete_gpt(&gpt2);
 				write_mbr();
+			}
 		} else {
 			if (delete_gpt(&gpt1) > 0)
 				warnx("Primary GPT header was deleted");
 			if (delete_gpt(&gpt2) > 0)
 				warnx("Secondary GPT header was deleted");
 			write_mbr();
+		}
+	}
 	exit(0);
+}
 static void
 usage(void)
+{
 	int indent = 7 + (int)strlen(getprogname()) + 1;
-	(void)fprintf(stderr, "usage: %s [-afiluvBS] "
+	(void)fprintf(stderr, "usage: %s [-aBFfIilSuv] "
 		"[-A ptn_alignment[/ptn_0_offset]] \\\n"
 		"%*s[-b cylinders/heads/sectors] \\\n"
 		"%*s[-0123 | -E num "
 		"[-s id/start/size[/bootmenu]]] \\\n"
 		"%*s[-t disktab] [-T disktype] \\\n"
 		"%*s[-c bootcode] "
 		"[-r|-w file] [device]\n"
 		"\t-a change active partition\n"
 		"\t-f force - not interactive\n"
 		"\t-i initialise MBR code\n"
 		"\t-l list partition types\n"
 		"\t-u update partition data\n"
 		"\t-v verbose output, -v -v more verbose still\n"
 		"\t-B update bootselect options\n"
 		"\t-F treat device as a regular file\n"
 		"\t-S output as shell defines\n"
 		"\t-r and -w access 'file' for non-destructive testing\n",
 		getprogname(), indent, "", indent, "", indent, "", indent, "");
 	exit(1);
+}
 static daddr_t
 ext_offset(int part)
+{
 	daddr_t offset = ext.base;
 	if (part != 0)
 		offset += le32toh(ext.ptn[part - 1].mbr_parts[1].mbrp_start);
 	return offset;
+}
 static void
 print_s0(int which)
+{
 	int part;
 	if (which == -1) {
 		if (!sh_flag)
 			printf("Partition table:\n");
 		for (part = 0; part < MBR_PART_COUNT; part++) {
 			if (!sh_flag)
 				printf("%d: ", part);
 			print_part(&mboot, part, 0);
+		}
 		if (!sh_flag) {
 			if (ext.is_corrupt)
 				printf("Extended partition table is corrupt\n");
 			else
 				if (ext.num_ptn != 0)
 					printf("Extended partition table:\n");
+		}
 		for (part = 0; part < ext.num_ptn; part++) {
 			if (!sh_flag)
 				printf("E%d: ", part);
 			print_part(&ext.ptn[part], 0, ext_offset(part));
 			if (!sh_flag && v_flag >= 2) {
 				printf("link: ");
 				print_mbr_partition(&ext.ptn[part], 1,
 						ext_offset(part), ext.base, 0);
+			}
+		}
 #ifdef BOOTSEL
 		if (!sh_flag && mboot.mbr_bootsel_magic == LE_MBR_BS_MAGIC) {
 			int tmo;
 			printf("Bootselector ");
 			if (mboot.mbr_bootsel.mbrbs_flags & MBR_BS_ACTIVE) {
 				printf("enabled");
 				tmo = le16toh(mboot.mbr_bootsel.mbrbs_timeo);
 				if (tmo == 0xffff)
 					printf(", infinite timeout");
 				else
 					printf(", timeout %d seconds",
 						    (10 * tmo + 9) / 182);
 			} else
 				printf("disabled");
 			printf(".\n");
+		}
 #endif
 		if (!sh_flag) {
 			int active = first_active();
 			if (active == MBR_PART_COUNT)
 				printf("No active partition.\n");
 			else
 				printf("First active partition: %d\n", active);
+		}
 		if (!sh_flag && mboot.mbr_dsn != 0)
 			printf("Drive serial number: %"PRIu32" (0x%08x)\n",
 			    le32toh(mboot.mbr_dsn),
 			    le32toh(mboot.mbr_dsn));
 		return;
+	}
 	if (E_flag) {
 		if (!sh_flag)
 			printf("Extended partition E%d:\n", which);
 		if (which > ext.num_ptn)
 			printf("Undefined\n");
 		else
 			print_part(&ext.ptn[which], 0, ext_offset(which));
 	} else {
 		if (!sh_flag)
 			printf("Partition %d:\n", which);
 		print_part(&mboot, which, 0);
+	}
+}
 static void
 print_part(struct mbr_sector *boot, int part, daddr_t offset)
+{
 	struct mbr_partition *partp;
 	const char *e;
 	if (!sh_flag) {
 		print_mbr_partition(boot, part, offset, 0, 0);
 		return;
+	}
 	partp = &boot->mbr_parts[part];
 	if (boot != &mboot) {
 		part = boot - ext.ptn;
 		e = "E";
 	} else
 		e = "";
 	if (partp->mbrp_type == 0) {
 		printf("PART%s%dSIZE=0\n", e, part);
 		return;
+	}
 	printf("PART%s%dID=%d\n", e, part, partp->mbrp_type);
 	printf("PART%s%dSIZE=%u\n", e, part, le32toh(partp->mbrp_size));
 	printf("PART%s%dSTART=%"PRIdaddr"\n", e, part,
 	    offset + le32toh(partp->mbrp_start));
 	printf("PART%s%dFLAG=0x%x\n", e, part, partp->mbrp_flag);
 	printf("PART%s%dBCYL=%d\n", e, part,
 	    MBR_PCYL(partp->mbrp_scyl, partp->mbrp_ssect));
 	printf("PART%s%dBHEAD=%d\n", e, part, partp->mbrp_shd);
 	printf("PART%s%dBSEC=%d\n", e, part, MBR_PSECT(partp->mbrp_ssect));
 	printf("PART%s%dECYL=%d\n", e, part,
 	    MBR_PCYL(partp->mbrp_ecyl, partp->mbrp_esect));
 	printf("PART%s%dEHEAD=%d\n", e, part, partp->mbrp_ehd);
 	printf("PART%s%dESEC=%d\n", e, part, MBR_PSECT(partp->mbrp_esect));
+}
 static void
 pr_cyls(daddr_t sector, int is_end)
+{
 	unsigned long cyl, head, sect;
 	cyl = sector / dos_cylindersectors;
 	sect = sector - cyl * dos_cylindersectors;
 	head = sect / dos_sectors;
 	sect -= head * dos_sectors;
 	printf("%lu", cyl);
 	if (is_end) {
 		if (head == dos_heads - 1 && sect == dos_sectors - 1)
 			return;
 	} else {
 		if (head == 0 && sect == 0)
 			return;
+	}
 	printf("/%lu/%lu", head, sect + 1);
+}
 static void
 print_mbr_partition(struct mbr_sector *boot, int part,
     daddr_t offset, daddr_t exoffset, int indent)
+{
 	daddr_t	start;
 	daddr_t	size;
 	struct mbr_partition *partp = &boot->mbr_parts[part];
 	struct mbr_sector eboot;
 	int p;
 	static int dumped = 0;
 	if (partp->mbrp_type == 0 && v_flag < 2) {
 		printf("<UNUSED>\n");
 		return;
+	}
 	start = le32toh(partp->mbrp_start);
 	size = le32toh(partp->mbrp_size);
 	if (MBR_IS_EXTENDED(partp->mbrp_type))
 		start += exoffset;
 	else
 		start += offset;
 	printf("%s (sysid %d)\n", get_type(partp->mbrp_type), partp->mbrp_type);
 #ifdef BOOTSEL
 	if (boot->mbr_bootsel_magic == LE_MBR_BS_MAGIC &&
 	    boot->mbr_bootsel.mbrbs_nametab[part][0])
 		printf("%*s    bootmenu: %s\n", indent, "",
 		    boot->mbr_bootsel.mbrbs_nametab[part]);
 #endif
 	printf("%*s    start %"PRIdaddr", size %"PRIdaddr,
 	    indent, "", start, size);
 	if (size != 0) {
 		printf(" (%u MB, Cyls ", SEC_TO_MB(size));
 		if (v_flag == 0 && le32toh(partp->mbrp_start) == ptn_0_offset)
 			pr_cyls(start - ptn_0_offset, 0);
 		else
 			pr_cyls(start, 0);
 		printf("-");
 		pr_cyls(start + size - 1, 1);
 		printf(")");
+	}
 	switch (partp->mbrp_flag) {
 	case 0:
 		break;
 	case MBR_PFLAG_ACTIVE:
 		printf(", Active");
 		break;
 	default:
 		printf(", flag 0x%x", partp->mbrp_flag);
 		break;
+	}
 	printf("\n");
 	if (v_flag) {
 		printf("%*s        beg: cylinder %4d, head %3d, sector %2d\n",
 		    indent, "",
 		    MBR_PCYL(partp->mbrp_scyl, partp->mbrp_ssect),
 		    partp->mbrp_shd, MBR_PSECT(partp->mbrp_ssect));
 		printf("%*s        end: cylinder %4d, head %3d, sector %2d\n",
 		    indent, "",
 		    MBR_PCYL(partp->mbrp_ecyl, partp->mbrp_esect),
 		    partp->mbrp_ehd, MBR_PSECT(partp->mbrp_esect));
+	}
 	if (partp->mbrp_type == 0 && start == 0 && v_flag < 3)
 		return;
 	if (! MBR_IS_EXTENDED(partp->mbrp_type))
 		print_pbr(start, indent + 8, partp->mbrp_type);
 	if (!MBR_IS_EXTENDED(partp->mbrp_type) ||
 	    (v_flag <= 2 && !ext.is_corrupt))
 		return;
 	/*
 	 * Recursive dump extended table,
 	 * This is read from the disk - so is wrong during editing.
 	 * Just ensure we only show it once.
 	 */
 	if (dumped)
 		return;
 	printf("%*s    Extended partition table:\n", indent, "");
 	indent += 4;
 	if (read_s0(start, &eboot) == -1)
 		return;
 	for (p = 0; p < MBR_PART_COUNT; p++) {
 		printf("%*s%d: ", indent, "", p);
 		print_mbr_partition(&eboot, p, start,
 				    exoffset ? exoffset : start, indent);
+	}
 	if (exoffset == 0)
 		dumped = 1;
+}
 /* Print a line with a label and a vis-encoded string */
 static void
 printvis(int indent, const char *label, const char *buf, size_t size)
+{
 	char *visbuf;
 	if ((visbuf = malloc(size * 4 + 1)) == NULL)
 		err(1, "Malloc failed");
 	strsvisx(visbuf, buf, size, VIS_TAB|VIS_NL|VIS_OCTAL, "\"");
 	printf("%*s%s: \"%s\"\n",
 	    indent, "",
 	    label, visbuf);
 	free(visbuf);
+}
 /* Check whether a buffer contains all bytes zero */
 static int
 is_all_zero(const unsigned char *p, size_t size)
+{
 	while (size-- > 0) {
 		if (*p++ != 0)
 			return 0;
+	}
 	return 1;
+}
 /*
  * Report on the contents of a PBR sector.
+ *
  * We first perform several sanity checks.  If vflag >= 2, we report all
  * failing tests, but for smaller values of v_flag we stop after the
  * first failing test.  Tests are ordered in an attempt to get the most
  * useful error message from the first failing test.
+ *
  * If v_flag >= 2, we also report some decoded values from the PBR.
  * These results may be meaningless, if the PBR doesn't follow common
  * conventions.
+ *
  * Trying to decode anything more than the magic number in the last
  * two bytes is a layering violation, but it can be very useful in
  * diagnosing boot failures.
  */
 static void
 print_pbr(daddr_t sector, int indent, uint8_t part_type)
+{
 	struct mbr_sector pboot;
 	unsigned char *p, *endp;
 	unsigned char val;
 	int ok;
 	int errcount = 0;
 #define PBR_ERROR(...)							\
 	do {								\
 		++errcount;						\
 		printf("%*s%s: ", indent, "",				\
 		    (v_flag < 2 ? "PBR is not bootable" : "Not bootable")); \
 		printf(__VA_ARGS__);					\
 		if (v_flag < 2)						\
 			return;						\
 	} while (/*CONSTCOND*/ 0)
 	if (v_flag >= 2) {
 		printf("%*sInformation from PBR:\n",
 		    indent, "");
 		indent += 4;
+	}
 	if (read_disk(sector, &pboot) == -1) {
 		PBR_ERROR("Sector %"PRIdaddr" is unreadable (%s)\n",
 		    sector, strerror(errno));
 		return;
+	}
 	/* all bytes identical? */
 	p = (unsigned char *)&pboot;
 	endp = p + sizeof(pboot);
 	val = *p;
 	ok = 0;
 	for (; p < endp; p++) {
 		if (*p != val) {
 			ok = 1;
 			break;
+		}
+	}
 	if (! ok)
 		PBR_ERROR("All bytes are identical (0x%02x)\n", val);
 	if (pboot.mbr_magic != LE_MBR_MAGIC)
 		PBR_ERROR("Bad magic number (0x%04x)\n",
 			le16toh(pboot.mbr_magic));
 #if 0
 	/* Some i386 OS might fail this test.  All non-i386 will fail. */
 	if (pboot.mbr_jmpboot[0] != 0xE9
 	    && pboot.mbr_jmpboot[0] != 0xEB) {
 		PBR_ERROR("Does not begin with i386 JMP instruction"
 			" (0x%02x 0x%02x0 0x%02x)\n",
 		    pboot.mbr_jmpboot[0], pboot.mbr_jmpboot[1],
 		    pboot.mbr_jmpboot[2]);
+	}
 #endif
 	if (v_flag > 0 && errcount == 0)
 		printf("%*sPBR appears to be bootable\n",
 		    indent, "");
 	if (v_flag < 2)
 		return;
 	if (! is_all_zero(pboot.mbr_oemname, sizeof(pboot.mbr_oemname))) {
 		printvis(indent, "OEM name", (char *)pboot.mbr_oemname,
 			sizeof(pboot.mbr_oemname));
+	}
 	if (pboot.mbr_bpb.bpb16.bsBootSig == 0x29)
 		printf("%*sBPB FAT16 boot signature found\n",
 		    indent, "");
 	if (pboot.mbr_bpb.bpb32.bsBootSig == 0x29)
 		printf("%*sBPB FAT32 boot signature found\n",
 		    indent, "");
 #undef PBR_ERROR
+}
 static int
 read_boot(const char *name, void *buf, size_t len, int err_exit)
+{
 	int bfd, ret;
 	struct stat st;
 	if (boot_path != NULL)
 		free(boot_path);
 	if (strchr(name, '/') == 0)
 		asprintf(&boot_path, "%s/%s", boot_dir, name);
 	else
 		boot_path = strdup(name);
 	if (boot_path == NULL)
 		err(1, "Malloc failed");
 	if ((bfd = open(boot_path, O_RDONLY)) < 0 || fstat(bfd, &st) == -1) {
 		warn("%s", boot_path);
 		goto fail;
+	}
 	if (st.st_size > (off_t)len) {
 		warnx("%s: bootcode too large", boot_path);
 		goto fail;
+	}
 	ret = st.st_size;
 	if (ret < 0x200) {
 		warnx("%s: bootcode too small", boot_path);
 		goto fail;
+	}
 	if (read(bfd, buf, len) != ret) {
 		warn("%s", boot_path);
 		goto fail;
+	}
 	/*
 	 * Do some sanity checking here
 	 */
 	if (((struct mbr_sector *)buf)->mbr_magic != LE_MBR_MAGIC) {
 		warnx("%s: invalid magic", boot_path);
 		goto fail;
+	}
 	close(bfd);
 	ret = (ret + 0x1ff) & ~0x1ff;
 	return ret;
     fail:
 	if (bfd >= 0)
 		close(bfd);
 	if (err_exit)
 		exit(1);
 	return 0;
+}
 static void
 init_sector0(int zappart)
+{
 	int i;
 	int copy_size = offsetof(struct mbr_sector, mbr_dsn);
 #ifdef DEFAULT_BOOTCODE
 	if (bootsize == 0)
 		bootsize = read_boot(DEFAULT_BOOTCODE, bootcode,
 			sizeof bootcode, 0);
 #endif
 #ifdef BOOTSEL
 	if (mboot.mbr_bootsel_magic == LE_MBR_BS_MAGIC
 	    && bootcode[0].mbr_bootsel_magic == LE_MBR_BS_MAGIC)
 		copy_size = MBR_BS_OFFSET;
 #endif
 	if (bootsize != 0) {
 		boot_installed = 1;
 		memcpy(&mboot, bootcode, copy_size);
 		mboot.mbr_bootsel_magic = bootcode[0].mbr_bootsel_magic;
+	}
 	mboot.mbr_magic = LE_MBR_MAGIC;
 	if (!zappart)
 		return;
 	for (i = 0; i < MBR_PART_COUNT; i++)
 		memset(&mboot.mbr_parts[i], 0, sizeof(mboot.mbr_parts[i]));
+}
 static void
 get_extended_ptn(void)
+{
 	struct mbr_partition *mp;
 	struct mbr_sector *boot;
 	daddr_t offset;
 	struct mbr_sector *nptn;
 	/* find first (there should only be one) extended partition */
 	for (mp = mboot.mbr_parts; !MBR_IS_EXTENDED(mp->mbrp_type); mp++)
 		if (mp >= &mboot.mbr_parts[MBR_PART_COUNT])
 			return;
 	/*
 	 * The extended partition should be structured as a linked list
 	 * (even though it appears, at first glance, to be a tree).
 	 */
 	ext.base = le32toh(mp->mbrp_start);
 	ext.limit = ext.base + le32toh(mp->mbrp_size);
 	ext.ptn_id = mp - mboot.mbr_parts;
 	for (offset = 0;; offset = le32toh(boot->mbr_parts[1].mbrp_start)) {
 		nptn = realloc(ext.ptn, (ext.num_ptn + 1) * sizeof *ext.ptn);
 		if (nptn == NULL)
 			err(1, "Malloc failed");
 		ext.ptn = nptn;
 		boot = ext.ptn + ext.num_ptn;
 		if (read_s0(offset + ext.base, boot) == -1)
 			break;
 		/* expect p0 to be valid and p1 to be another extended ptn */
 		if (MBR_IS_EXTENDED(boot->mbr_parts[0].mbrp_type))
 			break;
 		if (boot->mbr_parts[1].mbrp_type != 0 &&
 		    !MBR_IS_EXTENDED(boot->mbr_parts[1].mbrp_type))
 			break;
 		/* p2 and p3 should be unallocated */
 		if (boot->mbr_parts[2].mbrp_type != 0 ||
 		    boot->mbr_parts[3].mbrp_type != 0)
 			break;
 		/* data ptn inside extended one */
 		if (boot->mbr_parts[0].mbrp_type != 0 &&
 		    offset + le32toh(boot->mbr_parts[0].mbrp_start)
 		    + le32toh(boot->mbr_parts[0].mbrp_size) > ext.limit)
 			break;
 		ext.num_ptn++;
 		if (boot->mbr_parts[1].mbrp_type == 0)
 			/* end of extended partition chain */
 			return;
 		/* must be in sector order */
 		if (offset >= le32toh(boot->mbr_parts[1].mbrp_start))
 			break;
+	}
 	warnx("Extended partition table is corrupt\n");
 	ext.is_corrupt = 1;
 	ext.num_ptn = 0;
+}
 #if defined(USE_DISKLIST)
 static void
 get_diskname(const char *fullname, char *diskname, size_t size)
+{
 	const char *p, *p2;
 	size_t len;
 	p = strrchr(fullname, '/');
 	if (p == NULL)
 		p = fullname;
 	else
 		p++;
 	if (*p == 0) {
 		strlcpy(diskname, fullname, size);
 		return;
+	}
 	if (*p == 'r')
 		p++;
 	for (p2 = p; *p2 != 0; p2++)
 		if (isdigit((unsigned char)*p2))
 			break;
 	if (*p2 == 0) {
 		/* XXX invalid diskname? */
 		strlcpy(diskname, fullname, size);
 		return;
+	}
 	while (isdigit((unsigned char)*p2))
 		p2++;
 	len = p2 - p;
 	if (len > size) {
 		/* XXX */
 		strlcpy(diskname, fullname, size);
 		return;
+	}
 	memcpy(diskname, p, len);
 	diskname[len] = 0;
+}
 #endif
 static void
 get_ptn_alignmemt(void)
+{
 	struct mbr_partition *partp = &mboot.mbr_parts[0];
 	uint32_t ptn_0_base, ptn_0_limit;
 	/* Default to using 'traditional' cylinder alignment */
 	ptn_alignment = dos_cylindersectors;
 	ptn_0_offset = dos_sectors;
 	if (partp->mbrp_type != 0) {
 		/* Try to copy alignment of first partition */
 		ptn_0_base = le32toh(partp->mbrp_start);
 		ptn_0_limit = ptn_0_base + le32toh(partp->mbrp_size);
 		if (!(ptn_0_limit & 2047)) {
 			/* Partition ends on a 1MB boundary, align to 1MB */
 			ptn_alignment = 2048;
 			if (ptn_0_base <= 2048
 			    && !(ptn_0_base & (ptn_0_base - 1))) {
 				/* ptn_base is a power of 2, use it */
 				ptn_0_offset = ptn_0_base;
+			}
+		}
 	} else {
 		/* Use 1MB alignment for large disks */
 		if (disksectors > 2048 * 1024 * 128) {
 			ptn_alignment = 2048;
 			ptn_0_offset = 2048;
+		}
+	}
+}
 static void
 get_bios_geometry(void)
+{
 #if defined(USE_DISKLIST)
 	int mib[2], i;
 	size_t len;
 	struct biosdisk_info *bip;
 	struct nativedisk_info *nip;
 	char diskname[8];
 	mib[0] = CTL_MACHDEP;
 	mib[1] = CPU_DISKINFO;
 	if (sysctl(mib, 2, NULL, &len, NULL, 0) < 0) {
 		goto out;
+	}
 	dl = (struct disklist *) malloc(len);
 	if (dl == NULL)
 		err(1, "Malloc failed");
 	if (sysctl(mib, 2, dl, &len, NULL, 0) < 0) {
 		free(dl);
 		dl = 0;
 		goto out;
+	}
 	get_diskname(disk, diskname, sizeof diskname);
 	for (i = 0; i < dl->dl_nnativedisks; i++) {
 		nip = &dl->dl_nativedisks[i];
 		if (strcmp(diskname, nip->ni_devname))
 			continue;
 		/*
 		 * XXX listing possible matches is better. This is ok for
 		 * now because the user has a chance to change it later.
 		 * Also, if all the disks have the same parameters then we can
 		 * just use them, we don't need to know which disk is which.
 		 */
 		if (nip->ni_nmatches != 0) {
 			bip = &dl->dl_biosdisks[nip->ni_biosmatches[0]];
 			dos_cylinders = bip->bi_cyl;
 			dos_heads = bip->bi_head;
 			dos_sectors = bip->bi_sec;
 			if (bip->bi_lbasecs)
 				dos_disksectors = bip->bi_lbasecs;
 			return;
+		}
+	}
  out:
 #endif
 	/* Allright, allright, make a stupid guess.. */
 	intuit_translated_geometry();
+}
 #ifdef BOOTSEL
 static daddr_t
 get_default_boot(void)
+{
 	unsigned int id;
 	int p;
 	if (mboot.mbr_bootsel_magic != LE_MBR_BS_MAGIC)
 		/* default to first active partition */
 		return DEFAULT_ACTIVE;
 	id = mboot.mbr_bootsel.mbrbs_defkey;
 	if (mboot.mbr_bootsel.mbrbs_flags & MBR_BS_ASCII) {
 		/* Keycode is ascii */
 		if (id == '\r')
 		    return DEFAULT_ACTIVE;
 		/* '1'+ => allocated partition id, 'a'+ => disk 0+ */
 		if (id >= 'a' && id < 'a' + MAX_BIOS_DISKS)
 			return DEFAULT_DISK(id - 'a');
 		id -= '1';
 	} else {
 		/* keycode is PS/2 keycode */
 		if (id == SCAN_ENTER)
 			return DEFAULT_ACTIVE;
 		/* 1+ => allocated partition id, F1+ => disk 0+ */
 		if (id >= SCAN_F1 && id < SCAN_F1 + MAX_BIOS_DISKS)
 			return DEFAULT_DISK(id - SCAN_F1);
 		id -= SCAN_1;
+	}
 	/* Convert partition index to the invariant start sector number */
 	for (p = 0; p < MBR_PART_COUNT; p++) {
 		if (mboot.mbr_parts[p].mbrp_type == 0)
 			continue;
 		if (mboot.mbr_bootsel.mbrbs_nametab[p][0] == 0)
 			continue;
 		if (id-- == 0)
 			return le32toh(mboot.mbr_parts[p].mbrp_start);
+	}
 	for (p = 0; p < ext.num_ptn; p++) {
 		if (ext.ptn[p].mbr_parts[0].mbrp_type == 0)
 			continue;
 		if (ext.ptn[p].mbr_bootsel.mbrbs_nametab[0][0] == 0)
 			continue;
 		if (id-- == 0)
 			return ext_offset(p)
 				+ le32toh(ext.ptn[p].mbr_parts[0].mbrp_start);
+	}
 	return DEFAULT_ACTIVE;
+}
 static void
 set_default_boot(daddr_t default_ptn)
+{
 	int p;
 	static const unsigned char key_list[] = { SCAN_ENTER, SCAN_F1, SCAN_1,
 						'\r', 'a', '1' };
 	const unsigned char *key = key_list;
 	if (mboot.mbr_bootsel_magic != LE_MBR_BS_MAGIC)
 		/* sanity */
 		return;
 	if (mboot.mbr_bootsel.mbrbs_flags & MBR_BS_ASCII)
 		/* Use ascii values */
 		key += 3;
 	if (default_ptn == DEFAULT_ACTIVE) {
 		mboot.mbr_bootsel.mbrbs_defkey = key[0];
 		return;
+	}
 	if (default_ptn >= DEFAULT_DISK(0)
 	    && default_ptn < DEFAULT_DISK(MAX_BIOS_DISKS)) {
 		mboot.mbr_bootsel.mbrbs_defkey = key[1]
 		    + default_ptn - DEFAULT_DISK(0);
 		return;
+	}
 	mboot.mbr_bootsel.mbrbs_defkey = key[2];
 	for (p = 0; p < MBR_PART_COUNT; p++) {
 		if (mboot.mbr_parts[p].mbrp_type == 0)
 			continue;
 		if (mboot.mbr_bootsel.mbrbs_nametab[p][0] == 0)
 			continue;
 		if (le32toh(mboot.mbr_parts[p].mbrp_start) == default_ptn)
 			return;
 		mboot.mbr_bootsel.mbrbs_defkey++;
+	}
 	if (mboot.mbr_bootsel.mbrbs_flags & MBR_BS_EXTLBA) {
 		for (p = 0; p < ext.num_ptn; p++) {
 			if (ext.ptn[p].mbr_parts[0].mbrp_type == 0)
 				continue;
 			if (ext.ptn[p].mbr_bootsel.mbrbs_nametab[0][0] == 0)
 				continue;
 			if (le32toh(ext.ptn[p].mbr_parts[0].mbrp_start) +
 			    ext_offset(p) == default_ptn)
 				return;
 			mboot.mbr_bootsel.mbrbs_defkey++;
+		}
+	}
 	/* Default to first active partition */
 	mboot.mbr_bootsel.mbrbs_defkey = key[0];
+}
 static void
 install_bootsel(int needed)
+{
 	struct mbr_bootsel *mbs = &mboot.mbr_bootsel;
 	int p;
 	int ext13 = 0;
 	const char *code;
 	needed |= MBR_BS_NEWMBR;	/* need new bootsel code */
 	/* Work out which boot code we need for this configuration */
 	for (p = 0; p < MBR_PART_COUNT; p++) {
 		if (mboot.mbr_parts[p].mbrp_type == 0)
 			continue;
 		if (mboot.mbr_bootsel_magic != LE_MBR_BS_MAGIC)
 			break;
 		if (mbs->mbrbs_nametab[p][0] == 0)
 			continue;
 		needed |= MBR_BS_ACTIVE;
 		if (le32toh(mboot.mbr_parts[p].mbrp_start) >= dos_totalsectors)
 			ext13 = MBR_BS_EXTINT13;
+	}
 	for (p = 0; p < ext.num_ptn; p++) {
 		if (ext.ptn[p].mbr_bootsel_magic != LE_MBR_BS_MAGIC)
 			continue;
 		if (ext.ptn[p].mbr_parts[0].mbrp_type == 0)
 			continue;
 		if (ext.ptn[p].mbr_bootsel.mbrbs_nametab[p][0] == 0)
 			continue;
 		needed |= MBR_BS_EXTLBA | MBR_BS_ACTIVE;
+	}
 	if (B_flag)
 		needed |= MBR_BS_ACTIVE;
 	/* Is the installed code good enough ? */
 	if (!i_flag && (needed == 0 ||
 	    (mboot.mbr_bootsel_magic == LE_MBR_BS_MAGIC
 	    && (mbs->mbrbs_flags & needed) == needed))) {
 		/* yes - just set flags */
 		mbs->mbrbs_flags |= ext13;
 		return;
+	}
 	/* ok - we need to replace the bootcode */
 	if (f_flag && !(i_flag || B_flag)) {
 		warnx("Installed bootfile doesn't support required options.");
 		return;
+	}
 	if (!f_flag && bootsize == 0 && !i_flag)
 		/* Output an explanation for the 'update bootcode' prompt. */
 		printf("\n%s\n",
 		    "Installed bootfile doesn't support required options.");
 	/* Were we told a specific file ? (which we have already read) */
 	/* If so check that it supports what we need. */
 	if (bootsize != 0 && needed != 0
 	    && (bootcode[0].mbr_bootsel_magic != LE_MBR_BS_MAGIC
 	    || ((bootcode[0].mbr_bootsel.mbrbs_flags & needed) != needed))) {
 		/* No it doesn't... */
 		if (f_flag)
 			warnx("Bootfile %s doesn't support "
 				    "required bootsel options", boot_path );
 			/* But install it anyway */
 		else
 			if (yesno("Bootfile %s doesn't support the required "
 			    "options,\ninstall default bootfile instead?",
 			    boot_path))
 				bootsize = 0;
+	}
 	if (bootsize == 0) {
 		/* Get name of bootfile that supports the required facilities */
 		code = DEFAULT_BOOTCODE;
 		if (needed & MBR_BS_ACTIVE)
 			code = DEFAULT_BOOTSELCODE;
 #ifdef DEFAULT_BOOTEXTCODE
 		if (needed & MBR_BS_EXTLBA)
 			code = DEFAULT_BOOTEXTCODE;
 #endif
 		bootsize = read_boot(code, bootcode, sizeof bootcode, 0);
 		if (bootsize == 0)
 			/* The old bootcode is better than no bootcode at all */
 			return;
 		if ((bootcode[0].mbr_bootsel.mbrbs_flags & needed) != needed)
 			warnx("Default bootfile %s doesn't support required "
 				"options.  Got flags 0x%x, wanted 0x%x\n",
 				boot_path, bootcode[0].mbr_bootsel.mbrbs_flags,
 				needed);
+	}
 	if (!f_flag && !yesno("Update the bootcode from %s?", boot_path))
 		return;
 	init_sector0(0);
 	if (mboot.mbr_bootsel_magic == LE_MBR_BS_MAGIC)
 		mbs->mbrbs_flags = bootcode[0].mbr_bootsel.mbrbs_flags | ext13;
+}
 static daddr_t
 configure_bootsel(daddr_t default_ptn)
+{
 	struct mbr_bootsel *mbs = &mboot.mbr_bootsel;
 	int i, item, opt;
 	int tmo;
 	daddr_t *off;
 	int num_bios_disks;
 #if defined(USE_DISKLIST)
 	if (dl != NULL) {
 		num_bios_disks = dl->dl_nbiosdisks;
 		if (num_bios_disks > MAX_BIOS_DISKS)
 			num_bios_disks = MAX_BIOS_DISKS;
 	} else
 #endif
 		num_bios_disks = MAX_BIOS_DISKS;
 	printf("\nBoot selector configuration:\n");
 	/* The timeout value is in ticks, ~18.2 Hz. Avoid using floats.
 	 * Ticks are nearly 64k/3600 - so our long timers are sligtly out!
 	 * Newer bootcode always waits for 1 tick, so treats 0xffff
 	 * as wait forever.
 	 */
 	tmo = le16toh(mbs->mbrbs_timeo);
 	tmo = tmo == 0xffff ? -1 : (10 * tmo + 9) / 182;
 	tmo = decimal("Timeout value (0 to 3600 seconds, -1 => never)",
 			tmo, 0, -1, 3600);
 	mbs->mbrbs_timeo = htole16(tmo == -1 ? 0xffff : (tmo * 182) / 10);
 	off = calloc(1 + MBR_PART_COUNT + ext.num_ptn + num_bios_disks, sizeof *off);
 	if (off == NULL)
 		err(1, "Malloc failed");
 	printf("Select the default boot option. Options are:\n\n");
 	item = 0;
 	opt = 0;
 	off[opt] = DEFAULT_ACTIVE;
 	printf("%d: The first active partition\n", opt);
 	for (i = 0; i < MBR_PART_COUNT; i++) {
 		if (mboot.mbr_parts[i].mbrp_type == 0)
 			continue;
 		if (mbs->mbrbs_nametab[i][0] == 0)
 			continue;
 		printf("%d: %s\n", ++opt, &mbs->mbrbs_nametab[i][0]);
 		off[opt] = le32toh(mboot.mbr_parts[i].mbrp_start);
 		if (off[opt] == default_ptn)
 			item = opt;
+	}
 	if (mbs->mbrbs_flags & MBR_BS_EXTLBA) {
 		for (i = 0; i < ext.num_ptn; i++) {
 			if (ext.ptn[i].mbr_parts[0].mbrp_type == 0)
 				continue;
 			if (ext.ptn[i].mbr_bootsel.mbrbs_nametab[0][0] == 0)
 				continue;
 			printf("%d: %s\n",
 			    ++opt, ext.ptn[i].mbr_bootsel.mbrbs_nametab[0]);
 			off[opt] = ext_offset(i) +
 			    le32toh(ext.ptn[i].mbr_parts[0].mbrp_start);
 			if (off[opt] == default_ptn)
 				item = opt;
+		}
+	}
 	for (i = 0; i < num_bios_disks; i++) {
 		printf("%d: Harddisk %d\n", ++opt, i);
 		off[opt] = DEFAULT_DISK(i);
 		if (DEFAULT_DISK(i) == default_ptn)
 			item = opt;
+	}
 	item = decimal("Default boot option", item, 0, 0, opt);
 	default_ptn = off[item];
 	free(off);
 	return default_ptn;
+}
 #endif /* BOOTSEL */
 /* Prerequisite: the disklabel parameters and master boot record must
  *		 have been read (i.e. dos_* and mboot are meaningful).
  * Specification: modifies dos_cylinders, dos_heads, dos_sectors, and
  *		  dos_cylindersectors to be consistent with what the
  *		  partition table is using, if we can find a geometry
  *		  which is consistent with all partition table entries.
  *		  We may get the number of cylinders slightly wrong (in
  *		  the conservative direction).  The idea is to be able
  *		  to create a NetBSD partition on a disk we don't know
  *		  the translated geometry of.
  * This routine is only used for non-x86 systems or when we fail to
  * get the BIOS geometry from the kernel.
  */
 static void
 intuit_translated_geometry(void)
+{
 	uint32_t xcylinders;
 	int xheads = -1, xsectors = -1, i, j;
 	unsigned int c1, h1, s1, c2, h2, s2;
 	unsigned long a1, a2;
 	uint64_t num, denom;
 	/*
 	 * The physical parameters may be invalid as bios geometry.
 	 * If we cannot determine the actual bios geometry, we are
 	 * better off picking a likely 'faked' geometry than leaving
 	 * the invalid physical one.
 	 */
 	if (dos_cylinders > MAXCYL || dos_heads > MAXHEAD ||
 	    dos_sectors > MAXSECTOR) {
 		h1 = MAXHEAD - 1;
 		c1 = MAXCYL - 1;
 #if defined(USE_DISKLIST)
 		if (dl != NULL) {
 			/* BIOS may use 256 heads or 1024 cylinders */
 			for (i = 0; i < dl->dl_nbiosdisks; i++) {
 				if (h1 < (unsigned int)dl->dl_biosdisks[i].bi_head)
 					h1 = dl->dl_biosdisks[i].bi_head;
 				if (c1 < (unsigned int)dl->dl_biosdisks[i].bi_cyl)
 					c1 = dl->dl_biosdisks[i].bi_cyl;
+			}
+		}