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

source code of glibc/gmon/gmon.c