/usr/src/sbin/newfs/newfs.c

Bug Summary

File:	src/sbin/newfs/newfs.c
Warning:	line 460, column 11 Access to field 'p_sizeh' results in a dereference of a null pointer (loaded from variable 'pp')

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 newfs.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/newfs/obj -resource-dir /usr/local/lib/clang/13.0.0 -D MFS -I /usr/src/sbin/newfs/../mount -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/newfs/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/newfs/newfs.c

1/*	$OpenBSD: newfs.c,v 1.115 2021/06/03 06:42:03 otto Exp $	*/
2/*	$NetBSD: newfs.c,v 1.20 1996/05/16 07:13:03 thorpej Exp $	*/

4/*
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Marshall
* Kirk McKusick and Network Associates Laboratories, the Security
* Research Division of Network Associates, Inc. under DARPA/SPAWAR
* contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
* research program.
*
* Copyright (c) 1983, 1989, 1993, 1994
*	The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

42#include <sys/param.h>	/* DEV_BSIZE MAXBSIZE */
43#include <sys/types.h>
44#include <sys/stat.h>
45#include <sys/ioctl.h>
46#include <sys/dkio.h>
47#include <sys/disklabel.h>
48#include <sys/mount.h>
49#include <sys/resource.h>
50#include <sys/sysctl.h>
51#include <sys/wait.h>

53#include <ufs/ufs/dinode.h>
54#include <ufs/ufs/dir.h>
55#include <ufs/ffs/fs.h>

57#include <ctype.h>
58#include <err.h>
59#include <errno(*__errno()).h>
60#include <fcntl.h>
61#include <paths.h>
62#include <stdarg.h>
63#include <stdio.h>
64#include <stdlib.h>
65#include <string.h>
66#include <syslog.h>
67#include <unistd.h>
68#include <limits.h>
69#include <signal.h>
70#include <util.h>

72#include "mntopts.h"
73#include "pathnames.h"

75#define MINIMUM(a, b)(((a) < (b)) ? (a) : (b))	(((a) < (b)) ? (a) : (b))
76#define MAXIMUM(a, b)(((a) > (b)) ? (a) : (b))	(((a) > (b)) ? (a) : (b))

78struct mntopt mopts[] = {
MOPT_STDOPTS{ "userquota", 0, 0x02 | 0x04 | 0x10 }, { "groupquota", 0, 0x02
 | 0x04 | 0x10 }, { "ro", 0x00000001, 0x02 }, { "rw", 0x00000001
, 0x01 | 0x02 }, { "net", 0, 0x02 }, { "auto", 0, 0x02 }, { "accesstime"
, 0x00008000, 0x01 | 0x02 }, { "atime", 0x00008000, 0x01 | 0x02
 }, { "dev", 0x00000010, 0x01 | 0x02 }, { "exec", 0x00000004,
 0x01 | 0x02 }, { "suid", 0x00000008, 0x01 | 0x02 }, { "rdonly"
, 0x00000001, 0x02 },
MOPT_WXALLOWED{ "wxallowed", 0x00000800, 0x02 },
MOPT_NOPERM{ "perm", 0x00000020, 0x01 | 0x02 },
MOPT_ASYNC{ "async", 0x00000040, 0x02 },
MOPT_UPDATE{ "update", 0x00010000, 0x02 },
MOPT_FORCE{ "force", 0x00080000, 0x02 },
{ NULL((void *)0) },
86};

88void	fatal(const char *fmt, ...)
   __attribute__((__format__ (printf, 1, 2)))
   __attribute__((__nonnull__ (1)));
91__dead__attribute__((__noreturn__)) void	usage(void);
92void	mkfs(struct partition *, char *, int, int, mode_t, uid_t, gid_t);
93void	getphysmem(void);
94void	rewritelabel(char *, int, struct disklabel *);
95u_short	dkcksum(struct disklabel *);

