![[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.