 @@ -1,1855 +1,1858 @@
-/*	$NetBSD: gpt.c,v 1.23 2021/01/31 22:45:46 rillig Exp $	*/
+/*	$NetBSD: gpt.c,v 1.24 2021/07/17 11:32:50 martin Exp $	*/
 /*
  * Copyright 2018 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * 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.
+ *
  * 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.
+ *
  */
 #include "defs.h"
 #include "mbr.h"
 #include "md.h"
 #include "gpt_uuid.h"
 #include <assert.h>
 #include <err.h>
 #include <paths.h>
 #include <sys/param.h>
 #include <sys/ioctl.h>
 #include <util.h>
 #include <uuid.h>
 bool	gpt_parts_check(void);	/* check for needed binaries */
 /*************** GPT ************************************************/
 /* a GPT based disk_partitions interface */
 #define GUID_STR_LEN	40
 #define	GPT_PTYPE_ALLOC	32	/* initial type array allocation, should be >
 				 * gpt type -l | wc -l */
 #define	GPT_DEV_LEN	16	/* dkNN */
 #define	GPT_PARTS_PER_SEC	4	/* a 512 byte sector holds 4 entries */
 #define	GPT_DEFAULT_MAX_PARTS	128
 /* a usable label will be short, so we can get away with an arbitrary limit */
 #define	GPT_LABEL_LEN		96
 #define	GPT_ATTR_BIOSBOOT	1
 #define	GPT_ATTR_BOOTME		2
 #define	GPT_ATTR_BOOTONCE	4
 #define	GPT_ATTR_BOOTFAILED	8
 #define	GPT_ATTR_NOBLOCKIO	16
 #define	GPT_ATTR_REQUIRED	32
 /* when we don't care for BIOS or UEFI boot, use the combined boot flags */
 #define	GPT_ATTR_BOOT	(GPT_ATTR_BIOSBOOT|GPT_ATTR_BOOTME)
 struct gpt_attr_desc {
 	const char *name;
 	uint flag;
 };
 static const struct gpt_attr_desc gpt_avail_attrs[] = {
 	{ "biosboot", GPT_ATTR_BIOSBOOT },
 	{ "bootme", GPT_ATTR_BOOTME },
 	{ "bootonce", GPT_ATTR_BOOTONCE },
 	{ "bootfailed", GPT_ATTR_BOOTFAILED },
 	{ "noblockio", GPT_ATTR_NOBLOCKIO },
 	{ "required", GPT_ATTR_REQUIRED },
 	{ NULL, 0 }
 };
 struct gpt_ptype_desc {
 	struct part_type_desc gent;
 	char tid[GUID_STR_LEN];
 	uint fsflags, default_fs_type;
 };
 static const
 struct {
 	const char *name;
 	uint fstype;
 	enum part_type ptype;
 	uint fsflags;
 } gpt_fs_types[] = {
 	{ .name = "ffs",	.fstype = FS_BSDFFS,	.ptype = PT_root,
 	  .fsflags = GLM_LIKELY_FFS },
 	{ .name = "swap",	.fstype = FS_SWAP,	.ptype = PT_swap },
 	{ .name = "windows",	.fstype = FS_MSDOS,	.ptype = PT_FAT,
 	  .fsflags = GLM_MAYBE_FAT32|GLM_MAYBE_NTFS },
 	{ .name = "windows",	.fstype = FS_NTFS,	.ptype = PT_FAT,
 	  .fsflags = GLM_MAYBE_FAT32|GLM_MAYBE_NTFS },
 	{ .name = "efi",	.fstype = FS_MSDOS,	.ptype = PT_EFI_SYSTEM,
 	  .fsflags = GLM_MAYBE_FAT32 },
 	{ .name = "bios",	.fstype = FS_MSDOS,	.ptype = PT_FAT,
 	  .fsflags = GLM_MAYBE_FAT32 },
 	{ .name = "lfs",	.fstype = FS_BSDLFS,	.ptype = PT_root },
 	{ .name = "linux-data",	.fstype = FS_EX2FS,	.ptype = PT_root },
 	{ .name = "apple",	.fstype = FS_HFS,	.ptype = PT_unknown },
 	{ .name = "ccd",	.fstype = FS_CCD,	.ptype = PT_root },
 	{ .name = "cgd",	.fstype = FS_CGD,	.ptype = PT_root },
 	{ .name = "raid",	.fstype = FS_RAID,	.ptype = PT_root },
 	{ .name = "vmcore",	.fstype = FS_VMKCORE,	.ptype = PT_unknown },
 	{ .name = "vmfs",	.fstype = FS_VMFS,	.ptype = PT_unknown },
 	{ .name = "vmresered",	.fstype = FS_VMWRESV,	.ptype = PT_unknown },
 	{ .name = "zfs",	.fstype = FS_ZFS,	.ptype = PT_root },
 };
 static size_t gpt_ptype_cnt = 0, gpt_ptype_alloc = 0;
 static struct gpt_ptype_desc *gpt_ptype_descs = NULL;
 /* "well" known types with special handling */
 static const struct part_type_desc *gpt_native_root;
 /* similar to struct gpt_ent, but matching our needs */
 struct gpt_part_entry {
 	const struct gpt_ptype_desc *gp_type;
 	char gp_id[GUID_STR_LEN];	/* partition guid as string */
 	daddr_t gp_start, gp_size;
 	uint gp_attr;			/* various attribute bits */
 	char gp_label[GPT_LABEL_LEN];	/* user defined label */
 	char gp_dev_name[GPT_DEV_LEN];	/* name of wedge */
 	const char *last_mounted;	/* last mounted if known */
 	uint fs_type, fs_sub_type,	/* FS_* and maybe sub type */
 	    fs_opt1, fs_opt2, fs_opt3;	/* transient file system options */
 	uint gp_flags;
 #define	GPEF_ON_DISK	1		/* This entry exists on-disk */
 #define	GPEF_MODIFIED	2		/* this entry has been changed */
 #define	GPEF_WEDGE	4		/* wedge for this exists */
 #define	GPEF_RESIZED	8		/* size has changed */
 #define	GPEF_TARGET	16		/* marked install target */
 	struct gpt_part_entry *gp_next;
 };
 static const struct gpt_ptype_desc *gpt_find_native_type(
     const struct part_type_desc *gent);
 static const struct gpt_ptype_desc *gpt_find_guid_type(const char*);
 static bool
 gpt_info_to_part(struct gpt_part_entry *p, const struct disk_part_info *info,
     const char **err_msg);
 const struct disk_partitioning_scheme gpt_parts;
 struct gpt_disk_partitions {
 	struct disk_partitions dp;
 	/*
 	 * We keep a list of our current valid partitions, pointed
 	 * to by "partitions".
 	 * dp.num_part is the number of entries in "partitions".
 	 * When partitions that have a representation on disk already
 	 * are deleted, we move them to the "obsolete" list so we
 	 * can issue the proper commands to remove it when writing back.
 	 */
 	struct gpt_part_entry *partitions,	/* current partitions */
 	    *obsolete;				/* deleted partitions */
 	size_t max_num_parts;			/* how many entries max? */
 	size_t prologue, epilogue;		/* number of sectors res. */
 	bool has_gpt;	/* disk already has a GPT */
 };
 /*
  * Init global variables from MD details
  */
 static void
 gpt_md_init(bool is_boot_disk, size_t *max_parts, size_t *head, size_t *tail)
+{
 	size_t num;
 	if (is_boot_disk) {
 #ifdef MD_GPT_INITIAL_SIZE
 #if MD_GPT_INITIAL_SIZE < 2*512
 #error	impossible small GPT prologue
 #endif
 		num = ((MD_GPT_INITIAL_SIZE-(2*512))/512)*GPT_PARTS_PER_SEC;
 #else
 		num = GPT_DEFAULT_MAX_PARTS;
 #endif
 	} else {
 		num = GPT_DEFAULT_MAX_PARTS;
+	}
 	*max_parts = num;
 	*head = 2 + num/GPT_PARTS_PER_SEC;
 	*tail = 1 + num/GPT_PARTS_PER_SEC;
+}
 /*
  * Parse a part of "gpt show" output into a struct gpt_part_entry.
  * Output is from "show -a" format if details = false, otherwise
  * from details for a specific partition (show -i or show -b)
  */
 static void
 gpt_add_info(struct gpt_part_entry *part, const char *tag, char *val,
     bool details)
+{
 	char *s, *e;
 	if (details && strcmp(tag, "Start:") == 0) {
 		part->gp_start = strtouq(val, NULL, 10);
 	} else if (details && strcmp(tag, "Size:") == 0) {
 		part->gp_size = strtouq(val, NULL, 10);
 	} else if (details && strcmp(tag, "Type:") == 0) {
 		s = strchr(val, '(');
 		if (!s)
 			return;
 		e = strchr(s, ')');
 		if (!e)
 			return;
 		*e = 0;
 		part->gp_type = gpt_find_guid_type(s+1);
 	} else if (strcmp(tag, "TypeID:") == 0) {
 		part->gp_type = gpt_find_guid_type(val);
 	} else if (strcmp(tag, "GUID:") == 0) {
 		strlcpy(part->gp_id, val, sizeof(part->gp_id));
 	} else if (strcmp(tag, "Label:") == 0) {
 		strlcpy(part->gp_label, val, sizeof(part->gp_label));
 	} else if (strcmp(tag, "Attributes:") == 0) {
 		char *n;
 		while ((n = strsep(&val, ", ")) != NULL) {
 			if (*n == 0)
 				continue;
 			for (const struct gpt_attr_desc *p = gpt_avail_attrs;
 			    p->name != NULL; p++) {
 				if (strcmp(p->name, n) == 0)
 					part->gp_attr |= p->flag;
+			}
+		}
+	}
+}
 /*
  * Find the partition matching this wedge info and record that we
  * have a wedge already.
  */
 static void
 update_part_from_wedge_info(struct gpt_disk_partitions *parts,
     const struct dkwedge_info *dkw)
+{
 	for (struct gpt_part_entry *p = parts->partitions; p != NULL;
 	    p = p->gp_next) {
 		if (p->gp_start != dkw->dkw_offset ||
 		    (uint64_t)p->gp_size != dkw->dkw_size)
 			continue;
 		p->gp_flags |= GPEF_WEDGE;
 		strlcpy(p->gp_dev_name, dkw->dkw_devname,
 		    sizeof p->gp_dev_name);
 		return;
+	}
+}
 static struct disk_partitions *
 gpt_read_from_disk(const char *dev, daddr_t start, daddr_t len, size_t bps,
     const struct disk_partitioning_scheme *scheme)
+{
 	char diskpath[MAXPATHLEN];
 	int fd;
 	struct dkwedge_info *dkw;
 	struct dkwedge_list dkwl;
 	size_t bufsize, dk;
 	assert(start == 0);
 	assert(have_gpt);
 	if (run_program(RUN_SILENT | RUN_ERROR_OK,
 	    "gpt -rq header %s", dev) != 0)
 		return NULL;
 	/* read the partitions */
 	int i;
 	unsigned int p_index;
 	daddr_t p_start = 0, p_size = 0, avail_start = 0, avail_size = 0,
 	    disk_size = 0;
 	char *textbuf, *t, *tt, p_type[STRSIZE];
 	static const char regpart_prefix[] = "GPT part - ";
 	struct gpt_disk_partitions *parts;
 	struct gpt_part_entry *last = NULL, *add_to = NULL;
 	const struct gpt_ptype_desc *native_root
 	     = gpt_find_native_type(gpt_native_root);
 	bool have_target = false;
 	if (collect(T_OUTPUT, &textbuf, "gpt -r show -a %s 2>/dev/null", dev)
 	    < 1)
 		return NULL;
 	/* parse output and create our list */
 	parts = calloc(1, sizeof(*parts));
 	if (parts == NULL)
 		return NULL;
 	(void)strtok(textbuf, "\n"); /* ignore first line */
 	while ((t = strtok(NULL, "\n")) != NULL) {
 		i = 0; p_start = 0; p_size = 0; p_index = 0;
 		p_type[0] = 0;
 		while ((tt = strsep(&t, " \t")) != NULL) {
 			if (strlen(tt) == 0)
 				continue;
 			if (i == 0) {
 				if (add_to != NULL)
 					gpt_add_info(add_to, tt, t, false);
 				p_start = strtouq(tt, NULL, 10);
 				if (p_start == 0 && add_to != NULL)
 					break;
 				else
 					add_to = NULL;
+			}
 			if (i == 1)
 				p_size = strtouq(tt, NULL, 10);
 			if (i == 2)
 				p_index = strtouq(tt, NULL, 10);
 			if (i > 2 || (i == 2 && p_index == 0)) {
 				if (p_type[0])
 					strlcat(p_type, " ", STRSIZE);
 				strlcat(p_type, tt, STRSIZE);
+			}
 			i++;
+		}
 		if (p_start == 0 || p_size == 0)
 			continue;
 		else if (strcmp(p_type, "Pri GPT table") == 0) {
 			avail_start = p_start + p_size;
 			parts->prologue = avail_start;
 			parts->epilogue = p_size + 1;
 			parts->max_num_parts = p_size * GPT_PARTS_PER_SEC;
 		} else if (strcmp(p_type, "Sec GPT table") == 0)
 			avail_size = p_start - avail_start;
 		else if(strcmp(p_type, "Sec GPT header") == 0)
 			disk_size = p_start + p_size;
 		else if (p_index == 0 && strlen(p_type) > 0)
 			/* Utilitary entry (PMBR, etc) */
 			continue;
 		else if (p_index == 0) {
 			/* Free space */
 			continue;
 		} else {
 			/* Usual partition */
 			tt = p_type;
 			if (strncmp(tt, regpart_prefix,
 			    strlen(regpart_prefix)) == 0)
 				tt += strlen(regpart_prefix);
 			/* Add to our linked list */
 			struct gpt_part_entry *np = calloc(1, sizeof(*np));
 			if (np == NULL)
 				break;
 			strlcpy(np->gp_label, tt, sizeof(np->gp_label));
 			np->gp_start = p_start;
 			np->gp_size = p_size;
 			np->gp_flags |= GPEF_ON_DISK;
 			if (!have_target && native_root != NULL &&
 			    strcmp(np->gp_id, native_root->tid) == 0) {
 				have_target = true;
 				np->gp_flags |= GPEF_TARGET;
+			}
 			if (last == NULL)
 				parts->partitions = np;
 			else
 				last->gp_next = np;
 			last = np;
 			add_to = np;
 			parts->dp.num_part++;
+		}
+	}
 	free(textbuf);
 	/* If the GPT was not complete (e.g. truncated image), barf */
 	if (disk_size <= 0) {
 		free(parts);
 		return NULL;
+	}
 	parts->dp.pscheme = scheme;
 	parts->dp.disk = strdup(dev);
 	parts->dp.disk_start = start;
 	parts->dp.disk_size = disk_size;
 	parts->dp.free_space = avail_size;
 	parts->dp.bytes_per_sector = bps;
 	parts->has_gpt = true;
 	fd = opendisk(parts->dp.disk, O_RDONLY, diskpath, sizeof(diskpath), 0);
 	for (struct gpt_part_entry *p = parts->partitions; p != NULL;
 	    p = p->gp_next) {
 #ifdef DEFAULT_UFS2
 		bool fs_is_default = false;
 #endif
 		if (p->gp_type != NULL) {
 			if (p->gp_type->fsflags != 0) {
 				const char *lm = get_last_mounted(fd,
 				    p->gp_start, &p->fs_type,
 				    &p->fs_sub_type, p->gp_type->fsflags);
 				if (lm != NULL && *lm != 0) {
 					char *path = strdup(lm);
 					canonicalize_last_mounted(path);
 					p->last_mounted = path;
 				} else {
 					p->fs_type = p->gp_type->
 					    default_fs_type;
 #ifdef DEFAULT_UFS2
 					fs_is_default = true;
 #endif
+				}
 			} else {
 				p->fs_type = p->gp_type->default_fs_type;
 #ifdef DEFAULT_UFS2
 				fs_is_default = true;
 #endif
+			}
 #ifdef DEFAULT_UFS2
 			if (fs_is_default && p->fs_type == FS_BSDFFS)
 				p->fs_sub_type = 2;
 #endif
+		}
 		parts->dp.free_space -= p->gp_size;
+	}
 	/*
 	 * Check if we have any (matching/auto-configured) wedges already
 	 */
 	dkw = NULL;
 	dkwl.dkwl_buf = dkw;
 	dkwl.dkwl_bufsize = 0;
 	if (ioctl(fd, DIOCLWEDGES, &dkwl) == 0) {
 		/* do not even try to deal with any races at this point */
 		bufsize = dkwl.dkwl_nwedges * sizeof(*dkw);
 		dkw = malloc(bufsize);
 		dkwl.dkwl_buf = dkw;
 		dkwl.dkwl_bufsize = bufsize;
 		if (dkw != NULL && ioctl(fd, DIOCLWEDGES, &dkwl) == 0) {
 			for (dk = 0; dk < dkwl.dkwl_ncopied; dk++)
 				update_part_from_wedge_info(parts, &dkw[dk]);
+		}
 		free(dkw);
+	}
 	close(fd);
 	return &parts->dp;
+}
 static size_t
 gpt_cyl_size(const struct disk_partitions *arg)
+{
 	return MEG / 512;
+}
 static struct disk_partitions *
 gpt_create_new(const char *disk, daddr_t start, daddr_t len,
     bool is_boot_drive, struct disk_partitions *parent)
+{
 	struct gpt_disk_partitions *parts;
 	struct disk_geom geo;
 	if (start != 0) {
 		assert(0);
 		return NULL;
+	}
 	if (!get_disk_geom(disk, &geo))
 		return NULL;
 	parts = calloc(1, sizeof(*parts));
 	if (!parts)
 		return NULL;
 	parts->dp.pscheme = &gpt_parts;
 	parts->dp.disk = strdup(disk);
 	gpt_md_init(is_boot_drive, &parts->max_num_parts, &parts->prologue,
 	    &parts->epilogue);
 	parts->dp.disk_start = start;
 	parts->dp.disk_size = len;
 	parts->dp.bytes_per_sector = geo.dg_secsize;
 	parts->dp.free_space = len - start - parts->prologue - parts->epilogue;
 	parts->has_gpt = false;
 	return &parts->dp;
+}
 static bool
 gpt_get_part_info(const struct disk_partitions *arg, part_id id,
     struct disk_part_info *info)
