/usr/src/sbin/disklabel/editor.c

Bug Summary

File:	src/sbin/disklabel/editor.c
Warning:	line 2503, column 37 Division by zero
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name editor.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sbin/disklabel/obj -resource-dir /usr/local/lib/clang/13.0.0 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/disklabel/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/sbin/disklabel/editor.c
1/*	$OpenBSD: editor.c,v 1.370 2021/12/19 19:26:18 krw Exp $	*/

3/*
* Copyright (c) 1997-2000 Todd C. Miller <millert@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

19#include <sys/param.h>	/* MAXBSIZE DEV_BSIZE */
20#include <sys/types.h>
21#include <sys/signal.h>
22#include <sys/stat.h>
23#include <sys/ioctl.h>
24#include <sys/dkio.h>
25#include <sys/sysctl.h>
26#define	DKTYPENAMES
27#include <sys/disklabel.h>

29#include <ufs/ffs/fs.h>

31#include <ctype.h>
32#include <err.h>
33#include <errno(*__errno()).h>
34#include <string.h>
35#include <libgen.h>
36#include <stdint.h>
37#include <stdio.h>
38#include <stdlib.h>
39#include <unistd.h>
40#include <limits.h>

42#include "extern.h"
43#include "pathnames.h"

45#define MAXIMUM(a, b)(((a) > (b)) ? (a) : (b))	(((a) > (b)) ? (a) : (b))

47/* flags for getuint64() */
48#define	DO_CONVERSIONS0x00000001	0x00000001
49#define	DO_ROUNDING0x00000002	0x00000002

51/* flags for alignpartition() */
52#define	ROUND_OFFSET_UP0x00000001		0x00000001
53#define	ROUND_OFFSET_DOWN0x00000002	0x00000002
54#define	ROUND_SIZE_UP0x00000004		0x00000004
55#define	ROUND_SIZE_DOWN0x00000008		0x00000008
56#define	ROUND_SIZE_OVERLAP0x00000010	0x00000010

58/* Special return values for getnumber and getuint64() */
59#define	CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1)	(ULLONG_MAX(9223372036854775807LL*2ULL+1ULL) - 1)
60#define	CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL))	(ULLONG_MAX(9223372036854775807LL*2ULL+1ULL))

62/* structure to describe a portion of a disk */
63struct diskchunk {
u_int64_t start;
u_int64_t stop;
66};

68/* used when sorting mountpoints in mpsave() */
69struct mountinfo {
char *mountpoint;
int partno;
72};

74/* used when allocating all space according to recommendations */

76struct space_allocation {
u_int64_t	minsz;	/* starts as blocks, xlated to sectors. */
u_int64_t	maxsz;	/* starts as blocks, xlated to sectors. */
int		rate;	/* % of extra space to use */
char	       *mp;
81};

83/*
* NOTE! Changing partition sizes in the space_allocation tables
*       requires corresponding updates to the *.ok files in
*	 /usr/src/regress/sbin/disklabel.
*/

89/* entries for swap and var are changed by editor_allocspace() */
90struct space_allocation alloc_big[] = {
{  MEG(150)((150) * 1024LL * (1024 / (1 << 9))),         GIG(1)(((1) * 1024LL * (1024 / (1 << 9))) * 1024LL),   5, "/"		},
{   MEG(80)((80) * 1024LL * (1024 / (1 << 9))),       MEG(256)((256) * 1024LL * (1024 / (1 << 9))),  10, "swap"	},
{  MEG(120)((120) * 1024LL * (1024 / (1 << 9))),         GIG(4)(((4) * 1024LL * (1024 / (1 << 9))) * 1024LL),   8, "/tmp"	},
{   MEG(80)((80) * 1024LL * (1024 / (1 << 9))),         GIG(4)(((4) * 1024LL * (1024 / (1 << 9))) * 1024LL),  13, "/var"	},
{ MEG(1500)((1500) * 1024LL * (1024 / (1 << 9))),         GIG(6)(((6) * 1024LL * (1024 / (1 << 9))) * 1024LL),  10, "/usr"	},
{  MEG(384)((384) * 1024LL * (1024 / (1 << 9))),         GIG(1)(((1) * 1024LL * (1024 / (1 << 9))) * 1024LL),   3, "/usr/X11R6"	},
{    GIG(1)(((1) * 1024LL * (1024 / (1 << 9))) * 1024LL),        GIG(20)(((20) * 1024LL * (1024 / (1 << 9))) * 1024LL),  15, "/usr/local"	},
{ MEG(1500)((1500) * 1024LL * (1024 / (1 << 9))),         GIG(3)(((3) * 1024LL * (1024 / (1 << 9))) * 1024LL),   2, "/usr/src"	},
{    GIG(5)(((5) * 1024LL * (1024 / (1 << 9))) * 1024LL),         GIG(6)(((6) * 1024LL * (1024 / (1 << 9))) * 1024LL),   4, "/usr/obj"	},
{    GIG(1)(((1) * 1024LL * (1024 / (1 << 9))) * 1024LL),       GIG(300)(((300) * 1024LL * (1024 / (1 << 9))) * 1024LL),  30, "/home"	}
/* Anything beyond this leave for the user to decide */
102};

104struct space_allocation alloc_medium[] = {
{  MEG(800)((800) * 1024LL * (1024 / (1 << 9))),         GIG(2)(((2) * 1024LL * (1024 / (1 << 9))) * 1024LL),   5, "/"		},
{   MEG(80)((80) * 1024LL * (1024 / (1 << 9))),       MEG(256)((256) * 1024LL * (1024 / (1 << 9))),  10, "swap"	},
{ MEG(1300)((1300) * 1024LL * (1024 / (1 << 9))),         GIG(3)(((3) * 1024LL * (1024 / (1 << 9))) * 1024LL),  78, "/usr"	},
{  MEG(256)((256) * 1024LL * (1024 / (1 << 9))),         GIG(2)(((2) * 1024LL * (1024 / (1 << 9))) * 1024LL),   7, "/home"	}
109};

111struct space_allocation alloc_small[] = {
{  MEG(700)((700) * 1024LL * (1024 / (1 << 9))),         GIG(4)(((4) * 1024LL * (1024 / (1 << 9))) * 1024LL),  95, "/"		},
{    MEG(1)((1) * 1024LL * (1024 / (1 << 9))),       MEG(256)((256) * 1024LL * (1024 / (1 << 9))),   5, "swap"	}
114};

116struct space_allocation alloc_stupid[] = {
{    MEG(1)((1) * 1024LL * (1024 / (1 << 9))),      MEG(2048)((2048) * 1024LL * (1024 / (1 << 9))), 100, "/"		}
118};

120#ifndef nitems
121#define nitems(_a)(sizeof((_a)) / sizeof((_a)[0]))	(sizeof((_a)) / sizeof((_a)[0]))
122#endif

124struct alloc_table {
struct space_allocation *table;
int sz;
127};

129struct alloc_table alloc_table_default[] = {
{ alloc_big,	nitems(alloc_big)(sizeof((alloc_big)) / sizeof((alloc_big)[0])) },
{ alloc_medium,	nitems(alloc_medium)(sizeof((alloc_medium)) / sizeof((alloc_medium)[0])) },
{ alloc_small,	nitems(alloc_small)(sizeof((alloc_small)) / sizeof((alloc_small)[0])) },
{ alloc_stupid,	nitems(alloc_stupid)(sizeof((alloc_stupid)) / sizeof((alloc_stupid)[0])) }
134};
135struct alloc_table *alloc_table = alloc_table_default;
136int alloc_table_nitems = 4;

138void	edit_parms(struct disklabel *);
139void	editor_resize(struct disklabel *, char *);
140void	editor_add(struct disklabel *, char *);
141void	editor_change(struct disklabel *, char *);
142u_int64_t editor_countfree(struct disklabel *);
143void	editor_delete(struct disklabel *, char *);
144void	editor_help(void);
145void	editor_modify(struct disklabel *, char *);
146void	editor_name(struct disklabel *, char *);
147char	*getstring(const char *, const char *, const char *);
148u_int64_t getuint64(struct disklabel *, char *, char *, u_int64_t,
  u_int64_t, int *);
150u_int64_t getnumber(char *, char *, u_int32_t, u_int32_t);
151int	has_overlap(struct disklabel *);
152int	partition_cmp(const void *, const void *);
153struct partition **sort_partitions(struct disklabel *);
154void	getdisktype(struct disklabel *, char *, char *);
155void	find_bounds(struct disklabel *);
156void	set_bounds(struct disklabel *);
157void	set_duid(struct disklabel *);
158struct diskchunk *free_chunks(struct disklabel *);
159int	micmp(const void *, const void *);
160int	mpequal(char **, char **);
161int	get_bsize(struct disklabel *, int);
162int	get_fsize(struct disklabel *, int);
163int	get_cpg(struct disklabel *, int);
164int	get_fstype(struct disklabel *, int);
165int	get_mp(struct disklabel *, int);
166int	get_offset(struct disklabel *, int);
167int	get_size(struct disklabel *, int);
168void	get_geometry(int, struct disklabel **);
169void	set_geometry(struct disklabel *, struct disklabel *, struct disklabel *,
  char *);
171void	zero_partitions(struct disklabel *);
172u_int64_t max_partition_size(struct disklabel *, int);
173void	display_edit(struct disklabel *, char);
174void	psize(u_int64_t sz, char unit, struct disklabel *lp);
175char	*get_token(char **);
176int	apply_unit(double, u_char, u_int64_t *);
177int	parse_sizespec(const char *, double *, char **);
178int	parse_sizerange(char *, u_int64_t *, u_int64_t *);
179int	parse_pct(char *, int *);
180int	alignpartition(struct disklabel *, int, u_int64_t, u_int64_t, int);

182static u_int64_t starting_sector;
183static u_int64_t ending_sector;
184static int expert;
185static int overlap;

