![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to process.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / dbx|
Return to process.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / dbx |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char sccsid[] = "@(#)process.c 5.3 (Berkeley) 1/12/88"; ! 9: #endif not lint ! 10: ! 11: static char rcsid[] = "$Header: process.c,v 1.4 88/01/10 00:49:31 donn Exp $"; ! 12: ! 13: /* ! 14: * Process management. ! 15: * ! 16: * This module contains the routines to manage the execution and ! 17: * tracing of the debuggee process. ! 18: */ ! 19: ! 20: #include "defs.h" ! 21: #include "process.h" ! 22: #include "machine.h" ! 23: #include "events.h" ! 24: #include "tree.h" ! 25: #include "eval.h" ! 26: #include "operators.h" ! 27: #include "source.h" ! 28: #include "object.h" ! 29: #include "mappings.h" ! 30: #include "main.h" ! 31: #include "coredump.h" ! 32: #include <signal.h> ! 33: #include <errno.h> ! 34: #include <sys/stat.h> ! 35: ! 36: #ifndef public ! 37: ! 38: typedef struct Process *Process; ! 39: ! 40: Process process; ! 41: ! 42: #define DEFSIG -1 ! 43: ! 44: #include "machine.h" ! 45: ! 46: #endif ! 47: ! 48: #define NOTSTARTED 1 ! 49: #define STOPPED 0177 ! 50: #define FINISHED 0 ! 51: ! 52: /* ! 53: * A cache of the instruction segment is kept to reduce the number ! 54: * of system calls. Might be better just to read the entire ! 55: * code space into memory. ! 56: */ ! 57: ! 58: #define CACHESIZE 1003 ! 59: ! 60: typedef struct { ! 61: Word addr; ! 62: Word val; ! 63: } CacheWord; ! 64: ! 65: /* ! 66: * This structure holds the information we need from the user structure. ! 67: */ ! 68: ! 69: struct Process { ! 70: int pid; /* process being traced */ ! 71: int mask; /* process status word */ ! 72: Word reg[NREG]; /* process' registers */ ! 73: Word oreg[NREG]; /* registers when process last stopped */ ! 74: short status; /* either STOPPED or FINISHED */ ! 75: short signo; /* signal that stopped process */ ! 76: short sigcode; /* extra signal information */ ! 77: int exitval; /* return value from exit() */ ! 78: long sigset; /* bit array of traced signals */ ! 79: CacheWord word[CACHESIZE]; /* text segment cache */ ! 80: Ttyinfo ttyinfo; /* process' terminal characteristics */ ! 81: Address sigstatus; /* process' handler for current signal */ ! 82: }; ! 83: ! 84: /* ! 85: * These definitions are for the arguments to "pio". ! 86: */ ! 87: ! 88: typedef enum { PREAD, PWRITE } PioOp; ! 89: typedef enum { TEXTSEG, DATASEG } PioSeg; ! 90: ! 91: private struct Process pbuf; ! 92: ! 93: #define MAXNCMDARGS 1000 /* maximum number of arguments to RUN */ ! 94: ! 95: extern int errno; ! 96: ! 97: private Boolean just_started; ! 98: private int argc; ! 99: private String argv[MAXNCMDARGS]; ! 100: private String infile, outfile; ! 101: ! 102: /* ! 103: * Initialize process information. ! 104: */ ! 105: ! 106: public process_init() ! 107: { ! 108: register integer i; ! 109: char buf[10]; ! 110: ! 111: process = &pbuf; ! 112: process->status = (coredump) ? STOPPED : NOTSTARTED; ! 113: setsigtrace(); ! 114: # if vax || tahoe ! 115: for (i = 0; i < NREG; i++) { ! 116: sprintf(buf, "$r%d", i); ! 117: defregname(identname(buf, false), i); ! 118: } ! 119: # ifdef vax ! 120: defregname(identname("$ap", true), ARGP); ! 121: # endif ! 122: # else ! 123: # ifdef mc68000 ! 124: for (i = 0; i < 8; i++) { ! 125: sprintf(buf, "$d%d", i); ! 126: defregname(identname(buf, false), i); ! 127: sprintf(buf, "$a%d", i); ! 128: defregname(identname(buf, false), i + 8); ! 129: } ! 130: # endif ! 131: # endif ! 132: defregname(identname("$fp", true), FRP); ! 133: defregname(identname("$sp", true), STKP); ! 134: defregname(identname("$pc", true), PROGCTR); ! 135: if (coredump) { ! 136: coredump_readin(process->mask, process->reg, process->signo); ! 137: pc = process->reg[PROGCTR]; ! 138: } ! 139: arginit(); ! 140: } ! 141: ! 142: /* ! 143: * Routines to get at process information from outside this module. ! 144: */ ! 145: ! 146: public Word reg(n) ! 147: Integer n; ! 148: { ! 149: register Word w; ! 150: ! 151: if (n == NREG) { ! 152: w = process->mask; ! 153: } else { ! 154: w = process->reg[n]; ! 155: } ! 156: return w; ! 157: } ! 158: ! 159: public setreg(n, w) ! 160: Integer n; ! 161: Word w; ! 162: { ! 163: process->reg[n] = w; ! 164: } ! 165: ! 166: /* ! 167: * Begin execution. ! 168: * ! 169: * We set a breakpoint at the end of the code so that the ! 170: * process data doesn't disappear after the program terminates. ! 171: */ ! 172: ! 173: private Boolean remade(); ! 174: ! 175: public start(argv, infile, outfile) ! 176: String argv[]; ! 177: String infile, outfile; ! 178: { ! 179: String pargv[4]; ! 180: Node cond; ! 181: ! 182: if (coredump) { ! 183: coredump = false; ! 184: fclose(corefile); ! 185: coredump_close(); ! 186: } ! 187: if (argv == nil) { ! 188: argv = pargv; ! 189: pargv[0] = objname; ! 190: pargv[1] = nil; ! 191: } else { ! 192: argv[argc] = nil; ! 193: } ! 194: pstart(process, argv, infile, outfile); ! 195: if (remade(objname)) { ! 196: reinit(argv, infile, outfile); ! 197: } ! 198: if (process->status == STOPPED) { ! 199: pc = CODESTART; ! 200: setcurfunc(program); ! 201: if (objsize != 0) { ! 202: cond = build(O_EQ, build(O_SYM, pcsym), build(O_LCON, lastaddr())); ! 203: event_once(cond, buildcmdlist(build(O_ENDX))); ! 204: } ! 205: } ! 206: } ! 207: ! 208: /* ! 209: * Check to see if the object file has changed since the symbolic ! 210: * information last was read. ! 211: */ ! 212: ! 213: private time_t modtime; ! 214: ! 215: private Boolean remade(filename) ! 216: String filename; ! 217: { ! 218: struct stat s; ! 219: Boolean b; ! 220: ! 221: stat(filename, &s); ! 222: b = (Boolean) (modtime != 0 and modtime < s.st_mtime); ! 223: modtime = s.st_mtime; ! 224: return b; ! 225: } ! 226: ! 227: /* ! 228: * Set up what signals we want to trace. ! 229: */ ! 230: ! 231: private setsigtrace() ! 232: { ! 233: register Integer i; ! 234: register Process p; ! 235: ! 236: p = process; ! 237: for (i = 1; i <= NSIG; i++) { ! 238: psigtrace(p, i, true); ! 239: } ! 240: psigtrace(p, SIGHUP, false); ! 241: psigtrace(p, SIGKILL, false); ! 242: psigtrace(p, SIGALRM, false); ! 243: # ifdef SIGTSTP ! 244: psigtrace(p, SIGTSTP, false); ! 245: psigtrace(p, SIGCONT, false); ! 246: # endif ! 247: psigtrace(p, SIGCHLD, false); ! 248: psigtrace(p, SIGWINCH, false); ! 249: } ! 250: ! 251: /* ! 252: * Initialize the argument list. ! 253: */ ! 254: ! 255: public arginit() ! 256: { ! 257: infile = nil; ! 258: outfile = nil; ! 259: argv[0] = objname; ! 260: argc = 1; ! 261: } ! 262: ! 263: /* ! 264: * Add an argument to the list for the debuggee. ! 265: */ ! 266: ! 267: public newarg(arg) ! 268: String arg; ! 269: { ! 270: if (argc >= MAXNCMDARGS) { ! 271: error("too many arguments"); ! 272: } ! 273: argv[argc++] = arg; ! 274: } ! 275: ! 276: /* ! 277: * Set the standard input for the debuggee. ! 278: */ ! 279: ! 280: public inarg(filename) ! 281: String filename; ! 282: { ! 283: if (infile != nil) { ! 284: error("multiple input redirects"); ! 285: } ! 286: infile = filename; ! 287: } ! 288: ! 289: /* ! 290: * Set the standard output for the debuggee. ! 291: * Probably should check to avoid overwriting an existing file. ! 292: */ ! 293: ! 294: public outarg(filename) ! 295: String filename; ! 296: { ! 297: if (outfile != nil) { ! 298: error("multiple output redirect"); ! 299: } ! 300: outfile = filename; ! 301: } ! 302: ! 303: /* ! 304: * Start debuggee executing. ! 305: */ ! 306: ! 307: public run() ! 308: { ! 309: process->status = STOPPED; ! 310: fixbps(); ! 311: curline = 0; ! 312: start(argv, infile, outfile); ! 313: just_started = true; ! 314: isstopped = false; ! 315: cont(0); ! 316: } ! 317: ! 318: /* ! 319: * Continue execution wherever we left off. ! 320: * ! 321: * Note that this routine never returns. Eventually bpact() will fail ! 322: * and we'll call printstatus or step will call it. ! 323: */ ! 324: ! 325: typedef int Intfunc(); ! 326: ! 327: private Intfunc *dbintr; ! 328: private intr(); ! 329: ! 330: public cont(signo) ! 331: integer signo; ! 332: { ! 333: integer s; ! 334: ! 335: dbintr = signal(SIGINT, intr); ! 336: if (just_started) { ! 337: just_started = false; ! 338: } else { ! 339: if (not isstopped) { ! 340: error("can't continue execution"); ! 341: } ! 342: isstopped = false; ! 343: stepover(); ! 344: } ! 345: s = signo; ! 346: for (;;) { ! 347: if (single_stepping) { ! 348: printnews(); ! 349: } else { ! 350: setallbps(); ! 351: resume(s); ! 352: unsetallbps(); ! 353: s = DEFSIG; ! 354: if (not isbperr() or not bpact()) { ! 355: printstatus(); ! 356: } ! 357: } ! 358: stepover(); ! 359: } ! 360: /* NOTREACHED */ ! 361: } ! 362: ! 363: /* ! 364: * This routine is called if we get an interrupt while "running" ! 365: * but actually in the debugger. Could happen, for example, while ! 366: * processing breakpoints. ! 367: * ! 368: * We basically just want to keep going; the assumption is ! 369: * that when the process resumes it will get the interrupt, ! 370: * which will then be handled. ! 371: */ ! 372: ! 373: private intr() ! 374: { ! 375: signal(SIGINT, intr); ! 376: } ! 377: ! 378: public fixintr() ! 379: { ! 380: signal(SIGINT, dbintr); ! 381: } ! 382: ! 383: /* ! 384: * Resume execution. ! 385: */ ! 386: ! 387: public resume(signo) ! 388: int signo; ! 389: { ! 390: register Process p; ! 391: ! 392: p = process; ! 393: pcont(p, signo); ! 394: pc = process->reg[PROGCTR]; ! 395: if (p->status != STOPPED) { ! 396: if (p->signo != 0) { ! 397: error("program terminated by signal %d", p->signo); ! 398: } else if (not runfirst) { ! 399: if (p->exitval == 0) { ! 400: error("program exited"); ! 401: } else { ! 402: error("program exited with code %d", p->exitval); ! 403: } ! 404: } ! 405: } ! 406: } ! 407: ! 408: /* ! 409: * Continue execution up to the next source line. ! 410: * ! 411: * There are two ways to define the next source line depending on what ! 412: * is desired when a procedure or function call is encountered. Step ! 413: * stops at the beginning of the procedure or call; next skips over it. ! 414: */ ! 415: ! 416: /* ! 417: * Stepc is what is called when the step command is given. ! 418: * It has to play with the "isstopped" information. ! 419: */ ! 420: ! 421: public stepc() ! 422: { ! 423: if (not isstopped) { ! 424: error("can't continue execution"); ! 425: } ! 426: isstopped = false; ! 427: dostep(false); ! 428: isstopped = true; ! 429: } ! 430: ! 431: public next() ! 432: { ! 433: Address oldfrp, newfrp; ! 434: ! 435: if (not isstopped) { ! 436: error("can't continue execution"); ! 437: } ! 438: isstopped = false; ! 439: oldfrp = reg(FRP); ! 440: do { ! 441: dostep(true); ! 442: pc = reg(PROGCTR); ! 443: newfrp = reg(FRP); ! 444: } while (newfrp < oldfrp and newfrp != 0); ! 445: isstopped = true; ! 446: } ! 447: ! 448: /* ! 449: * Continue execution until the current function returns, or, ! 450: * if the given argument is non-nil, until execution returns to ! 451: * somewhere within the given function. ! 452: */ ! 453: ! 454: public rtnfunc (f) ! 455: Symbol f; ! 456: { ! 457: Address addr; ! 458: Symbol t; ! 459: ! 460: if (not isstopped) { ! 461: error("can't continue execution"); ! 462: } else if (f != nil and not isactive(f)) { ! 463: error("%s is not active", symname(f)); ! 464: } else { ! 465: addr = return_addr(); ! 466: if (addr == nil) { ! 467: error("no place to return to"); ! 468: } else { ! 469: isstopped = false; ! 470: contto(addr); ! 471: if (f != nil) { ! 472: for (;;) { ! 473: t = whatblock(pc); ! 474: addr = return_addr(); ! 475: if (t == f or addr == nil) break; ! 476: contto(addr); ! 477: } ! 478: } ! 479: if (not bpact()) { ! 480: isstopped = true; ! 481: printstatus(); ! 482: } ! 483: } ! 484: } ! 485: } ! 486: ! 487: /* ! 488: * Single-step over the current machine instruction. ! 489: * ! 490: * If we're single-stepping by source line we want to step to the ! 491: * next source line. Otherwise we're going to continue so there's ! 492: * no reason to do all the work necessary to single-step to the next ! 493: * source line. ! 494: */ ! 495: ! 496: public stepover() ! 497: { ! 498: Boolean b; ! 499: ! 500: if (traceexec) { ! 501: printf("!! stepping over 0x%x\n", process->reg[PROGCTR]); ! 502: } ! 503: if (single_stepping) { ! 504: dostep(false); ! 505: } else { ! 506: b = inst_tracing; ! 507: inst_tracing = true; ! 508: dostep(false); ! 509: inst_tracing = b; ! 510: } ! 511: if (traceexec) { ! 512: printf("!! stepped over to 0x%x\n", process->reg[PROGCTR]); ! 513: } ! 514: } ! 515: ! 516: /* ! 517: * Resume execution up to the given address. We can either ignore ! 518: * breakpoints (stepto) or catch them (contto). ! 519: */ ! 520: ! 521: public stepto(addr) ! 522: Address addr; ! 523: { ! 524: xto(addr, false); ! 525: } ! 526: ! 527: private contto (addr) ! 528: Address addr; ! 529: { ! 530: xto(addr, true); ! 531: } ! 532: ! 533: private xto (addr, catchbps) ! 534: Address addr; ! 535: boolean catchbps; ! 536: { ! 537: Address curpc; ! 538: ! 539: if (catchbps) { ! 540: stepover(); ! 541: } ! 542: curpc = process->reg[PROGCTR]; ! 543: if (addr != curpc) { ! 544: if (traceexec) { ! 545: printf("!! stepping from 0x%x to 0x%x\n", curpc, addr); ! 546: } ! 547: if (catchbps) { ! 548: setallbps(); ! 549: } ! 550: setbp(addr); ! 551: resume(DEFSIG); ! 552: unsetbp(addr); ! 553: if (catchbps) { ! 554: unsetallbps(); ! 555: } ! 556: if (not isbperr()) { ! 557: printstatus(); ! 558: } ! 559: } ! 560: } ! 561: ! 562: /* ! 563: * Print the status of the process. ! 564: * This routine does not return. ! 565: */ ! 566: ! 567: public printstatus () ! 568: { ! 569: int status; ! 570: ! 571: if (process->status == FINISHED) { ! 572: exit(0); ! 573: } else { ! 574: if (runfirst) { ! 575: fprintf(stderr, "\nEntering debugger ...\n"); ! 576: printheading(); ! 577: init(); ! 578: } ! 579: setcurfunc(whatblock(pc)); ! 580: getsrcpos(); ! 581: if (process->signo == SIGINT) { ! 582: isstopped = true; ! 583: printerror(); ! 584: } else if (isbperr() and isstopped) { ! 585: printf("stopped "); ! 586: printloc(); ! 587: putchar('\n'); ! 588: if (curline > 0) { ! 589: printlines(curline, curline); ! 590: } else { ! 591: printinst(pc, pc); ! 592: } ! 593: erecover(); ! 594: } else { ! 595: fixintr(); ! 596: isstopped = true; ! 597: printerror(); ! 598: } ! 599: } ! 600: } ! 601: ! 602: /* ! 603: * Print out the current location in the debuggee. ! 604: */ ! 605: ! 606: public printloc() ! 607: { ! 608: printf("in "); ! 609: printname(stdout, curfunc); ! 610: putchar(' '); ! 611: if (curline > 0 and not useInstLoc) { ! 612: printsrcpos(); ! 613: } else { ! 614: useInstLoc = false; ! 615: curline = 0; ! 616: printf("at 0x%x", pc); ! 617: } ! 618: } ! 619: ! 620: /* ! 621: * Some functions for testing the state of the process. ! 622: */ ! 623: ! 624: public Boolean notstarted(p) ! 625: Process p; ! 626: { ! 627: return (Boolean) (p->status == NOTSTARTED); ! 628: } ! 629: ! 630: public Boolean isfinished(p) ! 631: Process p; ! 632: { ! 633: return (Boolean) (p->status == FINISHED); ! 634: } ! 635: ! 636: /* ! 637: * Predicate to test if the reason the process stopped was because ! 638: * of a breakpoint. If so, as a side effect clear the local copy of ! 639: * signal handler associated with process. We must do this so as to ! 640: * not confuse future stepping or continuing by possibly concluding ! 641: * the process should continue with a SIGTRAP handler. ! 642: */ ! 643: ! 644: public boolean isbperr() ! 645: { ! 646: Process p; ! 647: boolean b; ! 648: ! 649: p = process; ! 650: if (p->status == STOPPED and p->signo == SIGTRAP) { ! 651: b = true; ! 652: p->sigstatus = 0; ! 653: } else { ! 654: b = false; ! 655: } ! 656: return b; ! 657: } ! 658: ! 659: /* ! 660: * Return the signal number that stopped the process. ! 661: */ ! 662: ! 663: public integer errnum (p) ! 664: Process p; ! 665: { ! 666: return p->signo; ! 667: } ! 668: ! 669: /* ! 670: * Return the signal code associated with the signal. ! 671: */ ! 672: ! 673: public integer errcode (p) ! 674: Process p; ! 675: { ! 676: return p->sigcode; ! 677: } ! 678: ! 679: /* ! 680: * Return the termination code of the process. ! 681: */ ! 682: ! 683: public integer exitcode (p) ! 684: Process p; ! 685: { ! 686: return p->exitval; ! 687: } ! 688: ! 689: /* ! 690: * These routines are used to access the debuggee process from ! 691: * outside this module. ! 692: * ! 693: * They invoke "pio" which eventually leads to a call to "ptrace". ! 694: * The system generates an I/O error when a ptrace fails. During reads ! 695: * these are ignored, during writes they are reported as an error, and ! 696: * for anything else they cause a fatal error. ! 697: */ ! 698: ! 699: extern Intfunc *onsyserr(); ! 700: ! 701: private badaddr; ! 702: private read_err(), write_err(); ! 703: ! 704: /* ! 705: * Read from the process' instruction area. ! 706: */ ! 707: ! 708: public iread(buff, addr, nbytes) ! 709: char *buff; ! 710: Address addr; ! 711: int nbytes; ! 712: { ! 713: Intfunc *f; ! 714: ! 715: f = onsyserr(EIO, read_err); ! 716: badaddr = addr; ! 717: if (coredump) { ! 718: coredump_readtext(buff, addr, nbytes); ! 719: } else { ! 720: pio(process, PREAD, TEXTSEG, buff, addr, nbytes); ! 721: } ! 722: onsyserr(EIO, f); ! 723: } ! 724: ! 725: /* ! 726: * Write to the process' instruction area, usually in order to set ! 727: * or unset a breakpoint. ! 728: */ ! 729: ! 730: public iwrite(buff, addr, nbytes) ! 731: char *buff; ! 732: Address addr; ! 733: int nbytes; ! 734: { ! 735: Intfunc *f; ! 736: ! 737: if (coredump) { ! 738: error("no process to write to"); ! 739: } ! 740: f = onsyserr(EIO, write_err); ! 741: badaddr = addr; ! 742: pio(process, PWRITE, TEXTSEG, buff, addr, nbytes); ! 743: onsyserr(EIO, f); ! 744: } ! 745: ! 746: /* ! 747: * Read for the process' data area. ! 748: */ ! 749: ! 750: public dread(buff, addr, nbytes) ! 751: char *buff; ! 752: Address addr; ! 753: int nbytes; ! 754: { ! 755: Intfunc *f; ! 756: ! 757: badaddr = addr; ! 758: if (coredump) { ! 759: f = onsyserr(EFAULT, read_err); ! 760: coredump_readdata(buff, addr, nbytes); ! 761: onsyserr(EFAULT, f); ! 762: } else { ! 763: f = onsyserr(EIO, read_err); ! 764: pio(process, PREAD, DATASEG, buff, addr, nbytes); ! 765: onsyserr(EIO, f); ! 766: } ! 767: } ! 768: ! 769: /* ! 770: * Write to the process' data area. ! 771: */ ! 772: ! 773: public dwrite(buff, addr, nbytes) ! 774: char *buff; ! 775: Address addr; ! 776: int nbytes; ! 777: { ! 778: Intfunc *f; ! 779: ! 780: if (coredump) { ! 781: error("no process to write to"); ! 782: } ! 783: f = onsyserr(EIO, write_err); ! 784: badaddr = addr; ! 785: pio(process, PWRITE, DATASEG, buff, addr, nbytes); ! 786: onsyserr(EIO, f); ! 787: } ! 788: ! 789: /* ! 790: * Trap for errors in reading or writing to a process. ! 791: * The current approach is to "ignore" read errors and complain ! 792: * bitterly about write errors. ! 793: */ ! 794: ! 795: private read_err() ! 796: { ! 797: /* ! 798: * Ignore. ! 799: */ ! 800: } ! 801: ! 802: private write_err() ! 803: { ! 804: error("can't write to process (address 0x%x)", badaddr); ! 805: } ! 806: ! 807: /* ! 808: * Ptrace interface. ! 809: */ ! 810: ! 811: #define WMASK (~(sizeof(Word) - 1)) ! 812: #define cachehash(addr) ((unsigned) ((addr >> 2) % CACHESIZE)) ! 813: ! 814: #define FIRSTSIG SIGINT ! 815: #define LASTSIG SIGQUIT ! 816: #define ischild(pid) ((pid) == 0) ! 817: #define traceme() ptrace(0, 0, 0, 0) ! 818: #define setrep(n) (1 << ((n)-1)) ! 819: #define istraced(p) (p->sigset&setrep(p->signo)) ! 820: ! 821: /* ! 822: * Ptrace options (specified in first argument). ! 823: */ ! 824: ! 825: #define UREAD 3 /* read from process's user structure */ ! 826: #define UWRITE 6 /* write to process's user structure */ ! 827: #define IREAD 1 /* read from process's instruction space */ ! 828: #define IWRITE 4 /* write to process's instruction space */ ! 829: #define DREAD 2 /* read from process's data space */ ! 830: #define DWRITE 5 /* write to process's data space */ ! 831: #define CONT 7 /* continue stopped process */ ! 832: #define SSTEP 9 /* continue for approximately one instruction */ ! 833: #define PKILL 8 /* terminate the process */ ! 834: ! 835: #ifdef IRIS ! 836: # define readreg(p, r) ptrace(10, p->pid, r, 0) ! 837: # define writereg(p, r, v) ptrace(11, p->pid, r, v) ! 838: #else ! 839: # define readreg(p, r) ptrace(UREAD, p->pid, regloc(r), 0); ! 840: # define writereg(p, r, v) ptrace(UWRITE, p->pid, regloc(r), v); ! 841: #endif ! 842: ! 843: /* ! 844: * Start up a new process by forking and exec-ing the ! 845: * given argument list, returning when the process is loaded ! 846: * and ready to execute. The PROCESS information (pointed to ! 847: * by the first argument) is appropriately filled. ! 848: * ! 849: * If the given PROCESS structure is associated with an already running ! 850: * process, we terminate it. ! 851: */ ! 852: ! 853: /* VARARGS2 */ ! 854: private pstart(p, argv, infile, outfile) ! 855: Process p; ! 856: String argv[]; ! 857: String infile; ! 858: String outfile; ! 859: { ! 860: int status; ! 861: ! 862: if (p->pid != 0) { ! 863: pterm(p); ! 864: cacheflush(p); ! 865: } ! 866: fflush(stdout); ! 867: psigtrace(p, SIGTRAP, true); ! 868: # ifdef IRIS ! 869: p->pid = fork(); ! 870: # else ! 871: p->pid = vfork(); ! 872: # endif ! 873: if (p->pid == -1) { ! 874: panic("can't fork"); ! 875: } ! 876: if (ischild(p->pid)) { ! 877: nocatcherrs(); ! 878: traceme(); ! 879: if (infile != nil) { ! 880: infrom(infile); ! 881: } ! 882: if (outfile != nil) { ! 883: outto(outfile); ! 884: } ! 885: execv(argv[0], argv); ! 886: _exit(1); ! 887: } ! 888: pwait(p->pid, &status); ! 889: getinfo(p, status); ! 890: if (p->status != STOPPED) { ! 891: beginerrmsg(); ! 892: fprintf(stderr, "warning: cannot execute %s\n", argv[0]); ! 893: } else { ! 894: ptraced(p->pid); ! 895: } ! 896: } ! 897: ! 898: /* ! 899: * Terminate a ptrace'd process. ! 900: */ ! 901: ! 902: public pterm (p) ! 903: Process p; ! 904: { ! 905: integer status; ! 906: ! 907: if (p != nil and p->pid != 0) { ! 908: ptrace(PKILL, p->pid, 0, 0); ! 909: pwait(p->pid, &status); ! 910: unptraced(p->pid); ! 911: } ! 912: } ! 913: ! 914: /* ! 915: * Continue a stopped process. The first argument points to a Process ! 916: * structure. Before the process is restarted it's user area is modified ! 917: * according to the values in the structure. When this routine finishes, ! 918: * the structure has the new values from the process's user area. ! 919: * ! 920: * Pcont terminates when the process stops with a signal pending that ! 921: * is being traced (via psigtrace), or when the process terminates. ! 922: */ ! 923: ! 924: private pcont(p, signo) ! 925: Process p; ! 926: int signo; ! 927: { ! 928: int s, status; ! 929: ! 930: if (p->pid == 0) { ! 931: error("program is not active"); ! 932: } ! 933: s = signo; ! 934: do { ! 935: setinfo(p, s); ! 936: if (traceexec) { ! 937: printf("!! pcont from 0x%x with signal %d (%d)\n", ! 938: p->reg[PROGCTR], s, p->signo); ! 939: fflush(stdout); ! 940: } ! 941: sigs_off(); ! 942: if (ptrace(CONT, p->pid, p->reg[PROGCTR], p->signo) < 0) { ! 943: panic("error %d trying to continue process", errno); ! 944: } ! 945: pwait(p->pid, &status); ! 946: sigs_on(); ! 947: getinfo(p, status); ! 948: if (p->status == STOPPED and traceexec and not istraced(p)) { ! 949: printf("!! ignored signal %d at 0x%x\n", ! 950: p->signo, p->reg[PROGCTR]); ! 951: fflush(stdout); ! 952: } ! 953: s = p->signo; ! 954: } while (p->status == STOPPED and not istraced(p)); ! 955: if (traceexec) { ! 956: printf("!! pcont to 0x%x on signal %d\n", p->reg[PROGCTR], p->signo); ! 957: fflush(stdout); ! 958: } ! 959: } ! 960: ! 961: /* ! 962: * Single step as best ptrace can. ! 963: */ ! 964: ! 965: public pstep(p, signo) ! 966: Process p; ! 967: integer signo; ! 968: { ! 969: int s, status; ! 970: ! 971: s = signo; ! 972: do { ! 973: setinfo(p, s); ! 974: if (traceexec) { ! 975: printf("!! pstep from 0x%x with signal %d (%d)\n", ! 976: p->reg[PROGCTR], s, p->signo); ! 977: fflush(stdout); ! 978: } ! 979: sigs_off(); ! 980: if (ptrace(SSTEP, p->pid, p->reg[PROGCTR], p->signo) < 0) { ! 981: panic("error %d trying to step process", errno); ! 982: } ! 983: pwait(p->pid, &status); ! 984: sigs_on(); ! 985: getinfo(p, status); ! 986: # if mc68000 || m68000 ! 987: if (p->status == STOPPED and p->signo == SIGTRAP) { ! 988: p->reg[PROGCTR] += 2; ! 989: } ! 990: # endif ! 991: if (p->status == STOPPED and traceexec and not istraced(p)) { ! 992: printf("!! pstep ignored signal %d at 0x%x\n", ! 993: p->signo, p->reg[PROGCTR]); ! 994: fflush(stdout); ! 995: } ! 996: s = p->signo; ! 997: } while (p->status == STOPPED and not istraced(p)); ! 998: if (traceexec) { ! 999: printf("!! pstep to 0x%x on signal %d\n", ! 1000: p->reg[PROGCTR], p->signo); ! 1001: fflush(stdout); ! 1002: } ! 1003: if (p->status != STOPPED) { ! 1004: if (p->exitval == 0) { ! 1005: error("program exited\n"); ! 1006: } else { ! 1007: error("program exited with code %d\n", p->exitval); ! 1008: } ! 1009: } ! 1010: } ! 1011: ! 1012: /* ! 1013: * Return from execution when the given signal is pending. ! 1014: */ ! 1015: ! 1016: public psigtrace(p, sig, sw) ! 1017: Process p; ! 1018: int sig; ! 1019: Boolean sw; ! 1020: { ! 1021: if (sw) { ! 1022: p->sigset |= setrep(sig); ! 1023: } else { ! 1024: p->sigset &= ~setrep(sig); ! 1025: } ! 1026: } ! 1027: ! 1028: /* ! 1029: * Don't catch any signals. ! 1030: * Particularly useful when letting a process finish uninhibited. ! 1031: */ ! 1032: ! 1033: public unsetsigtraces(p) ! 1034: Process p; ! 1035: { ! 1036: p->sigset = 0; ! 1037: } ! 1038: ! 1039: /* ! 1040: * Turn off attention to signals not being caught. ! 1041: */ ! 1042: ! 1043: private Intfunc *sigfunc[NSIG]; ! 1044: ! 1045: private sigs_off() ! 1046: { ! 1047: register int i; ! 1048: ! 1049: for (i = FIRSTSIG; i < LASTSIG; i++) { ! 1050: if (i != SIGKILL) { ! 1051: sigfunc[i] = signal(i, SIG_IGN); ! 1052: } ! 1053: } ! 1054: } ! 1055: ! 1056: /* ! 1057: * Turn back on attention to signals. ! 1058: */ ! 1059: ! 1060: private sigs_on() ! 1061: { ! 1062: register int i; ! 1063: ! 1064: for (i = FIRSTSIG; i < LASTSIG; i++) { ! 1065: if (i != SIGKILL) { ! 1066: signal(i, sigfunc[i]); ! 1067: } ! 1068: } ! 1069: } ! 1070: ! 1071: /* ! 1072: * Get process information from user area. ! 1073: */ ! 1074: ! 1075: private getinfo (p, status) ! 1076: register Process p; ! 1077: register int status; ! 1078: { ! 1079: register int i; ! 1080: Address addr; ! 1081: ! 1082: p->signo = (status&0177); ! 1083: p->exitval = ((status >> 8)&0377); ! 1084: if (p->signo != STOPPED) { ! 1085: p->status = FINISHED; ! 1086: p->pid = 0; ! 1087: p->reg[PROGCTR] = 0; ! 1088: } else { ! 1089: p->status = p->signo; ! 1090: p->signo = p->exitval; ! 1091: p->exitval = 0; ! 1092: # ifdef IRIS ! 1093: p->mask = readreg(p, RPS); ! 1094: # else ! 1095: p->sigcode = ptrace(UREAD, p->pid, &((struct user *)0)->u_code, 0); ! 1096: p->mask = readreg(p, PS); ! 1097: # endif ! 1098: for (i = 0; i < NREG; i++) { ! 1099: p->reg[i] = readreg(p, rloc[i]); ! 1100: p->oreg[i] = p->reg[i]; ! 1101: } ! 1102: # ifdef mc68000 ! 1103: if (p->status == STOPPED and p->signo == SIGTRAP and ! 1104: p->reg[PROGCTR] > CODESTART ! 1105: ) { ! 1106: p->reg[PROGCTR] -= 2; ! 1107: } ! 1108: # endif ! 1109: savetty(stdout, &(p->ttyinfo)); ! 1110: addr = (Address) &(((struct user *) 0)->u_signal[p->signo]); ! 1111: p->sigstatus = (Address) ptrace(UREAD, p->pid, addr, 0); ! 1112: } ! 1113: } ! 1114: ! 1115: /* ! 1116: * Set process's user area information from given process structure. ! 1117: */ ! 1118: ! 1119: private setinfo (p, signo) ! 1120: register Process p; ! 1121: int signo; ! 1122: { ! 1123: register int i; ! 1124: register int r; ! 1125: ! 1126: if (signo == DEFSIG) { ! 1127: if (istraced(p) and (p->sigstatus == 0 or p->sigstatus == 1)) { ! 1128: p->signo = 0; ! 1129: } ! 1130: } else { ! 1131: p->signo = signo; ! 1132: } ! 1133: for (i = 0; i < NREG; i++) { ! 1134: if ((r = p->reg[i]) != p->oreg[i]) { ! 1135: writereg(p, rloc[i], r); ! 1136: } ! 1137: } ! 1138: restoretty(stdout, &(p->ttyinfo)); ! 1139: } ! 1140: ! 1141: /* ! 1142: * Return the address associated with the current signal. ! 1143: * (Plus two since the address points to the beginning of a procedure). ! 1144: */ ! 1145: ! 1146: public Address usignal (p) ! 1147: Process p; ! 1148: { ! 1149: Address r; ! 1150: ! 1151: r = p->sigstatus; ! 1152: if (r != 0 and r != 1) { ! 1153: r += FUNCOFFSET; ! 1154: } ! 1155: return r; ! 1156: } ! 1157: ! 1158: /* ! 1159: * Structure for reading and writing by words, but dealing with bytes. ! 1160: */ ! 1161: ! 1162: typedef union { ! 1163: Word pword; ! 1164: Byte pbyte[sizeof(Word)]; ! 1165: } Pword; ! 1166: ! 1167: /* ! 1168: * Read (write) from (to) the process' address space. ! 1169: * We must deal with ptrace's inability to look anywhere other ! 1170: * than at a word boundary. ! 1171: */ ! 1172: ! 1173: private Word fetch(); ! 1174: private store(); ! 1175: ! 1176: private pio(p, op, seg, buff, addr, nbytes) ! 1177: Process p; ! 1178: PioOp op; ! 1179: PioSeg seg; ! 1180: char *buff; ! 1181: Address addr; ! 1182: int nbytes; ! 1183: { ! 1184: register int i; ! 1185: register Address newaddr; ! 1186: register char *cp; ! 1187: char *bufend; ! 1188: Pword w; ! 1189: Address wordaddr; ! 1190: int byteoff; ! 1191: ! 1192: if (p->status != STOPPED) { ! 1193: error("program is not active"); ! 1194: } ! 1195: cp = buff; ! 1196: newaddr = addr; ! 1197: wordaddr = (newaddr&WMASK); ! 1198: if (wordaddr != newaddr) { ! 1199: w.pword = fetch(p, seg, wordaddr); ! 1200: for (i = newaddr - wordaddr; i < sizeof(Word) and nbytes > 0; i++) { ! 1201: if (op == PREAD) { ! 1202: *cp++ = w.pbyte[i]; ! 1203: } else { ! 1204: w.pbyte[i] = *cp++; ! 1205: } ! 1206: nbytes--; ! 1207: } ! 1208: if (op == PWRITE) { ! 1209: store(p, seg, wordaddr, w.pword); ! 1210: } ! 1211: newaddr = wordaddr + sizeof(Word); ! 1212: } ! 1213: byteoff = (nbytes&(~WMASK)); ! 1214: nbytes -= byteoff; ! 1215: bufend = cp + nbytes; ! 1216: #ifdef tahoe ! 1217: if (((int)cp)&WMASK) { ! 1218: /* ! 1219: * Must copy a byte at a time, buffer not word addressable. ! 1220: */ ! 1221: while (cp < bufend) { ! 1222: if (op == PREAD) { ! 1223: w.pword = fetch(p, seg, newaddr); ! 1224: for (i = 0; i < sizeof(Word); i++) ! 1225: *cp++ = w.pbyte[i]; ! 1226: } else { ! 1227: for (i = 0; i < sizeof(Word); i++) ! 1228: w.pbyte[i] = *cp++; ! 1229: store(p, seg, newaddr, w.pword); ! 1230: } ! 1231: newaddr += sizeof(Word); ! 1232: } ! 1233: } else { ! 1234: /* ! 1235: * Buffer, word aligned, act normally... ! 1236: */ ! 1237: #endif ! 1238: while (cp < bufend) { ! 1239: if (op == PREAD) { ! 1240: *((Word *) cp) = fetch(p, seg, newaddr); ! 1241: } else { ! 1242: store(p, seg, newaddr, *((Word *) cp)); ! 1243: } ! 1244: cp += sizeof(Word); ! 1245: newaddr += sizeof(Word); ! 1246: } ! 1247: #ifdef tahoe ! 1248: } ! 1249: #endif ! 1250: if (byteoff > 0) { ! 1251: w.pword = fetch(p, seg, newaddr); ! 1252: for (i = 0; i < byteoff; i++) { ! 1253: if (op == PREAD) { ! 1254: *cp++ = w.pbyte[i]; ! 1255: } else { ! 1256: w.pbyte[i] = *cp++; ! 1257: } ! 1258: } ! 1259: if (op == PWRITE) { ! 1260: store(p, seg, newaddr, w.pword); ! 1261: } ! 1262: } ! 1263: } ! 1264: ! 1265: /* ! 1266: * Get a word from a process at the given address. ! 1267: * The address is assumed to be on a word boundary. ! 1268: * ! 1269: * A simple cache scheme is used to avoid redundant ptrace calls ! 1270: * to the instruction space since it is assumed to be pure. ! 1271: * ! 1272: * It is necessary to use a write-through scheme so that ! 1273: * breakpoints right next to each other don't interfere. ! 1274: */ ! 1275: ! 1276: private Integer nfetchs, nreads, nwrites; ! 1277: ! 1278: private Word fetch(p, seg, addr) ! 1279: Process p; ! 1280: PioSeg seg; ! 1281: register int addr; ! 1282: { ! 1283: register CacheWord *wp; ! 1284: register Word w; ! 1285: ! 1286: switch (seg) { ! 1287: case TEXTSEG: ! 1288: ++nfetchs; ! 1289: wp = &p->word[cachehash(addr)]; ! 1290: if (addr == 0 or wp->addr != addr) { ! 1291: ++nreads; ! 1292: w = ptrace(IREAD, p->pid, addr, 0); ! 1293: wp->addr = addr; ! 1294: wp->val = w; ! 1295: } else { ! 1296: w = wp->val; ! 1297: } ! 1298: break; ! 1299: ! 1300: case DATASEG: ! 1301: w = ptrace(DREAD, p->pid, addr, 0); ! 1302: break; ! 1303: ! 1304: default: ! 1305: panic("fetch: bad seg %d", seg); ! 1306: /* NOTREACHED */ ! 1307: } ! 1308: return w; ! 1309: } ! 1310: ! 1311: /* ! 1312: * Put a word into the process' address space at the given address. ! 1313: * The address is assumed to be on a word boundary. ! 1314: */ ! 1315: ! 1316: private store(p, seg, addr, data) ! 1317: Process p; ! 1318: PioSeg seg; ! 1319: int addr; ! 1320: Word data; ! 1321: { ! 1322: register CacheWord *wp; ! 1323: ! 1324: switch (seg) { ! 1325: case TEXTSEG: ! 1326: ++nwrites; ! 1327: wp = &p->word[cachehash(addr)]; ! 1328: wp->addr = addr; ! 1329: wp->val = data; ! 1330: ptrace(IWRITE, p->pid, addr, data); ! 1331: break; ! 1332: ! 1333: case DATASEG: ! 1334: ptrace(DWRITE, p->pid, addr, data); ! 1335: break; ! 1336: ! 1337: default: ! 1338: panic("store: bad seg %d", seg); ! 1339: /* NOTREACHED */ ! 1340: } ! 1341: } ! 1342: ! 1343: /* ! 1344: * Flush the instruction cache associated with a process. ! 1345: */ ! 1346: ! 1347: private cacheflush (p) ! 1348: Process p; ! 1349: { ! 1350: bzero(p->word, sizeof(p->word)); ! 1351: } ! 1352: ! 1353: public printptraceinfo() ! 1354: { ! 1355: printf("%d fetchs, %d reads, %d writes\n", nfetchs, nreads, nwrites); ! 1356: } ! 1357: ! 1358: /* ! 1359: * Redirect input. ! 1360: * Assuming this is called from a child, we should be careful to avoid ! 1361: * (possibly) shared standard I/O buffers. ! 1362: */ ! 1363: ! 1364: private infrom (filename) ! 1365: String filename; ! 1366: { ! 1367: Fileid in; ! 1368: ! 1369: in = open(filename, 0); ! 1370: if (in == -1) { ! 1371: write(2, "can't read ", 11); ! 1372: write(2, filename, strlen(filename)); ! 1373: write(2, "\n", 1); ! 1374: _exit(1); ! 1375: } ! 1376: fswap(0, in); ! 1377: } ! 1378: ! 1379: /* ! 1380: * Redirect standard output. ! 1381: * Same assumptions as for "infrom" above. ! 1382: */ ! 1383: ! 1384: private outto (filename) ! 1385: String filename; ! 1386: { ! 1387: Fileid out; ! 1388: ! 1389: out = creat(filename, 0666); ! 1390: if (out == -1) { ! 1391: write(2, "can't write ", 12); ! 1392: write(2, filename, strlen(filename)); ! 1393: write(2, "\n", 1); ! 1394: _exit(1); ! 1395: } ! 1396: fswap(1, out); ! 1397: } ! 1398: ! 1399: /* ! 1400: * Swap file numbers, useful for redirecting standard input or output. ! 1401: */ ! 1402: ! 1403: private fswap(oldfd, newfd) ! 1404: Fileid oldfd; ! 1405: Fileid newfd; ! 1406: { ! 1407: if (oldfd != newfd) { ! 1408: close(oldfd); ! 1409: dup(newfd); ! 1410: close(newfd); ! 1411: } ! 1412: } ! 1413: ! 1414: /* ! 1415: * Signal name manipulation. ! 1416: */ ! 1417: ! 1418: private String signames[NSIG] = { ! 1419: 0, ! 1420: "HUP", "INT", "QUIT", "ILL", "TRAP", ! 1421: "IOT", "EMT", "FPE", "KILL", "BUS", ! 1422: "SEGV", "SYS", "PIPE", "ALRM", "TERM", ! 1423: 0, "STOP", "TSTP", "CONT", "CHLD", ! 1424: "TTIN", "TTOU", "TINT", "XCPU", "XFSZ", ! 1425: "VTALRM", "PROF", "WINCH", "USR1", "USR2" ! 1426: }; ! 1427: ! 1428: /* ! 1429: * Get the signal number associated with a given name. ! 1430: * The name is first translated to upper case if necessary. ! 1431: */ ! 1432: ! 1433: public integer siglookup (s) ! 1434: String s; ! 1435: { ! 1436: register char *p, *q; ! 1437: char buf[100]; ! 1438: integer i; ! 1439: ! 1440: p = s; ! 1441: q = buf; ! 1442: while (*p != '\0') { ! 1443: if (*p >= 'a' and *p <= 'z') { ! 1444: *q = (*p - 'a') + 'A'; ! 1445: } else { ! 1446: *q = *p; ! 1447: } ! 1448: ++p; ! 1449: ++q; ! 1450: } ! 1451: *q = '\0'; ! 1452: p = buf; ! 1453: if (buf[0] == 'S' and buf[1] == 'I' and buf[2] == 'G') { ! 1454: p += 3; ! 1455: } ! 1456: i = 1; ! 1457: for (;;) { ! 1458: if (i >= sizeof(signames) div sizeof(signames[0])) { ! 1459: error("signal \"%s\" unknown", s); ! 1460: i = 0; ! 1461: break; ! 1462: } ! 1463: if (signames[i] != nil and streq(signames[i], p)) { ! 1464: break; ! 1465: } ! 1466: ++i; ! 1467: } ! 1468: return i; ! 1469: } ! 1470: ! 1471: /* ! 1472: * Print all signals being ignored by the debugger. ! 1473: * These signals are auotmatically ! 1474: * passed on to the debugged process. ! 1475: */ ! 1476: ! 1477: public printsigsignored (p) ! 1478: Process p; ! 1479: { ! 1480: printsigs(~p->sigset); ! 1481: } ! 1482: ! 1483: /* ! 1484: * Print all signals being intercepted by ! 1485: * the debugger for the specified process. ! 1486: */ ! 1487: ! 1488: public printsigscaught(p) ! 1489: Process p; ! 1490: { ! 1491: printsigs(p->sigset); ! 1492: } ! 1493: ! 1494: private printsigs (set) ! 1495: integer set; ! 1496: { ! 1497: integer s; ! 1498: char separator[2]; ! 1499: ! 1500: separator[0] = '\0'; ! 1501: for (s = 1; s < sizeof(signames) div sizeof(signames[0]); s++) { ! 1502: if (set & setrep(s)) { ! 1503: if (signames[s] != nil) { ! 1504: printf("%s%s", separator, signames[s]); ! 1505: separator[0] = ' '; ! 1506: separator[1] = '\0'; ! 1507: } ! 1508: } ! 1509: } ! 1510: if (separator[0] == ' ') { ! 1511: putchar('\n'); ! 1512: } ! 1513: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.