/usr/src/sbin/fsdb/../../sbin/fsck_ffs/utilities.c

Bug Summary

File:	src/sbin/fsdb/../../sbin/fsck_ffs/utilities.c
Warning:	line 465, column 9 The left operand of '==' is a garbage value

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 utilities.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/fsdb/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/sbin/fsdb/../../sbin/fsck -I /usr/src/sbin/fsdb/../../sbin/fsck_ffs -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/fsdb/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/fsdb/../../sbin/fsck_ffs/utilities.c

1/*	$OpenBSD: utilities.c,v 1.54 2020/07/13 06:52:53 otto Exp $	*/
2/*	$NetBSD: utilities.c,v 1.18 1996/09/27 22:45:20 christos Exp $	*/

4/*
* Copyright (c) 1980, 1986, 1993
*	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.
*/

33#include <sys/param.h>	/* DEV_BSIZE isset setbit clrbit */
34#include <sys/time.h>
35#include <sys/uio.h>
36#include <ufs/ufs/dinode.h>
37#include <ufs/ufs/dir.h>
38#include <ufs/ffs/fs.h>
39#include <signal.h>
40#include <stdio.h>
41#include <stdlib.h>
42#include <string.h>
43#include <ctype.h>
44#include <unistd.h>
45#include <limits.h>
46#include <errno(*__errno()).h>
47#include <fcntl.h>
48#include <paths.h>

50#include "fsutil.h"
51#include "fsck.h"
52#include "extern.h"

54long				diskreads, totalreads;	/* Disk cache statistics */
55static struct bufarea		cgblk;			/* backup buffer for cylinder group blocks */

57static void rwerror(char *, daddr_t);

59int
60ftypeok(union dinode *dp)
61{
switch (DIP(dp, di_mode)(((*sblk.b_un.b_fs).fs_magic == 0x011954) ? (dp)->dp1.di_mode
 : (dp)->dp2.di_mode) & IFMT0170000) {
case IFDIR0040000:
case IFREG0100000:
case IFBLK0060000:
case IFCHR0020000:
case IFLNK0120000:
case IFSOCK0140000:
case IFIFO0010000:
return (1);
default:
if (debug)
	printf("bad file type 0%o\n", DIP(dp, di_mode)(((*sblk.b_un.b_fs).fs_magic == 0x011954) ? (dp)->dp1.di_mode
 : (dp)->dp2.di_mode));
return (0);
}
76}

78int
79reply(char *question)
80{
int persevere, c;

if (preen)
pfatal("INTERNAL ERROR: GOT TO reply()");
persevere = !strcmp(question, "CONTINUE");
printf("\n");
if (!persevere && (nflag || fswritefd < 0)) {
printf("%s? no\n\n", question);
resolved = 0;
return (0);
}
if (yflag || (persevere && nflag)) {
printf("%s? yes\n\n", question);
return (1);
}

do {
printf("%s? [Fyn?] ", question);
(void) fflush(stdout(&__sF[1]));
c = getc(stdin)(!__isthreaded ? (--((&__sF[0]))->_r < 0 ? __srget(
(&__sF[0])) : (int)(*((&__sF[0]))->_p++)) : (getc)
((&__sF[0])));
if (c == 'F') {
	yflag = 1;
	return (1);
}
while (c != '\n' && getc(stdin)(!__isthreaded ? (--((&__sF[0]))->_r < 0 ? __srget(
(&__sF[0])) : (int)(*((&__sF[0]))->_p++)) : (getc)
((&__sF[0]))) != '\n') {
	if (feof(stdin)(!__isthreaded ? ((((&__sF[0]))->_flags & 0x0020) !=
 0) : (feof)((&__sF[0])))) {
		resolved = 0;
		return (0);
	}
}
} while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
printf("\n");
if (c == 'y' || c == 'Y')
return (1);
resolved = 0;
return (0);
117}

