![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / db_400|
Return to trace1.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / db_400 |
1.1 root 1: /*
2: * trace1.c
3: *
4: * The information contained herein is a trade secret of Mark Williams
5: * Company, and is confidential information. It is provided under a
6: * license agreement, and may be copied or disclosed only under the
7: * terms of that agreement. Any reproduction or disclosure of this
8: * material without the express written authorization of Mark Williams
9: * Company or persuant to the license agreement is unlawful.
10: *
11: * COHERENT Version 2.3.35
12: * Copyright (c) 1982, 1983, 1984.
13: * An unpublished work by Mark Williams Company, Chicago.
14: * All rights reserved.
15: *
16: * Initialization, command line parsing.
17: */
18: #include <stdio.h>
19: #include <ctype.h>
20: #include <canon.h>
21: #include <l.out.h>
22: #include <sys/timeout.h>
23: #include <sys/proc.h>
24: #include <sys/ptrace.h>
25: #include <signal.h>
26: #include <sys/uproc.h>
27: #include "trace.h"
28:
29: static char *symName();
30:
31: main(argc, argv)
32: char **argv;
33: {
34: initialise();
35: setup(argc, argv);
36: signal(SIGINT, &armsint);
37: signal(SIGQUIT, SIG_IGN);
38: process();
39: }
40:
41: /*
42: * Leave.
43: */
44: leave()
45: {
46: nfree(ssymp);
47: nfree(gblsymMap);
48: killc();
49: exit(0);
50: }
51:
52: /*
53: * Initialize segment formats and clear the breakpoint table.
54: */
55: initialise()
56: {
57: strcpy(segform[DSEG], "w");
58: strcpy(segform[ISEG], "i");
59: strcpy(segform[USEG], "w");
60: bptinit();
61: }
62:
63: /*
64: * Setup arguments.
65: */
66: setup(argc, argv)
67: char **argv;
68: {
69: register char *cp;
70: register int c;
71: register int t;
72: register int u;
73: register int tflag;
74:
75: t = '\0';
76: tflag = 0;
77:
78: /* process command line switches -[cdefkorst] */
79: for (; argc>1; argc--, argv++) {
80: cp = argv[1];
81: if (*cp++ != '-')
82: break;
83: while ((c=*cp++) != '\0') {
84: switch (c) {
85: case 'c':
86: case 'd':
87: case 'e':
88: case 'f':
89: case 'k':
90: case 'o':
91: /* only one of [cdefko] is allowed */
92: if (t != '\0')
93: usage();
94: t = c;
95: continue;
96: case 'r':
97: rflag = 1;
98: continue;
99: case 's':
100: sflag = 1;
101: continue;
102: case 't':
103: tflag = 1;
104: continue;
105: default:
106: usage();
107: }
108: }
109: }
110: switch (t) {
111: case '\0':
112: switch (argc) {
113: case 1:
114: setfh(DEFLT_OBJ, 3);
115: setcore(DEFLT_AUX);
116: break;
117: case 2:
118: setfh(argv[1], 3);
119: break;
120: case 3:
121: setfh(argv[1], 3);
122: setcore(argv[2]);
123: break;
124: default:
125: usage();
126: }
127: break;
128: case 'c':
129: switch (argc) {
130: case 1:
131: setfh(DEFLT_OBJ, 3);
132: setcore(DEFLT_AUX);
133: break;
134: case 2:
135: setcore(argv[1]);
136: break;
137: case 3:
138: setfh(argv[1], 3);
139: setcore(argv[2]);
140: break;
141: default:
142: usage();
143: }
144: break;
145: case 'd':
146: switch (argc) {
147: case 1:
148: setfh("/coherent", 3);
149: setdump("/dev/dump");
150: break;
151: case 3:
152: setfh(argv[1], 3);
153: setdump(argv[2]);
154: break;
155: default:
156: usage();
157: }
158: break;
159: case 'e':
160: if (argc < 2)
161: usage();
162: setfh(argv[1], 3);
163: if (startup(&argv[1], NULL, NULL, 0)==0 || shiftup()==0)
164: leave();
165: break;
166: case 'f':
167: switch (argc) {
168: case 2:
169: setfile(argv[1]);
170: break;
171: case 3:
172: setfh(argv[1], 1);
173: setfile(argv[2]);
174: break;
175: default:
176: usage();
177: }
178: break;
179: case 'k':
180: switch (argc) {
181: case 1:
182: setfh("/coherent", 1);
183: setkmem("/dev/mem");
184: break;
185: case 2:
186: setkmem(argv[1]);
187: break;
188: case 3:
189: setfh(argv[1], 1);
190: setkmem(argv[2]);
191: break;
192: default:
193: usage();
194: }
195: break;
196: case 'o':
197: switch (argc) {
198: case 1:
199: setfh(DEFLT_OBJ, 3);
200: break;
201: case 2:
202: setfh(argv[1], 3);
203: break;
204: case 3:
205: setfh(argv[1], 1);
206: setfh(argv[2], 2);
207: break;
208: default:
209: usage();
210: }
211: }
212: if (tflag) {
213: if ((u=open("/dev/tty", 2)) < 0)
214: panic("Cannot open /dev/tty");
215: dup2(u, 0);
216: dup2(u, 1);
217: dup2(u, 2);
218: }
219: }
220:
221: /*
222: * Generate a usage message.
223: */
224: usage()
225: {
226: panic("Usage: db [-cdefort] [object file] [auxiliary file]");
227: }
228:
229: /*
230: * Catch and flag interrupts.
231: */
232: armsint()
233: {
234: signal(SIGINT, &armsint);
235: intflag++;
236: }
237:
238: /*
239: * Check for interrupts and clear flag.
240: */
241: testint()
242: {
243: register int n;
244:
245: if ((n=intflag) != 0)
246: printe("Interrupt");
247: intflag = 0;
248: return (n);
249: }
250:
251: /*
252: * Assume the file, `np', is the name of an l.out. If the bottom bit
253: * of the flag is set, set up the symbol table. If the next bit is set,
254: * set up segmentation for the l.out.
255: */
256: setlout(np, f)
257: char *np;
258: {
259: struct ldheader ldh;
260:
261: fseek(lfp, 0L, 0L);
262: if (fread(&ldh, sizeof(ldh), 1, lfp) != 1)
263: panic("Cannot read object file");
264: canlout(&ldh);
265: if (ldh.l_magic != L_MAGIC)
266: panic("Bad object file");
267: hdrinfo.magic = ldh.l_magic;
268: hdrinfo.defsegatt = DSA16;
269: objflag = 1;
270: if ((f&1) != 0) {
271: sbase = sizeof(ldh);
272: sbase += ldh.l_ssize[L_SHRI] + ldh.l_ssize[L_PRVI];
273: sbase += ldh.l_ssize[L_SHRD] + ldh.l_ssize[L_PRVD];
274: snsym = ldh.l_ssize[L_SYM] / sizeof(struct ldsym);
275: if (snsym != 0) {
276: sfp = lfp;
277: if (sflag == 0)
278: readsym(sfp);
279: }
280: }
281: if ((f&2) != 0) {
282: lfn = np;
283: setaseg(&ldh);
284: }
285: }
286:
287: /*
288: * Canonicalize an l.out header.
289: */
290: canlout(ldp)
291: struct ldheader *ldp;
292: {
293: register int i;
294:
295: canint(ldp->l_magic);
296: canint(ldp->l_flag);
297: canint(ldp->l_machine);
298: canvaddr(ldp->l_entry);
299: for (i=0; i<NLSEG; i++)
300: cansize(ldp->l_ssize[i]);
301: }
302:
303: /*
304: * Read all global symbols into memory.
305: */
306: readsym(fp)
307: FILE *fp;
308: {
309: register int n, i;
310: register SYM *sp;
311: struct ldsym lds;
312: struct LDSYM LDS;
313:
314: if ((ssymp=nalloc((int)snsym * sizeof(SYM))) == NULL)
315: return;
316: fseek(fp, (long)sbase, 0);
317: for (n=snsym, sp=ssymp; n--; sp++) {
318: if (fread(&lds, sizeof(struct ldsym), 1, fp) != 1) {
319: nfree(ssymp);
320: ssymp = NULL;
321: return;
322: }
323: canint(lds.ls_type);
324: canvaddr(lds.ls_addr);
325: for (i=0; i<NCPLN; i++)
326: LDS.ls_id[i] = lds.ls_id[i];
327: LDS.ls_type = lds.ls_type;
328: LDS.ls_addr = (long)lds.ls_addr;
329:
330: sp->s_hash = hash(&LDS);
331: sp->s_type = LDS.ls_type;
332: sp->s_sval = LDS.ls_addr;
333: }
334: }
335:
336: /*
337: * Hash a symbol name.
338: */
339: hash(ldp)
340: struct LDSYM *ldp;
341: {
342: register int h, n;
343: register char *cp;
344:
345: h = 0;
346: n = CCSSIZE;
347: cp = ldp->ls_id;
348: do {
349: if (*cp != '_')
350: h += *cp;
351: if (*cp++ == '\0')
352: break;
353: } while (--n);
354: return (h&0377);
355: }
356:
357: /*
358: * Set up segmentation for a core dump. The registers are also read.
359: */
360: setcore(np)
361: char *np;
362: {
363: register unsigned i;
364: register MAP *mp;
365: register char *cp;
366: register char *lcp;
367: register fsize_t size;
368: register fsize_t offt;
369: char ucomm[10];
370: SR usegs[NUSEG];
371:
372: cfp = openfil(np, rflag);
373: fseek(cfp, (long)offset(uproc, u_comm[0]), 0);
374: if ((cp=lfn)!=NULL && fread(ucomm, sizeof(ucomm), 1, cfp)==1) {
375: lcp = cp;
376: while (*cp) {
377: if (*cp++ == '/')
378: lcp = cp;
379: }
380: if (strncmp(lcp, ucomm, sizeof(ucomm)) != 0)
381: printr("Core different from object");
382: }
383: fseek(cfp, (long)offset(uproc, u_segl[0]), 0);
384: if (fread(usegs, sizeof(usegs), 1, cfp) != 1)
385: panic("Bad core file");
386: USPACE = setsmap(NULL, (fsize_t)0, (fsize_t)UPASIZE, (fsize_t)0,
387: getf, putf, 1);
388: mp = clrsmap(DSPACE, endpure);
389: offt = usegs[0].sr_size;
390: #ifdef _I386
391: usegs[SISTACK].sr_base -= usegs[SISTACK].sr_size;
392: #endif
393: for (i=1; i<NUSEG; i++) {
394: if (usegs[i].sr_segp == NULL)
395: continue;
396: if ((~usegs[i].sr_flag) & (SRFDUMP|SRFPMAP))
397: continue;
398: size = usegs[i].sr_size;
399: mp = setsmap(mp, (fsize_t)usegs[i].sr_base, size, offt,
400: getf, putf, 1);
401: offt += size;
402: }
403: if (ISPACE == DSPACE)
404: ISPACE = mp;
405: DSPACE = mp;
406: settrap();
407: setregs();
408: }
409:
410: /*
411: * Find out signal sent to traced process.
412: */
413: settrap()
414: {
415: int f;
416:
417: trapstr = "???";
418: add = PTRACE_SIG;
419: if (getb(USEG, (char *)&f, sizeof(f)) == 0) {
420: printr("Cannot read signal in traced process");
421: return 0;
422: }
423: if (f<=0 || f>NSIG) {
424: printr("Bad signal in traced process");
425: return 0;
426: }
427: trapstr = signame[f-1];
428: return f;
429: }
430:
431: /*
432: * Set up segmentation for an ordinary file.
433: * This is really easy.
434: */
435: setfile(np)
436: char *np;
437: {
438: lfp = openfil(np, rflag);
439: DSPACE = setsmap(NULL, (fsize_t)0, (fsize_t)LI, (fsize_t)0,
440: getf, putf, 0);
441: ISPACE = DSPACE;
442: }
443:
444: /*
445: * Open the given file. If `rflag' is set, the file is opened for
446: * read only.
447: */
448: FILE *
449: openfil(np, rflag)
450: char *np;
451: {
452: register FILE *fp;
453:
454: if (rflag) {
455: if ((fp=fopen(np, "r")) != NULL)
456: return (fp);
457: } else {
458: if ((fp=fopen(np, "r+w")) != NULL)
459: return (fp);
460: if ((fp=fopen(np, "r")) != NULL) {
461: printr("%s: opened read only", np);
462: return (fp);
463: }
464: }
465: panic("Cannot open %s", np);
466: }
467:
468: /*
469: * Initialise an element of a segment map.
470: */
471: MAP * setsmap(next, base, size, offt, getf, putf, segi)
472: MAP *next;
473: fsize_t base;
474: fsize_t size;
475: fsize_t offt;
476: int (*getf)();
477: int (*putf)();
478: {
479: register MAP *mp;
480:
481: mp = (MAP *)nalloc(sizeof(MAP));
482: mp->m_next = next;
483: mp->m_base = base;
484: mp->m_bend = base+size;
485: mp->m_offt = offt;
486: mp->m_getf = getf;
487: mp->m_putf = putf;
488: mp->m_segi = segi;
489: return (mp);
490: }
491:
492: /*
493: * Clear a section of a segment map.
494: */
495: MAP * clrsmap(mp, np)
496: register MAP *mp;
497: register MAP *np;
498: {
499: while (mp != np) {
500: nfree(mp);
501: mp = mp->m_next;
502: }
503: return (mp);
504: }
505:
506: /*
507: * Clear all maps.
508: */
509: clramap()
510: {
511: register int n;
512:
513: n = 0;
514: if (segmapl[0] == segmapl[1])
515: segmapl[n++] = NULL;
516: while (n < NSEGM) {
517: segmapl[n] = clrsmap(segmapl[n], NULL);
518: n++;
519: }
520: }
521:
522:
523: /******************************************************************************
524: *
525: * Note some #defines in these include files interferes with
526: * items in preceeding include files. Hence the strange
527: * program order.
528: *
529: ******************************************************************************/
530:
531: #include <coff.h>
532:
533: char *read_str_tab();
534: SCNHDR *read_scns();
535:
536: /*
537: * Setup object file.
538: *
539: * Arguments:
540: * np = file name
541: * f is bit mapped
542: * set 1's bit if reading symbol table info from file "np"
543: * set 2's bit if reading segment info from file "np"
544: */
545: setfh (np,f)
546: char *np;
547: {
548: FILEHDR coffh;
549:
550: lfp = openfil(np, (f&2) ? rflag : 1);
551: if (fread(&coffh, sizeof(coffh), 1, lfp) != 1)
552: panic("Cannot read object file");
553: if (coffh.f_magic == C_386_MAGIC)
554: setcoff(lfp, &coffh, np, f);
555: else setlout(np, f);
556: }
557:
558: setcoff(fp, coffhp, np, f)
559: FILE *fp;
560: FILEHDR *coffhp;
561: char *np;
562: int f;
563: {
564: hdrinfo.magic = coffhp->f_magic;
565: hdrinfo.defsegatt = DSA32;
566: objflag = 1;
567: if (f&1) {
568: if (coffhp->f_nsyms) {
569: sbase = (fsize_t)coffhp->f_symptr;
570: snsym = (fsize_t)coffhp->f_nsyms;
571: if (snsym != 0L) {
572: sfp = fp;
573: if (sflag == 0) {
574: readCoffSym(fp, coffhp);
575: }
576: }
577: }
578: }
579: if (f&2) {
580: lfn = np;
581: setcoffseg(fp, coffhp);
582: }
583: }
584:
585: readCoffSym(fp, coffhp)
586: FILE *fp;
587: FILEHDR *coffhp;
588: {
589: SYMENT coffsym;
590: struct LDSYM lds;
591: SYM *sp;
592: long n;
593: char *str_tabp;
594: SCNHDR *scnhp;
595:
596:
597: str_tabp = read_str_tab(fp, coffhp->f_nsyms, coffhp->f_symptr);
598:
599: scnhp = read_scns(fp, coffhp->f_nscns
600: , sizeof(FILEHDR)+coffhp->f_opthdr);
601:
602: /* could get entry point here FIX 386 */
603:
604: if (scnhp == NULL)
605: return;
606:
607: if ((gblsymMap=nalloc((int)coffhp->f_nsyms * sizeof(off_t))) == NULL) {
608: printf("Not enough memory for the global symbol map.\n");
609: return;
610: }
611: if ((ssymp=nalloc((int)coffhp->f_nsyms * sizeof(SYM))) == NULL) {
612: printf("Not enough memory for the coff symbol header section.\n");
613: return;
614: }
615:
616: fseek(fp, coffhp->f_symptr, 0);
617:
618: for (n=coffhp->f_nsyms, sp=ssymp; n--; ) {
619: if (fread(&coffsym, sizeof(SYMENT), 1, fp) != 1) {
620: printf("Cannot read coff.h symbols\n");
621: nfree(ssymp);
622: ssymp = NULL;
623: return;
624: }
625:
626: switch (coffsym.n_sclass) {
627: case C_EXT:
628: case C_EXTDEF:
629: break;
630: default:
631: continue;
632: }
633:
634: coff_to_lout(&coffsym, &lds, str_tabp, scnhp);
635:
636: sp->s_hash = hash(&lds);
637: sp->s_type = lds.ls_type;
638: sp->s_sval = lds.ls_addr;
639:
640: gblsymMap[sp-ssymp] = snsym - n - 1;
641: sp++;
642: }
643: gblsymMap=(off_t *)realloc( gblsymMap, (sp-ssymp)*sizeof(off_t) );
644: ssymp=(SYM *)realloc( ssymp, (sp-ssymp)*sizeof(SYM) );
645: sngblsym = sp - ssymp;
646: if (str_tabp) nfree(str_tabp);
647: nfree(scnhp);
648: }
649:
650: char *
651: read_str_tab(fp, nsyms, symptr)
652: FILE *fp;
653: long nsyms;
654: long symptr;
655: {
656: long strtab_len, symtab_len;
657: unsigned len;
658: char * strTabp;
659:
660: strtab_len = 0;
661: strTabp = NULL;
662: len = symtab_len = sizeof(SYMENT) * nsyms;
663: if (!len)
664: return(NULL);
665:
666: if (symtab_len != len) {
667: panic("Cannot process small model");
668: }
669: fseek(fp, symptr+len, 0);
670: if (1 != fread(&strtab_len, sizeof(strtab_len), 1, fp)) {
671: strtab_len = 0;
672: }
673: if (!strtab_len)
674: return(NULL);
675:
676: len = strtab_len -= 4;
677: if (len != strtab_len)
678: panic("Cannot process small model");
679: if ( (strTabp = nalloc((int)len)) == NULL ) {
680: printf("Not enough memory for the symbol string table.\n");
681: return(NULL);
682: }
683: if ( fread(strTabp, len, 1, fp) != 1) {
684: printf("Unable to read symbol string table.\n");
685: return(NULL);
686: }
687:
688: return(strTabp);
689: }
690:
691: SCNHDR *
692: read_scns(fp, nscns, scnh_off)
693: FILE *fp;
694: unsigned short nscns, scnh_off;
695: {
696: int len;
697: SCNHDR *scnhp;
698:
699: len = (int)(nscns*sizeof(SCNHDR));
700: if ( (scnhp = nalloc(len)) == NULL ) {
701: printf("Not enough memory for the symbol string table.\n");
702: return(NULL);
703: }
704: fseek(fp, scnh_off, 0);
705: if ( fread(scnhp, len, 1, fp) != 1) {
706: printf("Unable to read section headers.\n");
707: return(NULL);
708: }
709: return(scnhp);
710: }
711:
712: coff_to_lout(coffsymp, ldsp, str_tabp, scnhp)
713: SYMENT *coffsymp;
714: struct LDSYM *ldsp;
715: char *str_tabp;
716: SCNHDR *scnhp;
717: {
718: char *cp;
719: char w1[SYMNMLEN+1];
720:
721: cp = symName(coffsymp, w1, str_tabp);
722: memcpy(ldsp->ls_id, cp, NCPLN-1);
723: ldsp->ls_id[NCPLN-1] = '\0';
724:
725: switch((int)scnhp[coffsymp->n_scnum-1].s_flags) {
726: case STYP_TEXT:
727: ldsp->ls_type = L_GLOBAL + L_SHRI;
728: break;
729: case STYP_DATA:
730: ldsp->ls_type = L_GLOBAL + L_PRVD;
731: break;
732: case STYP_BSS:
733: ldsp->ls_type = L_GLOBAL + L_BSSD;
734: break;
735: default:
736: ldsp->ls_type = -1;
737: panic("Unallowed section flag in coff header");
738: }
739:
740: ldsp->ls_addr = (long)coffsymp->n_value;
741: }
742:
743: /*
744: * Symbol name.
745: */
746: static char *
747: symName(sym, work, str_tabp)
748: SYMENT *sym;
749: char *work;
750: char *str_tabp;
751: {
752: if (!sym->n_zeroes) {
753: return (str_tabp + sym->n_offset - 4);
754: }
755:
756: /* make sure it's zero terminated */
757: memcpy(work, sym->n_name, SYMNMLEN);
758: work[SYMNMLEN] = '\0';
759: return (work);
760: }
761:
762: /* end of trace1.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.