1/*-
2 * Copyright (c) 1983, 1992, 1993, 2011
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#include <wchar.h>
40
41#include <stdio.h>
42#include <stdlib.h>
43#include <string.h>
44#include <stddef.h>
45#include <unistd.h>
46#include <libc-internal.h>
47#include <not-cancel.h>
48
49#define TUNABLE_NAMESPACE gmon
50#include <elf/dl-tunables.h>
51
52#ifdef PIC
53# include <link.h>
54
55static int
56callback (struct dl_phdr_info *info, size_t size, void *data)
57{
58 if (info->dlpi_name[0] == '\0')
59 {
60 /* The link map for the executable is created by calling
61 _dl_new_object with "" as filename. dl_iterate_phdr
62 calls the callback function with filename from the
63 link map as dlpi_name. */
64 u_long *load_address = data;
65 *load_address = (u_long) info->dlpi_addr;
66 return 1;
67 }
68
69 return 0;
70}
71#endif
72
73/* Head of basic-block list or NULL. */
74struct __bb *__bb_head attribute_hidden;
75
76struct gmonparam _gmonparam attribute_hidden = { GMON_PROF_OFF };
77
78/*
79 * See profil(2) where this is described:
80 */
81static int s_scale;
82#define SCALE_1_TO_1 0x10000L
83
84#define ERR(s) __write_nocancel (STDERR_FILENO, s, sizeof (s) - 1)
85
86void moncontrol (int mode);
87void __moncontrol (int mode);
88libc_hidden_proto (__moncontrol)
89static void write_hist (int fd, u_long load_address);
90static void write_call_graph (int fd, u_long load_address);
91static void write_bb_counts (int fd);
92
93/*
94 * Control profiling
95 * profiling is what mcount checks to see if
96 * all the data structures are ready.
97 */
98void
99__moncontrol (int mode)
100{
101 struct gmonparam *p = &_gmonparam;
102
103 /* Treat start request as stop if error or gmon not initialized. */
104 if (mode && p->state != GMON_PROF_ERROR && p->tos != NULL)
105 {
106 /* start */
107 __profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale);
108 p->state = GMON_PROF_ON;
109 }
110 else
111 {
112 /* stop */
113 __profil(NULL, 0, 0, 0);
114 /* Don't change the state if we ran into an error. */
115 if (p->state != GMON_PROF_ERROR)
116 p->state = GMON_PROF_OFF;
117 }
118}
119libc_hidden_def (__moncontrol)
120weak_alias (__moncontrol, moncontrol)
121
122
123void
124__monstartup (u_long lowpc, u_long highpc)
125{
126 int o;
127 char *cp;
128 struct gmonparam *p = &_gmonparam;
129 long int minarcs, maxarcs;
130
131 /* Read minarcs/maxarcs tunables. */
132 minarcs = TUNABLE_GET (minarcs, int32_t, NULL);
133 maxarcs = TUNABLE_GET (maxarcs, int32_t, NULL);
134 if (maxarcs < minarcs)
135 {
136 ERR("monstartup: maxarcs < minarcs, setting maxarcs = minarcs\n");
137 maxarcs = minarcs;
138 }
139
140 /*
141 * If we are incorrectly called twice in a row (without an
142 * intervening call to _mcleanup), ignore the second call to
143 * prevent leaking memory.
144 */
145 if (p->tos != NULL)
146 return;
147
148 /*
149 * round lowpc and highpc to multiples of the density we're using
150 * so the rest of the scaling (here and in gprof) stays in ints.
151 */
152 p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
153 p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER));
154 p->textsize = p->highpc - p->lowpc;
155 /* This looks like a typo, but it's here to align the p->froms
156 section. */
157 p->kcountsize = ROUNDUP(p->textsize / HISTFRACTION, sizeof(*p->froms));
158 p->hashfraction = HASHFRACTION;
159 p->log_hashfraction = -1;
160 /* The following test must be kept in sync with the corresponding
161 test in mcount.c. */
162 if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) {
163 /* if HASHFRACTION is a power of two, mcount can use shifting
164 instead of integer division. Precompute shift amount. */
165 p->log_hashfraction = ffs(p->hashfraction * sizeof(*p->froms)) - 1;
166 }
167 p->fromssize = ROUNDUP(p->textsize / HASHFRACTION, sizeof(*p->froms));
168 p->tolimit = p->textsize * ARCDENSITY / 100;
169 if (p->tolimit < minarcs)
170 p->tolimit = minarcs;
171 else if (p->tolimit > maxarcs)
172 p->tolimit = maxarcs;
173 p->tossize = p->tolimit * sizeof(struct tostruct);
174
175 cp = calloc (p->kcountsize + p->fromssize + p->tossize, 1);
176 if (! cp)
177 {
178 ERR("monstartup: out of memory\n");
179 p->tos = NULL;
180 p->state = GMON_PROF_ERROR;
181 return;
182 }
183 p->tos = (struct tostruct *)cp;
184 cp += p->tossize;
185 p->kcount = (HISTCOUNTER *)cp;
186 cp += p->kcountsize;
187 p->froms = (ARCINDEX *)cp;
188
189 p->tos[0].link = 0;
190
191 o = p->highpc - p->lowpc;
192 if (p->kcountsize < (u_long) o)
193 {
194#ifndef hp300
195 s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;
196#else
197 /* avoid floating point operations */
198 int quot = o / p->kcountsize;
199
200 if (quot >= 0x10000)
201 s_scale = 1;
202 else if (quot >= 0x100)
203 s_scale = 0x10000 / quot;
204 else if (o >= 0x800000)
205 s_scale = 0x1000000 / (o / (p->kcountsize >> 8));
206 else
207 s_scale = 0x1000000 / ((o << 8) / p->kcountsize);
208#endif
209 } else
210 s_scale = SCALE_1_TO_1;
211
212 __moncontrol(1);
213}
214weak_alias (__monstartup, monstartup)
215
216
217static void
218write_hist (int fd, u_long load_address)
219{
220 u_char tag = GMON_TAG_TIME_HIST;
221
222 if (_gmonparam.kcountsize > 0)
223 {
224 struct real_gmon_hist_hdr
225 {
226 char *low_pc;
227 char *high_pc;
228 int32_t hist_size;
229 int32_t prof_rate;
230 char dimen[15];
231 char dimen_abbrev;
232 } thdr;
233 struct iovec iov[3] =
234 {
235 { &tag, sizeof (tag) },
236 { &thdr, sizeof (struct gmon_hist_hdr) },
237 { _gmonparam.kcount, _gmonparam.kcountsize }
238 };
239
240 if (sizeof (thdr) != sizeof (struct gmon_hist_hdr)
241 || (offsetof (struct real_gmon_hist_hdr, low_pc)
242 != offsetof (struct gmon_hist_hdr, low_pc))
243 || (offsetof (struct real_gmon_hist_hdr, high_pc)
244 != offsetof (struct gmon_hist_hdr, high_pc))
245 || (offsetof (struct real_gmon_hist_hdr, hist_size)
246 != offsetof (struct gmon_hist_hdr, hist_size))
247 || (offsetof (struct real_gmon_hist_hdr, prof_rate)
248 != offsetof (struct gmon_hist_hdr, prof_rate))
249 || (offsetof (struct real_gmon_hist_hdr, dimen)
250 != offsetof (struct gmon_hist_hdr, dimen))
251 || (offsetof (struct real_gmon_hist_hdr, dimen_abbrev)
252 != offsetof (struct gmon_hist_hdr, dimen_abbrev)))
253 abort ();
254
255 thdr.low_pc = (char *) _gmonparam.lowpc - load_address;
256 thdr.high_pc = (char *) _gmonparam.highpc - load_address;
257 thdr.hist_size = _gmonparam.kcountsize / sizeof (HISTCOUNTER);
258 thdr.prof_rate = __profile_frequency ();
259 strncpy (thdr.dimen, "seconds", sizeof (thdr.dimen));
260 thdr.dimen_abbrev = 's';
261
262 __writev_nocancel_nostatus (fd, iov, 3);
263 }
264}
265
266
267static void
268write_call_graph (int fd, u_long load_address)
269{
270#define NARCS_PER_WRITEV 32
271 u_char tag = GMON_TAG_CG_ARC;
272 struct gmon_cg_arc_record raw_arc[NARCS_PER_WRITEV]
273 __attribute__ ((aligned (__alignof__ (char*))));
274 ARCINDEX from_index, to_index;
275 u_long from_len;
276 u_long frompc;
277 struct iovec iov[2 * NARCS_PER_WRITEV];
278 int nfilled;
279
280 for (nfilled = 0; nfilled < NARCS_PER_WRITEV; ++nfilled)
281 {
282 iov[2 * nfilled].iov_base = &tag;
283 iov[2 * nfilled].iov_len = sizeof (tag);
284
285 iov[2 * nfilled + 1].iov_base = &raw_arc[nfilled];
286 iov[2 * nfilled + 1].iov_len = sizeof (struct gmon_cg_arc_record);
287 }
288
289 nfilled = 0;
290 from_len = _gmonparam.fromssize / sizeof (*_gmonparam.froms);
291 for (from_index = 0; from_index < from_len; ++from_index)
292 {
293 if (_gmonparam.froms[from_index] == 0)
294 continue;
295
296 frompc = _gmonparam.lowpc;
297 frompc += (from_index * _gmonparam.hashfraction
298 * sizeof (*_gmonparam.froms));
299 for (to_index = _gmonparam.froms[from_index];
300 to_index != 0;
301 to_index = _gmonparam.tos[to_index].link)
302 {
303 struct arc
304 {
305 char *frompc;
306 char *selfpc;
307 int32_t count;
308 }
309 arc;
310
311 arc.frompc = (char *) frompc - load_address;
312 arc.selfpc = ((char *) _gmonparam.tos[to_index].selfpc
313 - load_address);
314 arc.count = _gmonparam.tos[to_index].count;
315 memcpy (raw_arc + nfilled, &arc, sizeof (raw_arc [0]));
316
317 if (++nfilled == NARCS_PER_WRITEV)
318 {
319 __writev_nocancel_nostatus (fd, iov, 2 * nfilled);
320 nfilled = 0;
321 }
322 }
323 }
324 if (nfilled > 0)
325 __writev_nocancel_nostatus (fd, iov, 2 * nfilled);
326}
327
328
329static void
330write_bb_counts (int fd)
331{
332 struct __bb *grp;
333 u_char tag = GMON_TAG_BB_COUNT;
334 size_t ncounts;
335 size_t i;
336
337 struct iovec bbhead[2] =
338 {
339 { &tag, sizeof (tag) },
340 { &ncounts, sizeof (ncounts) }
341 };
342 struct iovec bbbody[8];
343 size_t nfilled;
344
345 for (i = 0; i < (sizeof (bbbody) / sizeof (bbbody[0])); i += 2)
346 {
347 bbbody[i].iov_len = sizeof (grp->addresses[0]);
348 bbbody[i + 1].iov_len = sizeof (grp->counts[0]);
349 }
350
351 /* Write each group of basic-block info (all basic-blocks in a
352 compilation unit form a single group). */
353
354 for (grp = __bb_head; grp; grp = grp->next)
355 {
356 ncounts = grp->ncounts;
357 __writev_nocancel_nostatus (fd, bbhead, 2);
358 for (nfilled = i = 0; i < ncounts; ++i)
359 {
360 if (nfilled > (sizeof (bbbody) / sizeof (bbbody[0])) - 2)
361 {
362 __writev_nocancel_nostatus (fd, bbbody, nfilled);
363 nfilled = 0;
364 }
365
366 bbbody[nfilled++].iov_base = (char *) &grp->addresses[i];
367 bbbody[nfilled++].iov_base = &grp->counts[i];
368 }
369 if (nfilled > 0)
370 __writev_nocancel_nostatus (fd, bbbody, nfilled);
371 }
372}
373
374
375static void
376write_gmon (void)
377{
378 int fd = -1;
379 char *env;
380
381 env = getenv ("GMON_OUT_PREFIX");
382 if (env != NULL && !__libc_enable_secure)
383 {
384 size_t len = strlen (env);
385 char buf[len + 20];
386 __snprintf (buf, sizeof (buf), "%s.%u", env, __getpid ());
387 fd = __open_nocancel (buf, O_CREAT | O_TRUNC | O_WRONLY | O_NOFOLLOW
388 | O_CLOEXEC, 0666);
389 }
390
391 if (fd == -1)
392 {
393 fd = __open_nocancel ("gmon.out", O_CREAT | O_TRUNC | O_WRONLY
394 | O_NOFOLLOW | O_CLOEXEC, 0666);
395 if (fd < 0)
396 {
397 char buf[300];
398 int errnum = errno;
399 __fxprintf (NULL, "_mcleanup: gmon.out: %s\n",
400 __strerror_r (errnum, buf, sizeof buf));
401 return;
402 }
403 }
404
405 /* write gmon.out header: */
406 struct real_gmon_hdr
407 {
408 char cookie[4];
409 int32_t version;
410 char spare[3 * 4];
411 } ghdr;
412 if (sizeof (ghdr) != sizeof (struct gmon_hdr)
413 || (offsetof (struct real_gmon_hdr, cookie)
414 != offsetof (struct gmon_hdr, cookie))
415 || (offsetof (struct real_gmon_hdr, version)
416 != offsetof (struct gmon_hdr, version)))
417 abort ();
418 memcpy (&ghdr.cookie[0], GMON_MAGIC, sizeof (ghdr.cookie));
419 ghdr.version = GMON_VERSION;
420 memset (ghdr.spare, '\0', sizeof (ghdr.spare));
421 __write_nocancel (fd, &ghdr, sizeof (struct gmon_hdr));
422
423 /* Get load_address to profile PIE. */
424 u_long load_address = 0;
425#ifdef PIC
426 __dl_iterate_phdr (callback, &load_address);
427#endif
428
429 /* write PC histogram: */
430 write_hist (fd, load_address);
431
432 /* write call-graph: */
433 write_call_graph (fd, load_address);
434
435 /* write basic-block execution counts: */
436 write_bb_counts (fd);
437
438 __close_nocancel_nostatus (fd);
439}
440
441
442void
443__write_profiling (void)
444{
445 int save = _gmonparam.state;
446 _gmonparam.state = GMON_PROF_OFF;
447 if (save == GMON_PROF_ON)
448 write_gmon ();
449 _gmonparam.state = save;
450}
451#ifndef SHARED
452/* This symbol isn't used anywhere in the DSO and it is not exported.
453 This would normally mean it should be removed to get the same API
454 in static libraries. But since profiling is special in static libs
455 anyway we keep it. But not when building the DSO since some
456 quality assurance tests will otherwise trigger. */
457weak_alias (__write_profiling, write_profiling)
458#endif
459
460
461void
462_mcleanup (void)
463{
464 __moncontrol (0);
465
466 if (_gmonparam.state != GMON_PROF_ERROR && _gmonparam.tos != NULL)
467 write_gmon ();
468
469 /* free the memory. */
470 free (_gmonparam.tos);
471
472 /* reset buffer to initial state for safety */
473 memset(&_gmonparam, 0, sizeof _gmonparam);
474 /* somewhat confusingly, ON=0, OFF=3 */
475 _gmonparam.state = GMON_PROF_OFF;
476}
477