 @@ -1,960 +1,960 @@
-/*	$NetBSD: defs.h,v 1.57 2020/03/16 06:48:17 martin Exp $	*/
+/*	$NetBSD: defs.h,v 1.58 2020/04/22 23:43:12 joerg Exp $	*/
 /*
  * Copyright 1997 Piermont Information Systems Inc.
  * All rights reserved.
+ *
  * Written by Philip A. Nelson for Piermont Information Systems Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of Piermont Information Systems Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 #ifndef _DEFS_H_
 #define _DEFS_H_
 /* defs.h -- definitions for use in the sysinst program. */
 /* System includes needed for this. */
 #include <sys/queue.h>
 #include <sys/types.h>
 #include <sys/disk.h>
 #include <uuid.h>
 const char *getfslabelname(uint, uint);
 #include "msg_defs.h"
 #include "menu_defs.h"
 #include "partitions.h"
 #define min(a,b)	((a) < (b) ? (a) : (b))
 #define max(a,b)	((a) > (b) ? (a) : (b))
 /* constants */
 #define MEG (1024UL * 1024UL)
 #define GIG (1024UL * MEG)
 #define STRSIZE		255
 #define	MENUSTRSIZE	80
 #define SSTRSIZE	30
 /* these are used for different alignment defaults */
 #define	HUGE_DISK_SIZE	(daddr_t)(128 * (GIG / 512))
 #define	TINY_DISK_SIZE	(daddr_t)(1800 * (MEG / 512))
 /*
  * if a system does not have more ram (in MB) than this, swap will be enabled
  * very early (as soon as the swap partition has been created)
  */
 #define	TINY_RAM_SIZE		32
 /*
  * if a system has less ram (in MB) than this, we will not create a
  * tmpfs /tmp by default (to workaround PR misc/54886)
  */
 #define	SMALL_RAM_SIZE		384
 /* helper macros to create unique internal error messages */
 #define STR_NO(STR)	#STR
 #define	TO_STR(NO)	STR_NO(NO)
 #define	INTERNAL_ERROR __FILE__ ":" TO_STR(__LINE__) ": internal error"
 /* For run.c: collect() */
 #define T_FILE		0
 #define T_OUTPUT	1
 /* Some install status/response values */
 #define	SET_OK		0		/* Set extracted */
 #define	SET_RETRY	1		/* Retry */
 #define	SET_SKIP	2		/* Skip this set */
 #define	SET_SKIP_GROUP	3		/* Skip this set and rest of group */
 #define	SET_ABANDON	4		/* Abandon installation */
 #define	SET_CONTINUE	5		/* Continue (copy from floppy loop) */
 /* run_prog flags */
 #define RUN_DISPLAY	0x0001		/* Display program output */
 #define RUN_FATAL	0x0002		/* errors are fatal */
 #define RUN_CHROOT	0x0004		/* chroot to target disk */
 #define RUN_FULLSCREEN	0x0008		/* fullscreen (use with RUN_DISPLAY) */
 #define RUN_SILENT	0x0010		/* Do not show output */
 #define RUN_ERROR_OK	0x0040		/* Don't wait for error confirmation */
 #define RUN_PROGRESS	0x0080		/* Output is just progess test */
 #define RUN_NO_CLEAR	0x0100		/* Leave program output after error */
 #define RUN_XFER_DIR	0x0200		/* cd to xfer_dir in child */
 /* for bsddisklabel.c */
 enum layout_type { LY_KEEPEXISTING, LY_SETSIZES, LY_USEDEFAULT, LY_USEFULL };
 enum setup_type { SY_NEWRAID, SY_NEWCGD, SY_NEWLVM };
 /* Installation sets */
 enum {
     SET_NONE,
     SET_KERNEL_FIRST,
     SET_KERNEL_1,	/* Usually GENERIC */
     SET_KERNEL_2,	/* MD kernel... */
     SET_KERNEL_3,	/* MD kernel... */
     SET_KERNEL_4,	/* MD kernel... */
     SET_KERNEL_5,	/* MD kernel... */
     SET_KERNEL_6,	/* MD kernel... */
     SET_KERNEL_7,	/* MD kernel... */
     SET_KERNEL_8,	/* MD kernel... */
     SET_KERNEL_9,	/* MD kernel... */
     SET_KERNEL_LAST,	/* allow 9 kernels */
     /* System sets */
     SET_BASE,		/* base */
     SET_ETC,		/* /etc */
     SET_COMPILER,	/* compiler tools */
     SET_GAMES,		/* text games */
     SET_MAN_PAGES,	/* online manual pages */
     SET_MISC,		/* miscellaneuous */
     SET_MODULES,	/* kernel modules */
     SET_RESCUE,		/* /rescue recovery tools */
     SET_TESTS,		/* tests */
     SET_TEXT_TOOLS,	/* text processing tools */
     /* X11 sets */
     SET_X11_FIRST,
     SET_X11_BASE,	/* X11 base and clients */
     SET_X11_FONTS,	/* X11 fonts */
     SET_X11_SERVERS,	/* X11 servers */
     SET_X11_PROG,	/* X11 programming */
     SET_X11_ETC,	/* X11 config */
     SET_X11_LAST,
     /* Machine dependent sets */
     SET_MD_1,		/* Machine dependent set */
     SET_MD_2,		/* Machine dependent set */
     SET_MD_3,		/* Machine dependent set */
     SET_MD_4,		/* Machine dependent set */
     /* Source sets */
     SET_SYSSRC,
     SET_SRC,
     SET_SHARESRC,
     SET_GNUSRC,
     SET_XSRC,
     /* Debug sets */
     SET_DEBUG,
     SET_X11_DEBUG,
     SET_LAST,
     SET_GROUP,		/* Start of submenu */
     SET_GROUP_END,	/* End of submenu */
     SET_PKGSRC,		/* pkgsrc, not counted as regular set */
 };
 /* Initialisers to select sets */
 /* All kernels */
 #define SET_KERNEL SET_KERNEL_1, SET_KERNEL_2, SET_KERNEL_3, SET_KERNEL_4, \
 		    SET_KERNEL_5, SET_KERNEL_6, SET_KERNEL_7, SET_KERNEL_8
 /* Core system sets */
 #define SET_CORE SET_MODULES, SET_BASE, SET_ETC
 /* All system sets */
 #define SET_SYSTEM SET_CORE, SET_COMPILER, SET_GAMES, \
 		    SET_MAN_PAGES, SET_MISC, SET_RESCUE, \
 		    SET_TESTS, SET_TEXT_TOOLS
 /* All X11 sets */
 #define SET_X11_NOSERVERS SET_X11_BASE, SET_X11_FONTS, SET_X11_PROG, SET_X11_ETC
 #define SET_X11 SET_X11_NOSERVERS, SET_X11_SERVERS
 /* All machine dependent sets */
 #define SET_MD SET_MD_1, SET_MD_2, SET_MD_3, SET_MD_4
 /* All source sets */
 #define SET_SOURCE SET_SYSSRC, SET_SRC, SET_SHARESRC, SET_GNUSRC, SET_XSRC
 /* All debug sets */
 #define SET_DEBUGGING SET_DEBUG, SET_X11_DEBUG
 /* Set list flags */
 #define SFLAG_MINIMAL	1
 #define	SFLAG_NOX	2
 /* Round up to the next full cylinder size */
 #define NUMSEC(size, sizemult, cylsize) \
 	((sizemult) == 1 ? (size) : \
 	 roundup((size) * (sizemult), (cylsize)))
 /* What FS type? */
 #define PI_ISBSDFS(PI) (PI_FSTYPE(PI) == FS_BSDLFS || \
 		        PI_FSTYPE(PI) == FS_BSDFFS)
 /*
  * We do not offer CDs or floppies as installation target usually.
  * Architectures might want to undefine if they want to allow
  * these devices or redefine if they have unusual CD device names.
  * Do not define to empty or an empty string, undefine instead.
  */
 #define CD_NAMES "cd*"
 #define FLOPPY_NAMES "fd*"
 /* Types */
 /* pass a void* argument into a menu and also provide a int return value */
 typedef struct arg_rv {
 	void *arg;
 	int rv;
 } arg_rv;
 /*
  * A minimal argument for menus using string replacements
  */
 typedef struct arg_replace {
 	const char **argv;
 	size_t argc;
 } arg_replace;
 /*
  * pass a parameter array (for string replacements) into a menu and provide
  * an integer return value
  */
 typedef struct arg_rep_int {
 	arg_replace args;
 	int rv;
 } arg_rep_int;
 typedef struct distinfo {
 	const char	*name;
 	uint		set;
 	bool		force_tgz;	/* this set is always in .tgz format */
 	const char	*desc;
 	const char	*marker_file;	/* set assumed installed if exists */
 } distinfo;
 #define MOUNTLEN 20
 /*
  * A description of a future partition and its usage.
  * A list of this is the output of the first stage partition
  * editor, before it gets transformed into a concrete partition
  * layout according to the partitioning scheme backend.
  */
 struct part_usage_info {
 	daddr_t	size;			/* thumb guestimate of size,
 					 * [sec if positive, %-of-ram
 					 * if TMPFS and negative]
 					 */
 	daddr_t def_size;		/* default size */
 	daddr_t limit;			/* max size */
 	char 	mount[MOUNTLEN];	/* where will we mount this? */
 	enum part_type type;		/* PT_root/PT_swap/PT_EFI_SYSTEM */
 #define	PUIFLAG_EXTEND		1	/* extend this part if free space
 					 * is available */
 #define	PUIFLAG_ADD_OUTER	2	/* Add this partition to the outer
 					 * partitions (if available) */
 #define	PUIFLG_IS_OUTER		4	/* this is an existing outer one */
 #define	PUIFLG_ADD_INNER	8	/* add outer also to inner */
 #define	PUIFLG_JUST_MOUNTPOINT	16	/* tmpfs of mfs mountpoints */
 #define	PUIFLG_CLONE_PARTS	32	/* clone external partitions */
 	uint flags;
 	struct disk_partitions *parts;	/* Where does this partition live?
 					 * We currently only support
 					 * a single disk, but we plan to
 					 * extend that.
 					 * Use pm->parts to access
 					 * the partitions. */
 	part_id cur_part_id;		/* this may change, but we try to
 					 * fix it up after all changes */
 	daddr_t cur_start;		/* may change during editing, just
 					 * used as a unique identifier */
 	uint32_t cur_flags;		/* PTI_* flags from disk_part_info */
 #define PUIMNT_ASYNC		0x0001	/* mount -o async */
 #define PUIMNT_NOATIME		0x0002	/* mount -o noatime */
 #define PUIMNT_NODEV		0x0004	/* mount -o nodev */
 #define PUIMNT_NODEVMTIME	0x0008	/* mount -o nodevmtime */
 #define PUIMNT_NOEXEC		0x0010	/* mount -o noexec */
 #define PUIMNT_NOSUID		0x0020	/* mount -o nosuid */
 #define PUIMNT_LOG		0x0040	/* mount -o log */
 #define PUIMNT_NOAUTO		0x0080	/* "noauto" fstab flag */
 	unsigned int mountflags;	/* flags for fstab */
 #define PUIINST_NEWFS	0x0001		/* need to 'newfs' partition */
 #define PUIINST_MOUNT	0x0002		/* need to mount partition */
 #define	PUIINST_BOOT	0x0004		/* this is a boot partition */
 	unsigned int instflags;		/* installer handling flags */
 	uint fs_type, fs_version;	/* e.g. FS_LFS, or FS_BSDFS,
 					 * version = 2 for FFSv2 */
 #ifndef	NO_CLONES
 	/*
 	 * Only != NULL when PUIFLG_CLONE_PARTS is set, describes the
 	 * source partitions to clone here.
 	 */
 	struct selected_partitions *clone_src;
 	/*
 	 * If clone_src != NULL, this record corresponds to a single
 	 * selected source partition, if clone_ndx is a valid index in clone_src
 	 * (>= 0 && <= clone_src->num_sel, or all of them if clone_ndx = ~0U.
 	 */
 	size_t clone_ndx;
 #endif
 };
 /*
  * A list of partition suggestions, bundled for editing
  */
 struct partition_usage_set {
 	struct disk_partitions *parts;
 	size_t num;
 	struct part_usage_info *infos;	/* 0 .. num-1 */
 	daddr_t cur_free_space;		/* estimate of free sectors */
 	menu_ent *menu_opts;		/* 0 .. num+N */
 	int menu;			/* the menu to edit this */
 	bool ok;			/* ok to continue (all fit) */
 };
 /*
  * A structure we pass around in menus that edit a single partition out
  * of a partition_usage_set.
  */
 struct single_part_fs_edit {
  	struct partition_usage_set *pset;
 	size_t index, first_custom_attr;
 	part_id id;
 	struct disk_part_info info;	/* current partition data */
 	struct part_usage_info *wanted;	/* points at our edit data */
 	/*
 	 * "Backup" of old data, so we can restore previous values
 	 * ("undo").
 	 */
 	struct part_usage_info old_usage;
 	struct disk_part_info old_info;
 	/* menu return value */
 	int rv;
 };
 /*
  * Description of a full target installation, all partitions and
  * devices (may be accross several struct pm_devs / disks).
  */
 struct install_partition_desc {
 	size_t num;				/* how many entries in infos */
 	struct part_usage_info *infos;		/* individual partitions */
 	bool cur_system;			/* target is the life system */
 };
 /* variables */