119/*
* Look up state information for an inode.
*/
122struct inostat *
123inoinfo(ino_t inum)
124{
static struct inostat unallocated = { USTATE01, 0, 0 };
struct inostatlist *ilp;
int iloff;

if (inum > maxino)
errexit("inoinfo: inumber %llu out of range",
    (unsigned long long)inum);
ilp = &inostathead[inum / sblock(*sblk.b_un.b_fs).fs_ipg];
iloff = inum % sblock(*sblk.b_un.b_fs).fs_ipg;
if (iloff >= ilp->il_numalloced)
return (&unallocated);
return (&ilp->il_stat[iloff]);
137}

139/*
* Malloc buffers and set up cache.
*/
142void
143bufinit(void)
144{
struct bufarea *bp;
long bufcnt, i;
char *bufp;

pbp = pdirbp = NULL((void *)0);
bufp = malloc((unsigned int)sblock(*sblk.b_un.b_fs).fs_bsize);
if (bufp == 0)
errexit("cannot allocate buffer pool\n");
cgblk.b_un.b_buf = bufp;
initbarea(&cgblk)(&cgblk)->b_dirty = 0; (&cgblk)->b_bno = -1; (&
cgblk)->b_flags = 0;;
bufhead.b_next = bufhead.b_prev = &bufhead;
bufcnt = MAXBUFSPACE40*1024 / sblock(*sblk.b_un.b_fs).fs_bsize;
if (bufcnt < MINBUFS5)
bufcnt = MINBUFS5;
for (i = 0; i < bufcnt; i++) {
bp = malloc(sizeof(struct bufarea));
bufp = malloc((unsigned int)sblock(*sblk.b_un.b_fs).fs_bsize);
if (bp == NULL((void *)0) || bufp == NULL((void *)0)) {
	free(bp);
	free(bufp);
	if (i >= MINBUFS5)
		break;
	errexit("cannot allocate buffer pool\n");
}
bp->b_un.b_buf = bufp;
bp->b_prev = &bufhead;
bp->b_next = bufhead.b_next;
bufhead.b_next->b_prev = bp;
bufhead.b_next = bp;
initbarea(bp)(bp)->b_dirty = 0; (bp)->b_bno = -1; (bp)->b_flags =
 0;;
}
bufhead.b_size = i;	/* save number of buffers */
177}

179/*
* Manage cylinder group buffers.
*/
182static struct bufarea *cgbufs;	/* header for cylinder group cache */
183static int flushtries;		/* number of tries to reclaim memory */
184struct bufarea *
185cglookup(u_int cg)
186{
struct bufarea *cgbp;
struct cg *cgp;

if (cgbufs == NULL((void *)0)) {
14
←
Assuming 'cgbufs' is not equal to NULL→
15
←
Taking false branch→
cgbufs = calloc(sblock(*sblk.b_un.b_fs).fs_ncg, sizeof(struct bufarea));
if (cgbufs == NULL((void *)0))
	errexit("cannot allocate cylinder group buffers");
}
cgbp = &cgbufs[cg];
if (cgbp->b_un.b_cg != NULL((void *)0))
16
←
Assuming field 'b_cg' is equal to NULL→
17
←
Taking false branch→
return (cgbp);
cgp = NULL((void *)0);
if (flushtries == 0)
18
←
Assuming 'flushtries' is equal to 0→
19
←
Taking true branch→
cgp = malloc((unsigned int)sblock(*sblk.b_un.b_fs).fs_cgsize);
20
←
Uninitialized value stored to field 'cg_magic'→
if (cgp == NULL((void *)0)) {
21
←
Assuming 'cgp' is not equal to NULL→
22
←
Taking false branch→
getblk(&cgblk, cgtod(&sblock, cg)((((daddr_t)(&(*sblk.b_un.b_fs))->fs_fpg * (cg)) + (&
(*sblk.b_un.b_fs))->fs_cgoffset * ((cg) & ~((&(*sblk
.b_un.b_fs))->fs_cgmask))) + (&(*sblk.b_un.b_fs))->
fs_cblkno), sblock(*sblk.b_un.b_fs).fs_cgsize);
return (&cgblk);
}
cgbp->b_un.b_cg = cgp;
initbarea(cgbp)(cgbp)->b_dirty = 0; (cgbp)->b_bno = -1; (cgbp)->b_flags
 = 0;;
getblk(cgbp, cgtod(&sblock, cg)((((daddr_t)(&(*sblk.b_un.b_fs))->fs_fpg * (cg)) + (&
(*sblk.b_un.b_fs))->fs_cgoffset * ((cg) & ~((&(*sblk
.b_un.b_fs))->fs_cgmask))) + (&(*sblk.b_un.b_fs))->
fs_cblkno), sblock(*sblk.b_un.b_fs).fs_cgsize);
return (cgbp);
209}


