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

Bug Summary

File:	src/sbin/disklabel/editor.c
Warning:	line 2005, column 24 Array access (from variable 'unit2') results in a null pointer dereference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name editor.c -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 -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -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/llvm16/lib/clang/16 -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/disklabel/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -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/scan/2024-01-11-140451-98009-1 -x c /usr/src/sbin/disklabel/editor.c
1/*	$OpenBSD: editor.c,v 1.417 2023/09/06 12:45:19 robert 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	ROUNDUP(_s, _a)((((_s) + (_a) - 1) / (_a)) * (_a))		((((_s) + (_a) - 1) / (_a)) * (_a))
46#define	ROUNDDOWN(_s, _a)(((_s) / (_a)) * (_a))	(((_s) / (_a)) * (_a))
47#define	CHUNKSZ(_c)((_c)->stop - (_c)->start)		((_c)->stop - (_c)->start)

49/* flags for getuint64() */
50#define	DO_CONVERSIONS0x00000001	0x00000001
51#define	DO_ROUNDING0x00000002	0x00000002

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

60/* Special return values for getnumber and getuint64() */
61#define	CMD_ABORTED(0xffffffffffffffffULL - 1)	(ULLONG_MAX0xffffffffffffffffULL - 1)
62#define	CMD_BADVALUE(0xffffffffffffffffULL)	(ULLONG_MAX0xffffffffffffffffULL)

64/* structure to describe a portion of a disk */
65struct diskchunk {
u_int64_t start;
u_int64_t stop;
68};

70/* used when sorting mountpoints in mpsave() */
71struct mountinfo {
char *mountpoint;
int partno;
74};

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

78struct 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;
83};

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

91/* entries for swap and var are changed by editor_allocspace() */
92struct 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(30)(((30) * 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 */
104};

106struct 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"	}
111};

113struct 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"	}
116};

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

122#ifndef nitems
123#define nitems(_a)(sizeof((_a)) / sizeof((_a)[0]))	(sizeof((_a)) / sizeof((_a)[0]))
124#endif

126struct alloc_table {
struct space_allocation *table;
int sz;
129};

131struct 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])) }
136};
137struct alloc_table *alloc_table = alloc_table_default;
138int alloc_table_nitems = 4;

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

184static u_int64_t starting_sector;
185static u_int64_t ending_sector;
186static int resizeok;

188/*
* Simple partition editor.
*/
191int
192editor(int f)
193{
struct disklabel origlabel, lastlabel, tmplabel, newlab = lab;
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 *))) ||
   !(origmountpoints = calloc(MAXPARTITIONS16, sizeof(char *))) ||
   !(tmpmountpoints = calloc(MAXPARTITIONS16, sizeof(char *))))
err(1, NULL((void *)0));

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

/* Make sure there is no partition overlap. */
if (has_overlap(&newlab))
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_npartitions <= RAW_PART2 || 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_npartitions <= RAW_PART2)
	newlab.d_npartitions = RAW_PART2 + 1;
DL_SETPOFFSET(pp, 0)do { u_int64_t __x = (0); (pp)->p_offseth = __x >> 32
; (pp)->p_offset = __x; } while (0);
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);
pp->p_fstype = FS_UNUSED0;
pp->p_fragblock = pp->p_cpg = 0;
}

227#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.");
}
234#endif