+{
 	static const struct part_type_desc gpt_unknown_type =
 		{ .generic_ptype = PT_undef,
 		  .short_desc = "<unknown>" };
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	const struct gpt_part_entry *p = parts->partitions;
 	part_id no;
 	for (no = 0; p != NULL && no < id; no++)
 		p = p->gp_next;
 	if (no != id || p == NULL)
 		return false;
 	memset(info, 0, sizeof(*info));
 	info->start = p->gp_start;
 	info->size = p->gp_size;
 	if (p->gp_type)
 		info->nat_type = &p->gp_type->gent;
 	else
 		info->nat_type = &gpt_unknown_type;
 	info->last_mounted = p->last_mounted;
 	info->fs_type = p->fs_type;
 	info->fs_sub_type = p->fs_sub_type;
 	info->fs_opt1 = p->fs_opt1;
 	info->fs_opt2 = p->fs_opt2;
 	info->fs_opt3 = p->fs_opt3;
 	if (p->gp_flags & GPEF_TARGET)
 		info->flags |= PTI_INSTALL_TARGET;
 	return true;
+}
 static bool
 gpt_get_part_attr_str(const struct disk_partitions *arg, part_id id,
     char *str, size_t avail_space)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	const struct gpt_part_entry *p = parts->partitions;
 	part_id no;
 	static const char *flags = NULL;
 	for (no = 0; p != NULL && no < id; no++)
 		p = p->gp_next;
 	if (no != id || p == NULL)
 		return false;
 	if (flags == NULL)
 		flags = msg_string(MSG_gpt_flags);
 	if (avail_space < 2)
 		return false;
 	if (p->gp_attr & GPT_ATTR_BOOT)
 		*str++ = flags[0];
 	*str = 0;
 	return true;
+}
 /*
  * Find insert position and check for duplicates.
  * If all goes well, insert the new "entry" in the "list".
  * If there are collisions, report "no free space".
  * We keep all lists sorted by start sector number,
  */
 static bool
 gpt_insert_part_into_list(struct gpt_disk_partitions *parts,
     struct gpt_part_entry **list,
     struct gpt_part_entry *entry, const char **err_msg)
+{
 	struct gpt_part_entry *p, *last;
 	/* find the first entry past the new one (if any) */
 	for (last = NULL, p = *list; p != NULL; last = p, p = p->gp_next) {
 		if (p->gp_start > entry->gp_start)
 			break;
+	}
 	/* check if last partition overlaps with new one */
 	if (last) {
 		if (last->gp_start + last->gp_size > entry->gp_start) {
 			if (err_msg)
 				*err_msg = msg_string(MSG_No_free_space);
 			return false;
+		}
+	}
 	if (p == NULL) {
 		entry->gp_next = NULL;
 		if (last != NULL) {
 			last->gp_next = entry;
+		}
 	} else {
 		/* check if new entry overlaps with next */
 		if (entry->gp_start + entry->gp_size > p->gp_start) {
 			if (err_msg)
 				*err_msg = msg_string(MSG_No_free_space);
 			return false;
+		}
 		entry->gp_next = p;
 		if (last != NULL)
 			last->gp_next = entry;
 		else
 			*list = entry;
+	}
 	if (*list == NULL)
 		*list = entry;
 	return true;
+}
 static bool
 gpt_set_part_info(struct disk_partitions *arg, part_id id,
     const struct disk_part_info *info, const char **err_msg)
+{
 	struct gpt_disk_partitions *parts =
 	    (struct gpt_disk_partitions*)arg;
 	struct gpt_part_entry *p = parts->partitions, *n;
 	part_id no;
 	daddr_t lendiff;
 	bool was_target;
 	for (no = 0; p != NULL && no < id; no++)
 		p = p->gp_next;
 	if (no != id || p == NULL)
 		return false;
 	/* update target mark - we can only have one */
 	was_target = (p->gp_flags & GPEF_TARGET) != 0;
 	if (info->flags & PTI_INSTALL_TARGET)
 		p->gp_flags |= GPEF_TARGET;
 	else
 		p->gp_flags &= ~GPEF_TARGET;
 	if (was_target)
 		for (n = parts->partitions; n != NULL; n = n->gp_next)
 			if (n != p)
 				n->gp_flags &= ~GPEF_TARGET;
 	if ((p->gp_flags & GPEF_ON_DISK)) {
 		if (info->start != p->gp_start) {
 			/* partition moved, we need to delete and re-add */
 			n = calloc(1, sizeof(*n));
 			if (n == NULL) {
 				if (err_msg)
 					*err_msg = err_outofmem;
 				return false;
+			}
 			*n = *p;
 			p->gp_flags &= ~GPEF_ON_DISK;
 			if (!gpt_insert_part_into_list(parts, &parts->obsolete,
 			    n, err_msg))
 				return false;
 		} else if (info->size != p->gp_size) {
 			p->gp_flags |= GPEF_RESIZED;
+		}
+	}
 	p->gp_flags |= GPEF_MODIFIED;
 	lendiff = info->size - p->gp_size;
 	parts->dp.free_space -= lendiff;
 	return gpt_info_to_part(p, info, err_msg);
+}
 static size_t
 gpt_get_free_spaces_internal(const struct gpt_disk_partitions *parts,
     struct disk_part_free_space *result, size_t max_num_result,
     daddr_t min_space_size, daddr_t align, daddr_t start, daddr_t ignore)
+{
 	size_t cnt = 0;
 	daddr_t s, e, from, size, end_of_disk;
 	struct gpt_part_entry *p;
 	if (align > 1)
 		start = max(roundup(start, align), align);
 	if (start < 0 || start < (daddr_t)parts->prologue)
 		start = parts->prologue;
 	if (parts->dp.disk_start != 0 && parts->dp.disk_start > start)
 		start = parts->dp.disk_start;
 	if (min_space_size < 1)
 		min_space_size = 1;
 	end_of_disk = parts->dp.disk_start + parts->dp.disk_size
 	    - parts->epilogue;
 	from = start;
 	while (from < end_of_disk && cnt < max_num_result) {
 again:
 		size = parts->dp.disk_start + parts->dp.disk_size - from;
 		start = from;
 		if (start + size > end_of_disk)
 			size = end_of_disk - start;
 		for (p = parts->partitions; p != NULL; p = p->gp_next) {
 			s = p->gp_start;
 			e = p->gp_size + s;
 			if (s == ignore)
 				continue;
 			if (e < from)
 				continue;
 			if (s <= from && e > from) {
 				if (e - 1 >= end_of_disk)
 					return cnt;
 				from = e + 1;
 				if (align > 1) {
 					from = max(roundup(from, align), align);
 					if (from >= end_of_disk) {
 						size = 0;
 						break;
+					}
+				}
 				goto again;
+			}
 			if (s > from && s - from < size) {
 				size = s - from;
+			}
+		}
 		if (size >= min_space_size) {
 			result->start = start;
 			result->size = size;
 			result++;
 			cnt++;
+		}
 		from += size + 1;
 		if (align > 1)
 			from = max(roundup(from, align), align);
+	}
 	return cnt;
+}
 static daddr_t
 gpt_max_free_space_at(const struct disk_partitions *arg, daddr_t start)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	struct disk_part_free_space space;
 	if (gpt_get_free_spaces_internal(parts, &space, 1, 1, 0,
 	    start, start) == 1)
 		return space.size;
 	return 0;
+}
 static size_t
 gpt_get_free_spaces(const struct disk_partitions *arg,
     struct disk_part_free_space *result, size_t max_num_result,
     daddr_t min_space_size, daddr_t align, daddr_t start,
     daddr_t ignore)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	return gpt_get_free_spaces_internal(parts, result,
 	    max_num_result, min_space_size, align, start, ignore);
+}
 static void
 gpt_match_ptype(const char *name, struct gpt_ptype_desc *t)
+{
 	size_t i;
 	for (i = 0; i < __arraycount(gpt_fs_types); i++) {
 		if (strcmp(name, gpt_fs_types[i].name) == 0) {
 			t->gent.generic_ptype = gpt_fs_types[i].ptype;
 			t->fsflags = gpt_fs_types[i].fsflags;
 			t->default_fs_type = gpt_fs_types[i].fstype;
 			/* recongnize special entries */
 			if (gpt_native_root == NULL && i == 0)
 				gpt_native_root = &t->gent;
 			return;
+		}
+	}
 	t->gent.generic_ptype = PT_unknown;
 	t->fsflags = 0;
 	t->default_fs_type = FS_BSDFFS;
+}
 static void
 gpt_internal_add_ptype(const char *uid, const char *name, const char *desc)
+{
 	if (gpt_ptype_cnt >= gpt_ptype_alloc) {
 		gpt_ptype_alloc = gpt_ptype_alloc ? 2*gpt_ptype_alloc
 		    : GPT_PTYPE_ALLOC;
 		struct gpt_ptype_desc *nptypes = realloc(gpt_ptype_descs,
 		    gpt_ptype_alloc*sizeof(*gpt_ptype_descs));
 		if (nptypes == 0)
 			errx(EXIT_FAILURE, "out of memory");
 		gpt_ptype_descs = nptypes;
+	}
 	strlcpy(gpt_ptype_descs[gpt_ptype_cnt].tid, uid,
 	    sizeof(gpt_ptype_descs[gpt_ptype_cnt].tid));
 	gpt_ptype_descs[gpt_ptype_cnt].gent.short_desc = strdup(name);
 	gpt_ptype_descs[gpt_ptype_cnt].gent.description = strdup(desc);
 	gpt_match_ptype(name, &gpt_ptype_descs[gpt_ptype_cnt]);
 	gpt_ptype_cnt++;
+}
 static void
 gpt_init_ptypes(void)
+{
 	if (gpt_ptype_cnt == 0)
 		gpt_uuid_query(gpt_internal_add_ptype);
+}
 static void
 gpt_cleanup(void)
+{
 	/* free all of gpt_ptype_descs */
 	for (size_t i = 0; i < gpt_ptype_cnt; i++) {
 		free(__UNCONST(gpt_ptype_descs[i].gent.short_desc));
 		free(__UNCONST(gpt_ptype_descs[i].gent.description));
+	}
 	free(gpt_ptype_descs);
 	gpt_ptype_descs = NULL;
 	gpt_ptype_cnt = gpt_ptype_alloc = 0;
+}
 static size_t
 gpt_type_count(void)
+{
 	if (gpt_ptype_cnt == 0)
 		gpt_init_ptypes();
 	return gpt_ptype_cnt;
+}
 static const struct part_type_desc *
 gpt_get_ptype(size_t ndx)
+{
 	if (gpt_ptype_cnt == 0)
 		gpt_init_ptypes();
 	if (ndx >= gpt_ptype_cnt)
 		return NULL;
 	return &gpt_ptype_descs[ndx].gent;
+}
 static const struct part_type_desc *
 gpt_get_generic_type(enum part_type gent)
+{
 	if (gpt_ptype_cnt == 0)
 		gpt_init_ptypes();
 	if (gent == PT_root)
 		return gpt_native_root;
 	if (gent == PT_unknown)
 		return NULL;
 	for (size_t i = 0; i < gpt_ptype_cnt; i++)
 		if (gpt_ptype_descs[i].gent.generic_ptype == gent)
 			return &gpt_ptype_descs[i].gent;
 	return NULL;
+}
 static const struct gpt_ptype_desc *
 gpt_find_native_type(const struct part_type_desc *gent)
+{
 	if (gpt_ptype_cnt == 0)
 		gpt_init_ptypes();
 	if (gent == NULL)
 		return NULL;
 	for (size_t i = 0; i < gpt_ptype_cnt; i++)
 		if (gent == &gpt_ptype_descs[i].gent)
 			return &gpt_ptype_descs[i];
 	gent = gpt_get_generic_type(gent->generic_ptype);
 	if (gent == NULL)
 		return NULL;
 	/* this can not recurse deeper than once, we would not have found a
 	 * generic type a few lines above if it would. */
 	return gpt_find_native_type(gent);
+}
 static const struct gpt_ptype_desc *
 gpt_find_guid_type(const char *uid)
+{
 	if (gpt_ptype_cnt == 0)
 		gpt_init_ptypes();
 	if (uid == NULL || uid[0] == 0)
 		return NULL;
 	for (size_t i = 0; i < gpt_ptype_cnt; i++)
 		if (strcmp(gpt_ptype_descs[i].tid, uid) == 0)
 			return &gpt_ptype_descs[i];
 	return NULL;
+}
 static const struct part_type_desc *
 gpt_find_type(const char *desc)
+{
 	if (gpt_ptype_cnt == 0)
 		gpt_init_ptypes();
 	if (desc == NULL || desc[0] == 0)
 		return NULL;
 	for (size_t i = 0; i < gpt_ptype_cnt; i++)
 		if (strcmp(gpt_ptype_descs[i].gent.short_desc, desc) == 0)
 			return &gpt_ptype_descs[i].gent;
 	return NULL;
+}
 static const struct part_type_desc *
 gpt_get_fs_part_type(enum part_type pt, unsigned fstype, unsigned fs_sub_type)
+{
 	size_t i;
 	/* Try with complete match (including part_type) first */
 	for (i = 0; i < __arraycount(gpt_fs_types); i++)
 		if (fstype == gpt_fs_types[i].fstype &&
 		    pt == gpt_fs_types[i].ptype)
 			return gpt_find_type(gpt_fs_types[i].name);
 	/* If that did not work, ignore part_type */
 	for (i = 0; i < __arraycount(gpt_fs_types); i++)
 		if (fstype == gpt_fs_types[i].fstype)
 			return gpt_find_type(gpt_fs_types[i].name);
 	return NULL;
+}
 static bool
 gpt_get_default_fstype(const struct part_type_desc *nat_type,
     unsigned *fstype, unsigned *fs_sub_type)
+{
 	const struct gpt_ptype_desc *gtype;
 	gtype = gpt_find_native_type(nat_type);
 	if (gtype == NULL)
 		return false;
 	*fstype = gtype->default_fs_type;
 #ifdef DEFAULT_UFS2
 	if (gtype->default_fs_type == FS_BSDFFS)
 		*fs_sub_type = 2;
 	else
 #endif
 		*fs_sub_type = 0;
 	return true;
+}
 static const struct part_type_desc *
 gpt_get_uuid_part_type(const uuid_t *id)
+{
 	char str[GUID_STR_LEN], desc[GUID_STR_LEN + MENUSTRSIZE];
 	const struct gpt_ptype_desc *t;
 	char *guid = NULL;
 	uint32_t err;
 	uuid_to_string(id, &guid, &err);
 	strlcpy(str, err == uuid_s_ok ? guid : "-", sizeof str);
 	free(guid);
 	t = gpt_find_guid_type(str);
 	if (t == NULL) {
 		snprintf(desc, sizeof desc, "%s (%s)",
 		    msg_string(MSG_custom_type), str);
 		gpt_internal_add_ptype(str, str, desc);
 		t = gpt_find_guid_type(str);
 		assert(t != NULL);
+	}
 	return &t->gent;
+}
 static const struct part_type_desc *
 gpt_create_custom_part_type(const char *custom, const char **err_msg)
+{
 	uuid_t id;
 	uint32_t err;
 	uuid_from_string(custom, &id, &err);
 	if (err_msg != NULL &&
 	   (err == uuid_s_invalid_string_uuid || err == uuid_s_bad_version)) {
 		*err_msg = MSG_invalid_guid;
 		return NULL;
+	}
 	if (err != uuid_s_ok)
 		return NULL;
 	return gpt_get_uuid_part_type(&id);
+}
 static const struct part_type_desc *
 gpt_create_unknown_part_type(void)
+{
 	uuid_t id;
 	uint32_t err;
 	uuid_create(&id, &err);
 	if (err != uuid_s_ok)
 		return NULL;
 	return gpt_get_uuid_part_type(&id);
+}
 static daddr_t
 gpt_get_part_alignment(const struct disk_partitions *parts)
+{
 	assert(parts->disk_size > 0);
 	if (parts->disk_size < 0)
 		return 1;
 	/* Use 1MB offset/alignemnt for large (>128GB) disks */
 	if (parts->disk_size > HUGE_DISK_SIZE)
 		return 2048;
 	else if (parts->disk_size > TINY_DISK_SIZE)
 		return 64;
 	else
 		return 4;
+}
 static bool
 gpt_can_add_partition(const struct disk_partitions *arg)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	struct disk_part_free_space space;
 	daddr_t align;
 	if (parts->dp.num_part >= parts->max_num_parts)
 		return false;
 	align = gpt_get_part_alignment(arg);
 	if (parts->dp.free_space <= align)
 		return false;
 	if (gpt_get_free_spaces_internal(parts, &space, 1, align, align,
 , -1) < 1)
 		return false;
 	return true;
+}
 static bool
 gpt_info_to_part(struct gpt_part_entry *p, const struct disk_part_info *info,
     const char **err_msg)
+{
 	p->gp_type = gpt_find_native_type(info->nat_type);
 	p->gp_start = info->start;
 	p->gp_size = info->size;
 	if (info->last_mounted != NULL && info->last_mounted !=
 	    p->last_mounted) {
 		free(__UNCONST(p->last_mounted));
 		p->last_mounted = strdup(info->last_mounted);
+	}
 	p->fs_type = info->fs_type;
 	p->fs_sub_type = info->fs_sub_type;
 	p->fs_opt1 = info->fs_opt1;
 	p->fs_opt2 = info->fs_opt2;
 	p->fs_opt3 = info->fs_opt3;
 	return true;
+}
 static part_id
 gpt_add_part(struct disk_partitions *arg,
     const struct disk_part_info *info, const char **err_msg)
+{
 	struct gpt_disk_partitions *parts =
 	    (struct gpt_disk_partitions*)arg;
 	struct disk_part_free_space space;
 	struct disk_part_info data = *info;
 	struct gpt_part_entry *p;
 	bool ok;
 	if (err_msg != NULL)
 		*err_msg = NULL;
 	if (gpt_get_free_spaces_internal(parts, &space, 1, 1, 1,
 	    info->start, -1) < 1) {
 		if (err_msg)
 			*err_msg = msg_string(MSG_No_free_space);
 		return NO_PART;
+	}
 	if (parts->dp.num_part >= parts->max_num_parts) {
 		if (err_msg)
 			*err_msg = msg_string(MSG_err_too_many_partitions);
 		return NO_PART;
+	}
 	if (data.size > space.size)
 		data.size = space.size;
 	p = calloc(1, sizeof(*p));
 	if (p == NULL) {
 		if (err_msg != NULL)
 			*err_msg = INTERNAL_ERROR;
 		return NO_PART;
+	}
 	if (!gpt_info_to_part(p, &data, err_msg)) {
 		free(p);
 		return NO_PART;
+	}
 	p->gp_flags |= GPEF_MODIFIED;
 	ok = gpt_insert_part_into_list(parts, &parts->partitions, p, err_msg);
 	if (ok) {
 		parts->dp.num_part++;
 		parts->dp.free_space -= p->gp_size;
 		return parts->dp.num_part-1;
 	} else {
 		free(p);
 		return NO_PART;
+	}
+}
 static bool
 gpt_delete_partition(struct disk_partitions *arg, part_id id,
     const char **err_msg)
+{
 	struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg;
 	struct gpt_part_entry *p, *last = NULL;
 	part_id i;
 	bool res;
 	if (parts->dp.num_part == 0)
 		return false;
 	for (i = 0, p = parts->partitions;
 	    i != id && i < parts->dp.num_part && p != NULL;
 	    i++, p = p->gp_next)
 		last = p;
 	if (p == NULL) {
 		if (err_msg)
 			*err_msg = INTERNAL_ERROR;
 		return false;
+	}
 	if (last == NULL)
 		parts->partitions = p->gp_next;
 	else
 		last->gp_next = p->gp_next;
 	res = true;
 	if (p->gp_flags & GPEF_ON_DISK) {
 		if (!gpt_insert_part_into_list(parts, &parts->obsolete,
 		    p, err_msg))
 			res = false;
 	} else {
 		free(p);
+	}
 	if (res) {
 		parts->dp.num_part--;
 		parts->dp.free_space += p->gp_size;
+	}
 	return res;
+}
 static bool
 gpt_delete_all_partitions(struct disk_partitions *arg)
