Return to trace.c CVS log

Up to [Research Unix] / researchv10no / cmd / adb / cray

Annotation of researchv10no/cmd/adb/cray/trace.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * ptrace goo for reading and writing
                      3:  * cray version: io is addressed by words.  careful.
                      4:  */
                      5: 
                      6: #include "defs.h"
                      7: #include "space.h"
                      8: #include "ptrace.h"
                      9: #include "machine.h"
                     10: 
                     11: #define        min(a, b)       (((a) < (b)) ? (a) : (b))
                     12: extern int errno;
                     13: 
                     14: ptri(addr, space, buf, size)
                     15: ADDR addr;
                     16: int space;
                     17: register char *buf;
                     18: int size;
                     19: {
                     20:        PTWORD w;
                     21:        register char *p, *q;
                     22:        register int n;
                     23:        register int off;
                     24:        int rf;
                     25: 
                     26:        switch (space & SPTYPE) {
                     27:        default:
                     28:        case INSTSP:
                     29:                rf = P_RDI;
                     30:                break;
                     31: 
                     32:        case DATASP:
                     33:                rf = P_RDD;
                     34:                break;
                     35: 
                     36:        case UBLKSP:
                     37:                rf = P_RDU;
                     38:                break;
                     39:        }
                     40:        for (p = buf, n = size; n > 0; n--)
                     41:                *p++ = 0;
                     42:        off = waoff(addr);
                     43:        while (size) {
                     44:                errno = 0;
                     45:                w = ptrace(rf, pid, batowa(addr), 0);
                     46:                if (errno) {
                     47:                        errflg = "process address not found";
                     48:                        return (0);
                     49:                }
                     50:                p = (char *)&w + off;
                     51:                for (n = min(size, sizeof(w) - off); n > 0; size--, n--)
                     52:                        *buf++ = *p++;
                     53:                addr += sizeof(w);
                     54:                off = 0;
                     55:        }
                     56:        return (1);
                     57: }
                     58: 
                     59: ptro(addr, space, buf, size)
                     60: ADDR addr;
                     61: int space;
                     62: register char *buf;
                     63: int size;
                     64: {
                     65:        PTWORD w;
                     66:        register char *p;
                     67:        register int n;
                     68:        register int off;
                     69:        int rf, wf;
                     70: 
                     71:        switch (space & SPTYPE) {
                     72:        default:
                     73:        case INSTSP:
                     74:                rf = P_RDI;
                     75:                wf = P_WRI;
                     76:                break;
                     77: 
                     78:        case DATASP:
                     79:                rf = P_RDD;
                     80:                wf = P_WRD;
                     81:                break;
                     82: 
                     83:        case UBLKSP:
                     84:                rf = P_RDU;
                     85:                wf = P_WRU;
                     86:                break;
                     87:        }
                     88:        off = waoff(addr);
                     89:        while (size) {
                     90:                errno = 0;
                     91:                w = ptrace(rf, pid, batowa(addr), 0);
                     92:                if (errno) {
                     93:                        errflg = "process address not found";
                     94:                        return (0);
                     95:                }
                     96:                p = (char *)&w + off;
                     97:                for (n = min(size, sizeof(w) - off); n > 0; size--, n--)
                     98:                        *p++ = *buf++;
                     99:                errno = 0;
                    100:                ptrace(wf, pid, batowa(addr), w);
                    101:                if (errno) {
                    102:                        errflg = "process address not found";
                    103:                        return (0);
                    104:                }
                    105:                addr += sizeof(w);
                    106:        }
                    107:        return (1);
                    108: }

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