97/*
* The following two constants set the default block and fragment sizes.
* Both constants must be a power of 2 and meet the following constraints:
*	MINBSIZE <= DESBLKSIZE <= MAXBSIZE
*	sectorsize <= DESFRAGSIZE <= DESBLKSIZE
*	DESBLKSIZE / DESFRAGSIZE <= 8
*/
104#define	DFL_FRAGSIZE2048	2048
105#define	DFL_BLKSIZE16384	16384

107/*
* MAXBLKPG determines the maximum number of data blocks which are
* placed in a single cylinder group. The default is one indirect
* block worth of data blocks.
*/
112#define MAXBLKPG_FFS1(bsize)((bsize) / sizeof(int32_t))	((bsize) / sizeof(int32_t))
113#define MAXBLKPG_FFS2(bsize)((bsize) / sizeof(int64_t))	((bsize) / sizeof(int64_t))

115/*
* Each file system has a number of inodes statically allocated.
* We allocate one inode slot per NFPI fragments, expecting this
* to be far more than we will ever need.
*/
120#define	NFPI4		4

122int	mfs;			/* run as the memory based filesystem */
123int	Nflag;			/* run without writing file system */
124int	Oflag = 2;		/* 0 = 4.3BSD ffs, 1 = 4.4BSD ffs, 2 = ffs2 */
125daddr_t	fssize;			/* file system size in 512-byte blocks */
126long long	sectorsize;		/* bytes/sector */
127int	fsize = 0;		/* fragment size */
128int	bsize = 0;		/* block size */
129int	maxfrgspercg = INT_MAX2147483647;	/* maximum fragments per cylinder group */
130int	minfree = MINFREE5;	/* free space threshold */
131int	opt = DEFAULTOPT0;	/* optimization preference (space or time) */
132int	reqopt = -1;		/* opt preference has not been specified */
133int	density;		/* number of bytes per inode */
134int	maxbpg;			/* maximum blocks per file in a cyl group */
135int	avgfilesize = AVFILESIZ16384;/* expected average file size */
136int	avgfilesperdir = AFPDIR64;/* expected number of files per directory */
137int	mntflags = MNT_ASYNC0x00000040;	/* flags to be passed to mount */
138int	quiet = 0;		/* quiet flag */
139caddr_t	membase;		/* start address of memory based filesystem */
140char	*disktype;
141int	unlabeled;

143extern	char *__progname;
144struct disklabel *getdisklabel(char *, int);

146#ifdef MFS1
147static void waitformount(char *, pid_t);
148static int do_exec(const char *, const char *, char *const[]);
149static int isdir(const char *);
150static void copy(char *, char *);
151static int gettmpmnt(char *, size_t);
152#endif

154int64_t physmem;

156void
157getphysmem(void)
158{
int mib[] = { CTL_HW6, HW_PHYSMEM6419 };
size_t len = sizeof(physmem);

if (sysctl(mib, 2, &physmem, &len, NULL((void *)0), 0) != 0)
err(1, "can't get physmem");
164}