/* 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 (;;) {
fprintf(stdout(&__sF[1]), "%s%s> ", dkname,
    (memcmp(&lab, &newlab, sizeof(newlab)) == 0) ? "" : "*");
if (fgets(buf, sizeof(buf), stdin(&__sF[0])) == NULL((void *)0)) {
	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))
	continue;
arg = strtok(NULL((void *)0), " \t\r\n");

if ((*cmd != 'u') && (*cmd != 'U')) {
	/*
	 * 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) {
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;
		aflag = 1;
		quiet = 0;
		editor_allocspace(&newlab);
		quiet = oquiet;
	}
	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_packname(&newlab);
	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 && resizeok)
		editor_resize(&newlab, arg);
	else
		fputs("Resize only implemented for auto "
		    "allocated labels\n", stderr(&__sF[2]));
	break;

case 'r': {
	const struct diskchunk *chunk;
	uint64_t total = 0;
	/* Display free space. */
	chunk = free_chunks(&newlab, -1);
	for (; chunk->start != 0 || chunk->stop != 0; chunk++) {
		total += CHUNKSZ(chunk)((chunk)->stop - (chunk)->start);
		fprintf(stderr(&__sF[2]), "Free sectors: %16llu - %16llu "
		    "(%16llu)\n",
		    chunk->start, chunk->stop - 1,
		    CHUNKSZ(chunk)((chunk)->stop - (chunk)->start));
	}
	fprintf(stderr(&__sF[2]), "Total free sectors: %llu.\n", total);
	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':
	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);
}
}
508done:
mpfree(omountpoints, DISCARD0);
mpfree(origmountpoints, DISCARD0);
mpfree(tmpmountpoints, DISCARD0);
return error;
513}

515/*
* Allocate all disk space according to standard recommendations for a
* root disk.
*/
519int
520editor_allocspace(struct disklabel *lp_org)
521{
struct disklabel label;
struct partition *pp;
u_int64_t pstart, pend;
int i;

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

resizeok = 1;
for (i = 0;  i < MAXPARTITIONS16; i++) {
if (i == RAW_PART2)
	continue;
pp = &lp_org->d_partitions[i];
if (DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0 || pp->p_fstype == FS_UNUSED0)
	continue;
pstart = DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
);
pend = pstart + DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size);
if (((pstart >= starting_sector && pstart < ending_sector) ||
    (pend > starting_sector && pend <= ending_sector)))
	resizeok = 0; /* Part of OBSD area is in use! */
}

for (i = 0; i < alloc_table_nitems; i++) {
memcpy(&label, lp_org, sizeof(label));
if (allocate_space(&label, &alloc_table[i]) == 0) {
	memcpy(lp_org, &label, sizeof(struct disklabel));
	return 0;
}
}

return 1;
553}

555const struct diskchunk *
556allocate_diskchunk(const struct disklabel *lp,
  const struct space_allocation *sa)
558{
const struct diskchunk *chunk;
static struct diskchunk largest;
uint64_t maxstop;

largest.start = largest.stop = 0;

chunk = free_chunks(lp, -1);
for (; chunk->start != 0 || chunk->stop != 0; chunk++) {
if (CHUNKSZ(chunk)((chunk)->stop - (chunk)->start) > CHUNKSZ(&largest)((&largest)->stop - (&largest)->start))
	largest = *chunk;
}
maxstop = largest.start + DL_BLKTOSEC(lp, sa->maxsz)((sa->maxsz) / ((lp)->d_secsize / (1 << 9)));
if (maxstop > largest.stop)
maxstop = largest.stop;
573#ifdef SUN_CYLCHECK
if (lp->d_flags & D_VENDOR0x08) {
largest.start = ROUNDUP(largest.start, lp->d_secpercyl)((((largest.start) + (lp->d_secpercyl) - 1) / (lp->d_secpercyl
)) * (lp->d_secpercyl));
maxstop = ROUNDUP(maxstop, lp->d_secpercyl)((((maxstop) + (lp->d_secpercyl) - 1) / (lp->d_secpercyl
)) * (lp->d_secpercyl));
if (maxstop > largest.stop)
	maxstop -= lp->d_secpercyl;
if (largest.start >= maxstop)
	largest.start = largest.stop = maxstop = 0;
}
582#endif
if (maxstop < largest.stop)
largest.stop = maxstop;
if (CHUNKSZ(&largest)((&largest)->stop - (&largest)->start) < DL_BLKTOSEC(lp, sa->minsz)((sa->minsz) / ((lp)->d_secsize / (1 << 9))))
return NULL((void *)0);

return &largest;
589}

