Return to phase1b.c CVS log

Up to [MW Coherent from dump] / coherent / d / etc / fsck

Annotation of coherent/d/etc/fsck/phase1b.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *     Phase 1b of fsck - Rescan for more Dups
                      3:  */
                      4: 
                      5: #include "fsck.h"
                      6: 
                      7: extern int     numdup;         /* declared in phase1.c */
                      8: 
                      9: phase1b()
                     10: {
                     11:        if (!qflag)
                     12:                printf("Phase 1b: Rescan for more Dups\n");
                     13:        buildtable();
                     14:        iscanb();
                     15: }
                     16: 
                     17: buildtable()
                     18: {
                     19:        unsigned cntr=0, numdiff=0;
                     20:        daddr_t bn;
                     21: 
                     22:        while (cntr<totdups) {
                     23:                bn = dupblck[cntr++];
                     24:                if (!testdup(bn)) {
                     25:                        markdup(bn);
                     26:                        numdiff++;
                     27:                }
                     28:        }
                     29:        totdups = numdiff;
                     30: }
                     31: 
                     32: iscanb()
                     33: {
                     34:        register daddr_t bn;
                     35:        register struct dinode *dip;
                     36:        register ino_t  ino;
                     37:        int i;
                     38: 
                     39:        ino = 1;
                     40: 
                     41:        for (bn=INODEI; bn<isize; bn++) {
                     42:                if (testblock(bn)) {            /* block is bad via inode 1 */
                     43:                        ino += INOPB;
                     44:                        continue;
                     45:                }
                     46:                bread(bn, databuf);
                     47:                dip = (struct dinode *) databuf;
                     48:                for (i=0; i<INOPB; i++) {
                     49:                        candino(dip);
                     50:                        if (inuse(dip) == TRUE) 
                     51:                                ckblksb(dip, ino);
                     52:                        if (totdups == 0)
                     53:                                return;                 
                     54:                        ino++;
                     55:                        dip++;
                     56:                }
                     57:        }
                     58: }
                     59: 
                     60: /*
                     61:  *     Check the blocks associated with the given inode to find the
                     62:  *     remaining duplicate blocks
                     63:  */
                     64: 
                     65: ckblksb(dip, ino)
                     66: register struct dinode *dip;
                     67: register ino_t ino;
                     68: {
                     69:        daddr_t addrs[NADDR];
                     70:        int i, lev;
                     71:        int mode;
                     72: 
                     73:        mode = dip->di_mode & IFMT;
                     74: 
                     75:        if ( (mode != IFREG) && (mode != IFDIR) )
                     76:                return;
                     77: 
                     78:        l3tol(addrs, dip->di_addr, NADDR);
                     79: 
                     80:        numdup = 0;                     /* num dup blocks so far THIS INODE */
                     81: 
                     82:        for(i=0; i<NADDR; i++)
                     83:                for (lev=0; lev<4; lev++) 
                     84:                        if (i < offsets[lev]) {
                     85:                                dblocksb(addrs[i], ino, lev);
                     86:                                break;
                     87:                        }
                     88: }
                     89: 
                     90: /*
                     91:  *     Checks recursively the blocks pointed at via
                     92:  *     the inode list of blocks.  'bn' is the block number,
                     93:  *     'ino' is the inode referencing it, and 'lev' is the
                     94:  *     level 0 == direct ... 3 = triple-indirect
                     95:  */
                     96: 
                     97: dblocksb(bn, ino, lev)
                     98: daddr_t        bn;
                     99: ino_t  ino;
                    100: int    lev;
                    101: {
                    102:        char buf[BSIZE];
                    103:        int  i;
                    104:        daddr_t *bnptr;
                    105: 
                    106:        if (bn == 0)
                    107:                return(OK);
                    108:                
                    109:        switch ( cdupb(bn, ino) ) {
                    110:        case OK:
                    111:                if (lev--==0)
                    112:                        return(OK);
                    113:                bread(bn, buf);
                    114:                bnptr = (long *) buf;
                    115:                for (i=0; i<NBN; i++) {
                    116:                        bn = bnptr[i];
                    117:                        candaddr(bn);
                    118:                        if ( dblocksb(bn, ino, lev) == STOP )
                    119:                                return(STOP);
                    120:                }
                    121:                return(OK);
                    122:        case STOP:
                    123:                return(STOP);
                    124:        }
                    125: }
                    126: 
                    127: /*
                    128:  *     Check the given block number for duplicate reference.
                    129:  */
                    130: 
                    131: cdupb(bn, ino)
                    132: daddr_t        bn;
                    133: ino_t  ino;
                    134: {
                    135:        if ( !testdup(bn) ) 
                    136:                return(OK);
                    137: 
                    138:        totdups--;
                    139:        unmarkdup(bn);
                    140:        if (!fflag)
                    141:                orflags(ino, IBAD_IDUP);
                    142:        printf("Dup Block %U, i-number = %u\n", bn, ino);
                    143: 
                    144:        return(STOP);
                    145: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.