![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hostcore.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / pi|
Return to hostcore.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / pi |
1.1 ! root 1: #include "process.pub" ! 2: #include "frame.pri" ! 3: #include "symtab.pri" ! 4: #include "symbol.h" ! 5: #include "hostcore.h" ! 6: #include <a.out.h> ! 7: #include "asm.pri" ! 8: #include "format.pub" ! 9: #include "bpts.pri" ! 10: #include "master.pri" ! 11: SRCFILE("hostcore.c") ! 12: #define TXTOFF(magic) (magic==ZMAGIC ? 0 : sizeof (struct exec)) ! 13: #include <setjmp.h> ! 14: ! 15: static WaitList waitlist; ! 16: int kill(int,int); ! 17: ! 18: const int STOPPED=0, RUNNING=1, EXITED=2, DIED=3; ! 19: const REGADDR = USRADR - 18 * 4; ! 20: ! 21: Behavs HostCore::behavetype() { return behavs(); } ! 22: char *HostCore::eventname() { return SignalName(event()); } ! 23: char *HostCore::stop() { ::kill(pid, SIGSTOP); return 0; } ! 24: int HostCore::event() { return cursig; } ! 25: long HostCore::regaddr() { return REGADDR; } ! 26: long HostCore::scratchaddr() { return 0x2000; } ! 27: ! 28: extern int errno; ! 29: ! 30: int HostCore::ptrace(int cmd, int a, int d, int a2) ! 31: { ! 32: errno = 0; ! 33: int ret = ::ptrace(cmd, pid, a, d, a2); ! 34: switch (cmd) { ! 35: case PTRACE_CONT: ! 36: case PTRACE_KILL: ! 37: case PTRACE_SINGLESTEP: ! 38: case PTRACE_ATTACH: ! 39: case PTRACE_DETACH: ! 40: break; ! 41: default: ! 42: if (!errno) ! 43: waitlist.wait(this, WAIT_DISCARD); ! 44: break; ! 45: } ! 46: return ret; ! 47: } ! 48: ! 49: char *HostCore::run() ! 50: { ! 51: if (cursig == SIGSTOP || cursig == SIGTRAP) ! 52: cursig = 0; ! 53: ptrace(PTRACE_CONT, 1, cursig); ! 54: state = RUNNING; ! 55: cursig = 0; ! 56: return 0; ! 57: } ! 58: ! 59: #define SUNBPT 0x4e4f /* Trap #15 */ ! 60: char *HostCore::laybpt(Trap *t) ! 61: { ! 62: Cslfd *cp = peek(t->stmt->range.lo, 0); ! 63: if (!cp) ! 64: return "text not readable (probably shared)"; ! 65: t->saved = cp->sht; ! 66: return poke(t->stmt->range.lo, SUNBPT, 2); ! 67: } ! 68: ! 69: Behavs HostCore::behavs() ! 70: { ! 71: if( !online() ) ! 72: return PENDING; ! 73: // Confirm it is still running ! 74: if ( state == EXITED || state == DIED) ! 75: return ERRORED; ! 76: if ( state == RUNNING ) { ! 77: if (waitlist.wait(this, WAIT_POLL|WAIT_PCFIX)) { ! 78: if (state != STOPPED) ! 79: return ERRORED; ! 80: if (!(sigmask&(1<<(cursig-1)))) { ! 81: run(); ! 82: return ACTIVE; ! 83: } ! 84: } else ! 85: return ACTIVE; ! 86: } ! 87: switch( cursig ){ ! 88: case SIGSTOP: ! 89: return HALTED; ! 90: case SIGTRAP: ! 91: return BREAKED; ! 92: default: ! 93: return PENDING; ! 94: } ! 95: } ! 96: ! 97: char *HostCore::problem() ! 98: { ! 99: static char buf[64]; ! 100: ! 101: if( !online() ) { ! 102: if( corefstat() ) ! 103: return "core image has gone away"; ! 104: return Core::problem(); ! 105: } ! 106: if (state == EXITED) ! 107: sprintf( buf, "exited with status %d", cursig); ! 108: else if (state == DIED) ! 109: sprintf( buf, "died from signal %d", cursig); ! 110: return buf; ! 111: } ! 112: ! 113: char *HostCore::readcontrol() ! 114: { ! 115: if( online() ) ! 116: return "online readcontrol"; ! 117: if( corefstat() ) ! 118: return "cannot fstat core image"; ! 119: int got = ::read(corefd, (char *)&bsdcore, sizeof(bsdcore)); ! 120: if (got != sizeof(bsdcore)) ! 121: return "cannot read bsdcore"; ! 122: state = STOPPED; ! 123: cursig = bsdcore.c_signo; ! 124: endtext = N_TXTADDR(bsdcore.c_aouthdr) + bsdcore.c_tsize; ! 125: startdata = N_DATADDR(bsdcore.c_aouthdr); ! 126: enddata = startdata + bsdcore.c_dsize; ! 127: startstack = SYSADR - bsdcore.c_ssize; ! 128: return 0; ! 129: } ! 130: ! 131: void HostCore::close() ! 132: { ! 133: if (online()){ ! 134: if (state == RUNNING) { ! 135: stop(); ! 136: waitstop(WAIT_PCFIX); ! 137: ptrace(PTRACE_DETACH, 1); ! 138: } else if (state == STOPPED) { ! 139: ::kill(pid, SIGSTOP); ! 140: ptrace(PTRACE_DETACH, 1); ! 141: } ! 142: waitlist.remove(this); ! 143: } ! 144: Core::close(); ! 145: } ! 146: ! 147: char *HostCore::open() ! 148: { ! 149: int mode = 2; ! 150: if( procpath() && !strcmp(basename(procpath()), "core") ) { ! 151: while( corefd<0 && mode>=0 ) ! 152: corefd = ::open(procpath(), mode--); ! 153: if( corefd<0 ) ! 154: return SysErr("core image: " ); ! 155: if( corefstat() ) ! 156: return SysErr("core image: " ); ! 157: if( corestat.st_mode & S_IEXEC ) ! 158: return "executable - should be dump (core)"; ! 159: } else if( procpath() ) { ! 160: sscanf(procpath(), "%d", &pid); ! 161: _online = 1; ! 162: waitlist.add(this); ! 163: waitlist.wait(this, 0); ! 164: cursig = SIGSTOP; ! 165: } ! 166: stabfd = ::open(stabpath(),0); ! 167: if( stabfd<0 ) { ! 168: if( online() ) { ! 169: ::kill(pid, SIGSTOP); ! 170: ptrace(PTRACE_DETACH, 1); ! 171: } ! 172: return SysErr( "symbol tables: " ); ! 173: } ! 174: stabfstat(); ! 175: BsdSymTab *bsdsp = new BsdSymTab(this, stabfd, _symtab); ! 176: _symtab = bsdsp; ! 177: _symtab->read(); ! 178: // Can't find endtext from U structure in 4.0 release, this is a kludge ! 179: endtext = bsdsp->endtext(); ! 180: if( online() || !procpath() ) ! 181: return 0; ! 182: return readcontrol(); ! 183: } ! 184: ! 185: char *HostCore::reopen(char *newprocpath, char *newstabpath) ! 186: { ! 187: int compstabfd = -1; ! 188: char *error = 0; ! 189: int retstat; ! 190: ! 191: if( !online() || (newprocpath && !strcmp(basename(newprocpath), "core")) ) ! 192: return "reopen core not implemented"; ! 193: int opid = pid; ! 194: int ostate = state; ! 195: int ocursig = cursig; ! 196: sscanf(newprocpath, "%d", &pid); ! 197: waitlist.wait(this, 0); ! 198: ! 199: compstabfd = ::open(newstabpath, 0); ! 200: struct stat compstabstat; ! 201: if( compstabfd < 0 ) { ! 202: error = "symbol table error"; ! 203: goto out; ! 204: } ! 205: retstat = ::fstat(compstabfd, &compstabstat); ! 206: ::close(compstabfd); ! 207: if (retstat) ! 208: error = "symbol table error"; ! 209: else if( compstabstat.st_mtime != stabstat.st_mtime ) ! 210: error = "symbol tables differ (modified time)"; ! 211: else if( compstabstat.st_size != stabstat.st_size ) ! 212: error = "symbol tables differ (file size)"; ! 213: cursig = ocursig; ! 214: state = ostate; ! 215: if (error) { ! 216: out: ! 217: ::kill(pid, SIGSTOP); ! 218: ptrace(PTRACE_DETACH, 1); ! 219: pid = opid; ! 220: return error; ! 221: } ! 222: // Must disconnect from the old process ! 223: int npid = pid; ! 224: pid = opid; ! 225: switch (state) { ! 226: case RUNNING: ! 227: stop(); ! 228: waitstop(WAIT_PCFIX); ! 229: ptrace(PTRACE_DETACH, 1); ! 230: break; ! 231: case STOPPED: ! 232: ::kill(pid, SIGSTOP); ! 233: ptrace(PTRACE_DETACH, 1); ! 234: break; ! 235: case EXITED: ! 236: case DIED: ! 237: break; ! 238: } ! 239: pid = npid; ! 240: state = STOPPED; ! 241: cursig = SIGSTOP; ! 242: // Can't find endtext from U structure in 4.0 release, this is a kludge ! 243: BsdSymTab *bsdsp = (BsdSymTab *)_symtab; ! 244: endtext = bsdsp->endtext(); ! 245: return 0; ! 246: } ! 247: ! 248: const int REGFD = -2, DATAFD = -3, TEXTFD = -4, USERFD = -5; ! 249: char *HostCore::seekto(int &fd, long &addr, int &whence) ! 250: { ! 251: if( !online() ) { ! 252: if ( (u_long)addr >= USRADR) { ! 253: addr -= USRADR + ctob(UPAGES); ! 254: whence = 2; ! 255: } else if ( (u_long)addr >= REGADDR) { ! 256: addr -= REGADDR; ! 257: fd = REGFD; ! 258: } else if ( (u_long)addr < 0x2000) ! 259: return "offset below text segment"; ! 260: else if ( (u_long)addr <= endtext) { ! 261: addr += N_TXTOFF(bsdcore.c_aouthdr) ! 262: - N_TXTADDR(bsdcore.c_aouthdr); ! 263: fd = stabfd; ! 264: } else if ( (u_long)addr < startdata) ! 265: return "offset beyond text segment"; ! 266: else if ( (u_long)addr <= enddata) ! 267: addr -= startdata - bsdcore.c_len; ! 268: else if ( (u_long)addr < startstack) ! 269: return "offset beyond data segment"; ! 270: else if ( (u_long)addr < SYSADR) { ! 271: addr -= SYSADR + ctob(UPAGES); ! 272: whence = 2; ! 273: } else ! 274: return "offset in system space"; ! 275: } else { ! 276: if ( (u_long)addr >= USRADR) { ! 277: addr -= USRADR; ! 278: fd = USERFD; ! 279: } else if ( (u_long)addr >= REGADDR) { ! 280: addr -= REGADDR; ! 281: fd = REGFD; ! 282: } else if ( (u_long)addr >= SYSADR ) { ! 283: extern char *DEVKMEM; ! 284: if( kmemfd == -1 ) { ! 285: kmemfd = ::open(DEVKMEM, 0); ! 286: if (kmemfd == -1) ! 287: return "can't read kernel"; ! 288: } ! 289: fd = kmemfd; ! 290: } else if ( (u_long)addr <= endtext) ! 291: fd = TEXTFD; ! 292: else ! 293: fd = DATAFD; ! 294: } ! 295: return 0; ! 296: } ! 297: ! 298: void bcopy(char*,char*,int); ! 299: ! 300: char *HostCore::readwrite(long offset, char *buf, int r, int w) ! 301: { ! 302: int fd = corefd, whence = 0; ! 303: int rv; ! 304: char *msg = "core image:"; ! 305: ! 306: char *error = seekto(fd, offset, whence); ! 307: if( error ) ! 308: return sf("core image: %s", error); ! 309: if( fd >= 0 ) { ! 310: if( lseek(fd, offset, whence) == -1 ) ! 311: return sf("lseek(%d,0x%X,%d)", fd, offset, whence); ! 312: if( r ){ ! 313: int got = ::read(fd, buf, r); ! 314: for( int i = got; i < r; ++i ) buf[i] = 0; ! 315: if( got > 0 ) return 0; ! 316: } ! 317: if( w && ::write(fd, buf, w) == w ) return 0; ! 318: return SysErr(msg); ! 319: } ! 320: int wasrunning = 0; ! 321: if (state == RUNNING) { ! 322: stop(); ! 323: if (error = waitstop(WAIT_PCFIX)) ! 324: return error; ! 325: if (cursig != SIGSTOP) { ! 326: int savesig = cursig; ! 327: /* The STOP signal still has to be eaten */ ! 328: run(); ! 329: waitstop(WAIT_PCFIX); ! 330: cursig = savesig; ! 331: } else ! 332: wasrunning = 1; ! 333: } ! 334: if (fd == REGFD) { ! 335: error = regrw(offset, buf, r, w); ! 336: if (wasrunning && !error) ! 337: run(); ! 338: return error; ! 339: } else if (fd == DATAFD) { ! 340: if ( r ) ! 341: rv = ptrace(PTRACE_READDATA, offset, r, (int)buf); ! 342: else ! 343: rv = ptrace(PTRACE_WRITEDATA, offset, w, (int)buf); ! 344: } ! 345: else if (fd == TEXTFD) { ! 346: if ( r ) ! 347: rv = ptrace(PTRACE_READTEXT, offset, r, (int)buf); ! 348: else { ! 349: /* Damn bug in Sun's kernel */ ! 350: if (w < 4){ ! 351: int tmp; ! 352: ptrace(PTRACE_READTEXT, offset, 4, (int)&tmp); ! 353: ::bcopy(buf, (char*)&tmp, w); ! 354: if (rv = ptrace(PTRACE_WRITETEXT, offset, 4, (int)&tmp)) ! 355: return "text not writable (probably shared)"; ! 356: } else ! 357: rv = ptrace(PTRACE_WRITETEXT, offset, w, (int)buf); ! 358: } ! 359: } ! 360: else if (fd == USERFD) { ! 361: int *ip = (int *)buf; ! 362: if ( r ) { ! 363: do { ! 364: *ip++ = ptrace(PTRACE_PEEKUSER, offset); ! 365: offset += 4; ! 366: r -= 4; ! 367: } while (r > 0 && errno == 0); ! 368: } else { ! 369: do { ! 370: ptrace(PTRACE_POKEUSER, offset, *ip++); ! 371: offset += 4; ! 372: w -= 4; ! 373: } while (w > 0 && errno == 0); ! 374: } ! 375: rv = errno; ! 376: } ! 377: if (wasrunning && !rv) ! 378: run(); ! 379: return rv == 0 ? 0 : "bad ptrace call"; ! 380: } ! 381: ! 382: char *HostCore::regrw(long offset, char *buf, int r, int w) ! 383: { ! 384: if ( online() ) { ! 385: regs rg; ! 386: if ( ptrace(PTRACE_GETREGS, (int)&rg) ) ! 387: return "Can't read registers"; ! 388: if ( r ) ! 389: ::bcopy( (char*)&rg + offset, buf, r); ! 390: else { ! 391: ::bcopy( buf, (char*)&rg + offset, w); ! 392: ptrace(PTRACE_SETREGS, (int)&rg); ! 393: } ! 394: } else { ! 395: if ( r ) ! 396: ::bcopy( (char*)&bsdcore.c_regs + offset, buf, r); ! 397: else if ( w ) ! 398: ::bcopy( buf, (char*)&bsdcore.c_regs + offset, w); ! 399: } ! 400: return 0; ! 401: } ! 402: ! 403: int HostCore::instack(long curfp, long prevfp ) ! 404: { ! 405: return ((curfp&0xf8000000)==0x08000000) && ((curfp&0xff000000)!=0x0f000000) ! 406: && (curfp>prevfp); ! 407: } ! 408: ! 409: int HostCore::fpvalid(long fp) ! 410: { ! 411: return (instack(fp, 0x08000000) && fp < 0x0f000000); ! 412: } ! 413: ! 414: char *HostCore::signalmask(long mask) ! 415: { ! 416: sigmask = mask; ! 417: return 0; ! 418: } ! 419: ! 420: char *HostCore::exechang(long ehang) ! 421: { ! 422: if (!ehang) ! 423: return "Must hang on exec"; ! 424: return 0; ! 425: } ! 426: ! 427: #define PSW_T 0x00008000 ! 428: char *HostCore::pswT(long psw_loc, int t) ! 429: { ! 430: long ps; ! 431: ! 432: char *error = read(psw_loc, (char*) &ps, 4 ); ! 433: if( error ) return error; ! 434: if( t ) ! 435: ps |= PSW_T; ! 436: else ! 437: ps &= ~PSW_T; ! 438: return write(psw_loc, (char*)&ps, 4); ! 439: } ! 440: ! 441: static jmp_buf saveenv; ! 442: void longjmp(jmp_buf, int); ! 443: int setjmp(jmp_buf); ! 444: ! 445: static void SigCatch(int) ! 446: { ! 447: longjmp(saveenv, 1); ! 448: } ! 449: ! 450: const int STEPWAIT = 15; ! 451: ! 452: char *HostCore::waitstop(int flags) ! 453: { ! 454: int wret; ! 455: ! 456: SIG_TYP oldsig = ::signal(SIGALRM, (SIG_TYP)&SigCatch); ! 457: int oldalarm = ::alarm(STEPWAIT); ! 458: if( ::setjmp(saveenv) ){ ! 459: ::alarm(oldalarm); ! 460: ::signal(SIGALRM, (SIG_TYP)oldsig); ! 461: ::kill(pid, SIGSTOP); ! 462: return sf("timeout (%d secs)", STEPWAIT); ! 463: } ! 464: wret = waitlist.wait(this, flags); ! 465: ::alarm(oldalarm); ! 466: ::signal(SIGALRM, (SIG_TYP)oldsig); ! 467: if (!wret ) ! 468: return "Unexpected wait error"; ! 469: if (state != STOPPED) ! 470: return "Process exited"; ! 471: return 0; ! 472: } ! 473: ! 474: const short M68K_TRAP0=0x4E40, M68K_RTS = 0x4E75; ! 475: ! 476: char *HostCore::dostep(long lo, long hi, int sstep) ! 477: { ! 478: char *error = 0; ! 479: long fp0, time0, time(long); ! 480: ! 481: time0 = ::time(0L); ! 482: fp0 = fp(); ! 483: for(;;){ ! 484: if( hi && isM68KJSB(peek(pc())->sht) ) { ! 485: error = stepoverM68KJSB(); ! 486: goto next; ! 487: } ! 488: if (sstep) ! 489: ptrace(PTRACE_SINGLESTEP, 1); ! 490: else ! 491: error = run(); ! 492: if( !error ) error = waitstop(sstep ? 0 : WAIT_PCFIX); ! 493: if( !error && event()!=SIGTRAP ) ! 494: error = sf( "single step error. signal=%d", event() ); ! 495: if( !error ) error = clrcurrsig(); ! 496: next: ! 497: if( error ) return error; ! 498: if( !hi || pc()<lo || pc()>=hi || ! 499: (fp()>fp0 && peek(pc())->sht != M68K_RTS) ) ! 500: return 0; ! 501: if( ::time(0L) > time0+STEPWAIT ) ! 502: return sf("single step timeout (%d secs)",STEPWAIT); ! 503: } ! 504: } ! 505: ! 506: char *HostCore::destroy() ! 507: { ! 508: char *error; ! 509: ! 510: if ( state == EXITED || state == DIED) ! 511: return 0; ! 512: clrcurrsig(); ! 513: if (state == RUNNING) { ! 514: stop(); ! 515: if (error = waitstop(WAIT_PCFIX)) ! 516: return error; ! 517: } ! 518: ptrace(PTRACE_KILL); ! 519: waitlist.wait(this, WAIT_DISCARD|WAIT_POLL); ! 520: state = EXITED; ! 521: cursig = SIGKILL; ! 522: return 0; ! 523: } ! 524: ! 525: char *HostCore::clrcurrsig() ! 526: { ! 527: cursig = 0; ! 528: return 0; ! 529: } ! 530: ! 531: char *HostCore::sendsig(long sig) ! 532: { ! 533: if( !online() ) return "send signal: process not live"; ! 534: ::kill(pid, sig); ! 535: return 0; ! 536: } ! 537: ! 538: Context* HostCore::newContext() ! 539: { ! 540: HostContext *cc = new HostContext; ! 541: cc->error = 0; ! 542: cc->core = this; ! 543: cc->pending = 0; ! 544: if( state != STOPPED ) ! 545: cc->error = "context save: process not stopped"; ! 546: else if( peek(pc()-2)->sht == M68K_TRAP0 ) ! 547: cc->error = "context save: process in system call"; ! 548: else if( cc->pending = cursig ) ! 549: cc->error = clrcurrsig(); ! 550: if( !cc->error ) ! 551: for( int i = 0; i < 18; ++i ) ! 552: cc->regs[i] = regpeek(i); ! 553: return cc; ! 554: } ! 555: ! 556: void HostContext::restore() ! 557: { ! 558: if( pending ) ! 559: core->cursig = pending; ! 560: for( int i = 0; i < 18; ++i ) ! 561: if( error = core->regpoke(i, regs[i]) ) ! 562: return; ! 563: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.