187/*
* Simple partition editor.
*/
190int
191editor(int f)
192{
struct disklabel origlabel, lastlabel, tmplabel, newlab = lab;
struct disklabel *disk_geop = NULL((void *)0);
struct partition *pp;
FILE *fp;
char buf[BUFSIZ1024], *cmd, *arg;
char **omountpoints = NULL((void *)0);
char **origmountpoints = NULL((void *)0), **tmpmountpoints = NULL((void *)0);
int i, error = 0;

/* Alloc and init mount point info */
if (!(omountpoints = calloc(MAXPARTITIONS16, sizeof(char *))) ||
1
Assuming 'omountpoints' is non-null→
4
←
Taking false branch→
   !(origmountpoints = calloc(MAXPARTITIONS16, sizeof(char *))) ||
2
←
Assuming 'origmountpoints' is non-null→
   !(tmpmountpoints = calloc(MAXPARTITIONS16, sizeof(char *))))
3
←
Assuming 'tmpmountpoints' is non-null→
errx(4, "out of memory");

/* Don't allow disk type of "unknown" */
getdisktype(&newlab, "You need to specify a type for this disk.",
   specname);

/* Get the on-disk geometries if possible */
get_geometry(f, &disk_geop);

/* How big is the OpenBSD portion of the disk?  */
find_bounds(&newlab);

/* Make sure there is no partition overlap. */
if (has_overlap(&newlab))
5
←
Taking false branch→
errx(1, "can't run when there is partition overlap.");

/* If we don't have a 'c' partition, create one. */
pp = &newlab.d_partitions[RAW_PART2];
if (newlab.d_npartitions5.1
Field 'd_npartitions' is < 3
 < 3 || DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0) {
puts("No 'c' partition found, adding one that spans the disk.");
if (newlab.d_npartitions5.2
Field 'd_npartitions' is < 3
 < 3)
6
←
Taking true branch→
	newlab.d_npartitions = 3;
DL_SETPOFFSET(pp, 0)do { u_int64_t __x = (0); (pp)->p_offseth = __x >> 32
; (pp)->p_offset = __x; } while (0);
7
←
Loop condition is false.  Exiting loop→
DL_SETPSIZE(pp, DL_GETDSIZE(&newlab))do { u_int64_t __x = ((((u_int64_t)(&newlab)->d_secperunith
 << 32) + (&newlab)->d_secperunit)); (pp)->p_sizeh
 = __x >> 32; (pp)->p_size = __x; } while (0);
8
←
Loop condition is false.  Exiting loop→
pp->p_fstype = FS_UNUSED0;
pp->p_fragblock = pp->p_cpg = 0;
}

234#ifdef SUN_CYLCHECK
if ((newlab.d_flags & D_VENDOR0x08) && !quiet) {
puts("This platform requires that partition offsets/sizes "
    "be on cylinder boundaries.\n"
    "Partition offsets/sizes will be rounded to the "
    "nearest cylinder automatically.");
}
241#endif

/* Set d_bbsize and d_sbsize as necessary */
if (newlab.d_bbsize == 0)
9
←
Assuming field 'd_bbsize' is not equal to 0→
10
←
Taking false branch→
newlab.d_bbsize = BBSIZE8192;
if (newlab.d_sbsize == 0)
11
←
Assuming field 'd_sbsize' is not equal to 0→
12
←
Taking false branch→
newlab.d_sbsize = SBSIZE8192;

/* Save the (U|u)ndo labels and mountpoints. */
mpcopy(origmountpoints, mountpoints);
origlabel = newlab;
lastlabel = newlab;

puts("Label editor (enter '?' for help at any prompt)");
for (;;) {
13
←
Loop condition is true.  Entering loop body→
fprintf(stdout(&__sF[1]), "%s%s%c ", dkname,
    (memcmp(&lab, &newlab, sizeof(newlab)) == 0) ? "" : "*",
14
←
Assuming the condition is false→
15
←
'?' condition is false→
    (expert == 0) ? '>' : '#');
16
←
Assuming 'expert' is not equal to 0→
17
←
'?' condition is false→
if (fgets(buf, sizeof(buf), stdin(&__sF[0])) == NULL((void *)0)) {
18
←
Assuming the condition is false→
19
←
Taking false branch→
	putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
	buf[0] = 'q';
	buf[1] = '\0';
}
if ((cmd = strtok(buf, " \t\r\n")) == NULL((void *)0))
20
←
Assuming the condition is false→
21
←
Taking false branch→
	continue;
arg = strtok(NULL((void *)0), " \t\r\n");

if ((*cmd != 'u') && (*cmd != 'U')) {
22
←
Assuming the condition is true→
23
←
Assuming the condition is true→
24
←
Taking true branch→
	/*
	 * Save undo info in case the command tries to make
	 * changes but decides not to.
	 */
	tmplabel = lastlabel;
	lastlabel = newlab;
	mpcopy(tmpmountpoints, omountpoints);
	mpcopy(omountpoints, mountpoints);
}

switch (*cmd) {
25
←
Control jumps to 'case 82:'  at line 418→
case '?':
case 'h':
	editor_help();
	break;

case 'A':
	if (ioctl(f, DIOCGPDINFO((unsigned long)0x40000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((114))), &newlab) == -1) {
		warn("DIOCGPDINFO");
		newlab = lastlabel;
	} else {
		int oquiet = quiet, oexpert = expert;
		aflag = 1;
		quiet = expert = 0;
		editor_allocspace(&newlab);
		quiet = oquiet;
		expert = oexpert;
	}
	break;
case 'a':
	editor_add(&newlab, arg);
	break;

case 'b':
	set_bounds(&newlab);
	break;

case 'c':
	editor_change(&newlab, arg);
	break;

case 'D':
	if (ioctl(f, DIOCGPDINFO((unsigned long)0x40000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((114))), &newlab) == -1)
		warn("DIOCGPDINFO");
	else {
		dflag = 1;
		for (i = 0; i < MAXPARTITIONS16; i++) {
			free(mountpoints[i]);
			mountpoints[i] = NULL((void *)0);
		}
	}
	break;

case 'd':
	editor_delete(&newlab, arg);
	break;

case 'e':
	edit_parms(&newlab);
	break;

case 'g':
	set_geometry(&newlab, disk_geop, &lab, arg);
	break;

case 'i':
	set_duid(&newlab);
	break;

case 'm':
	editor_modify(&newlab, arg);
	break;

case 'n':
	if (!fstabfile) {
		fputs("This option is not valid when run "
		    "without the -F or -f flags.\n", stderr(&__sF[2]));
		break;
	}
	editor_name(&newlab, arg);
	break;

case 'p':
	display_edit(&newlab, arg ? *arg : 0);
	break;

case 'l':
	display(stdout(&__sF[1]), &newlab, arg ? *arg : 0, 0);
	break;

case 'M': {
	sig_t opipe = signal(SIGPIPE13, SIG_IGN(void (*)(int))1);
	char *pager, *comm = NULL((void *)0);
	extern const u_char manpage[];
	extern const int manpage_sz;

	if ((pager = getenv("PAGER")) == NULL((void *)0) || *pager == '\0')
		pager = _PATH_LESS"/usr/bin/less";

	if (asprintf(&comm, "gunzip -qc|%s", pager) != -1 &&
	    (fp = popen(comm, "w")) != NULL((void *)0)) {
		(void) fwrite(manpage, manpage_sz, 1, fp);
		pclose(fp);
	} else
		warn("unable to execute %s", pager);

	free(comm);
	(void)signal(SIGPIPE13, opipe);
	break;
}

case 'q':
	if (donothing) {
		puts("In no change mode, not writing label.");
		goto done;
	}

	/*
	 * If we haven't changed the original label, and it
	 * wasn't a default label or an auto-allocated label,
	 * there is no need to do anything before exiting. Note
	 * that 'w' will reset dflag and aflag to allow 'q' to
	 * exit without further questions.
	 */
	if (!dflag && !aflag &&
	    memcmp(&lab, &newlab, sizeof(newlab)) == 0) {
		puts("No label changes.");
		/* Save mountpoint info. */
		mpsave(&newlab);
		goto done;
	}
	do {
		arg = getstring("Write new label?",
		    "Write the modified label to disk?",
		    "y");
	} while (arg && tolower((unsigned char)*arg) != 'y' &&
	    tolower((unsigned char)*arg) != 'n');
	if (arg && tolower((unsigned char)*arg) == 'y') {
		if (writelabel(f, &newlab) == 0) {
			newlab = lab; /* lab now has UID info */
			goto done;
		}
		warnx("unable to write label");
	}
	error = 1;
	goto done;
	/* NOTREACHED */
	break;

case 'R':
	if (aflag && !overlap)
26
←
Assuming 'aflag' is not equal to 0→
27
←
Assuming 'overlap' is 0→
28
←
Taking true branch→
		editor_resize(&newlab, arg);
29
←
Calling 'editor_resize'→
	else
		fputs("Resize only implemented for auto "
		    "allocated labels\n", stderr(&__sF[2]));
	break;

case 'r': {
	struct diskchunk *chunks;
	int i;
	/* Display free space. */
	chunks = free_chunks(&newlab);
	for (i = 0; chunks[i].start != 0 || chunks[i].stop != 0;
	    i++)
		fprintf(stderr(&__sF[2]), "Free sectors: %16llu - %16llu "
		    "(%16llu)\n",
		    chunks[i].start, chunks[i].stop - 1,
		    chunks[i].stop - chunks[i].start);
	fprintf(stderr(&__sF[2]), "Total free sectors: %llu.\n",
	    editor_countfree(&newlab));
	break;
}

case 's':
	if (arg == NULL((void *)0)) {
		arg = getstring("Filename",
		    "Name of the file to save label into.",
		    NULL((void *)0));
		if (arg == NULL((void *)0) || *arg == '\0')
			break;
	}
	if ((fp = fopen(arg, "w")) == NULL((void *)0)) {
		warn("cannot open %s", arg);
	} else {
		display(fp, &newlab, 0, 1);
		(void)fclose(fp);
	}
	break;

case 'U':
	/*
	 * If we allow 'U' repeatedly, information would be
	 * lost. This way multiple 'U's followed by 'u' will
	 * undo the 'U's.
	 */
	if (memcmp(&newlab, &origlabel, sizeof(newlab)) ||
	    !mpequal(mountpoints, origmountpoints)) {
		tmplabel = newlab;
		newlab = origlabel;
		lastlabel = tmplabel;
		mpcopy(tmpmountpoints, mountpoints);
		mpcopy(mountpoints, origmountpoints);
		mpcopy(omountpoints, tmpmountpoints);
	}
	puts("Original label and mount points restored.");
	break;

case 'u':
	tmplabel = newlab;
	newlab = lastlabel;
	lastlabel = tmplabel;
	mpcopy(tmpmountpoints, mountpoints);
	mpcopy(mountpoints, omountpoints);
	mpcopy(omountpoints, tmpmountpoints);
	puts("Last change undone.");
	break;

case 'w':
	if (donothing)  {
		puts("In no change mode, not writing label.");
		break;
	}

	/* Write label to disk. */
	if (writelabel(f, &newlab) != 0)
		warnx("unable to write label");
	else {
		dflag = aflag = 0;
		newlab = lab; /* lab now has UID info */
	}
	break;

case 'X':
	expert = !expert;
	printf("%s expert mode\n", expert ? "Entering" :
	    "Exiting");
	break;

case 'x':
	goto done;
	break;

case 'z':
	zero_partitions(&newlab);
	break;

case '\n':
	break;

default:
	printf("Unknown option: %c ('?' for help)\n", *cmd);
	break;
}

/*
 * If no changes were made to label or mountpoints, then
 * restore undo info.
 */
if (memcmp(&newlab, &lastlabel, sizeof(newlab)) == 0 &&
    (mpequal(mountpoints, omountpoints))) {
	lastlabel = tmplabel;
	mpcopy(omountpoints, tmpmountpoints);
}
}
533done:
mpfree(omountpoints);
mpfree(origmountpoints);
mpfree(tmpmountpoints);
free(disk_geop);
return (error);
539}

541/*
* Allocate all disk space according to standard recommendations for a
* root disk.
*/
545int
546editor_allocspace(struct disklabel *lp_org)
547{
struct disklabel *lp, label;
struct space_allocation *alloc;
struct space_allocation *ap;
struct partition *pp;
struct diskchunk *chunks;
u_int64_t chunkstart, chunkstop, chunksize;
u_int64_t cylsecs, secs, xtrasecs;
char **partmp;
int i, j, lastalloc, index, partno, freeparts;
extern int64_t physmem;

/* How big is the OpenBSD portion of the disk?  */
find_bounds(lp_org);

overlap = 0;
freeparts = 0;
for (i = 0;  i < MAXPARTITIONS16; i++) {
u_int64_t psz, pstart, pend;

pp = &lp_org->d_partitions[i];
psz = DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size);
if (psz == 0)
	freeparts++;
pstart = DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
);
pend = pstart + psz;
if (i != RAW_PART2 && psz != 0 &&
    ((pstart >= starting_sector && pstart < ending_sector) ||
    (pend > starting_sector && pend <= ending_sector))) {
	overlap = 1;
	break;
}
}

cylsecs = lp_org->d_secpercyl;
alloc = NULL((void *)0);
index = -1;
584again:
free(alloc);
alloc = NULL((void *)0);
index++;
if (index >= alloc_table_nitems)
return 1;
lp = &label;
for (i=0; i<MAXPARTITIONS16; i++) {
free(mountpoints[i]);
mountpoints[i] = NULL((void *)0);
}
memcpy(lp, lp_org, sizeof(struct disklabel));
lp->d_npartitions = MAXPARTITIONS16;
lastalloc = alloc_table[index].sz;
if (lastalloc > freeparts)
goto again;
alloc = reallocarray(NULL((void *)0), lastalloc, sizeof(struct space_allocation));
if (alloc == NULL((void *)0))
errx(4, "out of memory");
memcpy(alloc, alloc_table[index].table,
   lastalloc * sizeof(struct space_allocation));