166int
167main(int argc, char *argv[])
168{
int ch;
struct partition *pp;
struct disklabel *lp;
struct disklabel mfsfakelabel;
struct partition oldpartition;
struct stat st;
struct statfs *mp;
struct rlimit rl;
int fsi = -1, oflagset = 0, fso, len, n, maxpartitions;
char *cp = NULL((void *)0), *s1, *s2, *special, *opstring, *realdev;
179#ifdef MFS1
char mountfromname[BUFSIZ1024];
char *pop = NULL((void *)0), node[PATH_MAX1024];
pid_t pid;
struct stat mountpoint;
184#endif
uid_t mfsuid = 0;
gid_t mfsgid = 0;
mode_t mfsmode = 0;
char *fstype = NULL((void *)0);
char **saveargv = argv;
int ffsflag = 1;
const char *errstr;
long long fssize_input = 0;
int fssize_usebytes = 0;
int defaultfsize;
u_int64_t nsecs;

if (strstr(__progname, "mfs"))
1
Assuming the condition is false→
2
←
Taking false branch→
mfs = Nflag = quiet = Oflag = 1;

getphysmem();
maxpartitions = getmaxpartitions();
if (maxpartitions > 26)
3
←
Assuming 'maxpartitions' is <= 26→
4
←
Taking false branch→
fatal("insane maxpartitions value %d", maxpartitions);

opstring = mfs ?
5
←
Assuming 'mfs' is not equal to 0→
6
←
'?' condition is true→
   "P:T:b:c:e:f:i:m:o:s:" :
   "NO:S:T:b:c:e:f:g:h:i:m:o:qs:t:";
while ((ch = getopt(argc, argv, opstring)) != -1) {
7
←
Assuming the condition is false→
8
←
Loop condition is false. Execution continues on line 320→
switch (ch) {
case 'N':
	Nflag = 1;
	break;
case 'O':
	Oflag = strtonum(optarg, 0, 2, &errstr);
	if (errstr)
		fatal("%s: invalid ffs version", optarg);
	oflagset = 1;
	break;
case 'S':
	if (scan_scaled(optarg, &sectorsize) == -1 ||
	    sectorsize <= 0 || (sectorsize % DEV_BSIZE(1 << 9)))
		fatal("sector size invalid: %s", optarg);
	break;
case 'T':
	disktype = optarg;
	break;
case 'b':
	bsize = strtonum(optarg, MINBSIZE4096, MAXBSIZE(64 * 1024), &errstr);
	if (errstr)
		fatal("block size is %s: %s", errstr, optarg);
	break;
case 'c':
	maxfrgspercg = strtonum(optarg, 1, INT_MAX2147483647, &errstr);
	if (errstr)
		fatal("fragments per cylinder group is %s: %s",
		    errstr, optarg);
	break;
case 'e':
	maxbpg = strtonum(optarg, 1, INT_MAX2147483647, &errstr);
	if (errstr)
		fatal("blocks per file in a cylinder group is"
		    " %s: %s", errstr, optarg);
	break;
case 'f':
	fsize = strtonum(optarg, MINBSIZE4096 / MAXFRAG8, MAXBSIZE(64 * 1024),
	    &errstr);
	if (errstr)
		fatal("fragment size is %s: %s",
		    errstr, optarg);
	break;
case 'g':
	avgfilesize = strtonum(optarg, 1, INT_MAX2147483647, &errstr);
	if (errstr)
		fatal("average file size is %s: %s",
		    errstr, optarg);
	break;
case 'h':
	avgfilesperdir = strtonum(optarg, 1, INT_MAX2147483647, &errstr);
	if (errstr)
		fatal("average files per dir is %s: %s",
		    errstr, optarg);
	break;
case 'i':
	density = strtonum(optarg, 1, INT_MAX2147483647, &errstr);
	if (errstr)
		fatal("bytes per inode is %s: %s",
		    errstr, optarg);
	break;
case 'm':
	minfree = strtonum(optarg, 0, 99, &errstr);
	if (errstr)
		fatal("free space %% is %s: %s",
		    errstr, optarg);
	break;
case 'o':
	if (mfs)
		getmntopts(optarg, mopts, &mntflags);
	else {
		if (strcmp(optarg, "space") == 0)
			reqopt = opt = FS_OPTSPACE1;
		else if (strcmp(optarg, "time") == 0)
			reqopt = opt = FS_OPTTIME0;
		else
			fatal("%s: unknown optimization "
			    "preference: use `space' or `time'.",
			    optarg);
	}
	break;
case 'q':
	quiet = 1;
	break;
case 's':
	if (scan_scaled(optarg, &fssize_input) == -1 ||
	    fssize_input <= 0)
		fatal("file system size invalid: %s", optarg);
	fssize_usebytes = 0;    /* in case of multiple -s */
	for (s1 = optarg; *s1 != '\0'; s1++)
		if (isalpha((unsigned char)*s1)) {
			fssize_usebytes = 1;
			break;
		}
	break;
case 't':
	fstype = optarg;
	if (strcmp(fstype, "ffs"))
		ffsflag = 0;
	break;
308#ifdef MFS1
case 'P':
	pop = optarg;
	break;
312#endif
case '?':
default:
	usage();
}
if (!ffsflag)
	break;
}
argc -= optind;
argv += optind;

if (ffsflag8.1
'ffsflag' is 1
 && argc - mfs != 1)
9
←
Assuming the condition is false→
10
←
Taking false branch→
usage();

if (mfs10.1
'mfs' is not equal to 0
) {
11
←
Taking true branch→
/* Increase our data size to the max */
if (getrlimit(RLIMIT_DATA2, &rl) == 0) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
	rl.rlim_cur = rl.rlim_max;
	(void)setrlimit(RLIMIT_DATA2, &rl);
}
}

