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.10 2007/04/20 22:20:10 dillon 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 #include <string.h>
  54
  55 #include "fsck.h"
  56
  57 static int argtoi(int flag, char *req, char *str, int base);
  58 static int docheck(struct fstab *fsp);
  59 static int checkfilesys(char *filesys, char *mntpt, long auxdata,
  60                 int child);
  61 static struct statfs *getmntpt(const char *);
  62 int main(int argc, char *argv[]);
  63
  64 int
  65 main(int argc, char **argv)
  66 {
  67         int ch;
  68         int ret, maxrun = 0;
  69         struct rlimit rlimit;
  70
  71         sync();
  72         while ((ch = getopt(argc, argv, "dfLpnNyYb:c:l:m:")) != -1) {
  73                 switch (ch) {
  74                 case 'p':
  75                         preen++;
  76                         break;
  77
  78                 case 'b':
  79                         bflag = argtoi('b', "number", optarg, 10);
  80                         printf("Alternate super block location: %d\n", bflag);
  81                         break;
  82
  83                 case 'c':
  84                         cvtlevel = argtoi('c', "conversion level", optarg, 10);
  85                         break;
  86
  87                 case 'd':
  88                         debug++;
  89                         break;
  90
  91                 case 'f':
  92                         fflag++;
  93                         break;
  94
  95                 case 'l':
  96                         maxrun = argtoi('l', "number", optarg, 10);
  97                         break;
  98
  99                 case 'L':
 100                         lastmntonly++;
 101                         break;
 102
 103                 case 'm':
 104                         lfmode = argtoi('m', "mode", optarg, 8);
 105                         if (lfmode &~ 07777)
 106                                 errx(EEXIT, "bad mode to -m: %o", lfmode);
 107                         printf("** lost+found creation mode %o\n", lfmode);
 108                         break;
 109
 110                 case 'n':
 111                 case 'N':
 112                         nflag++;
 113                         yflag = 0;
 114                         break;
 115
 116                 case 'y':
 117                 case 'Y':
 118                         yflag++;
 119                         nflag = 0;
 120                         break;
 121
 122                 default:
 123                         errx(EEXIT, "%c option?", ch);
 124                 }
 125         }
 126         argc -= optind;
 127         argv += optind;
 128         if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 129                 signal(SIGINT, catch);
 130         if (preen)
 131                 signal(SIGQUIT, catchquit);
 132         signal(SIGINFO, infohandler);
 133         /*
 134          * Push up our allowed memory limit so we can cope
 135          * with huge filesystems.
 136          */
 137         if (getrlimit(RLIMIT_DATA, &rlimit) == 0) {
 138                 rlimit.rlim_cur = rlimit.rlim_max;
 139                 setrlimit(RLIMIT_DATA, &rlimit);
 140         }
 141         if (argc) {
 142                 while (argc-- > 0) {
 143                         char *path = blockcheck(*argv);
 144
 145                         if (path == NULL)
 146                                 pfatal("Can't check %s\n", *argv);
 147                         else
 148                                 checkfilesys(path, 0, 0L, 0);
 149                         ++argv;
 150                 }
 151                 exit(0);
 152         }
 153         ret = checkfstab(preen, maxrun, docheck, checkfilesys);
 154         if (returntosingle)
 155                 exit(2);
 156         exit(ret);
 157 }
 158
 159 static int
 160 argtoi(int flag, char *req, char *str, int base)
 161 {
 162         char *cp;
 163         int ret;
 164
 165         ret = (int)strtol(str, &cp, base);
 166         if (cp == str || *cp)
 167                 errx(EEXIT, "-%c flag requires a %s", flag, req);
 168         return (ret);
 169 }
 170
 171 /*
 172  * Determine whether a filesystem should be checked.
 173  */
 174 static int
 175 docheck(struct fstab *fsp)
 176 {
 177
 178         if (strcmp(fsp->fs_vfstype, "ufs") ||
 179             (strcmp(fsp->fs_type, FSTAB_RW) &&
 180              strcmp(fsp->fs_type, FSTAB_RO)) ||
 181             fsp->fs_passno == 0)
 182                 return (0);
 183         return (1);
 184 }
 185
 186 /*
 187  * Check the specified filesystem.
 188  */
 189 /* ARGSUSED */
 190 static int
 191 checkfilesys(char *filesys, char *mntpt, long auxdata, int child)
 192 {
 193         ufs_daddr_t n_ffree, n_bfree;
 194         struct dups *dp;
 195         struct statfs *mntbuf;
 196         struct zlncnt *zlnp;
 197         int cylno;
 198
 199         if (preen && child)
 200                 signal(SIGQUIT, voidquit);
 201         cdevname = filesys;
 202         if (debug && preen)
 203                 pwarn("starting\n");
 204         switch (setup(filesys)) {
 205         case 0:
 206                 if (preen)
 207                         pfatal("CAN'T CHECK FILE SYSTEM.");
 208                 return (0);
 209         case -1:
 210                 pwarn("clean, %ld free ", sblock.fs_cstotal.cs_nffree +
 211                     sblock.fs_frag * sblock.fs_cstotal.cs_nbfree);
 212                 printf("(%d frags, %d blocks, %.1f%% fragmentation)\n",
 213                     sblock.fs_cstotal.cs_nffree, sblock.fs_cstotal.cs_nbfree,
 214                     sblock.fs_cstotal.cs_nffree * 100.0 / sblock.fs_dsize);
 215                 return (0);
 216         }
 217         got_siginfo = 0;
 218
 219         /*
 220          * Get the mount point information of the filesystem, if
 221          * it is available.
 222          */
 223         mntbuf = getmntpt(filesys);
 224
 225         /*
 226          * Cleared if any questions answered no. Used to decide if
 227          * the superblock should be marked clean.
 228          */
 229         resolved = 1;
 230         /*
 231          * 1: scan inodes tallying blocks used
 232          */
 233         if (lastmntonly) {
 234                 printf("** %s Last Mounted on %s\n", filesys, sblock.fs_fsmnt);
 235                 return (0);
 236         }
 237         if (preen == 0) {
 238                 printf("** Last Mounted on %s\n", sblock.fs_fsmnt);
 239                 if (mntbuf != NULL && mntbuf->f_flags & MNT_ROOTFS)
 240                         printf("** Root file system\n");
 241                 printf("** Phase 1 - Check Blocks and Sizes\n");
 242         }
 243         pass1();
 244
 245         /*
 246          * 1b: locate first references to duplicates, if any
 247          */
 248         if (duplist) {
 249                 if (preen || usedsoftdep)
 250                         pfatal("INTERNAL ERROR: dups with -p");
 251                 printf("** Phase 1b - Rescan For More DUPS\n");
 252                 pass1b();
 253         }
 254
 255         /*
 256          * 2: traverse directories from root to mark all connected directories
 257          */
 258         if (preen == 0)
 259                 printf("** Phase 2 - Check Pathnames\n");
 260         pass2();
 261
 262         /*
 263          * 3: scan inodes looking for disconnected directories
 264          */
 265         if (preen == 0)
 266                 printf("** Phase 3 - Check Connectivity\n");
 267         pass3();
 268
 269         /*
 270          * 4: scan inodes looking for disconnected files; check reference counts
 271          */
 272         if (preen == 0)
 273                 printf("** Phase 4 - Check Reference Counts\n");
 274         pass4();
 275
 276         /*
 277          * 5: check and repair resource counts in cylinder groups
 278          */
 279         if (preen == 0)
 280                 printf("** Phase 5 - Check Cyl groups\n");
 281         pass5();
 282
 283         /*
 284          * print out summary statistics
 285          */
 286         n_ffree = sblock.fs_cstotal.cs_nffree;
 287         n_bfree = sblock.fs_cstotal.cs_nbfree;
 288         pwarn("%ld files, %ld used, %ld free ",
 289             n_files, n_blks, n_ffree + sblock.fs_frag * n_bfree);
 290         printf("(%d frags, %d blocks, %.1f%% fragmentation)\n",
 291             n_ffree, n_bfree, n_ffree * 100.0 / sblock.fs_dsize);
 292         if (debug &&
 293             (n_files -= maxino - ROOTINO - sblock.fs_cstotal.cs_nifree))
 294                 printf("%d files missing\n", n_files);
 295         if (debug) {
 296                 n_blks += sblock.fs_ncg *
 297                         (cgdmin(&sblock, 0) - cgsblock(&sblock, 0));
 298                 n_blks += cgsblock(&sblock, 0) - cgbase(&sblock, 0);
 299                 n_blks += howmany(sblock.fs_cssize, sblock.fs_fsize);
 300                 if (n_blks -= maxfsblock - (n_ffree + sblock.fs_frag * n_bfree))
 301                         printf("%d blocks missing\n", n_blks);
 302                 if (duplist != NULL) {
 303                         printf("The following duplicate blocks remain:");
 304                         for (dp = duplist; dp; dp = dp->next)
 305                                 printf(" %d,", dp->dup);
 306                         printf("\n");
 307                 }
 308                 if (zlnhead != NULL) {
 309                         printf("The following zero link count inodes remain:");
 310                         for (zlnp = zlnhead; zlnp; zlnp = zlnp->next)
 311                                 printf(" %u,", zlnp->zlncnt);
 312                         printf("\n");
 313                 }
 314         }
 315         zlnhead = (struct zlncnt *)0;
 316         duplist = (struct dups *)0;
 317         muldup = (struct dups *)0;
 318         inocleanup();
 319         if (fsmodified) {
 320                 sblock.fs_time = time(NULL);
 321                 sbdirty();
 322         }
 323         if (cvtlevel && sblk.b_dirty) {
 324                 /*
 325                  * Write out the duplicate super blocks
 326                  */
 327                 for (cylno = 0; cylno < sblock.fs_ncg; cylno++)
 328                         bwrite(fswritefd, (char *)&sblock,
 329                             fsbtodb(&sblock, cgsblock(&sblock, cylno)), SBSIZE);
 330         }
 331         if (rerun)
 332                 resolved = 0;
 333
 334         /*
 335          * Check to see if the filesystem is mounted read-write.
 336          */
 337         if (mntbuf != NULL && (mntbuf->f_flags & MNT_RDONLY) == 0)
 338                 resolved = 0;
 339         ckfini(resolved);
 340
 341         for (cylno = 0; cylno < sblock.fs_ncg; cylno++)
 342                 if (inostathead[cylno].il_stat != NULL)
 343                         free((char *)inostathead[cylno].il_stat);
 344         free((char *)inostathead);
 345         inostathead = NULL;
 346         if (fsmodified && !preen)
 347                 printf("\n***** FILE SYSTEM WAS MODIFIED *****\n");
 348         if (rerun)
 349                 printf("\n***** PLEASE RERUN FSCK *****\n");
 350         if (mntbuf != NULL) {
 351                 struct ufs_args args;
 352                 int ret;
 353                 /*
 354                  * We modified a mounted filesystem.  Do a mount update on
 355                  * it unless it is read-write, so we can continue using it
 356                  * as safely as possible.
 357                  */
 358                 if (mntbuf->f_flags & MNT_RDONLY) {
 359                         args.fspec = 0;
 360                         args.export.ex_flags = 0;
 361                         args.export.ex_root = 0;
 362                         ret = mount("ufs", mntbuf->f_mntonname,
 363                             mntbuf->f_flags | MNT_UPDATE | MNT_RELOAD, &args);
 364                         if (ret == 0)
 365                                 return (0);
 366                         pwarn("mount reload of '%s' failed: %s\n\n",
 367                             mntbuf->f_mntonname, strerror(errno));
 368                 }
 369                 if (!fsmodified)
 370                         return (0);
 371                 if (!preen)
 372                         printf("\n***** REBOOT NOW *****\n");
 373                 sync();
 374                 return (4);
 375         }
 376         return (0);
 377 }
 378
 379 /*
 380  * Get the directory that the device is mounted on.
 381  */
 382 static struct statfs *
 383 getmntpt(const char *name)
 384 {
 385         struct stat devstat, mntdevstat;
 386         char device[sizeof(_PATH_DEV) - 1 + MNAMELEN];
 387         char *devname;
 388         struct statfs *mntbuf;
 389         int i, mntsize;
 390
 391         if (stat(name, &devstat) != 0 ||
 392             !(S_ISCHR(devstat.st_mode) || S_ISBLK(devstat.st_mode)))
 393                 return (NULL);
 394         mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
 395         for (i = 0; i < mntsize; i++) {
 396                 if (strcmp(mntbuf[i].f_fstypename, "ufs") != 0)
 397                         continue;
 398                 devname = mntbuf[i].f_mntfromname;
 399                 if (*devname != '/') {
 400                         strcpy(device, _PATH_DEV);
 401                         strcat(device, devname);
 402                         devname = device;
 403                 }
 404                 if (stat(devname, &mntdevstat) == 0 &&
 405                     mntdevstat.st_rdev == devstat.st_rdev)
 406                         return (&mntbuf[i]);
 407         }
 408         return (NULL);
 409 }