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