xref: /freebsd/sbin/fsck_ffs/main.c (revision d101cdd6edd782f6ec56eef63ed91abd77a8b317)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1980, 1986, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31 
32 #if 0
33 #ifndef lint
34 static const char copyright[] =
35 "@(#) Copyright (c) 1980, 1986, 1993\n\
36 	The Regents of the University of California.  All rights reserved.\n";
37 #endif /* not lint */
38 
39 #ifndef lint
40 static char sccsid[] = "@(#)main.c	8.6 (Berkeley) 5/14/95";
41 #endif /* not lint */
42 #endif
43 #include <sys/cdefs.h>
44 __FBSDID("$FreeBSD$");
45 
46 #define	IN_RTLD			/* So we pickup the P_OSREL defines */
47 #include <sys/param.h>
48 #include <sys/file.h>
49 #include <sys/mount.h>
50 #include <sys/resource.h>
51 #include <sys/stat.h>
52 #include <sys/sysctl.h>
53 #include <sys/uio.h>
54 #include <sys/disklabel.h>
55 
56 #include <ufs/ufs/dinode.h>
57 #include <ufs/ffs/fs.h>
58 
59 #include <err.h>
60 #include <errno.h>
61 #include <fstab.h>
62 #include <grp.h>
63 #include <inttypes.h>
64 #include <libufs.h>
65 #include <mntopts.h>
66 #include <paths.h>
67 #include <stdint.h>
68 #include <string.h>
69 #include <time.h>
70 
71 #include "fsck.h"
72 
73 static int	restarts;
74 
75 static void usage(void) __dead2;
76 static intmax_t argtoimax(int flag, const char *req, const char *str, int base);
77 static int checkfilesys(char *filesys);
78 static int setup_bkgrdchk(struct statfs *mntp, int sbrdfailed, char **filesys);
79 
80 int
81 main(int argc, char *argv[])
82 {
83 	int ch;
84 	struct rlimit rlimit;
85 	struct itimerval itimerval;
86 	int fsret;
87 	int ret = 0;
88 
89 	sync();
90 	skipclean = 1;
91 	inoopt = 0;
92 	while ((ch = getopt(argc, argv, "b:Bc:CdEfFm:npRrSyZz")) != -1) {
93 		switch (ch) {
94 		case 'b':
95 			skipclean = 0;
96 			bflag = argtoimax('b', "number", optarg, 10);
97 			printf("Alternate super block location: %jd\n", bflag);
98 			break;
99 
100 		case 'B':
101 			bkgrdflag = 1;
102 			break;
103 
104 		case 'c':
105 			skipclean = 0;
106 			cvtlevel = argtoimax('c', "conversion level", optarg,
107 			    10);
108 			if (cvtlevel < 3)
109 				errx(EEXIT, "cannot do level %d conversion",
110 				    cvtlevel);
111 			break;
112 
113 		case 'd':
114 			debug++;
115 			break;
116 
117 		case 'E':
118 			Eflag++;
119 			break;
120 
121 		case 'f':
122 			skipclean = 0;
123 			break;
124 
125 		case 'F':
126 			bkgrdcheck = 1;
127 			break;
128 
129 		case 'm':
130 			lfmode = argtoimax('m', "mode", optarg, 8);
131 			if (lfmode &~ 07777)
132 				errx(EEXIT, "bad mode to -m: %o", lfmode);
133 			printf("** lost+found creation mode %o\n", lfmode);
134 			break;
135 
136 		case 'n':
137 			nflag++;
138 			yflag = 0;
139 			break;
140 
141 		case 'p':
142 			preen++;
143 			/*FALLTHROUGH*/
144 
145 		case 'C':
146 			ckclean++;
147 			break;
148 
149 		case 'R':
150 			wantrestart = 1;
151 			break;
152 		case 'r':
153 			inoopt++;
154 			break;
155 
156 		case 'S':
157 			surrender = 1;
158 			break;
159 
160 		case 'y':
161 			yflag++;
162 			nflag = 0;
163 			break;
164 
165 		case 'Z':
166 			Zflag++;
167 			break;
168 
169 		case 'z':
170 			zflag++;
171 			break;
172 
173 		default:
174 			usage();
175 		}
176 	}
177 	argc -= optind;
178 	argv += optind;
179 
180 	if (!argc)
181 		usage();
182 
183 	if (bkgrdflag && cvtlevel > 0) {
184 		pfatal("CANNOT CONVERT A SNAPSHOT\n");
185 		exit(EEXIT);
186 	}
187 
188 	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
189 		(void)signal(SIGINT, catch);
190 	if (ckclean)
191 		(void)signal(SIGQUIT, catchquit);
192 	signal(SIGINFO, infohandler);
193 	if (bkgrdflag) {
194 		signal(SIGALRM, alarmhandler);
195 		itimerval.it_interval.tv_sec = 5;
196 		itimerval.it_interval.tv_usec = 0;
197 		itimerval.it_value.tv_sec = 5;
198 		itimerval.it_value.tv_usec = 0;
199 		setitimer(ITIMER_REAL, &itimerval, NULL);
200 	}
201 	/*
202 	 * Push up our allowed memory limit so we can cope
203 	 * with huge file systems.
204 	 */
205 	if (getrlimit(RLIMIT_DATA, &rlimit) == 0) {
206 		rlimit.rlim_cur = rlimit.rlim_max;
207 		(void)setrlimit(RLIMIT_DATA, &rlimit);
208 	}
209 	while (argc > 0) {
210 		if ((fsret = checkfilesys(*argv)) == ERESTART)
211 			continue;
212 		ret |= fsret;
213 		argc--;
214 		argv++;
215 	}
216 
217 	if (returntosingle)
218 		ret = 2;
219 	exit(ret);
220 }
221 
222 static intmax_t
223 argtoimax(int flag, const char *req, const char *str, int base)
224 {
225 	char *cp;
226 	intmax_t ret;
227 
228 	ret = strtoimax(str, &cp, base);
229 	if (cp == str || *cp)
230 		errx(EEXIT, "-%c flag requires a %s", flag, req);
231 	return (ret);
232 }
233 
234 /*
235  * Check the specified file system.
236  */
237 /* ARGSUSED */
238 static int
239 checkfilesys(char *filesys)
240 {
241 	ufs2_daddr_t n_ffree, n_bfree;
242 	struct dups *dp;
243 	struct statfs *mntp;
244 	intmax_t blks, files;
245 	size_t size;
246 	int sbreadfailed, ofsmodified;
247 
248 	fsutilinit();
249 	fsckinit();
250 
251 	cdevname = filesys;
252 	if (debug && ckclean)
253 		pwarn("starting\n");
254 	/*
255 	 * Make best effort to get the disk name. Check first to see
256 	 * if it is listed among the mounted file systems. Failing that
257 	 * check to see if it is listed in /etc/fstab.
258 	 */
259 	mntp = getmntpoint(filesys);
260 	if (mntp != NULL)
261 		filesys = mntp->f_mntfromname;
262 	else
263 		filesys = blockcheck(filesys);
264 	/*
265 	 * If -F flag specified, check to see whether a background check
266 	 * is possible and needed. If possible and needed, exit with
267 	 * status zero. Otherwise exit with status non-zero. A non-zero
268 	 * exit status will cause a foreground check to be run.
269 	 */
270 	sblock_init();
271 	sbreadfailed = 0;
272 	if (openfilesys(filesys) == 0 || readsb() == 0)
273 		sbreadfailed = 1;
274 	if (bkgrdcheck) {
275 		if (sbreadfailed)
276 			exit(3);	/* Cannot read superblock */
277 		/* Earlier background failed or journaled */
278 		if (sblock.fs_flags & (FS_NEEDSFSCK | FS_SUJ))
279 			exit(4);
280 		if ((sblock.fs_flags & FS_DOSOFTDEP) == 0)
281 			exit(5);	/* Not running soft updates */
282 		size = MIBSIZE;
283 		if (sysctlnametomib("vfs.ffs.adjrefcnt", adjrefcnt, &size) < 0)
284 			exit(6);	/* Lacks kernel support */
285 		if ((mntp == NULL && sblock.fs_clean == 1) ||
286 		    (mntp != NULL && (sblock.fs_flags & FS_UNCLEAN) == 0))
287 			exit(7);	/* Filesystem clean, report it now */
288 		exit(0);
289 	}
290 	if (ckclean && skipclean) {
291 		/*
292 		 * If file system is gjournaled, check it here.
293 		 */
294 		if (sbreadfailed)
295 			exit(3);	/* Cannot read superblock */
296 		if (bkgrdflag == 0 &&
297 		    (nflag || (fswritefd = open(filesys, O_WRONLY)) < 0)) {
298 			fswritefd = -1;
299 			if (preen)
300 				pfatal("NO WRITE ACCESS");
301 			printf(" (NO WRITE)");
302 		}
303 		if ((sblock.fs_flags & FS_GJOURNAL) != 0) {
304 			if (sblock.fs_clean == 1) {
305 				pwarn("FILE SYSTEM CLEAN; SKIPPING CHECKS\n");
306 				exit(0);
307 			}
308 			if ((sblock.fs_flags &
309 			    (FS_UNCLEAN | FS_NEEDSFSCK)) == 0) {
310 				bufinit();
311 				gjournal_check(filesys);
312 				if (chkdoreload(mntp, pwarn) == 0)
313 					exit(0);
314 				exit(4);
315 			} else {
316 				pfatal("FULL FSCK NEEDED, CANNOT RUN FAST "
317 				    "FSCK\n");
318 			}
319 		}
320 		close(fswritefd);
321 		fswritefd = -1;
322 	}
323 	if (bkgrdflag) {
324 		switch (setup_bkgrdchk(mntp, sbreadfailed, &filesys)) {
325 		case -1: /* filesystem clean */
326 			goto clean;
327 		case 0: /* cannot do background, give up */
328 			exit(EEXIT);
329 		case 1: /* doing background check, preen rules apply */
330 			preen = 1;
331 			break;
332 		}
333 	}
334 
335 	switch (setup(filesys)) {
336 	case 0:
337 		if (preen)
338 			pfatal("CAN'T CHECK FILE SYSTEM.");
339 		return (EEXIT);
340 	case -1:
341 	clean:
342 		pwarn("clean, %ld free ", (long)(sblock.fs_cstotal.cs_nffree +
343 		    sblock.fs_frag * sblock.fs_cstotal.cs_nbfree));
344 		printf("(%jd frags, %jd blocks, %.1f%% fragmentation)\n",
345 		    (intmax_t)sblock.fs_cstotal.cs_nffree,
346 		    (intmax_t)sblock.fs_cstotal.cs_nbfree,
347 		    sblock.fs_cstotal.cs_nffree * 100.0 / sblock.fs_dsize);
348 		return (0);
349 	}
350 	/*
351 	 * Determine if we can and should do journal recovery.
352 	 */
353 	if ((sblock.fs_flags & FS_SUJ) == FS_SUJ) {
354 		if ((sblock.fs_flags & FS_NEEDSFSCK) != FS_NEEDSFSCK && skipclean) {
355 			sujrecovery = 1;
356 			if (suj_check(filesys) == 0) {
357 				printf("\n***** FILE SYSTEM MARKED CLEAN *****\n");
358 				if (chkdoreload(mntp, pwarn) == 0)
359 					exit(0);
360 				exit(4);
361 			}
362 			sujrecovery = 0;
363 			printf("** Skipping journal, falling through to full fsck\n\n");
364 		}
365 		if (fswritefd != -1) {
366 			/*
367 			 * Write the superblock so we don't try to recover the
368 			 * journal on another pass. If this is the only change
369 			 * to the filesystem, we do not want it to be called
370 			 * out as modified.
371 			 */
372 			sblock.fs_mtime = time(NULL);
373 			sbdirty();
374 			ofsmodified = fsmodified;
375 			flush(fswritefd, &sblk);
376 			fsmodified = ofsmodified;
377 		}
378 	}
379 	/*
380 	 * If the filesystem was run on an old kernel that did not
381 	 * support check hashes, clear the check-hash flags so that
382 	 * we do not try to verify them.
383 	 */
384 	if ((sblock.fs_flags & FS_METACKHASH) == 0)
385 		sblock.fs_metackhash = 0;
386 	/*
387 	 * If we are running on a kernel that can provide check hashes
388 	 * that are not yet enabled for the filesystem and we are
389 	 * running manually without the -y flag, offer to add any
390 	 * supported check hashes that are not already enabled.
391 	 */
392 	ckhashadd = 0;
393 	if (preen == 0 && yflag == 0 && sblock.fs_magic != FS_UFS1_MAGIC &&
394 	    fswritefd != -1 && getosreldate() >= P_OSREL_CK_CYLGRP) {
395 		if ((sblock.fs_metackhash & CK_CYLGRP) == 0 &&
396 		    reply("ADD CYLINDER GROUP CHECK-HASH PROTECTION") != 0) {
397 			ckhashadd |= CK_CYLGRP;
398 			sblock.fs_metackhash |= CK_CYLGRP;
399 		}
400 		if ((sblock.fs_metackhash & CK_SUPERBLOCK) == 0 &&
401 		    getosreldate() >= P_OSREL_CK_SUPERBLOCK &&
402 		    reply("ADD SUPERBLOCK CHECK-HASH PROTECTION") != 0) {
403 			ckhashadd |= CK_SUPERBLOCK;
404 			sblock.fs_metackhash |= CK_SUPERBLOCK;
405 		}
406 		if ((sblock.fs_metackhash & CK_INODE) == 0 &&
407 		    getosreldate() >= P_OSREL_CK_INODE &&
408 		    reply("ADD INODE CHECK-HASH PROTECTION") != 0) {
409 			ckhashadd |= CK_INODE;
410 			sblock.fs_metackhash |= CK_INODE;
411 		}
412 #ifdef notyet
413 		if ((sblock.fs_metackhash & CK_INDIR) == 0 &&
414 		    getosreldate() >= P_OSREL_CK_INDIR &&
415 		    reply("ADD INDIRECT BLOCK CHECK-HASH PROTECTION") != 0) {
416 			ckhashadd |= CK_INDIR;
417 			sblock.fs_metackhash |= CK_INDIR;
418 		}
419 		if ((sblock.fs_metackhash & CK_DIR) == 0 &&
420 		    getosreldate() >= P_OSREL_CK_DIR &&
421 		    reply("ADD DIRECTORY CHECK-HASH PROTECTION") != 0) {
422 			ckhashadd |= CK_DIR;
423 			sblock.fs_metackhash |= CK_DIR;
424 		}
425 #endif /* notyet */
426 		if (ckhashadd != 0) {
427 			sblock.fs_flags |= FS_METACKHASH;
428 			sbdirty();
429 		}
430 	}
431 	/*
432 	 * Cleared if any questions answered no. Used to decide if
433 	 * the superblock should be marked clean.
434 	 */
435 	resolved = 1;
436 	/*
437 	 * 1: scan inodes tallying blocks used
438 	 */
439 	if (preen == 0) {
440 		printf("** Last Mounted on %s\n", sblock.fs_fsmnt);
441 		if (mntp != NULL && mntp->f_flags & MNT_ROOTFS)
442 			printf("** Root file system\n");
443 		printf("** Phase 1 - Check Blocks and Sizes\n");
444 	}
445 	clock_gettime(CLOCK_REALTIME_PRECISE, &startprog);
446 	pass1();
447 	IOstats("Pass1");
448 
449 	/*
450 	 * 1b: locate first references to duplicates, if any
451 	 */
452 	if (duplist) {
453 		if (preen || usedsoftdep)
454 			pfatal("INTERNAL ERROR: DUPS WITH %s%s%s",
455 			    preen ? "-p" : "",
456 			    (preen && usedsoftdep) ? " AND " : "",
457 			    usedsoftdep ? "SOFTUPDATES" : "");
458 		printf("** Phase 1b - Rescan For More DUPS\n");
459 		pass1b();
460 		IOstats("Pass1b");
461 	}
462 
463 	/*
464 	 * 2: traverse directories from root to mark all connected directories
465 	 */
466 	if (preen == 0)
467 		printf("** Phase 2 - Check Pathnames\n");
468 	pass2();
469 	IOstats("Pass2");
470 
471 	/*
472 	 * 3: scan inodes looking for disconnected directories
473 	 */
474 	if (preen == 0)
475 		printf("** Phase 3 - Check Connectivity\n");
476 	pass3();
477 	IOstats("Pass3");
478 
479 	/*
480 	 * 4: scan inodes looking for disconnected files; check reference counts
481 	 */
482 	if (preen == 0)
483 		printf("** Phase 4 - Check Reference Counts\n");
484 	pass4();
485 	IOstats("Pass4");
486 
487 	/*
488 	 * 5: check and repair resource counts in cylinder groups
489 	 */
490 	if (preen == 0)
491 		printf("** Phase 5 - Check Cyl groups\n");
492 	snapflush(std_checkblkavail);
493 	pass5();
494 	IOstats("Pass5");
495 
496 	/*
497 	 * print out summary statistics
498 	 */
499 	n_ffree = sblock.fs_cstotal.cs_nffree;
500 	n_bfree = sblock.fs_cstotal.cs_nbfree;
501 	files = maxino - UFS_ROOTINO - sblock.fs_cstotal.cs_nifree - n_files;
502 	blks = n_blks +
503 	    sblock.fs_ncg * (cgdmin(&sblock, 0) - cgsblock(&sblock, 0));
504 	blks += cgsblock(&sblock, 0) - cgbase(&sblock, 0);
505 	blks += howmany(sblock.fs_cssize, sblock.fs_fsize);
506 	blks = maxfsblock - (n_ffree + sblock.fs_frag * n_bfree) - blks;
507 	if (bkgrdflag && (files > 0 || blks > 0)) {
508 		countdirs = sblock.fs_cstotal.cs_ndir - countdirs;
509 		pwarn("Reclaimed: %ld directories, %jd files, %jd fragments\n",
510 		    countdirs, files - countdirs, blks);
511 	}
512 	pwarn("%ld files, %jd used, %ju free ",
513 	    (long)n_files, (intmax_t)n_blks,
514 	    (uintmax_t)n_ffree + sblock.fs_frag * n_bfree);
515 	printf("(%ju frags, %ju blocks, %.1f%% fragmentation)\n",
516 	    (uintmax_t)n_ffree, (uintmax_t)n_bfree,
517 	    n_ffree * 100.0 / sblock.fs_dsize);
518 	if (debug) {
519 		if (files < 0)
520 			printf("%jd inodes missing\n", -files);
521 		if (blks < 0)
522 			printf("%jd blocks missing\n", -blks);
523 		if (duplist != NULL) {
524 			printf("The following duplicate blocks remain:");
525 			for (dp = duplist; dp; dp = dp->next)
526 				printf(" %jd,", (intmax_t)dp->dup);
527 			printf("\n");
528 		}
529 	}
530 	duplist = (struct dups *)0;
531 	muldup = (struct dups *)0;
532 	inocleanup();
533 	if (fsmodified) {
534 		sblock.fs_time = time(NULL);
535 		sbdirty();
536 	}
537 	if (cvtlevel && (sblk.b_flags & B_DIRTY) != 0) {
538 		/*
539 		 * Write out the duplicate super blocks
540 		 */
541 		if (sbput(fswritefd, &sblock, sblock.fs_ncg) == 0)
542 			fsmodified = 1;
543 	}
544 	if (rerun)
545 		resolved = 0;
546 
547 	/*
548 	 * Check to see if the file system is mounted read-write.
549 	 */
550 	if (bkgrdflag == 0 && mntp != NULL && (mntp->f_flags & MNT_RDONLY) == 0)
551 		resolved = 0;
552 	ckfini(resolved);
553 
554 	if (fsmodified && !preen)
555 		printf("\n***** FILE SYSTEM WAS MODIFIED *****\n");
556 	if (rerun) {
557 		if (wantrestart && (restarts++ < 10) &&
558 		    (preen || reply("RESTART")))
559 			return (ERESTART);
560 		printf("\n***** PLEASE RERUN FSCK *****\n");
561 	}
562 	if (chkdoreload(mntp, pwarn) != 0) {
563 		if (!fsmodified)
564 			return (0);
565 		if (!preen)
566 			printf("\n***** REBOOT NOW *****\n");
567 		sync();
568 		return (4);
569 	}
570 	return (rerun ? ERERUN : 0);
571 }
572 
573 /*
574  * If we are to do a background check:
575  *	Get the mount point information of the file system
576  *	If already clean, return -1
577  *	Check that kernel supports background fsck
578  *	Find or create the snapshot directory
579  *	Create the snapshot file
580  *	Open snapshot
581  *	If anything fails print reason and return 0 which exits
582  */
583 static int
584 setup_bkgrdchk(struct statfs *mntp, int sbreadfailed, char **filesys)
585 {
586 	struct stat snapdir;
587 	struct group *grp;
588 	struct iovec *iov;
589 	char errmsg[255];
590 	int iovlen;
591 	size_t size;
592 
593 	/* Get the mount point information of the file system */
594 	if (mntp == NULL) {
595 		pwarn("NOT MOUNTED, CANNOT RUN IN BACKGROUND\n");
596 		return (0);
597 	}
598 	if ((mntp->f_flags & MNT_RDONLY) != 0) {
599 		pwarn("MOUNTED READ-ONLY, CANNOT RUN IN BACKGROUND\n");
600 		return (0);
601 	}
602 	if ((mntp->f_flags & MNT_SOFTDEP) == 0) {
603 		pwarn("NOT USING SOFT UPDATES, CANNOT RUN IN BACKGROUND\n");
604 		return (0);
605 	}
606 	if (sbreadfailed) {
607 		pwarn("SUPERBLOCK READ FAILED, CANNOT RUN IN BACKGROUND\n");
608 		return (0);
609 	}
610 	if ((sblock.fs_flags & FS_NEEDSFSCK) != 0) {
611 		pwarn("FULL FSCK NEEDED, CANNOT RUN IN BACKGROUND\n");
612 		return (0);
613 	}
614 	if ((sblock.fs_flags & FS_SUJ) != 0) {
615 		pwarn("JOURNALED FILESYSTEM, CANNOT RUN IN BACKGROUND\n");
616 		return (0);
617 	}
618 	if (skipclean && ckclean &&
619 	   (sblock.fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK)) == 0) {
620 		/*
621 		 * file system is clean;
622 		 * skip snapshot and report it clean
623 		 */
624 		pwarn("FILE SYSTEM CLEAN; SKIPPING CHECKS\n");
625 		return (-1);
626 	}
627 	/* Check that kernel supports background fsck */
628 	size = MIBSIZE;
629 	if (sysctlnametomib("vfs.ffs.adjrefcnt", adjrefcnt, &size) < 0||
630 	    sysctlnametomib("vfs.ffs.adjblkcnt", adjblkcnt, &size) < 0||
631 	    sysctlnametomib("vfs.ffs.setsize", setsize, &size) < 0 ||
632 	    sysctlnametomib("vfs.ffs.freefiles", freefiles, &size) < 0||
633 	    sysctlnametomib("vfs.ffs.freedirs", freedirs, &size) < 0 ||
634 	    sysctlnametomib("vfs.ffs.freeblks", freeblks, &size) < 0) {
635 		pwarn("KERNEL LACKS BACKGROUND FSCK SUPPORT\n");
636 		return (0);
637 	}
638 	/*
639 	 * When kernel lacks runtime bgfsck superblock summary
640 	 * adjustment functionality, it does not mean we can not
641 	 * continue, as old kernels will recompute the summary at
642 	 * mount time. However, it will be an unexpected softupdates
643 	 * inconsistency if it turns out that the summary is still
644 	 * incorrect. Set a flag so subsequent operation can know this.
645 	 */
646 	bkgrdsumadj = 1;
647 	if (sysctlnametomib("vfs.ffs.adjndir", adjndir, &size) < 0 ||
648 	   sysctlnametomib("vfs.ffs.adjnbfree", adjnbfree, &size) < 0 ||
649 	   sysctlnametomib("vfs.ffs.adjnifree", adjnifree, &size) < 0 ||
650 	   sysctlnametomib("vfs.ffs.adjnffree", adjnffree, &size) < 0 ||
651 	   sysctlnametomib("vfs.ffs.adjnumclusters", adjnumclusters,
652 	   &size) < 0) {
653 		bkgrdsumadj = 0;
654 		pwarn("KERNEL LACKS RUNTIME SUPERBLOCK SUMMARY ADJUSTMENT "
655 		    "SUPPORT\n");
656 	}
657 	/* Find or create the snapshot directory */
658 	snprintf(snapname, sizeof snapname, "%s/.snap",
659 	    mntp->f_mntonname);
660 	if (stat(snapname, &snapdir) < 0) {
661 		if (errno != ENOENT) {
662 			pwarn("CANNOT FIND SNAPSHOT DIRECTORY %s: %s, CANNOT "
663 			    "RUN IN BACKGROUND\n", snapname, strerror(errno));
664 			return (0);
665 		}
666 		if ((grp = getgrnam("operator")) == NULL ||
667 			   mkdir(snapname, 0770) < 0 ||
668 			   chown(snapname, -1, grp->gr_gid) < 0 ||
669 			   chmod(snapname, 0770) < 0) {
670 			pwarn("CANNOT CREATE SNAPSHOT DIRECTORY %s: %s, "
671 			    "CANNOT RUN IN BACKGROUND\n", snapname,
672 			    strerror(errno));
673 			return (0);
674 		}
675 	} else if (!S_ISDIR(snapdir.st_mode)) {
676 		pwarn("%s IS NOT A DIRECTORY, CANNOT RUN IN BACKGROUND\n",
677 		    snapname);
678 		return (0);
679 	}
680 	/* Create the snapshot file */
681 	iov = NULL;
682 	iovlen = 0;
683 	errmsg[0] = '\0';
684 	snprintf(snapname, sizeof snapname, "%s/.snap/fsck_snapshot",
685 	    mntp->f_mntonname);
686 	build_iovec(&iov, &iovlen, "fstype", "ffs", 4);
687 	build_iovec(&iov, &iovlen, "from", snapname, (size_t)-1);
688 	build_iovec(&iov, &iovlen, "fspath", mntp->f_mntonname, (size_t)-1);
689 	build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg));
690 	build_iovec(&iov, &iovlen, "update", NULL, 0);
691 	build_iovec(&iov, &iovlen, "snapshot", NULL, 0);
692 	/* Create snapshot, removing old snapshot if it exists */
693 	while (nmount(iov, iovlen, mntp->f_flags) < 0) {
694 		if (errno == EEXIST && unlink(snapname) == 0)
695 			continue;
696 		pwarn("CANNOT CREATE SNAPSHOT %s: %s %s\n", snapname,
697 		    strerror(errno), errmsg);
698 		return (0);
699 	}
700 	/* Open snapshot */
701 	if (openfilesys(snapname) == 0) {
702 		unlink(snapname);
703 		pwarn("CANNOT OPEN SNAPSHOT %s: %s, CANNOT RUN IN "
704 		    "BACKGROUND\n", snapname, strerror(errno));
705 		return (0);
706 	}
707 	free(sblock.fs_csp);
708 	free(sblock.fs_si);
709 	havesb = 0;
710 	*filesys = snapname;
711 	cmd.version = FFS_CMD_VERSION;
712 	cmd.handle = fsreadfd;
713 	return (1);
714 }
715 
716 static void
717 usage(void)
718 {
719 	(void) fprintf(stderr,
720 "usage: %s [-BCdEFfnpRrSyZ] [-b block] [-c level] [-m mode] filesystem ...\n",
721 	    getprogname());
722 	exit(1);
723 }
724 
725 void
726 infohandler(int sig __unused)
727 {
728 	got_siginfo = 1;
729 }
730 
731 void
732 alarmhandler(int sig __unused)
733 {
734 	got_sigalarm = 1;
735 }
736