-int debug;		/* set by -D option */
+extern int debug;		/* set by -D option */
-char machine[SSTRSIZE];
+extern char machine[SSTRSIZE];
-int ignorerror;
+extern int ignorerror;
-int ttysig_ignore;
+extern int ttysig_ignore;
-pid_t ttysig_forward;
+extern pid_t ttysig_forward;
-uint sizemult;
+extern uint sizemult;
 extern const char *multname;
 extern const char *err_outofmem;
-int partman_go; /* run extended partition manager */
+extern int partman_go; /* run extended partition manager */
 /* logging variables */
-FILE *logfp;
+extern FILE *logfp;
-FILE *script;
+extern FILE *script;
 #define MAX_DISKS 15
-daddr_t root_limit;    /* BIOS (etc) read limit */
+extern daddr_t root_limit;    /* BIOS (etc) read limit */
 enum SHRED_T { SHRED_NONE=0, SHRED_ZEROS, SHRED_RANDOM };
 /* All information that is unique for each drive */
-SLIST_HEAD(pm_head_t, pm_devs) pm_head;
+extern SLIST_HEAD(pm_head_t, pm_devs) pm_head;
 struct pm_devs {
 	/*
 	 * If device is blocked (e.g. part of a raid)
 	 * this is a pointers to the  parent dev
 	 */
 	void *refdev;
 	char diskdev[SSTRSIZE];		/* Actual name of the disk. */
 	char diskdev_descr[STRSIZE];	/* e.g. IDENTIFY result */
 	/*
 	 * What the disk layout should look like.
 	 */
 	struct disk_partitions *parts;
 	/*
 	 * The device does not take a MBR, even if we usually use
 	 * MBR master / disklabel secondary partitioning.
 	 * Used e.g. for raid* pseudo-disks.
 	 */
 	bool no_mbr;	/* userd for raid (etc) */
 	/*
 	 * This device can not be partitioned (in any way).
 	 * Used for wedges (dk*) or LVM devices.
 	 */
 	bool no_part;
 	/*
 	 * This is a pseudo-device representing the currently running
 	 * system (i.e. all mounted file systems).
 	 */
 	bool cur_system;
 	/* Actual values for current disk geometry - set by find_disks() or
 	 *  md_get_info()
 	 */
 	uint sectorsize, dlcyl, dlhead, dlsec, dlcylsize, current_cylsize;
 	/*
 	 * Total size of the disk - in 'sectorsize' units (!)
 	 */
 	daddr_t dlsize;	/* total number of disk sectors */
 	/* Area of disk we can allocate, start and size in sectors. */
 	daddr_t ptstart, ptsize;
 	/* For some bootblocks we need to know the CHS addressable limit */
 	daddr_t max_chs;	/* bcyl * bhead * bsec */
 	/* If we have an MBR boot partition, start and size in sectors */
 	daddr_t bootstart, bootsize;
 	/*
 	 * In extended partitioning: all partitions in parts (number of
 	 * entries is parts->num_part) may actually be mounted (temporarily)
 	 * somewhere, e.g. to access a vnd device on them. This list has
 	 * a pointer to the current mount point (strdup()'d) if mounted,
 	 * or NULL if not.
 	 */
 	char **mounted;
 	bool unsaved;	/* Flag indicating to partman that device need saving */
 	bool found;	/* Flag to delete unplugged and unconfigured devices */
 	int blocked;	/* Device is busy and cannot be changed */
 	SLIST_ENTRY(pm_devs) l;
 };
-struct pm_devs *pm; /* Pointer to current device with which we work */
+extern struct pm_devs *pm; /* Pointer to current device with which we work */
-struct pm_devs *pm_new; /* Pointer for next allocating device in find_disks() */
+extern struct pm_devs *pm_new; /* Pointer for next allocating device in find_disks() */
 /* Generic structure for partman */
 struct part_entry {
 	part_id id;
 	struct disk_partitions *parts;
 	void *dev_ptr;
 	size_t index;	/* e.g. if PM_RAID: this is raids[index] */
 	int dev_ptr_delta;
 	char fullname[SSTRSIZE];
 	enum {PM_DISK=1, PM_PART, PM_SPEC,
 	    PM_RAID, PM_CGD, PM_VND, PM_LVM, PM_LVMLV} type;
 };
 /* Relative file name for storing a distribution. */
-char xfer_dir[STRSIZE];
+extern char xfer_dir[STRSIZE];
-int  clean_xfer_dir;
+extern int  clean_xfer_dir;
 #if !defined(SYSINST_FTP_HOST)
 #define SYSINST_FTP_HOST	"ftp.NetBSD.org"
 #endif
 #if !defined(SYSINST_HTTP_HOST)
 #define SYSINST_HTTP_HOST	"cdn.NetBSD.org"
 #endif
 #if !defined(SYSINST_FTP_DIR)
 #if defined(NETBSD_OFFICIAL_RELEASE)
 #define SYSINST_FTP_DIR		"pub/NetBSD/NetBSD-" REL
 #elif defined(REL_PATH)
 #define SYSINST_FTP_DIR		"pub/NetBSD-daily/" REL_PATH "/latest"
 #else
 #define SYSINST_FTP_DIR		"pub/NetBSD/NetBSD-" REL
 #endif
 #endif
 #if !defined(ARCH_SUBDIR)
 #define	ARCH_SUBDIR	MACH
 #endif
 #if !defined(PKG_ARCH_SUBDIR)
 #define	PKG_ARCH_SUBDIR	MACH
 #endif
 #if !defined(SYSINST_PKG_HOST)
 #define SYSINST_PKG_HOST	"ftp.NetBSD.org"
 #endif
 #if !defined(SYSINST_PKG_HTTP_HOST)
 #define SYSINST_PKG_HTTP_HOST	"cdn.NetBSD.org"
 #endif
 #if !defined(SYSINST_PKG_DIR)
 #define SYSINST_PKG_DIR		"pub/pkgsrc/packages/NetBSD"
 #endif
 #if !defined(PKG_SUBDIR)
 #define	PKG_SUBDIR		REL
 #endif
 #if !defined(SYSINST_PKGSRC_HOST)
 #define SYSINST_PKGSRC_HOST	SYSINST_PKG_HOST
 #endif
 #if !defined(SYSINST_PKGSRC_HTTP_HOST)
 #define SYSINST_PKGSRC_HTTP_HOST	SYSINST_PKG_HTTP_HOST
 #endif
 #ifndef SETS_TAR_SUFF
 #define	SETS_TAR_SUFF	 "tgz"
 #endif
 #ifdef	USING_PAXASTAR
 #define	TAR_EXTRACT_FLAGS	"-xhepf"
 #else
 #define	TAR_EXTRACT_FLAGS	"-xpf"
 #endif
 /* Abs. path we extract binary sets from */
-char ext_dir_bin[STRSIZE];
+extern char ext_dir_bin[STRSIZE];
 /* Abs. path we extract source sets from */
-char ext_dir_src[STRSIZE];
+extern char ext_dir_src[STRSIZE];
 /* Abs. path we extract pkgsrc from */
-char ext_dir_pkgsrc[STRSIZE];
+extern char ext_dir_pkgsrc[STRSIZE];
 /* Place we look for binary sets in all fs types */
-char set_dir_bin[STRSIZE];
+extern char set_dir_bin[STRSIZE];
 /* Place we look for source sets in all fs types */
-char set_dir_src[STRSIZE];
+extern char set_dir_src[STRSIZE];
 /* Place we look for pkgs in all fs types */
-char pkg_dir[STRSIZE];
+extern char pkg_dir[STRSIZE];
 /* Place we look for pkgsrc in all fs types */
-char pkgsrc_dir[STRSIZE];
+extern char pkgsrc_dir[STRSIZE];
 /* User shell */
-const char *ushell;
+extern const char *ushell;
 #define	XFER_FTP	0
 #define	XFER_HTTP	1
 #define	XFER_MAX	XFER_HTTP
 struct ftpinfo {
 	char xfer_host[XFER_MAX+1][STRSIZE];
 	char dir[STRSIZE] ;
 	char user[SSTRSIZE];
 	char pass[STRSIZE];
 	char proxy[STRSIZE];
 	unsigned int xfer;	/* XFER_FTP for "ftp" or XFER_HTTP for "http" */
 };
 /* use the same struct for sets ftp and to build pkgpath */