591int
592allocate_partition(struct disklabel *lp, struct space_allocation *sa)
593{
const struct diskchunk *chunk;
struct partition *pp;
unsigned int partno;

for (partno = 0; partno < nitems(lp->d_partitions)(sizeof((lp->d_partitions)) / sizeof((lp->d_partitions)
[0])); partno++) {
if (partno == RAW_PART2)
	continue;
pp = &lp->d_partitions[partno];
if (DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0 || pp->p_fstype == FS_UNUSED0)
	break;
}
if (partno >= nitems(lp->d_partitions)(sizeof((lp->d_partitions)) / sizeof((lp->d_partitions)
[0])))
return 1;		/* No free partition. */

/* Find appropriate chunk of free space. */
chunk = allocate_diskchunk(lp, sa);
if (chunk == NULL((void *)0))
return 1;

if (strcasecmp(sa->mp, "raid") == 0)
pp->p_fstype = FS_RAID19;
else if (strcasecmp(sa->mp, "swap") == 0)
pp->p_fstype = FS_SWAP1;
else if (sa->mp[0] == '/')
pp->p_fstype = FS_BSDFFS7;
else
return 1;

DL_SETPSIZE(pp, chunk->stop - chunk->start)do { u_int64_t __x = (chunk->stop - chunk->start); (pp)
->p_sizeh = __x >> 32; (pp)->p_size = __x; } while
 (0);
DL_SETPOFFSET(pp, chunk->start)do { u_int64_t __x = (chunk->start); (pp)->p_offseth = __x
 >> 32; (pp)->p_offset = __x; } while (0);

if (pp->p_fstype == FS_BSDFFS7 && DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) > 0) {
mountpoints[partno] = strdup(sa->mp);
if (mountpoints[partno] == NULL((void *)0))
	err(1, NULL((void *)0));
if (set_fragblock(lp, partno))
	return 1;
}

return 0;
634}

636void
637allocate_physmemincr(struct space_allocation *sa)
638{
u_int64_t memblks;
extern int64_t physmem;

if (physmem == 0)
return;

memblks = physmem / DEV_BSIZE(1 << 9);
if (strcasecmp(sa->mp, "swap") == 0) {
if (memblks < MEG(256)((256) * 1024LL * (1024 / (1 << 9))))
	sa->minsz = sa->maxsz = 2 * memblks;
else
	sa->maxsz += memblks;
} else if (strcasecmp(sa->mp, "/var") == 0) {
sa->maxsz += 2 * memblks;
}
654}

656int
657allocate_space(struct disklabel *lp, const struct alloc_table *alloc_table)
658{
struct space_allocation sa[MAXPARTITIONS16];
u_int64_t maxsz, xtrablks;
int i;

xtrablks = DL_SECTOBLK(lp, editor_countfree(lp))((editor_countfree(lp)) * ((lp)->d_secsize / (1 << 9
)));
memset(sa, 0, sizeof(sa));
for (i = 0; i < alloc_table->sz; i++) {
sa[i] = alloc_table->table[i];
if (alloc_table->table == alloc_big)
	allocate_physmemincr(&sa[i]);
if (xtrablks < sa[i].minsz)
	return 1;	/* Too few free blocks. */
xtrablks -= sa[i].minsz;
}
sa[alloc_table->sz - 1].rate = 100; /* Last allocation is greedy. */

for (i = lp->d_npartitions; i < MAXPARTITIONS16; i++) {
if (i == RAW_PART2)
	continue;
memset(&lp->d_partitions[i], 0, sizeof(lp->d_partitions[i]));
}
lp->d_npartitions = MAXPARTITIONS16;

mpfree(mountpoints, KEEP1);
for (i = 0; i < alloc_table->sz; i++) {
if (sa[i].rate == 100)
	maxsz = sa[i].minsz + xtrablks;
else
	maxsz = sa[i].minsz + (xtrablks / 100) * sa[i].rate;
if (maxsz < sa[i].maxsz)
	sa[i].maxsz = maxsz;
if (allocate_partition(lp, &sa[i])) {
	mpfree(mountpoints, KEEP1);
	return 1;
}
}

return 0;
697}

