Return to access.c CVS log

Up to [Research Unix] / researchv10no / cmd / sdb

Annotation of researchv10no/cmd/sdb/access.c, revision 1.1.1.1

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

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