Return to access.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / sdb

Annotation of 3BSD/cmd/sdb/access.c, revision 1.1.1.1

1.1       root        1: #
                      2: /*
                      3:  *
                      4:  *     UNIX debugger
                      5:  *
                      6:  */
                      7: 
                      8: #include "head.h"
                      9: struct user u;
                     10: 
                     11: 
                     12: MSG            BADDAT;
                     13: MSG            BADTXT;
                     14: MAP            txtmap;
                     15: MAP            datmap;
                     16: STRING         errflg;
                     17: int            errno;
                     18: 
                     19: INT            pid;
                     20: 
                     21: 
                     22: 
                     23: 
                     24: /* file handling and access routines */
                     25: 
                     26: int dmask[5] = {0, 0xff, 0xffff, 0xffffff, 0xffffffff};
                     27: 
                     28: /* get data at loc using descriptor format d */
                     29: long
                     30: getval(loc, d)
                     31: ADDR loc;
                     32: char d; {
                     33:        register int val;
                     34:        
                     35:        val = get(loc, DSP);
                     36:        val &= dmask[dtol(d)];
                     37:        return(val);
                     38: }
                     39: 
                     40: /* put value at loc using descriptor format d */
                     41: putval(loc, d, value)
                     42: ADDR loc; char d; long value; {
                     43:        register long val;
                     44:        
                     45:        val = get(loc, DSP);
                     46:        val = (val & !dmask[dtol(d)]) | (value & dmask[dtol(d)]);
                     47:        put(loc, DSP, val);
                     48: }
                     49: 
                     50: /* put value in named register using descriptor format d */
                     51: putreg(reg, d, value)
                     52: ADDR reg; char d; long value; {
                     53:        register long val;
                     54:        
                     55:        val = *(ADDR *)(((ADDR)&u)+R0+WORDSIZE*reg);
                     56:        val = (val & !dmask[dtol(d)]) | (value & dmask[dtol(d)]);
                     57:        *(ADDR *)(((ADDR)&u)+R0+WORDSIZE*reg) = val;
                     58: }
                     59: 
                     60: put(adr,space,value)
                     61: L_INT  adr;
                     62: {
                     63:        access(WT,adr,space,value);
                     64: }
                     65: 
                     66: POS    get(adr, space)
                     67: L_INT          adr;
                     68: {
                     69:        return(access(RD,adr,space,0));
                     70: }
                     71: 
                     72: 
                     73: access(mode,adr,space,value)
                     74: L_INT  adr;
                     75: {
                     76:        INT     pmode,rd,file;
                     77:        ADDR    w;
                     78:        rd = mode==RD;
                     79: 
                     80:        IF space == NSP THEN return(0); FI
                     81: 
                     82:        IF pid          /* tracing on? */
                     83:        THEN
                     84: #ifndef vax
                     85:                IF adr&01 ANDF !rd THEN error(ODDADR); FI
                     86: #endif
                     87:             pmode = (space&DSP?(rd?RDUSER:WDUSER):(rd?RIUSER:WIUSER));
                     88:             w = ptrace(pmode, pid, adr, value);
                     89: #ifndef vax
                     90:             IF adr&01
                     91:             THEN w1 = ptrace(pmode, pid, shorten(adr+1), value);
                     92:                  w = (w>>8)&LOBYTE | (w1<<8);
                     93:             FI
                     94: #endif
                     95:             IF errno
                     96:             THEN errflg = (space&DSP ? BADDAT : BADTXT);
                     97:             FI
                     98:             return(w);
                     99:        FI
                    100:        w = 0;
                    101:        IF !chkmap(&adr,space)
                    102:        THEN return(0);
                    103:        FI
                    104:        file=(space&DSP?datmap.ufd:txtmap.ufd);
                    105:        IF longseek(file,adr)==0 ORF
                    106:           (rd ? read(file,&w,sizeof(w)) : write(file,&value,sizeof(w))) < 1
                    107:        THEN    errflg=(space&DSP?BADDAT:BADTXT);
                    108:        FI
                    109:        return(w);
                    110: 
                    111: }
                    112: 
                    113: chkmap(adr,space)
                    114:        REG L_INT       *adr;
                    115:        REG INT         space;
                    116: {
                    117:        REG MAPPTR amap;
                    118:        amap=((space&DSP?&datmap:&txtmap));
                    119:        IF space&STAR ORF !within(*adr,amap->b1,amap->e1)
                    120:        THEN IF within(*adr,amap->b2,amap->e2)
                    121:             THEN *adr += (amap->f2)-(amap->b2);
                    122:             ELSE errflg=(space&DSP?BADDAT:BADTXT); return(0);
                    123:             FI
                    124:        ELSE *adr += (amap->f1)-(amap->b1);
                    125:        FI
                    126:        return(1);
                    127: }
                    128: 
                    129: within(adr,lbd,ubd)
                    130: POS    adr, lbd, ubd;
                    131: {
                    132:        return(adr>=lbd && adr<ubd);
                    133: }

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