699/*
* Resize a partition, moving all subsequent partitions
*/
702void
703editor_resize(struct disklabel *lp, const char *p)
704{
struct disklabel label;
struct partition *pp, *prev;
u_int64_t ui, sz, off;
int partno, i, flags, shrunk;

label = *lp;

if ((partno = getpartno(&label, p, "resize")) == -1)
return;

pp = &label.d_partitions[partno];
sz = DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size);
if (pp->p_fstype != FS_BSDFFS7 && pp->p_fstype != FS_SWAP1) {
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(0xffffffffffffffffULL - 1))
return;
else if (ui == CMD_BADVALUE(0xffffffffffffffffULL))
return;
else if (ui == 0) {
fputs("The size must be > 0 sectors\n", stderr(&__sF[2]));
return;
}

735#ifdef SUN_CYLCHECK
if (lp->d_flags & D_VENDOR0x08)
ui = ROUNDUP(ui, lp->d_secpercyl)((((ui) + (lp->d_secpercyl) - 1) / (lp->d_secpercyl)) *
 (lp->d_secpercyl));
738#endif
if (DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
) + ui > ending_sector) {
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);
pp->p_fragblock = 0;
if (set_fragblock(&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 = 0;
		if (set_fragblock(&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;
788}

790/*
* Add a new partition.
*/
793void
794editor_add(struct disklabel *lp, const char *p)
795{
struct partition *pp;
const struct diskchunk *chunk;
int partno;
u_int64_t new_offset, new_size;

chunk = free_chunks(lp, -1);
new_size = new_offset = 0;
for (; chunk->start != 0 || chunk->stop != 0; chunk++) {
if (CHUNKSZ(chunk)((chunk)->stop - (chunk)->start) > new_size) {
	new_size = CHUNKSZ(chunk)((chunk)->stop - (chunk)->start);
	new_offset = chunk->start;
}
}

810#ifdef SUN_CYLCHECK
if ((lp->d_flags & D_VENDOR0x08) && new_size < lp->d_secpercyl) {
fputs("No space left, you need to shrink a partition "
    "(need at least one full cylinder)\n",
    stderr(&__sF[2]));
return;
}
817#endif
if (new_size == 0) {
fputs("No space left, you need to shrink a partition\n",
    stderr(&__sF[2]));
return;
}

if ((partno = getpartno(lp, p, "add")) == -1)
return;
pp = &lp->d_partitions[partno];
memset(pp, 0, sizeof(*pp));

/*
* 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));

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 &&
   set_fragblock(lp, partno) == 0)
return;

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

851/*
* Set the mountpoint of an existing partition ('name').
*/
854void
855editor_name(const struct disklabel *lp, const char *p)
856{
int partno;

if ((partno = getpartno(lp, p, "name")) == -1)
return;

get_mp(lp, partno);
863}

865/*
* Change an existing partition.
*/
868void
869editor_modify(struct disklabel *lp, const char *p)
870{
struct partition opp, *pp;
int partno;

if ((partno = getpartno(lp, p, "modify")) == -1)
return;

pp = &lp->d_partitions[partno];
opp = *pp;

if (get_offset(lp, partno) == 0 &&
   get_size(lp, partno) == 0   &&
   get_fstype(lp, partno) == 0 &&
   get_mp(lp, partno) == 0 &&
   set_fragblock(lp, partno) == 0)
return;

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

891/*
* Delete an existing partition.
*/
894void
895editor_delete(struct disklabel *lp, const char *p)
896{
struct partition *pp;
int partno;

if ((partno = getpartno(lp, p, "delete")) == -1)
return;
if (partno == lp->d_npartitions) {
zero_partitions(lp);
return;
}
pp = &lp->d_partitions[partno];

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

914/*
* Change the size of an existing partition.
*/
917void
918editor_change(struct disklabel *lp, const char *p)
919{
struct partition *pp;
int partno;

if ((partno = getpartno(lp, p, "change size")) == -1)
return;

pp = &lp->d_partitions[partno];
printf("Partition %c is currently %llu sectors in size, and can have "
   "a maximum\nsize of %llu sectors.\n",
   'a' + partno, 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);
933}

935/*
* Sort the partitions based on starting offset.
* This assumes there can be no overlap.
*/
939int
940partition_cmp(const void *e1, const void *e2)
941{
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;
953}

955char *
956getstring(const char *prompt, const char *helpstring, const char *oval)
957{
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];
983}

985int
986getpartno(const struct disklabel *lp, const char *p, const char *action)
987{
char buf[2] = { '\0', '\0'};
const char *promptfmt = "partition to %s";
const char *helpfmt = "Partition must be between 'a' and '%c' "
   "(excluding 'c')%s.\n";
const struct partition *pp;
char *help = NULL((void *)0), *prompt = NULL((void *)0);
unsigned char maxpart;
unsigned int partno;
int add, delete, inuse;

add = strcmp("add", action) == 0;
delete = strcmp("delete", action) == 0;
maxpart = 'a' - 1 + (add ? MAXPARTITIONS16 : lp->d_npartitions);

if (p == NULL((void *)0)) {
if (asprintf(&prompt, promptfmt, action) == -1 ||
    asprintf(&help, helpfmt, maxpart, delete ? ", or '*'" : "")
    == -1) {
	fprintf(stderr(&__sF[2]), "Unable to build prompt or help\n");
	goto done;
}
if (add) {
	/* Default to first unused partition. */
	for (partno = 0; partno < MAXPARTITIONS16; partno++) {
		if (partno == RAW_PART2)
			continue;
		pp = &lp->d_partitions[partno];
		if (partno >= lp->d_npartitions ||
		    DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0 ||
		    pp->p_fstype == FS_UNUSED0) {
			buf[0] = 'a' + partno;
			p = buf;
			break;
		}
	}
}
p = getstring(prompt, help, p);
free(prompt);
free(help);
if (p == NULL((void *)0) || *p == '\0')
	goto done;
}

if (delete && strlen(p) == 1 && *p == '*')
return lp->d_npartitions;

if (strlen(p) > 1 || *p < 'a' || *p > maxpart || *p == 'c') {
fprintf(stderr(&__sF[2]), helpfmt, maxpart, delete ? ", or '*'" : "");
goto done;
}

partno = *p - 'a';
pp = &lp->d_partitions[partno];
inuse = partno < lp->d_npartitions && DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) > 0 &&
   pp->p_fstype != FS_UNUSED0;

if ((add && !inuse) || (!add && inuse))
return partno;

fprintf(stderr(&__sF[2]), "Partition '%c' is %sin use.\n", *p,
   inuse ? "" : "not ");

done:
return -1;
1052}

1054/*
* Returns
* 0 .. CMD_ABORTED - 1	==> valid value
* CMD_BADVALUE		==> invalid value
* CMD_ABORTED		==> ^D on input
*/
1060u_int64_t
1061getnumber(const char *prompt, const char *helpstring, u_int32_t oval,
  u_int32_t maxval)
1063{
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(0xffffffffffffffffULL);

p = getstring(prompt, helpstring, buf);
if (p == NULL((void *)0))
return CMD_ABORTED(0xffffffffffffffffULL - 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(0xffffffffffffffffULL);
}

return rval;
1086}

1088/*
* Returns
* 0 .. CMD_ABORTED - 1	==> valid value
* CMD_BADVALUE		==> invalid value
* CMD_ABORTED		==> ^D on input
*/
1094u_int64_t
1095getuint64(const struct disklabel *lp, char *prompt, char *helpstring,
  u_int64_t oval, u_int64_t maxval, int *flags)
1097{
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(0xffffffffffffffffULL - 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(0xffffffffffffffffULL - 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;
1165#ifdef SUN_CYLCHECK
if (lp->d_flags & D_VENDOR0x08)
	*flags |= DO_ROUNDING0x00000002;
1168#endif
}
return rval;

1172invalid:
fputs("Invalid entry\n", stderr(&__sF[2]));
return CMD_BADVALUE(0xffffffffffffffffULL);
1175}

1177/*
* 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.
*/
1181int
1182has_overlap(struct disklabel *lp)
1183{
const struct partition **spp;
int i, p1, p2;
char *line = NULL((void *)0);
size_t linesize = 0;
ssize_t linelen;

for (;;) {
spp = sort_partitions(lp, -1);
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;
}

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

1227void
1228edit_packname(struct disklabel *lp)
1229{
char *p;
struct disklabel oldlabel = *lp;

printf("Changing label description for %s:\n", specname);

/* 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 */
1244}

1246const struct partition **
1247sort_partitions(const struct disklabel *lp, int ignore)
1248{
const 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 (i != ignore && 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;
1270}

1272/*
* Get beginning and ending sectors of the OpenBSD portion of the disk
* from the user.
*/
1276void
1277set_bounds(struct disklabel *lp)
1278{
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(0xffffffffffffffffULL - 1))
	return;
else if (ui == CMD_BADVALUE(0xffffffffffffffffULL))
	;	/* 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(0xffffffffffffffffULL - 1))
	return;
else if (ui == CMD_BADVALUE(0xffffffffffffffffULL))
	;	/* 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);
1318}

1320/*
* Allow user to interactively change disklabel UID.
*/
1323void
1324set_duid(struct disklabel *lp)
1325{
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);
1345}

1347/*
* Return a list of the "chunks" of free space available
*/
1350const struct diskchunk *
1351free_chunks(const struct disklabel *lp, int partno)
1352{
const 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, partno);

/* 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;
1400}

1402void
1403find_bounds(const struct disklabel *lp)
1404{
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);
}
1415}

1417/*
* Calculate free space.
*/
1420u_int64_t
1421editor_countfree(const struct disklabel *lp)
1422{
const struct diskchunk *chunk;
u_int64_t freesectors = 0;

chunk = free_chunks(lp, -1);

for (; chunk->start != 0 || chunk->stop != 0; chunk++)
freesectors += CHUNKSZ(chunk)((chunk)->stop - (chunk)->start);

return freesectors;
1432}

1434void
1435editor_help(void)
1436{
puts("Available commands:");
puts(
1439" ? | h    - show help                 n [part] - set mount point\n"
1440" A        - auto partition all space  p [unit] - print partitions\n"
1441" a [part] - add partition             q        - quit & save changes\n"
1442" b        - set OpenBSD boundaries    R [part] - resize auto allocated partition\n"
1443" c [part] - change partition size     r        - display free space\n"
1444" D        - reset label to default    s [path] - save label to file\n"
1445" d [part] - delete partition          U        - undo all changes\n"
1446" e        - edit label description    u        - undo last change\n"
1447" i        - modify disklabel UID      w        - write label to disk\n"
1448" l [unit] - print disk label header   x        - exit & lose changes\n"
1449" M        - disklabel(8) man page     z        - delete all partitions\n"
1450" m [part] - modify partition\n"
1451"\n"
1452"Suffixes can be used to indicate units other than sectors:\n"
1453" 'b' (bytes), 'k' (kilobytes), 'm' (megabytes), 'g' (gigabytes) 't' (terabytes)\n"
1454" 'c' (cylinders), '%' (% of total disk), '&' (% of free space).\n"
1455"Values in non-sector units are truncated to the nearest cylinder boundary.");

1457}

1459void
1460mpcopy(char **to, char **from)
1461{
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))
		err(1, NULL((void *)0));
}
}
1473}

1475int
1476mpequal(char **mp1, char **mp2)
1477{
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;
1490}

1492void
1493mpsave(const struct disklabel *lp)
1494{
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_RAID19)
		continue;
	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);
}
1553}