212/*
* Manage a cache of directory blocks.
*/
215struct bufarea *
216getdatablk(daddr_t blkno, long size)
217{
struct bufarea *bp;

for (bp = bufhead.b_next; bp != &bufhead; bp = bp->b_next)
if (bp->b_bno == fsbtodb(&sblock, blkno)((blkno) << (&(*sblk.b_un.b_fs))->fs_fsbtodb))
	goto foundit;
for (bp = bufhead.b_prev; bp != &bufhead; bp = bp->b_prev)
if ((bp->b_flags & B_INUSE1) == 0)
	break;
if (bp == &bufhead)
errexit("deadlocked buffer pool\n");
getblk(bp, blkno, size);
/* FALLTHROUGH */
230foundit:
totalreads++;
bp->b_prev->b_next = bp->b_next;
bp->b_next->b_prev = bp->b_prev;
bp->b_prev = &bufhead;
bp->b_next = bufhead.b_next;
bufhead.b_next->b_prev = bp;
bufhead.b_next = bp;
bp->b_flags |= B_INUSE1;
return (bp);
240}

242void
243getblk(struct bufarea *bp, daddr_t blk, long size)
244{
daddr_t dblk;

dblk = fsbtodb(&sblock, blk)((blk) << (&(*sblk.b_un.b_fs))->fs_fsbtodb);
if (bp->b_bno != dblk) {
flush(fswritefd, bp);
diskreads++;
bp->b_errs = bread(fsreadfd, bp->b_un.b_buf, dblk, size);
bp->b_bno = dblk;
bp->b_size = size;
}
255}

257void
258flush(int fd, struct bufarea *bp)
259{
int i, j;

if (!bp->b_dirty)
return;
if (bp->b_errs != 0)
pfatal("WRITING %sZERO'ED BLOCK %lld TO DISK\n",
    (bp->b_errs == bp->b_size / DEV_BSIZE(1 << 9)) ? "" : "PARTIALLY ",
    (long long)bp->b_bno);
bp->b_dirty = 0;
bp->b_errs = 0;
bwrite(fd, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
if (bp != &sblk)
return;
for (i = 0, j = 0; i < sblock(*sblk.b_un.b_fs).fs_cssize; i += sblock(*sblk.b_un.b_fs).fs_bsize, j++) {
bwrite(fswritefd, (char *)sblock(*sblk.b_un.b_fs).fs_csp + i,
    fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag)(((*sblk.b_un.b_fs).fs_csaddr + j * (*sblk.b_un.b_fs).fs_frag
) << (&(*sblk.b_un.b_fs))->fs_fsbtodb),
    sblock(*sblk.b_un.b_fs).fs_cssize - i < sblock(*sblk.b_un.b_fs).fs_bsize ?
    sblock(*sblk.b_un.b_fs).fs_cssize - i : sblock(*sblk.b_un.b_fs).fs_bsize);
}
279}

281static void
282rwerror(char *mesg, daddr_t blk)
283{

if (preen == 0)
printf("\n");
pfatal("CANNOT %s: BLK %lld", mesg, (long long)blk);
if (reply("CONTINUE") == 0)
errexit("Program terminated\n");
290}

