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     ! 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.