 @@ -1,14 +1,14 @@
-/*	$NetBSD: fdisk.c,v 1.131 2011/05/08 14:22:16 pgoyette Exp $ */
+/*	$NetBSD: fdisk.c,v 1.132 2011/08/27 17:16:01 joerg 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"
 @@ -29,27 +29,27 @@
 /*
  * 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.131 2011/05/08 14:22:16 pgoyette Exp $");
+__RCSID("$NetBSD: fdisk.c,v 1.132 2011/08/27 17:16:01 joerg 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>
 @@ -130,34 +130,34 @@ __RCSID("$NetBSD: fdisk.c,v 1.131 2011/0
 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];
-const char *disk = _PATH_DEFDISK;
+static const char *disk = _PATH_DEFDISK;
-struct disklabel disklabel;		/* disk parameters */
+static struct disklabel disklabel;		/* disk parameters */
-struct mbr_sector mboot;
+static struct mbr_sector mboot;
-const char *boot_dir = DEFAULT_BOOTDIR;
+static const char *boot_dir = DEFAULT_BOOTDIR;
-char *boot_path = 0;			/* name of file we actually opened */
+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'
 @@ -181,137 +181,137 @@ char *boot_path = 0;			/* name of file w
+ *
  * 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 */
-unsigned int cylinders, sectors, heads;
+static unsigned int cylinders, sectors, heads;
-daddr_t disksectors;
+static daddr_t disksectors;
 #define cylindersectors (heads * sectors)
 /* Geometry from the BIOS */
-unsigned int dos_cylinders;
+static unsigned int dos_cylinders;
-unsigned int dos_heads;
+static unsigned int dos_heads;
-unsigned int dos_sectors;
+static unsigned int dos_sectors;
-daddr_t dos_disksectors;
+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
-int partition = -1;
+static int partition = -1;
 /* Alignment of partition, and offset if first sector unusable */
-unsigned int ptn_alignment;	/* default dos_cylindersectors */
+static unsigned int ptn_alignment;	/* default dos_cylindersectors */
-unsigned int ptn_0_offset;	/* default dos_sectors */
+static unsigned int ptn_0_offset;	/* default dos_sectors */
-int fd = -1, wfd = -1, *rfd = &fd;
+static int fd = -1, wfd = -1, *rfd = &fd;
-char *disk_file = NULL;
+static char *disk_file = NULL;
-char *disk_type = NULL;
+static char *disk_type = NULL;
-int a_flag;		/* set active partition */
+static int a_flag;		/* set active partition */
-int i_flag;		/* init bootcode */
+static int i_flag;		/* init bootcode */
-int u_flag;		/* update partition data */
+static int u_flag;		/* update partition data */
-int v_flag;		/* more verbose */
+static int v_flag;		/* more verbose */
-int sh_flag;		/* Output data as shell defines */
+static int sh_flag;		/* Output data as shell defines */
-int f_flag;		/* force --not interactive */
+static int f_flag;		/* force --not interactive */
-int s_flag;		/* set id,offset,size */
+static int s_flag;		/* set id,offset,size */
-int b_flag;		/* Set cyl, heads, secs (as c/h/s) */
+static int b_flag;		/* Set cyl, heads, secs (as c/h/s) */
-int B_flag;		/* Edit/install bootselect code */
+static int B_flag;		/* Edit/install bootselect code */
-int E_flag;		/* extended partition number */
+static int E_flag;		/* extended partition number */
-int b_cyl, b_head, b_sec;  /* b_flag values. */
+static int b_cyl, b_head, b_sec;  /* b_flag values. */
 #if !HAVE_NBTOOL_CONFIG_H
-int F_flag = 0;
+static int F_flag = 0;
 #else
 /* Tool - force 'file' mode to avoid unsupported functions and ioctls */
-int F_flag = 1;
+static int F_flag = 1;
 #endif