292void
293ckfini(int markclean)
294{
struct bufarea *bp, *nbp;
int cnt = 0;
sigset_t oset, nset;
int64_t sblockloc;

sigemptyset(&nset);
sigaddset(&nset, SIGINT2);
sigprocmask(SIG_BLOCK1, &nset, &oset);

if (fswritefd < 0) {
(void)close(fsreadfd);
fsreadfd = -1;
sigprocmask(SIG_SETMASK3, &oset, NULL((void *)0));
return;
}
if (sblock(*sblk.b_un.b_fs).fs_magic == FS_UFS1_MAGIC0x011954) {
sblockloc = SBLOCK_UFS18192;
sblock(*sblk.b_un.b_fs).fs_ffs1_time = sblock(*sblk.b_un.b_fs).fs_time;
sblock(*sblk.b_un.b_fs).fs_ffs1_size = sblock(*sblk.b_un.b_fs).fs_size;
sblock(*sblk.b_un.b_fs).fs_ffs1_dsize = sblock(*sblk.b_un.b_fs).fs_dsize;
sblock(*sblk.b_un.b_fs).fs_ffs1_csaddr = sblock(*sblk.b_un.b_fs).fs_csaddr;
sblock(*sblk.b_un.b_fs).fs_ffs1_cstotal.cs_ndir = sblock(*sblk.b_un.b_fs).fs_cstotal.cs_ndir;
sblock(*sblk.b_un.b_fs).fs_ffs1_cstotal.cs_nbfree = sblock(*sblk.b_un.b_fs).fs_cstotal.cs_nbfree;
sblock(*sblk.b_un.b_fs).fs_ffs1_cstotal.cs_nifree = sblock(*sblk.b_un.b_fs).fs_cstotal.cs_nifree;
sblock(*sblk.b_un.b_fs).fs_ffs1_cstotal.cs_nffree = sblock(*sblk.b_un.b_fs).fs_cstotal.cs_nffree;
/* Force update on next mount */
sblock(*sblk.b_un.b_fs).fs_ffs1_flags &= ~FS_FLAGS_UPDATED0x80;
} else
sblockloc = SBLOCK_UFS265536;
flush(fswritefd, &sblk);
if (havesb && sblk.b_bno != sblockloc / DEV_BSIZE(1 << 9) && !preen &&
   reply("UPDATE STANDARD SUPERBLOCK")) {
sblk.b_bno = sblockloc / DEV_BSIZE(1 << 9);
sbdirty()sblk.b_dirty = 1;
flush(fswritefd, &sblk);
}
flush(fswritefd, &cgblk);
free(cgblk.b_un.b_buf);
for (bp = bufhead.b_prev; bp && bp != &bufhead; bp = nbp) {
cnt++;
flush(fswritefd, bp);
nbp = bp->b_prev;
free(bp->b_un.b_buf);
free(bp);
}
if (bufhead.b_size != cnt)
errexit("Panic: lost %d buffers\n", bufhead.b_size - cnt);
if (cgbufs != NULL((void *)0)) {	
for (cnt = 0; cnt < sblock(*sblk.b_un.b_fs).fs_ncg; cnt++) {
	if (cgbufs[cnt].b_un.b_cg == NULL((void *)0))
		continue;
	flush(fswritefd, &cgbufs[cnt]);
	free(cgbufs[cnt].b_un.b_cg);
}
free(cgbufs);
}
pbp = pdirbp = NULL((void *)0);
if (markclean && (sblock(*sblk.b_un.b_fs).fs_clean & FS_ISCLEAN0x01) == 0) {
/*
 * Mark the file system as clean, and sync the superblock.
 */
if (preen)
	pwarn("MARKING FILE SYSTEM CLEAN\n");
else if (!reply("MARK FILE SYSTEM CLEAN"))
	markclean = 0;
if (markclean) {
	sblock(*sblk.b_un.b_fs).fs_clean = FS_ISCLEAN0x01;
	sbdirty()sblk.b_dirty = 1;
	flush(fswritefd, &sblk);
}
}
if (debug)
printf("cache missed %ld of %ld (%d%%)\n", diskreads,
    totalreads, (int)(diskreads * 100 / totalreads));
(void)close(fsreadfd);
fsreadfd = -1;
(void)close(fswritefd);
fswritefd = -1;
sigprocmask(SIG_SETMASK3, &oset, NULL((void *)0));
374}