-struct ftpinfo ftp, pkg, pkgsrc;
+extern struct ftpinfo ftp, pkg, pkgsrc;
-int (*fetch_fn)(const char *);
+extern int (*fetch_fn)(const char *);
-char nfs_host[STRSIZE];
+extern char nfs_host[STRSIZE];
-char nfs_dir[STRSIZE];
+extern char nfs_dir[STRSIZE];
-char cdrom_dev[SSTRSIZE];		/* Typically "cd0a" */
+extern char cdrom_dev[SSTRSIZE];		/* Typically "cd0a" */
-char fd_dev[SSTRSIZE];			/* Typically "/dev/fd0a" */
+extern char fd_dev[SSTRSIZE];			/* Typically "/dev/fd0a" */
-const char *fd_type;			/* "msdos", "ffs" or maybe "ados" */
+extern const char *fd_type;			/* "msdos", "ffs" or maybe "ados" */
-char localfs_dev[SSTRSIZE];
+extern char localfs_dev[SSTRSIZE];
-char localfs_fs[SSTRSIZE];
+extern char localfs_fs[SSTRSIZE];
-char localfs_dir[STRSIZE];
+extern char localfs_dir[STRSIZE];
-char targetroot_mnt[SSTRSIZE];
+extern char targetroot_mnt[SSTRSIZE];
-int  mnt2_mounted;
+extern int  mnt2_mounted;
-char dist_postfix[SSTRSIZE];
+extern char dist_postfix[SSTRSIZE];
-char dist_tgz_postfix[SSTRSIZE];
+extern char dist_tgz_postfix[SSTRSIZE];
 /* needed prototypes */
 void set_menu_numopts(int, int);
 void remove_color_options(void);
 void remove_raid_options(void);
 void remove_lvm_options(void);
 void remove_cgd_options(void);
 /* Machine dependent functions .... */
 void	md_init(void);
 void	md_init_set_status(int); /* SFLAG_foo */
  /* MD functions if user selects install - in order called */
 bool	md_get_info(struct install_partition_desc*);
 bool	md_make_bsd_partitions(struct install_partition_desc*);
 bool	md_check_partitions(struct install_partition_desc*);
 #ifdef HAVE_GPT
 /*
  * New GPT partitions have been written, update bootloader or remember
  * data untill needed in md_post_newfs
  */
 bool	md_gpt_post_write(struct disk_partitions*, part_id root_id,
 	    bool root_is_new, part_id efi_id, bool efi_is_new);
 #endif
 /*
  * md_pre_disklabel and md_post_disklabel may be called
  * multiple times, for each affected device, with the
  * "inner" partitions pointer of the relevant partitions
  * passed.
  */
 bool	md_pre_disklabel(struct install_partition_desc*, struct disk_partitions*);
 bool	md_post_disklabel(struct install_partition_desc*, struct disk_partitions*);
 int	md_pre_mount(struct install_partition_desc*, size_t);
 int	md_post_newfs(struct install_partition_desc*);
 int	md_post_extract(struct install_partition_desc*);
 void	md_cleanup_install(struct install_partition_desc*);
  /* MD functions if user selects upgrade - in order called */
 int	md_pre_update(struct install_partition_desc*);
 int	md_update(struct install_partition_desc*);
 /* Also calls md_post_extract() */
 /* from main.c */
 void	toplevel(void);
 /* from disks.c */
 bool	get_default_cdrom(char *, size_t);
 int	find_disks(const char *, bool);
 bool enumerate_disks(void *state,bool (*func)(void *state, const char *dev));
 bool is_cdrom_device(const char *dev, bool as_target);
 bool is_bootable_device(const char *dev);
 bool is_partitionable_device(const char *dev);
 bool convert_scheme(struct pm_devs *p, bool is_boot_drive, const char **err_msg);
 #ifndef	NO_CLONES
 /* a single partition selected for cloning (etc) */
 struct selected_partition {
 	struct disk_partitions *parts;
 	part_id id;
 };
 struct selected_partitions {
 	struct selected_partition *selection;
 	size_t num_sel;
 	bool with_data;		/* partitions and their data selected */
 	bool free_parts;	/* caller should free parts */
 };
 bool select_partitions(struct selected_partitions *res,
     const struct disk_partitions *ignore);
 daddr_t	selected_parts_size(struct selected_partitions *);
 void	free_selected_partitions(struct selected_partitions *);
 struct clone_target_menu_data {
 	struct partition_usage_set usage;
 	int res;
 };
 int	clone_target_select(menudesc *m, void *arg);
 bool	clone_partition_data(struct disk_partitions *dest_parts, part_id did,
 	struct disk_partitions *src_parts, part_id sid);
 #endif
 struct menudesc;
 void	disp_cur_fspart(int, int);
 int	make_filesystems(struct install_partition_desc *);
 int	make_fstab(struct install_partition_desc *);
 int	mount_disks(struct install_partition_desc *);
 int	set_swap_if_low_ram(struct install_partition_desc *);
 int	set_swap(struct install_partition_desc *);
 int	check_swap(const char *, int);
 char *bootxx_name(struct install_partition_desc *);
 int get_dkwedges(struct dkwedge_info **, const char *);
 /* from disks_lfs.c */
 int	fs_is_lfs(void *);
 /* from label.c */
 /*
  * Bits valid for "flags" in get_last_mounted.
  * Currently we return the real last mount from FFS, the volume label
  * from FAT32, and nothing otherwise. The NTFS support is currently
  * restricted to verify the partition has an NTFS (as some partitioning
  * schemes do not tell NTFS from FAT).
  */
 #define GLM_LIKELY_FFS		1U
 #define	GLM_MAYBE_FAT32		2U
 #define	GLM_MAYBE_NTFS		4U
 /*
  * possible fs_sub_types are currently:
  *  FS_BSDFFS:
  *	0	unknown
  *	1	FFSv1
  *	2	FFSv2
  * FS_MSDOS:
  *	0	unknown
  *	else	MBR_PTYPE_FAT* for the current FAT variant
  * FS_NTFS:
  *	0	unknown
  *	else	MBR_PTYPE_NTFS (if valid NTFS was found)
+ *
  * The fs_type and fs_sub_type pointers may be NULL.
  */
 const char *get_last_mounted(int fd, daddr_t offset, uint *fs_type,
      uint *fs_sub_type, uint flags);
 void	canonicalize_last_mounted(char*);
 int	edit_and_check_label(struct pm_devs *p, struct partition_usage_set *pset, bool install);
 int edit_ptn(menudesc *, void *);
 int checkoverlap(struct disk_partitions *parts);
 daddr_t getpartsize(struct disk_partitions *parts, daddr_t partstart,
     daddr_t defpartsize);
 daddr_t getpartoff(struct disk_partitions *parts, daddr_t defpartstart);
 /* from install.c */
 void	do_install(void);
 /* from factor.c */
 void	factor(long, long *, int, int *);
 /* from fdisk.c */
 void	get_disk_info(char *);
 void	set_disk_info(char *);
 /* from geom.c */
 bool	disk_ioctl(const char *, unsigned long, void *);
 bool	get_wedge_list(const char *, struct dkwedge_list *);
 bool	get_wedge_info(const char *, struct dkwedge_info *);
 bool	get_disk_geom(const char *, struct disk_geom *);
 bool	get_label_geom(const char *, struct disklabel *);
 /* from net.c */
 extern int network_up;
 extern char net_namesvr[STRSIZE];
 int	get_via_ftp(unsigned int);
 int	get_via_nfs(void);
 int	config_network(void);
 void	mnt_net_config(void);
 void	make_url(char *, struct ftpinfo *, const char *);
 int	get_pkgsrc(void);
 const char *url_proto(unsigned int);
 /* From run.c */
 int	collect(int, char **, const char *, ...) __printflike(3, 4);
 int	run_program(int, const char *, ...) __printflike(2, 3);
 void	do_logging(void);
 int	do_system(const char *);
 /* from upgrade.c */
 void	do_upgrade(void);
 void	do_reinstall_sets(void);
 void	restore_etc(void);
 /* from part_edit.c */
 int	err_msg_win(const char*);
 const struct disk_partitioning_scheme *select_part_scheme(struct pm_devs *dev,
     const struct disk_partitioning_scheme *skip, bool bootable,
     const char *title);
 bool	edit_outer_parts(struct disk_partitions*);
 bool	parts_use_wholedisk(struct disk_partitions*,
 	     size_t add_ext_parts, const struct disk_part_info *ext_parts);
 /*
  * Machine dependent partitioning function, only used when
  * innern/outer partitioning schemes are in use - this sets
  * up the outer scheme for maximum NetBSD usage.
  */
 bool	md_parts_use_wholedisk(struct disk_partitions*);
 /* from util.c */
 bool	root_is_read_only(void);
 void	get_ptn_alignment(const struct disk_partitions *parts, daddr_t *align, daddr_t *p0off);
 struct disk_partitions *get_inner_parts(struct disk_partitions *parts);
 char*	str_arg_subst(const char *, size_t, const char **);
 void	msg_display_subst(const char *, size_t, ...);
 void	msg_display_add_subst(const char *, size_t, ...);
 int	ask_yesno(const char *);
 int	ask_noyes(const char *);
 void	hit_enter_to_continue(const char *msg, const char *title);
 /*
  * return value:
  *  0 -> abort
  *  1 -> re-edit
  *  2 -> continue installation
 */
 int	ask_reedit(const struct disk_partitions *);
 int	dir_exists_p(const char *);
 int	file_exists_p(const char *);
 int	file_mode_match(const char *, unsigned int);
 uint64_t	get_ramsize(void);	/* in MB! */
 void	ask_sizemult(int);
 void	run_makedev(void);
 int	boot_media_still_needed(void);
 int	get_via_floppy(void);
 int	get_via_cdrom(void);
 int	get_via_localfs(void);
 int	get_via_localdir(void);
 void	show_cur_distsets(void);
 void	make_ramdisk_dir(const char *);
 void    set_kernel_set(unsigned int);
 void    set_noextract_set(unsigned int);
 unsigned int    get_kernel_set(void);
 unsigned int    set_X11_selected(void);
 int 	get_and_unpack_sets(int, msg, msg, msg);
 int	sanity_check(void);
 int	set_timezone(void);
 void	scripting_fprintf(FILE *, const char *, ...) __printflike(2, 3);
 void	scripting_vfprintf(FILE *, const char *, va_list) __printflike(2, 0);
 void	add_rc_conf(const char *, ...) __printflike(1, 2);
 int	del_rc_conf(const char *);
 void	add_sysctl_conf(const char *, ...) __printflike(1, 2);
 void	enable_rc_conf(void);
 void	set_sizemult(daddr_t, uint bps);
 void	set_default_sizemult(const char *disk, daddr_t unit, uint bps);
 int	check_lfs_progs(void);
 void	init_set_status(int);
 void	customise_sets(void);
 void	umount_mnt2(void);
 int 	set_is_source(const char *);
 const char *set_dir_for_set(const char *);
 const char *ext_dir_for_set(const char *);
 void	replace(const char *, const char *, ...) __printflike(2, 3);
 void	get_tz_default(void);
 distinfo*	get_set_distinfo(int);
 int	extract_file(distinfo *, int);
 int extract_file_to(distinfo *dist, int update, const char *dest_dir,
     const char *extr_pattern, bool do_stats);
 void	do_coloring (unsigned int, unsigned int);
 int set_menu_select(menudesc *, void *);
 const char *safectime(time_t *);
 bool	use_tgz_for_set(const char*);
 const char *set_postfix(const char*);
 bool	usage_set_from_parts(struct partition_usage_set*,
 	    struct disk_partitions*);
 void	free_usage_set(struct partition_usage_set*);
 bool	install_desc_from_parts(struct install_partition_desc *,
 	    struct disk_partitions*);
 void	free_install_desc(struct install_partition_desc*);
 bool	may_swap_if_not_sdmmc(const char*);
 /* from target.c */
 #if defined(DEBUG)  ||	defined(DEBUG_ROOT)
 void	backtowin(void);
 #endif
 bool	is_root_part_mount(const char *);
 const	char *concat_paths(const char *, const char *);
 const	char *target_expand(const char *);
 bool	needs_expanding(const char *, size_t);
 void	make_target_dir(const char *);
 void	append_to_target_file(const char *, const char *);
 void	echo_to_target_file(const char *, const char *);
 void	trunc_target_file(const char *);
 const	char *target_prefix(void);
 int	target_chdir(const char *);
 void	target_chdir_or_die(const char *);
 int	target_already_root(void);
 FILE	*target_fopen(const char *, const char *);
 int	target_collect_file(int, char **, const char *);
 int	is_active_rootpart(const char *, int);
 int	cp_to_target(const char *, const char *);
 void	dup_file_into_target(const char *);
 void	mv_within_target_or_die(const char *, const char *);
 int	cp_within_target(const char *, const char *, int);
 int	target_mount(const char *, const char *, const char *);
 int	target_mount_do(const char *, const char *, const char *);
 int	target_test(unsigned int, const char *);
 int	target_dir_exists_p(const char *);
 int	target_file_exists_p(const char *);
 int	target_symlink_exists_p(const char *);
 void	unwind_mounts(void);
 int	target_mounted(void);
 void	umount_root(void);
 /* from partman.c */
 #ifndef NO_PARTMAN
 int partman(void);
 int pm_getrefdev(struct pm_devs *);
 void update_wedges(const char *);
 void pm_destroy_all(void);
 #else
 static inline int partman(void) { return -1; }
 static inline int pm_getrefdev(struct pm_devs *x __unused) { return -1; }
 #define update_wedges(x) __nothing
 #endif
 void pmdiskentry_enable(menudesc*, struct part_entry *);
 int pm_partusage(struct pm_devs *, int, int);
 void pm_setfstype(struct pm_devs *, part_id, int, int);
 void pm_set_lvmpv(struct pm_devs *, part_id, bool);
 bool pm_is_lvmpv(struct pm_devs *, part_id, const struct disk_part_info*);
 int pm_editpart(int);
 void pm_rename(struct pm_devs *);
 void pm_shred(struct part_entry *, int);
 void pm_umount(struct pm_devs *, int);
 int pm_unconfigure(struct pm_devs *);
 int pm_cgd_edit_new(struct pm_devs *pm, part_id id);
 int pm_cgd_edit_old(struct part_entry *);
 void pm_wedges_fill(struct pm_devs *);
 void pm_edit_partitions(struct part_entry *);
 part_id pm_whole_disk(struct part_entry *, int);
 struct pm_devs * pm_from_pe(struct part_entry *);
 bool pm_force_parts(struct pm_devs *);
 /*
  * Parse a file system position or size in a common way, return
  * sector count and multiplicator.
  * If "extend" is supported, things like 120+ will be parsed as
  * 120 plus "extend this" flag.
  * Caller needs to init muliplicator upfront to the default value.
  */
 daddr_t parse_disk_pos(
 	const char *,	/* in: input string */
 	daddr_t *,	/* in/out: multiplicator for return value */
 	daddr_t bps,	/* in: sector size in bytes */
 	daddr_t,	/* in: cylinder size in sectors */
 	bool *);	/* NULL if "extend" is not supported, & of
 			 * "extend" flag otherwise */
 /* flags whether to offer the respective options (depending on helper
    programs available on install media */
 extern int have_raid, have_vnd, have_cgd, have_lvm, have_gpt, have_dk;
 /* initialize above variables */
 void check_available_binaries(void);
 /* from bsddisklabel.c */
 bool	make_bsd_partitions(struct install_partition_desc*);
 void	set_ptn_titles(menudesc *, int, void *);
 int	set_ptn_size(menudesc *, void *);
 bool	get_ptn_sizes(struct partition_usage_set*);
 bool	check_partitions(struct install_partition_desc*);
 /* from aout2elf.c */
 int move_aout_libs(void);
 #ifdef WSKBD
 void	get_kb_encoding(void);
 void	save_kb_encoding(void);
 #else
 #define	get_kb_encoding()
 #define	save_kb_encoding()
 #endif
 /* from configmenu.c */
 void	do_configmenu(struct install_partition_desc*);
 /* from checkrc.c */
 int	check_rcvar(const char *);
 int	check_rcdefault(const char *);