1555void
1556mpfree(char **mp, int action)
1557{
int part;

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

for (part = 0; part < MAXPARTITIONS16; part++) {
free(mp[part]);
mp[part] = NULL((void *)0);
}

if (action == DISCARD0) {
free(mp);
mp = NULL((void *)0);
}
1572}

1574int
1575get_offset(struct disklabel *lp, int partno)
1576{
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(0xffffffffffffffffULL - 1) || ui == CMD_BADVALUE(0xffffffffffffffffULL))
return 1;
1589#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;
}
1595#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;
}

return 0;
1608}

1610int
1611get_size(struct disklabel *lp, int partno)
1612{
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(0xffffffffffffffffULL - 1) || ui == CMD_BADVALUE(0xffffffffffffffffULL))
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;
}

return 0;
1639}

1641int
1642set_fragblock(struct disklabel *lp, int partno)
1643{
struct partition opp, *pp = &lp->d_partitions[partno];
u_int64_t bytes, offsetalign, sizealign;
u_int32_t frag, fsize;

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

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

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))));
}
1670#ifdef SUN_CYLCHECK
return 0;
1672#endif
opp = *pp;
sizealign = (DISKLABELV1_FFS_FRAG(pp->p_fragblock)((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) & 0x07) - 1))) *
   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;