special = argv[0];

if (!mfs13.1
'mfs' is not equal to 0
) {
14
←
Taking false branch→
char execname[PATH_MAX1024], name[PATH_MAX1024];

if (fstype == NULL((void *)0))
	fstype = readlabelfs(special, 0);
if (fstype != NULL((void *)0) && strcmp(fstype, "ffs")) {
	snprintf(name, sizeof name, "newfs_%s", fstype);
	saveargv[0] = name;
	snprintf(execname, sizeof execname, "%s/newfs_%s",
	    _PATH_SBIN"/sbin", fstype);
	(void)execv(execname, saveargv);
	snprintf(execname, sizeof execname, "%s/newfs_%s",
	    _PATH_USRSBIN"/usr/sbin", fstype);
	(void)execv(execname, saveargv);
	err(1, "%s not found", name);
}
}

if (mfs14.1
'mfs' is not equal to 0
 && !strcmp(special, "swap")) {
15
←
Assuming the condition is false→
16
←
Taking false branch→
/*
 * it's an MFS, mounted on "swap."  fake up a label.
 * XXX XXX XXX
 */
fso = -1;	/* XXX; normally done below. */

memset(&mfsfakelabel, 0, sizeof(mfsfakelabel));
mfsfakelabel.d_secsize = 512;
mfsfakelabel.d_nsectors = 64;
mfsfakelabel.d_ntracks = 16;
mfsfakelabel.d_ncylinders = 16;
mfsfakelabel.d_secpercyl = 1024;
DL_SETDSIZE(&mfsfakelabel, 16384)do { u_int64_t __x = (16384); (&mfsfakelabel)->d_secperunith
 = __x >> 32; (&mfsfakelabel)->d_secperunit = __x
; } while (0);
mfsfakelabel.d_npartitions = 1;
mfsfakelabel.d_version = 1;
DL_SETPSIZE(&mfsfakelabel.d_partitions[0], 16384)do { u_int64_t __x = (16384); (&mfsfakelabel.d_partitions
[0])->p_sizeh = __x >> 32; (&mfsfakelabel.d_partitions
[0])->p_size = __x; } while (0);
mfsfakelabel.d_partitions[0].p_fragblock =
    DISKLABELV1_FFS_FRAGBLOCK(1024, 8)((1024) * (8) == 0 ? 0 : (((ffs((1024) * (8)) - 13) << 3
) | (ffs(8))));
mfsfakelabel.d_partitions[0].p_cpg = 16;

lp = &mfsfakelabel;
pp = &mfsfakelabel.d_partitions[0];

goto havelabel;
}
if (Nflag) {
17
←
Assuming 'Nflag' is not equal to 0→
18
←
Taking true branch→
fso = -1;
} else {
fso = opendev(special, O_WRONLY0x0001, 0, &realdev);
if (fso == -1)
	fatal("%s: %s", special, strerror(errno(*__errno())));
special = realdev;

/* Bail if target special is mounted */
n = getmntinfo(&mp, MNT_NOWAIT2);
if (n == 0)
	fatal("%s: getmntinfo: %s", special, strerror(errno(*__errno())));

len = sizeof(_PATH_DEV"/dev/") - 1;
s1 = special;
if (strncmp(_PATH_DEV"/dev/", s1, len) == 0)
	s1 += len;

while (--n >= 0) {
	s2 = mp->f_mntfromname;
	if (strncmp(_PATH_DEV"/dev/", s2, len) == 0) {
		s2 += len - 1;
		*s2 = 'r';
	}
	if (strcmp(s1, s2) == 0 || strcmp(s1, &s2[1]) == 0)
		fatal("%s is mounted on %s",
		    special, mp->f_mntonname);
	++mp;
}
}
if (mfs18.1
'mfs' is not equal to 0
 && disktype != NULL((void *)0)) {
19
←
Assuming 'disktype' is not equal to NULL→
20
←
Taking true branch→
lp = (struct disklabel *)getdiskbyname(disktype);
21
←
Value assigned to 'lp'→
if (lp == NULL((void *)0))
22
←
Assuming 'lp' is equal to NULL→
23
←
Taking true branch→
	fatal("%s: unknown disk type", disktype);
pp = &lp->d_partitions[1];
24
←
Null pointer value stored to 'pp'→
} else {
fsi = opendev(special, O_RDONLY0x0000, 0, NULL((void *)0));
if (fsi == -1)
	fatal("%s: %s", special, strerror(errno(*__errno())));
if (fstat(fsi, &st) == -1)
	fatal("%s: %s", special, strerror(errno(*__errno())));
if (!mfs) {
	if (S_ISBLK(st.st_mode)((st.st_mode & 0170000) == 0060000))
		fatal("%s: block device", special);
	if (!S_ISCHR(st.st_mode)((st.st_mode & 0170000) == 0020000))
		warnx("%s: not a character-special device",
		    special);
}
if (*argv[0] == '\0')
	fatal("empty partition name supplied");
cp = argv[0] + strlen(argv[0]) - 1;
if ((*cp < 'a' || *cp > ('a' + maxpartitions - 1))
    && !isdigit((unsigned char)*cp))
	fatal("%s: can't figure out file system partition",
	    argv[0]);
lp = getdisklabel(special, fsi);
if (!mfs) {
	if (pledge("stdio disklabel tty", NULL((void *)0)) == -1)
		err(1, "pledge");
}
if (isdigit((unsigned char)*cp))
	pp = &lp->d_partitions[0];
else
	pp = &lp->d_partitions[*cp - 'a'];
if (DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) == 0)
	fatal("%s: `%c' partition is unavailable",
	    argv[0], *cp);
}
448havelabel:
if (sectorsize == 0) {
25
←
Assuming 'sectorsize' is not equal to 0→
26
←
Taking false branch→
sectorsize = lp->d_secsize;
if (sectorsize <= 0)
	fatal("%s: no default sector size", argv[0]);
}