/* bump max swap based on phys mem, little physmem gets 2x swap */
if (index == 0 && alloc_table == alloc_table_default) {
if (physmem && physmem / DEV_BSIZE(1 << 9) < MEG(256)((256) * 1024LL * (1024 / (1 << 9))))
	alloc[1].minsz = alloc[1].maxsz = 2 * (physmem /
	    DEV_BSIZE(1 << 9));
else
	alloc[1].maxsz += (physmem / DEV_BSIZE(1 << 9));
/* bump max /var to make room for 2 crash dumps */
alloc[3].maxsz += 2 * (physmem / DEV_BSIZE(1 << 9));
}

xtrasecs = editor_countfree(lp);

for (i = 0; i < lastalloc; i++) {
alloc[i].minsz = DL_BLKTOSEC(lp, alloc[i].minsz)((alloc[i].minsz) / ((lp)->d_secsize / (1 << 9)));
alloc[i].maxsz = DL_BLKTOSEC(lp, alloc[i].maxsz)((alloc[i].maxsz) / ((lp)->d_secsize / (1 << 9)));
if (xtrasecs >= alloc[i].minsz)
	xtrasecs -= alloc[i].minsz;
else {
	/* It did not work out, try next strategy */
	goto again;
}
}

for (i = 0; i < lastalloc; i++) {
/* Find next available partition. */
for (j = 0;  j < MAXPARTITIONS16; j++)
	if (DL_GETPSIZE(&lp->d_partitions[j])(((u_int64_t)(&lp->d_partitions[j])->p_sizeh <<
 32) + (&lp->d_partitions[j])->p_size) == 0)
		break;
if (j == MAXPARTITIONS16) {
	/* It did not work out, try next strategy */
	goto again;
}
partno = j;
pp = &lp->d_partitions[j];
partmp = &mountpoints[j];
ap = &alloc[i];

/* Find largest chunk of free space. */
chunks = free_chunks(lp);
chunksize = 0;
for (j = 0; chunks[j].start != 0 || chunks[j].stop != 0; j++) {
	if ((chunks[j].stop - chunks[j].start) > chunksize) {
		chunkstart = chunks[j].start;
		chunkstop = chunks[j].stop;
651#ifdef SUN_CYLCHECK
		if (lp->d_flags & D_VENDOR0x08) {
			/* Align to cylinder boundaries. */
			chunkstart = ((chunkstart + cylsecs - 1)
			    / cylsecs) * cylsecs;
			chunkstop = (chunkstop / cylsecs) *
			    cylsecs;
		}
659#endif
		chunksize = chunkstop - chunkstart;
	}
}

/* Figure out the size of the partition. */
if (i == lastalloc - 1) {
	if (chunksize > ap->maxsz)
		secs = ap->maxsz;
	else
		secs = chunksize;
} else {
	secs = ap->minsz;
	if (xtrasecs > 0)
		secs += (xtrasecs / 100) * ap->rate;
	if (secs > ap->maxsz)
		secs = ap->maxsz;
}
677#ifdef SUN_CYLCHECK
if (lp->d_flags & D_VENDOR0x08) {
	secs = ((secs + cylsecs - 1) / cylsecs) * cylsecs;
	while (secs > chunksize)
		secs -= cylsecs;
}
683#endif

/* See if partition can fit into chunk. */
if (secs > chunksize)
	secs = chunksize;
if (secs < ap->minsz) {
	/* It did not work out, try next strategy */
	goto again;
}

/* Everything seems ok so configure the partition. */
DL_SETPSIZE(pp, secs)do { u_int64_t __x = (secs); (pp)->p_sizeh = __x >> 32
; (pp)->p_size = __x; } while (0);
DL_SETPOFFSET(pp, chunkstart)do { u_int64_t __x = (chunkstart); (pp)->p_offseth = __x >>
 32; (pp)->p_offset = __x; } while (0);
if (ap->mp[0] != '/')
	pp->p_fstype = FS_SWAP1;
else {
	pp->p_fstype = FS_BSDFFS7;
	pp->p_fragblock = 0;
	if (get_fsize(lp, partno) == 1 ||
	    get_bsize(lp, partno) == 1 ||
	    get_cpg(lp, partno) == 1) {
		free(alloc);
		return 1;
	}
	free(*partmp);
	if ((*partmp = strdup(ap->mp)) == NULL((void *)0))
		errx(4, "out of memory");
}
}

free(alloc);
memcpy(lp_org, lp, sizeof(struct disklabel));
return 0;
716}

718/*
* Resize a partition, moving all subsequent partitions
*/
721void
722editor_resize(struct disklabel *lp, char *p)
723{
struct disklabel label;
struct partition *pp, *prev;
u_int64_t ui, sz, off;
int partno, i, flags, shrunk;

label = *lp;

/* Change which partition? */
if (p == NULL((void *)0))
30
←
Assuming 'p' is not equal to NULL→
31
←
Taking false branch→
p = getstring("partition to resize",
    "The letter of the partition to name, a - p.", NULL((void *)0));
if (p31.1
'p' is not equal to NULL
 == NULL((void *)0))
32
←
Taking false branch→
return;
partno = p[0] - 'a';
if (partno < 0 || partno == RAW_PART2 || partno >= lp->d_npartitions) {
33
←
Assuming 'partno' is >= 0→
34
←
Assuming 'partno' is not equal to RAW_PART→
35
←
Assuming 'partno' is < field 'd_npartitions'→
36
←
Taking false branch→
fprintf(stderr(&__sF[2]), "Partition must be between 'a' and '%c' "
    "(excluding 'c').\n", 'a' + lp->d_npartitions - 1);
return;
}

pp = &label.d_partitions[partno];
sz = DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size);
if (sz == 0) {
37
←
Assuming 'sz' is not equal to 0→
38
←
Taking false branch→
fputs("No such partition\n", stderr(&__sF[2]));
return;
}
if (pp->p_fstype != FS_BSDFFS7 && pp->p_fstype != FS_SWAP1) {
39
←
Assuming field 'p_fstype' is equal to FS_BSDFFS→
fputs("Cannot resize spoofed partition\n", stderr(&__sF[2]));
return;
}
flags = DO_CONVERSIONS0x00000001;
ui = getuint64(lp, "[+|-]new size (with unit)",
   "new size or amount to grow (+) or shrink (-) partition including "
   "unit", sz, sz + editor_countfree(lp), &flags);

if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1))
40
←
Assuming the condition is false→
41
←
Taking false branch→
return;
else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
42
←
Assuming the condition is false→
43
←
Taking false branch→
return;
else if (ui == 0) {
44
←
Assuming 'ui' is not equal to 0→
45
←
Taking false branch→
fputs("The size must be > 0 sectors\n", stderr(&__sF[2]));
return;
}

768#ifdef SUN_CYLCHECK
if (lp->d_secpercyl & D_VENDOR0x08) {
u_int64_t cylsecs;
cylsecs = lp->d_secpercyl;
ui = ((ui + cylsecs - 1) / cylsecs) * cylsecs;
}
774#endif
if (DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
) + ui > ending_sector) {
46
←
Assuming the condition is false→
47
←
Taking false branch→
fputs("Amount too big\n", stderr(&__sF[2]));
return;
}

DL_SETPSIZE(pp, ui)do { u_int64_t __x = (ui); (pp)->p_sizeh = __x >> 32
; (pp)->p_size = __x; } while (0);
48
←
Loop condition is false.  Exiting loop→
pp->p_fragblock = 0;
if (get_fsize(&label, partno) == 1 ||
   get_bsize(&label, partno) == 1 ||
49
←
Calling 'get_bsize'→
   get_cpg(&label, partno) == 1)
return;

/*
* Pack partitions above the resized partition, leaving unused
* partitions alone.
*/
shrunk = -1;
prev = pp;
for (i = partno + 1; i < MAXPARTITIONS16; i++) {
if (i == RAW_PART2)
	continue;
pp = &label.d_partitions[i];
if (pp->p_fstype != FS_BSDFFS7 && pp->p_fstype != FS_SWAP1)
	continue;
sz = DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size);
if (sz == 0)
	continue;

off = DL_GETPOFFSET(prev)(((u_int64_t)(prev)->p_offseth << 32) + (prev)->p_offset
) + DL_GETPSIZE(prev)(((u_int64_t)(prev)->p_sizeh << 32) + (prev)->p_size
);

if (off < ending_sector) {
	DL_SETPOFFSET(pp, off)do { u_int64_t __x = (off); (pp)->p_offseth = __x >>
 32; (pp)->p_offset = __x; } while (0);
	if (off + DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) > ending_sector) {
		DL_SETPSIZE(pp, ending_sector - off)do { u_int64_t __x = (ending_sector - off); (pp)->p_sizeh =
 __x >> 32; (pp)->p_size = __x; } while (0);
		pp->p_fragblock = DISKLABELV1_FFS_FRAGBLOCK(0, 0)((0) * (0) == 0 ? 0 : (((ffs((0) * (0)) - 13) << 3) | (
ffs(0))));
		if (get_fsize(&label, i) == 1 ||
		    get_bsize(&label, i) == 1 ||
		    get_cpg(&label, i) == 1)
			return;
		shrunk = i;
	}
} else {
	fputs("Amount too big\n", stderr(&__sF[2]));
	return;
}
prev = pp;
}

if (shrunk != -1)
fprintf(stderr(&__sF[2]), "Partition %c shrunk to %llu sectors to make "
    "room\n", 'a' + shrunk,
    DL_GETPSIZE(&label.d_partitions[shrunk])(((u_int64_t)(&label.d_partitions[shrunk])->p_sizeh <<
 32) + (&label.d_partitions[shrunk])->p_size));
*lp = label;
828}

830/*
* Add a new partition.
*/
833void
834editor_add(struct disklabel *lp, char *p)
835{
struct partition *pp;
struct diskchunk *chunks;
char buf[2];
int i, partno;
u_int64_t freesectors, new_offset, new_size;

freesectors = editor_countfree(lp);

/* XXX - prompt user to steal space from another partition instead */
845#ifdef SUN_CYLCHECK
if ((lp->d_flags & D_VENDOR0x08) && freesectors < lp->d_secpercyl) {
fputs("No space left, you need to shrink a partition "
    "(need at least one full cylinder)\n",
    stderr(&__sF[2]));
return;
}
852#endif
if (freesectors == 0) {
fputs("No space left, you need to shrink a partition\n",
    stderr(&__sF[2]));
return;
}

if (p == NULL((void *)0)) {
/*
 * Use the first unused partition that is not 'c' as the
 * default partition in the prompt string.
 */
pp = &lp->d_partitions[0];
buf[0] = buf[1] = '\0';
for (partno = 0; partno < MAXPARTITIONS16; partno++, pp++) {
	if (DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0 && partno != RAW_PART2) {
		buf[0] = partno + 'a';
		p = &buf[0];
		break;
	}
}
p = getstring("partition",
    "The letter of the new partition, a - p.", p);
}
if (p == NULL((void *)0))
return;
partno = p[0] - 'a';
if (partno < 0 || partno == RAW_PART2 || partno >= MAXPARTITIONS16) {
fprintf(stderr(&__sF[2]), "Partition must be between 'a' and '%c' "
    "(excluding 'c').\n", 'a' + MAXPARTITIONS16 - 1);
return;
}
pp = &lp->d_partitions[partno];

if (pp->p_fstype != FS_UNUSED0 && DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) != 0) {
fprintf(stderr(&__sF[2]), "Partition '%c' exists.  Delete it first.\n",
    p[0]);
return;
}