376int
377bread(int fd, char *buf, daddr_t blk, long size)
378{
char *cp;
int i, errs;
off_t offset;

offset = blk;
offset *= DEV_BSIZE(1 << 9);
if (pread(fd, buf, size, offset) == size)
return (0);
rwerror("READ", blk);
errs = 0;
memset(buf, 0, (size_t)size);
printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
if (pread(fd, cp, secsize, offset + i) != secsize) {
	if (secsize != DEV_BSIZE(1 << 9))
		printf(" %lld (%lld),",
		    (long long)(offset + i) / secsize,
		    (long long)blk + i / DEV_BSIZE(1 << 9));
	else
		printf(" %lld,", (long long)blk +
		    i / DEV_BSIZE(1 << 9));
	errs++;
}
}
printf("\n");
return (errs);
405}

407void
408bwrite(int fd, char *buf, daddr_t blk, long size)
409{
int i;
char *cp;
off_t offset;

if (fd < 0)
return;
offset = blk;
offset *= DEV_BSIZE(1 << 9);
if (pwrite(fd, buf, size, offset) == size) {
fsmodified = 1;
return;
}
rwerror("WRITE", blk);
printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
for (cp = buf, i = 0; i < size; i += secsize, cp += secsize)
if (pwrite(fd, cp, secsize, offset + i) != secsize) {
	if (secsize != DEV_BSIZE(1 << 9))
		printf(" %lld (%lld),",
		    (long long)(offset + i) / secsize,
		    (long long)blk + i / DEV_BSIZE(1 << 9));
	else
		printf(" %lld,", (long long)blk +
		    i / DEV_BSIZE(1 << 9));
}
printf("\n");
return;
436}

438/*
* allocate a data block with the specified number of fragments
*/
441daddr_t
442allocblk(int frags)
443{
daddr_t i, baseblk;
int j, k, cg;
struct bufarea *cgbp;
struct cg *cgp;

if (frags <= 0 || frags > sblock(*sblk.b_un.b_fs).fs_frag)
1
Assuming 'frags' is > 0→
2
←
Assuming 'frags' is <= field 'fs_frag'→
3
←
Taking false branch→
return (0);
for (i = 0; i < maxfsblock - sblock(*sblk.b_un.b_fs).fs_frag; i += sblock(*sblk.b_un.b_fs).fs_frag) {
4
←
Assuming the condition is true→
5
←
Loop condition is true.  Entering loop body→
for (j = 0; j <= sblock(*sblk.b_un.b_fs).fs_frag - frags; j++) {
6
←
Assuming the condition is true→
7
←
Loop condition is true.  Entering loop body→
	if (testbmap(i + j)((blockmap)[(i + j)>>3] & (1<<((i + j)&(8
 -1)))))
8
←
Assuming the condition is false→
9
←
Taking false branch→
		continue;
	for (k = 1; k < frags; k++)
10
←
Assuming 'k' is >= 'frags'→
11
←
Loop condition is false. Execution continues on line 458→
		if (testbmap(i + j + k)((blockmap)[(i + j + k)>>3] & (1<<((i + j + k
)&(8 -1)))))
			break;
	if (k11.1
'k' is >= 'frags'
 < frags) {
12
←
Taking false branch→
		j += k;
		continue;
	}
	cg = dtog(&sblock, i + j)((i + j) / (&(*sblk.b_un.b_fs))->fs_fpg);
	cgbp = cglookup(cg);
13
←
Calling 'cglookup'→
23
←
Returning from 'cglookup'→
	cgp = cgbp->b_un.b_cg;
	if (!cg_chkmagic(cgp)((cgp)->cg_magic == 0x090255 || ((struct ocg *)(cgp))->
cg_magic == 0x090255))
24
←
The left operand of '==' is a garbage value
		pfatal("CG %d: BAD MAGIC NUMBER\n", cg);
	baseblk = dtogd(&sblock, i + j)((i + j) % (&(*sblk.b_un.b_fs))->fs_fpg);

	for (k = 0; k < frags; k++) {
		setbmap(i + j + k)((blockmap)[(i + j + k)>>3] |= 1<<((i + j + k)&
(8 -1)));
		clrbit(cg_blksfree(cgp), baseblk + k)(((((cgp)->cg_magic != 0x090255) ? (((struct ocg *)(cgp))->
cg_free) : ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_freeoff
))))[(baseblk + k)>>3] &= ~(1<<((baseblk + k)
&(8 -1))));
	}
	n_blks += frags;
	if (frags == sblock(*sblk.b_un.b_fs).fs_frag)
		cgp->cg_cs.cs_nbfree--;
	else
		cgp->cg_cs.cs_nffree -= frags;
	return (i + j);
}
}
return (0);
482}