if (fssize_usebytes26.1
'fssize_usebytes' is 0
) {
27
←
Taking false branch→
nsecs = fssize_input / sectorsize;
if (fssize_input % sectorsize != 0)
	nsecs++;
} else if (fssize_input27.1
'fssize_input' is equal to 0
 == 0)
28
←
Taking true branch→
nsecs = DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size);
29
←
Access to field 'p_sizeh' results in a dereference of a null pointer (loaded from variable 'pp')
else
nsecs = fssize_input;

if (nsecs > DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size) && !mfs)
      fatal("%s: maximum file system size on the `%c' partition is "
   "%llu sectors", argv[0], *cp, DL_GETPSIZE(pp)(((u_int64_t)(pp)->p_sizeh << 32) + (pp)->p_size));

/* Can't use DL_SECTOBLK() because sectorsize may not be from label! */
fssize = nsecs * (sectorsize / DEV_BSIZE(1 << 9));
if (oflagset == 0 && fssize >= INT_MAX2147483647)
Oflag = 2;	/* FFS2 */
defaultfsize = fsize == 0;
if (fsize == 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)))));
if (fsize <= 0)
	fsize = MAXIMUM(DFL_FRAGSIZE, lp->d_secsize)(((2048) > (lp->d_secsize)) ? (2048) : (lp->d_secsize
));
}
if (bsize == 0) {
bsize = DISKLABELV1_FFS_BSIZE(pp->p_fragblock)((pp->p_fragblock) == 0 ? 0 : (1 << (((pp->p_fragblock
) >> 3) + 12)));
if (bsize <= 0)
	bsize = MINIMUM(DFL_BLKSIZE, 8 * fsize)(((16384) < (8 * fsize)) ? (16384) : (8 * fsize));
}
if (density == 0) {
density = NFPI4 * fsize;
/* large sectors lead to fewer inodes due to large fsize,
   compensate */
if (defaultfsize && sectorsize > DEV_BSIZE(1 << 9))
	density /= 2;
}
if (minfree < MINFREE5 && opt != FS_OPTSPACE1 && reqopt == -1) {
warnx("warning: changing optimization to space "
    "because minfree is less than %d%%\n", MINFREE5);
opt = FS_OPTSPACE1;
}
if (maxbpg == 0) {
if (Oflag <= 1)
	maxbpg = MAXBLKPG_FFS1(bsize)((bsize) / sizeof(int32_t));
else
	maxbpg = MAXBLKPG_FFS2(bsize)((bsize) / sizeof(int64_t));
}
oldpartition = *pp;
502#ifdef MFS1
if (mfs) {
if (realpath(argv[1], node) == NULL((void *)0))
	err(1, "realpath %s", argv[1]);
if (stat(node, &mountpoint) == -1)
	err(ECANCELED88, "stat %s", node);
mfsuid = mountpoint.st_uid;
mfsgid = mountpoint.st_gid;
mfsmode = mountpoint.st_mode & ALLPERMS(0004000|0002000|0001000|0000700|0000070|0000007);
}
512#endif

