1/*
2 * Copyright (c) 1980, 1986, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#if 0
31#ifndef lint
32static const char sccsid[] = "@(#)utilities.c	8.6 (Berkeley) 5/19/95";
33#endif /* not lint */
34#endif
35#include <sys/cdefs.h>
36__FBSDID("$FreeBSD$");
37
38#include <sys/param.h>
39#include <sys/time.h>
40#include <sys/types.h>
41#include <sys/sysctl.h>
42#include <sys/disk.h>
43#include <sys/disklabel.h>
44#include <sys/ioctl.h>
45#include <sys/stat.h>
46
47#include <ufs/ufs/dinode.h>
48#include <ufs/ufs/dir.h>
49#include <ufs/ffs/fs.h>
50
51#include <err.h>
52#include <errno.h>
53#include <string.h>
54#include <ctype.h>
55#include <fstab.h>
56#include <stdint.h>
57#include <stdio.h>
58#include <stdlib.h>
59#include <time.h>
60#include <unistd.h>
61
62#include "fsck.h"
63
64static void slowio_start(void);
65static void slowio_end(void);
66static void printIOstats(void);
67
68static long diskreads, totaldiskreads, totalreads; /* Disk cache statistics */
69static struct timespec startpass, finishpass;
70struct timeval slowio_starttime;
71int slowio_delay_usec = 10000;	/* Initial IO delay for background fsck */
72int slowio_pollcnt;
73static struct bufarea cgblk;	/* backup buffer for cylinder group blocks */
74static TAILQ_HEAD(buflist, bufarea) bufhead;	/* head of buffer cache list */
75static int numbufs;				/* size of buffer cache */
76static char *buftype[BT_NUMBUFTYPES] = BT_NAMES;
77
78int
79ftypeok(union dinode *dp)
80{
81	switch (DIP(dp, di_mode) & IFMT) {
82
83	case IFDIR:
84	case IFREG:
85	case IFBLK:
86	case IFCHR:
87	case IFLNK:
88	case IFSOCK:
89	case IFIFO:
90		return (1);
91
92	default:
93		if (debug)
94			printf("bad file type 0%o\n", DIP(dp, di_mode));
95		return (0);
96	}
97}
98
99int
100reply(const char *question)
101{
102	int persevere;
103	char c;
104
105	if (preen)
106		pfatal("INTERNAL ERROR: GOT TO reply()");
107	persevere = !strcmp(question, "CONTINUE");
108	printf("\n");
109	if (!persevere && (nflag || (fswritefd < 0 && bkgrdflag == 0))) {
110		printf("%s? no\n\n", question);
111		resolved = 0;
112		return (0);
113	}
114	if (yflag || (persevere && nflag)) {
115		printf("%s? yes\n\n", question);
116		return (1);
117	}
118	do	{
119		printf("%s? [yn] ", question);
120		(void) fflush(stdout);
121		c = getc(stdin);
122		while (c != '\n' && getc(stdin) != '\n') {
123			if (feof(stdin)) {
124				resolved = 0;
125				return (0);
126			}
127		}
128	} while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
129	printf("\n");
130	if (c == 'y' || c == 'Y')
131		return (1);
132	resolved = 0;
133	return (0);
134}
135
136/*
137 * Look up state information for an inode.
138 */
139struct inostat *
140inoinfo(ino_t inum)
141{
142	static struct inostat unallocated = { USTATE, 0, 0 };
143	struct inostatlist *ilp;
144	int iloff;
145
146	if (inum > maxino)
147		errx(EEXIT, "inoinfo: inumber %ju out of range",
148		    (uintmax_t)inum);
149	ilp = &inostathead[inum / sblock.fs_ipg];
150	iloff = inum % sblock.fs_ipg;
151	if (iloff >= ilp->il_numalloced)
152		return (&unallocated);
153	return (&ilp->il_stat[iloff]);
154}
155
156/*
157 * Malloc buffers and set up cache.
158 */
159void
160bufinit(void)
161{
162	struct bufarea *bp;
163	long bufcnt, i;
164	char *bufp;
165
166	pbp = pdirbp = (struct bufarea *)0;
167	bufp = Malloc((unsigned int)sblock.fs_bsize);
168	if (bufp == 0)
169		errx(EEXIT, "cannot allocate buffer pool");
170	cgblk.b_un.b_buf = bufp;
171	initbarea(&cgblk, BT_CYLGRP);
172	TAILQ_INIT(&bufhead);
173	bufcnt = MAXBUFS;
174	if (bufcnt < MINBUFS)
175		bufcnt = MINBUFS;
176	for (i = 0; i < bufcnt; i++) {
177		bp = (struct bufarea *)Malloc(sizeof(struct bufarea));
178		bufp = Malloc((unsigned int)sblock.fs_bsize);
179		if (bp == NULL || bufp == NULL) {
180			if (i >= MINBUFS)
181				break;
182			errx(EEXIT, "cannot allocate buffer pool");
183		}
184		bp->b_un.b_buf = bufp;
185		TAILQ_INSERT_HEAD(&bufhead, bp, b_list);
186		initbarea(bp, BT_UNKNOWN);
187	}
188	numbufs = i;	/* save number of buffers */
189	for (i = 0; i < BT_NUMBUFTYPES; i++) {
190		readtime[i].tv_sec = totalreadtime[i].tv_sec = 0;
191		readtime[i].tv_nsec = totalreadtime[i].tv_nsec = 0;
192		readcnt[i] = totalreadcnt[i] = 0;
193	}
194}
195
196/*
197 * Manage cylinder group buffers.
198 */
199static struct bufarea *cgbufs;	/* header for cylinder group cache */
200static int flushtries;		/* number of tries to reclaim memory */
201
202struct bufarea *
203cgget(int cg)
204{
205	struct bufarea *cgbp;
206	struct cg *cgp;
207
208	if (cgbufs == NULL) {
209		cgbufs = Calloc(sblock.fs_ncg, sizeof(struct bufarea));
210		if (cgbufs == NULL)
211			errx(EEXIT, "cannot allocate cylinder group buffers");
212	}
213	cgbp = &cgbufs[cg];
214	if (cgbp->b_un.b_cg != NULL)
215		return (cgbp);
216	cgp = NULL;
217	if (flushtries == 0)
218		cgp = malloc((unsigned int)sblock.fs_cgsize);
219	if (cgp == NULL) {
220		getblk(&cgblk, cgtod(&sblock, cg), sblock.fs_cgsize);
221		return (&cgblk);
222	}
223	cgbp->b_un.b_cg = cgp;
224	initbarea(cgbp, BT_CYLGRP);
225	getblk(cgbp, cgtod(&sblock, cg), sblock.fs_cgsize);
226	return (cgbp);
227}
228
229/*
230 * Attempt to flush a cylinder group cache entry.
231 * Return whether the flush was successful.
232 */
233int
234flushentry(void)
235{
236	struct bufarea *cgbp;
237
238	cgbp = &cgbufs[flushtries++];
239	if (cgbp->b_un.b_cg == NULL)
240		return (0);
241	flush(fswritefd, cgbp);
242	free(cgbp->b_un.b_buf);
243	cgbp->b_un.b_buf = NULL;
244	return (1);
245}
246
247/*
248 * Manage a cache of directory blocks.
249 */
250struct bufarea *
251getdatablk(ufs2_daddr_t blkno, long size, int type)
252{
253	struct bufarea *bp;
254
255	TAILQ_FOREACH(bp, &bufhead, b_list)
256		if (bp->b_bno == fsbtodb(&sblock, blkno))
257			goto foundit;
258	TAILQ_FOREACH_REVERSE(bp, &bufhead, buflist, b_list)
259		if ((bp->b_flags & B_INUSE) == 0)
260			break;
261	if (bp == NULL)
262		errx(EEXIT, "deadlocked buffer pool");
263	bp->b_type = type;
264	getblk(bp, blkno, size);
265	/* fall through */
266foundit:
267	if (debug && bp->b_type != type)
268		printf("Buffer type changed from %s to %s\n",
269		    buftype[bp->b_type], buftype[type]);
270	TAILQ_REMOVE(&bufhead, bp, b_list);
271	TAILQ_INSERT_HEAD(&bufhead, bp, b_list);
272	bp->b_flags |= B_INUSE;
273	return (bp);
274}
275
276/*
277 * Timespec operations (from <sys/time.h>).
278 */
279#define	timespecsub(vvp, uvp)						\
280	do {								\
281		(vvp)->tv_sec -= (uvp)->tv_sec;				\
282		(vvp)->tv_nsec -= (uvp)->tv_nsec;			\
283		if ((vvp)->tv_nsec < 0) {				\
284			(vvp)->tv_sec--;				\
285			(vvp)->tv_nsec += 1000000000;			\
286		}							\
287	} while (0)
288#define	timespecadd(vvp, uvp)						\
289	do {								\
290		(vvp)->tv_sec += (uvp)->tv_sec;				\
291		(vvp)->tv_nsec += (uvp)->tv_nsec;			\
292		if ((vvp)->tv_nsec >= 1000000000) {			\
293			(vvp)->tv_sec++;				\
294			(vvp)->tv_nsec -= 1000000000;			\
295		}							\
296	} while (0)
297
298void
299getblk(struct bufarea *bp, ufs2_daddr_t blk, long size)
300{
301	ufs2_daddr_t dblk;
302	struct timespec start, finish;
303
304	dblk = fsbtodb(&sblock, blk);
305	if (bp->b_bno == dblk) {
306		totalreads++;
307	} else {
308		flush(fswritefd, bp);
309		if (debug) {
310			readcnt[bp->b_type]++;
311			clock_gettime(CLOCK_REALTIME_PRECISE, &start);
312		}
313		bp->b_errs = blread(fsreadfd, bp->b_un.b_buf, dblk, size);
314		if (debug) {
315			clock_gettime(CLOCK_REALTIME_PRECISE, &finish);
316			timespecsub(&finish, &start);
317			timespecadd(&readtime[bp->b_type], &finish);
318		}
319		bp->b_bno = dblk;
320		bp->b_size = size;
321	}
322}
323
324void
325flush(int fd, struct bufarea *bp)
326{
327	int i, j;
328
329	if (!bp->b_dirty)
330		return;
331	bp->b_dirty = 0;
332	if (fswritefd < 0) {
333		pfatal("WRITING IN READ_ONLY MODE.\n");
334		return;
335	}
336	if (bp->b_errs != 0)
337		pfatal("WRITING %sZERO'ED BLOCK %lld TO DISK\n",
338		    (bp->b_errs == bp->b_size / dev_bsize) ? "" : "PARTIALLY ",
339		    (long long)bp->b_bno);
340	bp->b_errs = 0;
341	blwrite(fd, bp->b_un.b_buf, bp->b_bno, bp->b_size);
342	if (bp != &sblk)
343		return;
344	for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
345		blwrite(fswritefd, (char *)sblock.fs_csp + i,
346		    fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
347		    sblock.fs_cssize - i < sblock.fs_bsize ?
348		    sblock.fs_cssize - i : sblock.fs_bsize);
349	}
350}
351
352void
353rwerror(const char *mesg, ufs2_daddr_t blk)
354{
355
356	if (bkgrdcheck)
357		exit(EEXIT);
358	if (preen == 0)
359		printf("\n");
360	pfatal("CANNOT %s: %ld", mesg, (long)blk);
361	if (reply("CONTINUE") == 0)
362		exit(EEXIT);
363}
364
365void
366ckfini(int markclean)
367{
368	struct bufarea *bp, *nbp;
369	int ofsmodified, cnt;
370
371	if (bkgrdflag) {
372		unlink(snapname);
373		if ((!(sblock.fs_flags & FS_UNCLEAN)) != markclean) {
374			cmd.value = FS_UNCLEAN;
375			cmd.size = markclean ? -1 : 1;
376			if (sysctlbyname("vfs.ffs.setflags", 0, 0,
377			    &cmd, sizeof cmd) == -1)
378				rwerror("SET FILE SYSTEM FLAGS", FS_UNCLEAN);
379			if (!preen) {
380				printf("\n***** FILE SYSTEM MARKED %s *****\n",
381				    markclean ? "CLEAN" : "DIRTY");
382				if (!markclean)
383					rerun = 1;
384			}
385		} else if (!preen && !markclean) {
386			printf("\n***** FILE SYSTEM STILL DIRTY *****\n");
387			rerun = 1;
388		}
389	}
390	if (debug && totalreads > 0)
391		printf("cache with %d buffers missed %ld of %ld (%d%%)\n",
392		    numbufs, totaldiskreads, totalreads,
393		    (int)(totaldiskreads * 100 / totalreads));
394	if (fswritefd < 0) {
395		(void)close(fsreadfd);
396		return;
397	}
398	flush(fswritefd, &sblk);
399	if (havesb && cursnapshot == 0 && sblock.fs_magic == FS_UFS2_MAGIC &&
400	    sblk.b_bno != sblock.fs_sblockloc / dev_bsize &&
401	    !preen && reply("UPDATE STANDARD SUPERBLOCK")) {
402		sblk.b_bno = sblock.fs_sblockloc / dev_bsize;
403		sbdirty();
404		flush(fswritefd, &sblk);
405	}
406	flush(fswritefd, &cgblk);
407	free(cgblk.b_un.b_buf);
408	cnt = 0;
409	TAILQ_FOREACH_REVERSE_SAFE(bp, &bufhead, buflist, b_list, nbp) {
410		TAILQ_REMOVE(&bufhead, bp, b_list);
411		cnt++;
412		flush(fswritefd, bp);
413		free(bp->b_un.b_buf);
414		free((char *)bp);
415	}
416	if (numbufs != cnt)
417		errx(EEXIT, "panic: lost %d buffers", numbufs - cnt);
418	for (cnt = 0; cnt < sblock.fs_ncg; cnt++) {
419		if (cgbufs[cnt].b_un.b_cg == NULL)
420			continue;
421		flush(fswritefd, &cgbufs[cnt]);
422		free(cgbufs[cnt].b_un.b_cg);
423	}
424	free(cgbufs);
425	pbp = pdirbp = (struct bufarea *)0;
426	if (cursnapshot == 0 && sblock.fs_clean != markclean) {
427		if ((sblock.fs_clean = markclean) != 0) {
428			sblock.fs_flags &= ~(FS_UNCLEAN | FS_NEEDSFSCK);
429			sblock.fs_pendingblocks = 0;
430			sblock.fs_pendinginodes = 0;
431		}
432		sbdirty();
433		ofsmodified = fsmodified;
434		flush(fswritefd, &sblk);
435		fsmodified = ofsmodified;
436		if (!preen) {
437			printf("\n***** FILE SYSTEM MARKED %s *****\n",
438			    markclean ? "CLEAN" : "DIRTY");
439			if (!markclean)
440				rerun = 1;
441		}
442	} else if (!preen) {
443		if (markclean) {
444			printf("\n***** FILE SYSTEM IS CLEAN *****\n");
445		} else {
446			printf("\n***** FILE SYSTEM STILL DIRTY *****\n");
447			rerun = 1;
448		}
449	}
450	(void)close(fsreadfd);
451	(void)close(fswritefd);
452}
453
454/*
455 * Print out I/O statistics.
456 */
457void
458IOstats(char *what)
459{
460	int i;
461
462	if (debug == 0)
463		return;
464	if (diskreads == 0) {
465		printf("%s: no I/O\n\n", what);
466		return;
467	}
468	if (startpass.tv_sec == 0)
469		startpass = startprog;
470	printf("%s: I/O statistics\n", what);
471	printIOstats();
472	totaldiskreads += diskreads;
473	diskreads = 0;
474	for (i = 0; i < BT_NUMBUFTYPES; i++) {
475		timespecadd(&totalreadtime[i], &readtime[i]);
476		totalreadcnt[i] += readcnt[i];
477		readtime[i].tv_sec = readtime[i].tv_nsec = 0;
478		readcnt[i] = 0;
479	}
480	clock_gettime(CLOCK_REALTIME_PRECISE, &startpass);
481}
482
483void
484finalIOstats(void)
485{
486	int i;
487
488	if (debug == 0)
489		return;
490	printf("Final I/O statistics\n");
491	totaldiskreads += diskreads;
492	diskreads = totaldiskreads;
493	startpass = startprog;
494	for (i = 0; i < BT_NUMBUFTYPES; i++) {
495		timespecadd(&totalreadtime[i], &readtime[i]);
496		totalreadcnt[i] += readcnt[i];
497		readtime[i] = totalreadtime[i];
498		readcnt[i] = totalreadcnt[i];
499	}
500	printIOstats();
501}
502
503static void printIOstats(void)
504{
505	long long msec, totalmsec;
506	int i;
507
508	clock_gettime(CLOCK_REALTIME_PRECISE, &finishpass);
509	timespecsub(&finishpass, &startpass);
510	printf("Running time: %jd.%03ld sec\n",
511		(intmax_t)finishpass.tv_sec, finishpass.tv_nsec / 1000000);
512	printf("buffer reads by type:\n");
513	for (totalmsec = 0, i = 0; i < BT_NUMBUFTYPES; i++)
514		totalmsec += readtime[i].tv_sec * 1000 +
515		    readtime[i].tv_nsec / 1000000;
516	if (totalmsec == 0)
517		totalmsec = 1;
518	for (i = 0; i < BT_NUMBUFTYPES; i++) {
519		if (readcnt[i] == 0)
520			continue;
521		msec =
522		    readtime[i].tv_sec * 1000 + readtime[i].tv_nsec / 1000000;
523		printf("%21s:%8ld %2ld.%ld%% %4jd.%03ld sec %2lld.%lld%%\n",
524		    buftype[i], readcnt[i], readcnt[i] * 100 / diskreads,
525		    (readcnt[i] * 1000 / diskreads) % 10,
526		    (intmax_t)readtime[i].tv_sec, readtime[i].tv_nsec / 1000000,
527		    msec * 100 / totalmsec, (msec * 1000 / totalmsec) % 10);
528	}
529	printf("\n");
530}
531
532int
533blread(int fd, char *buf, ufs2_daddr_t blk, long size)
534{
535	char *cp;
536	int i, errs;
537	off_t offset;
538
539	offset = blk;
540	offset *= dev_bsize;
541	if (bkgrdflag)
542		slowio_start();
543	totalreads++;
544	diskreads++;
545	if (lseek(fd, offset, 0) < 0)
546		rwerror("SEEK BLK", blk);
547	else if (read(fd, buf, (int)size) == size) {
548		if (bkgrdflag)
549			slowio_end();
550		return (0);
551	}
552
553	/*
554	 * This is handled specially here instead of in rwerror because
555	 * rwerror is used for all sorts of errors, not just true read/write
556	 * errors.  It should be refactored and fixed.
557	 */
558	if (surrender) {
559		pfatal("CANNOT READ_BLK: %ld", (long)blk);
560		errx(EEXIT, "ABORTING DUE TO READ ERRORS");
561	} else
562		rwerror("READ BLK", blk);
563
564	if (lseek(fd, offset, 0) < 0)
565		rwerror("SEEK BLK", blk);
566	errs = 0;
567	memset(buf, 0, (size_t)size);
568	printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
569	for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
570		if (read(fd, cp, (int)secsize) != secsize) {
571			(void)lseek(fd, offset + i + secsize, 0);
572			if (secsize != dev_bsize && dev_bsize != 1)
573				printf(" %jd (%jd),",
574				    (intmax_t)(blk * dev_bsize + i) / secsize,
575				    (intmax_t)blk + i / dev_bsize);
576			else
577				printf(" %jd,", (intmax_t)blk + i / dev_bsize);
578			errs++;
579		}
580	}
581	printf("\n");
582	if (errs)
583		resolved = 0;
584	return (errs);
585}
586
587void
588blwrite(int fd, char *buf, ufs2_daddr_t blk, ssize_t size)
589{
590	int i;
591	char *cp;
592	off_t offset;
593
594	if (fd < 0)
595		return;
596	offset = blk;
597	offset *= dev_bsize;
598	if (lseek(fd, offset, 0) < 0)
599		rwerror("SEEK BLK", blk);
600	else if (write(fd, buf, size) == size) {
601		fsmodified = 1;
602		return;
603	}
604	resolved = 0;
605	rwerror("WRITE BLK", blk);
606	if (lseek(fd, offset, 0) < 0)
607		rwerror("SEEK BLK", blk);
608	printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
609	for (cp = buf, i = 0; i < size; i += dev_bsize, cp += dev_bsize)
610		if (write(fd, cp, dev_bsize) != dev_bsize) {
611			(void)lseek(fd, offset + i + dev_bsize, 0);
612			printf(" %jd,", (intmax_t)blk + i / dev_bsize);
613		}
614	printf("\n");
615	return;
616}
617
618void
619blerase(int fd, ufs2_daddr_t blk, long size)
620{
621	off_t ioarg[2];
622
623	if (fd < 0)
624		return;
625	ioarg[0] = blk * dev_bsize;
626	ioarg[1] = size;
627	ioctl(fd, DIOCGDELETE, ioarg);
628	/* we don't really care if we succeed or not */
629	return;
630}
631
632/*
633 * Fill a contiguous region with all-zeroes.  Note ZEROBUFSIZE is by
634 * definition a multiple of dev_bsize.
635 */
636void
637blzero(int fd, ufs2_daddr_t blk, long size)
638{
639	static char *zero;
640	off_t offset, len;
641
642	if (fd < 0)
643		return;
644	if (zero == NULL) {
645		zero = calloc(ZEROBUFSIZE, 1);
646		if (zero == NULL)
647			errx(EEXIT, "cannot allocate buffer pool");
648	}
649	offset = blk * dev_bsize;
650	if (lseek(fd, offset, 0) < 0)
651		rwerror("SEEK BLK", blk);
652	while (size > 0) {
653		len = size > ZEROBUFSIZE ? ZEROBUFSIZE : size;
654		if (write(fd, zero, len) != len)
655			rwerror("WRITE BLK", blk);
656		blk += len / dev_bsize;
657		size -= len;
658	}
659}
660
661/*
662 * Verify cylinder group's magic number and other parameters.  If the
663 * test fails, offer an option to rebuild the whole cylinder group.
664 */
665int
666check_cgmagic(int cg, struct bufarea *cgbp)
667{
668	struct cg *cgp = cgbp->b_un.b_cg;
669
670	/*
671	 * Extended cylinder group checks.
672	 */
673	if (cg_chkmagic(cgp) &&
674	    ((sblock.fs_magic == FS_UFS1_MAGIC &&
675	      cgp->cg_old_niblk == sblock.fs_ipg &&
676	      cgp->cg_ndblk <= sblock.fs_fpg &&
677	      cgp->cg_old_ncyl <= sblock.fs_old_cpg) ||
678	     (sblock.fs_magic == FS_UFS2_MAGIC &&
679	      cgp->cg_niblk == sblock.fs_ipg &&
680	      cgp->cg_ndblk <= sblock.fs_fpg &&
681	      cgp->cg_initediblk <= sblock.fs_ipg))) {
682		return (1);
683	}
684	pfatal("CYLINDER GROUP %d: BAD MAGIC NUMBER", cg);
685	if (!reply("REBUILD CYLINDER GROUP")) {
686		printf("YOU WILL NEED TO RERUN FSCK.\n");
687		rerun = 1;
688		return (1);
689	}
690	/*
691	 * Zero out the cylinder group and then initialize critical fields.
692	 * Bit maps and summaries will be recalculated by later passes.
693	 */
694	memset(cgp, 0, (size_t)sblock.fs_cgsize);
695	cgp->cg_magic = CG_MAGIC;
696	cgp->cg_cgx = cg;
697	cgp->cg_niblk = sblock.fs_ipg;
698	cgp->cg_initediblk = sblock.fs_ipg < 2 * INOPB(&sblock) ?
699	    sblock.fs_ipg : 2 * INOPB(&sblock);
700	if (cgbase(&sblock, cg) + sblock.fs_fpg < sblock.fs_size)
701		cgp->cg_ndblk = sblock.fs_fpg;
702	else
703		cgp->cg_ndblk = sblock.fs_size - cgbase(&sblock, cg);
704	cgp->cg_iusedoff = &cgp->cg_space[0] - (u_char *)(&cgp->cg_firstfield);
705	if (sblock.fs_magic == FS_UFS1_MAGIC) {
706		cgp->cg_niblk = 0;
707		cgp->cg_initediblk = 0;
708		cgp->cg_old_ncyl = sblock.fs_old_cpg;
709		cgp->cg_old_niblk = sblock.fs_ipg;
710		cgp->cg_old_btotoff = cgp->cg_iusedoff;
711		cgp->cg_old_boff = cgp->cg_old_btotoff +
712		    sblock.fs_old_cpg * sizeof(int32_t);
713		cgp->cg_iusedoff = cgp->cg_old_boff +
714		    sblock.fs_old_cpg * sizeof(u_int16_t);
715	}
716	cgp->cg_freeoff = cgp->cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
717	cgp->cg_nextfreeoff = cgp->cg_freeoff + howmany(sblock.fs_fpg,CHAR_BIT);
718	if (sblock.fs_contigsumsize > 0) {
719		cgp->cg_nclusterblks = cgp->cg_ndblk / sblock.fs_frag;
720		cgp->cg_clustersumoff =
721		    roundup(cgp->cg_nextfreeoff, sizeof(u_int32_t));
722		cgp->cg_clustersumoff -= sizeof(u_int32_t);
723		cgp->cg_clusteroff = cgp->cg_clustersumoff +
724		    (sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
725		cgp->cg_nextfreeoff = cgp->cg_clusteroff +
726		    howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
727	}
728	dirty(cgbp);
729	return (0);
730}
731
732/*
733 * allocate a data block with the specified number of fragments
734 */
735ufs2_daddr_t
736allocblk(long frags)
737{
738	int i, j, k, cg, baseblk;
739	struct bufarea *cgbp;
740	struct cg *cgp;
741
742	if (frags <= 0 || frags > sblock.fs_frag)
743		return (0);
744	for (i = 0; i < maxfsblock - sblock.fs_frag; i += sblock.fs_frag) {
745		for (j = 0; j <= sblock.fs_frag - frags; j++) {
746			if (testbmap(i + j))
747				continue;
748			for (k = 1; k < frags; k++)
749				if (testbmap(i + j + k))
750					break;
751			if (k < frags) {
752				j += k;
753				continue;
754			}
755			cg = dtog(&sblock, i + j);
756			cgbp = cgget(cg);
757			cgp = cgbp->b_un.b_cg;
758			if (!check_cgmagic(cg, cgbp))
759				return (0);
760			baseblk = dtogd(&sblock, i + j);
761			for (k = 0; k < frags; k++) {
762				setbmap(i + j + k);
763				clrbit(cg_blksfree(cgp), baseblk + k);
764			}
765			n_blks += frags;
766			if (frags == sblock.fs_frag)
767				cgp->cg_cs.cs_nbfree--;
768			else
769				cgp->cg_cs.cs_nffree -= frags;
770			dirty(cgbp);
771			return (i + j);
772		}
773	}
774	return (0);
775}
776
777/*
778 * Free a previously allocated block
779 */
780void
781freeblk(ufs2_daddr_t blkno, long frags)
782{
783	struct inodesc idesc;
784
785	idesc.id_blkno = blkno;
786	idesc.id_numfrags = frags;
787	(void)pass4check(&idesc);
788}
789
790/* Slow down IO so as to leave some disk bandwidth for other processes */
791void
792slowio_start()
793{
794
795	/* Delay one in every 8 operations */
796	slowio_pollcnt = (slowio_pollcnt + 1) & 7;
797	if (slowio_pollcnt == 0) {
798		gettimeofday(&slowio_starttime, NULL);
799	}
800}
801
802void
803slowio_end()
804{
805	struct timeval tv;
806	int delay_usec;
807
808	if (slowio_pollcnt != 0)
809		return;
810
811	/* Update the slowdown interval. */
812	gettimeofday(&tv, NULL);
813	delay_usec = (tv.tv_sec - slowio_starttime.tv_sec) * 1000000 +
814	    (tv.tv_usec - slowio_starttime.tv_usec);
815	if (delay_usec < 64)
816		delay_usec = 64;
817	if (delay_usec > 2500000)
818		delay_usec = 2500000;
819	slowio_delay_usec = (slowio_delay_usec * 63 + delay_usec) >> 6;
820	/* delay by 8 times the average IO delay */
821	if (slowio_delay_usec > 64)
822		usleep(slowio_delay_usec * 8);
823}
824
825/*
826 * Find a pathname
827 */
828void
829getpathname(char *namebuf, ino_t curdir, ino_t ino)
830{
831	int len;
832	char *cp;
833	struct inodesc idesc;
834	static int busy = 0;
835
836	if (curdir == ino && ino == ROOTINO) {
837		(void)strcpy(namebuf, "/");
838		return;
839	}
840	if (busy || !INO_IS_DVALID(curdir)) {
841		(void)strcpy(namebuf, "?");
842		return;
843	}
844	busy = 1;
845	memset(&idesc, 0, sizeof(struct inodesc));
846	idesc.id_type = DATA;
847	idesc.id_fix = IGNORE;
848	cp = &namebuf[MAXPATHLEN - 1];
849	*cp = '\0';
850	if (curdir != ino) {
851		idesc.id_parent = curdir;
852		goto namelookup;
853	}
854	while (ino != ROOTINO) {
855		idesc.id_number = ino;
856		idesc.id_func = findino;
857		idesc.id_name = strdup("..");
858		if ((ckinode(ginode(ino), &idesc) & FOUND) == 0)
859			break;
860	namelookup:
861		idesc.id_number = idesc.id_parent;
862		idesc.id_parent = ino;
863		idesc.id_func = findname;
864		idesc.id_name = namebuf;
865		if ((ckinode(ginode(idesc.id_number), &idesc)&FOUND) == 0)
866			break;
867		len = strlen(namebuf);
868		cp -= len;
869		memmove(cp, namebuf, (size_t)len);
870		*--cp = '/';
871		if (cp < &namebuf[MAXNAMLEN])
872			break;
873		ino = idesc.id_number;
874	}
875	busy = 0;
876	if (ino != ROOTINO)
877		*--cp = '?';
878	memmove(namebuf, cp, (size_t)(&namebuf[MAXPATHLEN] - cp));
879}
880
881void
882catch(int sig __unused)
883{
884
885	ckfini(0);
886	exit(12);
887}
888
889/*
890 * When preening, allow a single quit to signal
891 * a special exit after file system checks complete
892 * so that reboot sequence may be interrupted.
893 */
894void
895catchquit(int sig __unused)
896{
897	printf("returning to single-user after file system check\n");
898	returntosingle = 1;
899	(void)signal(SIGQUIT, SIG_DFL);
900}
901
902/*
903 * determine whether an inode should be fixed.
904 */
905int
906dofix(struct inodesc *idesc, const char *msg)
907{
908
909	switch (idesc->id_fix) {
910
911	case DONTKNOW:
912		if (idesc->id_type == DATA)
913			direrror(idesc->id_number, msg);
914		else
915			pwarn("%s", msg);
916		if (preen) {
917			printf(" (SALVAGED)\n");
918			idesc->id_fix = FIX;
919			return (ALTERED);
920		}
921		if (reply("SALVAGE") == 0) {
922			idesc->id_fix = NOFIX;
923			return (0);
924		}
925		idesc->id_fix = FIX;
926		return (ALTERED);
927
928	case FIX:
929		return (ALTERED);
930
931	case NOFIX:
932	case IGNORE:
933		return (0);
934
935	default:
936		errx(EEXIT, "UNKNOWN INODESC FIX MODE %d", idesc->id_fix);
937	}
938	/* NOTREACHED */
939	return (0);
940}
941
942#include <stdarg.h>
943
944/*
945 * An unexpected inconsistency occurred.
946 * Die if preening or file system is running with soft dependency protocol,
947 * otherwise just print message and continue.
948 */
949void
950pfatal(const char *fmt, ...)
951{
952	va_list ap;
953	va_start(ap, fmt);
954	if (!preen) {
955		(void)vfprintf(stdout, fmt, ap);
956		va_end(ap);
957		if (usedsoftdep)
958			(void)fprintf(stdout,
959			    "\nUNEXPECTED SOFT UPDATE INCONSISTENCY\n");
960		/*
961		 * Force foreground fsck to clean up inconsistency.
962		 */
963		if (bkgrdflag) {
964			cmd.value = FS_NEEDSFSCK;
965			cmd.size = 1;
966			if (sysctlbyname("vfs.ffs.setflags", 0, 0,
967			    &cmd, sizeof cmd) == -1)
968				pwarn("CANNOT SET FS_NEEDSFSCK FLAG\n");
969			fprintf(stdout, "CANNOT RUN IN BACKGROUND\n");
970			ckfini(0);
971			exit(EEXIT);
972		}
973		return;
974	}
975	if (cdevname == NULL)
976		cdevname = strdup("fsck");
977	(void)fprintf(stdout, "%s: ", cdevname);
978	(void)vfprintf(stdout, fmt, ap);
979	(void)fprintf(stdout,
980	    "\n%s: UNEXPECTED%sINCONSISTENCY; RUN fsck MANUALLY.\n",
981	    cdevname, usedsoftdep ? " SOFT UPDATE " : " ");
982	/*
983	 * Force foreground fsck to clean up inconsistency.
984	 */
985	if (bkgrdflag) {
986		cmd.value = FS_NEEDSFSCK;
987		cmd.size = 1;
988		if (sysctlbyname("vfs.ffs.setflags", 0, 0,
989		    &cmd, sizeof cmd) == -1)
990			pwarn("CANNOT SET FS_NEEDSFSCK FLAG\n");
991	}
992	ckfini(0);
993	exit(EEXIT);
994}
995
996/*
997 * Pwarn just prints a message when not preening or running soft dependency
998 * protocol, or a warning (preceded by filename) when preening.
999 */
1000void
1001pwarn(const char *fmt, ...)
1002{
1003	va_list ap;
1004	va_start(ap, fmt);
1005	if (preen)
1006		(void)fprintf(stdout, "%s: ", cdevname);
1007	(void)vfprintf(stdout, fmt, ap);
1008	va_end(ap);
1009}
1010
1011/*
1012 * Stub for routines from kernel.
1013 */
1014void
1015panic(const char *fmt, ...)
1016{
1017	va_list ap;
1018	va_start(ap, fmt);
1019	pfatal("INTERNAL INCONSISTENCY:");
1020	(void)vfprintf(stdout, fmt, ap);
1021	va_end(ap);
1022	exit(EEXIT);
1023}
1024