+{
 	struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg;
 	while (parts->dp.num_part > 0) {
 		if (!gpt_delete_partition(&parts->dp, 0, NULL))
 			return false;
+	}
 	return true;
+}
 static bool
 gpt_read_part(const char *disk, daddr_t start, struct gpt_part_entry *p)
+{
 	char *textbuf, *t, *tt;
 	static const char expected_hdr[] = "Details for index ";
 	/* run gpt show for this partition */
 	if (collect(T_OUTPUT, &textbuf,
 	    "gpt -r show -b %" PRIu64 " %s 2>/dev/null", start, disk) < 1)
 		return false;
 	/*
 	 * gpt show should respond with single partition details, but will
 	 * fall back to "show -a" output if something is wrong
 	 */
 	t = strtok(textbuf, "\n"); /* first line is special */
 	if (strncmp(t, expected_hdr, sizeof(expected_hdr)-1) != 0) {
 		free(textbuf);
 		return false;
+	}
 	/* parse output into "old" */
 	while ((t = strtok(NULL, "\n")) != NULL) {
 		tt = strsep(&t, " \t");
 		if (strlen(tt) == 0)
 			continue;
 		gpt_add_info(p, tt, t, true);
+	}
 	free(textbuf);
 	return true;
+}
 static bool
 gpt_apply_attr(const char *disk, const char *cmd, off_t start, uint todo)
+{
 	size_t i;
 	char attr_str[STRSIZE];
 	if (todo == 0)
 		return true;
 	strcpy(attr_str, "-a ");
 	for (i = 0; todo != 0; i++) {
 		if (!(gpt_avail_attrs[i].flag & todo))
 			continue;
 		todo &= ~gpt_avail_attrs[i].flag;
 		if (attr_str[0])
 			strlcat(attr_str, ",",
 			    sizeof(attr_str));
 		strlcat(attr_str,
 		    gpt_avail_attrs[i].name,
 		    sizeof(attr_str));
+	}
 	if (run_program(RUN_SILENT,
 	    "gpt %s %s -b %" PRIu64 " %s", cmd, attr_str, start, disk) != 0)
 		return false;
 	return true;
+}
 /*
  * Modify an existing on-disk partition.
  * Start and size can not be changed here, caller needs to deal
  * with that kind of changes upfront.
  */
 static bool
 gpt_modify_part(const char *disk, struct gpt_part_entry *p)
+{
 	struct gpt_part_entry old;
 	uint todo_set, todo_unset;
 	/*
 	 * Query current on-disk state
 	 */
 	memset(&old, 0, sizeof old);
 	if (!gpt_read_part(disk, p->gp_start, &old))
 		return false;
 	/* Reject unsupported changes */
 	if (old.gp_start != p->gp_start || old.gp_size != p->gp_size)
 		return false;
 	/*
 	 * GUID should never change, but the internal copy
 	 * may not yet know it.
 	 */
 	strcpy(p->gp_id, old.gp_id);
 	/* Check type */
 	if (p->gp_type != old.gp_type) {
 		if (run_program(RUN_SILENT,
 		    "gpt type -b %" PRIu64 " -T %s %s",
 		    p->gp_start, p->gp_type->tid, disk) != 0)
 			return false;
+	}
 	/* Check label */
 	if (strcmp(p->gp_label, old.gp_label) != 0) {
 		if (run_program(RUN_SILENT,
 		    "gpt label -b %" PRIu64 " -l \'%s\' %s",
 		    p->gp_start, p->gp_label, disk) != 0)
 			return false;
+	}
 	/* Check attributes */
 	if (p->gp_attr != old.gp_attr) {
 		if (p->gp_attr == 0) {
 			if (run_program(RUN_SILENT,
 			    "gpt set -N -b %" PRIu64 " %s",
 			    p->gp_start, disk) != 0)
 				return false;
 		} else {
 			todo_set = (p->gp_attr ^ old.gp_attr) & p->gp_attr;
 			todo_unset = (p->gp_attr ^ old.gp_attr) & old.gp_attr;
 			if (!gpt_apply_attr(disk, "unset", p->gp_start,
 			    todo_unset))
 				return false;
 			if (!gpt_apply_attr(disk, "set", p->gp_start,
 			    todo_set))
 				return false;
+		}
+	}
 	return true;
+}
 /*
  * verbatim copy from sys/dev/dkwedge/dkwedge_bsdlabel.c:
  *  map FS_* to wedge strings
  */
 static const char *
 bsdlabel_fstype_to_str(uint8_t fstype)
+{
 	const char *str;
 	/*
 	 * For each type known to FSTYPE_DEFN (from <sys/disklabel.h>),
 	 * a suitable case branch will convert the type number to a string.
 	 */
 	switch (fstype) {
 #define FSTYPE_TO_STR_CASE(tag, number, name, fsck, mount) \
 	case __CONCAT(FS_,tag):	str = __CONCAT(DKW_PTYPE_,tag);			break;
 	FSTYPE_DEFN(FSTYPE_TO_STR_CASE)
 #undef FSTYPE_TO_STR_CASE
 	default:		str = NULL;			break;
+	}
 	return (str);
+}
 static bool
 gpt_add_wedge(const char *disk, struct gpt_part_entry *p)
+{
 	struct dkwedge_info dkw;
 	const char *tname;
 	char diskpath[MAXPATHLEN];
 	int fd;
 	memset(&dkw, 0, sizeof(dkw));
 	tname = bsdlabel_fstype_to_str(p->fs_type);
 	if (tname)
 		strlcpy(dkw.dkw_ptype, tname, sizeof(dkw.dkw_ptype));
 	strlcpy((char*)&dkw.dkw_wname, p->gp_id, sizeof(dkw.dkw_wname));
 	dkw.dkw_offset = p->gp_start;
 	dkw.dkw_size = p->gp_size;
 	if (dkw.dkw_wname[0] == 0) {
 		if (p->gp_label[0] != 0)
 				strlcpy((char*)&dkw.dkw_wname,
 				    p->gp_label, sizeof(dkw.dkw_wname));
+	}
 	if (dkw.dkw_wname[0] == 0) {
 		snprintf((char*)dkw.dkw_wname, sizeof dkw.dkw_wname,
 		    "%s_%" PRIi64 "@%" PRIi64, disk, p->gp_size, p->gp_start);
+	}
 	fd = opendisk(disk, O_RDWR, diskpath, sizeof(diskpath), 0);
 	if (fd < 0)
 		return false;
 	if (ioctl(fd, DIOCAWEDGE, &dkw) == -1) {
 		close(fd);
 		return false;
+	}
 	close(fd);
 	strlcpy(p->gp_dev_name, dkw.dkw_devname, sizeof(p->gp_dev_name));
 	p->gp_flags |= GPEF_WEDGE;
 	return true;
+}
 static void
 escape_spaces(char *dest, const char *src)
+{
 	unsigned char c;
 	while (*src) {
 		c = *src++;
 		if (isspace(c) || c == '\\')
 			*dest++ = '\\';
 		*dest++ = c;
+	}
 	*dest = 0;
+}
 static bool
 gpt_get_part_device(const struct disk_partitions *arg,
     part_id id, char *devname, size_t max_devname_len, int *part,
     enum dev_name_usage usage, bool with_path, bool life)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	struct  gpt_part_entry *p = parts->partitions;
 	char tmpname[GPT_LABEL_LEN*2];
 	part_id no;
 	for (no = 0; p != NULL && no < id; no++)
 		p = p->gp_next;
 	if (no != id || p == NULL)
 		return false;
 	if (part)
 		*part = -1;
 	if (usage == logical_name && p->gp_label[0] == 0 && p->gp_id[0] == 0)
 		usage = plain_name;
 	if (usage == plain_name || usage == raw_dev_name)
 		life = true;
-	if (!(p->gp_flags & GPEF_WEDGE) && life)
+	if (!(p->gp_flags & GPEF_WEDGE) && life &&
-		gpt_add_wedge(arg->disk, p);
+	    !gpt_add_wedge(arg->disk, p)) {
 		devname[0] = 0;
 		return false;
+	}
 	switch (usage) {
 	case logical_name:
 		if (p->gp_label[0] != 0) {
 			escape_spaces(tmpname, p->gp_label);
 			snprintf(devname, max_devname_len,
 			    "NAME=%s", tmpname);
 		} else {
 			snprintf(devname, max_devname_len,
 			    "NAME=%s", p->gp_id);
+		}
 		break;
 	case plain_name:
 		assert(p->gp_flags & GPEF_WEDGE);
 		if (with_path)
 			snprintf(devname, max_devname_len, _PATH_DEV "%s",
 			    p->gp_dev_name);
 		else
 			strlcpy(devname, p->gp_dev_name, max_devname_len);
 		break;
 	case raw_dev_name:
 		assert(p->gp_flags & GPEF_WEDGE);
 		if (with_path)
 			snprintf(devname, max_devname_len, _PATH_DEV "r%s",
 			    p->gp_dev_name);
 		else
 			snprintf(devname, max_devname_len, "r%s",
 			    p->gp_dev_name);
 		break;
 	default:
 		return false;
+	}
 	return true;
+}
 static bool
 gpt_write_to_disk(struct disk_partitions *arg)
+{
 	struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg;
 	struct gpt_part_entry *p, *n;
 	char label_arg[sizeof(p->gp_label) + 10];
 	char diskpath[MAXPATHLEN];
 	int fd, bits = 0;
 	bool root_is_new = false, efi_is_new = false;
 	part_id root_id = NO_PART, efi_id = NO_PART, pno;
 	/*
 	 * Remove all wedges on this disk - they may become invalid and we
 	 * have no easy way to associate them with the partitioning data.
 	 * Instead we will explicitly request creation of wedges on demand
 	 * later.
 	 */
 	fd = opendisk(arg->disk, O_RDWR, diskpath, sizeof(diskpath), 0);
 	if (fd < 0)
 		return false;
 	if (ioctl(fd, DIOCRMWEDGES, &bits) == -1)
 		return false;
 	close(fd);
 	/*
 	 * Collect first root and efi partition (if available), clear
 	 * "have wedge" flags.
 	 */
 	for (pno = 0, p = parts->partitions; p != NULL; p = p->gp_next, pno++) {
 		p->gp_flags &= ~GPEF_WEDGE;
 		if (root_id == NO_PART && p->gp_type != NULL) {
 			if (p->gp_type->gent.generic_ptype == PT_root &&
 			    (p->gp_flags & GPEF_TARGET)) {
 				root_id = pno;
 				root_is_new = !(p->gp_flags & GPEF_ON_DISK);
 			} else if (efi_id == NO_PART &&
 			    p->gp_type->gent.generic_ptype == PT_EFI_SYSTEM) {
 				efi_id = pno;
 				efi_is_new = !(p->gp_flags & GPEF_ON_DISK);
+			}
+		}
+	}
 	/*
 	 * If no GPT on disk yet, create it.
 	 */
 	if (!parts->has_gpt) {
 		char limit[30];
 		if (parts->max_num_parts > 0)
 			sprintf(limit, "-p %zu", parts->max_num_parts);
 		else
 			limit[0] = 0;
 		if (run_program(RUN_SILENT, "gpt create %s %s",
 		    limit, parts->dp.disk))
 			return false;
 		parts->has_gpt = true;
+	}
 	/*
 	 * Delete all old partitions
 	 */
 	for (p = parts->obsolete; p != NULL; p = n) {
 		run_program(RUN_SILENT, "gpt -n remove -b %" PRIu64 " %s",
 		    p->gp_start, arg->disk);
 		n = p->gp_next;
 		free(p);
+	}
 	parts->obsolete = NULL;
 	/*
 	 * Modify existing but changed partitions
 	 */
 	for (p = parts->partitions; p != NULL; p = p->gp_next) {
 		if (!(p->gp_flags & GPEF_ON_DISK))
 			continue;
 		if (p->gp_flags & GPEF_RESIZED) {
 			run_program(RUN_SILENT,
 			    "gpt -n resize -b %" PRIu64 " -s %" PRIu64 "s %s",
 			    p->gp_start, p->gp_size, arg->disk);
 			p->gp_flags &= ~GPEF_RESIZED;
+		}
 		if (!(p->gp_flags & GPEF_MODIFIED))
 			continue;
 		if (!gpt_modify_part(parts->dp.disk, p))
 			return false;
+	}
 	/*
 	 * Add new partitions
 	 */
 	for (p = parts->partitions; p != NULL; p = p->gp_next) {
 		if (p->gp_flags & GPEF_ON_DISK)
 			continue;
 		if (!(p->gp_flags & GPEF_MODIFIED))
 			continue;
 		if (p->gp_label[0] == 0)
 			label_arg[0] = 0;
 		else
 			sprintf(label_arg, "-l \'%s\'", p->gp_label);
 		if (p->gp_type != NULL)
 			run_program(RUN_SILENT,
 			    "gpt -n add -b %" PRIu64 " -s %" PRIu64
 			    "s -t %s %s %s",
 			    p->gp_start, p->gp_size, p->gp_type->tid,
 			    label_arg, arg->disk);
 		else
 			run_program(RUN_SILENT,
 			    "gpt -n add -b %" PRIu64 " -s %" PRIu64
 			    "s %s %s",
 			    p->gp_start, p->gp_size, label_arg, arg->disk);
 		gpt_apply_attr(arg->disk, "set", p->gp_start, p->gp_attr);
 		gpt_read_part(arg->disk, p->gp_start, p);
 		p->gp_flags |= GPEF_ON_DISK;
+	}
 	/*
 	 * Additional MD bootloader magic...
 	 */
 	if (!md_gpt_post_write(&parts->dp, root_id, root_is_new, efi_id,
 	    efi_is_new))
 		return false;
 	return true;
+}
 static part_id
 gpt_find_by_name(struct disk_partitions *arg, const char *name)
+{
 	struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg;
 	struct gpt_part_entry *p;
 	part_id pno;
 	for (pno = 0, p = parts->partitions; p != NULL;
 	    p = p->gp_next, pno++) {
 		if (strcmp(p->gp_label, name) == 0)
 			return pno;
 		if (strcmp(p->gp_id, name) == 0)
 			return pno;
+	}
 	return NO_PART;
+}
 bool
 gpt_parts_check(void)
+{
 	check_available_binaries();
 	return have_gpt && have_dk;
+}
 static void
 gpt_free(struct disk_partitions *arg)
+{
 	struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg;
 	struct gpt_part_entry *p, *n;
 	assert(parts != NULL);
 	for (p = parts->partitions; p != NULL; p = n) {
 		free(__UNCONST(p->last_mounted));
 		n = p->gp_next;
 		free(p);
+	}
 	free(__UNCONST(parts->dp.disk));
 	free(parts);
+}
 static void
 gpt_destroy_part_scheme(struct disk_partitions *arg)
+{
 	run_program(RUN_SILENT, "gpt destroy %s", arg->disk);
 	gpt_free(arg);
+}
 static bool
 gpt_custom_attribute_writable(const struct disk_partitions *arg,
     part_id ptn, size_t attr_no)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	size_t i;
 	struct gpt_part_entry *p;
 	if (attr_no >= arg->pscheme->custom_attribute_count)
 		return false;
 	const msg label = arg->pscheme->custom_attributes[attr_no].label;
 	/* we can not edit the uuid attribute */
 	if (label == MSG_ptn_uuid)
 		return false;
 	/* the label is always editable */
 	if (label == MSG_ptn_label)
 		return true;
 	/* the GPT type is read only */
 	if (label == MSG_ptn_gpt_type)
 		return false;
 	/* BOOTME makes no sense on swap partitions */
 	for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next)
 		if (i == ptn)
 			break;
 	if (p == NULL)
 		return false;
 	if (p->fs_type == FS_SWAP ||
 	    (p->gp_type != NULL && p->gp_type->gent.generic_ptype == PT_swap))
 		return false;
 	return true;
+}
 static const char *
 gpt_get_label_str(const struct disk_partitions *arg, part_id ptn)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	size_t i;
 	struct gpt_part_entry *p;
 	for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next)
 		if (i == ptn)
 			break;
 	if (p == NULL)
 		return NULL;
 	if (p->gp_label[0] != 0)
 		return p->gp_label;
 	return p->gp_id;
+}
 static bool
 gpt_format_custom_attribute(const struct disk_partitions *arg,
     part_id ptn, size_t attr_no, const struct disk_part_info *info,
     char *out, size_t out_space)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	size_t i;
 	struct gpt_part_entry *p, data;
 	for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next)
 		if (i == ptn)
 			break;
 	if (p == NULL)
 		return false;
 	if (attr_no >= parts->dp.pscheme->custom_attribute_count)
 		return false;
 	const msg label = parts->dp.pscheme->custom_attributes[attr_no].label;
 	if (info != NULL) {
 		data = *p;
 		gpt_info_to_part(&data, info, NULL);
 		p = &data;
+	}
 	if (label == MSG_ptn_label)
 		strlcpy(out, p->gp_label, out_space);
 	else if (label == MSG_ptn_uuid)
 		strlcpy(out, p->gp_id, out_space);
 	else if (label == MSG_ptn_gpt_type) {
 		if (p->gp_type != NULL)
 			strlcpy(out, p->gp_type->gent.description, out_space);
 		else if (out_space > 1)
 			out[0] = 0;
 	} else if (label == MSG_ptn_boot)
 		strlcpy(out, msg_string(p->gp_attr & GPT_ATTR_BOOT ?
 		    MSG_Yes : MSG_No), out_space);
 	else
 		return false;
 	return true;
+}
 static bool
 gpt_custom_attribute_toggle(struct disk_partitions *arg,
     part_id ptn, size_t attr_no)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	size_t i;
 	struct gpt_part_entry *p;
 	for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next)
 		if (i == ptn)
 			break;
 	if (p == NULL)
 		return false;
 	if (attr_no >= parts->dp.pscheme->custom_attribute_count)
 		return false;
 	const msg label = parts->dp.pscheme->custom_attributes[attr_no].label;
 	if (label != MSG_ptn_boot)
 		return false;
 	if (p->gp_attr & GPT_ATTR_BOOT) {
 		p->gp_attr &= ~GPT_ATTR_BOOT;
 	} else {
 		for (i = 0, p = parts->partitions; p != NULL;
 		    i++, p = p->gp_next)
 			if (i == ptn)
 				p->gp_attr |= GPT_ATTR_BOOT;
 			else
 				p->gp_attr &= ~GPT_ATTR_BOOT;
+	}
 	return true;
+}
 static bool
 gpt_custom_attribute_set_str(struct disk_partitions *arg,
     part_id ptn, size_t attr_no, const char *new_val)
