sbin/fsck/main.c

   1 /*
   2  * Copyright (c) 1980, 1986, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * @(#) Copyright (c) 1980, 1986, 1993 The Regents of the University of California.  All rights reserved.
  34  * @(#)main.c   8.6 (Berkeley) 5/14/95
  35  * $FreeBSD: src/sbin/fsck/main.c,v 1.21.2.1 2001/01/23 23:11:07 iedowse Exp $
  36  * $DragonFly: src/sbin/fsck/main.c,v 1.5 2003/11/01 17:15:58 drhodus Exp $
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/stat.h>
  41 #include <sys/time.h>
  42 #include <sys/mount.h>
  43 #include <sys/resource.h>
  44
  45 #include <vfs/ufs/dinode.h>
  46 #include <vfs/ufs/ufsmount.h>
  47 #include <vfs/ufs/fs.h>
  48
  49 #include <err.h>
  50 #include <errno.h>
  51 #include <fstab.h>
  52 #include <paths.h>
  53
  54 #include "fsck.h"
  55
  56 static int argtoi(int flag, char *req, char *str, int base);
  57 static int docheck(struct fstab *fsp);
  58 static int checkfilesys __P((char *filesys, char *mntpt, long auxdata,
  59                 int child));
  60 static struct statfs *getmntpt(const char *);
  61 int main(int argc, char *argv[]);
  62
  63 int
  64 main(int argc, char **argv)
  65 {
  66         int ch;
  67         int ret, maxrun = 0;
  68         struct rlimit rlimit;
  69
  70         sync();
  71         while ((ch = getopt(argc, argv, "dfpnNyYb:c:l:m:")) != -1) {
  72                 switch (ch) {
  73                 case 'p':
  74                         preen++;
  75                         break;
  76
  77                 case 'b':
  78                         bflag = argtoi('b', "number", optarg, 10);
  79                         printf("Alternate super block location: %d\n", bflag);
  80                         break;
  81
  82                 case 'c':
  83                         cvtlevel = argtoi('c', "conversion level", optarg, 10);
  84                         break;
  85
  86                 case 'd':
  87                         debug++;
  88                         break;
  89
  90                 case 'f':
  91                         fflag++;
  92                         break;
  93
  94                 case 'l':
  95                         maxrun = argtoi('l', "number", optarg, 10);
  96                         break;
  97
  98                 case 'm':
  99                         lfmode = argtoi('m', "mode", optarg, 8);
 100                         if (lfmode &~ 07777)
 101                                 errx(EEXIT, "bad mode to -m: %o", lfmode);
 102                         printf("** lost+found creation mode %o\n", lfmode);
 103                         break;
 104
 105                 case 'n':
 106                 case 'N':
 107                         nflag++;
 108                         yflag = 0;
 109                         break;
 110
 111                 case 'y':
 112                 case 'Y':
 113                         yflag++;
 114                         nflag = 0;
 115                         break;
 116
 117                 default:
 118                         errx(EEXIT, "%c option?", ch);
 119                 }
 120         }
 121         argc -= optind;
 122         argv += optind;
 123         if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 124                 (void)signal(SIGINT, catch);
 125         if (preen)
 126                 (void)signal(SIGQUIT, catchquit);
 127         signal(SIGINFO, infohandler);
 128         /*
 129          * Push up our allowed memory limit so we can cope
 130          * with huge filesystems.
 131          */
 132         if (getrlimit(RLIMIT_DATA, &rlimit) == 0) {
 133                 rlimit.rlim_cur = rlimit.rlim_max;
 134                 (void)setrlimit(RLIMIT_DATA, &rlimit);
 135         }
 136         if (argc) {
 137                 while (argc-- > 0) {
 138                         char *path = blockcheck(*argv);
 139
 140                         if (path == NULL)
 141                                 pfatal("Can't check %s\n", *argv);
 142                         else
 143                                 (void)checkfilesys(path, 0, 0L, 0);
 144                         ++argv;
 145                 }
 146                 exit(0);
 147         }
 148         ret = checkfstab(preen, maxrun, docheck, checkfilesys);
 149         if (returntosingle)
 150                 exit(2);
 151         exit(ret);
 152 }
 153
 154 static int
 155 argtoi(int flag, char *req, char *str, int base)
 156 {
 157         char *cp;
 158         int ret;
 159
 160         ret = (int)strtol(str, &cp, base);
 161         if (cp == str || *cp)
 162                 errx(EEXIT, "-%c flag requires a %s", flag, req);
 163         return (ret);
 164 }
 165
 166 /*
 167  * Determine whether a filesystem should be checked.
 168  */
 169 static int
 170 docheck(register struct fstab *fsp)
 171 {
 172
 173         if (strcmp(fsp->fs_vfstype, "ufs") ||
 174             (strcmp(fsp->fs_type, FSTAB_RW) &&
 175              strcmp(fsp->fs_type, FSTAB_RO)) ||
 176             fsp->fs_passno == 0)
 177                 return (0);
 178         return (1);
 179 }
 180
 181 /*
 182  * Check the specified filesystem.
 183  */
 184 /* ARGSUSED */
 185 static int
 186 checkfilesys(char *filesys, char *mntpt, long auxdata, int child)
 187 {
 188         ufs_daddr_t n_ffree, n_bfree;
 189         struct dups *dp;
 190         struct statfs *mntbuf;
 191         struct zlncnt *zlnp;
 192         int cylno;
 193
 194         if (preen && child)
 195                 (void)signal(SIGQUIT, voidquit);
 196         cdevname = filesys;
 197         if (debug && preen)
 198                 pwarn("starting\n");
 199         switch (setup(filesys)) {
 200         case 0:
 201                 if (preen)
 202                         pfatal("CAN'T CHECK FILE SYSTEM.");
 203                 return (0);
 204         case -1:
 205                 pwarn("clean, %ld free ", sblock.fs_cstotal.cs_nffree +
 206                     sblock.fs_frag * sblock.fs_cstotal.cs_nbfree);
 207                 printf("(%d frags, %d blocks, %.1f%% fragmentation)\n",
 208                     sblock.fs_cstotal.cs_nffree, sblock.fs_cstotal.cs_nbfree,
 209                     sblock.fs_cstotal.cs_nffree * 100.0 / sblock.fs_dsize);
 210                 return (0);
 211         }
 212         got_siginfo = 0;
 213
 214         /*
 215          * Get the mount point information of the filesystem, if
 216          * it is available.
 217          */
 218         mntbuf = getmntpt(filesys);
 219
 220         /*
 221          * Cleared if any questions answered no. Used to decide if
 222          * the superblock should be marked clean.
 223          */
 224         resolved = 1;
 225         /*
 226          * 1: scan inodes tallying blocks used
 227          */
 228         if (preen == 0) {
 229                 printf("** Last Mounted on %s\n", sblock.fs_fsmnt);
 230                 if (mntbuf != NULL && mntbuf->f_flags & MNT_ROOTFS)
 231                         printf("** Root file system\n");
 232                 printf("** Phase 1 - Check Blocks and Sizes\n");
 233         }
 234         pass1();
 235
 236         /*
 237          * 1b: locate first references to duplicates, if any
 238          */
 239         if (duplist) {
 240                 if (preen || usedsoftdep)
 241                         pfatal("INTERNAL ERROR: dups with -p");
 242                 printf("** Phase 1b - Rescan For More DUPS\n");
 243                 pass1b();
 244         }
 245
 246         /*
 247          * 2: traverse directories from root to mark all connected directories
 248          */
 249         if (preen == 0)
 250                 printf("** Phase 2 - Check Pathnames\n");
 251         pass2();
 252
 253         /*
 254          * 3: scan inodes looking for disconnected directories
 255          */
 256         if (preen == 0)
 257                 printf("** Phase 3 - Check Connectivity\n");
 258         pass3();
 259
 260         /*
 261          * 4: scan inodes looking for disconnected files; check reference counts
 262          */
 263         if (preen == 0)
 264                 printf("** Phase 4 - Check Reference Counts\n");
 265         pass4();
 266
 267         /*
 268          * 5: check and repair resource counts in cylinder groups
 269          */
 270         if (preen == 0)
 271                 printf("** Phase 5 - Check Cyl groups\n");
 272         pass5();
 273
 274         /*
 275          * print out summary statistics
 276          */
 277         n_ffree = sblock.fs_cstotal.cs_nffree;
 278         n_bfree = sblock.fs_cstotal.cs_nbfree;
 279         pwarn("%ld files, %ld used, %ld free ",
 280             n_files, n_blks, n_ffree + sblock.fs_frag * n_bfree);
 281         printf("(%d frags, %d blocks, %.1f%% fragmentation)\n",
 282             n_ffree, n_bfree, n_ffree * 100.0 / sblock.fs_dsize);
 283         if (debug &&
 284             (n_files -= maxino - ROOTINO - sblock.fs_cstotal.cs_nifree))
 285                 printf("%d files missing\n", n_files);
 286         if (debug) {
 287                 n_blks += sblock.fs_ncg *
 288                         (cgdmin(&sblock, 0) - cgsblock(&sblock, 0));
 289                 n_blks += cgsblock(&sblock, 0) - cgbase(&sblock, 0);
 290                 n_blks += howmany(sblock.fs_cssize, sblock.fs_fsize);
 291                 if (n_blks -= maxfsblock - (n_ffree + sblock.fs_frag * n_bfree))
 292                         printf("%d blocks missing\n", n_blks);
 293                 if (duplist != NULL) {
 294                         printf("The following duplicate blocks remain:");
 295                         for (dp = duplist; dp; dp = dp->next)
 296                                 printf(" %d,", dp->dup);
 297                         printf("\n");
 298                 }
 299                 if (zlnhead != NULL) {
 300                         printf("The following zero link count inodes remain:");
 301                         for (zlnp = zlnhead; zlnp; zlnp = zlnp->next)
 302                                 printf(" %u,", zlnp->zlncnt);
 303                         printf("\n");
 304                 }
 305         }
 306         zlnhead = (struct zlncnt *)0;
 307         duplist = (struct dups *)0;
 308         muldup = (struct dups *)0;
 309         inocleanup();
 310         if (fsmodified) {
 311                 sblock.fs_time = time(NULL);
 312                 sbdirty();
 313         }
 314         if (cvtlevel && sblk.b_dirty) {
 315                 /*
 316                  * Write out the duplicate super blocks
 317                  */
 318                 for (cylno = 0; cylno < sblock.fs_ncg; cylno++)
 319                         bwrite(fswritefd, (char *)&sblock,
 320                             fsbtodb(&sblock, cgsblock(&sblock, cylno)), SBSIZE);
 321         }
 322         if (rerun)
 323                 resolved = 0;
 324
 325         /*
 326          * Check to see if the filesystem is mounted read-write.
 327          */
 328         if (mntbuf != NULL && (mntbuf->f_flags & MNT_RDONLY) == 0)
 329                 resolved = 0;
 330         ckfini(resolved);
 331
 332         for (cylno = 0; cylno < sblock.fs_ncg; cylno++)
 333                 if (inostathead[cylno].il_stat != NULL)
 334                         free((char *)inostathead[cylno].il_stat);
 335         free((char *)inostathead);
 336         inostathead = NULL;
 337         if (fsmodified && !preen)
 338                 printf("\n***** FILE SYSTEM WAS MODIFIED *****\n");
 339         if (rerun)
 340                 printf("\n***** PLEASE RERUN FSCK *****\n");
 341         if (mntbuf != NULL) {
 342                 struct ufs_args args;
 343                 int ret;
 344                 /*
 345                  * We modified a mounted filesystem.  Do a mount update on
 346                  * it unless it is read-write, so we can continue using it
 347                  * as safely as possible.
 348                  */
 349                 if (mntbuf->f_flags & MNT_RDONLY) {
 350                         args.fspec = 0;
 351                         args.export.ex_flags = 0;
 352                         args.export.ex_root = 0;
 353                         ret = mount("ufs", mntbuf->f_mntonname,
 354                             mntbuf->f_flags | MNT_UPDATE | MNT_RELOAD, &args);
 355                         if (ret == 0)
 356                                 return (0);
 357                         pwarn("mount reload of '%s' failed: %s\n\n",
 358                             mntbuf->f_mntonname, strerror(errno));
 359                 }
 360                 if (!fsmodified)
 361                         return (0);
 362                 if (!preen)
 363                         printf("\n***** REBOOT NOW *****\n");
 364                 sync();
 365                 return (4);
 366         }
 367         return (0);
 368 }
 369
 370 /*
 371  * Get the directory that the device is mounted on.
 372  */
 373 static struct statfs *
 374 getmntpt(const char *name)
 375 {
 376         struct stat devstat, mntdevstat;
 377         char device[sizeof(_PATH_DEV) - 1 + MNAMELEN];
 378         char *devname;
 379         struct statfs *mntbuf;
 380         int i, mntsize;
 381
 382         if (stat(name, &devstat) != 0 ||
 383             !(S_ISCHR(devstat.st_mode) || S_ISBLK(devstat.st_mode)))
 384                 return (NULL);
 385         mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
 386         for (i = 0; i < mntsize; i++) {
 387                 if (strcmp(mntbuf[i].f_fstypename, "ufs") != 0)
 388                         continue;
 389                 devname = mntbuf[i].f_mntfromname;
 390                 if (*devname != '/') {
 391                         strcpy(device, _PATH_DEV);
 392                         strcat(device, devname);
 393                         devname = device;
 394                 }
 395                 if (stat(devname, &mntdevstat) == 0 &&
 396                     mntdevstat.st_rdev == devstat.st_rdev)
 397                         return (&mntbuf[i]);
 398         }
 399         return (NULL);
 400 }