![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to access.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / adb|
Return to access.c CVS log | Up to [Research Unix] / researchv8dc / cmd / adb |
1.1 ! root 1: /* ! 2: * access the files: ! 3: * read or write data from some address in some space ! 4: */ ! 5: ! 6: #include "defs.h" ! 7: #include "regs.h" ! 8: #include <sys/param.h> ! 9: ! 10: /* ! 11: * routines to get/put various types ! 12: */ ! 13: ! 14: TLONG ! 15: lget(addr, space) ! 16: ADDR addr; ! 17: int space; ! 18: { ! 19: TLONG x; ! 20: ! 21: if ((space & SPTYPE) == NOSP) ! 22: return (wtol(dot)); ! 23: if (fget(addr, space, (char *)&x, sizeof(x)) == 0) ! 24: return (0); ! 25: return (x); ! 26: } ! 27: ! 28: TSHORT ! 29: sget(addr, space) ! 30: ADDR addr; ! 31: int space; ! 32: { ! 33: TSHORT x; ! 34: ! 35: if ((space & SPTYPE) == NOSP) ! 36: return (wtos(dot)); ! 37: if (fget(addr, space, (char *)&x, sizeof(x)) == 0) ! 38: return (0); ! 39: return (x); ! 40: } ! 41: ! 42: TCHAR ! 43: cget(addr, space) ! 44: ADDR addr; ! 45: int space; ! 46: { ! 47: TCHAR x; ! 48: ! 49: if ((space & SPTYPE) == NOSP) ! 50: return (wtoc(dot)); ! 51: if (fget(addr, space, (char *)&x, sizeof(x)) == 0) ! 52: return (0); ! 53: return (x); ! 54: } ! 55: ! 56: TADDR ! 57: aget(addr, space) ! 58: ADDR addr; ! 59: int space; ! 60: { ! 61: TADDR x; ! 62: ! 63: if ((space & SPTYPE) == NOSP) ! 64: return (wtoa(dot)); ! 65: if (fget(addr, space, (char *)&x, sizeof(x)) == 0) ! 66: return (0); ! 67: return (x); ! 68: } ! 69: ! 70: lput(addr, space, v) ! 71: ADDR addr; ! 72: int space; ! 73: TLONG v; ! 74: { ! 75: ! 76: return (fput(addr, space, (char *)&v, sizeof(v))); ! 77: } ! 78: ! 79: sput(addr, space, v) ! 80: ADDR addr; ! 81: int space; ! 82: TSHORT v; ! 83: { ! 84: ! 85: return (fput(addr, space, (char *)&v, sizeof(v))); ! 86: } ! 87: ! 88: cput(addr, space, v) ! 89: ADDR addr; ! 90: int space; ! 91: TCHAR v; ! 92: { ! 93: ! 94: return (fput(addr, space, (char *)&v, sizeof(v))); ! 95: } ! 96: ! 97: aput(addr, space, v) ! 98: ADDR addr; ! 99: int space; ! 100: TADDR v; ! 101: { ! 102: ! 103: return (fput(addr, space, (char *)&v, sizeof(v))); ! 104: } ! 105: ! 106: /* ! 107: * the real io code ! 108: */ ! 109: ! 110: int ! 111: fget(addr, space, buf, size) ! 112: ADDR addr; ! 113: register int space; ! 114: char *buf; ! 115: int size; ! 116: { ! 117: int fd; ! 118: off_t off; ! 119: ADDR oa; ! 120: ADDR regaddr(); ! 121: off_t lseek(); ! 122: ! 123: if ((space & SPTYPE) == NOSP) { ! 124: memset(buf, 0, size); ! 125: memcpy(buf, (char *)&dot, size < sizeof(dot) ? sizeof(dot) : size); ! 126: return (1); ! 127: } ! 128: if (space & SYMF) ! 129: fd = fsym; ! 130: else ! 131: fd = fcor; ! 132: oa = addr; ! 133: if ((space & SPTYPE) == REGSP) { ! 134: if (space & SYMF) { ! 135: errflg = "registers in corefile only"; ! 136: return (0); ! 137: } ! 138: if ((addr = regaddr(addr)) == 0) ! 139: return (intrget(oa, buf, size)); ! 140: space &=~ SPTYPE; ! 141: space |= DATASP; ! 142: } ! 143: if (reloc(addr, space, &off) == 0) ! 144: return (0); ! 145: if (lseek(fd, off, 0) == -1 ! 146: || read(fd, buf, size) != size) { ! 147: if ((space & SPTYPE) == INSTSP) ! 148: errflg = "can't read text"; ! 149: else ! 150: errflg = "can't read data"; ! 151: return (0); ! 152: } ! 153: return (1); ! 154: } ! 155: ! 156: int ! 157: fput(addr, space, buf, size) ! 158: ADDR addr; ! 159: register int space; ! 160: char *buf; ! 161: int size; ! 162: { ! 163: int fd; ! 164: off_t off; ! 165: ADDR oa; ! 166: ADDR regaddr(); ! 167: off_t lseek(); ! 168: ! 169: if ((space & SPTYPE) == NOSP) ! 170: return (0); ! 171: if (wtflag == 0 ! 172: && !((space & SYMF) == 0 && pid)) ! 173: error("not in write mode"); ! 174: if (space & SYMF) ! 175: fd = fsym; ! 176: else ! 177: fd = fcor; ! 178: oa = addr; ! 179: if ((space & SPTYPE) == REGSP) { ! 180: if (space & SYMF) { ! 181: errflg = "registers in corefile only"; ! 182: return (0); ! 183: } ! 184: if ((addr = regaddr(addr)) == 0) ! 185: return (intrput(oa, buf, size)); ! 186: space &=~ SPTYPE; ! 187: space |= DATASP; ! 188: } ! 189: if (reloc(addr, space, &off) == 0) ! 190: return (0); ! 191: if (lseek(fd, off, 0) == -1 ! 192: || write(fd, buf, size) != size) { ! 193: if ((space & SPTYPE) == INSTSP) ! 194: errflg = "can't write text"; ! 195: else ! 196: errflg = "can't write data"; ! 197: return (0); ! 198: } ! 199: return (1); ! 200: } ! 201: ! 202: /* ! 203: * register address hacks ! 204: * if the register allegedly has an address (e.g. we're knee deep in ! 205: * stack frames), return that ! 206: * otherwise do fake io to our internal copies of registers ! 207: * awful ! 208: */ ! 209: ! 210: static ADDR ! 211: regaddr(reg) ! 212: register ADDR reg; ! 213: { ! 214: extern ADDR raddr[]; ! 215: ! 216: reg /= sizeof(TREG); ! 217: if (MINREG <= reg && reg <= MAXREG) ! 218: return (raddr[reg - MINREG]); ! 219: return (0); ! 220: } ! 221: ! 222: static int ! 223: intrget(reg, buf, size) ! 224: ADDR reg; ! 225: char *buf; ! 226: { ! 227: register char *p, *q; ! 228: register int n; ! 229: register int rnum; ! 230: TREG r; ! 231: extern int roffs[]; ! 232: ! 233: for (p = buf, n = size; n > 0; n--) ! 234: *p++ = 0; ! 235: rnum = reg / sizeof(TREG); ! 236: if (rnum < MINREG) ! 237: return (0); ! 238: p = buf; ! 239: while (rnum <= MAXREG && size > 0) { ! 240: r = rget(roffs[rnum - MINREG]); ! 241: for (q = (char *)&r, n = sizeof(TREG); n > 0; n--) ! 242: *p++ = *q++; ! 243: size -= sizeof(TREG); ! 244: rnum++; ! 245: } ! 246: return (size <= 0); ! 247: } ! 248: ! 249: static int ! 250: intrput(reg, buf, size) ! 251: ADDR reg; ! 252: char *buf; ! 253: { ! 254: register char *p, *q; ! 255: register int n; ! 256: register int rnum; ! 257: TREG r; ! 258: extern int roffs[]; ! 259: ! 260: rnum = reg / sizeof(TREG); ! 261: if (rnum < MINREG) ! 262: return (0); ! 263: p = buf; ! 264: while (rnum <= MAXREG && size > 0) { ! 265: r = rget(roffs[rnum - MINREG]); ! 266: for (q = (char *)&r, n = sizeof(TREG); n > 0 && size > 0; n--, size--) ! 267: *q++ = *p++; ! 268: rput(roffs[rnum - MINREG], r); ! 269: rnum++; ! 270: } ! 271: return (size <= 0); ! 272: } ! 273: ! 274: /* ! 275: * turn address to file offset ! 276: * returns nonzero if ok ! 277: */ ! 278: ! 279: ! 280: int ! 281: reloc(addr, space, offp) ! 282: ADDR addr; ! 283: register int space; ! 284: off_t *offp; ! 285: { ! 286: register struct map *mp; ! 287: ! 288: for (mp = (space & SYMF) ? symmap : cormap; mp->flag & MPINUSE; mp++) ! 289: if ((space & SPTYPE) == (mp->sp & SPTYPE) ! 290: && mp->b <= addr && addr < mp->e) { ! 291: addr += mp->f - mp->b; ! 292: if ((space & (SYMF|RAWADDR)) == 0) ! 293: if (kmap(&addr, space) == 0) ! 294: return (0); ! 295: *offp = addr; ! 296: return (1); ! 297: } ! 298: /* ! 299: * if we wanted instruction space and didn't find it, ! 300: * try data space now ! 301: */ ! 302: if ((space & SPTYPE) == INSTSP) { ! 303: space &=~ SPTYPE; ! 304: space |= DATASP; ! 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 (space & SYMF) ! 317: errflg = "text address not found"; ! 318: else ! 319: errflg = "data address not found"; ! 320: return (0); ! 321: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.