![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsck.tar CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / etc|
Return to fsck.tar CVS log | Up to [MW Coherent from dump] / coherent / d / etc |
1.1 ! root 1: fsck/Makefile 644 3 3 1224 5045007365 6404 # ! 2: # for Inetco : CFLAGS = -O -DHPCOHERENT ! 3: # for PDP-11 : CFLAGS = -O ! 4: # others : CFLAGS = ! 5: # ! 6: ! 7: DESTDIR=/interim/etc/ ! 8: CFLAGS = -O ! 9: # ! 10: # for PDP-11 and IBM PC: LFLAGS = -i ! 11: # for Z8000 : LFLAGS = ! 12: # ! 13: LFLAGS = -i ! 14: OBJ=main.o init.o phase1.o phase1b.o phase2.o phase3.o phase4.o phase5.o\ ! 15: phase6.o cleanup.o util.o printf.o link.o virtual.o is_fs.o ! 16: ! 17: fsck: $(OBJ) ! 18: $(CC) $(CFLAGS) $(LFLAGS) -o $(DESTDIR)fsck $(OBJ) ! 19: ! 20: # ! 21: # for IBM PC Coherent executable, use: -DNBLK=1 ! 22: # for others, use : -DNBLK=8 ! 23: # ! 24: # If you are running out of malloc space, try lowering the ! 25: # value of NBLK (no smaller than 1). ! 26: # ! 27: ! 28: util.o: util.c ! 29: $(CC) -c $(CFLAGS) $< -DNBLK=8 ! 30: ! 31: $(OBJ): fsck.h ! 32: M PC: LFLAGS = -i ! 33: # for Z8000 : LFLAGS = ! 34: # ! 35: LFLAGS = -i ! 36: OBJ=main.o init.o phase1.o phase1b.o phase2.o phase3.o phase4.o phase5.o\ ! 37: phase6.o cleanup.o util.o printf.o link.o virtual.o is_fs.o ! 38: ! 39: fsck: $(OBJ) ! 40: $(CC) $(CFLAGS) $(LFLAGS) -o $(DESTDIR)fsck $(OBJ) ! 41: ! 42: # ! 43: # for IBM PC Coherent executable, use: -DNBLK=1 ! 44: # for others, use : -DNBLK=8 ! 45: # ! 46: # If you are rfsck/RCS/ 755 3 3 0 5050254740 5304 fsck/RCS/Makefile,v 444 3 3 2644 5045006646 7303 head 1.3; ! 47: branch ; ! 48: access ; ! 49: symbols ; ! 50: locks bin:1.3; ! 51: comment @@; ! 52: ! 53: ! 54: 1.3 ! 55: date 91.07.29.07.44.07; author bin; state Exp; ! 56: branches ; ! 57: next 1.2; ! 58: ! 59: 1.2 ! 60: date 91.03.15.18.33.07; author bin; state Exp; ! 61: branches ; ! 62: next 1.1; ! 63: ! 64: 1.1 ! 65: date 91.02.08.13.26.09; author bin; state Exp; ! 66: branches ; ! 67: next ; ! 68: ! 69: ! 70: desc ! 71: @initial version provided byinitial version provided by epstein ! 72: @ ! 73: ! 74: ! 75: 1.3 ! 76: log ! 77: @Updated by epstein for version 321. ! 78: @ ! 79: text ! 80: @# ! 81: # for Inetco : CFLAGS = -O -DHPCOHERENT ! 82: # for PDP-11 : CFLAGS = -O ! 83: # others : CFLAGS = ! 84: # ! 85: CFLAGS = -O ! 86: # ! 87: # for PDP-11 and IBM PC: LFLAGS = -i ! 88: # for Z8000 : LFLAGS = ! 89: # ! 90: LFLAGS = -i ! 91: OBJ=main.o init.o phase1.o phase1b.o phase2.o phase3.o phase4.o phase5.o\ ! 92: phase6.o cleanup.o util.o printf.o link.o virtual.o is_fs.o ! 93: ! 94: fsck: $(OBJ) ! 95: $(CC) $(CFLAGS) $(LFLAGS) -o fsck $(OBJ) ! 96: ! 97: # ! 98: # for IBM PC Coherent executable, use: -DNBLK=1 ! 99: # for others, use : -DNBLK=8 ! 100: # ! 101: # If you are running out of malloc space, try lowering the ! 102: # value of NBLK (no smaller than 1). ! 103: # ! 104: ! 105: util.o: util.c ! 106: $(CC) -c $(CFLAGS) util.c -DNBLK=8 ! 107: ! 108: $(OBJ): fsck.h ! 109: @ ! 110: ! 111: ! 112: 1.2 ! 113: log ! 114: @bob h added destdir, ownership, permissions... ! 115: @ ! 116: text ! 117: @a6 1 ! 118: DESTDIR = /interim/etc/ ! 119: d16 2 ! 120: a17 4 ! 121: $(CC) $(CFLAGS) $(LFLAGS) -o $(DESTDIR)fsck $(OBJ) ! 122: su root chown bin $(DESTDIR)$@@ ! 123: su root chgrp bin $(DESTDIR)$@@ ! 124: su root chmod 511 $(DESTDIR)$@@ ! 125: @ ! 126: ! 127: ! 128: 1.1 ! 129: log ! 130: @Initial revision ! 131: @ ! 132: text ! 133: @d7 1 ! 134: d17 4 ! 135: a20 2 ! 136: $(CC) $(CFLAGS) $(LFLAGS) -o fsck $(OBJ) ! 137: ! 138: @ ! 139: unning out of malloc space, try lowering the ! 140: # value of NBLK (no smaller than 1). ! 141: # ! 142: ! 143: util.o:fsck/RCS/READ_ME,v 444 3 3 1565 4754523421 6664 head 1.1; ! 144: access ; ! 145: symbols ; ! 146: locks ; ! 147: comment @@; ! 148: ! 149: ! 150: 1.1 ! 151: date 91.02.08.13.26.37; author bin; state Exp; ! 152: branches ; ! 153: next ; ! 154: ! 155: ! 156: desc ! 157: @updated version provided by epstein ! 158: @ ! 159: ! 160: ! 161: ! 162: 1.1 ! 163: log ! 164: @Initial revision ! 165: @ ! 166: text ! 167: @Ideas for improving the performance of fsck: ! 168: ! 169: (1) Utilize a different mechanism for storing the (struct direct) ! 170: entries throughout phase2.c, to remove implicit memory intensive ! 171: redundancy. ! 172: ! 173: (2) Encode the number of links per i-node count differently, in order ! 174: to save space taking advantage of the typical usage under Coherent. ! 175: ! 176: (3) Arrange space for the tables in a total needed way to avoid later ! 177: fragmentation problems affecting the memory requests for successive ! 178: file systems. ! 179: ! 180: (4) Devise a more clever buffering scheme for the blocks containing ! 181: i-nodes to understand the differences between phase1, phase2, and ! 182: phase4. ! 183: @ ! 184: ove implicit memory intensive ! 185: redundancy. ! 186: ! 187: (2) Encode the number of links per i-node count differently, in order ! 188: to save space tfsck/RCS/cleanup.c,v 444 3 3 2652 4753557355 7452 head 1.1; ! 189: access ; ! 190: symbols ; ! 191: locks ; ! 192: comment @ * @; ! 193: ! 194: ! 195: 1.1 ! 196: date 91.02.05.16.35.30; author bin; state Exp; ! 197: branches ; ! 198: next ; ! 199: ! 200: ! 201: desc ! 202: @provided by Mark Epstein ! 203: @ ! 204: ! 205: ! 206: ! 207: 1.1 ! 208: log ! 209: @Initial revision ! 210: @ ! 211: text ! 212: @/* ! 213: * Cleanup functions for phases of fsck ! 214: */ ! 215: ! 216: #include "fsck.h" ! 217: ! 218: cleanup() ! 219: { ! 220: int retval = 0; ! 221: ! 222: if (sbpfix == TRUE) ! 223: writesuper(); ! 224: prtstats(); ! 225: if (changeflg == TRUE) ! 226: retval = advise(); ! 227: close(fsfd); ! 228: cleanV(); ! 229: return(retval); ! 230: } ! 231: ! 232: writesuper() ! 233: { ! 234: register int i; ! 235: ! 236: canshort(sbp->s_isize); ! 237: candaddr(sbp->s_fsize); ! 238: canshort(sbp->s_nfree); ! 239: for(i=0; i<NICFREE; i++) ! 240: candaddr(sbp->s_free[i]); ! 241: canshort(sbp->s_ninode); ! 242: for(i=0; i<NICINOD; i++) ! 243: canino(sbp->s_inode[i]); ! 244: cantime(sbp->s_time); ! 245: candaddr(sbp->s_tfree); ! 246: canino(sbp->s_tinode); ! 247: canshort(sbp->s_m); ! 248: canshort(sbp->s_n); ! 249: canlong(sbp->s_unique); ! 250: ! 251: bwrite((daddr_t)SUPERI, sbp); ! 252: } ! 253: ! 254: prtstats() ! 255: { ! 256: if (!fflag) ! 257: printf("%u files ", numfiles); ! 258: printf("%U blocks ", fsize - isize - totfree); ! 259: printf("%U free\n", totfree); ! 260: if ( lostsize ) { ! 261: lostsize = (lostsize + BSIZE - 1)/BSIZE; ! 262: printf("Expect roughly %U missing block%s next\n", lostsize, ! 263: (lostsize!=1) ? "s" : "" ); ! 264: printf("time fsck is run as a result of inodes "); ! 265: printf("being cleared.\n"); ! 266: } ! 267: } ! 268: ! 269: advise() ! 270: { ! 271: int retval = 0; ! 272: ! 273: printf(" ***** File System %s was modified *****\n", fsname); ! 274: if ( mounted ) { ! 275: printf(" ***** BOOT Coherent (NO SYNC!) *****\n"); ! 276: retval = 1; ! 277: } ! 278: return(retval); ! 279: } ! 280: @ ! 281: ocks ", fsize - isize - totfree); ! 282: printf("%U free\n", totfree); ! 283: if ( lostsize ) { ! 284: fsck/RCS/fsck.h,v 444 3 3 14557 4771205357 6775 head 1.2; ! 285: access ; ! 286: symbols ; ! 287: locks bin:1.2; ! 288: comment @ * @; ! 289: ! 290: ! 291: 1.2 ! 292: date 91.03.18.18.45.54; author bin; state Exp; ! 293: branches ; ! 294: next 1.1; ! 295: ! 296: 1.1 ! 297: date 91.02.08.13.26.49; author bin; state Exp; ! 298: branches ; ! 299: next ; ! 300: ! 301: ! 302: desc ! 303: @updated version provided by epstein ! 304: @ ! 305: ! 306: ! 307: 1.2 ! 308: log ! 309: @update provided by epstein ! 310: @ ! 311: text ! 312: @/* ! 313: * Header file for fsck -- File System Check Program ! 314: * ! 315: */ ! 316: ! 317: #include <canon.h> ! 318: #include <sys/dir.h> ! 319: #include <sys/fblk.h> ! 320: #include <sys/filsys.h> ! 321: #include <sys/ino.h> ! 322: #include <sys/stat.h> ! 323: #include <sys/types.h> ! 324: #include <time.h> ! 325: ! 326: #if HPCOHERENT ! 327: typedef long fsize_t; ! 328: #endif ! 329: ! 330: /* ! 331: * Conditional Compilation Flags ! 332: */ ! 333: ! 334: #define NOT_ALL_ZERO_INODE /* Dependent on whether or not an inode */ ! 335: #ifdef ALL_ZERO_INODE /* is totally zeroed when unallocated */ ! 336: #undef ALL_ZERO_INODE /* or simply a zero mode and zero link */ ! 337: #endif ! 338: ! 339: ! 340: /* ! 341: * Definitions and Externs ! 342: */ ! 343: ! 344: #define NUL 0 /* true zero ! */ ! 345: #define NULL ((char *)0) ! 346: ! 347: #define YES 3 /* default actions */ ! 348: #define NO 2 ! 349: #define ASK 1 ! 350: ! 351: #define NFILSYS 10 /* max number of file systems */ ! 352: #define MAXCH 20 /* max length of filesys name */ ! 353: ! 354: #define MAXBADOK 10 /* Max number of bad blocks before excessive */ ! 355: extern int numbad; /* num bad blocks found so far this inode*/ ! 356: ! 357: #define MAXDUPOK 10 /* Max number of dup blocks */ ! 358: /* in a single inode before excessive */ ! 359: #define DUPTBLSIZE 20 /* Max number of dup referenced blocks */ ! 360: extern daddr_t dupblck[]; /* table of duplicate referenced blocks */ ! 361: extern int totdups; /* number of dup blocks found so far */ ! 362: ! 363: #define MAXBADFREE 10 /* max bad in free list before abort */ ! 364: #define MAXDUPFREE 10 /* max dup in free list before abort */ ! 365: ! 366: #define GOOD 1 /* returned by bad() in util.c */ ! 367: #define BAD 0 ! 368: ! 369: #define TRUE 1 /* errflag possibilities */ ! 370: #define FALSE 0 ! 371: extern int errflag; /* errflag indicates not to do phases */ ! 372: ! 373: #define OK 1 /* used to indicate excessive bad/dup */ ! 374: #define STOP 0 /* blocks in an inode in phase1.c */ ! 375: #define BAD_DUP 2 ! 376: ! 377: #define FIRSTIN 2 /* First real inode number */ ! 378: ! 379: #define ND 10 /* Number of Direct Blocks */ ! 380: #undef NI ! 381: #define NI 1 ! 382: #define NII 1 ! 383: #define NIII 1 ! 384: #undef NADDR ! 385: #define NADDR (ND+NI+NII+NIII) ! 386: extern int offsets[]; /* table of offsets for level of indirection */ ! 387: /* for the blocks in an inode */ ! 388: ! 389: extern char nextchar(); /* used in util.c */ ! 390: extern int fsfd; /* file system file descriptor */ ! 391: extern int mdaction; /* default action for this invocation */ ! 392: extern int daction; /* default action for current file system */ ! 393: extern int writeflg; /* system write ok or read-only */ ! 394: extern int qflag; /* quiet fsck flag */ ! 395: extern int fflag; /* fast fsck flag */ ! 396: extern int sflag; /* force free list salvation */ ! 397: extern daddr_t fsize; /* file system size in blocks */ ! 398: extern int isize; /* first block not in inode list */ ! 399: /* isize is NOT unsigned so that comparisons */ ! 400: /* with longs will not cast the long to */ ! 401: /* unsigned thus producing confusing results */ ! 402: ! 403: extern daddr_t totfree; /* running count of total free blocks */ ! 404: extern unsigned ninodes;/* Number of inodes in the files system */ ! 405: extern char *fsname; /* file system name */ ! 406: extern fsize_t pinfo(); /* returns size of file, in phase2.c */ ! 407: extern ino_t lostfound(); /* returns inumber of lost+found dir */ ! 408: extern struct dinode *ptrino(); /* returns a ptr to inode, give number */ ! 409: extern char databuf[]; /* buffer to read in block, used throughout */ ! 410: extern char buf2[]; /* alternate data buffer */ ! 411: extern daddr_t cdbn; /* current block number, used by nextblock() */ ! 412: #define DSIZE (sizeof(struct direct)) ! 413: extern char *lostname; /* name of lost+found directory */ ! 414: extern char *nameit(); /* nameing function for lost dirs and files */ ! 415: extern int depth; /* used during tree traversal in phase2.c */ ! 416: extern struct direct *path[]; /* used during tree traversal in phase2.c */ ! 417: extern char *typename(); /* return string to type of inode */ ! 418: extern struct filsys *sbp; /* Super Block */ ! 419: extern int sbpfix; /* flag for super block fixes */ ! 420: extern struct stat stats; /* used by statit() in util.c */ ! 421: extern dev_t rootdev; /* root device number */ ! 422: extern dev_t fsysrdev; /* file system real device number */ ! 423: extern int mounted; /* flag indicating mountedness of filesystem */ ! 424: extern int changeflg; /* file system modified flag */ ! 425: extern int fixerup; /* flag to rebuild free list */ ! 426: extern char *fixit; /* Prompt message phase[45].c */ ! 427: extern int numfiles; /* num files in system */ ! 428: extern daddr_t imap(); /* function for disk block mapping in util.c */ ! 429: extern fsize_t lostsize; /* Size of files cleared in phase4.c */ ! 430: extern char *tmpfile; /* TMP File name for virtual.c */ ! 431: ! 432: #define SUCCESS 1 /* used in connect() in phase3.c */ ! 433: #define FAILURE 0 ! 434: ! 435: #define MODEMASK 0x07 ! 436: #define ALLOCMASK 0x06 ! 437: #define UNALLOC 0x00 ! 438: #define UNKNOWN 0x01 ! 439: #define IDIR 0x02 ! 440: #define IREG 0x03 ! 441: #define ICHR 0x04 ! 442: #define IBLK 0x05 ! 443: #define IPIPE 0x06 ! 444: #define IBAD_IDUP 0x08 ! 445: #define VISITED 0x10 ! 446: #define UNREFDIR 0x20 ! 447: #define CHILDDIR 0x40 ! 448: #define IFREELIST 0x80 ! 449: ! 450: /* ! 451: * Macros for tables ! 452: */ ! 453: ! 454: #define LOGNBPC 3 /* Log2 Number of Bits per Character */ ! 455: ! 456: /* Actions for virtual block system */ ! 457: enum vact { testBlock, markBlock, unmarkBlock, grabBlock, ! 458: testDup, markDup, unmarkDup, setDup, ! 459: Flags, setFlags, orFlags, ! 460: linkCtr, incLinkctr, setLinkctr }; ! 461: ! 462: #define testblock(bn) findblock((unsigned long)(bn), testBlock) ! 463: #define markblock(bn) findblock((unsigned long)(bn), markBlock) ! 464: #define unmarkblock(bn) findblock((unsigned long)(bn), unmarkBlock) ! 465: ! 466: #define testdup(bn) findblock((unsigned long)(bn), testDup) ! 467: #define markdup(bn) findblock((unsigned long)(bn), markDup) ! 468: #define unmarkdup(bn) findblock((unsigned long)(bn), unmarkDup) ! 469: ! 470: #define flags(ino) findblock((unsigned long)(ino), Flags) ! 471: #define setflags(ino, data) findblock((unsigned long)(ino), setFlags, data) ! 472: #define orflags(ino, data) findblock((unsigned long)(ino), orFlags, data) ! 473: ! 474: #define linkctr(ino) findblock((unsigned long)(ino), linkCtr) ! 475: #define inclinkctr(ino) findblock((unsigned long)(ino), incLinkctr) ! 476: #define setlinkctr(ino, data) findblock((unsigned long)(ino), setLinkctr, data) ! 477: ! 478: #define badblks(ino) ( flags(ino)&IBAD_IDUP ) ! 479: ! 480: /* ! 481: * Miscellany ! 482: */ ! 483: ! 484: #define NBPC 8 /* number of bits per character */ ! 485: #define MAXINTN 255 /* used for interleave table */ ! 486: /* in phase6.c */ ! 487: /* ! 488: * Stdio Stuff ! 489: */ ! 490: ! 491: #define putchar(c) { char b = c; write(1, &b, 1); } ! 492: extern char *malloc(); ! 493: extern char *calloc(); ! 494: ! 495: @ ! 496: ! 497: ! 498: 1.1 ! 499: log ! 500: @Initial revision ! 501: @ ! 502: text ! 503: @d85 1 ! 504: @ ! 505: ne inclinkctr(ino) findblock((unsigned long)(ino), incLinkctr) ! 506: #define setlinkctr(ino, data) findblock((unsigned long)(ino), setLinkctr, data) ! 507: ! 508: #fsck/RCS/init.c,v 444 3 3 14501 5045006666 6767 head 1.2; ! 509: branch ; ! 510: access ; ! 511: symbols ; ! 512: locks bin:1.2; ! 513: comment @ * @; ! 514: ! 515: ! 516: 1.2 ! 517: date 91.07.29.07.44.33; author bin; state Exp; ! 518: branches ; ! 519: next 1.1; ! 520: ! 521: 1.1 ! 522: date 91.02.05.16.36.03; author bin; state Exp; ! 523: branches ; ! 524: next ; ! 525: ! 526: ! 527: desc ! 528: @prov by epstein ! 529: @ ! 530: ! 531: ! 532: 1.2 ! 533: log ! 534: @Updated by epstein for version 321. ! 535: @ ! 536: text ! 537: @/* ! 538: * Perform initialization for phases of fsck ! 539: */ ! 540: #include "fsck.h" ! 541: #include <mnttab.h> ! 542: #include <mtab.h> ! 543: ! 544: int fsfd; /* file system file descriptor */ ! 545: int writeflg; /* write ok or read-only flag */ ! 546: daddr_t fsize = SUPERI+1; /* file system size in blocks */ ! 547: /* Allows for read of Super Block */ ! 548: int isize; /* First block not in inode list */ ! 549: daddr_t totfree; /* Running total free block count */ ! 550: unsigned ninodes; /* number of inodes */ ! 551: int numfiles; /* number of files in file system */ ! 552: ! 553: char superb[BSIZE]; /* Super Block */ ! 554: struct filsys *sbp = superb; ! 555: int sbpfix; /* flag for super block fixes */ ! 556: ! 557: int offsets[] = /* table of offsets for the levels */ ! 558: { ND, ND+NI, ND+NI+NII, /* of indirection of blocks in the */ ! 559: ND+NI+NII+NIII }; /* inode block list */ ! 560: ! 561: daddr_t dupblck[DUPTBLSIZE]; /* duplicate referenced blocks */ ! 562: int totdups; /* number of dup blocks so far */ ! 563: ! 564: init() ! 565: { ! 566: int mode; ! 567: struct stat status; ! 568: unsigned short stmode; ! 569: ! 570: mode = (mdaction == NO) ? 0 : 2; ! 571: ! 572: if ( (fsfd = open(fsname, mode)) == (-1) ) { ! 573: mode = 0; ! 574: if ( (fsfd = open(fsname, mode)) == (-1) ) { ! 575: nonfatal("Can't open: %s", fsname); ! 576: return; ! 577: } ! 578: } ! 579: ! 580: if (mode == 0) { ! 581: daction = NO; ! 582: writeflg = FALSE; ! 583: } else { ! 584: daction = mdaction; ! 585: writeflg = TRUE; ! 586: } ! 587: ! 588: printf("%s: %s\n", fsname, (mode == 0) ? "(NO WRITE)" : ""); ! 589: ! 590: if ( fstat(fsfd, &status) == (-1) ) { ! 591: nonfatal("Can't stat: %s", fsname); ! 592: return; ! 593: } ! 594: ! 595: stmode = status.st_mode & S_IFMT; ! 596: if ( (stmode != S_IFBLK) && (stmode != S_IFCHR) ) ! 597: switch(query("file is not a block or character device; OK?")){ ! 598: case YES: ! 599: break; ! 600: case NO: ! 601: errflag = TRUE; ! 602: return; ! 603: } ! 604: ! 605: domount(); ! 606: sbpfix = FALSE; ! 607: readsuper(); ! 608: checksuper(); ! 609: if ( !errflag ) ! 610: alloctables(); ! 611: } ! 612: ! 613: /* ! 614: * Read in the super block and canonicalize ! 615: */ ! 616: ! 617: readsuper() ! 618: { ! 619: register int i; ! 620: ! 621: bread((daddr_t)SUPERI, superb); ! 622: sbp = superb; ! 623: ! 624: canshort(sbp->s_isize); ! 625: candaddr(sbp->s_fsize); ! 626: canshort(sbp->s_nfree); ! 627: for(i=0; i<NICFREE; i++) ! 628: candaddr(sbp->s_free[i]); ! 629: canshort(sbp->s_ninode); ! 630: for(i=0; i<NICINOD; i++) ! 631: canino(sbp->s_inode[i]); ! 632: cantime(sbp->s_time); ! 633: candaddr(sbp->s_tfree); ! 634: canino(sbp->s_tinode); ! 635: canshort(sbp->s_m); ! 636: canshort(sbp->s_n); ! 637: canlong(sbp->s_unique); ! 638: ! 639: } ! 640: ! 641: /* ! 642: * Check super block for obvious inconsistencies ! 643: */ ! 644: ! 645: checksuper() ! 646: { ! 647: fsize = sbp->s_fsize; ! 648: isize = sbp->s_isize; ! 649: totfree = fsize - isize; ! 650: ! 651: if ( (isize<=INODEI) || (isize>=fsize) || (fsize<=INODEI) ) { ! 652: badsuper("Size check: fsize %U isize %u", fsize, isize); ! 653: errflag = TRUE; ! 654: } ! 655: ! 656: if ( sbp->s_nfree > NICFREE ) ! 657: badsuper("Too large free block count"); ! 658: ! 659: if ( sbp->s_ninode > NICINOD ) ! 660: badsuper("Too large free i-node count"); ! 661: } ! 662: ! 663: /* ! 664: * Super Block Error Functions ! 665: */ ! 666: ! 667: badsuper(x) ! 668: { ! 669: printf("%r\n", &x); ! 670: printf("fsck: %s: Bad Super Block: %u\n", fsname, SUPERI); ! 671: } ! 672: ! 673: /* ! 674: * Allocate the necessary buffers for tables ! 675: */ ! 676: ! 677: alloctables() ! 678: { ! 679: unsigned num, numl; ! 680: ! 681: numl = 0; ! 682: if (!fflag) { ! 683: ninodes = (unsigned) (isize - INODEI) * INOPB; ! 684: numl = (unsigned) ninodes; ! 685: } ! 686: ! 687: num = (unsigned) ((fsize+NBPC-1)/NBPC) * sizeof(char); ! 688: initV(numl, numl, num, num); /* virtual allocation */ ! 689: ! 690: numfiles = /* number of files in the file system */ ! 691: totdups = 0; /* num dup blocks */ ! 692: } ! 693: ! 694: /* ! 695: * domount() checks the files /etc/mnttab and /etc/mtab to find ! 696: * out where the file system is mounted (if at all). It then ! 697: * reports where (and when if possible) it was last mounted. ! 698: */ ! 699: char *mnttab_name = "/etc/mnttab"; ! 700: char *mtab_name = "/etc/mtab"; ! 701: char *bttime_name = "/etc/boottime"; ! 702: ! 703: domount() ! 704: { ! 705: int fd; ! 706: struct mnttab mnttab; ! 707: struct mtab mtab; ! 708: register char *name; ! 709: struct stat sbuf; ! 710: time_t boottime; ! 711: int nothing(); ! 712: char devname[MNTNSIZ+6] = "/dev/"; ! 713: ! 714: mounted = FALSE; ! 715: name = fsname; /* strip off all initial */ ! 716: while (*name++ != '\0') ; /* directories in fsname */ ! 717: while ( (*--name != '/') && (name>fsname) ) ; ! 718: if (*name == '/') name++; ! 719: ! 720: if ( stat(bttime_name, &sbuf) == -1 ) ! 721: boottime = (time_t)0; ! 722: else ! 723: boottime = sbuf.st_mtime; ! 724: ! 725: if ( (fd=open(mnttab_name, 0)) != (-1) ) { ! 726: while ( read(fd, &mnttab, sizeof(mnttab))==sizeof(mnttab) ) ! 727: if ( mnttab.mt_dev[0] && mnttab.mt_filsys[0] ) { ! 728: strncpy(&devname[5], mnttab.mt_filsys, MNTNSIZ); ! 729: devname[MNTNSIZ+5] = '\0'; ! 730: statit(devname, nothing); ! 731: if (stats.st_rdev != fsysrdev) ! 732: continue; ! 733: statit(mnttab.mt_dev, nothing); ! 734: mounted = (stats.st_dev == fsysrdev); ! 735: prmnttab(&mnttab, boottime); ! 736: return; ! 737: } ! 738: } ! 739: if ( (fd=open(mtab_name, 0)) != (-1) ) { ! 740: while ( read(fd, &mtab, sizeof(mtab))==sizeof(mtab) ) ! 741: if ( mtab.mt_name[0] && mtab.mt_special[0] ) { ! 742: strncpy(&devname[5], mtab.mt_special, MNAMSIZ); ! 743: devname[MNAMSIZ+5] = '\0'; ! 744: statit(devname, nothing); ! 745: if (stats.st_rdev != fsysrdev) ! 746: continue; ! 747: statit(mtab.mt_name, nothing); ! 748: mounted = (stats.st_dev == fsysrdev); ! 749: prmtab(&mtab); ! 750: return; ! 751: } ! 752: } ! 753: ! 754: if (fsysrdev == rootdev) ! 755: mounted = TRUE; ! 756: else ! 757: mounted = FALSE; ! 758: ! 759: } ! 760: ! 761: prmnttab(ptr, boottime) ! 762: struct mnttab *ptr; ! 763: time_t boottime; ! 764: { ! 765: if (mounted) { ! 766: if (boottime < ptr->mt_time) ! 767: boottime = ptr->mt_time; ! 768: printf("%s mounted on %.*s as of %s", fsname, MNTNSIZ, ! 769: ptr->mt_dev, ctime(&boottime)); ! 770: } else ! 771: printf("%s unmounted. Last mounted on %.*s -- %s", ! 772: fsname, MNTNSIZ, ptr->mt_dev, ! 773: ctime(&ptr->mt_time)); ! 774: } ! 775: ! 776: ! 777: prmtab(ptr) ! 778: struct mtab *ptr; ! 779: { ! 780: if (mounted) ! 781: printf("%s mounted on %.*s\n", fsname, MNAMSIZ, ptr->mt_name); ! 782: else ! 783: printf("%s unmounted. Last mounted on %.*s\n", fsname, ! 784: MNAMSIZ, ptr->mt_name); ! 785: } ! 786: ! 787: nothing() ! 788: {} ! 789: @ ! 790: ! 791: ! 792: 1.1 ! 793: log ! 794: @Initial revision ! 795: @ ! 796: text ! 797: @d176 1 ! 798: d178 1 ! 799: d191 11 ! 800: a201 10 ! 801: if (mnttab.mt_dev[0] != '\0') ! 802: if ( strcmp(name, mnttab.mt_filsys) == 0 ) { ! 803: statit(mnttab.mt_dev, nothing); ! 804: if (stats.st_dev == fsysrdev) ! 805: mounted = TRUE; ! 806: else ! 807: mounted = FALSE; ! 808: prmnttab(&mnttab, boottime); ! 809: return; ! 810: } ! 811: d205 11 ! 812: a215 10 ! 813: if (mtab.mt_name[0] != '\0') ! 814: if ( strcmp(name, mtab.mt_special) == 0 ) { ! 815: statit(mtab.mt_name, nothing); ! 816: if (stats.st_dev == fsysrdev) ! 817: mounted = TRUE; ! 818: else ! 819: mounted = FALSE; ! 820: prmtab(&mtab); ! 821: return; ! 822: } ! 823: @ ! 824: mt_dev[0] != '\0') ! 825: if ( strcmp(name, mnttab.mt_filsys) == 0 ) { ! 826: statit(mnttab.mt_dev, nothing); ! 827: if (stats.st_dev == fsysrdev) ! 828: mounted = TRUE; ! 829: else ! 830: mounted = FAfsck/RCS/is_fs.c,v 444 3 3 4004 4753557413 7112 head 1.1; ! 831: access ; ! 832: symbols ; ! 833: locks ; ! 834: comment @ * @; ! 835: ! 836: ! 837: 1.1 ! 838: date 91.02.05.16.36.22; author bin; state Exp; ! 839: branches ; ! 840: next ; ! 841: ! 842: ! 843: desc ! 844: @prov by epstein ! 845: @ ! 846: ! 847: ! 848: ! 849: 1.1 ! 850: log ! 851: @Initial revision ! 852: @ ! 853: text ! 854: @#include <sys/stat.h> ! 855: #include <canon.h> ! 856: #include <sys/filsys.h> ! 857: ! 858: /* ! 859: * Check if a special file is a well-formed filesystem. ! 860: * This routine is derived from code in "mount.c". ! 861: * Return values: ! 862: * -1 Not a device, cannot open, read or seek failed ! 863: * 0 No filesystem ! 864: * 1 Legal filesystem ! 865: */ ! 866: int ! 867: is_fs(special) char *special; ! 868: { ! 869: static struct filsys f; ! 870: struct stat sbuf; ! 871: register int fd; ! 872: register struct filsys *fp; ! 873: register daddr_t *dp; ! 874: register ino_t *ip, maxinode; ! 875: ! 876: if (stat(special, &sbuf) < 0) ! 877: return -1; /* cannot stat device */ ! 878: else if ((sbuf.st_mode&S_IFMT) != S_IFBLK ! 879: && (sbuf.st_mode&S_IFMT) != S_IFCHR) ! 880: return -1; /* not a special file */ ! 881: else if ((fd = open(special, 2)) < 0) ! 882: return -1; /* cannot open */ ! 883: else if (lseek(fd, (long)SUPERI*BSIZE, 0) == -1L ! 884: || read(fd, &f, sizeof(f)) != sizeof(f)) { ! 885: close(fd); ! 886: return -1; /* seek or read failed */ ! 887: } else ! 888: close(fd); /* so far so good */ ! 889: ! 890: /* Canonical stuff. */ ! 891: fp = &f; ! 892: canshort(fp->s_isize); ! 893: candaddr(fp->s_fsize); ! 894: canshort(fp->s_nfree); ! 895: for (dp = &fp->s_free[0]; dp < &fp->s_free[NICFREE]; dp += 1) ! 896: candaddr(*dp); ! 897: canshort(fp->s_ninode); ! 898: for (ip = &fp->s_inode[0]; ip < &fp->s_inode[NICINOD]; ip += 1) ! 899: canino(*ip); ! 900: candaddr(fp->s_tfree); ! 901: canino(fp->s_tinode); ! 902: ! 903: /* Test for rationality. */ ! 904: maxinode = (fp->s_isize - INODEI) * INOPB + 1; ! 905: if (fp->s_isize >= fp->s_fsize) ! 906: return 0; ! 907: if ((fp->s_tfree < fp->s_nfree) ! 908: || (fp->s_tfree >= fp->s_fsize - fp->s_isize + 1)) ! 909: return 0; ! 910: if ((fp->s_tinode < fp->s_ninode) || (fp->s_tinode >= maxinode-1 )) ! 911: return 0; ! 912: for (dp = &fp->s_free[0]; dp < &fp->s_free[fp->s_nfree]; dp += 1) ! 913: if ((*dp < fp->s_isize) || (*dp >= fp->s_fsize)) ! 914: return 0; ! 915: for (ip = &fp->s_inode[0]; ip < &fp->s_inode[fp->s_ninode]; ip += 1) ! 916: if ((*ip < 1) || (*ip > maxinode)) ! 917: return 0; ! 918: return 1; ! 919: } ! 920: @ ! 921: INODEI) * INOPB + 1; ! 922: if (fp->s_isize >= fp->s_fsize) ! 923: return 0; ! 924: if ((fp->s_tfree < fp->s_nfree) ! 925: || (fp->s_tfree >= fp->s_fsize - fp->s_isize + 1)) ! 926: return 0; ! 927: if ((fp->s_tinode < fp->s_ninode) || (fp->s_tinode >= maxinode-1 )) ! 928: return 0; ! 929: for (dp = &fp->s_free[0]; dp < &fp->s_free[fp->s_nfree]; dp += 1) ! 930: if ((*dp < fp->s_isize) || (*dp >= fp->s_fsize)) ! 931: return 0; ! 932: for (ip = &fp->s_inode[0]; ip < &fp->s_inode[fp->s_ninode]; ip += 1) ! 933: if ((*ip < 1) || (*ip > maxinode)) ! 934: return 0; ! 935: return 1; ! 936: fsck/RCS/link.c,v 444 3 3 3277 4753557430 6756 head 1.1; ! 937: access ; ! 938: symbols ; ! 939: locks ; ! 940: comment @ * @; ! 941: ! 942: ! 943: 1.1 ! 944: date 91.02.05.16.36.34; author bin; state Exp; ! 945: branches ; ! 946: next ; ! 947: ! 948: ! 949: desc ! 950: @prov by epstein ! 951: @ ! 952: ! 953: ! 954: ! 955: 1.1 ! 956: log ! 957: @Initial revision ! 958: @ ! 959: text ! 960: @/* ! 961: * Routines to handle the counting of links for each i-node ! 962: */ ! 963: ! 964: #include "fsck.h" ! 965: ! 966: linkincr(inum) ! 967: ino_t inum; ! 968: { ! 969: if (inclinkctr(inum) == 0 ) ! 970: fatal("Too many links in i-node, %d", inum); ! 971: } ! 972: ! 973: /* ! 974: * The following is the beginning of thinking of how to change ! 975: * the number of bits used in the link count tables from 8-per ! 976: * i-node to 2-per i-node, with additional tables for those ! 977: * i-nodes with more than 2 links. The changes would be to the ! 978: * definition of i_lnks, the macro linkctr(), the function linkincr(), ! 979: * and in init.c, the allocation of table space. ! 980: */ ! 981: ! 982: #ifdef NEWLINKSTUFFF ! 983: ! 984: char *linkmap; /* table of inodes with one link */ ! 985: ! 986: #define testlink(in) ( linkmap[((unsigned)bn)>>(LOGNBPC-1)] & \ ! 987: 3 << (((unsigned)bn)&(NBPC>>1)) ) ! 988: #define marklink(in) ( linkmap[((unsigned)bn)>>(LOGNBPC-1)] |= \ ! 989: 1 << (((unsigned)bn)&(NBPC-2)) ) ! 990: #define unmarklink(in) ( linkmap[((unsigned)bn)>>(LOGNBPC-1)] ^= \ ! 991: 1 << (((unsigned)bn)&(NBPC-2)) ) ! 992: ! 993: linkcntr(inum) ! 994: ino_t inum; ! 995: { ! 996: index = ((unsigned) inum) >> (LOGNBPC-1) ; ! 997: distance = ((unsigned) inum) & ((NBPC>>1) - 1) ; ! 998: mask = 3 << distance; ! 999: answer = ( linkmap[index] & mask ) >> distance; ! 1000: ! 1001: if ( answer < 3 ) ! 1002: return(answer); ! 1003: ! 1004: hash = inum & 0xFF; ! 1005: bucket = &linktable[hash]; ! 1006: bktinum = bucket->inumb; ! 1007: ! 1008: if ( bktinum == inum ) { ! 1009: answer = bucket->numlink; ! 1010: if ( answer == 0xFF ) ! 1011: return( bigcntr(inum) ); ! 1012: else ! 1013: return( answer + 3 ); ! 1014: } ! 1015: ! 1016: if ( bktinum > inum ) ! 1017: fatal("internal linktable corruption."); ! 1018: ! 1019: ! 1020: } ! 1021: ! 1022: linkincr(inum) ! 1023: ino_t inum; ! 1024: { ! 1025: } ! 1026: ! 1027: #endif ! 1028: @ ! 1029: m) >> (LOGNBPC-1) ; ! 1030: distance = ((unsigned) inum) & ((NBPC>>1) - 1) ; ! 1031: mask = 3 << distance; ! 1032: answer = ( linkmap[index] & mask ) >> distance; ! 1033: ! 1034: if ( answer < 3 ) ! 1035: return(answer); ! 1036: ! 1037: hash = inum & 0xFF; ! 1038: bucket = &linktable[hash]; ! 1039: bktinum = bucket->inumb; ! 1040: ! 1041: if ( bktinum == inum ) { ! 1042: answer = bucket->numlink; ! 1043: if ( ansfsck/RCS/main.c,v 444 3 3 15241 5045006700 6737 head 1.3; ! 1044: branch ; ! 1045: access ; ! 1046: symbols ; ! 1047: locks bin:1.3; ! 1048: comment @ * @; ! 1049: ! 1050: ! 1051: 1.3 ! 1052: date 91.07.29.07.44.44; author bin; state Exp; ! 1053: branches ; ! 1054: next 1.2; ! 1055: ! 1056: 1.2 ! 1057: date 91.03.18.18.43.33; author bin; state Exp; ! 1058: branches ; ! 1059: next 1.1; ! 1060: ! 1061: 1.1 ! 1062: date 91.02.05.16.36.45; author bin; state Exp; ! 1063: branches ; ! 1064: next ; ! 1065: ! 1066: ! 1067: desc ! 1068: @prov by epstein ! 1069: @ ! 1070: ! 1071: ! 1072: 1.3 ! 1073: log ! 1074: @Updated by epstein for version 321. ! 1075: @ ! 1076: text ! 1077: @/* ! 1078: * fsck -- File System Check Program ! 1079: * an interactive file system check and repair program. ! 1080: * ! 1081: * Usage: ! 1082: * /etc/fsck [-y] [-n] [-q] [-f] [-{sS}] [-t TMPFILE] [filesystem ...] ! 1083: * audit and interactively repair inconsistent conditions for ! 1084: * file systems. Options -y and -n indicate an assumed response ! 1085: * to all questions asked by fsck. Default is to prompt operator ! 1086: * for yes/no response. Option -q is to quiet fsck from printing ! 1087: * certain messages, i.e. no size check messages, unreferenced ! 1088: * pipes will be silently removed, and counts in the superblock ! 1089: * will be automatically fixed and free list salvaged, if necessary. ! 1090: * Option -f is for a 'fast' check of the file system, i.e. only ! 1091: * check blocks, sizes, superblock counts, and the free list. ! 1092: * (-f) does not check pathnames, connectivity, or reference ! 1093: * counts. Option -s forces the reconstruction (or salvaging) of ! 1094: * both the free inode list and the free block list, even if there ! 1095: * are no file system problems. This will reorder the free block ! 1096: * list in the best order to limit additional fragmentation (respecting ! 1097: * interleaving as well). Note: Option -s will be ignored on mounted ! 1098: * file systems. The option -S acts in the same manner as -s except ! 1099: * that it will not be ignored on mounted file systems. Beware: -S ! 1100: * on mounted file systems should only be used if you intend to reboot ! 1101: * NO SYNC immediately afterwards. Option -t sets the temporary file ! 1102: * to use for disk caching of necessary tables on filesystems which are ! 1103: * too big to do in core. The temporary file defaults to "/dev/rram1", ! 1104: * which must be there. ! 1105: */ ! 1106: ! 1107: #include "fsck.h" ! 1108: ! 1109: int errflag; ! 1110: ! 1111: int mdaction; /* default action for invocation */ ! 1112: int daction; /* default action for file system */ ! 1113: int gSflag=FALSE; /* force salvage flag ignored mounted */ ! 1114: int gsflag=FALSE; /* force salvage flag ignored mounted */ ! 1115: int sflag=FALSE; /* force salvage flag */ ! 1116: int qflag=FALSE; /* fsck quiet flag */ ! 1117: int fflag=FALSE; /* fsck fast flag */ ! 1118: ! 1119: char *tmpfile = NULL; /* TMP file for virtual.c */ ! 1120: char *checklistfile = "/etc/checklist"; /* default file for list of file */ ! 1121: /* systems to fsck. */ ! 1122: char *filelist[NFILSYS]; /* list of filesystems */ ! 1123: char word[MAXCH]; /* hold single words */ ! 1124: char *fsname; /* file system name */ ! 1125: ! 1126: dev_t rootdev; /* root device number */ ! 1127: dev_t fsysrdev; /* file system real device number */ ! 1128: int mounted; /* flag for mounted file system */ ! 1129: ! 1130: int changeflg; /* file system modified flag */ ! 1131: ! 1132: main(argc, argv) ! 1133: char *argv[]; ! 1134: { ! 1135: int yflag=0, nflag=0; ! 1136: int retval; ! 1137: ! 1138: while (argc>1 && *argv[1]=='-') { ! 1139: switch (argv[1][1]) { ! 1140: case 'q': ! 1141: qflag = TRUE; ! 1142: break; ! 1143: case 'y': ! 1144: yflag = 1; ! 1145: break; ! 1146: case 'n': ! 1147: nflag = 1; ! 1148: break; ! 1149: case 'f': ! 1150: fflag = TRUE; ! 1151: break; ! 1152: case 'S': ! 1153: gSflag = TRUE; ! 1154: break; ! 1155: case 's': ! 1156: gsflag = TRUE; ! 1157: break; ! 1158: case 't': ! 1159: tmpfile = argv[2]; ! 1160: argc--; ! 1161: argv++; ! 1162: break; ! 1163: default: ! 1164: usage(); ! 1165: break; ! 1166: } ! 1167: ! 1168: argc--; ! 1169: argv++; ! 1170: } ! 1171: ! 1172: if ( yflag+nflag > 1 ) ! 1173: usage(); ! 1174: ! 1175: mdaction = ( yflag ? YES : ! 1176: nflag ? NO : ASK ); ! 1177: ! 1178: if ( argc > 1 ) ! 1179: retval = allfsck(argv+1); ! 1180: else { ! 1181: getlist(); ! 1182: retval = allfsck(filelist); ! 1183: } ! 1184: exit(retval); ! 1185: } ! 1186: ! 1187: ! 1188: /* ! 1189: * perform fsck on each of the individual filesystem in list ! 1190: */ ! 1191: ! 1192: allfsck(fsl) ! 1193: register char **fsl; ! 1194: { ! 1195: int fatal(); ! 1196: int retval = 0; ! 1197: ! 1198: sync(); ! 1199: statit("/", fatal); ! 1200: rootdev = stats.st_dev; ! 1201: while (*fsl != NULL) ! 1202: retval |= fsck(*fsl++); ! 1203: return(retval); ! 1204: } ! 1205: ! 1206: /* ! 1207: * get the names of the filesystems from the default file ! 1208: * checklistfile (e.g. /etc/checklist) ! 1209: */ ! 1210: ! 1211: getlist() ! 1212: { ! 1213: int fd; ! 1214: int index, size; ! 1215: ! 1216: if ( (fd = open(checklistfile, 0)) == (-1) ) ! 1217: fatal("Can't open checklist file: %s", checklistfile); ! 1218: ! 1219: index = 0; ! 1220: while ( ((size = getword(fd)) != 0) && (index < NFILSYS) ) { ! 1221: filelist[index] = malloc( size ); ! 1222: strcpy(filelist[index++], word); ! 1223: } ! 1224: ! 1225: if (size != 0) ! 1226: fatal("Too many file systems in checklist file: %s", ! 1227: checklistfile); ! 1228: ! 1229: filelist[index] = NULL; ! 1230: ! 1231: close(fd); ! 1232: } ! 1233: ! 1234: /* ! 1235: * read in the next "word" from file with descriptor fd ! 1236: * return the length of the word. ! 1237: */ ! 1238: ! 1239: getword(fd) ! 1240: int fd; ! 1241: { ! 1242: int n = 0, num; ! 1243: char *cp = word; ! 1244: char ch; ! 1245: ! 1246: while ( ( (num=read(fd, &ch, 1)) == 1 ) && ! 1247: ( (ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r') ) ); ! 1248: ! 1249: if (num != 1) ! 1250: return(0); ! 1251: ! 1252: do { ! 1253: *cp++ = ch; ! 1254: } while ( (++n < MAXCH) && (read(fd, &ch, 1) == 1) && ! 1255: (ch != ' ') && (ch != '\t') && (ch != '\n') && (ch != '\r') ); ! 1256: ! 1257: *cp = '\0'; ! 1258: ! 1259: return(n+1); ! 1260: } ! 1261: ! 1262: /* ! 1263: * perform fsck on the given filesystem ! 1264: */ ! 1265: fsck(name) ! 1266: char *name; ! 1267: { ! 1268: int retval = 1; ! 1269: int nonfatal(); ! 1270: ! 1271: fsname = name; /* file system name */ ! 1272: errflag = FALSE; ! 1273: statit(fsname, nonfatal); ! 1274: fsysrdev = stats.st_rdev; ! 1275: if ( errflag ) ! 1276: return(retval); ! 1277: changeflg = FALSE; ! 1278: init(); ! 1279: if ( sflag = ((gsflag && !mounted) || gSflag) ) ! 1280: printf("Switch \"-s\" selected to automatically rebuild free lists\n"); ! 1281: if (!sflag && gsflag) ! 1282: printf("Ignoring \"-s\" on mounted file system\n"); ! 1283: if ( !errflag ) { ! 1284: phase1(); /* check blocks and sizes */ ! 1285: if ( !fflag ) { ! 1286: phase2(); /* check pathnames */ ! 1287: phase3(); /* check connectivity */ ! 1288: phase4(); /* check reference counts */ ! 1289: } ! 1290: phase5(); /* check free list */ ! 1291: phase6(); /* salvage free list */ ! 1292: retval = cleanup(); ! 1293: } ! 1294: return(retval); ! 1295: } ! 1296: ! 1297: usage() ! 1298: { ! 1299: printf("\ ! 1300: Usage: /etc/fsck [-y] [-n] [-q] [-f] [-{sS}] [-t TMPFILE] [filesystem ...]\n"); ! 1301: _exit(1); ! 1302: } ! 1303: @ ! 1304: ! 1305: ! 1306: 1.2 ! 1307: log ! 1308: @update provided by epstein ! 1309: @ ! 1310: text ! 1311: @d6 1 ! 1312: a6 1 ! 1313: * /etc/fsck [-y] [-n] [-q] [-f] [-s] [-t TMPFILE] [filesystem ...] ! 1314: d21 7 ! 1315: a27 3 ! 1316: * interleaving as well). Option -t sets the temporary file to use ! 1317: * for disk caching of necessary tables on filesystems which are too ! 1318: * big to do in core. The temporary file defaults to "/dev/rram1", ! 1319: d37 2 ! 1320: d76 3 ! 1321: d80 1 ! 1322: a80 1 ! 1323: sflag = TRUE; ! 1324: d203 4 ! 1325: d224 1 ! 1326: a224 1 ! 1327: Usage: /etc/fsck [-y] [-n] [-q] [-f] [-s] [-t TMPFILE] [filesystem ...]\n"); ! 1328: @ ! 1329: ! 1330: ! 1331: 1.1 ! 1332: log ! 1333: @Initial revision ! 1334: @ ! 1335: text ! 1336: @d6 1 ! 1337: a6 1 ! 1338: * /etc/fsck [-y] [-n] [-q] [-f] [-t TMPFILE] [filesystem ...] ! 1339: d17 8 ! 1340: a24 4 ! 1341: * counts. Option -t sets the temporary file to use for disk caching ! 1342: * of necessary tables on filesystems which are too big to do in core. ! 1343: * The temporary file defaults to "/dev/rram1", which must be there. ! 1344: * ! 1345: d33 3 ! 1346: a35 2 ! 1347: int qflag=FALSE; /* fsck quiet flag */ ! 1348: int fflag=FALSE; /* fsck fast flag */ ! 1349: d70 3 ! 1350: d211 1 ! 1351: a211 1 ! 1352: Usage: /etc/fsck [-y] [-n] [-q] [-f] [-t TMPFILE] [filesystem ...]\n"); ! 1353: @ ! 1354: g ! 1355: @Initial revision ! 1356: @ ! 1357: text ! 1358: @d6 1 ! 1359: a6 1 ! 1360: * /etc/fsck [-y] [-n] [-q] [-f] [-t TMPFILE] [filesystem ...] ! 1361: d17 8 ! 1362: a24 4 ! 1363: * counts. Option -t sets the temporary file to use for disk caching ! 1364: * of necessary tables on filesystems which are too big to do in core. ! 1365: * The temporary file defaults to "/dev/rram1", which must be there. ! 1366: * ! 1367: d33 3 ! 1368: a35 2 ! 1369: int qflag=FALSfsck/RCS/phase1.c,v 444 3 3 16554 4771205175 7220 head 1.2; ! 1370: access ; ! 1371: symbols ; ! 1372: locks bin:1.2; ! 1373: comment @ * @; ! 1374: ! 1375: ! 1376: 1.2 ! 1377: date 91.03.18.18.43.50; author bin; state Exp; ! 1378: branches ; ! 1379: next 1.1; ! 1380: ! 1381: 1.1 ! 1382: date 91.02.05.16.36.59; author bin; state Exp; ! 1383: branches ; ! 1384: next ; ! 1385: ! 1386: ! 1387: desc ! 1388: @prov by epstein ! 1389: @ ! 1390: ! 1391: ! 1392: 1.2 ! 1393: log ! 1394: @update provided by epstein ! 1395: @ ! 1396: text ! 1397: @/* ! 1398: * phase 1 of fsck - Check Blocks and Sizes ! 1399: */ ! 1400: ! 1401: #include "fsck.h" ! 1402: ! 1403: char databuf[BSIZE]; /* buffer for blocks */ ! 1404: ! 1405: int clrflg; /* indicates when to clear an inode */ ! 1406: int dupflag; /* indicates whether there are any dups */ ! 1407: ! 1408: int numbad; /* number of bad blocks in the inode */ ! 1409: int numdup; /* number of duplicate blocks in inode */ ! 1410: long numblks; /* number of data blks for size check */ ! 1411: long sparsecnt; /* count for sparse blocks for size check */ ! 1412: ! 1413: /* The following is a table of the number of direct blocks pointed at by the ! 1414: * four types of blocks direct, ..., triple-indirect, to help count sparse ! 1415: * blocks. ! 1416: */ ! 1417: ! 1418: daddr_t blockcnt[] = {1, (daddr_t)NBN, (daddr_t)NBN*NBN, (daddr_t)NBN*NBN*NBN}; ! 1419: ! 1420: phase1() ! 1421: { ! 1422: if (!qflag) ! 1423: printf("Phase 1 : Check Blocks and Sizes\n"); ! 1424: dupflag = FALSE; ! 1425: inodescan(); ! 1426: if (dupflag) ! 1427: phase1b(); ! 1428: } ! 1429: ! 1430: inodescan() ! 1431: { ! 1432: register daddr_t bn; ! 1433: register struct dinode *dip; ! 1434: register ino_t ino; ! 1435: int i; ! 1436: ! 1437: ino = 1; ! 1438: ! 1439: for (bn=INODEI; bn<isize; bn++) { ! 1440: if (testblock(bn)) { /* block is bad via inode 1 */ ! 1441: ino += INOPB; ! 1442: continue; ! 1443: } ! 1444: bread(bn, databuf); ! 1445: clrflg = FALSE; ! 1446: dip = (struct dinode *) databuf; ! 1447: for (i=0; i<INOPB; i++) { ! 1448: candino(dip); ! 1449: if (inuse(dip) == TRUE) { ! 1450: if (!fflag) ! 1451: checkmode(dip, ino); ! 1452: if ( checkblks(dip, ino) != STOP ) ! 1453: if ( qflag == FALSE ) ! 1454: checksize(dip, ino); ! 1455: } ! 1456: candino(dip); ! 1457: ino++; ! 1458: dip++; ! 1459: } ! 1460: if (clrflg) ! 1461: bwrite(bn, databuf); ! 1462: } ! 1463: } ! 1464: ! 1465: /* ! 1466: * Determine if the given inode is in use. ! 1467: */ ! 1468: ! 1469: inuse(dip) ! 1470: register struct dinode *dip; ! 1471: { ! 1472: #ifdef NOT_ALL_ZERO_INODE ! 1473: ! 1474: if ( (dip->di_mode != 0) || (dip->di_nlink != 0) ) ! 1475: return(TRUE); ! 1476: else ! 1477: return(FALSE); ! 1478: #endif ! 1479: #ifdef ALL_ZERO_INODE ! 1480: ! 1481: register char *ptr; ! 1482: register struct dinode *next; ! 1483: ! 1484: ptr = (char *) dip; ! 1485: next = dip + 1; ! 1486: while (ptr < next) ! 1487: if (*ptr++ != 0) ! 1488: return(TRUE); ! 1489: ! 1490: return(FALSE); ! 1491: #endif ! 1492: } ! 1493: ! 1494: /* ! 1495: * Check the mode of the given inode ! 1496: */ ! 1497: ! 1498: checkmode(dip, ino) ! 1499: register struct dinode *dip; ! 1500: register ino_t ino; ! 1501: { ! 1502: register unsigned short mode; ! 1503: ! 1504: mode = dip->di_mode & IFMT; ! 1505: ! 1506: switch (mode) { ! 1507: case IFREG: ! 1508: setflags(ino, IREG); ! 1509: return; ! 1510: case IFDIR: ! 1511: setflags(ino, IDIR); ! 1512: return; ! 1513: case IFCHR: ! 1514: setflags(ino, ICHR); ! 1515: return; ! 1516: case IFBLK: ! 1517: setflags(ino, IBLK); ! 1518: return; ! 1519: case IFPIPE: ! 1520: setflags(ino, IPIPE); ! 1521: return; ! 1522: default: ! 1523: setflags(ino, UNKNOWN); ! 1524: break; ! 1525: } ! 1526: ! 1527: switch ( query("Unknown File Type i-number = %u (Clear)", ino) ){ ! 1528: case NO: ! 1529: return; ! 1530: case YES: ! 1531: zeroinode(dip); ! 1532: setflags(ino, UNALLOC); ! 1533: clrflg = TRUE; ! 1534: break; ! 1535: } ! 1536: } ! 1537: ! 1538: /* ! 1539: * Zero the given inode ! 1540: */ ! 1541: ! 1542: zeroinode(dip) ! 1543: struct dinode *dip; ! 1544: { ! 1545: register char *ptr; ! 1546: register struct dinode *next; ! 1547: ! 1548: lostsize += dip->di_size; ! 1549: next = dip+1; ! 1550: ptr = (char *) dip; ! 1551: ! 1552: while (ptr < next) ! 1553: *ptr++ = 0; ! 1554: ! 1555: } ! 1556: ! 1557: /* ! 1558: * Check the blocks associated with the given inode to determine ! 1559: * if any are bad or duplicate ! 1560: */ ! 1561: ! 1562: checkblks(dip, ino) ! 1563: struct dinode *dip; ! 1564: ino_t ino; ! 1565: { ! 1566: daddr_t addrs[NADDR]; ! 1567: register daddr_t bn; ! 1568: register int i, lev; ! 1569: register int mode; ! 1570: ! 1571: mode = dip->di_mode & IFMT; ! 1572: ! 1573: if ( (mode != IFREG) && (mode != IFDIR) ) ! 1574: return(STOP); ! 1575: ! 1576: l3tol(addrs, dip->di_addr, NADDR); ! 1577: ! 1578: numbad = /* number of bad blocks so far */ ! 1579: numdup = /* num dup blocks so far THIS INODE */ ! 1580: numblks = /* num used data blocks for size chk */ ! 1581: sparsecnt = 0; /* count of missed data blocks */ ! 1582: ! 1583: for(i=0; i<NADDR; i++) ! 1584: for (lev=0; lev<4; lev++) ! 1585: if (i < offsets[lev]) { ! 1586: if ( (bn=addrs[i]) != 0 ) { ! 1587: if (doblocks(bn, ino, lev) != OK) ! 1588: return(STOP); ! 1589: } else ! 1590: sparsecnt += blockcnt[lev]; ! 1591: break; ! 1592: } ! 1593: return(OK); ! 1594: } ! 1595: ! 1596: /* ! 1597: * Checks recursively the blocks pointed at via ! 1598: * the inode list of blocks. 'bn' is the block number, ! 1599: * 'ino' is the inode referencing it, and 'lev' is the ! 1600: * level 0 == direct ... 3 = triple-indirect ! 1601: */ ! 1602: ! 1603: doblocks(bn, ino, lev) ! 1604: register daddr_t bn; ! 1605: ino_t ino; ! 1606: int lev; ! 1607: { ! 1608: char buf[BSIZE]; ! 1609: register daddr_t *bnptr; ! 1610: register char *end; ! 1611: register int flag; ! 1612: ! 1613: if (lev-- == 0) { /* we have a direct block */ ! 1614: numblks += sparsecnt + 1; ! 1615: sparsecnt = 0; ! 1616: return(dodirect(bn, ino)); ! 1617: } else { ! 1618: end = &buf[BSIZE]; ! 1619: if ( (flag=dodirect(bn, ino)) == OK ) { ! 1620: bread(bn, buf); ! 1621: bnptr = (long *) buf; ! 1622: while ( bnptr < end ) { ! 1623: bn = *bnptr++; ! 1624: candaddr(bn); ! 1625: if ( bn == 0 ) { ! 1626: sparsecnt += blockcnt[lev]; ! 1627: continue; ! 1628: } ! 1629: if ( doblocks(bn, ino, lev) == STOP ) ! 1630: return(STOP); ! 1631: } ! 1632: return(OK); ! 1633: } else ! 1634: return(flag); ! 1635: } ! 1636: } ! 1637: ! 1638: /* ! 1639: * Check the given block to determine if it is bad ! 1640: * or if it is a duplicate. 'ino' is the inode referencing it ! 1641: */ ! 1642: ! 1643: dodirect(bn, ino) ! 1644: register daddr_t bn; ! 1645: register ino_t ino; ! 1646: { ! 1647: register int flag; ! 1648: ! 1649: if ( (flag=checkbad(bn, ino)) == OK ) ! 1650: return( checkdup(bn, ino) ); ! 1651: else ! 1652: return(flag); ! 1653: } ! 1654: ! 1655: /* ! 1656: * Check the given block number for being bad. ! 1657: */ ! 1658: ! 1659: checkbad(bn, ino) ! 1660: register daddr_t bn; ! 1661: ino_t ino; ! 1662: { ! 1663: if ( (bn>=isize) && (bn<fsize) ) ! 1664: return(OK); ! 1665: ! 1666: else if ( (bn<isize) && (bn>=INODEI) && (ino == 1) ) { ! 1667: /* bad block is in */ ! 1668: totfree++; /* the inode blocks */ ! 1669: return(OK); ! 1670: } ! 1671: ! 1672: if (!fflag) ! 1673: orflags(ino, IBAD_IDUP); ! 1674: ! 1675: printf("Bad block %U, i-number = %u\n", bn, ino); ! 1676: ! 1677: if (numbad++ < MAXBADOK) ! 1678: return(BAD_DUP); ! 1679: ! 1680: switch ( query("Excessive Bad Blocks i-number = %u (Continue)", ino) ){ ! 1681: case NO: ! 1682: abort(); ! 1683: case YES: ! 1684: return(STOP); ! 1685: } ! 1686: } ! 1687: ! 1688: ! 1689: /* ! 1690: * Check the given block number for duplicate reference. ! 1691: */ ! 1692: ! 1693: checkdup(bn, ino) ! 1694: register daddr_t bn; ! 1695: ino_t ino; ! 1696: { ! 1697: if ( !testblock(bn) ) { ! 1698: markblock(bn); ! 1699: totfree--; ! 1700: return(OK); ! 1701: } ! 1702: ! 1703: dupflag = TRUE; ! 1704: if (!fflag) ! 1705: orflags(ino, IBAD_IDUP); ! 1706: printf("Dup Block %U, i-number = %u\n", bn, ino); ! 1707: ! 1708: if (totdups < DUPTBLSIZE) ! 1709: dupblck[totdups++] = bn; ! 1710: else { ! 1711: switch ( query("DUP Table Overflow (Continue)") ) { ! 1712: case NO: ! 1713: abort(); ! 1714: case YES: ! 1715: return(BAD_DUP); ! 1716: } ! 1717: } ! 1718: ! 1719: if (numdup++ < MAXDUPOK) ! 1720: return(BAD_DUP); ! 1721: ! 1722: switch ( query("Excessive Dup Blocks i-number = %u (Continue)", ino) ) { ! 1723: case NO: ! 1724: abort(); ! 1725: case YES: ! 1726: return(STOP); ! 1727: } ! 1728: } ! 1729: ! 1730: /* ! 1731: * Check For Possible File Size Error ! 1732: */ ! 1733: ! 1734: checksize(dip, ino) ! 1735: register struct dinode *dip; ! 1736: ino_t ino; ! 1737: { ! 1738: register int mode; ! 1739: register fsize_t size; ! 1740: ! 1741: mode = dip->di_mode & IFMT; ! 1742: size = dip->di_size; ! 1743: ! 1744: if ( mode == IFREG ) ! 1745: filesize(ino, size); ! 1746: else /* mode == IFDIR */ ! 1747: dirsize(dip, ino, size); ! 1748: } ! 1749: ! 1750: dirsize(dip, ino, size) ! 1751: struct dinode *dip; ! 1752: ino_t ino; ! 1753: register fsize_t size; ! 1754: { ! 1755: if ( size <= 0 ) { ! 1756: switch ( query("\ ! 1757: Bad Directory Size, size = %D, i-number = %u (Clear i-node)", size, ino) ) { ! 1758: case NO: ! 1759: break; ! 1760: case YES: ! 1761: zeroinode(dip); ! 1762: setflags(ino, UNALLOC); ! 1763: clrflg = TRUE; ! 1764: return; ! 1765: } ! 1766: } ! 1767: ! 1768: if ( size < (2*DSIZE) ) ! 1769: printf("Directory Size too small i-number = %u\n", ino); ! 1770: ! 1771: if ( size % sizeof(struct direct) != 0 ) ! 1772: printf("Directory Misaligned i-number = %u\n", ino); ! 1773: ! 1774: if (sizerr(size)) ! 1775: printf("Possible Directory Size Error i-number = %u\n", ino); ! 1776: } ! 1777: ! 1778: filesize(ino, size) ! 1779: ino_t ino; ! 1780: register fsize_t size; ! 1781: { ! 1782: if (sizerr(size)) ! 1783: printf("Possible File Size Error i-number = %u\n", ino); ! 1784: } ! 1785: ! 1786: sizerr(size) ! 1787: register fsize_t size; ! 1788: { ! 1789: register fsize_t calc; ! 1790: ! 1791: calc = (unsigned long)numblks*BSIZE; ! 1792: if ( (size > calc) || ( calc >= (size+BSIZE) ) ) ! 1793: return(TRUE); ! 1794: else ! 1795: return(FALSE); ! 1796: } ! 1797: @ ! 1798: ! 1799: ! 1800: 1.1 ! 1801: log ! 1802: @Initial revision ! 1803: @ ! 1804: text ! 1805: @d152 1 ! 1806: d252 1 ! 1807: a252 1 ! 1808: ! 1809: @ ! 1810: saligned i-number = %u\n", ino); ! 1811: ! 1812: if (sizerr(size)) ! 1813: printf("Possible Directory Size Error i-number = %u\n", ino); ! 1814: } ! 1815: ! 1816: filesize(ino, size) ! 1817: ino_t infsck/RCS/phase1b.c,v 444 3 3 4676 4753557476 7362 head 1.1; ! 1818: access ; ! 1819: symbols ; ! 1820: locks ; ! 1821: comment @ * @; ! 1822: ! 1823: ! 1824: 1.1 ! 1825: date 91.02.05.16.37.12; author bin; state Exp; ! 1826: branches ; ! 1827: next ; ! 1828: ! 1829: ! 1830: desc ! 1831: @prov by epstein ! 1832: @ ! 1833: ! 1834: ! 1835: ! 1836: 1.1 ! 1837: log ! 1838: @Initial revision ! 1839: @ ! 1840: text ! 1841: @/* ! 1842: * Phase 1b of fsck - Rescan for more Dups ! 1843: */ ! 1844: ! 1845: #include "fsck.h" ! 1846: ! 1847: extern int numdup; /* declared in phase1.c */ ! 1848: ! 1849: phase1b() ! 1850: { ! 1851: if (!qflag) ! 1852: printf("Phase 1b: Rescan for more Dups\n"); ! 1853: buildtable(); ! 1854: iscanb(); ! 1855: } ! 1856: ! 1857: buildtable() ! 1858: { ! 1859: unsigned cntr=0, numdiff=0; ! 1860: daddr_t bn; ! 1861: ! 1862: while (cntr<totdups) { ! 1863: bn = dupblck[cntr++]; ! 1864: if (!testdup(bn)) { ! 1865: markdup(bn); ! 1866: numdiff++; ! 1867: } ! 1868: } ! 1869: totdups = numdiff; ! 1870: } ! 1871: ! 1872: iscanb() ! 1873: { ! 1874: register daddr_t bn; ! 1875: register struct dinode *dip; ! 1876: register ino_t ino; ! 1877: int i; ! 1878: ! 1879: ino = 1; ! 1880: ! 1881: for (bn=INODEI; bn<isize; bn++) { ! 1882: if (testblock(bn)) { /* block is bad via inode 1 */ ! 1883: ino += INOPB; ! 1884: continue; ! 1885: } ! 1886: bread(bn, databuf); ! 1887: dip = (struct dinode *) databuf; ! 1888: for (i=0; i<INOPB; i++) { ! 1889: candino(dip); ! 1890: if (inuse(dip) == TRUE) ! 1891: ckblksb(dip, ino); ! 1892: if (totdups == 0) ! 1893: return; ! 1894: ino++; ! 1895: dip++; ! 1896: } ! 1897: } ! 1898: } ! 1899: ! 1900: /* ! 1901: * Check the blocks associated with the given inode to find the ! 1902: * remaining duplicate blocks ! 1903: */ ! 1904: ! 1905: ckblksb(dip, ino) ! 1906: register struct dinode *dip; ! 1907: register ino_t ino; ! 1908: { ! 1909: daddr_t addrs[NADDR]; ! 1910: int i, lev; ! 1911: int mode; ! 1912: ! 1913: mode = dip->di_mode & IFMT; ! 1914: ! 1915: if ( (mode != IFREG) && (mode != IFDIR) ) ! 1916: return; ! 1917: ! 1918: l3tol(addrs, dip->di_addr, NADDR); ! 1919: ! 1920: numdup = 0; /* num dup blocks so far THIS INODE */ ! 1921: ! 1922: for(i=0; i<NADDR; i++) ! 1923: for (lev=0; lev<4; lev++) ! 1924: if (i < offsets[lev]) { ! 1925: dblocksb(addrs[i], ino, lev); ! 1926: break; ! 1927: } ! 1928: } ! 1929: ! 1930: /* ! 1931: * Checks recursively the blocks pointed at via ! 1932: * the inode list of blocks. 'bn' is the block number, ! 1933: * 'ino' is the inode referencing it, and 'lev' is the ! 1934: * level 0 == direct ... 3 = triple-indirect ! 1935: */ ! 1936: ! 1937: dblocksb(bn, ino, lev) ! 1938: daddr_t bn; ! 1939: ino_t ino; ! 1940: int lev; ! 1941: { ! 1942: char buf[BSIZE]; ! 1943: int i; ! 1944: daddr_t *bnptr; ! 1945: ! 1946: if (bn == 0) ! 1947: return(OK); ! 1948: ! 1949: switch ( cdupb(bn, ino) ) { ! 1950: case OK: ! 1951: if (lev--==0) ! 1952: return(OK); ! 1953: bread(bn, buf); ! 1954: bnptr = (long *) buf; ! 1955: for (i=0; i<NBN; i++) { ! 1956: bn = bnptr[i]; ! 1957: candaddr(bn); ! 1958: if ( dblocksb(bn, ino, lev) == STOP ) ! 1959: return(STOP); ! 1960: } ! 1961: return(OK); ! 1962: case STOP: ! 1963: return(STOP); ! 1964: } ! 1965: } ! 1966: ! 1967: /* ! 1968: * Check the given block number for duplicate reference. ! 1969: */ ! 1970: ! 1971: cdupb(bn, ino) ! 1972: daddr_t bn; ! 1973: ino_t ino; ! 1974: { ! 1975: if ( !testdup(bn) ) ! 1976: return(OK); ! 1977: ! 1978: totdups--; ! 1979: unmarkdup(bn); ! 1980: if (!fflag) ! 1981: orflags(ino, IBAD_IDUP); ! 1982: printf("Dup Block %U, i-number = %u\n", bn, ino); ! 1983: ! 1984: return(STOP); ! 1985: } ! 1986: @ ! 1987: ) ! 1988: return(OK); ! 1989: bread(bn, buf); ! 1990: bnptr = (long *) buf; ! 1991: for (fsck/RCS/phase2.c,v 444 3 3 17750 4771205232 7212 head 1.2; ! 1992: access ; ! 1993: symbols ; ! 1994: locks bin:1.2; ! 1995: comment @ * @; ! 1996: ! 1997: ! 1998: 1.2 ! 1999: date 91.03.18.18.44.18; author bin; state Exp; ! 2000: branches ; ! 2001: next 1.1; ! 2002: ! 2003: 1.1 ! 2004: date 91.02.05.16.37.24; author bin; state Exp; ! 2005: branches ; ! 2006: next ; ! 2007: ! 2008: ! 2009: desc ! 2010: @prov by epstein ! 2011: @ ! 2012: ! 2013: ! 2014: 1.2 ! 2015: log ! 2016: @update provided by epstein ! 2017: @ ! 2018: text ! 2019: @/* ! 2020: * phase 2 of fsck - Check Pathnames ! 2021: */ ! 2022: ! 2023: #include "fsck.h" ! 2024: #include <pwd.h> ! 2025: ! 2026: #define MAXDEPTH 50 ! 2027: struct direct *path[MAXDEPTH]; ! 2028: int depth; ! 2029: int fixflag; /* flags when must rewrite databuf */ ! 2030: daddr_t blocknum; /* Current block num read in */ ! 2031: ! 2032: typedef struct list { ! 2033: struct direct d_entry; ! 2034: struct list *next; ! 2035: } list; ! 2036: ! 2037: char buf2[BSIZE]; /* buffer for blocks */ ! 2038: daddr_t cdbn; /* current logical block number */ ! 2039: ! 2040: /* Format errors, args to blkerr() */ ! 2041: ! 2042: #define NULLNAME 5 ! 2043: #define NULLPAD 6 ! 2044: #define SLASHES 7 ! 2045: #define DOT 8 ! 2046: #define DOTDOT 9 ! 2047: ! 2048: phase2() ! 2049: { ! 2050: if (!qflag) ! 2051: printf("Phase 2 : Check Pathnames\n"); ! 2052: checkroot(); ! 2053: depth = 0; ! 2054: checkpath(ROOTIN); ! 2055: } ! 2056: ! 2057: ! 2058: checkroot() ! 2059: { ! 2060: if ( (flags(ROOTIN)&MODEMASK) == UNALLOC ) ! 2061: fatal("Root i-node is unallocated. Terminating"); ! 2062: ! 2063: if ( (flags(ROOTIN)&MODEMASK) != IDIR ) { ! 2064: switch ( query("Root i-node is not a directory (FIX)") ){ ! 2065: case YES: ! 2066: fixroot(); ! 2067: break; ! 2068: case NO: ! 2069: abort(); ! 2070: } ! 2071: } ! 2072: ! 2073: if ( badblks(ROOTIN) ){ ! 2074: switch ( query("Dup/Bad blocks in root i-node (Continue)") ) { ! 2075: case YES: ! 2076: break; ! 2077: case NO: ! 2078: abort(); ! 2079: } ! 2080: } ! 2081: linkincr(ROOTIN); /* (?) Feature (?) of mkfs is */ ! 2082: /* that root inode of a file */ ! 2083: /* system has a link count one */ ! 2084: /* too large. */ ! 2085: } ! 2086: ! 2087: fixroot() ! 2088: { ! 2089: register struct dinode *dip; ! 2090: ! 2091: if (!writeflg) ! 2092: fatal("File System Read-Only (NO WRITE)\n"); ! 2093: ! 2094: setflags(ROOTIN, (flags(ROOTIN) & ~MODEMASK) | IDIR); ! 2095: ! 2096: /* Save change to disk */ ! 2097: ! 2098: dip = ptrino(ROOTIN, databuf); ! 2099: dip->di_mode &= (~IFMT); ! 2100: dip->di_mode |= IFDIR; ! 2101: writeino(ROOTIN, databuf); ! 2102: } ! 2103: ! 2104: #define myinum ( (depth>0) ? path[depth-1]->d_ino : ROOTIN ) ! 2105: #define popinum ( (depth>1) ? path[depth-2]->d_ino : ROOTIN ) ! 2106: ! 2107: char *memory = "Can't malloc memory, phase 2"; ! 2108: ! 2109: list * ! 2110: procfiles(addrs, length) ! 2111: daddr_t *addrs; ! 2112: fsize_t length; ! 2113: { ! 2114: register struct direct *elemnt; ! 2115: register list *first, *ptr; ! 2116: ! 2117: if ((first=ptr=(list *)malloc(sizeof(list)))==NULL) ! 2118: fatal(memory); ! 2119: first->d_entry.d_ino = 0; ! 2120: first->next = NULL; ! 2121: if ( length < DSIZE ) ! 2122: return( first ); ! 2123: cdbn = 0; ! 2124: nextblock(addrs); ! 2125: fixflag = FALSE; ! 2126: elemnt = (struct direct *) databuf; ! 2127: cdots(elemnt++, ".", myinum, DOT); ! 2128: ++numfiles; ! 2129: if ( (length-=DSIZE) < DSIZE ) ! 2130: return( first ); ! 2131: cdots(elemnt++, "..", popinum, DOTDOT); ! 2132: ++numfiles; ! 2133: length -= DSIZE; ! 2134: ! 2135: while ( length >= DSIZE ) { ! 2136: while ( (elemnt<&databuf[BSIZE]) && (length>=DSIZE) ) { ! 2137: if (chck(elemnt)==IDIR) { ! 2138: copy(elemnt, &ptr->d_entry, ! 2139: sizeof(struct direct)); ! 2140: if ((ptr->next=(list *)malloc(sizeof(list))) == ! 2141: NULL) ! 2142: fatal(memory); ! 2143: ptr = ptr->next; ! 2144: ptr->d_entry.d_ino = 0; ! 2145: ptr->next = NULL; ! 2146: } ! 2147: elemnt++; ! 2148: length -= DSIZE; ! 2149: } ! 2150: if (fixflag && (fixblock(addrs) == NUL) ) ! 2151: fixblkerr(); ! 2152: nextblock(addrs); ! 2153: fixflag = FALSE; ! 2154: elemnt = (struct direct *) databuf; ! 2155: } ! 2156: return(first); ! 2157: } ! 2158: ! 2159: candblock(dptr) ! 2160: register struct direct *dptr; ! 2161: { ! 2162: register int num, i; ! 2163: ! 2164: num = BSIZE/sizeof(struct direct); ! 2165: for (i=0; i<num; i++) ! 2166: canino(dptr[i].d_ino); ! 2167: } ! 2168: ! 2169: nextblock(addrs) ! 2170: register daddr_t *addrs; ! 2171: { ! 2172: register daddr_t bn; ! 2173: ! 2174: if ( (bn=imap(addrs, cdbn++)) == 0 ) { ! 2175: bclear(databuf, BSIZE); ! 2176: return; ! 2177: } ! 2178: bread(bn, databuf); ! 2179: candblock(databuf); ! 2180: blocknum = bn; ! 2181: } ! 2182: ! 2183: fixblock(addrs) ! 2184: daddr_t *addrs; ! 2185: { ! 2186: daddr_t bn; ! 2187: ! 2188: if ( (bn=imap(addrs, cdbn-1)) == 0 ) ! 2189: return(NUL); ! 2190: candblock(databuf); ! 2191: bwrite(bn, databuf); ! 2192: return(TRUE); ! 2193: } ! 2194: ! 2195: fixblkerr() ! 2196: { ! 2197: fatal("Fixblock error."); ! 2198: } ! 2199: ! 2200: copy(from, to, size) ! 2201: register char *from, *to; ! 2202: register int size; ! 2203: { ! 2204: while (size--) ! 2205: *to++=*from++; ! 2206: } ! 2207: ! 2208: cdots(elemnt, dots, ino, type) ! 2209: register struct direct *elemnt; ! 2210: char *dots; ! 2211: ino_t ino; /* what the inode number should be */ ! 2212: int type; ! 2213: { ! 2214: register char *name = elemnt->d_name; ! 2215: register ino_t inum; ! 2216: ! 2217: inum = elemnt->d_ino; ! 2218: if ( (strcmp(name, dots) != 0) || (inum != ino) || ! 2219: (format(name) != GOOD) ) { ! 2220: blkerr(type); ! 2221: return; ! 2222: } ! 2223: linkincr(inum); ! 2224: } ! 2225: ! 2226: format(name) ! 2227: register char *name; ! 2228: { ! 2229: register char *ptr=name; ! 2230: register char *end=&name[DIRSIZ]; ! 2231: ! 2232: while ( (ptr<end) && (*ptr++ != '\0') ) ; ! 2233: ! 2234: if ( (ptr-1) == name ) ! 2235: return(NULLNAME); ! 2236: ! 2237: if (ptr<end) { ! 2238: while ( (ptr<end) && (*ptr++ == '\0') ) ; ! 2239: if (ptr!=end) ! 2240: return(NULLPAD); ! 2241: } ! 2242: ! 2243: ptr = name; ! 2244: while (ptr < end) ! 2245: if (*ptr++ == '/') ! 2246: return(SLASHES); ! 2247: ! 2248: return(GOOD); ! 2249: } ! 2250: ! 2251: ! 2252: blkerr(type) ! 2253: int type; ! 2254: { ! 2255: char *errname; ! 2256: ! 2257: switch(type) { ! 2258: case NULLNAME: ! 2259: errname = "Null name"; ! 2260: break; ! 2261: case NULLPAD: ! 2262: errname = "Non null padded"; ! 2263: break; ! 2264: case SLASHES: ! 2265: errname = "Embedded slashes in"; ! 2266: break; ! 2267: case DOT: ! 2268: errname = "Inconsistent ."; ! 2269: break; ! 2270: case DOTDOT: ! 2271: errname = "Inconsistent .."; ! 2272: break; ! 2273: default: ! 2274: errname = "Bad"; ! 2275: break; ! 2276: } ! 2277: ! 2278: printf("%s entry in block %U in directory\n", errname, blocknum); ! 2279: pinfo(myinum); ! 2280: pname(path[--depth]->d_name); ! 2281: depth++; ! 2282: } ! 2283: ! 2284: chck(elemnt) ! 2285: register struct direct *elemnt; ! 2286: { ! 2287: register ino_t inum; ! 2288: register char *name; ! 2289: int type; ! 2290: ! 2291: inum = elemnt->d_ino; ! 2292: if ( inum == 0 ) ! 2293: return(UNALLOC); ! 2294: ! 2295: name = elemnt->d_name; ! 2296: if ( (type=format(name)) != GOOD ) ! 2297: blkerr(type); ! 2298: ! 2299: if (inum>ninodes) { ! 2300: if ( irange(inum, name) ) ! 2301: zeroent(elemnt); ! 2302: return(UNALLOC); ! 2303: } ! 2304: ! 2305: if ( (flags(inum)&ALLOCMASK)==UNALLOC ) { ! 2306: if ( unalloc(inum, name) ) ! 2307: zeroent(elemnt); ! 2308: return(UNALLOC); ! 2309: } ! 2310: ! 2311: if ( badblks(inum) ) { ! 2312: if ( baddup(inum, name) ) { ! 2313: zeroent(elemnt); ! 2314: return(UNALLOC); ! 2315: } ! 2316: if ( (flags(inum)&MODEMASK)==IDIR ) ! 2317: return(UNALLOC); ! 2318: } ! 2319: ! 2320: linkincr(inum); ! 2321: numfiles++; ! 2322: return( flags(inum)&MODEMASK ); ! 2323: } ! 2324: ! 2325: zeroent(elemnt) ! 2326: struct direct *elemnt; ! 2327: { ! 2328: elemnt->d_ino = 0; ! 2329: fixflag = TRUE; ! 2330: } ! 2331: ! 2332: pname(name) ! 2333: char *name; ! 2334: { ! 2335: int i=0; ! 2336: ! 2337: while (i<depth) ! 2338: prdirsize(path[i++]->d_name); ! 2339: prdirsize(name); ! 2340: putchar('\n'); ! 2341: } ! 2342: ! 2343: prdirsize(name) ! 2344: char *name; ! 2345: { ! 2346: if (name[DIRSIZ-1] == '\0') ! 2347: printf("/%s", name); ! 2348: else ! 2349: printf("/%*s", DIRSIZ, name); ! 2350: } ! 2351: ! 2352: fsize_t ! 2353: pinfo(inum) ! 2354: ino_t inum; ! 2355: { ! 2356: register struct dinode *dip; ! 2357: register struct passwd *pwd; ! 2358: ! 2359: if ( (dip=ptrino(inum, buf2)) == NULL ) { ! 2360: printf("i-number = %u is in a bad inode block.\n", inum); ! 2361: return(0); ! 2362: } ! 2363: ! 2364: printf("i-number = %u, ", inum); ! 2365: if ( (pwd=getpwuid(dip->di_uid)) != NULL ) ! 2366: printf("Owner=%s, ", pwd->pw_name); ! 2367: else ! 2368: printf("Owner=%u, ", dip->di_uid); ! 2369: printf(" Mode=0%o\n", dip->di_mode); ! 2370: printf("Size=%U, Mtime=%s", dip->di_size, ctime(&dip->di_mtime)); ! 2371: return(dip->di_size); ! 2372: } ! 2373: ! 2374: char *remove = "(Remove)"; ! 2375: ! 2376: irange(inum, name) ! 2377: ino_t inum; ! 2378: char *name; ! 2379: { ! 2380: printf("I-number is out of range I=%u\n", inum); ! 2381: pname(name); ! 2382: return(action(remove)); ! 2383: } ! 2384: ! 2385: unalloc(inum, name) ! 2386: ino_t inum; ! 2387: char *name; ! 2388: { ! 2389: fsize_t size; ! 2390: ! 2391: printf("Unallocated\n"); ! 2392: size = pinfo(inum); ! 2393: pname(name); ! 2394: if ( (daction != NO) && (size == 0) && (mounted == FALSE) ) { ! 2395: printf("%s [Forced - Yes]\n", remove); ! 2396: return(YES); ! 2397: } ! 2398: return(action(remove)); ! 2399: } ! 2400: ! 2401: baddup(inum, name) ! 2402: ino_t inum; ! 2403: char *name; ! 2404: { ! 2405: register int mode = flags(inum)&MODEMASK; ! 2406: ! 2407: printf("Bad or Dup blocks in %s\n",(mode==IDIR) ? "Directory" : "File"); ! 2408: pinfo(inum); ! 2409: pname(name); ! 2410: return(action(remove)); ! 2411: } ! 2412: ! 2413: checkpath(ino) ! 2414: register ino_t ino; ! 2415: { ! 2416: static daddr_t addrs[NADDR]; ! 2417: static struct dinode *dip; ! 2418: static list *temp; ! 2419: register list *ptr; ! 2420: ! 2421: if ( (flags(ino)&VISITED)==VISITED ) { ! 2422: circle(ino); ! 2423: return; ! 2424: } else ! 2425: orflags(ino, VISITED); ! 2426: ! 2427: dip = ptrino(ino, databuf); ! 2428: l3tol(addrs, dip->di_addr, NADDR); ! 2429: ! 2430: if ( (dip->di_mode&IFMT) != IFDIR ) ! 2431: fatal("Tried to checkpath i-node %u which is not dir.\n", ino); ! 2432: ! 2433: ptr = procfiles(addrs, dip->di_size); ! 2434: ! 2435: while (ptr->d_entry.d_ino) { ! 2436: if (depth >= MAXDEPTH) ! 2437: toolong(); ! 2438: path[depth++] = &ptr->d_entry; ! 2439: checkpath(ptr->d_entry.d_ino); ! 2440: depth--; ! 2441: temp = ptr; ! 2442: ptr = ptr->next; ! 2443: free(temp); ! 2444: } ! 2445: free(ptr); ! 2446: } ! 2447: ! 2448: circle(ino) ! 2449: ino_t ino; ! 2450: { ! 2451: printf("I-node %u is a multiply referenced directory i-node.\n", ino); ! 2452: } ! 2453: ! 2454: toolong() ! 2455: { ! 2456: printf("Name too long.\n"); ! 2457: pname("\0"); ! 2458: abort(); ! 2459: } ! 2460: ! 2461: ! 2462: @ ! 2463: ! 2464: ! 2465: 1.1 ! 2466: log ! 2467: @Initial revision ! 2468: @ ! 2469: text ! 2470: @d102 3 ! 2471: d110 3 ! 2472: d114 2 ! 2473: a115 2 ! 2474: numfiles += 2; ! 2475: length -= 2*DSIZE; /* for the . & .. entries */ ! 2476: d127 1 ! 2477: @ ! 2478: r->d_entry.d_ino) { ! 2479: iffsck/RCS/phase3.c,v 444 3 3 12752 5050254731 7207 head 1.2; ! 2480: branch ; ! 2481: access ; ! 2482: symbols ; ! 2483: locks bin:1.2; ! 2484: comment @ * @; ! 2485: ! 2486: ! 2487: 1.2 ! 2488: date 91.08.08.09.48.33; author bin; state Exp; ! 2489: branches ; ! 2490: next 1.1; ! 2491: ! 2492: 1.1 ! 2493: date 91.02.05.16.37.54; author bin; state Exp; ! 2494: branches ; ! 2495: next ; ! 2496: ! 2497: ! 2498: desc ! 2499: @prov by epstein (post 310) ! 2500: @ ! 2501: ! 2502: ! 2503: 1.2 ! 2504: log ! 2505: @updated by epstein to properly handle directory allocations. ! 2506: @ ! 2507: text ! 2508: @/* ! 2509: * phase 3 of fsck - Check Connectivity ! 2510: */ ! 2511: ! 2512: #include "fsck.h" ! 2513: ! 2514: char *lostname = "lost+found"; ! 2515: ! 2516: phase3() ! 2517: { ! 2518: ino_t i; ! 2519: ! 2520: if (!qflag) ! 2521: printf("Phase 3 : Check Connectivity\n"); ! 2522: for (i=FIRSTIN; i<=ninodes; i++) ! 2523: if ( ((flags(i)&MODEMASK) == IDIR) && ! 2524: (linkctr(i) == 0) ) { ! 2525: orflags(i, UNREFDIR); ! 2526: markchildren(i); ! 2527: } ! 2528: ! 2529: for (i=FIRSTIN; i<ninodes; i++) ! 2530: if ( (flags(i)&(UNREFDIR|CHILDDIR)) == UNREFDIR ) ! 2531: unrefdir(i); ! 2532: } ! 2533: ! 2534: markchildren(ino) ! 2535: ino_t ino; ! 2536: { ! 2537: struct dinode *dip; ! 2538: struct direct *element; ! 2539: daddr_t addrs[NADDR]; ! 2540: ino_t inumber; ! 2541: fsize_t length; ! 2542: ! 2543: if ( badblks(ino) ) ! 2544: return; ! 2545: dip = ptrino(ino, databuf); ! 2546: if ( (length=dip->di_size) <= 0 ) ! 2547: return; ! 2548: l3tol(addrs, dip->di_addr, NADDR); ! 2549: cdbn = 0; ! 2550: nextblock(addrs); ! 2551: element = (struct direct *) databuf; ! 2552: element += 2; /* skip over . and .. entries */ ! 2553: if ( (length-=2*DSIZE) <= 0 ) ! 2554: return; ! 2555: ! 2556: while ( length >= DSIZE ) { ! 2557: while ( (element<&databuf[BSIZE]) && (length>=DSIZE) ) { ! 2558: if ( ((inumber=element->d_ino) != 0) && ! 2559: ((flags(inumber)&MODEMASK)==IDIR) && ! 2560: (inumber!=ino) ) ! 2561: orflags(inumber, CHILDDIR); ! 2562: element++; ! 2563: length -= DSIZE; ! 2564: } ! 2565: nextblock(addrs); ! 2566: element = (struct direct *) databuf; ! 2567: } ! 2568: } ! 2569: ! 2570: char *reconnect = "(Reconnect)"; ! 2571: ! 2572: unrefdir(ino) ! 2573: ino_t ino; ! 2574: { ! 2575: printf("Unref Dir\n"); ! 2576: if( (pinfo(ino) == 0) || (daction == NO) || (mounted == TRUE) ) { ! 2577: if ( action(reconnect) == FALSE ) ! 2578: return; ! 2579: } else ! 2580: printf("%s FORCED\n", reconnect); ! 2581: ! 2582: connect(ino, IDIR); ! 2583: } ! 2584: ! 2585: #define CONNECT 1 ! 2586: #define NOCONNECT 0 ! 2587: ! 2588: connect(ino, type) ! 2589: ino_t ino; ! 2590: int type; ! 2591: { ! 2592: ino_t lostino; ! 2593: struct dinode *dip; ! 2594: daddr_t addrs[NADDR]; ! 2595: fsize_t length; ! 2596: struct direct *element; ! 2597: int chgino = FALSE; ! 2598: ! 2599: if ( ((lostino=lostfound()) == NUL) || ! 2600: ((flags(lostino)&MODEMASK) != IDIR) || ! 2601: ( badblks(lostino) ) ) { ! 2602: nolost(); ! 2603: if (type==IDIR) ! 2604: traverse(NOCONNECT, ino, lostino); ! 2605: return(FAILURE); ! 2606: } ! 2607: ! 2608: dip = ptrino(lostino, buf2); ! 2609: l3tol(addrs, dip->di_addr, NADDR); ! 2610: length = dip->di_size; ! 2611: cdbn = 0; ! 2612: while ( length>=DSIZE ) { ! 2613: nextblock(addrs); ! 2614: element = (struct direct *) databuf; ! 2615: while ( element<&databuf[BSIZE] ) { ! 2616: length -= DSIZE; ! 2617: if ( element->d_ino == 0 ) { ! 2618: element->d_ino = ino; ! 2619: strncpy(element->d_name, nameit(ino), DIRSIZ); ! 2620: if ( fixblock(addrs) == NUL ) ! 2621: fixblkerr(); ! 2622: linkincr(ino); ! 2623: numfiles++; ! 2624: if ( length<0 ) { ! 2625: dip->di_size -= length; ! 2626: chgino = TRUE; ! 2627: } ! 2628: if ( (type == IDIR) && ! 2629: (connected(ino, lostino)==YES) ) { ! 2630: dip->di_nlink++; ! 2631: writeino(lostino, buf2); ! 2632: traverse(CONNECT, ino, lostino); ! 2633: } else if (chgino) { ! 2634: writeino(lostino, buf2); ! 2635: } ! 2636: return(SUCCESS); ! 2637: } ! 2638: element++; ! 2639: } ! 2640: } ! 2641: ! 2642: noroom(); ! 2643: if (type == IDIR) ! 2644: traverse(NOCONNECT, ino, lostino); ! 2645: return(FAILURE); ! 2646: } ! 2647: ! 2648: traverse(flag, ino, lostino) ! 2649: int flag; ! 2650: ino_t ino, lostino; ! 2651: { ! 2652: struct direct dirlost, nothing, newtree; ! 2653: ! 2654: dirinit(&dirlost, lostino, lostname); ! 2655: dirinit(¬hing, 0, "??"); ! 2656: dirinit(&newtree, ino, nameit(ino)); ! 2657: depth = 0; ! 2658: if (flag == CONNECT) ! 2659: path[depth++] = &dirlost; ! 2660: else ! 2661: path[depth++] = ¬hing; ! 2662: ! 2663: path[depth++] = &newtree; ! 2664: checkpath(ino); ! 2665: } ! 2666: ! 2667: dirinit(element, ino, name) ! 2668: struct direct *element; ! 2669: ino_t ino; ! 2670: char *name; ! 2671: { ! 2672: element->d_ino = ino; ! 2673: strncpy(element->d_name, name, DIRSIZ); ! 2674: } ! 2675: ! 2676: connected(ino, lostino) ! 2677: ino_t ino; /* inumber just reconnected */ ! 2678: ino_t lostino; /* inumber of lostfound directory */ ! 2679: { ! 2680: struct dinode *dip; ! 2681: daddr_t addrs[NADDR]; ! 2682: fsize_t length; ! 2683: struct direct *element; ! 2684: ! 2685: if ( badblks(ino) ) { ! 2686: badconnect(ino); ! 2687: return(NO); ! 2688: } ! 2689: dip = ptrino(ino, databuf); ! 2690: l3tol(addrs, dip->di_addr, NADDR); ! 2691: length = dip->di_size; ! 2692: cdbn = 0; ! 2693: while ( length >= DSIZE ) { ! 2694: nextblock(addrs); ! 2695: element = (struct direct *) databuf; ! 2696: while ( (element<&databuf[BSIZE]) && (length>=DSIZE) ) { ! 2697: if ( strcmp(element->d_name, "..") == 0 ) { ! 2698: printf("Dir i-number = %u connected. ", ino); ! 2699: printf("Parent was i-number = %u.\n", ! 2700: element->d_ino); ! 2701: element->d_ino = lostino; ! 2702: if ( fixblock(addrs) == NUL ) ! 2703: fixblkerr(); ! 2704: return(YES); ! 2705: } ! 2706: length -= DSIZE; ! 2707: element++; ! 2708: } ! 2709: } ! 2710: noparent(ino); ! 2711: return(NO); ! 2712: } ! 2713: ! 2714: badconnect(ino) ! 2715: ino_t ino; ! 2716: { ! 2717: printf("Dir i-number = %u connected. It has bad/dup blocks.\n", ino); ! 2718: } ! 2719: ! 2720: noparent(ino) ! 2721: ino_t ino; ! 2722: { ! 2723: printf("Dir i-number = %u connected. It has no .. entry.\n", ino); ! 2724: } ! 2725: ! 2726: ino_t ! 2727: lostfound() ! 2728: { ! 2729: static daddr_t addrs[NADDR]; ! 2730: struct dinode *dip; ! 2731: struct direct *element; ! 2732: fsize_t length; ! 2733: ! 2734: dip = ptrino(ROOTIN, databuf); ! 2735: l3tol(addrs, dip->di_addr, NADDR); ! 2736: length = dip->di_size; ! 2737: cdbn = 0; ! 2738: while ( length>=DSIZE ) { ! 2739: nextblock(addrs); ! 2740: element = (struct direct *) databuf; ! 2741: while ( (element<&databuf[BSIZE]) && (length>=DSIZE) ) { ! 2742: if ( strcmp(element->d_name, lostname) == 0 ) ! 2743: return(element->d_ino); ! 2744: length -= DSIZE; ! 2745: element++; ! 2746: } ! 2747: } ! 2748: ! 2749: return(NUL); ! 2750: } ! 2751: ! 2752: nolost() ! 2753: { ! 2754: printf("Sorry. No %s directory.\n", lostname); ! 2755: ! 2756: } ! 2757: ! 2758: noroom() ! 2759: { ! 2760: printf("Sorry. No space in %s directory.\n", lostname); ! 2761: } ! 2762: ! 2763: char namebuf[DIRSIZ]; ! 2764: ! 2765: char * ! 2766: nameit(ino) ! 2767: register ino_t ino; ! 2768: { ! 2769: register int i = DIRSIZ-1; ! 2770: ! 2771: namebuf[i] = '\0'; ! 2772: while ( (ino != 0) && (i>0) ) { ! 2773: namebuf[--i] = '0' + ino%10; ! 2774: ino = ino/10; ! 2775: } ! 2776: return(&namebuf[i]); ! 2777: } ! 2778: @ ! 2779: ! 2780: ! 2781: 1.1 ! 2782: log ! 2783: @Initial revision ! 2784: @ ! 2785: text ! 2786: @d109 1 ! 2787: a130 1 ! 2788: length -= DSIZE; ! 2789: @ ! 2790: eturn(element->d_ino);fsck/RCS/phase4.c,v 444 3 3 12033 4771205260 7202 head 1.2; ! 2791: access ; ! 2792: symbols ; ! 2793: locks bin:1.2; ! 2794: comment @ * @; ! 2795: ! 2796: ! 2797: 1.2 ! 2798: date 91.03.18.18.44.48; author bin; state Exp; ! 2799: branches ; ! 2800: next 1.1; ! 2801: ! 2802: 1.1 ! 2803: date 91.02.05.16.38.17; author bin; state Exp; ! 2804: branches ; ! 2805: next ; ! 2806: ! 2807: ! 2808: desc ! 2809: @prov by epstein (post 310) ! 2810: @ ! 2811: ! 2812: ! 2813: 1.2 ! 2814: log ! 2815: @update provided by epstein ! 2816: @ ! 2817: text ! 2818: @/* ! 2819: * phase 4 of fsck - Check Reference Counts ! 2820: */ ! 2821: ! 2822: #include "fsck.h" ! 2823: ! 2824: extern char *reconnect; ! 2825: fsize_t lostsize; ! 2826: ! 2827: phase4() ! 2828: { ! 2829: ino_t i; ! 2830: short actlink; ! 2831: ! 2832: if (!qflag) ! 2833: printf("Phase 4 : Check Reference Counts\n"); ! 2834: for (i=FIRSTIN; i<=ninodes; i++) { ! 2835: if ( badblks(i) ) ! 2836: if ( bddp(i) == YES ) ! 2837: continue; /* inode zeroed */ ! 2838: ! 2839: if ( (linkctr(i) == 0) && ! 2840: ((flags(i)&MODEMASK) != IDIR) && ! 2841: ((flags(i)&ALLOCMASK) != UNALLOC) ) ! 2842: if ( unreflink(i) == YES ) ! 2843: continue; /* inode zeroed */ ! 2844: ! 2845: if ( (linkctr(i) == 0) && ! 2846: ((flags(i)&ALLOCMASK) != UNALLOC) ) ! 2847: if ( unrefclr(i) == YES ) ! 2848: continue; /* inode zeroed */ ! 2849: ! 2850: if ( (actlink=getlink(i)) == (-1) ) { ! 2851: i += INOPB-1; ! 2852: continue; /* bad inode block */ ! 2853: } ! 2854: ! 2855: if ( actlink != linkctr(i) ) ! 2856: linkprob(i, actlink); /* fix link count */ ! 2857: } ! 2858: ! 2859: freeilist(); ! 2860: } ! 2861: ! 2862: short ! 2863: getlink(inum) ! 2864: register ino_t inum; ! 2865: { ! 2866: register unsigned offset; ! 2867: static ibuf[BSIZE]; ! 2868: register struct dinode *dip; ! 2869: register daddr_t bn; ! 2870: ! 2871: offset = iblocko(inum); ! 2872: if ( (offset==0) || (inum==FIRSTIN) ) { ! 2873: bn = iblockn(inum); ! 2874: if ( (testblock(bn)) && (inum!=FIRSTIN) ) ! 2875: return(-1); ! 2876: bread(bn, ibuf); ! 2877: } ! 2878: dip = ((struct dinode *) ibuf) + offset; ! 2879: candino(dip); ! 2880: return(dip->di_nlink); ! 2881: } ! 2882: ! 2883: char *clearit = "(Clear i-node)"; ! 2884: ! 2885: unreflink(ino) ! 2886: ino_t ino; ! 2887: { ! 2888: fsize_t size; ! 2889: ! 2890: if ( (qflag == TRUE) && ((flags(ino)&MODEMASK) == IPIPE) ) { ! 2891: doclear(ino); ! 2892: return(YES); ! 2893: } ! 2894: ! 2895: printf("Unref %s\n", typename(ino)); ! 2896: size = pinfo(ino); ! 2897: if ( (daction != NO) && (size == 0) && (mounted == FALSE) ! 2898: && ((flags(ino)&MODEMASK) == IREG) ) { ! 2899: printf("%s [Forced - Yes]\n", clearit); ! 2900: doclear(ino); ! 2901: return(YES); ! 2902: } ! 2903: if ( action(reconnect) == TRUE ) ! 2904: if( connect(ino, IREG) == FAILURE ) /* connect back in the */ ! 2905: return(askclear(ino)); /* non dir inode */ ! 2906: ! 2907: return(NO); ! 2908: } ! 2909: ! 2910: askclear(ino) ! 2911: ino_t ino; ! 2912: { ! 2913: if ( action(clearit) == TRUE ) { ! 2914: doclear(ino); ! 2915: return(YES); ! 2916: } ! 2917: return(NO); ! 2918: } ! 2919: ! 2920: doclear(ino) ! 2921: ino_t ino; ! 2922: { ! 2923: struct dinode *dip; ! 2924: ! 2925: dip = ptrino(ino, databuf); ! 2926: zeroinode(dip); ! 2927: writeino(ino, databuf); ! 2928: setflags(ino, UNALLOC); ! 2929: setlinkctr(ino, 0); ! 2930: } ! 2931: ! 2932: char *adjust = "(Adjust)"; ! 2933: ! 2934: linkprob(ino, actlink) ! 2935: ino_t ino; ! 2936: short actlink; ! 2937: { ! 2938: printf("Link Count discrepancy in %s\n", typename(ino)); ! 2939: pinfo(ino); ! 2940: printf("Count = %u, should be %u ", actlink, linkctr(ino)); ! 2941: if ( action(adjust) == TRUE ) ! 2942: chglink(ino); ! 2943: } ! 2944: ! 2945: chglink(ino) ! 2946: ino_t ino; ! 2947: { ! 2948: struct dinode *dip; ! 2949: ! 2950: dip = ptrino(ino, databuf); ! 2951: dip->di_nlink = linkctr(ino); ! 2952: writeino(ino, databuf); ! 2953: } ! 2954: ! 2955: unrefclr(ino) ! 2956: ino_t ino; ! 2957: { ! 2958: printf("Unref %s\n", typename(ino)); ! 2959: pinfo(ino); ! 2960: return(askclear(ino)); ! 2961: } ! 2962: ! 2963: bddp(ino) ! 2964: ino_t ino; ! 2965: { ! 2966: printf("Bad/Dup blocks in %s\n", typename(ino)); ! 2967: pinfo(ino); ! 2968: return(askclear(ino)); ! 2969: } ! 2970: ! 2971: char *fixit = "(FIX)"; ! 2972: ! 2973: freeilist() ! 2974: { ! 2975: ino_t i, count=0; ! 2976: daddr_t bn; ! 2977: ! 2978: for (i=FIRSTIN; i<=ninodes; i++) ! 2979: if ( (flags(i)&ALLOCMASK) == UNALLOC ) ! 2980: count++; ! 2981: ! 2982: for (bn=INODEI+1; bn<isize; bn++) /* block # INODEI can't */ ! 2983: if ( testblock(bn) ) /* be bad since ROOTIN */ ! 2984: count -= INOPB; /* is in it, otherwise */ ! 2985: /* big time bad news. */ ! 2986: if ( sbp->s_tinode != count ) ! 2987: if ( (qflag==FALSE) && (daction!=NO) ) { ! 2988: printf("Free i-node count wrong in superblock. "); ! 2989: if ( action(fixit) == TRUE ) { ! 2990: sbp->s_tinode = count; ! 2991: sbpfix = TRUE; ! 2992: } ! 2993: } else { ! 2994: sbp->s_tinode = count; ! 2995: sbpfix = TRUE; ! 2996: } ! 2997: ! 2998: if ( (daction!=NO) && ! 2999: ( (sflag==TRUE) || (sbpfix==TRUE) || (badilist()==BAD) ) ) ! 3000: rebuild(); ! 3001: ! 3002: } ! 3003: ! 3004: badilist() ! 3005: { ! 3006: ino_t i, inum; ! 3007: unsigned numfree; ! 3008: daddr_t bn; ! 3009: ! 3010: if ( (numfree=(unsigned) sbp->s_ninode) > NICINOD ) ! 3011: return(BAD); ! 3012: for (i=0; i<numfree; i++) { ! 3013: inum = sbp->s_inode[i]; ! 3014: bn = iblockn(inum); ! 3015: if ( (testblock(bn)) && (bn!=INODEI) ) ! 3016: return(BAD); ! 3017: if ( (inum < FIRSTIN) || (inum > ninodes) ) ! 3018: return(BAD); ! 3019: if ( (flags(inum)&ALLOCMASK) != UNALLOC ) ! 3020: return(BAD); ! 3021: if ( flags(inum)&IFREELIST ) ! 3022: return(BAD); /* dup in ifree list */ ! 3023: orflags(inum, IFREELIST); ! 3024: } ! 3025: return(GOOD); ! 3026: } ! 3027: ! 3028: rebuild() ! 3029: { ! 3030: daddr_t bn; ! 3031: ino_t i; ! 3032: int index; ! 3033: ! 3034: sbpfix = TRUE; ! 3035: for (i=FIRSTIN, index=0; (i<=ninodes) && (index<NICINOD); i++) { ! 3036: if ( (flags(i)&ALLOCMASK) == UNALLOC ) { ! 3037: bn = iblockn(i); ! 3038: if ( (!testblock(bn)) || (bn==INODEI) ) ! 3039: index++; ! 3040: } ! 3041: } ! 3042: sbp->s_ninode = index; ! 3043: for (i=FIRSTIN; (i<=ninodes) && (index>0); i++) { ! 3044: if ( (flags(i)&ALLOCMASK) == UNALLOC ) { ! 3045: bn = iblockn(i); ! 3046: if ( (!testblock(bn)) || (bn==INODEI) ) ! 3047: sbp->s_inode[--index] = i; ! 3048: } ! 3049: } ! 3050: printf("Free i-node list in superblock rebuilt.\n"); ! 3051: } ! 3052: @ ! 3053: ! 3054: ! 3055: 1.1 ! 3056: log ! 3057: @Initial revision ! 3058: @ ! 3059: text ! 3060: @a16 1 ! 3061: lostsize = 0; ! 3062: a108 1 ! 3063: lostsize += dip->di_size; ! 3064: d181 2 ! 3065: a182 1 ! 3066: if ( (daction!=NO) && ((sbpfix==TRUE) || (badilist()==BAD)) ) ! 3067: d214 2 ! 3068: a215 2 ! 3069: ino_t i = FIRSTIN; ! 3070: int index = 0; ! 3071: d218 1 ! 3072: a218 1 ! 3073: while ( (i<=ninodes) && (index<NICINOD) ) { ! 3074: d222 1 ! 3075: a222 1 ! 3076: sbp->s_inode[index++] = i; ! 3077: a223 1 ! 3078: i++; ! 3079: a224 1 ! 3080: ! 3081: d226 7 ! 3082: @ ! 3083: bn = iblockn(i); ! 3084: if ( (!testblock(bn)) || (bn==INODEI) ) ! 3085: sbp->s_inode[--index] = i; ! 3086: } ! 3087: } ! 3088: printf("Free i-node list in superblock rebuilt.\n"); ! 3089: } ! 3090: @ ! 3091: ! 3092: ! 3093: 1.1 ! 3094: log ! 3095: @Initial revision ! 3096: @ ! 3097: text ! 3098: @a16 1 ! 3099: lostsize = 0; ! 3100: a108 1 ! 3101: lostsize += dip->di_size; ! 3102: d181 2 ! 3103: a182 1 ! 3104: if ( (daction!=NO) && ((sbpfix==TRUE) || (badilist()==BAD)) ) ! 3105: d214 2 ! 3106: a215 2 ! 3107: ino_t i = FIRSTIN; ! 3108: int index = 0; ! 3109: d218 1 ! 3110: a218 1 ! 3111: while ( (i<=ninodes) && (index<NICINOD) ) { ! 3112: d222 1 ! 3113: a222 1 ! 3114: sbp->s_inode[index++] = i; ! 3115: a223fsck/RCS/phase5.c,v 444 3 3 7463 4771205275 7204 head 1.2; ! 3116: access ; ! 3117: symbols ; ! 3118: locks bin:1.2; ! 3119: comment @ * @; ! 3120: ! 3121: ! 3122: 1.2 ! 3123: date 91.03.18.18.45.05; author bin; state Exp; ! 3124: branches ; ! 3125: next 1.1; ! 3126: ! 3127: 1.1 ! 3128: date 91.02.05.16.38.33; author bin; state Exp; ! 3129: branches ; ! 3130: next ; ! 3131: ! 3132: ! 3133: desc ! 3134: @prov by epstein (phase5.c) ! 3135: @ ! 3136: ! 3137: ! 3138: 1.2 ! 3139: log ! 3140: @update provided by epstein ! 3141: @ ! 3142: text ! 3143: @/* ! 3144: * phase 5 of fsck - Check Free List ! 3145: */ ! 3146: ! 3147: #include "fsck.h" ! 3148: ! 3149: daddr_t badcnt; /* Number of bad blocks in free list */ ! 3150: daddr_t dupcnt; /* Number of dup blocks in free list */ ! 3151: int badflag; /* Bad free list flag */ ! 3152: int fixerup; /* Flag to salvage free list */ ! 3153: ! 3154: phase5() ! 3155: { ! 3156: struct fblk *fbp; ! 3157: unsigned size; ! 3158: ! 3159: if (!qflag) ! 3160: printf("Phase 5 : Check Free List\n"); ! 3161: fbp = (struct fblk *) &sbp->s_nfree; ! 3162: size = (unsigned) ((fsize+NBPC-1)/NBPC) * sizeof(char); ! 3163: copyV(size); ! 3164: badcnt = dupcnt = 0; ! 3165: badflag = FALSE; ! 3166: freetrav(fbp); ! 3167: fixerup = FALSE; ! 3168: if (badflag || sflag) ! 3169: asksalvage(); ! 3170: } ! 3171: ! 3172: ! 3173: #define IGNORE 3 /* Return Possibilities from chk() */ ! 3174: #define ABORT 4 /* as well as perhaps GOOD and BAD */ ! 3175: ! 3176: freetrav(fbp) ! 3177: struct fblk *fbp; ! 3178: { ! 3179: daddr_t total=0; ! 3180: int i, flag; ! 3181: ! 3182: while ( fbp->df_nfree != 0 ) { ! 3183: if ( (unsigned) fbp->df_nfree > NICFREE ) { ! 3184: badflag = TRUE; ! 3185: printf("Bad freeblock count.\n"); ! 3186: break; ! 3187: } ! 3188: for (i=1; i<fbp->df_nfree; i++) { ! 3189: if ( (flag=chk(fbp->df_free[i])) == GOOD ) { ! 3190: total++; ! 3191: continue; ! 3192: } ! 3193: if (flag == BAD) ! 3194: continue; ! 3195: break; /* break for IGNORE or ABORT */ ! 3196: } ! 3197: if ( (flag == IGNORE) || (flag == ABORT) ) ! 3198: break; ! 3199: if ( chk(fbp->df_free[0]) != GOOD ) ! 3200: break; ! 3201: total++; ! 3202: bread(fbp->df_free[0], databuf); ! 3203: fbp = (struct fblk *) databuf; ! 3204: if ( !canfblk(fbp) ) { ! 3205: badflag = TRUE; ! 3206: printf("Bad freeblock count.\n"); ! 3207: break; ! 3208: } ! 3209: } ! 3210: ! 3211: #if 0 ! 3212: printf("Total traversed free blocks = %U\n", total); ! 3213: printf("Total free blocks by Superblock = %U\n", sbp->s_tfree); ! 3214: printf("Running total free blocks = %U\n", totfree); ! 3215: #endif ! 3216: ! 3217: if ( flag == ABORT ) { /* To Terminate fsck on this */ ! 3218: badflag = FALSE; /* File System, because of */ ! 3219: return; /* excessive dup or bad blocks */ ! 3220: } ! 3221: ! 3222: if ( sbp->s_tfree != totfree ) ! 3223: if ( (qflag==FALSE) && (daction!=NO) ) { ! 3224: printf("Free Block count wrong in superblock. "); ! 3225: if ( action(fixit) == TRUE ) { ! 3226: sbp->s_tfree = totfree; ! 3227: sbpfix = TRUE; ! 3228: } ! 3229: } else { ! 3230: sbp->s_tfree = totfree; ! 3231: sbpfix = TRUE; ! 3232: } ! 3233: ! 3234: report("%U Bad Block%s in Free List\n", badcnt); ! 3235: report("%U Dup Block%s in Free List\n", dupcnt); ! 3236: report("%U Block%s missing\n", totfree - total); ! 3237: ! 3238: } ! 3239: ! 3240: report(message, num) ! 3241: char *message; ! 3242: daddr_t num; ! 3243: { ! 3244: if ( num != 0 ) { ! 3245: printf(message, num, ( (num>1) ? "s" : "" ) ); ! 3246: badflag = TRUE; ! 3247: } ! 3248: } ! 3249: ! 3250: chk(bn) ! 3251: register daddr_t bn; ! 3252: { ! 3253: if ( (bn<isize) || (bn>=fsize) ) { ! 3254: badflag = TRUE; ! 3255: if (++badcnt > MAXBADFREE) ! 3256: return( stopit("bad") ); ! 3257: return(BAD); ! 3258: } ! 3259: ! 3260: if ( testdup(bn) ) { ! 3261: badflag = TRUE; ! 3262: if (++dupcnt > MAXDUPFREE) ! 3263: return( stopit("dup") ); ! 3264: return(BAD); ! 3265: } else { ! 3266: markdup(bn); ! 3267: return(GOOD); ! 3268: } ! 3269: } ! 3270: ! 3271: stopit(type) ! 3272: char *type; ! 3273: { ! 3274: printf("Excessive %s blocks in free list ", type); ! 3275: if ( query("(Continue)") == YES ) ! 3276: return(IGNORE); ! 3277: else ! 3278: return(ABORT); ! 3279: } ! 3280: ! 3281: ! 3282: canfblk(fbp) ! 3283: register struct fblk *fbp; ! 3284: { ! 3285: register short i; ! 3286: ! 3287: canshort(fbp->df_nfree); ! 3288: if ( (unsigned) fbp->df_nfree > NICFREE ) ! 3289: return(FALSE); ! 3290: ! 3291: for (i=0; i<fbp->df_nfree; i++) ! 3292: candaddr(fbp->df_free[i]); ! 3293: return(TRUE); ! 3294: } ! 3295: ! 3296: asksalvage() ! 3297: { ! 3298: if ( (daction!=NO) && (qflag || sflag) ) { ! 3299: fixerup = TRUE; ! 3300: return; ! 3301: } ! 3302: if ( action("Bad Free List (SALVAGE)") ) ! 3303: fixerup = TRUE; ! 3304: } ! 3305: @ ! 3306: ! 3307: ! 3308: 1.1 ! 3309: log ! 3310: @Initial revision ! 3311: @ ! 3312: text ! 3313: @d26 1 ! 3314: a26 1 ! 3315: if (badflag) ! 3316: d62 5 ! 3317: a66 1 ! 3318: canfblk(fbp); ! 3319: d69 5 ! 3320: a73 3 ! 3321: /* printf("Total traversed free blocks = %U\n", total); */ ! 3322: /* printf("Total free blocks by Superblock = %U\n", sbp->s_tfree); */ ! 3323: /* printf("Running total free blocks = %U\n", totfree); */ ! 3324: d146 3 ! 3325: d151 2 ! 3326: a153 2 ! 3327: } ! 3328: ! 3329: d156 1 ! 3330: a156 1 ! 3331: if ( qflag && (daction!=NO) ) { ! 3332: @ ! 3333: ( (daction!=NO) && (qflag || sflag) ) { ! 3334: fixerup = TRUE; ! 3335: return; ! 3336: } ! 3337: if ( action("Bad Free List (SALVAGE)") ) ! 3338: fixerup = TRUE; ! 3339: } ! 3340: @ ! 3341: ! 3342: ! 3343: 1.1 ! 3344: log ! 3345: @Initial revision ! 3346: @ ! 3347: text ! 3348: @d26 1 ! 3349: a26 1 ! 3350: if (badflag) ! 3351: d62 5 ! 3352: afsck/RCS/phase6.c,v 444 3 3 5736 4771205312 7176 head 1.2; ! 3353: access ; ! 3354: symbols ; ! 3355: locks bin:1.2; ! 3356: comment @ * @; ! 3357: ! 3358: ! 3359: 1.2 ! 3360: date 91.03.18.18.45.18; author bin; state Exp; ! 3361: branches ; ! 3362: next 1.1; ! 3363: ! 3364: 1.1 ! 3365: date 91.02.05.16.38.52; author bin; state Exp; ! 3366: branches ; ! 3367: next ; ! 3368: ! 3369: ! 3370: desc ! 3371: @prov by epstein (post 310) ! 3372: @ ! 3373: ! 3374: ! 3375: 1.2 ! 3376: log ! 3377: @update provided by epstein. ! 3378: @ ! 3379: text ! 3380: @/* ! 3381: * phase 6 of fsck - Salvage Free List ! 3382: */ ! 3383: ! 3384: #include "fsck.h" ! 3385: ! 3386: static unsigned char *maptab; /* table of interleave offsets */ ! 3387: static daddr_t mapbot; /* minimum block number to interleave map */ ! 3388: static daddr_t maptop; /* maximum block number to interleave map */ ! 3389: static short m,n; /* interleave factors */ ! 3390: #define DEF_N 1 /* default values */ ! 3391: #define DEF_M 1 ! 3392: daddr_t freeblks; /* number free blocks left to write out */ ! 3393: daddr_t blknm; /* current block number we are working with */ ! 3394: struct fblk *fblkp; /* pointer to free block list */ ! 3395: daddr_t *dp; /* pointer to block entry in free list block */ ! 3396: ! 3397: phase6() ! 3398: { ! 3399: if (!fixerup) { ! 3400: return; ! 3401: } ! 3402: ! 3403: if (!qflag) ! 3404: printf("Phase 6 : Salvage Free List\n"); ! 3405: if ( maketable() == BAD ) ! 3406: return; ! 3407: writefree(); ! 3408: free(maptab); ! 3409: } ! 3410: ! 3411: maketable() ! 3412: { ! 3413: register int i; ! 3414: register int ratio; ! 3415: ! 3416: m = sbp->s_m; ! 3417: n = sbp->s_n; ! 3418: ! 3419: if ( (n > MAXINTN) || (m > n) || (n%m != 0) ) { ! 3420: printf("Invalid interleave factors in superblock.\n"); ! 3421: printf("Default free-block list spacing assumed.\n"); ! 3422: sbp->s_n = n = DEF_N; ! 3423: sbp->s_m = m = DEF_M; ! 3424: } ! 3425: ! 3426: if ( (maptab = malloc(n)) == NULL ) { ! 3427: printf("Can't malloc space for interleave table.\n"); ! 3428: printf("Free-block list is not rebuilt.\n"); ! 3429: return(BAD); ! 3430: } ! 3431: ! 3432: mapbot = (isize + n - 1)/n*n; ! 3433: maptop = fsize/n*n; ! 3434: ratio = n/m; ! 3435: for (i=0; i<n; i++) ! 3436: maptab[i] = (i/ratio) + (i%ratio)*m; ! 3437: ! 3438: return(GOOD); ! 3439: } ! 3440: ! 3441: writefree() ! 3442: { ! 3443: register daddr_t bn; ! 3444: daddr_t blk, bmap(); ! 3445: short num; ! 3446: ! 3447: sbpfix = TRUE; ! 3448: freeblks = totfree; ! 3449: blknm = SUPERI; ! 3450: fblkp = (struct fblk *) &sbp->s_nfree; ! 3451: fblkp->df_nfree = num = (freeblks < NICFREE) ? freeblks : NICFREE; ! 3452: freeblks -= num; ! 3453: dp = &fblkp->df_free[num]; ! 3454: for (bn=isize; bn<fsize; bn++) { ! 3455: blk = bmap(bn); ! 3456: if ( !testblock(blk) ) ! 3457: if ( addfree(blk) == STOP ) ! 3458: break; ! 3459: } ! 3460: } ! 3461: ! 3462: addfree(bn) ! 3463: daddr_t bn; ! 3464: { ! 3465: short num; ! 3466: ! 3467: *--dp = bn; ! 3468: if (dp > &fblkp->df_free[0]) ! 3469: return(OK); ! 3470: ! 3471: if ( blknm != SUPERI ) { ! 3472: canwfblk(fblkp); ! 3473: bwrite(blknm, databuf); ! 3474: } ! 3475: ! 3476: bclear(databuf, BSIZE); ! 3477: if (freeblks == 0) { ! 3478: bwrite(bn, databuf); ! 3479: return(STOP); ! 3480: } ! 3481: blknm = bn; ! 3482: fblkp = (struct fblk *) databuf; ! 3483: fblkp->df_nfree = num = (freeblks < NICFREE) ? freeblks : NICFREE; ! 3484: freeblks -= num; ! 3485: dp = &fblkp->df_free[num]; ! 3486: return(OK); ! 3487: } ! 3488: ! 3489: daddr_t ! 3490: bmap(blk) ! 3491: register daddr_t blk; ! 3492: { ! 3493: short i; ! 3494: ! 3495: if ( (blk>=mapbot) && (blk<maptop) ) { ! 3496: i = blk%n; ! 3497: blk -= i; ! 3498: blk += maptab[i]; ! 3499: } ! 3500: return(blk); ! 3501: } ! 3502: ! 3503: canwfblk(fbp) ! 3504: register struct fblk *fbp; ! 3505: { ! 3506: register short i; ! 3507: ! 3508: for (i=0; i<fbp->df_nfree; i++) ! 3509: candaddr(fbp->df_free[i]); ! 3510: canshort(fbp->df_nfree); ! 3511: } ! 3512: @ ! 3513: ! 3514: ! 3515: 1.1 ! 3516: log ! 3517: @Initial revision ! 3518: @ ! 3519: text ! 3520: @d7 1 ! 3521: a7 1 ! 3522: static char *maptab; /* table of interleave offsets */ ! 3523: d114 1 ! 3524: a114 1 ! 3525: int i; ! 3526: d117 3 ! 3527: a119 2 ! 3528: i = ((unsigned)blk)%n; ! 3529: blk += maptab[i] - i; ! 3530: @ ! 3531: rn(OK); ! 3532: } ! 3533: ! 3534: daddr_t ! 3535: bmap(blk) ! 3536: regisfsck/RCS/printf.c,v 444 3 3 7620 4753557667 7333 head 1.1; ! 3537: access ; ! 3538: symbols ; ! 3539: locks ; ! 3540: comment @ * @; ! 3541: ! 3542: ! 3543: 1.1 ! 3544: date 91.02.05.16.39.10; author bin; state Exp; ! 3545: branches ; ! 3546: next ; ! 3547: ! 3548: ! 3549: desc ! 3550: @prov by epstein (post310) ! 3551: @ ! 3552: ! 3553: ! 3554: ! 3555: 1.1 ! 3556: log ! 3557: @Initial revision ! 3558: @ ! 3559: text ! 3560: @/* ! 3561: * Standard output printf using putchar. ! 3562: * Non-portable things: ! 3563: * 1) alignment of arguments is assumed to be completely contiguous. ! 3564: * 2) the smallest number is assumed to negate to itself. ! 3565: * 3) All of long, int, char*, and double are assumed to ! 3566: * be held in an exact number of ints. ! 3567: */ ! 3568: ! 3569: #define NULL ((char *)0) ! 3570: #define putchar(c) { char b = c; write(1, &b, 1); } ! 3571: #include <sys/mdata.h> ! 3572: ! 3573: union alltypes { ! 3574: char c; ! 3575: int i; ! 3576: unsigned u; ! 3577: long l; ! 3578: double d; ! 3579: char *s; ! 3580: }; ! 3581: ! 3582: #define bump(p,s) (p+=sizeof(s)/sizeof(int)) ! 3583: ! 3584: char *printi(); ! 3585: char *printl(); ! 3586: ! 3587: static char null[] = "{NULL}"; ! 3588: ! 3589: printf(args) ! 3590: union alltypes args; ! 3591: { ! 3592: xprintf(&args); ! 3593: } ! 3594: xprintf(argp) ! 3595: union alltypes *argp; ! 3596: { ! 3597: register char *cbp; ! 3598: int *iap; ! 3599: register c; ! 3600: char *s; ! 3601: char *cbs; ! 3602: char adj, pad; ! 3603: int prec; ! 3604: int fwidth; ! 3605: int pwidth; ! 3606: register char *fmt; ! 3607: union alltypes elem; ! 3608: char cbuf[64]; ! 3609: ! 3610: iap = (int *)argp; ! 3611: fmt = *(char **)iap; ! 3612: bump(iap, char*); ! 3613: for (;;) { ! 3614: while((c = *fmt++) != '%') { ! 3615: if(c == '\0') { ! 3616: return; ! 3617: } ! 3618: putchar(c); ! 3619: } ! 3620: pad = ' '; ! 3621: fwidth = -1; ! 3622: prec = -1; ! 3623: c = *fmt++; ! 3624: if (c == '-') { ! 3625: adj = 1; ! 3626: c = *fmt++; ! 3627: } else ! 3628: adj = 0; ! 3629: if (c == '0') { ! 3630: pad = '0'; ! 3631: c = *fmt++; ! 3632: } ! 3633: if (c == '*') { ! 3634: fwidth = *iap++; ! 3635: c = *fmt++; ! 3636: } else ! 3637: for (fwidth = 0; c>='0' && c<='9'; c = *fmt++) ! 3638: fwidth = fwidth*10 + c-'0'; ! 3639: if (c == '.') { ! 3640: c = *fmt++; ! 3641: if (c == '*') { ! 3642: prec = *iap++; ! 3643: c = *fmt++; ! 3644: } else ! 3645: for (prec=0; c>='0' && c<='9'; c=*fmt++) ! 3646: prec = prec*10 + c-'0'; ! 3647: } ! 3648: if (c == 'l') { ! 3649: c = *fmt++; ! 3650: if (c=='d' || c=='o' || c=='u' || c=='x') ! 3651: c += 'A' - 'a'; ! 3652: } ! 3653: cbp = cbs = cbuf; ! 3654: switch (c) { ! 3655: ! 3656: case 'd': ! 3657: elem.i = *iap++; ! 3658: if (elem.i < 0) { ! 3659: elem.i = -elem.i; ! 3660: *cbp++ = '-'; ! 3661: } ! 3662: cbp = printi(cbp, elem.i, 10); ! 3663: break; ! 3664: ! 3665: case 'u': ! 3666: cbp = printi(cbp, *iap++, 10); ! 3667: break; ! 3668: ! 3669: case 'o': ! 3670: cbp = printi(cbp, *iap++, 8); ! 3671: break; ! 3672: ! 3673: case 'x': ! 3674: cbp = printi(cbp, *iap++, 16); ! 3675: break; ! 3676: ! 3677: case 'D': ! 3678: elem.l = *(long *)iap; ! 3679: bump(iap, long); ! 3680: if (elem.l < 0) { ! 3681: elem.l = -elem.l; ! 3682: *cbp++ = '-'; ! 3683: } ! 3684: cbp = printl(cbp, elem.l, 10); ! 3685: break; ! 3686: ! 3687: case 'U': ! 3688: cbp = printl(cbp, *(long *)iap, 10); ! 3689: bump(iap, long); ! 3690: break; ! 3691: ! 3692: case 'O': ! 3693: cbp = printl(cbp, *(long *)iap, 8); ! 3694: bump(iap, long); ! 3695: break; ! 3696: ! 3697: case 'X': ! 3698: cbp = printl(cbp, *(long *)iap, 16); ! 3699: bump(iap, long); ! 3700: break; ! 3701: ! 3702: ! 3703: case 's': ! 3704: if ((s = *(char **)iap) == NULL) ! 3705: s = null; ! 3706: bump(iap, char*); ! 3707: /* ! 3708: * Do %s specially so it can be longer. ! 3709: */ ! 3710: cbp = cbs = s; ! 3711: while (*cbp++ != '\0') ! 3712: if (prec>=0 && cbp-s>prec) ! 3713: break; ! 3714: cbp--; ! 3715: break; ! 3716: ! 3717: case 'c': ! 3718: elem.c = *iap++; ! 3719: *cbp++ = elem.c; ! 3720: break; ! 3721: ! 3722: case 'r': ! 3723: xprintf(*(char ***)iap); ! 3724: bump(iap, char**); ! 3725: break; ! 3726: ! 3727: default: ! 3728: putchar(c); ! 3729: continue; ! 3730: } ! 3731: if ((pwidth = fwidth + cbs-cbp) < 0) ! 3732: pwidth = 0; ! 3733: if (!adj) ! 3734: while (pwidth-- != 0) ! 3735: putchar(pad); ! 3736: while (cbs < cbp) ! 3737: putchar(*cbs++); ! 3738: if (adj) ! 3739: while (pwidth-- != 0) ! 3740: putchar(pad); ! 3741: } ! 3742: } ! 3743: ! 3744: static char digits[] = { ! 3745: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ! 3746: 'A', 'B', 'C', 'D', 'E', 'F' ! 3747: }; ! 3748: ! 3749: /* ! 3750: * Print an unsigned integer in base b. ! 3751: */ ! 3752: static ! 3753: char * ! 3754: printi(cp, n, b) ! 3755: char *cp; ! 3756: register unsigned n; ! 3757: { ! 3758: register a; ! 3759: register char *ep; ! 3760: char pbuf[10]; ! 3761: ! 3762: ep = &pbuf[10]; ! 3763: *--ep = 0; ! 3764: for ( ; a = n/b; n=a) ! 3765: *--ep = digits[n%b]; ! 3766: *--ep = digits[n]; ! 3767: while (*ep) ! 3768: *cp++ = *ep++; ! 3769: return (cp); ! 3770: } ! 3771: ! 3772: /* ! 3773: * Print an unsigned long in base b. ! 3774: */ ! 3775: static ! 3776: char * ! 3777: printl(cp, n, b) ! 3778: register char *cp; ! 3779: unsigned long n; ! 3780: register b; ! 3781: { ! 3782: char pbuf[13]; ! 3783: unsigned long a; ! 3784: register char *ep; ! 3785: ! 3786: ep = &pbuf[13]; ! 3787: *--ep = '\0'; ! 3788: for ( ; (a = n/b) != 0; n = a) ! 3789: *--ep = digits[n%b]; ! 3790: *--ep = digits[n]; ! 3791: while (*ep) ! 3792: *cp++ = *ep++; ! 3793: return (cp); ! 3794: } ! 3795: @ ! 3796: egister char *ep; ! 3797: char pbuf[10]; ! 3798: ! 3799: ep = &pbuf[10]; ! 3800: *--ep = 0; ! 3801: for ( ; a = n/b; n=a) ! 3802: *--ep = digits[n%b]; ! 3803: *fsck/RCS/util.c,v 444 3 3 16442 5045006750 7001 head 1.2; ! 3804: branch ; ! 3805: access ; ! 3806: symbols ; ! 3807: locks bin:1.2; ! 3808: comment @ * @; ! 3809: ! 3810: ! 3811: 1.2 ! 3812: date 91.07.29.07.45.21; author bin; state Exp; ! 3813: branches ; ! 3814: next 1.1; ! 3815: ! 3816: 1.1 ! 3817: date 91.02.05.16.39.25; author bin; state Exp; ! 3818: branches ; ! 3819: next ; ! 3820: ! 3821: ! 3822: desc ! 3823: @prov by epstein (post 310) ! 3824: @ ! 3825: ! 3826: ! 3827: 1.2 ! 3828: log ! 3829: @Updated by epstein for version 321. ! 3830: @ ! 3831: text ! 3832: @/* ! 3833: * general utility functions for phases of fsck ! 3834: */ ! 3835: ! 3836: #include "fsck.h" ! 3837: ! 3838: struct stat stats; /* Used by statit() */ ! 3839: ! 3840: statit(name, probfun) ! 3841: char *name; ! 3842: int (*probfun)(); ! 3843: { ! 3844: ! 3845: if ( stat(name, &stats) == -1 ) { ! 3846: bclear(&stats, sizeof(struct stat)); ! 3847: (*probfun)("Can not stat %s", name); ! 3848: } ! 3849: } ! 3850: ! 3851: ! 3852: query(x) ! 3853: { ! 3854: while(1) { ! 3855: printf("%r [yes/no]: ", &x); ! 3856: ! 3857: switch (daction) { ! 3858: case YES: ! 3859: printf("[default - YES]\n"); ! 3860: return(YES); ! 3861: break; ! 3862: case NO: ! 3863: printf("[default - NO]\n"); ! 3864: return(NO); ! 3865: break; ! 3866: case ASK: ! 3867: switch( nextchar() ) { ! 3868: case 'Y': ! 3869: return(YES); ! 3870: case 'N': ! 3871: return(NO); ! 3872: } ! 3873: } ! 3874: } ! 3875: } ! 3876: ! 3877: action(msg) ! 3878: char *msg; ! 3879: { ! 3880: switch( query(msg) ) { ! 3881: case YES: ! 3882: return(TRUE); ! 3883: case NO: ! 3884: return(FALSE); ! 3885: } ! 3886: } ! 3887: ! 3888: char ! 3889: nextchar() ! 3890: { ! 3891: char buff[8]; ! 3892: int i, n, ch; ! 3893: ! 3894: if ( ((n=read(0,buff,8)) <= 0) || (n == 8) ) ! 3895: fatal("Invalid Response"); ! 3896: ! 3897: for(i=0; i<n; i++) ! 3898: if ( ((ch=buff[i])!=' ') && (ch!='\t') ) ! 3899: break; ! 3900: ! 3901: if ( (ch>='a') && (ch<='z') ) ! 3902: ch += 'A' - 'a'; ! 3903: ! 3904: return(ch); ! 3905: } ! 3906: ! 3907: char *nfile = "FILE"; ! 3908: char *ndir = "DIR"; ! 3909: char *nchr = "Character Special"; ! 3910: char *nblk = "Block Special"; ! 3911: char *npipe = "PIPE"; ! 3912: char *nunkwn = "Unknown I-node type"; ! 3913: ! 3914: char * ! 3915: typename(ino) ! 3916: ino_t ino; ! 3917: { ! 3918: switch( flags(ino)&MODEMASK ) { ! 3919: case IREG: ! 3920: return(nfile); ! 3921: case IDIR: ! 3922: return(ndir); ! 3923: case ICHR: ! 3924: return(nchr); ! 3925: case IBLK: ! 3926: return(nblk); ! 3927: case IPIPE: ! 3928: return(npipe); ! 3929: default: ! 3930: return(nunkwn); ! 3931: } ! 3932: } ! 3933: ! 3934: abort() ! 3935: { ! 3936: fatal("abort."); ! 3937: } ! 3938: ! 3939: fatal(x) ! 3940: { ! 3941: printf("fsck: %r\n", &x); ! 3942: _exit(1); ! 3943: } ! 3944: ! 3945: nonfatal(x) ! 3946: { ! 3947: printf("fsck: %r\n", &x); ! 3948: errflag = TRUE; ! 3949: } ! 3950: ! 3951: /* ! 3952: * Inode Manipulation Routines ! 3953: * ptrino: returns a pointer to the wanted inode using the given ! 3954: * buffer to read in the block performing canonicalization. ! 3955: * writeino: writes the block containing the given inode to the ! 3956: * disk performing the necessary canonicalization ! 3957: * candino: canonicalize an inode ! 3958: * ! 3959: */ ! 3960: ! 3961: struct dinode * ! 3962: ptrino(ino, buf) ! 3963: register ino_t ino; ! 3964: register char *buf; ! 3965: { ! 3966: register daddr_t bn; ! 3967: register struct dinode *dip; ! 3968: ! 3969: bn = iblockn(ino); ! 3970: if ( (testblock(bn)) && (bn!=INODEI) ) /* bad inode block */ ! 3971: return(NULL); ! 3972: bread(bn, buf); ! 3973: dip = ((struct dinode *) buf) + iblocko(ino); ! 3974: candino(dip); ! 3975: return(dip); ! 3976: } ! 3977: ! 3978: writeino(ino, buf) ! 3979: ino_t ino; ! 3980: char *buf; ! 3981: { ! 3982: struct dinode *dip; ! 3983: ! 3984: dip = ((struct dinode *) buf) + iblocko(ino); ! 3985: candino(dip); ! 3986: bwrite((daddr_t) iblockn(ino), buf); ! 3987: } ! 3988: ! 3989: candino(dip) ! 3990: register struct dinode *dip; ! 3991: { ! 3992: canshort(dip->di_mode); ! 3993: canshort(dip->di_nlink); ! 3994: canshort(dip->di_uid); ! 3995: canshort(dip->di_gid); ! 3996: cansize(dip->di_size); ! 3997: cantime(dip->di_atime); ! 3998: cantime(dip->di_mtime); ! 3999: cantime(dip->di_ctime); ! 4000: } ! 4001: ! 4002: /* ! 4003: * Transfer a logical block number for an inode to a ! 4004: * physical block number, chasing indirects as necessary. ! 4005: * The inefficiency of this method is put up with since ! 4006: * this is only used for directory inodes, and they tend ! 4007: * not to use indirects. Pass in 'addrs' which is a pointer ! 4008: * to the 13 daddr_s in the inode, and the logical block ! 4009: * number you would like. (Stolen from dcheck.c) ! 4010: */ ! 4011: ! 4012: static daddr_t ranges[] = { ! 4013: ND, ! 4014: ND + (daddr_t)NI*NBN, ! 4015: ND + (daddr_t)NI*NBN + (daddr_t)NII*NBN*NBN, ! 4016: ND + (daddr_t)NI*NBN + (daddr_t)NII*NBN*NBN + (daddr_t)NIII*NBN*NBN*NBN ! 4017: }; ! 4018: ! 4019: static char index[] = { ! 4020: 0, ! 4021: ND, ! 4022: ND+NI, ! 4023: ND+NI+NII ! 4024: }; ! 4025: ! 4026: static daddr_t coeff[] = { ! 4027: 1, (daddr_t)NBN, (daddr_t)NBN*NBN, (daddr_t)NBN*NBN*NBN ! 4028: }; ! 4029: ! 4030: daddr_t ! 4031: imap(addrs, block) ! 4032: daddr_t *addrs; ! 4033: register daddr_t block; ! 4034: { ! 4035: int i; ! 4036: register daddr_t bpos; ! 4037: register daddr_t *bp; ! 4038: register daddr_t bn; ! 4039: ! 4040: for (i=0; i<4; i++) ! 4041: if (block < ranges[i]) { ! 4042: if (i != 0) ! 4043: block -= ranges[i-1]; ! 4044: bpos = block/coeff[i]; ! 4045: block %= coeff[i]; ! 4046: bp = &addrs[(int)bpos + index[i]]; ! 4047: if ( (bn=*bp) != 0 ) { ! 4048: /* ! 4049: * Map through indirects here ! 4050: */ ! 4051: while (i-- > 0) { ! 4052: bread(bn, databuf); ! 4053: bpos = block/coeff[i]; ! 4054: block %= coeff[i]; ! 4055: bp = (daddr_t *)databuf + bpos; ! 4056: if ( (bn=*bp) == 0 ) ! 4057: break; ! 4058: bn = *bp; ! 4059: candaddr(bn); ! 4060: } ! 4061: } ! 4062: return(bn); ! 4063: } ! 4064: return(0); ! 4065: } ! 4066: ! 4067: /* ! 4068: * Read the specified block number into the given buffer ! 4069: */ ! 4070: ! 4071: char *rgblkerr = "Out of Range Block number: %U (CONTINUE)"; ! 4072: char *skblkerr = "Can not Seek: Blk num: %U (CONTINUE)"; ! 4073: char *rdblkerr = "Can not Read: Blk num: %U (CONTINUE)"; ! 4074: char *wtblkerr = "Can not Write: Blk num: %U (CONTINUE)"; ! 4075: ! 4076: bread(bn, buf) ! 4077: register daddr_t bn; ! 4078: register char *buf; ! 4079: { ! 4080: #ifdef DEBUG ! 4081: printf("Reading block number: %ld\n", bn); ! 4082: #endif ! 4083: if (bn<0 || bn >= fsize ) ! 4084: switch( query(rgblkerr, bn) ) { ! 4085: case YES: ! 4086: bclear(buf, BSIZE); ! 4087: return; ! 4088: case NO: ! 4089: abort(); ! 4090: } ! 4091: ! 4092: if ( (bn<isize) && getcache(bn, buf) ) { ! 4093: #if DEBUG ! 4094: bdump(buf); ! 4095: #endif ! 4096: return; ! 4097: } ! 4098: ! 4099: if ( lseek(fsfd, (unsigned long)bn*BSIZE, 0) == (-1L) ) ! 4100: switch( query(skblkerr, bn) ) { ! 4101: case YES: ! 4102: bclear(buf, BSIZE); ! 4103: return; ! 4104: case NO: ! 4105: abort(); ! 4106: } ! 4107: ! 4108: if ( read(fsfd, buf, BSIZE) != BSIZE ) ! 4109: switch( query(rdblkerr, bn) ) { ! 4110: case YES: ! 4111: bclear(buf, BSIZE); ! 4112: return; ! 4113: case NO: ! 4114: abort(); ! 4115: } ! 4116: #if DEBUG ! 4117: bdump(buf); ! 4118: #endif ! 4119: } ! 4120: ! 4121: /* ! 4122: * Write block number bn with data in buf ! 4123: */ ! 4124: ! 4125: bwrite(bn, buf) ! 4126: daddr_t bn; ! 4127: char *buf; ! 4128: { ! 4129: #ifdef DEBUG ! 4130: printf("Writing block number: %ld\n", bn); ! 4131: #endif ! 4132: if (!writeflg) ! 4133: return; ! 4134: ! 4135: if (bn<0 || bn>=fsize) ! 4136: switch( query(rgblkerr, bn) ) { ! 4137: case YES: ! 4138: return; ! 4139: case NO: ! 4140: abort(); ! 4141: } ! 4142: ! 4143: if ( lseek(fsfd, (fsize_t)BSIZE*bn, 0) == (-1L) ) ! 4144: switch( query(skblkerr, bn) ) { ! 4145: case YES: ! 4146: return; ! 4147: case NO: ! 4148: abort(); ! 4149: } ! 4150: ! 4151: if ( write(fsfd, buf, BSIZE) != BSIZE ) ! 4152: switch( query(wtblkerr, bn) ) { ! 4153: case YES: ! 4154: return; ! 4155: case NO: ! 4156: abort(); ! 4157: } ! 4158: ! 4159: if ( bn <= isize ) ! 4160: chgcache(bn, buf); ! 4161: changeflg = TRUE; ! 4162: } ! 4163: ! 4164: /* ! 4165: * i-node block area caching routines ! 4166: */ ! 4167: ! 4168: static char cache[NBLK * BSIZE]; ! 4169: static int low = 0; high = -1; ! 4170: ! 4171: getcache(bn, buf) ! 4172: register daddr_t bn; ! 4173: register char *buf; ! 4174: { ! 4175: int totsize; ! 4176: ! 4177: if ( bn > isize ) ! 4178: return(0); ! 4179: ! 4180: if ( (bn>=low) && (bn<=high) ) { ! 4181: blkmove(buf, &cache[BSIZE * (bn-low)]); ! 4182: return(1); ! 4183: } ! 4184: ! 4185: low = bn; ! 4186: if ( (high=bn+NBLK-1) > isize ) ! 4187: high = isize; ! 4188: totsize = BSIZE * (high-low+1); ! 4189: ! 4190: if ( (lseek(fsfd, (unsigned long)bn*BSIZE, 0) == (-1L)) || ! 4191: (read(fsfd, cache, totsize) != totsize) ) { ! 4192: low = 0; high = -1; ! 4193: return(0); ! 4194: } ! 4195: ! 4196: return( getcache(bn, buf) ); ! 4197: } ! 4198: ! 4199: chgcache(bn, buf) ! 4200: register daddr_t bn; ! 4201: register char *buf; ! 4202: { ! 4203: if ( (bn>=low) && (bn<=high) ) ! 4204: blkmove(&cache[BSIZE * (bn-low)], buf); ! 4205: } ! 4206: ! 4207: blkmove(to, from) ! 4208: register char *to, *from; ! 4209: { ! 4210: register int num=BSIZE; ! 4211: ! 4212: while ( num-- ) ! 4213: *to++= *from++; ! 4214: } ! 4215: ! 4216: /* ! 4217: * Clear the given block of memory ! 4218: */ ! 4219: ! 4220: bclear(bp, nb) ! 4221: register char *bp; ! 4222: register unsigned nb; ! 4223: { ! 4224: if (nb) ! 4225: do { ! 4226: *bp++ = 0; ! 4227: } while (--nb); ! 4228: } ! 4229: ! 4230: ! 4231: /* ! 4232: * Determine if the given block is bad ! 4233: */ ! 4234: ! 4235: bad(bn) ! 4236: daddr_t bn; ! 4237: { ! 4238: if ( (bn >= isize) && (bn < fsize) ) ! 4239: return(GOOD); ! 4240: else ! 4241: return(BAD); ! 4242: } ! 4243: ! 4244: ! 4245: #if DEBUG ! 4246: ! 4247: /* ! 4248: * Debug dump a block of data. ! 4249: */ ! 4250: ! 4251: #define NUMPLIN 16 ! 4252: ! 4253: bdump(buf) ! 4254: register unsigned char *buf; ! 4255: { ! 4256: register int i; ! 4257: ! 4258: for (i=0; i<BSIZE; i++) { ! 4259: if ( (i % NUMPLIN) == 0 ) ! 4260: printf("\n0x%04x: ", i); ! 4261: printf(" %02x", *buf++); ! 4262: } ! 4263: printf("\n\n"); ! 4264: } ! 4265: ! 4266: #endif ! 4267: @ ! 4268: ! 4269: ! 4270: 1.1 ! 4271: log ! 4272: @Initial revision ! 4273: @ ! 4274: text ! 4275: @d261 4 ! 4276: a264 1 ! 4277: if ( (bn<isize) && getcache(bn, buf) ) ! 4278: d266 1 ! 4279: d285 3 ! 4280: d412 24 ! 4281: @ ! 4282: iven block is bad ! 4283: */ ! 4284: ! 4285: bad(bn) ! 4286: daddr_t bn; ! 4287: { ! 4288: if ( (bn >= isize) && (bn < fsize) ) ! 4289: return(GOOD); ! 4290: else ! 4291: return(BAD); ! 4292: } ! 4293: ! 4294: ! 4295: #if DEBUG ! 4296: ! 4297: /* ! 4298: * Debug dump a block of data. ! 4299: */ ! 4300: ! 4301: #define NUMPLIN 16 ! 4302: ! 4303: bdump(buf) ! 4304: register unsignefsck/RCS/virtual.c,v 444 3 3 16557 4753557734 7543 head 1.1; ! 4305: access ; ! 4306: symbols ; ! 4307: locks ; ! 4308: comment @ * @; ! 4309: ! 4310: ! 4311: 1.1 ! 4312: date 91.02.05.16.39.42; author bin; state Exp; ! 4313: branches ; ! 4314: next ; ! 4315: ! 4316: ! 4317: desc ! 4318: @prov by epstein (post 310) ! 4319: @ ! 4320: ! 4321: ! 4322: ! 4323: 1.1 ! 4324: log ! 4325: @Initial revision ! 4326: @ ! 4327: text ! 4328: @/* ! 4329: * Virtual memory for fsck. Uses hash algorithm ! 4330: * rather than LRU to get it up fast. ! 4331: */ ! 4332: #include <assert.h> ! 4333: #include <sys/stat.h> ! 4334: #include "fsck.h" ! 4335: ! 4336: #define VBLKB 9 /* bytes in virtual block as power of 2 */ ! 4337: #define VBLK (1 << VBLKB) /* bytes in a virtual block */ ! 4338: #define MBKSB 6 /* number of virtual blocks as power of 2 */ ! 4339: #define MBKS (1 << MBKSB) /* number of virtual blocks */ ! 4340: ! 4341: #define DVTMP "/dev/rram1" /* Default Virtual Temp Filename */ ! 4342: #define DVTMPCLS "/dev/rram1close" /* Default Virtual Temp File Close */ ! 4343: #define MAJORRAM 8 /* Major Device Number for the Ram Disk */ ! 4344: ! 4345: struct mapper { ! 4346: unsigned dirty:1; ! 4347: unsigned what_in:15; /* which block is in memory */ ! 4348: }; ! 4349: ! 4350: static unsigned long flagdsp, blkdsp, dupdsp, duplim; ! 4351: static struct mapper map[MBKS]; ! 4352: static unsigned char data[MBKS][VBLK]; ! 4353: static int tmp; ! 4354: ! 4355: static char *dvtmp = DVTMP; ! 4356: static char *dvtmpcls = DVTMPCLS; ! 4357: ! 4358: /* ! 4359: * Init file system for virtual arrays. ! 4360: * Data is ordered links, flags, blocks then dups. ! 4361: */ ! 4362: initV(links, flags, blocks, dups) ! 4363: unsigned links, flags, blocks, dups; ! 4364: { ! 4365: register long bp; ! 4366: struct stat st; ! 4367: unsigned datasiz; ! 4368: ! 4369: flagdsp = links; ! 4370: blkdsp = flagdsp + flags; ! 4371: dupdsp = blkdsp + blocks; ! 4372: duplim = dupdsp + dups; ! 4373: ! 4374: memset(map, 0, sizeof(map)); /* zero ram arrays */ ! 4375: memset(data, 0, sizeof(data)); ! 4376: ! 4377: tmp = -1; ! 4378: ! 4379: datasiz = sizeof(data); ! 4380: if ( duplim < datasiz ) ! 4381: return; ! 4382: ! 4383: if ( tmpfile == NULL ) { ! 4384: switch ( is_fs(dvtmp) ) { ! 4385: case -1: ! 4386: fatal( ! 4387: "Can't access ram disk \"%s\", use the -t option", dvtmp); ! 4388: case 0: ! 4389: break; ! 4390: case 1: ! 4391: fatal( ! 4392: "Possible file system on ram disk \"%s\", use the -t option", dvtmp); ! 4393: } ! 4394: if ( (-1 == stat(dvtmp, &st)) || !(st.st_mode&S_IFCHR) || ! 4395: (major(st.st_rdev) != MAJORRAM) ) ! 4396: fatal("Ram disk \"%s\" not mknod'ed properly", ! 4397: dvtmp); ! 4398: if ( -1 == (tmp = open(dvtmp, 2)) ) ! 4399: fatal("Cannot open read/write Ram Disk \"%s\"", dvtmp); ! 4400: ! 4401: /* Ram disk driver may not promise zeroed start. ! 4402: * This code may go later. Extra write not important. */ ! 4403: for(bp = 0; bp < duplim; bp += VBLK) /* zero disk stuff */ ! 4404: if ( VBLK != write(tmp, data[0], VBLK) ) ! 4405: fatal("Error writing to tmp file"); ! 4406: } else { ! 4407: if ( -1 == (tmp = open(tmpfile, 2)) ) { ! 4408: if ( -1 == (tmp = creat(tmpfile, 0600)) ) ! 4409: fatal("Cannot create temp file \"%s\"", ! 4410: tmpfile); ! 4411: close(tmp); ! 4412: tmp = open(tmpfile, 2); ! 4413: unlink(tmpfile); ! 4414: } ! 4415: if ( -1 == fstat(tmp, &st) ) ! 4416: fatal("Can't stat temp file \"%s\"", tmpfile); ! 4417: if ( st.st_dev == fsysrdev ) ! 4418: fatal("Temp File must not be on file system to fsck"); ! 4419: } ! 4420: } ! 4421: ! 4422: /* ! 4423: * cleanup virtual system ! 4424: */ ! 4425: cleanV() ! 4426: { ! 4427: struct stat st; ! 4428: ! 4429: if ( tmp == -1 ) /* No Virtual Temp File Opened */ ! 4430: return; ! 4431: ! 4432: close(tmp); ! 4433: if ( tmpfile != NULL ) /* Virtual File not Default RAMDisk */ ! 4434: return; ! 4435: /* Virtual File is Default RAMDisk */ ! 4436: if ( (-1 == stat(dvtmpcls, &st)) || !(st.st_mode&S_IFCHR) || ! 4437: (major(st.st_rdev) != MAJORRAM) || ! 4438: ((minor(st.st_rdev)&0x7F) != 0) ) ! 4439: fatal("Ram disk close \"%s\" not mknod'ed properly", dvtmpcls); ! 4440: if ( -1 == (tmp = open(dvtmpcls, 2)) ) ! 4441: fatal("Cannot open Ram Disk Close \"%s\"", dvtmpcls); ! 4442: if ( close(tmp) < 0 ) ! 4443: fatal("Cannot close Ram Disk Close \"%s\"", dvtmpcls); ! 4444: } ! 4445: ! 4446: /* ! 4447: * All actions for virtual array ! 4448: */ ! 4449: findblock(bp, action, odata) ! 4450: long bp; /* data address */ ! 4451: enum vact action; /* what to do */ ! 4452: unsigned odata; /* optional data */ ! 4453: { ! 4454: unsigned which, what_in, byte_no, bit; ! 4455: unsigned long diskad; ! 4456: unsigned char *byte; ! 4457: extern long lseek(); ! 4458: ! 4459: switch(action) { /* use displacment to correct part of file */ ! 4460: case testBlock: ! 4461: case markBlock: ! 4462: case unmarkBlock: ! 4463: bit = 1 << (bp & 7); ! 4464: bp >>= 3; ! 4465: case grabBlock: /* 8 at a time for copy */ ! 4466: assert(bp >= 0); ! 4467: bp += blkdsp; ! 4468: assert(bp < dupdsp); ! 4469: break; ! 4470: case testDup: ! 4471: case markDup: ! 4472: case unmarkDup: ! 4473: bit = 1 << (bp & 7); ! 4474: bp >>= 3; ! 4475: case setDup: /* 8 at a time for copy */ ! 4476: assert(bp >= 0); ! 4477: bp += dupdsp; ! 4478: assert(bp < duplim); ! 4479: break; ! 4480: case Flags: ! 4481: case setFlags: ! 4482: case orFlags: ! 4483: assert(bp > 0); ! 4484: bp += flagdsp - 1; ! 4485: assert(bp < blkdsp); ! 4486: break; ! 4487: case linkCtr: ! 4488: case incLinkctr: ! 4489: case setLinkctr: ! 4490: assert(bp > 0); ! 4491: bp--; ! 4492: assert(bp < flagdsp); ! 4493: } ! 4494: ! 4495: byte_no = bp & (VBLK - 1); ! 4496: bp >>= VBLKB; ! 4497: which = bp & (MBKS - 1); ! 4498: bp >>= MBKSB; ! 4499: what_in = bp & 0x7fff; ! 4500: ! 4501: if((diskad = map[which].what_in) != what_in) { ! 4502: if(map[which].dirty) { ! 4503: diskad <<= VBLKB + MBKSB; ! 4504: diskad += which << VBLKB; ! 4505: if(-1 == lseek(tmp, diskad, 0)) ! 4506: fatal("Error seeking tmp file"); ! 4507: if(VBLK != write(tmp, data[which], VBLK)) ! 4508: fatal("Error writing tmp file"); ! 4509: } ! 4510: diskad = what_in; ! 4511: diskad <<= VBLKB + MBKSB; ! 4512: diskad += which << VBLKB; ! 4513: if(-1 == lseek(tmp, diskad, 0)) ! 4514: fatal("Error seeking tmp file"); ! 4515: if(VBLK != read(tmp, data[which], VBLK)) ! 4516: memset(data[which], 0, VBLK); ! 4517: map[which].what_in = what_in; ! 4518: map[which].dirty = 0; /* clean */ ! 4519: } ! 4520: byte = &data[which][byte_no]; ! 4521: ! 4522: switch(action) { ! 4523: case testBlock: ! 4524: case testDup: ! 4525: return(*byte & bit); ! 4526: case markBlock: ! 4527: case markDup: ! 4528: map[which].dirty = 1; ! 4529: return(*byte |= bit); ! 4530: case unmarkBlock: ! 4531: case unmarkDup: ! 4532: map[which].dirty = 1; ! 4533: return(*byte ^= bit); ! 4534: case linkCtr: ! 4535: case Flags: ! 4536: case grabBlock: ! 4537: return(*byte); ! 4538: case setLinkctr: ! 4539: case setFlags: ! 4540: case setDup: ! 4541: map[which].dirty = 1; ! 4542: return(*byte = odata); ! 4543: case orFlags: ! 4544: map[which].dirty = 1; ! 4545: return(*byte |= odata); ! 4546: case incLinkctr: ! 4547: map[which].dirty = 1; ! 4548: return(++*byte); ! 4549: default: ! 4550: fatal("Bad action in virtual system"); ! 4551: } ! 4552: } ! 4553: ! 4554: /* ! 4555: * copy virtual memory blockmap to dupmap ! 4556: * read and write groups to avoid possable thrashing. ! 4557: */ ! 4558: void ! 4559: copyV(size) ! 4560: unsigned size; ! 4561: { ! 4562: char buf[128]; ! 4563: register int i; ! 4564: long bp, bs; ! 4565: ! 4566: for(bs = bp = 0; bp < size; ) { ! 4567: for(i = 0; (i < 128) && (bp < size); i++, bp++) ! 4568: buf[i] = findblock(bp, grabBlock); ! 4569: ! 4570: for(i = 0; (i < 128) && (bs < size); i++, bs++) ! 4571: findblock(bs, setDup, buf[i]); ! 4572: } ! 4573: } ! 4574: ! 4575: #ifdef TEST ! 4576: fatal(s) ! 4577: char *s; ! 4578: { ! 4579: fprintf(stderr, "%s\n", s); ! 4580: exit(1); ! 4581: } ! 4582: ! 4583: static char buf[80]; ! 4584: gbuf() ! 4585: { ! 4586: if(NULL == gets(buf)) { ! 4587: unlink("vtmp"); ! 4588: exit(0); ! 4589: } ! 4590: return(buf[0]); ! 4591: } ! 4592: ! 4593: main() ! 4594: { ! 4595: unsigned long b; ! 4596: char data; ! 4597: ! 4598: initV(10000, 10000, 20000); ! 4599: for(;;) { ! 4600: printf("b = block, d = dup, f = flags, l = linkctr\n"); ! 4601: switch(gbuf()) { ! 4602: case 'l': ! 4603: printf("s = set, d = display, i = increment: then loc\n"); ! 4604: gbuf(); ! 4605: sscanf(buf + 2, "%ld", &b); ! 4606: switch(buf[0]) { ! 4607: case 's': ! 4608: setlinkctr(b, 0); /* no data */ ! 4609: case 'd': ! 4610: printf("%d\n", linkctr(b)); ! 4611: break; ! 4612: case 'i': ! 4613: printf("%d\n", inclinkctr(b)); ! 4614: } ! 4615: break; ! 4616: case 'f': ! 4617: printf("d = display, s = set, o = or: then loc\n"); ! 4618: gbuf(); ! 4619: sscanf(buf + 2, "%ld %c", &b, &data); ! 4620: switch(buf[0]) { ! 4621: case 's': ! 4622: setflags(b, data); ! 4623: case 'd': ! 4624: break; ! 4625: case 'o': ! 4626: orflags(b, data); ! 4627: } ! 4628: printf("%c\n", flags(b)); ! 4629: break; ! 4630: case 'b': ! 4631: printf("t = test, m = mark, u = unmark: then loc\n"); ! 4632: gbuf(); ! 4633: sscanf(buf + 2, "%ld", &b); ! 4634: switch(buf[0]) { ! 4635: case 'm': ! 4636: markblock(b); ! 4637: case 't': ! 4638: break; ! 4639: case 'u': ! 4640: unmarkblock(b); ! 4641: } ! 4642: printf("%c\n", testblock(b) ? '1' : '0'); ! 4643: break; ! 4644: case 'd': ! 4645: printf("t = test, m = mark, u = unmark: then loc\n"); ! 4646: gbuf(); ! 4647: sscanf(buf + 2, "%ld", &b); ! 4648: switch(buf[0]) { ! 4649: case 'm': ! 4650: markdup(b); ! 4651: case 't': ! 4652: break; ! 4653: case 'u': ! 4654: unmarkdup(b); ! 4655: } ! 4656: printf("%c\n", testdup(b) ? '1' : '0'); ! 4657: break; ! 4658: } ! 4659: } ! 4660: } ! 4661: #endif ! 4662: ! 4663: @ ! 4664: loc\n"); ! 4665: gbuf(); ! 4666: sscanf(buf + 2, "%ld", &b); ! 4667: switch(buf[0]) { ! 4668: case 'm': ! 4669: markblock(b); ! 4670: case 't': ! 4671: break; ! 4672: case 'u': ! 4673: ufsck/READ_ME 644 3 3 1227 4664524112 5766 Ideas for improving the performance of fsck: ! 4674: ! 4675: (1) Utilize a different mechanism for storing the (struct direct) ! 4676: entries throughout phase2.c, to remove implicit memory intensive ! 4677: redundancy. ! 4678: ! 4679: (2) Encode the number of links per i-node count differently, in order ! 4680: to save space taking advantage of the typical usage under Coherent. ! 4681: ! 4682: (3) Arrange space for the tables in a total needed way to avoid later ! 4683: fragmentation problems affecting the memory requests for successive ! 4684: file systems. ! 4685: ! 4686: (4) Devise a more clever buffering scheme for the blocks containing ! 4687: i-nodes to understand the differences between phase1, phase2, and ! 4688: phase4. ! 4689: emove implicit memory intensive ! 4690: redundancy. ! 4691: ! 4692: (2) Encode the number of links per i-node count differently, in order ! 4693: to save space taking advantage of the typical usage under Coherent. ! 4694: ! 4695: (3) Arrange space for the tables in a total needed way to avoid later ! 4696: fragmentation problems affecting the memory requests for successive ! 4697: file systems. ! 4698: ! 4699: (4fsck/cleanup.c 644 3 3 2324 4664524112 6541 /* ! 4700: * Cleanup functions for phases of fsck ! 4701: */ ! 4702: ! 4703: #include "fsck.h" ! 4704: ! 4705: cleanup() ! 4706: { ! 4707: int retval = 0; ! 4708: ! 4709: if (sbpfix == TRUE) ! 4710: writesuper(); ! 4711: prtstats(); ! 4712: if (changeflg == TRUE) ! 4713: retval = advise(); ! 4714: close(fsfd); ! 4715: cleanV(); ! 4716: return(retval); ! 4717: } ! 4718: ! 4719: writesuper() ! 4720: { ! 4721: register int i; ! 4722: ! 4723: canshort(sbp->s_isize); ! 4724: candaddr(sbp->s_fsize); ! 4725: canshort(sbp->s_nfree); ! 4726: for(i=0; i<NICFREE; i++) ! 4727: candaddr(sbp->s_free[i]); ! 4728: canshort(sbp->s_ninode); ! 4729: for(i=0; i<NICINOD; i++) ! 4730: canino(sbp->s_inode[i]); ! 4731: cantime(sbp->s_time); ! 4732: candaddr(sbp->s_tfree); ! 4733: canino(sbp->s_tinode); ! 4734: canshort(sbp->s_m); ! 4735: canshort(sbp->s_n); ! 4736: canlong(sbp->s_unique); ! 4737: ! 4738: bwrite((daddr_t)SUPERI, sbp); ! 4739: } ! 4740: ! 4741: prtstats() ! 4742: { ! 4743: if (!fflag) ! 4744: printf("%u files ", numfiles); ! 4745: printf("%U blocks ", fsize - isize - totfree); ! 4746: printf("%U free\n", totfree); ! 4747: if ( lostsize ) { ! 4748: lostsize = (lostsize + BSIZE - 1)/BSIZE; ! 4749: printf("Expect roughly %U missing block%s next\n", lostsize, ! 4750: (lostsize!=1) ? "s" : "" ); ! 4751: printf("time fsck is run as a result of inodes "); ! 4752: printf("being cleared.\n"); ! 4753: } ! 4754: } ! 4755: ! 4756: advise() ! 4757: { ! 4758: int retval = 0; ! 4759: ! 4760: printf(" ***** File System %s was modified *****\n", fsname); ! 4761: if ( mounted ) { ! 4762: printf(" ***** BOOT Coherent (NO SYNC!) *****\n"); ! 4763: retval = 1; ! 4764: } ! 4765: return(retval); ! 4766: } ! 4767: blocks ", fsize - isize - totfree); ! 4768: printf("%U free\n", totfree); ! 4769: if ( lostsize ) { ! 4770: lostsize = (lostsize + BSIZE - 1)/BSIZE; ! 4771: printf("Expect roughly %U missing block%s next\n", lostsize, ! 4772: (lostsize!=1) ? "s" : "" ); ! 4773: printf("time fsck is run as a result of inodes "); ! 4774: printf("being clearedfsck/fsck.h 644 3 3 14003 5033723044 6056 /* ! 4775: * Header file for fsck -- File System Check Program ! 4776: * ! 4777: */ ! 4778: ! 4779: #include <canon.h> ! 4780: #include <sys/dir.h> ! 4781: #include <sys/fblk.h> ! 4782: #include <sys/filsys.h> ! 4783: #include <sys/ino.h> ! 4784: #include <sys/stat.h> ! 4785: #include <sys/types.h> ! 4786: #include <time.h> ! 4787: ! 4788: #if HPCOHERENT ! 4789: typedef long fsize_t; ! 4790: #endif ! 4791: ! 4792: /* ! 4793: * Conditional Compilation Flags ! 4794: */ ! 4795: ! 4796: #define NOT_ALL_ZERO_INODE /* Dependent on whether or not an inode */ ! 4797: #ifdef ALL_ZERO_INODE /* is totally zeroed when unallocated */ ! 4798: #undef ALL_ZERO_INODE /* or simply a zero mode and zero link */ ! 4799: #endif ! 4800: ! 4801: ! 4802: /* ! 4803: * Definitions and Externs ! 4804: */ ! 4805: ! 4806: #define NUL 0 /* true zero ! */ ! 4807: #define NULL ((char *)0) ! 4808: ! 4809: #define YES 3 /* default actions */ ! 4810: #define NO 2 ! 4811: #define ASK 1 ! 4812: ! 4813: #define NFILSYS 10 /* max number of file systems */ ! 4814: #define MAXCH 20 /* max length of filesys name */ ! 4815: ! 4816: #define MAXBADOK 10 /* Max number of bad blocks before excessive */ ! 4817: extern int numbad; /* num bad blocks found so far this inode*/ ! 4818: ! 4819: #define MAXDUPOK 10 /* Max number of dup blocks */ ! 4820: /* in a single inode before excessive */ ! 4821: #define DUPTBLSIZE 20 /* Max number of dup referenced blocks */ ! 4822: extern daddr_t dupblck[]; /* table of duplicate referenced blocks */ ! 4823: extern int totdups; /* number of dup blocks found so far */ ! 4824: ! 4825: #define MAXBADFREE 10 /* max bad in free list before abort */ ! 4826: #define MAXDUPFREE 10 /* max dup in free list before abort */ ! 4827: ! 4828: #define GOOD 1 /* returned by bad() in util.c */ ! 4829: #define BAD 0 ! 4830: ! 4831: #define TRUE 1 /* errflag possibilities */ ! 4832: #define FALSE 0 ! 4833: extern int errflag; /* errflag indicates not to do phases */ ! 4834: ! 4835: #define OK 1 /* used to indicate excessive bad/dup */ ! 4836: #define STOP 0 /* blocks in an inode in phase1.c */ ! 4837: #define BAD_DUP 2 ! 4838: ! 4839: #define FIRSTIN 2 /* First real inode number */ ! 4840: ! 4841: #define ND 10 /* Number of Direct Blocks */ ! 4842: #undef NI ! 4843: #define NI 1 ! 4844: #define NII 1 ! 4845: #define NIII 1 ! 4846: #undef NADDR ! 4847: #define NADDR (ND+NI+NII+NIII) ! 4848: extern int offsets[]; /* table of offsets for level of indirection */ ! 4849: /* for the blocks in an inode */ ! 4850: ! 4851: extern char nextchar(); /* used in util.c */ ! 4852: extern int fsfd; /* file system file descriptor */ ! 4853: extern int mdaction; /* default action for this invocation */ ! 4854: extern int daction; /* default action for current file system */ ! 4855: extern int writeflg; /* system write ok or read-only */ ! 4856: extern int qflag; /* quiet fsck flag */ ! 4857: extern int fflag; /* fast fsck flag */ ! 4858: extern int sflag; /* force free list salvation */ ! 4859: extern daddr_t fsize; /* file system size in blocks */ ! 4860: extern int isize; /* first block not in inode list */ ! 4861: /* isize is NOT unsigned so that comparisons */ ! 4862: /* with longs will not cast the long to */ ! 4863: /* unsigned thus producing confusing results */ ! 4864: ! 4865: extern daddr_t totfree; /* running count of total free blocks */ ! 4866: extern unsigned ninodes;/* Number of inodes in the files system */ ! 4867: extern char *fsname; /* file system name */ ! 4868: extern fsize_t pinfo(); /* returns size of file, in phase2.c */ ! 4869: extern ino_t lostfound(); /* returns inumber of lost+found dir */ ! 4870: extern struct dinode *ptrino(); /* returns a ptr to inode, give number */ ! 4871: extern char databuf[]; /* buffer to read in block, used throughout */ ! 4872: extern char buf2[]; /* alternate data buffer */ ! 4873: extern daddr_t cdbn; /* current block number, used by nextblock() */ ! 4874: #define DSIZE (sizeof(struct direct)) ! 4875: extern char *lostname; /* name of lost+found directory */ ! 4876: extern char *nameit(); /* nameing function for lost dirs and files */ ! 4877: extern int depth; /* used during tree traversal in phase2.c */ ! 4878: extern struct direct *path[]; /* used during tree traversal in phase2.c */ ! 4879: extern char *typename(); /* return string to type of inode */ ! 4880: extern struct filsys *sbp; /* Super Block */ ! 4881: extern int sbpfix; /* flag for super block fixes */ ! 4882: extern struct stat stats; /* used by statit() in util.c */ ! 4883: extern dev_t rootdev; /* root device number */ ! 4884: extern dev_t fsysrdev; /* file system real device number */ ! 4885: extern int mounted; /* flag indicating mountedness of filesystem */ ! 4886: extern int changeflg; /* file system modified flag */ ! 4887: extern int fixerup; /* flag to rebuild free list */ ! 4888: extern char *fixit; /* Prompt message phase[45].c */ ! 4889: extern int numfiles; /* num files in system */ ! 4890: extern daddr_t imap(); /* function for disk block mapping in util.c */ ! 4891: extern fsize_t lostsize; /* Size of files cleared in phase4.c */ ! 4892: extern char *tmpfile; /* TMP File name for virtual.c */ ! 4893: ! 4894: #define SUCCESS 1 /* used in connect() in phase3.c */ ! 4895: #define FAILURE 0 ! 4896: ! 4897: #define MODEMASK 0x07 ! 4898: #define ALLOCMASK 0x06 ! 4899: #define UNALLOC 0x00 ! 4900: #define UNKNOWN 0x01 ! 4901: #define IDIR 0x02 ! 4902: #define IREG 0x03 ! 4903: #define ICHR 0x04 ! 4904: #define IBLK 0x05 ! 4905: #define IPIPE 0x06 ! 4906: #define IBAD_IDUP 0x08 ! 4907: #define VISITED 0x10 ! 4908: #define UNREFDIR 0x20 ! 4909: #define CHILDDIR 0x40 ! 4910: #define IFREELIST 0x80 ! 4911: ! 4912: /* ! 4913: * Macros for tables ! 4914: */ ! 4915: ! 4916: #define LOGNBPC 3 /* Log2 Number of Bits per Character */ ! 4917: ! 4918: /* Actions for virtual block system */ ! 4919: enum vact { testBlock, markBlock, unmarkBlock, grabBlock, ! 4920: testDup, markDup, unmarkDup, setDup, ! 4921: Flags, setFlags, orFlags, ! 4922: linkCtr, incLinkctr, setLinkctr }; ! 4923: ! 4924: #define testblock(bn) findblock((unsigned long)(bn), testBlock) ! 4925: #define markblock(bn) findblock((unsigned long)(bn), markBlock) ! 4926: #define unmarkblock(bn) findblock((unsigned long)(bn), unmarkBlock) ! 4927: ! 4928: #define testdup(bn) findblock((unsigned long)(bn), testDup) ! 4929: #define markdup(bn) findblock((unsigned long)(bn), markDup) ! 4930: #define unmarkdup(bn) findblock((unsigned long)(bn), unmarkDup) ! 4931: ! 4932: #define flags(ino) findblock((unsigned long)(ino), Flags) ! 4933: #define setflags(ino, data) findblock((unsigned long)(ino), setFlags, data) ! 4934: #define orflags(ino, data) findblock((unsigned long)(ino), orFlags, data) ! 4935: ! 4936: #define linkctr(ino) findblock((unsigned long)(ino), linkCtr) ! 4937: #define inclinkctr(ino) findblock((unsigned long)(ino), incLinkctr) ! 4938: #define setlinkctr(ino, data) findblock((unsigned long)(ino), setLinkctr, data) ! 4939: ! 4940: #define badblks(ino) ( flags(ino)&IBAD_IDUP ) ! 4941: ! 4942: /* ! 4943: * Miscellany ! 4944: */ ! 4945: ! 4946: #define NBPC 8 /* number of bits per character */ ! 4947: #define MAXINTN 255 /* used for interleave table */ ! 4948: /* in phase6.c */ ! 4949: /* ! 4950: * Stdio Stuff ! 4951: */ ! 4952: ! 4953: #define putchar(c) { char b = c; write(1, &b, 1); } ! 4954: extern char *malloc(); ! 4955: extern char *calloc(); ! 4956: ! 4957: findblock((unsigned long)(ino), linkCtr) ! 4958: #define inclinkctr(ino) findblock((unsigned long)(ino), incLinkctr) ! 4959: #define setlinkctr(ino, data) findblock((unsigned long)(ino), setLinkctr, data) ! 4960: ! 4961: #define badblks(ino) ( flags(ino)&IBAD_IDUP ) ! 4962: ! 4963: /* ! 4964: * Miscellany ! 4965: */ ! 4966: ! 4967: #define NBPC 8 /* number of bits per character */ ! 4968: #define MAXINTN 255 /* used for interleave table */ ! 4969: /* in phase6.c */ ! 4970: /* ! 4971: * Stdio Stuff ! 4972: */ ! 4973: ! 4974: #define putchar(c) { char b = c; write(1, &b, 1); } ! 4975: extern char *malloc(); ! 4976: extern char *calloc()fsck/init.c 644 3 3 12651 5041132573 6075 /* ! 4977: * Perform initialization for phases of fsck ! 4978: */ ! 4979: #include "fsck.h" ! 4980: #include <mnttab.h> ! 4981: #include <mtab.h> ! 4982: ! 4983: int fsfd; /* file system file descriptor */ ! 4984: int writeflg; /* write ok or read-only flag */ ! 4985: daddr_t fsize = SUPERI+1; /* file system size in blocks */ ! 4986: /* Allows for read of Super Block */ ! 4987: int isize; /* First block not in inode list */ ! 4988: daddr_t totfree; /* Running total free block count */ ! 4989: unsigned ninodes; /* number of inodes */ ! 4990: int numfiles; /* number of files in file system */ ! 4991: ! 4992: char superb[BSIZE]; /* Super Block */ ! 4993: struct filsys *sbp = superb; ! 4994: int sbpfix; /* flag for super block fixes */ ! 4995: ! 4996: int offsets[] = /* table of offsets for the levels */ ! 4997: { ND, ND+NI, ND+NI+NII, /* of indirection of blocks in the */ ! 4998: ND+NI+NII+NIII }; /* inode block list */ ! 4999: ! 5000: daddr_t dupblck[DUPTBLSIZE]; /* duplicate referenced blocks */ ! 5001: int totdups; /* number of dup blocks so far */ ! 5002: ! 5003: init() ! 5004: { ! 5005: int mode; ! 5006: struct stat status; ! 5007: unsigned short stmode; ! 5008: ! 5009: mode = (mdaction == NO) ? 0 : 2; ! 5010: ! 5011: if ( (fsfd = open(fsname, mode)) == (-1) ) { ! 5012: mode = 0; ! 5013: if ( (fsfd = open(fsname, mode)) == (-1) ) { ! 5014: nonfatal("Can't open: %s", fsname); ! 5015: return; ! 5016: } ! 5017: } ! 5018: ! 5019: if (mode == 0) { ! 5020: daction = NO; ! 5021: writeflg = FALSE; ! 5022: } else { ! 5023: daction = mdaction; ! 5024: writeflg = TRUE; ! 5025: } ! 5026: ! 5027: printf("%s: %s\n", fsname, (mode == 0) ? "(NO WRITE)" : ""); ! 5028: ! 5029: if ( fstat(fsfd, &status) == (-1) ) { ! 5030: nonfatal("Can't stat: %s", fsname); ! 5031: return; ! 5032: } ! 5033: ! 5034: stmode = status.st_mode & S_IFMT; ! 5035: if ( (stmode != S_IFBLK) && (stmode != S_IFCHR) ) ! 5036: switch(query("file is not a block or character device; OK?")){ ! 5037: case YES: ! 5038: break; ! 5039: case NO: ! 5040: errflag = TRUE; ! 5041: return; ! 5042: } ! 5043: ! 5044: domount(); ! 5045: sbpfix = FALSE; ! 5046: readsuper(); ! 5047: checksuper(); ! 5048: if ( !errflag ) ! 5049: alloctables(); ! 5050: } ! 5051: ! 5052: /* ! 5053: * Read in the super block and canonicalize ! 5054: */ ! 5055: ! 5056: readsuper() ! 5057: { ! 5058: register int i; ! 5059: ! 5060: bread((daddr_t)SUPERI, superb); ! 5061: sbp = superb; ! 5062: ! 5063: canshort(sbp->s_isize); ! 5064: candaddr(sbp->s_fsize); ! 5065: canshort(sbp->s_nfree); ! 5066: for(i=0; i<NICFREE; i++) ! 5067: candaddr(sbp->s_free[i]); ! 5068: canshort(sbp->s_ninode); ! 5069: for(i=0; i<NICINOD; i++) ! 5070: canino(sbp->s_inode[i]); ! 5071: cantime(sbp->s_time); ! 5072: candaddr(sbp->s_tfree); ! 5073: canino(sbp->s_tinode); ! 5074: canshort(sbp->s_m); ! 5075: canshort(sbp->s_n); ! 5076: canlong(sbp->s_unique); ! 5077: ! 5078: } ! 5079: ! 5080: /* ! 5081: * Check super block for obvious inconsistencies ! 5082: */ ! 5083: ! 5084: checksuper() ! 5085: { ! 5086: fsize = sbp->s_fsize; ! 5087: isize = sbp->s_isize; ! 5088: totfree = fsize - isize; ! 5089: ! 5090: if ( (isize<=INODEI) || (isize>=fsize) || (fsize<=INODEI) ) { ! 5091: badsuper("Size check: fsize %U isize %u", fsize, isize); ! 5092: errflag = TRUE; ! 5093: } ! 5094: ! 5095: if ( sbp->s_nfree > NICFREE ) ! 5096: badsuper("Too large free block count"); ! 5097: ! 5098: if ( sbp->s_ninode > NICINOD ) ! 5099: badsuper("Too large free i-node count"); ! 5100: } ! 5101: ! 5102: /* ! 5103: * Super Block Error Functions ! 5104: */ ! 5105: ! 5106: badsuper(x) ! 5107: { ! 5108: printf("%r\n", &x); ! 5109: printf("fsck: %s: Bad Super Block: %u\n", fsname, SUPERI); ! 5110: } ! 5111: ! 5112: /* ! 5113: * Allocate the necessary buffers for tables ! 5114: */ ! 5115: ! 5116: alloctables() ! 5117: { ! 5118: unsigned num, numl; ! 5119: ! 5120: numl = 0; ! 5121: if (!fflag) { ! 5122: ninodes = (unsigned) (isize - INODEI) * INOPB; ! 5123: numl = (unsigned) ninodes; ! 5124: } ! 5125: ! 5126: num = (unsigned) ((fsize+NBPC-1)/NBPC) * sizeof(char); ! 5127: initV(numl, numl, num, num); /* virtual allocation */ ! 5128: ! 5129: numfiles = /* number of files in the file system */ ! 5130: totdups = 0; /* num dup blocks */ ! 5131: } ! 5132: ! 5133: /* ! 5134: * domount() checks the files /etc/mnttab and /etc/mtab to find ! 5135: * out where the file system is mounted (if at all). It then ! 5136: * reports where (and when if possible) it was last mounted. ! 5137: */ ! 5138: char *mnttab_name = "/etc/mnttab"; ! 5139: char *mtab_name = "/etc/mtab"; ! 5140: char *bttime_name = "/etc/boottime"; ! 5141: ! 5142: domount() ! 5143: { ! 5144: int fd; ! 5145: struct mnttab mnttab; ! 5146: struct mtab mtab; ! 5147: register char *name; ! 5148: struct stat sbuf; ! 5149: time_t boottime; ! 5150: int nothing(); ! 5151: char devname[MNTNSIZ+6] = "/dev/"; ! 5152: ! 5153: mounted = FALSE; ! 5154: name = fsname; /* strip off all initial */ ! 5155: while (*name++ != '\0') ; /* directories in fsname */ ! 5156: while ( (*--name != '/') && (name>fsname) ) ; ! 5157: if (*name == '/') name++; ! 5158: ! 5159: if ( stat(bttime_name, &sbuf) == -1 ) ! 5160: boottime = (time_t)0; ! 5161: else ! 5162: boottime = sbuf.st_mtime; ! 5163: ! 5164: if ( (fd=open(mnttab_name, 0)) != (-1) ) { ! 5165: while ( read(fd, &mnttab, sizeof(mnttab))==sizeof(mnttab) ) ! 5166: if ( mnttab.mt_dev[0] && mnttab.mt_filsys[0] ) { ! 5167: strncpy(&devname[5], mnttab.mt_filsys, MNTNSIZ); ! 5168: devname[MNTNSIZ+5] = '\0'; ! 5169: statit(devname, nothing); ! 5170: if (stats.st_rdev != fsysrdev) ! 5171: continue; ! 5172: statit(mnttab.mt_dev, nothing); ! 5173: mounted = (stats.st_dev == fsysrdev); ! 5174: prmnttab(&mnttab, boottime); ! 5175: return; ! 5176: } ! 5177: } ! 5178: if ( (fd=open(mtab_name, 0)) != (-1) ) { ! 5179: while ( read(fd, &mtab, sizeof(mtab))==sizeof(mtab) ) ! 5180: if ( mtab.mt_name[0] && mtab.mt_special[0] ) { ! 5181: strncpy(&devname[5], mtab.mt_special, MNAMSIZ); ! 5182: devname[MNAMSIZ+5] = '\0'; ! 5183: statit(devname, nothing); ! 5184: if (stats.st_rdev != fsysrdev) ! 5185: continue; ! 5186: statit(mtab.mt_name, nothing); ! 5187: mounted = (stats.st_dev == fsysrdev); ! 5188: prmtab(&mtab); ! 5189: return; ! 5190: } ! 5191: } ! 5192: ! 5193: if (fsysrdev == rootdev) ! 5194: mounted = TRUE; ! 5195: else ! 5196: mounted = FALSE; ! 5197: ! 5198: } ! 5199: ! 5200: prmnttab(ptr, boottime) ! 5201: struct mnttab *ptr; ! 5202: time_t boottime; ! 5203: { ! 5204: if (mounted) { ! 5205: if (boottime < ptr->mt_time) ! 5206: boottime = ptr->mt_time; ! 5207: printf("%s mounted on %.*s as of %s", fsname, MNTNSIZ, ! 5208: ptr->mt_dev, ctime(&boottime)); ! 5209: } else ! 5210: printf("%s unmounted. Last mounted on %.*s -- %s", ! 5211: fsname, MNTNSIZ, ptr->mt_dev, ! 5212: ctime(&ptr->mt_time)); ! 5213: } ! 5214: ! 5215: ! 5216: prmtab(ptr) ! 5217: struct mtab *ptr; ! 5218: { ! 5219: if (mounted) ! 5220: printf("%s mounted on %.*s\n", fsname, MNAMSIZ, ptr->mt_name); ! 5221: else ! 5222: printf("%s unmounted. Last mounted on %.*s\n", fsname, ! 5223: MNAMSIZ, ptr->mt_name); ! 5224: } ! 5225: ! 5226: nothing() ! 5227: {} ! 5228: ) { ! 5229: if (boottime < ptr->mt_time) ! 5230: boottime = ptr->mt_time; ! 5231: printf("%s mounted on fsck/is_fs.c 644 3 3 3467 4705135657 6236 #include <sys/stat.h> ! 5232: #include <canon.h> ! 5233: #include <sys/filsys.h> ! 5234: ! 5235: /* ! 5236: * Check if a special file is a well-formed filesystem. ! 5237: * This routine is derived from code in "mount.c". ! 5238: * Return values: ! 5239: * -1 Not a device, cannot open, read or seek failed ! 5240: * 0 No filesystem ! 5241: * 1 Legal filesystem ! 5242: */ ! 5243: int ! 5244: is_fs(special) char *special; ! 5245: { ! 5246: static struct filsys f; ! 5247: struct stat sbuf; ! 5248: register int fd; ! 5249: register struct filsys *fp; ! 5250: register daddr_t *dp; ! 5251: register ino_t *ip, maxinode; ! 5252: ! 5253: if (stat(special, &sbuf) < 0) ! 5254: return -1; /* cannot stat device */ ! 5255: else if ((sbuf.st_mode&S_IFMT) != S_IFBLK ! 5256: && (sbuf.st_mode&S_IFMT) != S_IFCHR) ! 5257: return -1; /* not a special file */ ! 5258: else if ((fd = open(special, 2)) < 0) ! 5259: return -1; /* cannot open */ ! 5260: else if (lseek(fd, (long)SUPERI*BSIZE, 0) == -1L ! 5261: || read(fd, &f, sizeof(f)) != sizeof(f)) { ! 5262: close(fd); ! 5263: return -1; /* seek or read failed */ ! 5264: } else ! 5265: close(fd); /* so far so good */ ! 5266: ! 5267: /* Canonical stuff. */ ! 5268: fp = &f; ! 5269: canshort(fp->s_isize); ! 5270: candaddr(fp->s_fsize); ! 5271: canshort(fp->s_nfree); ! 5272: for (dp = &fp->s_free[0]; dp < &fp->s_free[NICFREE]; dp += 1) ! 5273: candaddr(*dp); ! 5274: canshort(fp->s_ninode); ! 5275: for (ip = &fp->s_inode[0]; ip < &fp->s_inode[NICINOD]; ip += 1) ! 5276: canino(*ip); ! 5277: candaddr(fp->s_tfree); ! 5278: canino(fp->s_tinode); ! 5279: ! 5280: /* Test for rationality. */ ! 5281: maxinode = (fp->s_isize - INODEI) * INOPB + 1; ! 5282: if (fp->s_isize >= fp->s_fsize) ! 5283: return 0; ! 5284: if ((fp->s_tfree < fp->s_nfree) ! 5285: || (fp->s_tfree >= fp->s_fsize - fp->s_isize + 1)) ! 5286: return 0; ! 5287: if ((fp->s_tinode < fp->s_ninode) || (fp->s_tinode >= maxinode-1 )) ! 5288: return 0; ! 5289: for (dp = &fp->s_free[0]; dp < &fp->s_free[fp->s_nfree]; dp += 1) ! 5290: if ((*dp < fp->s_isize) || (*dp >= fp->s_fsize)) ! 5291: return 0; ! 5292: for (ip = &fp->s_inode[0]; ip < &fp->s_inode[fp->s_ninode]; ip += 1) ! 5293: if ((*ip < 1) || (*ip > maxinode)) ! 5294: return 0; ! 5295: return 1; ! 5296: } ! 5297: - INODEI) * INOPB + 1; ! 5298: if (fp->s_isize >= fp->s_fsize) ! 5299: return 0; ! 5300: if ((fp->s_tfree < fp->s_nfree) ! 5301: || (fp->s_tfree >= fp->s_fsize - fp->s_isize + 1)) ! 5302: return 0; ! 5303: if ((fp->s_tinode < fp->s_ninode)fsck/link.c 644 3 3 2762 4664524116 6061 /* ! 5304: * Routines to handle the counting of links for each i-node ! 5305: */ ! 5306: ! 5307: #include "fsck.h" ! 5308: ! 5309: linkincr(inum) ! 5310: ino_t inum; ! 5311: { ! 5312: if (inclinkctr(inum) == 0 ) ! 5313: fatal("Too many links in i-node, %d", inum); ! 5314: } ! 5315: ! 5316: /* ! 5317: * The following is the beginning of thinking of how to change ! 5318: * the number of bits used in the link count tables from 8-per ! 5319: * i-node to 2-per i-node, with additional tables for those ! 5320: * i-nodes with more than 2 links. The changes would be to the ! 5321: * definition of i_lnks, the macro linkctr(), the function linkincr(), ! 5322: * and in init.c, the allocation of table space. ! 5323: */ ! 5324: ! 5325: #ifdef NEWLINKSTUFFF ! 5326: ! 5327: char *linkmap; /* table of inodes with one link */ ! 5328: ! 5329: #define testlink(in) ( linkmap[((unsigned)bn)>>(LOGNBPC-1)] & \ ! 5330: 3 << (((unsigned)bn)&(NBPC>>1)) ) ! 5331: #define marklink(in) ( linkmap[((unsigned)bn)>>(LOGNBPC-1)] |= \ ! 5332: 1 << (((unsigned)bn)&(NBPC-2)) ) ! 5333: #define unmarklink(in) ( linkmap[((unsigned)bn)>>(LOGNBPC-1)] ^= \ ! 5334: 1 << (((unsigned)bn)&(NBPC-2)) ) ! 5335: ! 5336: linkcntr(inum) ! 5337: ino_t inum; ! 5338: { ! 5339: index = ((unsigned) inum) >> (LOGNBPC-1) ; ! 5340: distance = ((unsigned) inum) & ((NBPC>>1) - 1) ; ! 5341: mask = 3 << distance; ! 5342: answer = ( linkmap[index] & mask ) >> distance; ! 5343: ! 5344: if ( answer < 3 ) ! 5345: return(answer); ! 5346: ! 5347: hash = inum & 0xFF; ! 5348: bucket = &linktable[hash]; ! 5349: bktinum = bucket->inumb; ! 5350: ! 5351: if ( bktinum == inum ) { ! 5352: answer = bucket->numlink; ! 5353: if ( answer == 0xFF ) ! 5354: return( bigcntr(inum) ); ! 5355: else ! 5356: return( answer + 3 ); ! 5357: } ! 5358: ! 5359: if ( bktinum > inum ) ! 5360: fatal("internal linktable corruption."); ! 5361: ! 5362: ! 5363: } ! 5364: ! 5365: linkincr(inum) ! 5366: ino_t inum; ! 5367: { ! 5368: } ! 5369: ! 5370: #endif ! 5371: num) >> (LOGNBfsck/main.c 644 3 3 12436 5041134504 6053 /* ! 5372: * fsck -- File System Check Program ! 5373: * an interactive file system check and repair program. ! 5374: * ! 5375: * Usage: ! 5376: * /etc/fsck [-y] [-n] [-q] [-f] [-{sS}] [-t TMPFILE] [filesystem ...] ! 5377: * audit and interactively repair inconsistent conditions for ! 5378: * file systems. Options -y and -n indicate an assumed response ! 5379: * to all questions asked by fsck. Default is to prompt operator ! 5380: * for yes/no response. Option -q is to quiet fsck from printing ! 5381: * certain messages, i.e. no size check messages, unreferenced ! 5382: * pipes will be silently removed, and counts in the superblock ! 5383: * will be automatically fixed and free list salvaged, if necessary. ! 5384: * Option -f is for a 'fast' check of the file system, i.e. only ! 5385: * check blocks, sizes, superblock counts, and the free list. ! 5386: * (-f) does not check pathnames, connectivity, or reference ! 5387: * counts. Option -s forces the reconstruction (or salvaging) of ! 5388: * both the free inode list and the free block list, even if there ! 5389: * are no file system problems. This will reorder the free block ! 5390: * list in the best order to limit additional fragmentation (respecting ! 5391: * interleaving as well). Note: Option -s will be ignored on mounted ! 5392: * file systems. The option -S acts in the same manner as -s except ! 5393: * that it will not be ignored on mounted file systems. Beware: -S ! 5394: * on mounted file systems should only be used if you intend to reboot ! 5395: * NO SYNC immediately afterwards. Option -t sets the temporary file ! 5396: * to use for disk caching of necessary tables on filesystems which are ! 5397: * too big to do in core. The temporary file defaults to "/dev/rram1", ! 5398: * which must be there. ! 5399: */ ! 5400: ! 5401: #include "fsck.h" ! 5402: ! 5403: int errflag; ! 5404: ! 5405: int mdaction; /* default action for invocation */ ! 5406: int daction; /* default action for file system */ ! 5407: int gSflag=FALSE; /* force salvage flag ignored mounted */ ! 5408: int gsflag=FALSE; /* force salvage flag ignored mounted */ ! 5409: int sflag=FALSE; /* force salvage flag */ ! 5410: int qflag=FALSE; /* fsck quiet flag */ ! 5411: int fflag=FALSE; /* fsck fast flag */ ! 5412: ! 5413: char *tmpfile = NULL; /* TMP file for virtual.c */ ! 5414: char *checklistfile = "/etc/checklist"; /* default file for list of file */ ! 5415: /* systems to fsck. */ ! 5416: char *filelist[NFILSYS]; /* list of filesystems */ ! 5417: char word[MAXCH]; /* hold single words */ ! 5418: char *fsname; /* file system name */ ! 5419: ! 5420: dev_t rootdev; /* root device number */ ! 5421: dev_t fsysrdev; /* file system real device number */ ! 5422: int mounted; /* flag for mounted file system */ ! 5423: ! 5424: int changeflg; /* file system modified flag */ ! 5425: ! 5426: main(argc, argv) ! 5427: char *argv[]; ! 5428: { ! 5429: int yflag=0, nflag=0; ! 5430: int retval; ! 5431: ! 5432: while (argc>1 && *argv[1]=='-') { ! 5433: switch (argv[1][1]) { ! 5434: case 'q': ! 5435: qflag = TRUE; ! 5436: break; ! 5437: case 'y': ! 5438: yflag = 1; ! 5439: break; ! 5440: case 'n': ! 5441: nflag = 1; ! 5442: break; ! 5443: case 'f': ! 5444: fflag = TRUE; ! 5445: break; ! 5446: case 'S': ! 5447: gSflag = TRUE; ! 5448: break; ! 5449: case 's': ! 5450: gsflag = TRUE; ! 5451: break; ! 5452: case 't': ! 5453: tmpfile = argv[2]; ! 5454: argc--; ! 5455: argv++; ! 5456: break; ! 5457: default: ! 5458: usage(); ! 5459: break; ! 5460: } ! 5461: ! 5462: argc--; ! 5463: argv++; ! 5464: } ! 5465: ! 5466: if ( yflag+nflag > 1 ) ! 5467: usage(); ! 5468: ! 5469: mdaction = ( yflag ? YES : ! 5470: nflag ? NO : ASK ); ! 5471: ! 5472: if ( argc > 1 ) ! 5473: retval = allfsck(argv+1); ! 5474: else { ! 5475: getlist(); ! 5476: retval = allfsck(filelist); ! 5477: } ! 5478: exit(retval); ! 5479: } ! 5480: ! 5481: ! 5482: /* ! 5483: * perform fsck on each of the individual filesystem in list ! 5484: */ ! 5485: ! 5486: allfsck(fsl) ! 5487: register char **fsl; ! 5488: { ! 5489: int fatal(); ! 5490: int retval = 0; ! 5491: ! 5492: sync(); ! 5493: statit("/", fatal); ! 5494: rootdev = stats.st_dev; ! 5495: while (*fsl != NULL) ! 5496: retval |= fsck(*fsl++); ! 5497: return(retval); ! 5498: } ! 5499: ! 5500: /* ! 5501: * get the names of the filesystems from the default file ! 5502: * checklistfile (e.g. /etc/checklist) ! 5503: */ ! 5504: ! 5505: getlist() ! 5506: { ! 5507: int fd; ! 5508: int index, size; ! 5509: ! 5510: if ( (fd = open(checklistfile, 0)) == (-1) ) ! 5511: fatal("Can't open checklist file: %s", checklistfile); ! 5512: ! 5513: index = 0; ! 5514: while ( ((size = getword(fd)) != 0) && (index < NFILSYS) ) { ! 5515: filelist[index] = malloc( size ); ! 5516: strcpy(filelist[index++], word); ! 5517: } ! 5518: ! 5519: if (size != 0) ! 5520: fatal("Too many file systems in checklist file: %s", ! 5521: checklistfile); ! 5522: ! 5523: filelist[index] = NULL; ! 5524: ! 5525: close(fd); ! 5526: } ! 5527: ! 5528: /* ! 5529: * read in the next "word" from file with descriptor fd ! 5530: * return the length of the word. ! 5531: */ ! 5532: ! 5533: getword(fd) ! 5534: int fd; ! 5535: { ! 5536: int n = 0, num; ! 5537: char *cp = word; ! 5538: char ch; ! 5539: ! 5540: while ( ( (num=read(fd, &ch, 1)) == 1 ) && ! 5541: ( (ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r') ) ); ! 5542: ! 5543: if (num != 1) ! 5544: return(0); ! 5545: ! 5546: do { ! 5547: *cp++ = ch; ! 5548: } while ( (++n < MAXCH) && (read(fd, &ch, 1) == 1) && ! 5549: (ch != ' ') && (ch != '\t') && (ch != '\n') && (ch != '\r') ); ! 5550: ! 5551: *cp = '\0'; ! 5552: ! 5553: return(n+1); ! 5554: } ! 5555: ! 5556: /* ! 5557: * perform fsck on the given filesystem ! 5558: */ ! 5559: fsck(name) ! 5560: char *name; ! 5561: { ! 5562: int retval = 1; ! 5563: int nonfatal(); ! 5564: ! 5565: fsname = name; /* file system name */ ! 5566: errflag = FALSE; ! 5567: statit(fsname, nonfatal); ! 5568: fsysrdev = stats.st_rdev; ! 5569: if ( errflag ) ! 5570: return(retval); ! 5571: changeflg = FALSE; ! 5572: init(); ! 5573: if ( sflag = ((gsflag && !mounted) || gSflag) ) ! 5574: printf("Switch \"-s\" selected to automatically rebuild free lists\n"); ! 5575: if (!sflag && gsflag) ! 5576: printf("Ignoring \"-s\" on mounted file system\n"); ! 5577: if ( !errflag ) { ! 5578: phase1(); /* check blocks and sizes */ ! 5579: if ( !fflag ) { ! 5580: phase2(); /* check pathnames */ ! 5581: phase3(); /* check connectivity */ ! 5582: phase4(); /* check reference counts */ ! 5583: } ! 5584: phase5(); /* check free list */ ! 5585: phase6(); /* salvage free list */ ! 5586: retval = cleanup(); ! 5587: } ! 5588: return(retval); ! 5589: } ! 5590: ! 5591: usage() ! 5592: { ! 5593: printf("\ ! 5594: Usage: /etc/fsck [-y] [-n] [-q] [-f] [-{sS}] [-t TMPFILE] [filesystem ...]\n"); ! 5595: _exit(1); ! 5596: } ! 5597: sflag && gsflag) ! 5598: printf("Ignoring \"-s\" on mounted file system\n"); ! 5599: if ( !errflag ) { ! 5600: phase1(); /* check blocks and sizes */ ! 5601: if ( !fflag ) { ! 5602: phase2(); /* check pathnames */ ! 5603: phase3(); /* check connectivity fsck/objects/ 755 3 3 0 5045007474 6312 fsck/objects/main.o 644 3 3 4453 5045007122 7477 & 0 & p I&VW� �F� �F� �~&� �v ! 5604: �|�=-t� �~ ! 5605: �}�E&��B � CC.;��u`.�gS f n q s t y ~ v o ` � � h �6& �;�F�& �4�F�& �-�8& �%�0& � �2& ��~ ! 5606: �E�:�N�F ! 5607: ��r�N�F ! 5608: �c��F�F�=& ~�Z�~� t� ��~� t� ��& � �~&~�F ! 5609: @@P��X h � ���F�P�����_^�VW� �v�F� ���h hM������ � �< t�����5�=&�� F���F��_^�VW� j �6<�����F�=��u �6<hO�����F� �v��b ���F� �t-�~� ! 5610: }'�~���P�u����� h �~��F����� �\����Ã~� t �6<hm�G����~���Dž �v��3����_^�VW� �F� �F� j&�F�P�v�����F�=& u�~� t�~� t݀~� ! 5611: t׀~� tу~�&t+��M�~��F��F����F��F�= },j&�F�P�v�����=& u�~� t�~� t �~� ! 5612: t�~� u��~�� �F�@�_^�VW� �F�& �F� � h P�t���� � �> ur� �[��>2 t�> t�>0 t�& �+��4 �t h��2����>4 u�>2 t h������> u ���>8 u ���&��������������F��F��_^�VWU��h������j&������_^� >/etc/checklist / Can't open checklist file: %s Too many file systems in checklist file: %s Switch "-s" selected to automatically rebuild free lists ! 5613: Ignoring "-s" on mounted file system ! 5614: Usage: /etc/fsck [-y] [-n] [-q] [-f] [-{sS}] [-t TMPFILE] [filesystem ...] ! 5615: daction_ errflag_ strcpy_ main_ fsck_ ncleanup_ stats_ tmpfile_ :open_ init_ gsflag_ 2fsysrdev_ malloc_ exit_ fsname_ getword_ �&getlist_ @&mounted_ word_ sync_ fflag_ 8phase1_ phase2_ rootdev_ phase3_ phase4_ phase5_ phase6_ fatal_ qflag_ 6sflag_ 4mdaction_ printf_ nonfatal_ gSflag_ 0usage_ close_ _exit_ statit_ checklistfile_ <read_ filelist_ changeflg_ allfsck_ � $<0 0% 2 R T V X Z \ ^ $b $x $� $� $� 0� 0� 0� '� 0� '� ) 0� 7� 7& '& $&7&& ' & ' & 0/&$J&7M& $\&$_&7b& 0p&7�& '�&) '�& '�&) 7�& $�&$�&7�& '�&) 7�&$ '�& 7�&( 7>( '} '�& '�! 7�& '� '� '�& '�* 7� $�'� $�$�$�7� $�$�$�7� '�& 7� $�7� 7� 7 7 7 7 $7 7&% 0usage_ close_ _exit_ statit_ checklistfile_ <read_ filelist_ changeflg_ allfsck_ � $<0 0% 2 R T V X Z \ fsck/objects/init.o 644 3 3 6460 5045007137 7524 & L �& � jVW�" �> u+��� �F�P�6 ������ =��u*�F� �v��6 ������ =��u�6 h`����� �~� u� � � � � � & �~� uhw�h��6 ho�t����F�P�6 �f���=��u �6 h�렋F�% ��Fށ~� `t�~� th��8���= t = �� � �� �> u �&�� & �_^�VW� h j j&������P �>P�u�u������>P�E�U+���@}-����P�F�����>P�u ! 5616: �u�����~��E�U ! 5617: F��+���d}F���>P���&���&�����>P���&���&���&���&�n����>P���&���&���&���&�T����>P���&���&�_^�VWU��>P�E�U�L�N�� ��؋ʡL�N+�ѣ � �> ~"� �;N|;Ls�>N | "�>Lw�6 �6N�6Lh��8 ��� & �>P�E=@ ~ h�� ���>P��&=d ~ h�� ���_^�VWU��FPh����j&�6 h�~����_^�VW� �F� �> u� HH��� �F�j j�L�N �� -& �� RP�;����F�PP�v��v��*���+�� � �_^�VW�� Ɔ.�/Ɔ/�dƆ0�eƆ1�vƆ2�/Ɔ3� � �6 ��F�= u�N���=/t;6 w�</u&F��X�P�6^�����=��udžT� džV� ���n���p���T���V�j �6Z�����F�=��u� jF�F�P�v��|���=F un�~� t�~� t�j �F�P��3�P�Z���ƆS� hC��.�P�G���� ; u�hC�F�P�1���� ; u�& �+�� ��V���T��F�P� ��� j �6\������F�=��t}jB��v�P�v������=B uh��v� t�~� t�j �F�P��3�P�����ƆS� hC��.�P����� ; u�hC��v�P����� ; u�& �+�� ��v�P� ���� ; u� & �� �_^�VWU��> t=�~�F ! 5618: �V ;UD|;EBs�~�EB�UD�F ! 5619: �V �F ! 5620: P�#���P�vj �6 h[��FB P����P�vj �6 hw����� ! 5621: �_^�VWU��> t�vj �6 h�� �vj �6 h�������_^�VWU���_^� ! 5622: 7CMCan't open: %s %s: %s ! 5623: (NO WRITE) Can't stat: %s file is not a block or character device; OK? Size check: fsize %U isize %u Too large free block count Too large free i-node count %r ! 5624: fsck: %s: Bad Super Block: %u ! 5625: /etc/mnttab /etc/mtab /etc/boottime %s mounted on %.*s as of %s %s unmounted. Last mounted on %.*s -- %s %s mounted on %.*s ! 5626: %s unmounted. Last mounted on %.*s ! 5627: fsize_ Lfstat_ daction_ errflag_ numfiles_ fsfd_ mtab_name_ \isize_ writeflg_ dupblck_ P prmnttab_ �checksuper_ �&stats_ ninodes_ open_ init_ fsysrdev_ query_ nothing_ Ctotfree_ fsname_ offsets_ Rstat_ mounted_ _canl_ bread_ fflag_ lrdiv rootdev_ bttime_name_ ^sbp_ Pprmtab_ mnttab_name_ Zalloctables_ �domount_ �initV_ readsuper_ � sbpfix_ mdaction_ superb_ ctime_ strncpy_ printf_ nonfatal_ totdups_ badsuper_ dstatit_ read_ 'P' ' & ' 7 '# '4 77 '= 'F $I 7L + 0R '\ 'b 'i & 'l 'p ${ $� '� $� 7� * '� 7� & '� $� $� 7� 0� '� % 0� 0� '� 0� '� '� ' 7& $ &'&' $&7 & $#&$9&$E&7N& $k&7v& $}&7�& $�&7�& $�&$�&$�&$�&'�& $�&$�&'�& '�& '�& '�& $�&$$ $' $ $$$'0*'1 $7$B0E$L$X0[$n7q* 'z $}7�* '� '� '� $�$�7� 7�# '�, '� $Z$\$^' ' '% $679 $e7h 0v7�/ 7�) �7�. '� '� �7�. '� '� '� 0�0�$�7& 7/ 7<) G7O. 'U 'Y ^7f. 'l 'p '| 0�'� '� '� '� '� 7�( '� $�7�( ' $7 ! 5628: * ' '& $)'4 $77:* � & '� $� $� 7� 0� '� % 0� 0� '� 0� '� '� ' 7& $ &'&' $&7 & $#&$9&$E&7N& $k&7v& $}&7�& $�&7�& $�&$�&$�&$�&'�& $�&$�&'�& '�& '�& '�& $�&$$ $' $ $$$'0*'1 $7$B0E$L$X0[$nfsck/objects/phase1.o 644 3 3 7042 5045007155 7737 & � �& 4 >VWU��> u h������� � �> t����_^�VW� �& �F� �F� � �;V� }� ;F�w� j �v��v����� �t ���F�&�V� ��h �v��v������ � �F� �~�}MV�e���V�b ��=& u*�> uWV�l ��WV�7&�� �t�> uWV�p��V�(���G��@�F�뭃> u�|�h �v��v������j��_^�VWU��v�< u�| t�& �+��_^�VW� �v�~ ! 5629: �% ��F��G&� CC.;��u:.�g ! 5630: @ ` �{&s&o&w&]&jj ��+�RP�����Qj��j��j��j��j&j ��+�RP�t���Wh��j���= t"= u V� ��j j ��+�RP�I���� & �_^�VWU��^�G�W ! 5631: & �F@ ���v;�v��F� ���_^�VW�: �^�% ��FƁ~� �t �~� @t+�� j �F P�F�P�����+��У � � � � � +��� }Z+���}P����;� }C����G̋WΉFȉV� �tW�v ! 5632: R�v��. ��=& t 댋���������& �G�F롸& �_^�VW� �F�N �u3� � & �� & � � �v �v ! 5633: �v� ��� ���v �v ! 5634: �v� ������=& ur�� �P�v ! 5635: �v������� �;�vT�ރ���W�F�V ! 5636: RP������F�V ! 5637: �u�^��������& ���v�v �v ! 5638: �v�A��� �u�+�� �& ������_^�VWU��v V�v ! 5639: �v� ����=& uV�v ! 5640: �v�� ������_^�VWU�� �;V ! 5641: |r;Fwm�F�V ! 5642: ; |_; sY�& � �> ujj ! 5643: �F +�RP�����v �v ! 5644: �vh������� � = ! 5645: }� �N�v h�����= t8= t6�6� �;V ! 5646: |�;Fv��~ ! 5647: |��~r��~ &u�� &� �v���+��_^�VWU��j �v ! 5648: �v���� �u j&�v ! 5649: �v�n����. &� �& � � & �> ujj ! 5650: �F +�RP�@����v �v ! 5651: �vh=�.����> }B�> � ���F�V ! 5652: �� �� � � = ! 5653: }� �7�v hx�����= t!= t � hZ�����= t= t�����������+��_^�VW� �v�% ����D�T ! 5654: �F��V��� �u RP�v ! 5655: � ����v��v��v ! 5656: V� ���_^�VWU��~ xu"�~ u �v ! 5657: �v�v h��Z���= t= tK�~ rw�~ s �v ! 5658: h��6����F t �v ! 5659: h ! 5660: �#����v�v �^ �� �t.�v ! 5661: h.����� �v�����j j �F ! 5662: +�RP������ & �_^�VWU���v �v ! 5663: � �� �t �vh[������_^�VW� � � � �������F��V��F�V ! 5664: ;V�| ;F�w�F�V ! 5665: �� ;V�| ! 5666: ;F�w�& �+��_^�& � @ Phase 1 : Check Blocks and Sizes ! 5667: Unknown File Type i-number = %u (Clear) Bad block %U, i-number = %u ! 5668: Excessive Bad Blocks i-number = %u (Continue) Dup Block %U, i-number = %u ! 5669: DUP Table Overflow (Continue) Excessive Dup Blocks i-number = %u (Continue) Bad Directory Size, size = %D, i-number = %u (Clear i-node) Directory Size too small i-number = %u ! 5670: Directory Misaligned i-number = %u ! 5671: Possible Directory Size Error i-number = %u ! 5672: Possible File Size Error i-number = %u ! 5673: fsize_ checkmode_ "&dupflag_ inuse_ &isize_ phase1b_ dupblck_ checkbad_ �checkblks_ �&findblock_ l3tol_ inodescan_ , query_ numbad_ totfree_ checksize_ Adirsize_ �offsets_ clrflg_ numblks_ _canl_ lostsize_ bread_ fflag_ phase1_ checkdup_ pqflag_ bwrite_ dodirect_ �zeroinode_ �&blockcnt_ �doblocks_ �totdups_ printf_ sparsecnt_ databuf_ abort_ numdup_ filesize_ "candino_ sizerr_ G' $ 7 ! ' 0 ' 7& '@ 0K 0S 7^ 'u # 7~ '� '� # 7� ' 0� '� 0� 0� '� 0� 7� ' '� 0� '� # 7� 0� 7& S& U& W& Y& [&7h& 7�& $�&7�& 0�&7�& '�& '�& '�& 07' ! 5674: '1" '5" '8 '< '?% 'B 'X 0|$�$�'�" '�" '�" '�" '� '� '�" '�" 0�0�0�7 75 $L$P'T" 'X" 0i0�0�'� '� '� 0�'� 7� $7! ' ' $"7% '7 '\ 'a 0e7h$ 7~ 7� '� '� 0�'� '� 7� $�7�! '� '� '� '� '� '�% '�% $ ! 5675: 7 $ 7" 74$ 79$ 0i0{$�7� $�7�! $�7�! 0�$�7�! 07 ' 0.$;7>! 'N 'R '� # 7� ' 0� '� 0� 0� '� 0� 7� ' '� 0� '� # 7� 0� 7& S& U& W& Y& [&7h& 7�& $�&7�& 0�&7�& '�& '�& '�& 07' ! 5676: '1" '5" '8 '< '?% 'B 'X 0|$�$�'�" '�" '�" '�" '� '� '�" '�" 0�0�0�7 75 $L$P'T" 'X" 0i0�0�'� '� '� 0�'� 7� $7! ' ' $"7% '7 '\ 'a 0e7h$ 7~ 7� '� '� 0�'� '� 7� $�7�! '� '� '� '� '� '�% '�% $ ! 5677: 7 $ 7" 74$ 79$ 0i0{$�7� $�7�! $�7�! 0�$�7�! fsck/objects/phase1b.o 644 3 3 2472 5045007170 10100 & � > �& � VWU��> u h������� �_ �_^�VW� �F� �F� �F�; s8�~��F����� �� �F��V�jRP���� �u�j�v��v������F�뿋F�� �_^�VW� �& �F� �F� � �;V�|l;F�vgj �v��v��X��� �t ���F�&�V� ��h �v��v��8���� �F� �~�}�V�#���V� ���=& uWV� ���> t G��@�F����_^�VW�: �v�~ ! 5678: �% ��FƁ~� �t�~� @u^j �D P�F�P������ �F� �~� }=�F� �~�}-�^���F�;� }�v�W�^�����w��w�� ����F����F���_^�VW� �F F ! 5679: u�& � �v �v ! 5680: �v� �� �tr=& uo�F�N �t؍� �P�v ! 5681: �v�0����� �����dž�� ����� }������������U�F�V ! 5682: RP������F�V ! 5683: �v�v RP�t��� �t�����+��_^�VWU��j�v ! 5684: �v����� �u�& �>� j�v ! 5685: �v�����> ujj ! 5686: �F +�RP�����v �v ! 5687: �vh�����+��_^� Phase 1b: Rescan for more Dups ! 5688: Dup Block %U, i-number = %u ! 5689: inuse_ isize_ phase1b_ dupblck_ findblock_ l3tol_ iscanb_ z offsets_ _canl_ bread_ fflag_ dblocksb_ �&qflag_ cdupb_ +totdups_ printf_ databuf_ buildtable_ numdup_ ckblksb_ &candino_ ' $ 7 0 0 '4 'C 'G 7T 7f 't '� & 7� '� 7� '� 7� 7� 0� '� 75& '<& '`& 0w&0�&0�&7�& 7 079 'I 7T '[ ! 5690: 7l ${7~ findblock_ l3tol_ iscanb_ z offsets_ _canl_ bread_ fflag_ dblocksb_ �&qflag_ cdupb_ fsck/objects/phase2.o 644 3 3 11604 5045007207 7755 & � � 8 � |VWU��> u h������� � j�}���_^�VWU��jj j��������� u h�����jj j����% = th�����= t ! 5691: = u�= ���jj j�|������� th �k���= t= t��Y�j�T����_^�VWU��> u h. �;���jj j�/���%�� Pj j j� ���h j�������$�� @h j������_^�VW� j������F��� �u ! 5692: �6������� �E �~ s�Z&w �~ ! 5693: s�O&� � �v�b&��� � j�> ~� K�㋟ �7�jhm �ƃ�P� ��� �n ! 5694: �^ �F ! 5695: �V �؋ʃ� s�� w��s�� j �> &~� KK�㋟ �7�jho �ƃ�P��&��� �n ! 5696: �^ �~ ws� �~ ! 5697: s� �� sd�~ wr\�~ ! 5698: rVV����= u=j�v�V�S&��j������^��G �u ! 5699: �6������^��G�F��^�� �G ���n ! 5700: �^ 떃> t�v� �� �u�� �v�4 ��� � �V����_^�VW� �v� �F� ;~�~�F����_^�VW� �v� � � &� RPV�#����F��V� �uh h � ����%h �v��v������h �����F��V�� � �_^�VW� � � -& �� RP�v������F��V� �u+��h �K���h �v��v������& �_^�VWU��hr �����_^�VW� �v�~ ! 5701: �F �N �t��G�F���F���^�����_^�VW� �v�|��F��v ! 5702: W�=��� �u�F�;F u W� ��=& t�v�p ��v������_^�VW� �v���D�F�;~�s��G�? u��I;�u� �3;~�s;~�s��G�? t�;~�t� ���;~�s ��G�?/u� ��& �_^�VW� �F- = w6����.��nx����F�� �!�F�� ��F�� ��F�� � �F�� ��F�� �6 �6 �v�h� �O����> ~�> O�狽 �5�j�w&��� �> �狅 @@P�� ��� �_^�VW� �v�< �u+�� �D�F�P������F�=& tP�6���;> v�v�W�&�� �t�V� ����j��+�RP�������� u �v�W�&��j��+�RP�������� t'�v�W��&�� �u�j��+�RP�t���% = u�f�W�b���� j��+�RP�P���% �_^�VWU��~� � & �_^�VW� �F� �F�; }�~��F��狅 @@P�$ �����v� ���F� ! 5703: j&�F�Pj&������_^�VWU��~�} u Wh� �������vjh� ������_^�VWU��h �v������ �u�vh� ����+����Y�vh' ! 5704: �����t������ �t�5h7 ! 5705: ��thB ! 5706: �f����4hM ! 5707: �[����D8P�Q���P�t ! 5708: �thX ! 5709: �A����D�T ! 5710: �_^�VWU���vhs ! 5711: �&����v ! 5712: ������6������_^�VW� h� ! 5713: � ����v�=����F��V��v ! 5714: �����> t!�F� F�u�> u�6�h� ! 5715: ������ � ! 5716: �6������_^�VWU��j�F+�RP����% ����uh� ! 5717: �h� ! 5718: h� ! 5719: �����v������v ! 5720: �A����6��g����_^�VWU��vj��+�RP�M���% = uV� � jj ! 5721: ��+�RP�.���h V�$����� j PhT ����� � �% �= @t ! 5722: Vh� ! 5723: ������ � �w ! 5724: �whT ��������= t7�> 2|�M � � �㉿ �5�`���� �>� �}�6� ������W�����_^�VWU���vh �����_^�VWU��hA �{���hQ �B����l��_^�P j ! 5725: Phase 2 : Check Pathnames ! 5726: Root i-node is unallocated. Terminating Root i-node is not a directory (FIX) Dup/Bad blocks in root i-node (Continue) File System Read-Only (NO WRITE) ! 5727: Can't malloc memory, phase 2 . .. Fixblock error. Null name Non null padded Embedded slashes in Inconsistent . Inconsistent .. Bad %s entry in block %U in directory ! 5728: /%s /%*s i-number = %u is in a bad inode block. ! 5729: i-number = %u, Owner=%s, Owner=%u, Mode=0%o ! 5730: Size=%U, Mtime=%s (Remove) I-number is out of range I=%u ! 5731: Unallocated ! 5732: %s [Forced - Yes] ! 5733: Bad or Dup blocks in %s ! 5734: Directory File Tried to checkpath i-node %u which is not dir. ! 5735: I-node %u is a multiply referenced directory i-node. ! 5736: Name too long. ! 5737: candblock_ �fixflag_ free_ daction_ numfiles_ writeflg_ imap_ getpwuid_ bclear_ write_ checkpath_ �findblock_ path_ d l3tol_ unalloc_ �buf2_ baddup_ Qninodes_ writeino_ circle_ eirange_ �query_ malloc_ copy_ ~mounted_ action_ bread_ toolong_ zblkerr_ Tcheckroot_ * phase2_ zeroent_ �procfiles_ &fatal_ format_ �fixblkerr_ lnextblock_ �fixroot_ � qflag_ bwrite_ remove_ �pname_ �ctime_ fixblock_ !printf_ depth_ databuf_ cdbn_ abort_ strcmp_ chck_ �memory_ �linkincr_ blocknum_ prdirsize_ pinfo_ Fptrino_ cdots_ �' & $ 7 , 0 ' - 0! 76 $D 7G ! 7S $a 7d 0t 7y 0 7� $� 7� 7� 0 7� 4 '� $� 7� ! 7� 7� '� . 7� 8 '� . 7& $�7& $$&7'&! 0<&0G&'K&/ 'Q&/ 0Y&'`&& 'e&. 'k&- 'r&- 'y& $�&0�&'�& 0�&0�&'�&- '�&- '�& $�&0�&'�& 0�&0 '. 00)71 $B7E! 'n& 0w0�0�'�& '�. 0�'�/ '�/ '�/ '�/ 7� '�. 7� '�. 7 '. 0 '5 '5 '(/ ',/ 7: 'N. 0Q'W. 7`' $r7u! 7�1 0�0�7�4 l n p r t v${$�$�$�$�$�'�5 '�5 $�7�, '�- '�- '� 0�'�- '�- '� 0�'�- 00 0 '# 0,077G 0Y7f 0x7� 0�7�4 '� 7� '�& '�- '� 0�0�7 $*7-, $:7=, 'L 7R8 $a7d, $s7v, 7 $�$�7�, $�7�, 7�* $�7�, $�$�7�, 0�$�7� $�7�, 00' ', $3$679, $E7H 7` $p$u$x7{, 0�0�$�7� 7� 0�0�7� '�. 7�8 %�%�7� %�$&7! % %0'%- 0+'/- '3- '9 0>'E- %I%P7S 7\ $n7q, $�7�, $�0�7�0 $r7u! 7�1 0�0�7�4 l n p r t v${$�$�$�$�$�'�5 '�5 $�7�, '�- '�- '� 0�'�- '�- '� 0�'�- 00 fsck/objects/phase3.o 644 3 3 6464 5050255263 7751 & l 6& 4 FVW� �> u h{������F� �F�; wFj+�RP�����% = u-j �F�+�RP���� �uj j ! 5738: �F�+�RP�����v��< ���F���F� �F�; s"j+�RP����%` = u �v�� &���F����_^�VW�> j�F+�RP�P������� t�� h �v�9����F��~��E�U ! 5739: �FV� �y�� u �u�� j �F� P�F�P����� � �F�P������F� �F� �n� �^� �FV� �x~u �tx�~� wrp�~�rj�~� sR�~� wrJ�~�rD�~���F� �t*j+�RP����% = u�F�;Ftj@j ! 5740: +�RP�t����F��n��^� 맍F�P�\����F� ��_^�VWU��h��C����v�:��� �t�> t�> &u�6n� ��� �u��6nh�� ���j�v� ���_^�VW�@ �F� �I�F� �t+j+�RP�����% = uj�F�+�RP��������� t��&&h �v������F�j P�F�P�����~��E�U ! 5741: �FĉV�� � �~� ws�� �~�s�� �F�P�^����F� �~� sփn��^� �~= t� �F�j�v�W��P�F�@@P�"����F�P���� �u���v����� �~� y�FċVƋ~�)EU ! 5742: �F�& �~ ! 5743: u3�v��v�&��= u"�~��Eh �v�������v��vj&�@ ����~� t h �v������& � �F��:���~ ! 5744: u�v��vj � ��+��_^�VW�0 �6l�v �F�P�s ��h�j �F�P�d ���v ! 5745: �o��P�v ! 5746: �F�P�M ��� �~&u�> � ��F�� �> � ��F��� �> � ��FЉ� �v ! 5747: ������_^�VWU��F ! 5748: �~�j�v �F@@P������_^�VW�< j�F+�RP�������� t �v�� �� h �v�����F�j P�F�P�����~��E�U ! 5749: �FƉV�� � �~� w s� �~�r}�F�P�R����F� �~� sك~� wrу~�r�h��F�@@P�)��� �u8�vh������~��5h�� ����F ! 5750: �~ĉ�F�P����� �u���� ��n��^� �F���v� ��� �_^�VWU���vh������_^�VWU���vh1�����_^�VW� h j�����F�j Ph������~��E�U ! 5751: �F��V�� � �~� wrR�~�rLh��P����F� �~� s݃~� wrՃ~�r��6l�F�@@P�&��� �u�~����n��^� �F���+��_^�VWU���6lhd������_^�VWU���6lh~������_^�VWU��v� ƅ �t& �~"O�ߋ�+�.�6j��0 �� ��+�.�6j���֍� �_^� ! 5752: p�lost+found Phase 3 : Check Connectivity ! 5753: (Reconnect) Unref Dir ! 5754: %s FORCED ! 5755: ?? .. Dir i-number = %u connected. Parent was i-number = %u. ! 5756: Dir i-number = %u connected. It has bad/dup blocks. ! 5757: Dir i-number = %u connected. It has no .. entry. ! 5758: Sorry. No %s directory. ! 5759: Sorry. No space in %s directory. ! 5760: daction_ numfiles_ lostname_ lnoparent_ Iconnect_ checkpath_ traverse_ �findblock_ path_ l3tol_ buf2_ ninodes_ writeino_ dirinit_ connected_ 6markchildren_ � mounted_ nameit_ (action_ reconnect_ nphase3_ fixblkerr_ nextblock_ qflag_ badconnect_ 4fixblock_ strncpy_ printf_ depth_ cdbn_ databuf_ strcmp_ noroom_ linkincr_ pinfo_ ptrino_ namebuf_ lostfound_ ^nolost_ �unrefdir_ �&$l' $ 7 ' 7+ 7B 7W 0` 't 7 0� 7� 0� '� 7� # 0� 0� 7� '&& '& 7& '& 'G& 7l& 7�& 7�& '�& $n$�&7�& 7�&" '�& '�& $�&7�& $�&$�&7�& 0�&07# 7: 0H0K'N ! 5761: 7T# 7g '} '� 0�0�7� '� '� 0�0�7� 7� 7� 7�! '�& 0&'7 ! 5762: 7= 0K'Y ! 5763: 7_ 0n0q0�$�0�$�0�0�0�'� '� '� '� '� '� '� '� ' 7 7- 7F 0W0Z'] 7c# 7v '� '� 0�7� '� '� $�7� $�7� $�7� 7 7 0($=7@ $R7U 'e 7j# %y7| '� '� %�7� '� '� $�7� $$7 $$ 7 '5$ J'S$ \'d$ 0� 0� 7� '&& '& 7& '& 'G& 7l& 7�& 7�& '�& $n$�&7�& 7�&" '�& '�& $�&7�& $�&$�&7�& 0�&07# 7: 0H0K'N ! 5764: 7T# 7g '} '� 0�0�7� '� '� 0�0�7� 7� 7� 7�! '�& 0&'fsck/objects/phase4.o 644 3 3 6171 5045007242 7741 & H & � VW� �> u hN������F� �F�; v�� j+�RP��������� t�v��F��= u�F���j �F�+�RP���� �u<j�F�+�RP����% = t%j�F�+�RP�|������� t�v��� ��= t�j �F�+�RP�W��� �u(j�F�+�RP�D������� t�v����= u�q��v��? ���F�=��u�F��Y�j �F�+�RP����;F�u�B��v��v��&���3���_^�VW� �v����% �� �t��u=��������AA��+҉F��V�j RP���� �t ! 5765: ��t����'hV�v��v���������V�F�P�{����^��G�_^�VW� �> &u&j�F+�RP�U���% = u�v� ��� � �v�5���Ph�+����v�"����F��V��> t1 �u-�> u&j�F+�RP�����% = u�6Hh��������6 �����=& uj�v����� �u �v� ���� �_^�VWU���6H����=& u�v� ��� �� �_^�VW� h �v�y����F�P�o���h �v�c���j j �F+�RP�R���j j �F+�RP�A����_^�VWU���v�/���Ph��%����v� ���j �F+�RP� ���P�v ! 5766: h�� ����6J�����=& u �v� ���_^�VW� h �v������F�j �F+�RP������~��Eh �v�����_^�VWU���v����Ph������v�����v������_^�VWU���v�n���Ph��d����v�[����v�����_^�VW� �F� �F� �F�; w j+�RP�)������� u�F��F����F� �F� � �;V�|%;F�v j �v��v������ �t�n��F�&�V� �Ћ> ���&;F�t7�> u �> th�����6L����=& u�F��> ���&� & �> t�> &t�> &t� �u�� �_^�VW� ! 5767: �> ��&�F�=d v+�� �F� �F�;F�r� �~���> �� ! 5768: &�F��~������GG��+҉F��V�j RP� ��� �t �~� u��~�u��~�r��F�; w�j+�RP��������� u�j�F�+�RP��������ǀ t�o�h� j ! 5769: �F�+�RP�����F��a��& �_^�VW� � & �F� �F� �F�; wQ�~�d}Kj+�RP�������� u2�~������GG��+҉F��V�j RP�Z��� �t �~� u �~�u�F��F�릋F��> ��&�F� �F�; wa�~� ~[j+�RP�������� uB�~������GG��+҉F��V�j RP����� �t �~� u�~�u�N��~���> �F��� ! 5770: &�F��h,�����_^�p��Phase 4 : Check Reference Counts ! 5771: (Clear i-node) Unref %s ! 5772: %s [Forced - Yes] ! 5773: (Adjust) Link Count discrepancy in %s ! 5774: Count = %u, should be %u Unref %s ! 5775: Bad/Dup blocks in %s ! 5776: (FIX) Free i-node count wrong in superblock. Free i-node list in superblock rebuilt. ! 5777: linkprob_ �unrefclr_ Ydaction_ typename_ isize_ fixit_ Lclearit_ Hrebuild_ Qconnect_ findblock_ getlink_ &ninodes_ writeino_ mounted_ lostsize_ action_ bread_ reconnect_ sbp_ phase4_ askclear_ Ofreeilist_ �adjust_ Jqflag_ badilist_ �sbpfix_ sflag_ unreflink_ �&zeroinode_ printf_ databuf_ doclear_ xbddp_ �ptrino_ pinfo_ candino_ chglink_ ' $ 7 ' 0% 7. 0? 7X 7k 7� 0� 7� 7� 0� 0� 0� 0� 7� 0&0&0&0&7T& %h&7q& %|&7�&# $H'�& 7�& 0�&0�&7�& $�&7�& 7�&" '�& '�& 7 $$7 '! 7$ 74 0A$V7Y 0g' 7�! 7� '� 7� 7� 7� $J7� $�7� 7�" 7� $�7� $7 0'& 7,! 7> 'J 7P 7b $i7l 7u" 0~7� $�7� 7�" 0�$L'� 7� '� 7 '& '3 ': $@7C $J7M '\ 'd 'j 'q 'x 0~0�'� 0�0�'� 7� ' 7 7" 007? 0H'Y 'l 7} 7� '� '� 7� 7 '- $<7? % 7. 0? 7X 7k 7� 0� 7� 7� 0� 0� 0� 0� 7� 0&0&0&0&7T& %h&7q& %|&7�&# $H'�& 7�& 0�&0�&7�& $�&7�& 7�&" '�& '�& 7 $$7 '! 7$ 74 0A$V7Y 0g' 7�! 7� '� 7� 7� 7� $J7� $�7� 7�" 7� $�7� $7 0'& 7,! 7> 'J 7P 7b $i7l 7u" 0~7� $�7� 7�" 0�$L'� 7� '� 7 '& '3 ': $@7C $J7M '\ 'd fsck/objects/phase5.o 644 3 3 4231 5045007255 7741 & � & D �&VW� �> u h������� �F�j j� � �� -& �� RP������F�P����+��У � � � � �v�� ��� �> u�> t���_^�VW� �F� �F� �~�= u� �=@ v� & h��N���� �F�& �~�F�;}0�~���~�u�u�Y&���F�=& u �F�&�V� �F��̃~� t��~�tU�~�tO�~�u�u�#&��=& u;�F�&�V� h �~�u�u������F �v��&�� �t�N�� & h��]��~�u � � �> ���&���&; u; t?�> u �> th��s����6 �i���=& u� � �> ���&���&� & �6 �6 h��0 ���6 �6 h� ��� � +F�V�RPh+� ���_^�VWU��F ! 5778: F t+�~ | �~ ! 5779: &vh?�hA�v �v ! 5780: �v������ & �_^�VWU�� �;V ! 5781: |;Fw�F�V ! 5782: ; |9; r3� & � &� � � �� |�� ! 5783: v hB�Y ���P+��Lj�v ! 5784: �v�g��� �t)� & � &� � � �� |˃� ! 5785: v�hF�j�v ! 5786: �v�,����& �_^�VWU���vhJ����hl� ���= u� �� �_^�VW� �v�<@v+��2+�;<})����ƉF�������w�w������^��G�WG�Ӹ& �_^�VWU��> t�> u�> u hw���� �t� & �_^�Phase 5 : Check Free List ! 5787: Bad freeblock count. ! 5788: Bad freeblock count. ! 5789: Free Block count wrong in superblock. %U Bad Block%s in Free List ! 5790: %U Dup Block%s in Free List ! 5791: %U Block%s missing ! 5792: s bad dup Excessive %s blocks in free list (Continue) Bad Free List (SALVAGE) fsize_ daction_ asksalvage_ Qstopit_ �isize_ fixit_ findblock_ badcnt_ query_ chk_ 2totfree_ _canl_ action_ bread_ badflag_ lrdiv fixerup_ sbp_ phase5_ qflag_ sbpfix_ sflag_ dupcnt_ canfblk_ copyV_ printf_ databuf_ report_ �&freetrav_ � ' $ 7 ' '$ '( 79 7C 'M 'Q 'T 'X '\ 0d 'k 'q 'x 0~ 0� '� $� 7� 0� 0� 0 &' & 7,& '4& 0:&0D&'H& $M&0P&'Z& 0_&'c& 'o& ! 5793: 'u& ! 5794: '{& '�&& $�&7�& '�& 7�& '�& ! 5795: '�& ! 5796: '�& '�& '�& '�& $�&0�&'�& '�& $�&0�&'�& ! 5797: '�& ! 5798: $�&0�&$$7# '* '8 'O 'W '] 'c 'h 'm 'q $�0�7� '� '� '� '� '� $�7� $�7� $�7� 79 'X& '_ 'f $l7o 'z copyV_ printf_ databuf_ report_ �&freetrav_ � ' $ 7 ' '$ '( 79 7C 'M 'Q 'T 'X '\ 0d 'k 'q 'x 0~ 0� '� $� 7� 0� 0� 0 &' & 7,& '4& 0:&0D&'H& $M&0P&'Z& 0_&'c& 'o& ! 5799: 'u& ! 5800: '{& '�&& $�&7�& '�& 7�& '�& ! 5801: '�& ! 5802: '�& '�& '�& '�& $�&0�&'�& '�& $�&0�&'�& ! 5803: '�& ! 5804: $�fsck/objects/phase6.o 644 3 3 4104 5045007271 7737 & b � 0 �&VWU��> t$�> u hb������ �t �&�6 ������_^�VWU�� ���&�*���&�,�>,� �*;, �,��>* �t*h����h������& �,� ���&�& �*���&�6,�g���� �uh��W���h��N���+��w� ,H��>,�.,�ȋ���"�$�,�RP�RP�6 �6 ����RP�����&�(�,��>*��+�;6,} �� �ƙ�����.*�ȋƙ����F�۸& �_^�VW� ! 5805: � & � � � � � & � � � �> | �> @s� ��@ �F��> ��F��) ���@@� � ��F��V��F��V�; |@; s:�v��v��� ���F��V�j RP�/��� �u�v��v�� �� �t ! 5806: �F�&�V� ��_^�VW� �. �> �F�V ! 5807: ��U� @@; s� �> u�> &t�6 �� ��h �6 �6 ����h h ����� uh �v ! 5808: �v����+��M�F�V ! 5809: � � � �> | �> @s� ��@ �F��> ��F��) ���@@� �& �_^�VW� �F�V ! 5810: ;$|G;"rA�F�V ! 5811: ;(|3;&s-�,�RP�v ! 5812: �v�����F��)FV ! 5813: �> ��*�&FV ! 5814: �F�V ! 5815: �_^�VW� �v+�;<})����ƉF�������w�w�����^��G�WG���_^� Phase 6 : Salvage Free List ! 5816: Invalid interleave factors in superblock. ! 5817: Default free-block list spacing assumed. ! 5818: Can't malloc space for interleave table. ! 5819: Free-block list is not rebuilt. ! 5820: fsize_ free_ isize_ maketable_ 4 bclear_ findblock_ malloc_ totfree_ _canl_ lrdiv lrrem fixerup_ sbp_ phase6_ canwfblk_ %addfree_ �&qflag_ sbpfix_ bwrite_ lrmul writefree_ 4&freeblks_ fblkp_ printf_ dp_ blknm_ databuf_ bmap_ �' ' $ 7 0 0$ %( 7+ & '; %B %I %M %T %X %] %b $i 7l $r 7u %~ '� %� %� 7� %� $� 7� $� 7� '� %� %� %� %� %� %� '� '� 7� 7� %� %� %� %&% ! 5821: &%&% &'<& 'A& 'E& 'H& 'L& 'P& 'V& '[& 'a& 'e& 'n& 't& '�& '�& '�& '�& '�& '�& '�& 0�&7�& 0�&'�& ' ' ' 0 ' '' '. 01'7 '; '? 7B 'K 7N 'T 'X '] 7f 'v 'z '~ '� '� '� '� '� '� '� '� %�%�%�%�%�7� ! 5822: % 7L m_ databuf_ bmap_ �' ' $ 7 0 0$ %( 7+ & '; %B %I %M %T %X %] %b $i 7l $r 7u %~ '� %� %� 7� %� $� 7� $� 7� '� %� %� %� %� %� %� '� '� 7� 7� %� %� %� %&% ! 5823: &%&% &'<& 'A& 'E& 'H& 'L& 'P& 'V& '[& 'a& 'e& 'n& 't& '�& '�& '�& '�& '�& '�& '�& 0�&7�& 0�&'�& ' ' ' 0 ' '' '. 01'7 '; '? 7B 'K 7N 'T 'X '] 7f 'v 'z '~ fsck/objects/cleanup.o 644 3 3 2674 5045007303 10206 & �& � �& &VW� �F� �> &u�$ �� �> &u�&�F��6 ���������F��_^�VW� �> �u�u�����> �E�U+���@}-���� �F�����> �u ! 5824: �u�����~��E�U ! 5825: F��+���d}F���> ���&���&�Z����> ���&���&���&���&�@����> ���&���&���&���&�&����> ���&���&Wj j&�����_^�VWU��> u �6 h�&������ ��؋ʡ � +��+ RPh�&������6 �6 h�&����� t`j h � � �� -& �� RP����� � �> u�> &th0�h2�6 �6 h�d���h3�[���h[�R����_^�VW� �F� �6 hk�6����> th��&����F�& �F��_^� %u files %U blocks %U free ! 5826: Expect roughly %U missing block%s next ! 5827: s time fsck is run as a result of inodes being cleared. ! 5828: ***** File System %s was modified ***** ! 5829: ***** BOOT Coherent (NO SYNC!) ***** ! 5830: fsize_ numfiles_ fsfd_ isize_ cleanup_ totfree_ fsname_ mounted_ advise_ �&lostsize_ _canl_ fflag_ lrdiv sbp_ prtstats_ � sbpfix_ bwrite_ printf_ close_ cleanV_ writesuper_ 9 changeflg_ ' 0 0 ' 0 '' 7* 70 'A 7J ! 5831: 'Q 'g 's 7| ! 5832: '� 7� ! 5833: '� 7� ! 5834: '� 7� ! 5835: '� 7� '� '&& $ &7 & '& '& ' & '&& '*& $/&72& '9& '=& $@&7C& 'I& 'M& 'W& '[& 7l& 'r& 'v& 'z& '�& $�&$�&'�& '�& $�&7�& $�&7�& $�&7�& '�& $�&7�& '�& $�&7�& fflag_ lrdiv sbp_ fsck/objects/util.o 644 3 3 7635 5045007407 7543 & � �& � IVWU��h �v�����=��uj h �_���vh ! 5836: �V ! 5837: ���_^�VWU��FPh������ H= w�����.��U t i [ h(����� � h9������6 =N t=Y t�본 �_^�VWU���v����= t ! 5838: = u�& �+��_^�VW� j�F�Pj �B����F� �~�~�u hI� ���F� �F�;F�}����E���F�= t�~� u�F��݃~�a| ! 5839: �~�z�n� �F��_^�VWU��j�F+�RP�����% - = w,����.��>&M&H&R&W&\&��������� ���������_^�VWU��h�� ���_^�VWU��FPh��w���j&�o����_^�VWU��FPh��Y���� & �_^�VW� �v�~ ! 5840: ��������AA��+҉F��V�j RP�#��� �t�~� u�~�t+��'W�v��v�� ! 5841: ������% ��ljF�P�G ���F��_^�VW� �F��% ��F ! 5842: �F�P�! ���v ! 5843: �~�����GG��+�RP����_^�VWU��v�t ! 5844: �t�����D�T ! 5845: �t6�t4�����D4�T6�t:�t8�o����D8�T:�t>�t<�]����D<�T>�_^�VW� ! 5846: �F� �~�|�<&�~����F ! 5847: �V ;��|~� &;��r�&�~� t�~�O��������)F ! 5848: V �F����P�v �v ! 5849: ������F��V��~����������v �v ! 5850: ������F ! 5851: �V �^��������F����F����T�F��V� �u� �F��N� �� h �v��v�� ���F����P�v �v ! 5852: �m����F��V��~����������v �v ! 5853: �M����F ! 5854: �V �F��� ����T�F��V� �t ��T�F��V�RP�����F��V��r��F��V�� ! 5855: �F���+����_^�VWU��v �~ ! 5856: x�F�V ! 5857: ; |0; r*�v ! 5858: �v�6������= t= uh V�2��� ��� �;V ! 5859: |;FvV�v ! 5860: �v�&�� �t� j �F�V ! 5861: � ������RP�6 �n������Ǚ�؋ʃ��u$���u �v ! 5862: �v�6 �|���= t= t����h V�6 �.���= t �v ! 5863: �v�6�J���= t= u�M��n��_^�VWU��> u�� �~ ! 5864: x�F�V ! 5865: ; |(; r"�v ! 5866: �v�6������= t ! 5867: = u� �� �j �F�V ! 5868: � ������RP�6 �������Ǚ�؋ʃ��u$���u �v ! 5869: �v�6 ����= t= t^����h �v �6 �[���= t �v ! 5870: �v�6�w���= t= t*���� �;V ! 5871: |;Fr�v �v ! 5872: �v�&��� & �_^�VW� �v � �;V ! 5873: | ! 5874: ;Fs+��� ��;V ! 5875: |A;Fw<��;V ! 5876: |1;Fr,���؋ʋF�V ! 5877: +�ѹ ������T PV�� ���& � �F��F�V ! 5878: �� -& �� �; ~� ��+@�� �F�j �F�V ! 5879: � ������RP�6 �R������Ǚ�؋ʃ��u���t�v�hT �6 �/���;F�t� ����&�V�v ! 5880: �v�����_^�VWU��v ��;V ! 5881: |;;Fw6��;V ! 5882: |+;Fr&V���؋ʋF�V ! 5883: +�ѹ ������T P� ���_^�VW� �v�~ ! 5884: �F� �F��N� �t��F�F���G���^�����_^�VWU��v�~ ! 5885: �t ��F� Ou��_^�VWU�� �;V ! 5886: | ;Fw�F�V ! 5887: ; | ; s�& �+��_^� Z_cu�� ! 5888: � �@ �@ ! 5889: & � @ �� - ��Can not stat %s %r [yes/no]: [default - YES] ! 5890: [default - NO] ! 5891: Invalid Response FILE DIR Character Special Block Special PIPE Unknown I-node type abort. fsck: %r ! 5892: fsck: %r ! 5893: Out of Range Block number: %U (CONTINUE) Can not Seek: Blk num: %U (CONTINUE) Can not Read: Blk num: %U (CONTINUE) Can not Write: Blk num: %U (CONTINUE) fsize_ nunkwn_ �daction_ fsfd_ errflag_ typename_ &writeflg_ isize_ chgcache_ �bad_ �imap_ �nblk_ �bclear_ }write_ nchr_ �findblock_ wtblkerr_ ndir_ �stats_ blkmove_ Kwriteino_ getcache_ �query_ 1 lldiv stat_ _canl_ bread_ action_ � lrrem fatal_ z&bwrite_ �nfile_ �nonfatal_ �&printf_ lseek_ databuf_ rdblkerr_ abort_ h&_exit_ statit_ rgblkerr_ �candino_ \ptrino_ �&npipe_ �read_ nextchar_ � changeflg_ high_ skblkerr_ ' 7 ' 0 $% $; 7> ! 'D S U W Y $\ 7_ ! $j 7m ! 0u 0� 7� , $� 0� $�$�$�$�$�$�7%& <& >& @& B& D& F&$I&$N&$S&$X&$]&$b&$n&0q&$�&7�&! 7�&& $�&7�&! '�& 7�& 0�&0090S7k 7} 7� 7� 0�$�0�$�0�$�$�$7 $#$'70 $@0b0o'r# 0{$�7� $�$�7� '�# 7� 0�0�$�$ $$' '& $2050I0O0R'U 0l0v'� 7�" $�0�0�'� 7�, $�0�0�0�' 0 ' '# $/020B0G'^ 7a" $�0�0�'� 7� $�0�0�'� 0�'�. '� 0$$$$4%O0T0]$c$x'| '� $�$�$�'� 7�" %�'� 7�, $�$�0�0�$$$#%>0B'� '� '� $� 0� $�$�$�$�$�$�7%& <& >& @& B& D& F&$I&$N&$S&$X&$]&$b&$n&0q&$�&7�&! 7�&& $�&7�&! '�& 7�fsck/objects/fsck.o 644 3 3 54 5045007416 7440 & 644 3 3 54 5045007416 7440 fsck/objects/printf.o 644 3 3 2543 5045007431 10056 & L d o VWU��FP� ���_^�VW�Y �F�F��^���F��F��^��F�����=% t �u���LjF�j&�F�Pj&�������F� �F����F����^��F�������-u�F�&�^��F�������F� ��0u�F�0�^��F�������*u�^��F���F�^��F������,�F� ��0|"��9 kF� ! 5894: �ȋ��-0 �F�^��F������ك�.uU�^��F�������*u�^��F���F��^��F������,�F� ��0|"��9 kF� ! 5895: �ȋ��-0 �F��^��F������ك�lu"�^��F�������dt��ot ! 5896: ��ut��xu�� �F��F����ǻ�&� CC.;��t��.�gD O U X c d o r s u x �&M4Q��&�&�U�&�&�^��F���F�~� } �؉F��F�-j ! 5897: �v�V�b&������ j ! 5898: �^��F��7��j��j��^���W�F�V�F��~� y���� �F�V��F�-j ! 5899: �v��v�V�&���j ! 5900: �^��w�7V�p&�����F��fj��j��^���F� �u�F�L�F��F��F�����F�? t�~� |��+F�;F�~�N�&�^��F���F��F�F蘈��^��7�g����F��F�F�+ƉF� �}�F� �~� u �F��N� �t�F��F�j&�F�Pj&������;v�v�^��F���F�j&�F�Pj&��������~� u���F��N� �u���F��F�j&�F�Pj&��������_^�VW� �v ! 5901: �F��F��N��^�� ��+��v �� �t �N��F��F��+��v �ڊ�T��^������N��^���T���^��? t�F�F�F��F����^���F�_^�VW� �v�~�n��N�^�� �ǙRP�v �v ! 5902: �(����F�V� �t4�N�F�F�ǙRP�v �v ! 5903: �����؊�T��^��F�V�F ! 5904: �V ��N�F�F�F ! 5905: �؊�T��^��^�? t ��F�F��F�����_^�{NULL} 0123456789ABCDEFwrite_ xprintf_ vrdiv vrrem printf_ 0 ! 5906: 0@ 7P t&0�& �& �& �& �& �& �& �& �& �& �& �&0�&0�&0-0@$d0�7� 7 00!72 $v$�7� 7� $$)���_^�VW� �v ! 5907: �F��F��N��^�� ��+��v �� �t �N��F��F��+��v �ڊ�T��^������N��^���T���^��? t�F�F�F��F����^���F�_^�VW� �v�~�n��N�^�� �ǙRP�v �vfsck/objects/link.o 644 3 3 273 5045007443 7472 & ( < VWU��j �F+�RP����� �u �vh( ������_^�Too many links in i-node, %d findblock_ fatal_ linkincr_ 7 $ 7 & fsck/objects/virtual.o 644 3 3 10046 5045007462 10263 & � r �� �& $VW�$ �F+ңF �H �F ! 5908: +�F H �J �L �F +�J L �N �P �F+�N P �R �T h� j hV ����h �j h� ��������F� ��F�+�;T v�x&r ;R v�m&�> t�� �6��a���@= w%����.��� � � � �6�h���6�h!�6����F�P�6��(���=��t�F� t�F���%� = t �6�hZ�&���j�6�������=��u �6�h~������F� �F� �F��V�;T rv� ;R r� h h� �6����= t h������F� �V� �j�6 �����=��uEh�&�6 �r����=��u �6 h��]����6�S���j�6 �G�����6 �:����F�P�6�,���=��u �6 h������F�; u h������_^�VW� �>�u� �6������> ux�F�P�6������=��t �F� t�F���%� = u�F� t �6�h! ����j�6������=��u �6�hK �����6�|��� �} �6�hk �k����_^�VW� �F = v��&����.������ZZZ����???�F�V ! 5909: % +ҋ��& ����������F�� �F�V ! 5910: �������F�V ! 5911: �~ ! 5912: yh� h� h� h� �����j&������J �L &FV ! 5913: �F�V ! 5914: ;P ws�[&;N s�R&h� h� h� h� �5&�F�V ! 5915: % +ҋ��& ����������F�� �F�V ! 5916: �������F�V ! 5917: �~ ! 5918: yh ! 5919: h� h� h� �_���j&�W����N �P &FV ! 5920: �F�V ! 5921: ;T ws�� ;R s�� h6 ! 5922: h� h) ! 5923: h ! 5924: � �~ ! 5925: xu �~ uha ! 5926: h� hT ! 5927: h8 ! 5928: �&���j&������F �H -& �� &FV ! 5929: �F�V ! 5930: ;L wrr;J rlh� ! 5931: h� h ! 5932: hc ! 5933: �P�~ ! 5934: xu �~ uh� ! 5935: h� h� ! 5936: h� ! 5937: ����j&�����n&�^ ! 5938: �F�V ! 5939: ;H wr ;F rh� ! 5940: h� h� ! 5941: h� ! 5942: �n���j&�f����F�V ! 5943: %�&+҉F�� �F�V ! 5944: �������F�V ! 5945: %? +҉F�� �F�V ! 5946: �������F�V ! 5947: %�+҉F��F�V��v��拼V ������+҉F�V�;V�u;F�u�*&�~�����V & tr� �F�V��������F�V��~��� ��+�&F�V�R�v��v��6�����؋ʃ��u���u h� ! 5948: ����h �F��� � P�6����= t h� ! 5949: �s����F�+҉F�V�� �������F�V��~��� ��+�&F�V�R�v��v��6�8����؋ʃ��u���u h �!���h �F��� � P�6� ! 5950: ���= th j �F��� � P������~���F���%����V & �V �~��灥V ����V �F��� F�� �F�F = v� ����.��^z���z����������~�*�#F�� �~��灥V ����V & �F��~��*��r�~��灥V ����V & �F��~�0�ߋ~��ڋ~��灥V ����V & �F�~����~��灥V ����V & �F뤋~��灥V ����V & �~���h) ������_^�VWȈ +��Љ�|���~���x���z��F+�;�~�ws� ;�|�w� +���� }7�F+�;�~�wr*;�|�v$���j��~���|��!����E�F��|�&��~� ��+���� }��F+�;�z�wr�;�x�v�����E��Pj��z���x������F��x�&��z� ���_^� ��/dev/rram1 /dev/rram1close Can't access ram disk "%s", use the -t option Possible file system on ram disk "%s", use the -t option Ram disk "%s" not mknod'ed properly Cannot open read/write Ram Disk "%s" Error writing to tmp file Cannot create temp file "%s" Can't stat temp file "%s" Temp File must not be on file system to fsck Ram disk close "%s" not mknod'ed properly Cannot open Ram Disk Close "%s" Cannot close Ram Disk Close "%s" %s: %d: assert(%s) failed. ! 5951: ../virtual.c p %s: %d: assert(%s) failed. ! 5952: ../virtual.c p %s: %d: assert(%s) failed. ! 5953: ../virtual.c p %s: %d: assert(%s) failed. ! 5954: ../virtual.c p %s: %d: assert(%s) failed. ! 5955: ../virtual.c p %s: %d: assert(%s) failed. ! 5956: ../virtual.c p %s: %d: assert(%s) failed. ! 5957: ../virtual.c p %s: %d: assert(%s) failed. ! 5958: ../virtual.c p Error seeking tmp file Error writing tmp file Error seeking tmp file Bad action in virtual system fstat_ write_ findblock_ �tmpfile_ open_ fsysrdev_ exit_ stat_ fatal_ initV_ memset_ creat_ copyV_ unlink_ printf_ lseek_ is_fs_ close_ cleanV_ �&read_ $�$�% % % % % %$ %- %1 %4 %8 %A %E %H %L %T 7W ! 5959: %b 7e ! 5960: %l %| 0� %� 0� '� 0� $� 7� � � � � $� $� $� $� 7� $� 7� $� $� 7� $&7 & %&$&$&7 & %5&0<&%@&0E&%K&%O&7R&& $]&7`& 't& 7w& %}&'�& 7�& %�&'�& $�&7�& %�&7�& '�& 7�& %�&'�& 7�& %�&7�& '�& $�&7�& '�& $�&7�& %0 %7 ' $&7) $Q$T7W $`7c %i$r$u7x %7� $�$�7� 0� � � � � � � � � � � � � � � �$ $$7 7 %%%)%90@%D0I$L$R$U0X$�$�$�7� 7� %�%�%�0�%�0�$�$�$�0�$�$�$�7� 7 % %%%%-$2$8$;$N$T$W7Z 7b %w%$�$�$�7� 7� %�0%%L7O $c7f %u%z7}& $�7� %�7� $�7� %�%�7� % ! 5961: 7 ! 5962: %"%(%1%7%E0S \ ^ ` b d f h j l n p r t v x0�%�%�%�%�%�%�%�%�%�%$7 0D0M0y0�$�&7�& %0 %7 ' $&7) $Q$T7W $`7c %i$r$u7x %7� $�$�7� 0� � � � � � � � � � � � � � � �$ $$7 7 %%%)%90@%D0I$L$R$U0X$�$�$�7� 7� %�%�%�0�%�0�$�$�$�0�$�$�$�7� 7 % %%%%-$2$8$;$N$T$W7Z 7b %w%$�$�$�7� 7� %�0%%L7O $c7f %u%z7}& $�7� %�7� $�7� %�%�7� % ! 5963: 7 ! 5964: %"%(%1%7%E0S \ ^ ` b d f h j l n p r t v x0�%�%�%�%�fsck/objects/is_fs.o 644 3 3 1347 5045007474 7667 & �& �& � E VW�$ �F�P�v����� �}�����&�F�% �= `t �F�% �= u�j�v������� �|�j j h V�����Ћ�؋ʃ��u���th�&h�&V����=�&t V�����V�|�����&�u�u�m����E�U�E�F��ρ�&�F�;�s �^��w�7�F����^���W�F��� ! 5965: &�Fދρ��&�F�;�s�F������&���&�������&���&�����@�F܋+�;Uwr ! 5966: ;Er+��� �E�;��&|�;��&w�+ҋ؋ʋE�U+��& �;��&r�w;��&vċ��&;�&r��F���;��&v��E�F��E��� ;F�v2�^��+�;Wrw�;w��^���W;U~�v�|;Er�l��F�뾍� ! 5967: &�Fދ�&��� ! 5968: &;F�v�^ދ=& s�B�;F�v�:��F��ո& �_^�open_ stat_ _canl_ lseek_ is_fs_ close_ read_ 7 & 0 79 7M %i 7m 7y 7� %� 7� 7� 7� 0&0�&0�&0�&0�&��^���W�F��� ! 5969: &�Fދρ��&�F�;�s�F������&���&�������&���&�����@�F܋+�;Uwr ! 5970: ;Er+��� �E�;��&|�;��&w�+ҋ؋ʋE�U+��& �;��&r�w;��&vċ��&;�&r��F���;��&v��E�F��E��� ;F�v2�^��+�;Wrw�;w��^���W;U~�v�|;Er�l��F�뾍� ! 5971: &�Fދ�&��� ! 5972: &;F�v�^ދ=& s�Bfsck/phase1.c 644 3 3 16004 4767515610 6322 /* ! 5973: * phase 1 of fsck - Check Blocks and Sizes ! 5974: */ ! 5975: ! 5976: #include "fsck.h" ! 5977: ! 5978: char databuf[BSIZE]; /* buffer for blocks */ ! 5979: ! 5980: int clrflg; /* indicates when to clear an inode */ ! 5981: int dupflag; /* indicates whether there are any dups */ ! 5982: ! 5983: int numbad; /* number of bad blocks in the inode */ ! 5984: int numdup; /* number of duplicate blocks in inode */ ! 5985: long numblks; /* number of data blks for size check */ ! 5986: long sparsecnt; /* count for sparse blocks for size check */ ! 5987: ! 5988: /* The following is a table of the number of direct blocks pointed at by the ! 5989: * four types of blocks direct, ..., triple-indirect, to help count sparse ! 5990: * blocks. ! 5991: */ ! 5992: ! 5993: daddr_t blockcnt[] = {1, (daddr_t)NBN, (daddr_t)NBN*NBN, (daddr_t)NBN*NBN*NBN}; ! 5994: ! 5995: phase1() ! 5996: { ! 5997: if (!qflag) ! 5998: printf("Phase 1 : Check Blocks and Sizes\n"); ! 5999: dupflag = FALSE; ! 6000: inodescan(); ! 6001: if (dupflag) ! 6002: phase1b(); ! 6003: } ! 6004: ! 6005: inodescan() ! 6006: { ! 6007: register daddr_t bn; ! 6008: register struct dinode *dip; ! 6009: register ino_t ino; ! 6010: int i; ! 6011: ! 6012: ino = 1; ! 6013: ! 6014: for (bn=INODEI; bn<isize; bn++) { ! 6015: if (testblock(bn)) { /* block is bad via inode 1 */ ! 6016: ino += INOPB; ! 6017: continue; ! 6018: } ! 6019: bread(bn, databuf); ! 6020: clrflg = FALSE; ! 6021: dip = (struct dinode *) databuf; ! 6022: for (i=0; i<INOPB; i++) { ! 6023: candino(dip); ! 6024: if (inuse(dip) == TRUE) { ! 6025: if (!fflag) ! 6026: checkmode(dip, ino); ! 6027: if ( checkblks(dip, ino) != STOP ) ! 6028: if ( qflag == FALSE ) ! 6029: checksize(dip, ino); ! 6030: } ! 6031: candino(dip); ! 6032: ino++; ! 6033: dip++; ! 6034: } ! 6035: if (clrflg) ! 6036: bwrite(bn, databuf); ! 6037: } ! 6038: } ! 6039: ! 6040: /* ! 6041: * Determine if the given inode is in use. ! 6042: */ ! 6043: ! 6044: inuse(dip) ! 6045: register struct dinode *dip; ! 6046: { ! 6047: #ifdef NOT_ALL_ZERO_INODE ! 6048: ! 6049: if ( (dip->di_mode != 0) || (dip->di_nlink != 0) ) ! 6050: return(TRUE); ! 6051: else ! 6052: return(FALSE); ! 6053: #endif ! 6054: #ifdef ALL_ZERO_INODE ! 6055: ! 6056: register char *ptr; ! 6057: register struct dinode *next; ! 6058: ! 6059: ptr = (char *) dip; ! 6060: next = dip + 1; ! 6061: while (ptr < next) ! 6062: if (*ptr++ != 0) ! 6063: return(TRUE); ! 6064: ! 6065: return(FALSE); ! 6066: #endif ! 6067: } ! 6068: ! 6069: /* ! 6070: * Check the mode of the given inode ! 6071: */ ! 6072: ! 6073: checkmode(dip, ino) ! 6074: register struct dinode *dip; ! 6075: register ino_t ino; ! 6076: { ! 6077: register unsigned short mode; ! 6078: ! 6079: mode = dip->di_mode & IFMT; ! 6080: ! 6081: switch (mode) { ! 6082: case IFREG: ! 6083: setflags(ino, IREG); ! 6084: return; ! 6085: case IFDIR: ! 6086: setflags(ino, IDIR); ! 6087: return; ! 6088: case IFCHR: ! 6089: setflags(ino, ICHR); ! 6090: return; ! 6091: case IFBLK: ! 6092: setflags(ino, IBLK); ! 6093: return; ! 6094: case IFPIPE: ! 6095: setflags(ino, IPIPE); ! 6096: return; ! 6097: default: ! 6098: setflags(ino, UNKNOWN); ! 6099: break; ! 6100: } ! 6101: ! 6102: switch ( query("Unknown File Type i-number = %u (Clear)", ino) ){ ! 6103: case NO: ! 6104: return; ! 6105: case YES: ! 6106: zeroinode(dip); ! 6107: setflags(ino, UNALLOC); ! 6108: clrflg = TRUE; ! 6109: break; ! 6110: } ! 6111: } ! 6112: ! 6113: /* ! 6114: * Zero the given inode ! 6115: */ ! 6116: ! 6117: zeroinode(dip) ! 6118: struct dinode *dip; ! 6119: { ! 6120: register char *ptr; ! 6121: register struct dinode *next; ! 6122: ! 6123: lostsize += dip->di_size; ! 6124: next = dip+1; ! 6125: ptr = (char *) dip; ! 6126: ! 6127: while (ptr < next) ! 6128: *ptr++ = 0; ! 6129: ! 6130: } ! 6131: ! 6132: /* ! 6133: * Check the blocks associated with the given inode to determine ! 6134: * if any are bad or duplicate ! 6135: */ ! 6136: ! 6137: checkblks(dip, ino) ! 6138: struct dinode *dip; ! 6139: ino_t ino; ! 6140: { ! 6141: daddr_t addrs[NADDR]; ! 6142: register daddr_t bn; ! 6143: register int i, lev; ! 6144: register int mode; ! 6145: ! 6146: mode = dip->di_mode & IFMT; ! 6147: ! 6148: if ( (mode != IFREG) && (mode != IFDIR) ) ! 6149: return(STOP); ! 6150: ! 6151: l3tol(addrs, dip->di_addr, NADDR); ! 6152: ! 6153: numbad = /* number of bad blocks so far */ ! 6154: numdup = /* num dup blocks so far THIS INODE */ ! 6155: numblks = /* num used data blocks for size chk */ ! 6156: sparsecnt = 0; /* count of missed data blocks */ ! 6157: ! 6158: for(i=0; i<NADDR; i++) ! 6159: for (lev=0; lev<4; lev++) ! 6160: if (i < offsets[lev]) { ! 6161: if ( (bn=addrs[i]) != 0 ) { ! 6162: if (doblocks(bn, ino, lev) != OK) ! 6163: return(STOP); ! 6164: } else ! 6165: sparsecnt += blockcnt[lev]; ! 6166: break; ! 6167: } ! 6168: return(OK); ! 6169: } ! 6170: ! 6171: /* ! 6172: * Checks recursively the blocks pointed at via ! 6173: * the inode list of blocks. 'bn' is the block number, ! 6174: * 'ino' is the inode referencing it, and 'lev' is the ! 6175: * level 0 == direct ... 3 = triple-indirect ! 6176: */ ! 6177: ! 6178: doblocks(bn, ino, lev) ! 6179: register daddr_t bn; ! 6180: ino_t ino; ! 6181: int lev; ! 6182: { ! 6183: char buf[BSIZE]; ! 6184: register daddr_t *bnptr; ! 6185: register char *end; ! 6186: register int flag; ! 6187: ! 6188: if (lev-- == 0) { /* we have a direct block */ ! 6189: numblks += sparsecnt + 1; ! 6190: sparsecnt = 0; ! 6191: return(dodirect(bn, ino)); ! 6192: } else { ! 6193: end = &buf[BSIZE]; ! 6194: if ( (flag=dodirect(bn, ino)) == OK ) { ! 6195: bread(bn, buf); ! 6196: bnptr = (long *) buf; ! 6197: while ( bnptr < end ) { ! 6198: bn = *bnptr++; ! 6199: candaddr(bn); ! 6200: if ( bn == 0 ) { ! 6201: sparsecnt += blockcnt[lev]; ! 6202: continue; ! 6203: } ! 6204: if ( doblocks(bn, ino, lev) == STOP ) ! 6205: return(STOP); ! 6206: } ! 6207: return(OK); ! 6208: } else ! 6209: return(flag); ! 6210: } ! 6211: } ! 6212: ! 6213: /* ! 6214: * Check the given block to determine if it is bad ! 6215: * or if it is a duplicate. 'ino' is the inode referencing it ! 6216: */ ! 6217: ! 6218: dodirect(bn, ino) ! 6219: register daddr_t bn; ! 6220: register ino_t ino; ! 6221: { ! 6222: register int flag; ! 6223: ! 6224: if ( (flag=checkbad(bn, ino)) == OK ) ! 6225: return( checkdup(bn, ino) ); ! 6226: else ! 6227: return(flag); ! 6228: } ! 6229: ! 6230: /* ! 6231: * Check the given block number for being bad. ! 6232: */ ! 6233: ! 6234: checkbad(bn, ino) ! 6235: register daddr_t bn; ! 6236: ino_t ino; ! 6237: { ! 6238: if ( (bn>=isize) && (bn<fsize) ) ! 6239: return(OK); ! 6240: ! 6241: else if ( (bn<isize) && (bn>=INODEI) && (ino == 1) ) { ! 6242: /* bad block is in */ ! 6243: totfree++; /* the inode blocks */ ! 6244: return(OK); ! 6245: } ! 6246: ! 6247: if (!fflag) ! 6248: orflags(ino, IBAD_IDUP); ! 6249: ! 6250: printf("Bad block %U, i-number = %u\n", bn, ino); ! 6251: ! 6252: if (numbad++ < MAXBADOK) ! 6253: return(BAD_DUP); ! 6254: ! 6255: switch ( query("Excessive Bad Blocks i-number = %u (Continue)", ino) ){ ! 6256: case NO: ! 6257: abort(); ! 6258: case YES: ! 6259: return(STOP); ! 6260: } ! 6261: } ! 6262: ! 6263: ! 6264: /* ! 6265: * Check the given block number for duplicate reference. ! 6266: */ ! 6267: ! 6268: checkdup(bn, ino) ! 6269: register daddr_t bn; ! 6270: ino_t ino; ! 6271: { ! 6272: if ( !testblock(bn) ) { ! 6273: markblock(bn); ! 6274: totfree--; ! 6275: return(OK); ! 6276: } ! 6277: ! 6278: dupflag = TRUE; ! 6279: if (!fflag) ! 6280: orflags(ino, IBAD_IDUP); ! 6281: printf("Dup Block %U, i-number = %u\n", bn, ino); ! 6282: ! 6283: if (totdups < DUPTBLSIZE) ! 6284: dupblck[totdups++] = bn; ! 6285: else { ! 6286: switch ( query("DUP Table Overflow (Continue)") ) { ! 6287: case NO: ! 6288: abort(); ! 6289: case YES: ! 6290: return(BAD_DUP); ! 6291: } ! 6292: } ! 6293: ! 6294: if (numdup++ < MAXDUPOK) ! 6295: return(BAD_DUP); ! 6296: ! 6297: switch ( query("Excessive Dup Blocks i-number = %u (Continue)", ino) ) { ! 6298: case NO: ! 6299: abort(); ! 6300: case YES: ! 6301: return(STOP); ! 6302: } ! 6303: } ! 6304: ! 6305: /* ! 6306: * Check For Possible File Size Error ! 6307: */ ! 6308: ! 6309: checksize(dip, ino) ! 6310: register struct dinode *dip; ! 6311: ino_t ino; ! 6312: { ! 6313: register int mode; ! 6314: register fsize_t size; ! 6315: ! 6316: mode = dip->di_mode & IFMT; ! 6317: size = dip->di_size; ! 6318: ! 6319: if ( mode == IFREG ) ! 6320: filesize(ino, size); ! 6321: else /* mode == IFDIR */ ! 6322: dirsize(dip, ino, size); ! 6323: } ! 6324: ! 6325: dirsize(dip, ino, size) ! 6326: struct dinode *dip; ! 6327: ino_t ino; ! 6328: register fsize_t size; ! 6329: { ! 6330: if ( size <= 0 ) { ! 6331: switch ( query("\ ! 6332: Bad Directory Size, size = %D, i-number = %u (Clear i-node)", size, ino) ) { ! 6333: case NO: ! 6334: break; ! 6335: case YES: ! 6336: zeroinode(dip); ! 6337: setflags(ino, UNALLOC); ! 6338: clrflg = TRUE; ! 6339: return; ! 6340: } ! 6341: } ! 6342: ! 6343: if ( size < (2*DSIZE) ) ! 6344: printf("Directory Size too small i-number = %u\n", ino); ! 6345: ! 6346: if ( size % sizeof(struct direct) != 0 ) ! 6347: printf("Directory Misaligned i-number = %u\n", ino); ! 6348: ! 6349: if (sizerr(size)) ! 6350: printf("Possible Directory Size Error i-number = %u\n", ino); ! 6351: } ! 6352: ! 6353: filesize(ino, size) ! 6354: ino_t ino; ! 6355: register fsize_t size; ! 6356: { ! 6357: if (sizerr(size)) ! 6358: printf("Possible File Size Error i-number = %u\n", ino); ! 6359: } ! 6360: ! 6361: sizerr(size) ! 6362: register fsize_t size; ! 6363: { ! 6364: register fsize_t calc; ! 6365: ! 6366: calc = (unsigned long)numblks*BSIZE; ! 6367: if ( (size > calc) || ( calc >= (size+BSIZE) ) ) ! 6368: return(TRUE); ! 6369: else ! 6370: return(FALSE); ! 6371: } ! 6372: f ( size % sizeof(struct direct) != 0 ) ! 6373: printf("Directory Misaligned i-number = %u\n", ino); ! 6374: ! 6375: if (sizerr(size)) ! 6376: printf("Possible Directory Size Error i-number = %u\n", ino); ! 6377: } ! 6378: ! 6379: filesize(ino, size) ! 6380: ino_t ino; ! 6381: register fsize_t size; ! 6382: { ! 6383: if (sizerr(size)) ! 6384: printf("Possible File Size Error i-number = %u\n", ino); ! 6385: } ! 6386: ! 6387: sizerr(size) ! 6388: register fsize_t size; ! 6389: { ! 6390: register fsize_t calc; ! 6391: ! 6392: calc = (unsigned long)numblks*BSIZE; ! 6393: if ( (size > calc) || ( calc >= (size+BSIZE) ) ) ! 6394: return(TRUE); ! 6395: else ! 6396: return(FALSE)fsck/phase1b.c 644 3 3 4361 4664524116 6444 /* ! 6397: * Phase 1b of fsck - Rescan for more Dups ! 6398: */ ! 6399: ! 6400: #include "fsck.h" ! 6401: ! 6402: extern int numdup; /* declared in phase1.c */ ! 6403: ! 6404: phase1b() ! 6405: { ! 6406: if (!qflag) ! 6407: printf("Phase 1b: Rescan for more Dups\n"); ! 6408: buildtable(); ! 6409: iscanb(); ! 6410: } ! 6411: ! 6412: buildtable() ! 6413: { ! 6414: unsigned cntr=0, numdiff=0; ! 6415: daddr_t bn; ! 6416: ! 6417: while (cntr<totdups) { ! 6418: bn = dupblck[cntr++]; ! 6419: if (!testdup(bn)) { ! 6420: markdup(bn); ! 6421: numdiff++; ! 6422: } ! 6423: } ! 6424: totdups = numdiff; ! 6425: } ! 6426: ! 6427: iscanb() ! 6428: { ! 6429: register daddr_t bn; ! 6430: register struct dinode *dip; ! 6431: register ino_t ino; ! 6432: int i; ! 6433: ! 6434: ino = 1; ! 6435: ! 6436: for (bn=INODEI; bn<isize; bn++) { ! 6437: if (testblock(bn)) { /* block is bad via inode 1 */ ! 6438: ino += INOPB; ! 6439: continue; ! 6440: } ! 6441: bread(bn, databuf); ! 6442: dip = (struct dinode *) databuf; ! 6443: for (i=0; i<INOPB; i++) { ! 6444: candino(dip); ! 6445: if (inuse(dip) == TRUE) ! 6446: ckblksb(dip, ino); ! 6447: if (totdups == 0) ! 6448: return; ! 6449: ino++; ! 6450: dip++; ! 6451: } ! 6452: } ! 6453: } ! 6454: ! 6455: /* ! 6456: * Check the blocks associated with the given inode to find the ! 6457: * remaining duplicate blocks ! 6458: */ ! 6459: ! 6460: ckblksb(dip, ino) ! 6461: register struct dinode *dip; ! 6462: register ino_t ino; ! 6463: { ! 6464: daddr_t addrs[NADDR]; ! 6465: int i, lev; ! 6466: int mode; ! 6467: ! 6468: mode = dip->di_mode & IFMT; ! 6469: ! 6470: if ( (mode != IFREG) && (mode != IFDIR) ) ! 6471: return; ! 6472: ! 6473: l3tol(addrs, dip->di_addr, NADDR); ! 6474: ! 6475: numdup = 0; /* num dup blocks so far THIS INODE */ ! 6476: ! 6477: for(i=0; i<NADDR; i++) ! 6478: for (lev=0; lev<4; lev++) ! 6479: if (i < offsets[lev]) { ! 6480: dblocksb(addrs[i], ino, lev); ! 6481: break; ! 6482: } ! 6483: } ! 6484: ! 6485: /* ! 6486: * Checks recursively the blocks pointed at via ! 6487: * the inode list of blocks. 'bn' is the block number, ! 6488: * 'ino' is the inode referencing it, and 'lev' is the ! 6489: * level 0 == direct ... 3 = triple-indirect ! 6490: */ ! 6491: ! 6492: dblocksb(bn, ino, lev) ! 6493: daddr_t bn; ! 6494: ino_t ino; ! 6495: int lev; ! 6496: { ! 6497: char buf[BSIZE]; ! 6498: int i; ! 6499: daddr_t *bnptr; ! 6500: ! 6501: if (bn == 0) ! 6502: return(OK); ! 6503: ! 6504: switch ( cdupb(bn, ino) ) { ! 6505: case OK: ! 6506: if (lev--==0) ! 6507: return(OK); ! 6508: bread(bn, buf); ! 6509: bnptr = (long *) buf; ! 6510: for (i=0; i<NBN; i++) { ! 6511: bn = bnptr[i]; ! 6512: candaddr(bn); ! 6513: if ( dblocksb(bn, ino, lev) == STOP ) ! 6514: return(STOP); ! 6515: } ! 6516: return(OK); ! 6517: case STOP: ! 6518: return(STOP); ! 6519: } ! 6520: } ! 6521: ! 6522: /* ! 6523: * Check the given block number for duplicate reference. ! 6524: */ ! 6525: ! 6526: cdupb(bn, ino) ! 6527: daddr_t bn; ! 6528: ino_t ino; ! 6529: { ! 6530: if ( !testdup(bn) ) ! 6531: return(OK); ! 6532: ! 6533: totdups--; ! 6534: unmarkdup(bn); ! 6535: if (!fflag) ! 6536: orflags(ino, IBAD_IDUP); ! 6537: printf("Dup Block %U, i-number = %u\n", bn, ino); ! 6538: ! 6539: return(STOP); ! 6540: } ! 6541: =0) ! 6542: return(OK); ! 6543: bread(bn, buf); ! 6544: bnptr = (long *) buf; ! 6545: for (i=0; i<NBN; i++) { ! 6546: bn = bnptr[i]; ! 6547: candaddr(bn); ! 6548: if ( dblocksb(bn, ino, lev) == STOP ) ! 6549: return(STOP); ! 6550: } ! 6551: return(OK); ! 6552: case STOP: ! 6553: return(STOP); ! 6554: } ! 6555: } ! 6556: ! 6557: /* ! 6558: * Check the given block number forfsck/phase2.c 644 3 3 17061 4767515401 6325 /* ! 6559: * phase 2 of fsck - Check Pathnames ! 6560: */ ! 6561: ! 6562: #include "fsck.h" ! 6563: #include <pwd.h> ! 6564: ! 6565: #define MAXDEPTH 50 ! 6566: struct direct *path[MAXDEPTH]; ! 6567: int depth; ! 6568: int fixflag; /* flags when must rewrite databuf */ ! 6569: daddr_t blocknum; /* Current block num read in */ ! 6570: ! 6571: typedef struct list { ! 6572: struct direct d_entry; ! 6573: struct list *next; ! 6574: } list; ! 6575: ! 6576: char buf2[BSIZE]; /* buffer for blocks */ ! 6577: daddr_t cdbn; /* current logical block number */ ! 6578: ! 6579: /* Format errors, args to blkerr() */ ! 6580: ! 6581: #define NULLNAME 5 ! 6582: #define NULLPAD 6 ! 6583: #define SLASHES 7 ! 6584: #define DOT 8 ! 6585: #define DOTDOT 9 ! 6586: ! 6587: phase2() ! 6588: { ! 6589: if (!qflag) ! 6590: printf("Phase 2 : Check Pathnames\n"); ! 6591: checkroot(); ! 6592: depth = 0; ! 6593: checkpath(ROOTIN); ! 6594: } ! 6595: ! 6596: ! 6597: checkroot() ! 6598: { ! 6599: if ( (flags(ROOTIN)&MODEMASK) == UNALLOC ) ! 6600: fatal("Root i-node is unallocated. Terminating"); ! 6601: ! 6602: if ( (flags(ROOTIN)&MODEMASK) != IDIR ) { ! 6603: switch ( query("Root i-node is not a directory (FIX)") ){ ! 6604: case YES: ! 6605: fixroot(); ! 6606: break; ! 6607: case NO: ! 6608: abort(); ! 6609: } ! 6610: } ! 6611: ! 6612: if ( badblks(ROOTIN) ){ ! 6613: switch ( query("Dup/Bad blocks in root i-node (Continue)") ) { ! 6614: case YES: ! 6615: break; ! 6616: case NO: ! 6617: abort(); ! 6618: } ! 6619: } ! 6620: linkincr(ROOTIN); /* (?) Feature (?) of mkfs is */ ! 6621: /* that root inode of a file */ ! 6622: /* system has a link count one */ ! 6623: /* too large. */ ! 6624: } ! 6625: ! 6626: fixroot() ! 6627: { ! 6628: register struct dinode *dip; ! 6629: ! 6630: if (!writeflg) ! 6631: fatal("File System Read-Only (NO WRITE)\n"); ! 6632: ! 6633: setflags(ROOTIN, (flags(ROOTIN) & ~MODEMASK) | IDIR); ! 6634: ! 6635: /* Save change to disk */ ! 6636: ! 6637: dip = ptrino(ROOTIN, databuf); ! 6638: dip->di_mode &= (~IFMT); ! 6639: dip->di_mode |= IFDIR; ! 6640: writeino(ROOTIN, databuf); ! 6641: } ! 6642: ! 6643: #define myinum ( (depth>0) ? path[depth-1]->d_ino : ROOTIN ) ! 6644: #define popinum ( (depth>1) ? path[depth-2]->d_ino : ROOTIN ) ! 6645: ! 6646: char *memory = "Can't malloc memory, phase 2"; ! 6647: ! 6648: list * ! 6649: procfiles(addrs, length) ! 6650: daddr_t *addrs; ! 6651: fsize_t length; ! 6652: { ! 6653: register struct direct *elemnt; ! 6654: register list *first, *ptr; ! 6655: ! 6656: if ((first=ptr=(list *)malloc(sizeof(list)))==NULL) ! 6657: fatal(memory); ! 6658: first->d_entry.d_ino = 0; ! 6659: first->next = NULL; ! 6660: if ( length < DSIZE ) ! 6661: return( first ); ! 6662: cdbn = 0; ! 6663: nextblock(addrs); ! 6664: fixflag = FALSE; ! 6665: elemnt = (struct direct *) databuf; ! 6666: cdots(elemnt++, ".", myinum, DOT); ! 6667: ++numfiles; ! 6668: if ( (length-=DSIZE) < DSIZE ) ! 6669: return( first ); ! 6670: cdots(elemnt++, "..", popinum, DOTDOT); ! 6671: ++numfiles; ! 6672: length -= DSIZE; ! 6673: ! 6674: while ( length >= DSIZE ) { ! 6675: while ( (elemnt<&databuf[BSIZE]) && (length>=DSIZE) ) { ! 6676: if (chck(elemnt)==IDIR) { ! 6677: copy(elemnt, &ptr->d_entry, ! 6678: sizeof(struct direct)); ! 6679: if ((ptr->next=(list *)malloc(sizeof(list))) == ! 6680: NULL) ! 6681: fatal(memory); ! 6682: ptr = ptr->next; ! 6683: ptr->d_entry.d_ino = 0; ! 6684: ptr->next = NULL; ! 6685: } ! 6686: elemnt++; ! 6687: length -= DSIZE; ! 6688: } ! 6689: if (fixflag && (fixblock(addrs) == NUL) ) ! 6690: fixblkerr(); ! 6691: nextblock(addrs); ! 6692: fixflag = FALSE; ! 6693: elemnt = (struct direct *) databuf; ! 6694: } ! 6695: return(first); ! 6696: } ! 6697: ! 6698: candblock(dptr) ! 6699: register struct direct *dptr; ! 6700: { ! 6701: register int num, i; ! 6702: ! 6703: num = BSIZE/sizeof(struct direct); ! 6704: for (i=0; i<num; i++) ! 6705: canino(dptr[i].d_ino); ! 6706: } ! 6707: ! 6708: nextblock(addrs) ! 6709: register daddr_t *addrs; ! 6710: { ! 6711: register daddr_t bn; ! 6712: ! 6713: if ( (bn=imap(addrs, cdbn++)) == 0 ) { ! 6714: bclear(databuf, BSIZE); ! 6715: return; ! 6716: } ! 6717: bread(bn, databuf); ! 6718: candblock(databuf); ! 6719: blocknum = bn; ! 6720: } ! 6721: ! 6722: fixblock(addrs) ! 6723: daddr_t *addrs; ! 6724: { ! 6725: daddr_t bn; ! 6726: ! 6727: if ( (bn=imap(addrs, cdbn-1)) == 0 ) ! 6728: return(NUL); ! 6729: candblock(databuf); ! 6730: bwrite(bn, databuf); ! 6731: return(TRUE); ! 6732: } ! 6733: ! 6734: fixblkerr() ! 6735: { ! 6736: fatal("Fixblock error."); ! 6737: } ! 6738: ! 6739: copy(from, to, size) ! 6740: register char *from, *to; ! 6741: register int size; ! 6742: { ! 6743: while (size--) ! 6744: *to++=*from++; ! 6745: } ! 6746: ! 6747: cdots(elemnt, dots, ino, type) ! 6748: register struct direct *elemnt; ! 6749: char *dots; ! 6750: ino_t ino; /* what the inode number should be */ ! 6751: int type; ! 6752: { ! 6753: register char *name = elemnt->d_name; ! 6754: register ino_t inum; ! 6755: ! 6756: inum = elemnt->d_ino; ! 6757: if ( (strcmp(name, dots) != 0) || (inum != ino) || ! 6758: (format(name) != GOOD) ) { ! 6759: blkerr(type); ! 6760: return; ! 6761: } ! 6762: linkincr(inum); ! 6763: } ! 6764: ! 6765: format(name) ! 6766: register char *name; ! 6767: { ! 6768: register char *ptr=name; ! 6769: register char *end=&name[DIRSIZ]; ! 6770: ! 6771: while ( (ptr<end) && (*ptr++ != '\0') ) ; ! 6772: ! 6773: if ( (ptr-1) == name ) ! 6774: return(NULLNAME); ! 6775: ! 6776: if (ptr<end) { ! 6777: while ( (ptr<end) && (*ptr++ == '\0') ) ; ! 6778: if (ptr!=end) ! 6779: return(NULLPAD); ! 6780: } ! 6781: ! 6782: ptr = name; ! 6783: while (ptr < end) ! 6784: if (*ptr++ == '/') ! 6785: return(SLASHES); ! 6786: ! 6787: return(GOOD); ! 6788: } ! 6789: ! 6790: ! 6791: blkerr(type) ! 6792: int type; ! 6793: { ! 6794: char *errname; ! 6795: ! 6796: switch(type) { ! 6797: case NULLNAME: ! 6798: errname = "Null name"; ! 6799: break; ! 6800: case NULLPAD: ! 6801: errname = "Non null padded"; ! 6802: break; ! 6803: case SLASHES: ! 6804: errname = "Embedded slashes in"; ! 6805: break; ! 6806: case DOT: ! 6807: errname = "Inconsistent ."; ! 6808: break; ! 6809: case DOTDOT: ! 6810: errname = "Inconsistent .."; ! 6811: break; ! 6812: default: ! 6813: errname = "Bad"; ! 6814: break; ! 6815: } ! 6816: ! 6817: printf("%s entry in block %U in directory\n", errname, blocknum); ! 6818: pinfo(myinum); ! 6819: pname(path[--depth]->d_name); ! 6820: depth++; ! 6821: } ! 6822: ! 6823: chck(elemnt) ! 6824: register struct direct *elemnt; ! 6825: { ! 6826: register ino_t inum; ! 6827: register char *name; ! 6828: int type; ! 6829: ! 6830: inum = elemnt->d_ino; ! 6831: if ( inum == 0 ) ! 6832: return(UNALLOC); ! 6833: ! 6834: name = elemnt->d_name; ! 6835: if ( (type=format(name)) != GOOD ) ! 6836: blkerr(type); ! 6837: ! 6838: if (inum>ninodes) { ! 6839: if ( irange(inum, name) ) ! 6840: zeroent(elemnt); ! 6841: return(UNALLOC); ! 6842: } ! 6843: ! 6844: if ( (flags(inum)&ALLOCMASK)==UNALLOC ) { ! 6845: if ( unalloc(inum, name) ) ! 6846: zeroent(elemnt); ! 6847: return(UNALLOC); ! 6848: } ! 6849: ! 6850: if ( badblks(inum) ) { ! 6851: if ( baddup(inum, name) ) { ! 6852: zeroent(elemnt); ! 6853: return(UNALLOC); ! 6854: } ! 6855: if ( (flags(inum)&MODEMASK)==IDIR ) ! 6856: return(UNALLOC); ! 6857: } ! 6858: ! 6859: linkincr(inum); ! 6860: numfiles++; ! 6861: return( flags(inum)&MODEMASK ); ! 6862: } ! 6863: ! 6864: zeroent(elemnt) ! 6865: struct direct *elemnt; ! 6866: { ! 6867: elemnt->d_ino = 0; ! 6868: fixflag = TRUE; ! 6869: } ! 6870: ! 6871: pname(name) ! 6872: char *name; ! 6873: { ! 6874: int i=0; ! 6875: ! 6876: while (i<depth) ! 6877: prdirsize(path[i++]->d_name); ! 6878: prdirsize(name); ! 6879: putchar('\n'); ! 6880: } ! 6881: ! 6882: prdirsize(name) ! 6883: char *name; ! 6884: { ! 6885: if (name[DIRSIZ-1] == '\0') ! 6886: printf("/%s", name); ! 6887: else ! 6888: printf("/%*s", DIRSIZ, name); ! 6889: } ! 6890: ! 6891: fsize_t ! 6892: pinfo(inum) ! 6893: ino_t inum; ! 6894: { ! 6895: register struct dinode *dip; ! 6896: register struct passwd *pwd; ! 6897: ! 6898: if ( (dip=ptrino(inum, buf2)) == NULL ) { ! 6899: printf("i-number = %u is in a bad inode block.\n", inum); ! 6900: return(0); ! 6901: } ! 6902: ! 6903: printf("i-number = %u, ", inum); ! 6904: if ( (pwd=getpwuid(dip->di_uid)) != NULL ) ! 6905: printf("Owner=%s, ", pwd->pw_name); ! 6906: else ! 6907: printf("Owner=%u, ", dip->di_uid); ! 6908: printf(" Mode=0%o\n", dip->di_mode); ! 6909: printf("Size=%U, Mtime=%s", dip->di_size, ctime(&dip->di_mtime)); ! 6910: return(dip->di_size); ! 6911: } ! 6912: ! 6913: char *remove = "(Remove)"; ! 6914: ! 6915: irange(inum, name) ! 6916: ino_t inum; ! 6917: char *name; ! 6918: { ! 6919: printf("I-number is out of range I=%u\n", inum); ! 6920: pname(name); ! 6921: return(action(remove)); ! 6922: } ! 6923: ! 6924: unalloc(inum, name) ! 6925: ino_t inum; ! 6926: char *name; ! 6927: { ! 6928: fsize_t size; ! 6929: ! 6930: printf("Unallocated\n"); ! 6931: size = pinfo(inum); ! 6932: pname(name); ! 6933: if ( (daction != NO) && (size == 0) && (mounted == FALSE) ) { ! 6934: printf("%s [Forced - Yes]\n", remove); ! 6935: return(YES); ! 6936: } ! 6937: return(action(remove)); ! 6938: } ! 6939: ! 6940: baddup(inum, name) ! 6941: ino_t inum; ! 6942: char *name; ! 6943: { ! 6944: register int mode = flags(inum)&MODEMASK; ! 6945: ! 6946: printf("Bad or Dup blocks in %s\n",(mode==IDIR) ? "Directory" : "File"); ! 6947: pinfo(inum); ! 6948: pname(name); ! 6949: return(action(remove)); ! 6950: } ! 6951: ! 6952: checkpath(ino) ! 6953: register ino_t ino; ! 6954: { ! 6955: static daddr_t addrs[NADDR]; ! 6956: static struct dinode *dip; ! 6957: static list *temp; ! 6958: register list *ptr; ! 6959: ! 6960: if ( (flags(ino)&VISITED)==VISITED ) { ! 6961: circle(ino); ! 6962: return; ! 6963: } else ! 6964: orflags(ino, VISITED); ! 6965: ! 6966: dip = ptrino(ino, databuf); ! 6967: l3tol(addrs, dip->di_addr, NADDR); ! 6968: ! 6969: if ( (dip->di_mode&IFMT) != IFDIR ) ! 6970: fatal("Tried to checkpath i-node %u which is not dir.\n", ino); ! 6971: ! 6972: ptr = procfiles(addrs, dip->di_size); ! 6973: ! 6974: while (ptr->d_entry.d_ino) { ! 6975: if (depth >= MAXDEPTH) ! 6976: toolong(); ! 6977: path[depth++] = &ptr->d_entry; ! 6978: checkpath(ptr->d_entry.d_ino); ! 6979: depth--; ! 6980: temp = ptr; ! 6981: ptr = ptr->next; ! 6982: free(temp); ! 6983: } ! 6984: free(ptr); ! 6985: } ! 6986: ! 6987: circle(ino) ! 6988: ino_t ino; ! 6989: { ! 6990: printf("I-node %u is a multiply referenced directory i-node.\n", ino); ! 6991: } ! 6992: ! 6993: toolong() ! 6994: { ! 6995: printf("Name too long.\n"); ! 6996: pname("\0"); ! 6997: abort(); ! 6998: } ! 6999: ! 7000: ! 7001: i_mode&IFMT) != IFDIR ) ! 7002: fatal("Tried to checkpath i-node %u which is not dir.\n", ino); ! 7003: ! 7004: ptr = procfiles(addrs, dip->di_size); ! 7005: ! 7006: while (ptr->d_entry.d_ino) { ! 7007: if (depth >= MAXDEPTH) ! 7008: toolong(); ! 7009: path[depth++] = &ptr->d_entry; ! 7010: checkpath(ptr->d_entry.d_ino); ! 7011: depth--; ! 7012: temp = ptr; ! 7013: ptr = ptr->next; ! 7014: free(temp); ! 7015: } ! 7016: free(ptr); ! 7017: } ! 7018: ! 7019: circle(ino) ! 7020: ino_t ino; ! 7021: { ! 7022: printf("I-node %u is a multiply referenced directory i-node.\n", ino); ! 7023: } ! 7024: ! 7025: toolong() ! 7026: { ! 7027: printf("fsck/phase3.c 644 3 3 12066 5050254732 6317 /* ! 7028: * phase 3 of fsck - Check Connectivity ! 7029: */ ! 7030: ! 7031: #include "fsck.h" ! 7032: ! 7033: char *lostname = "lost+found"; ! 7034: ! 7035: phase3() ! 7036: { ! 7037: ino_t i; ! 7038: ! 7039: if (!qflag) ! 7040: printf("Phase 3 : Check Connectivity\n"); ! 7041: for (i=FIRSTIN; i<=ninodes; i++) ! 7042: if ( ((flags(i)&MODEMASK) == IDIR) && ! 7043: (linkctr(i) == 0) ) { ! 7044: orflags(i, UNREFDIR); ! 7045: markchildren(i); ! 7046: } ! 7047: ! 7048: for (i=FIRSTIN; i<ninodes; i++) ! 7049: if ( (flags(i)&(UNREFDIR|CHILDDIR)) == UNREFDIR ) ! 7050: unrefdir(i); ! 7051: } ! 7052: ! 7053: markchildren(ino) ! 7054: ino_t ino; ! 7055: { ! 7056: struct dinode *dip; ! 7057: struct direct *element; ! 7058: daddr_t addrs[NADDR]; ! 7059: ino_t inumber; ! 7060: fsize_t length; ! 7061: ! 7062: if ( badblks(ino) ) ! 7063: return; ! 7064: dip = ptrino(ino, databuf); ! 7065: if ( (length=dip->di_size) <= 0 ) ! 7066: return; ! 7067: l3tol(addrs, dip->di_addr, NADDR); ! 7068: cdbn = 0; ! 7069: nextblock(addrs); ! 7070: element = (struct direct *) databuf; ! 7071: element += 2; /* skip over . and .. entries */ ! 7072: if ( (length-=2*DSIZE) <= 0 ) ! 7073: return; ! 7074: ! 7075: while ( length >= DSIZE ) { ! 7076: while ( (element<&databuf[BSIZE]) && (length>=DSIZE) ) { ! 7077: if ( ((inumber=element->d_ino) != 0) && ! 7078: ((flags(inumber)&MODEMASK)==IDIR) && ! 7079: (inumber!=ino) ) ! 7080: orflags(inumber, CHILDDIR); ! 7081: element++; ! 7082: length -= DSIZE; ! 7083: } ! 7084: nextblock(addrs); ! 7085: element = (struct direct *) databuf; ! 7086: } ! 7087: } ! 7088: ! 7089: char *reconnect = "(Reconnect)"; ! 7090: ! 7091: unrefdir(ino) ! 7092: ino_t ino; ! 7093: { ! 7094: printf("Unref Dir\n"); ! 7095: if( (pinfo(ino) == 0) || (daction == NO) || (mounted == TRUE) ) { ! 7096: if ( action(reconnect) == FALSE ) ! 7097: return; ! 7098: } else ! 7099: printf("%s FORCED\n", reconnect); ! 7100: ! 7101: connect(ino, IDIR); ! 7102: } ! 7103: ! 7104: #define CONNECT 1 ! 7105: #define NOCONNECT 0 ! 7106: ! 7107: connect(ino, type) ! 7108: ino_t ino; ! 7109: int type; ! 7110: { ! 7111: ino_t lostino; ! 7112: struct dinode *dip; ! 7113: daddr_t addrs[NADDR]; ! 7114: fsize_t length; ! 7115: struct direct *element; ! 7116: int chgino = FALSE; ! 7117: ! 7118: if ( ((lostino=lostfound()) == NUL) || ! 7119: ((flags(lostino)&MODEMASK) != IDIR) || ! 7120: ( badblks(lostino) ) ) { ! 7121: nolost(); ! 7122: if (type==IDIR) ! 7123: traverse(NOCONNECT, ino, lostino); ! 7124: return(FAILURE); ! 7125: } ! 7126: ! 7127: dip = ptrino(lostino, buf2); ! 7128: l3tol(addrs, dip->di_addr, NADDR); ! 7129: length = dip->di_size; ! 7130: cdbn = 0; ! 7131: while ( length>=DSIZE ) { ! 7132: nextblock(addrs); ! 7133: element = (struct direct *) databuf; ! 7134: while ( element<&databuf[BSIZE] ) { ! 7135: length -= DSIZE; ! 7136: if ( element->d_ino == 0 ) { ! 7137: element->d_ino = ino; ! 7138: strncpy(element->d_name, nameit(ino), DIRSIZ); ! 7139: if ( fixblock(addrs) == NUL ) ! 7140: fixblkerr(); ! 7141: linkincr(ino); ! 7142: numfiles++; ! 7143: if ( length<0 ) { ! 7144: dip->di_size -= length; ! 7145: chgino = TRUE; ! 7146: } ! 7147: if ( (type == IDIR) && ! 7148: (connected(ino, lostino)==YES) ) { ! 7149: dip->di_nlink++; ! 7150: writeino(lostino, buf2); ! 7151: traverse(CONNECT, ino, lostino); ! 7152: } else if (chgino) { ! 7153: writeino(lostino, buf2); ! 7154: } ! 7155: return(SUCCESS); ! 7156: } ! 7157: element++; ! 7158: } ! 7159: } ! 7160: ! 7161: noroom(); ! 7162: if (type == IDIR) ! 7163: traverse(NOCONNECT, ino, lostino); ! 7164: return(FAILURE); ! 7165: } ! 7166: ! 7167: traverse(flag, ino, lostino) ! 7168: int flag; ! 7169: ino_t ino, lostino; ! 7170: { ! 7171: struct direct dirlost, nothing, newtree; ! 7172: ! 7173: dirinit(&dirlost, lostino, lostname); ! 7174: dirinit(¬hing, 0, "??"); ! 7175: dirinit(&newtree, ino, nameit(ino)); ! 7176: depth = 0; ! 7177: if (flag == CONNECT) ! 7178: path[depth++] = &dirlost; ! 7179: else ! 7180: path[depth++] = ¬hing; ! 7181: ! 7182: path[depth++] = &newtree; ! 7183: checkpath(ino); ! 7184: } ! 7185: ! 7186: dirinit(element, ino, name) ! 7187: struct direct *element; ! 7188: ino_t ino; ! 7189: char *name; ! 7190: { ! 7191: element->d_ino = ino; ! 7192: strncpy(element->d_name, name, DIRSIZ); ! 7193: } ! 7194: ! 7195: connected(ino, lostino) ! 7196: ino_t ino; /* inumber just reconnected */ ! 7197: ino_t lostino; /* inumber of lostfound directory */ ! 7198: { ! 7199: struct dinode *dip; ! 7200: daddr_t addrs[NADDR]; ! 7201: fsize_t length; ! 7202: struct direct *element; ! 7203: ! 7204: if ( badblks(ino) ) { ! 7205: badconnect(ino); ! 7206: return(NO); ! 7207: } ! 7208: dip = ptrino(ino, databuf); ! 7209: l3tol(addrs, dip->di_addr, NADDR); ! 7210: length = dip->di_size; ! 7211: cdbn = 0; ! 7212: while ( length >= DSIZE ) { ! 7213: nextblock(addrs); ! 7214: element = (struct direct *) databuf; ! 7215: while ( (element<&databuf[BSIZE]) && (length>=DSIZE) ) { ! 7216: if ( strcmp(element->d_name, "..") == 0 ) { ! 7217: printf("Dir i-number = %u connected. ", ino); ! 7218: printf("Parent was i-number = %u.\n", ! 7219: element->d_ino); ! 7220: element->d_ino = lostino; ! 7221: if ( fixblock(addrs) == NUL ) ! 7222: fixblkerr(); ! 7223: return(YES); ! 7224: } ! 7225: length -= DSIZE; ! 7226: element++; ! 7227: } ! 7228: } ! 7229: noparent(ino); ! 7230: return(NO); ! 7231: } ! 7232: ! 7233: badconnect(ino) ! 7234: ino_t ino; ! 7235: { ! 7236: printf("Dir i-number = %u connected. It has bad/dup blocks.\n", ino); ! 7237: } ! 7238: ! 7239: noparent(ino) ! 7240: ino_t ino; ! 7241: { ! 7242: printf("Dir i-number = %u connected. It has no .. entry.\n", ino); ! 7243: } ! 7244: ! 7245: ino_t ! 7246: lostfound() ! 7247: { ! 7248: static daddr_t addrs[NADDR]; ! 7249: struct dinode *dip; ! 7250: struct direct *element; ! 7251: fsize_t length; ! 7252: ! 7253: dip = ptrino(ROOTIN, databuf); ! 7254: l3tol(addrs, dip->di_addr, NADDR); ! 7255: length = dip->di_size; ! 7256: cdbn = 0; ! 7257: while ( length>=DSIZE ) { ! 7258: nextblock(addrs); ! 7259: element = (struct direct *) databuf; ! 7260: while ( (element<&databuf[BSIZE]) && (length>=DSIZE) ) { ! 7261: if ( strcmp(element->d_name, lostname) == 0 ) ! 7262: return(element->d_ino); ! 7263: length -= DSIZE; ! 7264: element++; ! 7265: } ! 7266: } ! 7267: ! 7268: return(NUL); ! 7269: } ! 7270: ! 7271: nolost() ! 7272: { ! 7273: printf("Sorry. No %s directory.\n", lostname); ! 7274: ! 7275: } ! 7276: ! 7277: noroom() ! 7278: { ! 7279: printf("Sorry. No space in %s directory.\n", lostname); ! 7280: } ! 7281: ! 7282: char namebuf[DIRSIZ]; ! 7283: ! 7284: char * ! 7285: nameit(ino) ! 7286: register ino_t ino; ! 7287: { ! 7288: register int i = DIRSIZ-1; ! 7289: ! 7290: namebuf[i] = '\0'; ! 7291: while ( (ino != 0) && (i>0) ) { ! 7292: namebuf[--i] = '0' + ino%10; ! 7293: ino = ino/10; ! 7294: } ! 7295: return(&namebuf[i]); ! 7296: } ! 7297: length>=DSIZE) ) { ! 7298: if ( strcmp(element->d_name, lostname) == 0 ) ! 7299: return(element->d_ino); ! 7300: length -= DSIZE; ! 7301: element++; ! 7302: } ! 7303: } ! 7304: ! 7305: return(NUL); ! 7306: } ! 7307: ! 7308: nolost() ! 7309: { ! 7310: printf("Sorry. No %s directory.\n", lostname); ! 7311: ! 7312: } ! 7313: ! 7314: noroom() ! 7315: { ! 7316: printf("Sorry. No space in %s directory.\n", lostname); ! 7317: } ! 7318: ! 7319: char namebuf[DIRSIZ]; ! 7320: ! 7321: char * ! 7322: nameit(ino) ! 7323: register ino_t ino; ! 7324: { ! 7325: register int i = DIRSIZ-1; ! 7326: ! 7327: namebuf[i] = '\0'; ! 7328: while ( (ino != 0) && (i>0) ) { ! 7329: namebuf[--i] = '0'fsck/phase4.c 644 3 3 10602 4767744166 6335 /* ! 7330: * phase 4 of fsck - Check Reference Counts ! 7331: */ ! 7332: ! 7333: #include "fsck.h" ! 7334: ! 7335: extern char *reconnect; ! 7336: fsize_t lostsize; ! 7337: ! 7338: phase4() ! 7339: { ! 7340: ino_t i; ! 7341: short actlink; ! 7342: ! 7343: if (!qflag) ! 7344: printf("Phase 4 : Check Reference Counts\n"); ! 7345: for (i=FIRSTIN; i<=ninodes; i++) { ! 7346: if ( badblks(i) ) ! 7347: if ( bddp(i) == YES ) ! 7348: continue; /* inode zeroed */ ! 7349: ! 7350: if ( (linkctr(i) == 0) && ! 7351: ((flags(i)&MODEMASK) != IDIR) && ! 7352: ((flags(i)&ALLOCMASK) != UNALLOC) ) ! 7353: if ( unreflink(i) == YES ) ! 7354: continue; /* inode zeroed */ ! 7355: ! 7356: if ( (linkctr(i) == 0) && ! 7357: ((flags(i)&ALLOCMASK) != UNALLOC) ) ! 7358: if ( unrefclr(i) == YES ) ! 7359: continue; /* inode zeroed */ ! 7360: ! 7361: if ( (actlink=getlink(i)) == (-1) ) { ! 7362: i += INOPB-1; ! 7363: continue; /* bad inode block */ ! 7364: } ! 7365: ! 7366: if ( actlink != linkctr(i) ) ! 7367: linkprob(i, actlink); /* fix link count */ ! 7368: } ! 7369: ! 7370: freeilist(); ! 7371: } ! 7372: ! 7373: short ! 7374: getlink(inum) ! 7375: register ino_t inum; ! 7376: { ! 7377: register unsigned offset; ! 7378: static ibuf[BSIZE]; ! 7379: register struct dinode *dip; ! 7380: register daddr_t bn; ! 7381: ! 7382: offset = iblocko(inum); ! 7383: if ( (offset==0) || (inum==FIRSTIN) ) { ! 7384: bn = iblockn(inum); ! 7385: if ( (testblock(bn)) && (inum!=FIRSTIN) ) ! 7386: return(-1); ! 7387: bread(bn, ibuf); ! 7388: } ! 7389: dip = ((struct dinode *) ibuf) + offset; ! 7390: candino(dip); ! 7391: return(dip->di_nlink); ! 7392: } ! 7393: ! 7394: char *clearit = "(Clear i-node)"; ! 7395: ! 7396: unreflink(ino) ! 7397: ino_t ino; ! 7398: { ! 7399: fsize_t size; ! 7400: ! 7401: if ( (qflag == TRUE) && ((flags(ino)&MODEMASK) == IPIPE) ) { ! 7402: doclear(ino); ! 7403: return(YES); ! 7404: } ! 7405: ! 7406: printf("Unref %s\n", typename(ino)); ! 7407: size = pinfo(ino); ! 7408: if ( (daction != NO) && (size == 0) && (mounted == FALSE) ! 7409: && ((flags(ino)&MODEMASK) == IREG) ) { ! 7410: printf("%s [Forced - Yes]\n", clearit); ! 7411: doclear(ino); ! 7412: return(YES); ! 7413: } ! 7414: if ( action(reconnect) == TRUE ) ! 7415: if( connect(ino, IREG) == FAILURE ) /* connect back in the */ ! 7416: return(askclear(ino)); /* non dir inode */ ! 7417: ! 7418: return(NO); ! 7419: } ! 7420: ! 7421: askclear(ino) ! 7422: ino_t ino; ! 7423: { ! 7424: if ( action(clearit) == TRUE ) { ! 7425: doclear(ino); ! 7426: return(YES); ! 7427: } ! 7428: return(NO); ! 7429: } ! 7430: ! 7431: doclear(ino) ! 7432: ino_t ino; ! 7433: { ! 7434: struct dinode *dip; ! 7435: ! 7436: dip = ptrino(ino, databuf); ! 7437: zeroinode(dip); ! 7438: writeino(ino, databuf); ! 7439: setflags(ino, UNALLOC); ! 7440: setlinkctr(ino, 0); ! 7441: } ! 7442: ! 7443: char *adjust = "(Adjust)"; ! 7444: ! 7445: linkprob(ino, actlink) ! 7446: ino_t ino; ! 7447: short actlink; ! 7448: { ! 7449: printf("Link Count discrepancy in %s\n", typename(ino)); ! 7450: pinfo(ino); ! 7451: printf("Count = %u, should be %u ", actlink, linkctr(ino)); ! 7452: if ( action(adjust) == TRUE ) ! 7453: chglink(ino); ! 7454: } ! 7455: ! 7456: chglink(ino) ! 7457: ino_t ino; ! 7458: { ! 7459: struct dinode *dip; ! 7460: ! 7461: dip = ptrino(ino, databuf); ! 7462: dip->di_nlink = linkctr(ino); ! 7463: writeino(ino, databuf); ! 7464: } ! 7465: ! 7466: unrefclr(ino) ! 7467: ino_t ino; ! 7468: { ! 7469: printf("Unref %s\n", typename(ino)); ! 7470: pinfo(ino); ! 7471: return(askclear(ino)); ! 7472: } ! 7473: ! 7474: bddp(ino) ! 7475: ino_t ino; ! 7476: { ! 7477: printf("Bad/Dup blocks in %s\n", typename(ino)); ! 7478: pinfo(ino); ! 7479: return(askclear(ino)); ! 7480: } ! 7481: ! 7482: char *fixit = "(FIX)"; ! 7483: ! 7484: freeilist() ! 7485: { ! 7486: ino_t i, count=0; ! 7487: daddr_t bn; ! 7488: ! 7489: for (i=FIRSTIN; i<=ninodes; i++) ! 7490: if ( (flags(i)&ALLOCMASK) == UNALLOC ) ! 7491: count++; ! 7492: ! 7493: for (bn=INODEI+1; bn<isize; bn++) /* block # INODEI can't */ ! 7494: if ( testblock(bn) ) /* be bad since ROOTIN */ ! 7495: count -= INOPB; /* is in it, otherwise */ ! 7496: /* big time bad news. */ ! 7497: if ( sbp->s_tinode != count ) ! 7498: if ( (qflag==FALSE) && (daction!=NO) ) { ! 7499: printf("Free i-node count wrong in superblock. "); ! 7500: if ( action(fixit) == TRUE ) { ! 7501: sbp->s_tinode = count; ! 7502: sbpfix = TRUE; ! 7503: } ! 7504: } else { ! 7505: sbp->s_tinode = count; ! 7506: sbpfix = TRUE; ! 7507: } ! 7508: ! 7509: if ( (daction!=NO) && ! 7510: ( (sflag==TRUE) || (sbpfix==TRUE) || (badilist()==BAD) ) ) ! 7511: rebuild(); ! 7512: ! 7513: } ! 7514: ! 7515: badilist() ! 7516: { ! 7517: ino_t i, inum; ! 7518: unsigned numfree; ! 7519: daddr_t bn; ! 7520: ! 7521: if ( (numfree=(unsigned) sbp->s_ninode) > NICINOD ) ! 7522: return(BAD); ! 7523: for (i=0; i<numfree; i++) { ! 7524: inum = sbp->s_inode[i]; ! 7525: bn = iblockn(inum); ! 7526: if ( (testblock(bn)) && (bn!=INODEI) ) ! 7527: return(BAD); ! 7528: if ( (inum < FIRSTIN) || (inum > ninodes) ) ! 7529: return(BAD); ! 7530: if ( (flags(inum)&ALLOCMASK) != UNALLOC ) ! 7531: return(BAD); ! 7532: if ( flags(inum)&IFREELIST ) ! 7533: return(BAD); /* dup in ifree list */ ! 7534: orflags(inum, IFREELIST); ! 7535: } ! 7536: return(GOOD); ! 7537: } ! 7538: ! 7539: rebuild() ! 7540: { ! 7541: daddr_t bn; ! 7542: ino_t i; ! 7543: int index; ! 7544: ! 7545: sbpfix = TRUE; ! 7546: for (i=FIRSTIN, index=0; (i<=ninodes) && (index<NICINOD); i++) { ! 7547: if ( (flags(i)&ALLOCMASK) == UNALLOC ) { ! 7548: bn = iblockn(i); ! 7549: if ( (!testblock(bn)) || (bn==INODEI) ) ! 7550: index++; ! 7551: } ! 7552: } ! 7553: sbp->s_ninode = index; ! 7554: for (i=FIRSTIN; (i<=ninodes) && (index>0); i++) { ! 7555: if ( (flags(i)&ALLOCMASK) == UNALLOC ) { ! 7556: bn = iblockn(i); ! 7557: if ( (!testblock(bn)) || (bn==INODEI) ) ! 7558: sbp->s_inode[--index] = i; ! 7559: } ! 7560: } ! 7561: printf("Free i-node list in superblock rebuilt.\n"); ! 7562: } ! 7563: t bn; ! 7564: ino_t i; ! 7565: int index; ! 7566: ! 7567: sbpfix = TRUE; ! 7568: for (i=FIRSTIN, index=0; (i<=ninodes) && (index<NICINOD); i++) { ! 7569: if ( (flags(ifsck/phase5.c 644 3 3 6203 4767744635 6321 /* ! 7570: * phase 5 of fsck - Check Free List ! 7571: */ ! 7572: ! 7573: #include "fsck.h" ! 7574: ! 7575: daddr_t badcnt; /* Number of bad blocks in free list */ ! 7576: daddr_t dupcnt; /* Number of dup blocks in free list */ ! 7577: int badflag; /* Bad free list flag */ ! 7578: int fixerup; /* Flag to salvage free list */ ! 7579: ! 7580: phase5() ! 7581: { ! 7582: struct fblk *fbp; ! 7583: unsigned size; ! 7584: ! 7585: if (!qflag) ! 7586: printf("Phase 5 : Check Free List\n"); ! 7587: fbp = (struct fblk *) &sbp->s_nfree; ! 7588: size = (unsigned) ((fsize+NBPC-1)/NBPC) * sizeof(char); ! 7589: copyV(size); ! 7590: badcnt = dupcnt = 0; ! 7591: badflag = FALSE; ! 7592: freetrav(fbp); ! 7593: fixerup = FALSE; ! 7594: if (badflag || sflag) ! 7595: asksalvage(); ! 7596: } ! 7597: ! 7598: ! 7599: #define IGNORE 3 /* Return Possibilities from chk() */ ! 7600: #define ABORT 4 /* as well as perhaps GOOD and BAD */ ! 7601: ! 7602: freetrav(fbp) ! 7603: struct fblk *fbp; ! 7604: { ! 7605: daddr_t total=0; ! 7606: int i, flag; ! 7607: ! 7608: while ( fbp->df_nfree != 0 ) { ! 7609: if ( (unsigned) fbp->df_nfree > NICFREE ) { ! 7610: badflag = TRUE; ! 7611: printf("Bad freeblock count.\n"); ! 7612: break; ! 7613: } ! 7614: for (i=1; i<fbp->df_nfree; i++) { ! 7615: if ( (flag=chk(fbp->df_free[i])) == GOOD ) { ! 7616: total++; ! 7617: continue; ! 7618: } ! 7619: if (flag == BAD) ! 7620: continue; ! 7621: break; /* break for IGNORE or ABORT */ ! 7622: } ! 7623: if ( (flag == IGNORE) || (flag == ABORT) ) ! 7624: break; ! 7625: if ( chk(fbp->df_free[0]) != GOOD ) ! 7626: break; ! 7627: total++; ! 7628: bread(fbp->df_free[0], databuf); ! 7629: fbp = (struct fblk *) databuf; ! 7630: if ( !canfblk(fbp) ) { ! 7631: badflag = TRUE; ! 7632: printf("Bad freeblock count.\n"); ! 7633: break; ! 7634: } ! 7635: } ! 7636: ! 7637: #if 0 ! 7638: printf("Total traversed free blocks = %U\n", total); ! 7639: printf("Total free blocks by Superblock = %U\n", sbp->s_tfree); ! 7640: printf("Running total free blocks = %U\n", totfree); ! 7641: #endif ! 7642: ! 7643: if ( flag == ABORT ) { /* To Terminate fsck on this */ ! 7644: badflag = FALSE; /* File System, because of */ ! 7645: return; /* excessive dup or bad blocks */ ! 7646: } ! 7647: ! 7648: if ( sbp->s_tfree != totfree ) ! 7649: if ( (qflag==FALSE) && (daction!=NO) ) { ! 7650: printf("Free Block count wrong in superblock. "); ! 7651: if ( action(fixit) == TRUE ) { ! 7652: sbp->s_tfree = totfree; ! 7653: sbpfix = TRUE; ! 7654: } ! 7655: } else { ! 7656: sbp->s_tfree = totfree; ! 7657: sbpfix = TRUE; ! 7658: } ! 7659: ! 7660: report("%U Bad Block%s in Free List\n", badcnt); ! 7661: report("%U Dup Block%s in Free List\n", dupcnt); ! 7662: report("%U Block%s missing\n", totfree - total); ! 7663: ! 7664: } ! 7665: ! 7666: report(message, num) ! 7667: char *message; ! 7668: daddr_t num; ! 7669: { ! 7670: if ( num != 0 ) { ! 7671: printf(message, num, ( (num>1) ? "s" : "" ) ); ! 7672: badflag = TRUE; ! 7673: } ! 7674: } ! 7675: ! 7676: chk(bn) ! 7677: register daddr_t bn; ! 7678: { ! 7679: if ( (bn<isize) || (bn>=fsize) ) { ! 7680: badflag = TRUE; ! 7681: if (++badcnt > MAXBADFREE) ! 7682: return( stopit("bad") ); ! 7683: return(BAD); ! 7684: } ! 7685: ! 7686: if ( testdup(bn) ) { ! 7687: badflag = TRUE; ! 7688: if (++dupcnt > MAXDUPFREE) ! 7689: return( stopit("dup") ); ! 7690: return(BAD); ! 7691: } else { ! 7692: markdup(bn); ! 7693: return(GOOD); ! 7694: } ! 7695: } ! 7696: ! 7697: stopit(type) ! 7698: char *type; ! 7699: { ! 7700: printf("Excessive %s blocks in free list ", type); ! 7701: if ( query("(Continue)") == YES ) ! 7702: return(IGNORE); ! 7703: else ! 7704: return(ABORT); ! 7705: } ! 7706: ! 7707: ! 7708: canfblk(fbp) ! 7709: register struct fblk *fbp; ! 7710: { ! 7711: register short i; ! 7712: ! 7713: canshort(fbp->df_nfree); ! 7714: if ( (unsigned) fbp->df_nfree > NICFREE ) ! 7715: return(FALSE); ! 7716: ! 7717: for (i=0; i<fbp->df_nfree; i++) ! 7718: candaddr(fbp->df_free[i]); ! 7719: return(TRUE); ! 7720: } ! 7721: ! 7722: asksalvage() ! 7723: { ! 7724: if ( (daction!=NO) && (qflag || sflag) ) { ! 7725: fixerup = TRUE; ! 7726: return; ! 7727: } ! 7728: if ( action("Bad Free List (SALVAGE)") ) ! 7729: fixerup = TRUE; ! 7730: } ! 7731: tf("Excessive %s blocks in free list ", type); ! 7732: if ( query("(Continue)") == YES ) ! 7733: return(IGNORE); ! 7734: else ! 7735: return(ABORT); ! 7736: } ! 7737: ! 7738: ! 7739: canfblk(fbp) ! 7740: register struct fblk *fbp; ! 7741: { ! 7742: register short i; ! 7743: ! 7744: canshort(fbp->df_nfree); ! 7745: if ( (unsigned) fbp->df_nfree > NICFREE ) ! 7746: return(FALSE); ! 7747: ! 7748: for (i=0; i<fbp->df_nfree; i++) ! 7749: candaddr(fbp->df_free[i]); ! 7750: return(TRUE); ! 7751: } ! 7752: ! 7753: asksalvage() ! 7754: { ! 7755: if ( fsck/phase6.c 644 3 3 4752 4767014240 6307 /* ! 7756: * phase 6 of fsck - Salvage Free List ! 7757: */ ! 7758: ! 7759: #include "fsck.h" ! 7760: ! 7761: static unsigned char *maptab; /* table of interleave offsets */ ! 7762: static daddr_t mapbot; /* minimum block number to interleave map */ ! 7763: static daddr_t maptop; /* maximum block number to interleave map */ ! 7764: static short m,n; /* interleave factors */ ! 7765: #define DEF_N 1 /* default values */ ! 7766: #define DEF_M 1 ! 7767: daddr_t freeblks; /* number free blocks left to write out */ ! 7768: daddr_t blknm; /* current block number we are working with */ ! 7769: struct fblk *fblkp; /* pointer to free block list */ ! 7770: daddr_t *dp; /* pointer to block entry in free list block */ ! 7771: ! 7772: phase6() ! 7773: { ! 7774: if (!fixerup) { ! 7775: return; ! 7776: } ! 7777: ! 7778: if (!qflag) ! 7779: printf("Phase 6 : Salvage Free List\n"); ! 7780: if ( maketable() == BAD ) ! 7781: return; ! 7782: writefree(); ! 7783: free(maptab); ! 7784: } ! 7785: ! 7786: maketable() ! 7787: { ! 7788: register int i; ! 7789: register int ratio; ! 7790: ! 7791: m = sbp->s_m; ! 7792: n = sbp->s_n; ! 7793: ! 7794: if ( (n > MAXINTN) || (m > n) || (n%m != 0) ) { ! 7795: printf("Invalid interleave factors in superblock.\n"); ! 7796: printf("Default free-block list spacing assumed.\n"); ! 7797: sbp->s_n = n = DEF_N; ! 7798: sbp->s_m = m = DEF_M; ! 7799: } ! 7800: ! 7801: if ( (maptab = malloc(n)) == NULL ) { ! 7802: printf("Can't malloc space for interleave table.\n"); ! 7803: printf("Free-block list is not rebuilt.\n"); ! 7804: return(BAD); ! 7805: } ! 7806: ! 7807: mapbot = (isize + n - 1)/n*n; ! 7808: maptop = fsize/n*n; ! 7809: ratio = n/m; ! 7810: for (i=0; i<n; i++) ! 7811: maptab[i] = (i/ratio) + (i%ratio)*m; ! 7812: ! 7813: return(GOOD); ! 7814: } ! 7815: ! 7816: writefree() ! 7817: { ! 7818: register daddr_t bn; ! 7819: daddr_t blk, bmap(); ! 7820: short num; ! 7821: ! 7822: sbpfix = TRUE; ! 7823: freeblks = totfree; ! 7824: blknm = SUPERI; ! 7825: fblkp = (struct fblk *) &sbp->s_nfree; ! 7826: fblkp->df_nfree = num = (freeblks < NICFREE) ? freeblks : NICFREE; ! 7827: freeblks -= num; ! 7828: dp = &fblkp->df_free[num]; ! 7829: for (bn=isize; bn<fsize; bn++) { ! 7830: blk = bmap(bn); ! 7831: if ( !testblock(blk) ) ! 7832: if ( addfree(blk) == STOP ) ! 7833: break; ! 7834: } ! 7835: } ! 7836: ! 7837: addfree(bn) ! 7838: daddr_t bn; ! 7839: { ! 7840: short num; ! 7841: ! 7842: *--dp = bn; ! 7843: if (dp > &fblkp->df_free[0]) ! 7844: return(OK); ! 7845: ! 7846: if ( blknm != SUPERI ) { ! 7847: canwfblk(fblkp); ! 7848: bwrite(blknm, databuf); ! 7849: } ! 7850: ! 7851: bclear(databuf, BSIZE); ! 7852: if (freeblks == 0) { ! 7853: bwrite(bn, databuf); ! 7854: return(STOP); ! 7855: } ! 7856: blknm = bn; ! 7857: fblkp = (struct fblk *) databuf; ! 7858: fblkp->df_nfree = num = (freeblks < NICFREE) ? freeblks : NICFREE; ! 7859: freeblks -= num; ! 7860: dp = &fblkp->df_free[num]; ! 7861: return(OK); ! 7862: } ! 7863: ! 7864: daddr_t ! 7865: bmap(blk) ! 7866: register daddr_t blk; ! 7867: { ! 7868: short i; ! 7869: ! 7870: if ( (blk>=mapbot) && (blk<maptop) ) { ! 7871: i = blk%n; ! 7872: blk -= i; ! 7873: blk += maptab[i]; ! 7874: } ! 7875: return(blk); ! 7876: } ! 7877: ! 7878: canwfblk(fbp) ! 7879: register struct fblk *fbp; ! 7880: { ! 7881: register short i; ! 7882: ! 7883: for (i=0; i<fbp->df_nfree; i++) ! 7884: candaddr(fbp->df_free[i]); ! 7885: canshort(fbp->df_nfree); ! 7886: } ! 7887: uf); ! 7888: return(STOP); ! 7889: fsck/printf.c 644 3 3 7271 4664524124 6425 /* ! 7890: * Standard output printf using putchar. ! 7891: * Non-portable things: ! 7892: * 1) alignment of arguments is assumed to be completely contiguous. ! 7893: * 2) the smallest number is assumed to negate to itself. ! 7894: * 3) All of long, int, char*, and double are assumed to ! 7895: * be held in an exact number of ints. ! 7896: */ ! 7897: ! 7898: #define NULL ((char *)0) ! 7899: #define putchar(c) { char b = c; write(1, &b, 1); } ! 7900: #include <sys/mdata.h> ! 7901: ! 7902: union alltypes { ! 7903: char c; ! 7904: int i; ! 7905: unsigned u; ! 7906: long l; ! 7907: double d; ! 7908: char *s; ! 7909: }; ! 7910: ! 7911: #define bump(p,s) (p+=sizeof(s)/sizeof(int)) ! 7912: ! 7913: char *printi(); ! 7914: char *printl(); ! 7915: ! 7916: static char null[] = "{NULL}"; ! 7917: ! 7918: printf(args) ! 7919: union alltypes args; ! 7920: { ! 7921: xprintf(&args); ! 7922: } ! 7923: xprintf(argp) ! 7924: union alltypes *argp; ! 7925: { ! 7926: register char *cbp; ! 7927: int *iap; ! 7928: register c; ! 7929: char *s; ! 7930: char *cbs; ! 7931: char adj, pad; ! 7932: int prec; ! 7933: int fwidth; ! 7934: int pwidth; ! 7935: register char *fmt; ! 7936: union alltypes elem; ! 7937: char cbuf[64]; ! 7938: ! 7939: iap = (int *)argp; ! 7940: fmt = *(char **)iap; ! 7941: bump(iap, char*); ! 7942: for (;;) { ! 7943: while((c = *fmt++) != '%') { ! 7944: if(c == '\0') { ! 7945: return; ! 7946: } ! 7947: putchar(c); ! 7948: } ! 7949: pad = ' '; ! 7950: fwidth = -1; ! 7951: prec = -1; ! 7952: c = *fmt++; ! 7953: if (c == '-') { ! 7954: adj = 1; ! 7955: c = *fmt++; ! 7956: } else ! 7957: adj = 0; ! 7958: if (c == '0') { ! 7959: pad = '0'; ! 7960: c = *fmt++; ! 7961: } ! 7962: if (c == '*') { ! 7963: fwidth = *iap++; ! 7964: c = *fmt++; ! 7965: } else ! 7966: for (fwidth = 0; c>='0' && c<='9'; c = *fmt++) ! 7967: fwidth = fwidth*10 + c-'0'; ! 7968: if (c == '.') { ! 7969: c = *fmt++; ! 7970: if (c == '*') { ! 7971: prec = *iap++; ! 7972: c = *fmt++; ! 7973: } else ! 7974: for (prec=0; c>='0' && c<='9'; c=*fmt++) ! 7975: prec = prec*10 + c-'0'; ! 7976: } ! 7977: if (c == 'l') { ! 7978: c = *fmt++; ! 7979: if (c=='d' || c=='o' || c=='u' || c=='x') ! 7980: c += 'A' - 'a'; ! 7981: } ! 7982: cbp = cbs = cbuf; ! 7983: switch (c) { ! 7984: ! 7985: case 'd': ! 7986: elem.i = *iap++; ! 7987: if (elem.i < 0) { ! 7988: elem.i = -elem.i; ! 7989: *cbp++ = '-'; ! 7990: } ! 7991: cbp = printi(cbp, elem.i, 10); ! 7992: break; ! 7993: ! 7994: case 'u': ! 7995: cbp = printi(cbp, *iap++, 10); ! 7996: break; ! 7997: ! 7998: case 'o': ! 7999: cbp = printi(cbp, *iap++, 8); ! 8000: break; ! 8001: ! 8002: case 'x': ! 8003: cbp = printi(cbp, *iap++, 16); ! 8004: break; ! 8005: ! 8006: case 'D': ! 8007: elem.l = *(long *)iap; ! 8008: bump(iap, long); ! 8009: if (elem.l < 0) { ! 8010: elem.l = -elem.l; ! 8011: *cbp++ = '-'; ! 8012: } ! 8013: cbp = printl(cbp, elem.l, 10); ! 8014: break; ! 8015: ! 8016: case 'U': ! 8017: cbp = printl(cbp, *(long *)iap, 10); ! 8018: bump(iap, long); ! 8019: break; ! 8020: ! 8021: case 'O': ! 8022: cbp = printl(cbp, *(long *)iap, 8); ! 8023: bump(iap, long); ! 8024: break; ! 8025: ! 8026: case 'X': ! 8027: cbp = printl(cbp, *(long *)iap, 16); ! 8028: bump(iap, long); ! 8029: break; ! 8030: ! 8031: ! 8032: case 's': ! 8033: if ((s = *(char **)iap) == NULL) ! 8034: s = null; ! 8035: bump(iap, char*); ! 8036: /* ! 8037: * Do %s specially so it can be longer. ! 8038: */ ! 8039: cbp = cbs = s; ! 8040: while (*cbp++ != '\0') ! 8041: if (prec>=0 && cbp-s>prec) ! 8042: break; ! 8043: cbp--; ! 8044: break; ! 8045: ! 8046: case 'c': ! 8047: elem.c = *iap++; ! 8048: *cbp++ = elem.c; ! 8049: break; ! 8050: ! 8051: case 'r': ! 8052: xprintf(*(char ***)iap); ! 8053: bump(iap, char**); ! 8054: break; ! 8055: ! 8056: default: ! 8057: putchar(c); ! 8058: continue; ! 8059: } ! 8060: if ((pwidth = fwidth + cbs-cbp) < 0) ! 8061: pwidth = 0; ! 8062: if (!adj) ! 8063: while (pwidth-- != 0) ! 8064: putchar(pad); ! 8065: while (cbs < cbp) ! 8066: putchar(*cbs++); ! 8067: if (adj) ! 8068: while (pwidth-- != 0) ! 8069: putchar(pad); ! 8070: } ! 8071: } ! 8072: ! 8073: static char digits[] = { ! 8074: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ! 8075: 'A', 'B', 'C', 'D', 'E', 'F' ! 8076: }; ! 8077: ! 8078: /* ! 8079: * Print an unsigned integer in base b. ! 8080: */ ! 8081: static ! 8082: char * ! 8083: printi(cp, n, b) ! 8084: char *cp; ! 8085: register unsigned n; ! 8086: { ! 8087: register a; ! 8088: register char *ep; ! 8089: char pbuf[10]; ! 8090: ! 8091: ep = &pbuf[10]; ! 8092: *--ep = 0; ! 8093: for ( ; a = n/b; n=a) ! 8094: *--ep = digits[n%b]; ! 8095: *--ep = digits[n]; ! 8096: while (*ep) ! 8097: *cp++ = *ep++; ! 8098: return (cp); ! 8099: } ! 8100: ! 8101: /* ! 8102: * Print an unsigned long in base b. ! 8103: */ ! 8104: static ! 8105: char * ! 8106: printl(cp, n, b) ! 8107: register char *cp; ! 8108: unsigned long n; ! 8109: register b; ! 8110: { ! 8111: char pbuf[13]; ! 8112: unsigned long a; ! 8113: register char *ep; ! 8114: ! 8115: ep = &pbuf[13]; ! 8116: *--ep = '\0'; ! 8117: for ( ; (a = n/b) != 0; n = a) ! 8118: *--ep = digits[n%b]; ! 8119: *--ep = digits[n]; ! 8120: while (*ep) ! 8121: *cp++ = *ep++; ! 8122: return (cp); ! 8123: } ! 8124: register char *ep; ! 8125: char pbuf[10]; ! 8126: ! 8127: ep = &pbuf[10]; ! 8128: *--ep = 0; ! 8129: for ( ; a = n/b; n=a) ! 8130: *--ep = digits[n%b]; ! 8131: *--ep = digits[n]; ! 8132: while (*ep) ! 8133: *cp++ = *ep++; ! 8134: return (cp); ! 8135: } ! 8136: ! 8137: /* ! 8138: * Print an unsigned long in base b. ! 8139: */ ! 8140: static ! 8141: char * ! 8142: printl(cp, n, b) ! 8143: register char *cp; ! 8144: unsigned long n; ! 8145: register b; ! 8146: { ! 8147: char pbuf[13]; ! 8148: unsignfsck/util.c 644 3 3 15535 5033710270 6110 /* ! 8149: * general utility functions for phases of fsck ! 8150: */ ! 8151: ! 8152: #include "fsck.h" ! 8153: ! 8154: struct stat stats; /* Used by statit() */ ! 8155: ! 8156: statit(name, probfun) ! 8157: char *name; ! 8158: int (*probfun)(); ! 8159: { ! 8160: ! 8161: if ( stat(name, &stats) == -1 ) { ! 8162: bclear(&stats, sizeof(struct stat)); ! 8163: (*probfun)("Can not stat %s", name); ! 8164: } ! 8165: } ! 8166: ! 8167: ! 8168: query(x) ! 8169: { ! 8170: while(1) { ! 8171: printf("%r [yes/no]: ", &x); ! 8172: ! 8173: switch (daction) { ! 8174: case YES: ! 8175: printf("[default - YES]\n"); ! 8176: return(YES); ! 8177: break; ! 8178: case NO: ! 8179: printf("[default - NO]\n"); ! 8180: return(NO); ! 8181: break; ! 8182: case ASK: ! 8183: switch( nextchar() ) { ! 8184: case 'Y': ! 8185: return(YES); ! 8186: case 'N': ! 8187: return(NO); ! 8188: } ! 8189: } ! 8190: } ! 8191: } ! 8192: ! 8193: action(msg) ! 8194: char *msg; ! 8195: { ! 8196: switch( query(msg) ) { ! 8197: case YES: ! 8198: return(TRUE); ! 8199: case NO: ! 8200: return(FALSE); ! 8201: } ! 8202: } ! 8203: ! 8204: char ! 8205: nextchar() ! 8206: { ! 8207: char buff[8]; ! 8208: int i, n, ch; ! 8209: ! 8210: if ( ((n=read(0,buff,8)) <= 0) || (n == 8) ) ! 8211: fatal("Invalid Response"); ! 8212: ! 8213: for(i=0; i<n; i++) ! 8214: if ( ((ch=buff[i])!=' ') && (ch!='\t') ) ! 8215: break; ! 8216: ! 8217: if ( (ch>='a') && (ch<='z') ) ! 8218: ch += 'A' - 'a'; ! 8219: ! 8220: return(ch); ! 8221: } ! 8222: ! 8223: char *nfile = "FILE"; ! 8224: char *ndir = "DIR"; ! 8225: char *nchr = "Character Special"; ! 8226: char *nblk = "Block Special"; ! 8227: char *npipe = "PIPE"; ! 8228: char *nunkwn = "Unknown I-node type"; ! 8229: ! 8230: char * ! 8231: typename(ino) ! 8232: ino_t ino; ! 8233: { ! 8234: switch( flags(ino)&MODEMASK ) { ! 8235: case IREG: ! 8236: return(nfile); ! 8237: case IDIR: ! 8238: return(ndir); ! 8239: case ICHR: ! 8240: return(nchr); ! 8241: case IBLK: ! 8242: return(nblk); ! 8243: case IPIPE: ! 8244: return(npipe); ! 8245: default: ! 8246: return(nunkwn); ! 8247: } ! 8248: } ! 8249: ! 8250: abort() ! 8251: { ! 8252: fatal("abort."); ! 8253: } ! 8254: ! 8255: fatal(x) ! 8256: { ! 8257: printf("fsck: %r\n", &x); ! 8258: _exit(1); ! 8259: } ! 8260: ! 8261: nonfatal(x) ! 8262: { ! 8263: printf("fsck: %r\n", &x); ! 8264: errflag = TRUE; ! 8265: } ! 8266: ! 8267: /* ! 8268: * Inode Manipulation Routines ! 8269: * ptrino: returns a pointer to the wanted inode using the given ! 8270: * buffer to read in the block performing canonicalization. ! 8271: * writeino: writes the block containing the given inode to the ! 8272: * disk performing the necessary canonicalization ! 8273: * candino: canonicalize an inode ! 8274: * ! 8275: */ ! 8276: ! 8277: struct dinode * ! 8278: ptrino(ino, buf) ! 8279: register ino_t ino; ! 8280: register char *buf; ! 8281: { ! 8282: register daddr_t bn; ! 8283: register struct dinode *dip; ! 8284: ! 8285: bn = iblockn(ino); ! 8286: if ( (testblock(bn)) && (bn!=INODEI) ) /* bad inode block */ ! 8287: return(NULL); ! 8288: bread(bn, buf); ! 8289: dip = ((struct dinode *) buf) + iblocko(ino); ! 8290: candino(dip); ! 8291: return(dip); ! 8292: } ! 8293: ! 8294: writeino(ino, buf) ! 8295: ino_t ino; ! 8296: char *buf; ! 8297: { ! 8298: struct dinode *dip; ! 8299: ! 8300: dip = ((struct dinode *) buf) + iblocko(ino); ! 8301: candino(dip); ! 8302: bwrite((daddr_t) iblockn(ino), buf); ! 8303: } ! 8304: ! 8305: candino(dip) ! 8306: register struct dinode *dip; ! 8307: { ! 8308: canshort(dip->di_mode); ! 8309: canshort(dip->di_nlink); ! 8310: canshort(dip->di_uid); ! 8311: canshort(dip->di_gid); ! 8312: cansize(dip->di_size); ! 8313: cantime(dip->di_atime); ! 8314: cantime(dip->di_mtime); ! 8315: cantime(dip->di_ctime); ! 8316: } ! 8317: ! 8318: /* ! 8319: * Transfer a logical block number for an inode to a ! 8320: * physical block number, chasing indirects as necessary. ! 8321: * The inefficiency of this method is put up with since ! 8322: * this is only used for directory inodes, and they tend ! 8323: * not to use indirects. Pass in 'addrs' which is a pointer ! 8324: * to the 13 daddr_s in the inode, and the logical block ! 8325: * number you would like. (Stolen from dcheck.c) ! 8326: */ ! 8327: ! 8328: static daddr_t ranges[] = { ! 8329: ND, ! 8330: ND + (daddr_t)NI*NBN, ! 8331: ND + (daddr_t)NI*NBN + (daddr_t)NII*NBN*NBN, ! 8332: ND + (daddr_t)NI*NBN + (daddr_t)NII*NBN*NBN + (daddr_t)NIII*NBN*NBN*NBN ! 8333: }; ! 8334: ! 8335: static char index[] = { ! 8336: 0, ! 8337: ND, ! 8338: ND+NI, ! 8339: ND+NI+NII ! 8340: }; ! 8341: ! 8342: static daddr_t coeff[] = { ! 8343: 1, (daddr_t)NBN, (daddr_t)NBN*NBN, (daddr_t)NBN*NBN*NBN ! 8344: }; ! 8345: ! 8346: daddr_t ! 8347: imap(addrs, block) ! 8348: daddr_t *addrs; ! 8349: register daddr_t block; ! 8350: { ! 8351: int i; ! 8352: register daddr_t bpos; ! 8353: register daddr_t *bp; ! 8354: register daddr_t bn; ! 8355: ! 8356: for (i=0; i<4; i++) ! 8357: if (block < ranges[i]) { ! 8358: if (i != 0) ! 8359: block -= ranges[i-1]; ! 8360: bpos = block/coeff[i]; ! 8361: block %= coeff[i]; ! 8362: bp = &addrs[(int)bpos + index[i]]; ! 8363: if ( (bn=*bp) != 0 ) { ! 8364: /* ! 8365: * Map through indirects here ! 8366: */ ! 8367: while (i-- > 0) { ! 8368: bread(bn, databuf); ! 8369: bpos = block/coeff[i]; ! 8370: block %= coeff[i]; ! 8371: bp = (daddr_t *)databuf + bpos; ! 8372: if ( (bn=*bp) == 0 ) ! 8373: break; ! 8374: bn = *bp; ! 8375: candaddr(bn); ! 8376: } ! 8377: } ! 8378: return(bn); ! 8379: } ! 8380: return(0); ! 8381: } ! 8382: ! 8383: /* ! 8384: * Read the specified block number into the given buffer ! 8385: */ ! 8386: ! 8387: char *rgblkerr = "Out of Range Block number: %U (CONTINUE)"; ! 8388: char *skblkerr = "Can not Seek: Blk num: %U (CONTINUE)"; ! 8389: char *rdblkerr = "Can not Read: Blk num: %U (CONTINUE)"; ! 8390: char *wtblkerr = "Can not Write: Blk num: %U (CONTINUE)"; ! 8391: ! 8392: bread(bn, buf) ! 8393: register daddr_t bn; ! 8394: register char *buf; ! 8395: { ! 8396: #ifdef DEBUG ! 8397: printf("Reading block number: %ld\n", bn); ! 8398: #endif ! 8399: if (bn<0 || bn >= fsize ) ! 8400: switch( query(rgblkerr, bn) ) { ! 8401: case YES: ! 8402: bclear(buf, BSIZE); ! 8403: return; ! 8404: case NO: ! 8405: abort(); ! 8406: } ! 8407: ! 8408: if ( (bn<isize) && getcache(bn, buf) ) { ! 8409: #if DEBUG ! 8410: bdump(buf); ! 8411: #endif ! 8412: return; ! 8413: } ! 8414: ! 8415: if ( lseek(fsfd, (unsigned long)bn*BSIZE, 0) == (-1L) ) ! 8416: switch( query(skblkerr, bn) ) { ! 8417: case YES: ! 8418: bclear(buf, BSIZE); ! 8419: return; ! 8420: case NO: ! 8421: abort(); ! 8422: } ! 8423: ! 8424: if ( read(fsfd, buf, BSIZE) != BSIZE ) ! 8425: switch( query(rdblkerr, bn) ) { ! 8426: case YES: ! 8427: bclear(buf, BSIZE); ! 8428: return; ! 8429: case NO: ! 8430: abort(); ! 8431: } ! 8432: #if DEBUG ! 8433: bdump(buf); ! 8434: #endif ! 8435: } ! 8436: ! 8437: /* ! 8438: * Write block number bn with data in buf ! 8439: */ ! 8440: ! 8441: bwrite(bn, buf) ! 8442: daddr_t bn; ! 8443: char *buf; ! 8444: { ! 8445: #ifdef DEBUG ! 8446: printf("Writing block number: %ld\n", bn); ! 8447: #endif ! 8448: if (!writeflg) ! 8449: return; ! 8450: ! 8451: if (bn<0 || bn>=fsize) ! 8452: switch( query(rgblkerr, bn) ) { ! 8453: case YES: ! 8454: return; ! 8455: case NO: ! 8456: abort(); ! 8457: } ! 8458: ! 8459: if ( lseek(fsfd, (fsize_t)BSIZE*bn, 0) == (-1L) ) ! 8460: switch( query(skblkerr, bn) ) { ! 8461: case YES: ! 8462: return; ! 8463: case NO: ! 8464: abort(); ! 8465: } ! 8466: ! 8467: if ( write(fsfd, buf, BSIZE) != BSIZE ) ! 8468: switch( query(wtblkerr, bn) ) { ! 8469: case YES: ! 8470: return; ! 8471: case NO: ! 8472: abort(); ! 8473: } ! 8474: ! 8475: if ( bn <= isize ) ! 8476: chgcache(bn, buf); ! 8477: changeflg = TRUE; ! 8478: } ! 8479: ! 8480: /* ! 8481: * i-node block area caching routines ! 8482: */ ! 8483: ! 8484: static char cache[NBLK * BSIZE]; ! 8485: static int low = 0; high = -1; ! 8486: ! 8487: getcache(bn, buf) ! 8488: register daddr_t bn; ! 8489: register char *buf; ! 8490: { ! 8491: int totsize; ! 8492: ! 8493: if ( bn > isize ) ! 8494: return(0); ! 8495: ! 8496: if ( (bn>=low) && (bn<=high) ) { ! 8497: blkmove(buf, &cache[BSIZE * (bn-low)]); ! 8498: return(1); ! 8499: } ! 8500: ! 8501: low = bn; ! 8502: if ( (high=bn+NBLK-1) > isize ) ! 8503: high = isize; ! 8504: totsize = BSIZE * (high-low+1); ! 8505: ! 8506: if ( (lseek(fsfd, (unsigned long)bn*BSIZE, 0) == (-1L)) || ! 8507: (read(fsfd, cache, totsize) != totsize) ) { ! 8508: low = 0; high = -1; ! 8509: return(0); ! 8510: } ! 8511: ! 8512: return( getcache(bn, buf) ); ! 8513: } ! 8514: ! 8515: chgcache(bn, buf) ! 8516: register daddr_t bn; ! 8517: register char *buf; ! 8518: { ! 8519: if ( (bn>=low) && (bn<=high) ) ! 8520: blkmove(&cache[BSIZE * (bn-low)], buf); ! 8521: } ! 8522: ! 8523: blkmove(to, from) ! 8524: register char *to, *from; ! 8525: { ! 8526: register int num=BSIZE; ! 8527: ! 8528: while ( num-- ) ! 8529: *to++= *from++; ! 8530: } ! 8531: ! 8532: /* ! 8533: * Clear the given block of memory ! 8534: */ ! 8535: ! 8536: bclear(bp, nb) ! 8537: register char *bp; ! 8538: register unsigned nb; ! 8539: { ! 8540: if (nb) ! 8541: do { ! 8542: *bp++ = 0; ! 8543: } while (--nb); ! 8544: } ! 8545: ! 8546: ! 8547: /* ! 8548: * Determine if the given block is bad ! 8549: */ ! 8550: ! 8551: bad(bn) ! 8552: daddr_t bn; ! 8553: { ! 8554: if ( (bn >= isize) && (bn < fsize) ) ! 8555: return(GOOD); ! 8556: else ! 8557: return(BAD); ! 8558: } ! 8559: ! 8560: ! 8561: #if DEBUG ! 8562: ! 8563: /* ! 8564: * Debug dump a block of data. ! 8565: */ ! 8566: ! 8567: #define NUMPLIN 16 ! 8568: ! 8569: bdump(buf) ! 8570: register unsigned char *buf; ! 8571: { ! 8572: register int i; ! 8573: ! 8574: for (i=0; i<BSIZE; i++) { ! 8575: if ( (i % NUMPLIN) == 0 ) ! 8576: printf("\n0x%04x: ", i); ! 8577: printf(" %02x", *buf++); ! 8578: } ! 8579: printf("\n\n"); ! 8580: } ! 8581: ! 8582: #endif ! 8583: ister char *bp; ! 8584: register unsigned nb; ! 8585: { ! 8586: if (nb) ! 8587: do { ! 8588: *bp++ = 0; ! 8589: } while (--nb); ! 8590: } ! 8591: ! 8592: ! 8593: /* ! 8594: * Determine if the given block is bad ! 8595: */ ! 8596: ! 8597: bad(bn) ! 8598: daddr_t bn; ! 8599: { ! 8600: ifsck/virtual.c 644 3 3 16227 4767016247 6640 /* ! 8601: * Virtual memory for fsck. Uses hash algorithm ! 8602: * rather than LRU to get it up fast. ! 8603: */ ! 8604: #include <assert.h> ! 8605: #include <sys/stat.h> ! 8606: #include "fsck.h" ! 8607: ! 8608: #define VBLKB 9 /* bytes in virtual block as power of 2 */ ! 8609: #define VBLK (1 << VBLKB) /* bytes in a virtual block */ ! 8610: #define MBKSB 6 /* number of virtual blocks as power of 2 */ ! 8611: #define MBKS (1 << MBKSB) /* number of virtual blocks */ ! 8612: ! 8613: #define DVTMP "/dev/rram1" /* Default Virtual Temp Filename */ ! 8614: #define DVTMPCLS "/dev/rram1close" /* Default Virtual Temp File Close */ ! 8615: #define MAJORRAM 8 /* Major Device Number for the Ram Disk */ ! 8616: ! 8617: struct mapper { ! 8618: unsigned dirty:1; ! 8619: unsigned what_in:15; /* which block is in memory */ ! 8620: }; ! 8621: ! 8622: static unsigned long flagdsp, blkdsp, dupdsp, duplim; ! 8623: static struct mapper map[MBKS]; ! 8624: static unsigned char data[MBKS][VBLK]; ! 8625: static int tmp; ! 8626: ! 8627: static char *dvtmp = DVTMP; ! 8628: static char *dvtmpcls = DVTMPCLS; ! 8629: ! 8630: /* ! 8631: * Init file system for virtual arrays. ! 8632: * Data is ordered links, flags, blocks then dups. ! 8633: */ ! 8634: initV(links, flags, blocks, dups) ! 8635: unsigned links, flags, blocks, dups; ! 8636: { ! 8637: register long bp; ! 8638: struct stat st; ! 8639: unsigned datasiz; ! 8640: ! 8641: flagdsp = links; ! 8642: blkdsp = flagdsp + flags; ! 8643: dupdsp = blkdsp + blocks; ! 8644: duplim = dupdsp + dups; ! 8645: ! 8646: memset(map, 0, sizeof(map)); /* zero ram arrays */ ! 8647: memset(data, 0, sizeof(data)); ! 8648: ! 8649: tmp = -1; ! 8650: ! 8651: datasiz = sizeof(data); ! 8652: if ( duplim < datasiz ) ! 8653: return; ! 8654: ! 8655: if ( tmpfile == NULL ) { ! 8656: switch ( is_fs(dvtmp) ) { ! 8657: case -1: ! 8658: fatal( ! 8659: "Can't access ram disk \"%s\", use the -t option", dvtmp); ! 8660: case 0: ! 8661: break; ! 8662: case 1: ! 8663: fatal( ! 8664: "Possible file system on ram disk \"%s\", use the -t option", dvtmp); ! 8665: } ! 8666: if ( (-1 == stat(dvtmp, &st)) || !(st.st_mode&S_IFCHR) || ! 8667: (major(st.st_rdev) != MAJORRAM) ) ! 8668: fatal("Ram disk \"%s\" not mknod'ed properly", ! 8669: dvtmp); ! 8670: if ( -1 == (tmp = open(dvtmp, 2)) ) ! 8671: fatal("Cannot open read/write Ram Disk \"%s\"", dvtmp); ! 8672: ! 8673: /* Ram disk driver may not promise zeroed start. ! 8674: * This code may go later. Extra write not important. */ ! 8675: for(bp = 0; bp < duplim; bp += VBLK) /* zero disk stuff */ ! 8676: if ( VBLK != write(tmp, data[0], VBLK) ) ! 8677: fatal("Error writing to tmp file"); ! 8678: } else { ! 8679: if ( -1 == (tmp = open(tmpfile, 2)) ) { ! 8680: if ( -1 == (tmp = creat(tmpfile, 0600)) ) ! 8681: fatal("Cannot create temp file \"%s\"", ! 8682: tmpfile); ! 8683: close(tmp); ! 8684: tmp = open(tmpfile, 2); ! 8685: unlink(tmpfile); ! 8686: } ! 8687: if ( -1 == fstat(tmp, &st) ) ! 8688: fatal("Can't stat temp file \"%s\"", tmpfile); ! 8689: if ( st.st_dev == fsysrdev ) ! 8690: fatal("Temp File must not be on file system to fsck"); ! 8691: } ! 8692: } ! 8693: ! 8694: /* ! 8695: * cleanup virtual system ! 8696: */ ! 8697: cleanV() ! 8698: { ! 8699: struct stat st; ! 8700: ! 8701: if ( tmp == -1 ) /* No Virtual Temp File Opened */ ! 8702: return; ! 8703: ! 8704: close(tmp); ! 8705: if ( tmpfile != NULL ) /* Virtual File not Default RAMDisk */ ! 8706: return; ! 8707: /* Virtual File is Default RAMDisk */ ! 8708: if ( (-1 == stat(dvtmpcls, &st)) || !(st.st_mode&S_IFCHR) || ! 8709: (major(st.st_rdev) != MAJORRAM) || ! 8710: ((minor(st.st_rdev)&0x7F) != 0) ) ! 8711: fatal("Ram disk close \"%s\" not mknod'ed properly", dvtmpcls); ! 8712: if ( -1 == (tmp = open(dvtmpcls, 2)) ) ! 8713: fatal("Cannot open Ram Disk Close \"%s\"", dvtmpcls); ! 8714: if ( close(tmp) < 0 ) ! 8715: fatal("Cannot close Ram Disk Close \"%s\"", dvtmpcls); ! 8716: } ! 8717: ! 8718: /* ! 8719: * All actions for virtual array ! 8720: */ ! 8721: findblock(bp, action, odata) ! 8722: long bp; /* data address */ ! 8723: enum vact action; /* what to do */ ! 8724: unsigned odata; /* optional data */ ! 8725: { ! 8726: unsigned which, what_in, byte_no, bit; ! 8727: unsigned long diskad; ! 8728: unsigned char *byte; ! 8729: extern long lseek(); ! 8730: ! 8731: switch(action) { /* use displacment to correct part of file */ ! 8732: case testBlock: ! 8733: case markBlock: ! 8734: case unmarkBlock: ! 8735: bit = 1 << (bp & 7); ! 8736: bp >>= 3; ! 8737: case grabBlock: /* 8 at a time for copy */ ! 8738: assert(bp >= 0); ! 8739: bp += blkdsp; ! 8740: assert(bp < dupdsp); ! 8741: break; ! 8742: case testDup: ! 8743: case markDup: ! 8744: case unmarkDup: ! 8745: bit = 1 << (bp & 7); ! 8746: bp >>= 3; ! 8747: case setDup: /* 8 at a time for copy */ ! 8748: assert(bp >= 0); ! 8749: bp += dupdsp; ! 8750: assert(bp < duplim); ! 8751: break; ! 8752: case Flags: ! 8753: case setFlags: ! 8754: case orFlags: ! 8755: assert(bp > 0); ! 8756: bp += flagdsp - 1; ! 8757: assert(bp < blkdsp); ! 8758: break; ! 8759: case linkCtr: ! 8760: case incLinkctr: ! 8761: case setLinkctr: ! 8762: assert(bp > 0); ! 8763: bp--; ! 8764: assert(bp < flagdsp); ! 8765: } ! 8766: ! 8767: byte_no = bp & (VBLK - 1); ! 8768: bp >>= VBLKB; ! 8769: which = bp & (MBKS - 1); ! 8770: bp >>= MBKSB; ! 8771: what_in = bp & 0x7fff; ! 8772: ! 8773: if((diskad = map[which].what_in) != what_in) { ! 8774: if(map[which].dirty) { ! 8775: diskad <<= VBLKB + MBKSB; ! 8776: diskad += which << VBLKB; ! 8777: if(-1 == lseek(tmp, diskad, 0)) ! 8778: fatal("Error seeking tmp file"); ! 8779: if(VBLK != write(tmp, data[which], VBLK)) ! 8780: fatal("Error writing tmp file"); ! 8781: } ! 8782: diskad = what_in; ! 8783: diskad <<= VBLKB + MBKSB; ! 8784: diskad += which << VBLKB; ! 8785: if(-1 == lseek(tmp, diskad, 0)) ! 8786: fatal("Error seeking tmp file"); ! 8787: if(VBLK != read(tmp, data[which], VBLK)) ! 8788: memset(data[which], 0, VBLK); ! 8789: map[which].what_in = what_in; ! 8790: map[which].dirty = 0; /* clean */ ! 8791: } ! 8792: byte = &data[which][byte_no]; ! 8793: ! 8794: switch(action) { ! 8795: case testBlock: ! 8796: case testDup: ! 8797: return(*byte & bit); ! 8798: case markBlock: ! 8799: case markDup: ! 8800: map[which].dirty = 1; ! 8801: return(*byte |= bit); ! 8802: case unmarkBlock: ! 8803: case unmarkDup: ! 8804: map[which].dirty = 1; ! 8805: return(*byte ^= bit); ! 8806: case linkCtr: ! 8807: case Flags: ! 8808: case grabBlock: ! 8809: return(*byte); ! 8810: case setLinkctr: ! 8811: case setFlags: ! 8812: case setDup: ! 8813: map[which].dirty = 1; ! 8814: return(*byte = odata); ! 8815: case orFlags: ! 8816: map[which].dirty = 1; ! 8817: return(*byte |= odata); ! 8818: case incLinkctr: ! 8819: map[which].dirty = 1; ! 8820: return(++*byte); ! 8821: default: ! 8822: fatal("Bad action in virtual system"); ! 8823: } ! 8824: } ! 8825: ! 8826: /* ! 8827: * copy virtual memory blockmap to dupmap ! 8828: * read and write groups to avoid possable thrashing. ! 8829: */ ! 8830: void ! 8831: copyV(size) ! 8832: unsigned size; ! 8833: { ! 8834: char buf[128]; ! 8835: register int i; ! 8836: long bp, bs; ! 8837: ! 8838: for(bs = bp = 0; bp < size; ) { ! 8839: for(i = 0; (i < 128) && (bp < size); i++, bp++) ! 8840: buf[i] = findblock(bp, grabBlock); ! 8841: ! 8842: for(i = 0; (i < 128) && (bs < size); i++, bs++) ! 8843: findblock(bs, setDup, buf[i]); ! 8844: } ! 8845: } ! 8846: ! 8847: #ifdef TEST ! 8848: fatal(s) ! 8849: char *s; ! 8850: { ! 8851: fprintf(stderr, "%s\n", s); ! 8852: exit(1); ! 8853: } ! 8854: ! 8855: static char buf[80]; ! 8856: gbuf() ! 8857: { ! 8858: if(NULL == gets(buf)) { ! 8859: unlink("vtmp"); ! 8860: exit(0); ! 8861: } ! 8862: return(buf[0]); ! 8863: } ! 8864: ! 8865: main() ! 8866: { ! 8867: unsigned long b; ! 8868: char data; ! 8869: ! 8870: initV(10000, 10000, 20000); ! 8871: for(;;) { ! 8872: printf("b = block, d = dup, f = flags, l = linkctr\n"); ! 8873: switch(gbuf()) { ! 8874: case 'l': ! 8875: printf("s = set, d = display, i = increment: then loc\n"); ! 8876: gbuf(); ! 8877: sscanf(buf + 2, "%ld", &b); ! 8878: switch(buf[0]) { ! 8879: case 's': ! 8880: setlinkctr(b, 0); /* no data */ ! 8881: case 'd': ! 8882: printf("%d\n", linkctr(b)); ! 8883: break; ! 8884: case 'i': ! 8885: printf("%d\n", inclinkctr(b)); ! 8886: } ! 8887: break; ! 8888: case 'f': ! 8889: printf("d = display, s = set, o = or: then loc\n"); ! 8890: gbuf(); ! 8891: sscanf(buf + 2, "%ld %c", &b, &data); ! 8892: switch(buf[0]) { ! 8893: case 's': ! 8894: setflags(b, data); ! 8895: case 'd': ! 8896: break; ! 8897: case 'o': ! 8898: orflags(b, data); ! 8899: } ! 8900: printf("%c\n", flags(b)); ! 8901: break; ! 8902: case 'b': ! 8903: printf("t = test, m = mark, u = unmark: then loc\n"); ! 8904: gbuf(); ! 8905: sscanf(buf + 2, "%ld", &b); ! 8906: switch(buf[0]) { ! 8907: case 'm': ! 8908: markblock(b); ! 8909: case 't': ! 8910: break; ! 8911: case 'u': ! 8912: unmarkblock(b); ! 8913: } ! 8914: printf("%c\n", testblock(b) ? '1' : '0'); ! 8915: break; ! 8916: case 'd': ! 8917: printf("t = test, m = mark, u = unmark: then loc\n"); ! 8918: gbuf(); ! 8919: sscanf(buf + 2, "%ld", &b); ! 8920: switch(buf[0]) { ! 8921: case 'm': ! 8922: markdup(b); ! 8923: case 't': ! 8924: break; ! 8925: case 'u': ! 8926: unmarkdup(b); ! 8927: } ! 8928: printf("%c\n", testdup(b) ? '1' : '0'); ! 8929: break; ! 8930: } ! 8931: } ! 8932: } ! 8933: #endif ! 8934: ! 8935: en loc\n"); ! 8936: gbuf(); ! 8937: sscanf(buf + 2, "%ld", &b); ! 8938: switch(buf[0]) { ! 8939: case 'm': ! 8940: markblock(b); ! 8941: case 't': ! 8942: break; ! 8943: case 'u': ! 8944: unmarkblock(b); ! 8945: } ! 8946: printf("%c\n", testblock(b) ? '1' : '0'); ! 8947: break; ! 8948: case 'd': ! 8949: printf("t = test, m = mark, u = unmark: then loc\n"); ! 8950: gbuf(); ! 8951: sscanf(buf + 2, "%ld", &b); ! 8952: switch(buf[0]) { ! 8953: case
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.