-struct gpt_hdr gpt1, gpt2;	/* GUID partition tables */
+static struct gpt_hdr gpt1, gpt2;	/* GUID partition tables */
-struct mbr_sector bootcode[8192 / sizeof (struct mbr_sector)];
+static struct mbr_sector bootcode[8192 / sizeof (struct mbr_sector)];
-int bootsize;		/* actual size of bootcode */
+static int bootsize;		/* actual size of bootcode */
-int boot_installed;	/* 1 if we've copied code into the mbr */
+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
-struct disklist *dl;
+static struct disklist *dl;
 #endif
 #define KNOWN_SYSIDS	(sizeof(mbr_ptypes)/sizeof(mbr_ptypes[0]))
-void	usage(void);
+__dead static void	usage(void);
-void	print_s0(int);
+static void	print_s0(int);
-void	print_part(struct mbr_sector *, int, daddr_t);
+static void	print_part(struct mbr_sector *, int, daddr_t);
-void	print_mbr_partition(struct mbr_sector *, int, daddr_t, daddr_t, int);
+static void	print_mbr_partition(struct mbr_sector *, int, daddr_t, daddr_t, int);
-void	print_pbr(daddr_t, int, uint8_t);
+static void	print_pbr(daddr_t, int, uint8_t);
-int	is_all_zero(const unsigned char *, size_t);
+static int	is_all_zero(const unsigned char *, size_t);
-void	printvis(int, const char *, const char *, size_t);
+static void	printvis(int, const char *, const char *, size_t);
-int	read_boot(const char *, void *, size_t, int);
+static int	read_boot(const char *, void *, size_t, int);
-void	init_sector0(int);
+static void	init_sector0(int);
-void	intuit_translated_geometry(void);
+static void	intuit_translated_geometry(void);
-void	get_bios_geometry(void);
+static void	get_bios_geometry(void);
-void	get_extended_ptn(void);
+static void	get_extended_ptn(void);
-static void get_ptn_alignmemt(void);
+static static void get_ptn_alignmemt(void);
 #if defined(USE_DISKLIST)
-void	get_diskname(const char *, char *, size_t);
+static void	get_diskname(const char *, char *, size_t);
 #endif
-int	change_part(int, int, int, daddr_t, daddr_t, char *);
+static int	change_part(int, int, int, daddr_t, daddr_t, char *);
-void	print_geometry(void);
+static void	print_geometry(void);
-int	first_active(void);
+static int	first_active(void);
-void	change_active(int);
+static void	change_active(int);
-void	change_bios_geometry(void);
+static void	change_bios_geometry(void);
-void	dos(int, unsigned char *, unsigned char *, unsigned char *);
+static void	dos(int, unsigned char *, unsigned char *, unsigned char *);
-int	open_disk(int);
+static int	open_disk(int);
-int	read_disk(daddr_t, void *);
+static int	read_disk(daddr_t, void *);
-int	write_disk(daddr_t, void *);
+static int	write_disk(daddr_t, void *);
-int	get_params(void);
+static int	get_params(void);
-int	read_s0(daddr_t, struct mbr_sector *);
+static int	read_s0(daddr_t, struct mbr_sector *);
-int	write_mbr(void);
+static int	write_mbr(void);
-int	read_gpt(daddr_t, struct gpt_hdr *);
+static int	read_gpt(daddr_t, struct gpt_hdr *);
-int	delete_gpt(struct gpt_hdr *);
+static int	delete_gpt(struct gpt_hdr *);
-int	yesno(const char *, ...);
+static int	yesno(const char *, ...);
-int64_t	decimal(const char *, int64_t, int, int64_t, int64_t);
+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 */
-void	string(const char *, int, char *);
+static void	string(const char *, int, char *);
-int	ptn_id(const char *, int *);
+static int	ptn_id(const char *, int *);
-int	type_match(const void *, const void *);
+static int	type_match(const void *, const void *);
-const char *get_type(int);
+static const char *get_type(int);
-int	get_mapping(int, unsigned int *, unsigned int *, unsigned int *, unsigned long *);
+static int	get_mapping(int, unsigned int *, unsigned int *, unsigned int *, unsigned long *);
 #ifdef BOOTSEL