mkfs(pp, special, fsi, fso, mfsmode, mfsuid, mfsgid);
if (!Nflag && memcmp(pp, &oldpartition, sizeof(oldpartition)))
rewritelabel(special, fso, lp);
if (!Nflag)
close(fso);
if (fsi != -1)
close(fsi);
521#ifdef MFS1
if (mfs) {
struct mfs_args args;
char tmpnode[PATH_MAX1024];

if (pop != NULL((void *)0) && gettmpmnt(tmpnode, sizeof(tmpnode)) == 0)
	errx(1, "Cannot create tmp mountpoint for -P");
memset(&args, 0, sizeof(args));
args.base = membase;
args.size = fssize * DEV_BSIZE(1 << 9);
args.export_info.ex_root = -2;
if (mntflags & MNT_RDONLY0x00000001)
	args.export_info.ex_flags = MNT_EXRDONLY0x00000080;
if (mntflags & MNT_NOPERM0x00000020)
	mntflags |= MNT_NODEV0x00000010 | MNT_NOEXEC0x00000004;

switch (pid = fork()) {
case -1:
	err(10, "mfs");
case 0:
	snprintf(mountfromname, sizeof(mountfromname),
	    "mfs:%d", getpid());
	break;
default:
	if (pop != NULL((void *)0)) {
		waitformount(tmpnode, pid);
		copy(pop, tmpnode);
		unmount(tmpnode, 0);
		rmdir(tmpnode);
	}
	waitformount(node, pid);
	exit(0);
	/* NOTREACHED */
}

(void) setsid();
(void) close(0);
(void) close(1);
(void) close(2);
(void) chdir("/");

args.fspec = mountfromname;
if (pop != NULL((void *)0)) {
	int tmpflags = mntflags & ~MNT_RDONLY0x00000001;
	if (mount(MOUNT_MFS"mfs", tmpnode, tmpflags, &args) == -1)
		exit(errno(*__errno())); /* parent prints message */
}
if (mount(MOUNT_MFS"mfs", node, mntflags, &args) == -1)
	exit(errno(*__errno())); /* parent prints message */
}
571#endif
exit(0);
573}

575struct disklabel *
576getdisklabel(char *s, int fd)
577{
static struct disklabel lab;

if (ioctl(fd, DIOCGDINFO((unsigned long)0x40000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((101))), (char *)&lab) == -1) {
if (disktype != NULL((void *)0)) {
	struct disklabel *lp;

	unlabeled++;
	lp = getdiskbyname(disktype);
	if (lp == NULL((void *)0))
		fatal("%s: unknown disk type", disktype);
	return (lp);
}
warn("ioctl (GDINFO)");
fatal("%s: can't read disk label; disk type must be specified",
    s);
}
return (&lab);
595}

