xref: /freebsd/sbin/fsck_ffs/fsutil.c (revision 2b5373de83ee2113eafb46726ba37257622e26e5)
14336716bSAdrian Chadd /*
24336716bSAdrian Chadd  * Copyright (c) 1980, 1986, 1993
34336716bSAdrian Chadd  *	The Regents of the University of California.  All rights reserved.
44336716bSAdrian Chadd  *
54336716bSAdrian Chadd  * Redistribution and use in source and binary forms, with or without
64336716bSAdrian Chadd  * modification, are permitted provided that the following conditions
74336716bSAdrian Chadd  * are met:
84336716bSAdrian Chadd  * 1. Redistributions of source code must retain the above copyright
94336716bSAdrian Chadd  *    notice, this list of conditions and the following disclaimer.
104336716bSAdrian Chadd  * 2. Redistributions in binary form must reproduce the above copyright
114336716bSAdrian Chadd  *    notice, this list of conditions and the following disclaimer in the
124336716bSAdrian Chadd  *    documentation and/or other materials provided with the distribution.
134336716bSAdrian Chadd  * 4. Neither the name of the University nor the names of its contributors
144336716bSAdrian Chadd  *    may be used to endorse or promote products derived from this software
154336716bSAdrian Chadd  *    without specific prior written permission.
164336716bSAdrian Chadd  *
174336716bSAdrian Chadd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
184336716bSAdrian Chadd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
194336716bSAdrian Chadd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
204336716bSAdrian Chadd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
214336716bSAdrian Chadd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
224336716bSAdrian Chadd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
234336716bSAdrian Chadd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
244336716bSAdrian Chadd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
254336716bSAdrian Chadd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
264336716bSAdrian Chadd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
274336716bSAdrian Chadd  * SUCH DAMAGE.
284336716bSAdrian Chadd  */
294336716bSAdrian Chadd 
304336716bSAdrian Chadd #if 0
31c69284caSDavid E. O'Brien #ifndef lint
324336716bSAdrian Chadd static const char sccsid[] = "@(#)utilities.c	8.6 (Berkeley) 5/19/95";
334336716bSAdrian Chadd #endif /* not lint */
34c69284caSDavid E. O'Brien #endif
35c69284caSDavid E. O'Brien #include <sys/cdefs.h>
36c69284caSDavid E. O'Brien __FBSDID("$FreeBSD$");
374336716bSAdrian Chadd 
384336716bSAdrian Chadd #include <sys/param.h>
399d580d7cSIan Dowse #include <sys/time.h>
404336716bSAdrian Chadd #include <sys/types.h>
41bf58d635SIan Dowse #include <sys/sysctl.h>
428d3dfc26SDag-Erling Smørgrav #include <sys/disk.h>
431c85e6a3SKirk McKusick #include <sys/disklabel.h>
448d3dfc26SDag-Erling Smørgrav #include <sys/ioctl.h>
454336716bSAdrian Chadd #include <sys/stat.h>
464336716bSAdrian Chadd 
474336716bSAdrian Chadd #include <ufs/ufs/dinode.h>
484336716bSAdrian Chadd #include <ufs/ufs/dir.h>
494336716bSAdrian Chadd #include <ufs/ffs/fs.h>
504336716bSAdrian Chadd 
514336716bSAdrian Chadd #include <err.h>
524336716bSAdrian Chadd #include <errno.h>
534336716bSAdrian Chadd #include <string.h>
544336716bSAdrian Chadd #include <ctype.h>
554336716bSAdrian Chadd #include <fstab.h>
5684fc0d7eSMaxime Henrion #include <stdint.h>
574336716bSAdrian Chadd #include <stdio.h>
584336716bSAdrian Chadd #include <stdlib.h>
59ed75b5a1SKirk McKusick #include <time.h>
604336716bSAdrian Chadd #include <unistd.h>
614336716bSAdrian Chadd 
624336716bSAdrian Chadd #include "fsck.h"
634336716bSAdrian Chadd 
649d580d7cSIan Dowse static void slowio_start(void);
659d580d7cSIan Dowse static void slowio_end(void);
66ed75b5a1SKirk McKusick static void printIOstats(void);
679d580d7cSIan Dowse 
68ed75b5a1SKirk McKusick static long diskreads, totaldiskreads, totalreads; /* Disk cache statistics */
69ed75b5a1SKirk McKusick static struct timespec startpass, finishpass;
709d580d7cSIan Dowse struct timeval slowio_starttime;
719d580d7cSIan Dowse int slowio_delay_usec = 10000;	/* Initial IO delay for background fsck */
729d580d7cSIan Dowse int slowio_pollcnt;
7381fbded2SKirk McKusick static struct bufarea cgblk;	/* backup buffer for cylinder group blocks */
742ec5c914SKirk McKusick static TAILQ_HEAD(buflist, bufarea) bufhead;	/* head of buffer cache list */
752ec5c914SKirk McKusick static int numbufs;				/* size of buffer cache */
76ed75b5a1SKirk McKusick static char *buftype[BT_NUMBUFTYPES] = BT_NAMES;
774336716bSAdrian Chadd 
784336716bSAdrian Chadd int
791c85e6a3SKirk McKusick ftypeok(union dinode *dp)
804336716bSAdrian Chadd {
811c85e6a3SKirk McKusick 	switch (DIP(dp, di_mode) & IFMT) {
824336716bSAdrian Chadd 
834336716bSAdrian Chadd 	case IFDIR:
844336716bSAdrian Chadd 	case IFREG:
854336716bSAdrian Chadd 	case IFBLK:
864336716bSAdrian Chadd 	case IFCHR:
874336716bSAdrian Chadd 	case IFLNK:
884336716bSAdrian Chadd 	case IFSOCK:
894336716bSAdrian Chadd 	case IFIFO:
904336716bSAdrian Chadd 		return (1);
914336716bSAdrian Chadd 
924336716bSAdrian Chadd 	default:
934336716bSAdrian Chadd 		if (debug)
941c85e6a3SKirk McKusick 			printf("bad file type 0%o\n", DIP(dp, di_mode));
954336716bSAdrian Chadd 		return (0);
964336716bSAdrian Chadd 	}
974336716bSAdrian Chadd }
984336716bSAdrian Chadd 
994336716bSAdrian Chadd int
100599304a4SPoul-Henning Kamp reply(const char *question)
1014336716bSAdrian Chadd {
1024336716bSAdrian Chadd 	int persevere;
1034336716bSAdrian Chadd 	char c;
1044336716bSAdrian Chadd 
1054336716bSAdrian Chadd 	if (preen)
1064336716bSAdrian Chadd 		pfatal("INTERNAL ERROR: GOT TO reply()");
1074336716bSAdrian Chadd 	persevere = !strcmp(question, "CONTINUE");
1084336716bSAdrian Chadd 	printf("\n");
1097578c6abSKirk McKusick 	if (!persevere && (nflag || (fswritefd < 0 && bkgrdflag == 0))) {
1104336716bSAdrian Chadd 		printf("%s? no\n\n", question);
1114336716bSAdrian Chadd 		resolved = 0;
1124336716bSAdrian Chadd 		return (0);
1134336716bSAdrian Chadd 	}
1144336716bSAdrian Chadd 	if (yflag || (persevere && nflag)) {
1154336716bSAdrian Chadd 		printf("%s? yes\n\n", question);
1164336716bSAdrian Chadd 		return (1);
1174336716bSAdrian Chadd 	}
1184336716bSAdrian Chadd 	do	{
1194336716bSAdrian Chadd 		printf("%s? [yn] ", question);
1204336716bSAdrian Chadd 		(void) fflush(stdout);
1214336716bSAdrian Chadd 		c = getc(stdin);
1224336716bSAdrian Chadd 		while (c != '\n' && getc(stdin) != '\n') {
1234336716bSAdrian Chadd 			if (feof(stdin)) {
1244336716bSAdrian Chadd 				resolved = 0;
1254336716bSAdrian Chadd 				return (0);
1264336716bSAdrian Chadd 			}
1274336716bSAdrian Chadd 		}
1284336716bSAdrian Chadd 	} while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
1294336716bSAdrian Chadd 	printf("\n");
1304336716bSAdrian Chadd 	if (c == 'y' || c == 'Y')
1314336716bSAdrian Chadd 		return (1);
1324336716bSAdrian Chadd 	resolved = 0;
1334336716bSAdrian Chadd 	return (0);
1344336716bSAdrian Chadd }
1354336716bSAdrian Chadd 
1364336716bSAdrian Chadd /*
1374336716bSAdrian Chadd  * Look up state information for an inode.
1384336716bSAdrian Chadd  */
1394336716bSAdrian Chadd struct inostat *
140b70cd7eeSWarner Losh inoinfo(ino_t inum)
1414336716bSAdrian Chadd {
1424336716bSAdrian Chadd 	static struct inostat unallocated = { USTATE, 0, 0 };
1434336716bSAdrian Chadd 	struct inostatlist *ilp;
1444336716bSAdrian Chadd 	int iloff;
1454336716bSAdrian Chadd 
1464336716bSAdrian Chadd 	if (inum > maxino)
147623d7cb6SMatthew D Fleming 		errx(EEXIT, "inoinfo: inumber %ju out of range",
148623d7cb6SMatthew D Fleming 		    (uintmax_t)inum);
1494336716bSAdrian Chadd 	ilp = &inostathead[inum / sblock.fs_ipg];
1504336716bSAdrian Chadd 	iloff = inum % sblock.fs_ipg;
1514336716bSAdrian Chadd 	if (iloff >= ilp->il_numalloced)
1524336716bSAdrian Chadd 		return (&unallocated);
1534336716bSAdrian Chadd 	return (&ilp->il_stat[iloff]);
1544336716bSAdrian Chadd }
1554336716bSAdrian Chadd 
1564336716bSAdrian Chadd /*
1574336716bSAdrian Chadd  * Malloc buffers and set up cache.
1584336716bSAdrian Chadd  */
1594336716bSAdrian Chadd void
160b70cd7eeSWarner Losh bufinit(void)
1614336716bSAdrian Chadd {
1623d438ad6SDavid E. O'Brien 	struct bufarea *bp;
1634336716bSAdrian Chadd 	long bufcnt, i;
1644336716bSAdrian Chadd 	char *bufp;
1654336716bSAdrian Chadd 
1664336716bSAdrian Chadd 	pbp = pdirbp = (struct bufarea *)0;
16781fbded2SKirk McKusick 	bufp = Malloc((unsigned int)sblock.fs_bsize);
1684336716bSAdrian Chadd 	if (bufp == 0)
1694336716bSAdrian Chadd 		errx(EEXIT, "cannot allocate buffer pool");
1704336716bSAdrian Chadd 	cgblk.b_un.b_buf = bufp;
171ed75b5a1SKirk McKusick 	initbarea(&cgblk, BT_CYLGRP);
1722ec5c914SKirk McKusick 	TAILQ_INIT(&bufhead);
1732ec5c914SKirk McKusick 	bufcnt = MAXBUFS;
1744336716bSAdrian Chadd 	if (bufcnt < MINBUFS)
1754336716bSAdrian Chadd 		bufcnt = MINBUFS;
1764336716bSAdrian Chadd 	for (i = 0; i < bufcnt; i++) {
17781fbded2SKirk McKusick 		bp = (struct bufarea *)Malloc(sizeof(struct bufarea));
17881fbded2SKirk McKusick 		bufp = Malloc((unsigned int)sblock.fs_bsize);
1794336716bSAdrian Chadd 		if (bp == NULL || bufp == NULL) {
1804336716bSAdrian Chadd 			if (i >= MINBUFS)
1814336716bSAdrian Chadd 				break;
1824336716bSAdrian Chadd 			errx(EEXIT, "cannot allocate buffer pool");
1834336716bSAdrian Chadd 		}
1844336716bSAdrian Chadd 		bp->b_un.b_buf = bufp;
1852ec5c914SKirk McKusick 		TAILQ_INSERT_HEAD(&bufhead, bp, b_list);
186ed75b5a1SKirk McKusick 		initbarea(bp, BT_UNKNOWN);
1874336716bSAdrian Chadd 	}
1882ec5c914SKirk McKusick 	numbufs = i;	/* save number of buffers */
189ed75b5a1SKirk McKusick 	for (i = 0; i < BT_NUMBUFTYPES; i++) {
190ed75b5a1SKirk McKusick 		readtime[i].tv_sec = totalreadtime[i].tv_sec = 0;
191ed75b5a1SKirk McKusick 		readtime[i].tv_nsec = totalreadtime[i].tv_nsec = 0;
192ed75b5a1SKirk McKusick 		readcnt[i] = totalreadcnt[i] = 0;
193ed75b5a1SKirk McKusick 	}
1944336716bSAdrian Chadd }
1954336716bSAdrian Chadd 
1964336716bSAdrian Chadd /*
19781fbded2SKirk McKusick  * Manage cylinder group buffers.
19881fbded2SKirk McKusick  */
19981fbded2SKirk McKusick static struct bufarea *cgbufs;	/* header for cylinder group cache */
20081fbded2SKirk McKusick static int flushtries;		/* number of tries to reclaim memory */
20181fbded2SKirk McKusick 
20281fbded2SKirk McKusick struct bufarea *
20381fbded2SKirk McKusick cgget(int cg)
20481fbded2SKirk McKusick {
20581fbded2SKirk McKusick 	struct bufarea *cgbp;
20681fbded2SKirk McKusick 	struct cg *cgp;
20781fbded2SKirk McKusick 
20881fbded2SKirk McKusick 	if (cgbufs == NULL) {
20981fbded2SKirk McKusick 		cgbufs = Calloc(sblock.fs_ncg, sizeof(struct bufarea));
21081fbded2SKirk McKusick 		if (cgbufs == NULL)
21181fbded2SKirk McKusick 			errx(EEXIT, "cannot allocate cylinder group buffers");
21281fbded2SKirk McKusick 	}
21381fbded2SKirk McKusick 	cgbp = &cgbufs[cg];
21481fbded2SKirk McKusick 	if (cgbp->b_un.b_cg != NULL)
21581fbded2SKirk McKusick 		return (cgbp);
21681fbded2SKirk McKusick 	cgp = NULL;
21781fbded2SKirk McKusick 	if (flushtries == 0)
21881fbded2SKirk McKusick 		cgp = malloc((unsigned int)sblock.fs_cgsize);
21981fbded2SKirk McKusick 	if (cgp == NULL) {
22081fbded2SKirk McKusick 		getblk(&cgblk, cgtod(&sblock, cg), sblock.fs_cgsize);
22181fbded2SKirk McKusick 		return (&cgblk);
22281fbded2SKirk McKusick 	}
22381fbded2SKirk McKusick 	cgbp->b_un.b_cg = cgp;
22481fbded2SKirk McKusick 	initbarea(cgbp, BT_CYLGRP);
22581fbded2SKirk McKusick 	getblk(cgbp, cgtod(&sblock, cg), sblock.fs_cgsize);
22681fbded2SKirk McKusick 	return (cgbp);
22781fbded2SKirk McKusick }
22881fbded2SKirk McKusick 
22981fbded2SKirk McKusick /*
23081fbded2SKirk McKusick  * Attempt to flush a cylinder group cache entry.
23181fbded2SKirk McKusick  * Return whether the flush was successful.
23281fbded2SKirk McKusick  */
23381fbded2SKirk McKusick int
23481fbded2SKirk McKusick flushentry(void)
23581fbded2SKirk McKusick {
23681fbded2SKirk McKusick 	struct bufarea *cgbp;
23781fbded2SKirk McKusick 
23881fbded2SKirk McKusick 	cgbp = &cgbufs[flushtries++];
23981fbded2SKirk McKusick 	if (cgbp->b_un.b_cg == NULL)
24081fbded2SKirk McKusick 		return (0);
24181fbded2SKirk McKusick 	flush(fswritefd, cgbp);
24281fbded2SKirk McKusick 	free(cgbp->b_un.b_buf);
24381fbded2SKirk McKusick 	cgbp->b_un.b_buf = NULL;
24481fbded2SKirk McKusick 	return (1);
24581fbded2SKirk McKusick }
24681fbded2SKirk McKusick 
24781fbded2SKirk McKusick /*
2484336716bSAdrian Chadd  * Manage a cache of directory blocks.
2494336716bSAdrian Chadd  */
2504336716bSAdrian Chadd struct bufarea *
251ed75b5a1SKirk McKusick getdatablk(ufs2_daddr_t blkno, long size, int type)
2524336716bSAdrian Chadd {
2533d438ad6SDavid E. O'Brien 	struct bufarea *bp;
2544336716bSAdrian Chadd 
2552ec5c914SKirk McKusick 	TAILQ_FOREACH(bp, &bufhead, b_list)
2564336716bSAdrian Chadd 		if (bp->b_bno == fsbtodb(&sblock, blkno))
2574336716bSAdrian Chadd 			goto foundit;
2582ec5c914SKirk McKusick 	TAILQ_FOREACH_REVERSE(bp, &bufhead, buflist, b_list)
2594336716bSAdrian Chadd 		if ((bp->b_flags & B_INUSE) == 0)
2604336716bSAdrian Chadd 			break;
2612ec5c914SKirk McKusick 	if (bp == NULL)
2624336716bSAdrian Chadd 		errx(EEXIT, "deadlocked buffer pool");
263ed75b5a1SKirk McKusick 	bp->b_type = type;
2644336716bSAdrian Chadd 	getblk(bp, blkno, size);
2654336716bSAdrian Chadd 	/* fall through */
2664336716bSAdrian Chadd foundit:
267ed75b5a1SKirk McKusick 	if (debug && bp->b_type != type)
268ed75b5a1SKirk McKusick 		printf("Buffer type changed from %s to %s\n",
269ed75b5a1SKirk McKusick 		    buftype[bp->b_type], buftype[type]);
2702ec5c914SKirk McKusick 	TAILQ_REMOVE(&bufhead, bp, b_list);
2712ec5c914SKirk McKusick 	TAILQ_INSERT_HEAD(&bufhead, bp, b_list);
2724336716bSAdrian Chadd 	bp->b_flags |= B_INUSE;
2734336716bSAdrian Chadd 	return (bp);
2744336716bSAdrian Chadd }
2754336716bSAdrian Chadd 
276ed75b5a1SKirk McKusick /*
277ed75b5a1SKirk McKusick  * Timespec operations (from <sys/time.h>).
278ed75b5a1SKirk McKusick  */
279ed75b5a1SKirk McKusick #define	timespecsub(vvp, uvp)						\
280ed75b5a1SKirk McKusick 	do {								\
281ed75b5a1SKirk McKusick 		(vvp)->tv_sec -= (uvp)->tv_sec;				\
282ed75b5a1SKirk McKusick 		(vvp)->tv_nsec -= (uvp)->tv_nsec;			\
283ed75b5a1SKirk McKusick 		if ((vvp)->tv_nsec < 0) {				\
284ed75b5a1SKirk McKusick 			(vvp)->tv_sec--;				\
285ed75b5a1SKirk McKusick 			(vvp)->tv_nsec += 1000000000;			\
286ed75b5a1SKirk McKusick 		}							\
287ed75b5a1SKirk McKusick 	} while (0)
288ed75b5a1SKirk McKusick #define	timespecadd(vvp, uvp)						\
289ed75b5a1SKirk McKusick 	do {								\
290ed75b5a1SKirk McKusick 		(vvp)->tv_sec += (uvp)->tv_sec;				\
291ed75b5a1SKirk McKusick 		(vvp)->tv_nsec += (uvp)->tv_nsec;			\
292ed75b5a1SKirk McKusick 		if ((vvp)->tv_nsec >= 1000000000) {			\
293ed75b5a1SKirk McKusick 			(vvp)->tv_sec++;				\
294ed75b5a1SKirk McKusick 			(vvp)->tv_nsec -= 1000000000;			\
295ed75b5a1SKirk McKusick 		}							\
296ed75b5a1SKirk McKusick 	} while (0)
297ed75b5a1SKirk McKusick 
2984336716bSAdrian Chadd void
2991c85e6a3SKirk McKusick getblk(struct bufarea *bp, ufs2_daddr_t blk, long size)
3004336716bSAdrian Chadd {
3011c85e6a3SKirk McKusick 	ufs2_daddr_t dblk;
302ed75b5a1SKirk McKusick 	struct timespec start, finish;
3034336716bSAdrian Chadd 
3044336716bSAdrian Chadd 	dblk = fsbtodb(&sblock, blk);
305ed75b5a1SKirk McKusick 	if (bp->b_bno == dblk) {
306ed75b5a1SKirk McKusick 		totalreads++;
307ed75b5a1SKirk McKusick 	} else {
3084336716bSAdrian Chadd 		flush(fswritefd, bp);
309ed75b5a1SKirk McKusick 		if (debug) {
310ed75b5a1SKirk McKusick 			readcnt[bp->b_type]++;
311ed75b5a1SKirk McKusick 			clock_gettime(CLOCK_REALTIME_PRECISE, &start);
312ed75b5a1SKirk McKusick 		}
313aef8d244SPawel Jakub Dawidek 		bp->b_errs = blread(fsreadfd, bp->b_un.b_buf, dblk, size);
314ed75b5a1SKirk McKusick 		if (debug) {
315ed75b5a1SKirk McKusick 			clock_gettime(CLOCK_REALTIME_PRECISE, &finish);
316ed75b5a1SKirk McKusick 			timespecsub(&finish, &start);
317ed75b5a1SKirk McKusick 			timespecadd(&readtime[bp->b_type], &finish);
318ed75b5a1SKirk McKusick 		}
3194336716bSAdrian Chadd 		bp->b_bno = dblk;
3204336716bSAdrian Chadd 		bp->b_size = size;
3214336716bSAdrian Chadd 	}
3224336716bSAdrian Chadd }
3234336716bSAdrian Chadd 
3244336716bSAdrian Chadd void
325b70cd7eeSWarner Losh flush(int fd, struct bufarea *bp)
3264336716bSAdrian Chadd {
3273d438ad6SDavid E. O'Brien 	int i, j;
3284336716bSAdrian Chadd 
3294336716bSAdrian Chadd 	if (!bp->b_dirty)
3304336716bSAdrian Chadd 		return;
3317578c6abSKirk McKusick 	bp->b_dirty = 0;
3327578c6abSKirk McKusick 	if (fswritefd < 0) {
3337578c6abSKirk McKusick 		pfatal("WRITING IN READ_ONLY MODE.\n");
3347578c6abSKirk McKusick 		return;
3357578c6abSKirk McKusick 	}
3364336716bSAdrian Chadd 	if (bp->b_errs != 0)
337599304a4SPoul-Henning Kamp 		pfatal("WRITING %sZERO'ED BLOCK %lld TO DISK\n",
3384336716bSAdrian Chadd 		    (bp->b_errs == bp->b_size / dev_bsize) ? "" : "PARTIALLY ",
339599304a4SPoul-Henning Kamp 		    (long long)bp->b_bno);
3404336716bSAdrian Chadd 	bp->b_errs = 0;
3414a835375SDavid E. O'Brien 	blwrite(fd, bp->b_un.b_buf, bp->b_bno, bp->b_size);
3424336716bSAdrian Chadd 	if (bp != &sblk)
3434336716bSAdrian Chadd 		return;
3444336716bSAdrian Chadd 	for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
345aef8d244SPawel Jakub Dawidek 		blwrite(fswritefd, (char *)sblock.fs_csp + i,
3464336716bSAdrian Chadd 		    fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
3474336716bSAdrian Chadd 		    sblock.fs_cssize - i < sblock.fs_bsize ?
3484336716bSAdrian Chadd 		    sblock.fs_cssize - i : sblock.fs_bsize);
3494336716bSAdrian Chadd 	}
3504336716bSAdrian Chadd }
3514336716bSAdrian Chadd 
3527578c6abSKirk McKusick void
353599304a4SPoul-Henning Kamp rwerror(const char *mesg, ufs2_daddr_t blk)
3544336716bSAdrian Chadd {
3554336716bSAdrian Chadd 
35615fca934SKirk McKusick 	if (bkgrdcheck)
35715fca934SKirk McKusick 		exit(EEXIT);
3584336716bSAdrian Chadd 	if (preen == 0)
3594336716bSAdrian Chadd 		printf("\n");
360bf58d635SIan Dowse 	pfatal("CANNOT %s: %ld", mesg, (long)blk);
3614336716bSAdrian Chadd 	if (reply("CONTINUE") == 0)
3624336716bSAdrian Chadd 		exit(EEXIT);
3634336716bSAdrian Chadd }
3644336716bSAdrian Chadd 
3654336716bSAdrian Chadd void
366b70cd7eeSWarner Losh ckfini(int markclean)
3674336716bSAdrian Chadd {
3683d438ad6SDavid E. O'Brien 	struct bufarea *bp, *nbp;
3692ec5c914SKirk McKusick 	int ofsmodified, cnt;
3704336716bSAdrian Chadd 
3717578c6abSKirk McKusick 	if (bkgrdflag) {
3727578c6abSKirk McKusick 		unlink(snapname);
3737578c6abSKirk McKusick 		if ((!(sblock.fs_flags & FS_UNCLEAN)) != markclean) {
3747578c6abSKirk McKusick 			cmd.value = FS_UNCLEAN;
3757578c6abSKirk McKusick 			cmd.size = markclean ? -1 : 1;
3767578c6abSKirk McKusick 			if (sysctlbyname("vfs.ffs.setflags", 0, 0,
3777578c6abSKirk McKusick 			    &cmd, sizeof cmd) == -1)
3787578c6abSKirk McKusick 				rwerror("SET FILE SYSTEM FLAGS", FS_UNCLEAN);
3797578c6abSKirk McKusick 			if (!preen) {
3807578c6abSKirk McKusick 				printf("\n***** FILE SYSTEM MARKED %s *****\n",
3817578c6abSKirk McKusick 				    markclean ? "CLEAN" : "DIRTY");
3827578c6abSKirk McKusick 				if (!markclean)
3837578c6abSKirk McKusick 					rerun = 1;
3847578c6abSKirk McKusick 			}
3857578c6abSKirk McKusick 		} else if (!preen && !markclean) {
3867578c6abSKirk McKusick 			printf("\n***** FILE SYSTEM STILL DIRTY *****\n");
3877578c6abSKirk McKusick 			rerun = 1;
3887578c6abSKirk McKusick 		}
3897578c6abSKirk McKusick 	}
3902ec5c914SKirk McKusick 	if (debug && totalreads > 0)
3912ec5c914SKirk McKusick 		printf("cache with %d buffers missed %ld of %ld (%d%%)\n",
392ed75b5a1SKirk McKusick 		    numbufs, totaldiskreads, totalreads,
393ed75b5a1SKirk McKusick 		    (int)(totaldiskreads * 100 / totalreads));
3944336716bSAdrian Chadd 	if (fswritefd < 0) {
3954336716bSAdrian Chadd 		(void)close(fsreadfd);
3964336716bSAdrian Chadd 		return;
3974336716bSAdrian Chadd 	}
3984336716bSAdrian Chadd 	flush(fswritefd, &sblk);
3991c85e6a3SKirk McKusick 	if (havesb && cursnapshot == 0 && sblock.fs_magic == FS_UFS2_MAGIC &&
400ada981b2SKirk McKusick 	    sblk.b_bno != sblock.fs_sblockloc / dev_bsize &&
4014336716bSAdrian Chadd 	    !preen && reply("UPDATE STANDARD SUPERBLOCK")) {
402ada981b2SKirk McKusick 		sblk.b_bno = sblock.fs_sblockloc / dev_bsize;
4034336716bSAdrian Chadd 		sbdirty();
4044336716bSAdrian Chadd 		flush(fswritefd, &sblk);
4054336716bSAdrian Chadd 	}
4064336716bSAdrian Chadd 	flush(fswritefd, &cgblk);
4074336716bSAdrian Chadd 	free(cgblk.b_un.b_buf);
4082ec5c914SKirk McKusick 	cnt = 0;
4092ec5c914SKirk McKusick 	TAILQ_FOREACH_REVERSE_SAFE(bp, &bufhead, buflist, b_list, nbp) {
4102ec5c914SKirk McKusick 		TAILQ_REMOVE(&bufhead, bp, b_list);
4114336716bSAdrian Chadd 		cnt++;
4124336716bSAdrian Chadd 		flush(fswritefd, bp);
4134336716bSAdrian Chadd 		free(bp->b_un.b_buf);
4144336716bSAdrian Chadd 		free((char *)bp);
4154336716bSAdrian Chadd 	}
4162ec5c914SKirk McKusick 	if (numbufs != cnt)
4172ec5c914SKirk McKusick 		errx(EEXIT, "panic: lost %d buffers", numbufs - cnt);
41881fbded2SKirk McKusick 	for (cnt = 0; cnt < sblock.fs_ncg; cnt++) {
41981fbded2SKirk McKusick 		if (cgbufs[cnt].b_un.b_cg == NULL)
42081fbded2SKirk McKusick 			continue;
42181fbded2SKirk McKusick 		flush(fswritefd, &cgbufs[cnt]);
42281fbded2SKirk McKusick 		free(cgbufs[cnt].b_un.b_cg);
42381fbded2SKirk McKusick 	}
42481fbded2SKirk McKusick 	free(cgbufs);
4254336716bSAdrian Chadd 	pbp = pdirbp = (struct bufarea *)0;
4267578c6abSKirk McKusick 	if (cursnapshot == 0 && sblock.fs_clean != markclean) {
42768aff084SKirk McKusick 		if ((sblock.fs_clean = markclean) != 0) {
42838375c40SKirk McKusick 			sblock.fs_flags &= ~(FS_UNCLEAN | FS_NEEDSFSCK);
42968aff084SKirk McKusick 			sblock.fs_pendingblocks = 0;
43068aff084SKirk McKusick 			sblock.fs_pendinginodes = 0;
43168aff084SKirk McKusick 		}
4324336716bSAdrian Chadd 		sbdirty();
4334336716bSAdrian Chadd 		ofsmodified = fsmodified;
4344336716bSAdrian Chadd 		flush(fswritefd, &sblk);
4354336716bSAdrian Chadd 		fsmodified = ofsmodified;
4364336716bSAdrian Chadd 		if (!preen) {
4374336716bSAdrian Chadd 			printf("\n***** FILE SYSTEM MARKED %s *****\n",
4384336716bSAdrian Chadd 			    markclean ? "CLEAN" : "DIRTY");
4394336716bSAdrian Chadd 			if (!markclean)
4404336716bSAdrian Chadd 				rerun = 1;
4414336716bSAdrian Chadd 		}
442910b491eSKirk McKusick 	} else if (!preen) {
443910b491eSKirk McKusick 		if (markclean) {
444910b491eSKirk McKusick 			printf("\n***** FILE SYSTEM IS CLEAN *****\n");
445910b491eSKirk McKusick 		} else {
4464336716bSAdrian Chadd 			printf("\n***** FILE SYSTEM STILL DIRTY *****\n");
4474336716bSAdrian Chadd 			rerun = 1;
4484336716bSAdrian Chadd 		}
449910b491eSKirk McKusick 	}
4504336716bSAdrian Chadd 	(void)close(fsreadfd);
4514336716bSAdrian Chadd 	(void)close(fswritefd);
4524336716bSAdrian Chadd }
4534336716bSAdrian Chadd 
454ed75b5a1SKirk McKusick /*
455ed75b5a1SKirk McKusick  * Print out I/O statistics.
456ed75b5a1SKirk McKusick  */
457ed75b5a1SKirk McKusick void
458ed75b5a1SKirk McKusick IOstats(char *what)
459ed75b5a1SKirk McKusick {
460ed75b5a1SKirk McKusick 	int i;
461ed75b5a1SKirk McKusick 
462ed75b5a1SKirk McKusick 	if (debug == 0)
463ed75b5a1SKirk McKusick 		return;
464ed75b5a1SKirk McKusick 	if (diskreads == 0) {
465ed75b5a1SKirk McKusick 		printf("%s: no I/O\n\n", what);
466ed75b5a1SKirk McKusick 		return;
467ed75b5a1SKirk McKusick 	}
468ed75b5a1SKirk McKusick 	if (startpass.tv_sec == 0)
469ed75b5a1SKirk McKusick 		startpass = startprog;
470ed75b5a1SKirk McKusick 	printf("%s: I/O statistics\n", what);
471ed75b5a1SKirk McKusick 	printIOstats();
472ed75b5a1SKirk McKusick 	totaldiskreads += diskreads;
473ed75b5a1SKirk McKusick 	diskreads = 0;
474ed75b5a1SKirk McKusick 	for (i = 0; i < BT_NUMBUFTYPES; i++) {
475ed75b5a1SKirk McKusick 		timespecadd(&totalreadtime[i], &readtime[i]);
476ed75b5a1SKirk McKusick 		totalreadcnt[i] += readcnt[i];
477ed75b5a1SKirk McKusick 		readtime[i].tv_sec = readtime[i].tv_nsec = 0;
478ed75b5a1SKirk McKusick 		readcnt[i] = 0;
479ed75b5a1SKirk McKusick 	}
480ed75b5a1SKirk McKusick 	clock_gettime(CLOCK_REALTIME_PRECISE, &startpass);
481ed75b5a1SKirk McKusick }
482ed75b5a1SKirk McKusick 
483ed75b5a1SKirk McKusick void
484ed75b5a1SKirk McKusick finalIOstats(void)
485ed75b5a1SKirk McKusick {
486ed75b5a1SKirk McKusick 	int i;
487ed75b5a1SKirk McKusick 
488ed75b5a1SKirk McKusick 	if (debug == 0)
489ed75b5a1SKirk McKusick 		return;
490ed75b5a1SKirk McKusick 	printf("Final I/O statistics\n");
491ed75b5a1SKirk McKusick 	totaldiskreads += diskreads;
492ed75b5a1SKirk McKusick 	diskreads = totaldiskreads;
493ed75b5a1SKirk McKusick 	startpass = startprog;
494ed75b5a1SKirk McKusick 	for (i = 0; i < BT_NUMBUFTYPES; i++) {
495ed75b5a1SKirk McKusick 		timespecadd(&totalreadtime[i], &readtime[i]);
496ed75b5a1SKirk McKusick 		totalreadcnt[i] += readcnt[i];
497ed75b5a1SKirk McKusick 		readtime[i] = totalreadtime[i];
498ed75b5a1SKirk McKusick 		readcnt[i] = totalreadcnt[i];
499ed75b5a1SKirk McKusick 	}
500ed75b5a1SKirk McKusick 	printIOstats();
501ed75b5a1SKirk McKusick }
502ed75b5a1SKirk McKusick 
503ed75b5a1SKirk McKusick static void printIOstats(void)
504ed75b5a1SKirk McKusick {
505ed75b5a1SKirk McKusick 	long long msec, totalmsec;
506ed75b5a1SKirk McKusick 	int i;
507ed75b5a1SKirk McKusick 
508ed75b5a1SKirk McKusick 	clock_gettime(CLOCK_REALTIME_PRECISE, &finishpass);
509ed75b5a1SKirk McKusick 	timespecsub(&finishpass, &startpass);
510061ea59dSKirk McKusick 	printf("Running time: %jd.%03ld sec\n",
5114b3bbe04SSean Bruno 		(intmax_t)finishpass.tv_sec, finishpass.tv_nsec / 1000000);
512ed75b5a1SKirk McKusick 	printf("buffer reads by type:\n");
513ed75b5a1SKirk McKusick 	for (totalmsec = 0, i = 0; i < BT_NUMBUFTYPES; i++)
514ed75b5a1SKirk McKusick 		totalmsec += readtime[i].tv_sec * 1000 +
515ed75b5a1SKirk McKusick 		    readtime[i].tv_nsec / 1000000;
516ed75b5a1SKirk McKusick 	if (totalmsec == 0)
517ed75b5a1SKirk McKusick 		totalmsec = 1;
518ed75b5a1SKirk McKusick 	for (i = 0; i < BT_NUMBUFTYPES; i++) {
519ed75b5a1SKirk McKusick 		if (readcnt[i] == 0)
520ed75b5a1SKirk McKusick 			continue;
521061ea59dSKirk McKusick 		msec =
522061ea59dSKirk McKusick 		    readtime[i].tv_sec * 1000 + readtime[i].tv_nsec / 1000000;
5234b3bbe04SSean Bruno 		printf("%21s:%8ld %2ld.%ld%% %4jd.%03ld sec %2lld.%lld%%\n",
524ed75b5a1SKirk McKusick 		    buftype[i], readcnt[i], readcnt[i] * 100 / diskreads,
52581fbded2SKirk McKusick 		    (readcnt[i] * 1000 / diskreads) % 10,
5264b3bbe04SSean Bruno 		    (intmax_t)readtime[i].tv_sec, readtime[i].tv_nsec / 1000000,
527ed75b5a1SKirk McKusick 		    msec * 100 / totalmsec, (msec * 1000 / totalmsec) % 10);
528ed75b5a1SKirk McKusick 	}
529ed75b5a1SKirk McKusick 	printf("\n");
530ed75b5a1SKirk McKusick }
531ed75b5a1SKirk McKusick 
5324336716bSAdrian Chadd int
533aef8d244SPawel Jakub Dawidek blread(int fd, char *buf, ufs2_daddr_t blk, long size)
5344336716bSAdrian Chadd {
5354336716bSAdrian Chadd 	char *cp;
5364336716bSAdrian Chadd 	int i, errs;
5374336716bSAdrian Chadd 	off_t offset;
5384336716bSAdrian Chadd 
5394336716bSAdrian Chadd 	offset = blk;
5404336716bSAdrian Chadd 	offset *= dev_bsize;
5419d580d7cSIan Dowse 	if (bkgrdflag)
5429d580d7cSIan Dowse 		slowio_start();
543ed75b5a1SKirk McKusick 	totalreads++;
544ed75b5a1SKirk McKusick 	diskreads++;
5454336716bSAdrian Chadd 	if (lseek(fd, offset, 0) < 0)
5467578c6abSKirk McKusick 		rwerror("SEEK BLK", blk);
5479d580d7cSIan Dowse 	else if (read(fd, buf, (int)size) == size) {
5489d580d7cSIan Dowse 		if (bkgrdflag)
5499d580d7cSIan Dowse 			slowio_end();
5504336716bSAdrian Chadd 		return (0);
5519d580d7cSIan Dowse 	}
5527578c6abSKirk McKusick 	rwerror("READ BLK", blk);
5534336716bSAdrian Chadd 	if (lseek(fd, offset, 0) < 0)
5547578c6abSKirk McKusick 		rwerror("SEEK BLK", blk);
5554336716bSAdrian Chadd 	errs = 0;
5564336716bSAdrian Chadd 	memset(buf, 0, (size_t)size);
5574336716bSAdrian Chadd 	printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
5584336716bSAdrian Chadd 	for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
5594336716bSAdrian Chadd 		if (read(fd, cp, (int)secsize) != secsize) {
5604336716bSAdrian Chadd 			(void)lseek(fd, offset + i + secsize, 0);
5614336716bSAdrian Chadd 			if (secsize != dev_bsize && dev_bsize != 1)
56284fc0d7eSMaxime Henrion 				printf(" %jd (%jd),",
56384fc0d7eSMaxime Henrion 				    (intmax_t)(blk * dev_bsize + i) / secsize,
56484fc0d7eSMaxime Henrion 				    (intmax_t)blk + i / dev_bsize);
5654336716bSAdrian Chadd 			else
56684fc0d7eSMaxime Henrion 				printf(" %jd,", (intmax_t)blk + i / dev_bsize);
5674336716bSAdrian Chadd 			errs++;
5684336716bSAdrian Chadd 		}
5694336716bSAdrian Chadd 	}
5704336716bSAdrian Chadd 	printf("\n");
5714336716bSAdrian Chadd 	if (errs)
5724336716bSAdrian Chadd 		resolved = 0;
5734336716bSAdrian Chadd 	return (errs);
5744336716bSAdrian Chadd }
5754336716bSAdrian Chadd 
5764336716bSAdrian Chadd void
5774a835375SDavid E. O'Brien blwrite(int fd, char *buf, ufs2_daddr_t blk, ssize_t size)
5784336716bSAdrian Chadd {
5794336716bSAdrian Chadd 	int i;
5804336716bSAdrian Chadd 	char *cp;
5814336716bSAdrian Chadd 	off_t offset;
5824336716bSAdrian Chadd 
5834336716bSAdrian Chadd 	if (fd < 0)
5844336716bSAdrian Chadd 		return;
5854336716bSAdrian Chadd 	offset = blk;
5864336716bSAdrian Chadd 	offset *= dev_bsize;
5874336716bSAdrian Chadd 	if (lseek(fd, offset, 0) < 0)
5887578c6abSKirk McKusick 		rwerror("SEEK BLK", blk);
5894a835375SDavid E. O'Brien 	else if (write(fd, buf, size) == size) {
5904336716bSAdrian Chadd 		fsmodified = 1;
5914336716bSAdrian Chadd 		return;
5924336716bSAdrian Chadd 	}
5934336716bSAdrian Chadd 	resolved = 0;
5947578c6abSKirk McKusick 	rwerror("WRITE BLK", blk);
5954336716bSAdrian Chadd 	if (lseek(fd, offset, 0) < 0)
5967578c6abSKirk McKusick 		rwerror("SEEK BLK", blk);
5974336716bSAdrian Chadd 	printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
5984336716bSAdrian Chadd 	for (cp = buf, i = 0; i < size; i += dev_bsize, cp += dev_bsize)
5994a835375SDavid E. O'Brien 		if (write(fd, cp, dev_bsize) != dev_bsize) {
6004336716bSAdrian Chadd 			(void)lseek(fd, offset + i + dev_bsize, 0);
60184fc0d7eSMaxime Henrion 			printf(" %jd,", (intmax_t)blk + i / dev_bsize);
6024336716bSAdrian Chadd 		}
6034336716bSAdrian Chadd 	printf("\n");
6044336716bSAdrian Chadd 	return;
6054336716bSAdrian Chadd }
6064336716bSAdrian Chadd 
6078d3dfc26SDag-Erling Smørgrav void
6088d3dfc26SDag-Erling Smørgrav blerase(int fd, ufs2_daddr_t blk, long size)
6098d3dfc26SDag-Erling Smørgrav {
6108d3dfc26SDag-Erling Smørgrav 	off_t ioarg[2];
6118d3dfc26SDag-Erling Smørgrav 
6128d3dfc26SDag-Erling Smørgrav 	if (fd < 0)
6138d3dfc26SDag-Erling Smørgrav 		return;
6148d3dfc26SDag-Erling Smørgrav 	ioarg[0] = blk * dev_bsize;
6158d3dfc26SDag-Erling Smørgrav 	ioarg[1] = size;
6168d3dfc26SDag-Erling Smørgrav 	ioctl(fd, DIOCGDELETE, ioarg);
6178d3dfc26SDag-Erling Smørgrav 	/* we don't really care if we succeed or not */
6188d3dfc26SDag-Erling Smørgrav 	return;
6198d3dfc26SDag-Erling Smørgrav }
6208d3dfc26SDag-Erling Smørgrav 
621*2b5373deSDag-Erling Smørgrav void
622*2b5373deSDag-Erling Smørgrav blzero(int fd, ufs2_daddr_t blk, long size)
623*2b5373deSDag-Erling Smørgrav {
624*2b5373deSDag-Erling Smørgrav 	static char *zero;
625*2b5373deSDag-Erling Smørgrav 	off_t offset, len;
626*2b5373deSDag-Erling Smørgrav 
627*2b5373deSDag-Erling Smørgrav 	if (fd < 0)
628*2b5373deSDag-Erling Smørgrav 		return;
629*2b5373deSDag-Erling Smørgrav 	len = ZEROBUFSIZE;
630*2b5373deSDag-Erling Smørgrav 	if (zero == NULL) {
631*2b5373deSDag-Erling Smørgrav 		zero = calloc(len, 1);
632*2b5373deSDag-Erling Smørgrav 		if (zero == NULL)
633*2b5373deSDag-Erling Smørgrav 			errx(EEXIT, "cannot allocate buffer pool");
634*2b5373deSDag-Erling Smørgrav 	}
635*2b5373deSDag-Erling Smørgrav 	offset = blk * dev_bsize;
636*2b5373deSDag-Erling Smørgrav 	if (lseek(fd, offset, 0) < 0)
637*2b5373deSDag-Erling Smørgrav 		rwerror("SEEK BLK", blk);
638*2b5373deSDag-Erling Smørgrav 	while (size > 0) {
639*2b5373deSDag-Erling Smørgrav 		if (size > len)
640*2b5373deSDag-Erling Smørgrav 			size = len;
641*2b5373deSDag-Erling Smørgrav 		else
642*2b5373deSDag-Erling Smørgrav 			len = size;
643*2b5373deSDag-Erling Smørgrav 		if (write(fd, zero, len) != len)
644*2b5373deSDag-Erling Smørgrav 			rwerror("WRITE BLK", blk);
645*2b5373deSDag-Erling Smørgrav 		blk += len / dev_bsize;
646*2b5373deSDag-Erling Smørgrav 		size -= len;
647*2b5373deSDag-Erling Smørgrav 	}
648*2b5373deSDag-Erling Smørgrav }
649*2b5373deSDag-Erling Smørgrav 
6504336716bSAdrian Chadd /*
651910b491eSKirk McKusick  * Verify cylinder group's magic number and other parameters.  If the
652910b491eSKirk McKusick  * test fails, offer an option to rebuild the whole cylinder group.
65314320f1eSXin LI  */
654910b491eSKirk McKusick int
65581fbded2SKirk McKusick check_cgmagic(int cg, struct bufarea *cgbp)
65614320f1eSXin LI {
65781fbded2SKirk McKusick 	struct cg *cgp = cgbp->b_un.b_cg;
65814320f1eSXin LI 
659910b491eSKirk McKusick 	/*
660910b491eSKirk McKusick 	 * Extended cylinder group checks.
661910b491eSKirk McKusick 	 */
662910b491eSKirk McKusick 	if (cg_chkmagic(cgp) &&
663910b491eSKirk McKusick 	    ((sblock.fs_magic == FS_UFS1_MAGIC &&
664910b491eSKirk McKusick 	      cgp->cg_old_niblk == sblock.fs_ipg &&
665910b491eSKirk McKusick 	      cgp->cg_ndblk <= sblock.fs_fpg &&
66636ef6b65SKirk McKusick 	      cgp->cg_old_ncyl <= sblock.fs_old_cpg) ||
667910b491eSKirk McKusick 	     (sblock.fs_magic == FS_UFS2_MAGIC &&
668910b491eSKirk McKusick 	      cgp->cg_niblk == sblock.fs_ipg &&
669910b491eSKirk McKusick 	      cgp->cg_ndblk <= sblock.fs_fpg &&
670910b491eSKirk McKusick 	      cgp->cg_initediblk <= sblock.fs_ipg))) {
671910b491eSKirk McKusick 		return (1);
672910b491eSKirk McKusick 	}
673910b491eSKirk McKusick 	pfatal("CYLINDER GROUP %d: BAD MAGIC NUMBER", cg);
674910b491eSKirk McKusick 	if (!reply("REBUILD CYLINDER GROUP")) {
675910b491eSKirk McKusick 		printf("YOU WILL NEED TO RERUN FSCK.\n");
676910b491eSKirk McKusick 		rerun = 1;
677910b491eSKirk McKusick 		return (1);
678910b491eSKirk McKusick 	}
679910b491eSKirk McKusick 	/*
680910b491eSKirk McKusick 	 * Zero out the cylinder group and then initialize critical fields.
681910b491eSKirk McKusick 	 * Bit maps and summaries will be recalculated by later passes.
682910b491eSKirk McKusick 	 */
68314320f1eSXin LI 	memset(cgp, 0, (size_t)sblock.fs_cgsize);
684910b491eSKirk McKusick 	cgp->cg_magic = CG_MAGIC;
68514320f1eSXin LI 	cgp->cg_cgx = cg;
68614320f1eSXin LI 	cgp->cg_niblk = sblock.fs_ipg;
687910b491eSKirk McKusick 	cgp->cg_initediblk = sblock.fs_ipg < 2 * INOPB(&sblock) ?
688910b491eSKirk McKusick 	    sblock.fs_ipg : 2 * INOPB(&sblock);
689910b491eSKirk McKusick 	if (cgbase(&sblock, cg) + sblock.fs_fpg < sblock.fs_size)
690910b491eSKirk McKusick 		cgp->cg_ndblk = sblock.fs_fpg;
691910b491eSKirk McKusick 	else
69214320f1eSXin LI 		cgp->cg_ndblk = sblock.fs_size - cgbase(&sblock, cg);
693910b491eSKirk McKusick 	cgp->cg_iusedoff = &cgp->cg_space[0] - (u_char *)(&cgp->cg_firstfield);
694910b491eSKirk McKusick 	if (sblock.fs_magic == FS_UFS1_MAGIC) {
695910b491eSKirk McKusick 		cgp->cg_niblk = 0;
696910b491eSKirk McKusick 		cgp->cg_initediblk = 0;
697910b491eSKirk McKusick 		cgp->cg_old_ncyl = sblock.fs_old_cpg;
698910b491eSKirk McKusick 		cgp->cg_old_niblk = sblock.fs_ipg;
699910b491eSKirk McKusick 		cgp->cg_old_btotoff = cgp->cg_iusedoff;
700910b491eSKirk McKusick 		cgp->cg_old_boff = cgp->cg_old_btotoff +
701910b491eSKirk McKusick 		    sblock.fs_old_cpg * sizeof(int32_t);
702910b491eSKirk McKusick 		cgp->cg_iusedoff = cgp->cg_old_boff +
703910b491eSKirk McKusick 		    sblock.fs_old_cpg * sizeof(u_int16_t);
704910b491eSKirk McKusick 	}
705910b491eSKirk McKusick 	cgp->cg_freeoff = cgp->cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
706910b491eSKirk McKusick 	cgp->cg_nextfreeoff = cgp->cg_freeoff + howmany(sblock.fs_fpg,CHAR_BIT);
707910b491eSKirk McKusick 	if (sblock.fs_contigsumsize > 0) {
708910b491eSKirk McKusick 		cgp->cg_nclusterblks = cgp->cg_ndblk / sblock.fs_frag;
709910b491eSKirk McKusick 		cgp->cg_clustersumoff =
710910b491eSKirk McKusick 		    roundup(cgp->cg_nextfreeoff, sizeof(u_int32_t));
711910b491eSKirk McKusick 		cgp->cg_clustersumoff -= sizeof(u_int32_t);
712910b491eSKirk McKusick 		cgp->cg_clusteroff = cgp->cg_clustersumoff +
713910b491eSKirk McKusick 		    (sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
714910b491eSKirk McKusick 		cgp->cg_nextfreeoff = cgp->cg_clusteroff +
715910b491eSKirk McKusick 		    howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
716910b491eSKirk McKusick 	}
71781fbded2SKirk McKusick 	dirty(cgbp);
718910b491eSKirk McKusick 	return (0);
71914320f1eSXin LI }
72014320f1eSXin LI 
72114320f1eSXin LI /*
7224336716bSAdrian Chadd  * allocate a data block with the specified number of fragments
7234336716bSAdrian Chadd  */
7241c85e6a3SKirk McKusick ufs2_daddr_t
725b70cd7eeSWarner Losh allocblk(long frags)
7264336716bSAdrian Chadd {
7274336716bSAdrian Chadd 	int i, j, k, cg, baseblk;
72881fbded2SKirk McKusick 	struct bufarea *cgbp;
72981fbded2SKirk McKusick 	struct cg *cgp;
7304336716bSAdrian Chadd 
7314336716bSAdrian Chadd 	if (frags <= 0 || frags > sblock.fs_frag)
7324336716bSAdrian Chadd 		return (0);
7334336716bSAdrian Chadd 	for (i = 0; i < maxfsblock - sblock.fs_frag; i += sblock.fs_frag) {
7344336716bSAdrian Chadd 		for (j = 0; j <= sblock.fs_frag - frags; j++) {
7354336716bSAdrian Chadd 			if (testbmap(i + j))
7364336716bSAdrian Chadd 				continue;
7374336716bSAdrian Chadd 			for (k = 1; k < frags; k++)
7384336716bSAdrian Chadd 				if (testbmap(i + j + k))
7394336716bSAdrian Chadd 					break;
7404336716bSAdrian Chadd 			if (k < frags) {
7414336716bSAdrian Chadd 				j += k;
7424336716bSAdrian Chadd 				continue;
7434336716bSAdrian Chadd 			}
7444336716bSAdrian Chadd 			cg = dtog(&sblock, i + j);
74581fbded2SKirk McKusick 			cgbp = cgget(cg);
74681fbded2SKirk McKusick 			cgp = cgbp->b_un.b_cg;
74781fbded2SKirk McKusick 			if (!check_cgmagic(cg, cgbp))
748910b491eSKirk McKusick 				return (0);
7494336716bSAdrian Chadd 			baseblk = dtogd(&sblock, i + j);
7504336716bSAdrian Chadd 			for (k = 0; k < frags; k++) {
7514336716bSAdrian Chadd 				setbmap(i + j + k);
7524336716bSAdrian Chadd 				clrbit(cg_blksfree(cgp), baseblk + k);
7534336716bSAdrian Chadd 			}
7544336716bSAdrian Chadd 			n_blks += frags;
7554336716bSAdrian Chadd 			if (frags == sblock.fs_frag)
7564336716bSAdrian Chadd 				cgp->cg_cs.cs_nbfree--;
7574336716bSAdrian Chadd 			else
7584336716bSAdrian Chadd 				cgp->cg_cs.cs_nffree -= frags;
75981fbded2SKirk McKusick 			dirty(cgbp);
7604336716bSAdrian Chadd 			return (i + j);
7614336716bSAdrian Chadd 		}
7624336716bSAdrian Chadd 	}
7634336716bSAdrian Chadd 	return (0);
7644336716bSAdrian Chadd }
7654336716bSAdrian Chadd 
7664336716bSAdrian Chadd /*
7674336716bSAdrian Chadd  * Free a previously allocated block
7684336716bSAdrian Chadd  */
7694336716bSAdrian Chadd void
7701c85e6a3SKirk McKusick freeblk(ufs2_daddr_t blkno, long frags)
7714336716bSAdrian Chadd {
7724336716bSAdrian Chadd 	struct inodesc idesc;
7734336716bSAdrian Chadd 
7744336716bSAdrian Chadd 	idesc.id_blkno = blkno;
7754336716bSAdrian Chadd 	idesc.id_numfrags = frags;
7764336716bSAdrian Chadd 	(void)pass4check(&idesc);
7774336716bSAdrian Chadd }
7784336716bSAdrian Chadd 
7799d580d7cSIan Dowse /* Slow down IO so as to leave some disk bandwidth for other processes */
7809d580d7cSIan Dowse void
7819d580d7cSIan Dowse slowio_start()
7829d580d7cSIan Dowse {
7839d580d7cSIan Dowse 
78408983aeeSScott Long 	/* Delay one in every 8 operations */
7859d580d7cSIan Dowse 	slowio_pollcnt = (slowio_pollcnt + 1) & 7;
7869d580d7cSIan Dowse 	if (slowio_pollcnt == 0) {
7879d580d7cSIan Dowse 		gettimeofday(&slowio_starttime, NULL);
7889d580d7cSIan Dowse 	}
7899d580d7cSIan Dowse }
7909d580d7cSIan Dowse 
7919d580d7cSIan Dowse void
7929d580d7cSIan Dowse slowio_end()
7939d580d7cSIan Dowse {
7949d580d7cSIan Dowse 	struct timeval tv;
7959d580d7cSIan Dowse 	int delay_usec;
7969d580d7cSIan Dowse 
7979d580d7cSIan Dowse 	if (slowio_pollcnt != 0)
7989d580d7cSIan Dowse 		return;
7999d580d7cSIan Dowse 
8009d580d7cSIan Dowse 	/* Update the slowdown interval. */
8019d580d7cSIan Dowse 	gettimeofday(&tv, NULL);
8029d580d7cSIan Dowse 	delay_usec = (tv.tv_sec - slowio_starttime.tv_sec) * 1000000 +
8039d580d7cSIan Dowse 	    (tv.tv_usec - slowio_starttime.tv_usec);
8049d580d7cSIan Dowse 	if (delay_usec < 64)
8059d580d7cSIan Dowse 		delay_usec = 64;
80608983aeeSScott Long 	if (delay_usec > 2500000)
80708983aeeSScott Long 		delay_usec = 2500000;
8089d580d7cSIan Dowse 	slowio_delay_usec = (slowio_delay_usec * 63 + delay_usec) >> 6;
80908983aeeSScott Long 	/* delay by 8 times the average IO delay */
81008983aeeSScott Long 	if (slowio_delay_usec > 64)
81108983aeeSScott Long 		usleep(slowio_delay_usec * 8);
8129d580d7cSIan Dowse }
8139d580d7cSIan Dowse 
8144336716bSAdrian Chadd /*
8154336716bSAdrian Chadd  * Find a pathname
8164336716bSAdrian Chadd  */
8174336716bSAdrian Chadd void
818b70cd7eeSWarner Losh getpathname(char *namebuf, ino_t curdir, ino_t ino)
8194336716bSAdrian Chadd {
8204336716bSAdrian Chadd 	int len;
8213d438ad6SDavid E. O'Brien 	char *cp;
8224336716bSAdrian Chadd 	struct inodesc idesc;
8234336716bSAdrian Chadd 	static int busy = 0;
8244336716bSAdrian Chadd 
8254336716bSAdrian Chadd 	if (curdir == ino && ino == ROOTINO) {
8264336716bSAdrian Chadd 		(void)strcpy(namebuf, "/");
8274336716bSAdrian Chadd 		return;
8284336716bSAdrian Chadd 	}
829af6726e6SDon Lewis 	if (busy || !INO_IS_DVALID(curdir)) {
8304336716bSAdrian Chadd 		(void)strcpy(namebuf, "?");
8314336716bSAdrian Chadd 		return;
8324336716bSAdrian Chadd 	}
8334336716bSAdrian Chadd 	busy = 1;
8344336716bSAdrian Chadd 	memset(&idesc, 0, sizeof(struct inodesc));
8354336716bSAdrian Chadd 	idesc.id_type = DATA;
8364336716bSAdrian Chadd 	idesc.id_fix = IGNORE;
8374336716bSAdrian Chadd 	cp = &namebuf[MAXPATHLEN - 1];
8384336716bSAdrian Chadd 	*cp = '\0';
8394336716bSAdrian Chadd 	if (curdir != ino) {
8404336716bSAdrian Chadd 		idesc.id_parent = curdir;
8414336716bSAdrian Chadd 		goto namelookup;
8424336716bSAdrian Chadd 	}
8434336716bSAdrian Chadd 	while (ino != ROOTINO) {
8444336716bSAdrian Chadd 		idesc.id_number = ino;
8454336716bSAdrian Chadd 		idesc.id_func = findino;
846599304a4SPoul-Henning Kamp 		idesc.id_name = strdup("..");
8474336716bSAdrian Chadd 		if ((ckinode(ginode(ino), &idesc) & FOUND) == 0)
8484336716bSAdrian Chadd 			break;
8494336716bSAdrian Chadd 	namelookup:
8504336716bSAdrian Chadd 		idesc.id_number = idesc.id_parent;
8514336716bSAdrian Chadd 		idesc.id_parent = ino;
8524336716bSAdrian Chadd 		idesc.id_func = findname;
8534336716bSAdrian Chadd 		idesc.id_name = namebuf;
8544336716bSAdrian Chadd 		if ((ckinode(ginode(idesc.id_number), &idesc)&FOUND) == 0)
8554336716bSAdrian Chadd 			break;
8564336716bSAdrian Chadd 		len = strlen(namebuf);
8574336716bSAdrian Chadd 		cp -= len;
8584336716bSAdrian Chadd 		memmove(cp, namebuf, (size_t)len);
8594336716bSAdrian Chadd 		*--cp = '/';
8604336716bSAdrian Chadd 		if (cp < &namebuf[MAXNAMLEN])
8614336716bSAdrian Chadd 			break;
8624336716bSAdrian Chadd 		ino = idesc.id_number;
8634336716bSAdrian Chadd 	}
8644336716bSAdrian Chadd 	busy = 0;
8654336716bSAdrian Chadd 	if (ino != ROOTINO)
8664336716bSAdrian Chadd 		*--cp = '?';
8674336716bSAdrian Chadd 	memmove(namebuf, cp, (size_t)(&namebuf[MAXPATHLEN] - cp));
8684336716bSAdrian Chadd }
8694336716bSAdrian Chadd 
8704336716bSAdrian Chadd void
871599304a4SPoul-Henning Kamp catch(int sig __unused)
8724336716bSAdrian Chadd {
873381ee4c2SPoul-Henning Kamp 
8744336716bSAdrian Chadd 	ckfini(0);
8754336716bSAdrian Chadd 	exit(12);
8764336716bSAdrian Chadd }
8774336716bSAdrian Chadd 
8784336716bSAdrian Chadd /*
8794336716bSAdrian Chadd  * When preening, allow a single quit to signal
8804336716bSAdrian Chadd  * a special exit after file system checks complete
8814336716bSAdrian Chadd  * so that reboot sequence may be interrupted.
8824336716bSAdrian Chadd  */
8834336716bSAdrian Chadd void
884599304a4SPoul-Henning Kamp catchquit(int sig __unused)
8854336716bSAdrian Chadd {
8864336716bSAdrian Chadd 	printf("returning to single-user after file system check\n");
8874336716bSAdrian Chadd 	returntosingle = 1;
8884336716bSAdrian Chadd 	(void)signal(SIGQUIT, SIG_DFL);
8894336716bSAdrian Chadd }
8904336716bSAdrian Chadd 
8914336716bSAdrian Chadd /*
8924336716bSAdrian Chadd  * determine whether an inode should be fixed.
8934336716bSAdrian Chadd  */
8944336716bSAdrian Chadd int
895599304a4SPoul-Henning Kamp dofix(struct inodesc *idesc, const char *msg)
8964336716bSAdrian Chadd {
8974336716bSAdrian Chadd 
8984336716bSAdrian Chadd 	switch (idesc->id_fix) {
8994336716bSAdrian Chadd 
9004336716bSAdrian Chadd 	case DONTKNOW:
9014336716bSAdrian Chadd 		if (idesc->id_type == DATA)
9024336716bSAdrian Chadd 			direrror(idesc->id_number, msg);
9034336716bSAdrian Chadd 		else
9045979df34SKris Kennaway 			pwarn("%s", msg);
9054336716bSAdrian Chadd 		if (preen) {
9064336716bSAdrian Chadd 			printf(" (SALVAGED)\n");
9074336716bSAdrian Chadd 			idesc->id_fix = FIX;
9084336716bSAdrian Chadd 			return (ALTERED);
9094336716bSAdrian Chadd 		}
9104336716bSAdrian Chadd 		if (reply("SALVAGE") == 0) {
9114336716bSAdrian Chadd 			idesc->id_fix = NOFIX;
9124336716bSAdrian Chadd 			return (0);
9134336716bSAdrian Chadd 		}
9144336716bSAdrian Chadd 		idesc->id_fix = FIX;
9154336716bSAdrian Chadd 		return (ALTERED);
9164336716bSAdrian Chadd 
9174336716bSAdrian Chadd 	case FIX:
9184336716bSAdrian Chadd 		return (ALTERED);
9194336716bSAdrian Chadd 
9204336716bSAdrian Chadd 	case NOFIX:
9214336716bSAdrian Chadd 	case IGNORE:
9224336716bSAdrian Chadd 		return (0);
9234336716bSAdrian Chadd 
9244336716bSAdrian Chadd 	default:
9254336716bSAdrian Chadd 		errx(EEXIT, "UNKNOWN INODESC FIX MODE %d", idesc->id_fix);
9264336716bSAdrian Chadd 	}
9274336716bSAdrian Chadd 	/* NOTREACHED */
9284336716bSAdrian Chadd 	return (0);
9294336716bSAdrian Chadd }
9304336716bSAdrian Chadd 
9314336716bSAdrian Chadd #include <stdarg.h>
9324336716bSAdrian Chadd 
9334336716bSAdrian Chadd /*
9344b85a12fSUlrich Spörlein  * An unexpected inconsistency occurred.
9354336716bSAdrian Chadd  * Die if preening or file system is running with soft dependency protocol,
9364336716bSAdrian Chadd  * otherwise just print message and continue.
9374336716bSAdrian Chadd  */
9384336716bSAdrian Chadd void
9394336716bSAdrian Chadd pfatal(const char *fmt, ...)
9404336716bSAdrian Chadd {
9414336716bSAdrian Chadd 	va_list ap;
9424336716bSAdrian Chadd 	va_start(ap, fmt);
9434336716bSAdrian Chadd 	if (!preen) {
94415fca934SKirk McKusick 		(void)vfprintf(stdout, fmt, ap);
9454336716bSAdrian Chadd 		va_end(ap);
9464336716bSAdrian Chadd 		if (usedsoftdep)
94715fca934SKirk McKusick 			(void)fprintf(stdout,
9484336716bSAdrian Chadd 			    "\nUNEXPECTED SOFT UPDATE INCONSISTENCY\n");
94938375c40SKirk McKusick 		/*
95038375c40SKirk McKusick 		 * Force foreground fsck to clean up inconsistency.
95138375c40SKirk McKusick 		 */
95238375c40SKirk McKusick 		if (bkgrdflag) {
95338375c40SKirk McKusick 			cmd.value = FS_NEEDSFSCK;
95438375c40SKirk McKusick 			cmd.size = 1;
95538375c40SKirk McKusick 			if (sysctlbyname("vfs.ffs.setflags", 0, 0,
95638375c40SKirk McKusick 			    &cmd, sizeof cmd) == -1)
95738375c40SKirk McKusick 				pwarn("CANNOT SET FS_NEEDSFSCK FLAG\n");
95815fca934SKirk McKusick 			fprintf(stdout, "CANNOT RUN IN BACKGROUND\n");
95938375c40SKirk McKusick 			ckfini(0);
96038375c40SKirk McKusick 			exit(EEXIT);
96138375c40SKirk McKusick 		}
9624336716bSAdrian Chadd 		return;
9634336716bSAdrian Chadd 	}
9644336716bSAdrian Chadd 	if (cdevname == NULL)
965599304a4SPoul-Henning Kamp 		cdevname = strdup("fsck");
96615fca934SKirk McKusick 	(void)fprintf(stdout, "%s: ", cdevname);
96715fca934SKirk McKusick 	(void)vfprintf(stdout, fmt, ap);
96815fca934SKirk McKusick 	(void)fprintf(stdout,
9694336716bSAdrian Chadd 	    "\n%s: UNEXPECTED%sINCONSISTENCY; RUN fsck MANUALLY.\n",
9704336716bSAdrian Chadd 	    cdevname, usedsoftdep ? " SOFT UPDATE " : " ");
97138375c40SKirk McKusick 	/*
97238375c40SKirk McKusick 	 * Force foreground fsck to clean up inconsistency.
97338375c40SKirk McKusick 	 */
97438375c40SKirk McKusick 	if (bkgrdflag) {
97538375c40SKirk McKusick 		cmd.value = FS_NEEDSFSCK;
97638375c40SKirk McKusick 		cmd.size = 1;
97738375c40SKirk McKusick 		if (sysctlbyname("vfs.ffs.setflags", 0, 0,
97838375c40SKirk McKusick 		    &cmd, sizeof cmd) == -1)
97938375c40SKirk McKusick 			pwarn("CANNOT SET FS_NEEDSFSCK FLAG\n");
98038375c40SKirk McKusick 	}
9814336716bSAdrian Chadd 	ckfini(0);
9824336716bSAdrian Chadd 	exit(EEXIT);
9834336716bSAdrian Chadd }
9844336716bSAdrian Chadd 
9854336716bSAdrian Chadd /*
9864336716bSAdrian Chadd  * Pwarn just prints a message when not preening or running soft dependency
9874336716bSAdrian Chadd  * protocol, or a warning (preceded by filename) when preening.
9884336716bSAdrian Chadd  */
9894336716bSAdrian Chadd void
9904336716bSAdrian Chadd pwarn(const char *fmt, ...)
9914336716bSAdrian Chadd {
9924336716bSAdrian Chadd 	va_list ap;
9934336716bSAdrian Chadd 	va_start(ap, fmt);
9944336716bSAdrian Chadd 	if (preen)
99515fca934SKirk McKusick 		(void)fprintf(stdout, "%s: ", cdevname);
99615fca934SKirk McKusick 	(void)vfprintf(stdout, fmt, ap);
9974336716bSAdrian Chadd 	va_end(ap);
9984336716bSAdrian Chadd }
9994336716bSAdrian Chadd 
10004336716bSAdrian Chadd /*
10014336716bSAdrian Chadd  * Stub for routines from kernel.
10024336716bSAdrian Chadd  */
10034336716bSAdrian Chadd void
10044336716bSAdrian Chadd panic(const char *fmt, ...)
10054336716bSAdrian Chadd {
10064336716bSAdrian Chadd 	va_list ap;
10074336716bSAdrian Chadd 	va_start(ap, fmt);
10084336716bSAdrian Chadd 	pfatal("INTERNAL INCONSISTENCY:");
100915fca934SKirk McKusick 	(void)vfprintf(stdout, fmt, ap);
10104336716bSAdrian Chadd 	va_end(ap);
10114336716bSAdrian Chadd 	exit(EEXIT);
10124336716bSAdrian Chadd }
1013