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