/*
* Increase d_npartitions if necessary. Ensure all new partitions are
* zero'ed to avoid inadvertent overlaps.
*/
for(; lp->d_npartitions <= partno; lp->d_npartitions++)
memset(&lp->d_partitions[lp->d_npartitions], 0, sizeof(*pp));

/* Make sure selected partition is zero'd too. */
memset(pp, 0, sizeof(*pp));
chunks = free_chunks(lp);

/*
* Since we know there's free space, there must be at least one
* chunk. So find the largest chunk and assume we want to add the
* partition in that free space.
*/
new_size = new_offset = 0;
for (i = 0; chunks[i].start != 0 || chunks[i].stop != 0; i++) {
if (chunks[i].stop - chunks[i].start > new_size) {
	new_size = chunks[i].stop - chunks[i].start;
	new_offset = chunks[i].start;
}
}
DL_SETPSIZE(pp, new_size)do { u_int64_t __x = (new_size); (pp)->p_sizeh = __x >>
 32; (pp)->p_size = __x; } while (0);
DL_SETPOFFSET(pp, new_offset)do { u_int64_t __x = (new_offset); (pp)->p_offseth = __x >>
 32; (pp)->p_offset = __x; } while (0);
pp->p_fstype = partno == 1 ? FS_SWAP1 : FS_BSDFFS7;

if (get_offset(lp, partno) == 0 &&
   get_size(lp, partno) == 0 &&
   get_fstype(lp, partno) == 0 &&
   get_mp(lp, partno) == 0 &&
   get_fsize(lp, partno) == 0  &&
   get_bsize(lp, partno) == 0 &&
   get_cpg(lp, partno) == 0)
return;

/* Bailed out at some point, so effectively delete the partition. */
memset(pp, 0, sizeof(*pp));
930}

932/*
* Set the mountpoint of an existing partition ('name').
*/
935void
936editor_name(struct disklabel *lp, char *p)
937{
struct partition *pp;
int partno;

/* Change which partition? */
if (p == NULL((void *)0))
p = getstring("partition to name",
    "The letter of the partition to name, a - p.", NULL((void *)0));
if (p == NULL((void *)0))
return;
partno = p[0] - 'a';
if (partno < 0 || partno == RAW_PART2 || partno >= lp->d_npartitions) {
fprintf(stderr(&__sF[2]), "Partition must be between 'a' and '%c' "
    "(excluding 'c').\n", 'a' + lp->d_npartitions - 1);
return;
}
pp = &lp->d_partitions[partno];

if (pp->p_fstype == FS_UNUSED0 && DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0) {
fprintf(stderr(&__sF[2]), "Partition '%c' is not in use.\n", p[0]);
return;
}

get_mp(lp, partno);
961}

963/*
* Change an existing partition.
*/
966void
967editor_modify(struct disklabel *lp, char *p)
968{
struct partition opp, *pp;
int partno;

/* Change which partition? */
if (p == NULL((void *)0))
p = getstring("partition to modify",
    "The letter of the partition to modify, a - p.", NULL((void *)0));
if (p == NULL((void *)0))
return;
partno = p[0] - 'a';
if (partno < 0 || partno == RAW_PART2 || partno >= lp->d_npartitions) {
fprintf(stderr(&__sF[2]), "Partition must be between 'a' and '%c' "
    "(excluding 'c').\n", 'a' + lp->d_npartitions - 1);
return;
}
pp = &lp->d_partitions[partno];

if (pp->p_fstype == FS_UNUSED0 && DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0) {
fprintf(stderr(&__sF[2]), "Partition '%c' is not in use.\n", p[0]);
return;
}

opp = *pp;

if (get_offset(lp, partno) == 0 &&
   get_size(lp, partno) == 0   &&
   get_fstype(lp, partno) == 0 &&
   get_mp(lp, partno) == 0 &&
   get_fsize(lp, partno) == 0  &&
   get_bsize(lp, partno) == 0 &&
   get_cpg(lp, partno) == 0)
return;

/* Bailed out at some point, so undo any changes. */
*pp = opp;
1004}

1006/*
* Delete an existing partition.
*/
1009void
1010editor_delete(struct disklabel *lp, char *p)
1011{
struct partition *pp;
int partno;

if (p == NULL((void *)0))
p = getstring("partition to delete",
    "The letter of the partition to delete, a - p, or '*'.",
    NULL((void *)0));
if (p == NULL((void *)0))
return;
if (p[0] == '*') {
zero_partitions(lp);
return;
}
partno = p[0] - 'a';
if (partno < 0 || partno == RAW_PART2 || partno >= lp->d_npartitions) {
fprintf(stderr(&__sF[2]), "Partition must be between 'a' and '%c' "
    "(excluding 'c').\n", 'a' + lp->d_npartitions - 1);
return;
}
pp = &lp->d_partitions[partno];

if (pp->p_fstype == FS_UNUSED0 && DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0) {
fprintf(stderr(&__sF[2]), "Partition '%c' is not in use.\n", p[0]);
return;
}

/* Really delete it (as opposed to just setting to "unused") */
memset(pp, 0, sizeof(*pp));
free(mountpoints[partno]);
mountpoints[partno] = NULL((void *)0);
1042}

1044/*
* Change the size of an existing partition.
*/
1047void
1048editor_change(struct disklabel *lp, char *p)
1049{
struct partition *pp;
int partno;

if (p == NULL((void *)0))
p = getstring("partition to change size",
    "The letter of the partition to change size, a - p.", NULL((void *)0));
if (p == NULL((void *)0))
return;
partno = p[0] - 'a';
if (partno < 0 || partno == RAW_PART2 || partno >= lp->d_npartitions) {
fprintf(stderr(&__sF[2]), "Partition must be between 'a' and '%c' "
    "(excluding 'c').\n", 'a' + lp->d_npartitions - 1);
return;
}
pp = &lp->d_partitions[partno];

if (DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0) {
fprintf(stderr(&__sF[2]), "Partition '%c' is not in use.\n", p[0]);
return;
}

printf("Partition %c is currently %llu sectors in size, and can have "
   "a maximum\nsize of %llu sectors.\n",
   p[0], DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size), max_partition_size(lp, partno));

/* Get new size */
get_size(lp, partno);
1077}

1079/*
* Sort the partitions based on starting offset.
* This assumes there can be no overlap.
*/
1083int
1084partition_cmp(const void *e1, const void *e2)
1085{
struct partition *p1 = *(struct partition **)e1;
struct partition *p2 = *(struct partition **)e2;
u_int64_t o1 = DL_GETPOFFSET(p1)(((u_int64_t)(p1)->p_offseth << 32) + (p1)->p_offset
);
u_int64_t o2 = DL_GETPOFFSET(p2)(((u_int64_t)(p2)->p_offseth << 32) + (p2)->p_offset
);

if (o1 < o2)
return -1;
else if (o1 > o2)
return 1;
else
return 0;
1097}

1099char *
1100getstring(const char *prompt, const char *helpstring, const char *oval)
1101{
static char buf[BUFSIZ1024];
int n;

buf[0] = '\0';
do {
printf("%s: [%s] ", prompt, oval ? oval : "");
if (fgets(buf, sizeof(buf), stdin(&__sF[0])) == NULL((void *)0)) {
	buf[0] = '\0';
	if (feof(stdin)(!__isthreaded ? ((((&__sF[0]))->_flags & 0x0020) !=
 0) : (feof)((&__sF[0])))) {
		clearerr(stdin)(!__isthreaded ? ((void)(((&__sF[0]))->_flags &= ~
(0x0040|0x0020))) : (clearerr)((&__sF[0])));
		putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
		fputs("Command aborted\n", stderr(&__sF[2]));
		return (NULL((void *)0));
	}
}
n = strlen(buf);
if (n > 0 && buf[n-1] == '\n')
	buf[--n] = '\0';
if (buf[0] == '?')
	puts(helpstring);
else if (oval != NULL((void *)0) && buf[0] == '\0')
	strlcpy(buf, oval, sizeof(buf));
} while (buf[0] == '?');

return (&buf[0]);
1127}

1129/*
* Returns
* 0 .. CMD_ABORTED - 1	==> valid value
* CMD_BADVALUE		==> invalid value
* CMD_ABORTED		==> ^D on input
*/
1135u_int64_t
1136getnumber(char *prompt, char *helpstring, u_int32_t oval, u_int32_t maxval)
1137{
char buf[BUFSIZ1024], *p;
int rslt;
long long rval;
const char *errstr;

rslt = snprintf(buf, sizeof(buf), "%u", oval);
if (rslt < 0 || (unsigned int)rslt >= sizeof(buf))
return (CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)));

p = getstring(prompt, helpstring, buf);
if (p == NULL((void *)0))
return (CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1));
if (strlen(p) == 0)
return (oval);

rval = strtonum(p, 0, maxval, &errstr);
if (errstr != NULL((void *)0)) {
printf("%s must be between 0 and %u\n", prompt, maxval);
return (CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)));
}

return (rval);
1160}

1162/*
* Returns
* 0 .. CMD_ABORTED - 1	==> valid value
* CMD_BADVALUE		==> invalid value
* CMD_ABORTED		==> ^D on input
*/
1168u_int64_t
1169getuint64(struct disklabel *lp, char *prompt, char *helpstring,
  u_int64_t oval, u_int64_t maxval, int *flags)
1171{
char buf[21], *p, operator = '\0';
char *unit = NULL((void *)0);
u_int64_t rval = oval;
double d;
int rslt;

rslt = snprintf(buf, sizeof(buf), "%llu", oval);
if (rslt < 0 || (unsigned int)rslt >= sizeof(buf))
goto invalid;

p = getstring(prompt, helpstring, buf);
if (p == NULL((void *)0))
return (CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1));
else if (p[0] == '\0')
rval = oval;
else if (p[0] == '*' && p[1] == '\0')
rval = maxval;
else {
if (*p == '+' || *p == '-')
	operator = *p++;
if (parse_sizespec(p, &d, &unit) == -1)
	goto invalid;
if (unit == NULL((void *)0))
	rval = d;
else if (flags != NULL((void *)0) && (*flags & DO_CONVERSIONS0x00000001) == 0)
	goto invalid;
else {
	switch (tolower((unsigned char)*unit)) {
	case 'b':
		rval = d / lp->d_secsize;
		break;
	case 'c':
		rval = d * lp->d_secpercyl;
		break;
	case '%':
		rval = DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
) * (d / 100.0);
		break;
	case '&':
		rval = maxval * (d / 100.0);
		break;
	default:
		if (apply_unit(d, *unit, &rval) == -1)
			goto invalid;
		rval = DL_BLKTOSEC(lp, rval)((rval) / ((lp)->d_secsize / (1 << 9)));
		break;
	}
}

/* Range check then apply [+-] operator */
if (operator == '+') {
	if (CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1) - oval > rval)
		rval += oval;
	else {
		goto invalid;
	}
} else if (operator == '-') {
	if (oval >= rval)
		rval = oval - rval;
	else {
		goto invalid;
	}
}
}

if (flags != NULL((void *)0)) {
if (unit != NULL((void *)0))
	*flags |= DO_ROUNDING0x00000002;
1239#ifdef SUN_CYLCHECK
if (lp->d_flags & D_VENDOR0x08)
	*flags |= DO_ROUNDING0x00000002;
1242#endif
}
return (rval);

1246invalid:
fputs("Invalid entry\n", stderr(&__sF[2]));
return (CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)));
1249}

