src/vfsck/setup.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 RCSID("$Header$");
  22
  23 #include <stdio.h>
  24 #define VICE
  25
  26 #if     defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV)
  27 #define AFS_NEWCG_ENV
  28 #else
  29 #undef AFS_NEWCG_ENV
  30 #endif
  31
  32 #ifdef VICE
  33 #define msgprintf vfscklogprintf
  34 extern vfscklogprintf();
  35 #endif
  36
  37 #define DKTYPENAMES
  38 #include <sys/param.h>
  39 #include <sys/time.h>
  40
  41 #ifdef  AFS_OSF_ENV
  42 #include <sys/vnode.h>
  43 #include <sys/mount.h>
  44 #include <ufs/inode.h>
  45 #include <ufs/fs.h>
  46 #define _BSD
  47 #define _KERNEL
  48 #include <ufs/dir.h>
  49 #undef  _KERNEL
  50 #undef  _BSD
  51 #include <stdio.h>
  52 #else   /* AFS_OSF_ENV */
  53 #ifdef AFS_VFSINCL_ENV
  54 #include <sys/vnode.h>
  55 #ifdef    AFS_SUN5_ENV
  56 #include <stdio.h>
  57 #include <unistd.h>
  58 #include <sys/fs/ufs_inode.h>
  59 #include <sys/fs/ufs_fs.h>
  60 #define _KERNEL
  61 #include <sys/fs/ufs_fsdir.h>
  62 #undef _KERNEL
  63 #include <sys/fs/ufs_mount.h>
  64 #else
  65 #include <ufs/inode.h>
  66 #include <ufs/fs.h>
  67 #endif
  68 #else /* AFS_VFSINCL_ENV */
  69 #include <sys/inode.h>
  70 #ifdef  AFS_HPUX_ENV
  71 #include <ctype.h>
  72 #define LONGFILENAMES   1
  73 #include <sys/sysmacros.h>
  74 #include <sys/ino.h>
  75 #endif
  76 #include <sys/fs.h>
  77 #endif /* AFS_VFSINCL_ENV */
  78 #endif  /* AFS_OSF_ENV */
  79
  80 #include <sys/stat.h>
  81 #include <sys/ioctl.h>
  82 #include <sys/file.h>
  83 #include <ctype.h>
  84 #ifdef  AFS_SUN5_ENV
  85 #include <sys/mntent.h>
  86 #include <sys/vfstab.h>
  87 #endif
  88
  89 #include <afs/osi_inode.h>
  90 #include "fsck.h"
  91
  92 struct bufarea asblk;
  93 struct bufarea *pbp;
  94
  95 #define altsblock (*asblk.b_un.b_fs)
  96 #define POWEROF2(num)   (((num) & ((num) - 1)) == 0)
  97
  98 /*
  99  * The size of a cylinder group is calculated by CGSIZE. The maximum size
 100  * is limited by the fact that cylinder groups are at most one block.
 101  * Its size is derived from the size of the maps maintained in the
 102  * cylinder group and the (struct cg) size.
 103  */
 104 #define CGSIZE(fs) \
 105     /* base cg */       (sizeof(struct cg) + \
 106     /* blktot size */   (fs)->fs_cpg * sizeof(afs_int32) + \
 107     /* blks size */     (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(short) + \
 108     /* inode map */     howmany((fs)->fs_ipg, NBBY) + \
 109     /* block map */     howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY))
 110
 111 char    *malloc(), *calloc();
 112 struct  disklabel *getdisklabel();
 113
 114 setup(dev)
 115         char *dev;
 116 {
 117         dev_t rootdev;
 118         long cg, size, asked, i, j;
 119         long bmapsize;
 120         struct disklabel *lp;
 121         struct stat statb;
 122         struct fs proto;
 123 #if     defined(AFS_SUN5_ENV)
 124         static char sname[MAXPATHLEN];
 125 #endif
 126
 127         /* reset static variables that may have been damaged by parent fork */
 128         mlk_pbp = 0;
 129         pbp = 0;
 130         mlk_startinum = 0;
 131 #ifdef  AFS_DEC_ENV
 132         iscorrupt = 0;
 133 #endif
 134 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 135         n_cont = 0;
 136 #endif
 137         havesb = 0;
 138         if (stat("/", &statb) < 0)
 139                 errexit("Can't stat root\n");
 140         rootdev = statb.st_dev;
 141 #if     defined(AFS_SUN5_ENV)
 142         strncpy(sname, dev, sizeof(sname));
 143 restat:
 144         if (stat(sname, &statb) < 0) {
 145                 perror(sname);
 146                 msgprintf("Can't stat %s\n", sname);
 147 #else
 148         if (stat(dev, &statb) < 0) {
 149                 perror(dev);
 150                 printf("Can't stat %s\n", dev);
 151 #endif
 152                 return (0);
 153         }
 154 #ifdef  AFS_SUN5_ENV
 155         if ((statb.st_mode & S_IFMT) == S_IFDIR) {
 156             FILE *fp;
 157             struct vfstab vtab;
 158
 159             if ((fp = fopen(VFSTAB, "r")) == NULL) {
 160                 pfatal("Can't open %s file\n", VFSTAB);
 161                 exit(1);
 162             }
 163             while (!getvfsent(fp, &vtab)) {
 164                 if (vtab.vfs_mountp && !strcmp(vtab.vfs_mountp, sname)) {
 165                     strcpy(sname, vtab.vfs_special);
 166                     if (rflag) {
 167                         char *s = vtab.vfs_fsckdev;
 168                         strcpy(sname, s);
 169                     }
 170                     goto restat;
 171                 }
 172             }
 173             fclose(fp);
 174         }
 175 #endif
 176         if ((statb.st_mode & S_IFMT) != S_IFBLK &&
 177             (statb.st_mode & S_IFMT) != S_IFCHR) {
 178             pfatal("device is not a block or character device");
 179             if (reply("file is not a block or character device; OK") == 0)
 180                 return (0);
 181         }
 182 #ifdef  AFS_SUN5_ENV
 183         if (mounted(sname))
 184             if (rflag)
 185                 mountedfs++;
 186             else {
 187                 printf("%s is mounted, fsck on BLOCK device ignored\n", sname);
 188                 exit(33);
 189             }
 190         if (rflag) {
 191             char bname[MAXPATHLEN], *tname;
 192
 193             strcpy(bname, sname);
 194             tname = unrawname(bname);
 195             if (stat(tname, &statb) < 0) {
 196                 pfatal("Can't stat %s\n", tname);
 197                 return (0);
 198             }
 199             dev = sname;
 200         }
 201 #endif
 202         hotroot = is_hotroot(dev);
 203
 204         /*
 205          * The following code is added to improve usability of fsck.
 206          * we need to give user a warning if the device being checked is
 207          * a hotroot, a mounted file system, or a swap device.
 208          * The rules are:
 209          *      1) if nflag is set, it's pretty safe to fsck the target dev
 210          *      2) if the target device is a swap, exit
 211          *      3) if hotroot is set, and "-F" is not specified prompt the
 212          *              user and wait for reply
 213          *      4) if the target is a mounted file system, and "-F" is not
 214          *              specified, prompt the user and wait for reply
 215          *      5) if the "-m" is specifed, do no prompting since only a sanity
 216          *              check is being done. important during booting
 217          *
 218          * Caveat: There is no way to tell the current run level, so we cannot
 219          * tell whether or not we are in single user mode.
 220          */
 221          if (!nflag) {
 222              int mounted, swap;
 223              struct stat st_mounted;
 224
 225              mounted = swap = 0;
 226              if (!hotroot) {
 227                  mounted = is_mounted(dev,&st_mounted);
 228 #ifdef  AFS_HPUX_ENV
 229                  swap = is_swap(st_mounted.st_rdev);
 230 #endif
 231              }
 232              if (!fflag
 233 #ifdef  AFS_HPUX_ENV
 234 && !mflag
 235 #endif
 236 ) {
 237                  if (hotroot) {
 238                      msgprintf("fsck: %s: root file system",dev);
 239                      if (preen)
 240                          msgprintf(" (CONTINUING)\n");
 241                      else {
 242                          if (!freply("continue (y/n)"))
 243                              return (0);
 244                      }
 245                  } else if (mounted) {
 246                      msgprintf("fsck: %s: mounted file system",dev);
 247                      if (preen)
 248                          msgprintf(" (CONTINUING)\n");
 249                      else {
 250                          if (!freply("continue (y/n)"))
 251                              return (0);
 252                      }
 253                  } else if (swap) {
 254                      msgprintf("fsck: %s: swap device\n",dev);
 255                      if (preen)
 256                          msgprintf(" (CONTINUING)\n");
 257                      else {
 258                          if (!freply("continue (y/n)"))
 259                              return (0);
 260                      }
 261                  }
 262              }
 263          }
 264         if (rootdev == statb.st_rdev)
 265                 hotroot++;
 266         if ((fsreadfd = open(dev, O_RDONLY)) < 0) {
 267                 perror(dev);
 268                 msgprintf("Can't open %s\n", dev);
 269                 return (0);
 270         }
 271         if (preen == 0)
 272                 msgprintf("** %s", dev);
 273         if (nflag || (fswritefd = open(dev, O_WRONLY)) < 0) {
 274                 fswritefd = -1;
 275                 msgprintf(" (NO WRITE)");
 276 #ifdef  notdef
 277                 if (preen) {
 278                   pfatal("NO WRITE ACCESS");
 279                 }
 280 #endif
 281         }
 282         if (preen == 0)
 283                 msgprintf("\n");
 284 #if     defined(AFS_HPUX101_ENV)
 285         setup_all_block_seek();
 286 #endif
 287 #ifdef  AFS_SUN5_ENV
 288         else if (debug)
 289                 printf(" pid %d\n", getpid());
 290         if (debug && (hotroot || mountedfs)) {
 291                 printf("** %s", sname);
 292                 if (hotroot) {
 293                         printf(" is root fs");
 294                         if (mountedfs)
 295                                 printf(" and");
 296                 }
 297                 if (mountedfs)
 298                         printf(" is mounted");
 299                 printf(".\n");
 300         }
 301 #endif
 302         fsmodified = 0;
 303         lfdir = 0;
 304         initbarea(&sblk);
 305         initbarea(&asblk);
 306 #ifdef __alpha
 307         sblk.b_un.b_buf = malloc(SBSIZE+ALPHA_EXT);
 308         asblk.b_un.b_buf = malloc(SBSIZE+ALPHA_EXT);
 309 #else   /* __alpha */
 310         sblk.b_un.b_buf = malloc(SBSIZE);
 311         asblk.b_un.b_buf = malloc(SBSIZE);
 312 #endif
 313         if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
 314                 errexit("cannot allocate space for superblock\n");
 315                 dev_bsize = secsize = DEV_BSIZE;
 316
 317         /*
 318          * Read in the superblock, looking for alternates if necessary
 319          */
 320         if (readsb(1) == 0) {
 321                 if (bflag || preen || calcsb(dev, fsreadfd, &proto) == 0)
 322                         return(0);
 323                 if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
 324                         return (0);
 325                 for (cg = 0; cg < proto.fs_ncg; cg++) {
 326                         bflag = fsbtodb(&proto, cgsblock(&proto, cg));
 327                         if (readsb(0) != 0)
 328                                 break;
 329                 }
 330                 if (cg >= proto.fs_ncg) {
 331                         msgprintf("%s %s\n%s %s\n%s %s\n",
 332                                 "SEARCH FOR ALTERNATE SUPER-BLOCK",
 333                                 "FAILED. YOU MUST USE THE",
 334                                 "-b OPTION TO FSCK TO SPECIFY THE",
 335                                 "LOCATION OF AN ALTERNATE",
 336                                 "SUPER-BLOCK TO SUPPLY NEEDED",
 337                                 "INFORMATION; SEE fsck(8).");
 338                         return(0);
 339                 }
 340                 pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
 341         }
 342         maxfsblock = sblock.fs_size;
 343         maxino = sblock.fs_ncg * sblock.fs_ipg;
 344         /*
 345          * Check and potentially fix certain fields in the super block.
 346          */
 347         if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
 348                 pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
 349                 if (reply("SET TO DEFAULT") == 1) {
 350                         sblock.fs_optim = FS_OPTTIME;
 351                         sbdirty();
 352                 }
 353         }
 354         if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
 355                 pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
 356                         sblock.fs_minfree);
 357                 if (reply("SET TO DEFAULT") == 1) {
 358                         sblock.fs_minfree = 10;
 359                         sbdirty();
 360                 }
 361         }
 362 #ifdef  AFS_DEC_ENV
 363         /*
 364          * If '-p' is used and the partition was cleanly unmounted last time then skip the
 365          * fscking process
 366          */
 367         if (only_when_needed && (sblock.fs_clean == FS_CLEAN) &&
 368                                 clean_byte_valid(sblock.fs_lastfsck)) {
 369                 msgprintf("%s: umounted cleanly\n", dev);
 370                 return(FS_CLEAN);
 371         }
 372 #endif
 373 #ifdef  AFS_HPUX_ENV
 374         /*
 375          * Do we need to continue ?
 376          */
 377         if (pclean && sblock.fs_clean == FS_CLEAN)
 378             return(-1);
 379         if (pclean && hotroot && sblock.fs_clean == FS_OK)
 380             return(-1);
 381 #endif
 382 #ifdef AFS_NEWCG_ENV
 383         if (sblock.fs_interleave < 1) {
 384                 pwarn("IMPOSSIBLE INTERLEAVE=%d IN SUPERBLOCK",
 385                         sblock.fs_interleave);
 386                 sblock.fs_interleave = 1;
 387                 if (preen)
 388                         msgprintf(" (FIXED)\n");
 389                 if (preen || reply("SET TO DEFAULT") == 1) {
 390                         sbdirty();
 391                         dirty(&asblk);
 392                 }
 393         }
 394 #endif /* AFS_NEWCG_ENV */
 395 #ifdef AFS_NEWCG_ENV
 396         if (sblock.fs_npsect < sblock.fs_nsect) {
 397                 pwarn("IMPOSSIBLE NPSECT=%d IN SUPERBLOCK",
 398                         sblock.fs_npsect);
 399                 sblock.fs_npsect = sblock.fs_nsect;
 400                 if (preen)
 401                         msgprintf(" (FIXED)\n");
 402                 if (preen || reply("SET TO DEFAULT") == 1) {
 403                         sbdirty();
 404                         dirty(&asblk);
 405                 }
 406         }
 407 #endif /* AFS_NEWCG_ENV */
 408 #ifdef AFS_NEWCG_ENV
 409         if (cvtflag) {
 410                 if (sblock.fs_postblformat == FS_42POSTBLFMT) {
 411                         /*
 412                          * Requested to convert from old format to new format
 413                          */
 414                         if (preen)
 415                                 pwarn("CONVERTING TO NEW FILE SYSTEM FORMAT\n");
 416                         else if (!reply("CONVERT TO NEW FILE SYSTEM FORMAT"))
 417                                 return(0);
 418                         isconvert = 1;
 419                         sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
 420                         sblock.fs_nrpos = 8;
 421                         sblock.fs_postbloff =
 422                             (char *)(&sblock.fs_opostbl[0][0]) -
 423                             (char *)(&sblock.fs_link);
 424                         sblock.fs_rotbloff = &sblock.fs_space[0] -
 425                             (u_char *)(&sblock.fs_link);
 426                         sblock.fs_cgsize =
 427                                 fragroundup(&sblock, CGSIZE(&sblock));
 428                         /*
 429                          * Planning now for future expansion.
 430                          */
 431 #                       if (BYTE_ORDER == BIG_ENDIAN)
 432                                 sblock.fs_qbmask.val[0] = 0;
 433                                 sblock.fs_qbmask.val[1] = ~sblock.fs_bmask;
 434                                 sblock.fs_qfmask.val[0] = 0;
 435                                 sblock.fs_qfmask.val[1] = ~sblock.fs_fmask;
 436 #                       endif /* BIG_ENDIAN */
 437 #                       if (BYTE_ORDER == LITTLE_ENDIAN)
 438                                 sblock.fs_qbmask.val[0] = ~sblock.fs_bmask;
 439                                 sblock.fs_qbmask.val[1] = 0;
 440                                 sblock.fs_qfmask.val[0] = ~sblock.fs_fmask;
 441                                 sblock.fs_qfmask.val[1] = 0;
 442 #                       endif /* LITTLE_ENDIAN */
 443 #if     defined(AFS_SUN_ENV) && !defined(AFS_SUN3_ENV)
 444 #ifdef  AFS_SUN5_ENV
 445                         sblock.fs_state = FSOKAY - sblock.fs_time; /* make mountable */
 446 #else
 447                         fs_set_state(&sblock, FSOKAY - sblock.fs_time);
 448 #endif
 449                         sblock.fs_clean = FSCLEAN;
 450 #endif
 451                         sbdirty();
 452                         dirty(&asblk);
 453                 } else if (sblock.fs_postblformat == FS_DYNAMICPOSTBLFMT) {
 454                         /*
 455                          * Requested to convert from new format to old format
 456                          */
 457                         if (sblock.fs_nrpos != 8 || sblock.fs_ipg > 2048 ||
 458                             sblock.fs_cpg > 32 || sblock.fs_cpc > 16) {
 459                                 msgprintf(
 460                                 "PARAMETERS OF CURRENT FILE SYSTEM DO NOT\n\t");
 461                                 msgprintf(
 462                                 "ALLOW CONVERSION TO OLD FILE SYSTEM FORMAT\n");                                errexit("");
 463
 464                         }
 465                         if (preen)
 466                                 pwarn("CONVERTING TO OLD FILE SYSTEM FORMAT\n");
 467                         else if (!reply("CONVERT TO OLD FILE SYSTEM FORMAT"))
 468                                 return(0);
 469                         isconvert = 1;
 470                         sblock.fs_postblformat = FS_42POSTBLFMT;
 471                         sblock.fs_cgsize = fragroundup(&sblock,
 472                             sizeof(struct ocg) + howmany(sblock.fs_fpg, NBBY));
 473 #if     defined(AFS_SUN_ENV) && !defined(AFS_SUN3_ENV)
 474 #ifdef  AFS_SUN5_ENV
 475                         sblock.fs_npsect = 0;
 476                         sblock.fs_interleave = 0;
 477                         sblock.fs_state = FSOKAY - sblock.fs_time; /* make mountable */
 478 #else
 479                         fs_set_state(&sblock, FSOKAY - sblock.fs_time);
 480 #endif
 481                         sblock.fs_clean = FSCLEAN;
 482 #endif
 483                         sbdirty();
 484                         dirty(&asblk);
 485                 } else {
 486                         errexit("UNKNOWN FILE SYSTEM FORMAT\n");
 487                 }
 488         }
 489 #endif /* AFS_NEWCG_ENV */
 490         if (asblk.b_dirty) {
 491                 memcpy((char *)&altsblock, (char *)&sblock, (int)sblock.fs_sbsize);
 492                 flush(fswritefd, &asblk);
 493         }
 494         /*
 495          * read in the summary info.
 496          */
 497         asked = 0;
 498 #if     defined(AFS_SUN56_ENV)
 499         {
 500             caddr_t sip;
 501             sip = calloc(1, sblock.fs_cssize);
 502             sblock.fs_u.fs_csp = (struct csum *)sip;
 503             for (i=0, j=0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
 504                 size = sblock.fs_cssize - i < sblock.fs_bsize ?
 505                     sblock.fs_cssize - i : sblock.fs_bsize;
 506                 if (bread(fsreadfd, sip,
 507                     fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
 508                     size) != 0 && !asked) {
 509                         pfatal("BAD SUMMARY INFORMATION");
 510                         if (reply("CONTINUE") == 0)
 511                                 errexit("");
 512                         return (0);
 513                 }
 514                 sip += size;
 515             }
 516         }
 517 #else   /* AFS_SUN56_ENV */
 518 #if     defined(AFS_HPUX110_ENV)
 519         size = fragroundup(&sblock, sblock.fs_cssize);
 520         sblock.fs_csp = (struct csum *)calloc(1, (unsigned)size);
 521         if ((bread(fsreadfd, (char *)sblock.fs_csp,
 522                    fsbtodb(&sblock, sblock.fs_csaddr), size) != 0) &&
 523             !asked) {
 524            pfatal("BAD SUMMARY INFORMATION");
 525            if (reply("CONTINUE") == 0)
 526              errexit("");
 527            asked++;
 528         }
 529 #else   /* AFS_HPUX110_ENV */
 530 #if     defined(AFS_HPUX101_ENV)
 531         {
 532                 j = 0;
 533                 size = fragroundup(&sblock, sblock.fs_cssize);
 534 #else
 535         for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
 536                 size = sblock.fs_cssize - i < sblock.fs_bsize ?
 537                     sblock.fs_cssize - i : sblock.fs_bsize;
 538 #endif /* AFS_HPUX101_ENV */
 539                 sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
 540                 if (bread(fsreadfd, (char *)sblock.fs_csp[j],
 541                     fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
 542                     size) != 0 && !asked) {
 543                         pfatal("BAD SUMMARY INFORMATION");
 544                         if (reply("CONTINUE") == 0)
 545                                 errexit("");
 546 #ifdef  AFS_SUN_ENV
 547                         return (0);
 548 #else
 549                         asked++;
 550 #endif
 551                 }
 552         }
 553 #endif /* else AFS_HPUX110_ENV */
 554 #endif /* else AFS_SUN56_ENV */
 555
 556 #if     defined(AFS_SUN_ENV) && !defined(AFS_SUN3_ENV)
 557         /*
 558          * if not forced, preening, not converting, and is clean; stop checking
 559          */
 560 #ifdef  AFS_SUN5_ENV
 561         if ((fflag == 0) && preen && (isconvert == 0) &&
 562             (FSOKAY == (sblock.fs_state + sblock.fs_time)) &&
 563 #else
 564         if (preen && (isconvert == 0) &&
 565             (FSOKAY == (fs_get_state(&sblock) + sblock.fs_time)) &&
 566 #endif
 567             ((sblock.fs_clean == FSCLEAN) ||
 568              (sblock.fs_clean == FSSTABLE)))
 569         {
 570                 iscorrupt = 0;
 571                 printclean();
 572                 return (0);
 573         }
 574 #endif
 575 #ifdef  AFS_OSF_ENV
 576         if (!fflag && !bflag && !nflag && !hotroot
 577             && sblock.fs_clean == FS_CLEAN && !sblk.b_dirty) {
 578             pwarn("Clean file system - skipping fsck\n");
 579             return(FS_CLEAN);
 580         }
 581 #endif  /* AFS_OSF_ENV */
 582
 583         /*
 584          * allocate and initialize the necessary maps
 585          */
 586         bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(short));
 587         blockmap = calloc((unsigned)bmapsize, sizeof (char));
 588         if (blockmap == NULL) {
 589                 msgprintf("cannot alloc %d bytes for blockmap\n", bmapsize);
 590                 goto badsb;
 591         }
 592         statemap = calloc((unsigned)(maxino + 1), sizeof(char));
 593         if (statemap == NULL) {
 594                 msgprintf("cannot alloc %d bytes for statemap\n", maxino + 1);
 595                 goto badsb;
 596         }
 597         lncntp = (short *)calloc((unsigned)(maxino + 1), sizeof(short));
 598         if (lncntp == NULL) {
 599                 msgprintf("cannot alloc %d bytes for lncntp\n",
 600                     (maxino + 1) * sizeof(short));
 601                 goto badsb;
 602         }
 603
 604         bufinit();
 605         return (1);
 606
 607 badsb:
 608         ckfini();
 609         return (0);
 610 }
 611
 612 /*
 613  * Read in the super block and its summary info.
 614  */
 615 readsb(listerr)
 616         int listerr;
 617 {
 618 #ifdef AFS_NEWCG_ENV
 619         daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
 620 #else /* AFS_NEWCG_ENV */
 621         daddr_t super = bflag ? bflag : SBLOCK;
 622
 623 #endif /* AFS_NEWCG_ENV */
 624         if (bread(fsreadfd, (char *)&sblock, super, (long)SBSIZE) != 0)
 625                 return (0);
 626         sblk.b_bno = super;
 627         sblk.b_size = SBSIZE;
 628         /*
 629          * run a few consistency checks of the super block
 630          */
 631 #ifdef  AFS_HPUX_ENV
 632 #if defined(FD_FSMAGIC)
 633         if ((sblock.fs_magic != FS_MAGIC) && (sblock.fs_magic != FS_MAGIC_LFN)
 634                 && (sblock.fs_magic != FD_FSMAGIC)
 635 #if     defined(AFS_HPUX101_ENV)
 636                 && ( sblock.fs_magic != FD_FSMAGIC_2)
 637 #endif
 638         )
 639 #else /* not new magic number */
 640         if ((sblock.fs_magic != FS_MAGIC) && (sblock.fs_magic != FS_MAGIC_LFN))
 641 #endif /* new magic number */
 642 #else
 643         if (sblock.fs_magic != FS_MAGIC)
 644 #endif
 645                 { badsb(listerr, "MAGIC NUMBER WRONG"); return (0); }
 646         if (sblock.fs_ncg < 1)
 647                 { badsb(listerr, "NCG OUT OF RANGE"); return (0); }
 648         if (sblock.fs_cpg < 1)
 649                 { printf("fs_cpg= %d\n", sblock.fs_cpg); badsb(listerr, "CPG OUT OF RANGE"); return (0); }
 650         if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
 651             (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
 652                 { badsb(listerr, "NCYL LESS THAN NCG*CPG"); return (0); }
 653         if (sblock.fs_sbsize > SBSIZE)
 654                 { badsb(listerr, "SIZE PREPOSTEROUSLY LARGE"); return (0); }
 655         /*
 656          * Compute block size that the filesystem is based on,
 657          * according to fsbtodb, and adjust superblock block number
 658          * so we can tell if this is an alternate later.
 659          */
 660         super *= dev_bsize;
 661         dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
 662         sblk.b_bno = super / dev_bsize;
 663         /*
 664          * Set all possible fields that could differ, then do check
 665          * of whole super block against an alternate super block.
 666          * When an alternate super-block is specified this check is skipped.
 667          */
 668         getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
 669         if (asblk.b_errs)
 670                 return (0);
 671         if (bflag) {
 672                 havesb = 1;
 673                 return (1);
 674         }
 675         altsblock.fs_link = sblock.fs_link;
 676 #ifdef STRUCT_FS_HAS_FS_ROLLED
 677         altsblock.fs_rolled = sblock.fs_rolled;
 678 #else
 679         altsblock.fs_rlink = sblock.fs_rlink;
 680 #endif
 681         altsblock.fs_time = sblock.fs_time;
 682         altsblock.fs_cstotal = sblock.fs_cstotal;
 683         altsblock.fs_cgrotor = sblock.fs_cgrotor;
 684         altsblock.fs_fmod = sblock.fs_fmod;
 685
 686         altsblock.fs_clean = sblock.fs_clean;
 687 #if     defined(AFS_SUN_ENV) && !defined(AFS_SUN3_ENV)
 688 #ifdef  AFS_SUN5_ENV
 689         altsblock.fs_state = sblock.fs_state;
 690 #else
 691         fs_set_state(&altsblock, fs_get_state(&sblock));
 692 #endif
 693 #endif
 694         altsblock.fs_ronly = sblock.fs_ronly;
 695         altsblock.fs_flags = sblock.fs_flags;
 696         altsblock.fs_maxcontig = sblock.fs_maxcontig;
 697         altsblock.fs_minfree = sblock.fs_minfree;
 698         altsblock.fs_optim = sblock.fs_optim;
 699         altsblock.fs_rotdelay = sblock.fs_rotdelay;
 700         altsblock.fs_maxbpg = sblock.fs_maxbpg;
 701 #if     !defined(__alpha) && !defined(AFS_SUN56_ENV)
 702 #if !defined(AFS_HPUX110_ENV)
 703         /* HPUX110 will use UpdateAlternateSuper() below */
 704         memcpy((char *)altsblock.fs_csp, (char *)sblock.fs_csp, sizeof sblock.fs_csp);
 705 #endif  /* ! AFS_HPUX110_ENV */
 706 #endif  /* ! __alpha */
 707 #if     defined(AFS_SUN56_ENV)
 708         memcpy((char *)altsblock.fs_u.fs_csp_pad, (char *)sblock.fs_u.fs_csp_pad, sizeof (sblock.fs_u.fs_csp_pad));
 709 #endif
 710         memcpy((char *)altsblock.fs_fsmnt, (char *)sblock.fs_fsmnt, sizeof sblock.fs_fsmnt);
 711 #ifndef AFS_HPUX_ENV
 712         memcpy((char *)altsblock.fs_sparecon, (char *)sblock.fs_sparecon, sizeof sblock.fs_sparecon);
 713 #endif
 714 #if defined(AFS_DEC_ENV)
 715         memcpy((char *)altsblock.fs_extra, (char *)sblock.fs_extra, sizeof sblock.fs_extra);
 716         altsblock.fs_deftimer = sblock.fs_deftimer;
 717         altsblock.fs_lastfsck = sblock.fs_lastfsck;
 718         altsblock.fs_gennum = sblock.fs_gennum;
 719 #endif
 720         /*
 721          * The following should not have to be copied.
 722          */
 723         altsblock.fs_fsbtodb = sblock.fs_fsbtodb;
 724 #ifdef AFS_NEWCG_ENV
 725         altsblock.fs_interleave = sblock.fs_interleave;
 726         altsblock.fs_npsect = sblock.fs_npsect;
 727         altsblock.fs_nrpos = sblock.fs_nrpos;
 728 #endif /* AFS_NEWCG_ENV */
 729 #if     defined(AFS_HPUX110_ENV)
 730         UpdateAlternateSuper(&sblock, &altsblock);
 731 #endif  /* AFS_HPUX110_ENV */
 732         if (memcmp((char *)&sblock, (char *)&altsblock, (int)sblock.fs_sbsize)) {
 733 #ifdef  __alpha
 734                 if (memcmp((char *)&sblock.fs_blank[0],
 735                          (char *)&altsblock.fs_blank[0],
 736                          MAXCSBUFS*sizeof(int))) {
 737                     memset((char *)sblock.fs_blank, 0, sizeof(sblock.fs_blank));
 738                 } else {
 739 #endif  /* __alpha */
 740                 badsb(listerr,
 741                 "VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
 742                 return (0);
 743 #ifdef  __alpha
 744             }
 745 #endif  /* __alpha */
 746         }
 747         havesb = 1;
 748         return (1);
 749 }
 750
 751 badsb(listerr, s)
 752         int listerr;
 753         char *s;
 754 {
 755
 756         if (!listerr)
 757                 return;
 758         if (preen)
 759                 msgprintf("%s: ", devname);
 760         pfatal("BAD SUPER BLOCK: %s\n", s);
 761 #ifdef  AFS_SUN5_ENV
 762         pwarn("USE AN ALTERNATE SUPER-BLOCK TO SUPPLY NEEDED INFORMATION;\n");
 763         pwarn("eg. fsck [-F ufs] -o b=# [special ...] \n");
 764         pfatal("where # is the alternate super block. SEE fsck_ufs(1M). \n");
 765 #endif
 766 }
 767
 768 /* dummy function that fails if ever called */
 769 calcsb(dev, devfd, fs)
 770         char *dev;
 771         int devfd;
 772         register struct fs *fs;
 773 {
 774     return 0;
 775 }
 776
 777 #ifdef  AFS_DEC_ENV
 778 clean_byte_valid(lastfsck)
 779     time_t lastfsck;
 780 {
 781     time_t now;
 782     int delta;
 783
 784     time(&now);
 785     if ((!sblock.fs_deftimer) || (!sblock.fs_lastfsck) || (lastfsck > now)) {
 786         sblock.fs_deftimer = 0;
 787         return(0);
 788     }
 789     if (!sblock.fs_cleantimer)
 790         return(0);
 791     delta = (now - lastfsck) / 86400;
 792     if (delta > 60)
 793         return(0);
 794     return(1);
 795 }
 796 #endif
 797
 798 #include <sys/ustat.h>
 799 #ifdef  AFS_HPUX_ENV
 800 #include <sys/pstat.h>
 801 #endif
 802 #include <sys/errno.h>
 803
 804 extern int errno;
 805
 806 is_mounted(device,dev_st)
 807     char *device;
 808     struct stat *dev_st;
 809 {
 810     char blockdev[BUFSIZ];
 811     struct ustat ust;
 812     char *dp;
 813
 814     strcpy(blockdev,device);
 815     if (stat(blockdev,dev_st)<0)
 816         return (0);
 817
 818     if (is_pre_init(dev_st->st_rdev))
 819         return (0);
 820
 821     if ((dev_st->st_mode & S_IFMT) == S_IFCHR) {
 822         dp = strrchr(blockdev, '/');
 823         if (strncmp(dp, "/r", 2) != 0)
 824             while (dp >= blockdev && *--dp != '/');
 825         if (*(dp+1) == 'r')
 826             (void)strcpy(dp+1, dp+2);
 827         if (stat(blockdev,dev_st)<0)
 828             return(0);
 829     }
 830     if (ustat(dev_st->st_rdev, &ust) >= 0) {
 831         /* make sure we are not in pre_init_rc. If we are 0 should be returned in here. */
 832         if ((is_root(dev_st->st_rdev)) && is_roroot()) return (0);
 833         return (1);
 834     }
 835     return (0);
 836 }
 837
 838 #ifdef  AFS_HPUX_ENV
 839
 840 #define PS_BURST 1
 841 #ifdef AFS_HPUX102_ENV
 842 #define PSTAT(P, N, I) pstat_getswap(P, sizeof(*P), (size_t)N, I)
 843 #else
 844 #define PSTAT(P, N, I) pstat(PSTAT_SWAPINFO, P, sizeof(*P), (size_t)N, I)
 845 #endif
 846 is_swap(devno)
 847     dev_t devno;
 848 {
 849     struct pst_swapinfo pst[PS_BURST];
 850     register struct pst_swapinfo *psp = &pst[0];
 851     int idx = 0, count, match=0;
 852
 853     while ((count = PSTAT(psp, PS_BURST, idx) != 0)) {
 854         idx = pst[count - 1].pss_idx + 1;
 855         if ((psp->pss_flags & SW_BLOCK) && (psp->pss_major == major(devno)) && (psp->pss_minor == minor(devno))) {
 856             match = 1;
 857             break;
 858         }
 859     }
 860     return (match);
 861 }
 862
 863 #endif AFS_HPUX_ENV
 864
 865
 866 is_pre_init(rdevnum)
 867     dev_t rdevnum;
 868 {
 869     if (rdevnum == -1)
 870         return (1);
 871     return (0);
 872 }
 873
 874 is_roroot()
 875 {
 876 #ifndef UID_NO_CHANGE
 877     struct stat stslash;
 878
 879     if (stat("/",&stslash) < 0)
 880         return (0);
 881     if ( chown("/", stslash.st_uid, stslash.st_gid) == 0 )
 882         return(0);
 883 #else
 884     if ( chown("/",UID_NO_CHANGE,GID_NO_CHANGE) == 0 )
 885         return(0);
 886 #endif
 887     else if (errno != EROFS ) {
 888         printf ("fsck: chown failed: %d\n",errno);
 889         return (0);
 890     }
 891     return(1);
 892 }
 893
 894 is_hotroot(fs_device)
 895     char *fs_device;
 896 {
 897     struct stat stslash, stblock, stchar;
 898     char blockdev[BUFSIZ];
 899
 900     strcpy(blockdev,fs_device);
 901     if (stat("/", &stslash) < 0) {
 902         pfatal("Can't stat root\n");
 903         return (0);
 904     }
 905
 906     if (stat(blockdev, &stblock) < 0) {
 907         pfatal("Can't stat %s\n", blockdev);
 908         return (0);
 909     }
 910
 911     if (is_pre_init(stblock.st_rdev))
 912         return(0);
 913
 914     /* convert the device name to be block device name */
 915     if ((stblock.st_mode & S_IFMT) == S_IFCHR) {
 916         unrawname(blockdev);
 917         if (stat(blockdev, &stblock) < 0)
 918             return (0);
 919     }
 920     if ((stblock.st_mode & S_IFMT) != S_IFBLK)
 921         return(0);
 922     if (stslash.st_dev != stblock.st_rdev)
 923         return(0);
 924     /* is root file system mounted read only? */
 925     if (is_roroot())
 926         return(0);
 927     return(1);
 928 }
 929
 930 is_root (rdev_num)
 931     dev_t rdev_num;
 932 {
 933     struct stat stslash;
 934
 935     if (stat("/",&stslash) < 0)
 936         return (0);
 937     if (stslash.st_dev != rdev_num)
 938         return (0);
 939     return (1);
 940 }
 941
 942 getline(fp, loc, maxlen)
 943     FILE *fp;
 944     char *loc;
 945 {
 946     register n;
 947     register char *p, *lastloc;
 948
 949     p = loc;
 950     lastloc = &p[maxlen-1];
 951     while ((n = getc(fp)) != '\n') {
 952         if (n == EOF)
 953             return (EOF);
 954         if (!isspace(n) && p < lastloc)
 955             *p++ = n;
 956     }
 957     *p = 0;
 958     return (p - loc);
 959 }
 960
 961 /*
 962  * freply - prints the string, s, gets a reply fromterminal and returns
 963  * 0 - no (don't continue), and 1 - yes (continue)
 964  */
 965 freply(s)
 966     char *s;
 967 {
 968     char line[80];
 969
 970     if (!isatty(0))
 971         errexit("exiting\n");
 972     printf("\n%s? ", s);
 973     if (getline(stdin, line, sizeof(line)) == EOF)
 974         errexit("\n");
 975     if (line[0] == 'y' || line[0] == 'Y')
 976         return (1);
 977     return (0);
 978 }
 979
 980
 981 #if   defined(AFS_HPUX110_ENV)
 982 /*
 983  *  Refer to function compare_sblocks() in HP's fsck.c
 984  *
 985  *  DESCRIPTION:
 986  *     This routine will compare the primary superblock (PRIM_SBLOCK) to the
 987  *     alternate superblock (ALT_SBLOCK).  This routine will take into account
 988  *     that certain fields in the alternate superblock could be different than
 989  *     in the primary superblock.  This routine checks the "static" fields
 990  *     and ignores the "dynamic" fields.  Superblocks with the same "static"
 991  *     fields are considered equivalent.
 992  *
 993  */
 994 UpdateAlternateSuper(prim_sblock, alt_sblock)
 995   struct  fs *prim_sblock;
 996   struct  fs *alt_sblock;  /* will be modified */
 997 {
 998      /*
 999       * Set all possible fields that could differ, then do check
1000       * of whole super block against an alternate super block.
1001       *
1002       * Copy dynamic fields of prim_sblock into alt_sblock
1003       */
1004      alt_sblock->fs_time      = prim_sblock->fs_time;
1005      alt_sblock->fs_minfree   = prim_sblock->fs_minfree;
1006      alt_sblock->fs_rotdelay  = prim_sblock->fs_rotdelay;
1007      alt_sblock->fs_maxcontig = prim_sblock->fs_maxcontig;
1008      alt_sblock->fs_maxbpg    = prim_sblock->fs_maxbpg;
1009      alt_sblock->fs_mirror    = prim_sblock->fs_mirror;
1010      alt_sblock->fs_cstotal   = prim_sblock->fs_cstotal;
1011      alt_sblock->fs_fmod      = prim_sblock->fs_fmod;
1012      alt_sblock->fs_clean     = prim_sblock->fs_clean;
1013      alt_sblock->fs_ronly     = prim_sblock->fs_ronly;
1014      alt_sblock->fs_flags     = prim_sblock->fs_flags;
1015      alt_sblock->fs_cgrotor   = prim_sblock->fs_cgrotor;
1016 #ifdef __LP64__
1017      alt_sblock->fs_csp       = prim_sblock->fs_csp;
1018 #else  /* not __LP64__ */
1019      alt_sblock->fs_csp       = prim_sblock->fs_csp;
1020      alt_sblock->fs_csp_pad   = prim_sblock->fs_csp_pad;
1021 #endif /* not __LP64__ */
1022      memcpy((char *)alt_sblock->fs_fsmnt, (char *)prim_sblock->fs_fsmnt,
1023              sizeof prim_sblock->fs_fsmnt);
1024      memcpy((char *)alt_sblock->fs_fname, (char *)prim_sblock->fs_fname,
1025              sizeof prim_sblock->fs_fname);
1026      memcpy((char *)alt_sblock->fs_fpack, (char *)prim_sblock->fs_fpack,
1027              sizeof prim_sblock->fs_fpack);
1028      if (prim_sblock->fs_featurebits & FSF_LARGEUIDS)
1029        alt_sblock->fs_featurebits |= FSF_LARGEUIDS;
1030      else
1031        alt_sblock->fs_featurebits &= ~FSF_LARGEUIDS;
1032 }
1033 #endif  /* AFS_HPUX110_ENV */