Return to util.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / stand / vdfmt

Annotation of cci/sys/stand/vdfmt/util.c, revision 1.1

1.1     ! root        1: #include       "vdfmt.h"
        !             2: #include       "cmd.h"
        !             3: 
        !             4: /*
        !             5: */
        !             6: 
        !             7: to_track(daddr)
        !             8: dskadr daddr;
        !             9: {
        !            10:        return ((daddr.cylinder * CURRENT->ntrak) + daddr.track);
        !            11: }
        !            12: 
        !            13: 
        !            14: /*
        !            15: */
        !            16: 
        !            17: dskadr *from_track(trk)
        !            18: int    trk;
        !            19: {
        !            20:        static dskadr   temp;
        !            21: 
        !            22:        temp.cylinder = trk / CURRENT->ntrak;
        !            23:        temp.track = trk % CURRENT->ntrak;
        !            24:        temp.sector = 0;
        !            25:        return &temp;
        !            26: }
        !            27: 
        !            28: 
        !            29: /*
        !            30: */
        !            31: 
        !            32: to_sector(daddr)
        !            33: dskadr daddr;
        !            34: {
        !            35:        return ((to_track(daddr) * CURRENT->nsec) + daddr.sector);
        !            36: }
        !            37: 
        !            38: 
        !            39: /*
        !            40: */
        !            41: 
        !            42: dskadr *from_sector(sec)
        !            43: unsigned int   sec;
        !            44: {
        !            45:        static dskadr   temp;
        !            46: 
        !            47:        temp = *from_track((int)(sec / CURRENT->nsec));
        !            48:        temp.sector = sec % CURRENT->nsec;
        !            49:        return &temp;
        !            50: }
        !            51: 
        !            52: 
        !            53: /*
        !            54: **
        !            55: */
        !            56: 
        !            57: print_unix_block(dskaddr)
        !            58: dskadr dskaddr;
        !            59: {
        !            60:        char    fs;
        !            61:        int     blk;
        !            62:        int     sec_per_blk=DEV_BSIZE / CURRENT->secsize;
        !            63:                        
        !            64:        indent();
        !            65:        blk = to_sector(dskaddr) / sec_per_blk;
        !            66:        print("** Warning - Unable to relocate sector %d:\n",to_sector(dskaddr)); 
        !            67:        indent();
        !            68:        print("to map out using BADSECT use the following values:\n");
        !            69:        indent();
        !            70:        for(fs = 0; fs < 8; fs++) {
        !            71:                int     s, l;
        !            72: 
        !            73:                s = CURRENT->partition[fs].par_start;
        !            74:                l = CURRENT->partition[fs].par_len;
        !            75:                if((blk < (s+l)) && (blk >= s)) {
        !            76:                        print("On the '%c' Partition use block %d.\n",
        !            77:                            fs+'a', blk-s);
        !            78:                }
        !            79:        }
        !            80:        exdent(3);
        !            81: }
        !            82: 
        !            83: dskadr *from_unix(par, block)
        !            84: unsigned char  par;
        !            85: unsigned int   block;
        !            86: {
        !            87:        unsigned int    sector;
        !            88:        register int    fs;
        !            89:        static dskadr           dskaddr;
        !            90: 
        !            91:        fs =  tolower(par) - 'a';
        !            92:        if((fs < 8) && (block <= CURRENT->partition[fs].par_len)) {
        !            93:                sector = CURRENT->partition[fs].par_start;
        !            94:                sector += block;
        !            95:                sector *= DEV_BSIZE;
        !            96:                sector /=  CURRENT->secsize;
        !            97:                dskaddr = *from_sector(sector);
        !            98:        }
        !            99:        else {
        !           100:                dskaddr.cylinder = -1;
        !           101:                dskaddr.track = -1;
        !           102:                dskaddr.sector = -1;
        !           103:        }
        !           104:        return &dskaddr;
        !           105: }
        !           106: 
        !           107: 
        !           108: blkzero(addr, len)
        !           109: register char  *addr;
        !           110: register int   len;
        !           111: {
        !           112:        while(len--)
        !           113:                *(addr++) = (char)0;
        !           114: }
        !           115: 
        !           116: 
        !           117: blkcopy(from, to, len)
        !           118: register char  *from;
        !           119: register char  *to;
        !           120: register int   len;
        !           121: {
        !           122:        while(len--)
        !           123:                *(to++) = *(from++);
        !           124: }
        !           125: 
        !           126: 
        !           127: boolean blkcmp(a, b, len)
        !           128: register char  *a;
        !           129: register char  *b;
        !           130: register int   len;
        !           131: {
        !           132:        while(len--) {
        !           133:                if(*(a++) != *(b++))
        !           134:                        return false;
        !           135:        }
        !           136:        return true;
        !           137: }
        !           138: 

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