1251/*
* Check for partition overlap in lp and prompt the user to resolve the overlap
* if any is found.  Returns 1 if unable to resolve, else 0.
*/
1255int
1256has_overlap(struct disklabel *lp)
1257{
struct partition **spp;
int i, p1, p2;
char *line = NULL((void *)0);
size_t linesize = 0;
ssize_t linelen;

for (;;) {
spp = sort_partitions(lp);
for (i = 0; spp[i+1] != NULL((void *)0); i++) {
	if (DL_GETPOFFSET(spp[i])(((u_int64_t)(spp[i])->p_offseth << 32) + (spp[i])->
p_offset) + DL_GETPSIZE(spp[i])(((u_int64_t)(spp[i])->p_sizeh << 32) + (spp[i])->
p_size) >
	    DL_GETPOFFSET(spp[i+1])(((u_int64_t)(spp[i+1])->p_offseth << 32) + (spp[i+1
])->p_offset))
		break;
}
if (spp[i+1] == NULL((void *)0)) {
	free(line);
	return (0);
}

p1 = 'a' + (spp[i] - lp->d_partitions);
p2 = 'a' + (spp[i+1] - lp->d_partitions);
printf("\nError, partitions %c and %c overlap:\n", p1, p2);
printf("#    %16.16s %16.16s  fstype [fsize bsize    cpg]\n",
    "size", "offset");
display_partition(stdout(&__sF[1]), lp, p1 - 'a', 0);
display_partition(stdout(&__sF[1]), lp, p2 - 'a', 0);

for (;;) {
	printf("Disable which one? (%c %c) ", p1, p2);
	linelen = getline(&line, &linesize, stdin(&__sF[0]));
	if (linelen == -1)
		goto done;
	if (linelen == 2 && (line[0] == p1 || line[0] == p2))
		break;
}
lp->d_partitions[line[0] - 'a'].p_fstype = FS_UNUSED0;
}

1295done:
putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
free(line);
return (1);
1299}

1301void
1302edit_parms(struct disklabel *lp)
1303{
char *p;
u_int64_t freesectors, ui;
struct disklabel oldlabel = *lp;

printf("Changing device parameters for %s:\n", specname);

/* disk type */
for (;;) {
p = getstring("disk type",
    "What kind of disk is this?  Usually SCSI, ESDI, ST506, or "
    "floppy (use ESDI for IDE).", dktypenames[lp->d_type]);
if (p == NULL((void *)0))
	return;
if (strcasecmp(p, "IDE") == 0)
	ui = DTYPE_ESDI5;
else
	for (ui = 1; ui < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1) && strcasecmp(p,
	    dktypenames[ui]); ui++)
		;
if (ui < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1)) {
	break;
} else {
	printf("\"%s\" is not a valid disk type.\n", p);
	fputs("Valid types are: ", stdout(&__sF[1]));
	for (ui = 1; ui < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1); ui++) {
		printf("\"%s\"", dktypenames[ui]);
		if (ui < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1) - 1)
			fputs(", ", stdout(&__sF[1]));
	}
	putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
}
}
lp->d_type = ui;

/* pack/label id */
p = getstring("label name",
   "15 char string that describes this label, usually the disk name.",
   lp->d_packname);
if (p == NULL((void *)0)) {
*lp = oldlabel;		/* undo damage */
return;
}
strncpy(lp->d_packname, p, sizeof(lp->d_packname));	/* checked */

/* sectors/track */
for (;;) {
ui = getnumber("sectors/track",
    "The Number of sectors per track.", lp->d_nsectors,
    UINT32_MAX0xffffffffU);
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1)) {
	*lp = oldlabel;		/* undo damage */
	return;
} else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else
	break;
}
lp->d_nsectors = ui;

/* tracks/cylinder */
for (;;) {
ui = getnumber("tracks/cylinder",
    "The number of tracks per cylinder.", lp->d_ntracks,
    UINT32_MAX0xffffffffU);
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1)) {
	*lp = oldlabel;		/* undo damage */
	return;
} else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else
	break;
}
lp->d_ntracks = ui;

/* sectors/cylinder */
for (;;) {
ui = getnumber("sectors/cylinder",
    "The number of sectors per cylinder (Usually sectors/track "
    "* tracks/cylinder).", lp->d_secpercyl, UINT32_MAX0xffffffffU);
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1)) {
	*lp = oldlabel;		/* undo damage */
	return;
} else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else
	break;
}
lp->d_secpercyl = ui;

/* number of cylinders */
for (;;) {
ui = getnumber("number of cylinders",
    "The total number of cylinders on the disk.",
    lp->d_ncylinders, UINT32_MAX0xffffffffU);
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1)) {
	*lp = oldlabel;		/* undo damage */
	return;
} else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else
	break;
}
lp->d_ncylinders = ui;

/* total sectors */
for (;;) {
u_int64_t nsec = MAXIMUM(DL_GETDSIZE(lp),((((((u_int64_t)(lp)->d_secperunith << 32) + (lp)->
d_secperunit)) > ((u_int64_t)lp->d_ncylinders * lp->
d_secpercyl)) ? ((((u_int64_t)(lp)->d_secperunith <<
 32) + (lp)->d_secperunit)) : ((u_int64_t)lp->d_ncylinders
 * lp->d_secpercyl))
    (u_int64_t)lp->d_ncylinders * lp->d_secpercyl)((((((u_int64_t)(lp)->d_secperunith << 32) + (lp)->
d_secperunit)) > ((u_int64_t)lp->d_ncylinders * lp->
d_secpercyl)) ? ((((u_int64_t)(lp)->d_secperunith <<
 32) + (lp)->d_secperunit)) : ((u_int64_t)lp->d_ncylinders
 * lp->d_secpercyl));
ui = getuint64(lp, "total sectors",
    "The total number of sectors on the disk.",
    nsec, nsec, NULL((void *)0));
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1)) {
	*lp = oldlabel;		/* undo damage */
	return;
} else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else if (ui > DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
) &&
    ending_sector == DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
)) {
	puts("You may want to increase the size of the 'c' "
	    "partition.");
	break;
} else if (ui < DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
) &&
    ending_sector == DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
)) {
	/* shrink free count */
	freesectors = editor_countfree(lp);
	if (DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
) - ui > freesectors)
		fprintf(stderr(&__sF[2]),
		    "Not enough free space to shrink by %llu "
		    "sectors (only %llu sectors left)\n",
		    DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
) - ui, freesectors);
	else
		break;
} else
	break;
}
/* Adjust ending_sector if necessary. */
if (ending_sector > ui) {
ending_sector = ui;
DL_SETBEND(lp, ending_sector)do { u_int64_t __x = (ending_sector); (lp)->d_bendh = __x >>
 32; (lp)->d_bend = __x; } while (0);
}
DL_SETDSIZE(lp, ui)do { u_int64_t __x = (ui); (lp)->d_secperunith = __x >>
 32; (lp)->d_secperunit = __x; } while (0);
1445}

1447struct partition **
1448sort_partitions(struct disklabel *lp)
1449{
static struct partition *spp[MAXPARTITIONS16+2];
int i, npartitions;

memset(spp, 0, sizeof(spp));

for (npartitions = 0, i = 0; i < lp->d_npartitions; i++) {
if (lp->d_partitions[i].p_fstype != FS_UNUSED0 &&
    DL_GETPSIZE(&lp->d_partitions[i])(((u_int64_t)(&lp->d_partitions[i])->p_sizeh <<
 32) + (&lp->d_partitions[i])->p_size) != 0)
	spp[npartitions++] = &lp->d_partitions[i];
}

/*
* Sort the partitions based on starting offset.
* This is safe because we guarantee no overlap.
*/
if (npartitions > 1)
if (mergesort((void *)spp, npartitions, sizeof(spp[0]),
    partition_cmp))
	err(4, "failed to sort partition table");

return (spp);
1471}

1473/*
* Get a valid disk type if necessary.
*/
1476void
1477getdisktype(struct disklabel *lp, char *banner, char *dev)
1478{
int i;
char *s;
const char *def = "SCSI";
const struct dtypes {
const char *dev;
const char *type;
} dtypes[] = {
{ "sd",   "SCSI" },
{ "wd",   "IDE" },
{ "fd",   "FLOPPY" },
{ "xd",   "SMD" },
{ "xy",   "SMD" },
{ "hd",   "HP-IB" },
{ "vnd",  "VND" },
{ "svnd", "VND" },
{ NULL((void *)0),   NULL((void *)0) }
};

if ((s = basename(dev)) != NULL((void *)0)) {
if (*s == 'r')
	s++;
i = strcspn(s, "0123456789");
s[i] = '\0';
dev = s;
for (i = 0; dtypes[i].dev != NULL((void *)0); i++) {
	if (strcmp(dev, dtypes[i].dev) == 0) {
		def = dtypes[i].type;
		break;
	}
}
}

if (lp->d_type > DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1) || lp->d_type == 0) {
puts(banner);
puts("Possible values are:");
printf("\"IDE\", ");
for (i = 1; i < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1); i++) {
	printf("\"%s\"", dktypenames[i]);
	if (i < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1) - 1)
		fputs(", ", stdout(&__sF[1]));
}
putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));

for (;;) {
	s = getstring("Disk type",
	    "What kind of disk is this?  Usually SCSI, IDE, "
	    "ESDI, ST506, or floppy.", def);
	if (s == NULL((void *)0))
		continue;
	if (strcasecmp(s, "IDE") == 0) {
		lp->d_type = DTYPE_ESDI5;
		return;
	}
	for (i = 1; i < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1); i++)
		if (strcasecmp(s, dktypenames[i]) == 0) {
			lp->d_type = i;
			return;
		}
	printf("\"%s\" is not a valid disk type.\n", s);
	fputs("Valid types are: ", stdout(&__sF[1]));
	for (i = 1; i < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1); i++) {
		printf("\"%s\"", dktypenames[i]);
		if (i < DKMAXTYPES(sizeof(dktypenames) / sizeof(dktypenames[0]) - 1) - 1)
			fputs(", ", stdout(&__sF[1]));
	}
	putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
}
}
1547}

1549/*
* Get beginning and ending sectors of the OpenBSD portion of the disk
* from the user.
*/
1553void
1554set_bounds(struct disklabel *lp)
1555{
u_int64_t ui, start_temp;

/* Starting sector */
for (;;) {
ui = getuint64(lp, "Starting sector",
    "The start of the OpenBSD portion of the disk.",
    starting_sector, DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
), NULL((void *)0));
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1))
	return;
else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else if (ui >= DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
))
	fprintf(stderr(&__sF[2]), "starting sector must be < %llu\n",
	    DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
));
else
	break;
}
start_temp = ui;

/* Size */
for (;;) {
ui = getuint64(lp, "Size ('*' for entire disk)",
    "The size of the OpenBSD portion of the disk ('*' for the "
    "entire disk).", ending_sector - starting_sector,
    DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
) - start_temp, NULL((void *)0));
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1))
	return;
else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else if (ui > DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
) - start_temp)
	fprintf(stderr(&__sF[2]), "size must be <= %llu\n",
	    DL_GETDSIZE(lp)(((u_int64_t)(lp)->d_secperunith << 32) + (lp)->d_secperunit
) - start_temp);
else
	break;
}
ending_sector = start_temp + ui;
DL_SETBEND(lp, ending_sector)do { u_int64_t __x = (ending_sector); (lp)->d_bendh = __x >>
 32; (lp)->d_bend = __x; } while (0);
starting_sector = start_temp;
DL_SETBSTART(lp, starting_sector)do { u_int64_t __x = (starting_sector); (lp)->d_bstarth = __x
 >> 32; (lp)->d_bstart = __x; } while (0);
1595}

1597/*
* Allow user to interactively change disklabel UID.
*/
1600void
1601set_duid(struct disklabel *lp)
1602{
char *s;
int i;

printf("The disklabel UID is currently: "
   "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx\n",
   lp->d_uid[0], lp->d_uid[1], lp->d_uid[2], lp->d_uid[3],
   lp->d_uid[4], lp->d_uid[5], lp->d_uid[6], lp->d_uid[7]);

do {
s = getstring("duid", "The disklabel UID, given as a 16 "
    "character hexadecimal string.", NULL((void *)0));
if (s == NULL((void *)0) || strlen(s) == 0) {
	fputs("Command aborted\n", stderr(&__sF[2]));
	return;
}
i = duid_parse(lp, s);
if (i != 0)
	fputs("Invalid UID entered.\n", stderr(&__sF[2]));
} while (i != 0);
1622}

