 @@ -1,1766 +1,1772 @@
-/*	$NetBSD: disks.c,v 1.72 2021/01/31 22:45:46 rillig Exp $ */
+/*	$NetBSD: disks.c,v 1.73 2021/07/14 18:56:05 martin 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.
+ *
  */
 /* disks.c -- routines to deal with finding disks and labeling disks. */
 #include <assert.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <fnmatch.h>
 #include <util.h>
 #include <uuid.h>
 #include <paths.h>
 #include <fstab.h>
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #include <sys/swap.h>
 #include <sys/disklabel_gpt.h>
 #include <ufs/ufs/dinode.h>
 #include <ufs/ffs/fs.h>
 #include <dev/scsipi/scsipi_all.h>
 #include <sys/scsiio.h>
 #include <dev/ata/atareg.h>
 #include <sys/ataio.h>
 #include "defs.h"
 #include "md.h"
 #include "msg_defs.h"
 #include "menu_defs.h"
 #include "txtwalk.h"
 /* #define DEBUG_VERBOSE	1 */
 /* Disk descriptions */
 struct disk_desc {
 	char	dd_name[SSTRSIZE];
 	char	dd_descr[256];
 	bool	dd_no_mbr, dd_no_part;
 	uint	dd_cyl;
 	uint	dd_head;
 	uint	dd_sec;
 	uint	dd_secsize;
 	daddr_t	dd_totsec;
 };
 #define	NAME_PREFIX	"NAME="
 static const char name_prefix[] = NAME_PREFIX;
 /* things we could have as /sbin/newfs_* and /sbin/fsck_* */
 static const char *extern_fs_with_chk[] = {
 	"ext2fs", "lfs", "msdos", "v7fs"
 };
 /* things we could have as /sbin/newfs_* but not /sbin/fsck_* */
 static const char *extern_fs_newfs_only[] = {
 	"sysvbfs", "udf"
 };
 /* Local prototypes */
 static int found_fs(struct data *, size_t, const struct lookfor*);
 static int found_fs_nocheck(struct data *, size_t, const struct lookfor*);
 static int fsck_preen(const char *, const char *, bool silent);
 static void fixsb(const char *, const char *);
 static bool tmpfs_on_var_shm(void);
 const char *
 getfslabelname(uint f, uint f_version)
+{
 	if (f == FS_TMPFS)
 		return "tmpfs";
 	else if (f == FS_MFS)
 		return "mfs";
 	else if (f == FS_BSDFFS && f_version > 0)
 		return f_version == 2 ?
 		    msg_string(MSG_fs_type_ffsv2) : msg_string(MSG_fs_type_ffs);
 	else if (f == FS_EX2FS && f_version == 1)
 		return msg_string(MSG_fs_type_ext2old);
 	else if (f >= __arraycount(fstypenames) || fstypenames[f] == NULL)
 		return "invalid";
 	return fstypenames[f];
+}
 /*
  * Decide wether we want to mount a tmpfs on /var/shm: we do this always
  * when the machine has more than 16 MB of user memory. On smaller machines,
  * shm_open() and friends will not perform well anyway.
  */
 static bool
 tmpfs_on_var_shm()
+{
 	uint64_t ram;
 	size_t len;
 	len = sizeof(ram);
 	if (sysctlbyname("hw.usermem64", &ram, &len, NULL, 0))
 		return false;
 	return ram > 16 * MEG;
+}
 /* from src/sbin/atactl/atactl.c
  * extract_string: copy a block of bytes out of ataparams and make
  * a proper string out of it, truncating trailing spaces and preserving
  * strict typing. And also, not doing unaligned accesses.
  */
 static void
 ata_extract_string(char *buf, size_t bufmax,
 		   uint8_t *bytes, unsigned numbytes,
 		   int needswap)
+{
 	unsigned i;
 	size_t j;
 	unsigned char ch1, ch2;
 	for (i = 0, j = 0; i < numbytes; i += 2) {
 		ch1 = bytes[i];
 		ch2 = bytes[i+1];
 		if (needswap && j < bufmax-1) {
 			buf[j++] = ch2;
+		}
 		if (j < bufmax-1) {
 			buf[j++] = ch1;
+		}
 		if (!needswap && j < bufmax-1) {
 			buf[j++] = ch2;
+		}
+	}
 	while (j > 0 && buf[j-1] == ' ') {
 		j--;
+	}
 	buf[j] = '\0';
+}
 /*
  * from src/sbin/scsictl/scsi_subr.c
  */
 #define STRVIS_ISWHITE(x) ((x) == ' ' || (x) == '\0' || (x) == (u_char)'\377')
 static void
 scsi_strvis(char *sdst, size_t dlen, const char *ssrc, size_t slen)
+{
 	u_char *dst = (u_char *)sdst;
 	const u_char *src = (const u_char *)ssrc;
 	/* Trim leading and trailing blanks and NULs. */
 	while (slen > 0 && STRVIS_ISWHITE(src[0]))
 		++src, --slen;
 	while (slen > 0 && STRVIS_ISWHITE(src[slen - 1]))
 		--slen;
 	while (slen > 0) {
 		if (*src < 0x20 || *src >= 0x80) {
 			/* non-printable characters */
 			dlen -= 4;
 			if (dlen < 1)
 				break;
 			*dst++ = '\\';
 			*dst++ = ((*src & 0300) >> 6) + '0';
 			*dst++ = ((*src & 0070) >> 3) + '0';
 			*dst++ = ((*src & 0007) >> 0) + '0';
 		} else if (*src == '\\') {
 			/* quote characters */
 			dlen -= 2;
 			if (dlen < 1)
 				break;
 			*dst++ = '\\';
 			*dst++ = '\\';
 		} else {
 			/* normal characters */
 			if (--dlen < 1)
 				break;
 			*dst++ = *src;
+		}
 		++src, --slen;
+	}
 	*dst++ = 0;
+}
 static int
 get_descr_scsi(struct disk_desc *dd)