597void
598rewritelabel(char *s, int fd, struct disklabel *lp)
599{
if (unlabeled)
return;

lp->d_checksum = 0;
lp->d_checksum = dkcksum(lp);
if (ioctl(fd, DIOCWDINFO((unsigned long)0x80000000 | ((sizeof(struct disklabel) &
 0x1fff) << 16) | ((('d')) << 8) | ((103))), (char *)lp) == -1) {
warn("ioctl (WDINFO)");
fatal("%s: can't rewrite disk label", s);
}
609}

611void
612fatal(const char *fmt, ...)
613{
va_list ap;

va_start(ap, fmt)__builtin_va_start(ap, fmt);
if (fcntl(STDERR_FILENO2, F_GETFL3) == -1) {
openlog(__progname, LOG_CONS0x02, LOG_DAEMON(3<<3));
vsyslog(LOG_ERR3, fmt, ap);
closelog();
} else {
vwarnx(fmt, ap);
}
va_end(ap)__builtin_va_end(ap);
exit(1);
/*NOTREACHED*/
627}

629__dead__attribute__((__noreturn__)) void
630usage(void)
631{
extern char *__progname;

if (mfs) {
   fprintf(stderr(&__sF[2]),
       "usage: %s [-b block-size] [-c fragments-per-cylinder-group] "
"[-e maxbpg]\n"
"\t[-f frag-size] [-i bytes] [-m free-space] [-o options] "
"[-P file]\n"
"\t[-s size] special node\n",
__progname);
} else {
   fprintf(stderr(&__sF[2]),
       "usage: %s [-Nq] [-b block-size] "
"[-c fragments-per-cylinder-group] [-e maxbpg]\n"
"\t[-f frag-size] [-g avgfilesize] [-h avgfpdir] [-i bytes]\n"
"\t[-m free-space] [-O filesystem-format] [-o optimization]\n"
"\t[-S sector-size] [-s size] [-T disktype] [-t fstype] "
"special\n",
__progname);
}

exit(1);
654}

656#ifdef MFS1

658static void
659waitformount(char *node, pid_t pid)
660{
char mountfromname[BUFSIZ1024];
struct statfs sf;
int status;
pid_t res;

snprintf(mountfromname, sizeof(mountfromname), "mfs:%d", pid);
for (;;) {
/*
 * spin until the mount succeeds
 * or the child exits
 */
usleep(1);

/*
 * XXX Here is a race condition: another process
 * can mount a filesystem which hides our
 * ramdisk before we see the success.
 */
if (statfs(node, &sf) == -1)
	err(ECANCELED88, "statfs %s", node);
if (!strcmp(sf.f_mntfromname, mountfromname) &&
    !strncmp(sf.f_mntonname, node,
	     MNAMELEN90) &&
    !strcmp(sf.f_fstypename, "mfs")) {
	return;
}
res = waitpid(pid, &status, WNOHANG1);
if (res == -1)
	err(EDEADLK11, "waitpid");
if (res != pid)
	continue;
if (WIFEXITED(status)(((status) & 0177) == 0)) {
	if (WEXITSTATUS(status)(int)(((unsigned)(status) >> 8) & 0xff) == 0)
		exit(0);
	errx(1, "%s: mount: %s", node,
	     strerror(WEXITSTATUS(status)(int)(((unsigned)(status) >> 8) & 0xff)));
} else
	errx(EDEADLK11, "abnormal termination");
}
700}