1624/*
* Return a list of the "chunks" of free space available
*/
1627struct diskchunk *
1628free_chunks(struct disklabel *lp)
1629{
struct partition **spp;
static struct diskchunk chunks[MAXPARTITIONS16 + 2];
u_int64_t start, stop;
int i, numchunks;

/* Sort the in-use partitions based on offset */
spp = sort_partitions(lp);

/* If there are no partitions, it's all free. */
if (spp[0] == NULL((void *)0)) {
chunks[0].start = starting_sector;
chunks[0].stop = ending_sector;
chunks[1].start = chunks[1].stop = 0;
return (chunks);
}

/* Find chunks of free space */
numchunks = 0;
if (DL_GETPOFFSET(spp[0])(((u_int64_t)(spp[0])->p_offseth << 32) + (spp[0])->
p_offset) > starting_sector) {
chunks[0].start = starting_sector;
chunks[0].stop = DL_GETPOFFSET(spp[0])(((u_int64_t)(spp[0])->p_offseth << 32) + (spp[0])->
p_offset);
numchunks++;
}
for (i = 0; spp[i] != NULL((void *)0); i++) {
start = DL_GETPOFFSET(spp[i])(((u_int64_t)(spp[i])->p_offseth << 32) + (spp[i])->
p_offset) + DL_GETPSIZE(spp[i])(((u_int64_t)(spp[i])->p_sizeh << 32) + (spp[i])->
p_size);
if (start < starting_sector)
	start = starting_sector;
else if (start > ending_sector)
	start = ending_sector;
if (spp[i + 1] != NULL((void *)0))
	stop = DL_GETPOFFSET(spp[i+1])(((u_int64_t)(spp[i+1])->p_offseth << 32) + (spp[i+1
])->p_offset);
else
	stop = ending_sector;
if (stop < starting_sector)
	stop = starting_sector;
else if (stop > ending_sector)
	stop = ending_sector;
if (start < stop) {
	chunks[numchunks].start = start;
	chunks[numchunks].stop = stop;
	numchunks++;
}
}

/* Terminate and return */
chunks[numchunks].start = chunks[numchunks].stop = 0;
return (chunks);
1677}

1679void
1680find_bounds(struct disklabel *lp)
1681{
starting_sector = DL_GETBSTART(lp)(((u_int64_t)(lp)->d_bstarth << 32) + (lp)->d_bstart
);
ending_sector = DL_GETBEND(lp)(((u_int64_t)(lp)->d_bendh << 32) + (lp)->d_bend);

if (ending_sector) {
if (verbose)
	printf("Treating sectors %llu-%llu as the OpenBSD"
	    " portion of the disk.\nYou can use the 'b'"
	    " command to change this.\n\n", starting_sector,
	    ending_sector);
}
1692}

1694/*
* Calculate free space.
*/
1697u_int64_t
1698editor_countfree(struct disklabel *lp)
1699{
struct diskchunk *chunks;
u_int64_t freesectors = 0;
int i;

chunks = free_chunks(lp);

for (i = 0; chunks[i].start != 0 || chunks[i].stop != 0; i++)
freesectors += chunks[i].stop - chunks[i].start;

return (freesectors);
1710}

1712void
1713editor_help(void)
1714{
puts("Available commands:");
puts(
1717" ? | h    - show help                 n [part] - set mount point\n"
1718" A        - auto partition all space  p [unit] - print partitions\n"
1719" a [part] - add partition             q        - quit & save changes\n"
1720" b        - set OpenBSD boundaries    R [part] - resize auto allocated partition\n"
1721" c [part] - change partition size     r        - display free space\n"
1722" D        - reset label to default    s [path] - save label to file\n"
1723" d [part] - delete partition          U        - undo all changes\n"
1724" e        - edit drive parameters     u        - undo last change\n"
1725" g [d|u]  - [d]isk or [u]ser geometry w        - write label to disk\n"
1726" i        - modify disklabel UID      X        - toggle expert mode\n"
1727" l [unit] - print disk label header   x        - exit & lose changes\n"
1728" M        - disklabel(8) man page     z        - delete all partitions\n"
1729" m [part] - modify partition\n"
1730"\n"
1731"Suffixes can be used to indicate units other than sectors:\n"
1732" 'b' (bytes), 'k' (kilobytes), 'm' (megabytes), 'g' (gigabytes) 't' (terabytes)\n"
1733" 'c' (cylinders), '%' (% of total disk), '&' (% of free space).\n"
1734"Values in non-sector units are truncated to the nearest cylinder boundary.");

1736}

1738void
1739mpcopy(char **to, char **from)
1740{
int i;

for (i = 0; i < MAXPARTITIONS16; i++) {
free(to[i]);
to[i] = NULL((void *)0);
if (from[i] != NULL((void *)0)) {
	to[i] = strdup(from[i]);
	if (to[i] == NULL((void *)0))
		errx(4, "out of memory");
}
}
1752}

1754int
1755mpequal(char **mp1, char **mp2)
1756{
int i;

for (i = 0; i < MAXPARTITIONS16; i++) {
if (mp1[i] == NULL((void *)0) && mp2[i] == NULL((void *)0))
	continue;

if ((mp1[i] != NULL((void *)0) && mp2[i] == NULL((void *)0)) ||
    (mp1[i] == NULL((void *)0) && mp2[i] != NULL((void *)0)) ||
    (strcmp(mp1[i], mp2[i]) != 0))
	return (0);
}
return (1);
1769}

1771void
1772mpsave(struct disklabel *lp)
1773{
int i, j;
char bdev[PATH_MAX1024], *p;
struct mountinfo mi[MAXPARTITIONS16];
FILE *fp;
u_int8_t fstype;

if (!fstabfile)
return;

memset(&mi, 0, sizeof(mi));

for (i = 0; i < MAXPARTITIONS16; i++) {
fstype = lp->d_partitions[i].p_fstype;
if (mountpoints[i] != NULL((void *)0) || fstype == FS_SWAP1) {
	mi[i].mountpoint = mountpoints[i];
	mi[i].partno = i;
}
}

/* Convert specname to bdev */
if (uidflag) {
snprintf(bdev, sizeof(bdev),
    "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx.%c",
    lab.d_uid[0], lab.d_uid[1], lab.d_uid[2], lab.d_uid[3],
    lab.d_uid[4], lab.d_uid[5], lab.d_uid[6], lab.d_uid[7],
    specname[strlen(specname)-1]);
} else if (strncmp(_PATH_DEV"/dev/", specname, sizeof(_PATH_DEV"/dev/") - 1) == 0 &&
   specname[sizeof(_PATH_DEV"/dev/") - 1] == 'r') {
snprintf(bdev, sizeof(bdev), "%s%s", _PATH_DEV"/dev/",
    &specname[sizeof(_PATH_DEV"/dev/")]);
} else {
if ((p = strrchr(specname, '/')) == NULL((void *)0) || *(++p) != 'r')
	return;
*p = '\0';
snprintf(bdev, sizeof(bdev), "%s%s", specname, p + 1);
*p = 'r';
}
bdev[strlen(bdev) - 1] = '\0';

/* Sort mountpoints so we don't try to mount /usr/local before /usr */
qsort((void *)mi, MAXPARTITIONS16, sizeof(struct mountinfo), micmp);

if ((fp = fopen(fstabfile, "w"))) {
for (i = 0; i < MAXPARTITIONS16; i++) {
	j =  mi[i].partno;
	fstype = lp->d_partitions[j].p_fstype;
	if (fstype == FS_SWAP1) {
		fprintf(fp, "%s%c none swap sw\n", bdev, 'a'+j);
	} else if (mi[i].mountpoint) {
		fprintf(fp, "%s%c %s %s rw 1 %d\n", bdev,
		    'a' + j, mi[i].mountpoint,
		    fstypesnames[fstype], j == 0 ? 1 : 2);
	}
}
fclose(fp);
}
1830}

1832void
1833mpfree(char **mp)
1834{
int part;

if (mp == NULL((void *)0))
return;

for (part = 0; part < MAXPARTITIONS16; part++)
free(mp[part]);

free(mp);
1844}

1846int
1847get_offset(struct disklabel *lp, int partno)
1848{
struct partition opp, *pp = &lp->d_partitions[partno];
u_int64_t ui, offsetalign;
int flags;

flags = DO_CONVERSIONS0x00000001;
ui = getuint64(lp, "offset",
   "Starting sector for this partition.",
   DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
),
   DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
), &flags);

if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1) || ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
return (1);
1861#ifdef SUN_AAT0
if (partno == 0 && ui != 0) {
fprintf(stderr(&__sF[2]), "This architecture requires that "
    "partition 'a' start at sector 0.\n");
return (1);
}
1867#endif
opp = *pp;
DL_SETPOFFSET(pp, ui)do { u_int64_t __x = (ui); (pp)->p_offseth = __x >> 32
; (pp)->p_offset = __x; } while (0);
offsetalign = 1;
if ((flags & DO_ROUNDING0x00000002) != 0 && pp->p_fstype == FS_BSDFFS7)
offsetalign = lp->d_secpercyl;

if (alignpartition(lp, partno, offsetalign, 1, ROUND_OFFSET_UP0x00000001) == 1) {
*pp = opp;
return (1);
}

if (expert == 1 && quiet == 0 && ui != DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
))
printf("offset rounded to sector %llu\n", DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
));

return (0);
1883}

1885int
1886get_size(struct disklabel *lp, int partno)
1887{
struct partition opp, *pp = &lp->d_partitions[partno];
u_int64_t maxsize, ui, sizealign;
int flags;

maxsize = max_partition_size(lp, partno);
flags = DO_CONVERSIONS0x00000001;
ui = getuint64(lp, "size", "Size of the partition. "
   "You may also say +/- amount for a relative change.",
   DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size), maxsize, &flags);

if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1) || ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
return (1);

opp = *pp;
DL_SETPSIZE(pp, ui)do { u_int64_t __x = (ui); (pp)->p_sizeh = __x >> 32
; (pp)->p_size = __x; } while (0);
sizealign = 1;
if ((flags & DO_ROUNDING0x00000002) != 0 && (pp->p_fstype == FS_SWAP1 ||
   pp->p_fstype == FS_BSDFFS7))
sizealign = lp->d_secpercyl;

if (alignpartition(lp, partno, 1, sizealign, ROUND_SIZE_UP0x00000004) == 1) {
*pp = opp;
return (1);
}

if (expert == 1 && quiet == 0 && ui != DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size))
printf("size rounded to %llu sectors\n", DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size));

return (0);
1917}

1919int
1920get_cpg(struct disklabel *lp, int partno)
1921{
u_int64_t ui;
struct partition *pp = &lp->d_partitions[partno];

if (pp->p_fstype != FS_BSDFFS7)
return (0);

if (pp->p_cpg == 0)
pp->p_cpg = 1;

if (expert == 0)
return (0);

for (;;) {
ui = getnumber("cpg", "Size of partition in fs blocks.",
    pp->p_cpg, USHRT_MAX(32767 *2 +1));
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1))
	return (1);
else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else
	break;
}
pp->p_cpg = ui;
return (0);
1946}

1948int
1949get_fsize(struct disklabel *lp, int partno)
1950{
struct partition *pp = &lp->d_partitions[partno];
u_int64_t ui, bytes;
u_int32_t frag, fsize;

if (pp->p_fstype != FS_BSDFFS7)
return (0);

fsize = DISKLABELV1_FFS_FSIZE(pp->p_fragblock)(((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1))) == 0 ? 0 : (((pp->p_fragblock) == 0 ?
: (1 << (((pp->p_fragblock) >> 3) + 12))) /
 ((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1)))));