-	WINDOW *mainwin;
+extern	WINDOW *mainwin;
 /* in menus.mi */
 void expand_all_option_texts(menudesc *menu, void *arg);
 void resize_menu_height(menudesc *);
 #endif	/* _DEFS_H_ */

 @@ -1,570 +1,609 @@
-/*	$NetBSD: main.c,v 1.23 2020/03/04 11:15:06 martin Exp $	*/
+/*	$NetBSD: main.c,v 1.24 2020/04/22 23:43:12 joerg Exp $	*/
 /*
  * Copyright 1997 Piermont Information Systems Inc.
  * All rights reserved.
+ *
  * Written by Philip A. Nelson for Piermont Information Systems Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of Piermont Information Systems Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 /* main sysinst program. */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/syslimits.h>
 #include <sys/uio.h>
 #include <stdio.h>
 #include <signal.h>
 #include <curses.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <dirent.h>
 #include <locale.h>
 #include "defs.h"
 #include "md.h"
 #include "msg_defs.h"
 #include "menu_defs.h"
 #include "txtwalk.h"
 int debug;
 char machine[SSTRSIZE];
 int ignorerror;
 int ttysig_ignore;
 pid_t ttysig_forward;
 uint sizemult;
 int partman_go;
 FILE *logfp;
 FILE *script;
 daddr_t root_limit;
 struct pm_head_t pm_head;
 struct pm_devs *pm;
 struct pm_devs *pm_new;
 char xfer_dir[STRSIZE];
 int  clean_xfer_dir;
 char ext_dir_bin[STRSIZE];
 char ext_dir_src[STRSIZE];
 char ext_dir_pkgsrc[STRSIZE];
 char set_dir_bin[STRSIZE];
 char set_dir_src[STRSIZE];
 char pkg_dir[STRSIZE];
 char pkgsrc_dir[STRSIZE];
 const char *ushell;
 struct ftpinfo ftp, pkg, pkgsrc;
 int (*fetch_fn)(const char *);
 char nfs_host[STRSIZE];
 char nfs_dir[STRSIZE];
 char cdrom_dev[SSTRSIZE];
 char fd_dev[SSTRSIZE];
 const char *fd_type;
 char localfs_dev[SSTRSIZE];
 char localfs_fs[SSTRSIZE];
 char localfs_dir[STRSIZE];
 char targetroot_mnt[SSTRSIZE];
 int  mnt2_mounted;
 char dist_postfix[SSTRSIZE];
 char dist_tgz_postfix[SSTRSIZE];
 WINDOW *mainwin;
 static void select_language(void);
 __dead static void usage(void);
 __dead static void miscsighandler(int);
 static void ttysighandler(int);
 static void cleanup(void);
 static void process_f_flag(char *);
 static int exit_cleanly = 0;	/* Did we finish nicely? */
 FILE *logfp;			/* log file */
 FILE *script;			/* script file */
 const char *multname;
 const char *err_outofmem;
 #ifdef DEBUG
 extern int log_flip(void);
 #endif
 /* Definion for colors */
 struct {
 	unsigned int bg;
 	unsigned int fg;
 } clr_arg;
 /* String defaults and stuff for processing the -f file argument. */
 struct f_arg {
 	const char *name;
 	const char *dflt;
 	char *var;
 	int size;
 };
 static const struct f_arg fflagopts[] = {
 	{"release", REL, NULL, 0},
 	{"machine", MACH, machine, sizeof machine},
 	{"xfer dir", "/usr/INSTALL", xfer_dir, sizeof xfer_dir},
 	{"ext dir", "", ext_dir_bin, sizeof ext_dir_bin},
 	{"ext src dir", "", ext_dir_src, sizeof ext_dir_src},
 	{"ftp host", SYSINST_FTP_HOST, ftp.xfer_host[XFER_FTP], sizeof ftp.xfer_host[XFER_FTP]},
 	{"http host", SYSINST_HTTP_HOST, ftp.xfer_host[XFER_HTTP], sizeof ftp.xfer_host[XFER_HTTP]},
 	{"ftp dir", SYSINST_FTP_DIR, ftp.dir, sizeof ftp.dir},
 	{"ftp prefix", "/" ARCH_SUBDIR "/binary/sets", set_dir_bin, sizeof set_dir_bin},
 	{"ftp src prefix", "/source/sets", set_dir_src, sizeof set_dir_src},
 	{"ftp user", "ftp", ftp.user, sizeof ftp.user},
 	{"ftp pass", "", ftp.pass, sizeof ftp.pass},
 	{"ftp proxy", "", ftp.proxy, sizeof ftp.proxy},
 	{"nfs host", "", nfs_host, sizeof nfs_host},
 	{"nfs dir", "/bsd/release", nfs_dir, sizeof nfs_dir},
 	{"cd dev", 0, cdrom_dev, sizeof cdrom_dev}, /* default filled in init */
 	{"fd dev", "/dev/fd0a", fd_dev, sizeof fd_dev},
 	{"local dev", "", localfs_dev, sizeof localfs_dev},
 	{"local fs", "ffs", localfs_fs, sizeof localfs_fs},
 	{"local dir", "release", localfs_dir, sizeof localfs_dir},
 	{"targetroot mount", "/targetroot", targetroot_mnt, sizeof targetroot_mnt},
 	{"dist postfix", "." SETS_TAR_SUFF, dist_postfix, sizeof dist_postfix},
 	{"dist tgz postfix", ".tgz", dist_tgz_postfix, sizeof dist_tgz_postfix},
 	{"pkg host", SYSINST_PKG_HOST, pkg.xfer_host[XFER_FTP], sizeof pkg.xfer_host[XFER_FTP]},
 	{"pkg http host", SYSINST_PKG_HTTP_HOST, pkg.xfer_host[XFER_HTTP], sizeof pkg.xfer_host[XFER_HTTP]},
 	{"pkg dir", SYSINST_PKG_DIR, pkg.dir, sizeof pkg.dir},
 	{"pkg prefix", "/" PKG_ARCH_SUBDIR "/" PKG_SUBDIR "/All", pkg_dir, sizeof pkg_dir},
 	{"pkg user", "ftp", pkg.user, sizeof pkg.user},
 	{"pkg pass", "", pkg.pass, sizeof pkg.pass},
 	{"pkg proxy", "", pkg.proxy, sizeof pkg.proxy},
 	{"pkgsrc host", SYSINST_PKGSRC_HOST, pkgsrc.xfer_host[XFER_FTP], sizeof pkgsrc.xfer_host[XFER_FTP]},
 	{"pkgsrc http host", SYSINST_PKGSRC_HTTP_HOST, pkgsrc.xfer_host[XFER_HTTP], sizeof pkgsrc.xfer_host[XFER_HTTP]},
 	{"pkgsrc dir", "", pkgsrc.dir, sizeof pkgsrc.dir},
 	{"pkgsrc prefix", "pub/pkgsrc/stable", pkgsrc_dir, sizeof pkgsrc_dir},
 	{"pkgsrc user", "ftp", pkgsrc.user, sizeof pkgsrc.user},
 	{"pkgsrc pass", "", pkgsrc.pass, sizeof pkgsrc.pass},
 	{"pkgsrc proxy", "", pkgsrc.proxy, sizeof pkgsrc.proxy},
 	{NULL, NULL, NULL, 0}
 };
 static void
 init(void)
+{
 	const struct f_arg *arg;
 	sizemult = 1;
 	clean_xfer_dir = 0;
 	mnt2_mounted = 0;
 	fd_type = "msdos";
 	pm_head = (struct pm_head_t) SLIST_HEAD_INITIALIZER(pm_head);
 	SLIST_INIT(&pm_head);
 	pm_new = malloc(sizeof (struct pm_devs));
 	memset(pm_new, 0, sizeof *pm_new);
 	for (arg = fflagopts; arg->name != NULL; arg++) {
 		if (arg->var == NULL)
 			continue;
 		if (arg->var == cdrom_dev)
 			get_default_cdrom(arg->var, arg->size);
 		else
 			strlcpy(arg->var, arg->dflt, arg->size);
+	}
 	pkg.xfer = pkgsrc.xfer = XFER_HTTP;
 	clr_arg.bg=COLOR_BLUE;
 	clr_arg.fg=COLOR_WHITE;
+}
 static void
 init_lang(void)
+{
 	sizemult = 1;
 	err_outofmem = msg_string(MSG_out_of_memory);
 	multname = msg_string(MSG_secname);
+}
 int
 main(int argc, char **argv)
+{
 	int ch;
 	init();
 #ifdef DEBUG
 	log_flip();
 #endif
 	/* Check for TERM ... */
 	if (!getenv("TERM")) {
 		(void)fprintf(stderr,
 			 "sysinst: environment variable TERM not set.\n");
 		exit(4);
+	}
 	/* argv processing */
 	while ((ch = getopt(argc, argv, "Dr:f:C:"
 #ifndef NO_PARTMAN
 	    "p"
 #endif
 	    )) != -1)
 		switch(ch) {
 		case 'D':	/* set to get past certain errors in testing */
 			debug = 1;
 			break;
 		case 'r':
 			/* Release name - ignore for compatibility with older versions */
 			break;
 		case 'f':
 			/* Definition file to read. */
 			process_f_flag(optarg);
 			break;
 		case 'C':
 			/* Define colors */
 			sscanf(optarg, "%u:%u", &clr_arg.bg, &clr_arg.fg);
 			break;
 #ifndef NO_PARTMAN
 		case 'p':
 			/* Partition tool */
 			partman_go = 1;
 			break;
 #endif
 		case '?':
 		default:
 			usage();
+		}
 	md_init();
 	/* Initialize the partitioning subsystem */
 	partitions_init();
 	/* initialize message window */
 	if (menu_init()) {
 		__menu_initerror();
 		exit(4);
+	}
 	/*
 	 * Put 'messages' in a window that has a one-character border
 	 * on the real screen.
 	 */
 	mainwin = newwin(getmaxy(stdscr) - 2, getmaxx(stdscr) - 2, 1, 1);
 	if (mainwin == NULL) {
 		(void)fprintf(stderr,
 			 "sysinst: screen too small\n");
 		exit(1);
+	}
 	if (has_colors()) {
 		start_color();
 		do_coloring(clr_arg.fg,clr_arg.bg);
 	} else {
 		remove_color_options();
+	}
 	msg_window(mainwin);
 	/* Watch for signals and clean up */
 	(void)atexit(cleanup);
 	(void)signal(SIGINT, ttysighandler);
 	(void)signal(SIGQUIT, ttysighandler);
 	(void)signal(SIGHUP, miscsighandler);
 	/* redraw screen */
 	touchwin(stdscr);
 	refresh();
 	/* Ensure we have mountpoint for target filesystems */
 	mkdir(targetroot_mnt, S_IRWXU| S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH);
 	select_language();
 	get_kb_encoding();
 	init_lang();
 	/* Menu processing */
 	if (partman_go)
 		partman();
 	else
 		process_menu(MENU_netbsd, NULL);
 #ifndef NO_PARTMAN
 	/* clean up internal storage */
 	pm_destroy_all();
 #endif
 	partitions_cleanup();
 	exit_cleanly = 1;
 	return 0;
+}
 static int
 set_language(menudesc *m, void *arg)