-daddr_t	configure_bootsel(daddr_t);
+static daddr_t	configure_bootsel(daddr_t);
-void	install_bootsel(int);
+static void	install_bootsel(int);
-daddr_t	get_default_boot(void);
+static daddr_t	get_default_boot(void);
-void	set_default_boot(daddr_t);
+static void	set_default_boot(daddr_t);
 #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 ||
 @@ -585,27 +585,27 @@ main(int argc, char *argv[])
+			}
 		} 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);
+}
-void
+static void
 usage(void)
+{
 	int indent = 7 + (int)strlen(getprogname()) + 1;
 	(void)fprintf(stderr, "usage: %s [-afiluvBS] "
 		"[-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"
 @@ -622,27 +622,27 @@ usage(void)
 	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;
+}
-void
+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) {
 @@ -698,27 +698,27 @@ print_s0(int which)
 		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);
+	}
+}
-void
+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;
 @@ -758,27 +758,27 @@ pr_cyls(daddr_t sector, int is_end)
 	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);
+}
-void
+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;
 @@ -858,69 +858,69 @@ print_mbr_partition(struct mbr_sector *b
 	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 */
-void
+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 */
-int
+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.
  */
-void
+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")); \
 @@ -981,27 +981,27 @@ print_pbr(daddr_t sector, int indent, ui
 			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
+}
-int
+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");
 @@ -1035,27 +1035,27 @@ read_boot(const char *name, void *buf, s
 	close(bfd);
 	ret = (ret + 0x1ff) & ~0x1ff;
 	return ret;
     fail:
 	if (bfd >= 0)
 		close(bfd);
 	if (err_exit)
 		exit(1);
 	return 0;
+}
-void
+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)
 @@ -1065,27 +1065,27 @@ init_sector0(int zappart)
 	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]));
+}
-void
+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;
 	/*
 @@ -1125,29 +1125,29 @@ get_extended_ptn(void)
 			/* 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)
-void
+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;
+	}
 @@ -1200,27 +1200,27 @@ get_ptn_alignmemt(void)
 				/* 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;
+		}
+	}
+}
-void
+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;
 @@ -1253,27 +1253,27 @@ get_bios_geometry(void)
 			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
-daddr_t
+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 */
 @@ -1307,27 +1307,27 @@ get_default_boot(void)
 	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;
+}
-void
+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 */
 @@ -1363,27 +1363,27 @@ set_default_boot(daddr_t default_ptn)
 			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];
+}
-void
+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;
 @@ -1467,27 +1467,27 @@ install_bootsel(int needed)
 				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;
+}
-daddr_t
+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;
 @@ -1560,27 +1560,27 @@ configure_bootsel(daddr_t default_ptn)
 /* 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.
  */
-void
+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.
 @@ -1668,27 +1668,27 @@ intuit_translated_geometry(void)
 	else
 		dos_cylinders = xcylinders;
 	dos_heads = xheads;
 	dos_sectors = xsectors;
+}
 /*
  * For the purposes of intuit_translated_geometry(), treat the partition
  * table as a list of eight mapping between (cylinder, head, sector)
  * triplets and absolute sectors.  Get the relevant geometry triplet and
  * absolute sectors for a given entry, or return -1 if it isn't present.
  * Note: for simplicity, the returned sector is 0-based.
  */
-int
+static int
 get_mapping(int i, unsigned int *cylinder, unsigned int *head, unsigned int *sector,
     unsigned long *absolute)
