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

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.