offsetalign = 1;
if (DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
) != starting_sector)
offsetalign = sizealign;

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

return 0;
1687}

1689int
1690get_fstype(struct disklabel *lp, int partno)
1691{
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(0xffffffffffffffffULL - 1))
		return 1;
	else if (ui == CMD_BADVALUE(0xffffffffffffffffULL))
		;	/* Try again. */
	else
		break;
}
pp->p_fstype = ui;
}
return 0;
1730}

1732int
1733get_mp(const struct disklabel *lp, int partno)
1734{
const 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))
		err(1, NULL((void *)0));
	break;
}
fputs("Mount points must start with '/'\n", stderr(&__sF[2]));
}

return 0;
1780}

1782int
1783micmp(const void *a1, const void *a2)
1784{
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);
1797}

1799void
1800zero_partitions(struct disklabel *lp)
1801{
memset(lp->d_partitions, 0, sizeof(lp->d_partitions));
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);

mpfree(mountpoints, KEEP1);
1806}

1808u_int64_t
1809max_partition_size(const struct disklabel *lp, int partno)
1810{
const struct diskchunk *chunk;
u_int64_t maxsize = 0, offset;

chunk = free_chunks(lp, partno);

offset = DL_GETPOFFSET(&lp->d_partitions[partno])(((u_int64_t)(&lp->d_partitions[partno])->p_offseth
 << 32) + (&lp->d_partitions[partno])->p_offset
);
for (; chunk->start != 0 || chunk->stop != 0; chunk++) {
if (offset < chunk->start || offset >= chunk->stop)
	continue;
maxsize = chunk->stop - offset;
break;
}
return maxsize;
1824}

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