+{
 	struct mbr_partition *part = &mboot.mbr_parts[i / 2];
 	if (part->mbrp_type == 0)
 		return -1;
 	if (i % 2 == 0) {
 		*cylinder = MBR_PCYL(part->mbrp_scyl, part->mbrp_ssect);
 		*head = part->mbrp_shd;
 		*sector = MBR_PSECT(part->mbrp_ssect);
 		*absolute = le32toh(part->mbrp_start);
 	} else {
 @@ -1942,27 +1942,27 @@ check_ext_overlap(int part, int sysid, d
 				return "Overlaps another extended partition";
 			if (fix) {
 				if (part == -1)
 					delete_ext_ptn(p);
 				else
 					/* must not change numbering yet */
 					ext.ptn[p].mbr_parts[0].mbrp_type = 0;
+			}
+		}
+	}
 	return 0;
+}
-int
+static int
 change_part(int extended, int part, int sysid, daddr_t start, daddr_t size,
 	char *bootmenu)
+{
 	struct mbr_partition *partp;
 	struct mbr_sector *boot;
 	daddr_t offset;
 	const char *e;
 	int upart = part;
 	int p;
 	int fl;
 	daddr_t n_s, n_e;
 	const char *errtext;
 #ifdef BOOTSEL
 @@ -2275,27 +2275,27 @@ change_part(int extended, int part, int
 	/* If we had to mark an extended partition as deleted because
 	 * another request would have overlapped it, now is the time
 	 * to do the actual delete.
 	 */
 	if (extended && f_flag) {
 		for (p = ext.num_ptn; --p >= 0;)
 			if (ext.ptn[p].mbr_parts[0].mbrp_type == 0)
 				delete_ext_ptn(p);
+	}
 	return 1;
+}
-void
+static void
 print_geometry(void)
+{
 	if (sh_flag) {
 		printf("DISK=%s\n", disk);
 		printf("DLCYL=%d\nDLHEAD=%d\nDLSEC=%d\nDLSIZE=%"PRIdaddr"\n",
 			cylinders, heads, sectors, disksectors);
 		printf("BCYL=%d\nBHEAD=%d\nBSEC=%d\nBDLSIZE=%"PRIdaddr"\n",
 			dos_cylinders, dos_heads, dos_sectors, dos_disksectors);
 		printf("NUMEXTPTN=%d\n", ext.num_ptn);
 		return;
+	}
 @@ -2305,39 +2305,39 @@ print_geometry(void)
 	printf("cylinders: %d, heads: %d, sectors/track: %d "
 	    "(%d sectors/cylinder)\ntotal sectors: %"PRIdaddr"\n\n",
 	    cylinders, heads, sectors, cylindersectors, disksectors);
 	printf("BIOS disk geometry:\n");
 	printf("cylinders: %d, heads: %d, sectors/track: %d "
 	    "(%d sectors/cylinder)\ntotal sectors: %"PRIdaddr"\n\n",
 	    dos_cylinders, dos_heads, dos_sectors, dos_cylindersectors,
 	    dos_disksectors);
 	printf("Partitions aligned to %d sector boundaries, offset %d\n\n",
 	    ptn_alignment, ptn_0_offset);
+}
 /* Find the first active partition, else return MBR_PART_COUNT */
-int
+static int
 first_active(void)
+{
 	struct mbr_partition *partp = &mboot.mbr_parts[0];
 	int part;
 	for (part = 0; part < MBR_PART_COUNT; part++)
 		if (partp[part].mbrp_flag & MBR_PFLAG_ACTIVE)
 			return part;
 	return MBR_PART_COUNT;
+}
-void
+static void
 change_active(int which)
+{
 	struct mbr_partition *partp;
 	int part;
 	int active = MBR_PART_COUNT;
 	partp = &mboot.mbr_parts[0];
 	if (a_flag && which != -1)
 		active = which;
 	else
 		active = first_active();
 	if (!f_flag) {
 @@ -2350,27 +2350,27 @@ change_active(int which)
 			} while (!yesno("Are you happy with this choice?"));
 		} else
 			return;
 	} else
 		if (active != MBR_PART_COUNT)
 			printf ("Making partition %d active.\n", active);
 	for (part = 0; part < MBR_PART_COUNT; part++)
 		partp[part].mbrp_flag &= ~MBR_PFLAG_ACTIVE;
 	if (active < MBR_PART_COUNT)
 		partp[active].mbrp_flag |= MBR_PFLAG_ACTIVE;
