![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsck.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd|
Return to fsck.c CVS log | Up to [Research Unix] / researchv10no / cmd |
1.1 root 1: #define BITFS(x) (1)
2: #ifdef notdef
3: #define SMALL 0 /* 1k file systems */
4: #endif
5: /* #include <ansi.h> */
6: /* #include <posix.h> */
7: #include <pwd.h>
8: #include <stdio.h>
9: #include <ctype.h>
10: #include <sys/param.h>
11: #ifdef SMALL
12: #include <sys/fblk.h>
13: #endif
14: #include <sys/filsys.h>
15: #include <sys/dir.h>
16: /* #include <sys/dinode.h> */
17: #include <sys/fblk.h>
18: #include <sys/ino.h>
19: #include <sys/inode.h>
20: /* #include <sys/stat.h> */
21: #include <stat.h>
22: #include <fstab.h>
23:
24: #define BIG 64 /* 4k file systems */
25: #define BCOUNT BSIZE(BIG)
26: #define BITSPERBLK (BCOUNT*NBBY)
27: #define NDIRECT(x) (BSIZE(x)/sizeof(struct direct))
28: #define SPERB(x) (BSIZE(x)/sizeof(short))
29:
30: #define NO 0
31: #define YES 1
32:
33: #define MAXDUP 10 /* limit on dup blks (per inode) */
34: #define MAXBAD 10 /* limit on bad blks (per inode) */
35:
36: #define STEPSIZE 9 /* default step for freelist spacing */
37: #define CYLSIZE 400 /* default cyl size for spacing */
38: #define MAXCYL 1000 /* maximum cylinder size */
39:
40: #define BITSPB 8 /* number bits per byte */
41: #define BITSHIFT 3 /* log2(BITSPB) */
42: #define BITMASK 07 /* BITSPB-1 */
43: #define LSTATE 2 /* bits per inode state */
44: #define STATEPB (BITSPB/LSTATE) /* inode states per byte */
45: #define USTATE 0 /* inode not allocated */
46: #define FSTATE 01 /* inode is file */
47: #define DSTATE 02 /* inode is directory */
48: #define CLEAR 03 /* inode is to be cleared */
49: #define SMASK 03 /* mask for inode state */
50:
51: typedef struct dinode DINODE;
52: typedef struct direct DIRECT;
53:
54: #define ALLOC ((dp->di_mode & IFMT) != 0)
55: #define DIR ((dp->di_mode & IFMT) == IFDIR)
56: #define REG ((dp->di_mode & IFMT) == IFREG)
57: #define BLK ((dp->di_mode & IFMT) == IFBLK)
58: #define CHR ((dp->di_mode & IFMT) == IFCHR)
59: #define MPC ((dp->di_mode & IFMT) == IFMPC)
60: #define MPB ((dp->di_mode & IFMT) == IFMPB)
61: #define LNK ((dp->di_mode & IFMT) == IFLNK)
62: #define SPECIAL (BLK || CHR /* || MPC || MPB */ )
63:
64: #define NINOBLK 11 /* num blks for raw reading */
65: #define MAXRAW 110 /* largest raw read (in blks) */
66: daddr_t startib; /* blk num of first in raw area */
67: unsigned niblk; /* num of blks in raw area */
68:
69: struct bufarea {
70: struct bufarea *b_next; /* must be first */
71: daddr_t b_bno;
72: union {
73: char b_buf[BSIZE(BIG)]; /* buffer space */
74: short b_lnks[SPERB(BIG)]; /* link counts */
75: daddr_t b_indir[NINDIR(BIG)]; /* indirect block */
76: struct filsys b_fs; /* super block */
77: #ifdef SMALL
78: struct fblk b_fb; /* free block */
79: #endif
80: struct dinode b_dinode[INOPB(BIG)]; /* inode block */
81: DIRECT b_dir[NDIRECT(BIG)]; /* directory */
82: } b_un;
83: char b_dirty;
84: };
85:
86: typedef struct bufarea BUFAREA;
87:
88: BUFAREA inoblk; /* inode blocks */
89: BUFAREA fileblk; /* other blks in filesys */
90: BUFAREA sblk; /* file system superblock */
91: BUFAREA *poolhead; /* ptr to first buffer in pool */
92:
93: #define initbarea(x) (x)->b_dirty = 0;(x)->b_bno = (daddr_t)-1
94: #define dirty(x) (x)->b_dirty = 1
95: #define inodirty() inoblk.b_dirty = 1
96: #define fbdirty() fileblk.b_dirty = 1
97: #define sbdirty() sblk.b_dirty = 1
98:
99: #define freeblk fileblk.b_un.b_fb
100: #define dirblk fileblk.b_un
101: #define superblk sblk.b_un.b_fs
102:
103: struct filecntl {
104: int rfdes;
105: int wfdes;
106: int mod;
107: };
108:
109: struct filecntl dfile; /* file descriptors for filesys */
110: struct filecntl sfile; /* file descriptors for scratch file */
111:
112: typedef unsigned MEMSIZE;
113:
114: MEMSIZE memsize; /* amt of memory we got */
115: MEMSIZE minsize;
116: #ifdef pdp11
117: #define MAXDATA ((MEMSIZE)54*1024)
118: #endif
119: #ifdef vax
120: #define MAXDATA ((MEMSIZE)400*1024)
121: #endif
122: #ifdef interdata
123: #define MAXDATA ((MEMSIZE)400*1024)
124: #endif
125: #ifdef mips
126: #define MAXDATA (0x10000000+(MEMSIZE)400*1024) /* hack */
127: #endif
128: #ifndef MAXDATA
129: #define MAXDATA ((MEMSIZE)200*1024)
130: #endif
131:
132: #define DUPTBLSIZE 100 /* num of dup blocks to remember */
133: daddr_t duplist[DUPTBLSIZE]; /* dup block table */
134: daddr_t *enddup; /* next entry in dup table */
135: daddr_t *muldup; /* multiple dups part of table */
136:
137: #define MAXLNCNT 500 /* num zero link cnts to remember */
138: ino_t badlncnt[MAXLNCNT]; /* table of inos with zero link cnts */
139: ino_t *badlnp; /* next entry in table */
140:
141: char sflag; /* salvage free block list */
142: char csflag; /* salvage free block list (conditional) */
143: char nflag; /* assume a no response */
144: char yflag; /* assume a yes response */
145: char tflag; /* scratch file specified */
146: char preen; /* just fix normal inconsistencies */
147: char rplyflag; /* any questions asked? */
148: char hotroot; /* checking root device */
149: char rawflg; /* read raw device */
150: char rmscr; /* remove scratch file when done */
151: char fixfree; /* corrupted free list */
152: char *membase; /* base of memory we get */
153: long *bm_buf; /* ptr to bit map buffer area */
154: char *blkmap; /* ptr to primary blk allocation map */
155: char *freemap; /* ptr to secondary blk allocation map */
156: char *statemap; /* ptr to inode state table */
157: char *pathp; /* pointer to pathname position */
158: char *thisname; /* ptr to current pathname component */
159: char *srchname; /* name being searched for in dir */
160: char pathname[200];
161: char scrfile[80];
162: char *lfname = "lost+found";
163: char *checklist = FSTAB;
164: char big; /* it is a 4k file system */
165:
166: short *lncntp; /* ptr to link count table */
167:
168: int cylsize; /* num blocks per cylinder */
169: int stepsize; /* num blocks for spacing purposes */
170: int badblk; /* num of bad blks seen (per inode) */
171: int dupblk; /* num of dup blks seen (per inode) */
172: int (*pfunc)(); /* function to call to chk blk */
173: int zcleared; /* num of empty, linkless files cleared */
174:
175: ino_t inum; /* inode we are currently working on */
176: ino_t imax; /* number of inodes */
177: ino_t parentdir; /* i number of parent directory */
178: ino_t lastino; /* hiwater mark of inodes */
179: ino_t lfdir; /* lost & found directory */
180: ino_t orphan; /* orphaned inode */
181:
182: off_t filsize; /* num blks seen in file */
183: off_t maxblk; /* largest logical blk in file */
184: off_t bmapsz; /* num chars in blkmap */
185:
186: daddr_t smapblk; /* starting blk of state map */
187: daddr_t lncntblk; /* starting blk of link cnt table */
188: daddr_t fmapblk; /* starting blk of free map */
189: daddr_t n_free; /* number of free blocks */
190: daddr_t n_blks; /* number of blocks used */
191: daddr_t n_files; /* number of files seen */
192: daddr_t fmin; /* block number of the first data block */
193: daddr_t fmax; /* number of blocks in the volume */
194: daddr_t m_blks; /* number of bitmap blocks in the file system */
195:
196: #undef howmany
197: #undef roundup
198: #define howmany(x,y) (((x)+((y)-1))/(y))
199: #define roundup(x,y) ((((x)+((y)-1))/(y))*(y))
200: #define outrange(x) (x < fmin || x >= fmax)
201: #define zapino(x) clear((char *)(x),sizeof(DINODE))
202:
203: #define setlncnt(x) dolncnt(x,0)
204: #define getlncnt() dolncnt(0,1)
205: #define declncnt() dolncnt(0,2)
206:
207: #define setbmap(x) domap(x,0)
208: #define getbmap(x) domap(x,1)
209: #define clrbmap(x) domap(x,2)
210:
211: #define setfmap(x) domap(x,0+4)
212: #define getfmap(x) domap(x,1+4)
213: #define clrfmap(x) domap(x,2+4)
214:
215: #define setstate(x) dostate(x,0)
216: #define getstate() dostate(0,1)
217:
218: #define DATA 1
219: #define ADDR 0
220: #define ALTERD 010
221: #define KEEPON 04
222: #define SKIP 02
223: #define STOP 01
224:
225: DINODE *ginode();
226: BUFAREA *getblk();
227: BUFAREA *search();
228: int dirscan();
229: int findino();
230: void catch(int);
231: int mkentry();
232: int chgdd();
233: int pass1();
234: int pass1b();
235: int pass2();
236: int pass3();
237: int pass4();
238: int pass5();
239: void ltol3(char *, long *, int);
240: void l3tol(long *, char *, int);
241:
242: char *devname;
243:
244: main(argc,argv)
245: int argc;
246: char *argv[];
247: {
248: register FILE *fp;
249: register n;
250: register char *p;
251: char filename[50];
252: char *sbrk();
253:
254: setbuf(stdout, NULL);
255: sync();
256: while(--argc > 0 && **++argv == '-') {
257: switch(*++*argv) {
258: case 'p':
259: preen++;
260: break;
261: case 't':
262: case 'T':
263: tflag++;
264: if(**++argv == '-' || --argc <= 0)
265: errexit("Bad -t option\n");
266: p = scrfile;
267: while(*p++ = **argv)
268: (*argv)++;
269: break;
270: case 's': /* salvage flag */
271: stype(++*argv);
272: sflag++;
273: break;
274: case 'S': /* conditional salvage */
275: stype(++*argv);
276: csflag++;
277: break;
278: case 'n': /* default no answer flag */
279: case 'N':
280: nflag++;
281: yflag = 0;
282: break;
283: case 'y': /* default yes answer flag */
284: case 'Y':
285: yflag++;
286: nflag = 0;
287: break;
288: default:
289: errexit("%c option?\n",**argv);
290: }
291: }
292: if(nflag && (sflag || csflag))
293: errexit("Incompatible options: -n and -%s\n",sflag?"s":"S");
294: if(sflag && csflag)
295: sflag = 0;
296: memsize = (MEMSIZE)sbrk(0);
297: memsize = MAXDATA - memsize - sizeof(int);
298: minsize = 2*sizeof(BUFAREA)+BSIZE(BIG);
299: while(memsize >= minsize &&
300: (membase = sbrk(memsize)) == (char *)-1)
301: memsize -= 1024;
302: if(memsize < minsize)
303: errexit("Can't get memory\n");
304: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
305: signal(SIGINT, catch);
306: if(argc) { /* arg list has file names */
307: while(argc-- > 0){
308: hotroot = 0;
309: check(*argv++);
310: }
311: }
312: else { /* use default checklist */
313: struct fstab *fsp;
314: int pid, passno, anygtr, sumstatus = 0;
315: passno = 1;
316: do {
317: anygtr = 0;
318: if (setfsent() == 0)
319: errexit("Can't open checklist file: %s\n",
320: FSTAB);
321: while ( (fsp = getfsent()) != 0){
322: if (fsp->fs_ftype != 0) /* regular fs */
323: continue;
324: if (preen == 0 ||
325: passno == 1 && fsp->fs_passno == passno) {
326: if (blockcheck(fsp->fs_spec) == NO &&
327: preen)
328: exit(8);
329: } else if (fsp->fs_passno > passno)
330: anygtr = 1;
331: else if (fsp->fs_passno == passno) {
332: pid = fork();
333: if (pid < 0) {
334: perror("fork");
335: exit(8);
336: }
337: if (pid == 0)
338: if (blockcheck(fsp->fs_spec)==NO)
339: exit(8);
340: else
341: exit(0);
342: }
343: }
344: if (preen) {
345: int status;
346: while (wait(&status) != -1)
347: sumstatus |= status;
348: }
349: passno++;
350: } while (anygtr);
351: if (sumstatus)
352: exit(8);
353: endfsent();
354: }
355: exit(0);
356: }
357:
358: /* char *rawname(), *unrawname(); */
359: char *rawname(), *strrchr(), *unrawname();
360:
361: blockcheck(name)
362: char *name;
363: {
364: struct stat stat_slash, stat_block, stat_char;
365: char *raw;
366: int looped = 0;
367:
368: hotroot = 0;
369: if (stat("/", &stat_slash) < 0){
370: error("Can't stat root\n");
371: return(NO);
372: }
373: retry:
374: if (stat(name, &stat_block) < 0){
375: error("Can't stat %s\n", name);
376: return(NO);
377: }
378: big = BIG; /* 1k blocks by default */
379: if (S_ISBLK(stat_block.st_mode)){
380: if(BITFS(stat_block.st_rdev))
381: big = BIG; /* a 4k file system */
382: raw = rawname(name);
383: if (stat(raw, &stat_char) < 0){
384: error("Can't stat %s\n", raw);
385: return(NO);
386: }
387: if (S_ISCHR(stat_char.st_mode)){
388: if (stat_slash.st_dev == stat_block.st_rdev) {
389: hotroot++;
390: raw = unrawname(name);
391: }
392: check(raw);
393: return(YES);
394: } else if(big == BIG) {
395: check(name);
396: return(YES);
397: } else {
398: error("%s is not a character device\n", raw);
399: return(NO);
400: }
401: } else
402: if (S_ISCHR(stat_block.st_mode)){
403: if (looped) {
404: error("Can't make sense out of name %s\n", name);
405: return(NO);
406: }
407: name = unrawname(name);
408: looped++;
409: goto retry;
410: }
411: error("Can't make sense out of name %s\n", name);
412: return(NO);
413: }
414:
415: char *
416: unrawname(cp)
417: char *cp;
418: {
419: char *dp = strrchr(cp, '/');
420: struct stat stb;
421: if (dp == 0)
422: return(cp);
423: if (stat(cp, &stb) < 0)
424: return(cp);
425: if (S_ISCHR(stb.st_mode) == 0)
426: return(cp);
427: if (*(dp+1) != 'r')
428: return(cp);
429: strcpy(dp+1, dp+2);
430: return(cp);
431: }
432:
433: char *
434: rawname(cp)
435: char *cp;
436: {
437: static char rawbuf[32];
438: char *dp = strrchr(cp, '/');
439:
440: if (dp == 0)
441: return (0);
442: if(big == BIG)
443: return(cp);
444: *dp = 0;
445: strcpy(rawbuf, cp);
446: *dp = '/';
447: strcat(rawbuf, "/r");
448: strcat(rawbuf, dp+1);
449: return (rawbuf);
450: }
451:
452: check(dev)
453: char *dev;
454: {
455:
456: devname = dev;
457: check1(dev);
458: devname = 0;
459: }
460:
461: check1(dev)
462: char *dev;
463: {
464: register DINODE *dp;
465: register n;
466: register ino_t *blp;
467: ino_t savino;
468: daddr_t blk;
469: BUFAREA *bp1, *bp2;
470:
471: if(setup(dev) == NO)
472: return;
473: if (preen==0) {
474: printf("** Checking %s\n", dev);
475: printf("** Phase 1 - Check Blocks and Sizes\n");
476: }
477: pfunc = pass1;
478: for(inum = 1; inum <= imax; inum++) {
479: if((dp = ginode()) == NULL)
480: continue;
481: if(ALLOC) {
482: lastino = inum;
483: if(ftypeok(dp) == NO) {
484: pfatal("UNKNOWN FILE TYPE I=%u",inum);
485: if(reply("CLEAR") == YES) {
486: zapino(dp);
487: inodirty();
488: }
489: continue;
490: }
491: n_files++;
492: if(setlncnt(dp->di_nlink) <= 0) {
493: if(badlnp < &badlncnt[MAXLNCNT])
494: *badlnp++ = inum;
495: else {
496: pfatal("LINK COUNT TABLE OVERFLOW");
497: if(reply("CONTINUE") == NO)
498: errexit("");
499: }
500: }
501: setstate(DIR ? DSTATE : FSTATE);
502: badblk = dupblk = 0;
503: filsize = 0;
504: maxblk = 0;
505: ckinode(dp,ADDR);
506: if((n = getstate()) == DSTATE || n == FSTATE)
507: sizechk(dp);
508: }
509: else if(dp->di_mode != 0) {
510: pfatal("PARTIALLY ALLOCATED INODE I=%u",inum);
511: if(reply("CLEAR") == YES) {
512: zapino(dp);
513: inodirty();
514: }
515: }
516: }
517:
518:
519: if(enddup != &duplist[0]) {
520: if (preen)
521: pfatal("INTERNAL ERROR: dups with -p");
522: printf("** Phase 1b - Rescan For More DUPS\n");
523: pfunc = pass1b;
524: for(inum = 1; inum <= lastino; inum++) {
525: if(getstate() != USTATE && (dp = ginode()) != NULL)
526: if(ckinode(dp,ADDR) & STOP)
527: break;
528: }
529: }
530: if(rawflg) { /* shouldn't be set for 4k system */
531: if(inoblk.b_dirty)
532: bwrite(&dfile,membase,startib,(int)niblk*BSIZE(big));
533: inoblk.b_dirty = 0;
534: if(poolhead) {
535: clear(membase,niblk*BSIZE(BIG));
536: for(bp1 = poolhead;bp1->b_next;bp1 = bp1->b_next);
537: bp2 = &((BUFAREA *)membase)[(niblk*BSIZE(BIG))/sizeof(BUFAREA)];
538: while(--bp2 >= (BUFAREA *)membase) {
539: initbarea(bp2);
540: bp2->b_next = bp1->b_next;
541: bp1->b_next = bp2;
542: }
543: }
544: rawflg = 0;
545:
546: }
547:
548:
549: if (preen == 0)
550: printf("** Phase 2 - Check Pathnames\n");
551: inum = ROOTINO;
552: thisname = pathp = pathname;
553: pfunc = pass2;
554: switch(getstate()) {
555: case USTATE:
556: errexit("ROOT INODE UNALLOCATED. TERMINATING.\n");
557: case FSTATE:
558: pfatal("ROOT INODE NOT DIRECTORY");
559: if(reply("FIX") == NO || (dp = ginode()) == NULL)
560: errexit("");
561: dp->di_mode &= ~IFMT;
562: dp->di_mode |= IFDIR;
563: inodirty();
564: setstate(DSTATE);
565: case DSTATE:
566: descend();
567: break;
568: case CLEAR:
569: pfatal("DUPS/BAD IN ROOT INODE");
570: printf("\n");
571: if(reply("CONTINUE") == NO)
572: errexit("");
573: setstate(DSTATE);
574: descend();
575: }
576:
577:
578: if (preen == 0)
579: printf("** Phase 3 - Check Connectivity\n");
580: for(inum = 1; inum <= lastino; inum++) {
581: if(getstate() == DSTATE) {
582: pfunc = findino;
583: srchname = "..";
584: savino = inum;
585: do {
586: orphan = inum;
587: if((dp = ginode()) == NULL)
588: break;
589: filsize = dp->di_size;
590: parentdir = 0;
591: ckinode(dp,DATA);
592: if((inum = parentdir) == 0)
593: break;
594: } while(getstate() == DSTATE);
595: inum = orphan;
596: if(linkup() == YES) {
597: thisname = pathp = pathname;
598: *pathp++ = '?';
599: pfunc = pass2;
600: descend();
601: }
602: inum = savino;
603: }
604: }
605:
606:
607: if (preen == 0)
608: printf("** Phase 4 - Check Reference Counts\n");
609: pfunc = pass4;
610: zcleared = 0;
611: for(inum = 1; inum <= lastino; inum++) {
612: switch(getstate()) {
613: case FSTATE:
614: if(n = getlncnt())
615: adjust((short)n);
616: else {
617: for(blp = badlncnt;blp < badlnp; blp++)
618: if(*blp == inum) {
619: clri("UNREF",preen?NO:YES,YES);
620: break;
621: }
622: }
623: break;
624: case DSTATE:
625: clri("UNREF",YES,NO);
626: break;
627: case CLEAR:
628: clri("BAD/DUP",YES,NO);
629: }
630: }
631: if (zcleared)
632: pwarn("%u LINKLESS FILES CLEARED\n", zcleared);
633: if(imax - n_files != superblk.s_tinode) {
634: pwarn("FREE INODE COUNT %u SHOULD BE %u IN SUPERBLK",
635: superblk.s_tinode, imax - n_files);
636: if (preen)
637: printf(" (FIXED)\n");
638: if (preen || reply("FIX") == YES) {
639: superblk.s_tinode = imax - n_files;
640: sbdirty();
641: }
642: }
643: flush(&dfile,&fileblk);
644:
645: if (preen == 0)
646: printf("** Phase 5 - Check Free List ");
647: if(sflag || (csflag && rplyflag == 0)) {
648: if (preen == 0)
649: printf("(Ignored)\n");
650: fixfree = 1;
651: }
652: else {
653: if (preen == 0)
654: printf("\n");
655: if(freemap)
656: copy(blkmap,freemap,(MEMSIZE)bmapsz);
657: else {
658: for(blk = 0; blk < fmapblk; blk++) {
659: bp1 = getblk((BUFAREA *)NULL,blk);
660: bp2 = getblk((BUFAREA *)NULL,blk+fmapblk);
661: copy(bp1->b_un.b_buf,bp2->b_un.b_buf,BSIZE(big));
662: dirty(bp2);
663: }
664: }
665: badblk = dupblk = 0;
666: #ifdef SMALL
667: if(big == SMALL) {
668: freeblk.df_nfree = superblk.s_nfree;
669: for(n = 0; n < NICFREE; n++)
670: freeblk.df_free[n] = superblk.s_free[n];
671: }
672: #endif
673: freechk();
674: if(badblk) {
675: pfatal("%d BAD BLKS IN FREE LIST",badblk);
676: printf("\n");
677: }
678: if(dupblk)
679: pwarn("%d DUP BLKS IN FREE LIST\n",dupblk);
680: if(fixfree == 0) {
681: if((n_blks+n_free) != (fmax-fmin)) {
682: pwarn("%ld BLK(S) MISSING\n",
683: fmax-fmin-n_blks-n_free);
684: fixfree = 1;
685: }
686: #ifdef SMALL
687: else if(big == SMALL && n_free != superblk.s_tfree) {
688: pwarn("FREE BLK COUNT WRONG IN SUPERBLK");
689: if (preen)
690: printf(" (FIXED)\n");
691: if(preen || reply("FIX") == YES) {
692: superblk.s_tfree = n_free;
693: sbdirty();
694: }
695: }
696: #endif
697: }
698: if(fixfree) {
699: pwarn("BAD FREE LIST");
700: if (preen)
701: printf(" (SALVAGED)\n");
702: else if(reply("SALVAGE") == NO)
703: fixfree = 0;
704: }
705: }
706:
707: if(fixfree) {
708: if (preen == 0)
709: printf("** Phase 6 - Salvage Free List\n");
710: makefree();
711: n_free = superblk.s_tfree;
712: }
713:
714: pwarn("%ld files %ld blocks %ld free\n", n_files,n_blks,n_free);
715: if(dfile.mod) {
716: time(&superblk.s_time);
717: sbdirty();
718: }
719: ckfini();
720: sync();
721: if(dfile.mod && hotroot) {
722: printf("ROOT MODIFIED\n");
723: }
724: if(dfile.mod && preen == 0)
725: printf("\n***** FILE SYSTEM WAS MODIFIED *****\n");
726: }
727:
728: /* VARARGS1 */
729: error(s1,s2,s3,s4)
730: char *s1;
731: {
732: printf(s1,s2,s3,s4);
733: }
734:
735: /* VARARGS1 */
736: errexit(s1,s2,s3,s4)
737: char *s1;
738: {
739: error(s1,s2,s3,s4);
740: exit(8);
741: }
742:
743: /*
744: * Pfatal is called when an inconsistency occurs
745: * which should not happen during normal operations.
746: * It printfs a message and then dies.
747: * When not preening, this is just a printf.
748: */
749: pfatal(s,a1,a2,a3)
750: char *s;
751: {
752:
753: if (preen) {
754: printf("%s: ", devname);
755: printf(s, a1, a2, a3);
756: printf("\n");
757: preendie();
758: }
759: printf(s, a1, a2, a3);
760: }
761:
762: /*
763: * Fatal is called to terminate preening
764: * due to unexplainable inconsistency.
765: */
766: preendie()
767: {
768:
769: printf("%s: UNEXPECTED INCONSISTENCY; RUN fsck MANUALLY.\n", devname);
770: exit(8);
771: }
772:
773: /*
774: * Pwarn is like printf when not preening,
775: * or a warning (preceded by filename) when preening.
776: */
777: pwarn(s,a1,a2,a3,a4,a5,a6)
778: char *s;
779: {
780:
781: if (preen)
782: printf("%s: ", devname);
783: printf(s, a1, a2, a3, a4, a5, a6);
784: }
785:
786: ckinode(dp,flg)
787: DINODE *dp;
788: register flg;
789: {
790: register daddr_t *ap;
791: register ret;
792: int (*func)(), n;
793: daddr_t iaddrs[NADDR];
794:
795: if(SPECIAL)
796: return(KEEPON);
797: l3tol(iaddrs,dp->di_addr,NADDR);
798: func = (flg == ADDR) ? pfunc : dirscan;
799: for(ap = iaddrs; ap < &iaddrs[NADDR-3]; ap++) {
800: if(*ap && (ret = (*func)(*ap)) & STOP)
801: return(ret);
802: }
803: for(n = 1; n < 4; n++) {
804: if(*ap && (ret = iblock(*ap,n,flg)) & STOP)
805: return(ret);
806: ap++;
807: }
808: return(KEEPON);
809: }
810:
811:
812: iblock(blk,ilevel,flg)
813: daddr_t blk;
814: register ilevel;
815: {
816: register daddr_t *ap;
817: register n;
818: int (*func)();
819: BUFAREA ib;
820:
821: if(flg == ADDR) {
822: func = pfunc;
823: if(((n = (*func)(blk)) & KEEPON) == 0)
824: return(n);
825: }
826: else
827: func = dirscan;
828: if(outrange(blk)) /* protect thyself */
829: return(SKIP);
830: initbarea(&ib);
831: if(getblk(&ib,blk) == NULL)
832: return(SKIP);
833: ilevel--;
834: for(ap = ib.b_un.b_indir; ap < &ib.b_un.b_indir[NINDIR(big)]; ap++) {
835: if(*ap) {
836: if(ilevel > 0) {
837: n = iblock(*ap,ilevel,flg);
838: }
839: else
840: n = (*func)(*ap);
841: if(n & STOP)
842: return(n);
843: }
844: }
845: return(KEEPON);
846: }
847:
848:
849: pass1(blk)
850: daddr_t blk;
851: {
852: register daddr_t *dlp;
853:
854: if(outrange(blk)) {
855: blkerr("BAD",blk);
856: if(++badblk >= MAXBAD) {
857: printf("EXCESSIVE BAD BLKS I=%u",inum);
858: if(reply("CONTINUE") == NO)
859: errexit("");
860: return(STOP);
861: }
862: return(SKIP);
863: }
864: if(getbmap(blk)) {
865: blkerr("DUP",blk);
866: if(++dupblk >= MAXDUP) {
867: printf("EXCESSIVE DUP BLKS I=%u",inum);
868: if(reply("CONTINUE") == NO)
869: errexit("");
870: return(STOP);
871: }
872: if(enddup >= &duplist[DUPTBLSIZE]) {
873: printf("DUP TABLE OVERFLOW.");
874: if(reply("CONTINUE") == NO)
875: errexit("");
876: return(STOP);
877: }
878: for(dlp = duplist; dlp < muldup; dlp++) {
879: if(*dlp == blk) {
880: *enddup++ = blk;
881: break;
882: }
883: }
884: if(dlp >= muldup) {
885: *enddup++ = *muldup;
886: *muldup++ = blk;
887: }
888: }
889: else {
890: n_blks++;
891: setbmap(blk);
892: }
893: filsize++;
894: return(KEEPON);
895: }
896:
897:
898: pass1b(blk)
899: daddr_t blk;
900: {
901: register daddr_t *dlp;
902:
903: if(outrange(blk))
904: return(SKIP);
905: for(dlp = duplist; dlp < muldup; dlp++) {
906: if(*dlp == blk) {
907: blkerr("DUP",blk);
908: *dlp = *--muldup;
909: *muldup = blk;
910: return(muldup == duplist ? STOP : KEEPON);
911: }
912: }
913: return(KEEPON);
914: }
915:
916:
917: pass2(dirp)
918: register DIRECT *dirp;
919: {
920: register char *p;
921: register n;
922: DINODE *dp;
923:
924: if((inum = dirp->d_ino) == 0)
925: return(KEEPON);
926: thisname = pathp;
927: for(p = dirp->d_name; p < &dirp->d_name[DIRSIZ]; )
928: if((*pathp++ = *p++) == 0) {
929: --pathp;
930: break;
931: }
932: *pathp = 0;
933: n = NO;
934: if(inum > imax || inum <= 0)
935: n = direrr("I OUT OF RANGE");
936: else {
937: again:
938: switch(getstate()) {
939: case USTATE:
940: n = direrr("UNALLOCATED");
941: break;
942: case CLEAR:
943: if((n = direrr("DUP/BAD")) == YES)
944: break;
945: if((dp = ginode()) == NULL)
946: break;
947: setstate(DIR ? DSTATE : FSTATE);
948: goto again;
949: case FSTATE:
950: declncnt();
951: break;
952: case DSTATE:
953: declncnt();
954: descend();
955: }
956: }
957: pathp = thisname;
958: if(n == NO)
959: return(KEEPON);
960: dirp->d_ino = 0;
961: return(KEEPON|ALTERD);
962: }
963:
964:
965: pass4(blk)
966: daddr_t blk;
967: {
968: register daddr_t *dlp;
969:
970: if(outrange(blk))
971: return(SKIP);
972: if(getbmap(blk)) {
973: for(dlp = duplist; dlp < enddup; dlp++)
974: if(*dlp == blk) {
975: *dlp = *--enddup;
976: return(KEEPON);
977: }
978: clrbmap(blk);
979: n_blks--;
980: }
981: return(KEEPON);
982: }
983:
984:
985: pass5(blk)
986: daddr_t blk;
987: {
988: if(outrange(blk)) {
989: fixfree = 1;
990: if (preen)
991: pfatal("BAD BLOCKS IN FREE LIST.");
992: if(++badblk >= MAXBAD) {
993: printf("EXCESSIVE BAD BLKS IN FREE LIST.");
994: if(reply("CONTINUE") == NO)
995: errexit("");
996: return(STOP);
997: }
998: return(SKIP);
999: }
1000: if(getfmap(blk)) {
1001: fixfree = 1;
1002: if(++dupblk >= DUPTBLSIZE) {
1003: printf("EXCESSIVE DUP BLKS IN FREE LIST.");
1004: if(reply("CONTINUE") == NO)
1005: errexit("");
1006: return(STOP);
1007: }
1008: }
1009: else {
1010: n_free++;
1011: setfmap(blk);
1012: }
1013: return(KEEPON);
1014: }
1015:
1016:
1017: blkerr(s,blk)
1018: daddr_t blk;
1019: char *s;
1020: {
1021: pfatal("%ld %s I=%u",blk,s,inum);
1022: printf("\n");
1023: setstate(CLEAR); /* mark for possible clearing */
1024: }
1025:
1026:
1027: descend()
1028: {
1029: register DINODE *dp;
1030: register char *savname;
1031: off_t savsize;
1032:
1033: setstate(FSTATE);
1034: if((dp = ginode()) == NULL)
1035: return;
1036: savname = thisname;
1037: *pathp++ = '/';
1038: savsize = filsize;
1039: filsize = dp->di_size;
1040: ckinode(dp,DATA);
1041: thisname = savname;
1042: *--pathp = 0;
1043: filsize = savsize;
1044: }
1045:
1046:
1047: dirscan(blk)
1048: daddr_t blk;
1049: {
1050: register DIRECT *dirp;
1051: register char *p1, *p2;
1052: register n;
1053: DIRECT direntry;
1054:
1055: if(outrange(blk)) {
1056: filsize -= BSIZE(big);
1057: return(SKIP);
1058: }
1059: for(dirp = dirblk.b_dir; dirp < &dirblk.b_dir[NDIRECT(big)] &&
1060: filsize > 0; dirp++, filsize -= sizeof(DIRECT)) {
1061: if(getblk(&fileblk,blk) == NULL) {
1062: filsize -= (&dirblk.b_dir[NDIRECT(big)]-dirp)*
1063: sizeof(DIRECT);
1064: return(SKIP);
1065: }
1066: p1 = &dirp->d_name[DIRSIZ];
1067: p2 = &direntry.d_name[DIRSIZ];
1068: while(p1 > (char *)dirp)
1069: *--p2 = *--p1;
1070: if((n = (*pfunc)(&direntry)) & ALTERD) {
1071: if(getblk(&fileblk,blk) != NULL) {
1072: p1 = &dirp->d_name[DIRSIZ];
1073: p2 = &direntry.d_name[DIRSIZ];
1074: while(p1 > (char *)dirp)
1075: *--p1 = *--p2;
1076: fbdirty();
1077: }
1078: else
1079: n &= ~ALTERD;
1080: }
1081: if(n & STOP)
1082: return(n);
1083: }
1084: return(filsize > 0 ? KEEPON : STOP);
1085: }
1086:
1087:
1088: direrr(s)
1089: char *s;
1090: {
1091: register DINODE *dp;
1092:
1093: pwarn("%s ",s);
1094: pinode();
1095: printf("\n");
1096: if((dp = ginode()) != NULL && ftypeok(dp))
1097: pfatal("%s=%s",DIR?"DIR":"FILE",pathname);
1098: else
1099: pfatal("NAME=%s",pathname);
1100: return(reply("REMOVE"));
1101: }
1102:
1103:
1104: adjust(lcnt)
1105: register short lcnt;
1106: {
1107: register DINODE *dp;
1108:
1109: if((dp = ginode()) == NULL)
1110: return;
1111: if(dp->di_nlink == lcnt) {
1112: if(linkup() == NO)
1113: clri("UNREF",NO,NO);
1114: }
1115: else {
1116: pwarn("LINK COUNT %s",
1117: (lfdir==inum)?lfname:(DIR?"DIR":"FILE"));
1118: pinode();
1119: printf(" COUNT %d SHOULD BE %d",
1120: dp->di_nlink,dp->di_nlink-lcnt);
1121: if (preen) {
1122: if (lcnt < 0) {
1123: printf("\n");
1124: preendie();
1125: }
1126: printf(" (ADJUSTED)\n");
1127: }
1128: if(preen || reply("ADJUST") == YES) {
1129: dp->di_nlink -= lcnt;
1130: inodirty();
1131: }
1132: }
1133: }
1134:
1135:
1136: clri(s,flg,jclr)
1137: char *s;
1138: {
1139: register DINODE *dp;
1140:
1141: if((dp = ginode()) == NULL)
1142: return;
1143: if(flg == YES) {
1144: pwarn("%s %s",s,DIR?"DIR":"FILE");
1145: pinode();
1146: }
1147: if(preen || reply("CLEAR") == YES) {
1148: if (preen)
1149: if (jclr == YES)
1150: zcleared++;
1151: else
1152: printf(" (CLEARED)\n");
1153: n_files--;
1154: pfunc = pass4;
1155: ckinode(dp,ADDR);
1156: zapino(dp);
1157: inodirty();
1158: }
1159: }
1160:
1161:
1162: setup(dev)
1163: char *dev;
1164: {
1165: register n;
1166: register BUFAREA *bp;
1167: register MEMSIZE msize;
1168: char *mbase;
1169: daddr_t bcnt, nscrblk;
1170: dev_t rootdev;
1171: off_t smapsz, lncntsz, totsz;
1172: struct stat statarea;
1173:
1174: if(stat("/",&statarea) < 0)
1175: errexit("Can't stat root\n");
1176: rootdev = statarea.st_dev;
1177: if(stat(dev,&statarea) < 0) {
1178: error("Can't stat %s\n",dev);
1179: return(NO);
1180: }
1181: rawflg = 0;
1182: big = BIG; /* does this undo the work in blockcheck? */
1183: if(S_ISBLK(statarea.st_mode)) {
1184: if(BITFS(statarea.st_rdev))
1185: big = BIG;
1186: }
1187: else if(S_ISCHR(statarea.st_mode))
1188: rawflg++;
1189: else {
1190: if (reply("file is not a block or character device; OK") == NO)
1191: return(NO);
1192: big = BIG;
1193: }
1194: if(rootdev == statarea.st_rdev)
1195: hotroot++;
1196: if((dfile.rfdes = open(dev,0)) < 0) {
1197: error("Can't open %s\n",dev);
1198: return(NO);
1199: }
1200: if (preen == 0)
1201: printf("\n%s",dev);
1202: if(nflag || (dfile.wfdes = open(dev,1)) < 0) {
1203: dfile.wfdes = -1;
1204: if (preen)
1205: pfatal("NO WRITE ACCESS");
1206: printf(" (NO WRITE)");
1207: }
1208: if (preen == 0)
1209: printf("\n");
1210: fixfree = 0;
1211: dfile.mod = 0;
1212: n_files = n_blks = n_free = 0;
1213: muldup = enddup = &duplist[0];
1214: badlnp = &badlncnt[0];
1215: lfdir = 0;
1216: rplyflag = 0;
1217: initbarea(&sblk);
1218: initbarea(&fileblk);
1219: initbarea(&inoblk);
1220: sfile.wfdes = sfile.rfdes = -1;
1221: rmscr = 0;
1222: if(getblk(&sblk,SUPERB) == NULL) {
1223: ckfini();
1224: return(NO);
1225: }
1226: imax = ((ino_t)superblk.s_isize - (SUPERB+1)) * INOPB(big);
1227: fmin = (daddr_t)superblk.s_isize; /* first data blk num */
1228: fmax = superblk.s_fsize; /* first invalid blk num */
1229: m_blks = 0;
1230: /*
1231: * if this is a big bit mapped file system,
1232: * back off fmax by m_blks the number of bitmap blocks.
1233: */
1234: if ((big == BIG) && superblk.U.N.S_flag) {
1235: m_blks = (superblk.s_fsize+superblk.U.N.S_bsize-1)/superblk.U.N.S_bsize;
1236: fmax -= m_blks;
1237: }
1238: if(fmin >= fmax ||
1239: (imax/INOPB(big)) != ((ino_t)superblk.s_isize-(SUPERB+1))) {
1240: pfatal("Size check: fsize %ld isize %d",
1241: superblk.s_fsize,superblk.s_isize);
1242: printf("\n");
1243: ckfini();
1244: return(NO);
1245: }
1246: if (preen == 0)
1247: printf("File System: %.12s\n\n", superblk.s_fsmnt);
1248: bmapsz = roundup(howmany(fmax,BITSPB),sizeof(*lncntp));
1249: smapsz = roundup(howmany((long)(imax+1),STATEPB),sizeof(*lncntp));
1250: lncntsz = (long)(imax+1) * sizeof(*lncntp);
1251: if(bmapsz > smapsz+lncntsz)
1252: smapsz = bmapsz-lncntsz;
1253: totsz = bmapsz+smapsz+lncntsz;
1254:
1255: bm_buf = (long *)membase;
1256: memsize = memsize-BSIZE(BIG);
1257: membase = membase+BSIZE(BIG);
1258:
1259: msize = memsize;
1260: mbase = membase;
1261: if(rawflg) {
1262: if(msize < (MEMSIZE)(NINOBLK*BSIZE(big)) + 2*sizeof(BUFAREA))
1263: rawflg = 0;
1264: else {
1265: msize -= (MEMSIZE)NINOBLK*BSIZE(big);
1266: mbase += (MEMSIZE)NINOBLK*BSIZE(big);
1267: niblk = NINOBLK;
1268: startib = fmax;
1269: }
1270: }
1271: clear(mbase,msize);
1272: if((off_t)msize < totsz) {
1273: bmapsz = roundup(bmapsz,BSIZE(big));
1274: smapsz = roundup(smapsz,BSIZE(big));
1275: lncntsz = roundup(lncntsz,BSIZE(big));
1276: nscrblk = (bmapsz+smapsz+lncntsz)>>BSHIFT(big);
1277: if(tflag == 0) {
1278: printf("\nNEED SCRATCH FILE (%ld BLKS)\n",nscrblk);
1279: do {
1280: printf("ENTER FILENAME: ");
1281: if((n = getline(stdin,scrfile,sizeof(scrfile))) == EOF)
1282: errexit("\n");
1283: } while(n == 0);
1284: }
1285: if(stat(scrfile,&statarea) < 0 || S_ISREG(statarea.st_mode))
1286: rmscr++;
1287: if((sfile.wfdes = creat(scrfile,0666)) < 0 ||
1288: (sfile.rfdes = open(scrfile,0)) < 0) {
1289: error("Can't create %s\n",scrfile);
1290: ckfini();
1291: return(NO);
1292: }
1293: bp = &((BUFAREA *)mbase)[(msize/sizeof(BUFAREA))];
1294: poolhead = NULL;
1295: while(--bp >= (BUFAREA *)mbase) {
1296: initbarea(bp);
1297: bp->b_next = poolhead;
1298: poolhead = bp;
1299: }
1300: bp = poolhead;
1301: for(bcnt = 0; bcnt < nscrblk; bcnt++) {
1302: bp->b_bno = bcnt;
1303: dirty(bp);
1304: flush(&sfile,bp);
1305: }
1306: blkmap = freemap = statemap = (char *) NULL;
1307: lncntp = (short *) NULL;
1308: smapblk = bmapsz / BSIZE(big);
1309: lncntblk = smapblk + smapsz / BSIZE(big);
1310: fmapblk = smapblk;
1311: }
1312: else {
1313: if(rawflg && (off_t)msize > totsz+BSIZE(big)) {
1314: niblk += (unsigned)((off_t)msize-totsz)>>BSHIFT(big);
1315: if(niblk > MAXRAW)
1316: niblk = MAXRAW;
1317: msize = memsize - (niblk*BSIZE(big));
1318: mbase = membase + (niblk*BSIZE(big));
1319: }
1320: poolhead = NULL;
1321: blkmap = mbase;
1322: statemap = &mbase[(MEMSIZE)bmapsz];
1323: freemap = statemap;
1324: lncntp = (short *)&statemap[(MEMSIZE)smapsz];
1325: }
1326: return(YES);
1327: }
1328:
1329:
1330: DINODE *
1331: ginode()
1332: {
1333: register DINODE *dp;
1334: register char *mbase;
1335: daddr_t iblk;
1336:
1337: if(inum > imax)
1338: return(NULL);
1339: iblk = itod(big, inum);
1340: if(rawflg) {
1341: mbase = membase;
1342: if(iblk < startib || iblk >= startib+niblk) {
1343: if(inoblk.b_dirty)
1344: bwrite(&dfile,mbase,startib,(int)niblk*BSIZE(big));
1345: inoblk.b_dirty = 0;
1346: if(bread(&dfile,mbase,iblk,(int)niblk*BSIZE(big)) == NO) {
1347: startib = fmax;
1348: return(NULL);
1349: }
1350: startib = iblk;
1351: }
1352: dp = (DINODE *)&mbase[(unsigned)((iblk-startib)<<BSHIFT(big))];
1353: }
1354: else if(getblk(&inoblk,iblk) != NULL)
1355: dp = inoblk.b_un.b_dinode;
1356: else
1357: return(NULL);
1358: return(dp + itoo(big, inum));
1359: }
1360:
1361:
1362: ftypeok(dp)
1363: DINODE *dp;
1364: {
1365: switch(dp->di_mode & IFMT) {
1366: case IFDIR:
1367: case IFREG:
1368: case IFBLK:
1369: case IFCHR:
1370: /* case IFMPC: */
1371: case IFLNK:
1372: /* case IFMPB: */
1373: return(YES);
1374: default:
1375: return(NO);
1376: }
1377: }
1378:
1379:
1380: reply(s)
1381: char *s;
1382: {
1383: char line[80];
1384:
1385: if (preen)
1386: pfatal("INTERNAL ERROR: GOT TO reply()");
1387: rplyflag = 1;
1388: printf("\n%s? ",s);
1389: if(nflag || csflag || dfile.wfdes < 0) {
1390: printf(" no\n\n");
1391: return(NO);
1392: }
1393: if(yflag) {
1394: printf(" yes\n\n");
1395: return(YES);
1396: }
1397: if(getline(stdin,line,sizeof(line)) == EOF)
1398: errexit("\n");
1399: printf("\n");
1400: if(line[0] == 'y' || line[0] == 'Y')
1401: return(YES);
1402: else
1403: return(NO);
1404: }
1405:
1406:
1407: getline(fp,loc,maxlen)
1408: FILE *fp;
1409: char *loc;
1410: {
1411: register n;
1412: register char *p, *lastloc;
1413:
1414: p = loc;
1415: lastloc = &p[maxlen-1];
1416: while((n = getc(fp)) != '\n') {
1417: if(n == EOF)
1418: return(EOF);
1419: if(!isspace(n) && p < lastloc)
1420: *p++ = n;
1421: }
1422: *p = 0;
1423: return(p - loc);
1424: }
1425:
1426:
1427: stype(p)
1428: register char *p;
1429: {
1430: if(*p == 0)
1431: return;
1432: cylsize = atoi(p);
1433: while(*p && *p != ':')
1434: p++;
1435: if(*p)
1436: p++;
1437: stepsize = atoi(p);
1438: if(stepsize <= 0 || stepsize > cylsize ||
1439: cylsize <= 0 || cylsize > MAXCYL) {
1440: error("Invalid -s argument, defaults assumed\n");
1441: cylsize = stepsize = 0;
1442: }
1443: }
1444:
1445:
1446: dostate(s,flg)
1447: {
1448: register char *p;
1449: register unsigned byte, shift;
1450: BUFAREA *bp;
1451:
1452: byte = (inum)/STATEPB;
1453: shift = LSTATE * ((inum)%STATEPB);
1454: if(statemap != NULL) {
1455: bp = NULL;
1456: p = &statemap[byte];
1457: }
1458: else if((bp = getblk((BUFAREA *)NULL,
1459: (daddr_t)(smapblk+(byte/BSIZE(big))))) == NULL)
1460: errexit("Fatal I/O error\n");
1461: else
1462: p = &bp->b_un.b_buf[byte%BSIZE(big)];
1463: switch(flg) {
1464: case 0:
1465: *p &= ~(SMASK<<(shift));
1466: *p |= s<<(shift);
1467: if(bp != NULL)
1468: dirty(bp);
1469: return(s);
1470: case 1:
1471: return((*p>>(shift)) & SMASK);
1472: }
1473: return(USTATE);
1474: }
1475:
1476:
1477: domap(blk,flg)
1478: daddr_t blk;
1479: {
1480: register char *p;
1481: register unsigned n;
1482: register BUFAREA *bp;
1483: off_t byte;
1484:
1485: byte = blk >> BITSHIFT;
1486: n = 1<<((unsigned)(blk & BITMASK));
1487: if(flg & 04) {
1488: p = freemap;
1489: blk = fmapblk;
1490: }
1491: else {
1492: p = blkmap;
1493: blk = 0;
1494: }
1495: if(p != NULL) {
1496: bp = NULL;
1497: p += (unsigned)byte;
1498: }
1499: else if((bp = getblk((BUFAREA *)NULL,blk+(byte>>BSHIFT(big)))) == NULL)
1500: errexit("Fatal I/O error\n");
1501: else
1502: p = &bp->b_un.b_buf[(unsigned)(byte&BMASK(big))];
1503: switch(flg&03) {
1504: case 0:
1505: *p |= n;
1506: break;
1507: case 1:
1508: n &= *p;
1509: bp = NULL;
1510: break;
1511: case 2:
1512: *p &= ~n;
1513: }
1514: if(bp != NULL)
1515: dirty(bp);
1516: return(n);
1517: }
1518:
1519:
1520: dobfree(blk,flg)
1521: {
1522: }
1523:
1524:
1525: dolncnt(val,flg)
1526: short val;
1527: {
1528: register short *sp;
1529: register BUFAREA *bp;
1530:
1531: if(lncntp != NULL) {
1532: bp = NULL;
1533: sp = &lncntp[inum];
1534: }
1535: else if((bp = getblk((BUFAREA *)NULL,(daddr_t)(lncntblk+(inum/SPERB(big))))) == NULL)
1536: errexit("Fatal I/O error\n");
1537: else
1538: sp = &bp->b_un.b_lnks[inum%SPERB(big)];
1539: switch(flg) {
1540: case 0:
1541: *sp = val;
1542: break;
1543: case 1:
1544: bp = NULL;
1545: break;
1546: case 2:
1547: (*sp)--;
1548: }
1549: if(bp != NULL)
1550: dirty(bp);
1551: return(*sp);
1552: }
1553:
1554:
1555: BUFAREA *
1556: getblk(bp,blk)
1557: daddr_t blk;
1558: register BUFAREA *bp;
1559: {
1560: register struct filecntl *fcp;
1561:
1562: if(bp == NULL) {
1563: bp = search(blk);
1564: fcp = &sfile;
1565: }
1566: else
1567: fcp = &dfile;
1568: if(bp->b_bno == blk)
1569: return(bp);
1570: flush(fcp,bp);
1571: if(bread(fcp,bp->b_un.b_buf,blk,BSIZE(big)) != NO) {
1572: bp->b_bno = blk;
1573: return(bp);
1574: }
1575: bp->b_bno = (daddr_t)-1;
1576: return(NULL);
1577: }
1578:
1579:
1580: flush(fcp,bp)
1581: struct filecntl *fcp;
1582: register BUFAREA *bp;
1583: {
1584: if(bp->b_dirty) {
1585: bwrite(fcp,bp->b_un.b_buf,bp->b_bno,BSIZE(big));
1586: }
1587: bp->b_dirty = 0;
1588: }
1589:
1590:
1591: rwerr(s,blk)
1592: char *s;
1593: daddr_t blk;
1594: {
1595: if (preen == 0)
1596: printf("\n");
1597: pfatal("CAN NOT %s: BLK %ld",s,blk);
1598: if(reply("CONTINUE") == NO)
1599: errexit("Program terminated\n");
1600: }
1601:
1602:
1603: sizechk(dp)
1604: register DINODE *dp;
1605: {
1606: /*
1607: if (maxblk != howmany(dp->di_size, BSIZE))
1608: printf("POSSIBLE FILE SIZE ERROR I=%u (%ld,%ld)\n\n",
1609: inum, maxblk, howmany(dp->di_size,BSIZE));
1610: */
1611: if(DIR && (dp->di_size % sizeof(DIRECT)) != 0) {
1612: pwarn("DIRECTORY MISALIGNED I=%u\n",inum);
1613: if (preen == 0)
1614: printf("\n");
1615: }
1616: }
1617:
1618:
1619: ckfini()
1620: {
1621: flush(&dfile,&fileblk);
1622: flush(&dfile,&sblk);
1623: flush(&dfile,&inoblk);
1624: close(dfile.rfdes);
1625: close(dfile.wfdes);
1626: close(sfile.rfdes);
1627: close(sfile.wfdes);
1628: if(rmscr) {
1629: unlink(scrfile);
1630: }
1631: }
1632:
1633:
1634: pinode()
1635: {
1636: register DINODE *dp;
1637: register char *p;
1638: struct passwd *passwd;
1639: struct passwd *getpwuid();
1640: char *ctime();
1641:
1642: printf(" I=%u ",inum);
1643: if((dp = ginode()) == NULL)
1644: return;
1645: printf(" OWNER=");
1646: if((passwd = getpwuid((int)dp->di_uid)) != 0) {
1647: printf("%s ", passwd->pw_name);
1648: }
1649: else {
1650: printf("%d ",dp->di_uid);
1651: }
1652: printf("MODE=%o\n",dp->di_mode);
1653: if (preen)
1654: printf("%s: ", devname);
1655: printf("SIZE=%ld ",dp->di_size);
1656: p = ctime(&dp->di_mtime);
1657: printf("MTIME=%12.12s %4.4s ",p+4,p+20);
1658: }
1659:
1660:
1661: copy(fp,tp,size)
1662: register char *tp, *fp;
1663: MEMSIZE size;
1664: {
1665: while(size--)
1666: *tp++ = *fp++;
1667: }
1668:
1669:
1670: freechk()
1671: {
1672: register daddr_t *ap;
1673: daddr_t blkno;
1674: daddr_t bm_blk;
1675: daddr_t bitno;
1676:
1677: n_free = 0;
1678: if(big == BIG) {
1679: if (m_blks) {
1680: blkno = bitno = superblk.s_isize;
1681: bm_blk = fmax;
1682: memset((char *)bm_buf, 0, BSIZE(BIG));
1683: while(blkno < fmax) {
1684: if(!getfmap(blkno++)) {
1685: BITFREE(bm_buf, bitno);
1686: n_free++;
1687: }
1688: if(++bitno == BITSPERBLK) {
1689: bwrite(&dfile, (char *)bm_buf, bm_blk, BSIZE(BIG));
1690: bm_blk++;
1691: memset((char *)bm_buf, 0, BSIZE(BIG));
1692: bitno = 0;
1693: }
1694:
1695: }
1696: if(bitno) {
1697: bwrite(&dfile, (char *)bm_buf, bm_blk, BSIZE(BIG));
1698: }
1699: }
1700: else {
1701: memset((char *)superblk.s_bfree, 0, BITMAP);
1702: for(blkno = superblk.s_isize; blkno < fmax; blkno++) {
1703: if(!getfmap(blkno)) {
1704: BITFREE(superblk.s_bfree, blkno-superblk.s_isize);
1705: n_free++;
1706: }
1707: }
1708: }
1709: superblk.s_valid = 1;
1710: superblk.s_tfree = n_free;
1711: sbdirty();
1712: return;
1713: }
1714: #ifdef SMALL
1715: if(freeblk.df_nfree == 0)
1716: return;
1717: do {
1718: if(freeblk.df_nfree <= 0 || freeblk.df_nfree > NICFREE) {
1719: pwarn("BAD FREEBLK COUNT");
1720: printf("\n");
1721: fixfree = 1;
1722: return;
1723: }
1724: ap = &freeblk.df_free[freeblk.df_nfree];
1725: while(--ap > &freeblk.df_free[0]) {
1726: if(pass5(*ap) == STOP)
1727: return;
1728: }
1729: if(*ap == (daddr_t)0 || pass5(*ap) != KEEPON)
1730: return;
1731: } while(getblk(&fileblk,*ap) != NULL);
1732: #endif
1733: }
1734:
1735:
1736: makefree()
1737: {
1738: register i, cyl, step;
1739: int j;
1740: char flg[MAXCYL];
1741: short addr[MAXCYL];
1742: daddr_t blk, baseblk;
1743:
1744: if(big == BIG)
1745: return;
1746: #ifdef SMALL
1747: superblk.s_nfree = 0;
1748: superblk.s_flock = 0;
1749: superblk.s_fmod = 0;
1750: superblk.s_tfree = 0;
1751: superblk.s_ninode = 0;
1752: superblk.s_ilock = 0;
1753: superblk.s_ronly = 0;
1754: if(cylsize == 0 || stepsize == 0) {
1755: step = superblk.s_dinfo[0];
1756: cyl = superblk.s_dinfo[1];
1757: }
1758: else {
1759: step = stepsize;
1760: cyl = cylsize;
1761: }
1762: if(step > cyl || step <= 0 || cyl <= 0 || cyl > MAXCYL) {
1763: error("Default free list spacing assumed\n");
1764: step = STEPSIZE;
1765: cyl = CYLSIZE;
1766: }
1767: superblk.s_dinfo[0] = step;
1768: superblk.s_dinfo[1] = cyl;
1769: clear(flg,sizeof(flg));
1770: i = 0;
1771: for(j = 0; j < cyl; j++) {
1772: while(flg[i])
1773: i = (i + 1) % cyl;
1774: addr[j] = i + 1;
1775: flg[i]++;
1776: i = (i + step) % cyl;
1777: }
1778: baseblk = (daddr_t)roundup(fmax,cyl);
1779: clear((char *)&freeblk,BSIZE(big));
1780: freeblk.df_nfree++;
1781: for( ; baseblk > 0; baseblk -= cyl)
1782: for(i = 0; i < cyl; i++) {
1783: blk = baseblk - addr[i];
1784: if(!outrange(blk) && !getbmap(blk)) {
1785: superblk.s_tfree++;
1786: if(freeblk.df_nfree >= NICFREE) {
1787: fbdirty();
1788: fileblk.b_bno = blk;
1789: flush(&dfile,&fileblk);
1790: clear((char *)&freeblk,BSIZE(big));
1791: }
1792: freeblk.df_free[freeblk.df_nfree] = blk;
1793: freeblk.df_nfree++;
1794: }
1795: }
1796: superblk.s_nfree = freeblk.df_nfree;
1797: for(i = 0; i < NICFREE; i++)
1798: superblk.s_free[i] = freeblk.df_free[i];
1799: sbdirty();
1800: #endif
1801: }
1802:
1803:
1804: clear(p,cnt)
1805: register char *p;
1806: MEMSIZE cnt;
1807: {
1808: while(cnt--)
1809: *p++ = 0;
1810: }
1811:
1812:
1813: BUFAREA *
1814: search(blk)
1815: daddr_t blk;
1816: {
1817: register BUFAREA *pbp, *bp;
1818:
1819: for(bp = (BUFAREA *) &poolhead; bp->b_next; ) {
1820: pbp = bp;
1821: bp = pbp->b_next;
1822: if(bp->b_bno == blk)
1823: break;
1824: }
1825: pbp->b_next = bp->b_next;
1826: bp->b_next = poolhead;
1827: poolhead = bp;
1828: return(bp);
1829: }
1830:
1831:
1832: findino(dirp)
1833: register DIRECT *dirp;
1834: {
1835: register char *p1, *p2;
1836:
1837: if(dirp->d_ino == 0)
1838: return(KEEPON);
1839: for(p1 = dirp->d_name,p2 = srchname;*p2++ == *p1; p1++) {
1840: if(*p1 == 0 || p1 == &dirp->d_name[DIRSIZ-1]) {
1841: if(dirp->d_ino > 0 && dirp->d_ino <= imax)
1842: parentdir = dirp->d_ino;
1843: return(STOP);
1844: }
1845: }
1846: return(KEEPON);
1847: }
1848:
1849:
1850: mkentry(dirp)
1851: register DIRECT *dirp;
1852: {
1853: register ino_t in;
1854: register char *p;
1855:
1856: if(dirp->d_ino)
1857: return(KEEPON);
1858: dirp->d_ino = orphan;
1859: in = orphan;
1860: p = &dirp->d_name[8];
1861: *--p = 0;
1862: while(p > dirp->d_name) {
1863: *--p = (in % 10) + '0';
1864: in /= 10;
1865: }
1866: *p = '#';
1867: return(ALTERD|STOP);
1868: }
1869:
1870:
1871: chgdd(dirp)
1872: register DIRECT *dirp;
1873: {
1874: if(dirp->d_name[0] == '.' && dirp->d_name[1] == '.' &&
1875: dirp->d_name[2] == 0) {
1876: dirp->d_ino = lfdir;
1877: return(ALTERD|STOP);
1878: }
1879: return(KEEPON);
1880: }
1881:
1882:
1883: linkup()
1884: {
1885: register DINODE *dp;
1886: register lostdir;
1887: register ino_t pdir;
1888:
1889: if((dp = ginode()) == NULL)
1890: return(NO);
1891: lostdir = DIR;
1892: pdir = parentdir;
1893: if (preen && dp->di_size == 0)
1894: return(NO);
1895: pwarn("UNREF %s ",lostdir ? "DIR" : "FILE");
1896: pinode();
1897: if (preen)
1898: printf(" (RECONNECTED)\n");
1899: else
1900: if (reply("RECONNECT") == NO)
1901: return(NO);
1902: orphan = inum;
1903: if(lfdir == 0) {
1904: inum = ROOTINO;
1905: if((dp = ginode()) == NULL) {
1906: inum = orphan;
1907: return(NO);
1908: }
1909: pfunc = findino;
1910: srchname = lfname;
1911: filsize = dp->di_size;
1912: parentdir = 0;
1913: ckinode(dp,DATA);
1914: inum = orphan;
1915: if((lfdir = parentdir) == 0) {
1916: pfatal("SORRY. NO lost+found DIRECTORY");
1917: printf("\n\n");
1918: return(NO);
1919: }
1920: }
1921: inum = lfdir;
1922: if((dp = ginode()) == NULL || !DIR || getstate() != FSTATE) {
1923: inum = orphan;
1924: pfatal("SORRY. NO lost+found DIRECTORY");
1925: printf("\n\n");
1926: return(NO);
1927: }
1928: if(dp->di_size & BMASK(big)) {
1929: dp->di_size = roundup(dp->di_size,BSIZE(big));
1930: inodirty();
1931: }
1932: filsize = dp->di_size;
1933: inum = orphan;
1934: pfunc = mkentry;
1935: if((ckinode(dp,DATA) & ALTERD) == 0) {
1936: pfatal("SORRY. NO SPACE IN lost+found DIRECTORY");
1937: printf("\n\n");
1938: return(NO);
1939: }
1940: declncnt();
1941: if(lostdir) {
1942: pfunc = chgdd;
1943: dp = ginode();
1944: filsize = dp->di_size;
1945: ckinode(dp,DATA);
1946: inum = lfdir;
1947: if((dp = ginode()) != NULL) {
1948: dp->di_nlink++;
1949: inodirty();
1950: setlncnt(getlncnt()+1);
1951: }
1952: inum = orphan;
1953: pwarn("DIR I=%u CONNECTED. ",orphan);
1954: printf("PARENT WAS I=%u\n",pdir);
1955: if (preen == 0)
1956: printf("\n");
1957: }
1958: return(YES);
1959: }
1960:
1961:
1962: bread(fcp,buf,blk,size)
1963: daddr_t blk;
1964: register struct filecntl *fcp;
1965: register size;
1966: char *buf;
1967: {
1968: if(lseek(fcp->rfdes,blk<<BSHIFT(big),0) < 0)
1969: rwerr("SEEK",blk);
1970: else if(read(fcp->rfdes,buf,size) == size)
1971: return(YES);
1972: rwerr("READ",blk);
1973: return(NO);
1974: }
1975:
1976:
1977: bwrite(fcp,buf,blk,size)
1978: daddr_t blk;
1979: register struct filecntl *fcp;
1980: register size;
1981: char *buf;
1982: {
1983: if(fcp->wfdes < 0)
1984: return(NO);
1985: if(lseek(fcp->wfdes,blk<<BSHIFT(big),0) < 0)
1986: rwerr("SEEK",blk);
1987: else if(write(fcp->wfdes,buf,size) == size) {
1988: fcp->mod = 1;
1989: return(YES);
1990: }
1991: rwerr("WRITE",blk);
1992: return(NO);
1993: }
1994:
1995: void
1996: catch(int signo)
1997: {
1998: ckfini();
1999: exit(12);
2000: }
2001: /*
2002: * Convert longs to and from 3-byte disk addresses
2003: */
2004: /*
2005: void
2006: ltol3(char *cp, long *lp, int n)
2007: {
2008: int i;
2009: char *a, *b;
2010:
2011: a = cp;
2012: b = (char *)lp;
2013: for (i = 0; i < n; i++) {
2014: b++;
2015: *a++ = *b++;
2016: *a++ = *b++;
2017: *a++ = *b++;
2018: }
2019: }
2020:
2021: void
2022: l3tol(long *lp, char *cp, int n)
2023: {
2024: int i;
2025: char *a, *b;
2026:
2027: a = (char *)lp;
2028: b = cp;
2029: for (i = 0; i < n; i++) {
2030: *a++ = 0;
2031: *a++ = *b++;
2032: *a++ = *b++;
2033: *a++ = *b++;
2034: }
2035: }
2036: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.