1836void
1837display_edit(const struct disklabel *lp, char unit)
1838{
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);
1858}

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

if (strcmp(filename, "-") == 0)
1
Assuming the condition is false→
2
←
Taking false branch→
cfile = stdin(&__sF[0]);
else if ((cfile = fopen(filename, "r")) == NULL((void *)0))
3
←
Assuming the condition is false→
4
←
Taking false branch→
err(1, "%s", filename);
if ((alloc_table = calloc(1, sizeof(struct alloc_table))) == NULL((void *)0))
5
←
Assuming the condition is false→
6
←
Taking false branch→
err(1, NULL((void *)0));
alloc_table_nitems = 1;

while (getline(&line, &linesize, cfile) != -1) {
7
←
Assuming the condition is true→
8
←
Loop condition is true.  Entering loop body→
if ((alloc_table[0].table = reallocarray(alloc_table[0].table,
9
←
Assuming the condition is false→
10
←
Taking false branch→
    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] != '/' && strcasecmp(sa->mp, "swap") &&
11
←
Assuming the condition is true→
    strcasecmp(sa->mp, "raid")))
	errx(1, "%s: parse error on line %u", filename, idx);
if ((t = get_token(&buf)) == NULL((void *)0) ||
12
←
Assuming the condition is false→
    parse_sizerange(t, &sa->minsz, &sa->maxsz) == -1)
13
←
Calling 'parse_sizerange'→
	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);
