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