fsutil.c revision 253822
166864Sadrian/* 266864Sadrian * Copyright (c) 1980, 1986, 1993 366864Sadrian * The Regents of the University of California. All rights reserved. 466864Sadrian * 566864Sadrian * Redistribution and use in source and binary forms, with or without 666864Sadrian * modification, are permitted provided that the following conditions 766864Sadrian * are met: 866864Sadrian * 1. Redistributions of source code must retain the above copyright 966864Sadrian * notice, this list of conditions and the following disclaimer. 1066864Sadrian * 2. Redistributions in binary form must reproduce the above copyright 1166864Sadrian * notice, this list of conditions and the following disclaimer in the 1266864Sadrian * documentation and/or other materials provided with the distribution. 1366864Sadrian * 4. Neither the name of the University nor the names of its contributors 1466864Sadrian * may be used to endorse or promote products derived from this software 1566864Sadrian * without specific prior written permission. 1666864Sadrian * 1766864Sadrian * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 1866864Sadrian * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1966864Sadrian * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2066864Sadrian * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 2166864Sadrian * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2266864Sadrian * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2366864Sadrian * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2466864Sadrian * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2566864Sadrian * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2666864Sadrian * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2766864Sadrian * SUCH DAMAGE. 2866864Sadrian */ 2966864Sadrian 30114589Sobrien#if 0 3166864Sadrian#ifndef lint 3266864Sadrianstatic const char sccsid[] = "@(#)utilities.c 8.6 (Berkeley) 5/19/95"; 33114589Sobrien#endif /* not lint */ 3466864Sadrian#endif 35114589Sobrien#include <sys/cdefs.h> 36114589Sobrien__FBSDID("$FreeBSD: head/sbin/fsck_ffs/fsutil.c 253822 2013-07-30 22:57:12Z scottl $"); 3766864Sadrian 3866864Sadrian#include <sys/param.h> 39107671Siedowse#include <sys/time.h> 4066864Sadrian#include <sys/types.h> 4186514Siedowse#include <sys/sysctl.h> 42221233Sdes#include <sys/disk.h> 4398542Smckusick#include <sys/disklabel.h> 44221233Sdes#include <sys/ioctl.h> 4566864Sadrian#include <sys/stat.h> 4666864Sadrian 4766864Sadrian#include <ufs/ufs/dinode.h> 4866864Sadrian#include <ufs/ufs/dir.h> 4966864Sadrian#include <ufs/ffs/fs.h> 5066864Sadrian 5166864Sadrian#include <err.h> 5266864Sadrian#include <errno.h> 5366864Sadrian#include <string.h> 5466864Sadrian#include <ctype.h> 5566864Sadrian#include <fstab.h> 56101037Smux#include <stdint.h> 5766864Sadrian#include <stdio.h> 5866864Sadrian#include <stdlib.h> 59247212Smckusick#include <time.h> 6066864Sadrian#include <unistd.h> 6166864Sadrian 6266864Sadrian#include "fsck.h" 6366864Sadrian 64107671Siedowsestatic void slowio_start(void); 65107671Siedowsestatic void slowio_end(void); 66247212Smckusickstatic void printIOstats(void); 67107671Siedowse 68247212Smckusickstatic long diskreads, totaldiskreads, totalreads; /* Disk cache statistics */ 69247212Smckusickstatic struct timespec startpass, finishpass; 70107671Siedowsestruct timeval slowio_starttime; 71107671Siedowseint slowio_delay_usec = 10000; /* Initial IO delay for background fsck */ 72107671Siedowseint slowio_pollcnt; 73248658Smckusickstatic struct bufarea cgblk; /* backup buffer for cylinder group blocks */ 74246812Smckusickstatic TAILQ_HEAD(buflist, bufarea) bufhead; /* head of buffer cache list */ 75246812Smckusickstatic int numbufs; /* size of buffer cache */ 76247212Smckusickstatic char *buftype[BT_NUMBUFTYPES] = BT_NAMES; 7766864Sadrian 7866864Sadrianint 7998542Smckusickftypeok(union dinode *dp) 8066864Sadrian{ 8198542Smckusick switch (DIP(dp, di_mode) & IFMT) { 8266864Sadrian 8366864Sadrian case IFDIR: 8466864Sadrian case IFREG: 8566864Sadrian case IFBLK: 8666864Sadrian case IFCHR: 8766864Sadrian case IFLNK: 8866864Sadrian case IFSOCK: 8966864Sadrian case IFIFO: 9066864Sadrian return (1); 9166864Sadrian 9266864Sadrian default: 9366864Sadrian if (debug) 9498542Smckusick printf("bad file type 0%o\n", DIP(dp, di_mode)); 9566864Sadrian return (0); 9666864Sadrian } 9766864Sadrian} 9866864Sadrian 9966864Sadrianint 100100935Sphkreply(const char *question) 10166864Sadrian{ 10266864Sadrian int persevere; 10366864Sadrian char c; 10466864Sadrian 10566864Sadrian if (preen) 10666864Sadrian pfatal("INTERNAL ERROR: GOT TO reply()"); 10766864Sadrian persevere = !strcmp(question, "CONTINUE"); 10866864Sadrian printf("\n"); 10974556Smckusick if (!persevere && (nflag || (fswritefd < 0 && bkgrdflag == 0))) { 11066864Sadrian printf("%s? no\n\n", question); 11166864Sadrian resolved = 0; 11266864Sadrian return (0); 11366864Sadrian } 11466864Sadrian if (yflag || (persevere && nflag)) { 11566864Sadrian printf("%s? yes\n\n", question); 11666864Sadrian return (1); 11766864Sadrian } 11866864Sadrian do { 11966864Sadrian printf("%s? [yn] ", question); 12066864Sadrian (void) fflush(stdout); 12166864Sadrian c = getc(stdin); 12266864Sadrian while (c != '\n' && getc(stdin) != '\n') { 12366864Sadrian if (feof(stdin)) { 12466864Sadrian resolved = 0; 12566864Sadrian return (0); 12666864Sadrian } 12766864Sadrian } 12866864Sadrian } while (c != 'y' && c != 'Y' && c != 'n' && c != 'N'); 12966864Sadrian printf("\n"); 13066864Sadrian if (c == 'y' || c == 'Y') 13166864Sadrian return (1); 13266864Sadrian resolved = 0; 13366864Sadrian return (0); 13466864Sadrian} 13566864Sadrian 13666864Sadrian/* 13766864Sadrian * Look up state information for an inode. 13866864Sadrian */ 13966864Sadrianstruct inostat * 14092839Simpinoinfo(ino_t inum) 14166864Sadrian{ 14266864Sadrian static struct inostat unallocated = { USTATE, 0, 0 }; 14366864Sadrian struct inostatlist *ilp; 14466864Sadrian int iloff; 14566864Sadrian 14666864Sadrian if (inum > maxino) 147241012Smdf errx(EEXIT, "inoinfo: inumber %ju out of range", 148241012Smdf (uintmax_t)inum); 14966864Sadrian ilp = &inostathead[inum / sblock.fs_ipg]; 15066864Sadrian iloff = inum % sblock.fs_ipg; 15166864Sadrian if (iloff >= ilp->il_numalloced) 15266864Sadrian return (&unallocated); 15366864Sadrian return (&ilp->il_stat[iloff]); 15466864Sadrian} 15566864Sadrian 15666864Sadrian/* 15766864Sadrian * Malloc buffers and set up cache. 15866864Sadrian */ 15966864Sadrianvoid 16092839Simpbufinit(void) 16166864Sadrian{ 16292806Sobrien struct bufarea *bp; 16366864Sadrian long bufcnt, i; 16466864Sadrian char *bufp; 16566864Sadrian 16666864Sadrian pbp = pdirbp = (struct bufarea *)0; 167248658Smckusick bufp = Malloc((unsigned int)sblock.fs_bsize); 16866864Sadrian if (bufp == 0) 16966864Sadrian errx(EEXIT, "cannot allocate buffer pool"); 17066864Sadrian cgblk.b_un.b_buf = bufp; 171247212Smckusick initbarea(&cgblk, BT_CYLGRP); 172246812Smckusick TAILQ_INIT(&bufhead); 173246812Smckusick bufcnt = MAXBUFS; 17466864Sadrian if (bufcnt < MINBUFS) 17566864Sadrian bufcnt = MINBUFS; 17666864Sadrian for (i = 0; i < bufcnt; i++) { 177248658Smckusick bp = (struct bufarea *)Malloc(sizeof(struct bufarea)); 178248658Smckusick bufp = Malloc((unsigned int)sblock.fs_bsize); 17966864Sadrian if (bp == NULL || bufp == NULL) { 18066864Sadrian if (i >= MINBUFS) 18166864Sadrian break; 18266864Sadrian errx(EEXIT, "cannot allocate buffer pool"); 18366864Sadrian } 18466864Sadrian bp->b_un.b_buf = bufp; 185246812Smckusick TAILQ_INSERT_HEAD(&bufhead, bp, b_list); 186247212Smckusick initbarea(bp, BT_UNKNOWN); 18766864Sadrian } 188246812Smckusick numbufs = i; /* save number of buffers */ 189247212Smckusick for (i = 0; i < BT_NUMBUFTYPES; i++) { 190247212Smckusick readtime[i].tv_sec = totalreadtime[i].tv_sec = 0; 191247212Smckusick readtime[i].tv_nsec = totalreadtime[i].tv_nsec = 0; 192247212Smckusick readcnt[i] = totalreadcnt[i] = 0; 193247212Smckusick } 19466864Sadrian} 19566864Sadrian 19666864Sadrian/* 197248658Smckusick * Manage cylinder group buffers. 198248658Smckusick */ 199248658Smckusickstatic struct bufarea *cgbufs; /* header for cylinder group cache */ 200248658Smckusickstatic int flushtries; /* number of tries to reclaim memory */ 201248658Smckusick 202248658Smckusickstruct bufarea * 203248658Smckusickcgget(int cg) 204248658Smckusick{ 205248658Smckusick struct bufarea *cgbp; 206248658Smckusick struct cg *cgp; 207248658Smckusick 208248658Smckusick if (cgbufs == NULL) { 209248658Smckusick cgbufs = Calloc(sblock.fs_ncg, sizeof(struct bufarea)); 210248658Smckusick if (cgbufs == NULL) 211248658Smckusick errx(EEXIT, "cannot allocate cylinder group buffers"); 212248658Smckusick } 213248658Smckusick cgbp = &cgbufs[cg]; 214248658Smckusick if (cgbp->b_un.b_cg != NULL) 215248658Smckusick return (cgbp); 216248658Smckusick cgp = NULL; 217248658Smckusick if (flushtries == 0) 218248658Smckusick cgp = malloc((unsigned int)sblock.fs_cgsize); 219248658Smckusick if (cgp == NULL) { 220248658Smckusick getblk(&cgblk, cgtod(&sblock, cg), sblock.fs_cgsize); 221248658Smckusick return (&cgblk); 222248658Smckusick } 223248658Smckusick cgbp->b_un.b_cg = cgp; 224248658Smckusick initbarea(cgbp, BT_CYLGRP); 225248658Smckusick getblk(cgbp, cgtod(&sblock, cg), sblock.fs_cgsize); 226248658Smckusick return (cgbp); 227248658Smckusick} 228248658Smckusick 229248658Smckusick/* 230248658Smckusick * Attempt to flush a cylinder group cache entry. 231248658Smckusick * Return whether the flush was successful. 232248658Smckusick */ 233248658Smckusickint 234248658Smckusickflushentry(void) 235248658Smckusick{ 236248658Smckusick struct bufarea *cgbp; 237248658Smckusick 238248658Smckusick cgbp = &cgbufs[flushtries++]; 239248658Smckusick if (cgbp->b_un.b_cg == NULL) 240248658Smckusick return (0); 241248658Smckusick flush(fswritefd, cgbp); 242248658Smckusick free(cgbp->b_un.b_buf); 243248658Smckusick cgbp->b_un.b_buf = NULL; 244248658Smckusick return (1); 245248658Smckusick} 246248658Smckusick 247248658Smckusick/* 24866864Sadrian * Manage a cache of directory blocks. 24966864Sadrian */ 25066864Sadrianstruct bufarea * 251247212Smckusickgetdatablk(ufs2_daddr_t blkno, long size, int type) 25266864Sadrian{ 25392806Sobrien struct bufarea *bp; 25466864Sadrian 255246812Smckusick TAILQ_FOREACH(bp, &bufhead, b_list) 25666864Sadrian if (bp->b_bno == fsbtodb(&sblock, blkno)) 25766864Sadrian goto foundit; 258246812Smckusick TAILQ_FOREACH_REVERSE(bp, &bufhead, buflist, b_list) 25966864Sadrian if ((bp->b_flags & B_INUSE) == 0) 26066864Sadrian break; 261246812Smckusick if (bp == NULL) 26266864Sadrian errx(EEXIT, "deadlocked buffer pool"); 263247212Smckusick bp->b_type = type; 26466864Sadrian getblk(bp, blkno, size); 26566864Sadrian /* fall through */ 26666864Sadrianfoundit: 267247212Smckusick if (debug && bp->b_type != type) 268247212Smckusick printf("Buffer type changed from %s to %s\n", 269247212Smckusick buftype[bp->b_type], buftype[type]); 270246812Smckusick TAILQ_REMOVE(&bufhead, bp, b_list); 271246812Smckusick TAILQ_INSERT_HEAD(&bufhead, bp, b_list); 27266864Sadrian bp->b_flags |= B_INUSE; 27366864Sadrian return (bp); 27466864Sadrian} 27566864Sadrian 276247212Smckusick/* 277247212Smckusick * Timespec operations (from <sys/time.h>). 278247212Smckusick */ 279247212Smckusick#define timespecsub(vvp, uvp) \ 280247212Smckusick do { \ 281247212Smckusick (vvp)->tv_sec -= (uvp)->tv_sec; \ 282247212Smckusick (vvp)->tv_nsec -= (uvp)->tv_nsec; \ 283247212Smckusick if ((vvp)->tv_nsec < 0) { \ 284247212Smckusick (vvp)->tv_sec--; \ 285247212Smckusick (vvp)->tv_nsec += 1000000000; \ 286247212Smckusick } \ 287247212Smckusick } while (0) 288247212Smckusick#define timespecadd(vvp, uvp) \ 289247212Smckusick do { \ 290247212Smckusick (vvp)->tv_sec += (uvp)->tv_sec; \ 291247212Smckusick (vvp)->tv_nsec += (uvp)->tv_nsec; \ 292247212Smckusick if ((vvp)->tv_nsec >= 1000000000) { \ 293247212Smckusick (vvp)->tv_sec++; \ 294247212Smckusick (vvp)->tv_nsec -= 1000000000; \ 295247212Smckusick } \ 296247212Smckusick } while (0) 297247212Smckusick 29866864Sadrianvoid 29998542Smckusickgetblk(struct bufarea *bp, ufs2_daddr_t blk, long size) 30066864Sadrian{ 30198542Smckusick ufs2_daddr_t dblk; 302247212Smckusick struct timespec start, finish; 30366864Sadrian 30466864Sadrian dblk = fsbtodb(&sblock, blk); 305247212Smckusick if (bp->b_bno == dblk) { 306247212Smckusick totalreads++; 307247212Smckusick } else { 30866864Sadrian flush(fswritefd, bp); 309247212Smckusick if (debug) { 310247212Smckusick readcnt[bp->b_type]++; 311247212Smckusick clock_gettime(CLOCK_REALTIME_PRECISE, &start); 312247212Smckusick } 313163845Spjd bp->b_errs = blread(fsreadfd, bp->b_un.b_buf, dblk, size); 314247212Smckusick if (debug) { 315247212Smckusick clock_gettime(CLOCK_REALTIME_PRECISE, &finish); 316247212Smckusick timespecsub(&finish, &start); 317247212Smckusick timespecadd(&readtime[bp->b_type], &finish); 318247212Smckusick } 31966864Sadrian bp->b_bno = dblk; 32066864Sadrian bp->b_size = size; 32166864Sadrian } 32266864Sadrian} 32366864Sadrian 32466864Sadrianvoid 32592839Simpflush(int fd, struct bufarea *bp) 32666864Sadrian{ 32792806Sobrien int i, j; 32866864Sadrian 32966864Sadrian if (!bp->b_dirty) 33066864Sadrian return; 33174556Smckusick bp->b_dirty = 0; 33274556Smckusick if (fswritefd < 0) { 33374556Smckusick pfatal("WRITING IN READ_ONLY MODE.\n"); 33474556Smckusick return; 33574556Smckusick } 33666864Sadrian if (bp->b_errs != 0) 337100935Sphk pfatal("WRITING %sZERO'ED BLOCK %lld TO DISK\n", 33866864Sadrian (bp->b_errs == bp->b_size / dev_bsize) ? "" : "PARTIALLY ", 339100935Sphk (long long)bp->b_bno); 34066864Sadrian bp->b_errs = 0; 341240406Sobrien blwrite(fd, bp->b_un.b_buf, bp->b_bno, bp->b_size); 34266864Sadrian if (bp != &sblk) 34366864Sadrian return; 34466864Sadrian for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) { 345163845Spjd blwrite(fswritefd, (char *)sblock.fs_csp + i, 34666864Sadrian fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag), 34766864Sadrian sblock.fs_cssize - i < sblock.fs_bsize ? 34866864Sadrian sblock.fs_cssize - i : sblock.fs_bsize); 34966864Sadrian } 35066864Sadrian} 35166864Sadrian 35274556Smckusickvoid 353100935Sphkrwerror(const char *mesg, ufs2_daddr_t blk) 35466864Sadrian{ 35566864Sadrian 35675927Smckusick if (bkgrdcheck) 35775927Smckusick exit(EEXIT); 35866864Sadrian if (preen == 0) 35966864Sadrian printf("\n"); 36086514Siedowse pfatal("CANNOT %s: %ld", mesg, (long)blk); 36166864Sadrian if (reply("CONTINUE") == 0) 36266864Sadrian exit(EEXIT); 36366864Sadrian} 36466864Sadrian 36566864Sadrianvoid 36692839Simpckfini(int markclean) 36766864Sadrian{ 36892806Sobrien struct bufarea *bp, *nbp; 369246812Smckusick int ofsmodified, cnt; 37066864Sadrian 37174556Smckusick if (bkgrdflag) { 37274556Smckusick unlink(snapname); 37374556Smckusick if ((!(sblock.fs_flags & FS_UNCLEAN)) != markclean) { 37474556Smckusick cmd.value = FS_UNCLEAN; 37574556Smckusick cmd.size = markclean ? -1 : 1; 37674556Smckusick if (sysctlbyname("vfs.ffs.setflags", 0, 0, 37774556Smckusick &cmd, sizeof cmd) == -1) 378118302Sru rwerror("SET FILE SYSTEM FLAGS", FS_UNCLEAN); 37974556Smckusick if (!preen) { 38074556Smckusick printf("\n***** FILE SYSTEM MARKED %s *****\n", 38174556Smckusick markclean ? "CLEAN" : "DIRTY"); 38274556Smckusick if (!markclean) 38374556Smckusick rerun = 1; 38474556Smckusick } 38574556Smckusick } else if (!preen && !markclean) { 38674556Smckusick printf("\n***** FILE SYSTEM STILL DIRTY *****\n"); 38774556Smckusick rerun = 1; 38874556Smckusick } 38974556Smckusick } 390246812Smckusick if (debug && totalreads > 0) 391246812Smckusick printf("cache with %d buffers missed %ld of %ld (%d%%)\n", 392247212Smckusick numbufs, totaldiskreads, totalreads, 393247212Smckusick (int)(totaldiskreads * 100 / totalreads)); 39466864Sadrian if (fswritefd < 0) { 39566864Sadrian (void)close(fsreadfd); 39666864Sadrian return; 39766864Sadrian } 39866864Sadrian flush(fswritefd, &sblk); 39998542Smckusick if (havesb && cursnapshot == 0 && sblock.fs_magic == FS_UFS2_MAGIC && 400107294Smckusick sblk.b_bno != sblock.fs_sblockloc / dev_bsize && 40166864Sadrian !preen && reply("UPDATE STANDARD SUPERBLOCK")) { 402107294Smckusick sblk.b_bno = sblock.fs_sblockloc / dev_bsize; 40366864Sadrian sbdirty(); 40466864Sadrian flush(fswritefd, &sblk); 40566864Sadrian } 40666864Sadrian flush(fswritefd, &cgblk); 40766864Sadrian free(cgblk.b_un.b_buf); 408246812Smckusick cnt = 0; 409246812Smckusick TAILQ_FOREACH_REVERSE_SAFE(bp, &bufhead, buflist, b_list, nbp) { 410246812Smckusick TAILQ_REMOVE(&bufhead, bp, b_list); 41166864Sadrian cnt++; 41266864Sadrian flush(fswritefd, bp); 41366864Sadrian free(bp->b_un.b_buf); 41466864Sadrian free((char *)bp); 41566864Sadrian } 416246812Smckusick if (numbufs != cnt) 417246812Smckusick errx(EEXIT, "panic: lost %d buffers", numbufs - cnt); 418248658Smckusick for (cnt = 0; cnt < sblock.fs_ncg; cnt++) { 419248658Smckusick if (cgbufs[cnt].b_un.b_cg == NULL) 420248658Smckusick continue; 421248658Smckusick flush(fswritefd, &cgbufs[cnt]); 422248658Smckusick free(cgbufs[cnt].b_un.b_cg); 423248658Smckusick } 424248658Smckusick free(cgbufs); 42566864Sadrian pbp = pdirbp = (struct bufarea *)0; 42674556Smckusick if (cursnapshot == 0 && sblock.fs_clean != markclean) { 427105436Smckusick if ((sblock.fs_clean = markclean) != 0) { 42875557Smckusick sblock.fs_flags &= ~(FS_UNCLEAN | FS_NEEDSFSCK); 429105436Smckusick sblock.fs_pendingblocks = 0; 430105436Smckusick sblock.fs_pendinginodes = 0; 431105436Smckusick } 43266864Sadrian sbdirty(); 43366864Sadrian ofsmodified = fsmodified; 43466864Sadrian flush(fswritefd, &sblk); 43566864Sadrian fsmodified = ofsmodified; 43666864Sadrian if (!preen) { 43766864Sadrian printf("\n***** FILE SYSTEM MARKED %s *****\n", 43866864Sadrian markclean ? "CLEAN" : "DIRTY"); 43966864Sadrian if (!markclean) 44066864Sadrian rerun = 1; 44166864Sadrian } 442188110Smckusick } else if (!preen) { 443188110Smckusick if (markclean) { 444188110Smckusick printf("\n***** FILE SYSTEM IS CLEAN *****\n"); 445188110Smckusick } else { 446188110Smckusick printf("\n***** FILE SYSTEM STILL DIRTY *****\n"); 447188110Smckusick rerun = 1; 448188110Smckusick } 44966864Sadrian } 45066864Sadrian (void)close(fsreadfd); 45166864Sadrian (void)close(fswritefd); 45266864Sadrian} 45366864Sadrian 454247212Smckusick/* 455247212Smckusick * Print out I/O statistics. 456247212Smckusick */ 457247212Smckusickvoid 458247212SmckusickIOstats(char *what) 459247212Smckusick{ 460247212Smckusick int i; 461247212Smckusick 462247212Smckusick if (debug == 0) 463247212Smckusick return; 464247212Smckusick if (diskreads == 0) { 465247212Smckusick printf("%s: no I/O\n\n", what); 466247212Smckusick return; 467247212Smckusick } 468247212Smckusick if (startpass.tv_sec == 0) 469247212Smckusick startpass = startprog; 470247212Smckusick printf("%s: I/O statistics\n", what); 471247212Smckusick printIOstats(); 472247212Smckusick totaldiskreads += diskreads; 473247212Smckusick diskreads = 0; 474247212Smckusick for (i = 0; i < BT_NUMBUFTYPES; i++) { 475247212Smckusick timespecadd(&totalreadtime[i], &readtime[i]); 476247212Smckusick totalreadcnt[i] += readcnt[i]; 477247212Smckusick readtime[i].tv_sec = readtime[i].tv_nsec = 0; 478247212Smckusick readcnt[i] = 0; 479247212Smckusick } 480247212Smckusick clock_gettime(CLOCK_REALTIME_PRECISE, &startpass); 481247212Smckusick} 482247212Smckusick 483247212Smckusickvoid 484247212SmckusickfinalIOstats(void) 485247212Smckusick{ 486247212Smckusick int i; 487247212Smckusick 488247212Smckusick if (debug == 0) 489247212Smckusick return; 490247212Smckusick printf("Final I/O statistics\n"); 491247212Smckusick totaldiskreads += diskreads; 492247212Smckusick diskreads = totaldiskreads; 493247212Smckusick startpass = startprog; 494247212Smckusick for (i = 0; i < BT_NUMBUFTYPES; i++) { 495247212Smckusick timespecadd(&totalreadtime[i], &readtime[i]); 496247212Smckusick totalreadcnt[i] += readcnt[i]; 497247212Smckusick readtime[i] = totalreadtime[i]; 498247212Smckusick readcnt[i] = totalreadcnt[i]; 499247212Smckusick } 500247212Smckusick printIOstats(); 501247212Smckusick} 502247212Smckusick 503247212Smckusickstatic void printIOstats(void) 504247212Smckusick{ 505247212Smckusick long long msec, totalmsec; 506247212Smckusick int i; 507247212Smckusick 508247212Smckusick clock_gettime(CLOCK_REALTIME_PRECISE, &finishpass); 509247212Smckusick timespecsub(&finishpass, &startpass); 510248691Smckusick printf("Running time: %jd.%03ld sec\n", 511248680Ssbruno (intmax_t)finishpass.tv_sec, finishpass.tv_nsec / 1000000); 512247212Smckusick printf("buffer reads by type:\n"); 513247212Smckusick for (totalmsec = 0, i = 0; i < BT_NUMBUFTYPES; i++) 514247212Smckusick totalmsec += readtime[i].tv_sec * 1000 + 515247212Smckusick readtime[i].tv_nsec / 1000000; 516247212Smckusick if (totalmsec == 0) 517247212Smckusick totalmsec = 1; 518247212Smckusick for (i = 0; i < BT_NUMBUFTYPES; i++) { 519247212Smckusick if (readcnt[i] == 0) 520247212Smckusick continue; 521248691Smckusick msec = 522248691Smckusick readtime[i].tv_sec * 1000 + readtime[i].tv_nsec / 1000000; 523248680Ssbruno printf("%21s:%8ld %2ld.%ld%% %4jd.%03ld sec %2lld.%lld%%\n", 524247212Smckusick buftype[i], readcnt[i], readcnt[i] * 100 / diskreads, 525248658Smckusick (readcnt[i] * 1000 / diskreads) % 10, 526248680Ssbruno (intmax_t)readtime[i].tv_sec, readtime[i].tv_nsec / 1000000, 527247212Smckusick msec * 100 / totalmsec, (msec * 1000 / totalmsec) % 10); 528247212Smckusick } 529247212Smckusick printf("\n"); 530247212Smckusick} 531247212Smckusick 53266864Sadrianint 533163845Spjdblread(int fd, char *buf, ufs2_daddr_t blk, long size) 53466864Sadrian{ 53566864Sadrian char *cp; 53666864Sadrian int i, errs; 53766864Sadrian off_t offset; 53866864Sadrian 53966864Sadrian offset = blk; 54066864Sadrian offset *= dev_bsize; 541107671Siedowse if (bkgrdflag) 542107671Siedowse slowio_start(); 543247212Smckusick totalreads++; 544247212Smckusick diskreads++; 54566864Sadrian if (lseek(fd, offset, 0) < 0) 54674556Smckusick rwerror("SEEK BLK", blk); 547107671Siedowse else if (read(fd, buf, (int)size) == size) { 548107671Siedowse if (bkgrdflag) 549107671Siedowse slowio_end(); 55066864Sadrian return (0); 551107671Siedowse } 552253822Sscottl 553253822Sscottl /* 554253822Sscottl * This is handled specially here instead of in rwerror because 555253822Sscottl * rwerror is used for all sorts of errors, not just true read/write 556253822Sscottl * errors. It should be refactored and fixed. 557253822Sscottl */ 558253822Sscottl if (surrender) { 559253822Sscottl pfatal("CANNOT READ_BLK: %ld", (long)blk); 560253822Sscottl errx(EEXIT, "ABORTING DUE TO READ ERRORS"); 561253822Sscottl } else 562253822Sscottl rwerror("READ BLK", blk); 563253822Sscottl 56466864Sadrian if (lseek(fd, offset, 0) < 0) 56574556Smckusick rwerror("SEEK BLK", blk); 56666864Sadrian errs = 0; 56766864Sadrian memset(buf, 0, (size_t)size); 56866864Sadrian printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:"); 56966864Sadrian for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) { 57066864Sadrian if (read(fd, cp, (int)secsize) != secsize) { 57166864Sadrian (void)lseek(fd, offset + i + secsize, 0); 57266864Sadrian if (secsize != dev_bsize && dev_bsize != 1) 573101037Smux printf(" %jd (%jd),", 574101037Smux (intmax_t)(blk * dev_bsize + i) / secsize, 575101037Smux (intmax_t)blk + i / dev_bsize); 57666864Sadrian else 577101037Smux printf(" %jd,", (intmax_t)blk + i / dev_bsize); 57866864Sadrian errs++; 57966864Sadrian } 58066864Sadrian } 58166864Sadrian printf("\n"); 58266864Sadrian if (errs) 58366864Sadrian resolved = 0; 58466864Sadrian return (errs); 58566864Sadrian} 58666864Sadrian 58766864Sadrianvoid 588240406Sobrienblwrite(int fd, char *buf, ufs2_daddr_t blk, ssize_t size) 58966864Sadrian{ 59066864Sadrian int i; 59166864Sadrian char *cp; 59266864Sadrian off_t offset; 59366864Sadrian 59466864Sadrian if (fd < 0) 59566864Sadrian return; 59666864Sadrian offset = blk; 59766864Sadrian offset *= dev_bsize; 59866864Sadrian if (lseek(fd, offset, 0) < 0) 59974556Smckusick rwerror("SEEK BLK", blk); 600240406Sobrien else if (write(fd, buf, size) == size) { 60166864Sadrian fsmodified = 1; 60266864Sadrian return; 60366864Sadrian } 60466864Sadrian resolved = 0; 60574556Smckusick rwerror("WRITE BLK", blk); 60666864Sadrian if (lseek(fd, offset, 0) < 0) 60774556Smckusick rwerror("SEEK BLK", blk); 60866864Sadrian printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:"); 60966864Sadrian for (cp = buf, i = 0; i < size; i += dev_bsize, cp += dev_bsize) 610240406Sobrien if (write(fd, cp, dev_bsize) != dev_bsize) { 61166864Sadrian (void)lseek(fd, offset + i + dev_bsize, 0); 612101037Smux printf(" %jd,", (intmax_t)blk + i / dev_bsize); 61366864Sadrian } 61466864Sadrian printf("\n"); 61566864Sadrian return; 61666864Sadrian} 61766864Sadrian 618221233Sdesvoid 619221233Sdesblerase(int fd, ufs2_daddr_t blk, long size) 620221233Sdes{ 621221233Sdes off_t ioarg[2]; 622221233Sdes 623221233Sdes if (fd < 0) 624221233Sdes return; 625221233Sdes ioarg[0] = blk * dev_bsize; 626221233Sdes ioarg[1] = size; 627221233Sdes ioctl(fd, DIOCGDELETE, ioarg); 628221233Sdes /* we don't really care if we succeed or not */ 629221233Sdes return; 630221233Sdes} 631221233Sdes 632250056Sdesvoid 633250056Sdesblzero(int fd, ufs2_daddr_t blk, long size) 634250056Sdes{ 635250056Sdes static char *zero; 636250056Sdes off_t offset, len; 637250056Sdes 638250056Sdes if (fd < 0) 639250056Sdes return; 640250056Sdes len = ZEROBUFSIZE; 641250056Sdes if (zero == NULL) { 642250056Sdes zero = calloc(len, 1); 643250056Sdes if (zero == NULL) 644250056Sdes errx(EEXIT, "cannot allocate buffer pool"); 645250056Sdes } 646250056Sdes offset = blk * dev_bsize; 647250056Sdes if (lseek(fd, offset, 0) < 0) 648250056Sdes rwerror("SEEK BLK", blk); 649250056Sdes while (size > 0) { 650250056Sdes if (size > len) 651250056Sdes size = len; 652250056Sdes else 653250056Sdes len = size; 654250056Sdes if (write(fd, zero, len) != len) 655250056Sdes rwerror("WRITE BLK", blk); 656250056Sdes blk += len / dev_bsize; 657250056Sdes size -= len; 658250056Sdes } 659250056Sdes} 660250056Sdes 66166864Sadrian/* 662188110Smckusick * Verify cylinder group's magic number and other parameters. If the 663188110Smckusick * test fails, offer an option to rebuild the whole cylinder group. 664178088Sdelphij */ 665188110Smckusickint 666248658Smckusickcheck_cgmagic(int cg, struct bufarea *cgbp) 667178088Sdelphij{ 668248658Smckusick struct cg *cgp = cgbp->b_un.b_cg; 669178088Sdelphij 670188110Smckusick /* 671188110Smckusick * Extended cylinder group checks. 672188110Smckusick */ 673188110Smckusick if (cg_chkmagic(cgp) && 674188110Smckusick ((sblock.fs_magic == FS_UFS1_MAGIC && 675188110Smckusick cgp->cg_old_niblk == sblock.fs_ipg && 676188110Smckusick cgp->cg_ndblk <= sblock.fs_fpg && 677201700Smckusick cgp->cg_old_ncyl <= sblock.fs_old_cpg) || 678188110Smckusick (sblock.fs_magic == FS_UFS2_MAGIC && 679188110Smckusick cgp->cg_niblk == sblock.fs_ipg && 680188110Smckusick cgp->cg_ndblk <= sblock.fs_fpg && 681188110Smckusick cgp->cg_initediblk <= sblock.fs_ipg))) { 682188110Smckusick return (1); 683178088Sdelphij } 684188110Smckusick pfatal("CYLINDER GROUP %d: BAD MAGIC NUMBER", cg); 685188110Smckusick if (!reply("REBUILD CYLINDER GROUP")) { 686188110Smckusick printf("YOU WILL NEED TO RERUN FSCK.\n"); 687188110Smckusick rerun = 1; 688188110Smckusick return (1); 689188110Smckusick } 690188110Smckusick /* 691188110Smckusick * Zero out the cylinder group and then initialize critical fields. 692188110Smckusick * Bit maps and summaries will be recalculated by later passes. 693188110Smckusick */ 694188110Smckusick memset(cgp, 0, (size_t)sblock.fs_cgsize); 695188110Smckusick cgp->cg_magic = CG_MAGIC; 696188110Smckusick cgp->cg_cgx = cg; 697188110Smckusick cgp->cg_niblk = sblock.fs_ipg; 698188110Smckusick cgp->cg_initediblk = sblock.fs_ipg < 2 * INOPB(&sblock) ? 699188110Smckusick sblock.fs_ipg : 2 * INOPB(&sblock); 700188110Smckusick if (cgbase(&sblock, cg) + sblock.fs_fpg < sblock.fs_size) 701188110Smckusick cgp->cg_ndblk = sblock.fs_fpg; 702188110Smckusick else 703188110Smckusick cgp->cg_ndblk = sblock.fs_size - cgbase(&sblock, cg); 704188110Smckusick cgp->cg_iusedoff = &cgp->cg_space[0] - (u_char *)(&cgp->cg_firstfield); 705188110Smckusick if (sblock.fs_magic == FS_UFS1_MAGIC) { 706188110Smckusick cgp->cg_niblk = 0; 707188110Smckusick cgp->cg_initediblk = 0; 708188110Smckusick cgp->cg_old_ncyl = sblock.fs_old_cpg; 709188110Smckusick cgp->cg_old_niblk = sblock.fs_ipg; 710188110Smckusick cgp->cg_old_btotoff = cgp->cg_iusedoff; 711188110Smckusick cgp->cg_old_boff = cgp->cg_old_btotoff + 712188110Smckusick sblock.fs_old_cpg * sizeof(int32_t); 713188110Smckusick cgp->cg_iusedoff = cgp->cg_old_boff + 714188110Smckusick sblock.fs_old_cpg * sizeof(u_int16_t); 715188110Smckusick } 716188110Smckusick cgp->cg_freeoff = cgp->cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT); 717188110Smckusick cgp->cg_nextfreeoff = cgp->cg_freeoff + howmany(sblock.fs_fpg,CHAR_BIT); 718188110Smckusick if (sblock.fs_contigsumsize > 0) { 719188110Smckusick cgp->cg_nclusterblks = cgp->cg_ndblk / sblock.fs_frag; 720188110Smckusick cgp->cg_clustersumoff = 721188110Smckusick roundup(cgp->cg_nextfreeoff, sizeof(u_int32_t)); 722188110Smckusick cgp->cg_clustersumoff -= sizeof(u_int32_t); 723188110Smckusick cgp->cg_clusteroff = cgp->cg_clustersumoff + 724188110Smckusick (sblock.fs_contigsumsize + 1) * sizeof(u_int32_t); 725188110Smckusick cgp->cg_nextfreeoff = cgp->cg_clusteroff + 726188110Smckusick howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT); 727188110Smckusick } 728248658Smckusick dirty(cgbp); 729188110Smckusick return (0); 730178088Sdelphij} 731178088Sdelphij 732178088Sdelphij/* 73366864Sadrian * allocate a data block with the specified number of fragments 73466864Sadrian */ 73598542Smckusickufs2_daddr_t 73692839Simpallocblk(long frags) 73766864Sadrian{ 73866864Sadrian int i, j, k, cg, baseblk; 739248658Smckusick struct bufarea *cgbp; 740248658Smckusick struct cg *cgp; 74166864Sadrian 74266864Sadrian if (frags <= 0 || frags > sblock.fs_frag) 74366864Sadrian return (0); 74466864Sadrian for (i = 0; i < maxfsblock - sblock.fs_frag; i += sblock.fs_frag) { 74566864Sadrian for (j = 0; j <= sblock.fs_frag - frags; j++) { 74666864Sadrian if (testbmap(i + j)) 74766864Sadrian continue; 74866864Sadrian for (k = 1; k < frags; k++) 74966864Sadrian if (testbmap(i + j + k)) 75066864Sadrian break; 75166864Sadrian if (k < frags) { 75266864Sadrian j += k; 75366864Sadrian continue; 75466864Sadrian } 75566864Sadrian cg = dtog(&sblock, i + j); 756248658Smckusick cgbp = cgget(cg); 757248658Smckusick cgp = cgbp->b_un.b_cg; 758248658Smckusick if (!check_cgmagic(cg, cgbp)) 759188110Smckusick return (0); 76066864Sadrian baseblk = dtogd(&sblock, i + j); 76166864Sadrian for (k = 0; k < frags; k++) { 76266864Sadrian setbmap(i + j + k); 76366864Sadrian clrbit(cg_blksfree(cgp), baseblk + k); 76466864Sadrian } 76566864Sadrian n_blks += frags; 76666864Sadrian if (frags == sblock.fs_frag) 76766864Sadrian cgp->cg_cs.cs_nbfree--; 76866864Sadrian else 76966864Sadrian cgp->cg_cs.cs_nffree -= frags; 770248658Smckusick dirty(cgbp); 77166864Sadrian return (i + j); 77266864Sadrian } 77366864Sadrian } 77466864Sadrian return (0); 77566864Sadrian} 77666864Sadrian 77766864Sadrian/* 77866864Sadrian * Free a previously allocated block 77966864Sadrian */ 78066864Sadrianvoid 78198542Smckusickfreeblk(ufs2_daddr_t blkno, long frags) 78266864Sadrian{ 78366864Sadrian struct inodesc idesc; 78466864Sadrian 78566864Sadrian idesc.id_blkno = blkno; 78666864Sadrian idesc.id_numfrags = frags; 78766864Sadrian (void)pass4check(&idesc); 78866864Sadrian} 78966864Sadrian 790107671Siedowse/* Slow down IO so as to leave some disk bandwidth for other processes */ 791107671Siedowsevoid 792107671Siedowseslowio_start() 793107671Siedowse{ 794107671Siedowse 795129401Sscottl /* Delay one in every 8 operations */ 796107671Siedowse slowio_pollcnt = (slowio_pollcnt + 1) & 7; 797107671Siedowse if (slowio_pollcnt == 0) { 798107671Siedowse gettimeofday(&slowio_starttime, NULL); 799107671Siedowse } 800107671Siedowse} 801107671Siedowse 802107671Siedowsevoid 803107671Siedowseslowio_end() 804107671Siedowse{ 805107671Siedowse struct timeval tv; 806107671Siedowse int delay_usec; 807107671Siedowse 808107671Siedowse if (slowio_pollcnt != 0) 809107671Siedowse return; 810107671Siedowse 811107671Siedowse /* Update the slowdown interval. */ 812107671Siedowse gettimeofday(&tv, NULL); 813107671Siedowse delay_usec = (tv.tv_sec - slowio_starttime.tv_sec) * 1000000 + 814107671Siedowse (tv.tv_usec - slowio_starttime.tv_usec); 815107671Siedowse if (delay_usec < 64) 816107671Siedowse delay_usec = 64; 817129401Sscottl if (delay_usec > 2500000) 818129401Sscottl delay_usec = 2500000; 819107671Siedowse slowio_delay_usec = (slowio_delay_usec * 63 + delay_usec) >> 6; 820129401Sscottl /* delay by 8 times the average IO delay */ 821129401Sscottl if (slowio_delay_usec > 64) 822129401Sscottl usleep(slowio_delay_usec * 8); 823107671Siedowse} 824107671Siedowse 82566864Sadrian/* 82666864Sadrian * Find a pathname 82766864Sadrian */ 82866864Sadrianvoid 82992839Simpgetpathname(char *namebuf, ino_t curdir, ino_t ino) 83066864Sadrian{ 83166864Sadrian int len; 83292806Sobrien char *cp; 83366864Sadrian struct inodesc idesc; 83466864Sadrian static int busy = 0; 83566864Sadrian 83666864Sadrian if (curdir == ino && ino == ROOTINO) { 83766864Sadrian (void)strcpy(namebuf, "/"); 83866864Sadrian return; 83966864Sadrian } 840136281Struckman if (busy || !INO_IS_DVALID(curdir)) { 84166864Sadrian (void)strcpy(namebuf, "?"); 84266864Sadrian return; 84366864Sadrian } 84466864Sadrian busy = 1; 84566864Sadrian memset(&idesc, 0, sizeof(struct inodesc)); 84666864Sadrian idesc.id_type = DATA; 84766864Sadrian idesc.id_fix = IGNORE; 84866864Sadrian cp = &namebuf[MAXPATHLEN - 1]; 84966864Sadrian *cp = '\0'; 85066864Sadrian if (curdir != ino) { 85166864Sadrian idesc.id_parent = curdir; 85266864Sadrian goto namelookup; 85366864Sadrian } 85466864Sadrian while (ino != ROOTINO) { 85566864Sadrian idesc.id_number = ino; 85666864Sadrian idesc.id_func = findino; 857100935Sphk idesc.id_name = strdup(".."); 85866864Sadrian if ((ckinode(ginode(ino), &idesc) & FOUND) == 0) 85966864Sadrian break; 86066864Sadrian namelookup: 86166864Sadrian idesc.id_number = idesc.id_parent; 86266864Sadrian idesc.id_parent = ino; 86366864Sadrian idesc.id_func = findname; 86466864Sadrian idesc.id_name = namebuf; 86566864Sadrian if ((ckinode(ginode(idesc.id_number), &idesc)&FOUND) == 0) 86666864Sadrian break; 86766864Sadrian len = strlen(namebuf); 86866864Sadrian cp -= len; 86966864Sadrian memmove(cp, namebuf, (size_t)len); 87066864Sadrian *--cp = '/'; 87166864Sadrian if (cp < &namebuf[MAXNAMLEN]) 87266864Sadrian break; 87366864Sadrian ino = idesc.id_number; 87466864Sadrian } 87566864Sadrian busy = 0; 87666864Sadrian if (ino != ROOTINO) 87766864Sadrian *--cp = '?'; 87866864Sadrian memmove(namebuf, cp, (size_t)(&namebuf[MAXPATHLEN] - cp)); 87966864Sadrian} 88066864Sadrian 88166864Sadrianvoid 882100935Sphkcatch(int sig __unused) 88366864Sadrian{ 88496483Sphk 88596483Sphk ckfini(0); 88666864Sadrian exit(12); 88766864Sadrian} 88866864Sadrian 88966864Sadrian/* 89066864Sadrian * When preening, allow a single quit to signal 891102231Strhodes * a special exit after file system checks complete 89266864Sadrian * so that reboot sequence may be interrupted. 89366864Sadrian */ 89466864Sadrianvoid 895100935Sphkcatchquit(int sig __unused) 89666864Sadrian{ 897102231Strhodes printf("returning to single-user after file system check\n"); 89866864Sadrian returntosingle = 1; 89966864Sadrian (void)signal(SIGQUIT, SIG_DFL); 90066864Sadrian} 90166864Sadrian 90266864Sadrian/* 90366864Sadrian * determine whether an inode should be fixed. 90466864Sadrian */ 90566864Sadrianint 906100935Sphkdofix(struct inodesc *idesc, const char *msg) 90766864Sadrian{ 90866864Sadrian 90966864Sadrian switch (idesc->id_fix) { 91066864Sadrian 91166864Sadrian case DONTKNOW: 91266864Sadrian if (idesc->id_type == DATA) 91366864Sadrian direrror(idesc->id_number, msg); 91466864Sadrian else 91581911Skris pwarn("%s", msg); 91666864Sadrian if (preen) { 91766864Sadrian printf(" (SALVAGED)\n"); 91866864Sadrian idesc->id_fix = FIX; 91966864Sadrian return (ALTERED); 92066864Sadrian } 92166864Sadrian if (reply("SALVAGE") == 0) { 92266864Sadrian idesc->id_fix = NOFIX; 92366864Sadrian return (0); 92466864Sadrian } 92566864Sadrian idesc->id_fix = FIX; 92666864Sadrian return (ALTERED); 92766864Sadrian 92866864Sadrian case FIX: 92966864Sadrian return (ALTERED); 93066864Sadrian 93166864Sadrian case NOFIX: 93266864Sadrian case IGNORE: 93366864Sadrian return (0); 93466864Sadrian 93566864Sadrian default: 93666864Sadrian errx(EEXIT, "UNKNOWN INODESC FIX MODE %d", idesc->id_fix); 93766864Sadrian } 93866864Sadrian /* NOTREACHED */ 93966864Sadrian return (0); 94066864Sadrian} 94166864Sadrian 94266864Sadrian#include <stdarg.h> 94366864Sadrian 94466864Sadrian/* 945229778Suqs * An unexpected inconsistency occurred. 946102231Strhodes * Die if preening or file system is running with soft dependency protocol, 94766864Sadrian * otherwise just print message and continue. 94866864Sadrian */ 94966864Sadrianvoid 95066864Sadrianpfatal(const char *fmt, ...) 95166864Sadrian{ 95266864Sadrian va_list ap; 95366864Sadrian va_start(ap, fmt); 95466864Sadrian if (!preen) { 95575927Smckusick (void)vfprintf(stdout, fmt, ap); 95666864Sadrian va_end(ap); 95766864Sadrian if (usedsoftdep) 95875927Smckusick (void)fprintf(stdout, 95966864Sadrian "\nUNEXPECTED SOFT UPDATE INCONSISTENCY\n"); 96075557Smckusick /* 96175557Smckusick * Force foreground fsck to clean up inconsistency. 96275557Smckusick */ 96375557Smckusick if (bkgrdflag) { 96475557Smckusick cmd.value = FS_NEEDSFSCK; 96575557Smckusick cmd.size = 1; 96675557Smckusick if (sysctlbyname("vfs.ffs.setflags", 0, 0, 96775557Smckusick &cmd, sizeof cmd) == -1) 96875557Smckusick pwarn("CANNOT SET FS_NEEDSFSCK FLAG\n"); 96975927Smckusick fprintf(stdout, "CANNOT RUN IN BACKGROUND\n"); 97075557Smckusick ckfini(0); 97175557Smckusick exit(EEXIT); 97275557Smckusick } 97366864Sadrian return; 97466864Sadrian } 97566864Sadrian if (cdevname == NULL) 976100935Sphk cdevname = strdup("fsck"); 97775927Smckusick (void)fprintf(stdout, "%s: ", cdevname); 97875927Smckusick (void)vfprintf(stdout, fmt, ap); 97975927Smckusick (void)fprintf(stdout, 98066864Sadrian "\n%s: UNEXPECTED%sINCONSISTENCY; RUN fsck MANUALLY.\n", 98166864Sadrian cdevname, usedsoftdep ? " SOFT UPDATE " : " "); 98275557Smckusick /* 98375557Smckusick * Force foreground fsck to clean up inconsistency. 98475557Smckusick */ 98575557Smckusick if (bkgrdflag) { 98675557Smckusick cmd.value = FS_NEEDSFSCK; 98775557Smckusick cmd.size = 1; 98875557Smckusick if (sysctlbyname("vfs.ffs.setflags", 0, 0, 98975557Smckusick &cmd, sizeof cmd) == -1) 99075557Smckusick pwarn("CANNOT SET FS_NEEDSFSCK FLAG\n"); 99175557Smckusick } 99266864Sadrian ckfini(0); 99366864Sadrian exit(EEXIT); 99466864Sadrian} 99566864Sadrian 99666864Sadrian/* 99766864Sadrian * Pwarn just prints a message when not preening or running soft dependency 99866864Sadrian * protocol, or a warning (preceded by filename) when preening. 99966864Sadrian */ 100066864Sadrianvoid 100166864Sadrianpwarn(const char *fmt, ...) 100266864Sadrian{ 100366864Sadrian va_list ap; 100466864Sadrian va_start(ap, fmt); 100566864Sadrian if (preen) 100675927Smckusick (void)fprintf(stdout, "%s: ", cdevname); 100775927Smckusick (void)vfprintf(stdout, fmt, ap); 100866864Sadrian va_end(ap); 100966864Sadrian} 101066864Sadrian 101166864Sadrian/* 101266864Sadrian * Stub for routines from kernel. 101366864Sadrian */ 101466864Sadrianvoid 101566864Sadrianpanic(const char *fmt, ...) 101666864Sadrian{ 101766864Sadrian va_list ap; 101866864Sadrian va_start(ap, fmt); 101966864Sadrian pfatal("INTERNAL INCONSISTENCY:"); 102075927Smckusick (void)vfprintf(stdout, fmt, ap); 102166864Sadrian va_end(ap); 102266864Sadrian exit(EEXIT); 102366864Sadrian} 1024