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