484/*
* Free a previously allocated block
*/
487void
488freeblk(daddr_t blkno, int frags)
489{
struct inodesc idesc;

idesc.id_blkno = blkno;
idesc.id_numfrags = frags;
(void)pass4check(&idesc);
495}

497/*
* Find a pathname
*/
500void
501getpathname(char *namebuf, size_t namebuflen, ino_t curdir, ino_t ino)
502{
int len;
char *cp;
struct inodesc idesc;
static int busy = 0;

if (curdir == ino && ino == ROOTINO((ufsino_t)2)) {
(void)strlcpy(namebuf, "/", namebuflen);
return;
}
if (busy ||
   (GET_ISTATE(curdir)(inoinfo(curdir)->ino_state) != DSTATE03 && GET_ISTATE(curdir)(inoinfo(curdir)->ino_state) != DFOUND04)) {
(void)strlcpy(namebuf, "?", namebuflen);
return;
}
busy = 1;
memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA1;
idesc.id_fix = IGNORE;
cp = &namebuf[PATH_MAX1024 - 1];
*cp = '\0';
if (curdir != ino) {
idesc.id_parent = curdir;
goto namelookup;
}
while (ino != ROOTINO((ufsino_t)2)) {
idesc.id_number = ino;
idesc.id_func = findino;
idesc.id_name = "..";
if ((ckinode(ginode(ino), &idesc) & FOUND0x10) == 0)
	break;
namelookup:
idesc.id_number = idesc.id_parent;
idesc.id_parent = ino;
idesc.id_func = findname;
idesc.id_name = namebuf;
if ((ckinode(ginode(idesc.id_number), &idesc)&FOUND0x10) == 0)
	break;
len = strlen(namebuf);
cp -= len;
memmove(cp, namebuf, (size_t)len);
*--cp = '/';
if (cp < &namebuf[MAXNAMLEN255])
	break;
ino = idesc.id_number;
}
busy = 0;
if (ino != ROOTINO((ufsino_t)2))
*--cp = '?';
memmove(namebuf, cp, (size_t)(&namebuf[PATH_MAX1024] - cp));
552}

554/*ARGSUSED*/
555void
556catch(int signo)
557{
ckfini(0);			/* XXX signal race */
_exit(12);
560}

562/*
* When preening, allow a single quit to signal
* a special exit after filesystem checks complete
* so that reboot sequence may be interrupted.
*/
567/*ARGSUSED*/
568void
569catchquit(int signo)
570{
extern volatile sig_atomic_t returntosingle;
static const char message[] =
   "returning to single-user after filesystem check\n";

write(STDOUT_FILENO1, message, sizeof(message)-1);
returntosingle = 1;
(void)signal(SIGQUIT3, SIG_DFL(void (*)(int))0);
578}

