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