lib/libc/gmon/gmon.c

   1 /*      $NetBSD: gmon.c,v 1.29 2006/10/15 16:14:46 christos 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.29 2006/10/15 16:14:46 christos 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/sysctl.h>
  82
  83 #include <stdio.h>
  84 #include <stdlib.h>
  85 #include <string.h>
  86 #include <fcntl.h>
  87 #include <limits.h>
  88 #include <unistd.h>
  89 #include <err.h>
  90 #include "extern.h"
  91 #include "reentrant.h"
  92
  93 struct gmonparam _gmonparam = { .state = GMON_PROF_OFF };
  94
  95 #ifdef _REENTRANT
  96 struct gmonparam *_gmonfree;
  97 struct gmonparam *_gmoninuse;
  98 mutex_t _gmonlock = MUTEX_INITIALIZER;
  99 thread_key_t _gmonkey;
 100 struct gmonparam _gmondummy;
 101 #endif
 102
 103 static u_int    s_scale;
 104 /* see profil(2) where this is describe (incorrectly) */
 105 #define         SCALE_1_TO_1    0x10000L
 106
 107 #define ERR(s) write(STDERR_FILENO, s, sizeof(s))
 108
 109 void    moncontrol __P((int));
 110 void    monstartup __P((u_long, u_long));
 111 void    _mcleanup __P((void));
 112 static int hertz __P((void));
 113
 114 #ifdef _REENTRANT
 115 static void _m_gmon_destructor(void *);
 116 struct gmonparam *_m_gmon_alloc(void)  __attribute__((__no_instrument_function__));
 117 static void _m_gmon_merge(void);
 118 static void _m_gmon_merge_two(struct gmonparam *, struct gmonparam *);
 119 #endif
 120
 121 void
 122 monstartup(lowpc, highpc)
 123         u_long lowpc;
 124         u_long highpc;
 125 {
 126         u_long o;
 127         char *cp;
 128         struct gmonparam *p = &_gmonparam;
 129
 130         /*
 131          * round lowpc and highpc to multiples of the density we're using
 132          * so the rest of the scaling (here and in gprof) stays in ints.
 133          */
 134         p->lowpc = rounddown(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
 135         p->highpc = roundup(highpc, HISTFRACTION * sizeof(HISTCOUNTER));
 136         p->textsize = p->highpc - p->lowpc;
 137         p->kcountsize = p->textsize / HISTFRACTION;
 138         p->hashfraction = HASHFRACTION;
 139         p->fromssize = p->textsize / p->hashfraction;
 140         p->tolimit = p->textsize * ARCDENSITY / 100;
 141         if (p->tolimit < MINARCS)
 142                 p->tolimit = MINARCS;
 143         else if (p->tolimit > MAXARCS)
 144                 p->tolimit = MAXARCS;
 145         p->tossize = p->tolimit * sizeof(struct tostruct);
 146
 147         cp = sbrk((intptr_t)(p->kcountsize + p->fromssize + p->tossize));
 148         if (cp == (char *)-1) {
 149                 ERR("monstartup: out of memory\n");
 150                 return;
 151         }
 152 #ifdef notdef
 153         memset(cp, 0, p->kcountsize + p->fromssize + p->tossize);
 154 #endif
 155         p->tos = (struct tostruct *)(void *)cp;
 156         cp += (size_t)p->tossize;
 157         p->kcount = (u_short *)(void *)cp;
 158         cp += (size_t)p->kcountsize;
 159         p->froms = (u_short *)(void *)cp;
 160
 161         __minbrk = sbrk((intptr_t)0);
 162         p->tos[0].link = 0;
 163
 164         o = p->highpc - p->lowpc;
 165         if (p->kcountsize < o) {
 166 #ifndef notdef
 167                 s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;
 168 #else /* avoid floating point */
 169                 u_long quot = o / p->kcountsize;
 170
 171                 if (quot >= 0x10000)
 172                         s_scale = 1;
 173                 else if (quot >= 0x100)
 174                         s_scale = 0x10000 / quot;
 175                 else if (o >= 0x800000)
 176                         s_scale = 0x1000000 / (o / (p->kcountsize >> 8));
 177                 else
 178                         s_scale = 0x1000000 / ((o << 8) / p->kcountsize);
 179 #endif
 180         } else
 181                 s_scale = SCALE_1_TO_1;
 182
 183 #ifdef _REENTRANT
 184         _gmondummy.state = GMON_PROF_BUSY;
 185         thr_keycreate(&_gmonkey, _m_gmon_destructor);
 186 #endif
 187         moncontrol(1);
 188 }
 189
 190 #ifdef _REENTRANT
 191 static void
 192 _m_gmon_destructor(void *arg)
 193 {
 194         struct gmonparam *p = arg, *q, **prev;
 195
 196         if (p == &_gmondummy)
 197                 return;
 198
 199         thr_setspecific(_gmonkey, &_gmondummy);
 200
 201         mutex_lock(&_gmonlock);
 202         /* XXX eww, linear list traversal. */
 203         for (q = _gmoninuse, prev = &_gmoninuse;
 204              q != NULL;
 205              prev = (struct gmonparam **)(void *)&q->kcount,    /* XXX */
 206                  q = (struct gmonparam *)(void *)q->kcount) {
 207                 if (q == p)
 208                         *prev = (struct gmonparam *)(void *)q->kcount;
 209         }
 210         p->kcount = (u_short *)(void *)_gmonfree;
 211         _gmonfree = p;
 212         mutex_unlock(&_gmonlock);
 213
 214         thr_setspecific(_gmonkey, NULL);
 215 }
 216
 217 struct gmonparam *
 218 _m_gmon_alloc(void)
 219 {
 220         struct gmonparam *p;
 221         char *cp;
 222
 223         mutex_lock(&_gmonlock);
 224         if (_gmonfree != NULL) {
 225                 p = _gmonfree;
 226                 _gmonfree = (struct gmonparam *)(void *)p->kcount;
 227                 p->kcount = (u_short *)(void *)_gmoninuse;
 228                 _gmoninuse = p;
 229         } else {
 230                 mutex_unlock(&_gmonlock);
 231                 cp = mmap(NULL,
 232                     (size_t)(sizeof (struct gmonparam) +
 233                         _gmonparam.fromssize + _gmonparam.tossize),
 234                     PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0LL);
 235                 p = (void *)cp;
 236                 *p = _gmonparam;
 237                 p->kcount = NULL;
 238                 cp += sizeof (struct gmonparam);
 239                 memset(cp, 0, (size_t)(p->fromssize + p->tossize));
 240                 p->froms = (u_short *)(void *)cp;
 241                 p->tos = (struct tostruct *)(void *)(cp + p->fromssize);
 242                 mutex_lock(&_gmonlock);
 243                 p->kcount = (u_short *)(void *)_gmoninuse;
 244                 _gmoninuse = p;
 245         }
 246         mutex_unlock(&_gmonlock);
 247         thr_setspecific(_gmonkey, p);
 248
 249         return p;
 250 }
 251
 252 static void
 253 _m_gmon_merge_two(struct gmonparam *p, struct gmonparam *q)
 254 {
 255         u_long fromindex;
 256         u_short *frompcindex, qtoindex, toindex;
 257         u_long selfpc;
 258         u_long endfrom;
 259         long count;
 260         struct tostruct *top;
 261
 262         endfrom = (q->fromssize / sizeof(*q->froms));
 263         for (fromindex = 0; fromindex < endfrom; fromindex++) {
 264                 if (q->froms[fromindex] == 0)
 265                         continue;
 266                 for (qtoindex = q->froms[fromindex]; qtoindex != 0;
 267                      qtoindex = q->tos[qtoindex].link) {
 268                         selfpc = q->tos[qtoindex].selfpc;
 269                         count = q->tos[qtoindex].count;
 270                         /* cribbed from mcount */
 271                         frompcindex = &p->froms[fromindex];
 272                         toindex = *frompcindex;
 273                         if (toindex == 0) {
 274                                 /*
 275                                  *      first time traversing this arc
 276                                  */
 277                                 toindex = ++p->tos[0].link;
 278                                 if (toindex >= p->tolimit)
 279                                         /* halt further profiling */
 280                                         goto overflow;
 281
 282                                 *frompcindex = (u_short)toindex;
 283                                 top = &p->tos[(size_t)toindex];
 284                                 top->selfpc = selfpc;
 285                                 top->count = count;
 286                                 top->link = 0;
 287                                 goto done;
 288                         }
 289                         top = &p->tos[(size_t)toindex];
 290                         if (top->selfpc == selfpc) {
 291                                 /*
 292                                  * arc at front of chain; usual case.
 293                                  */
 294                                 top->count+= count;
 295                                 goto done;
 296                         }
 297                         /*
 298                          * have to go looking down chain for it.
 299                          * top points to what we are looking at,
 300                          * we know it is not at the head of the chain.
 301                          */
 302                         for (; /* goto done */; ) {
 303                                 if (top->link == 0) {
 304                                         /*
 305                                          * top is end of the chain and
 306                                          * none of the chain had
 307                                          * top->selfpc == selfpc.  so
 308                                          * we allocate a new tostruct
 309                                          * and link it to the head of
 310                                          * the chain.
 311                                          */
 312                                         toindex = ++p->tos[0].link;
 313                                         if (toindex >= p->tolimit)
 314                                                 goto overflow;
 315
 316                                         top = &p->tos[(size_t)toindex];
 317                                         top->selfpc = selfpc;
 318                                         top->count = count;
 319                                         top->link = *frompcindex;
 320                                         *frompcindex = (u_short)toindex;
 321                                         goto done;
 322                                 }
 323                                 /*
 324                                  * otherwise, check the next arc on the chain.
 325                                  */
 326                                 top = &p->tos[top->link];
 327                                 if (top->selfpc == selfpc) {
 328                                         /*
 329                                          * there it is.
 330                                          * add to its count.
 331                                          */
 332                                         top->count += count;
 333                                         goto done;
 334                                 }
 335
 336                         }
 337
 338                 done: ;
 339                 }
 340
 341         }
 342  overflow: ;
 343
 344 }
 345
 346 static void
 347 _m_gmon_merge(void)
 348 {
 349         struct gmonparam *q;
 350
 351         mutex_lock(&_gmonlock);
 352
 353         for (q = _gmonfree; q != NULL; q = (struct gmonparam *)(void *)q->kcount)
 354                 _m_gmon_merge_two(&_gmonparam, q);
 355
 356         for (q = _gmoninuse; q != NULL; q = (struct gmonparam *)(void *)q->kcount) {
 357                 q->state = GMON_PROF_OFF;
 358                 _m_gmon_merge_two(&_gmonparam, q);
 359         }
 360
 361         mutex_unlock(&_gmonlock);
 362 }
 363 #endif
 364
 365 void
 366 _mcleanup()
 367 {
 368         int fd;
 369         int fromindex;
 370         int endfrom;
 371         u_long frompc;
 372         int toindex;
 373         struct rawarc rawarc;
 374         struct gmonparam *p = &_gmonparam;
 375         struct gmonhdr gmonhdr, *hdr;
 376         struct clockinfo clockinfo;
 377         int mib[2];
 378         size_t size;
 379         char *profdir;
 380         const char *proffile;
 381         char  buf[PATH_MAX];
 382 #ifdef DEBUG
 383         int logfd, len;
 384         char buf2[200];
 385 #endif
 386
 387         /*
 388          * We disallow writing to the profiling file, if we are a
 389          * set{u,g}id program and our effective {u,g}id does not match
 390          * our real one.
 391          */
 392         if (issetugid() && (geteuid() != getuid() || getegid() != getgid())) {
 393                 warnx("mcount: Profiling of set{u,g}id binaries is not"
 394                     " allowed");
 395                 return;
 396         }
 397
 398         if (p->state == GMON_PROF_ERROR)
 399                 ERR("_mcleanup: tos overflow\n");
 400
 401         size = sizeof(clockinfo);
 402         mib[0] = CTL_KERN;
 403         mib[1] = KERN_CLOCKRATE;
 404         if (sysctl(mib, 2, &clockinfo, &size, NULL, 0) < 0) {
 405                 /*
 406                  * Best guess
 407                  */
 408                 clockinfo.profhz = hertz();
 409         } else if (clockinfo.profhz == 0) {
 410                 if (clockinfo.hz != 0)
 411                         clockinfo.profhz = clockinfo.hz;
 412                 else
 413                         clockinfo.profhz = hertz();
 414         }
 415
 416         moncontrol(0);
 417
 418         if ((profdir = getenv("PROFDIR")) != NULL) {
 419                 /* If PROFDIR contains a null value, no profiling
 420                    output is produced */
 421                 if (*profdir == '\0')
 422                         return;
 423
 424                 if (snprintf(buf, sizeof buf, "%s/%d.%s",
 425                             profdir, getpid(), getprogname()) >= (int)(sizeof buf)) {
 426                         warnx("_mcleanup: internal buffer overflow, PROFDIR too long");
 427                         return;
 428                 }
 429
 430                 proffile = buf;
 431         } else {
 432                 proffile = "gmon.out";
 433         }
 434
 435         fd = open(proffile , O_CREAT|O_TRUNC|O_WRONLY, 0666);
 436         if (fd < 0) {
 437                 warn("mcount: Cannot open `%s'", proffile);
 438                 return;
 439         }
 440 #ifdef DEBUG
 441         logfd = open("gmon.log", O_CREAT|O_TRUNC|O_WRONLY, 0664);
 442         if (logfd < 0) {
 443                 warn("mcount: Cannot open `gmon.log'");
 444                 return;
 445         }
 446         len = snprintf(buf2, sizeof buf2, "[mcleanup1] kcount %p ssiz %lu\n",
 447             p->kcount, p->kcountsize);
 448         (void)write(logfd, buf2, (size_t)len);
 449 #endif
 450 #ifdef _REENTRANT
 451         _m_gmon_merge();
 452 #endif
 453         hdr = (struct gmonhdr *)&gmonhdr;
 454         hdr->lpc = p->lowpc;
 455         hdr->hpc = p->highpc;
 456         hdr->ncnt = (int)(p->kcountsize + sizeof(gmonhdr));
 457         hdr->version = GMONVERSION;
 458         hdr->profrate = clockinfo.profhz;
 459         (void)write(fd, hdr, sizeof *hdr);
 460         (void)write(fd, p->kcount, (size_t)p->kcountsize);
 461         endfrom = (int)(p->fromssize / sizeof(*p->froms));
 462         for (fromindex = 0; fromindex < endfrom; fromindex++) {
 463                 if (p->froms[fromindex] == 0)
 464                         continue;
 465
 466                 frompc = p->lowpc;
 467                 frompc += fromindex * p->hashfraction * sizeof(*p->froms);
 468                 for (toindex = p->froms[fromindex]; toindex != 0;
 469                      toindex = p->tos[toindex].link) {
 470 #ifdef DEBUG
 471                         len = snprintf(buf2, sizeof buf2,
 472                         "[mcleanup2] frompc 0x%lx selfpc 0x%lx count %lu\n" ,
 473                                 (u_long)frompc, (u_long)p->tos[toindex].selfpc,
 474                                 (u_long)p->tos[toindex].count);
 475                         (void)write(logfd, buf2, (size_t)len);
 476 #endif
 477                         rawarc.raw_frompc = frompc;
 478                         rawarc.raw_selfpc = p->tos[toindex].selfpc;
 479                         rawarc.raw_count = p->tos[toindex].count;
 480                         write(fd, &rawarc, sizeof rawarc);
 481                 }
 482         }
 483         close(fd);
 484 }
 485
 486 /*
 487  * Control profiling
 488  *      profiling is what mcount checks to see if
 489  *      all the data structures are ready.
 490  */
 491 void
 492 moncontrol(mode)
 493         int mode;
 494 {
 495         struct gmonparam *p = &_gmonparam;
 496
 497         if (mode) {
 498                 /* start */
 499                 profil((char *)(void *)p->kcount, (size_t)p->kcountsize,
 500                     p->lowpc, s_scale);
 501                 p->state = GMON_PROF_ON;
 502         } else {
 503                 /* stop */
 504                 profil(NULL, 0, (u_long)0, 0);
 505                 p->state = GMON_PROF_OFF;
 506         }
 507 }
 508
 509 /*
 510  * discover the tick frequency of the machine
 511  * if something goes wrong, we return 0, an impossible hertz.
 512  */
 513 static int
 514 hertz()
 515 {
 516         struct itimerval tim;
 517
 518         tim.it_interval.tv_sec = 0;
 519         tim.it_interval.tv_usec = 1;
 520         tim.it_value.tv_sec = 0;
 521         tim.it_value.tv_usec = 0;
 522         setitimer(ITIMER_REAL, &tim, 0);
 523         setitimer(ITIMER_REAL, 0, &tim);
 524         if (tim.it_interval.tv_usec < 2)
 525                 return(0);
 526         return (int)(1000000 / tim.it_interval.tv_usec);
 527 }