![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kgmon.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc|
Return to kgmon.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc |
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: char copyright[] =
9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)kgmon.c 5.2 (Berkeley) 2/18/86";
15: #endif not lint
16:
17: #include <sys/param.h>
18: #include <machine/pte.h>
19: #include <sys/file.h>
20: #include <sys/vm.h>
21: #include <stdio.h>
22: #include <nlist.h>
23: #include <ctype.h>
24: #include <sys/gprof.h>
25:
26: #define PROFILING_ON 0
27: #define PROFILING_OFF 3
28:
29: /*
30: * froms is actually a bunch of unsigned shorts indexing tos
31: */
32: u_short *froms;
33: struct tostruct *tos;
34: char *s_lowpc;
35: u_long s_textsize;
36: int ssiz;
37: off_t sbuf;
38:
39: struct nlist nl[] = {
40: #define N_SYSMAP 0
41: { "_Sysmap" },
42: #define N_SYSSIZE 1
43: { "_Syssize" },
44: #define N_FROMS 2
45: { "_froms" },
46: #define N_PROFILING 3
47: { "_profiling" },
48: #define N_S_LOWPC 4
49: { "_s_lowpc" },
50: #define N_S_TEXTSIZE 5
51: { "_s_textsize" },
52: #define N_SBUF 6
53: { "_sbuf" },
54: #define N_SSIZ 7
55: { "_ssiz" },
56: #define N_TOS 8
57: { "_tos" },
58: 0,
59: };
60:
61: #if defined(vax)
62: #define clear(x) ((x) &~ 0x80000000)
63: #endif
64:
65: struct pte *Sysmap;
66:
67: char *system = "/vmunix";
68: char *kmemf = "/dev/kmem";
69: int kmem;
70: int bflag, hflag, kflag, rflag, pflag;
71: int debug = 0;
72:
73: main(argc, argv)
74: int argc;
75: char *argv[];
76: {
77: int mode, disp, openmode = O_RDONLY;
78:
79: argc--, argv++;
80: while (argc > 0 && argv[0][0] == '-') {
81: switch (argv[0][1]) {
82: case 'b':
83: bflag++;
84: openmode = O_RDWR;
85: break;
86: case 'h':
87: hflag++;
88: openmode = O_RDWR;
89: break;
90: case 'r':
91: rflag++;
92: openmode = O_RDWR;
93: break;
94: case 'p':
95: pflag++;
96: openmode = O_RDWR;
97: break;
98: default:
99: printf("Usage: kgmon [ -b -h -r -p system memory ]\n");
100: exit(1);
101: }
102: argc--, argv++;
103: }
104: if (argc > 0) {
105: system = *argv;
106: argv++, argc--;
107: }
108: nlist(system, nl);
109: if (nl[0].n_type == 0) {
110: fprintf(stderr, "%s: no namelist\n", system);
111: exit(2);
112: }
113: if (argc > 0) {
114: kmemf = *argv;
115: kflag++;
116: }
117: kmem = open(kmemf, openmode);
118: if (kmem < 0) {
119: openmode = O_RDONLY;
120: kmem = open(kmemf, openmode);
121: if (kmem < 0) {
122: fprintf(stderr, "cannot open ");
123: perror(kmemf);
124: exit(3);
125: }
126: fprintf(stderr, "%s opened read-only\n", kmemf);
127: if (rflag)
128: fprintf(stderr, "-r supressed\n");
129: if (bflag)
130: fprintf(stderr, "-b supressed\n");
131: if (hflag)
132: fprintf(stderr, "-h supressed\n");
133: rflag = 0;
134: bflag = 0;
135: hflag = 0;
136: }
137: if (kflag) {
138: off_t off;
139:
140: off = clear(nl[N_SYSMAP].n_value);
141: lseek(kmem, off, L_SET);
142: nl[N_SYSSIZE].n_value *= 4;
143: Sysmap = (struct pte *)malloc(nl[N_SYSSIZE].n_value);
144: if (Sysmap == 0) {
145: perror("Sysmap");
146: exit(4);
147: }
148: read(kmem, Sysmap, nl[N_SYSSIZE].n_value);
149: }
150: mode = kfetch(N_PROFILING);
151: if (hflag)
152: disp = PROFILING_OFF;
153: else if (bflag)
154: disp = PROFILING_ON;
155: else
156: disp = mode;
157: if (pflag) {
158: if (openmode == O_RDONLY && mode == PROFILING_ON)
159: fprintf(stderr, "data may be inconsistent\n");
160: dumpstate();
161: }
162: if (rflag)
163: resetstate();
164: turnonoff(disp);
165: fprintf(stdout, "kernel profiling is %s.\n", disp ? "off" : "running");
166: }
167:
168: dumpstate()
169: {
170: int i;
171: int fd;
172: off_t kfroms, ktos;
173: int fromindex, endfrom, fromssize, tossize;
174: u_long frompc;
175: int toindex;
176: struct rawarc rawarc;
177: char buf[BUFSIZ];
178:
179: turnonoff(PROFILING_OFF);
180: fd = creat("gmon.out", 0666);
181: if (fd < 0) {
182: perror("gmon.out");
183: return;
184: }
185: ssiz = kfetch(N_SSIZ);
186: sbuf = kfetch(N_SBUF);
187: klseek(kmem, (off_t)sbuf, L_SET);
188: for (i = ssiz; i > 0; i -= BUFSIZ) {
189: read(kmem, buf, i < BUFSIZ ? i : BUFSIZ);
190: write(fd, buf, i < BUFSIZ ? i : BUFSIZ);
191: }
192: s_textsize = kfetch(N_S_TEXTSIZE);
193: fromssize = s_textsize / HASHFRACTION;
194: froms = (u_short *)malloc(fromssize);
195: kfroms = kfetch(N_FROMS);
196: klseek(kmem, kfroms, L_SET);
197: i = read(kmem, ((char *)(froms)), fromssize);
198: if (i != fromssize) {
199: fprintf(stderr, "read froms: request %d, got %d", fromssize, i);
200: perror("");
201: exit(5);
202: }
203: tossize = (s_textsize * ARCDENSITY / 100) * sizeof(struct tostruct);
204: tos = (struct tostruct *)malloc(tossize);
205: ktos = kfetch(N_TOS);
206: klseek(kmem, ktos, L_SET);
207: i = read(kmem, ((char *)(tos)), tossize);
208: if (i != tossize) {
209: fprintf(stderr, "read tos: request %d, got %d", tossize, i);
210: perror("");
211: exit(6);
212: }
213: s_lowpc = (char *)kfetch(N_S_LOWPC);
214: if (debug)
215: fprintf(stderr, "s_lowpc 0x%x, s_textsize 0x%x\n",
216: s_lowpc, s_textsize);
217: endfrom = fromssize / sizeof(*froms);
218: for (fromindex = 0; fromindex < endfrom; fromindex++) {
219: if (froms[fromindex] == 0)
220: continue;
221: frompc = (u_long)s_lowpc +
222: (fromindex * HASHFRACTION * sizeof(*froms));
223: for (toindex = froms[fromindex]; toindex != 0;
224: toindex = tos[toindex].link) {
225: if (debug)
226: fprintf(stderr,
227: "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
228: frompc, tos[toindex].selfpc, tos[toindex].count);
229: rawarc.raw_frompc = frompc;
230: rawarc.raw_selfpc = (u_long)tos[toindex].selfpc;
231: rawarc.raw_count = tos[toindex].count;
232: write(fd, &rawarc, sizeof (rawarc));
233: }
234: }
235: close(fd);
236: }
237:
238: resetstate()
239: {
240: int i;
241: off_t kfroms, ktos;
242: int fromssize, tossize;
243: char buf[BUFSIZ];
244:
245: turnonoff(PROFILING_OFF);
246: bzero(buf, BUFSIZ);
247: ssiz = kfetch(N_SSIZ);
248: sbuf = kfetch(N_SBUF);
249: ssiz -= sizeof(struct phdr);
250: sbuf += sizeof(struct phdr);
251: klseek(kmem, (off_t)sbuf, L_SET);
252: for (i = ssiz; i > 0; i -= BUFSIZ)
253: if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
254: perror("sbuf write");
255: exit(7);
256: }
257: s_textsize = kfetch(N_S_TEXTSIZE);
258: fromssize = s_textsize / HASHFRACTION;
259: kfroms = kfetch(N_FROMS);
260: klseek(kmem, kfroms, L_SET);
261: for (i = fromssize; i > 0; i -= BUFSIZ)
262: if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
263: perror("kforms write");
264: exit(8);
265: }
266: tossize = (s_textsize * ARCDENSITY / 100) * sizeof(struct tostruct);
267: ktos = kfetch(N_TOS);
268: klseek(kmem, ktos, L_SET);
269: for (i = tossize; i > 0; i -= BUFSIZ)
270: if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
271: perror("ktos write");
272: exit(9);
273: }
274: }
275:
276: turnonoff(onoff)
277: int onoff;
278: {
279: off_t off;
280:
281: if ((off = nl[N_PROFILING].n_value) == 0) {
282: printf("profiling: not defined in kernel\n");
283: exit(10);
284: }
285: klseek(kmem, off, L_SET);
286: write(kmem, (char *)&onoff, sizeof (onoff));
287: }
288:
289: kfetch(index)
290: int index;
291: {
292: off_t off;
293: int value;
294:
295: if ((off = nl[index].n_value) == 0) {
296: printf("%s: not defined in kernel\n", nl[index].n_name);
297: exit(11);
298: }
299: if (klseek(kmem, off, L_SET) == -1) {
300: perror("lseek");
301: exit(12);
302: }
303: if (read(kmem, (char *)&value, sizeof (value)) != sizeof (value)) {
304: perror("read");
305: exit(13);
306: }
307: return (value);
308: }
309:
310: klseek(fd, base, off)
311: int fd, base, off;
312: {
313:
314: if (kflag) {
315: /* get kernel pte */
316: base = clear(base);
317: base = ((int)ptob(Sysmap[btop(base)].pg_pfnum))+(base&(NBPG-1));
318: }
319: return (lseek(fd, base, off));
320: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.