702static int
703do_exec(const char *dir, const char *cmd, char *const argv[])
704{
pid_t pid;
int ret, status;
sig_t intsave, quitsave;

switch (pid = fork()) {
case -1:
err(1, "fork");
case 0:
if (dir != NULL((void *)0) && chdir(dir) != 0)
	err(1, "chdir");
if (execv(cmd, argv) != 0)
	err(1, "%s", cmd);
break;
default:
intsave = signal(SIGINT2, SIG_IGN(void (*)(int))1);
quitsave = signal(SIGQUIT3, SIG_IGN(void (*)(int))1);
for (;;) {
	ret = waitpid(pid, &status, 0);
	if (ret == -1)
		err(11, "waitpid");
	if (WIFEXITED(status)(((status) & 0177) == 0)) {
		status = WEXITSTATUS(status)(int)(((unsigned)(status) >> 8) & 0xff);
		if (status != 0)
			warnx("%s: exited", cmd);
		break;
	} else if (WIFSIGNALED(status)(((status) & 0177) != 0177 && ((status) & 0177
) != 0)) {
		warnx("%s: %s", cmd,
		    strsignal(WTERMSIG(status)(((status) & 0177))));
		status = 1;
		break;
	}
}
signal(SIGINT2, intsave);
signal(SIGQUIT3, quitsave);
return (status);
}
/* NOTREACHED */
return (-1);
743}

745static int
746isdir(const char *path)
747{
struct stat st;

if (stat(path, &st) != 0)
err(1, "cannot stat %s", path);
if (!S_ISDIR(st.st_mode)((st.st_mode & 0170000) == 0040000) && !S_ISBLK(st.st_mode)((st.st_mode & 0170000) == 0060000))
errx(1, "%s: not a dir or a block device", path);
return (S_ISDIR(st.st_mode)((st.st_mode & 0170000) == 0040000));
755}

757static void
758copy(char *src, char *dst)
759{
int ret, dir, created = 0;
struct ufs_args mount_args;
char mountpoint[MNAMELEN90];
char *const argv[] = { "pax", "-rw", "-pe", ".", dst, NULL((void *)0) } ;

dir = isdir(src);
if (dir)
strlcpy(mountpoint, src, sizeof(mountpoint));
else {
created = gettmpmnt(mountpoint, sizeof(mountpoint));
memset(&mount_args, 0, sizeof(mount_args));
mount_args.fspec = src;
ret = mount(MOUNT_FFS"ffs", mountpoint, MNT_RDONLY0x00000001, &mount_args);
if (ret != 0) {
	int saved_errno = errno(*__errno());
	if (created && rmdir(mountpoint) != 0)
		warn("rmdir %s", mountpoint);
	if (unmount(dst, 0) != 0)
		warn("unmount %s", dst);
	errc(1, saved_errno, "mount %s %s", src, mountpoint);
}
}
ret = do_exec(mountpoint, "/bin/pax", argv);
if (!dir && unmount(mountpoint, 0) != 0)
warn("unmount %s", mountpoint);
if (created && rmdir(mountpoint) != 0)
warn("rmdir %s", mountpoint);
if (ret != 0) {
if (unmount(dst, 0) != 0)
	warn("unmount %s", dst);
errx(1, "copy %s to %s failed", mountpoint, dst);
}
792}

794static int
795gettmpmnt(char *mountpoint, size_t len)
796{
const char *tmp = _PATH_TMP"/tmp/";
const char *mnt = _PATH_MNT"/mnt";
struct statfs fs;
size_t n;

if (statfs(tmp, &fs) != 0)
err(1, "statfs %s", tmp);
if (fs.f_flags & MNT_RDONLY0x00000001) {
if (statfs(mnt, &fs) != 0)
	err(1, "statfs %s", mnt);
if (strcmp(fs.f_mntonname, "/") != 0)
	errx(1, "tmp mountpoint %s busy", mnt);
if (strlcpy(mountpoint, mnt, len) >= len)
	errx(1, "tmp mountpoint %s too long", mnt);
return (0);
}
n = strlcpy(mountpoint, tmp, len);
if (n >= len)
errx(1, "tmp mount point too long");
if (mountpoint[n - 1] != '/')
strlcat(mountpoint, "/", len);
n = strlcat(mountpoint, "mntXXXXXXXXXX", len);
if (n >= len)
errx(1, "tmp mount point too long");
if (mkdtemp(mountpoint) == NULL((void *)0))
err(1, "mkdtemp %s", mountpoint);
return (1);
824}

826#endif /* MFS */