src/vfsck/main.c

   1 /*
   2  * Copyright (c) 1980, 1986 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that the above copyright notice and this paragraph are
   7  * duplicated in all such forms and that any documentation,
   8  * advertising materials, and other materials related to such
   9  * distribution and use acknowledge that the software was developed
  10  * by the University of California, Berkeley.  The name of the
  11  * University may not be used to endorse or promote products derived
  12  * from this software without specific prior written permission.
  13  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16  */
  17
  18 #include <afsconfig.h>
  19 #include <afs/param.h>
  20
  21 #ifdef AFS_HPUX_ENV
  22 /* We need the old directory type headers (included below), so don't include
  23  * the normal dirent.h, or it will conflict. */
  24 # undef HAVE_DIRENT_H
  25 # include <sys/inode.h>
  26 # define        LONGFILENAMES   1
  27 # include <sys/sysmacros.h>
  28 # include <sys/ino.h>
  29 # define        DIRSIZ_MACRO
  30 # ifdef HAVE_USR_OLD_USR_INCLUDE_NDIR_H
  31 #  include </usr/old/usr/include/ndir.h>
  32 # else
  33 #  include <ndir.h>
  34 # endif
  35 #endif
  36
  37 #include <roken.h>
  38
  39 #include <ctype.h>
  40
  41 #ifdef HAVE_SYS_FILE_H
  42 #include <sys/file.h>
  43 #endif
  44
  45 #define VICE                    /* allow us to put our changes in at will */
  46
  47 #ifdef AFS_SUN_ENV
  48 #define KERNEL
  49 #endif /* AFS_SUN_ENV */
  50 #include <sys/mount.h>
  51 #ifdef AFS_SUN_ENV
  52 #undef KERNEL
  53 #endif
  54
  55 #ifdef  AFS_OSF_ENV
  56 #include <sys/vnode.h>
  57 #include <sys/mount.h>
  58 #include <ufs/inode.h>
  59 #include <ufs/fs.h>
  60 #else /* AFS_OSF_ENV */
  61 #ifdef AFS_VFSINCL_ENV
  62 #define VFS
  63 #include <sys/vnode.h>
  64 #ifdef    AFS_SUN5_ENV
  65 #include <sys/fs/ufs_inode.h>
  66 #include <sys/fs/ufs_fs.h>
  67 #define _KERNEL
  68 #include <sys/fs/ufs_fsdir.h>
  69 #undef _KERNEL
  70 #include <sys/fs/ufs_mount.h>
  71 #else
  72 #include <ufs/inode.h>
  73 #include <ufs/fs.h>
  74 #define KERNEL
  75 #include <ufs/fsdir.h>
  76 #undef KERNEL
  77 #endif
  78 #else /* AFS_VFSINCL_ENV */
  79
  80 #include <sys/inode.h>
  81 #ifndef AFS_HPUX_ENV
  82 #define KERNEL
  83 #include <sys/dir.h>
  84 #undef KERNEL
  85 #endif
  86 #include <sys/fs.h>
  87 #endif /* AFS_VFSINCL_ENV */
  88 #endif /* AFS_OSF_ENV */
  89
  90 #include <sys/wait.h>
  91 #ifdef  XAFS_SUN_ENV
  92 #include <mntent.h>
  93 #else
  94 #ifdef  AFS_SUN5_ENV
  95 #include <sys/mnttab.h>
  96 #include <sys/mntent.h>
  97 #include <sys/vfstab.h>
  98 #include <sys/ustat.h>
  99 #else
 100 #include <fstab.h>
 101 #endif
 102 #endif
 103 #include "fsck.h"
 104 #include <sys/signal.h>
 105
 106 char *rawname(), *unrawname(), *blockcheck();
 107 void catch(), catchquit(), voidquit();
 108 static int tryForce;
 109 int returntosingle;
 110
 111 extern int errno;
 112
 113 struct part {
 114     char *name;                 /* device name */
 115     char *fsname;               /* mounted filesystem name */
 116     struct part *next;          /* forward link of partitions on disk */
 117 } *badlist, **badnext = &badlist;
 118
 119 struct disk {
 120     char *name;                 /* disk base name */
 121     struct disk *next;          /* forward link for list of disks */
 122     struct part *part;          /* head of list of partitions on disk */
 123     int pid;                    /* If != 0, pid of proc working on */
 124 } *disks;
 125
 126 int nrun, ndisks, maxrun, wflag = 0;
 127 #ifdef  AFS_HPUX_ENV
 128 int fixed;
 129 #endif
 130
 131 #if     defined(AFS_HPUX100_ENV)
 132 #include <ustat.h>
 133 #include <mntent.h>
 134 #endif
 135
 136 #ifdef VICE
 137 #define msgprintf   vfscklogprintf
 138 #else /* VICE */
 139 #define msgprintf   printf
 140 #endif /* VICE */
 141
 142 #ifdef  AFS_SUN5_ENV
 143 int mnt_passno = 0;
 144 #endif
 145
 146 #include "AFS_component_version_number.c"
 147
 148 #ifdef  AFS_HPUX_ENV
 149 int ge_danger = 0;              /* on when fsck is not able to fix the dirty file
 150                                  * system within single run. Problems like dup table
 151                                  * overflow, maxdup is exceeding MAXDUP.. etc. could
 152                                  * potentailly prevent fsck from doing a complete
 153                                  * repair. This is found in a GE hotsite. */
 154 #endif
 155
 156 main(argc, argv)
 157      int argc;
 158      char *argv[];
 159 {
 160     struct fstab *fsp;
 161     int pid, passno, sumstatus;
 162     char *name;
 163     struct disk *dk, *nextdisk;
 164     struct part *pt;
 165     extern char *AFSVersion;    /* generated version */
 166 #ifdef  AFS_SUN5_ENV
 167     int other_than_ufs = 0;
 168     char *subopt;
 169     struct vfstab vt;
 170     FILE *vfile;
 171     int ret;
 172     struct vfstab vget;
 173     FILE *fd;
 174 #endif
 175
 176     sync();
 177     tryForce = 0;
 178 #if     defined(AFS_HPUX_ENV)
 179     pclean = 0;
 180 #endif
 181 #if     defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV)
 182     fflag = 0;
 183 #endif
 184 #ifdef  AFS_SUN5_ENV
 185     fsflag = oflag = mflag = exitstat = 0;
 186 #endif
 187 #if     defined(AFS_HPUX100_ENV)
 188     mflag = 0;
 189 #endif
 190     printf("----Open AFS (R) %s fsck----\n", AFSVersion);       /* generated version */
 191     if (access("/TRYFORCE", 0) == 0)
 192         tryForce = 1;
 193     while (--argc > 0 && **++argv == '-') {
 194         switch (*++*argv) {
 195
 196 #if     defined(AFS_HPUX_ENV)
 197 #if     defined(AFS_HPUX100_ENV)
 198         case 'f':               /* default yes to answer force to check */
 199             fflag++;
 200             break;
 201 #else /* AFS_HPUX100_ENV */
 202 #ifdef  AFS_HPUX_ENV
 203         case 'F':               /* default yes to answer force to check */
 204             fflag++;
 205             break;
 206 #endif /* AFS_HPUX_ENV */
 207 #endif /* AFS_HPUX100_ENV */
 208         case 'P':
 209             pclean++;
 210             preen++;
 211             break;
 212 #endif
 213         case 'p':
 214             preen++;
 215             break;
 216 #if     defined(AFS_HPUX100_ENV)
 217         case 'V':
 218             {
 219                 int opt_count;
 220                 char *opt_text;
 221
 222                 (void)fprintf(stdout, "fsck -F hfs ");
 223                 for (opt_count = 1; opt_count < argc; opt_count++) {
 224                     opt_text = argv[opt_count];
 225                     if (opt_text)
 226                         (void)fprintf(stdout, " %s ", opt_text);
 227                 }
 228                 (void)fprintf(stdout, "\n");
 229                 exit(0);
 230             }
 231             break;
 232         case 'm':
 233             mflag++;
 234             break;
 235 #endif
 236 #ifdef  AFS_SUN5_ENV
 237         case 'V':
 238             {
 239                 int opt_count;
 240                 char *opt_text;
 241
 242                 (void)fprintf(stdout, "fsck -F ufs ");
 243                 for (opt_count = 1; opt_count < argc; opt_count++) {
 244                     opt_text = argv[opt_count];
 245                     if (opt_text)
 246                         (void)fprintf(stdout, " %s ", opt_text);
 247                 }
 248                 (void)fprintf(stdout, "\n");
 249             }
 250             break;
 251
 252         case 'o':
 253             subopt = *++argv;
 254             argc--;
 255             while (*subopt != '\0') {
 256                 if (*subopt == 'p') {
 257                     preen++;
 258                     break;
 259                 } else if (*subopt == 'b') {
 260                     if (argv[0][1] != '\0') {
 261                         bflag = atoi(argv[0] + 1);
 262                     } else {
 263                         bflag = atoi(*++argv);
 264                         argc--;
 265                     }
 266                     msgprintf("Alternate super block location: %d\n", bflag);
 267                     break;
 268                 } else if (*subopt == 'd') {
 269                     debug++;
 270                     break;
 271                 } else if (*subopt == 'r') {
 272                     break;
 273                 } else if (*subopt == 'w') {
 274                     wflag++;
 275                     break;
 276                 } else if (*subopt == 'c') {
 277                     cvtflag++;
 278                     break;
 279                 } else if (*subopt == 'f') {
 280                     fflag++;
 281                     break;
 282                 } else {
 283                     errexit("-o %c option?\n", *subopt);
 284                 }
 285                 subopt++;
 286                 ++argv;
 287                 argc--;
 288             }
 289             oflag++;
 290             break;
 291         case 'm':
 292             mflag++;
 293             break;
 294 #else
 295         case 'b':
 296             if (argv[0][1] != '\0') {
 297                 bflag = atoi(argv[0] + 1);
 298             } else {
 299                 bflag = atoi(*++argv);
 300                 argc--;
 301             }
 302             msgprintf("Alternate super block location: %d\n", bflag);
 303             break;
 304
 305         case 'c':
 306             cvtflag++;
 307             break;
 308
 309             /* who knows?  defined, but doesn't do much */
 310         case 'r':
 311             break;
 312
 313         case 'w':               /* check writable only */
 314             wflag++;
 315             break;
 316         case 'd':
 317             debug++;
 318             break;
 319         case 'l':
 320             if (!isdigit(argv[1][0]))
 321                 errexit("-l flag requires a number\n");
 322             maxrun = atoi(*++argv);
 323             argc--;
 324             break;
 325 #if     !defined(AFS_HPUX100_ENV)
 326         case 'm':
 327             if (!isdigit(argv[1][0]))
 328                 errexit("-m flag requires a mode\n");
 329             sscanf(*++argv, "%o", &lfmode);
 330             if (lfmode & ~07777)
 331                 errexit("bad mode to -m: %o\n", lfmode);
 332             argc--;
 333             printf("** lost+found creation mode %o\n", lfmode);
 334             break;
 335 #endif /* AFS_HPUX100_ENV */
 336 #endif /* AFS_SUN5_ENV */
 337 #ifdef  AFS_OSF_ENV
 338         case 'o':
 339             fflag++;
 340             break;
 341 #endif /* AFS_OSF_ENV */
 342         case 'n':
 343         case 'N':
 344             nflag++;
 345             yflag = 0;
 346             break;
 347
 348             /*
 349              * NOTE: -q flag is used only by HPux fsck versions but we add it for all systems since
 350              * it's general/useful flag to use.
 351              */
 352         case 'q':
 353             qflag++;
 354             break;
 355
 356         case 'y':
 357         case 'Y':
 358             yflag++;
 359             nflag = 0;
 360             break;
 361
 362         default:
 363             errexit("%c option?\n", **argv);
 364         }
 365     }
 366     /*
 367      * The following checks were only available on hpux but are useful to all systems.
 368      */
 369     if (nflag && preen)
 370         errexit("Incompatible options: -n and -p\n");
 371     if (nflag && qflag)
 372         errexit("Incompatible options: -n and -q\n");
 373
 374 #ifdef  AFS_SUN5_ENV
 375     rflag++;                    /* check raw devices */
 376 #endif
 377     if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 378         (void)signal(SIGINT, catch);
 379     if (preen)
 380         (void)signal(SIGQUIT, catchquit);
 381     if (argc) {
 382         while (argc-- > 0) {
 383             hotroot = 0;
 384 #ifdef  AFS_SUN5_ENV
 385             if (wflag && !writable(*argv)) {
 386                 (void)fprintf(stderr, "not writeable '%s'\n", *argv);
 387                 argv++;
 388             } else
 389 #endif
 390                 checkfilesys(*argv++, NULL);
 391         }
 392 #ifdef  AFS_HPUX_ENV
 393         if (ge_danger)
 394             exit(-1);
 395 #endif
 396 #ifdef  AFS_SUN5_ENV
 397         exit(exitstat);
 398 #else
 399         exit(0);
 400 #endif
 401     }
 402 #ifndef AFS_SUN5_ENV
 403     sumstatus = 0;
 404 #ifdef  AFS_SUN5_ENV
 405     if (fstype == NULL || strcmp(fstype, MNTTYPE_UFS) == 0) {
 406         int status;
 407
 408         if ((fd = fopen(VFSTAB, "r")) == NULL) {
 409             errexit("vfsck: cannot open vfstab\n");
 410         }
 411         while ((ret = getvfsent(fd, &vget)) == 0) {
 412             if (strcmp(vget.vfs_fstype, MNTTYPE_UFS)
 413                 && numbers(vget.vfs_fsckpass)) {
 414                 other_than_ufs++;
 415                 continue;
 416             }
 417             if (numbers(vget.vfs_fsckpass))
 418                 passno = atoi(vget.vfs_fsckpass);
 419             else
 420                 continue;
 421             if (passno < 1)
 422                 continue;
 423             if (preen == 0 || passno == 1) {
 424                 checkfilesys(vget.vfs_fsckdev, get.vfs_mountp);
 425             } else if (passno > 1) {
 426                 addpart(vget.vfs_fsckdev, vget.vfs_special);
 427             }
 428         }
 429 #else
 430     for (passno = 1; passno <= 2; passno++) {
 431         if (setfsent() == 0)
 432             errexit("Can't open checklist file: %s\n", FSTAB);
 433         while ((fsp = getfsent()) != 0) {
 434             if (strcmp(fsp->fs_type, FSTAB_RW)
 435                 && strcmp(fsp->fs_type, FSTAB_RO)
 436                 && strcmp(fsp->fs_type, FSTAB_RQ))
 437                 continue;
 438 #ifdef  AFS_OSF_ENV
 439             if (strcmp(fsp->fs_vfstype, "ufs") || fsp->fs_passno == 0) {
 440                 continue;
 441             }
 442 #endif /* AFS_OSF_ENV */
 443             if (preen == 0 || passno == 1 && fsp->fs_passno == 1) {
 444                 if (passno == 1) {
 445                     name = blockcheck(fsp->fs_spec);
 446                     if (name != NULL) {
 447                         checkfilesys(name, fsp->fs_file);
 448                     } else if (preen) {
 449                         printf("pid %d exiting 8/1\n", getpid());
 450                         exit(8);
 451                     }
 452                 }
 453             } else if (passno == 2 && fsp->fs_passno > 1) {
 454                 name = blockcheck(fsp->fs_spec);
 455                 if (name == NULL) {
 456                     pwarn("BAD DISK NAME %s\n", fsp->fs_spec);
 457                     sumstatus |= 8;
 458                     printf("pid %d saw bad disk name 8/3\n", getpid());
 459                     continue;
 460                 }
 461                 addpart(name, fsp->fs_file);
 462             }
 463         }
 464 #endif /* AFS_SUN5_ENV */
 465     }
 466     if (preen) {
 467         int status, rc;
 468
 469         if (maxrun == 0)
 470             maxrun = ndisks;
 471         if (maxrun > ndisks)
 472             maxrun = ndisks;
 473         nextdisk = disks;
 474         for (passno = 0; passno < maxrun; ++passno) {
 475             startdisk(nextdisk);
 476             nextdisk = nextdisk->next;
 477         }
 478         while ((pid = wait(&status)) != -1) {
 479             for (dk = disks; dk; dk = dk->next)
 480                 if (dk->pid == pid)
 481                     break;
 482             if (dk == 0) {
 483                 printf("Unknown pid %d\n", pid);
 484                 continue;
 485             }
 486             rc = WEXITSTATUS(status);
 487             if (WIFSIGNALED(status)) {
 488                 printf("%s (%s): EXITED WITH SIGNAL %d\n", dk->part->name,
 489                        dk->part->fsname, WTERMSIG(status));
 490                 rc = 8;
 491             }
 492             if (rc != 0) {
 493                 sumstatus |= rc;
 494                 *badnext = dk->part;
 495                 badnext = &dk->part->next;
 496                 dk->part = dk->part->next;
 497                 *badnext = NULL;
 498             } else
 499                 dk->part = dk->part->next;
 500             dk->pid = 0;
 501             nrun--;
 502             if (dk->part == NULL)
 503                 ndisks--;
 504
 505             if (nextdisk == NULL) {
 506                 if (dk->part)
 507                     startdisk(dk);
 508             } else if (nrun < maxrun && nrun < ndisks) {
 509                 for (;;) {
 510                     if ((nextdisk = nextdisk->next) == NULL)
 511                         nextdisk = disks;
 512                     if (nextdisk->part != NULL && nextdisk->pid == 0)
 513                         break;
 514                 }
 515                 startdisk(nextdisk);
 516             }
 517         }
 518     }
 519     if (sumstatus) {
 520         if (badlist == 0) {
 521             printf("pid %d exiting 8/2\n", getpid());
 522             exit(8);
 523         }
 524         printf("THE FOLLOWING FILE SYSTEM%s HAD AN %s\n\t",
 525                badlist->next ? "S" : "", "UNEXPECTED INCONSISTENCY:");
 526         for (pt = badlist; pt; pt = pt->next)
 527             printf("%s (%s)%s", pt->name, pt->fsname, pt->next ? ", " : "\n");
 528         exit(8);
 529     }
 530 #ifdef  AFS_SUN5_ENV
 531     fclose(fd);
 532 #else
 533     (void)endfsent();
 534 #endif
 535     if (returntosingle)
 536         exit(2);
 537 #endif /* !AFS_SUN5_ENV */
 538     exit(0);
 539 }
 540
 541 struct disk *
 542 finddisk(name)
 543      char *name;
 544 {
 545     struct disk *dk, **dkp;
 546     char *p;
 547     int len;
 548
 549     for (p = name + strlen(name) - 1; p >= name; --p)
 550         if (isdigit(*p)) {
 551             len = p - name + 1;
 552             break;
 553         }
 554     if (p < name)
 555         len = strlen(name);
 556
 557     for (dk = disks, dkp = &disks; dk; dkp = &dk->next, dk = dk->next) {
 558         if (strncmp(dk->name, name, len) == 0 && dk->name[len] == 0)
 559             return (dk);
 560     }
 561     if ((*dkp = (struct disk *)malloc(sizeof(struct disk))) == NULL)
 562         errexit("out of memory");
 563     dk = *dkp;
 564     if ((dk->name = malloc((unsigned int)len + 1)) == NULL)
 565         errexit("out of memory");
 566     strncpy(dk->name, name, len);
 567     dk->name[len] = '\0';
 568     dk->part = NULL;
 569     dk->next = NULL;
 570     dk->pid = 0;
 571     ndisks++;
 572     return (dk);
 573 }
 574
 575 addpart(name, fsname)
 576      char *name, *fsname;
 577 {
 578     struct disk *dk = finddisk(name);
 579     struct part *pt, **ppt = &dk->part;
 580
 581     for (pt = dk->part; pt; ppt = &pt->next, pt = pt->next)
 582         if (strcmp(pt->name, name) == 0) {
 583             printf("%s in fstab more than once!\n", name);
 584             return;
 585         }
 586     if ((*ppt = (struct part *)malloc(sizeof(struct part))) == NULL)
 587         errexit("out of memory");
 588     pt = *ppt;
 589     if ((pt->name = malloc((unsigned int)strlen(name) + 1)) == NULL)
 590         errexit("out of memory");
 591     strcpy(pt->name, name);
 592     if ((pt->fsname = malloc((unsigned int)strlen(fsname) + 1)) == NULL)
 593         errexit("out of memory");
 594     strcpy(pt->fsname, fsname);
 595     pt->next = NULL;
 596 }
 597
 598 startdisk(dk)
 599      struct disk *dk;
 600 {
 601
 602     nrun++;
 603     dk->pid = fork();
 604     if (dk->pid < 0) {
 605         perror("fork");
 606         exit(8);
 607     }
 608     if (dk->pid == 0) {
 609         (void)signal(SIGQUIT, voidquit);
 610         checkfilesys(dk->part->name, dk->part->fsname);
 611         exit(0);
 612     }
 613 }
 614
 615 checkfilesys(filesys, parname)
 616      char *filesys;
 617 {
 618     daddr_t n_ffree, n_bfree;
 619     struct dups *dp;
 620     struct stat tstat;          /* for ultrix 3 unmount */
 621     struct zlncnt *zlnp;
 622     char devbuffer[128];
 623     int ret_val;
 624
 625 #ifdef  AFS_OSF_ENV
 626     int temp;
 627 #endif /* AFS_OSF_ENV */
 628
 629 #ifdef  AFS_SUN_ENV
 630     iscorrupt = 1;
 631 #endif
 632 #ifdef  AFS_SUN5_ENV
 633     mountedfs = 0;
 634     isconvert = 0;
 635 #endif
 636 #ifdef  AFS_HPUX_ENV
 637     ge_danger = 0;              /* set to 1 by any table overflow or more
 638                                  * dup/bad blocks than expected */
 639
 640     fixed = 1;                  /* set to 0 by any 'no' reply */
 641 #endif
 642     strcpy(devbuffer, filesys); /* copy the file system name to the device buffer */
 643     devname = devbuffer;        /* remember generic ptr for later */
 644     EnsureDevice(devname);      /* canonicalize name */
 645     if (debug && preen)
 646         pinfo("starting\n");
 647
 648         ret_val = setup(devname);
 649
 650         if (ret_val == 0) {
 651 #ifdef  AFS_SUN_ENV
 652             if (iscorrupt == 0)
 653                 return;
 654 #endif
 655             if (preen)
 656                 pfatal("CAN'T CHECK FILE SYSTEM.");
 657 #ifdef  AFS_SUN5_ENV
 658             if ((exitstat == 0) && (mflag))
 659                 exitstat = 32;
 660             exit(exitstat);
 661 #endif
 662             return (0);
 663 #ifdef  AFS_HPUX_ENV
 664         } else if (ret_val == -1) {     /* pclean && FS_CLEAN */
 665             return (1);
 666 #endif
 667 #if     defined(AFS_OSF_ENV)
 668         } else if (ret_val == FS_CLEAN) {       /* pclean && FS_CLEAN */
 669             return (1);
 670 #endif
 671         }
 672 #if     defined(AFS_HPUX100_ENV)
 673         if (mflag)
 674             check_sanity(filesys);
 675 #endif
 676
 677 #ifdef  AFS_SUN5_ENV
 678         if (mflag)
 679             check_sanity(filesys);
 680         if (debug)
 681             printclean();
 682 #endif
 683 #ifdef  AFS_SUN_ENV
 684         iscorrupt = 0;
 685 #endif
 686         /*
 687          * 1: scan inodes tallying blocks used
 688          */
 689         if (preen == 0) {
 690 #if     defined(AFS_SUN5_ENV)
 691             if (mountedfs)
 692                 msgprintf("** Currently Mounted on %s\n", sblock.fs_fsmnt);
 693             else
 694 #endif
 695                 msgprintf("** Last Mounted on %s\n", sblock.fs_fsmnt);
 696             if (hotroot)
 697                 msgprintf("** Root file system\n");
 698 #ifdef  AFS_SUN5_ENV
 699             if (mflag) {
 700                 printf("** Phase 1 - Sanity Check only\n");
 701                 return;
 702             } else
 703 #endif
 704                 msgprintf("** Phase 1 - Check Blocks and Sizes\n");
 705         }
 706         pass1();
 707
 708         /*
 709          * 1b: locate first references to duplicates, if any
 710          */
 711         if (duplist) {
 712             if (preen)
 713                 pfatal("INTERNAL ERROR: dups with -p");
 714             msgprintf("** Phase 1b - Rescan For More DUPS\n");
 715             pass1b();
 716         }
 717
 718         /*
 719          * 2: traverse directories from root to mark all connected directories
 720          */
 721         if (preen == 0)
 722             msgprintf("** Phase 2 - Check Pathnames\n");
 723         pass2();
 724
 725         /*
 726          * 3: scan inodes looking for disconnected directories
 727          */
 728         if (preen == 0)
 729             msgprintf("** Phase 3 - Check Connectivity\n");
 730         pass3();
 731
 732         /*
 733          * 4: scan inodes looking for disconnected files; check reference counts
 734          */
 735         if (preen == 0)
 736             msgprintf("** Phase 4 - Check Reference Counts\n");
 737         pass4();
 738
 739         /*
 740          * 5: check and repair resource counts in cylinder groups
 741          */
 742         if (preen == 0)
 743             msgprintf("** Phase 5 - Check Cyl groups\n");
 744         pass5();
 745
 746 #if     defined(AFS_SUN_ENV)
 747     updateclean();
 748     if (debug)
 749         printclean();
 750 #endif
 751     /*
 752      * print out summary statistics
 753      */
 754     n_ffree = sblock.fs_cstotal.cs_nffree;
 755     n_bfree = sblock.fs_cstotal.cs_nbfree;
 756 #ifdef VICE
 757 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 758     pinfo("%d files, %d icont, %d used, %d free", n_files, n_cont, n_blks,
 759           n_ffree + sblock.fs_frag * n_bfree);
 760 #else
 761     pinfo("%d files, %d used, %d free", n_files, n_blks,
 762           n_ffree + sblock.fs_frag * n_bfree);
 763 #endif
 764     if (nViceFiles)
 765         msgprintf(", %d AFS files", nViceFiles);
 766     msgprintf(" (%d frags, %d blocks, %.1f%% fragmentation)\n", n_ffree,
 767               n_bfree, (float)(n_ffree * 100) / sblock.fs_dsize);
 768 #else /* VICE */
 769 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 770     pinfo("%d files, %d icont, %d used, %d free ", n_files, n_cont, n_blks,
 771           n_ffree + sblock.fs_frag * n_bfree);
 772 #else
 773     pinfo("%d files, %d used, %d free ", n_files, n_blks,
 774           n_ffree + sblock.fs_frag * n_bfree);
 775 #endif
 776     n printf("(%d frags, %d blocks, %.1f%% fragmentation)\n", n_ffree,
 777              n_bfree, (float)(n_ffree * 100) / sblock.fs_dsize);
 778 #endif /* VICE */
 779     if (debug && (n_files -= maxino - ROOTINO - sblock.fs_cstotal.cs_nifree))
 780         msgprintf("%d files missing\n", n_files);
 781     if (debug) {
 782         n_blks += sblock.fs_ncg * (cgdmin(&sblock, 0) - cgsblock(&sblock, 0));
 783         n_blks += cgsblock(&sblock, 0) - cgbase(&sblock, 0);
 784         n_blks += howmany(sblock.fs_cssize, sblock.fs_fsize);
 785         if (n_blks -= maxfsblock - (n_ffree + sblock.fs_frag * n_bfree))
 786             printf("%d blocks missing\n", n_blks);
 787         if (duplist != NULL) {
 788             msgprintf("The following duplicate blocks remain:");
 789             for (dp = duplist; dp; dp = dp->next)
 790                 msgprintf(" %d,", dp->dup);
 791             msgprintf("\n");
 792         }
 793         if (zlnhead != NULL) {
 794             msgprintf("The following zero link count inodes remain:");
 795             for (zlnp = zlnhead; zlnp; zlnp = zlnp->next)
 796                 msgprintf(" %d,", zlnp->zlncnt);
 797             msgprintf("\n");
 798         }
 799     }
 800 #ifdef  AFS_HPUX_ENV
 801     /* if user's specification denotes that the file system block
 802      * is going to be modified (nflag == 0) then fsck store the
 803      * correct magic number in the super block if it is not already
 804      * there
 805      */
 806     if (!nflag && !(fswritefd < 0)) {
 807         if (ge_danger) {
 808             printf("***** FILE SYSTEM IS NOT CLEAN, FSCK AGAIN *****\n");
 809             fsmodified++;
 810         } else {
 811             if (!hotroot) {
 812                 if (fixed && (sblock.fs_clean != FS_CLEAN)) {
 813                     if (!preen && !qflag)
 814                         printf("***** MARKING FILE SYSTEM CLEAN *****\n");
 815                     sblock.fs_clean = FS_CLEAN;
 816                     fsmodified++;
 817                 }
 818             } else {
 819                 /* fix FS_CLEAN if changes made and no 'no' replies */
 820                 if (fsmodified && fixed)
 821                     sblock.fs_clean = FS_CLEAN;
 822                 /*
 823                  *  Fix fs_clean if there were no 'no' replies.
 824                  *  This is done for both the s300 and s800.  The s800 root will be
 825                  *  guaranteed clean as of 7.0.
 826                  */
 827                 if (fixed && (sblock.fs_clean != FS_OK)) {
 828                     if (!preen && !qflag)
 829                         printf("***** MARKING FILE SYSTEM CLEAN *****\n");
 830                     sblock.fs_clean = FS_CLEAN;
 831                     fsmodified++;
 832                 }
 833             }
 834         }
 835     }
 836 #endif
 837     zlnhead = NULL;
 838     duplist = NULL;
 839
 840 #if     defined(AFS_SUN_ENV) && !defined(AFS_SUN3_ENV)  /* WAS AFS_SUN5_ENV */
 841 #ifdef  notdef
 842     inocleanup();
 843 #endif
 844     if (fsmodified)
 845         fixstate = 1;
 846     else
 847         fixstate = 0;
 848     if (hotroot && sblock.fs_clean == FSACTIVE)
 849         rebflg = 1;
 850 #ifdef  AFS_SUN5_ENV
 851     else if (!((sblock.fs_state + (afs_int32) sblock.fs_time == FSOKAY) &&
 852 #else
 853     else if (!((fs_get_state(&sblock) + (afs_int32) sblock.fs_time == FSOKAY)
 854                &&
 855 #endif
 856                (sblock.fs_clean == FSCLEAN || sblock.fs_clean == FSSTABLE))) {
 857         if (yflag || !iscorrupt) {
 858             printf("%s FILE SYSTEM STATE SET TO OKAY\n", devname);
 859             fixstate = 1;
 860         } else {
 861             printf("%s FILE SYSTEM STATE NOT SET TO OKAY\n", devname);
 862             fixstate = 0;
 863         }
 864     }
 865     if (fixstate) {
 866         (void)time(&sblock.fs_time);
 867         if (!iscorrupt) {
 868             if (hotroot && rebflg)
 869                 sblock.fs_clean = FSACTIVE;
 870             else
 871                 sblock.fs_clean = FSSTABLE;
 872 #ifdef  AFS_SUN5_ENV
 873             sblock.fs_state = FSOKAY - (afs_int32) sblock.fs_time;
 874 #else
 875             fs_set_state(&sblock, FSOKAY - (afs_int32) sblock.fs_time);
 876 #endif
 877         }
 878         sbdirty();
 879     }
 880 #else
 881 #ifdef  AFS_OSF_ENV
 882     if (!nflag && !bflag && !hotroot) {
 883         temp = fsmodified;
 884         sblock.fs_clean = FS_CLEAN;
 885         (void)time(&sblock.fs_time);
 886         sbdirty();
 887         flush(fswritefd, &sblk);
 888         fsmodified = temp;
 889     }
 890 #else /* AFS_OSF_ENV */
 891     if (fsmodified) {
 892         (void)time(&sblock.fs_time);
 893         sbdirty();
 894     }
 895 #endif
 896 #endif
 897     ckfini();
 898     free(blockmap);
 899     free(statemap);
 900     free((char *)lncntp);
 901     lncntp = NULL;
 902     blockmap = statemap = NULL;
 903 #ifdef  AFS_SUN5_ENV
 904     if (iscorrupt)
 905         exitstat = 36;
 906 #endif
 907     if (!fsmodified)
 908         return;
 909     if (!preen) {
 910         msgprintf("\n***** FILE SYSTEM WAS MODIFIED *****\n");
 911
 912         if (hotroot)
 913             msgprintf("\n***** REBOOT UNIX *****\n");
 914     }
 915 #ifdef  AFS_SUN5_ENV
 916     if (mountedfs || hotroot) {
 917         exitstat = 40;
 918     }
 919 #endif
 920     if (hotroot) {
 921         sync();
 922 #ifdef  AFS_HPUX_ENV
 923         if (ge_danger)
 924             exit(-1);
 925         else
 926 #endif
 927 #ifdef  AFS_SUN5_ENV
 928             exit(exitstat);
 929 #else
 930             exit(4);
 931 #endif
 932     }
 933 #ifdef VICE
 934     (void)close(fsreadfd);
 935     (void)close(fswritefd);
 936     if (nViceFiles || tryForce) {
 937         /* Modified file system with vice files: force full salvage */
 938         /* Salvager recognizes the file FORCESALVAGE in the root of each partition */
 939         struct ufs_args ufsargs;
 940
 941         char pname[100], fname[100], *special;
 942         int fd, code, failed = 0;
 943
 944         msgprintf
 945             ("%s: AFS file system partition was modified; forcing full salvage\n",
 946              devname);
 947         devname = unrawname(devname);
 948         special = (char *)strrchr(devname, '/');
 949         if (!special++)
 950             special = devname;
 951         strcpy(pname, "/etc/vfsck.");   /* Using /etc, rather than /tmp, since
 952                                          * /tmp is a link to /usr/tmp on some systems, and isn't mounted now */
 953         strcat(pname, special);
 954 #ifdef AFS_SUN_ENV
 955         /* if system mounted / as read-only, we'll try to fix now */
 956         if (access("/", W_OK) < 0 && errno == EROFS) {
 957             code = system("mount -o remount /");
 958             if (code) {
 959                 printf("Couldn't remount / R/W; continuing anyway (%d).\n",
 960                        errno);
 961                 failed = 1;
 962             }
 963         }
 964 #endif
 965 #ifdef  AFS_OSF_ENV
 966         /* if system mounted / as read-only, we'll try to fix now */
 967         if (access("/", W_OK) < 0 && errno == EROFS) {
 968             printf("Can't RW acceess /; %d\n", errno);
 969             code = system("/sbin/mount -u /");
 970             if (code) {
 971                 printf("Couldn't remount / R/W; continuing anyway (%d).\n",
 972                        errno);
 973                 failed = 1;
 974             }
 975         }
 976 #endif
 977         rmdir(pname);
 978         unlink(pname);
 979         if (mkdir(pname, 0777) < 0) {
 980             if (errno != EEXIST) {
 981                 perror("fsck mkdir");
 982                 failed = 1;
 983             }
 984         }
 985         if (failed && parname) {
 986             strcpy(pname, parname);
 987         }
 988 #if !defined(AFS_HPUX_ENV)
 989 #ifdef  AFS_SUN5_ENV
 990         ufsargs.flags = UFSMNT_NOINTR;
 991 #else
 992         ufsargs.fspec = devname;
 993 #endif
 994 #ifdef  AFS_SUN5_ENV
 995         if (mount
 996             (devname, pname, MS_DATA, "ufs", (char *)&ufsargs,
 997              sizeof(ufsargs)) < 0) {
 998 #else
 999         if (mount(MOUNT_UFS, pname, 0, &ufsargs) < 0) {
1000 #endif
1001 #else
1002         if (mount(devname, pname, 0) < 0) {
1003 #endif
1004             printf
1005                 ("Couldn't mount %s on %s to force FULL SALVAGE; continuing anyway (%d)!\n",
1006                  devname, pname, errno);
1007         } else {
1008             strcpy(fname, pname);
1009             strcat(fname, "/FORCESALVAGE");
1010             fd = open(fname, O_CREAT, 0);
1011             if (fd == -1) {
1012                 errexit("Couldn't create %s to force full salvage!\n", fname);
1013             } else {
1014                 fstat(fd, &tstat);
1015                 close(fd);
1016             }
1017 #if !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV)
1018             unmount(pname);
1019 #else
1020 #if     defined(AFS_OSF_ENV)
1021             umount(pname, MNT_NOFORCE);
1022 #else /* AFS_OSF_ENV */
1023             umount(devname);
1024 #endif
1025 #endif
1026         }
1027         rmdir(pname);
1028     }
1029     if (logfile) {
1030         fsync(fileno(logfile)); /* Since update isn't running */
1031         fclose(logfile);
1032         logfile = 0;
1033     }
1034 #endif /* VICE */
1035
1036 }
1037
1038 char *
1039 blockcheck(name)
1040      char *name;
1041 {
1042     struct stat stslash, stblock, stchar;
1043     char *raw;
1044     int retried = 0;
1045
1046     hotroot = 0;
1047     if (stat("/", &stslash) < 0) {
1048         perror("/");
1049         printf("Can't stat root\n");
1050         return (0);
1051     }
1052   retry:
1053     if (stat(name, &stblock) < 0) {
1054         perror(name);
1055         printf("Can't stat %s\n", name);
1056         return (0);
1057     }
1058     if ((stblock.st_mode & S_IFMT) == S_IFBLK) {
1059         if (stslash.st_dev == stblock.st_rdev) {
1060             hotroot++;
1061 #if     !defined(AFS_OSF_ENV)   /*  OSF/1 always uses the raw device, even for / */
1062             return (name);
1063 #endif /* AFS_OSF_ENV */
1064         }
1065         raw = rawname(name);
1066         if (raw) {
1067             return (raw);
1068         } else {
1069             printf("Cannot find character device for %s\n", name);
1070             return (name);
1071         }
1072     } else if ((stblock.st_mode & S_IFMT) == S_IFCHR && !retried) {
1073         name = unrawname(name);
1074         retried++;
1075         goto retry;
1076     }
1077     printf("Can't make sense out of name %s\n", name);
1078     return (0);
1079 }
1080
1081
1082 #if     defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV)
1083
1084 #ifdef  AFS_SUN5_ENV
1085 /*
1086  * exit 0 - file system is unmounted and okay
1087  * exit 32 - file system is unmounted and needs checking
1088  * exit 33 - file system is mounted for root file system
1089  * exit 34 - cannot stat device
1090  */
1091 check_sanity(filename)
1092      char *filename;
1093 {
1094     struct stat stbd, stbr;
1095     struct ustat usb;
1096     char *devname;
1097     struct vfstab vfsbuf;
1098     FILE *vfstab;
1099     int is_root = 0;
1100     int is_usr = 0;
1101     int is_block = 0;
1102
1103     if (stat(filename, &stbd) < 0) {
1104         fprintf(stderr, "ufs fsck: sanity check failed : cannot stat %s\n",
1105                 filename);
1106         exit(34);
1107     }
1108
1109     if ((stbd.st_mode & S_IFMT) == S_IFBLK)
1110         is_block = 1;
1111     else if ((stbd.st_mode & S_IFMT) == S_IFCHR)
1112         is_block = 0;
1113     else {
1114         fprintf(stderr,
1115                 "ufs fsck: sanity check failed: %s not block or character device\n",
1116                 filename);
1117         exit(34);
1118     }
1119     /*
1120      * Determine if this is the root file system via vfstab. Give up
1121      * silently on failures. The whole point of this is not to care
1122      * if the root file system is already mounted.
1123      *
1124      * XXX - similar for /usr. This should be fixed to simply return
1125      * a new code indicating, mounted and needs to be checked.
1126      */
1127     if ((vfstab = fopen(VFSTAB, "r")) != 0) {
1128         if (getvfsfile(vfstab, &vfsbuf, "/") == 0) {
1129             if (is_block)
1130                 devname = vfsbuf.vfs_special;
1131             else
1132                 devname = vfsbuf.vfs_fsckdev;
1133             if (stat(devname, &stbr) == 0)
1134                 if (stbr.st_rdev == stbd.st_rdev)
1135                     is_root = 1;
1136         }
1137         if (getvfsfile(vfstab, &vfsbuf, "/usr") == 0) {
1138             if (is_block)
1139                 devname = vfsbuf.vfs_special;
1140             else
1141                 devname = vfsbuf.vfs_fsckdev;
1142             if (stat(devname, &stbr) == 0)
1143                 if (stbr.st_rdev == stbd.st_rdev)
1144                     is_usr = 1;
1145         }
1146     }
1147
1148     /* XXX - only works if filename is a block device or if
1149      * character and block device has the same dev_t value */
1150     if (is_root == 0 && is_usr == 0 && ustat(stbd.st_rdev, &usb) == 0) {
1151         fprintf(stderr, "ufs fsck: sanity check: %s already mounted\n",
1152                 filename);
1153         exit(33);
1154     }
1155     /*
1156      * We mount the ufs root file system read-only first.  After fsck
1157      * runs, we remount the root as read-write.  Therefore, we no longer
1158      * check for different values for fs_state between the root file
1159      * system and the rest of file systems.
1160      */
1161     if (!((sblock.fs_state + (time_t) sblock.fs_time == FSOKAY)
1162           && (sblock.fs_clean == FSCLEAN || sblock.fs_clean == FSSTABLE))) {
1163         fprintf(stderr, "ufs fsck: sanity check: %s needs checking\n",
1164                 filename);
1165         exit(32);
1166     }
1167     fprintf(stderr, "ufs fsck: sanity check: %s okay\n", filename);
1168     exit(0);
1169 }
1170 #endif
1171
1172 #if     defined(AFS_HPUX100_ENV)
1173 check_sanity(filename)
1174      char *filename;
1175 {
1176     struct stat stbd, stbr;
1177     struct ustat usb;
1178     char *devname;
1179     FILE *vfstab;
1180     struct mntent *mnt;
1181     int is_root = 0;
1182     int is_usr = 0;
1183     int is_block = 0;
1184
1185     if (stat(filename, &stbd) < 0) {
1186         fprintf(stderr, "hfs fsck: sanity check failed : cannot stat %s\n",
1187                 filename);
1188         exit(34);
1189     }
1190
1191     if ((stbd.st_mode & S_IFMT) == S_IFBLK)
1192         is_block = 1;
1193     else if ((stbd.st_mode & S_IFMT) == S_IFCHR)
1194         is_block = 0;
1195     else {
1196         fprintf(stderr,
1197                 "hfs fsck: sanity check failed: %s not block or character device\n",
1198                 filename);
1199         exit(34);
1200     }
1201     /*
1202      * Determine if this is the root file system via vfstab. Give up
1203      * silently on failures. The whole point of this is not to care
1204      * if the root file system is already mounted.
1205      *
1206      * XXX - similar for /usr. This should be fixed to simply return
1207      * a new code indicating, mounted and needs to be checked.
1208      */
1209     if ((vfstab = setmntent(FSTAB, "r")) != 0) {
1210         while (mnt = getmntent(vfstab)) {
1211             if (!strcmp(mnt->mnt_dir, "/"))
1212                 if (stat(mnt->mnt_fsname, &stbr) == 0)
1213                     if (stbr.st_rdev == stbd.st_rdev)
1214                         is_root = 1;
1215
1216             if (!strcmp(mnt->mnt_dir, "/usr"))
1217                 if (stat(mnt->mnt_fsname, &stbr) == 0)
1218                     if (stbr.st_rdev == stbd.st_rdev)
1219                         is_usr = 1;
1220         }
1221         endmntent(vfstab);
1222     }
1223
1224     /* XXX - only works if filename is a block device or if
1225      * character and block device has the same dev_t value */
1226     if (is_root == 0 && is_usr == 0 && ustat(stbd.st_rdev, &usb) == 0) {
1227         fprintf(stderr, "hfs fsck: sanity check: %s already mounted\n",
1228                 filename);
1229         exit(33);
1230     }
1231     /*
1232      * We mount the ufs root file system read-only first.  After fsck
1233      * runs, we remount the root as read-write.  Therefore, we no longer
1234      * check for different values for fs_state between the root file
1235      * system and the rest of file systems.
1236      */
1237     if (!((sblock.fs_clean == FS_CLEAN || sblock.fs_clean == FS_OK))) {
1238         fprintf(stderr, "hfs fsck: sanity check: %s needs checking\n",
1239                 filename);
1240         exit(32);
1241     }
1242     fprintf(stderr, "hfs fsck: sanity check: %s okay\n", filename);
1243     exit(0);
1244 }
1245 #endif
1246 /* see if all numbers */
1247 numbers(yp)
1248      char *yp;
1249 {
1250     if (yp == NULL)
1251         return (0);
1252     while ('0' <= *yp && *yp <= '9')
1253         yp++;
1254     if (*yp)
1255         return (0);
1256     return (1);
1257 }
1258 #endif
1259
1260 /* Convert a raw device name into a block device name.
1261  * If the block device is not found, return the raw device name.
1262  * For HP and SUN, the returned value is not changed. For other
1263  * platforms it is changed (I see no rhyme or reason -jpm).
1264  */
1265 char *
1266 unrawname(rawdev)
1267      char *rawdev;
1268 {
1269     static char bldev[256];
1270     struct stat statbuf;
1271     int code, i;
1272
1273     code = stat(rawdev, &statbuf);
1274     if ((code < 0) || !S_ISCHR(statbuf.st_mode))
1275         return (rawdev);        /* Not a char device */
1276
1277     for (i = strlen(rawdev) - 2; i >= 0; i--) {
1278         if ((rawdev[i] == '/') && (rawdev[i + 1] == 'r')) {
1279             strcpy(bldev, rawdev);
1280             bldev[i + 1] = 0;
1281             strcat(bldev, &rawdev[i + 2]);
1282
1283             code = stat(bldev, &statbuf);       /* test for block device */
1284             if (!code && S_ISBLK(statbuf.st_mode)) {
1285 #if defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV)
1286                 return (bldev);
1287 #else
1288                 strcpy(rawdev, bldev);  /* Replace */
1289                 return (rawdev);
1290 #endif
1291             }
1292         }
1293     }
1294     return (rawdev);
1295 }
1296
1297 /* Convert a block device name into a raw device name.
1298  * If the block device is not found, return null
1299  */
1300 char *
1301 rawname(bldev)
1302      char *bldev;
1303 {
1304     static char rawdev[256];
1305     struct stat statbuf;
1306     int code, i;
1307
1308     for (i = strlen(bldev) - 1; i >= 0; i--) {
1309         if (bldev[i] == '/') {
1310             strcpy(rawdev, bldev);
1311             rawdev[i + 1] = 'r';
1312             rawdev[i + 2] = 0;
1313             strcat(rawdev, &bldev[i + 1]);
1314
1315             code = stat(rawdev, &statbuf);
1316             if (!code && S_ISCHR(statbuf.st_mode))
1317                 return (rawdev);
1318         }
1319     }
1320     return NULL;
1321 }