Return to trace.c CVS log

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

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

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

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