frag = DISKLABELV1_FFS_FRAG(pp->p_fragblock)((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1)));
if (fsize == 0) {
fsize = 2048;
frag = 8;
bytes = DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) * lp->d_secsize;
if (bytes > 128ULL * 1024 * 1024 * 1024)
	fsize *= 2;
if (bytes > 512ULL * 1024 * 1024 * 1024)
	fsize *= 2;
if (fsize < lp->d_secsize)
	fsize = lp->d_secsize;
if (fsize > MAXBSIZE(64 * 1024) / frag)
	fsize = MAXBSIZE(64 * 1024) / frag;
pp->p_fragblock = DISKLABELV1_FFS_FRAGBLOCK(fsize, frag)((fsize) * (frag) == 0 ? 0 : (((ffs((fsize) * (frag)) - 13) <<
 3) | (ffs(frag))));
}

if (expert == 0)
return (0);

for (;;) {
ui = getnumber("fragment size",
    "Size of ffs block fragments. A multiple of the disk "
    "sector-size.", fsize, UINT32_MAX0xffffffffU);
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1))
	return (1);
else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
	;	/* Try again. */
else if (ui < lp->d_secsize || (ui % lp->d_secsize) != 0)
	fprintf(stderr(&__sF[2]), "Error: fragment size must be a "
	    "multiple of the disk sector size (%d)\n",
	    lp->d_secsize);
else
	break;
}
if (ui == 0)
puts("Zero fragment size implies zero block size");
pp->p_fragblock = DISKLABELV1_FFS_FRAGBLOCK(ui, frag)((ui) * (frag) == 0 ? 0 : (((ffs((ui) * (frag)) - 13) <<
 3) | (ffs(frag))));
return (0);
1997}

1999int
2000get_bsize(struct disklabel *lp, int partno)
2001{
u_int64_t ui, frag, fsize;
struct partition opp, *pp = &lp->d_partitions[partno];
u_int64_t offsetalign, sizealign;
char *p;

if (pp->p_fstype49.1
Field 'p_fstype' is equal to FS_BSDFFS
 != FS_BSDFFS7)
50
←
Taking false branch→
return (0);

/* Avoid dividing by zero... */
if (pp->p_fragblock == 0)
51
←
Assuming field 'p_fragblock' is not equal to 0→
52
←
Taking false branch→
return (1);

opp = *pp;
if (expert52.1
'expert' is not equal to 0
 == 0)
53
←
Taking false branch→
goto align;

fsize = DISKLABELV1_FFS_FSIZE(pp->p_fragblock)(((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1))) == 0 ? 0 : (((pp->p_fragblock) == 0 ?
: (1 << (((pp->p_fragblock) >> 3) + 12))) /
 ((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1)))));
54
←
'?' condition is false→
55
←
Assuming the condition is false→
56
←
'?' condition is false→
57
←
'?' condition is false→
58
←
'?' condition is false→
frag = DISKLABELV1_FFS_FRAG(pp->p_fragblock)((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1)));
59
←
'?' condition is false→

for (;;) {
60
←
Loop condition is true.  Entering loop body→
ui = getnumber("block size",
    "Size of ffs blocks. 1, 2, 4 or 8 times ffs fragment size.",
    fsize * frag, UINT32_MAX0xffffffffU);

/* sanity checks */
if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1))
61
←
Assuming the condition is false→
62
←
Taking false branch→
	return (1);
else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
63
←
Assuming the condition is false→
64
←
Taking false branch→
	;	/* Try again. */
else if (ui < getpagesize())
65
←
Assuming the condition is false→
66
←
Taking false branch→
	fprintf(stderr(&__sF[2]),
	    "Error: block size must be at least as big "
	    "as page size (%d).\n", getpagesize());
else if (ui < fsize || (fsize != ui && fsize * 2 != ui &&
67
←
Assuming 'ui' is >= 'fsize'→
68
←
Assuming 'fsize' is equal to 'ui'→
    fsize * 4 != ui && fsize * 8 != ui))
	fprintf(stderr(&__sF[2]), "Error: block size must be 1, 2, 4 or "
	    "8 times fragment size (%llu).\n",
	    (unsigned long long) fsize);
else
	break;
69
←
 Execution continues on line 2043→
}
frag = ui / fsize;
pp->p_fragblock = DISKLABELV1_FFS_FRAGBLOCK(fsize, frag)((fsize) * (frag) == 0 ? 0 : (((ffs((fsize) * (frag)) - 13) <<
 3) | (ffs(frag))));
70
←
Assuming the condition is false→
71
←
'?' condition is false→

2046#ifdef SUN_CYLCHECK
return (0);
2048#endif
p = getstring("Align partition to block size",
   "Round the partition offset and size to multiples of bsize?", "y");
if (*p == 'n' || *p == 'N')
72
←
Assuming the condition is false→
73
←
Assuming the condition is false→
74
←
Taking false branch→
return (0);

2054align:
2055#ifdef SUN_CYLCHECK
return (0);
2057#endif
sizealign = (DISKLABELV1_FFS_FRAG(pp->p_fragblock)((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1))) *
75
←
Assuming field 'p_fragblock' is not equal to 0→
76
←
'?' condition is false→
80
←
The value 0 is assigned to 'sizealign'→
   DISKLABELV1_FFS_FSIZE(pp->p_fragblock)(((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1))) == 0 ? 0 : (((pp->p_fragblock) == 0 ?
: (1 << (((pp->p_fragblock) >> 3) + 12))) /
 ((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1)))))) / lp->d_secsize;
77
←
'?' condition is false→
78
←
Assuming the condition is true→
79
←
'?' condition is true→
offsetalign = 1;
if (DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
) != starting_sector)
81
←
Assuming the condition is true→
82
←
Taking true branch→
offsetalign = sizealign;
83
←
The value 0 is assigned to 'offsetalign'→

if (alignpartition(lp, partno, offsetalign, sizealign, ROUND_OFFSET_UP0x00000001 |
84
←
Passing the value 0 via 3rd parameter 'startalign'→
85
←
Calling 'alignpartition'→
   ROUND_SIZE_DOWN0x00000008 | ROUND_SIZE_OVERLAP0x00000010) == 1) {
*pp = opp;
return (1);
}

if (expert == 1 && quiet == 0 &&
   DL_GETPOFFSET(&opp)(((u_int64_t)(&opp)->p_offseth << 32) + (&opp
)->p_offset) != DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
))
printf("offset rounded to sector %llu\n", DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
));
if (expert == 1 && quiet == 0 && DL_GETPSIZE(&opp)(((u_int64_t)(&opp)->p_sizeh << 32) + (&opp)
->p_size) != DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size))
printf("size rounded to %llu sectors\n", DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size));

return (0);
2077}

2079int
2080get_fstype(struct disklabel *lp, int partno)
2081{
char *p;
u_int64_t ui;
struct partition *pp = &lp->d_partitions[partno];

if (pp->p_fstype < FSMAXTYPES(sizeof(fstypenames) / sizeof(fstypenames[0]) - 1)) {
p = getstring("FS type",
    "Filesystem type (usually 4.2BSD or swap)",
    fstypenames[pp->p_fstype]);
if (p == NULL((void *)0)) {
	return (1);
}
for (ui = 0; ui < FSMAXTYPES(sizeof(fstypenames) / sizeof(fstypenames[0]) - 1); ui++) {
	if (!strcasecmp(p, fstypenames[ui])) {
		pp->p_fstype = ui;
		break;
	}
}
if (ui >= FSMAXTYPES(sizeof(fstypenames) / sizeof(fstypenames[0]) - 1)) {
	printf("Unrecognized filesystem type '%s', treating "
	    "as 'unknown'\n", p);
	pp->p_fstype = FS_OTHER10;
}
} else {
for (;;) {
	ui = getnumber("FS type (decimal)",
	    "Filesystem type as a decimal number; usually 7 "
	    "(4.2BSD) or 1 (swap).",
	    pp->p_fstype, UINT8_MAX0xff);
	if (ui == CMD_ABORTED((9223372036854775807LL*2ULL+1ULL) - 1))
		return (1);
	else if (ui == CMD_BADVALUE((9223372036854775807LL*2ULL+1ULL)))
		;	/* Try again. */
	else
		break;
}
pp->p_fstype = ui;
}
return (0);
2120}

2122int
2123get_mp(struct disklabel *lp, int partno)
2124{
struct partition *pp = &lp->d_partitions[partno];
char *p;
int i;

if (fstabfile == NULL((void *)0) ||
   pp->p_fstype == FS_UNUSED0 ||
   pp->p_fstype == FS_SWAP1 ||
   pp->p_fstype == FS_BOOT13 ||
   pp->p_fstype == FS_OTHER10 ||
   pp->p_fstype == FS_RAID19) {
/* No fstabfile, no names. Not all fstypes can be named */
return 0;
}

for (;;) {
p = getstring("mount point",
    "Where to mount this filesystem (ie: / /var /usr)",
    mountpoints[partno] ? mountpoints[partno] : "none");
if (p == NULL((void *)0))
	return (1);
if (strcasecmp(p, "none") == 0) {
	free(mountpoints[partno]);
	mountpoints[partno] = NULL((void *)0);
	break;
}
for (i = 0; i < MAXPARTITIONS16; i++)
	if (mountpoints[i] != NULL((void *)0) && i != partno &&
	    strcmp(p, mountpoints[i]) == 0)
		break;
if (i < MAXPARTITIONS16) {
	fprintf(stderr(&__sF[2]), "'%c' already being mounted at "
	    "'%s'\n", 'a'+i, p);
	break;
}
if (*p == '/') {
	/* XXX - might as well realloc */
	free(mountpoints[partno]);
	if ((mountpoints[partno] = strdup(p)) == NULL((void *)0))
		errx(4, "out of memory");
	break;
}
fputs("Mount points must start with '/'\n", stderr(&__sF[2]));
}

return (0);
2170}

2172int
2173micmp(const void *a1, const void *a2)
2174{
struct mountinfo *mi1 = (struct mountinfo *)a1;
struct mountinfo *mi2 = (struct mountinfo *)a2;

/* We want all the NULLs at the end... */
if (mi1->mountpoint == NULL((void *)0) && mi2->mountpoint == NULL((void *)0))
return (0);
else if (mi1->mountpoint == NULL((void *)0))
return (1);
else if (mi2->mountpoint == NULL((void *)0))
return (-1);
else
return (strcmp(mi1->mountpoint, mi2->mountpoint));
2187}

2189void
2190get_geometry(int f, struct disklabel **dgpp)
2191{
struct stat st;
struct disklabel *disk_geop;

if (fstat(f, &st) == -1)
err(4, "Can't stat device");

/* Get disk geometry */
if ((disk_geop = calloc(1, sizeof(struct disklabel))) == NULL((void *)0))
errx(4, "out of memory");
if (ioctl(f, DIOCGPDINFO((unsigned long)0x40000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((114))), disk_geop) == -1)
err(4, "DIOCGPDINFO");
*dgpp = disk_geop;
2204}

2206void
2207set_geometry(struct disklabel *lp, struct disklabel *dgp,
  struct disklabel *ugp, char *p)