1906}

1908char *
1909get_token(char **s)
1910{
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;
1929}

1931int
1932apply_unit(double val, u_char unit, u_int64_t *n)
1933{
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 > (double)ULLONG_MAX0xffffffffffffffffULL)
return -1;
*n = val;
return 0;
1958}

1960int
1961parse_sizespec(const char *buf, double *val, char **unit)
1962{
errno(*__errno()) = 0;
*val = strtod(buf, unit);
if (errno(*__errno()) == ERANGE34 || *val < 0 || *val > (double)ULLONG_MAX0xffffffffffffffffULL)
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;
1972}

1974int
1975parse_sizerange(char *buf, u_int64_t *min, u_int64_t *max)
1976{
char	*p, *unit1 = NULL((void *)0), *unit2 = NULL((void *)0);
14
←
'unit2' initialized to a null pointer value→
double	 val1 = 0, val2 = 0;

if (strcmp(buf, "*") == 0) {
15
←
Assuming the condition is false→
16
←
Taking false branch→
*min = 0;
*max = UINT64_MAX0xffffffffffffffffULL;
goto done;
}

if ((p = strchr(buf, '-')) != NULL((void *)0)) {
17
←
Assuming the condition is false→
18
←
Taking false branch→
p[0] = '\0';
p++;
}
*max = 0;
if (parse_sizespec(buf, &val1, &unit1) == -1)
return -1;
if (p18.1
'p' is equal to NULL
 != NULL((void *)0) && p[0] != '\0') {
if (p[0] == '*')
	*max = UINT64_MAX0xffffffffffffffffULL;
else
	if (parse_sizespec(p, &val2, &unit2) == -1)
		return -1;
}
if (unit118.2
'unit1' is not equal to NULL
 == NULL((void *)0) && (unit1 = unit2) == NULL((void *)0))
return -1;
if (apply_unit(val1, unit1[0], min) == -1)
19
←
Taking false branch→
return -1;
if (val2 > 0) {
20
←
Assuming 'val2' is > 0→
21
←
Taking true branch→
if (apply_unit(val2, unit2[0], max) == -1)
22
←
Array access (from variable 'unit2') results in a null pointer dereference
	return -1;
} else
if (*max == 0)
	*max = *min;
done:
free(buf);
return 0;
2013}

2015int
2016parse_pct(char *buf, int *n)
2017{
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;
2029}

2031int
2032alignpartition(struct disklabel *lp, int partno, u_int64_t startalign,
  u_int64_t stopalign, int flags)
2034{
struct partition *pp = &lp->d_partitions[partno];
const struct diskchunk *chunk;
u_int64_t start, stop, maxstop;

start = DL_GETPOFFSET(pp)(((u_int64_t)(pp)->p_offseth << 32) + (pp)->p_offset
);
if ((flags & ROUND_OFFSET_UP0x00000001) == ROUND_OFFSET_UP0x00000001)
start = ROUNDUP(start, startalign)((((start) + (startalign) - 1) / (startalign)) * (startalign)
);
else if ((flags & ROUND_OFFSET_DOWN0x00000002) == ROUND_OFFSET_DOWN0x00000002)
start = ROUNDDOWN(start, startalign)(((start) / (startalign)) * (startalign));

/* Find the chunk that contains 'start'. */
chunk = free_chunks(lp, partno);
for (; chunk->start != 0 || chunk->stop != 0; chunk++) {
if (start >= chunk->start && start < chunk->stop)
	break;
}
if (chunk->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 = ROUNDDOWN(chunk->stop, stopalign)(((chunk->stop) / (stopalign)) * (stopalign));
else
maxstop = ROUNDDOWN(ending_sector, stopalign)(((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 = ROUNDUP(stop, stopalign)((((stop) + (stopalign) - 1) / (stopalign)) * (stopalign));
else if ((flags & ROUND_SIZE_DOWN0x00000008) == ROUND_SIZE_DOWN0x00000008)
stop = ROUNDDOWN(stop, stopalign)(((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;
2083}