+{
 	const struct gpt_disk_partitions *parts =
 	    (const struct gpt_disk_partitions*)arg;
 	size_t i;
 	struct gpt_part_entry *p;
 	for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next)
 		if (i == ptn)
 			break;
 	if (p == NULL)
 		return false;
 	if (attr_no >= parts->dp.pscheme->custom_attribute_count)
 		return false;
 	const msg label = parts->dp.pscheme->custom_attributes[attr_no].label;
 	if (label != MSG_ptn_label)
 		return false;
 	strlcpy(p->gp_label, new_val, sizeof(p->gp_label));
 	return true;
+}
 static bool
 gpt_have_boot_support(const char *disk)
+{
 #ifdef	HAVE_GPT_BOOT
 	return true;
 #else
 	return false;
 #endif
+}
 const struct disk_part_custom_attribute gpt_custom_attrs[] = {
 	{ .label = MSG_ptn_label,	.type = pet_str },
 	{ .label = MSG_ptn_uuid,	.type = pet_str },
 	{ .label = MSG_ptn_gpt_type,	.type = pet_str },
 	{ .label = MSG_ptn_boot,	.type = pet_bool },
 };
 const struct disk_partitioning_scheme
 gpt_parts = {
 	.name = MSG_parttype_gpt,
 	.short_name = MSG_parttype_gpt_short,
 	.part_flag_desc = MSG_gpt_flag_desc,
 	.custom_attribute_count = __arraycount(gpt_custom_attrs),
 	.custom_attributes = gpt_custom_attrs,
 	.get_part_types_count = gpt_type_count,
 	.get_part_type = gpt_get_ptype,
 	.get_generic_part_type = gpt_get_generic_type,
 	.get_fs_part_type = gpt_get_fs_part_type,
 	.get_default_fstype = gpt_get_default_fstype,
 	.create_custom_part_type = gpt_create_custom_part_type,
 	.create_unknown_part_type = gpt_create_unknown_part_type,
 	.get_part_alignment = gpt_get_part_alignment,
 	.read_from_disk = gpt_read_from_disk,
 	.get_cylinder_size = gpt_cyl_size,
 	.create_new_for_disk = gpt_create_new,
 	.have_boot_support = gpt_have_boot_support,
 	.find_by_name = gpt_find_by_name,
 	.can_add_partition = gpt_can_add_partition,
 	.custom_attribute_writable = gpt_custom_attribute_writable,
 	.format_custom_attribute = gpt_format_custom_attribute,
 	.custom_attribute_toggle = gpt_custom_attribute_toggle,
 	.custom_attribute_set_str = gpt_custom_attribute_set_str,
 	.other_partition_identifier = gpt_get_label_str,
 	.get_part_device = gpt_get_part_device,
 	.max_free_space_at = gpt_max_free_space_at,
 	.get_free_spaces = gpt_get_free_spaces,
 	.adapt_foreign_part_info = generic_adapt_foreign_part_info,
 	.get_part_info = gpt_get_part_info,
 	.get_part_attr_str = gpt_get_part_attr_str,
 	.set_part_info = gpt_set_part_info,
 	.add_partition = gpt_add_part,
 	.delete_all_partitions = gpt_delete_all_partitions,
 	.delete_partition = gpt_delete_partition,
 	.write_to_disk = gpt_write_to_disk,
 	.free = gpt_free,
 	.destroy_part_scheme = gpt_destroy_part_scheme,
 	.cleanup = gpt_cleanup,
 };

 @@ -1,1000 +1,1000 @@
-/*	$NetBSD: partman.c,v 1.51 2021/01/31 22:45:46 rillig Exp $ */
+/*	$NetBSD: partman.c,v 1.52 2021/07/17 11:32:50 martin Exp $ */
 /*
  * Copyright 2012 Eugene Lozovoy
  * All rights reserved.
+ *
  * 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 Eugene Lozovoy 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.
+ *
  */
 /*
  * Copyright 2010 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * 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.
+ *
  * 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.
+ *
  */
 /* partman.c - extended partitioning */
 #include <assert.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <libgen.h>
 #include <paths.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <util.h>
 #include "defs.h"
 #include "msg_defs.h"
 #include "menu_defs.h"
 /* XXX: replace all MAX_* defines with vars that depend on kernel settings */
 #define MAX_ENTRIES 96
 #define MAX_RAID 8
 #define MAX_IN_RAID 48
 struct raid_comp {
 	char name[SSTRSIZE];	/* display name for this component */
 	struct disk_partitions *parts;	/* where is this on? */
 	part_id id;		/* which partition in parts */
 	bool is_spare;		/* is this a spare component? */
 };
 struct raid_desc {
 	int enabled;
 	int blocked;
 	int node;		/* the N in raid${N} */
 	int numRow, numCol, numSpare;
 	int sectPerSU, SUsPerParityUnit, SUsPerReconUnit, raid_level;
 	daddr_t total_size;
 	struct raid_comp comp[MAX_IN_RAID];
 };
 struct raid_desc *raids;
 #define MAX_VND 4
 struct vnd_desc {
 	int enabled;
 	int blocked;
 	int node;	/* the N in vnd${N} */
 	char filepath[STRSIZE];
 	daddr_t size;
 	int readonly;
 	int is_exist;
 	int manual_geom;
 	int secsize, nsectors, ntracks, ncylinders;
 	struct pm_devs *pm;	/* device this is on */
 	part_id pm_part;	/* which partition (in pm->parts) */
 };
 struct vnd_desc *vnds;
 #define MAX_CGD 4
 struct cgd_desc {
 	int enabled;
 	int blocked;
 	int node;	/* the N in cgd${N} */
 	char pm_name[SSTRSIZE];
 	const char *keygen_type;
 	const char *verify_type;
 	const char *enc_type;
 	const char *iv_type;
 	int key_size;
 	struct pm_devs *pm;	/* device this is on */
 	part_id pm_part;	/* which partition (in pm->parts) */
 };
 struct cgd_desc *cgds;
 #define MAX_LVM_VG 16
 #define MAX_LVM_PV 255
 #define MAX_LVM_LV 255
 struct lvm_pv_reg {
 	struct pm_devs *pm;
 	daddr_t start;
 };
 struct lvm_pv_reg lvm_pvs[MAX_LVM_PV];	/* XXX - make dynamic */
 typedef struct pv_t {
 	struct pm_devs *pm;
 	char pm_name[SSTRSIZE];
 	part_id pm_part;
 	int metadatasize;
 	int metadatacopies;
 	int labelsector;
 	int setphysicalvolumesize;
 } pv_t;
 typedef struct lv_t {
 	int blocked;
 	daddr_t size;
 	char name[SSTRSIZE];
 	int readonly;
 	int contiguous;
 	char extents[SSTRSIZE];
 	int minor;
 	int mirrors;
 	int regionsize;
 	int persistent;
 	int readahead;
 	int stripes;
 	int stripesize;
 	int zero;
 } lv_t;
 typedef struct lvms_t {
 	int enabled;
 	int blocked;
 	char name[SSTRSIZE];
 	int maxlogicalvolumes;
 	int maxphysicalvolumes;
 	int physicalextentsize;
 	daddr_t total_size;
 	pv_t pv[MAX_LVM_PV];
 	lv_t lv[MAX_LVM_LV];
 } lvms_t;
 lvms_t *lvms;
 typedef struct structinfo_t {
 	int max;
 	uint entry_size;
 	uint parent_size;
 	void *entry_first;
 	void *entry_enabled;
 	void *entry_blocked;
 	void *entry_node;
 } structinfo_t;
 structinfo_t raids_t_info, vnds_t_info, cgds_t_info, lvms_t_info, lv_t_info;
 typedef struct pm_upddevlist_adv_t {
 	const char *create_msg;
 	int pe_type;
 	structinfo_t *s;
 	int sub_num;
 	struct pm_upddevlist_adv_t *sub;
 } pm_upddevlist_adv_t;
 #define MAX_MNTS 48
 struct {
     char dev[STRSIZE];
     const char *mnt_opts, *on;
 } *mnts;
 static int pm_cursel; /* Number of selected entry in main menu */
 static int pm_changed; /* flag indicating that we have unsaved changes */
 static int pm_raid_curspare; /* XXX: replace by true way */
 static int pm_retvalue;
 enum { /* RAIDframe menu enum */
 	PMR_MENU_DEVS, PMR_MENU_DEVSSPARE, PMR_MENU_RAIDLEVEL, PMR_MENU_NUMROW,
 	PMR_MENU_NUMCOL, PMR_MENU_NUMSPARE,	PMR_MENU_SECTPERSU,	PMR_MENU_SUSPERPARITYUNIT,
 	PMR_MENU_SUSPERRECONUNIT, PMR_MENU_REMOVE, PMR_MENU_END
 };
 enum { /* VND menu enum */
 	PMV_MENU_FILEPATH, PMV_MENU_EXIST, PMV_MENU_SIZE, PMV_MENU_RO, PMV_MENU_MGEOM,
 	PMV_MENU_SECSIZE, PMV_MENU_NSECTORS, PMV_MENU_NTRACKS, PMV_MENU_NCYLINDERS,
 	PMV_MENU_REMOVE, PMV_MENU_END
 };
 enum { /* CGD menu enum */
 	PMC_MENU_DEV, PMC_MENU_ENCTYPE, PMC_MENU_KEYSIZE, PMC_MENU_IVTYPE,
 	PMC_MENU_KEYGENTYPE, PMC_MENU_VERIFYTYPE, PMC_MENU_REMOVE, PMC_MENU_END
 };
 enum { /* LVM menu enum */
 	PML_MENU_PV, PML_MENU_NAME, PML_MENU_MAXLOGICALVOLUMES,
 	PML_MENU_MAXPHYSICALVOLUMES, PML_MENU_PHYSICALEXTENTSIZE,
 	PML_MENU_REMOVE, PML_MENU_END
 };
 enum { /* LVM submenu (logical volumes) enum */
 	PMLV_MENU_NAME, PMLV_MENU_SIZE, PMLV_MENU_READONLY, PMLV_MENU_CONTIGUOUS,
 	PMLV_MENU_EXTENTS, PMLV_MENU_MINOR, PMLV_MENU_PERSISTENT,
 	PMLV_MENU_MIRRORS, PMLV_MENU_REGIONSIZE, PMLV_MENU_READAHEAD,
 	PMLV_MENU_STRIPES, PMLV_MENU_STRIPESIZE, PMLV_MENU_ZERO,
 	PMLV_MENU_REMOVE, PMLV_MENU_END
 };
 struct part_entry pm_dev_list(int);
 static int pm_raid_disk_add(menudesc *, void *);
 static int pm_raid_disk_del(menudesc *, void *);
 static int pm_cgd_disk_set(struct cgd_desc *, struct part_entry *);
 static int pm_mount(struct pm_devs *, int);
 static int pm_upddevlist(menudesc *, void *);
 static void pm_select(struct pm_devs *);
 static void
 pm_edit_size_value(msg prompt_msg, daddr_t bps, daddr_t cylsec, daddr_t *size)
+{
 	char answer[16], dflt[16];
 	daddr_t new_size_val, mult;
 	snprintf(dflt, sizeof dflt, "%" PRIu64 "%s", *size / sizemult,
 	    multname);
 	msg_prompt_win(prompt_msg, -1, 18, 0, 0, dflt, answer, sizeof answer);
 	mult = sizemult;
 	new_size_val = parse_disk_pos(answer, &mult, bps, cylsec, NULL);
 	if (new_size_val > 0)
 		*size = new_size_val * mult;
+}
 static const char *
 pm_get_mount(struct pm_devs *p, part_id id)
+{
 	if (p->mounted == NULL)
 		return NULL;
 	if (id >= p->parts->num_part)
 		return NULL;
 	return p->mounted[id];
+}
 bool pm_set_mount(struct pm_devs *p, part_id id, const char *path);
 bool
 pm_set_mount(struct pm_devs *p, part_id id, const char *path)
+{
 	if (p->parts == NULL || id >= p->parts->num_part)
 		return false;
 	if (p->mounted == NULL) {
 		p->mounted = calloc(p->parts->num_part, sizeof(char*));
 		if (p->mounted == NULL)
 			return false;
+	}
 	free(p->mounted[id]);
 	p->mounted[id] = strdup(path);
 	return p->mounted[id] != NULL;
+}
 /* Universal menu for RAID/VND/CGD/LVM entry edit */
 static int
 pm_edit(int menu_entries_count, void (*menu_fmt)(menudesc *, int, void *),
 	int (*action)(menudesc *, void *), int (*check_fun)(void *),
 	void (*entry_init)(void *, void *),	void *entry_init_arg,
 	void *dev_ptr, int dev_ptr_delta, structinfo_t *s)
+{
 	int i, ok = 0;
 	menu_ent *menu_entries;
 	if (dev_ptr == NULL) {
 		/* We should create new device */
 		for (i = 0; i < s->max && !ok; i++)
 			if (*(int*)((char*)s->entry_enabled + dev_ptr_delta + s->entry_size * i) == 0) {
 				dev_ptr = (char*)s->entry_first + dev_ptr_delta + s->entry_size * i;
 				entry_init(dev_ptr, entry_init_arg);
 				ok = 1;
+			}
 		if (!ok) {
 			/* We do not have free device slots */
 			hit_enter_to_continue(NULL, MSG_limitcount);
 			return -1;
+		}
+	}
 	menu_entries = calloc(menu_entries_count, sizeof *menu_entries);
 	for (i = 0; i < menu_entries_count - 1; i++)
 		menu_entries[i] = (menu_ent) { .opt_action=action };
 	menu_entries[i] = (menu_ent) {	.opt_name=MSG_fremove,
 					.opt_flags=OPT_EXIT,
 					.opt_action=action };
 	int menu_no = -1;
 	menu_no = new_menu(NULL, menu_entries, menu_entries_count,
 		-1, -1, 0, 40, MC_NOCLEAR | MC_SCROLL,
 		NULL, menu_fmt, NULL, NULL, MSG_DONE);
 	process_menu(menu_no, dev_ptr);
 	free_menu(menu_no);
 	free(menu_entries);
 	return check_fun(dev_ptr);
+}
 /* Show filtered partitions menu */
 struct part_entry
 pm_dev_list(int type)
+{
 	int dev_num = -1, num_devs = 0;
 	bool ok;
 	part_id i;
 	int menu_no;
 	struct disk_part_info info;
 	menu_ent menu_entries[MAX_DISKS*MAXPARTITIONS];
 	struct part_entry disk_entries[MAX_DISKS*MAXPARTITIONS];
 	struct pm_devs *pm_i;
 	SLIST_FOREACH(pm_i, &pm_head, l) {
 		if (pm_i->parts == NULL)
 			continue;
 		for (i = 0; i < pm_i->parts->num_part; i++) {
 			ok = false;
 			if (!pm_i->parts->pscheme->get_part_info(pm_i->parts,
 			    i, &info))
 				continue;
 			if (info.flags &
 			    (PTI_WHOLE_DISK|PTI_PSCHEME_INTERNAL|PTI_RAW_PART))
 				continue;
 			switch (type) {
 				case PM_RAID:
 					if (info.fs_type == FS_RAID)
 						ok = 1;
 					break;
 				case PM_CGD:
 					if (info.fs_type == FS_CGD)
 						ok = 1;
 					break;
 				case PM_LVM:
 					if (pm_is_lvmpv(pm_i, i, &info))
 						ok = 1;
 					break;
+			}
 			if (!ok)
 				continue;
 			if (pm_partusage(pm_i, i, 0) != 0)
 				continue;
 			disk_entries[num_devs].dev_ptr = pm_i;
 			disk_entries[num_devs].id = i;
 			disk_entries[num_devs].parts = pm_i->parts;
 			pm_i->parts->pscheme->get_part_device(
 			    pm_i->parts, i, disk_entries[num_devs].fullname,
 			    sizeof disk_entries[num_devs].fullname,
 			    NULL, plain_name, false, true);
 			menu_entries[num_devs] = (struct menu_ent) {
 				.opt_name = disk_entries[num_devs].fullname,
 				.opt_action = set_menu_select,
 				.opt_flags = OPT_EXIT,
 			};
 			num_devs++;
+		}
+	}
 	menu_no = new_menu(MSG_avdisks,
 		menu_entries, num_devs, -1, -1,
 		(num_devs+1<3)?3:num_devs+1, 13,
 		MC_SCROLL | MC_NOCLEAR, NULL, NULL, NULL, NULL, MSG_cancel);
 	if (menu_no == -1)
 		return (struct part_entry) { };
 	process_menu(menu_no, &dev_num);
 	free_menu(menu_no);
 	if (dev_num < 0 || dev_num >= num_devs)
 		return (struct part_entry) { };
 	pm_retvalue = dev_num;
 	return disk_entries[dev_num];
+}
 /* Get unused raid*, cgd* or vnd* device */
 static int
 pm_manage_getfreenode(void *node, const char *d, structinfo_t *s)
+{
 	int i, ii, ok;
 	char buf[SSTRSIZE];
 	struct pm_devs *pm_i;
 	*(int*)node = -1;
 	for (i = 0; i < s->max; i++) {
 		ok = 1;
 		/* Check that node is not already reserved */
 		for (ii = 0; ii < s->max; ii++) {
 			if (*(int*)((char*)s->entry_enabled + s->entry_size
 			    * ii) == 0)
 				continue;
 			if (*(int*)((char*)s->entry_node + s->entry_size * ii)
 			    == i) {
 				ok = 0;
 				break;
+			}
+		}
 		if (! ok)
 			continue;
 		/* Check that node is not in the device list */
 		snprintf(buf, SSTRSIZE, "%s%d", d, i);
 		SLIST_FOREACH(pm_i, &pm_head, l)
 			if (! strcmp(pm_i->diskdev, buf)) {
 				ok = 0;
 				break;
+			}
 		if (ok) {
 			*(int*)node = i;
 			return i;
+		}
+	}
 	hit_enter_to_continue(NULL, MSG_nofreedev);
 	return -1;
+}
 /*
  * Show a line for a device, usually with full size in the right
  * column, alternatively (if != NULL) with no_size_display
  * instead in paranthesis (used for error displays or to note
  * a action that can be done to this device.
  */
 static void
 pm_fmt_disk_line(WINDOW *w, const char *line, const char *on,
     daddr_t total, const char *no_size_display)