+{
 	struct scsipi_inquiry_data inqbuf;
 	struct scsipi_inquiry cmd;
 	scsireq_t req;
         /* x4 in case every character is escaped, +1 for NUL. */
 	char vendor[(sizeof(inqbuf.vendor) * 4) + 1],
 	     product[(sizeof(inqbuf.product) * 4) + 1],
 	     revision[(sizeof(inqbuf.revision) * 4) + 1];
 	char size[5];
 	memset(&inqbuf, 0, sizeof(inqbuf));
 	memset(&cmd, 0, sizeof(cmd));
 	memset(&req, 0, sizeof(req));
 	cmd.opcode = INQUIRY;
 	cmd.length = sizeof(inqbuf);
 	memcpy(req.cmd, &cmd, sizeof(cmd));
 	req.cmdlen = sizeof(cmd);
 	req.databuf = &inqbuf;
 	req.datalen = sizeof(inqbuf);
 	req.timeout = 10000;
 	req.flags = SCCMD_READ;
 	req.senselen = SENSEBUFLEN;
 	if (!disk_ioctl(dd->dd_name, SCIOCCOMMAND, &req)
 	    || req.retsts != SCCMD_OK)
 		return 0;
 	scsi_strvis(vendor, sizeof(vendor), inqbuf.vendor,
 	    sizeof(inqbuf.vendor));
 	scsi_strvis(product, sizeof(product), inqbuf.product,
 	    sizeof(inqbuf.product));
 	scsi_strvis(revision, sizeof(revision), inqbuf.revision,
 	    sizeof(inqbuf.revision));
 	humanize_number(size, sizeof(size),
 	    (uint64_t)dd->dd_secsize * (uint64_t)dd->dd_totsec,
 	    "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
 	snprintf(dd->dd_descr, sizeof(dd->dd_descr),
 	    "%s (%s, %s %s)",
 	    dd->dd_name, size, vendor, product);
 	return 1;
+}
 static int
 get_descr_ata(struct disk_desc *dd)
+{
 	struct atareq req;
 	static union {
 		unsigned char inbuf[DEV_BSIZE];
 		struct ataparams inqbuf;
 	} inbuf;
 	struct ataparams *inqbuf = &inbuf.inqbuf;
 	char model[sizeof(inqbuf->atap_model)+1];
 	char size[5];
 	int needswap = 0;
 	memset(&inbuf, 0, sizeof(inbuf));
 	memset(&req, 0, sizeof(req));
 	req.flags = ATACMD_READ;
 	req.command = WDCC_IDENTIFY;
 	req.databuf = (void *)&inbuf;
 	req.datalen = sizeof(inbuf);
 	req.timeout = 1000;
 	if (!disk_ioctl(dd->dd_name, ATAIOCCOMMAND, &req)
 	    || req.retsts != ATACMD_OK)
 		return 0;
 #if BYTE_ORDER == LITTLE_ENDIAN
 	/*
 	 * On little endian machines, we need to shuffle the string
 	 * byte order.  However, we don't have to do this for NEC or
 	 * Mitsumi ATAPI devices
 	 */
 	if (!(inqbuf->atap_config != WDC_CFG_CFA_MAGIC &&
 	      (inqbuf->atap_config & WDC_CFG_ATAPI) &&
 	      ((inqbuf->atap_model[0] == 'N' &&
 	        inqbuf->atap_model[1] == 'E') ||
 	       (inqbuf->atap_model[0] == 'F' &&
 	        inqbuf->atap_model[1] == 'X')))) {
 		needswap = 1;
+	}
 #endif
 	ata_extract_string(model, sizeof(model),
 	    inqbuf->atap_model, sizeof(inqbuf->atap_model), needswap);
 	humanize_number(size, sizeof(size),
 	    (uint64_t)dd->dd_secsize * (uint64_t)dd->dd_totsec,
 	    "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
 	snprintf(dd->dd_descr, sizeof(dd->dd_descr), "%s (%s, %s)",
 	    dd->dd_name, size, model);
 	return 1;
+}
 static void
 get_descr(struct disk_desc *dd)
+{
 	char size[5];
 	dd->dd_descr[0] = '\0';
 	/* try ATA */
 	if (get_descr_ata(dd))
 		goto done;
 	/* try SCSI */
 	if (get_descr_scsi(dd))
 		goto done;
 	/* XXX: identify for ld @ NVME or microSD */
 	/* XXX: get description from raid, cgd, vnd... */
 done:
 	/* punt, just give some generic info */
 	humanize_number(size, sizeof(size),
 	    (uint64_t)dd->dd_secsize * (uint64_t)dd->dd_totsec,
 	    "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
 	snprintf(dd->dd_descr, sizeof(dd->dd_descr),
 	    "%s (%s)", dd->dd_name, size);
+}
 /*
  * State for helper callback for get_default_cdrom
  */
 struct default_cdrom_data {
 	char *device;
 	size_t max_len;
 	bool found;
 };
 /*
  * Helper function for get_default_cdrom, gets passed a device
  * name and a void pointer to default_cdrom_data.
  */
 static bool
 get_default_cdrom_helper(void *state, const char *dev)
+{
 	struct default_cdrom_data *data = state;
 	if (!is_cdrom_device(dev, false))
 		return true;
 	strlcpy(data->device, dev, data->max_len);
 	strlcat(data->device, "a", data->max_len); /* default to partition a */
 	data->found = true;
 	return false;	/* one is enough, stop iteration */
+}
 /*
  * Set the argument to the name of the first CD devices actually
  * available, leave it unmodified otherwise.
  * Return true if a device has been found.
  */
 bool
 get_default_cdrom(char *cd, size_t max_len)
+{
 	struct default_cdrom_data state;
 	state.device = cd;
 	state.max_len = max_len;
 	state.found = false;
 	if (enumerate_disks(&state, get_default_cdrom_helper))
 		return state.found;
 	return false;
+}
 static bool
 get_wedge_descr(struct disk_desc *dd)
+{
 	struct dkwedge_info dkw;
 	if (!get_wedge_info(dd->dd_name, &dkw))
 		return false;
 	snprintf(dd->dd_descr, sizeof(dd->dd_descr), "%s (%s@%s)",
 	    dkw.dkw_wname, dkw.dkw_devname, dkw.dkw_parent);
 	return true;
+}
 static bool
 get_name_and_parent(const char *dev, char *name, char *parent)
+{
 	struct dkwedge_info dkw;
 	if (!get_wedge_info(dev, &dkw))
 		return false;
 	strcpy(name, (const char *)dkw.dkw_wname);
 	strcpy(parent, dkw.dkw_parent);
 	return true;
+}
 static bool
 find_swap_part_on(const char *dev, char *swap_name)
+{
 	struct dkwedge_list dkwl;
 	struct dkwedge_info *dkw;
 	u_int i;
 	bool res = false;
 	if (!get_wedge_list(dev, &dkwl))
 		return false;
 	dkw = dkwl.dkwl_buf;
 	for (i = 0; i < dkwl.dkwl_nwedges; i++) {
 		res = strcmp(dkw[i].dkw_ptype, DKW_PTYPE_SWAP) == 0;
 		if (res) {
 			strcpy(swap_name, (const char*)dkw[i].dkw_wname);
 			break;
+		}
+	}
 	free(dkwl.dkwl_buf);
 	return res;
+}
 static bool
 is_ffs_wedge(const char *dev)
+{
 	struct dkwedge_info dkw;
 	if (!get_wedge_info(dev, &dkw))
 		return false;
 	return strcmp(dkw.dkw_ptype, DKW_PTYPE_FFS) == 0;
+}
 /*
  * Does this device match an entry in our default CDROM device list?
  * If looking for install targets, we also flag floopy devices.
  */
 bool
 is_cdrom_device(const char *dev, bool as_target)
+{
 	static const char *target_devices[] = {
 #ifdef CD_NAMES
 		CD_NAMES
 #endif
 #if defined(CD_NAMES) && defined(FLOPPY_NAMES)
+		,
 #endif
 #ifdef FLOPPY_NAMES
 		FLOPPY_NAMES
 #endif
 #if defined(CD_NAMES) || defined(FLOPPY_NAMES)
+		,
 #endif
 	};
 	static const char *src_devices[] = {
 #ifdef CD_NAMES
 		CD_NAMES ,
 #endif
 	};
 	for (const char **dev_pat = as_target ? target_devices : src_devices;
 	     *dev_pat; dev_pat++)
 		if (fnmatch(*dev_pat, dev, 0) == 0)
 			return true;
 	return false;
+}
 /* does this device match any entry in the driver list? */
 static bool
 dev_in_list(const char *dev, const char **list)
+{
 	for ( ; *list; list++) {
 		size_t len = strlen(*list);
 		/* start of name matches? */
 		if (strncmp(dev, *list, len) == 0) {
 			char *endp;
 			int e;
 			/* remainder of name is a decimal number? */
 			strtou(dev+len, &endp, 10, 0, INT_MAX, &e);
 			if (endp && *endp == 0 && e == 0)
 				return true;
+		}
+	}
 	return false;
+}
 bool
 is_bootable_device(const char *dev)
+{
 	static const char *non_bootable_devs[] = {
 		"raid",	/* bootcode lives outside of raid */
 		"xbd",	/* xen virtual device, can not boot from that */
 		NULL
 	};
 	return !dev_in_list(dev, non_bootable_devs);
+}
 bool
 is_partitionable_device(const char *dev)
+{
 	static const char *non_partitionable_devs[] = {
 		"dk",	/* this is already a partitioned slice */
 		NULL
 	};
 	return !dev_in_list(dev, non_partitionable_devs);
+}
 /*
  * Multi-purpose helper function:
  * iterate all known disks, invoke a callback for each.
  * Stop iteration when the callback returns false.
  * Return true when iteration actually happend, false on error.
  */
 bool
 enumerate_disks(void *state, bool (*func)(void *state, const char *dev))
+{
 	static const int mib[] = { CTL_HW, HW_DISKNAMES };
 	static const unsigned int miblen = __arraycount(mib);
 	const char *xd;
 	char *disk_names;
 	size_t len;
 	if (sysctl(mib, miblen, NULL, &len, NULL, 0) == -1)
 		return false;
 	disk_names = malloc(len);
 	if (disk_names == NULL)
 		return false;
 	if (sysctl(mib, miblen, disk_names, &len, NULL, 0) == -1) {
 		free(disk_names);
 		return false;
+	}
 	for (xd = strtok(disk_names, " "); xd != NULL; xd = strtok(NULL, " ")) {
 		if (!(*func)(state, xd))
 			break;
+	}
 	free(disk_names);
 	return true;
+}
 /*
  * Helper state for get_disks
  */
 struct get_disks_state {
 	int numdisks;
 	struct disk_desc *dd;
 	bool with_non_partitionable;
 };
 /*
  * Helper function for get_disks enumartion
  */
 static bool
 get_disks_helper(void *arg, const char *dev)
+{
 	struct get_disks_state *state = arg;
 	struct disk_geom geo;
 	/* is this a CD device? */
 	if (is_cdrom_device(dev, true))
 		return true;
 	memset(state->dd, 0, sizeof(*state->dd));
 	strlcpy(state->dd->dd_name, dev, sizeof state->dd->dd_name - 2);
 	state->dd->dd_no_mbr = !is_bootable_device(dev);
 	state->dd->dd_no_part = !is_partitionable_device(dev);
 	if (state->dd->dd_no_part && !state->with_non_partitionable)
 		return true;
 	if (!get_disk_geom(state->dd->dd_name, &geo)) {
 		if (errno == ENOENT)
 			return true;
 		if (errno != ENOTTY || !state->dd->dd_no_part)
 			/*
 			 * Allow plain partitions,
 			 * like already existing wedges
 			 * (like dk0) if marked as
 			 * non-partitioning device.
 			 * For all other cases, continue
 			 * with the next disk.
 			 */
 			return true;
 		if (!is_ffs_wedge(state->dd->dd_name))
 			return true;
+	}
 	/*
 	 * Exclude a disk mounted as root partition,
 	 * in case of install-image on a USB memstick.
 	 */
 	if (is_active_rootpart(state->dd->dd_name,
 	    state->dd->dd_no_part ? -1 : 0))
 		return true;
 	state->dd->dd_cyl = geo.dg_ncylinders;
 	state->dd->dd_head = geo.dg_ntracks;
 	state->dd->dd_sec = geo.dg_nsectors;
 	state->dd->dd_secsize = geo.dg_secsize;
 	state->dd->dd_totsec = geo.dg_secperunit;
 	if (!state->dd->dd_no_part || !get_wedge_descr(state->dd))
 		get_descr(state->dd);
 	state->dd++;
 	state->numdisks++;
 	if (state->numdisks == MAX_DISKS)
 		return false;
 	return true;
+}
 /*
  * Get all disk devices that are not CDs.
  * Optionally leave out those that can not be partitioned further.
  */
 static int
 get_disks(struct disk_desc *dd, bool with_non_partitionable)
+{
 	struct get_disks_state state;
 	/* initialize */
 	state.numdisks = 0;
 	state.dd = dd;
 	state.with_non_partitionable = with_non_partitionable;
 	if (enumerate_disks(&state, get_disks_helper))
 		return state.numdisks;
 	return 0;
+}
 #ifdef DEBUG_VERBOSE
 static void
 dump_parts(const struct disk_partitions *parts)
+{
 	fprintf(stderr, "%s partitions on %s:\n",
 	    MSG_XLAT(parts->pscheme->short_name), parts->disk);
 	for (size_t p = 0; p < parts->num_part; p++) {
 		struct disk_part_info info;
 		if (parts->pscheme->get_part_info(
 		    parts, p, &info)) {
 			fprintf(stderr, " #%zu: start: %" PRIu64 " "
 			    "size: %" PRIu64 ", flags: %x\n",
 			    p, info.start, info.size,
 			    info.flags);
 			if (info.nat_type)
 				fprintf(stderr, "\ttype: %s\n",
 				    info.nat_type->description);
 		} else {
 			fprintf(stderr, "failed to get info "
 			    "for partition #%zu\n", p);
+		}
+	}
 	fprintf(stderr, "%" PRIu64 " sectors free, disk size %" PRIu64
 	    " sectors, %zu partitions used\n", parts->free_space,
 	    parts->disk_size, parts->num_part);
+}
 #endif
 static bool
 delete_scheme(struct pm_devs *p)
+{
 	if (!ask_noyes(MSG_removepartswarn))
 		return false;
 	p->parts->pscheme->free(p->parts);
 	p->parts = NULL;
 	return true;
+}
 static void
 convert_copy(struct disk_partitions *old_parts,
     struct disk_partitions *new_parts)
+{
 	struct disk_part_info oinfo, ninfo;
 	part_id i;
 	for (i = 0; i < old_parts->num_part; i++) {
 		if (!old_parts->pscheme->get_part_info(old_parts, i, &oinfo))
 			continue;
 		if (oinfo.flags & PTI_PSCHEME_INTERNAL)
 			continue;
 		if (oinfo.flags & PTI_SEC_CONTAINER) {
 		    	if (old_parts->pscheme->secondary_partitions) {
 				struct disk_partitions *sec_part =
 					old_parts->pscheme->
 					    secondary_partitions(
 					    old_parts, oinfo.start, false);
 				if (sec_part)
 					convert_copy(sec_part, new_parts);
+			}
 			continue;
+		}
 		if (!new_parts->pscheme->adapt_foreign_part_info(new_parts,
 			    &ninfo, old_parts->pscheme, &oinfo))
 			continue;
 		new_parts->pscheme->add_partition(new_parts, &ninfo, NULL);
+	}
+}
 bool
 convert_scheme(struct pm_devs *p, bool is_boot_drive, const char **err_msg)
+{
 	struct disk_partitions *old_parts, *new_parts;
 	const struct disk_partitioning_scheme *new_scheme;
 	*err_msg = NULL;
 	old_parts = p->parts;
 	new_scheme = select_part_scheme(p, old_parts->pscheme,
 	    false, MSG_select_other_partscheme);
-	if (new_scheme == NULL)
+	if (new_scheme == NULL) {
 		if (err_msg)
 			*err_msg = INTERNAL_ERROR;
 		return false;
+	}
 	new_parts = new_scheme->create_new_for_disk(p->diskdev,
 , p->dlsize, is_boot_drive, NULL);
-	if (new_parts == NULL)
+	if (new_parts == NULL) {
 		if (err_msg)
 			*err_msg = MSG_out_of_memory;
 		return false;
+	}
 	convert_copy(old_parts, new_parts);
-	if (new_parts->num_part == 0) {
+	if (new_parts->num_part == 0 && old_parts->num_part != 0) {
 		/* need to cleanup */
 		new_parts->pscheme->free(new_parts);
 		return false;
+	}
 	old_parts->pscheme->free(old_parts);
 	p->parts = new_parts;
 	return true;
+}
 static struct pm_devs *
 dummy_whole_system_pm(void)
+{
 	static struct pm_devs whole_system = {
 		.diskdev = "/",
 		.no_mbr = true,
 		.no_part = true,
 		.cur_system = true,
 	};
 	static bool init = false;
 	if (!init) {
 		strlcpy(whole_system.diskdev_descr,
 		    msg_string(MSG_running_system),
 		    sizeof whole_system.diskdev_descr);
+	}
 	return &whole_system;
+}
 int
 find_disks(const char *doingwhat, bool allow_cur_system)
+{
 	struct disk_desc disks[MAX_DISKS];
 	/* need two more menu entries: current system + extended partitioning */
 	menu_ent dsk_menu[__arraycount(disks) + 2];
 	struct disk_desc *disk;
 	int i = 0, skipped = 0;
 	int already_found, numdisks, selected_disk = -1;
 	int menu_no;
 	struct pm_devs *pm_i, *pm_last = NULL;
 	memset(dsk_menu, 0, sizeof(dsk_menu));
 	/* Find disks. */
 	numdisks = get_disks(disks, partman_go <= 0);
 	/* need a redraw here, kernel messages hose everything */
 	touchwin(stdscr);
 	refresh();
 	/* Kill typeahead, it won't be what the user had in mind */
 	fpurge(stdin);
 	/*
 	 * partman_go: <0 - we want to see menu with extended partitioning
 	 *            ==0 - we want to see simple select disk menu
 	 *             >0 - we do not want to see any menus, just detect
 	 *                  all disks
 	 */
 	if (partman_go <= 0) {
 		if (numdisks == 0 && !allow_cur_system) {
 			/* No disks found! */
 			hit_enter_to_continue(MSG_nodisk, NULL);
 			/*endwin();*/
 			return -1;
 		} else {
 			/* One or more disks found or current system allowed */
 			i = 0;
 			if (allow_cur_system) {
 				dsk_menu[i].opt_name = MSG_running_system;
 				dsk_menu[i].opt_flags = OPT_EXIT;
 				dsk_menu[i].opt_action = set_menu_select;
 				i++;
+			}
 			for (; i < numdisks+allow_cur_system; i++) {
 				dsk_menu[i].opt_name =
 				    disks[i-allow_cur_system].dd_descr;
 				dsk_menu[i].opt_flags = OPT_EXIT;
 				dsk_menu[i].opt_action = set_menu_select;
+			}
 			if (partman_go < 0) {
 				dsk_menu[i].opt_name = MSG_partman;
 				dsk_menu[i].opt_flags = OPT_EXIT;
 				dsk_menu[i].opt_action = set_menu_select;
 				i++;
+			}
 			menu_no = new_menu(MSG_Available_disks,
 				dsk_menu, i, -1,
 , 0, 0, MC_SCROLL,
 				NULL, NULL, NULL, NULL, MSG_exit_menu_generic);
 			if (menu_no == -1)
 				return -1;
 			msg_fmt_display(MSG_ask_disk, "%s", doingwhat);
 			process_menu(menu_no, &selected_disk);
 			free_menu(menu_no);
 			if (allow_cur_system) {
 				if (selected_disk == 0) {
 					pm = dummy_whole_system_pm();
 					return 1;
 				} else {
 					selected_disk--;
+				}
+			}
+		}
 		if (partman_go < 0 && selected_disk == numdisks) {
 			partman_go = 1;
 			return -2;
 		} else
 			partman_go = 0;
 		if (selected_disk < 0 || selected_disk >= numdisks)
 			return -1;
+	}
 	/* Fill pm struct with device(s) info */
 	for (i = 0; i < numdisks; i++) {
 		if (! partman_go)
 			disk = disks + selected_disk;
 		else {
 			disk = disks + i;
 			already_found = 0;
 			SLIST_FOREACH(pm_i, &pm_head, l) {
 				pm_last = pm_i;
 				if (strcmp(pm_i->diskdev, disk->dd_name) == 0) {
 					already_found = 1;
 					break;
+				}
+			}
 			if (pm_i != NULL && already_found) {
 				/*
 				 * We already added this device, but
 				 * partitions might have changed
 				 */
 				if (!pm_i->found) {
 					pm_i->found = true;
 					if (pm_i->parts == NULL) {
 						pm_i->parts =
 						    partitions_read_disk(
 						    pm_i->diskdev,
 						    disk->dd_totsec,
 						    disk->dd_secsize,
 						    disk->dd_no_mbr);
+					}
+				}
 				continue;
+			}
+		}
 		pm = pm_new;
 		pm->found = 1;
 		pm->ptstart = 0;
 		pm->ptsize = 0;
 		strlcpy(pm->diskdev, disk->dd_name, sizeof pm->diskdev);
 		strlcpy(pm->diskdev_descr, disk->dd_descr, sizeof pm->diskdev_descr);
 		/* Use as a default disk if the user has the sets on a local disk */
 		strlcpy(localfs_dev, disk->dd_name, sizeof localfs_dev);
 		/*
 		 * Init disk size and geometry
 		 */
 		pm->sectorsize = disk->dd_secsize;
 		pm->dlcyl = disk->dd_cyl;
 		pm->dlhead = disk->dd_head;
 		pm->dlsec = disk->dd_sec;
 		pm->dlsize = disk->dd_totsec;
 		if (pm->dlsize == 0)
 			pm->dlsize =
 			    disk->dd_cyl * disk->dd_head * disk->dd_sec;
 		pm->parts = partitions_read_disk(pm->diskdev,
 		    pm->dlsize, disk->dd_secsize, disk->dd_no_mbr);
 again:
 #ifdef DEBUG_VERBOSE
 		if (pm->parts) {
 			fputs("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", stderr);
 			dump_parts(pm->parts);
 			if (pm->parts->pscheme->secondary_partitions) {
 				const struct disk_partitions *sparts =
 				    pm->parts->pscheme->secondary_partitions(
 				    pm->parts, pm->ptstart, false);
 				if (sparts != NULL)
 					dump_parts(sparts);
+			}
+		}
 #endif
 		pm->no_mbr = disk->dd_no_mbr;
 		pm->no_part = disk->dd_no_part;
 		if (!pm->no_part) {
 			pm->sectorsize = disk->dd_secsize;
 			pm->dlcyl = disk->dd_cyl;
 			pm->dlhead = disk->dd_head;
 			pm->dlsec = disk->dd_sec;
 			pm->dlsize = disk->dd_totsec;
 			if (pm->dlsize == 0)
 				pm->dlsize =
 				    disk->dd_cyl * disk->dd_head * disk->dd_sec;
 			if (pm->parts && pm->parts->pscheme->size_limit != 0
 			    && pm->dlsize > pm->parts->pscheme->size_limit
 			    && ! partman_go) {
 				char size[5], limit[5];
 				humanize_number(size, sizeof(size),
 				    (uint64_t)pm->dlsize * pm->sectorsize,
 				    "", HN_AUTOSCALE, HN_B | HN_NOSPACE
 				    | HN_DECIMAL);
 				humanize_number(limit, sizeof(limit),
 				    (uint64_t)pm->parts->pscheme->size_limit
 					* 512U,
 				    "", HN_AUTOSCALE, HN_B | HN_NOSPACE
 				    | HN_DECIMAL);
 				if (logfp)
 					fprintf(logfp,
 					    "disk %s: is too big (%" PRIu64
 					    " blocks, %s), will be truncated\n",
 						pm->diskdev, pm->dlsize,
 						size);
 				msg_display_subst(MSG_toobigdisklabel, 5,
 				   pm->diskdev,
 				   msg_string(pm->parts->pscheme->name),
 				   msg_string(pm->parts->pscheme->short_name),
 				   size, limit);
 				int sel = -1;
 				const char *err = NULL;
 				process_menu(MENU_convertscheme, &sel);
 				if (sel == 1) {
 					if (!delete_scheme(pm)) {
 						return -1;
+					}
 					goto again;
 				} else if (sel == 2) {
 					if (!convert_scheme(pm,
 					     partman_go < 0, &err)) {
 						if (err != NULL)
 							err_msg_win(err);
 						return -1;
+					}
 					goto again;
 				} else if (sel == 3) {
 					return -1;
+				}
 				pm->dlsize = pm->parts->pscheme->size_limit;
+			}
 		} else {
 			pm->sectorsize = 0;
 			pm->dlcyl = 0;
 			pm->dlhead = 0;
 			pm->dlsec = 0;
 			pm->dlsize = 0;
 			pm->no_mbr = 1;
+		}
 		pm->dlcylsize = pm->dlhead * pm->dlsec;
 		if (partman_go) {
 			pm_getrefdev(pm_new);
 			if (SLIST_EMPTY(&pm_head) || pm_last == NULL)
 				 SLIST_INSERT_HEAD(&pm_head, pm_new, l);
 			else
 				 SLIST_INSERT_AFTER(pm_last, pm_new, l);
 			pm_new = malloc(sizeof (struct pm_devs));
 			memset(pm_new, 0, sizeof *pm_new);
 		} else
 			/* We are not in partman and do not want to process
 			 * all devices, exit */
 			break;
+	}
 	return numdisks-skipped;
+}
 static int
 sort_part_usage_by_mount(const void *a, const void *b)
+{
 	const struct part_usage_info *pa = a, *pb = b;
 	/* sort all real partitions by mount point */
 	if ((pa->instflags & PUIINST_MOUNT) &&
 	    (pb->instflags & PUIINST_MOUNT))
 		return strcmp(pa->mount, pb->mount);
 	/* real partitions go first */
 	if (pa->instflags & PUIINST_MOUNT)
 		return -1;
 	if (pb->instflags & PUIINST_MOUNT)
 		return 1;
 	/* arbitrary order for all other partitions */
 	if (pa->type == PT_swap)
 		return -1;
 	if (pb->type == PT_swap)
 		return 1;
 	if (pa->type < pb->type)
 		return -1;
 	if (pa->type > pb->type)
 		return 1;
 	if (pa->cur_part_id < pb->cur_part_id)
 		return -1;
 	if (pa->cur_part_id > pb->cur_part_id)
 		return 1;
 	return (uintptr_t)a < (uintptr_t)b ? -1 : 1;
+}
 int
 make_filesystems(struct install_partition_desc *install)
+{
 	int error = 0, partno = -1;
 	char *newfs = NULL, devdev[PATH_MAX], rdev[PATH_MAX],
 	    opts[200], opt[30];
 	size_t i;
 	struct part_usage_info *ptn;
 	struct disk_partitions *parts;
 	const char *mnt_opts = NULL, *fsname = NULL;
 	if (pm->cur_system)
 		return 1;
 	if (pm->no_part) {
 		/* check if this target device already has a ffs */
 		snprintf(rdev, sizeof rdev, _PATH_DEV "/r%s", pm->diskdev);
 		error = fsck_preen(rdev, "ffs", true);
 		if (error) {
 			if (!ask_noyes(MSG_No_filesystem_newfs))
 				return EINVAL;
 			error = run_program(RUN_DISPLAY | RUN_PROGRESS,
 			    "/sbin/newfs -V2 -O2 %s", rdev);
+		}
 		md_pre_mount(install, 0);
 		make_target_dir("/");
 		snprintf(devdev, sizeof devdev, _PATH_DEV "%s", pm->diskdev);
 		error = target_mount_do("-o async", devdev, "/");
 		if (error) {
 			msg_display_subst(MSG_mountfail, 2, devdev, "/");
 			hit_enter_to_continue(NULL, NULL);
+		}
 		return error;
+	}
 	/* Making new file systems and mounting them */
 	/* sort to ensure /usr/local is mounted after /usr (etc) */
 	qsort(install->infos, install->num, sizeof(*install->infos),
 	    sort_part_usage_by_mount);
 	for (i = 0; i < install->num; i++) {
 		/*
 		 * Newfs all file systems marked as needing this.
 		 * Mount the ones that have a mountpoint in the target.
 		 */
 		ptn = &install->infos[i];
 		parts = ptn->parts;
 		newfs = NULL;
 		fsname = NULL;
 		if (ptn->size == 0 || parts == NULL|| ptn->type == PT_swap)
 			continue;
 		if (parts->pscheme->get_part_device(parts, ptn->cur_part_id,
 		    devdev, sizeof devdev, &partno, parent_device_only, false,
 		    false) && is_active_rootpart(devdev, partno))
 			continue;
 		parts->pscheme->get_part_device(parts, ptn->cur_part_id,
 		    devdev, sizeof devdev, &partno, plain_name, true, true);
 		parts->pscheme->get_part_device(parts, ptn->cur_part_id,
 		    rdev, sizeof rdev, &partno, raw_dev_name, true, true);
 		opts[0] = 0;
 		switch (ptn->fs_type) {
 		case FS_APPLEUFS:
 			if (ptn->fs_opt3 != 0)
 				snprintf(opts, sizeof opts, "-i %u",
 				    ptn->fs_opt3);
 			asprintf(&newfs, "/sbin/newfs %s", opts);
 			mnt_opts = "-tffs -o async";
 			fsname = "ffs";
 			break;
 		case FS_BSDFFS:
 			if (ptn->fs_opt3 != 0)
 				snprintf(opts, sizeof opts, "-i %u ",
 				    ptn->fs_opt3);
 			if (ptn->fs_opt1 != 0) {
 				snprintf(opt, sizeof opt, "-b %u ",
 				    ptn->fs_opt1);
 				strcat(opts, opt);
+			}
 			if (ptn->fs_opt2 != 0) {
 				snprintf(opt, sizeof opt, "-f %u ",
 				    ptn->fs_opt2);
 				strcat(opts, opt);
+			}
 			asprintf(&newfs,
 			    "/sbin/newfs -V2 -O %d %s",
 			    ptn->fs_version == 2 ? 2 : 1, opts);
 			if (ptn->mountflags & PUIMNT_LOG)
 				mnt_opts = "-tffs -o log";
 			else
 				mnt_opts = "-tffs -o async";
 			fsname = "ffs";
 			break;
 		case FS_BSDLFS:
 			if (ptn->fs_opt1 != 0 && ptn->fs_opt2 != 0)
 				snprintf(opts, sizeof opts, "-b %u",
 				     ptn->fs_opt1 * ptn->fs_opt2);
 			asprintf(&newfs, "/sbin/newfs_lfs %s", opts);
 			mnt_opts = "-tlfs";
 			fsname = "lfs";
 			break;
 		case FS_MSDOS:
 			asprintf(&newfs, "/sbin/newfs_msdos");
 			mnt_opts = "-tmsdos";
 			fsname = "msdos";
 			break;
 		case FS_SYSVBFS:
 			asprintf(&newfs, "/sbin/newfs_sysvbfs");
 			mnt_opts = "-tsysvbfs";
 			fsname = "sysvbfs";
 			break;
 		case FS_V7:
 			asprintf(&newfs, "/sbin/newfs_v7fs");
 			mnt_opts = "-tv7fs";
 			fsname = "v7fs";
 			break;
 		case FS_EX2FS:
 			asprintf(&newfs,
 			    ptn->fs_version == 1 ?
 				"/sbin/newfs_ext2fs -O 0" :
 				"/sbin/newfs_ext2fs");
 			mnt_opts = "-text2fs";
 			fsname = "ext2fs";
 			break;
+		}
 		if ((ptn->instflags & PUIINST_NEWFS) && newfs != NULL) {
 			error = run_program(RUN_DISPLAY | RUN_PROGRESS,
 			    "%s %s", newfs, rdev);
 		} else if ((ptn->instflags & (PUIINST_MOUNT|PUIINST_BOOT))
 		    && fsname != NULL) {
 			/* We'd better check it isn't dirty */
 			error = fsck_preen(devdev, fsname, false);
+		}
 		free(newfs);
 		if (error != 0)
 			return error;
 		ptn->instflags &= ~PUIINST_NEWFS;
 		md_pre_mount(install, i);
 		if (partman_go == 0 && (ptn->instflags & PUIINST_MOUNT) &&
 				mnt_opts != NULL) {
 			make_target_dir(ptn->mount);
 			error = target_mount_do(mnt_opts, devdev,
 			    ptn->mount);
 			if (error) {
 				msg_display_subst(MSG_mountfail, 2, devdev,
 				    ptn->mount);
 				hit_enter_to_continue(NULL, NULL);
 				return error;
+			}
+		}
+	}
 	return 0;
+}
 int
 make_fstab(struct install_partition_desc *install)
+{
 	FILE *f;
 	const char *dump_dev = NULL;
 	const char *dev;
 	char dev_buf[PATH_MAX], swap_dev[PATH_MAX];
 	if (pm->cur_system)
 		return 1;
 	swap_dev[0] = 0;
 	/* Create the fstab. */
 	make_target_dir("/etc");
 	f = target_fopen("/etc/fstab", "w");
 	scripting_fprintf(NULL, "cat <<EOF >%s/etc/fstab\n", target_prefix());
 	if (logfp)
 		(void)fprintf(logfp,
 		    "Making %s/etc/fstab (%s).\n", target_prefix(),
 		    pm->diskdev);
 	if (f == NULL) {
 		msg_display(MSG_createfstab);
 		if (logfp)
 			(void)fprintf(logfp, "Failed to make /etc/fstab!\n");
 		hit_enter_to_continue(NULL, NULL);
 #ifndef DEBUG
 		return 1;
 #else
 		f = stdout;
 #endif
+	}
 	scripting_fprintf(f, "# NetBSD /etc/fstab\n# See /usr/share/examples/"
 			"fstab/ for more examples.\n");
 	if (pm->no_part) {
 		/* single dk? target */
 		char buf[200], parent[200], swap[200], *prompt;
 		int res;
 		if (!get_name_and_parent(pm->diskdev, buf, parent))
 			goto done_with_disks;
 		scripting_fprintf(f, NAME_PREFIX "%s\t/\tffs\trw\t\t1 1\n",
 		    buf);
 		if (!find_swap_part_on(parent, swap))
 			goto done_with_disks;
 		const char *args[] = { parent, swap };
 		prompt = str_arg_subst(msg_string(MSG_Auto_add_swap_part),
 		    __arraycount(args), args);
 		res = ask_yesno(prompt);
 		free(prompt);
 		if (res)
 			scripting_fprintf(f, NAME_PREFIX "%s\tnone"
 			    "\tswap\tsw,dp\t\t0 0\n", swap);
 		goto done_with_disks;
+	}
 	for (size_t i = 0; i < install->num; i++) {
 		const struct part_usage_info *ptn = &install->infos[i];
 		if (ptn->size == 0)
 			continue;
 		bool is_tmpfs = ptn->type == PT_root &&
 		    ptn->fs_type == FS_TMPFS &&
 		    (ptn->flags & PUIFLG_JUST_MOUNTPOINT);
 		if (!is_tmpfs && ptn->type != PT_swap &&
 		    (ptn->instflags & PUIINST_MOUNT) == 0)
 			continue;
 		const char *s = "";
 		const char *mp = ptn->mount;
 		const char *fstype = "ffs";
 		int fsck_pass = 0, dump_freq = 0;
 		if (ptn->parts->pscheme->get_part_device(ptn->parts,
 			    ptn->cur_part_id, dev_buf, sizeof dev_buf, NULL,
 			    logical_name, true, false))
 			dev = dev_buf;
 		else
 			dev = NULL;
 		if (!*mp) {
 			/*
 			 * No mount point specified, comment out line and
 			 * use /mnt as a placeholder for the mount point.
 			 */
 			s = "# ";
 			mp = "/mnt";
+		}
 		switch (ptn->fs_type) {
 		case FS_UNUSED:
 			continue;
 		case FS_BSDLFS:
 			/* If there is no LFS, just comment it out. */
 			if (!check_lfs_progs())
 				s = "# ";
 			fstype = "lfs";
 			/* FALLTHROUGH */
 		case FS_BSDFFS:
 			fsck_pass = (strcmp(mp, "/") == 0) ? 1 : 2;
 			dump_freq = 1;
 			break;
 		case FS_MSDOS:
 			fstype = "msdos";
 			break;
 		case FS_SWAP:
 			if (swap_dev[0] == 0) {
 				strlcpy(swap_dev, dev, sizeof swap_dev);
 				dump_dev = ",dp";
 			} else {
 				dump_dev = "";
+			}
 			scripting_fprintf(f, "%s\t\tnone\tswap\tsw%s\t\t 0 0\n",
 				dev, dump_dev);
 			continue;
 #ifdef HAVE_TMPFS
 		case FS_TMPFS:
 			if (ptn->size < 0)
 				scripting_fprintf(f,
 				    "tmpfs\t\t/tmp\ttmpfs\trw,-m=1777,"
 				    "-s=ram%%%" PRIu64 "\n", -ptn->size);
 			else
 				scripting_fprintf(f,
 				    "tmpfs\t\t/tmp\ttmpfs\trw,-m=1777,"
 				    "-s=%" PRIu64 "M\n", ptn->size);
 			continue;
 #else
 		case FS_MFS:
 			if (swap_dev[0] != 0)
 				scripting_fprintf(f,
 				    "%s\t\t/tmp\tmfs\trw,-s=%"
 				    PRIu64 "\n", swap_dev, ptn->size);
 			else
 				scripting_fprintf(f,
 				    "swap\t\t/tmp\tmfs\trw,-s=%"
 				    PRIu64 "\n", ptn->size);
 			continue;
 #endif
 		case FS_SYSVBFS:
 			fstype = "sysvbfs";
 			make_target_dir("/stand");
 			break;
 		default:
 			fstype = "???";
 			s = "# ";
 			break;
+		}
 		/* The code that remounts root rw doesn't check the partition */
 		if (strcmp(mp, "/") == 0 &&
 		    (ptn->instflags & PUIINST_MOUNT) == 0)
 			s = "# ";
  		scripting_fprintf(f,
 		  "%s%s\t\t%s\t%s\trw%s%s%s%s%s%s%s%s\t\t %d %d\n",
 		   s, dev, mp, fstype,
 		   ptn->mountflags & PUIMNT_LOG ? ",log" : "",
 		   ptn->mountflags & PUIMNT_NOAUTO ? ",noauto" : "",
 		   ptn->mountflags & PUIMNT_ASYNC ? ",async" : "",
 		   ptn->mountflags & PUIMNT_NOATIME ? ",noatime" : "",
 		   ptn->mountflags & PUIMNT_NODEV ? ",nodev" : "",
 		   ptn->mountflags & PUIMNT_NODEVMTIME ? ",nodevmtime" : "",
 		   ptn->mountflags & PUIMNT_NOEXEC ? ",noexec" : "",
 		   ptn->mountflags & PUIMNT_NOSUID ? ",nosuid" : "",
 		   dump_freq, fsck_pass);
+	}
 done_with_disks:
 	if (cdrom_dev[0] == 0)
 		get_default_cdrom(cdrom_dev, sizeof(cdrom_dev));
 	/* Add /kern, /proc and /dev/pts to fstab and make mountpoint. */
 	scripting_fprintf(f, "kernfs\t\t/kern\tkernfs\trw\n");
 	scripting_fprintf(f, "ptyfs\t\t/dev/pts\tptyfs\trw\n");
 	scripting_fprintf(f, "procfs\t\t/proc\tprocfs\trw\n");
 	if (cdrom_dev[0] != 0)
 		scripting_fprintf(f, "/dev/%s\t\t/cdrom\tcd9660\tro,noauto\n",
 		    cdrom_dev);
 	scripting_fprintf(f, "%stmpfs\t\t/var/shm\ttmpfs\trw,-m1777,-sram%%25\n",
 	    tmpfs_on_var_shm() ? "" : "#");
 	make_target_dir("/kern");
 	make_target_dir("/proc");
 	make_target_dir("/dev/pts");
 	if (cdrom_dev[0] != 0)
 		make_target_dir("/cdrom");
 	make_target_dir("/var/shm");
 	scripting_fprintf(NULL, "EOF\n");
 	fclose(f);
 	fflush(NULL);
 	return 0;
+}
 static bool
 find_part_by_name(const char *name, struct disk_partitions **parts,
     part_id *pno)
+{
 	struct pm_devs *i;
 	struct disk_partitions *ps;
 	part_id id;
 	struct disk_desc disks[MAX_DISKS];
 	int n, cnt;
 	if (SLIST_EMPTY(&pm_head)) {
 		/*
 		 * List has not been filled, only "pm" is valid - check
 		 * that first.
 		 */
 		if (pm->parts != NULL &&
 		    pm->parts->pscheme->find_by_name != NULL) {
 			id = pm->parts->pscheme->find_by_name(pm->parts, name);
 			if (id != NO_PART) {
 				*pno = id;
 				*parts = pm->parts;
 				return true;
+			}
+		}
 		/*
 		 * Not that easy - check all other disks
 		 */
 		cnt = get_disks(disks, false);
 		for (n = 0; n < cnt; n++) {
 			if (strcmp(disks[n].dd_name, pm->diskdev) == 0)
 				continue;
 			ps = partitions_read_disk(disks[n].dd_name,
 			    disks[n].dd_totsec,
 			    disks[n].dd_secsize,
 			    disks[n].dd_no_mbr);
 			if (ps == NULL)
 				continue;
 			if (ps->pscheme->find_by_name == NULL)
 				continue;
 			id = ps->pscheme->find_by_name(ps, name);
 			if (id != NO_PART) {
 				*pno = id;
 				*parts = ps;
 				return true;	/* XXX this leaks memory */
+			}
 			ps->pscheme->free(ps);
+		}
 	} else {
 		SLIST_FOREACH(i, &pm_head, l) {
 			if (i->parts == NULL)
 				continue;
 			if (i->parts->pscheme->find_by_name == NULL)
 				continue;
 			id = i->parts->pscheme->find_by_name(i->parts, name);
 			if (id == NO_PART)
 				continue;
 			*pno = id;
 			*parts = i->parts;
 			return true;
+		}
+	}
 	*pno = NO_PART;
 	*parts = NULL;
 	return false;
+}
 static int
 /*ARGSUSED*/
 process_found_fs(struct data *list, size_t num, const struct lookfor *item,
     bool with_fsck)
+{
 	int error;
 	char rdev[PATH_MAX], dev[PATH_MAX],
 	    options[STRSIZE], tmp[STRSIZE], *op, *last;
 	const char *fsname = (const char*)item->var;
 	part_id pno;
 	struct disk_partitions *parts;
 	size_t len;
 	bool first, is_root;
 	if (num < 2 || strstr(list[2].u.s_val, "noauto") != NULL)
 		return 0;
 	is_root = strcmp(list[1].u.s_val, "/") == 0;
 	if (is_root && target_mounted())
 		return 0;
 	if (strcmp(item->head, name_prefix) == 0) {
 		/* this fstab entry uses NAME= syntax */
 		/* unescape */
 		char *src, *dst;
 		for (src = list[0].u.s_val, dst =src; src[0] != 0; ) {
 			if (src[0] == '\\' && src[1] != 0)
 				src++;
 			*dst++ = *src++;
+		}
 		*dst = 0;
 		if (!find_part_by_name(list[0].u.s_val,
 		    &parts, &pno) || parts == NULL || pno == NO_PART)
 			return 0;
 		parts->pscheme->get_part_device(parts, pno,
 		    dev, sizeof(dev), NULL, plain_name, true, true);
 		parts->pscheme->get_part_device(parts, pno,
 		    rdev, sizeof(rdev), NULL, raw_dev_name, true, true);
 	} else {
 		/* this fstab entry uses the plain device name */
 		if (is_root) {
 			/*
 			 * PR 54480: we can not use the current device name
 			 * as it might be different from the real environment.
 			 * This is an abuse of the functionality, but it used
 			 * to work before (and still does work if only a single
 			 * target disk is involved).
 			 * Use the device name from the current "pm" instead.
 			 */
 			strcpy(rdev, "/dev/r");
 			strlcat(rdev, pm->diskdev, sizeof(rdev));
 			strcpy(dev, "/dev/");
 			strlcat(dev, pm->diskdev, sizeof(dev));
 			/* copy over the partition letter, if any */
 			len = strlen(list[0].u.s_val);
 			if (list[0].u.s_val[len-1] >= 'a' &&
 			    list[0].u.s_val[len-1] <=
 			    ('a' + getmaxpartitions())) {
 				strlcat(rdev, &list[0].u.s_val[len-1],
 				    sizeof(rdev));
 				strlcat(dev, &list[0].u.s_val[len-1],
 				    sizeof(dev));
+			}
 		} else {
 			strcpy(rdev, "/dev/r");
 			strlcat(rdev, list[0].u.s_val, sizeof(rdev));
 			strcpy(dev, "/dev/");
 			strlcat(dev, list[0].u.s_val, sizeof(dev));
+		}
+	}
 	if (with_fsck) {
 		/* need the raw device for fsck_preen */
 		error = fsck_preen(rdev, fsname, false);
 		if (error != 0)
 			return error;
+	}
 	/* add mount option for fs type */
 	strcpy(options, "-t ");
 	strlcat(options, fsname, sizeof(options));
 	/* extract mount options from fstab */
 	strlcpy(tmp, list[2].u.s_val, sizeof(tmp));
 	for (first = true, op = strtok_r(tmp, ",", &last); op != NULL;
 	    op = strtok_r(NULL, ",", &last)) {
 		if (strcmp(op, FSTAB_RW) == 0 ||
 		    strcmp(op, FSTAB_RQ) == 0 ||
 		    strcmp(op, FSTAB_RO) == 0 ||
 		    strcmp(op, FSTAB_SW) == 0 ||
 		    strcmp(op, FSTAB_DP) == 0 ||
 		    strcmp(op, FSTAB_XX) == 0)
 			continue;
 		if (first) {
 			first = false;
 			strlcat(options, " -o ", sizeof(options));
 		} else {
 			strlcat(options, ",", sizeof(options));
+		}
 		strlcat(options, op, sizeof(options));
+	}
 	error = target_mount(options, dev, list[1].u.s_val);
 	if (error != 0) {
 		msg_fmt_display(MSG_mount_failed, "%s", list[0].u.s_val);
 		if (!ask_noyes(NULL))
 			return error;
+	}
 	return 0;
+}
 static int
 /*ARGSUSED*/
 found_fs(struct data *list, size_t num, const struct lookfor *item)
+{
 	return process_found_fs(list, num, item, true);
+}
 static int
 /*ARGSUSED*/
 found_fs_nocheck(struct data *list, size_t num, const struct lookfor *item)
+{
 	return process_found_fs(list, num, item, false);
+}
 /*
  * Do an fsck. On failure, inform the user by showing a warning
  * message and doing menu_ok() before proceeding.
  * The device passed should be the full qualified path to raw disk
  * (e.g. /dev/rwd0a).
  * Returns 0 on success, or nonzero return code from fsck() on failure.
  */
 static int
 fsck_preen(const char *disk, const char *fsname, bool silent)
+{
 	char *prog, err[12];
 	int error;
 	if (fsname == NULL)
 		return 0;
 	/* first, check if fsck program exists, if not, assume ok */
 	asprintf(&prog, "/sbin/fsck_%s", fsname);
 	if (prog == NULL)
 		return 0;
 	if (access(prog, X_OK) != 0) {
 		free(prog);
 		return 0;
+	}
 	if (!strcmp(fsname,"ffs"))
 		fixsb(prog, disk);
 	error = run_program(silent? RUN_SILENT|RUN_ERROR_OK : 0, "%s -p -q %s", prog, disk);
 	free(prog);
 	if (error != 0 && !silent) {
 		sprintf(err, "%d", error);
 		msg_display_subst(msg_string(MSG_badfs), 3,
 		    disk, fsname, err);
 		if (ask_noyes(NULL))
 			error = 0;
 		/* XXX at this point maybe we should run a full fsck? */
+	}
 	return error;
+}
 /* This performs the same function as the etc/rc.d/fixsb script
  * which attempts to correct problems with ffs1 filesystems
  * which may have been introduced by booting a netbsd-current kernel
  * from between April of 2003 and January 2004. For more information
  * This script was developed as a response to NetBSD pr install/25138
  * Additional prs regarding the original issue include:
  *  bin/17910 kern/21283 kern/21404 port-macppc/23925 port-macppc/23926
  */
 static void
 fixsb(const char *prog, const char *disk)
+{
 	int fd;
 	int rval;
 	union {
 		struct fs fs;
 		char buf[SBLOCKSIZE];
 	} sblk;
 	struct fs *fs = &sblk.fs;
 	fd = open(disk, O_RDONLY);
 	if (fd == -1)
 		return;
 	/* Read ffsv1 main superblock */
 	rval = pread(fd, sblk.buf, sizeof sblk.buf, SBLOCK_UFS1);
 	close(fd);
 	if (rval != sizeof sblk.buf)
 		return;
 	if (fs->fs_magic != FS_UFS1_MAGIC &&
 	    fs->fs_magic != FS_UFS1_MAGIC_SWAPPED)
 		/* Not FFSv1 */
 		return;
 	if (fs->fs_old_flags & FS_FLAGS_UPDATED)
 		/* properly updated fslevel 4 */
 		return;
 	if (fs->fs_bsize != fs->fs_maxbsize)
 		/* not messed up */
 		return;
 	/*
 	 * OK we have a munged fs, first 'upgrade' to fslevel 4,
 	 * We specify -b16 in order to stop fsck bleating that the
 	 * sb doesn't match the first alternate.
 	 */
 	run_program(RUN_DISPLAY | RUN_PROGRESS,
 	    "%s -p -b 16 -c 4 %s", prog, disk);
 	/* Then downgrade to fslevel 3 */
 	run_program(RUN_DISPLAY | RUN_PROGRESS,
 	    "%s -p -c 3 %s", prog, disk);
+}
 /*
  * fsck and mount the root partition.
  * devdev is the fully qualified block device name.
  */
 static int
 mount_root(const char *devdev, bool first, bool writeable,
      struct install_partition_desc *install)
+{
 	int	error;
 	error = fsck_preen(devdev, "ffs", false);
 	if (error != 0)
 		return error;
 	if (first)
 		md_pre_mount(install, 0);
 	/* Mount devdev on target's "".
 	 * If we pass "" as mount-on, Prefixing will DTRT.
 	 * for now, use no options.
 	 * XXX consider -o remount in case target root is
 	 * current root, still readonly from single-user?
 	 */
 	return target_mount(writeable? "" : "-r", devdev, "");
+}
 /* Get information on the file systems mounted from the root filesystem.
  * Offer to convert them into 4.4BSD inodes if they are not 4.4BSD
  * inodes.  Fsck them.  Mount them.
  */
 int
 mount_disks(struct install_partition_desc *install)
+{
 	char *fstab;
 	int   fstabsize;
 	int   error;
 	char devdev[PATH_MAX];
 	size_t i, num_fs_types, num_entries;
 	struct lookfor *fstabbuf, *l;