+{
 	char **fnames = arg;
 	msg_file(fnames[m->cursel]);
 	return 1;
+}
 static void
 select_language(void)
+{
 	DIR *dir;
 	struct dirent *dirent;
 	char **lang_msg, **fnames;
 	char prefix[PATH_MAX], fname[PATH_MAX];
 	int max_lang = 16, num_lang = 0;
 	const char *cp;
 	menu_ent *opt = 0;
 	int lang_menu = -1;
 	int lang;
 #ifdef CATALOG_DIR
 	strcpy(prefix, CATALOG_DIR "/");
 	dir = opendir(CATALOG_DIR);
 	if (!dir) {
 		strcpy(prefix, "./");
 		dir = opendir(".");
+	}
 #else
 	dir = opendir(".");
 	strcpy(prefix, "./");
 #endif
 	if (!dir)
 		return;
 	lang_msg = malloc(max_lang * sizeof *lang_msg);
 	fnames = malloc(max_lang * sizeof *fnames);
 	if (!lang_msg || !fnames)
 		goto done;
 	lang_msg[0] = strdup(msg_string(MSG_sysinst_message_language));
 	fnames[0] = 0;
 	num_lang = 1;
 	while ((dirent = readdir(dir)) != 0) {
 		if (memcmp(dirent->d_name, "sysinstmsgs.", 12))
 			continue;
 		strcpy(fname, prefix);
 		strcat(fname, dirent->d_name);
 		if (msg_file(fname))
 			continue;
 		cp = msg_string(MSG_sysinst_message_language);
 		if (!strcmp(cp, lang_msg[0]))
 			continue;
 		if (num_lang == max_lang) {
 			char **new;
 			max_lang *= 2;
 			new = realloc(lang_msg, max_lang * sizeof *lang_msg);
 			if (!new)
 				break;
 			lang_msg = new;
 			new = realloc(fnames, max_lang * sizeof *fnames);
 			if (!new)
 				break;
 			fnames = new;
+		}
 		fnames[num_lang] = strdup(fname);
 		lang_msg[num_lang++] = strdup(cp);
+	}
 	msg_file(0);
 	closedir(dir);
 	dir = 0;
 	if (num_lang == 1)
 		goto done;
 	opt = calloc(num_lang, sizeof *opt);
 	if (!opt)
 		goto done;
 	for (lang = 0; lang < num_lang; lang++) {
 		opt[lang].opt_name = lang_msg[lang];
 		opt[lang].opt_action = set_language;
+	}
 	lang_menu = new_menu(NULL, opt, num_lang, -1, 12, 0, 0, MC_NOEXITOPT,
 		NULL, NULL, NULL, NULL, NULL);
 	if (lang_menu != -1) {
 		msg_display(MSG_hello);
 		process_menu(lang_menu, fnames);
+	}
     done:
 	if (dir)
 		closedir(dir);
 	if (lang_menu != -1)
 		free_menu(lang_menu);
 	free(opt);
 	while (num_lang) {
 		free(lang_msg[--num_lang]);
 		free(fnames[num_lang]);
+	}
 	free(lang_msg);
 	free(fnames);
 	/* set locale according to selected language */
 	cp = msg_string(MSG_sysinst_message_locale);
 	if (cp) {
 		setlocale(LC_CTYPE, cp);
 		setenv("LC_CTYPE", cp, 1);
+	}
+}
 #ifndef md_may_remove_boot_medium
 #define md_may_remove_boot_medium()	(boot_media_still_needed()<=0)
 #endif
 /* toplevel menu handler ... */
 void
 toplevel(void)
+{
 	/*
 	 * Undo any stateful side-effects of previous menu choices.
 	 * XXX must be idempotent, since we get run each time the main
 	 *     menu is displayed.
 	 */
 	char *home = getenv("HOME");
 	if (home != NULL)
 		if (chdir(home) != 0)
 			(void)chdir("/");
 	unwind_mounts();
 	/* Display banner message in (english, francais, deutsch..) */
 	msg_display(MSG_hello);
 	msg_display_add(MSG_md_hello);
 	if (md_may_remove_boot_medium())
 		msg_display_add(MSG_md_may_remove_boot_medium);
 	msg_display_add(MSG_thanks);
+}
 /* The usage ... */
 static void
 usage(void)
+{
 	(void)fprintf(stderr, "usage: sysinst [-D] [-f definition_file] "
 	    "[-r release] [-C bg:fg]"
 #ifndef NO_PARTMAN
 	    " [-p]"
 #endif
 	    "\n"
 	    "where:\n"
 	    "\t-D\n\t\trun in debug mode\n"
 	    "\t-f definition_file\n\t\toverride built-in defaults from file\n"
 	    "\t-r release\n\t\toverride release name\n"
 	    "\t-C bg:fg\n\t\tuse different color scheme\n"
 #ifndef NO_PARTMAN
 	    "\t-p\n\t\tonly run the partition editor, no installation\n"
 #endif
 	    );
 	exit(1);
+}
 /* ARGSUSED */
 static void
 miscsighandler(int signo)
+{
 	/*
 	 * we need to cleanup(), but it was already scheduled with atexit(),
 	 * so it'll be invoked on exit().
 	 */
 	exit(1);
+}
 static void
 ttysighandler(int signo)
+{
 	/*
 	 * if we want to ignore a TTY signal (SIGINT or SIGQUIT), then we
 	 * just return.  If we want to forward a TTY signal, we forward it
 	 * to the specified process group.
+	 *
 	 * This functionality is used when setting up and displaying child
 	 * output so that the child gets the signal and presumably dies,
 	 * but sysinst continues.  We use this rather than actually ignoring
 	 * the signals, because that will be be passed on to a child
 	 * through fork/exec, whereas special handlers get reset on exec..
 	 */
 	if (ttysig_ignore)
 		return;
 	if (ttysig_forward) {
 		killpg(ttysig_forward, signo);
 		return;
+	}
 	/*
 	 * we need to cleanup(), but it was already scheduled with atexit(),
 	 * so it'll be invoked on exit().
 	 */
 	exit(1);
+}
 static void
 cleanup(void)
+{
 	time_t tloc;
 	(void)time(&tloc);
 #if 0
 	restore_etc();
 #endif
 	/* Ensure we aren't inside the target tree */
 	chdir(getenv("HOME"));
 	unwind_mounts();
 	umount_mnt2();
 	endwin();
 	if (logfp) {
 		fprintf(logfp, "Log ended at: %s\n", safectime(&tloc));
 		fflush(logfp);
 		fclose(logfp);
 		logfp = NULL;
+	}
 	if (script) {
 		fprintf(script, "# Script ended at: %s\n", safectime(&tloc));
 		fflush(script);
 		fclose(script);
 		script = NULL;
+	}
 	if (!exit_cleanly)
 		fprintf(stderr, "\n\nsysinst terminated.\n");
+}
 /* process function ... */
 void
 process_f_flag(char *f_name)
+{
 	char buffer[STRSIZE];
 	int len;
 	const struct f_arg *arg;
 	FILE *fp;
 	char *cp, *cp1, *err;
 	/* open the file */
 	fp = fopen(f_name, "r");
 	if (fp == NULL) {
 		const char *args[] = { f_name };
 		err = str_arg_subst(msg_string(MSG_config_open_error),
 		    __arraycount(args), args);
 		fprintf(stderr, "%s\n", err);
 		free(err);
 		exit(1);
+	}
 	while (fgets(buffer, sizeof buffer, fp) != NULL) {
 		cp = buffer + strspn(buffer, " \t");
 		if (strchr("#\r\n", *cp) != NULL)
 			continue;
 		for (arg = fflagopts; arg->name != NULL; arg++) {
 			len = strlen(arg->name);
 			if (memcmp(cp, arg->name, len) != 0)
 				continue;
 			if (arg->var == NULL || arg->size == 0)
 				continue;
 			cp1 = cp + len;
 			cp1 += strspn(cp1, " \t");
 			if (*cp1++ != '=')
 				continue;
 			cp1 += strspn(cp1, " \t");
 			len = strcspn(cp1, " \n\r\t");
 			cp1[len] = 0;
 			strlcpy(arg->var, cp1, arg->size);
 			break;
+		}
+	}
 	fclose(fp);
+}

 @@ -1,1146 +1,1146 @@
-/*	$NetBSD: mbr.c,v 1.31 2020/02/06 18:07:22 martin Exp $ */
+/*	$NetBSD: mbr.c,v 1.32 2020/04/22 23:43:12 joerg Exp $ */
 /*
  * Copyright 1997 Piermont Information Systems Inc.
  * All rights reserved.
+ *
  * Written by Philip A. Nelson for Piermont Information Systems Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of Piermont Information Systems Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 /*
  * Following applies to the geometry guessing code
  */
 /*
  * 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.
  */
 /* mbr.c -- DOS Master Boot Record editing code */
 #ifdef HAVE_MBR
 #include <sys/param.h>
 #include <sys/types.h>
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <util.h>
 #include <paths.h>
 #include <sys/ioctl.h>
 #include "defs.h"
 #include "mbr.h"
 #include "md.h"
 #include "msg_defs.h"
 #include "menu_defs.h"
 #include "defsizes.h"
 #include "endian.h"
 #define NO_BOOTMENU (-0x100)
 #define MAXCYL		1023    /* Possibly 1024 */
 #define MAXHEAD		255     /* Possibly 256 */
 #define MAXSECTOR	63
 #define	MBR_UNKNOWN_PTYPE	94	/* arbitrary not widely used value */
 /* A list of predefined partition types */
 const struct {
 	unsigned int ptype;
 	char short_desc[12];
 	const char *desc;
 } mbr_part_types_src[] = {
 	{ .ptype=MBR_PTYPE_NETBSD, .desc="NetBSD" },
 	{ .ptype=MBR_PTYPE_FAT32L, .desc="Windows FAT32, LBA" },
 	{ .ptype=MBR_PTYPE_EXT_LBA, .desc="Extended partition, LBA" },
 	{ .ptype=MBR_PTYPE_386BSD, .desc="FreeBSD/386BSD" },
 	{ .ptype=MBR_PTYPE_OPENBSD, .desc="OpenBSD"  },
 	{ .ptype=MBR_PTYPE_LNXEXT2, .desc="Linux native" },
 	{ .ptype=MBR_PTYPE_LNXSWAP, .desc="Linux swap" },
 	{ .ptype=MBR_PTYPE_NTFSVOL, .desc="NTFS volume set" },
 	{ .ptype=MBR_PTYPE_NTFS, .desc="NTFS" },
 	{ .ptype=MBR_PTYPE_PREP, .desc="PReP Boot" },
 #ifdef MBR_PTYPE_SOLARIS
 	{ .ptype=MBR_PTYPE_SOLARIS, .desc="Solaris" },
 #endif
 	{ .ptype=MBR_PTYPE_FAT12, .desc="DOS FAT12" },
 	{ .ptype=MBR_PTYPE_FAT16S, .desc="DOS FAT16, <32M" },
 	{ .ptype=MBR_PTYPE_FAT16B, .desc="DOS FAT16, >32M" },
 	{ .ptype=MBR_PTYPE_FAT16L, .desc="Windows FAT16, LBA" },
 	{ .ptype=MBR_PTYPE_FAT32, .desc="Windows FAT32" },
 	{ .ptype=MBR_PTYPE_EFI, .desc="(U)EFI Boot" },
 };
 /* bookeeping of available partition types (including custom ones) */
 struct mbr_part_type_info {
 	struct part_type_desc gen;	/* generic description */
 	char desc_buf[40], short_buf[10];
 	size_t next_ptype;		/* user interface order */
 };
 const struct disk_partitioning_scheme mbr_parts;
 struct mbr_disk_partitions {
 	struct disk_partitions dp, *dlabel;
 	mbr_info_t mbr;
 	uint ptn_alignment, ptn_0_offset, ext_ptn_alignment,
 	    geo_sec, geo_head, geo_cyl;
 };
 const struct disk_partitioning_scheme mbr_parts;
 static size_t known_part_types = 0, last_added_part_type = 0;
 static const size_t first_part_type = MBR_PTYPE_NETBSD;
 /* all partition types (we are lucky, only a fixed number is possible) */
 struct mbr_part_type_info mbr_gen_type_desc[256];