+}
-void
+static void
 change_bios_geometry(void)
+{
 	print_geometry();
 	if (!yesno("Do you want to change our idea of what BIOS thinks?"))
 		return;
 #if defined(USE_DISKLIST)
 	if (dl != NULL) {
 		struct biosdisk_info *bip;
 		int i;
 		for (i = 0; i < dl->dl_nbiosdisks; i++) {
 			if (i == 0)
 @@ -2390,46 +2390,46 @@ change_bios_geometry(void)
 					dos_cylinders, 0, 0, MAXCYL);
 		dos_heads = decimal("BIOS's idea of #heads",
 					dos_heads, 0, 0, MAXHEAD);
 		dos_sectors = decimal("BIOS's idea of #sectors",
 					dos_sectors, 0, 1, MAXSECTOR);
 		print_geometry();
 	} while (!yesno("Are you happy with this choice?"));
+}
 /***********************************************\
 * Change real numbers into strange dos numbers	*
 \***********************************************/
-void
+static void
 dos(int sector, unsigned char *cylinderp, unsigned char *headp,
     unsigned char *sectorp)
+{
 	int cylinder, head;
 	cylinder = sector / dos_cylindersectors;
 	sector -= cylinder * dos_cylindersectors;
 	head = sector / dos_sectors;
 	sector -= head * dos_sectors;
 	if (cylinder > 1023)
 		cylinder = 1023;
 	*cylinderp = DOSCYL(cylinder);
 	*headp = head;
 	*sectorp = DOSSECT(sector + 1, cylinder);
+}
-int
+static int
 open_disk(int update)
