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