-const struct disk_partitioning_scheme disklabel_parts;
+extern const struct disk_partitioning_scheme disklabel_parts;
 static void convert_mbr_chs(int, int, int, uint8_t *, uint8_t *,
 				 uint8_t *, uint32_t);
 static part_id mbr_add_part(struct disk_partitions *arg,
     const struct disk_part_info *info, const char **errmsg);
 static size_t mbr_get_free_spaces(const struct disk_partitions *arg,
     struct disk_part_free_space *result, size_t max_num_result,
     daddr_t min_size, daddr_t align, daddr_t lower_bound, daddr_t ignore);
 static size_t mbr_type_from_gen_desc(const struct part_type_desc *desc);
 /*
  * Notes on the extended partition editor.
+ *
  * The extended partition structure is actually a singly linked list.
  * Each of the 'mbr' sectors can only contain 2 items, the first describes
  * a user partition (relative to that mbr sector), the second describes
  * the following partition (relative to the start of the extended partition).
+ *
  * The 'start' sector for the user partition is always the size of one
  * track - very often 63.  The extended partitions themselves should
  * always start on a cylinder boundary using the BIOS geometry - often
  * 16065 sectors per cylinder.
+ *
  * The disk is also always described in increasing sector order.
+ *
  * During editing we keep the mbr sectors accurate (it might have been
  * easier to use absolute sector numbers though), and keep a copy of the
  * entire sector - to preserve any information any other OS has tried
  * to squirrel away in the (apparently) unused space.
+ *
  * Typical disk (with some small numbers):
+ *
  *      0 -> a       63       37	dos
  *           b      100     1000	extended LBA (type 15)
+ *
  *    100 -> a       63       37        user
  *           b      100      200	extended partiton (type 5)
+ *
  *    200 -> a       63       37        user
  *           b      200      300	extended partiton (type 5)
+ *
  *    300 -> a       63       37	user
  *           b        0        0        0 (end of chain)
+ *
  */
 #ifndef debug_extended
 #define dump_mbr(mbr, msg)
 #else
 static void
 dump_mbr(mbr_info_t *m, const char *label)
+{
 	int i;
 	uint ext_base = 0;
 	fprintf(stderr, "\n%s: bsec %d\n", label, bsec);
 	do {
 		fprintf(stderr, "%p: %12u %p\n",
 		    m, m->sector, m->extended);
 		for (i = 0; i < MBR_PART_COUNT; i++) {
 			fprintf(stderr, " %*d %12u %12u %12" PRIu64,
 ,
 			    m->mbr.mbr_parts[i].mbrp_type,
 			    m->mbr.mbr_parts[i].mbrp_start,
 			    m->mbr.mbr_parts[i].mbrp_size,
 			    (uint64_t)m->mbr.mbr_parts[i].mbrp_start +
 				(uint64_t)m->mbr.mbr_parts[i].mbrp_size);
 			if (m->sector == 0 &&
 			    MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type))
 				ext_base = m->mbr.mbr_parts[i].mbrp_start;
 			if (m->sector > 0 &&
 			    m->mbr.mbr_parts[i].mbrp_size > 0) {
 				uint off = MBR_IS_EXTENDED(
 				    m->mbr.mbr_parts[i].mbrp_type)
 				    ? ext_base : m->sector;
 				fprintf(stderr, " -> [%u .. %u]",
 				    m->mbr.mbr_parts[i].mbrp_start + off,
 				    m->mbr.mbr_parts[i].mbrp_size +
 				    m->mbr.mbr_parts[i].mbrp_start + off);
+			}
 			fprintf(stderr, ",\n");
 			if (m->sector > 0 && i >= 1)
 				break;
+		}
 	} while ((m = m->extended));
+}
 #endif
 /*
  * Like pread, but handles re-blocking for non 512 byte sector disks
  */
 static ssize_t
 blockread(int fd, size_t secsize, void *buf, size_t nbytes, off_t offset)
+{
         ssize_t nr;
 	off_t sector = offset / 512;
         off_t offs = sector * (off_t)secsize;
         off_t mod = offs & (secsize - 1);
         off_t rnd = offs & ~(secsize - 1);
 	char *iobuf;
 	assert(nbytes <= 512);
 	if (secsize == 512)
 		return pread(fd, buf, nbytes, offset);
 	iobuf = malloc(secsize);
 	if (iobuf == NULL)
 		return -1;
 	nr = pread(fd, iobuf, secsize, rnd);
 	if (nr == (off_t)secsize)
 		memcpy(buf, &iobuf[mod], nbytes);
 	free(iobuf);
 	return nr == (off_t)secsize ? (off_t)nbytes : -1;
+}
 /*
  * Same for pwrite
  */
 static ssize_t
 blockwrite(int fd, size_t secsize, const void *buf, size_t nbytes,
     off_t offset)
+{
         ssize_t nr;
 	off_t sector = offset / secsize;
         off_t offs = sector * (off_t)secsize;
         off_t mod = offs & (secsize - 1);
         off_t rnd = offs & ~(secsize - 1);
 	char *iobuf;
 	assert(nbytes <= 512);
 	if (secsize == 512)
 		return pwrite(fd, buf, nbytes, offset);
 	iobuf = malloc(secsize);
 	if (iobuf == NULL)
 		return -1;
 	nr = pread(fd, iobuf, secsize, rnd);
 	if (nr == (off_t)secsize) {
 		memcpy(&iobuf[mod], buf, nbytes);
 		nr = pwrite(fd, iobuf, secsize, rnd);
+	}
 	free(iobuf);
 	return nr == (off_t)secsize ? (off_t)nbytes : -1;
+}
 static void
 free_last_mounted(mbr_info_t *m)
+{
 	size_t i;
 	for (i = 0; i < MBR_PART_COUNT; i++)
 		free(__UNCONST(m->last_mounted[i]));
+}
 static void
 free_mbr_info(mbr_info_t *m)
+{
 	if (m == NULL)
 		return;
 	free_last_mounted(m);
 	free(m);
+}
 /*
  * To be used only on ports which cannot provide any bios geometry
  */
 bool
 set_bios_geom_with_mbr_guess(struct disk_partitions *parts)
+{
 	int cyl, head, sec;
 	msg_fmt_display(MSG_nobiosgeom, "%d%d%d",
 	    pm->dlcyl, pm->dlsec, pm->dlhead);
 	if (guess_biosgeom_from_parts(parts, &cyl, &head, &sec) >= 0)
 		msg_fmt_display_add(MSG_biosguess, "%d%d%d", cyl, head, sec);
 	set_bios_geom(parts, &cyl, &head, &sec);
 	if (parts->pscheme->change_disk_geom)
 		parts->pscheme->change_disk_geom(parts, cyl, head, sec);
 	return edit_outer_parts(parts);
+}
 static void
 mbr_init_chs(struct mbr_disk_partitions *parts, int ncyl, int nhead, int nsec)
+{
 	if (ncyl > MAXCYL)
 		ncyl = MAXCYL;
 	pm->current_cylsize = nhead*nsec;
 	pm->max_chs = (unsigned long)ncyl*nhead*nsec;
 	parts->geo_sec = nsec;
 	parts->geo_head = nhead;
 	parts->geo_cyl = ncyl;
+}
 /*
  * get C/H/S geometry from user via menu interface and
  * store in globals.
  */
 void
 set_bios_geom(struct disk_partitions *parts, int *cyl, int *head, int *sec)
+{
 	char res[80];
 	int bsec, bhead, bcyl;
 	daddr_t s;
 	if (parts->pscheme->change_disk_geom == NULL)
 		return;
 	msg_display_add(MSG_setbiosgeom);
 	do {
 		snprintf(res, 80, "%d", *sec);
 		msg_prompt_add(MSG_sectors, res, res, 80);
 		bsec = atoi(res);
 	} while (bsec <= 0 || bsec > MAXSECTOR);
 	do {
 		snprintf(res, 80, "%d", *head);
 		msg_prompt_add(MSG_heads, res, res, 80);
 		bhead = atoi(res);
 	} while (bhead <= 0 || bhead > MAXHEAD);
 	s = min(pm->dlsize, mbr_parts.size_limit);
 	bcyl = s / bsec / bhead;
 	if (s != bcyl * bsec * bhead)
 		bcyl++;
 	if (bcyl > MAXCYL)
 		bcyl = MAXCYL;
 	pm->max_chs = (unsigned long)bcyl * bhead * bsec;
 	pm->current_cylsize = bhead * bsec;
 	parts->pscheme->change_disk_geom(parts, bcyl, bhead, bsec);
 	*cyl = bcyl;
 	*head = bhead;
 	*sec = bsec;
+}
 static int
 find_mbr_space(const struct mbr_info_t *mbrs, uint *start, uint *size,
     uint from, uint end_of_disk, uint ignore_at, bool primary_only)
+{
 	uint sz;
 	int i, j;
 	uint s, e;
 	const mbr_info_t *m, *me;
 	bool is_extended;
     check_again:
 	m = mbrs;
 	sz = end_of_disk-from;
 	if (from >= end_of_disk)
 		return -1;
 	for (i = 0; i < MBR_PART_COUNT; i++) {
 		if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED)
 			continue;
 		is_extended = MBR_IS_EXTENDED(
 		    m->mbr.mbr_parts[i].mbrp_type);
 		s = m->mbr.mbr_parts[i].mbrp_start + m->sector;
 		if (s == ignore_at)
 			continue;
 		e = s + m->mbr.mbr_parts[i].mbrp_size;
 		if (s <= from && e > from
 		    && (!is_extended || primary_only)) {
 			if (e - 1 >= end_of_disk)
 				break;
 			if (e >= UINT_MAX) {
 				sz = 0;
 				break;
+			}
 			from = e + 1;
 			goto check_again;
+		}
 		if (s <= from && e > from && is_extended) {
 			/*
 			 * if we start in the extended partiton,
 			 * we must end before its end
 			 */
 			sz = e - from;
+		}
 		if (s > from && s - from < sz)
 			sz = s - from;
 		if (is_extended) {
 			for (me = m->extended; me != NULL; me = me->extended) {
 				for (j = 0; j < MBR_PART_COUNT; j++) {
 					if (me->mbr.mbr_parts[j].mbrp_type ==
 					    MBR_PTYPE_UNUSED)
 						continue;
 					is_extended = MBR_IS_EXTENDED(
 					    me->mbr.mbr_parts[j].mbrp_type);
 					if (is_extended && i > 0)
 						break;
 					s = me->mbr.mbr_parts[j].mbrp_start +
 					    me->sector;
 					if (s == ignore_at)
 						continue;
 					e = s + me->mbr.mbr_parts[j].mbrp_size;
 					if (me->sector != 0 && me->sector< s)
 						/*
 						 * can not allow to overwrite
 						 * the ext mbr
 						 */
 						s = me->sector;
 					if (s <= from && e > from) {
 						if (e - 1 >= end_of_disk)
 							break;
 						from = e + 1;
 						goto check_again;
+					}
 					if (s > from && s - from < sz)
 						sz = s - from;
+				}
+			}
+		}
+	}
 	if (sz == 0)
 		return -1;
 	if (start != NULL)
 		*start = from;
 	if (size != NULL)
 		*size = sz;
 	return 0;
+}
 #ifdef BOOTSEL
 static int
 validate_and_set_names(mbr_info_t *mbri, const struct mbr_bootsel *src,
     uint32_t ext_base)