+{
 	char out[STRSIZE], human[6];
 	if (on != NULL) {
 		snprintf(out, sizeof out, "%s %s %s", line,
 		    msg_string(MSG_pm_menu_on), on);
 		line = out;
+	}
 	if (no_size_display != NULL) {
 		wprintw(w, "   %-56s (%s)", line, no_size_display);
 	} else {
 		humanize_number(human, sizeof(human),
 	            total * 512, "",
 		    HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
 		wprintw(w, "   %-56s %s", line, human);
+	}
+}
 /***
  RAIDs
  ***/
 static void
 pm_raid_menufmt(menudesc *m, int opt, void *arg)
+{
 	int i, ok = 0;
 	char buf[STRSIZE], rdev[STRSIZE], level[STRSIZE], *line;
 	struct raid_desc *dev_ptr = ((struct part_entry *)arg)[opt].dev_ptr;
 	if (dev_ptr->enabled == 0)
 		return;
 	buf[0] = '\0';
 	sprintf(rdev, "raid%d", dev_ptr->node);
 	for (i = 0; i < MAX_IN_RAID; i++) {
 		if (dev_ptr->comp[i].parts != NULL) {
 			strlcat(buf, dev_ptr->comp[i].name, sizeof buf);
 			strlcat(buf, " ", sizeof buf);
 			ok = 1;
+		}
+	}
 	if (ok) {
 		sprintf(level, "%u", dev_ptr->raid_level);
 		const char *args[] = { rdev, level };
 		line = str_arg_subst(msg_string(MSG_raid_menufmt),
 		    __arraycount(args), args);
 		pm_fmt_disk_line(m->mw, line, buf, dev_ptr->total_size, NULL);
 		free(line);
 	} else {
 		pm_fmt_disk_line(m->mw, buf, NULL, 0,
 		    msg_string(MSG_raid_err_menufmt));
+	}
+}
 static void
 pm_raid_edit_menufmt(menudesc *m, int opt, void *arg)
+{
 	int i;
 	char buf[STRSIZE];
 	struct raid_desc *dev_ptr = arg;
 	buf[0] = '\0';
 	switch (opt) {
 		case PMR_MENU_DEVS:
 			strlcpy(buf, msg_string(MSG_raid_disks_fmt),
 			    sizeof buf);
 			strlcat(buf, ": ", sizeof buf);
 			for (i = 0; i < MAX_IN_RAID; i++) {
 				if (dev_ptr->comp[i].parts == NULL ||
 				     dev_ptr->comp[i].is_spare)
 					continue;
 				strlcat(buf, " ", sizeof buf);
 				strlcat(buf, dev_ptr->comp[i].name, sizeof buf);
+			}
 			wprintw(m->mw, "%s", buf);
 			break;
 		case PMR_MENU_DEVSSPARE:
 			strlcpy(buf, msg_string(MSG_raid_spares_fmt),
 			    sizeof buf);
 			strlcat(buf, ": ", sizeof buf);
 			for (i = 0; i < MAX_IN_RAID; i++) {
 				if (dev_ptr->comp[i].parts == NULL ||
 				     !dev_ptr->comp[i].is_spare)
 					continue;
 				strlcat(buf, " ", sizeof buf);
 				strlcat(buf, dev_ptr->comp[i].name, sizeof buf);
+			}
 			wprintw(m->mw, "%s", buf);
 			break;
 		case PMR_MENU_RAIDLEVEL:
 			wprintw(m->mw, "%s: %u",
 			    msg_string(MSG_raid_level_fmt),
 			    dev_ptr->raid_level);
 			break;
 		case PMR_MENU_NUMROW:
 			wprintw(m->mw, "%s: %u",
 			    msg_string(MSG_raid_numrow_fmt), dev_ptr->numRow);
 			break;
 		case PMR_MENU_NUMCOL:
 			wprintw(m->mw, "%s: %u",
 			    msg_string(MSG_raid_numcol_fmt), dev_ptr->numCol);
 			break;
 		case PMR_MENU_NUMSPARE:
 			wprintw(m->mw, "%s: %u",
 			    msg_string(MSG_raid_numspare_fmt),
 			    dev_ptr->numSpare);
 			break;
 		case PMR_MENU_SECTPERSU:
 			wprintw(m->mw, "%s: %u",
 			    msg_string(MSG_raid_sectpersu_fmt),
 			    dev_ptr->sectPerSU);
 			break;
 		case PMR_MENU_SUSPERPARITYUNIT:
 			wprintw(m->mw, "%s: %u",
 			    msg_string(MSG_raid_superpar_fmt),
 			    dev_ptr->SUsPerParityUnit);
 			break;
 		case PMR_MENU_SUSPERRECONUNIT:
 			wprintw(m->mw, "%s: %u",
 			    msg_string(MSG_raid_superrec_fmt),
 			    dev_ptr->SUsPerReconUnit);
 			break;
+	}
+}
 static int
 pm_raid_set_value(menudesc *m, void *arg)
+{
 	int retvalue = -1;
 	int *out_var = NULL;
 	char buf[SSTRSIZE];
 	const char *msg_to_show = NULL;
 	struct raid_desc *dev_ptr = arg;
 	static menu_ent menuent_disk_adddel[] = {
 	    { .opt_name=MSG_add, .opt_flags=OPT_EXIT,
 	      .opt_action=pm_raid_disk_add },
 	    { .opt_name=MSG_remove, .opt_flags=OPT_EXIT,
 	      .opt_action=pm_raid_disk_del }
 	};
 	static int menu_disk_adddel = -1;
 	if (menu_disk_adddel == -1) {
 		menu_disk_adddel = new_menu(NULL, menuent_disk_adddel,
 			__arraycount(menuent_disk_adddel),
 			-1, -1, 0, 10, MC_NOCLEAR, NULL, NULL, NULL, NULL,
 			MSG_cancel);
+	}
 	switch (m->cursel) {
 		case PMR_MENU_DEVS:
 			pm_raid_curspare = 0;
 			process_menu(menu_disk_adddel, dev_ptr);
 			return 0;
 		case PMR_MENU_DEVSSPARE:
 			pm_raid_curspare = 1;
 			process_menu(menu_disk_adddel, dev_ptr);
 			return 0;
 		case PMR_MENU_RAIDLEVEL:
 			process_menu(MENU_raidlevel, &retvalue);
 			if (retvalue >= 0)
 				dev_ptr->raid_level = retvalue;
 			return 0;
 		case PMR_MENU_NUMROW:
 			hit_enter_to_continue(NULL, MSG_raid_nomultidim);
 			return 0;
 #if 0 /* notyet */
 			msg_to_show = MSG_raid_numrow_ask;
 			out_var = &(dev_ptr->numRow);
 			break;
 #endif
 		case PMR_MENU_NUMCOL:
 			msg_to_show = MSG_raid_numcol_ask;
 			out_var = &(dev_ptr->numCol);
 			break;
 		case PMR_MENU_NUMSPARE:
 			msg_to_show = MSG_raid_numspare_ask;
 			out_var = &(dev_ptr->numSpare);
 			break;
 		case PMR_MENU_SECTPERSU:
 			msg_to_show = MSG_raid_sectpersu_ask;
 			out_var = &(dev_ptr->sectPerSU);
 			break;
 		case PMR_MENU_SUSPERPARITYUNIT:
 			msg_to_show = MSG_raid_superpar_ask;
 			out_var = &(dev_ptr->SUsPerParityUnit);
 			break;
 		case PMR_MENU_SUSPERRECONUNIT:
 			msg_to_show = MSG_raid_superrec_ask;
 			out_var = &(dev_ptr->SUsPerReconUnit);
 			break;
 		case PMR_MENU_REMOVE:
 			dev_ptr->enabled = 0;
 			return 0;
+	}
 	if (out_var == NULL || msg_to_show == NULL)
 		return -1;
 	snprintf(buf, SSTRSIZE, "%d", *out_var);
 	msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE);
 	if (atoi(buf) >= 0)
 		*out_var = atoi(buf);
 	return 0;
+}
 static void
 pm_raid_init(void *arg, void *none)
+{
 	struct raid_desc *dev_ptr = arg;
 	memset(dev_ptr, 0, sizeof(*dev_ptr));
 	*dev_ptr = (struct raid_desc) {
 		.enabled = 1,
 		.blocked = 0,
 		.sectPerSU = 32,
 		.SUsPerParityUnit = 1,
 		.SUsPerReconUnit = 1,
 	};
+}
 static int
 pm_raid_check(void *arg)
+{
 	size_t i, dev_num = 0;
 	daddr_t min_size = 0, cur_size = 0;
 	struct raid_desc *dev_ptr = arg;
 	struct disk_part_info info;
 	struct disk_partitions *parts;
 	if (dev_ptr->blocked)
 		return 0;
 	for (i = 0; i < MAX_IN_RAID; i++) {
 		if (dev_ptr->comp[i].parts != NULL) {
 			parts = dev_ptr->comp[i].parts;
 			if (!parts->pscheme->get_part_info(parts,
 			    dev_ptr->comp[i].id, &info))
 				continue;
 			cur_size = info.size;
 			if (cur_size < min_size || dev_num == 0)
 				min_size = cur_size;
 			if (dev_ptr->comp[i].is_spare)
 				continue;
 			dev_num++;
+		}
+	}
 	/* Calculate sum of available space */
 	if (dev_num > 0) {
 		switch (dev_ptr->raid_level) {
 			case 0:
 				dev_ptr->total_size = min_size * dev_num;
 				break;
 			case 1:
 				dev_ptr->total_size = min_size;
 				break;
 			case 4:
 			case 5:
 				dev_ptr->total_size = min_size * (dev_num - 1);
 				break;
+		}
 		pm_manage_getfreenode(&(dev_ptr->node), "raid", &raids_t_info);
 		if (dev_ptr->node < 0)
 			dev_ptr->enabled = 0;
+	}
 	else
 		dev_ptr->enabled = 0;
 	return dev_ptr->enabled;
+}
 static int
 pm_raid_disk_add(menudesc *m, void *arg)
+{
 	int i;
 	struct raid_desc *dev_ptr = arg;
 	struct part_entry disk_entrie = pm_dev_list(PM_RAID);
 	if (pm_retvalue < 0)
 		return pm_retvalue;
 	for (i = 0; i < MAX_IN_RAID; i++)
 		if (dev_ptr->comp[i].parts == NULL) {
 			dev_ptr->comp[i].parts = disk_entrie.parts;
 			dev_ptr->comp[i].id = disk_entrie.id;
 			dev_ptr->comp[i].is_spare = pm_raid_curspare;
 			strlcpy(dev_ptr->comp[i].name, disk_entrie.fullname,
 			    sizeof dev_ptr->comp[i].name);
 			if (pm_raid_curspare)
 				dev_ptr->numSpare++;
 			else
 				dev_ptr->numCol++;
 			dev_ptr->numRow = 1;
 			break;
+		}
 	return 0;
+}
 static int
 pm_raid_disk_del(menudesc *m, void *arg)
+{
 	int retvalue = -1, num_devs = 0;
 	int i, pm_cur;
 	int menu_no;
 	struct raid_desc *dev_ptr = arg;
 	menu_ent menu_entries[MAX_IN_RAID];
 	struct part_entry submenu_args[MAX_IN_RAID];
 	for (i = 0; i < MAX_IN_RAID; i++) {
 		if (dev_ptr->comp[i].parts == NULL ||
 			dev_ptr->comp[i].is_spare != pm_raid_curspare)
 			continue;
 		menu_entries[num_devs] = (struct menu_ent) {
 			.opt_name = dev_ptr->comp[i].name,
 			.opt_action = set_menu_select,
 			.opt_flags = OPT_EXIT,
 		};
 		submenu_args[num_devs].dev_ptr = dev_ptr;
 		submenu_args[num_devs].index = i;
 		num_devs++;
+	}
 	menu_no = new_menu(MSG_raid_disks,
 		menu_entries, num_devs, -1, -1,
 		(num_devs+1<3)?3:num_devs+1, 13,
 		MC_SCROLL | MC_NOCLEAR, NULL, NULL, NULL, NULL, MSG_cancel);
 	if (menu_no == -1)
 		return -1;
 	process_menu(menu_no, &retvalue);
 	free_menu(menu_no);
 	if (retvalue < 0 || retvalue >= num_devs)
 		return -1;
 	pm_cur = submenu_args[retvalue].index;
 	if (dev_ptr->comp[pm_cur].is_spare)
 		dev_ptr->numSpare--;
 	else
 		dev_ptr->numCol--;
 	dev_ptr->numRow = (dev_ptr->numCol)?1:0;
 	dev_ptr->comp[pm_cur].parts = NULL;
 	return 0;
+}
 static int
 pm_raid_commit(void)
+{
 	int i, ii;
 	FILE *f;
 	char f_name[STRSIZE], devname[STRSIZE];
 	for (i = 0; i < MAX_RAID; i++) {
 		if (! pm_raid_check(&raids[i]))
 			continue;
 		/* Generating configure file for our raid */
 		snprintf(f_name, SSTRSIZE, "/tmp/raid.%d.conf", raids[i].node);
 		f = fopen(f_name, "w");
 		if (f == NULL) {
 			endwin();
 			(void)fprintf(stderr,
 			    "Could not open %s for writing\n", f_name);
 			if (logfp)
 				(void)fprintf(logfp,
 				    "Could not open %s for writing\n", f_name);
 			return 1;
+		}
 		scripting_fprintf(NULL, "cat <<EOF >%s\n", f_name);
 		scripting_fprintf(f, "START array\n%d %d %d\n",
 		    raids[i].numRow, raids[i].numCol, raids[i].numSpare);
 		scripting_fprintf(f, "\nSTART disks\n");
 		for (ii = 0; ii < MAX_IN_RAID; ii++) {
 			if (raids[i].comp[ii].parts != NULL &&
 			    !raids[i].comp[ii].is_spare) {
 				strcpy(devname, raids[i].comp[ii].name);
 				if (raids[i].comp[ii].parts != NULL &&
 				    raids[i].comp[ii].id != NO_PART) {
 					/* wedge may have moved */
 					raids[i].comp[ii].parts->pscheme->
 					    get_part_device(
 					    raids[i].comp[ii].parts,
 					    raids[i].comp[ii].id,
 					    devname, sizeof devname, NULL,
 					    logical_name, true, true);
 					raids[i].comp[ii].parts->pscheme->
 					    get_part_device(
 					    raids[i].comp[ii].parts,
 					    raids[i].comp[ii].id,
 					    raids[i].comp[ii].name,
 					    sizeof raids[i].comp[ii].name,
 					    NULL, plain_name, true, true);
+				}
 				scripting_fprintf(f,  "%s\n", devname);
+			}
+		}
 		scripting_fprintf(f, "\nSTART spare\n");
 		for (ii = 0; ii < MAX_IN_RAID; ii++) {
 			if (raids[i].comp[ii].parts != NULL &&
 			    raids[i].comp[ii].is_spare) {
 				strcpy(devname, raids[i].comp[ii].name);
 				if (raids[i].comp[ii].parts != NULL &&
 				    raids[i].comp[ii].id != NO_PART) {
 					/* wedge may have moved */
 					raids[i].comp[ii].parts->pscheme->
 					    get_part_device(
 					    raids[i].comp[ii].parts,
 					    raids[i].comp[ii].id,
 					    devname, sizeof devname, NULL,
 					    logical_name, true, true);
 					raids[i].comp[ii].parts->pscheme->
 					    get_part_device(
 					    raids[i].comp[ii].parts,
 					    raids[i].comp[ii].id,
 					    raids[i].comp[ii].name,
 					    sizeof raids[i].comp[ii].name,
 					    NULL, plain_name, true, true);
+				}
 				scripting_fprintf(f,  "%s\n",
 				    devname);
+			}
+		}
 		scripting_fprintf(f, "\nSTART layout\n%d %d %d %d\n",
 		    raids[i].sectPerSU,	raids[i].SUsPerParityUnit,
 		    raids[i].SUsPerReconUnit, raids[i].raid_level);
 		scripting_fprintf(f, "\nSTART queue\nfifo 100\n\n");
 		scripting_fprintf(NULL, "EOF\n");
 		fclose (f);
 		fflush(NULL);
 		/* Raid initialization */
 		if (run_program(RUN_DISPLAY | RUN_PROGRESS,
 			"raidctl -C %s raid%d", f_name, raids[i].node) == 0 &&
 		    run_program(RUN_DISPLAY | RUN_PROGRESS,
 			"raidctl -I %d raid%d", rand(), raids[i].node) == 0 &&
 		    run_program(RUN_DISPLAY | RUN_PROGRESS,
 		        "raidctl -vi raid%d", raids[i].node) == 0 &&
 		    run_program(RUN_DISPLAY | RUN_PROGRESS,
 			"raidctl -v -A yes raid%d", raids[i].node) == 0) {
 			/*
 			 * RAID creation done, remove it from list to
 			 * prevent its repeated reinitialization
 			 */
 			raids[i].blocked = 1;
+		}
+	}
 	return 0;
+}
 /***
  VND
  ***/
 static void
 pm_vnd_menufmt(menudesc *m, int opt, void *arg)
+{
 	struct vnd_desc *dev_ptr = ((struct part_entry *)arg)[opt].dev_ptr;
 	char dev[STRSIZE];
 	if (dev_ptr->enabled == 0)
 		return;
 	sprintf(dev, "vnd%d", dev_ptr->node);
 	if (strlen(dev_ptr->filepath) < 1)
 		pm_fmt_disk_line(m->mw, dev, NULL,
 , msg_string(MSG_vnd_err_menufmt));
 	else if (dev_ptr->is_exist)
 		pm_fmt_disk_line(m->mw, dev, dev_ptr->filepath,
 , msg_string(MSG_vnd_assign));
 	else
 		pm_fmt_disk_line(m->mw, dev, dev_ptr->filepath,
 		    dev_ptr->size, NULL);
+}
 static int
 max_msg_length(const msg *p, size_t cnt)
+{
 	int len, m = 0;
 	while (cnt > 0) {
 		len = strlen(msg_string(*p));
 		if (len > m)
 			m = len;
 		cnt--; p++;
+	}
 	return m;
+}
 static void
 pm_vnd_edit_menufmt(menudesc *m, int opt, void *arg)
