Return to access.c CVS log

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

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

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