![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to runpcs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / sdb|
Return to runpcs.c CVS log | Up to [Research Unix] / researchv10no / cmd / sdb |
1.1 root 1: static char sccsid[] = "@(#)runpcs.c 4.1 10/9/80";
2: #
3: /*
4: *
5: * UNIX debugger
6: * process control routines for sdb
7: * this is a hack on top of a hack on top of a hack
8: *
9: */
10:
11: #include "head.h"
12: #include <a.out.h>
13: #include <stab.h>
14: struct user u;
15: #include <stdio.h>
16: #include <sys/pioctl.h>
17: #include <sys/proc.h>
18: #include "base.h"
19:
20: #ifndef SIGTRAP
21: #define SIGTRAP SIGTRC
22: #endif
23:
24: MSG NOFORK;
25: MSG ENDPCS;
26: MSG BADWAIT;
27:
28: ADDR sigint;
29: ADDR sigqit;
30: ADDR userpc;
31:
32: /* breakpoints */
33: BKPTR bkpthead;
34:
35: CHAR lastc;
36:
37: INT fcor;
38: INT fsym;
39: STRING errflg;
40: int errno;
41: INT signo;
42:
43: L_INT dot;
44: STRING symfil;
45: INT wtflag;
46: INT pid;
47: INT adrflg;
48: L_INT loopcnt;
49:
50:
51:
52:
53:
54:
55: getsig(sig)
56: { return(sig);
57: }
58:
59: runpcs(runmode,execsig)
60: {
61: REG BKPTR bkpt;
62: IF adrflg THEN userpc=dot; FI
63: WHILE --loopcnt>=0
64: DO
65: if (debug) printf("\ncontinue %x %d\n",userpc,execsig);
66: IF runmode==SINGLE
67: THEN delbp(); /* hardware handles single-stepping */
68: ELSE /* continuing from a breakpoint is hard */
69: IF bkpt=scanbkpt(userpc)
70: THEN execbkpt(bkpt,execsig); execsig=0;
71: FI
72: setbp();
73: FI
74: setrun(runmode,userpc,execsig);
75: bpwait(); chkerr(); execsig=0; delbp(); readregs();
76:
77: loop1: IF (signo==0) ANDF (bkpt=scanbkpt(userpc))
78: THEN /* stopped by BPT instruction */
79: if (debug) printf("\n BPT code; '%s'%o'%o'%d",
80: bkpt->comm,bkpt->comm[0],EOR,bkpt->flag);
81: dot=bkpt->loc;
82: IF bkpt->comm[0] != EOR
83: THEN acommand(bkpt->comm);
84: FI
85: IF bkpt->flag==BKPTEXEC
86: ORF ((bkpt->flag=BKPTEXEC)
87: ANDF bkpt->comm[0]!=EOR)
88: THEN execbkpt(bkpt,execsig); execsig=0; loopcnt++;
89: goto loop1;
90: ELSE bkpt->flag=BKPTSET; bkpt->count=bkpt->initcnt;
91: FI
92: ELSE execsig=signo;
93: if (execsig) break;
94: FI
95: OD
96: if (debug) printf("Returning from runpcs\n");
97: }
98:
99: #define BPOUT 0
100: #define BPIN 1
101: INT bpstate;
102:
103: endpcs()
104: {
105: REG BKPTR bkptr;
106: if (debug) printf("Entering endpcs with pid=%d\n");
107: IF pid
108: THEN killpcs(); pid=0; userpc=1;
109: FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
110: DO IF bkptr->flag
111: THEN bkptr->flag=BKPTSET;
112: FI
113: OD
114: FI
115: bpstate=BPOUT;
116: }
117:
118: setup()
119: {
120: int fd;
121: long tsigs = ~0;
122:
123: fd = openproc(getpid());
124: if (ioctl(fd, PIOCSEXEC, 0) < 0) {
125: close(fd);
126: error("no process ioctl");
127: }
128: close(fsym);
129: fsym = -1;
130: IF (pid = fork()) == 0
131: THEN close(fd);
132: signal(SIGINT,sigint); signal(SIGQUIT,sigqit);
133: if (debug) printf("About to doexec pid=%d\n",pid);
134: doexec(); _exit(0);
135: ELIF pid == -1
136: THEN error(NOFORK);
137: ELSE ioctl(fd, PIOCREXEC, 0);
138: close(fd);
139: datmap.ufd = fcor = openproc(pid);
140: ioctl(fcor, PIOCSMASK, &tsigs);
141: bpwait();
142: readregs();
143: if (debug) printf("About to open symfil = %s\n", symfil);
144: fsym=open(symfil,wtflag);
145: IF errflg
146: THEN printf("%s: cannot execute\n",symfil);
147: if (debug) printf("%d %s\n", errflg, errflg);
148: endpcs();
149: FI
150: FI
151: bpstate=BPOUT;
152: }
153:
154: execbkpt(bkptr,execsig)
155: BKPTR bkptr;
156: {
157: if (debug) printf("exbkpt: %d\n",bkptr->count);
158: delbp();
159: setrun(SINGLE,bkptr->loc,execsig);
160: bkptr->flag=BKPTSET;
161: bpwait(); chkerr(); readregs();
162: }
163:
164: doexec()
165: {
166: char *argl[MAXARG], args[LINSIZ];
167: register char c, redchar, *argsp, **arglp, *filnam;
168:
169: arglp = argl;
170: argsp = args;
171: *arglp++ = symfil;
172: c = ' ';
173:
174: do {
175: while (eqany(c, " \t")) {
176: c = rdc();
177: }
178: if (eqany(c, "<>")) {
179: redchar = c;
180: do {
181: c = rdc();
182: } while (eqany(c, " \t"));
183: filnam = argsp;
184: do {
185: *argsp++ = c;
186: c = rdc();
187: } while (!eqany(c, " <>\t\n"));
188: *argsp++ = '\0';
189: if (redchar == '<') {
190: close(0);
191: if (open(filnam,0) < 0) {
192: printf("%s: cannot open\n",filnam);
193: fflush(stdout);
194: _exit(0);
195: }
196: } else {
197: close(1);
198: if (creat(filnam,0666) < 0) {
199: printf("%s: cannot create\n",filnam);
200: fflush(stdout);
201: _exit(0);
202: }
203: }
204: } else if (c != '\n') {
205: *arglp++ = argsp;
206: do {
207: *argsp++ = c;
208: c = rdc();
209: } while(!eqany(c, " <>\t\n"));
210: *argsp++ = '\0';
211: }
212: } while (c != '\n');
213: *arglp = (char *) 0;
214: if (debug) {
215: char **dap;
216: printf("About to execv(%s, %d)\n",symfil,argl);
217: for (dap = argl; *dap; dap++) {
218: printf("%s, ", *dap);
219: }
220: }
221: execv(symfil, argl);
222: perror("Returned from exect");
223: }
224:
225: BKPTR scanbkpt(adr)
226: ADDR adr;
227: {
228: REG BKPTR bkptr;
229: FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
230: DO IF bkptr->flag ANDF bkptr->loc==adr
231: THEN break;
232: FI
233: OD
234: return(bkptr);
235: }
236:
237: delbp()
238: {
239: REG ADDR a;
240: REG BKPTR bkptr;
241: IF bpstate!=BPOUT
242: THEN
243: FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
244: DO IF bkptr->flag
245: THEN a=bkptr->loc;
246: prwrite(a, &bkptr->ins, 1);
247: FI
248: OD
249: bpstate=BPOUT;
250: FI
251: }
252:
253: setbp()
254: {
255: REG ADDR a;
256: REG BKPTR bkptr;
257: char bpt = BPT;
258:
259: IF bpstate!=BPIN
260: THEN
261: FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
262: DO IF bkptr->flag
263: THEN a = bkptr->loc;
264: prread(a, &bkptr->ins, 1);
265: prwrite(a, &bpt, 1);
266: IF errflg
267: THEN error("cannot set breakpoint: ");
268: printf("%s:%d @ %d\n", adrtoprocp(dot)->pname,
269: adrtolineno(dot), dot);
270: errflg = 0;
271: FI
272: FI
273: OD
274: bpstate=BPIN;
275: FI
276: }
277:
278: #define WSLEEP 10
279:
280: bpwait()
281: {
282: register int w;
283: struct proc p;
284: int pc;
285: int stat;
286: int (*isig)();
287: int nulsig();
288: extern int errno;
289:
290: isig = signal(SIGINT, SIG_IGN);
291: /*
292: * alarm stuff is just in case
293: */
294: for (;;) {
295: signal(SIGALRM, nulsig);
296: alarm(WSLEEP);
297: if (ioctl(fcor, PIOCWSTOP, 0) >= 0)
298: errno = 0;
299: alarm(0);
300: if (errno == 0) {
301: signal(SIGINT, isig);
302: ioctl(fcor, PIOCGETPR, &p);
303: signo = p.p_cursig;
304: prread(UBASE + PC, &pc, sizeof(pc));
305: if (signo == SIGTRAP || signo == SIGSTOP)
306: signo = 0;
307: else if (pc == extaddr("_dbsubn"))
308: signo = 0;
309: else
310: sigprint();
311: return;
312: }
313: if (errno == ENOENT)
314: break;
315: /* still there, still running. try again. */
316: }
317: /*
318: * process has died; wait and report status
319: * should check if it's really our child
320: */
321: signal(SIGALRM, nulsig);
322: alarm(WSLEEP);
323: while ((w = wait(&stat)) != -1 && w != pid)
324: ;
325: alarm(0);
326: pid = 0;
327: signal(SIGINT, isig);
328: close(fcor);
329: pid = 0;
330: corfil = NULL;
331: errflg = ENDPCS;
332: if (w == -1)
333: errflg = BADWAIT;
334: else {
335: if ((stat & 0177) == 0177)
336: printf("trace status? 0%o\n", stat);
337: else {
338: if ((signo = stat & 0177) != 0)
339: sigprint();
340: if (stat & 0200) {
341: printf(" - core dumped");
342: corfil = "core";
343: setcor();
344: }
345: printf("\n");
346: }
347: }
348: }
349:
350: nulsig() {}
351:
352: REGLIST reglist[];
353: readregs()
354: {
355: /*get REG values from pcs*/
356: REG i;
357: FOR i=24; --i>=0;
358: DO prread(UBASE + reglist[i].roffs, (char *)&u + reglist[i].roffs, sizeof(int));
359: OD
360: userpc = *(ADDR *)((char *)&u + PC);
361: }
362:
363: char
364: readchar() {
365: lastc = *argsp++;
366: if (lastc == '\0') lastc = '\n';
367: return(lastc);
368: }
369:
370: char
371: rdc()
372: {
373: register char c;
374:
375: c = *argsp++;
376: return(c == '\0' ? '\n' : c);
377: }
378:
379: /*
380: * miscellaneous /proc hooks
381: */
382:
383: setrun(mode, pc, sig)
384: {
385: int ps;
386:
387: if (pc != 1)
388: prwrite(UBASE + PC, &pc, sizeof(pc));
389: if (mode == SINGLE) {
390: prread(UBASE + PSL, &ps, sizeof(ps));
391: ps |= TBIT;
392: prwrite(UBASE + PSL, &ps, sizeof(ps));
393: }
394: if (sig == 0)
395: ioctl(fcor, PIOCCSIG, 0);
396: ioctl(fcor, PIOCRUN, 0);
397: }
398:
399: killpcs()
400: {
401: long ksig = SIGKILL;
402:
403: ioctl(fcor, PIOCCSIG, 0);
404: ioctl(fcor, PIOCKILL, &ksig);
405: ioctl(fcor, PIOCRUN, 0);
406: /*
407: * assert that it's our child
408: */
409: while (wait((int *)0) >= 0)
410: ;
411: }
412:
413: int
414: openproc(id)
415: int id;
416: {
417: char buf[20];
418: int fd;
419:
420: sprintf(buf, "/proc/%d", id);
421: if ((fd = open(buf, 2)) < 0) {
422: perror("can't open process");
423: longjmp(env, 0);
424: }
425: return (fd);
426: }
427:
428: prread(addr, buf, size)
429: char *buf;
430: {
431:
432: lseek(fcor, (long)addr, 0);
433: if (read(fcor, buf, size) != size)
434: errflg = "can't read process";
435: }
436:
437: prwrite(addr, buf, size)
438: char *buf;
439: {
440:
441: lseek(fcor, (long)addr, 0);
442: if (write(fcor, buf, size) != size)
443: errflg = "can't read process";
444: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.