+{
 	struct vnd_desc *dev_ptr = arg;
 	char buf[SSTRSIZE];
 	strcpy(buf, "-");
 	static int lcol_width;
 	if (lcol_width == 0) {
 		static const msg labels[] = {
 		    MSG_vnd_path_fmt, MSG_vnd_assign_fmt, MSG_vnd_size_fmt,
 		    MSG_vnd_ro_fmt, MSG_vnd_geom_fmt, MSG_vnd_bps_fmt,
 		    MSG_vnd_spt_fmt, MSG_vnd_tpc_fmt, MSG_vnd_cyl_fmt
 		};
 		lcol_width = max_msg_length(labels, __arraycount(labels)) + 3;
+	}
 	switch (opt) {
 		case PMV_MENU_FILEPATH:
 			wprintw(m->mw, "%*s %s", -lcol_width,
 			    msg_string(MSG_vnd_path_fmt), dev_ptr->filepath);
 			break;
 		case PMV_MENU_EXIST:
 			wprintw(m->mw, "%*s %s", -lcol_width,
 			    msg_string(MSG_vnd_assign_fmt),
 			    dev_ptr->is_exist?
 				msg_string(MSG_No) : msg_string(MSG_Yes));
 			break;
 		case PMV_MENU_SIZE:
 			if (!dev_ptr->is_exist)
 				snprintf(buf, SSTRSIZE, "%" PRIu64,
 				    dev_ptr->size / sizemult);
 			wprintw(m->mw, "%*s %s", -lcol_width,
 			    msg_string(MSG_vnd_size_fmt), buf);
 			break;
 		case PMV_MENU_RO:
 			wprintw(m->mw, "%*s %s", -lcol_width,
 			    msg_string(MSG_vnd_ro_fmt),
 			    dev_ptr->readonly?
 				msg_string(MSG_Yes) : msg_string(MSG_No));
 			break;
 		case PMV_MENU_MGEOM:
 			if (!dev_ptr->is_exist)
 				snprintf(buf, SSTRSIZE, "%s",
 				    dev_ptr->manual_geom?
 				    msg_string(MSG_Yes) : msg_string(MSG_No));
 			wprintw(m->mw, "%*s %s", -lcol_width,
 			    msg_string(MSG_vnd_geom_fmt), buf);
 @@ -1851,1563 +1851,1563 @@ pm_lvmlv_edit_menufmt(menudesc *m, int o
 				snprintf(buf, STRSIZE, "%d", dev_ptr->stripes);
 			wprintw(m->mw, "%-20s: %s",
 			    msg_string(MSG_lvmlv_stripes_fmt), buf);
 			break;
 		case PMLV_MENU_STRIPESIZE:
 			if (dev_ptr->stripesize > 0)
 				snprintf(buf, STRSIZE, "%dK", dev_ptr->stripesize);
 			wprintw(m->mw, "%-20s: %s",
 			    msg_string(MSG_lvmlv_stripesiz_fmt), buf);
 			break;
 		case PMLV_MENU_ZERO:
 			wprintw(m->mw, "%-20s: %s",
 			    msg_string(MSG_lvmlv_zero_fmt),
 			    dev_ptr->zero ?
 			    msg_string(MSG_Yes) : msg_string(MSG_No));
 			break;
+	}
+}
 static int
 pm_lvmlv_set_value(menudesc *m, void *arg)
+{
 	char buf[STRSIZE];
 	const char *msg_to_show = NULL;
 	int *out_var = NULL;
 	lv_t *dev_ptr = arg;
 	switch (m->cursel) {
 		case PMLV_MENU_NAME:
 			msg_prompt_win(MSG_lvmlv_name_ask, -1, 18, 0, 0,
 			    dev_ptr->name, dev_ptr->name, SSTRSIZE);
 			return 0;
 		case PMLV_MENU_SIZE:
 			pm_edit_size_value(MSG_lvmlv_size_ask,
 			    pm->sectorsize, pm->dlcylsize,
 			    &dev_ptr->size); /* XXX cylsize? */
 			break;
 		case PMLV_MENU_READONLY:
 			dev_ptr->readonly = !dev_ptr->readonly;
 			return 0;
 		case PMLV_MENU_CONTIGUOUS:
 			dev_ptr->contiguous = !dev_ptr->contiguous;
 			return 0;
 		case PMLV_MENU_EXTENTS:
 			msg_prompt_win(MSG_lvmlv_extnum_ask, -1, 18, 0, 0,
 			    dev_ptr->extents, dev_ptr->extents, SSTRSIZE);
 			return 0;
 		case PMLV_MENU_MINOR:
 			msg_to_show = MSG_lvmlv_minor_ask;
 			out_var = &(dev_ptr->minor);
 			break;
 		case PMLV_MENU_MIRRORS:
 			msg_to_show = MSG_lvmlv_mirrors_ask;
 			out_var = &(dev_ptr->mirrors);
 			break;
 		case PMLV_MENU_REGIONSIZE:
 			msg_to_show = MSG_lvmlv_regsiz_ask;
 			out_var = &(dev_ptr->regionsize);
 			break;
 		case PMLV_MENU_PERSISTENT:
 			dev_ptr->persistent = !dev_ptr->persistent;
 			return 0;
 		case PMLV_MENU_READAHEAD:
 			msg_to_show = MSG_lvmlv_readahsect_ask;
 			out_var = &(dev_ptr->readahead);
 			break;
 		case PMLV_MENU_STRIPES:
 			msg_to_show = MSG_lvmlv_stripes_ask;
 			out_var = &(dev_ptr->stripes);
 			break;
 		case PMLV_MENU_STRIPESIZE:
 			if (dev_ptr->stripesize << 1 > 512)
 				dev_ptr->stripesize = 4;
 			else
 				dev_ptr->stripesize <<= 1;
 			return 0;
 		case PMLV_MENU_ZERO:
 			dev_ptr->zero = !dev_ptr->zero;
 			return 0;
 		case PMLV_MENU_REMOVE:
 			dev_ptr->size = 0;
 			return 0;
+	}
 	if (out_var == NULL || msg_to_show == NULL)
 		return -1;
 	snprintf(buf, SSTRSIZE, "%d", *out_var);
 	msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE);
 	if (atoi(buf) >= 0)
 		*out_var = atoi(buf);
 	return 0;
+}
 static void
 pm_lvmlv_init(void *arg, void *none)
+{
 	lv_t *dev_ptr = arg;
 	memset(dev_ptr, 0, sizeof *(dev_ptr));
 	*dev_ptr = (struct lv_t) {
 		.blocked = 0,
 		.size = 1024,
 		.stripesize = 64,
 	};
 	sprintf (dev_ptr->name, "lvol%.2d", rand()%100);
+}
 static int
 pm_lvmlv_check(void *arg)
+{
 	lv_t *dev_ptr = arg;
 	if (dev_ptr->size > 0 && strlen(dev_ptr->name) > 0)
 		return 1;
 	else {
 		dev_ptr->size = 0;
 		return 0;
+	}
+}
 static int
 pm_lvm_commit(void)
+{
 	int i, ii, error;
 	uint used_size = 0;
 	char params[STRSIZE*3], devs[STRSIZE*3], arg[STRSIZE];
 	for (i = 0; i < MAX_LVM_VG; i++) {
 		/* Stage 0: checks */
 		if (! pm_lvm_check(&lvms[i]))
 			continue;
 		for (ii = 0; ii < MAX_LVM_LV; ii++)
 			used_size += lvms[i].lv[ii].size;
 		if (used_size > lvms[i].total_size)
 			continue;
 		params[0] = '\0';
 		devs[0] = '\0';
 		error = 0;
 		/* Stage 1: creating Physical Volumes (PV's) */
 		for (ii = 0; ii < MAX_LVM_PV && ! error; ii++)
 			if (lvms[i].pv[ii].pm != NULL) {
 				run_program(RUN_SILENT | RUN_ERROR_OK,
 				    "lvm pvremove -ffy /dev/r%s",
 				    (char*)lvms[i].pv[ii].pm_name);
 				error += run_program(RUN_DISPLAY | RUN_PROGRESS,
 				    "lvm pvcreate -ffy /dev/r%s",
 				    (char*)lvms[i].pv[ii].pm_name);
 				if (error)
 					break;
 				strlcat(devs, " /dev/r", sizeof devs);
 				strlcat(devs, lvms[i].pv[ii].pm_name,
 				    sizeof devs);
+			}
 		if (error)
 			continue;
 		/* Stage 2: creating Volume Groups (VG's) */
 		if (lvms[i].maxlogicalvolumes > 0) {
 			snprintf(arg, sizeof arg, " -l %d",
 			    lvms[i].maxlogicalvolumes);
 			strlcat(params, arg, sizeof params);
+		}
 		if (lvms[i].maxphysicalvolumes > 0) {
 			snprintf(arg, sizeof arg, " -p %d",
 			    lvms[i].maxphysicalvolumes);
 			strlcat(params, arg, sizeof params);
+		}
 		if (lvms[i].physicalextentsize > 0) {
 			snprintf(arg, sizeof arg, " -s %d",
 			    lvms[i].physicalextentsize);
 			strlcat(params, arg, sizeof params);
+		}
 		error += run_program(RUN_DISPLAY | RUN_PROGRESS,
 		    "lvm vgcreate %s %s %s", params, lvms[i].name, devs);
 		if (error)
 			continue;
 		/* Stage 3: creating Logical Volumes (LV's) */
 		for (ii = 0; ii < MAX_LVM_LV; ii++) {
 			if (lvms[i].lv[ii].size <= 0)
 				continue;
 			params[0] = '\0';
 			snprintf(arg, sizeof arg, " -C %c",
 			    lvms[i].lv[ii].contiguous?'y':'n');
 			strlcat(params, arg, sizeof params);
 			snprintf(arg, sizeof arg, " -M %c",
 			    lvms[i].lv[ii].persistent?'y':'n');
 			strlcat(params, arg, sizeof params);
 			snprintf(arg, sizeof arg, " -p %s",
 			    lvms[i].lv[ii].readonly?"r":"rw");
 			strlcat(params, arg, sizeof params);
 			snprintf(arg, sizeof arg, " -Z %c",
 			    lvms[i].lv[ii].zero?'y':'n');
 			strlcat(params, arg, sizeof params);
 			if (strlen(lvms[i].lv[ii].name) > 0) {
 				snprintf(arg, sizeof arg, " -n %s",
 				    lvms[i].lv[ii].name);
 				strlcat(params, arg, sizeof params);
+			}
 			if (strlen(lvms[i].lv[ii].extents) > 0) {
 				snprintf(arg, sizeof arg, " -l %s",
 				    lvms[i].lv[ii].extents);
 				strlcat(params, arg, sizeof params);
+			}
 			if (lvms[i].lv[ii].minor > 0) {
 				snprintf(arg, sizeof arg, " --minor %d",
 				    lvms[i].lv[ii].minor);
 				strlcat(params, arg, sizeof params);
+			}
 			if (lvms[i].lv[ii].mirrors > 0) {
 				snprintf(arg, sizeof arg, " -m %d",
 				    lvms[i].lv[ii].mirrors);
 				strlcat(params, arg, sizeof params);
 				if (lvms[i].lv[ii].regionsize > 0) {
 					snprintf(arg, sizeof arg, " -R %d",
 					     lvms[i].lv[ii].regionsize);
 					strlcat(params, arg, sizeof params);
+				}
+			}
 			if (lvms[i].lv[ii].readahead > 0) {
 				snprintf(arg, sizeof arg, " -r %d",
 				    lvms[i].lv[ii].readahead);
 				strlcat(params, arg, sizeof params);
+			}
 			if (lvms[i].lv[ii].stripes > 0) {
 				snprintf(arg, sizeof arg, " -i %d",
 				    lvms[i].lv[ii].stripes);
 				strlcat(params, arg, sizeof params);
 				if (lvms[i].lv[ii].stripesize > 0) {
 					snprintf(arg, sizeof arg, " -I %d",
 					    lvms[i].lv[ii].stripesize);
 					strlcat(params, arg, sizeof params);
+				}
+			}
 			snprintf(arg, sizeof arg, " -L %" PRIi64 "M",
 			    lvms[i].lv[ii].size);
 			strlcat(params, arg, sizeof params);
 			error += run_program(RUN_DISPLAY | RUN_PROGRESS,
 			    "lvm lvcreate %s %s", params, lvms[i].name);
+		}
 		if (! error) {
 			lvms[i].blocked = 1;
 			for (ii = 0; ii < MAX_LVM_PV; ii++)
 				if (lvms[i].pv[ii].pm != NULL)
 					lvms[i].pv[ii].pm->blocked++;
 			for (ii = 0; ii < MAX_LVM_LV; ii++)
 				if (lvms[i].lv[ii].size > 0)
 					lvms[i].lv[ii].blocked = 1;
+		}
+	}
 	return 0;
+}
 /***
  Partman generic functions
  ***/
 int
 pm_getrefdev(struct pm_devs *pm_cur)
+{
 	int i, ii, dev_num, num_devs, num_devs_s;
 	char descr[MENUSTRSIZE], dev[MENUSTRSIZE] = "";
 	pm_cur->refdev = NULL;
 	if (! strncmp(pm_cur->diskdev, "cgd", 3)) {
 		dev_num = pm_cur->diskdev[3] - '0';
 		for (i = 0; i < MAX_CGD; i++)
 			if (cgds[i].blocked && cgds[i].node == dev_num) {
 				pm_cur->refdev = &cgds[i];
 				snprintf(descr, sizeof descr,
 				    " (%s, %s-%d)", cgds[i].pm_name,
 				    cgds[i].enc_type, cgds[i].key_size);
 				strlcat(pm_cur->diskdev_descr, descr,
 				    sizeof(pm_cur->diskdev_descr));
 				break;
+			}
  	} else if (! strncmp(pm_cur->diskdev, "vnd", 3)) {
  		dev_num = pm_cur->diskdev[3] - '0';
  		for (i = 0; i < MAX_VND; i++)
 			if (vnds[i].blocked && vnds[i].node == dev_num) {
 				pm_cur->refdev = &vnds[i];
 				vnds[i].pm->parts->pscheme->get_part_device(
 				    vnds[i].pm->parts, vnds[i].pm_part,
 				    dev, sizeof dev, NULL, plain_name, false,
 				    true);
 				snprintf(descr, sizeof descr, " (%s, %s)",
 				    dev, vnds[i].filepath);
 				strlcat(pm_cur->diskdev_descr, descr,
 				    sizeof(pm_cur->diskdev_descr));
 				break;
+			}
 	} else if (! strncmp(pm_cur->diskdev, "raid", 4)) {
 		dev_num = pm_cur->diskdev[4] - '0';
  		for (i = 0; i < MAX_RAID; i++)
 			if (raids[i].blocked && raids[i].node == dev_num) {
 				pm_cur->refdev = &raids[i];
 				num_devs = 0; num_devs_s = 0;
 				for (ii = 0; ii < MAX_IN_RAID; ii++)
 					if (raids[i].comp[ii].parts != NULL) {
 						if(raids[i].comp[ii].is_spare)
 							num_devs_s++;
 						else
 							num_devs++;
+					}
 				snprintf(descr, sizeof descr,
 				    " (lvl %d, %d disks, %d spare)",
 				    raids[i].raid_level, num_devs,
 				    num_devs_s);
 				strlcat(pm_cur->diskdev_descr, descr,
 				    sizeof(pm_cur->diskdev_descr));
 				break;
+			}
 	} else
 		return -1;
 	return 0;
+}
 /*
  * Enable/disable items in the extended partition disk/partition action
  * menu
  */
 void
 pmdiskentry_enable(menudesc *menu, struct part_entry *pe)
+{
 	int i;
 	menu_ent *m;
 	bool enable;
 	for (i = 0; i < menu->numopts; i++) {
 		m = &menu->opts[i];
 		enable = false;
 		if (m->opt_name == MSG_unconfig) {
 			if (pe->type == PM_DISK)
 				enable = ((struct pm_devs *)pe->dev_ptr)
 				    ->refdev != NULL;
 		} else if (m->opt_name == MSG_undo) {
 			if (pe->type != PM_DISK)
 				continue;
 			enable = ((struct pm_devs *)pe->dev_ptr)->unsaved;
 		} else if (m->opt_name == MSG_switch_parts) {
 			enable = pm_from_pe(pe)->parts != NULL;
 		} else {
 			continue;
+		}
 		if (enable)
 			m->opt_flags &= ~OPT_IGNORE;
 		else
 			m->opt_flags |= OPT_IGNORE;
+	}
+}
 /* Detect that partition is in use */
 int
 pm_partusage(struct pm_devs *pm_cur, int part_num, int do_del)
+{
 	int i, ii, retvalue = 0;
 	struct disk_part_info info;
 	part_id id;
 	if (pm_cur->parts == NULL)
 		return -1;	/* nothing can be in use */
 	if (part_num < 0) {
 		/* Check all partitions on device */
 		for (id = 0; id < pm_cur->parts->num_part; id++) {
 			if (!pm_cur->parts->pscheme->get_part_info(
 			    pm_cur->parts, id, &info))
 				continue;
 			if (info.flags & (PTI_SEC_CONTAINER|
 			    PTI_WHOLE_DISK|PTI_PSCHEME_INTERNAL|
 			    PTI_RAW_PART))
 				continue;
 			retvalue += pm_partusage(pm_cur, id, do_del);
+		}
 		return retvalue;
+	}
 	id = (part_id)part_num;
 	if (id >= pm_cur->parts->num_part)
 		return 0;
 	for (i = 0; i < MAX_CGD; i++)
 		if (cgds[i].enabled &&
 			cgds[i].pm == pm_cur &&
 			cgds[i].pm_part == id) {
 			if (do_del) {
 				cgds[i].pm = NULL;
 				cgds[i].pm_name[0] = '\0';
+			}
 			return 1;
+		}
 	for (i = 0; i < MAX_RAID; i++)
 		for (ii = 0; ii < MAX_IN_RAID; ii++)
 			if (raids[i].enabled &&
 				raids[i].comp[ii].parts == pm_cur->parts &&
 				raids[i].comp[ii].id == id) {
 					if (do_del)
 						raids[i].comp[ii].parts = NULL;
 					return 1;
+			}
 	for (i = 0; i < MAX_LVM_VG; i++)
 		for (ii = 0; ii < MAX_LVM_PV; ii++)
 			if (lvms[i].enabled &&
 				lvms[i].pv[ii].pm == pm_cur &&
 				lvms[i].pv[ii].pm_part == id) {
 					if (do_del)
 						lvms[i].pv[ii].pm = NULL;
 					return 1;
+			}
 	return 0;
+}
 static void
 pm_destroy_one(struct pm_devs *pm_i)
+{
 	part_id i;
 	if (pm_i->parts != NULL) {
 		if (pm_i->mounted != NULL) {
 			for (i = 0; i < pm_i->parts->num_part; i++)
 				free(pm_i->mounted[i]);
+		}
 		pm_i->parts->pscheme->free(pm_i->parts);
+	}
 	free(pm_i);
+}
 /* Clean up removed devices */
 static int
 pm_clean(void)
+{
 	int count = 0;
 	struct pm_devs *pm_i, *tmp;
 	SLIST_FOREACH_SAFE(pm_i, &pm_head, l, tmp)
 		if (! pm_i->found) {
 			count++;
 			SLIST_REMOVE(&pm_head, pm_i, pm_devs, l);
 			pm_destroy_one(pm_i);
+		}
 	return count;
+}
 /* Free all pm storage */
 void
 pm_destroy_all(void)
+{
 	struct pm_devs *pm_i, *tmp;
 	if (pm_new != pm)
 		pm_destroy_one(pm_new);
 	SLIST_FOREACH_SAFE(pm_i, &pm_head, l, tmp) {
 		SLIST_REMOVE(&pm_head, pm_i, pm_devs, l);
 		pm_destroy_one(pm_i);
+	}
+}
 void
 pm_set_lvmpv(struct pm_devs *my_pm, part_id pno, bool add)
+{
 	size_t i;
 	struct disk_part_info info;
 	if (!my_pm->parts->pscheme->get_part_info(my_pm->parts, pno, &info))
 		return;
 	if (add) {
 		for (i = 0; i < __arraycount(lvm_pvs); i++)
 			if (lvm_pvs[i].pm == NULL && lvm_pvs[i].start == 0)
 				break;
 		if (i >= __arraycount(lvm_pvs))
 			return;
 		lvm_pvs[i].pm = my_pm;
 		lvm_pvs[i].start = info.start;
 		return;
 	} else {
 		for (i = 0; i < __arraycount(lvm_pvs); i++)
 			if (lvm_pvs[i].pm == my_pm &&
 			    lvm_pvs[i].start == info.start)
 				break;
 		if (i >= __arraycount(lvm_pvs))
 			return;
 		lvm_pvs[i].pm = NULL;
 		lvm_pvs[i].start = 0;
+	}
+}
 bool
 pm_is_lvmpv(struct pm_devs *my_pm, part_id id,
     const struct disk_part_info *info)
