gmon/gmon.c

   1 /*-
   2  * Copyright (c) 1983, 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29 #include <sys/param.h>
  30 #include <sys/time.h>
  31 #include <sys/gmon.h>
  32 #include <sys/gmon_out.h>
  33 #include <sys/uio.h>
  34
  35 #include <errno.h>
  36 #include <stdio.h>
  37 #include <fcntl.h>
  38 #include <unistd.h>
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44 #include <libc-internal.h>
  45
  46 #ifdef USE_IN_LIBIO
  47 # include <wchar.h>
  48 #endif
  49
  50 /*  Head of basic-block list or NULL. */
  51 struct __bb *__bb_head attribute_hidden;
  52
  53 struct gmonparam _gmonparam attribute_hidden = { GMON_PROF_OFF };
  54
  55 /*
  56  * See profil(2) where this is described:
  57  */
  58 static int      s_scale;
  59 #define         SCALE_1_TO_1    0x10000L
  60
  61 #define ERR(s) __write (STDERR_FILENO, s, sizeof (s) - 1)
  62
  63 void moncontrol __P ((int mode));
  64 void __moncontrol __P ((int mode));
  65 static void write_hist __P ((int fd)) internal_function;
  66 static void write_call_graph __P ((int fd)) internal_function;
  67 static void write_bb_counts __P ((int fd)) internal_function;
  68
  69 /*
  70  * Control profiling
  71  *      profiling is what mcount checks to see if
  72  *      all the data structures are ready.
  73  */
  74 void
  75 __moncontrol (mode)
  76      int mode;
  77 {
  78   struct gmonparam *p = &_gmonparam;
  79
  80   /* Don't change the state if we ran into an error.  */
  81   if (p->state == GMON_PROF_ERROR)
  82     return;
  83
  84   if (mode)
  85     {
  86       /* start */
  87       __profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale);
  88       p->state = GMON_PROF_ON;
  89     }
  90   else
  91     {
  92       /* stop */
  93       __profil(NULL, 0, 0, 0);
  94       p->state = GMON_PROF_OFF;
  95     }
  96 }
  97 weak_alias (__moncontrol, moncontrol)
  98
  99
 100 void
 101 __monstartup (lowpc, highpc)
 102      u_long lowpc;
 103      u_long highpc;
 104 {
 105   register int o;
 106   char *cp;
 107   struct gmonparam *p = &_gmonparam;
 108
 109   /*
 110    * round lowpc and highpc to multiples of the density we're using
 111    * so the rest of the scaling (here and in gprof) stays in ints.
 112    */
 113   p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
 114   p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER));
 115   p->textsize = p->highpc - p->lowpc;
 116   p->kcountsize = p->textsize / HISTFRACTION;
 117   p->hashfraction = HASHFRACTION;
 118   p->log_hashfraction = -1;
 119   /* The following test must be kept in sync with the corresponding
 120      test in mcount.c.  */
 121   if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) {
 122       /* if HASHFRACTION is a power of two, mcount can use shifting
 123          instead of integer division.  Precompute shift amount. */
 124       p->log_hashfraction = ffs(p->hashfraction * sizeof(*p->froms)) - 1;
 125   }
 126   p->fromssize = p->textsize / HASHFRACTION;
 127   p->tolimit = p->textsize * ARCDENSITY / 100;
 128   if (p->tolimit < MINARCS)
 129     p->tolimit = MINARCS;
 130   else if (p->tolimit > MAXARCS)
 131     p->tolimit = MAXARCS;
 132   p->tossize = p->tolimit * sizeof(struct tostruct);
 133
 134   cp = calloc (p->kcountsize + p->fromssize + p->tossize, 1);
 135   if (! cp)
 136     {
 137       ERR("monstartup: out of memory\n");
 138       p->tos = NULL;
 139       p->state = GMON_PROF_ERROR;
 140       return;
 141     }
 142   p->tos = (struct tostruct *)cp;
 143   cp += p->tossize;
 144   p->kcount = (HISTCOUNTER *)cp;
 145   cp += p->kcountsize;
 146   p->froms = (ARCINDEX *)cp;
 147
 148   p->tos[0].link = 0;
 149
 150   o = p->highpc - p->lowpc;
 151   if (p->kcountsize < (u_long) o)
 152     {
 153 #ifndef hp300
 154       s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;
 155 #else
 156       /* avoid floating point operations */
 157       int quot = o / p->kcountsize;
 158
 159       if (quot >= 0x10000)
 160         s_scale = 1;
 161       else if (quot >= 0x100)
 162         s_scale = 0x10000 / quot;
 163       else if (o >= 0x800000)
 164         s_scale = 0x1000000 / (o / (p->kcountsize >> 8));
 165       else
 166         s_scale = 0x1000000 / ((o << 8) / p->kcountsize);
 167 #endif
 168     } else
 169       s_scale = SCALE_1_TO_1;
 170
 171   __moncontrol(1);
 172 }
 173 weak_alias(__monstartup, monstartup)
 174
 175
 176 static void
 177 internal_function
 178 write_hist (fd)
 179      int fd;
 180 {
 181   u_char tag = GMON_TAG_TIME_HIST;
 182   struct gmon_hist_hdr thdr __attribute__ ((aligned (__alignof__ (char *))));
 183
 184   if (_gmonparam.kcountsize > 0)
 185     {
 186       struct iovec iov[3] =
 187         {
 188           { &tag, sizeof (tag) },
 189           { &thdr, sizeof (struct gmon_hist_hdr) },
 190           { _gmonparam.kcount, _gmonparam.kcountsize }
 191         };
 192
 193       *(char **) thdr.low_pc = (char *) _gmonparam.lowpc;
 194       *(char **) thdr.high_pc = (char *) _gmonparam.highpc;
 195       *(int32_t *) thdr.hist_size = (_gmonparam.kcountsize
 196                                      / sizeof (HISTCOUNTER));
 197       *(int32_t *) thdr.prof_rate = __profile_frequency ();
 198       strncpy (thdr.dimen, "seconds", sizeof (thdr.dimen));
 199       thdr.dimen_abbrev = 's';
 200
 201       __writev (fd, iov, 3);
 202     }
 203 }
 204
 205
 206 static void
 207 internal_function
 208 write_call_graph (fd)
 209      int fd;
 210 {
 211 #define NARCS_PER_WRITEV        32
 212   u_char tag = GMON_TAG_CG_ARC;
 213   struct gmon_cg_arc_record raw_arc[NARCS_PER_WRITEV]
 214     __attribute__ ((aligned (__alignof__ (char*))));
 215   ARCINDEX from_index, to_index;
 216   u_long from_len;
 217   u_long frompc;
 218   struct iovec iov[2 * NARCS_PER_WRITEV];
 219   int nfilled;
 220
 221   for (nfilled = 0; nfilled < NARCS_PER_WRITEV; ++nfilled)
 222     {
 223       iov[2 * nfilled].iov_base = &tag;
 224       iov[2 * nfilled].iov_len = sizeof (tag);
 225
 226       iov[2 * nfilled + 1].iov_base = &raw_arc[nfilled];
 227       iov[2 * nfilled + 1].iov_len = sizeof (struct gmon_cg_arc_record);
 228     }
 229
 230   nfilled = 0;
 231   from_len = _gmonparam.fromssize / sizeof (*_gmonparam.froms);
 232   for (from_index = 0; from_index < from_len; ++from_index)
 233     {
 234       if (_gmonparam.froms[from_index] == 0)
 235         continue;
 236
 237       frompc = _gmonparam.lowpc;
 238       frompc += (from_index * _gmonparam.hashfraction
 239                  * sizeof (*_gmonparam.froms));
 240       for (to_index = _gmonparam.froms[from_index];
 241            to_index != 0;
 242            to_index = _gmonparam.tos[to_index].link)
 243         {
 244           struct arc
 245             {
 246               char *frompc;
 247               char *selfpc;
 248               int32_t count;
 249             }
 250           arc;
 251
 252           arc.frompc = (char *) frompc;
 253           arc.selfpc = (char *) _gmonparam.tos[to_index].selfpc;
 254           arc.count  = _gmonparam.tos[to_index].count;
 255           memcpy (raw_arc + nfilled, &arc, sizeof (raw_arc [0]));
 256
 257           if (++nfilled == NARCS_PER_WRITEV)
 258             {
 259               __writev (fd, iov, 2 * nfilled);
 260               nfilled = 0;
 261             }
 262         }
 263     }
 264   if (nfilled > 0)
 265     __writev (fd, iov, 2 * nfilled);
 266 }
 267
 268
 269 static void
 270 internal_function
 271 write_bb_counts (fd)
 272      int fd;
 273 {
 274   struct __bb *grp;
 275   u_char tag = GMON_TAG_BB_COUNT;
 276   size_t ncounts;
 277   size_t i;
 278
 279   struct iovec bbhead[2] =
 280     {
 281       { &tag, sizeof (tag) },
 282       { &ncounts, sizeof (ncounts) }
 283     };
 284   struct iovec bbbody[8];
 285   size_t nfilled;
 286
 287   for (i = 0; i < (sizeof (bbbody) / sizeof (bbbody[0])); i += 2)
 288     {
 289       bbbody[i].iov_len = sizeof (grp->addresses[0]);
 290       bbbody[i + 1].iov_len = sizeof (grp->counts[0]);
 291     }
 292
 293   /* Write each group of basic-block info (all basic-blocks in a
 294      compilation unit form a single group). */
 295
 296   for (grp = __bb_head; grp; grp = grp->next)
 297     {
 298       ncounts = grp->ncounts;
 299       __writev (fd, bbhead, 2);
 300       for (nfilled = i = 0; i < ncounts; ++i)
 301         {
 302           if (nfilled > (sizeof (bbbody) / sizeof (bbbody[0])) - 2)
 303             {
 304               __writev (fd, bbbody, nfilled);
 305               nfilled = 0;
 306             }
 307
 308           bbbody[nfilled++].iov_base = (char *) &grp->addresses[i];
 309           bbbody[nfilled++].iov_base = &grp->counts[i];
 310         }
 311       if (nfilled > 0)
 312         __writev (fd, bbbody, nfilled);
 313     }
 314 }
 315
 316
 317 static void
 318 write_gmon (void)
 319 {
 320     struct gmon_hdr ghdr __attribute__ ((aligned (__alignof__ (int))));
 321     int fd = -1;
 322     char *env;
 323
 324 #ifndef O_NOFOLLOW
 325 # define O_NOFOLLOW     0
 326 #endif
 327
 328     env = getenv ("GMON_OUT_PREFIX");
 329     if (env != NULL && !__libc_enable_secure)
 330       {
 331         size_t len = strlen (env);
 332         char buf[len + 20];
 333         sprintf (buf, "%s.%u", env, __getpid ());
 334         fd = __open (buf, O_CREAT|O_TRUNC|O_WRONLY|O_NOFOLLOW, 0666);
 335       }
 336
 337     if (fd == -1)
 338       {
 339         fd = __open ("gmon.out", O_CREAT|O_TRUNC|O_WRONLY|O_NOFOLLOW, 0666);
 340         if (fd < 0)
 341           {
 342             char buf[300];
 343             int errnum = errno;
 344 #ifdef USE_IN_LIBIO
 345             if (_IO_fwide (stderr, 0) > 0)
 346               __fwprintf (stderr, L"_mcleanup: gmon.out: %s\n",
 347                           __strerror_r (errnum, buf, sizeof buf));
 348             else
 349 #endif
 350               fprintf (stderr, "_mcleanup: gmon.out: %s\n",
 351                        __strerror_r (errnum, buf, sizeof buf));
 352             return;
 353           }
 354       }
 355
 356     /* write gmon.out header: */
 357     memset (&ghdr, '\0', sizeof (struct gmon_hdr));
 358     memcpy (&ghdr.cookie[0], GMON_MAGIC, sizeof (ghdr.cookie));
 359     *(int32_t *) ghdr.version = GMON_VERSION;
 360     __write (fd, &ghdr, sizeof (struct gmon_hdr));
 361
 362     /* write PC histogram: */
 363     write_hist (fd);
 364
 365     /* write call-graph: */
 366     write_call_graph (fd);
 367
 368     /* write basic-block execution counts: */
 369     write_bb_counts (fd);
 370
 371     __close (fd);
 372 }
 373
 374
 375 void
 376 __write_profiling (void)
 377 {
 378   int save = _gmonparam.state;
 379   _gmonparam.state = GMON_PROF_OFF;
 380   if (save == GMON_PROF_ON)
 381     write_gmon ();
 382   _gmonparam.state = save;
 383 }
 384 #ifndef SHARED
 385 /* This symbol isn't used anywhere in the DSO and it is not exported.
 386    This would normally mean it should be removed to get the same API
 387    in static libraries.  But since profiling is special in static libs
 388    anyway we keep it.  But not when building the DSO since some
 389    quality assurance tests will otherwise trigger.  */
 390 weak_alias (__write_profiling, write_profiling)
 391 #endif
 392
 393
 394 void
 395 _mcleanup (void)
 396 {
 397   __moncontrol (0);
 398
 399   if (_gmonparam.state != GMON_PROF_ERROR)
 400     write_gmon ();
 401
 402   /* free the memory. */
 403   if (_gmonparam.tos != NULL)
 404     free (_gmonparam.tos);
 405 }