![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to x CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd|
Return to x CVS log | Up to [Research Unix] / researchv10dc / cmd |
1.1 root 1: #line 1 "/usr/include/stdio.h"
2:
3:
4:
5: extern struct _iobuf {
6: int _cnt;
7: unsigned char *_ptr;
8: unsigned char *_base;
9: short _flag;
10: char _file;
11: } _iob[ 120 ];
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38: struct _iobuf *fopen();
39: struct _iobuf *fdopen();
40: struct _iobuf *freopen();
41: struct _iobuf *popen();
42: long ftell();
43: char *fgets();
44:
45:
46: #line 1 "/usr/include/tmpnam.h"
47:
48:
49: #line 46 "/usr/include/stdio.h"
50:
51: #line 2 "fsck.c"
52: #line 1 "/usr/include/ctype.h"
53:
54:
55:
56:
57:
58:
59:
60:
61:
62: extern char _ctype[];
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79: #line 3 "fsck.c"
80: #line 1 "/usr/include/sys/param.h"
81:
82: #line 4 "/usr/include/sys/param.h"
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94: #line 19 "/usr/include/sys/param.h"
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109: #line 36 "/usr/include/sys/param.h"
110:
111:
112: #line 1 "/usr/include/signal.h"
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151: typedef int (*SIG_TYP)();
152:
153: SIG_TYP signal();
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172: #line 39 "/usr/include/sys/param.h"
173:
174:
175:
176: #line 44 "/usr/include/sys/param.h"
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190: #line 63 "/usr/include/sys/param.h"
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201: #line 75 "/usr/include/sys/param.h"
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226: #line 101 "/usr/include/sys/param.h"
227:
228:
229:
230:
231: #line 107 "/usr/include/sys/param.h"
232:
233:
234:
235:
236:
237:
238: #line 115 "/usr/include/sys/param.h"
239:
240:
241:
242: #line 121 "/usr/include/sys/param.h"
243:
244:
245:
246:
247:
248:
249:
250:
251: #line 131 "/usr/include/sys/param.h"
252: #line 1 "/usr/include/sys/types.h"
253:
254: #line 4 "/usr/include/sys/types.h"
255:
256:
257:
258: #line 9 "/usr/include/sys/types.h"
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280: #line 33 "/usr/include/sys/types.h"
281: typedef unsigned char u_char;
282: typedef unsigned short u_short;
283: typedef unsigned int u_int;
284: typedef unsigned long u_long;
285:
286: typedef long daddr_t;
287: typedef char * caddr_t;
288: typedef unsigned short ino_t;
289: typedef long swblk_t;
290: typedef long clicks_t;
291: typedef long time_t;
292: typedef long label_t[14];
293: typedef unsigned short dev_t;
294: typedef long off_t;
295: typedef struct { unsigned long lo; long hi; } llong_t;
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307: #line 62 "/usr/include/sys/types.h"
308:
309: typedef struct fd_set { unsigned int fds_bits[ (128+ sizeof(int) * 8 -1)/( sizeof(int) * 8 ) ]; } fd_set;
310:
311:
312:
313:
314: #line 132 "/usr/include/sys/param.h"
315:
316:
317: #line 136 "/usr/include/sys/param.h"
318:
319: llong_t ltoL();
320: llong_t Lladd();
321: llong_t Luadd();
322: llong_t LLadd();
323:
324: unsigned Lshift();
325: #line 4 "fsck.c"
326: #line 1 "/usr/include/sys/filsys.h"
327:
328: #line 4 "/usr/include/sys/filsys.h"
329: struct filsys
330: {
331: unsigned short s_isize;
332: daddr_t s_fsize;
333: short s_ninode;
334: ino_t s_inode[ 100 ];
335: char s_flock;
336: char s_ilock;
337: char s_fmod;
338: char s_ronly;
339: time_t s_time;
340: daddr_t s_tfree;
341: ino_t s_tinode;
342: short s_dinfo[2];
343:
344:
345:
346:
347: char s_fsmnt[14];
348: ino_t s_lasti;
349: ino_t s_nbehind;
350: union {
351: struct {
352: short S_nfree;
353: daddr_t S_free[ 178 ];
354: } R;
355: struct {
356: char S_valid;
357: char S_flag;
358:
359: long S_bfree[ 961 ];
360: } B;
361: struct {
362: char S_valid;
363: char S_flag;
364: long S_bsize;
365: struct buf * S_blk[ 961 -1];
366: } N;
367: } U;
368: };
369:
370:
371:
372:
373:
374:
375: #line 53 "/usr/include/sys/filsys.h"
376:
377:
378:
379:
380:
381:
382:
383:
384: #line 5 "fsck.c"
385: #line 1 "/usr/include/sys/dir.h"
386:
387:
388:
389: struct direct
390: {
391: ino_t d_ino;
392: char d_name[ 14 ];
393: };
394: #line 6 "fsck.c"
395: #line 1 "/usr/include/sys/fblk.h"
396: struct fblk
397: {
398: int df_nfree;
399: daddr_t df_free[ 178 ];
400: };
401: #line 7 "fsck.c"
402: #line 1 "/usr/include/sys/ino.h"
403:
404: #line 5 "/usr/include/sys/ino.h"
405: struct dinode
406: {
407: unsigned short di_mode;
408: short di_nlink;
409: short di_uid;
410: short di_gid;
411: off_t di_size;
412: char di_addr[40];
413: time_t di_atime;
414: time_t di_mtime;
415: time_t di_ctime;
416: };
417:
418: #line 22 "/usr/include/sys/ino.h"
419: #line 8 "fsck.c"
420: #line 1 "/usr/include/sys/inode.h"
421:
422: #line 11 "/usr/include/sys/inode.h"
423:
424:
425:
426: struct inode
427: {
428: short i_flag;
429: dev_t i_dev;
430: char i_fstyp;
431: unsigned short i_count;
432: long i_number;
433: unsigned short i_mode;
434: short i_nlink;
435: short i_uid;
436: short i_gid;
437: off_t i_size;
438: struct inode *i_mroot;
439: struct inode *i_mpoint;
440: struct stdata *i_sptr;
441: union {
442: struct {
443: daddr_t I_addr[ 13 ];
444: daddr_t I_lastr;
445: struct buf *I_bufp;
446: } i_f;
447:
448:
449:
450: struct {
451: daddr_t I_rdev;
452: } i_d;
453:
454: struct {
455: long I_tag;
456: struct inode *I_cip;
457: int I_fsflags;
458: time_t I_atime;
459: time_t I_mtime;
460: time_t I_ctime;
461: dev_t I_rdev;
462: } i_a;
463:
464:
465:
466:
467:
468:
469:
470: struct {
471: struct proc *I_proc;
472: int I_sigmask;
473: } i_p;
474:
475:
476: } i_un;
477: struct inode *i_hlink;
478: };
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521: struct argnamei {
522: short flag;
523: short len;
524: union {
525: short mode;
526: struct inode *il;
527: caddr_t buf;
528: } un;
529: };
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541: struct nx {
542: struct inode *dp;
543: char *cp;
544: char *nbuf;
545: short nlen;
546: short nlink;
547: };
548:
549:
550: #line 140 "/usr/include/sys/inode.h"
551:
552:
553:
554:
555: #line 151 "/usr/include/sys/inode.h"
556:
557:
558: #line 160 "/usr/include/sys/inode.h"
559:
560:
561: #line 9 "fsck.c"
562: #line 1 "/usr/include/sys/stat.h"
563: struct stat
564: {
565: dev_t st_dev;
566: ino_t st_ino;
567: unsigned short st_mode;
568: short st_nlink;
569: short st_uid;
570: short st_gid;
571: dev_t st_rdev;
572: off_t st_size;
573: time_t st_atime;
574: time_t st_mtime;
575: time_t st_ctime;
576: };
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592: #line 10 "fsck.c"
593: #line 1 "/usr/include/fstab.h"
594:
595: #line 7 "/usr/include/fstab.h"
596:
597:
598: #line 11 "/usr/include/fstab.h"
599:
600:
601:
602:
603:
604: struct fstab{
605: char fs_spec[ 32 ];
606: char fs_file[ 32 ];
607: int fs_ftype;
608: int fs_flags;
609: int fs_passno;
610: };
611:
612:
613: #line 28 "/usr/include/fstab.h"
614:
615:
616:
617:
618: struct fstab *getfsent();
619: struct fstab *getfsspec();
620: struct fstab *getfsfile();
621: int setfsent();
622: int endfsent();
623:
624:
625: #line 41 "/usr/include/fstab.h"
626:
627: struct mtab {
628: char file[ 32 ];
629: char spec[ 32 -1];
630: char type;
631: };
632:
633:
634: #line 11 "fsck.c"
635: #line 1 "/usr/include/pwd.h"
636: struct passwd {
637: char *pw_name;
638: char *pw_passwd;
639: int pw_uid;
640: int pw_gid;
641: int pw_quota;
642: char *pw_comment;
643: char *pw_gecos;
644: char *pw_dir;
645: char *pw_shell;
646: };
647: extern struct passwd *getpwent();
648: extern struct passwd *getpwuid();
649: extern struct passwd *getpwnam();
650: extern struct passwd *pwdecode();
651: #line 12 "fsck.c"
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681: typedef struct dinode DINODE;
682: typedef struct direct DIRECT;
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:
696: daddr_t startib;
697: unsigned niblk;
698:
699: struct bufarea {
700: struct bufarea *b_next;
701: daddr_t b_bno;
702: union {
703: char b_buf[ ( (( 64 ) & 64) ? 4096: 1024) ];
704: short b_lnks[ ( ( (( 64 ) & 64) ? 4096: 1024) /sizeof(short)) ];
705: daddr_t b_indir[ ( ( (( 64 ) & 64) ? 4096: 1024) /sizeof(daddr_t)) ];
706: struct filsys b_fs;
707: struct fblk b_fb;
708: struct dinode b_dinode[ ( (( 64 ) & 64) ? 64: 16) ];
709: DIRECT b_dir[ ( ( (( 64 ) & 64) ? 4096: 1024) /sizeof(struct direct)) ];
710: } b_un;
711: char b_dirty;
712: };
713:
714: typedef struct bufarea BUFAREA;
715:
716: BUFAREA inoblk;
717: BUFAREA fileblk;
718: BUFAREA sblk;
719: BUFAREA *poolhead;
720:
721:
722:
723:
724:
725:
726:
727:
728:
729:
730:
731: struct filecntl {
732: int rfdes;
733: int wfdes;
734: int mod;
735: };
736:
737: struct filecntl dfile;
738: struct filecntl sfile;
739:
740: typedef unsigned MEMSIZE;
741:
742: MEMSIZE memsize;
743:
744:
745:
746:
747:
748:
749:
750:
751: daddr_t duplist[ 100 ];
752: daddr_t *enddup;
753: daddr_t *muldup;
754:
755:
756: ino_t badlncnt[ 500 ];
757: ino_t *badlnp;
758:
759: char sflag;
760: char csflag;
761: char nflag;
762: char yflag;
763: char tflag;
764: char preen;
765: char rplyflag;
766: char hotroot;
767: char rawflg;
768: char rmscr;
769: char fixfree;
770: char *membase;
771: char *blkmap;
772: char *freemap;
773: char *statemap;
774: char *pathp;
775: char *thisname;
776: char *srchname;
777: char pathname[200];
778: char scrfile[80];
779: char *lfname = "lost+found";
780: char *checklist = "/etc/fstab" ;
781: char big;
782:
783: short *lncntp;
784:
785: int cylsize;
786: int stepsize;
787: int badblk;
788: int dupblk;
789: int (*pfunc)();
790: int zcleared;
791:
792: ino_t inum;
793: ino_t imax;
794: ino_t parentdir;
795: ino_t lastino;
796: ino_t lfdir;
797: ino_t orphan;
798:
799: off_t filsize;
800: off_t maxblk;
801: off_t bmapsz;
802:
803: daddr_t smapblk;
804: daddr_t lncntblk;
805: daddr_t fmapblk;
806: daddr_t n_free;
807: daddr_t n_blks;
808: daddr_t n_files;
809: daddr_t fmin;
810: daddr_t fmax;
811:
812:
813:
814:
815:
816:
817:
818:
819:
820:
821:
822:
823:
824:
825:
826:
827:
828:
829:
830:
831:
832:
833:
834:
835:
836:
837:
838:
839: int (*signal())();
840: long lseek();
841: long time();
842: DINODE *ginode();
843: BUFAREA *getblk();
844: BUFAREA *search();
845: int dirscan();
846: int findino();
847: int catch();
848: int mkentry();
849: int chgdd();
850: int pass1();
851: int pass1b();
852: int pass2();
853: int pass3();
854: int pass4();
855: int pass5();
856:
857: char *devname;
858:
859: main(argc,argv)
860: int argc;
861: char *argv[];
862: {
863: register struct _iobuf *fp;
864: register n;
865: register char *p;
866: char filename[50];
867: char *sbrk();
868:
869: setbuf( (&_iob[1]) , 0 );
870: sync();
871: while(--argc > 0 && **++argv == '-') {
872: switch(*++*argv) {
873: case 'p':
874: preen++;
875: break;
876: case 't':
877: case 'T':
878: tflag++;
879: if(**++argv == '-' || --argc <= 0)
880: errexit("Bad -t option\n");
881: p = scrfile;
882: while(*p++ = **argv)
883: (*argv)++;
884: break;
885: case 's':
886: stype(++*argv);
887: sflag++;
888: break;
889: case 'S':
890: stype(++*argv);
891: csflag++;
892: break;
893: case 'n':
894: case 'N':
895: nflag++;
896: yflag = 0;
897: break;
898: case 'y':
899: case 'Y':
900: yflag++;
901: nflag = 0;
902: break;
903: default:
904: errexit("%c option?\n",**argv);
905: }
906: }
907: if(nflag && (sflag || csflag))
908: errexit("Incompatible options: -n and -%s\n",sflag?"s":"S");
909: if(sflag && csflag)
910: sflag = 0;
911: memsize = (MEMSIZE)sbrk(0);
912: memsize = MAXDATA - memsize - sizeof(int);
913: while(memsize >= 2*sizeof(BUFAREA) &&
914: (membase = sbrk(memsize)) == (char *)-1)
915: memsize -= 1024;
916: if(memsize < 2*sizeof(BUFAREA))
917: errexit("Can't get memory\n");
918: if (signal( 2 , (SIG_TYP)1 ) != (SIG_TYP)1 )
919: signal( 2 , catch);
920: if(argc) {
921: while(argc-- > 0){
922: hotroot = 0;
923: check(*argv++);
924: }
925: }
926: else {
927: struct fstab *fsp;
928: int pid, passno, anygtr, sumstatus = 0;
929: passno = 1;
930: do {
931: anygtr = 0;
932: if (setfsent() == 0)
933: errexit("Can't open checklist file: %s\n",
934: "/etc/fstab" );
935: while ( (fsp = getfsent()) != 0){
936: if (fsp->fs_ftype != 0)
937: continue;
938: if (preen == 0 ||
939: passno == 1 && fsp->fs_passno == passno) {
940: if (blockcheck(fsp->fs_spec) == 0 &&
941: preen)
942: exit(8);
943: } else if (fsp->fs_passno > passno)
944: anygtr = 1;
945: else if (fsp->fs_passno == passno) {
946: pid = fork();
947: if (pid < 0) {
948: perror("fork");
949: exit(8);
950: }
951: if (pid == 0)
952: if (blockcheck(fsp->fs_spec)== 0 )
953: exit(8);
954: else
955: exit(0);
956: }
957: }
958: if (preen) {
959: int status;
960: while (wait(&status) != -1)
961: sumstatus |= status;
962: }
963: passno++;
964: } while (anygtr);
965: if (sumstatus)
966: exit(8);
967: endfsent();
968: }
969: exit(0);
970: }
971:
972: char *rawname(), *strrchr(), *unrawname();
973:
974: blockcheck(name)
975: char *name;
976: {
977: struct stat stat_slash, stat_block, stat_char;
978: char *raw;
979: int looped = 0;
980:
981: hotroot = 0;
982: if (stat("/", &stat_slash) < 0){
983: error("Can't stat root\n");
984: return( 0 );
985: }
986: retry:
987: if (stat(name, &stat_block) < 0){
988: error("Can't stat %s\n", name);
989: return( 0 );
990: }
991: big = 0 ;
992: if (stat_block.st_mode & 0060000 ){
993: if( (( stat_block.st_rdev ) & 64) )
994: big = 64 ;
995: raw = rawname(name);
996: if (stat(raw, &stat_char) < 0){
997: error("Can't stat %s\n", raw);
998: return( 0 );
999: }
1000: if (stat_char.st_mode & 0020000 ){
1001: if (stat_slash.st_dev == stat_block.st_rdev) {
1002: hotroot++;
1003: raw = unrawname(name);
1004: }
1005: check(raw);
1006: return( 1 );
1007: } else if(big == 64 ) {
1008: check(name);
1009: return( 1 );
1010: } else {
1011: error("%s is not a character device\n", raw);
1012: return( 0 );
1013: }
1014: } else
1015: if (stat_block.st_mode & 0020000 ){
1016: if (looped) {
1017: error("Can't make sense out of name %s\n", name);
1018: return( 0 );
1019: }
1020: name = unrawname(name);
1021: looped++;
1022: goto retry;
1023: }
1024: error("Can't make sense out of name %s\n", name);
1025: return( 0 );
1026: }
1027:
1028: char *
1029: unrawname(cp)
1030: char *cp;
1031: {
1032: char *dp = strrchr(cp, '/');
1033: struct stat stb;
1034: if (dp == 0)
1035: return(cp);
1036: if (stat(cp, &stb) < 0)
1037: return(cp);
1038: if ((stb.st_mode& 0170000 ) != 0020000 )
1039: return(cp);
1040: if (*(dp+1) != 'r')
1041: return(cp);
1042: strcpy(dp+1, dp+2);
1043: return(cp);
1044: }
1045:
1046: char *
1047: rawname(cp)
1048: char *cp;
1049: {
1050: static char rawbuf[32];
1051: char *dp = strrchr(cp, '/');
1052:
1053: if (dp == 0)
1054: return (0);
1055: if(big == 64 )
1056: return(cp);
1057: *dp = 0;
1058: strcpy(rawbuf, cp);
1059: *dp = '/';
1060: strcat(rawbuf, "/r");
1061: strcat(rawbuf, dp+1);
1062: return (rawbuf);
1063: }
1064:
1065: check(dev)
1066: char *dev;
1067: {
1068:
1069: devname = dev;
1070: check1(dev);
1071: devname = 0;
1072: }
1073:
1074: check1(dev)
1075: char *dev;
1076: {
1077: register DINODE *dp;
1078: register n;
1079: register ino_t *blp;
1080: ino_t savino;
1081: daddr_t blk;
1082: BUFAREA *bp1, *bp2;
1083:
1084: if(setup(dev) == 0 )
1085: return;
1086: if (preen==0) {
1087: printf("** Checking %s\n", dev);
1088: printf("** Phase 1 - Check Blocks and Sizes\n");
1089: }
1090: pfunc = pass1;
1091: for(inum = 1; inum <= imax; inum++) {
1092: if((dp = ginode()) == 0 )
1093: continue;
1094: if( ((dp->di_mode & 0170000 ) != 0) ) {
1095: lastino = inum;
1096: if(ftypeok(dp) == 0 ) {
1097: pfatal("UNKNOWN FILE TYPE I=%u",inum);
1098: if(reply("CLEAR") == 1 ) {
1099: clear((char *)( dp ),sizeof(DINODE)) ;
1100: inoblk.b_dirty = 1 ;
1101: }
1102: continue;
1103: }
1104: n_files++;
1105: if( dolncnt( dp->di_nlink ,0) <= 0) {
1106: if(badlnp < &badlncnt[ 500 ])
1107: *badlnp++ = inum;
1108: else {
1109: pfatal("LINK COUNT TABLE OVERFLOW");
1110: if(reply("CONTINUE") == 0 )
1111: errexit("");
1112: }
1113: }
1114: dostate( ((dp->di_mode & 0170000 ) == 0040000 ) ? 02 : 01 ,0) ;
1115: badblk = dupblk = 0;
1116: filsize = 0;
1117: maxblk = 0;
1118: ckinode(dp, 0 );
1119: if((n = dostate(0,1) ) == 02 || n == 01 )
1120: sizechk(dp);
1121: }
1122: else if(dp->di_mode != 0) {
1123: pfatal("PARTIALLY ALLOCATED INODE I=%u",inum);
1124: if(reply("CLEAR") == 1 ) {
1125: clear((char *)( dp ),sizeof(DINODE)) ;
1126: inoblk.b_dirty = 1 ;
1127: }
1128: }
1129: }
1130:
1131:
1132: if(enddup != &duplist[0]) {
1133: if (preen)
1134: pfatal("INTERNAL ERROR: dups with -p");
1135: printf("** Phase 1b - Rescan For More DUPS\n");
1136: pfunc = pass1b;
1137: for(inum = 1; inum <= lastino; inum++) {
1138: if( dostate(0,1) != 0 && (dp = ginode()) != 0 )
1139: if(ckinode(dp, 0 ) & 01 )
1140: break;
1141: }
1142: }
1143: if(rawflg) {
1144: if(inoblk.b_dirty)
1145: bwrite(&dfile,membase,startib,(int)niblk* ( (( big ) & 64) ? 4096: 1024) );
1146: inoblk.b_dirty = 0;
1147: if(poolhead) {
1148: clear(membase,niblk* ( (( 64 ) & 64) ? 4096: 1024) );
1149: for(bp1 = poolhead;bp1->b_next;bp1 = bp1->b_next);
1150: bp2 = &((BUFAREA *)membase)[(niblk* ( (( 64 ) & 64) ? 4096: 1024) )/sizeof(BUFAREA)];
1151: while(--bp2 >= (BUFAREA *)membase) {
1152: ( bp2 )->b_dirty = 0;( bp2 )->b_bno = (daddr_t)-1 ;
1153: bp2->b_next = bp1->b_next;
1154: bp1->b_next = bp2;
1155: }
1156: }
1157: rawflg = 0;
1158:
1159: }
1160:
1161:
1162: if (preen == 0)
1163: printf("** Phase 2 - Check Pathnames\n");
1164: inum = ((ino_t)2) ;
1165: thisname = pathp = pathname;
1166: pfunc = pass2;
1167: switch( dostate(0,1) ) {
1168: case 0 :
1169: errexit("ROOT INODE UNALLOCATED. TERMINATING.\n");
1170: case 01 :
1171: pfatal("ROOT INODE NOT DIRECTORY");
1172: if(reply("FIX") == 0 || (dp = ginode()) == 0 )
1173: errexit("");
1174: dp->di_mode &= ~ 0170000 ;
1175: dp->di_mode |= 0040000 ;
1176: inoblk.b_dirty = 1 ;
1177: dostate( 02 ,0) ;
1178: case 02 :
1179: descend();
1180: break;
1181: case 03 :
1182: pfatal("DUPS/BAD IN ROOT INODE");
1183: printf("\n");
1184: if(reply("CONTINUE") == 0 )
1185: errexit("");
1186: dostate( 02 ,0) ;
1187: descend();
1188: }
1189:
1190:
1191: if (preen == 0)
1192: printf("** Phase 3 - Check Connectivity\n");
1193: for(inum = 1; inum <= lastino; inum++) {
1194: if( dostate(0,1) == 02 ) {
1195: pfunc = findino;
1196: srchname = "..";
1197: savino = inum;
1198: do {
1199: orphan = inum;
1200: if((dp = ginode()) == 0 )
1201: break;
1202: filsize = dp->di_size;
1203: parentdir = 0;
1204: ckinode(dp, 1 );
1205: if((inum = parentdir) == 0)
1206: break;
1207: } while( dostate(0,1) == 02 );
1208: inum = orphan;
1209: if(linkup() == 1 ) {
1210: thisname = pathp = pathname;
1211: *pathp++ = '?';
1212: pfunc = pass2;
1213: descend();
1214: }
1215: inum = savino;
1216: }
1217: }
1218:
1219:
1220: if (preen == 0)
1221: printf("** Phase 4 - Check Reference Counts\n");
1222: pfunc = pass4;
1223: zcleared = 0;
1224: for(inum = 1; inum <= lastino; inum++) {
1225: switch( dostate(0,1) ) {
1226: case 01 :
1227: if(n = dolncnt(0,1) )
1228: adjust((short)n);
1229: else {
1230: for(blp = badlncnt;blp < badlnp; blp++)
1231: if(*blp == inum) {
1232: clri("UNREF",preen? 0 : 1 , 1 );
1233: break;
1234: }
1235: }
1236: break;
1237: case 02 :
1238: clri("UNREF", 1 , 0 );
1239: break;
1240: case 03 :
1241: clri("BAD/DUP", 1 , 0 );
1242: }
1243: }
1244: if (zcleared)
1245: pwarn("%u LINKLESS FILES CLEARED\n", zcleared);
1246: if(imax - n_files != sblk.b_un.b_fs .s_tinode) {
1247: pwarn("FREE INODE COUNT %u SHOULD BE %u IN SUPERBLK",
1248: sblk.b_un.b_fs .s_tinode, imax - n_files);
1249: if (preen)
1250: printf(" (FIXED)\n");
1251: if (preen || reply("FIX") == 1 ) {
1252: sblk.b_un.b_fs .s_tinode = imax - n_files;
1253: sblk.b_dirty = 1 ;
1254: }
1255: }
1256: flush(&dfile,&fileblk);
1257:
1258: if (preen == 0)
1259: printf("** Phase 5 - Check Free List ");
1260: if(sflag || (csflag && rplyflag == 0)) {
1261: if (preen == 0)
1262: printf("(Ignored)\n");
1263: fixfree = 1;
1264: }
1265: else {
1266: if (preen == 0)
1267: printf("\n");
1268: if(freemap)
1269: copy(blkmap,freemap,(MEMSIZE)bmapsz);
1270: else {
1271: for(blk = 0; blk < fmapblk; blk++) {
1272: bp1 = getblk((BUFAREA *) 0 ,blk);
1273: bp2 = getblk((BUFAREA *) 0 ,blk+fmapblk);
1274: copy(bp1->b_un.b_buf,bp2->b_un.b_buf, ( (( big ) & 64) ? 4096: 1024) );
1275: ( bp2 )->b_dirty = 1 ;
1276: }
1277: }
1278: badblk = dupblk = 0;
1279: if(big == 0 ) {
1280: fileblk.b_un.b_fb .df_nfree = sblk.b_un.b_fs . U.R.S_nfree ;
1281: for(n = 0; n < 178 ; n++)
1282: fileblk.b_un.b_fb .df_free[n] = sblk.b_un.b_fs . U.R.S_free [n];
1283: }
1284: freechk();
1285: if(badblk) {
1286: pfatal("%d BAD BLKS IN FREE LIST",badblk);
1287: printf("\n");
1288: }
1289: if(dupblk)
1290: pwarn("%d DUP BLKS IN FREE LIST\n",dupblk);
1291: if(fixfree == 0) {
1292: if((n_blks+n_free) != (fmax-fmin)) {
1293: pwarn("%ld BLK(S) MISSING\n",
1294: fmax-fmin-n_blks-n_free);
1295: fixfree = 1;
1296: }
1297: else if(big == 0 && n_free != sblk.b_un.b_fs .s_tfree) {
1298: pwarn("FREE BLK COUNT WRONG IN SUPERBLK");
1299: if (preen)
1300: printf(" (FIXED)\n");
1301: if(preen || reply("FIX") == 1 ) {
1302: sblk.b_un.b_fs .s_tfree = n_free;
1303: sblk.b_dirty = 1 ;
1304: }
1305: }
1306: }
1307: if(fixfree) {
1308: pwarn("BAD FREE LIST");
1309: if (preen)
1310: printf(" (SALVAGED)\n");
1311: else if(reply("SALVAGE") == 0 )
1312: fixfree = 0;
1313: }
1314: }
1315:
1316: if(fixfree) {
1317: if (preen == 0)
1318: printf("** Phase 6 - Salvage Free List\n");
1319: makefree();
1320: n_free = sblk.b_un.b_fs .s_tfree;
1321: }
1322:
1323: pwarn("%ld files %ld blocks %ld free\n", n_files,n_blks,n_free);
1324: if(dfile.mod) {
1325: time(& sblk.b_un.b_fs .s_time);
1326: sblk.b_dirty = 1 ;
1327: }
1328: ckfini();
1329: sync();
1330: if(dfile.mod && hotroot) {
1331: printf("ROOT MODIFIED\n");
1332: }
1333: if(dfile.mod && preen == 0)
1334: printf("\n***** FILE SYSTEM WAS MODIFIED *****\n");
1335: }
1336:
1337:
1338: error(s1,s2,s3,s4)
1339: char *s1;
1340: {
1341: printf(s1,s2,s3,s4);
1342: }
1343:
1344:
1345: errexit(s1,s2,s3,s4)
1346: char *s1;
1347: {
1348: error(s1,s2,s3,s4);
1349: exit(8);
1350: }
1351:
1352:
1353: #line 718 "fsck.c"
1354: pfatal(s,a1,a2,a3)
1355: {
1356:
1357: if (preen) {
1358: printf("%s: ", devname);
1359: printf(s, a1, a2, a3);
1360: printf("\n");
1361: preendie();
1362: }
1363: printf(s, a1, a2, a3);
1364: }
1365:
1366:
1367: #line 734 "fsck.c"
1368: preendie()
1369: {
1370:
1371: printf("%s: UNEXPECTED INCONSISTENCY; RUN fsck MANUALLY.\n", devname);
1372: exit(8);
1373: }
1374:
1375:
1376: #line 745 "fsck.c"
1377: pwarn(s,a1,a2,a3,a4,a5,a6)
1378: {
1379:
1380: if (preen)
1381: printf("%s: ", devname);
1382: printf(s, a1, a2, a3, a4, a5, a6);
1383: }
1384:
1385: ckinode(dp,flg)
1386: DINODE *dp;
1387: register flg;
1388: {
1389: register daddr_t *ap;
1390: register ret;
1391: int (*func)(), n;
1392: daddr_t iaddrs[ 13 ];
1393:
1394: if( ( ((dp->di_mode & 0170000 ) == 0060000 ) || ((dp->di_mode & 0170000 ) == 0020000 ) ) )
1395: return( 04 );
1396: l3tol(iaddrs,dp->di_addr, 13 );
1397: func = (flg == 0 ) ? pfunc : dirscan;
1398: for(ap = iaddrs; ap < &iaddrs[ 13 -3]; ap++) {
1399: if(*ap && (ret = (*func)(*ap)) & 01 )
1400: return(ret);
1401: }
1402: for(n = 1; n < 4; n++) {
1403: if(*ap && (ret = iblock(*ap,n,flg)) & 01 )
1404: return(ret);
1405: ap++;
1406: }
1407: return( 04 );
1408: }
1409:
1410:
1411: iblock(blk,ilevel,flg)
1412: daddr_t blk;
1413: register ilevel;
1414: {
1415: register daddr_t *ap;
1416: register n;
1417: int (*func)();
1418: BUFAREA ib;
1419:
1420: if(flg == 0 ) {
1421: func = pfunc;
1422: if(((n = (*func)(blk)) & 04 ) == 0)
1423: return(n);
1424: }
1425: else
1426: func = dirscan;
1427: if( ( blk < fmin || blk >= fmax) )
1428: return( 02 );
1429: ( &ib )->b_dirty = 0;( &ib )->b_bno = (daddr_t)-1 ;
1430: if(getblk(&ib,blk) == 0 )
1431: return( 02 );
1432: ilevel--;
1433: for(ap = ib.b_un.b_indir; ap < &ib.b_un.b_indir[ ( ( (( big ) & 64) ? 4096: 1024) /sizeof(daddr_t)) ]; ap++) {
1434: if(*ap) {
1435: if(ilevel > 0) {
1436: n = iblock(*ap,ilevel,flg);
1437: }
1438: else
1439: n = (*func)(*ap);
1440: if(n & 01 )
1441: return(n);
1442: }
1443: }
1444: return( 04 );
1445: }
1446:
1447:
1448: pass1(blk)
1449: daddr_t blk;
1450: {
1451: register daddr_t *dlp;
1452:
1453: if( ( blk < fmin || blk >= fmax) ) {
1454: blkerr("BAD",blk);
1455: if(++badblk >= 10 ) {
1456: printf("EXCESSIVE BAD BLKS I=%u",inum);
1457: if(reply("CONTINUE") == 0 )
1458: errexit("");
1459: return( 01 );
1460: }
1461: return( 02 );
1462: }
1463: if( domap( blk ,1) ) {
1464: blkerr("DUP",blk);
1465: if(++dupblk >= 10 ) {
1466: printf("EXCESSIVE DUP BLKS I=%u",inum);
1467: if(reply("CONTINUE") == 0 )
1468: errexit("");
1469: return( 01 );
1470: }
1471: if(enddup >= &duplist[ 100 ]) {
1472: printf("DUP TABLE OVERFLOW.");
1473: if(reply("CONTINUE") == 0 )
1474: errexit("");
1475: return( 01 );
1476: }
1477: for(dlp = duplist; dlp < muldup; dlp++) {
1478: if(*dlp == blk) {
1479: *enddup++ = blk;
1480: break;
1481: }
1482: }
1483: if(dlp >= muldup) {
1484: *enddup++ = *muldup;
1485: *muldup++ = blk;
1486: }
1487: }
1488: else {
1489: n_blks++;
1490: domap( blk ,0) ;
1491: }
1492: filsize++;
1493: return( 04 );
1494: }
1495:
1496:
1497: pass1b(blk)
1498: daddr_t blk;
1499: {
1500: register daddr_t *dlp;
1501:
1502: if( ( blk < fmin || blk >= fmax) )
1503: return( 02 );
1504: for(dlp = duplist; dlp < muldup; dlp++) {
1505: if(*dlp == blk) {
1506: blkerr("DUP",blk);
1507: *dlp = *--muldup;
1508: *muldup = blk;
1509: return(muldup == duplist ? 01 : 04 );
1510: }
1511: }
1512: return( 04 );
1513: }
1514:
1515:
1516: pass2(dirp)
1517: register DIRECT *dirp;
1518: {
1519: register char *p;
1520: register n;
1521: DINODE *dp;
1522:
1523: if((inum = dirp->d_ino) == 0)
1524: return( 04 );
1525: thisname = pathp;
1526: for(p = dirp->d_name; p < &dirp->d_name[ 14 ]; )
1527: if((*pathp++ = *p++) == 0) {
1528: --pathp;
1529: break;
1530: }
1531: *pathp = 0;
1532: n = 0 ;
1533: if(inum > imax || inum <= 0)
1534: n = direrr("I OUT OF RANGE");
1535: else {
1536: again:
1537: switch( dostate(0,1) ) {
1538: case 0 :
1539: n = direrr("UNALLOCATED");
1540: break;
1541: case 03 :
1542: if((n = direrr("DUP/BAD")) == 1 )
1543: break;
1544: if((dp = ginode()) == 0 )
1545: break;
1546: dostate( ((dp->di_mode & 0170000 ) == 0040000 ) ? 02 : 01 ,0) ;
1547: goto again;
1548: case 01 :
1549: dolncnt(0,2) ;
1550: break;
1551: case 02 :
1552: dolncnt(0,2) ;
1553: descend();
1554: }
1555: }
1556: pathp = thisname;
1557: if(n == 0 )
1558: return( 04 );
1559: dirp->d_ino = 0;
1560: return( 04 | 010 );
1561: }
1562:
1563:
1564: pass4(blk)
1565: daddr_t blk;
1566: {
1567: register daddr_t *dlp;
1568:
1569: if( ( blk < fmin || blk >= fmax) )
1570: return( 02 );
1571: if( domap( blk ,1) ) {
1572: for(dlp = duplist; dlp < enddup; dlp++)
1573: if(*dlp == blk) {
1574: *dlp = *--enddup;
1575: return( 04 );
1576: }
1577: domap( blk ,2) ;
1578: n_blks--;
1579: }
1580: return( 04 );
1581: }
1582:
1583:
1584: pass5(blk)
1585: daddr_t blk;
1586: {
1587: if( ( blk < fmin || blk >= fmax) ) {
1588: fixfree = 1;
1589: if (preen)
1590: pfatal("BAD BLOCKS IN FREE LIST.");
1591: if(++badblk >= 10 ) {
1592: printf("EXCESSIVE BAD BLKS IN FREE LIST.");
1593: if(reply("CONTINUE") == 0 )
1594: errexit("");
1595: return( 01 );
1596: }
1597: return( 02 );
1598: }
1599: if( domap( blk ,1+4) ) {
1600: fixfree = 1;
1601: if(++dupblk >= 100 ) {
1602: printf("EXCESSIVE DUP BLKS IN FREE LIST.");
1603: if(reply("CONTINUE") == 0 )
1604: errexit("");
1605: return( 01 );
1606: }
1607: }
1608: else {
1609: n_free++;
1610: domap( blk ,0+4) ;
1611: }
1612: return( 04 );
1613: }
1614:
1615:
1616: blkerr(s,blk)
1617: daddr_t blk;
1618: char *s;
1619: {
1620: pfatal("%ld %s I=%u",blk,s,inum);
1621: printf("\n");
1622: dostate( 03 ,0) ;
1623: }
1624:
1625:
1626: descend()
1627: {
1628: register DINODE *dp;
1629: register char *savname;
1630: off_t savsize;
1631:
1632: dostate( 01 ,0) ;
1633: if((dp = ginode()) == 0 )
1634: return;
1635: savname = thisname;
1636: *pathp++ = '/';
1637: savsize = filsize;
1638: filsize = dp->di_size;
1639: ckinode(dp, 1 );
1640: thisname = savname;
1641: *--pathp = 0;
1642: filsize = savsize;
1643: }
1644:
1645:
1646: dirscan(blk)
1647: daddr_t blk;
1648: {
1649: register DIRECT *dirp;
1650: register char *p1, *p2;
1651: register n;
1652: DIRECT direntry;
1653:
1654: if( ( blk < fmin || blk >= fmax) ) {
1655: filsize -= ( (( big ) & 64) ? 4096: 1024) ;
1656: return( 02 );
1657: }
1658: for(dirp = fileblk.b_un .b_dir; dirp < & fileblk.b_un .b_dir[ ( ( (( big ) & 64) ? 4096: 1024) /sizeof(struct direct)) ] &&
1659: filsize > 0; dirp++, filsize -= sizeof(DIRECT)) {
1660: if(getblk(&fileblk,blk) == 0 ) {
1661: filsize -= (& fileblk.b_un .b_dir[ ( ( (( big ) & 64) ? 4096: 1024) /sizeof(struct direct)) ]-dirp)*
1662: sizeof(DIRECT);
1663: return( 02 );
1664: }
1665: p1 = &dirp->d_name[ 14 ];
1666: p2 = &direntry.d_name[ 14 ];
1667: while(p1 > (char *)dirp)
1668: *--p2 = *--p1;
1669: if((n = (*pfunc)(&direntry)) & 010 ) {
1670: if(getblk(&fileblk,blk) != 0 ) {
1671: p1 = &dirp->d_name[ 14 ];
1672: p2 = &direntry.d_name[ 14 ];
1673: while(p1 > (char *)dirp)
1674: *--p1 = *--p2;
1675: fileblk.b_dirty = 1 ;
1676: }
1677: else
1678: n &= ~ 010 ;
1679: }
1680: if(n & 01 )
1681: return(n);
1682: }
1683: return(filsize > 0 ? 04 : 01 );
1684: }
1685:
1686:
1687: direrr(s)
1688: char *s;
1689: {
1690: register DINODE *dp;
1691:
1692: pwarn("%s ",s);
1693: pinode();
1694: printf("\n");
1695: if((dp = ginode()) != 0 && ftypeok(dp))
1696: pfatal("%s=%s", ((dp->di_mode & 0170000 ) == 0040000 ) ?"DIR":"FILE",pathname);
1697: else
1698: pfatal("NAME=%s",pathname);
1699: return(reply("REMOVE"));
1700: }
1701:
1702:
1703: adjust(lcnt)
1704: register short lcnt;
1705: {
1706: register DINODE *dp;
1707:
1708: if((dp = ginode()) == 0 )
1709: return;
1710: if(dp->di_nlink == lcnt) {
1711: if(linkup() == 0 )
1712: clri("UNREF", 0 , 0 );
1713: }
1714: else {
1715: pwarn("LINK COUNT %s",
1716: (lfdir==inum)?lfname:( ((dp->di_mode & 0170000 ) == 0040000 ) ?"DIR":"FILE"));
1717: pinode();
1718: printf(" COUNT %d SHOULD BE %d",
1719: dp->di_nlink,dp->di_nlink-lcnt);
1720: if (preen) {
1721: if (lcnt < 0) {
1722: printf("\n");
1723: preendie();
1724: }
1725: printf(" (ADJUSTED)\n");
1726: }
1727: if(preen || reply("ADJUST") == 1 ) {
1728: dp->di_nlink -= lcnt;
1729: inoblk.b_dirty = 1 ;
1730: }
1731: }
1732: }
1733:
1734:
1735: clri(s,flg,jclr)
1736: char *s;
1737: {
1738: register DINODE *dp;
1739:
1740: if((dp = ginode()) == 0 )
1741: return;
1742: if(flg == 1 ) {
1743: pwarn("%s %s",s, ((dp->di_mode & 0170000 ) == 0040000 ) ?"DIR":"FILE");
1744: pinode();
1745: }
1746: if(preen || reply("CLEAR") == 1 ) {
1747: if (preen)
1748: if (jclr == 1 )
1749: zcleared++;
1750: else
1751: printf(" (CLEARED)\n");
1752: n_files--;
1753: pfunc = pass4;
1754: ckinode(dp, 0 );
1755: clear((char *)( dp ),sizeof(DINODE)) ;
1756: inoblk.b_dirty = 1 ;
1757: }
1758: }
1759:
1760:
1761: setup(dev)
1762: char *dev;
1763: {
1764: register n;
1765: register BUFAREA *bp;
1766: register MEMSIZE msize;
1767: char *mbase;
1768: daddr_t bcnt, nscrblk;
1769: dev_t rootdev;
1770: off_t smapsz, lncntsz, totsz;
1771: struct stat statarea;
1772:
1773: if(stat("/",&statarea) < 0)
1774: errexit("Can't stat root\n");
1775: rootdev = statarea.st_dev;
1776: if(stat(dev,&statarea) < 0) {
1777: error("Can't stat %s\n",dev);
1778: return( 0 );
1779: }
1780: rawflg = 0;
1781: big = 0 ;
1782: if((statarea.st_mode & 0170000 ) == 0060000 ) {
1783: if( (( statarea.st_rdev ) & 64) )
1784: big = 64 ;
1785: }
1786: else if((statarea.st_mode & 0170000 ) == 0020000 )
1787: rawflg++;
1788: else {
1789: if (reply("file is not a block or character device; OK") == 0 )
1790: return( 0 );
1791: }
1792: if(rootdev == statarea.st_rdev)
1793: hotroot++;
1794: if((dfile.rfdes = open(dev,0)) < 0) {
1795: error("Can't open %s\n",dev);
1796: return( 0 );
1797: }
1798: if (preen == 0)
1799: printf("\n%s",dev);
1800: if(nflag || (dfile.wfdes = open(dev,1)) < 0) {
1801: dfile.wfdes = -1;
1802: if (preen)
1803: pfatal("NO WRITE ACCESS");
1804: printf(" (NO WRITE)");
1805: }
1806: if (preen == 0)
1807: printf("\n");
1808: fixfree = 0;
1809: dfile.mod = 0;
1810: n_files = n_blks = n_free = 0;
1811: muldup = enddup = &duplist[0];
1812: badlnp = &badlncnt[0];
1813: lfdir = 0;
1814: rplyflag = 0;
1815: ( &sblk )->b_dirty = 0;( &sblk )->b_bno = (daddr_t)-1 ;
1816: ( &fileblk )->b_dirty = 0;( &fileblk )->b_bno = (daddr_t)-1 ;
1817: ( &inoblk )->b_dirty = 0;( &inoblk )->b_bno = (daddr_t)-1 ;
1818: sfile.wfdes = sfile.rfdes = -1;
1819: rmscr = 0;
1820: if(getblk(&sblk, ((daddr_t)1) ) == 0 ) {
1821: ckfini();
1822: return( 0 );
1823: }
1824: imax = ((ino_t) sblk.b_un.b_fs .s_isize - ( ((daddr_t)1) +1)) * ( (( big ) & 64) ? 64: 16) ;
1825: fmin = (daddr_t) sblk.b_un.b_fs .s_isize;
1826: fmax = sblk.b_un.b_fs .s_fsize;
1827: if(fmin >= fmax ||
1828: (imax/ ( (( big ) & 64) ? 64: 16) ) != ((ino_t) sblk.b_un.b_fs .s_isize-( ((daddr_t)1) +1))) {
1829: pfatal("Size check: fsize %ld isize %d",
1830: sblk.b_un.b_fs .s_fsize, sblk.b_un.b_fs .s_isize);
1831: printf("\n");
1832: ckfini();
1833: return( 0 );
1834: }
1835: if (preen == 0)
1836: printf("File System: %.12s\n\n", sblk.b_un.b_fs .s_fsmnt);
1837: bmapsz = (((( ((( fmax )+(( 8 )-1))/( 8 )) )+(( sizeof(*lncntp) )-1))/( sizeof(*lncntp) ))*( sizeof(*lncntp) )) ;
1838: smapsz = (((( ((( (long)(imax+1) )+(( ( 8 / 2 ) )-1))/( ( 8 / 2 ) )) )+(( sizeof(*lncntp) )-1))/( sizeof(*lncntp) ))*( sizeof(*lncntp) )) ;
1839: lncntsz = (long)(imax+1) * sizeof(*lncntp);
1840: if(bmapsz > smapsz+lncntsz)
1841: smapsz = bmapsz-lncntsz;
1842: totsz = bmapsz+smapsz+lncntsz;
1843: msize = memsize;
1844: mbase = membase;
1845: if(rawflg) {
1846: if(msize < (MEMSIZE)( 11 * ( (( big ) & 64) ? 4096: 1024) ) + 2*sizeof(BUFAREA))
1847: rawflg = 0;
1848: else {
1849: msize -= (MEMSIZE) 11 * ( (( big ) & 64) ? 4096: 1024) ;
1850: mbase += (MEMSIZE) 11 * ( (( big ) & 64) ? 4096: 1024) ;
1851: niblk = 11 ;
1852: startib = fmax;
1853: }
1854: }
1855: clear(mbase,msize);
1856: if((off_t)msize < totsz) {
1857: bmapsz = (((( bmapsz )+(( ( (( big ) & 64) ? 4096: 1024) )-1))/( ( (( big ) & 64) ? 4096: 1024) ))*( ( (( big ) & 64) ? 4096: 1024) )) ;
1858: smapsz = (((( smapsz )+(( ( (( big ) & 64) ? 4096: 1024) )-1))/( ( (( big ) & 64) ? 4096: 1024) ))*( ( (( big ) & 64) ? 4096: 1024) )) ;
1859: lncntsz = (((( lncntsz )+(( ( (( big ) & 64) ? 4096: 1024) )-1))/( ( (( big ) & 64) ? 4096: 1024) ))*( ( (( big ) & 64) ? 4096: 1024) )) ;
1860: nscrblk = (bmapsz+smapsz+lncntsz)>> ( (( big ) & 64) ? 12: 10) ;
1861: if(tflag == 0) {
1862: printf("\nNEED SCRATCH FILE (%ld BLKS)\n",nscrblk);
1863: do {
1864: printf("ENTER FILENAME: ");
1865: if((n = getline( (&_iob[0]) ,scrfile,sizeof(scrfile))) == (-1) )
1866: errexit("\n");
1867: } while(n == 0);
1868: }
1869: if(stat(scrfile,&statarea) < 0 ||
1870: (statarea.st_mode & 0170000 ) == 0100000 )
1871: rmscr++;
1872: if((sfile.wfdes = creat(scrfile,0666)) < 0 ||
1873: (sfile.rfdes = open(scrfile,0)) < 0) {
1874: error("Can't create %s\n",scrfile);
1875: ckfini();
1876: return( 0 );
1877: }
1878: bp = &((BUFAREA *)mbase)[(msize/sizeof(BUFAREA))];
1879: poolhead = 0 ;
1880: while(--bp >= (BUFAREA *)mbase) {
1881: ( bp )->b_dirty = 0;( bp )->b_bno = (daddr_t)-1 ;
1882: bp->b_next = poolhead;
1883: poolhead = bp;
1884: }
1885: bp = poolhead;
1886: for(bcnt = 0; bcnt < nscrblk; bcnt++) {
1887: bp->b_bno = bcnt;
1888: ( bp )->b_dirty = 1 ;
1889: flush(&sfile,bp);
1890: }
1891: blkmap = freemap = statemap = (char *) 0 ;
1892: lncntp = (short *) 0 ;
1893: smapblk = bmapsz / ( (( big ) & 64) ? 4096: 1024) ;
1894: lncntblk = smapblk + smapsz / ( (( big ) & 64) ? 4096: 1024) ;
1895: fmapblk = smapblk;
1896: }
1897: else {
1898: if(rawflg && (off_t)msize > totsz+ ( (( big ) & 64) ? 4096: 1024) ) {
1899: niblk += (unsigned)((off_t)msize-totsz)>> ( (( big ) & 64) ? 12: 10) ;
1900: if(niblk > 110 )
1901: niblk = 110 ;
1902: msize = memsize - (niblk* ( (( big ) & 64) ? 4096: 1024) );
1903: mbase = membase + (niblk* ( (( big ) & 64) ? 4096: 1024) );
1904: }
1905: poolhead = 0 ;
1906: blkmap = mbase;
1907: statemap = &mbase[(MEMSIZE)bmapsz];
1908: freemap = statemap;
1909: lncntp = (short *)&statemap[(MEMSIZE)smapsz];
1910: }
1911: return( 1 );
1912: }
1913:
1914:
1915: DINODE *
1916: ginode()
1917: {
1918: register DINODE *dp;
1919: register char *mbase;
1920: daddr_t iblk;
1921:
1922: if(inum > imax)
1923: return( 0 );
1924: iblk = ((daddr_t)((((unsigned)( inum )+2* ( (( big ) & 64) ? 64: 16) -1)/ ( (( big ) & 64) ? 64: 16) ))) ;
1925: if(rawflg) {
1926: mbase = membase;
1927: if(iblk < startib || iblk >= startib+niblk) {
1928: if(inoblk.b_dirty)
1929: bwrite(&dfile,mbase,startib,(int)niblk* ( (( big ) & 64) ? 4096: 1024) );
1930: inoblk.b_dirty = 0;
1931: if(bread(&dfile,mbase,iblk,(int)niblk* ( (( big ) & 64) ? 4096: 1024) ) == 0 ) {
1932: startib = fmax;
1933: return( 0 );
1934: }
1935: startib = iblk;
1936: }
1937: dp = (DINODE *)&mbase[(unsigned)((iblk-startib)<< ( (( big ) & 64) ? 12: 10) )];
1938: }
1939: else if(getblk(&inoblk,iblk) != 0 )
1940: dp = inoblk.b_un.b_dinode;
1941: else
1942: return( 0 );
1943: return(dp + ((int)((( inum )+2* ( (( big ) & 64) ? 64: 16) -1)% ( (( big ) & 64) ? 64: 16) )) );
1944: }
1945:
1946:
1947: ftypeok(dp)
1948: DINODE *dp;
1949: {
1950: switch(dp->di_mode & 0170000 ) {
1951: case 0040000 :
1952: case 0100000 :
1953: case 0060000 :
1954: case 0020000 :
1955:
1956: case 0120000 :
1957:
1958: return( 1 );
1959: default:
1960: return( 0 );
1961: }
1962: }
1963:
1964:
1965: reply(s)
1966: char *s;
1967: {
1968: char line[80];
1969:
1970: if (preen)
1971: pfatal("INTERNAL ERROR: GOT TO reply()");
1972: rplyflag = 1;
1973: printf("\n%s? ",s);
1974: if(nflag || csflag || dfile.wfdes < 0) {
1975: printf(" no\n\n");
1976: return( 0 );
1977: }
1978: if(yflag) {
1979: printf(" yes\n\n");
1980: return( 1 );
1981: }
1982: if(getline( (&_iob[0]) ,line,sizeof(line)) == (-1) )
1983: errexit("\n");
1984: printf("\n");
1985: if(line[0] == 'y' || line[0] == 'Y')
1986: return( 1 );
1987: else
1988: return( 0 );
1989: }
1990:
1991:
1992: getline(fp,loc,maxlen)
1993: struct _iobuf *fp;
1994: char *loc;
1995: {
1996: register n;
1997: register char *p, *lastloc;
1998:
1999: p = loc;
2000: lastloc = &p[maxlen-1];
2001: while((n = (--( fp )->_cnt>=0? (int)*( fp )->_ptr++:_filbuf( fp )) ) != '\n') {
2002: if(n == (-1) )
2003: return( (-1) );
2004: if(! ((_ctype+1)[ n ]& 010 ) && p < lastloc)
2005: *p++ = n;
2006: }
2007: *p = 0;
2008: return(p - loc);
2009: }
2010:
2011:
2012: stype(p)
2013: register char *p;
2014: {
2015: if(*p == 0)
2016: return;
2017: cylsize = atoi(p);
2018: while(*p && *p != ':')
2019: p++;
2020: if(*p)
2021: p++;
2022: stepsize = atoi(p);
2023: if(stepsize <= 0 || stepsize > cylsize ||
2024: cylsize <= 0 || cylsize > 1000 ) {
2025: error("Invalid -s argument, defaults assumed\n");
2026: cylsize = stepsize = 0;
2027: }
2028: }
2029:
2030:
2031: dostate(s,flg)
2032: {
2033: register char *p;
2034: register unsigned byte, shift;
2035: BUFAREA *bp;
2036:
2037: byte = (inum)/ ( 8 / 2 ) ;
2038: shift = 2 * ((inum)% ( 8 / 2 ) );
2039: if(statemap != 0 ) {
2040: bp = 0 ;
2041: p = &statemap[byte];
2042: }
2043: else if((bp = getblk((BUFAREA *) 0 ,
2044: (daddr_t)(smapblk+(byte/ ( (( big ) & 64) ? 4096: 1024) )))) == 0 )
2045: errexit("Fatal I/O error\n");
2046: else
2047: p = &bp->b_un.b_buf[byte% ( (( big ) & 64) ? 4096: 1024) ];
2048: switch(flg) {
2049: case 0:
2050: *p &= ~( 03 <<(shift));
2051: *p |= s<<(shift);
2052: if(bp != 0 )
2053: ( bp )->b_dirty = 1 ;
2054: return(s);
2055: case 1:
2056: return((*p>>(shift)) & 03 );
2057: }
2058: return( 0 );
2059: }
2060:
2061:
2062: domap(blk,flg)
2063: daddr_t blk;
2064: {
2065: register char *p;
2066: register unsigned n;
2067: register BUFAREA *bp;
2068: off_t byte;
2069:
2070: byte = blk >> 3 ;
2071: n = 1<<((unsigned)(blk & 07 ));
2072: if(flg & 04) {
2073: p = freemap;
2074: blk = fmapblk;
2075: }
2076: else {
2077: p = blkmap;
2078: blk = 0;
2079: }
2080: if(p != 0 ) {
2081: bp = 0 ;
2082: p += (unsigned)byte;
2083: }
2084: else if((bp = getblk((BUFAREA *) 0 ,blk+(byte>> ( (( big ) & 64) ? 12: 10) ))) == 0 )
2085: errexit("Fatal I/O error\n");
2086: else
2087: p = &bp->b_un.b_buf[(unsigned)(byte& ( (( big ) & 64) ? 07777: 01777) )];
2088: switch(flg&03) {
2089: case 0:
2090: *p |= n;
2091: break;
2092: case 1:
2093: n &= *p;
2094: bp = 0 ;
2095: break;
2096: case 2:
2097: *p &= ~n;
2098: }
2099: if(bp != 0 )
2100: ( bp )->b_dirty = 1 ;
2101: return(n);
2102: }
2103:
2104:
2105: dolncnt(val,flg)
2106: short val;
2107: {
2108: register short *sp;
2109: register BUFAREA *bp;
2110:
2111: if(lncntp != 0 ) {
2112: bp = 0 ;
2113: sp = &lncntp[inum];
2114: }
2115: else if((bp = getblk((BUFAREA *) 0 ,(daddr_t)(lncntblk+(inum/ ( ( (( big ) & 64) ? 4096: 1024) /sizeof(short)) )))) == 0 )
2116: errexit("Fatal I/O error\n");
2117: else
2118: sp = &bp->b_un.b_lnks[inum% ( ( (( big ) & 64) ? 4096: 1024) /sizeof(short)) ];
2119: switch(flg) {
2120: case 0:
2121: *sp = val;
2122: break;
2123: case 1:
2124: bp = 0 ;
2125: break;
2126: case 2:
2127: (*sp)--;
2128: }
2129: if(bp != 0 )
2130: ( bp )->b_dirty = 1 ;
2131: return(*sp);
2132: }
2133:
2134:
2135: BUFAREA *
2136: getblk(bp,blk)
2137: daddr_t blk;
2138: register BUFAREA *bp;
2139: {
2140: register struct filecntl *fcp;
2141:
2142: if(bp == 0 ) {
2143: bp = search(blk);
2144: fcp = &sfile;
2145: }
2146: else
2147: fcp = &dfile;
2148: if(bp->b_bno == blk)
2149: return(bp);
2150: flush(fcp,bp);
2151: if(bread(fcp,bp->b_un.b_buf,blk, ( (( big ) & 64) ? 4096: 1024) ) != 0 ) {
2152: bp->b_bno = blk;
2153: return(bp);
2154: }
2155: bp->b_bno = (daddr_t)-1;
2156: return( 0 );
2157: }
2158:
2159:
2160: flush(fcp,bp)
2161: struct filecntl *fcp;
2162: register BUFAREA *bp;
2163: {
2164: if(bp->b_dirty) {
2165: bwrite(fcp,bp->b_un.b_buf,bp->b_bno, ( (( big ) & 64) ? 4096: 1024) );
2166: }
2167: bp->b_dirty = 0;
2168: }
2169:
2170:
2171: rwerr(s,blk)
2172: char *s;
2173: daddr_t blk;
2174: {
2175: if (preen == 0)
2176: printf("\n");
2177: pfatal("CAN NOT %s: BLK %ld",s,blk);
2178: if(reply("CONTINUE") == 0 )
2179: errexit("Program terminated\n");
2180: }
2181:
2182:
2183: sizechk(dp)
2184: register DINODE *dp;
2185: {
2186:
2187: #line 1559 "fsck.c"
2188: if( ((dp->di_mode & 0170000 ) == 0040000 ) && (dp->di_size % sizeof(DIRECT)) != 0) {
2189: pwarn("DIRECTORY MISALIGNED I=%u\n",inum);
2190: if (preen == 0)
2191: printf("\n");
2192: }
2193: }
2194:
2195:
2196: ckfini()
2197: {
2198: flush(&dfile,&fileblk);
2199: flush(&dfile,&sblk);
2200: flush(&dfile,&inoblk);
2201: close(dfile.rfdes);
2202: close(dfile.wfdes);
2203: close(sfile.rfdes);
2204: close(sfile.wfdes);
2205: if(rmscr) {
2206: unlink(scrfile);
2207: }
2208: }
2209:
2210:
2211: pinode()
2212: {
2213: register DINODE *dp;
2214: register char *p;
2215: struct passwd *passwd;
2216: char *ctime();
2217:
2218: printf(" I=%u ",inum);
2219: if((dp = ginode()) == 0 )
2220: return;
2221: printf(" OWNER=");
2222: if((passwd = getpwuid((int)dp->di_uid)) != 0) {
2223: printf("%s ", passwd->pw_name);
2224: }
2225: else {
2226: printf("%d ",dp->di_uid);
2227: }
2228: printf("MODE=%o\n",dp->di_mode);
2229: if (preen)
2230: printf("%s: ", devname);
2231: printf("SIZE=%ld ",dp->di_size);
2232: p = ctime(&dp->di_mtime);
2233: printf("MTIME=%12.12s %4.4s ",p+4,p+20);
2234: }
2235:
2236:
2237: copy(fp,tp,size)
2238: register char *tp, *fp;
2239: MEMSIZE size;
2240: {
2241: while(size--)
2242: *tp++ = *fp++;
2243: }
2244:
2245:
2246: freechk()
2247: {
2248: register daddr_t *ap;
2249: register int i, j;
2250:
2251: if(big == 64 ) {
2252: for(i = sblk.b_un.b_fs .s_isize; i < sblk.b_un.b_fs .s_fsize; i++) {
2253: j = i - sblk.b_un.b_fs .s_isize;
2254: if(! domap( i ,1+4) ) {
2255: sblk.b_un.b_fs . U.B.S_bfree [j>>5] |= (1 << (j&31));
2256: n_free++;
2257: }
2258: else
2259: sblk.b_un.b_fs . U.B.S_bfree [j>>5] &= ~(1 << (j&31));
2260: }
2261: sblk.b_un.b_fs . U.B.S_valid = 1;
2262: sblk.b_un.b_fs .s_tfree = n_free;
2263: sblk.b_dirty = 1 ;
2264: return;
2265: }
2266: if( fileblk.b_un.b_fb .df_nfree == 0)
2267: return;
2268: do {
2269: if( fileblk.b_un.b_fb .df_nfree <= 0 || fileblk.b_un.b_fb .df_nfree > 178 ) {
2270: pwarn("BAD FREEBLK COUNT");
2271: printf("\n");
2272: fixfree = 1;
2273: return;
2274: }
2275: ap = & fileblk.b_un.b_fb .df_free[ fileblk.b_un.b_fb .df_nfree];
2276: while(--ap > & fileblk.b_un.b_fb .df_free[0]) {
2277: if(pass5(*ap) == 01 )
2278: return;
2279: }
2280: if(*ap == (daddr_t)0 || pass5(*ap) != 04 )
2281: return;
2282: } while(getblk(&fileblk,*ap) != 0 );
2283: }
2284:
2285:
2286: makefree()
2287: {
2288: register i, cyl, step;
2289: int j;
2290: char flg[ 1000 ];
2291: short addr[ 1000 ];
2292: daddr_t blk, baseblk;
2293:
2294: if(big == 64 )
2295: return;
2296: sblk.b_un.b_fs . U.R.S_nfree = 0;
2297: sblk.b_un.b_fs .s_flock = 0;
2298: sblk.b_un.b_fs .s_fmod = 0;
2299: sblk.b_un.b_fs .s_tfree = 0;
2300: sblk.b_un.b_fs .s_ninode = 0;
2301: sblk.b_un.b_fs .s_ilock = 0;
2302: sblk.b_un.b_fs .s_ronly = 0;
2303: if(cylsize == 0 || stepsize == 0) {
2304: step = sblk.b_un.b_fs .s_dinfo[0];
2305: cyl = sblk.b_un.b_fs .s_dinfo[1];
2306: }
2307: else {
2308: step = stepsize;
2309: cyl = cylsize;
2310: }
2311: if(step > cyl || step <= 0 || cyl <= 0 || cyl > 1000 ) {
2312: error("Default free list spacing assumed\n");
2313: step = 9 ;
2314: cyl = 400 ;
2315: }
2316: sblk.b_un.b_fs .s_dinfo[0] = step;
2317: sblk.b_un.b_fs .s_dinfo[1] = cyl;
2318: clear(flg,sizeof(flg));
2319: i = 0;
2320: for(j = 0; j < cyl; j++) {
2321: while(flg[i])
2322: i = (i + 1) % cyl;
2323: addr[j] = i + 1;
2324: flg[i]++;
2325: i = (i + step) % cyl;
2326: }
2327: baseblk = (daddr_t) (((( fmax )+(( cyl )-1))/( cyl ))*( cyl )) ;
2328: clear((char *)& fileblk.b_un.b_fb , ( (( big ) & 64) ? 4096: 1024) );
2329: fileblk.b_un.b_fb .df_nfree++;
2330: for( ; baseblk > 0; baseblk -= cyl)
2331: for(i = 0; i < cyl; i++) {
2332: blk = baseblk - addr[i];
2333: if(! ( blk < fmin || blk >= fmax) && ! domap( blk ,1) ) {
2334: sblk.b_un.b_fs .s_tfree++;
2335: if( fileblk.b_un.b_fb .df_nfree >= 178 ) {
2336: fileblk.b_dirty = 1 ;
2337: fileblk.b_bno = blk;
2338: flush(&dfile,&fileblk);
2339: clear((char *)& fileblk.b_un.b_fb , ( (( big ) & 64) ? 4096: 1024) );
2340: }
2341: fileblk.b_un.b_fb .df_free[ fileblk.b_un.b_fb .df_nfree] = blk;
2342: fileblk.b_un.b_fb .df_nfree++;
2343: }
2344: }
2345: sblk.b_un.b_fs . U.R.S_nfree = fileblk.b_un.b_fb .df_nfree;
2346: for(i = 0; i < 178 ; i++)
2347: sblk.b_un.b_fs . U.R.S_free [i] = fileblk.b_un.b_fb .df_free[i];
2348: sblk.b_dirty = 1 ;
2349: }
2350:
2351:
2352: clear(p,cnt)
2353: register char *p;
2354: MEMSIZE cnt;
2355: {
2356: while(cnt--)
2357: *p++ = 0;
2358: }
2359:
2360:
2361: BUFAREA *
2362: search(blk)
2363: daddr_t blk;
2364: {
2365: register BUFAREA *pbp, *bp;
2366:
2367: for(bp = (BUFAREA *) &poolhead; bp->b_next; ) {
2368: pbp = bp;
2369: bp = pbp->b_next;
2370: if(bp->b_bno == blk)
2371: break;
2372: }
2373: pbp->b_next = bp->b_next;
2374: bp->b_next = poolhead;
2375: poolhead = bp;
2376: return(bp);
2377: }
2378:
2379:
2380: findino(dirp)
2381: register DIRECT *dirp;
2382: {
2383: register char *p1, *p2;
2384:
2385: if(dirp->d_ino == 0)
2386: return( 04 );
2387: for(p1 = dirp->d_name,p2 = srchname;*p2++ == *p1; p1++) {
2388: if(*p1 == 0 || p1 == &dirp->d_name[ 14 -1]) {
2389: if(dirp->d_ino > 0 && dirp->d_ino <= imax)
2390: parentdir = dirp->d_ino;
2391: return( 01 );
2392: }
2393: }
2394: return( 04 );
2395: }
2396:
2397:
2398: mkentry(dirp)
2399: register DIRECT *dirp;
2400: {
2401: register ino_t in;
2402: register char *p;
2403:
2404: if(dirp->d_ino)
2405: return( 04 );
2406: dirp->d_ino = orphan;
2407: in = orphan;
2408: p = &dirp->d_name[8];
2409: *--p = 0;
2410: while(p > dirp->d_name) {
2411: *--p = (in % 10) + '0';
2412: in /= 10;
2413: }
2414: *p = '#';
2415: return( 010 | 01 );
2416: }
2417:
2418:
2419: chgdd(dirp)
2420: register DIRECT *dirp;
2421: {
2422: if(dirp->d_name[0] == '.' && dirp->d_name[1] == '.' &&
2423: dirp->d_name[2] == 0) {
2424: dirp->d_ino = lfdir;
2425: return( 010 | 01 );
2426: }
2427: return( 04 );
2428: }
2429:
2430:
2431: linkup()
2432: {
2433: register DINODE *dp;
2434: register lostdir;
2435: register ino_t pdir;
2436:
2437: if((dp = ginode()) == 0 )
2438: return( 0 );
2439: lostdir = ((dp->di_mode & 0170000 ) == 0040000 ) ;
2440: pdir = parentdir;
2441: if (preen && dp->di_size == 0)
2442: return( 0 );
2443: pwarn("UNREF %s ",lostdir ? "DIR" : "FILE");
2444: pinode();
2445: if (preen)
2446: printf(" (RECONNECTED)\n");
2447: else
2448: if (reply("RECONNECT") == 0 )
2449: return( 0 );
2450: orphan = inum;
2451: if(lfdir == 0) {
2452: inum = ((ino_t)2) ;
2453: if((dp = ginode()) == 0 ) {
2454: inum = orphan;
2455: return( 0 );
2456: }
2457: pfunc = findino;
2458: srchname = lfname;
2459: filsize = dp->di_size;
2460: parentdir = 0;
2461: ckinode(dp, 1 );
2462: inum = orphan;
2463: if((lfdir = parentdir) == 0) {
2464: pfatal("SORRY. NO lost+found DIRECTORY");
2465: printf("\n\n");
2466: return( 0 );
2467: }
2468: }
2469: inum = lfdir;
2470: if((dp = ginode()) == 0 || ! ((dp->di_mode & 0170000 ) == 0040000 ) || dostate(0,1) != 01 ) {
2471: inum = orphan;
2472: pfatal("SORRY. NO lost+found DIRECTORY");
2473: printf("\n\n");
2474: return( 0 );
2475: }
2476: if(dp->di_size & ( (( big ) & 64) ? 07777: 01777) ) {
2477: dp->di_size = (((( dp->di_size )+(( ( (( big ) & 64) ? 4096: 1024) )-1))/( ( (( big ) & 64) ? 4096: 1024) ))*( ( (( big ) & 64) ? 4096: 1024) )) ;
2478: inoblk.b_dirty = 1 ;
2479: }
2480: filsize = dp->di_size;
2481: inum = orphan;
2482: pfunc = mkentry;
2483: if((ckinode(dp, 1 ) & 010 ) == 0) {
2484: pfatal("SORRY. NO SPACE IN lost+found DIRECTORY");
2485: printf("\n\n");
2486: return( 0 );
2487: }
2488: dolncnt(0,2) ;
2489: if(lostdir) {
2490: pfunc = chgdd;
2491: dp = ginode();
2492: filsize = dp->di_size;
2493: ckinode(dp, 1 );
2494: inum = lfdir;
2495: if((dp = ginode()) != 0 ) {
2496: dp->di_nlink++;
2497: inoblk.b_dirty = 1 ;
2498: dolncnt( dolncnt(0,1) +1 ,0) ;
2499: }
2500: inum = orphan;
2501: pwarn("DIR I=%u CONNECTED. ",orphan);
2502: printf("PARENT WAS I=%u\n",pdir);
2503: if (preen == 0)
2504: printf("\n");
2505: }
2506: return( 1 );
2507: }
2508:
2509:
2510: bread(fcp,buf,blk,size)
2511: daddr_t blk;
2512: register struct filecntl *fcp;
2513: register size;
2514: char *buf;
2515: {
2516: if(lseek(fcp->rfdes,blk<< ( (( big ) & 64) ? 12: 10) ,0) < 0)
2517: rwerr("SEEK",blk);
2518: else if(read(fcp->rfdes,buf,size) == size)
2519: return( 1 );
2520: rwerr("READ",blk);
2521: return( 0 );
2522: }
2523:
2524:
2525: bwrite(fcp,buf,blk,size)
2526: daddr_t blk;
2527: register struct filecntl *fcp;
2528: register size;
2529: char *buf;
2530: {
2531: if(fcp->wfdes < 0)
2532: return( 0 );
2533: if(lseek(fcp->wfdes,blk<< ( (( big ) & 64) ? 12: 10) ,0) < 0)
2534: rwerr("SEEK",blk);
2535: else if(write(fcp->wfdes,buf,size) == size) {
2536: fcp->mod = 1;
2537: return( 1 );
2538: }
2539: rwerr("WRITE",blk);
2540: return( 0 );
2541: }
2542:
2543: catch()
2544: {
2545: ckfini();
2546: exit(12);
2547: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.