+{
 	static char namebuf[MAXPATHLEN + 1];
 	int flags = update && disk_file == NULL ? O_RDWR : O_RDONLY;
 	if (!F_flag) {
 		fd = opendisk(disk, flags, namebuf, sizeof(namebuf), 0);
 		if (fd < 0) {
 			if (errno == ENODEV)
 				warnx("%s is not a character device", namebuf);
 			else
 				warn("cannot opendisk %s", namebuf);
 			return (-1);
 @@ -2452,61 +2452,61 @@ open_disk(int update)
 		/* for testing: read/write data from a disk file */
 		wfd = open(disk_file, update ? O_RDWR|O_CREAT : O_RDONLY, 0777);
 		if (wfd == -1) {
 			warn("%s", disk_file);
 			close(fd);
 			fd = -1;
 			return -1;
+		}
 	} else
 		wfd = fd;
 	return (0);
+}
-int
+static int
 read_disk(daddr_t sector, void *buf)
+{
 	if (*rfd == -1)
 		errx(1, "read_disk(); fd == -1");
 	if (lseek(*rfd, sector * (off_t)512, 0) == -1)
 		return (-1);
 	return (read(*rfd, buf, 512));
+}
-int
+static int
 write_disk(daddr_t sector, void *buf)
+{
 	if (wfd == -1)
 		errx(1, "write_disk(); wfd == -1");
 	if (lseek(wfd, sector * (off_t)512, 0) == -1)
 		return (-1);
 	return (write(wfd, buf, 512));
+}
 static void
 guess_geometry(daddr_t _sectors)
+{
 	dos_sectors = MAXSECTOR;
 	dos_heads = MAXHEAD - 1;	/* some BIOS might use 256 */
 	dos_cylinders = _sectors / (MAXSECTOR * (MAXHEAD - 1));
 	if (dos_cylinders < 1)
 		dos_cylinders = 1;
 	else if (dos_cylinders > MAXCYL - 1)
 		dos_cylinders = MAXCYL - 1;
+}
-int
+static int
 get_params(void)
+{
 	if (disk_type != NULL) {
 		struct disklabel *tmplabel;
 		if ((tmplabel = getdiskbyname(disk_type)) == NULL) {
 			warn("bad disktype");
 			return (-1);
+		}
 		disklabel = *tmplabel;
 	} else if (F_flag) {
 		struct stat st;
 		if (fstat(fd, &st) == -1) {
 @@ -2596,27 +2596,27 @@ validate_bootsel(struct mbr_bootsel *mbs
 	/* Check the menu strings are printable */
 	/* Unfortunately they aren't zero filled... */
 	for (i = 0; i < sizeof(mbs->mbrbs_nametab); i++) {
 		int c = (uint8_t)mbs->mbrbs_nametab[0][i];
 		if (c == 0 || isprint(c))
 			continue;
 		return 3;
+	}
 	return 0;
+}
 #endif
-int
+static int
 read_s0(daddr_t offset, struct mbr_sector *boot)
+{
 	const char *tabletype = offset ? "extended" : "primary";
 #ifdef BOOTSEL
 	static int reported;
 #endif
 	if (read_disk(offset, boot) == -1) {
 		warn("Can't read %s partition table", tabletype);
 		return -1;
+	}
 	if (boot->mbr_magic != LE_MBR_MAGIC) {
 		warnx("%s partition table invalid, "
 @@ -2659,27 +2659,27 @@ read_s0(daddr_t offset, struct mbr_secto
 		else if (mboot.mbr_parts[id].mbrp_type != 0)
 			id = le32toh(boot->mbr_parts[id].mbrp_start);
 		else
 			id = DEFAULT_ACTIVE;
 		boot->mbr_bootsel.mbrbs_defkey = id;
+	}
 	boot->mbr_bootsel_magic = LE_MBR_BS_MAGIC;
 		/* highlight that new bootsel code is necessary */
 	boot->mbr_bootsel.mbrbs_flags &= ~MBR_BS_NEWMBR;
 #endif /* BOOTSEL */
 	return 0;
+}
-int
+static int
 write_mbr(void)
+{
 	int flag, i;
 	daddr_t offset;
 	int rval = -1;
 	/*
 	 * write enable label sector before write (if necessary),
 	 * disable after writing.
 	 * needed if the disklabel protected area also protects
 	 * sector 0. (e.g. empty disk)
 	 */
 	flag = 1;
 @@ -2700,46 +2700,46 @@ write_mbr(void)
 			warn("Can't write %dth extended partition", i);
 			goto protect_label;
+		}
 		offset = le32toh(ext.ptn[i].mbr_parts[1].mbrp_start);
+	}
 	rval = 0;
     protect_label:
 	flag = 0;
 	if (wfd == fd && F_flag == 0 && ioctl(wfd, DIOCWLABEL, &flag) < 0)
 		warn("DIOCWLABEL");
 	return rval;
+}
-int
+static int
 yesno(const char *str, ...)
+{
 	int ch, first;
 	va_list ap;
 	va_start(ap, str);
 	vprintf(str, ap);
 	printf(" [n] ");
 	first = ch = getchar();
 	while (ch != '\n' && ch != EOF)
 		ch = getchar();
 	if (ch == EOF)
 		errx(1, "EOF");
 	return (first == 'y' || first == 'Y');
+}
-int64_t
+static int64_t
 decimal(const char *prompt, int64_t dflt, int flags, int64_t minval, int64_t maxval)
+{
 	int64_t acc = 0;
 	int valid;
 	int len;
 	char *cp;
 	for (;;) {
 		if (flags & DEC_SEC) {
 			printf("%s: [%" PRId64 "..%" PRId64 "cyl default: %" PRId64 ", %" PRId64 "cyl, %uMB] ",
 			    prompt, SEC_TO_CYL(minval), SEC_TO_CYL(maxval),
 			    dflt, SEC_TO_CYL(dflt), SEC_TO_MB(dflt));
 		} else
 @@ -2793,27 +2793,27 @@ decimal(const char *prompt, int64_t dflt
 		if (*cp != '\n') {
 			lbuf[strlen(lbuf) - 1] = 0;
 			printf("%s is not a valid %s number.\n", lbuf,
 			    flags & DEC_SEC ? "sector" : "decimal");
 			continue;
+		}
 		if (acc >= minval && acc <= maxval)
 			return acc;
 		printf("%" PRId64 " is not between %" PRId64 " and %" PRId64 ".\n", acc, minval, maxval);
+	}
+}
-int
+static int
 ptn_id(const char *prompt, int *extended)
+{
 	unsigned int acc = 0;
 	char *cp;
 	for (;; printf("%s is not a valid partition number.\n", lbuf)) {
 		printf("%s: [none] ", prompt);
 		if (!fgets(lbuf, LBUF, stdin))
 			errx(1, "EOF");
 		lbuf[strlen(lbuf)-1] = '\0';
 		cp = lbuf;
 @@ -2829,79 +2829,79 @@ ptn_id(const char *prompt, int *extended
 		acc = strtoul(cp, &cp, 10);
 		cp += strspn(cp, " \t");
 		if (*cp != '\0')
 			continue;
 		if (*extended || acc < MBR_PART_COUNT)
 			return acc;
+	}
+}
 #ifdef BOOTSEL
-void
+static void
 string(const char *prompt, int length, char *buf)
+{
 	int len;
 	for (;;) {
 		printf("%s: [%.*s] ", prompt, length, buf);
 		if (!fgets(lbuf, LBUF, stdin))
 			errx(1, "EOF");
 		len = strlen(lbuf);
 		if (len <= 1)
 			/* unchanged if just <enter> */
 			return;
 		/* now strip trailing spaces, <space><enter> deletes string */
 		do
 			lbuf[--len] = 0;
 		while (len != 0 && lbuf[len - 1] == ' ');
 		if (len < length)
 			break;
 		printf("'%s' is longer than %d characters.\n",
 		    lbuf, length - 1);
+	}
 	strncpy(buf, lbuf, length);
+}
 #endif
-int
+static int
 type_match(const void *key, const void *item)
+{
 	const int *idp = key;
 	const struct mbr_ptype *ptr = item;
 	if (*idp < ptr->id)
 		return (-1);
 	if (*idp > ptr->id)
 		return (1);
 	return (0);
+}
-const char *
+static const char *
 get_type(int type)
+{
 	struct mbr_ptype *ptr;
 	ptr = bsearch(&type, mbr_ptypes, KNOWN_SYSIDS,
 	    sizeof(mbr_ptypes[0]), type_match);
 	if (ptr == 0)
 		return ("unknown");
 	return (ptr->name);
+}
-int
+static int
 read_gpt(daddr_t offset, struct gpt_hdr *gptp)
+{
 	char buf[512];
 	struct gpt_hdr *hdr = (void *)buf;
 	const char *tabletype = GPT_TYPE(offset);
 	if (read_disk(offset, buf) == -1) {
 		warn("Can't read %s GPT header", tabletype);
 		return -1;
+	}
 	(void)memcpy(gptp, buf, GPT_HDR_SIZE);
 	/* GPT CRC should be calculated with CRC field preset to zero */
 @@ -2913,27 +2913,27 @@ read_gpt(daddr_t offset, struct gpt_hdr
 		/* not a GPT */
 		(void)memset(gptp, 0, GPT_HDR_SIZE);
+	}
 	if (v_flag && gptp->hdr_size != 0) {
 		printf("Found %s GPT header CRC %"PRIu32" "
 		    "at sector %"PRIdaddr", backup at %"PRIdaddr"\n",
 		    tabletype, gptp->hdr_crc_self, offset, gptp->hdr_lba_alt);
+	}
 	return gptp->hdr_size;
+}
-int
+static int
 delete_gpt(struct gpt_hdr *gptp)
+{
 	char buf[512];
 	struct gpt_hdr *hdr = (void *)buf;
 	if (gptp->hdr_size == 0)
 		return 0;
 	/* don't accidently overwrite something important */
 	if (gptp->hdr_lba_self != GPT_HDR_BLKNO &&
 	    gptp->hdr_lba_self != (uint64_t)disksectors - 1) {
 		warnx("given GPT header location doesn't seem correct");
 		return -1;