2209{
if (p == NULL((void *)0))
p = getstring("[d]isk or [u]ser geometry",
    "Enter 'd' to use the geometry based on what the disk "
    "itself thinks it is, or 'u' to use the geometry that "
    "was found in the label.",
    "d");
if (p == NULL((void *)0))
return;
switch (*p) {
case 'd':
case 'D':
if (dgp == NULL((void *)0))
	fputs("BIOS geometry not defined.\n", stderr(&__sF[2]));
else {
	lp->d_secsize = dgp->d_secsize;
	lp->d_nsectors = dgp->d_nsectors;
	lp->d_ntracks = dgp->d_ntracks;
	lp->d_ncylinders = dgp->d_ncylinders;
	lp->d_secpercyl = dgp->d_secpercyl;
	DL_SETDSIZE(lp, DL_GETDSIZE(dgp))do { u_int64_t __x = ((((u_int64_t)(dgp)->d_secperunith <<
 32) + (dgp)->d_secperunit)); (lp)->d_secperunith = __x
 >> 32; (lp)->d_secperunit = __x; } while (0);
}
break;
case 'u':
case 'U':
if (ugp == NULL((void *)0))
	fputs("BIOS geometry not defined.\n", stderr(&__sF[2]));
else {
	lp->d_secsize = ugp->d_secsize;
	lp->d_nsectors = ugp->d_nsectors;
	lp->d_ntracks = ugp->d_ntracks;
	lp->d_ncylinders = ugp->d_ncylinders;
	lp->d_secpercyl = ugp->d_secpercyl;
	DL_SETDSIZE(lp, DL_GETDSIZE(ugp))do { u_int64_t __x = ((((u_int64_t)(ugp)->d_secperunith <<
 32) + (ugp)->d_secperunit)); (lp)->d_secperunith = __x
 >> 32; (lp)->d_secperunit = __x; } while (0);
	if (dgp != NULL((void *)0) && ugp->d_secsize == dgp->d_secsize &&
	    ugp->d_nsectors == dgp->d_nsectors &&
	    ugp->d_ntracks == dgp->d_ntracks &&
	    ugp->d_ncylinders == dgp->d_ncylinders &&
	    ugp->d_secpercyl == dgp->d_secpercyl &&
	    DL_GETDSIZE(ugp)(((u_int64_t)(ugp)->d_secperunith << 32) + (ugp)->
d_secperunit) == DL_GETDSIZE(dgp)(((u_int64_t)(dgp)->d_secperunith << 32) + (dgp)->
d_secperunit))
		fputs("Note: user geometry is the same as disk "
		    "geometry.\n", stderr(&__sF[2]));
}
break;
default:
fputs("You must enter either 'd' or 'u'.\n", stderr(&__sF[2]));
break;
}
2257}

2259void
2260zero_partitions(struct disklabel *lp)
2261{
int i;

for (i = 0; i < MAXPARTITIONS16; i++) {
memset(&lp->d_partitions[i], 0, sizeof(struct partition));
free(mountpoints[i]);
mountpoints[i] = NULL((void *)0);
}

DL_SETPSIZE(&lp->d_partitions[RAW_PART], DL_GETDSIZE(lp))do { u_int64_t __x = ((((u_int64_t)(lp)->d_secperunith <<
 32) + (lp)->d_secperunit)); (&lp->d_partitions[2])
->p_sizeh = __x >> 32; (&lp->d_partitions[2])
->p_size = __x; } while (0);
2271}

2273u_int64_t
2274max_partition_size(struct disklabel *lp, int partno)
2275{
struct partition *pp = &lp->d_partitions[partno];
struct diskchunk *chunks;
u_int64_t maxsize = 0, offset;
int fstype, i;

fstype = pp->p_fstype;
pp->p_fstype = FS_UNUSED0;
chunks = free_chunks(lp);
pp->p_fstype = fstype;

offset = DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
);
for (i = 0; chunks[i].start != 0 || chunks[i].stop != 0; i++) {
if (offset < chunks[i].start || offset >= chunks[i].stop)
	continue;
maxsize = chunks[i].stop - offset;
break;
}
return (maxsize);
2294}

2296void
2297psize(u_int64_t sz, char unit, struct disklabel *lp)
2298{
double d = scale(sz, unit, lp);
if (d < 0)
printf("%llu", sz);
else
printf("%.*f%c", unit == 'B' ? 0 : 1, d, unit);
2304}

2306void
2307display_edit(struct disklabel *lp, char unit)
2308{
u_int64_t fr;
int i;

fr = editor_countfree(lp);
unit = canonical_unit(lp, unit);

printf("OpenBSD area: ");
psize(starting_sector, 0, lp);
printf("-");
psize(ending_sector, 0, lp);
printf("; size: ");
psize(ending_sector - starting_sector, unit, lp);
printf("; free: ");
psize(fr, unit, lp);

printf("\n#    %16.16s %16.16s  fstype [fsize bsize   cpg]\n",
   "size", "offset");
for (i = 0; i < lp->d_npartitions; i++)
display_partition(stdout(&__sF[1]), lp, i, unit);
2328}

2330void
2331parse_autotable(char *filename)
2332{
FILE	*cfile;
size_t	 linesize = 0;
char	*line = NULL((void *)0), *buf, *t;
uint	 idx = 0, pctsum = 0;
struct space_allocation *sa;

if ((cfile = fopen(filename, "r")) == NULL((void *)0))
err(1, "%s", filename);
if ((alloc_table = calloc(1, sizeof(struct alloc_table))) == NULL((void *)0))
err(1, NULL((void *)0));
alloc_table_nitems = 1;

while (getline(&line, &linesize, cfile) != -1) {
if ((alloc_table[0].table = reallocarray(alloc_table[0].table,
    idx + 1, sizeof(*sa))) == NULL((void *)0))
	err(1, NULL((void *)0));
sa = &(alloc_table[0].table[idx]);
memset(sa, 0, sizeof(*sa));
idx++;

buf = line;
if ((sa->mp = get_token(&buf)) == NULL((void *)0) ||
    (sa->mp[0] != '/' && strcmp(sa->mp, "swap")))
	errx(1, "%s: parse error on line %u", filename, idx);
if ((t = get_token(&buf)) == NULL((void *)0) ||
    parse_sizerange(t, &sa->minsz, &sa->maxsz) == -1)
	errx(1, "%s: parse error on line %u", filename, idx);
if ((t = get_token(&buf)) != NULL((void *)0) &&
    parse_pct(t, &sa->rate) == -1)
	errx(1, "%s: parse error on line %u", filename, idx);
if (sa->minsz > sa->maxsz)
	errx(1, "%s: min size > max size on line %u", filename,
	    idx);
pctsum += sa->rate;
}
if (pctsum > 100)
errx(1, "%s: sum of extra space allocation > 100%%", filename);
alloc_table[0].sz = idx;
free(line);
fclose(cfile);
2373}

2375char *
2376get_token(char **s)
2377{
char	*p, *r;
size_t	 tlen = 0;

p = *s;
while (**s != '\0' && !isspace((u_char)**s)) {
(*s)++;
tlen++;
}
if (tlen == 0)
return (NULL((void *)0));

/* eat whitespace */
while (isspace((u_char)**s))
(*s)++;

if ((r = strndup(p, tlen)) == NULL((void *)0))
err(1, NULL((void *)0));
return (r);
2396}

2398int
2399apply_unit(double val, u_char unit, u_int64_t *n)
2400{
u_int64_t factor = 1;

switch (tolower(unit)) {
case 't':
factor *= 1024;
/* FALLTHROUGH */
case 'g':
factor *= 1024;
/* FALLTHROUGH */
case 'm':
factor *= 1024;
/* FALLTHROUGH */
case 'k':
factor *= 1024;
break;
default:
return (-1);
}

val *= factor / DEV_BSIZE(1 << 9);
if (val > ULLONG_MAX(9223372036854775807LL*2ULL+1ULL))
return (-1);
*n = val;
return (0);
2425}

2427int
2428parse_sizespec(const char *buf, double *val, char **unit)
2429{
errno(*__errno()) = 0;
*val = strtod(buf, unit);
if (errno(*__errno()) == ERANGE34 || *val < 0 || *val > ULLONG_MAX(9223372036854775807LL*2ULL+1ULL))
return (-1);	/* too big/small */
if (*val == 0 && *unit == buf)
return (-1);	/* No conversion performed. */
if (*unit != NULL((void *)0) && *unit[0] == '\0')
*unit = NULL((void *)0);
return (0);
2439}

2441int
2442parse_sizerange(char *buf, u_int64_t *min, u_int64_t *max)
2443{
char	*p, *unit1 = NULL((void *)0), *unit2 = NULL((void *)0);
double	 val1 = 0, val2 = 0;

if ((p = strchr(buf, '-')) != NULL((void *)0)) {
p[0] = '\0';
p++;
}
*max = 0;
if (parse_sizespec(buf, &val1, &unit1) == -1)
return (-1);
if (p != NULL((void *)0) && p[0] != '\0') {
if (p[0] == '*')
	*max = -1;
else
	if (parse_sizespec(p, &val2, &unit2) == -1)
		return (-1);
}
if (unit1 == NULL((void *)0) && (unit1 = unit2) == NULL((void *)0))
return (-1);
if (apply_unit(val1, unit1[0], min) == -1)
return (-1);
if (val2 > 0) {
if (apply_unit(val2, unit2[0], max) == -1)
	return (-1);
} else
if (*max == 0)
	*max = *min;
free(buf);
return (0);
2473}

2475int
2476parse_pct(char *buf, int *n)
2477{
const char	*errstr;

if (buf[strlen(buf) - 1] == '%')
buf[strlen(buf) - 1] = '\0';
*n = strtonum(buf, 0, 100, &errstr);
if (errstr) {
warnx("parse percent %s: %s", buf, errstr);
return (-1);
}
free(buf);
return (0);
2489}

2491int
2492alignpartition(struct disklabel *lp, int partno, u_int64_t startalign,
  u_int64_t stopalign, int flags)
2494{
struct partition *pp = &lp->d_partitions[partno];
struct diskchunk *chunks;
u_int64_t start, stop, maxstop;
unsigned int i;
u_int8_t fstype;

start = DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
);
if ((flags & ROUND_OFFSET_UP0x00000001) == ROUND_OFFSET_UP0x00000001)
86
←
Taking true branch→
start = ((start + startalign - 1) / startalign) * startalign;
87
←
Division by zero
else if ((flags & ROUND_OFFSET_DOWN0x00000002) == ROUND_OFFSET_DOWN0x00000002)
start = (start / startalign) * startalign;

/* Find the chunk that contains 'start'. */
fstype = pp->p_fstype;
pp->p_fstype = FS_UNUSED0;
chunks = free_chunks(lp);
pp->p_fstype = fstype;
for (i = 0; chunks[i].start != 0 || chunks[i].stop != 0; i++) {
if (start >= chunks[i].start && start < chunks[i].stop)
	break;
}
if (chunks[i].stop == 0) {
fprintf(stderr(&__sF[2]), "'%c' aligned offset %llu lies outside "
    "the OpenBSD bounds or inside another partition\n",
    'a' + partno, start);
return (1);
}

/* Calculate the new 'stop' sector, the sector after the partition. */
if ((flags & ROUND_SIZE_OVERLAP0x00000010) == 0)
maxstop = (chunks[i].stop / stopalign) * stopalign;
else
maxstop = (ending_sector / stopalign) * stopalign;

stop = DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
) + DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size);
if ((flags & ROUND_SIZE_UP0x00000004) == ROUND_SIZE_UP0x00000004)
stop = ((stop + stopalign - 1) / stopalign) * stopalign;
else if ((flags & ROUND_SIZE_DOWN0x00000008) == ROUND_SIZE_DOWN0x00000008)
stop = (stop / stopalign) * stopalign;
if (stop > maxstop)
stop = maxstop;

if (stop <= start) {
fprintf(stderr(&__sF[2]), "not enough space\n");
return (1);
}

if (start != DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
))
DL_SETPOFFSET(pp, start)do { u_int64_t __x = (start); (pp)->p_offseth = __x >>
 32; (pp)->p_offset = __x; } while (0);
if (stop != DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
) + DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size))
DL_SETPSIZE(pp, stop - start)do { u_int64_t __x = (stop - start); (pp)->p_sizeh = __x >>
 32; (pp)->p_size = __x; } while (0);

return (0);
2548}