+{
 	size_t i;
 	for (i = 0; i < __arraycount(lvm_pvs); i++) {
 		if (lvm_pvs[i].pm != my_pm)
 			continue;
 		if (lvm_pvs[i].start == info->start)
 			return true;
+	}
 	return false;
+}
 void
 pm_setfstype(struct pm_devs *pm_cur, part_id id, int fstype, int fs_subtype)
+{
 	struct disk_part_info info;
 	if (!pm_cur->parts->pscheme->get_part_info(pm_cur->parts, id, &info))
 		return;
 	info.nat_type = pm_cur->parts->pscheme->get_fs_part_type(PT_root,
 	    fstype, fs_subtype);
 	if (info.nat_type == NULL)
 		return;
 	info.fs_type = fstype;
 	info.fs_sub_type = fs_subtype;
 	pm_cur->parts->pscheme->set_part_info(pm_cur->parts, id, &info, NULL);
+}
 static void
 pm_select(struct pm_devs *pm_devs_in)
+{
 	pm = pm_devs_in;
 	if (logfp)
 		(void)fprintf(logfp, "Partman device: %s\n", pm->diskdev);
+}
 void
 pm_rename(struct pm_devs *pm_cur)
+{
 #if 0	// XXX - convert to custom attribute or handle similar
 	pm_select(pm_cur);
 	msg_prompt_win(MSG_packname, -1, 18, 0, 0, pm_cur->bsddiskname,
 		pm_cur->bsddiskname, sizeof pm_cur->bsddiskname);
 #ifndef NO_DISKLABEL
 	(void) savenewlabel(pm_cur->bsdlabel, MAXPARTITIONS);
 #endif
 #endif
+}
 int
 pm_editpart(int part_num)
+{
 	struct partition_usage_set pset = {};
 	usage_set_from_parts(&pset, pm->parts);
 	edit_ptn(&(struct menudesc){.cursel = part_num}, &pset);
 	free_usage_set(&pset);
 	if (checkoverlap(pm->parts)) {
 		hit_enter_to_continue(MSG_cantsave, NULL);
 		return -1;
+	}
 	pm->unsaved = 1;
 	return 0;
+}
 /* Safe erase of disk */
 void
 pm_shred(struct part_entry *pe, int shredtype)
+{
 	const char *srcdev;
 	char dev[SSTRSIZE];
 	struct pm_devs *my_pm;
 	my_pm = pe->dev_ptr;
 	if (pe->type == PM_DISK) {
 		snprintf(dev, sizeof dev,
 		    _PATH_DEV "r%s%c", my_pm->diskdev, 'a' + RAW_PART);
 		if (pe->parts != NULL) {
 			pe->parts->pscheme->free(pe->parts);
 			pe->parts = NULL;
 			my_pm->parts = NULL;
+		}
 	} else if (pe->type == PM_PART) {
 		pe->parts->pscheme->get_part_device(pe->parts, pe->id,
 		    dev, sizeof dev, NULL, raw_dev_name, true, true);
+	}
 	switch (shredtype) {
 		case SHRED_ZEROS:
 			srcdev = _PATH_DEVZERO;
 			break;
 		case SHRED_RANDOM:
 			srcdev = _PATH_URANDOM;
 			break;
 		default:
 			return;
+	}
 	run_program(RUN_DISPLAY | RUN_PROGRESS,
 	    "progress -f %s -b 1m dd bs=1m of=%s", srcdev, dev);
 	pm_partusage(my_pm, -1, 1);
+}
 #if 0 // XXX
 static int
 pm_mountall_sort(const void *a, const void *b)
+{
 	return strcmp(mnts[*(const int *)a].on, mnts[*(const int *)b].on);
+}
 #endif
 #if 0	// XXX
 /* Mount all available partitions */
 static int
 pm_mountall(void)
+{
 	int num_devs = 0;
 	int mnts_order[MAX_MNTS];
 	int i, ii, error, ok;
 	char dev[SSTRSIZE]; dev[0] = '\0';
 	struct pm_devs *pm_i;
 	localfs_dev[0] = '\0';
 	if (mnts == NULL)
 		mnts = calloc(MAX_MNTS, sizeof(*mnts));
 	SLIST_FOREACH(pm_i, &pm_head, l) {
 		ok = 0;
 		for (i = 0; i < MAXPARTITIONS; i++) {
 			if (!(pm_i->bsdlabel[i].pi_flags & PIF_MOUNT &&
 					pm_i->bsdlabel[i].mnt_opts != NULL))
 				continue;
 			mnts[num_devs].mnt_opts = pm_i->bsdlabel[i].mnt_opts;
 			if (strlen(pm_i->bsdlabel[i].mounted) > 0) {
 				/* Device is already mounted. So, doing mount_null */
 				strlcpy(mnts[num_devs].dev, pm_i->bsdlabel[i].mounted, MOUNTLEN);
 				mnts[num_devs].mnt_opts = "-t null";
 			} else {
 				pm_getdevstring(dev, SSTRSIZE, pm_i, i);
 				snprintf(mnts[num_devs].dev, STRSIZE, "/dev/%s", dev);
+			}
 			mnts[num_devs].on = pm_i->bsdlabel[i].pi_mount;
 			if (strcmp(pm_i->bsdlabel[i].pi_mount, "/") == 0) {
 				/* Use disk with / as a default if the user has
 				the sets on a local disk */
 				strlcpy(localfs_dev, pm_i->diskdev, SSTRSIZE);
+			}
 			num_devs++;
 			ok = 1;
+		}
 		if (ok)
 			md_pre_mount(NULL, 0);
+	}
 	if (strlen(localfs_dev) < 1) {
 		hit_enter_to_continue(MSG_noroot, NULL);
 		return -1;
+	}
 	for (i = 0; i < num_devs; i++)
 		mnts_order[i] = i;
 	qsort(mnts_order, num_devs, sizeof mnts_order[0], pm_mountall_sort);
 	for (i = 0; i < num_devs; i++) {
 		ii = mnts_order[i];
 		make_target_dir(mnts[ii].on);
 		error = target_mount_do(mnts[ii].mnt_opts, mnts[ii].dev, mnts[ii].on);
 		if (error)
 			return error;
+	}
 	return 0;
+}
 #endif
 /* Mount partition bypassing ordinary order */
 static int
 pm_mount(struct pm_devs *pm_cur, int part_num)
+{
 	int error = 0;
 #if 0 // XXX
 	char buf[MOUNTLEN];
 	if (strlen(pm_cur->bsdlabel[part_num].mounted) > 0)
 		return 0;
 	snprintf(buf, sizeof(buf), "/tmp/%s%c", pm_cur->diskdev,
 	    part_num + 'a');
 	if (! dir_exists_p(buf))
 		run_program(RUN_DISPLAY | RUN_PROGRESS, "/bin/mkdir -p %s", buf);
 	if (pm_cur->bsdlabel[part_num].pi_flags & PIF_MOUNT &&
 		pm_cur->bsdlabel[part_num].mnt_opts != NULL &&
 		strlen(pm_cur->bsdlabel[part_num].mounted) < 1)
 		error += run_program(RUN_DISPLAY | RUN_PROGRESS, "/sbin/mount %s /dev/%s%c %s",
 				pm_cur->bsdlabel[part_num].mnt_opts,
 				pm_cur->diskdev, part_num + 'a', buf);
 	if (error)
 		pm_cur->bsdlabel[part_num].mounted[0] = '\0';
 	else {
 		strlcpy(pm_cur->bsdlabel[part_num].mounted, buf, MOUNTLEN);
 		pm_cur->blocked++;
+	}
 #endif
 	return error;
+}
 void
 pm_umount(struct pm_devs *pm_cur, int part_num)
+{
 	char buf[SSTRSIZE]; buf[0] = '\0';
 	part_id id;
 	if (part_num < 0)
 		return;
 	id = (part_id)part_num;
 	pm_cur->parts->pscheme->get_part_device(pm_cur->parts, id, buf,
 	    sizeof buf, NULL, plain_name, false, true);
 	if (run_program(RUN_DISPLAY | RUN_PROGRESS,
 			"umount -f /dev/%s", buf) == 0) {
 		free(pm_cur->mounted[id]);
 		pm_cur->mounted[id] = NULL;
 		if (pm_cur->blocked > 0)
 			pm_cur->blocked--;
+	}
+}
 int
 pm_unconfigure(struct pm_devs *pm_cur)
+{
 	int error = 0;
 	if (! strncmp(pm_cur->diskdev, "cgd", 3)) {
  		error = run_program(RUN_DISPLAY | RUN_PROGRESS, "cgdconfig -u %s", pm_cur->diskdev);
  		if (! error && pm_cur->refdev != NULL) {
 			((struct cgd_desc*)pm_cur->refdev)->pm->blocked--;
 			((struct cgd_desc*)pm_cur->refdev)->blocked = 0;
+ 		}
  	} else if (! strncmp(pm_cur->diskdev, "vnd", 3)) {
 		error = run_program(RUN_DISPLAY | RUN_PROGRESS, "vndconfig -u %s", pm_cur->diskdev);
  		if (! error && pm_cur->refdev != NULL) {
 			((struct vnd_desc*)pm_cur->refdev)->pm->blocked--;
 			((struct vnd_desc*)pm_cur->refdev)->blocked = 0;
+ 		}
 	} else if (! strncmp(pm_cur->diskdev, "raid", 4)) {
 		error = run_program(RUN_DISPLAY | RUN_PROGRESS, "raidctl -u %s", pm_cur->diskdev);
 		if (! error && pm_cur->refdev != NULL) {
 			((struct raid_desc*)pm_cur->refdev)->blocked = 0;
 #if 0 // XXX
 			for (i = 0; i < MAX_IN_RAID; i++)
 				if (((struct raid_desc*)pm_cur->refdev)->comp[i].parts != NULL)
 					((raids_t*)pm_cur->refdev)->pm[i]->blocked--;
 #endif
+		}
 	} else if (! strncmp(pm_cur->diskdev, "dk", 2)) {
 		if (pm_cur->refdev == NULL)
 			return -2;
 		/* error = */
 		run_program(RUN_DISPLAY | RUN_PROGRESS, "dkctl %s delwedge %s",
 			((struct pm_devs*)pm_cur->refdev)->diskdev, pm_cur->diskdev);
 #if 0 // XXX
 		if (! error) {
 			if (pm_cur->refdev != NULL && ((struct pm_devs*)pm_cur->refdev)->blocked > 0)
 				((struct pm_devs*)pm_cur->refdev)->blocked--;
 			sscanf(pm_cur->diskdev, "dk%d", &num);
 			if (num >= 0 && num < MAX_WEDGES)
 				wedges[num].allocated = 0;
+		}
 #endif
 	} /* XXX: lvm */
 	else
 		error = run_program(RUN_DISPLAY | RUN_PROGRESS, "eject -t disk /dev/%sd",
 			pm_cur->diskdev);
 	if (!error)
 		pm_cur->found = 0;
 	return error;
+}
 /* Last checks before leaving partition manager */
 #if 0
 static int
 pm_lastcheck(void)
+{
 	FILE *file_tmp = fopen(concat_paths(targetroot_mnt, "/etc/fstab"), "r");
 	if (file_tmp == NULL)
 		return 1;
 	fclose(file_tmp);
 	return 0;
+}
 #endif
 /* Are there unsaved changes? */
 static int
 pm_needsave(void)
+{
 	struct pm_devs *pm_i;
 	SLIST_FOREACH(pm_i, &pm_head, l)
 		if (pm_i->unsaved) {
 			/* Oops, we have unsaved changes */
 			pm_changed = 1;
 			msg_display(MSG_saveprompt);
 			return ask_yesno(NULL);
+		}
 	return 0;
+}
 /* Write all changes to disk */
 static int
 pm_commit(menudesc *m, void *arg)
+{
 	int retcode;
 	struct pm_devs *pm_i;
 	struct disk_partitions *secondary;
 	pm_retvalue = -1;
 	SLIST_FOREACH(pm_i, &pm_head, l) {
 		if (! pm_i->unsaved)
 			continue;
 		if (pm_i->parts == NULL) {
 			pm_i->unsaved = false;
 			continue;
+		}
 		if (!pm_i->parts->pscheme->write_to_disk(pm_i->parts)) {
 			if (logfp)
 				fprintf(logfp, "partitining error %s\n",
 				    pm_i->diskdev);
 			return -1;
+		}
 		if (pm_i->parts->pscheme->secondary_scheme != NULL) {
 			secondary = pm_i->parts->pscheme->
 			    secondary_partitions(pm_i->parts, -1, false);
 			if (secondary != NULL) {
 				if (!secondary->pscheme->write_to_disk(
 				    secondary)) {
 					if (logfp)
 						fprintf(logfp,
 						    "partitining error %s\n",
 						    pm_i->diskdev);
 					return -1;
+				}
+			}
+		}
+	}
 	/* Call all functions that may create new devices */
 	if ((retcode = pm_raid_commit()) != 0) {
 		if (logfp)
 			fprintf(logfp, "RAIDframe configuring error #%d\n", retcode);
 		return -1;
+	}
 	if ((retcode = pm_cgd_commit()) != 0) {
 		if (logfp)
 			fprintf(logfp, "CGD configuring error #%d\n", retcode);
 		return -1;
+	}
 	if ((retcode = pm_lvm_commit()) != 0) {
 		if (logfp)
 			fprintf(logfp, "LVM configuring error #%d\n", retcode);
 		return -1;
+	}
 	if ((retcode = pm_vnd_commit()) != 0) {
 		if (logfp)
 			fprintf(logfp, "VND configuring error #%d\n", retcode);
 		return -1;
+	}
 	if (m != NULL && arg != NULL)
 		pm_upddevlist(m, arg);
 	if (logfp)
 		fflush (logfp);
 	pm_retvalue = 0;
 	return 0;
+}
 #if 0 // XXX
 static int
 pm_savebootsector(void)
+{
 	struct pm_devs *pm_i;
 	SLIST_FOREACH(pm_i, &pm_head, l)
 		if (pm_i->bootable) {
 			if (! strncmp("raid", pm_i->diskdev, 4))
 				if (run_program(RUN_DISPLAY | RUN_PROGRESS,
 					"raidctl -v -A root %s", pm_i->diskdev) != 0) {
 					if (logfp)
 						fprintf(logfp, "Error writting RAID bootsector to %s\n",
 							pm_i->diskdev);
 					continue;
+				}
 			if (pm_i->no_part) {
 				if (pm_i->rootpart < 0 ||
 					run_program(RUN_DISPLAY | RUN_PROGRESS,
 					"gpt biosboot -i %d %s",
 					pm_i->rootpart + 1, pm_i->diskdev) != 0) {
 			 		if (logfp)
 						fprintf(logfp, "Error writting GPT bootsector to %s\n",
 							pm_i->diskdev);
 					continue;
+				}
 			} else {
 				pm_select(pm_i);
 			 	if (
 #ifndef NO_DISKLABEL
 				    !check_partitions(pm_i, pm_i->parts) ||
 #endif
 				    md_post_newfs() != 0) {
 		 			if (logfp)
 						fprintf(logfp, "Error writting bootsector to %s\n",
 							pm_i->diskdev);
 					continue;
+				}
+			}
+		}
 	return 0;
+}
 #endif
 /* Function for 'Enter'-menu */
 static int
 pm_submenu(menudesc *m, void *arg)
+{
 	struct pm_devs *pm_cur = NULL;
 	pm_retvalue = m->cursel + 1;
 	struct part_entry *cur_pe = (struct part_entry *)arg + m->cursel;
 	switch (cur_pe->type) {
 		case PM_DISK:
 		case PM_PART:
 		case PM_SPEC:
 			if (cur_pe->dev_ptr != NULL) {
 				pm_cur = cur_pe->dev_ptr;
 				if (pm_cur == NULL)
 					return -1;
 				if (pm_cur->blocked) {
 					clear();
 					refresh();
 					msg_display(MSG_wannaunblock);
 					if (!ask_noyes(NULL))
 						return -2;
 					pm_cur->blocked = 0;
+				}
 				pm_select(pm_cur);
+			}
 		default:
 			break;
+	}
 	switch (cur_pe->type) {
 		case PM_DISK:
 			process_menu(MENU_pmdiskentry, cur_pe);
 			break;
 		case PM_PART:
 			process_menu(MENU_pmpartentry, cur_pe);
 			break;
 		case PM_SPEC:
 			process_menu(MENU_pmpartentry, cur_pe);
 			break;
 		case PM_RAID:
 			pm_edit(PMR_MENU_END, pm_raid_edit_menufmt,
 			    pm_raid_set_value, pm_raid_check, pm_raid_init,
 			    NULL, cur_pe->dev_ptr, 0, &raids_t_info);
 			break;
 		case PM_VND:
 			return pm_edit(PMV_MENU_END, pm_vnd_edit_menufmt,
 			    pm_vnd_set_value, pm_vnd_check, pm_vnd_init,
 			    NULL, cur_pe->dev_ptr, 0, &vnds_t_info);
 		case PM_CGD:
 			pm_cgd_edit_old(cur_pe);
 			break;
 		case PM_LVM:
 			return pm_edit(PML_MENU_END, pm_lvm_edit_menufmt,
 			    pm_lvm_set_value, pm_lvm_check, pm_lvm_init,
 			    NULL, cur_pe->dev_ptr, 0, &lvms_t_info);
 		case PM_LVMLV:
 			return pm_edit(PMLV_MENU_END, pm_lvmlv_edit_menufmt,
 			    pm_lvmlv_set_value, pm_lvmlv_check, pm_lvmlv_init,
 			    NULL, cur_pe->dev_ptr,
 			    cur_pe->dev_ptr_delta, &lv_t_info);
+	}
 	return 0;
+}
 /* Functions that generate menu entries text */
 static void
 pm_menufmt(menudesc *m, int opt, void *arg)