+{
 	size_t i, l;
 	const unsigned char *p;
 	/*
 	 * The 16 bit magic used to detect whether mbr_bootsel is valid
 	 * or not is pretty week - collisions have been seen in the wild;
 	 * but maybe it is just foreign tools corruption reminiscents
 	 * of NetBSD MBRs. Anyway, before accepting a boot menu definition,
 	 * make sure it is kinda "sane".
 	 */
 	for (i = 0; i < MBR_PART_COUNT; i++) {
 		/*
 		 * Make sure the name does not contain controll chars
 		 * (not using iscntrl due to minimalistic locale support
 		 * in miniroot environments) and is properly 0-terminated.
 		 */
 		for (l = 0, p = (const unsigned char *)&src->mbrbs_nametab[i];
 		    *p != 0; l++, p++) {
 			if (l >	MBR_BS_PARTNAMESIZE)
 				return 0;
 			if (*p < ' ')	/* hacky 'iscntrl' */
 				return 0;
+		}
+	}
 	memcpy(&mbri->mbrb, src, sizeof(*src));
 	if (ext_base == 0)
 		return mbri->mbrb.mbrbs_defkey - SCAN_1;
 	return 0;
+}
 #endif
 static int
 valid_mbr(struct mbr_sector *mbrs)
+{
 	return (le16toh(mbrs->mbr_magic) == MBR_MAGIC);
+}
 static int
 read_mbr(const char *disk, size_t secsize, mbr_info_t *mbri)
+{
 	struct mbr_partition *mbrp;
 	struct mbr_sector *mbrs = &mbri->mbr;
 	mbr_info_t *ext = NULL;
 	char diskpath[MAXPATHLEN];
 	int fd, i;
 	uint32_t ext_base = 0, next_ext = 0;
 	int rval = -1;
 #ifdef BOOTSEL
 	mbr_info_t *ombri = mbri;
 	int bootkey = 0;
 #endif
 	memset(mbri, 0, sizeof *mbri);
 	/* Open the disk. */
 	fd = opendisk(disk, O_RDONLY, diskpath, sizeof(diskpath), 0);
 	if (fd < 0)
 		goto bad_mbr;
 	for (;;) {
 		if (blockread(fd, secsize, mbrs, sizeof *mbrs,
 		    (ext_base + next_ext) * (off_t)MBR_SECSIZE) - sizeof *mbrs != 0)
 			break;
 		if (!valid_mbr(mbrs))
 			break;
 		mbrp = &mbrs->mbr_parts[0];
 		if (ext_base != 0) {
 			/* sanity check extended chain */
 			if (MBR_IS_EXTENDED(mbrp[0].mbrp_type))
 				break;
 			if (mbrp[1].mbrp_type != MBR_PTYPE_UNUSED &&
 			    !MBR_IS_EXTENDED(mbrp[1].mbrp_type))
 				break;
 			if (mbrp[2].mbrp_type != MBR_PTYPE_UNUSED
 			    || mbrp[3].mbrp_type != MBR_PTYPE_UNUSED)
 				break;
 			/* Looks ok, link into extended chain */
 			mbri->extended = ext;
 			ext->extended = NULL;
 			mbri = ext;
 			ext = NULL;
+		}
 #if BOOTSEL
 		if (mbrs->mbr_bootsel_magic == htole16(MBR_MAGIC)) {
 			/* old bootsel, grab bootsel info */
 			bootkey = validate_and_set_names(mbri,
 				(struct mbr_bootsel *)
 				((uint8_t *)mbrs + MBR_BS_OLD_OFFSET),
 				ext_base);
 		} else if (mbrs->mbr_bootsel_magic == htole16(MBR_BS_MAGIC)) {
 			/* new location */
 			bootkey = validate_and_set_names(mbri,
 			    &mbrs->mbr_bootsel, ext_base);
+		}
 		/* Save original flags for mbr code update tests */
 		mbri->oflags = mbri->mbrb.mbrbs_flags;
 #endif
 		mbri->sector = next_ext + ext_base;
 		next_ext = 0;
 		rval = 0;
 		for (i = 0; i < MBR_PART_COUNT; mbrp++, i++) {
 			if (mbrp->mbrp_type == MBR_PTYPE_UNUSED) {
 				/* type is unused, discard scum */
 				memset(mbrp, 0, sizeof *mbrp);
 				continue;
+			}
 			mbrp->mbrp_start = le32toh(mbrp->mbrp_start);
 			mbrp->mbrp_size = le32toh(mbrp->mbrp_size);
 			if (MBR_IS_EXTENDED(mbrp->mbrp_type)) {
 				next_ext = mbrp->mbrp_start;
 			} else {
 				uint flags = 0;
 				if (mbrp->mbrp_type == MBR_PTYPE_NETBSD)
 					flags |= GLM_LIKELY_FFS;
 				else if (mbrp->mbrp_type == MBR_PTYPE_FAT12 ||
 				    mbrp->mbrp_type == MBR_PTYPE_FAT16S ||
 				    mbrp->mbrp_type == MBR_PTYPE_FAT16B ||
 				    mbrp->mbrp_type == MBR_PTYPE_FAT32 ||
 				    mbrp->mbrp_type == MBR_PTYPE_FAT32L ||
 				    mbrp->mbrp_type == MBR_PTYPE_FAT16L)
 					flags |= GLM_MAYBE_FAT32;
 				else if (mbrp->mbrp_type == MBR_PTYPE_NTFS)
 					flags |= GLM_MAYBE_NTFS;
 				if (flags != 0) {
 					const char *mount = get_last_mounted(
 					    fd, mbri->sector + mbrp->mbrp_start,
 					    &mbri->fs_type[i],
 					    &mbri->fs_sub_type[i],
 					    flags);
 					char *p = strdup(mount);
 					canonicalize_last_mounted(p);
 					mbri->last_mounted[i] = p;
+				}
+			}
 #if BOOTSEL
 			if (mbri->mbrb.mbrbs_nametab[i][0] != 0
 			    && bootkey-- == 0)
 				ombri->bootsec = mbri->sector +
 							mbrp->mbrp_start;
 #endif
+		}
 		if (next_ext == 0 || ext_base + next_ext <= mbri->sector)
 			break;
 		if (ext_base == 0) {
 			ext_base = next_ext;
 			next_ext = 0;
+		}
 		ext = calloc(1, sizeof *ext);
 		if (!ext)
 			break;
 		mbrs = &ext->mbr;
+	}
     bad_mbr:
 	free_mbr_info(ext);
 	if (fd >= 0)
 		close(fd);
 	if (rval == -1) {
 		memset(&mbrs->mbr_parts, 0, sizeof mbrs->mbr_parts);
 		mbrs->mbr_magic = htole16(MBR_MAGIC);
+	}
 	dump_mbr(ombri, "read");
 	return rval;
+}
 static int
 write_mbr(const char *disk, size_t secsize, mbr_info_t *mbri, int bsec,
     int bhead, int bcyl)
+{
 	char diskpath[MAXPATHLEN];
 	int fd, i, ret = 0, bits = 0;
 	struct mbr_partition *mbrp;
 	u_int32_t pstart, psize;
 #ifdef BOOTSEL
 	struct mbr_sector *mbrs;
 #endif
 	struct mbr_sector mbrsec;
 	mbr_info_t *ext;
 	uint sector;
 	dump_mbr(mbri, "write");
 	/* Open the disk. */
 	fd = opendisk(disk, secsize == 512 ? O_WRONLY : O_RDWR,
 	    diskpath, sizeof(diskpath), 0);
 	if (fd < 0)
 		return -1;
 	/* Remove all wedges */
 	if (ioctl(fd, DIOCRMWEDGES, &bits) == -1)
 		return -1;
 #ifdef BOOTSEL
 	/*
 	 * If the main boot code (appears to) contain the netbsd bootcode,
 	 * copy in all the menu strings and set the default keycode
 	 * to be that for the default partition.
 	 * Unfortunately we can't rely on the user having actually updated
 	 * to the new mbr code :-(
 	 */
 	if (mbri->mbr.mbr_bootsel_magic == htole16(MBR_BS_MAGIC)
 	    || mbri->mbr.mbr_bootsel_magic == htole16(MBR_MAGIC)) {
 		int8_t key = SCAN_1;
 		uint offset = MBR_BS_OFFSET;
 		if (mbri->mbr.mbr_bootsel_magic == htole16(MBR_MAGIC))
 			offset = MBR_BS_OLD_OFFSET;
 		mbri->mbrb.mbrbs_defkey = SCAN_ENTER;
 		if (mbri->mbrb.mbrbs_timeo == 0)
 			mbri->mbrb.mbrbs_timeo = 182;	/* 10 seconds */
 		for (ext = mbri; ext != NULL; ext = ext->extended) {
 			mbrs = &ext->mbr;
 			mbrp = &mbrs->mbr_parts[0];
 			/* Ensure marker is set in each sector */
 			mbrs->mbr_bootsel_magic = mbri->mbr.mbr_bootsel_magic;
 			/* and copy in bootsel parameters */
 			*(struct mbr_bootsel *)((uint8_t *)mbrs + offset) =
 								    ext->mbrb;
 			for (i = 0; i < MBR_PART_COUNT; i++) {
 				if (ext->mbrb.mbrbs_nametab[i][0] == 0)
 					continue;
 				if (ext->sector + mbrp->mbrp_start ==
 								mbri->bootsec)
 					mbri->mbrb.mbrbs_defkey = key;
 				key++;
+			}
+		}
 		/* copy main data (again) since we've put the 'key' in */
 		*(struct mbr_bootsel *)((uint8_t *)&mbri->mbr + offset) =
 								    mbri->mbrb;
+	}
 #endif
 	for (ext = mbri; ext != NULL; ext = ext->extended) {
 		memset(mbri->wedge, 0, sizeof mbri->wedge);
 		sector = ext->sector;
 		mbrsec = ext->mbr;	/* copy sector */
 		mbrp = &mbrsec.mbr_parts[0];
 		if (sector != 0 && ext->extended != NULL
 		    && ext->extended->mbr.mbr_parts[0].mbrp_type
 		    == MBR_PTYPE_UNUSED) {
 			/*
 			 * This should never happen nowadays, old code
 			 * inserted empty ext sectors in the chain to
 			 * help the gui out - we do not do that anymore.
 			 */
 			assert(false);
 			/* We are followed by an empty slot, collapse out */
 			ext = ext->extended;
 			/* Make us describe the next non-empty partition */
 			mbrp[1] = ext->mbr.mbr_parts[1];
+		}
 		for (i = 0; i < MBR_PART_COUNT; i++) {
 			if (mbrp[i].mbrp_start == 0 && mbrp[i].mbrp_size == 0) {
 				mbrp[i].mbrp_scyl = 0;
 				mbrp[i].mbrp_shd = 0;
 				mbrp[i].mbrp_ssect = 0;
 				mbrp[i].mbrp_ecyl = 0;
 				mbrp[i].mbrp_ehd = 0;
 				mbrp[i].mbrp_esect = 0;
 				continue;
+			}
 			pstart = mbrp[i].mbrp_start;
 			psize = mbrp[i].mbrp_size;
 			mbrp[i].mbrp_start = htole32(pstart);
 			mbrp[i].mbrp_size = htole32(psize);
 			if (bsec && bcyl && bhead) {
 				convert_mbr_chs(bcyl, bhead, bsec,
 				    &mbrp[i].mbrp_scyl, &mbrp[i].mbrp_shd,
 				    &mbrp[i].mbrp_ssect, pstart);
 				convert_mbr_chs(bcyl, bhead, bsec,
 				    &mbrp[i].mbrp_ecyl, &mbrp[i].mbrp_ehd,
 				    &mbrp[i].mbrp_esect, pstart + psize - 1);
+			}
+		}
 		mbrsec.mbr_magic = htole16(MBR_MAGIC);
 		if (blockwrite(fd, secsize, &mbrsec, sizeof mbrsec,
 					    sector * (off_t)MBR_SECSIZE) < 0) {
 			ret = -1;
 			break;
+		}
+	}
 	(void)close(fd);
 	return ret;
+}
 static void
 convert_mbr_chs(int cyl, int head, int sec,
 		uint8_t *cylp, uint8_t *headp, uint8_t *secp,
 		uint32_t relsecs)
