Return to access.c CVS log

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

Annotation of researchv10no/cmd/adb/comm/access.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * access the files:
        !             3:  * read or write data from some address in some space
        !             4:  * -DPTRACE and provide the appropriate routines somewhere
        !             5:  * if i/o to a process doesn't look like i/o to a file (eg v7 ptrace)
        !             6:  */
        !             7: 
        !             8: #include "defs.h"
        !             9: #include "regs.h"
        !            10: #include "space.h"
        !            11: #include "map.h"
        !            12: 
        !            13: #define        min(x, y)       ((x) < (y) ? (x) : (y))
        !            14: 
        !            15: static int intrget(), intrput();
        !            16: static int memclr(), memcpy();
        !            17: 
        !            18: /*
        !            19:  * routines to get/put various types
        !            20:  */
        !            21: 
        !            22: TLONG
        !            23: lget(addr, space)
        !            24: ADDR addr;
        !            25: int space;
        !            26: {
        !            27:        TLONG x;
        !            28: 
        !            29:        if (space == NOSP)
        !            30:                return (wtol((WORD)dot));
        !            31:        if (fget(addr, space, (char *)&x, SZLONG) == 0)
        !            32:                return (0);
        !            33:        return (x);
        !            34: }
        !            35: 
        !            36: TSHORT
        !            37: sget(addr, space)
        !            38: ADDR addr;
        !            39: int space;
        !            40: {
        !            41:        TSHORT x;
        !            42: 
        !            43:        if (space == NOSP)
        !            44:                return (wtos((WORD)dot));
        !            45:        if (fget(addr, space, (char *)&x, SZSHORT) == 0)
        !            46:                return (0);
        !            47:        return (x);
        !            48: }
        !            49: 
        !            50: TCHAR
        !            51: cget(addr, space)
        !            52: ADDR addr;
        !            53: int space;
        !            54: {
        !            55:        TCHAR x;
        !            56: 
        !            57:        if (space == NOSP)
        !            58:                return (wtoc((WORD)dot));
        !            59:        if (fget(addr, space, (char *)&x, SZCHAR) == 0)
        !            60:                return (0);
        !            61:        return (x);
        !            62: }
        !            63: 
        !            64: TADDR
        !            65: aget(addr, space)
        !            66: ADDR addr;
        !            67: int space;
        !            68: {
        !            69:        TADDR x;
        !            70: 
        !            71:        if (space == NOSP)
        !            72:                return (wtoa((WORD)dot));
        !            73:        if (fget(addr, space, (char *)&x, SZADDR) == 0)
        !            74:                return (0);
        !            75:        return (x);
        !            76: }
        !            77: 
        !            78: lput(addr, space, v)
        !            79: ADDR addr;
        !            80: int space;
        !            81: TLONG v;
        !            82: {
        !            83: 
        !            84:        return (fput(addr, space, (char *)&v, SZLONG));
        !            85: }
        !            86: 
        !            87: sput(addr, space, v)
        !            88: ADDR addr;
        !            89: int space;
        !            90: TSHORT v;
        !            91: {
        !            92: 
        !            93:        return (fput(addr, space, (char *)&v, SZSHORT));
        !            94: }
        !            95: 
        !            96: cput(addr, space, v)
        !            97: ADDR addr;
        !            98: int space;
        !            99: TCHAR v;
        !           100: {
        !           101: 
        !           102:        return (fput(addr, space, (char *)&v, SZCHAR));
        !           103: }
        !           104: 
        !           105: aput(addr, space, v)
        !           106: ADDR addr;
        !           107: int space;
        !           108: TADDR v;
        !           109: {
        !           110: 
        !           111:        return (fput(addr, space, (char *)&v, SZADDR));
        !           112: }
        !           113: 
        !           114: /*
        !           115:  * the real io code
        !           116:  */
        !           117: 
        !           118: int
        !           119: fget(addr, space, buf, size)
        !           120: ADDR addr;
        !           121: register int space;
        !           122: char *buf;
        !           123: int size;
        !           124: {
        !           125:        int fd;
        !           126:        long off;
        !           127:        ADDR oa;
        !           128:        static ADDR regaddr();
        !           129:        long lseek();
        !           130: 
        !           131:        if ((space & SPTYPE) == NOSP) {
        !           132:                memclr(buf, size);
        !           133:                size = min(size, sizeof(dot)-addr);
        !           134:                memcpy(buf, (char *)&dot, min(size, sizeof(dot)));
        !           135:                return (1);
        !           136:        }
        !           137:        if (space & SYMF)
        !           138:                fd = fsym;
        !           139:        else
        !           140:                fd = fcor;
        !           141:        oa = addr;
        !           142:        if ((space & SPTYPE) == REGSP) {
        !           143:                if (space & SYMF) {
        !           144:                        errflg = "registers in corefile only";
        !           145:                        return (0);
        !           146:                }
        !           147:                if ((addr = regaddr(addr)) == 0)
        !           148:                        return (intrget(oa, buf, size));
        !           149:                space &=~ SPTYPE;
        !           150:                space |= DATASP;
        !           151:        }
        !           152:        if (reloc(addr, space, &off) == 0)
        !           153:                return (0);
        !           154: #ifdef PTRACE
        !           155:        if ((space & SYMF) == 0 && pid)
        !           156:                return (ptri(addr, space, buf, size));
        !           157: #endif
        !           158:        if (lseek(fd, off, 0) == -1
        !           159:        ||  read(fd, buf, size) != size) {
        !           160:                if ((space & SPTYPE) == INSTSP)
        !           161:                        errflg = "can't read text";
        !           162:                else
        !           163:                        errflg = "can't read data";
        !           164:                return (0);
        !           165:        }
        !           166:        return (1);
        !           167: }
        !           168: 
        !           169: int
        !           170: fput(addr, space, buf, size)
        !           171: ADDR addr;
        !           172: register int space;
        !           173: char *buf;
        !           174: int size;
        !           175: {
        !           176:        int fd;
        !           177:        long off;
        !           178:        ADDR oa;
        !           179:        static ADDR regaddr();
        !           180:        long lseek();
        !           181: 
        !           182:        if ((space & SPTYPE) == NOSP)
        !           183:                return (0);
        !           184:        if (wtflag == 0
        !           185:        &&  !((space & SYMF) == 0 && pid))
        !           186:                error("not in write mode");
        !           187:        if (space & SYMF)
        !           188:                fd = fsym;
        !           189:        else
        !           190:                fd = fcor;
        !           191:        oa = addr;
        !           192:        if ((space & SPTYPE) == REGSP) {
        !           193:                if (space & SYMF) {
        !           194:                        errflg = "registers in corefile only";
        !           195:                        return (0);
        !           196:                }
        !           197:                if ((addr = regaddr(addr)) == 0)
        !           198:                        return (intrput(oa, buf, size));
        !           199:                space &=~ SPTYPE;
        !           200:                space |= DATASP;
        !           201:        }
        !           202:        if (reloc(addr, space, &off) == 0)
        !           203:                return (0);
        !           204: #ifdef PTRACE
        !           205:        if ((space & SYMF) == 0 && pid)
        !           206:                return (ptro(addr, space, buf, size));
        !           207: #endif
        !           208:        if (lseek(fd, off, 0) == -1
        !           209:        ||  write(fd, buf, size) != size) {
        !           210:                if ((space & SPTYPE) == INSTSP)
        !           211:                        errflg = "can't write text";
        !           212:                else
        !           213:                        errflg = "can't write data";
        !           214:                return (0);
        !           215:        }
        !           216:        return (1);
        !           217: }
        !           218: 
        !           219: /*
        !           220:  * register address hacks
        !           221:  * if the register allegedly has an address (e.g. we're knee deep in
        !           222:  * stack frames), return that
        !           223:  * otherwise do fake io to our internal copies of registers
        !           224:  * awful
        !           225:  */
        !           226: 
        !           227: extern ADDR raddr[];
        !           228: extern int roffs[];
        !           229: 
        !           230: static ADDR
        !           231: regaddr(reg)
        !           232: register ADDR reg;
        !           233: {
        !           234: 
        !           235:        reg /= SZREG;
        !           236:        if (MINREG <= reg && reg <= MAXREG)
        !           237:                return (raddr[reg - MINREG]);
        !           238:        return (0);
        !           239: }
        !           240: 
        !           241: static int
        !           242: intrget(reg, buf, size)
        !           243: ADDR reg;
        !           244: char *buf;
        !           245: {
        !           246:        register char *p, *q;
        !           247:        register int n;
        !           248:        register int rnum;
        !           249:        TREG r;
        !           250: 
        !           251:        for (p = buf, n = size; n > 0; n--)
        !           252:                *p++ = 0;
        !           253:        rnum = reg / SZREG;
        !           254:        if (rnum < MINREG)
        !           255:                return (0);
        !           256:        p = buf;
        !           257:        while (rnum <= MAXREG && size > 0) {
        !           258:                r = rget(roffs[rnum - MINREG]);
        !           259:                for (q = (char *)&r, n = SZREG; n > 0; n--)
        !           260:                        *p++ = *q++;
        !           261:                size -= SZREG;
        !           262:                rnum++;
        !           263:        }
        !           264:        return (size <= 0);
        !           265: }
        !           266: 
        !           267: static int
        !           268: intrput(reg, buf, size)
        !           269: ADDR reg;
        !           270: char *buf;
        !           271: {
        !           272:        register char *p, *q;
        !           273:        register int n;
        !           274:        register int rnum;
        !           275:        TREG r;
        !           276: 
        !           277:        rnum = reg / SZREG;
        !           278:        if (rnum < MINREG)
        !           279:                return (0);
        !           280:        p = buf;
        !           281:        while (rnum <= MAXREG && size > 0) {
        !           282:                r = rget(roffs[rnum - MINREG]);
        !           283:                for (q = (char *)&r, n = SZREG; n > 0 && size > 0; n--, size--)
        !           284:                        *q++ = *p++;
        !           285:                rput(roffs[rnum - MINREG], r);
        !           286:                rnum++;
        !           287:        }
        !           288:        return (size <= 0);
        !           289: }
        !           290: 
        !           291: /*
        !           292:  * turn address to file offset
        !           293:  * returns nonzero if ok
        !           294:  */
        !           295: 
        !           296: 
        !           297: int
        !           298: reloc(addr, space, offp)
        !           299: ADDR addr;
        !           300: register int space;
        !           301: long *offp;
        !           302: {
        !           303:        register struct map *mp;
        !           304: 
        !           305:        for (mp = (space & SYMF) ? symmap : cormap; mp->flag & MPINUSE; mp++)
        !           306:                if ((space & SPTYPE) == (mp->sp & SPTYPE)
        !           307:                &&  mp->b <= addr && addr < mp->e) {
        !           308:                        addr += mp->f - mp->b;
        !           309:                        if ((space & (SYMF|RAWADDR)) == 0)
        !           310:                                if (kmap(&addr, space) == 0)
        !           311:                                        return (0);
        !           312:                        *offp = addr;
        !           313:                        return (1);
        !           314:                }
        !           315:        /*
        !           316:         * if we wanted instruction space and didn't find it,
        !           317:         * try data space now
        !           318:         */
        !           319:        if ((space & SPTYPE) == INSTSP) {
        !           320:                space &=~ SPTYPE;
        !           321:                space |= DATASP;
        !           322:                for (mp = (space & SYMF) ? symmap : cormap; mp->flag & MPINUSE; mp++)
        !           323:                        if ((space & SPTYPE) == (mp->sp & SPTYPE)
        !           324:                        &&  mp->b <= addr && addr < mp->e) {
        !           325:                                addr += mp->f - mp->b;
        !           326:                                if ((space & (SYMF|RAWADDR)) == 0)
        !           327:                                        if (kmap(&addr, space) == 0)
        !           328:                                                return (0);
        !           329:                                *offp = addr;
        !           330:                                return (1);
        !           331:                        }
        !           332:        }
        !           333:        if (space & SYMF)
        !           334:                errflg = "text address not found";
        !           335:        else
        !           336:                errflg = "data address not found";
        !           337:        return (0);
        !           338: }
        !           339: 
        !           340: /*
        !           341:  * small hackery
        !           342:  */
        !           343: 
        !           344: static
        !           345: memclr(buf, size)
        !           346: register char *buf;
        !           347: register int size;
        !           348: {
        !           349: 
        !           350:        while (--size >= 0)
        !           351:                *buf++ = 0;
        !           352: }
        !           353: 
        !           354: static
        !           355: memcpy(to, fr, size)
        !           356: register char *to, *fr;
        !           357: register int size;
        !           358: {
        !           359: 
        !           360:        while (--size >= 0)
        !           361:                *to++ = *fr++;
        !           362: }

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