src/vfsck/utilities.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
  22     ("$Header$");
  23
  24 #include <sys/param.h>
  25 #define VICE                    /* allow us to put our changes in at will */
  26 #include <sys/time.h>
  27 #ifdef  AFS_OSF_ENV
  28 #include <sys/vnode.h>
  29 #include <sys/mount.h>
  30 #include <ufs/inode.h>
  31 #include <ufs/fs.h>
  32 #define _BSD
  33 #define _KERNEL
  34 #include <ufs/dir.h>
  35 #undef  _KERNEL
  36 #undef  _BSD
  37 #define AFS_NEWCG_ENV
  38 #else /* AFS_OSF_ENV */
  39 #ifdef AFS_VFSINCL_ENV
  40 #include <sys/vnode.h>
  41 #ifdef    AFS_SUN5_ENV
  42 #include <stdio.h>
  43 #include <unistd.h>
  44 #include <signal.h>
  45 #include <sys/fs/ufs_inode.h>
  46 #include <sys/fs/ufs_fs.h>
  47 #define _KERNEL
  48 #include <sys/fs/ufs_fsdir.h>
  49 #undef _KERNEL
  50 #include <sys/fs/ufs_mount.h>
  51 #else
  52 #include <ufs/inode.h>
  53 #include <ufs/fs.h>
  54 #include <ufs/fsdir.h>
  55 #endif
  56 #else /* AFS_VFSINCL_ENV */
  57 #include <sys/inode.h>
  58 #ifdef  AFS_HPUX_ENV
  59 #include <ctype.h>
  60 #define LONGFILENAMES   1
  61 #include <sys/sysmacros.h>
  62 #include <sys/ino.h>
  63 #include <sys/signal.h>
  64 #define DIRSIZ_MACRO
  65 #include <ndir.h>
  66 #else
  67 #include <sys/dir.h>
  68 #endif
  69 #include <sys/fs.h>
  70 #endif /* AFS_VFSINCL_ENV */
  71 #endif /* AFS_OSF_ENV */
  72
  73 #include <stdio.h>
  74 #include <ctype.h>
  75 #include "fsck.h"
  76
  77 #if     defined(AFS_HPUX101_ENV)
  78 #include <unistd.h>
  79 #endif
  80
  81 #if     defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV)
  82 #define AFS_NEWCG_ENV
  83 #else
  84 #undef AFS_NEWCG_ENV
  85 #endif
  86
  87 long diskreads, totalreads;     /* Disk cache statistics */
  88 #if     !defined(AFS_HPUX101_ENV)
  89 long lseek();
  90 #endif
  91 char *malloc();
  92 #if     defined(AFS_SUN_ENV) || defined(AFS_DEC_ENV)
  93 extern int iscorrupt;
  94 #endif
  95 #ifdef  AFS_SUN_ENV
  96 extern int isdirty;
  97 #endif
  98 #ifdef  AFS_SUN5_ENV
  99 #include <sys/mntent.h>
 100 #include <sys/mnttab.h>
 101 #include <sys/stat.h>
 102 #include <sys/vfstab.h>
 103
 104 offset_t llseek();
 105 #endif
 106
 107 ftypeok(dp)
 108      struct dinode *dp;
 109 {
 110     switch (dp->di_mode & IFMT) {
 111
 112     case IFDIR:
 113     case IFREG:
 114     case IFBLK:
 115     case IFCHR:
 116     case IFLNK:
 117     case IFSOCK:
 118 #ifdef  AFS_HPUX_ENV
 119     case IFNWK:
 120 #endif
 121 #ifdef IFIFO
 122     case IFIFO:
 123 #else
 124 #ifdef  IFPORT
 125     case IFPORT:
 126 #endif
 127 #endif /* IFIFO */
 128         return (1);
 129
 130     default:
 131         if (debug)
 132             printf("bad file type 0%o\n", dp->di_mode);
 133         return (0);
 134     }
 135 }
 136
 137 #ifdef  AFS_HPUX_ENV
 138 extern int fixed;
 139 #endif
 140 reply(question)
 141      char *question;
 142 {
 143     int persevere;
 144     char c;
 145
 146     if (preen)
 147         pfatal("INTERNAL ERROR: GOT TO reply()");
 148     persevere = !strcmp(question, "CONTINUE");
 149     printf("\n");
 150     if (!persevere && (nflag || fswritefd < 0)) {
 151         printf("%s? no\n\n", question);
 152 #if     defined(AFS_SUN_ENV) || defined(AFS_DEC_ENV)
 153         iscorrupt = 1;          /* known to be corrupt */
 154 #endif
 155         return (0);
 156     }
 157     if (yflag || (persevere && nflag)) {
 158         printf("%s? yes\n\n", question);
 159         return (1);
 160     }
 161     do {
 162         printf("%s? [yn] ", question);
 163         (void)fflush(stdout);
 164         c = getc(stdin);
 165         while (c != '\n' && getc(stdin) != '\n')
 166             if (feof(stdin))
 167                 return (0);
 168     } while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
 169     printf("\n");
 170     if (c == 'y' || c == 'Y')
 171         return (1);
 172 #ifdef  AFS_HPUX_ENV
 173     fixed = 0;
 174 #endif
 175 #if     defined(AFS_SUN_ENV) || defined(AFS_DEC_ENV)
 176     iscorrupt = 1;              /* known to be corrupt */
 177 #endif
 178     return (0);
 179 }
 180
 181 /*
 182  * Malloc buffers and set up cache.
 183  */
 184 bufinit()
 185 {
 186     register struct bufarea *bp;
 187     long bufcnt, i;
 188     char *bufp;
 189
 190     bufp = malloc((unsigned int)sblock.fs_bsize);
 191     if (bufp == 0)
 192         errexit("cannot allocate buffer pool\n");
 193     cgblk.b_un.b_buf = bufp;
 194     initbarea(&cgblk);
 195     bufhead.b_next = bufhead.b_prev = &bufhead;
 196     bufcnt = MAXBUFSPACE / sblock.fs_bsize;
 197     if (bufcnt < MINBUFS)
 198         bufcnt = MINBUFS;
 199     for (i = 0; i < bufcnt; i++) {
 200         bp = (struct bufarea *)malloc(sizeof(struct bufarea));
 201         bufp = malloc((unsigned int)sblock.fs_bsize);
 202         if (bp == NULL || bufp == NULL) {
 203             if (i >= MINBUFS)
 204                 break;
 205             errexit("cannot allocate buffer pool\n");
 206         }
 207         bp->b_un.b_buf = bufp;
 208         bp->b_prev = &bufhead;
 209         bp->b_next = bufhead.b_next;
 210         bufhead.b_next->b_prev = bp;
 211         bufhead.b_next = bp;
 212         initbarea(bp);
 213     }
 214     bufhead.b_size = i;         /* save number of buffers */
 215 #ifdef  AFS_SUN5_ENVX
 216     pbp = pdirbp = NULL;
 217 #endif
 218 }
 219
 220 /*
 221  * Manage a cache of directory blocks.
 222  */
 223 struct bufarea *
 224 getdatablk(blkno, size)
 225      daddr_t blkno;
 226      long size;
 227 {
 228     register struct bufarea *bp;
 229
 230     for (bp = bufhead.b_next; bp != &bufhead; bp = bp->b_next)
 231         if (bp->b_bno == fsbtodb(&sblock, blkno))
 232             goto foundit;
 233     for (bp = bufhead.b_prev; bp != &bufhead; bp = bp->b_prev)
 234         if ((bp->b_flags & B_INUSE) == 0)
 235             break;
 236     if (bp == &bufhead)
 237         errexit("deadlocked buffer pool\n");
 238     getblk(bp, blkno, size);
 239     /* fall through */
 240   foundit:
 241     totalreads++;
 242     bp->b_prev->b_next = bp->b_next;
 243     bp->b_next->b_prev = bp->b_prev;
 244     bp->b_prev = &bufhead;
 245     bp->b_next = bufhead.b_next;
 246     bufhead.b_next->b_prev = bp;
 247     bufhead.b_next = bp;
 248     bp->b_flags |= B_INUSE;
 249     return (bp);
 250 }
 251
 252 struct bufarea *
 253 getblk(bp, blk, size)
 254      register struct bufarea *bp;
 255      daddr_t blk;
 256      long size;
 257 {
 258     daddr_t dblk;
 259
 260     dblk = fsbtodb(&sblock, blk);
 261     if (bp->b_bno == dblk)
 262         return (bp);
 263     flush(fswritefd, bp);
 264     diskreads++;
 265     bp->b_errs = bread(fsreadfd, bp->b_un.b_buf, dblk, size);
 266     bp->b_bno = dblk;
 267     bp->b_size = size;
 268     return (bp);
 269 }
 270
 271 flush(fd, bp)
 272      int fd;
 273      register struct bufarea *bp;
 274 {
 275     register int i, j;
 276     caddr_t sip;
 277     long size;
 278
 279     if (!bp->b_dirty)
 280         return;
 281     if (bp->b_errs != 0) {
 282         pfatal("WRITING %sZERO'ED BLOCK %d TO DISK\n",
 283                (bp->b_errs == bp->b_size / dev_bsize) ? "" : "PARTIALLY ",
 284                bp->b_bno);
 285 #ifdef  AFS_DEC_ENV
 286         iscorrupt = 1;
 287 #endif
 288     }
 289     bp->b_dirty = 0;
 290     bp->b_errs = 0;
 291     bwrite(fd, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
 292     if (bp != &sblk)
 293         return;
 294 #if     defined(AFS_HPUX101_ENV)
 295 #if     defined(AFS_HPUX110_ENV)
 296     /* jpm: Need a fix here */
 297     if (0)
 298 #else /* AFS_HPUX110_ENV */
 299     if (bwrite
 300         (fswritefd, (char *)sblock.fs_csp[0],
 301          fsbtodb(&sblock, sblock.fs_csaddr), fragroundup(&sblock,
 302                                                          sblock.fs_cssize)) ==
 303         1)
 304 #endif /* else AFS_HPUX110_ENV */
 305     {
 306         printf
 307             ("\nUnable to write to cylinder group summary area (fs_csaddr)\n");
 308         printf("\tDisk write error at block %u\n",
 309                fsbtodb(&sblock, sblock.fs_csaddr));
 310     }
 311 #else
 312 #if     defined(AFS_SUN56_ENV)
 313     sip = (caddr_t) sblock.fs_u.fs_csp;
 314     for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
 315         size =
 316             sblock.fs_cssize - i <
 317             sblock.fs_bsize ? sblock.fs_cssize - i : sblock.fs_bsize;
 318         bwrite(fswritefd, sip,
 319                fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag), size);
 320         sip += size;
 321     }
 322 #else
 323     for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
 324         bwrite(fswritefd, (char *)sblock.fs_csp[j],
 325                fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
 326                sblock.fs_cssize - i <
 327                sblock.fs_bsize ? sblock.fs_cssize - i : sblock.fs_bsize);
 328     }
 329 #endif /* AFS_SUN56_ENV */
 330 #endif /* AFS_HPUX101_ENV */
 331 }
 332
 333 rwerror(mesg, blk)
 334      char *mesg;
 335      daddr_t blk;
 336 {
 337
 338     if (preen == 0)
 339         printf("\n");
 340     pfatal("CANNOT %s: BLK %ld", mesg, blk);
 341     if (reply("CONTINUE") == 0)
 342         errexit("Program terminated\n");
 343 }
 344
 345 ckfini()
 346 {
 347     register struct bufarea *bp, *nbp;
 348     int cnt = 0;
 349
 350     flush(fswritefd, &sblk);
 351 #ifdef AFS_NEWCG_ENV
 352     if (havesb && sblk.b_bno != SBOFF / dev_bsize && !preen
 353         && reply("UPDATE STANDARD SUPERBLOCK")) {
 354         sblk.b_bno = SBOFF / dev_bsize;
 355 #else /* AFS_NEWCG_ENV */
 356     if (havesb && sblk.b_bno != SBLOCK && !preen
 357         && reply("UPDATE STANDARD SUPERBLOCK")) {
 358         sblk.b_bno = SBLOCK;
 359 #endif /* AFS_NEWCG_ENV */
 360         sbdirty();
 361         flush(fswritefd, &sblk);
 362     }
 363     flush(fswritefd, &cgblk);
 364     if (cgblk.b_un.b_buf) {
 365         free(cgblk.b_un.b_buf);
 366         cgblk.b_un.b_buf = NULL;
 367     }
 368     for (bp = bufhead.b_prev; bp != &bufhead; bp = nbp) {
 369         cnt++;
 370         flush(fswritefd, bp);
 371         nbp = bp->b_prev;
 372         free(bp->b_un.b_buf);
 373         free((char *)bp);
 374     }
 375 #ifdef  AFS_SUN5_ENVX
 376     pbp = pdirbp = NULL;
 377 #endif
 378     if (bufhead.b_size != cnt)
 379         errexit("Panic: lost %d buffers\n", bufhead.b_size - cnt);
 380     if (debug)
 381         printf("cache missed %d of %d (%d%%)\n", diskreads, totalreads,
 382                diskreads * 100 / totalreads);
 383     (void)close(fsreadfd);
 384     (void)close(fswritefd);
 385 }
 386
 387 #if     !defined(AFS_HPUX101_ENV)
 388 bread(fd, buf, blk, size)
 389      int fd;
 390      char *buf;
 391      daddr_t blk;
 392      long size;
 393 {
 394     char *cp;
 395     int i, errs;
 396 #ifdef  AFS_SUN5_ENV
 397     offset_t offset = (offset_t) blk << DEV_BSHIFT;
 398     offset_t addr;
 399 #endif
 400
 401 #ifdef  AFS_HPUX_ENV
 402     /* To fix a stripping related bug?? */
 403     if (lseek(fd, blk * dev_bsize, 0) == -1)
 404 #else
 405 #ifdef  AFS_SUN5_ENV
 406     if (llseek(fd, offset, 0) < 0)
 407 #else
 408     if (lseek(fd, blk * dev_bsize, 0) < 0)
 409 #endif
 410 #endif
 411         rwerror("SEEK", blk);
 412     else if (read(fd, buf, (int)size) == size)
 413         return (0);
 414     rwerror("READ", blk);
 415 #ifdef  AFS_HPUX_ENV
 416     /* To fix a stripping related bug?? */
 417     if (lseek(fd, blk * dev_bsize, 0) == -1)
 418 #else
 419 #ifdef  AFS_SUN5_ENV
 420     if (llseek(fd, offset, 0) < 0)
 421 #else
 422     if (lseek(fd, blk * dev_bsize, 0) < 0)
 423 #endif
 424 #endif
 425         rwerror("SEEK", blk);
 426     errs = 0;
 427     memset(buf, 0, (int)size);
 428     printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
 429 #ifdef  AFS_SUN5_ENV
 430     for (cp = buf, i = 0; i < btodb(size); i++, cp += DEV_BSIZE) {
 431         addr = (offset_t) (blk + i) << DEV_BSHIFT;
 432         if (llseek(fd, addr, SEEK_CUR) < 0 || read(fd, cp, (int)secsize) < 0) {
 433             printf(" %d", blk + i);
 434 #else
 435     for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
 436         if (read(fd, cp, (int)secsize) < 0) {
 437             lseek(fd, blk * dev_bsize + i + secsize, 0);
 438             if (secsize != dev_bsize && dev_bsize != 1)
 439                 printf(" %d (%d),", (blk * dev_bsize + i) / secsize,
 440                        blk + i / dev_bsize);
 441             else
 442                 printf(" %d,", blk + i / dev_bsize);
 443 #endif
 444             errs++;
 445         }
 446     }
 447     printf("\n");
 448     return (errs);
 449 }
 450
 451 bwrite(fd, buf, blk, size)
 452      int fd;
 453      char *buf;
 454      daddr_t blk;
 455      long size;
 456 {
 457     int i, n;
 458     char *cp;
 459 #ifdef  AFS_SUN5_ENV
 460     offset_t offset = (offset_t) blk << DEV_BSHIFT;
 461     offset_t addr;
 462
 463     if (blk < SBLOCK) {
 464         char msg[256];
 465         sprintf(msg, "WARNING: Attempt to write illegal blkno %d on %s\n",
 466                 blk, devname);
 467         if (debug)
 468             printf(msg);
 469         return;
 470     }
 471 #endif
 472
 473     if (fd < 0)
 474         return;
 475 #ifdef  AFS_HPUX_ENV
 476     /* To fix a stripping related bug?? */
 477     if (lseek(fd, blk * dev_bsize, 0) == -1)
 478 #else
 479 #ifdef  AFS_SUN5_ENV
 480     if (llseek(fd, offset, 0) < 0)
 481 #else
 482     if (lseek(fd, blk * dev_bsize, 0) < 0)
 483 #endif
 484 #endif
 485         rwerror("SEEK", blk);
 486     else if (write(fd, buf, (int)size) == size) {
 487         fsmodified = 1;
 488         return;
 489     }
 490     rwerror("WRITE", blk);
 491 #ifdef  AFS_HPUX_ENV
 492     /* To fix a stripping related bug?? */
 493     if (lseek(fd, blk * dev_bsize, 0) == -1)
 494 #else
 495 #ifdef  AFS_SUN5_ENV
 496     if (llseek(fd, offset, 0) < 0)
 497 #else
 498     if (lseek(fd, blk * dev_bsize, 0) < 0)
 499 #endif
 500 #endif
 501         rwerror("SEEK", blk);
 502     printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
 503 #ifdef  AFS_SUN5_ENV
 504     for (cp = buf, i = 0; i < btodb(size); i++, cp += DEV_BSIZE) {
 505         n = 0;
 506         addr = (offset_t) (blk + i) << DEV_BSHIFT;
 507         if (llseek(fd, addr, SEEK_CUR) < 0
 508             || (n = write(fd, cp, DEV_BSIZE)) < 0) {
 509             printf(" %d", blk + i);
 510         } else if (n > 0) {
 511             fsmodified = 1;
 512         }
 513
 514     }
 515 #else
 516     for (cp = buf, i = 0; i < size; i += dev_bsize, cp += dev_bsize)
 517         if (write(fd, cp, (int)dev_bsize) < 0) {
 518             lseek(fd, blk * dev_bsize + i + dev_bsize, 0);
 519             printf(" %d,", blk + i / dev_bsize);
 520         }
 521 #endif
 522     printf("\n");
 523     return;
 524 }
 525 #endif /* AFS_HPUX101_ENV */
 526 /*
 527  * allocate a data block with the specified number of fragments
 528  */
 529 allocblk(frags)
 530      long frags;
 531 {
 532     register int i, j, k;
 533
 534     if (frags <= 0 || frags > sblock.fs_frag)
 535         return (0);
 536     for (i = 0; i < maxfsblock - sblock.fs_frag; i += sblock.fs_frag) {
 537         for (j = 0; j <= sblock.fs_frag - frags; j++) {
 538             if (testbmap(i + j))
 539                 continue;
 540             for (k = 1; k < frags; k++)
 541                 if (testbmap(i + j + k))
 542                     break;
 543             if (k < frags) {
 544                 j += k;
 545                 continue;
 546             }
 547             for (k = 0; k < frags; k++)
 548                 setbmap(i + j + k);
 549             n_blks += frags;
 550             return (i + j);
 551         }
 552     }
 553     return (0);
 554 }
 555
 556 /*
 557  * Free a previously allocated block
 558  */
 559 freeblk(blkno, frags)
 560      daddr_t blkno;
 561      long frags;
 562 {
 563     struct inodesc idesc;
 564
 565     idesc.id_blkno = blkno;
 566     idesc.id_numfrags = frags;
 567     pass4check(&idesc);
 568 }
 569
 570 /*
 571  * Find a pathname
 572  */
 573 getpathname(namebuf, curdir, ino)
 574      char *namebuf;
 575      ino_t curdir, ino;
 576 {
 577     int len;
 578     register char *cp;
 579     struct inodesc idesc;
 580     extern int findname();
 581
 582     if (statemap[ino] != DSTATE && statemap[ino] != DFOUND) {
 583         strcpy(namebuf, "?");
 584         return;
 585     }
 586     memset((char *)&idesc, 0, sizeof(struct inodesc));
 587     idesc.id_type = DATA;
 588     cp = &namebuf[BUFSIZ - 1];
 589     *cp = '\0';
 590     if (curdir != ino) {
 591         idesc.id_parent = curdir;
 592         goto namelookup;
 593     }
 594     while (ino != ROOTINO) {
 595         idesc.id_number = ino;
 596         idesc.id_func = findino;
 597         idesc.id_name = "..";
 598 #ifdef  AFS_SUN5_ENV
 599         idesc.id_fix = NOFIX;
 600 #endif
 601         if ((ckinode(ginode(ino), &idesc) & FOUND) == 0)
 602             break;
 603       namelookup:
 604         idesc.id_number = idesc.id_parent;
 605         idesc.id_parent = ino;
 606         idesc.id_func = findname;
 607         idesc.id_name = namebuf;
 608 #ifdef  AFS_SUN5_ENV
 609         idesc.id_fix = NOFIX;
 610 #endif
 611         if ((ckinode(ginode(idesc.id_number), &idesc) & FOUND) == 0)
 612             break;
 613         len = strlen(namebuf);
 614         cp -= len;
 615         if (cp < &namebuf[MAXNAMLEN])
 616             break;
 617         memcpy(cp, namebuf, len);
 618         *--cp = '/';
 619         ino = idesc.id_number;
 620     }
 621     if (ino != ROOTINO) {
 622         strcpy(namebuf, "?");
 623         return;
 624     }
 625     memcpy(namebuf, cp, &namebuf[BUFSIZ] - cp);
 626 }
 627
 628 void
 629 catch()
 630 {
 631     ckfini();
 632 #ifdef  AFS_SUN5_ENV
 633     exit(37);
 634 #else
 635     exit(12);
 636 #endif
 637 }
 638
 639 /*
 640  * When preening, allow a single quit to signal
 641  * a special exit after filesystem checks complete
 642  * so that reboot sequence may be interrupted.
 643  */
 644 void
 645 catchquit()
 646 {
 647     extern returntosingle;
 648
 649     printf("returning to single-user after filesystem check\n");
 650     returntosingle = 1;
 651     (void)signal(SIGQUIT, SIG_DFL);
 652 }
 653
 654 /*
 655  * Ignore a single quit signal; wait and flush just in case.
 656  * Used by child processes in preen.
 657  */
 658 void
 659 voidquit()
 660 {
 661
 662     sleep(1);
 663     (void)signal(SIGQUIT, SIG_IGN);
 664     (void)signal(SIGQUIT, SIG_DFL);
 665 }
 666
 667 /*
 668  * determine whether an inode should be fixed.
 669  */
 670 dofix(idesc, msg)
 671      register struct inodesc *idesc;
 672      char *msg;
 673 {
 674
 675     switch (idesc->id_fix) {
 676
 677     case DONTKNOW:
 678         if (idesc->id_type == DATA)
 679             direrror(idesc->id_number, msg);
 680         else
 681             pwarn(msg);
 682         if (preen) {
 683             printf(" (SALVAGED)\n");
 684             idesc->id_fix = FIX;
 685             return (ALTERED);
 686         }
 687         if (reply("SALVAGE") == 0) {
 688             idesc->id_fix = NOFIX;
 689             return (0);
 690         }
 691         idesc->id_fix = FIX;
 692         return (ALTERED);
 693
 694     case FIX:
 695         return (ALTERED);
 696
 697     case NOFIX:
 698         return (0);
 699
 700     default:
 701         errexit("UNKNOWN INODESC FIX MODE %d\n", idesc->id_fix);
 702     }
 703     /* NOTREACHED */
 704 }
 705
 706 /* VARARGS1 */
 707 errexit(s1, s2, s3, s4)
 708      char *s1;
 709      long s2, s3, s4;
 710 {
 711     printf(s1, s2, s3, s4);
 712 #ifdef  AFS_SUN5_ENV
 713     exit(39);
 714 #else
 715     exit(8);
 716 #endif
 717 }
 718
 719 /*
 720  * An unexpected inconsistency occured.
 721  * Die if preening, otherwise just print message and continue.
 722  */
 723 /* VARARGS1 */
 724 pfatal(s, a1, a2, a3)
 725      char *s;
 726      long a1, a2, a3;
 727 {
 728     if (preen) {
 729         printf("%s: ", devname);
 730         printf(s, a1, a2, a3);
 731         printf("\n");
 732         printf("%s: UNEXPECTED INCONSISTENCY; RUN fsck MANUALLY.\n", devname);
 733 #ifdef  AFS_SUN5_ENV
 734         exit(36);
 735 #else
 736         exit(8);
 737 #endif
 738     }
 739     printf(s, a1, a2, a3);
 740 }
 741
 742 /*
 743  * Pwarn just prints a message when not preening,
 744  * or a warning (preceded by filename) when preening.
 745  */
 746 /* VARARGS1 */
 747 pwarn(s, a1, a2, a3, a4, a5, a6)
 748      char *s;
 749      long a1, a2, a3, a4, a5, a6;
 750 {
 751     if (preen)
 752         printf("%s: ", devname);
 753     printf(s, a1, a2, a3, a4, a5, a6);
 754 }
 755
 756 /*
 757  * Pwarn just prints a message when not preening,
 758  * or a warning (preceded by filename) when preening.
 759  */
 760 /* VARARGS1 */
 761 pinfo(s, a1, a2, a3, a4, a5, a6)
 762      char *s;
 763      long a1, a2, a3, a4, a5, a6;
 764 {
 765     if (preen)
 766         printf("%s: ", devname);
 767     printf(s, a1, a2, a3, a4, a5, a6);
 768 }
 769
 770 #ifndef lint
 771 /*
 772  * Stub for routines from kernel.
 773  */
 774 panic(s)
 775      char *s;
 776 {
 777
 778     pfatal("INTERNAL INCONSISTENCY:");
 779     errexit(s);
 780 }
 781 #endif
 782
 783 #if     defined(AFS_SUN_ENV) && !defined(AFS_SUN3_ENV)
 784 debugclean()
 785 {
 786     char s[256];
 787
 788     if (debug == 0)
 789         return;
 790     if ((iscorrupt == 0) && (isdirty == 0))
 791         return;
 792     if ((sblock.fs_clean != FSSTABLE) && (sblock.fs_clean != FSCLEAN))
 793         return;
 794 #ifdef  AFS_SUN5_ENV
 795     if (FSOKAY != (sblock.fs_state + sblock.fs_time))
 796 #else
 797     if (FSOKAY != (fs_get_state(&sblock) + sblock.fs_time))
 798 #endif
 799         return;
 800
 801     sprintf(s, "WARNING: inconsistencies detected on `%s' filesystem %s",
 802             sblock.fs_clean == FSSTABLE ? "stable" : "clean", devname);
 803     printf("%s\n", s);
 804 }
 805
 806 updateclean()
 807 {
 808     struct bufarea cleanbuf;
 809     unsigned int size;
 810     unsigned int bno;
 811     unsigned int fsclean;
 812 #if     defined(AFS_SUN56_ENV)
 813     offset_t sblkoff;
 814 #endif
 815
 816     debugclean();
 817     /* set fsclean to its appropriate value */
 818     fsclean = sblock.fs_clean;
 819 #ifdef  AFS_SUN5_ENV
 820     if (FSOKAY != (sblock.fs_state + sblock.fs_time))
 821 #else
 822     if (FSOKAY != (fs_get_state(&sblock) + sblock.fs_time))
 823 #endif
 824         fsclean = FSACTIVE;
 825
 826     /* if necessary, update fs_clean and fs_state */
 827     switch (fsclean) {
 828     case FSACTIVE:
 829         if (iscorrupt == 0)
 830             fsclean = FSSTABLE;
 831         break;
 832     case FSCLEAN:
 833     case FSSTABLE:
 834         if (iscorrupt)
 835             fsclean = FSACTIVE;
 836         break;
 837     default:
 838         if (iscorrupt)
 839             fsclean = FSACTIVE;
 840         else
 841             fsclean = FSSTABLE;
 842     }
 843     /* if fs_clean and fs_state are ok, do nothing */
 844     if ((sblock.fs_clean == fsclean) &&
 845 #ifdef  AFS_SUN5_ENV
 846         (FSOKAY == (sblock.fs_state + sblock.fs_time)))
 847 #else
 848         (FSOKAY == (fs_get_state(&sblock) + sblock.fs_time)))
 849 #endif
 850         return;
 851     sblock.fs_clean = fsclean;
 852 #ifdef  AFS_SUN5_ENV
 853     sblock.fs_state = sblock.fs_time;
 854 #else
 855     fs_set_state(&sblock, sblock.fs_time);
 856 #endif
 857     /* if superblock can't be written, return */
 858     if (fswritefd < 0)
 859         return;
 860     /* read private copy of superblock, update clean flag, and write it */
 861     bno = sblk.b_bno;
 862     size = sblk.b_size;
 863 #if     defined(AFS_SUN56_ENV)
 864     sblkoff = (OFF_T) (bno) << DEV_BSHIFT;
 865     if (llseek(fsreadfd, sblkoff, 0) == -1)
 866         return;
 867 #else
 868     if (lseek(fsreadfd, (off_t) dbtob(bno), 0) == -1)
 869         return;
 870 #endif
 871     if ((cleanbuf.b_un.b_buf = malloc(size)) == NULL)
 872         errexit("out of memory");
 873     if (read(fsreadfd, cleanbuf.b_un.b_buf, (int)size) != size)
 874         return;
 875     cleanbuf.b_un.b_fs->fs_clean = sblock.fs_clean;
 876 #ifdef  AFS_SUN5_ENV
 877     cleanbuf.b_un.b_fs->fs_state = sblock.fs_state;
 878 #else
 879     fs_set_state(cleanbuf.b_un.b_fs, fs_get_state(&sblock));
 880 #endif
 881     cleanbuf.b_un.b_fs->fs_time = sblock.fs_time;
 882 #if     defined(AFS_SUN56_ENV)
 883     if (llseek(fswritefd, sblkoff, 0) == -1)
 884         return;
 885 #else
 886     if (lseek(fswritefd, (off_t) dbtob(bno), 0) == -1)
 887         return;
 888 #endif
 889     if (write(fswritefd, cleanbuf.b_un.b_buf, (int)size) != size)
 890         return;
 891 }
 892
 893 printclean()
 894 {
 895     char *s;
 896
 897 #ifdef  AFS_SUN5_ENV
 898     if (FSOKAY != (sblock.fs_state + sblock.fs_time))
 899 #else
 900     if (FSOKAY != (fs_get_state(&sblock) + sblock.fs_time))
 901 #endif
 902         s = "unknown";
 903     else
 904
 905         switch (sblock.fs_clean) {
 906         case FSACTIVE:
 907             s = "active";
 908             break;
 909         case FSCLEAN:
 910             s = "clean";
 911             break;
 912         case FSSTABLE:
 913             s = "stable";
 914             break;
 915         default:
 916             s = "unknown";
 917         }
 918     if (preen)
 919         pwarn("is %s.\n", s);
 920     else
 921         printf("** %s is %s.\n", devname, s);
 922 }
 923 #endif
 924
 925 #ifdef  AFS_SUN52_ENV
 926 char *
 927 hasvfsopt(vfs, opt)
 928      register struct vfstab *vfs;
 929      register char *opt;
 930 {
 931     char *f, *opts;
 932     static char *tmpopts;
 933
 934     if (vfs->vfs_mntopts == NULL)
 935         return (NULL);
 936     if (tmpopts == 0) {
 937         tmpopts = (char *)calloc(256, sizeof(char));
 938         if (tmpopts == 0)
 939             return (0);
 940     }
 941     strncpy(tmpopts, vfs->vfs_mntopts, (sizeof(tmpopts) - 1));
 942     opts = tmpopts;
 943     f = mntopt(&opts);
 944     for (; *f; f = mntopt(&opts)) {
 945         if (strncmp(opt, f, strlen(opt)) == 0)
 946             return (f - tmpopts + vfs->vfs_mntopts);
 947     }
 948     return (NULL);
 949 }
 950
 951
 952 writable(name)
 953      char *name;
 954 {
 955     int rw = 1;
 956     struct vfstab vfsbuf;
 957     FILE *vfstab;
 958     char *blkname, *unrawname();
 959
 960     vfstab = fopen(VFSTAB, "r");
 961     if (vfstab == NULL) {
 962         printf("can't open %s\n", VFSTAB);
 963         return (1);
 964     }
 965     blkname = unrawname(name);
 966     if ((getvfsspec(vfstab, &vfsbuf, blkname) == 0)
 967         && (vfsbuf.vfs_fstype != NULL)
 968         && (strcmp(vfsbuf.vfs_fstype, MNTTYPE_UFS) == 0)
 969         && (hasvfsopt(&vfsbuf, MNTOPT_RO))) {
 970         rw = 0;
 971     }
 972     fclose(vfstab);
 973     return (rw);
 974 }
 975
 976 mounted(name)
 977      char *name;
 978 {
 979     int found = 0;
 980     struct mnttab mnt;
 981     FILE *mnttab;
 982     struct stat device_stat, mount_stat;
 983     char *blkname, *unrawname();
 984
 985     mnttab = fopen(MNTTAB, "r");
 986     if (mnttab == NULL) {
 987         printf("can't open %s\n", MNTTAB);
 988         return (0);
 989     }
 990     blkname = unrawname(name);
 991     while ((getmntent(mnttab, &mnt)) == NULL) {
 992         if (strcmp(mnt.mnt_fstype, MNTTYPE_UFS) != 0) {
 993             continue;
 994         }
 995         if (strcmp(blkname, mnt.mnt_special) == 0) {
 996             stat(mnt.mnt_mountp, &mount_stat);
 997             stat(mnt.mnt_special, &device_stat);
 998             if (device_stat.st_rdev == mount_stat.st_dev) {
 999                 if (hasmntopt(&mnt, MNTOPT_RO) != 0)
1000                     found = 2;  /* mounted as RO */
1001                 else
1002                     found = 1;  /* mounted as R/W */
1003             }
1004             break;
1005         }
1006     }
1007     fclose(mnttab);
1008     return (found);
1009 }
1010
1011 #endif
1012
1013 #if     defined(AFS_HPUX101_ENV)
1014
1015 #include "libfs.h"
1016 #include <sys/stat.h>
1017 #include <sys/fcntl.h>
1018
1019 int seek_options;
1020
1021 bread(fd, buf, blk, size)
1022      int fd;
1023      char *buf;
1024      daddr_t blk;
1025      long size;
1026 {
1027     int i = 0;
1028     off_t lseek_offset;
1029
1030     switch (seek_options) {
1031     case BLKSEEK_ENABLED:
1032         lseek_offset = blk;
1033         break;
1034
1035     case BLKSEEK_NOT_ENABLED:   /* File */
1036 #if     defined(AFS_HPUX102_ENV)
1037         lseek_offset = dbtoo(blk);
1038 #else
1039         lseek_offset = dbtob(blk);
1040 #endif
1041         break;
1042
1043     default:
1044         rwerror("BLKSEEK", blk);
1045     }
1046     if (lseek(fd, (off_t) lseek_offset, 0) == (off_t) - 1)
1047         rwerror("SEEK", blk);
1048     else if (read(fd, buf, (int)size) == size)
1049         return 0;
1050     rwerror("READ", blk);
1051     return 1;
1052 }
1053
1054 bwrite(fd, buf, blk, size)
1055      int fd;
1056      char *buf;
1057      daddr_t blk;
1058      long size;
1059 {
1060     off_t lseek_offset;
1061
1062     if (fd < 0)
1063         return 1;
1064
1065     switch (seek_options) {
1066     case BLKSEEK_ENABLED:
1067         lseek_offset = blk;
1068         break;
1069
1070     case BLKSEEK_NOT_ENABLED:   /* File */
1071 #if     defined(AFS_HPUX102_ENV)
1072         lseek_offset = dbtoo(blk);
1073 #else
1074         lseek_offset = dbtob(blk);
1075 #endif
1076         break;
1077
1078     default:
1079         rwerror("BLKSEEK", blk);
1080     }
1081     if (lseek(fd, (off_t) lseek_offset, 0) == (off_t) - 1)
1082         rwerror("SEEK", blk);
1083     else if (write(fd, buf, (int)size) == size) {
1084         fsmodified = 1;
1085         return 0;
1086     }
1087     rwerror("WRITE", blk);
1088     return 1;
1089 }
1090
1091 int
1092 setup_block_seek(fd)
1093      int fd;                    /* File descriptor */
1094 {
1095     int flags = 0;              /* Flags to/from fcntl() */
1096
1097     return setup_block_seek_2(fd, &flags);
1098 }
1099
1100 #define set_fserror printf
1101
1102 int
1103 setup_block_seek_2(fd, cntl_flags)
1104      int fd;                    /* Input.     File descriptor    */
1105      int *cntl_flags;           /* Returned.  Flags from fcntl() */
1106 {
1107     int flags = 0;              /* Flags to/from fcntl() */
1108     off_t lstatus;              /* Status from lseek()   */
1109     struct stat statarea;
1110     char dummy[MAXBSIZE];
1111
1112     *cntl_flags = 0;
1113     /*
1114      *  Get control Flags
1115      */
1116     if ((flags = fcntl(fd, F_GETFL)) == -1) {
1117         set_fserror("Cannot get file control flags.");
1118         return (BLKSEEK_PROCESSING_ERROR);
1119     }
1120
1121     /*
1122      *  Check if fd is a non-device file
1123      */
1124
1125     if (fstat(fd, &statarea) == -1) {
1126         set_fserror("Cannot get status information on file descriptor.");
1127         return (BLKSEEK_PROCESSING_ERROR);
1128     }
1129     if (((statarea.st_mode & S_IFMT) != S_IFCHR)
1130         && ((statarea.st_mode & S_IFMT) != S_IFBLK)) {
1131         /* Not a device file -- BLKSEEK only works on device files */
1132         *cntl_flags = flags;    /* O_BLKSEEK bit never set */
1133         return (BLKSEEK_NOT_ENABLED);
1134     }
1135
1136     /*
1137      *  Set the fd to O_BLKSEEK
1138      */
1139     if (fcntl(fd, F_SETFL, flags | O_BLKSEEK) == -1) {
1140         set_fserror("Cannot set file control flags.");
1141         return (BLKSEEK_PROCESSING_ERROR);
1142     }
1143     if (flags & O_WRONLY) {
1144         /* Set lseek to location 0 before returning */
1145         if (lseek(fd, (off_t) 0, SEEK_SET) == (off_t) - 1) {
1146             set_fserror("Cannot lseek the device.");
1147             return (BLKSEEK_PROCESSING_ERROR);
1148         }
1149         if (debug)
1150             set_fserror
1151                 ("File is write only.  Cannot Verify O_BLKSEEK mode set.");
1152         *cntl_flags = flags | O_BLKSEEK;
1153         return (BLKSEEK_FILE_WRITEONLY);
1154     }
1155
1156     /*
1157      *  Verify that kernel knows how to do O_BLKSEEK
1158      */
1159     if (lseek(fd, (off_t) 0, SEEK_SET) == (off_t) - 1) {
1160         set_fserror("Cannot lseek the device.");
1161         return (BLKSEEK_PROCESSING_ERROR);
1162     }
1163     if (read(fd, &dummy[0], BBSIZE) != BBSIZE) {        /* BBSIZE = 8192 */
1164         set_fserror("Cannot read from the device");
1165         return (BLKSEEK_PROCESSING_ERROR);
1166     }
1167
1168     if ((lstatus = lseek(fd, (off_t) 0, SEEK_CUR)) == (off_t) - 1) {
1169         set_fserror("Cannot lseek the device.");
1170         return (BLKSEEK_PROCESSING_ERROR);
1171     }
1172
1173     /*
1174      *  Set lseek to location 0
1175      */
1176     if (lseek(fd, (off_t) 0, SEEK_SET) == (off_t) - 1) {
1177         set_fserror("Cannot lseek the device.");
1178         return (BLKSEEK_PROCESSING_ERROR);
1179     }
1180
1181     if (lstatus == (off_t) (BBSIZE / DEV_BSIZE)) {
1182         *cntl_flags = flags | O_BLKSEEK;
1183         return (BLKSEEK_ENABLED);       /* Successfully enabled O_BLKSEEK */
1184     }
1185     *cntl_flags = flags & (~O_BLKSEEK); /* Turn off O_BLKSEEK bit */
1186     return (BLKSEEK_NOT_ENABLED);       /* O_BLKSEEK not enabled */
1187 }
1188
1189 setup_all_block_seek()
1190 {
1191     int opt = 0;
1192     seek_options = setup_block_seek(fsreadfd);
1193     switch (seek_options) {
1194     case BLKSEEK_ENABLED:
1195     case BLKSEEK_NOT_ENABLED:
1196         break;
1197     default:
1198         errexit("setup_block_seek on fsreadfd");
1199         break;
1200     }
1201     if (fswritefd == -1)
1202         goto done;
1203     switch (opt = setup_block_seek(fswritefd)) {
1204     case BLKSEEK_FILE_WRITEONLY:        /* WO block or char device. */
1205     case BLKSEEK_NOT_ENABLED:   /* regular file.            */
1206         if (seek_options != opt)
1207             printf
1208                 ("seek_options on fsreadfd (%d) and fswritefd (%d) do not match",
1209                  seek_options, opt);
1210         break;
1211     default:
1212         errexit("setup_block_seek on fswritefd");
1213         break;
1214     }
1215   done:
1216     if (debug)
1217         printf("read option = %d write option = %d\n", seek_options, opt);
1218 }
1219
1220
1221
1222 #endif /* AFS_HPUX101_ENV */