Return to phase6.c CVS log

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

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

1.1       root        1: /*
                      2:  *     phase 6 of fsck - Salvage Free List
                      3:  */
                      4: 
                      5: #include "fsck.h"
                      6: 
                      7: static unsigned char *maptab;  /* table of interleave offsets  */
                      8: static daddr_t mapbot;         /* minimum block number to interleave map */
                      9: static daddr_t maptop;         /* maximum block number to interleave map */
                     10: static short   m,n;            /* interleave factors   */
                     11: #define        DEF_N   1               /* default values       */
                     12: #define        DEF_M   1               
                     13: daddr_t        freeblks;               /* number free blocks left to write out */
                     14: daddr_t        blknm;                  /* current block number we are working with */
                     15: struct fblk *fblkp;            /* pointer to free block list */
                     16: daddr_t        *dp;                    /* pointer to block entry in free list block */
                     17: 
                     18: phase6()
                     19: {
                     20:        if (!fixerup) {
                     21:                return;
                     22:        }
                     23: 
                     24:        if (!qflag)
                     25:                printf("Phase 6 : Salvage Free List\n");
                     26:        if ( maketable() == BAD )
                     27:                return;
                     28:        writefree();
                     29:        free(maptab);
                     30: }
                     31: 
                     32: maketable()
                     33: {
                     34:        register int i;
                     35:        register int ratio;
                     36: 
                     37:        m = sbp->s_m;
                     38:        n = sbp->s_n;
                     39: 
                     40:        if ( (n > MAXINTN) || (m > n) || (n%m != 0) ) {
                     41:                printf("Invalid interleave factors in superblock.\n");
                     42:                printf("Default free-block list spacing assumed.\n");
                     43:                sbp->s_n = n = DEF_N;
                     44:                sbp->s_m = m = DEF_M;
                     45:        }
                     46: 
                     47:        if ( (maptab = malloc(n)) == NULL ) {
                     48:                printf("Can't malloc space for interleave table.\n");
                     49:                printf("Free-block list is not rebuilt.\n");
                     50:                return(BAD);
                     51:        }
                     52: 
                     53:        mapbot = (isize + n - 1)/n*n;
                     54:        maptop = fsize/n*n;
                     55:        ratio = n/m;
                     56:        for (i=0; i<n; i++)
                     57:                maptab[i] = (i/ratio) + (i%ratio)*m;
                     58: 
                     59:        return(GOOD);
                     60: }
                     61: 
                     62: writefree()
                     63: {
                     64:        register daddr_t bn;
                     65:        daddr_t blk, bmap();
                     66:        short num;
                     67: 
                     68:        sbpfix = TRUE;
                     69:        freeblks = totfree;
                     70:        blknm = SUPERI;
                     71:        fblkp = (struct fblk *) &sbp->s_nfree;
                     72:        fblkp->df_nfree = num = (freeblks < NICFREE) ? freeblks : NICFREE;
                     73:        freeblks -= num;
                     74:        dp = &fblkp->df_free[num];
                     75:        for (bn=isize; bn<fsize; bn++) {
                     76:                blk = bmap(bn);
                     77:                if ( !testblock(blk) ) 
                     78:                        if ( addfree(blk) == STOP )
                     79:                                break;
                     80:        }
                     81: }
                     82: 
                     83: addfree(bn)
                     84: daddr_t bn;
                     85: {
                     86:        short num;
                     87: 
                     88:        *--dp = bn;
                     89:        if (dp > &fblkp->df_free[0])
                     90:                return(OK);
                     91: 
                     92:        if ( blknm != SUPERI ) {
                     93:                canwfblk(fblkp);
                     94:                bwrite(blknm, databuf);
                     95:        }
                     96: 
                     97:        bclear(databuf, BSIZE);
                     98:        if (freeblks == 0) {
                     99:                bwrite(bn, databuf);
                    100:                return(STOP);
                    101:        }
                    102:        blknm = bn;
                    103:        fblkp = (struct fblk *) databuf;
                    104:        fblkp->df_nfree = num = (freeblks < NICFREE) ? freeblks : NICFREE;
                    105:        freeblks -= num;
                    106:        dp = &fblkp->df_free[num];
                    107:        return(OK);
                    108: }
                    109: 
                    110: daddr_t
                    111: bmap(blk)
                    112: register daddr_t blk;
                    113: {
                    114:        short i;
                    115: 
                    116:        if ( (blk>=mapbot) && (blk<maptop) ) {
                    117:                i = blk%n;
                    118:                blk -= i;
                    119:                blk += maptab[i];
                    120:        }
                    121:        return(blk);
                    122: }
                    123: 
                    124: canwfblk(fbp)
                    125: register struct fblk *fbp;
                    126: {
                    127:        register short i;
                    128: 
                    129:        for (i=0; i<fbp->df_nfree; i++)
                    130:                candaddr(fbp->df_free[i]);
                    131:        canshort(fbp->df_nfree);
                    132: }

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