Home | History | Annotate | Line # | Download | only in gmon
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