580/*
* Ignore a single quit signal; wait and flush just in case.
* Used by child processes in preen.
*/
584/*ARGSUSED*/
585void
586voidquit(int signo)
587{
int save_errno = errno(*__errno());

sleep(1);
(void)signal(SIGQUIT3, SIG_IGN(void (*)(int))1);
(void)signal(SIGQUIT3, SIG_DFL(void (*)(int))0);
errno(*__errno()) = save_errno;
594}

596/*
* determine whether an inode should be fixed.
*/
599int
600dofix(struct inodesc *idesc, char *msg)
601{
switch (idesc->id_fix) {

case DONTKNOW:
if (idesc->id_type == DATA1)
	direrror(idesc->id_number, msg);
else
	pwarn("%s", msg);
if (preen) {
	printf(" (SALVAGED)\n");
	idesc->id_fix = FIX;
	return (ALTERED0x08);
}
if (reply("SALVAGE") == 0) {
	idesc->id_fix = NOFIX;
	return (0);
}
idesc->id_fix = FIX;
return (ALTERED0x08);

case FIX:
return (ALTERED0x08);

case NOFIX:
case IGNORE:
return (0);

default:
errexit("UNKNOWN INODESC FIX MODE %u\n", idesc->id_fix);
}
/* NOTREACHED */
632}

634int (* info_fn)(char *, size_t) = NULL((void *)0);
635char *info_filesys = "?";

637/*ARGSUSED*/
638void
639catchinfo(int signo)
640{
static int info_fd;
int save_errno = errno(*__errno());
struct iovec iov[4];
char buf[1024];

if (signo == 0) {
info_fd = open(_PATH_TTY"/dev/tty", O_WRONLY0x0001);
signal(SIGINFO29, catchinfo);
} else if (info_fd > 0 && info_fn != NULL((void *)0) && info_fn(buf, sizeof buf)) {
iov[0].iov_base = info_filesys;
iov[0].iov_len = strlen(info_filesys);
iov[1].iov_base = ": ";
iov[1].iov_len = sizeof ": " - 1;
iov[2].iov_base = buf;
iov[2].iov_len = strlen(buf);
iov[3].iov_base = "\n";
iov[3].iov_len = sizeof "\n" - 1;

writev(info_fd, iov, 4);
}
errno(*__errno()) = save_errno;
662}
663/*
* Attempt to flush a cylinder group cache entry.
* Return whether the flush was successful.
*/
667static int
668flushentry(void)
669{
struct bufarea *cgbp;

if (flushtries == sblock(*sblk.b_un.b_fs).fs_ncg || cgbufs == NULL((void *)0))
return (0);
cgbp = &cgbufs[flushtries++];
if (cgbp->b_un.b_cg == NULL((void *)0))
return (0);
flush(fswritefd, cgbp);
free(cgbp->b_un.b_buf);
cgbp->b_un.b_buf = NULL((void *)0);
return (1);
681}

683/*
* Wrapper for malloc() that flushes the cylinder group cache to try
* to get space.
*/
687void *
688Malloc(size_t size)
689{
void *retval;

while ((retval = malloc(size)) == NULL((void *)0))
if (flushentry() == 0)
	break;
return (retval);
696}

698/*
* Wrapper for calloc() that flushes the cylinder group cache to try
* to get space.
*/
702void*
703Calloc(size_t cnt, size_t size)
704{
void *retval;

while ((retval = calloc(cnt, size)) == NULL((void *)0))
if (flushentry() == 0)
	break;
return (retval);
711}

713/*
* Wrapper for reallocarray() that flushes the cylinder group cache to try
* to get space.
*/
717void*
718Reallocarray(void *p, size_t cnt, size_t size)
719{
void *retval;

while ((retval = reallocarray(p, cnt, size)) == NULL((void *)0))
if (flushentry() == 0)
	break;
return (retval);
726}