+{
 	const char *dev_status = "";
 	char buf[STRSIZE], dev[STRSIZE];
 	part_id part_num = ((struct part_entry *)arg)[opt].id;
 	struct pm_devs *pm_cur = ((struct part_entry *)arg)[opt].dev_ptr;
 	struct disk_partitions *parts = ((struct part_entry *)arg)[opt].parts;
 	struct disk_part_info info;
 	const char *mount_point, *fstype;
 	switch (((struct part_entry *)arg)[opt].type) {
 		case PM_DISK:
 			if (pm_cur->blocked)
 				dev_status = msg_string(MSG_pmblocked);
 			else if (! pm_cur->unsaved)
 				dev_status = msg_string(MSG_pmunchanged);
 			else
 				dev_status = msg_string(MSG_pmused);
 			wprintw(m->mw, "%-43.42s %25.24s",
 				pm_cur->diskdev_descr,
 				dev_status);
 			break;
 		case PM_PART:
-			if (parts->pscheme->get_part_device != NULL)
+			if (parts->pscheme->get_part_device == NULL ||
-				parts->pscheme->get_part_device(
+			    !parts->pscheme->get_part_device(
-				    parts,  part_num,
+				parts,  part_num,
-				    dev, sizeof dev, NULL, plain_name, false,
+				dev, sizeof dev, NULL, plain_name, false,
-				    true);
+				true))
-			else
+					strcpy(dev, "-");
 				strcpy(dev, "-");
 			parts->pscheme->get_part_info(parts,
 			    part_num, &info);
 			if (pm_cur->mounted != NULL &&
 			    pm_cur->mounted[part_num] != NULL &&
 			    pm_cur->mounted[part_num][0] != 0)
 				mount_point = msg_string(MSG_pmmounted);
 			else
 				mount_point = msg_string(MSG_pmunused);
 			fstype = getfslabelname(info.fs_type,
 			    info.fs_sub_type);
 			if (info.last_mounted != NULL) {
 				snprintf(buf, STRSIZE, "%s (%s) %s",
 				    info.last_mounted, fstype,
 				     mount_point);
 				pm_fmt_disk_line(m->mw, dev, buf,
 				    info.size, NULL);
 			} else {
 				if (fstype != NULL) {
 					strlcat(dev, " (", sizeof(dev));
 					strlcat(dev, fstype, sizeof(dev));
 					strlcat(dev, ")", sizeof(dev));
+				}
 				pm_fmt_disk_line(m->mw, dev, NULL,
 				    info.size, NULL);
+			}
 			break;
 		case PM_SPEC:
 			/* XXX ? */
 			pm_fmt_disk_line(m->mw, pm_cur->diskdev_descr, NULL,
 			    pm_cur->dlsize, NULL);
 			break;
 		case PM_RAID:
 			pm_raid_menufmt(m, opt, arg);
 			break;
 		case PM_VND:
 			pm_vnd_menufmt(m, opt, arg);
 			break;
 		case PM_CGD:
 			pm_cgd_menufmt(m, opt, arg);
 			break;
 		case PM_LVM:
 			pm_lvm_menufmt(m, opt, arg);
 			break;
 		case PM_LVMLV:
 			pm_lvmlv_menufmt(m, opt, arg);
 			break;
+	}
+}
 /* Submenu for RAID/LVM/CGD/VND */
 static void
 pm_upddevlist_adv(menudesc *m, void *arg, int *i,
 	pm_upddevlist_adv_t *d)
+{
 	int ii;
 	if (d->create_msg != NULL) {
 		/* We want to have menu entry that creates a new device */
 		((struct part_entry *)arg)[*i].type = d->pe_type;
 		((struct part_entry *)arg)[*i].dev_ptr = NULL;
 		((struct part_entry *)arg)[*i].dev_ptr_delta = d->s->parent_size * d->sub_num;
 		m->opts[(*i)++] = (struct menu_ent) {
 			.opt_name = d->create_msg,
 			.opt_action = pm_submenu,
 		};
+	}
 	for (ii = 0; ii < d->s->max; ii++) {
 		if (d->s->entry_enabled == NULL ||
 			d->s->entry_blocked == NULL ||
 			*(int*)((char*)d->s->entry_enabled + d->s->entry_size * ii +
 				d->s->parent_size * d->sub_num) == 0 ||
 			*(int*)((char*)d->s->entry_blocked + d->s->entry_size * ii +
 				d->s->parent_size * d->sub_num) != 0)
 			continue;
 		/* We have a entry for displaying */
 		pm_changed = 1;
 		m->opts[*i] = (struct menu_ent) {
 			.opt_name = NULL,
 			.opt_action = pm_submenu,
 		};
 		((struct part_entry *)arg)[*i].type = d->pe_type;
 		((struct part_entry *)arg)[*i].dev_ptr = (char*)d->s->entry_first +
 			d->s->entry_size * ii + d->s->parent_size * d->sub_num;
 		(*i)++;
 		/* We should show submenu for current entry */
 		if (d->sub != NULL) {
 			d->sub->sub_num = ii;
 			pm_upddevlist_adv(m, arg, i, d->sub);
+		}
+	}
+}
 /* Update partman main menu with devices list */
 static int
 pm_upddevlist(menudesc *m, void *arg)
+{
 	int i = 0;
 	size_t ii;
 	struct pm_devs *pm_i;
 	struct disk_partitions *secondary;
 	const struct disk_partitioning_scheme *ps;
 	struct disk_part_info info;
 	if (arg != NULL)
 		pm_retvalue = m->cursel + 1;
 	pm_changed = 0;
 	/* Mark all devices as not found */
 	SLIST_FOREACH(pm_i, &pm_head, l) {
 		if (pm_i->parts != NULL && !pm_i->unsaved) {
 			pm_i->parts->pscheme->free(pm_i->parts);
 			pm_i->parts = NULL;
+		}
 		if (pm_i->found > 0)
 			pm_i->found = 0;
+	}
 	/* Detect all present devices */
 	(void)find_disks("partman", false);
 	if (have_lvm)
 		pm_lvm_find();
 	pm_clean();
 	if (m == NULL || arg == NULL)
 		return -1;
 	SLIST_FOREACH(pm_i, &pm_head, l) {
 		memset(&m->opts[i], 0, sizeof m->opts[i]);
 		m->opts[i].opt_action = pm_submenu;
 		((struct part_entry *)arg)[i].dev_ptr = pm_i;
 		((struct part_entry *)arg)[i].id = NO_PART;
 		if (pm_i->no_part)
 			((struct part_entry *)arg)[i].type = PM_SPEC;
 		else {
 			ps = pm_i->parts != NULL ? pm_i->parts->pscheme : NULL;
 			secondary = NULL;
 			((struct part_entry *)arg)[i].type = PM_DISK;
 			for (ii = 0; pm_i->parts != NULL &&
 			    ii < pm_i->parts->num_part; ii++) {
 				if (!ps->get_part_info(
 				    pm_i->parts, ii, &info))
 					continue;
 				if (info.flags & PTI_SEC_CONTAINER) {
 					if (secondary == NULL &&
 					    ps->secondary_scheme != NULL)
 						secondary = ps->
 						    secondary_partitions(
 						    pm_i->parts,
 						    info.start, false);
 					continue;
+				}
 				if (info.flags & (PTI_WHOLE_DISK|
 				    PTI_PSCHEME_INTERNAL|PTI_RAW_PART))
 					continue;
 				if (info.fs_type == FS_UNUSED)
 					continue;
 				if (i >= MAX_ENTRIES)
 					break;
 				i++;
 				memset(&m->opts[i], 0, sizeof m->opts[i]);
 				m->opts[i].opt_action = pm_submenu;
 				((struct part_entry *)arg)[i].parts =
 				    pm_i->parts;
 				((struct part_entry *)arg)[i].dev_ptr = pm_i;
 				((struct part_entry *)arg)[i].id = ii;
 				((struct part_entry *)arg)[i].type = PM_PART;
+			}
 			for (ii = 0; secondary != NULL &&
 			    ii < secondary->num_part; ii++) {
 				if (!secondary->pscheme->get_part_info(
 				    secondary, ii, &info))
 					continue;
 				if (info.flags & (PTI_WHOLE_DISK|
 				    PTI_PSCHEME_INTERNAL|PTI_RAW_PART))
 					continue;
 				if (info.fs_type == FS_UNUSED)
 					continue;
 				if (i >= MAX_ENTRIES)
 					break;
 				i++;
 				memset(&m->opts[i], 0, sizeof m->opts[i]);
 				m->opts[i].opt_action = pm_submenu;
 				((struct part_entry *)arg)[i].parts = secondary;
 				((struct part_entry *)arg)[i].dev_ptr = pm_i;
 				((struct part_entry *)arg)[i].id = ii;
 				((struct part_entry *)arg)[i].type = PM_PART;
+			}
+		}
 		i++;
+	}
 	for (ii = 0; ii <= (size_t)i; ii++) {
 		m->opts[ii].opt_flags = OPT_EXIT;
+	}
 	if (have_cgd) {
 		pm_upddevlist_adv(m, arg, &i,
 		    &(pm_upddevlist_adv_t) {MSG_create_cgd, PM_CGD,
 		    &cgds_t_info, 0, NULL});
+	}
 	pm_upddevlist_adv(m, arg, &i,
 	    &(pm_upddevlist_adv_t) {MSG_create_vnd, PM_VND,
 	    &vnds_t_info, 0, NULL});
 	if (have_lvm) {
 		pm_upddevlist_adv(m, arg, &i,
 		    &(pm_upddevlist_adv_t) {MSG_create_vg, PM_LVM,
 		    &lvms_t_info, 0,
 		    &(pm_upddevlist_adv_t) {MSG_create_lv, PM_LVMLV,
 		    &lv_t_info, 0,
 		    NULL}});
+	}
 	if (have_raid) {
 		pm_upddevlist_adv(m, arg, &i,
 		    &(pm_upddevlist_adv_t) {MSG_create_raid, PM_RAID, &raids_t_info, 0, NULL});
+	}
 	m->opts[i++] = (struct menu_ent) {
 		.opt_name = MSG_updpmlist,
 		.opt_action = pm_upddevlist,
 	};
 	m->opts[i  ] = (struct menu_ent) {
 		.opt_name = MSG_savepm,
 		.opt_action = pm_commit,
 	};
 	if (pm_retvalue >= 0)
 		m->cursel = pm_retvalue - 1;
 	return i;
+}
 static void
 pm_menuin(menudesc *m, void *arg)
+{
 	if (pm_cursel > m->numopts)
 		m->cursel = m->numopts;
 	else if (pm_cursel < 0)
 		m->cursel = 0;
 	else
 		m->cursel = pm_cursel;
+}
 static void
 pm_menuout(menudesc *m, void *arg)
+{
 	pm_cursel = m->cursel;
+}
 /* Main partman function */
 int
 partman(void)
+{
 	int menu_no, menu_num_entries;
 	static int firstrun = 1;
 	menu_ent menu_entries[MAX_ENTRIES+6];
 	struct part_entry args[MAX_ENTRIES];
 	if (firstrun) {
 		check_available_binaries();
 		if (!have_raid)
 			remove_raid_options();
 		else if (!(raids = calloc(MAX_RAID, sizeof(*raids))))
 			have_raid = 0;
 #define remove_vnd_options() (void)0
 		if (!have_vnd)
 			remove_vnd_options();
 		else if (!(vnds = calloc(MAX_VND, sizeof(*vnds))))
 			have_vnd = 0;
 		if (!have_cgd)
 			remove_cgd_options();
 		else if (!(cgds = calloc(MAX_CGD, sizeof(*cgds))))
 			have_cgd = 0;
 		if (!have_lvm)
 			remove_lvm_options();
 		else if (!(lvms = calloc(MAX_LVM_VG, sizeof(*lvms))))
 			have_lvm = 0;
 		raids_t_info = (structinfo_t) {
 			.max = MAX_RAID,
 			.entry_size = sizeof raids[0],
 			.entry_first = &raids[0],
 			.entry_enabled = &(raids[0].enabled),
 			.entry_blocked = &(raids[0].blocked),
 			.entry_node = &(raids[0].node),
 		};
 		vnds_t_info = (structinfo_t) {
 			.max = MAX_VND,
 			.entry_size = sizeof vnds[0],
 			.entry_first = &vnds[0],
 			.entry_enabled = &(vnds[0].enabled),
 			.entry_blocked = &(vnds[0].blocked),
 			.entry_node = &(vnds[0].node),
 		};
 		cgds_t_info = (structinfo_t) {
 			.max = MAX_CGD,
 			.entry_size = sizeof cgds[0],
 			.entry_first = &cgds[0],
 			.entry_enabled = &(cgds[0].enabled),
 			.entry_blocked = &(cgds[0].blocked),
 			.entry_node = &(cgds[0].node),
 		};
 		lvms_t_info = (structinfo_t) {
 			.max = MAX_LVM_VG,
 			.entry_size = sizeof lvms[0],
 			.entry_first = &lvms[0],
 			.entry_enabled = &(lvms[0].enabled),
 			.entry_blocked = &(lvms[0].blocked),
 			.entry_node = NULL,
 		};
 		lv_t_info = (structinfo_t) {
 			.max = MAX_LVM_LV,
 			.entry_size = sizeof lvms[0].lv[0],
 			.entry_first = &lvms[0].lv[0],
 			.entry_enabled = &(lvms[0].lv[0].size),
 			.entry_blocked = &(lvms[0].lv[0].blocked),
 			.parent_size = sizeof lvms[0],
 		};
 		pm_cursel = 0;
 		pm_changed = 0;
 		firstrun = 0;
+	}
 	do {
 		menu_num_entries = pm_upddevlist(&(menudesc){.opts = menu_entries}, args);
 		menu_no = new_menu(MSG_partman_header,
 			menu_entries, menu_num_entries+1, 1, 1, 0, 75, /* Fixed width */
 			MC_ALWAYS_SCROLL | MC_NOBOX | MC_NOCLEAR,
 			pm_menuin, pm_menufmt, pm_menuout, NULL, MSG_finishpm);
 		if (menu_no == -1)
 			pm_retvalue = -1;
 		else {
 			pm_retvalue = 0;
 			clear();
 			refresh();
 			process_menu(menu_no, &args);
 			free_menu(menu_no);
+		}
 		if (pm_retvalue == 0 && pm->parts != NULL)
 			if (pm_needsave())
 				pm_commit(NULL, NULL);
 	} while (pm_retvalue > 0);
 	/* retvalue <0 - error, retvalue ==0 - user quits, retvalue >0 - all ok */
 	return (pm_retvalue >= 0)?0:-1;
+}
 void
 update_wedges(const char *disk)
+{
 	check_available_binaries();
 	if (!have_dk)
 		return;
 	run_program(RUN_SILENT | RUN_ERROR_OK,
 	    "dkctl %s makewedges", disk);
+}
 bool
 pm_force_parts(struct pm_devs *my_pm)
+{
 	if (my_pm == NULL)
 		return false;
 	if (my_pm->parts != NULL)
 		return true;
 	const struct disk_partitioning_scheme *ps =
 	    select_part_scheme(my_pm, NULL, false, NULL);
 	if (ps == NULL)
 		return false;
 	struct disk_partitions *parts =
 	   (*ps->create_new_for_disk)(my_pm->diskdev, 0,
 	   my_pm->dlsize, false, NULL);
 	if (parts == NULL)
 		return false;
 	my_pm->parts = parts;
 	if (pm->dlsize > ps->size_limit)
 		pm->dlsize = ps->size_limit;
 	return true;
+}
 void
 pm_edit_partitions(struct part_entry *pe)
+{
 	struct pm_devs *my_pm = pm_from_pe(pe);
 	struct partition_usage_set pset = { 0 };
 	struct disk_partitions *parts, *np;
 	if (!my_pm)
 		return;
 	if (!pm_force_parts(my_pm))
 		return;
 	parts = my_pm->parts;
 	clear();
 	refresh();
 	if (my_pm->parts->pscheme->secondary_scheme != NULL) {
 		if (!edit_outer_parts(my_pm->parts))
 			goto done;
 		np = get_inner_parts(parts);
 		if (np != NULL)
 			parts = np;
+	}
 	if (parts != NULL) {
 		usage_set_from_parts(&pset, parts);
 		edit_and_check_label(my_pm, &pset, false);
 		free_usage_set(&pset);
+	}
 done:
 	pm_partusage(my_pm, -1, -1);
 	my_pm->unsaved = true;
 	pm_retvalue = 1;
+}
 part_id
 pm_whole_disk(struct part_entry *pe, int t)
+{
 	struct pm_devs *my_pm = pm_from_pe(pe);
 	struct disk_partitions *parts, *outer;
 	struct disk_part_info info, oinfo;
 	struct disk_part_free_space space;
 	daddr_t align;
 	int fst;
 	struct partition_usage_set pset = { 0 };
 	part_id new_part, id;
 	size_t i, cnt;
 	if (!my_pm)
 		return NO_PART;
 	if (!pm_force_parts(my_pm))
 		return NO_PART;
 	parts = my_pm->parts;
 	parts->pscheme->delete_all_partitions(parts);
 	if (parts->pscheme->secondary_scheme != NULL) {
 		outer = parts;
 		parts = parts->pscheme->secondary_partitions(outer,
 , true);
 		if (parts == NULL) {
 			parts = outer;
 		} else {
 			if (outer->pscheme->write_to_disk(outer))
 				my_pm->parts = parts;
+		}
+	}
 	align = parts->pscheme->get_part_alignment(parts);
 	memset(&info, 0, sizeof info);
 	switch (t) {
 	case SY_NEWRAID:
 		fst = FS_RAID;
 		break;
 	case SY_NEWLVM:
 		fst = FS_BSDFFS;
 		break;
 	case SY_NEWCGD:
 		fst = FS_CGD;
 		break;
 	default:
 		assert(false);
 		return NO_PART;
+	}
 	info.nat_type = parts->pscheme->get_fs_part_type(PT_root, fst, 0);
 	if (info.nat_type != NULL && parts->pscheme->get_default_fstype != NULL)
 		parts->pscheme->get_default_fstype(info.nat_type,
 		    &info.fs_type, &info.fs_sub_type);
 	if (parts->pscheme->get_free_spaces(parts, &space, 1,
 *align, align, -1, -1) != 1)
 		return NO_PART;
 	info.start = space.start;
 	info.size = space.size;
 	new_part = parts->pscheme->add_partition(parts, &info, NULL);
 	if (new_part == NO_PART)
 		return NO_PART;
 	parts->pscheme->get_part_info(parts, new_part, &oinfo);
 	clear();
 	refresh();
 	usage_set_from_parts(&pset, parts);
 	edit_and_check_label(my_pm, &pset, false);
 	free_usage_set(&pset);
 	/*
 	 * Try to match our new partition after user edit
 	 */
 	new_part = NO_PART;
 	for (cnt = i = 0; i < parts->num_part; i++) {
 		if (!parts->pscheme->get_part_info(parts,i, &info))
 			continue;
 		if (info.flags & (PTI_SEC_CONTAINER|PTI_WHOLE_DISK|
 		    PTI_PSCHEME_INTERNAL|PTI_RAW_PART))
 			continue;
 		if (info.nat_type != oinfo.nat_type)
 			continue;
 		if (new_part == NO_PART)
 			new_part = i;
 		cnt++;
+	}
 	if (cnt > 1) {
 		/* multiple matches, retry matching with start */
 		id = NO_PART;
 		for (cnt = i = 0; i < parts->num_part; i++) {
 			if (!parts->pscheme->get_part_info(parts, i, &info))
 				continue;
 			if (info.flags & (PTI_SEC_CONTAINER|PTI_WHOLE_DISK|
 			    PTI_PSCHEME_INTERNAL|PTI_RAW_PART))
 				continue;
 			if (info.nat_type != oinfo.nat_type)
 				continue;
 			if (info.start != oinfo.start)
 				continue;
 			if (id == NO_PART)
 				id = i;
 			cnt++;
+		}
 		if (id != NO_PART)
 			new_part = id;
+	}
 	clear();
 	refresh();
 	pm_partusage(my_pm, -1, -1);
 	my_pm->unsaved = true;
 	pm_retvalue = 1;
 	return new_part;
+}
 struct pm_devs *
 pm_from_pe(struct part_entry *pe)
+{
 	switch (pe->type) {
 	case PM_DISK:
 		return pe->dev_ptr;
 	default:
 		assert(false);
+	}
 	return NULL;
+}