gmon.c revision 1.27 1 /* $NetBSD: gmon.c,v 1.27 2006/10/04 20:22:14 dogcow Exp $ */
2
3 /*
4 * Copyright (c) 2003, 2004 Wasabi Systems, Inc.
5 * All rights reserved.
6 *
7 * Written by Nathan J. Williams for Wasabi Systems, Inc.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed for the NetBSD Project by
20 * Wasabi Systems, Inc.
21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
22 * or promote products derived from this software without specific prior
23 * written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 * POSSIBILITY OF SUCH DAMAGE.
36 */
37
38 /*-
39 * Copyright (c) 1983, 1992, 1993
40 * The Regents of the University of California. All rights reserved.
41 *
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
44 * are met:
45 * 1. Redistributions of source code must retain the above copyright
46 * notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 * notice, this list of conditions and the following disclaimer in the
49 * documentation and/or other materials provided with the distribution.
50 * 3. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 */
66
67 #include <sys/cdefs.h>
68 #if !defined(lint) && defined(LIBC_SCCS)
69 #if 0
70 static char sccsid[] = "@(#)gmon.c 8.1 (Berkeley) 6/4/93";
71 #else
72 __RCSID("$NetBSD: gmon.c,v 1.27 2006/10/04 20:22:14 dogcow Exp $");
73 #endif
74 #endif
75
76 #include "namespace.h"
77 #include <sys/param.h>
78 #include <sys/time.h>
79 #include <sys/gmon.h>
80 #include <sys/mman.h>
81 #include <sys/param.h>
82 #include <sys/sysctl.h>
83
84 #include <stdio.h>
85 #include <stdlib.h>
86 #include <string.h>
87 #include <fcntl.h>
88 #include <limits.h>
89 #include <unistd.h>
90 #include <err.h>
91 #include "extern.h"
92 #include "reentrant.h"
93
94 struct gmonparam _gmonparam = { GMON_PROF_OFF };
95
96 #ifdef _REENTRANT
97 struct gmonparam *_gmonfree;
98 struct gmonparam *_gmoninuse;
99 mutex_t _gmonlock = MUTEX_INITIALIZER;
100 thread_key_t _gmonkey;
101 struct gmonparam _gmondummy;
102 #endif
103
104 static u_int s_scale;
105 /* see profil(2) where this is describe (incorrectly) */
106 #define SCALE_1_TO_1 0x10000L
107
108 #define ERR(s) write(STDERR_FILENO, s, sizeof(s))
109
110 void moncontrol __P((int));
111 void monstartup __P((u_long, u_long));
112 void _mcleanup __P((void));
113 static int hertz __P((void));
114
115 #ifdef _REENTRANT
116 static void _m_gmon_destructor(void *);
117 struct gmonparam *_m_gmon_alloc(void) __attribute__((__no_instrument_function__));
118 static void _m_gmon_merge(void);
119 static void _m_gmon_merge_two(struct gmonparam *, struct gmonparam *);
120 #endif
121
122 void
123 monstartup(lowpc, highpc)
124 u_long lowpc;
125 u_long highpc;
126 {
127 u_long o;
128 char *cp;
129 struct gmonparam *p = &_gmonparam;
130
131 /*
132 * round lowpc and highpc to multiples of the density we're using
133 * so the rest of the scaling (here and in gprof) stays in ints.
134 */
135 p->lowpc = rounddown(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
136 p->highpc = roundup(highpc, HISTFRACTION * sizeof(HISTCOUNTER));
137 p->textsize = p->highpc - p->lowpc;
138 p->kcountsize = p->textsize / HISTFRACTION;
139 p->hashfraction = HASHFRACTION;
140 p->fromssize = p->textsize / p->hashfraction;
141 p->tolimit = p->textsize * ARCDENSITY / 100;
142 if (p->tolimit < MINARCS)
143 p->tolimit = MINARCS;
144 else if (p->tolimit > MAXARCS)
145 p->tolimit = MAXARCS;
146 p->tossize = p->tolimit * sizeof(struct tostruct);
147
148 cp = sbrk((intptr_t)(p->kcountsize + p->fromssize + p->tossize));
149 if (cp == (char *)-1) {
150 ERR("monstartup: out of memory\n");
151 return;
152 }
153 #ifdef notdef
154 memset(cp, 0, p->kcountsize + p->fromssize + p->tossize);
155 #endif
156 p->tos = (struct tostruct *)(void *)cp;
157 cp += (size_t)p->tossize;
158 p->kcount = (u_short *)(void *)cp;
159 cp += (size_t)p->kcountsize;
160 p->froms = (u_short *)(void *)cp;
161
162 __minbrk = sbrk((intptr_t)0);
163 p->tos[0].link = 0;
164
165 o = p->highpc - p->lowpc;
166 if (p->kcountsize < o) {
167 #ifndef notdef
168 s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;
169 #else /* avoid floating point */
170 u_long quot = o / p->kcountsize;
171
172 if (quot >= 0x10000)
173 s_scale = 1;
174 else if (quot >= 0x100)
175 s_scale = 0x10000 / quot;
176 else if (o >= 0x800000)
177 s_scale = 0x1000000 / (o / (p->kcountsize >> 8));
178 else
179 s_scale = 0x1000000 / ((o << 8) / p->kcountsize);
180 #endif
181 } else
182 s_scale = SCALE_1_TO_1;
183
184 #ifdef _REENTRANT
185 _gmondummy.state = GMON_PROF_BUSY;
186 thr_keycreate(&_gmonkey, _m_gmon_destructor);
187 #endif
188 moncontrol(1);
189 }
190
191 #ifdef _REENTRANT
192 static void
193 _m_gmon_destructor(void *arg)
194 {
195 struct gmonparam *p = arg, *q, **prev;
196
197 if (p == &_gmondummy)
198 return;
199
200 thr_setspecific(_gmonkey, &_gmondummy);
201
202 mutex_lock(&_gmonlock);
203 /* XXX eww, linear list traversal. */
204 for (q = _gmoninuse, prev = &_gmoninuse;
205 q != NULL;
206 prev = (struct gmonparam **)(void *)&q->kcount, /* XXX */
207 q = (struct gmonparam *)(void *)q->kcount) {
208 if (q == p)
209 *prev = (struct gmonparam *)(void *)q->kcount;
210 }
211 p->kcount = (u_short *)(void *)_gmonfree;
212 _gmonfree = p;
213 mutex_unlock(&_gmonlock);
214
215 thr_setspecific(_gmonkey, NULL);
216 }
217
218 struct gmonparam *
219 _m_gmon_alloc(void)
220 {
221 struct gmonparam *p;
222 char *cp;
223
224 mutex_lock(&_gmonlock);
225 if (_gmonfree != NULL) {
226 p = _gmonfree;
227 _gmonfree = (struct gmonparam *)(void *)p->kcount;
228 p->kcount = (u_short *)(void *)_gmoninuse;
229 _gmoninuse = p;
230 } else {
231 mutex_unlock(&_gmonlock);
232 cp = mmap(NULL,
233 (size_t)(sizeof (struct gmonparam) +
234 _gmonparam.fromssize + _gmonparam.tossize),
235 PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0LL);
236 p = (void *)cp;
237 *p = _gmonparam;
238 p->kcount = NULL;
239 cp += sizeof (struct gmonparam);
240 memset(cp, 0, (size_t)(p->fromssize + p->tossize));
241 p->froms = (u_short *)(void *)cp;
242 p->tos = (struct tostruct *)(void *)(cp + p->fromssize);
243 mutex_lock(&_gmonlock);
244 p->kcount = (u_short *)(void *)_gmoninuse;
245 _gmoninuse = p;
246 }
247 mutex_unlock(&_gmonlock);
248 thr_setspecific(_gmonkey, p);
249
250 return p;
251 }
252
253 static void
254 _m_gmon_merge_two(struct gmonparam *p, struct gmonparam *q)
255 {
256 u_long fromindex;
257 u_short *frompcindex, qtoindex, toindex;
258 u_long selfpc;
259 int endfrom;
260 long count;
261 struct tostruct *top;
262
263 endfrom = (int)(q->fromssize / sizeof(*q->froms));
264 for (fromindex = 0; fromindex < endfrom; fromindex++) {
265 if (q->froms[fromindex] == 0)
266 continue;
267 for (qtoindex = q->froms[fromindex]; qtoindex != 0;
268 qtoindex = q->tos[qtoindex].link) {
269 selfpc = q->tos[qtoindex].selfpc;
270 count = q->tos[qtoindex].count;
271 /* cribbed from mcount */
272 frompcindex = &p->froms[fromindex];
273 toindex = *frompcindex;
274 if (toindex == 0) {
275 /*
276 * first time traversing this arc
277 */
278 toindex = ++p->tos[0].link;
279 if (toindex >= p->tolimit)
280 /* halt further profiling */
281 goto overflow;
282
283 *frompcindex = (u_short)toindex;
284 top = &p->tos[(size_t)toindex];
285 top->selfpc = selfpc;
286 top->count = count;
287 top->link = 0;
288 goto done;
289 }
290 top = &p->tos[(size_t)toindex];
291 if (top->selfpc == selfpc) {
292 /*
293 * arc at front of chain; usual case.
294 */
295 top->count+= count;
296 goto done;
297 }
298 /*
299 * have to go looking down chain for it.
300 * top points to what we are looking at,
301 * we know it is not at the head of the chain.
302 */
303 for (; /* goto done */; ) {
304 if (top->link == 0) {
305 /*
306 * top is end of the chain and
307 * none of the chain had
308 * top->selfpc == selfpc. so
309 * we allocate a new tostruct
310 * and link it to the head of
311 * the chain.
312 */
313 toindex = ++p->tos[0].link;
314 if (toindex >= p->tolimit)
315 goto overflow;
316
317 top = &p->tos[(size_t)toindex];
318 top->selfpc = selfpc;
319 top->count = count;
320 top->link = *frompcindex;
321 *frompcindex = (u_short)toindex;
322 goto done;
323 }
324 /*
325 * otherwise, check the next arc on the chain.
326 */
327 top = &p->tos[top->link];
328 if (top->selfpc == selfpc) {
329 /*
330 * there it is.
331 * add to its count.
332 */
333 top->count += count;
334 goto done;
335 }
336
337 }
338
339 done: ;
340 }
341
342 }
343 overflow: ;
344
345 }
346
347 static void
348 _m_gmon_merge(void)
349 {
350 struct gmonparam *q;
351
352 mutex_lock(&_gmonlock);
353
354 for (q = _gmonfree; q != NULL; q = (struct gmonparam *)(void *)q->kcount)
355 _m_gmon_merge_two(&_gmonparam, q);
356
357 for (q = _gmoninuse; q != NULL; q = (struct gmonparam *)(void *)q->kcount) {
358 q->state = GMON_PROF_OFF;
359 _m_gmon_merge_two(&_gmonparam, q);
360 }
361
362 mutex_unlock(&_gmonlock);
363 }
364 #endif
365
366 void
367 _mcleanup()
368 {
369 int fd;
370 int fromindex;
371 int endfrom;
372 u_long frompc;
373 int toindex;
374 struct rawarc rawarc;
375 struct gmonparam *p = &_gmonparam;
376 struct gmonhdr gmonhdr, *hdr;
377 struct clockinfo clockinfo;
378 int mib[2];
379 size_t size;
380 char *profdir;
381 const char *proffile;
382 char buf[PATH_MAX];
383 #ifdef DEBUG
384 int logfd, len;
385 char buf2[200];
386 #endif
387
388 /*
389 * We disallow writing to the profiling file, if we are a
390 * set{u,g}id program and our effective {u,g}id does not match
391 * our real one.
392 */
393 if (issetugid() && (geteuid() != getuid() || getegid() != getgid())) {
394 warnx("mcount: Profiling of set{u,g}id binaries is not"
395 " allowed");
396 return;
397 }
398
399 if (p->state == GMON_PROF_ERROR)
400 ERR("_mcleanup: tos overflow\n");
401
402 size = sizeof(clockinfo);
403 mib[0] = CTL_KERN;
404 mib[1] = KERN_CLOCKRATE;
405 if (sysctl(mib, 2, &clockinfo, &size, NULL, 0) < 0) {
406 /*
407 * Best guess
408 */
409 clockinfo.profhz = hertz();
410 } else if (clockinfo.profhz == 0) {
411 if (clockinfo.hz != 0)
412 clockinfo.profhz = clockinfo.hz;
413 else
414 clockinfo.profhz = hertz();
415 }
416
417 moncontrol(0);
418
419 if ((profdir = getenv("PROFDIR")) != NULL) {
420 /* If PROFDIR contains a null value, no profiling
421 output is produced */
422 if (*profdir == '\0')
423 return;
424
425 if (snprintf(buf, sizeof buf, "%s/%d.%s",
426 profdir, getpid(), getprogname()) >= sizeof buf) {
427 warnx("_mcleanup: internal buffer overflow, PROFDIR too long");
428 return;
429 }
430
431 proffile = buf;
432 } else {
433 proffile = "gmon.out";
434 }
435
436 fd = open(proffile , O_CREAT|O_TRUNC|O_WRONLY, 0666);
437 if (fd < 0) {
438 warn("mcount: Cannot open `%s'", proffile);
439 return;
440 }
441 #ifdef DEBUG
442 logfd = open("gmon.log", O_CREAT|O_TRUNC|O_WRONLY, 0664);
443 if (logfd < 0) {
444 warn("mcount: Cannot open `gmon.log'");
445 return;
446 }
447 len = snprintf(buf2, sizeof buf2, "[mcleanup1] kcount %p ssiz %lu\n",
448 p->kcount, p->kcountsize);
449 (void)write(logfd, buf2, (size_t)len);
450 #endif
451 #ifdef _REENTRANT
452 _m_gmon_merge();
453 #endif
454 hdr = (struct gmonhdr *)&gmonhdr;
455 hdr->lpc = p->lowpc;
456 hdr->hpc = p->highpc;
457 hdr->ncnt = (int)(p->kcountsize + sizeof(gmonhdr));
458 hdr->version = GMONVERSION;
459 hdr->profrate = clockinfo.profhz;
460 (void)write(fd, hdr, sizeof *hdr);
461 (void)write(fd, p->kcount, (size_t)p->kcountsize);
462 endfrom = (int)(p->fromssize / sizeof(*p->froms));
463 for (fromindex = 0; fromindex < endfrom; fromindex++) {
464 if (p->froms[fromindex] == 0)
465 continue;
466
467 frompc = p->lowpc;
468 frompc += fromindex * p->hashfraction * sizeof(*p->froms);
469 for (toindex = p->froms[fromindex]; toindex != 0;
470 toindex = p->tos[toindex].link) {
471 #ifdef DEBUG
472 len = snprintf(buf2, sizeof buf2,
473 "[mcleanup2] frompc 0x%lx selfpc 0x%lx count %lu\n" ,
474 (u_long)frompc, (u_long)p->tos[toindex].selfpc,
475 (u_long)p->tos[toindex].count);
476 (void)write(logfd, buf2, (size_t)len);
477 #endif
478 rawarc.raw_frompc = frompc;
479 rawarc.raw_selfpc = p->tos[toindex].selfpc;
480 rawarc.raw_count = p->tos[toindex].count;
481 write(fd, &rawarc, sizeof rawarc);
482 }
483 }
484 close(fd);
485 }
486
487 /*
488 * Control profiling
489 * profiling is what mcount checks to see if
490 * all the data structures are ready.
491 */
492 void
493 moncontrol(mode)
494 int mode;
495 {
496 struct gmonparam *p = &_gmonparam;
497
498 if (mode) {
499 /* start */
500 profil((char *)(void *)p->kcount, (size_t)p->kcountsize,
501 p->lowpc, s_scale);
502 p->state = GMON_PROF_ON;
503 } else {
504 /* stop */
505 profil(NULL, 0, (u_long)0, 0);
506 p->state = GMON_PROF_OFF;
507 }
508 }
509
510 /*
511 * discover the tick frequency of the machine
512 * if something goes wrong, we return 0, an impossible hertz.
513 */
514 static int
515 hertz()
516 {
517 struct itimerval tim;
518
519 tim.it_interval.tv_sec = 0;
520 tim.it_interval.tv_usec = 1;
521 tim.it_value.tv_sec = 0;
522 tim.it_value.tv_usec = 0;
523 setitimer(ITIMER_REAL, &tim, 0);
524 setitimer(ITIMER_REAL, 0, &tim);
525 if (tim.it_interval.tv_usec < 2)
526 return(0);
527 return (int)(1000000 / tim.it_interval.tv_usec);
528 }
529