+{
 	unsigned int tcyl, temp, thead, tsec;
 	temp = head * sec;
 	tcyl = relsecs / temp;
 	relsecs -= tcyl * temp;
 	thead = relsecs / sec;
 	tsec = relsecs - thead * sec + 1;
 	if (tcyl > MAXCYL)
 		tcyl = MAXCYL;
 	*cylp = MBR_PUT_LSCYL(tcyl);
 	*headp = thead;
 	*secp = MBR_PUT_MSCYLANDSEC(tcyl, tsec);
+}
 /*
  * This function is ONLY to be used as a last resort to provide a
  * hint for the user. Ports should provide a more reliable way
  * of getting the BIOS geometry. The i386 code, for example,
  * uses the BIOS geometry as passed on from the bootblocks,
  * and only uses this as a hint to the user when that information
  * is not present, or a match could not be made with a NetBSD
  * device.
  */
 int
 guess_biosgeom_from_parts(struct disk_partitions *parts,
     int *cyl, int *head, int *sec)
+{
 	/*
 	 * 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.
 	 */
 	int xcylinders = pm->dlcyl;
 	int xheads = pm->dlhead;
 	daddr_t xsectors = pm->dlsec;
 	daddr_t xsize = min(pm->dlsize, mbr_parts.size_limit);
 	if (xcylinders > MAXCYL || xheads > MAXHEAD || xsectors > MAXSECTOR) {
 		xsectors = MAXSECTOR;
 		xheads = MAXHEAD;
 		xcylinders = xsize / (MAXSECTOR * MAXHEAD);
 		if (xcylinders > MAXCYL)
 			xcylinders = MAXCYL;
+	}
 	*cyl = xcylinders;
 	*head = xheads;
 	*sec = xsectors;
 	if (parts->pscheme->guess_disk_geom == NULL)
 		return -1;
 	return parts->pscheme->guess_disk_geom(parts, cyl, head, sec);
+}
 static int
 mbr_comp_part_entry(const void *a, const void *b)
+{
 	const struct mbr_partition *part_a = a,
 		*part_b = b;
 	if (part_a->mbrp_type == MBR_PTYPE_UNUSED
 	    && part_b->mbrp_type != MBR_PTYPE_UNUSED)
 		return 1;
 	if (part_b->mbrp_type == MBR_PTYPE_UNUSED
 	    && part_a->mbrp_type != MBR_PTYPE_UNUSED)
 		return -1;
 	return part_a->mbrp_start < part_b->mbrp_start ? -1 : 1;
+}
 static void
 mbr_sort_main_mbr(struct mbr_sector *m)
+{
 	qsort(&m->mbr_parts[0], MBR_PART_COUNT,
 	    sizeof(m->mbr_parts[0]), mbr_comp_part_entry);
+}
 static void
 mbr_init_default_alignments(struct mbr_disk_partitions *parts, uint track)
+{
 	if (track == 0)
 		track = 16065;
 	assert(parts->dp.disk_size > 0);
 	if (parts->dp.disk_size < 0)
 		return;
 	/* Use 1MB offset/alignemnt for large (>128GB) disks */
 	if (parts->dp.disk_size > HUGE_DISK_SIZE) {
 		parts->ptn_alignment = 2048;
 		parts->ptn_0_offset = 2048;
 	} else if (parts->dp.disk_size > TINY_DISK_SIZE) {
 		parts->ptn_alignment = 64;
 		parts->ptn_0_offset = parts->geo_sec;
 	} else {
 		parts->ptn_alignment = 1;
 		parts->ptn_0_offset = parts->geo_sec;
+	}
 	parts->ext_ptn_alignment = track;
+}
 static struct disk_partitions *
 mbr_create_new(const char *disk, daddr_t start, daddr_t len,
     bool is_boot_drive, struct disk_partitions *parent)
+{
 	struct mbr_disk_partitions *parts;
 	struct disk_geom geo;
 	assert(start == 0);
 	if (start != 0)
 		return NULL;
 	parts = calloc(1, sizeof(*parts));
 	if (!parts)
 		return NULL;
 	parts->dp.pscheme = &mbr_parts;
 	parts->dp.disk = strdup(disk);
 	if (len > mbr_parts.size_limit)
 		len = mbr_parts.size_limit;
 	parts->dp.disk_start = start;
 	parts->dp.disk_size = len;
 	parts->dp.free_space = len-1;
 	parts->dp.bytes_per_sector = 512;
 	parts->geo_sec = MAXSECTOR;
 	parts->geo_head = MAXHEAD;
 	parts->geo_cyl = len/MAXHEAD/MAXSECTOR+1;
 	if (get_disk_geom(disk, &geo)) {
 		parts->geo_sec = geo.dg_nsectors;
 		parts->geo_head = geo.dg_ntracks;
 		parts->geo_cyl = geo.dg_ncylinders;
 		parts->dp.bytes_per_sector = geo.dg_secsize;
+	}
 	mbr_init_default_alignments(parts, 0);
 	return &parts->dp;
+}
 static void
 mbr_calc_free_space(struct mbr_disk_partitions *parts)
+{
 	size_t i;
 	mbr_info_t *m;
 	parts->dp.free_space = parts->dp.disk_size - 1;
 	parts->dp.num_part = 0;
 	m = &parts->mbr;
 	do {
 		for (i = 0; i < MBR_PART_COUNT; i++) {
 			if (m->mbr.mbr_parts[i].mbrp_type == MBR_PTYPE_UNUSED)
 				continue;
 			if (m != &parts->mbr && i > 0 &&
 			    MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type))
 				break;
 			parts->dp.num_part++;
 			if (MBR_IS_EXTENDED(m->mbr.mbr_parts[i].mbrp_type))
 				continue;
 			daddr_t psize = m->mbr.mbr_parts[i].mbrp_size;
 			if (m != &parts->mbr)
 				psize += m->mbr.mbr_parts[i].mbrp_start;
 			if (psize > parts->dp.free_space)
 				parts->dp.free_space = 0;
 			else
 				parts->dp.free_space -= psize;
+		}
 	} while ((m = m->extended));
+}
 static struct disk_partitions *
 mbr_read_from_disk(const char *disk, daddr_t start, daddr_t len, size_t bps,
     const struct disk_partitioning_scheme *scheme)
+{
 	struct mbr_disk_partitions *parts;
 	assert(start == 0);
 	if (start != 0)
 		return NULL;
 	parts = calloc(1, sizeof(*parts));
 	if (!parts)
 		return NULL;
 	parts->dp.pscheme = scheme;
 	parts->dp.disk = strdup(disk);
 	if (len >= mbr_parts.size_limit)
 		len = mbr_parts.size_limit;
 	parts->dp.disk_start = start;
 	parts->dp.disk_size = len;
 	parts->geo_sec = MAXSECTOR;
 	parts->geo_head = MAXHEAD;
 	parts->geo_cyl = len/MAXHEAD/MAXSECTOR+1;
 	parts->dp.bytes_per_sector = bps;
 	mbr_init_default_alignments(parts, 0);
 	if (read_mbr(disk, parts->dp.bytes_per_sector, &parts->mbr) == -1) {
 		free(parts);
 		return NULL;
+	}
 	mbr_calc_free_space(parts);
 	if (parts->dp.num_part == 1 &&
 	    parts->dp.free_space < parts->ptn_alignment) {
 		struct disk_part_info info;
 		/*
 		 * Check if this is a GPT protective MBR
 		 */
 		if (parts->dp.pscheme->get_part_info(&parts->dp, 0, &info)
 		    && info.nat_type != NULL
 		    && mbr_type_from_gen_desc(info.nat_type) == 0xEE) {
 			parts->dp.pscheme->free(&parts->dp);
 			return NULL;
+		}
+	}
 	return &parts->dp;
+}
 static bool
 mbr_write_to_disk(struct disk_partitions *new_state)
+{
 	struct mbr_disk_partitions *parts =
 	    (struct mbr_disk_partitions *)new_state;
 	unsigned long bsec, bhead, bcyl;
 	daddr_t t;
 	assert(parts->geo_sec != 0);
 	if (parts->geo_sec != 0) {
 		bsec = parts->geo_sec;
 		bhead = parts->ext_ptn_alignment / bsec;
 	} else {
 		bsec = MAXSECTOR;
 		bhead = MAXHEAD;
+	}
 	t = bsec * bhead;
 	assert(t != 0);
 	if ((daddr_t)(1UL<<10) * t <= parts->dp.disk_size)
 		bcyl = (1UL<<10) - 1;
 	else
 		bcyl = (unsigned long)(parts->dp.disk_size / t);
 	return write_mbr(parts->dp.disk, parts->dp.bytes_per_sector,
 	    &parts->mbr, bsec, bhead, bcyl) == 0;
+}
 static bool
 mbr_change_disk_geom(struct disk_partitions *arg, int ncyl, int nhead,
     int nsec)
+{
 	struct mbr_disk_partitions *parts = (struct mbr_disk_partitions *)arg;
 	daddr_t ptn_0_base, ptn_0_limit;
 	struct disk_part_info info;
 	/* Default to using 'traditional' cylinder alignment */
 	mbr_init_chs(parts, ncyl, nhead, nsec);
 	mbr_init_default_alignments(parts, nhead * nsec);
 	if (parts->dp.disk_size <= TINY_DISK_SIZE) {
 		set_default_sizemult(arg->disk,
 		    parts->dp.bytes_per_sector, parts->dp.bytes_per_sector);
 		return true;
+	}
 	if (parts->dp.num_part > 0 &&
 	    parts->dp.pscheme->get_part_info(arg, 0, &info)) {
 		/* Try to copy offset of first partition */
 		ptn_0_base = info.start;
 		ptn_0_limit = info.start + info.size;
 		if (!(ptn_0_limit & 2047)) {
 			/* Partition ends on a 1MB boundary, align to 1MB */
 			parts->ptn_alignment = 2048;
 			if ((ptn_0_base <= 2048
 			    && !(ptn_0_base & (ptn_0_base - 1)))
 			    || (ptn_0_base < parts->ptn_0_offset)) {
 				/*
 				 * If ptn_base is a power of 2, use it.
 				 * Also use it if the first partition
 				 * already is close to the begining
 				 * of the disk and we can't enforce
 				 * better alignment.
 				 */
 				parts->ptn_0_offset = ptn_0_base;
+			}
+		}
+	}
 	set_default_sizemult(arg->disk, MEG, parts->dp.bytes_per_sector);
 	return true;
+}
 static size_t
 mbr_type_from_gen_desc(const struct part_type_desc *desc)
+{
 	for (size_t i = 0; i < __arraycount(mbr_gen_type_desc); i++)
 		if (&mbr_gen_type_desc[i].gen == desc)
 			return i;
 	return SIZE_T_MAX;
+}
 static enum part_type
 mbr_map_part_type(unsigned int t)
+{
 	/* Map some special MBR partition types */
 	switch (t) {
 	case MBR_PTYPE_FAT32:
 	case MBR_PTYPE_FAT32L:
 	case MBR_PTYPE_FAT16S:
 	case MBR_PTYPE_FAT16B:
 	case MBR_PTYPE_FAT16L:
 	case MBR_PTYPE_FAT12:
 	case MBR_PTYPE_FT_FAT32:
 	case MBR_PTYPE_FT_FAT32_EXT:
 		return PT_FAT;
 	case MBR_PTYPE_EFI:
 		return PT_EFI_SYSTEM;
 	case MBR_PTYPE_NETBSD:
 		return PT_root;
+	}
 	return PT_unknown;
+}
 static void
 map_mbr_part_types(void)
+{
 	for (size_t i = 0; i < __arraycount(mbr_part_types_src); i++) {
 		unsigned int v = mbr_part_types_src[i].ptype;
 		snprintf(mbr_gen_type_desc[v].short_buf,
 		    sizeof(mbr_gen_type_desc[v].short_buf), "%u", v);
 		mbr_gen_type_desc[v].gen.short_desc =
 		    mbr_gen_type_desc[v].short_buf;
 		mbr_gen_type_desc[v].gen.description =
 		    mbr_part_types_src[i].desc;
 		mbr_gen_type_desc[v].gen.generic_ptype = mbr_map_part_type(v);
 		mbr_gen_type_desc[v].next_ptype = ~0U;
 		mbr_gen_type_desc[last_added_part_type].next_ptype = v;
 		known_part_types++;
 		last_added_part_type = v;
+	}
+}