2 * Copyright (c) 1983, 1992, 1993, 2011
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
29 #include <sys/param.h>
32 #include <sys/gmon_out.h>
46 #include <libc-internal.h>
47 #include <not-cancel.h>
53 callback (struct dl_phdr_info
*info
, size_t size
, void *data
)
55 if (info
->dlpi_name
[0] == '\0')
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
;
70 /* Head of basic-block list or NULL. */
71 struct __bb
*__bb_head attribute_hidden
;
73 struct gmonparam _gmonparam attribute_hidden
= { GMON_PROF_OFF
};
76 * See profil(2) where this is described:
79 #define SCALE_1_TO_1 0x10000L
81 #define ERR(s) __write_nocancel (STDERR_FILENO, s, sizeof (s) - 1)
83 void moncontrol (int mode
);
84 void __moncontrol (int mode
);
85 libc_hidden_proto (__moncontrol
)
86 static void write_hist (int fd
, u_long load_address
);
87 static void write_call_graph (int fd
, u_long load_address
);
88 static void write_bb_counts (int fd
);
92 * profiling is what mcount checks to see if
93 * all the data structures are ready.
96 __moncontrol (int mode
)
98 struct gmonparam
*p
= &_gmonparam
;
100 /* Treat start request as stop if error or gmon not initialized. */
101 if (mode
&& p
->state
!= GMON_PROF_ERROR
&& p
->tos
!= NULL
)
104 __profil((void *) p
->kcount
, p
->kcountsize
, p
->lowpc
, s_scale
);
105 p
->state
= GMON_PROF_ON
;
110 __profil(NULL
, 0, 0, 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
;
116 libc_hidden_def (__moncontrol
)
117 weak_alias (__moncontrol
, moncontrol
)
121 __monstartup (u_long lowpc
, u_long highpc
)
125 struct gmonparam
*p
= &_gmonparam
;
126 long int minarcs
, maxarcs
;
128 /* No tunables, we use hardcoded defaults */
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.
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.
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
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
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;
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
);
167 cp
= calloc (p
->kcountsize
+ p
->fromssize
+ p
->tossize
, 1);
170 ERR("monstartup: out of memory\n");
172 p
->state
= GMON_PROF_ERROR
;
175 p
->tos
= (struct tostruct
*)cp
;
177 p
->kcount
= (HISTCOUNTER
*)cp
;
179 p
->froms
= (ARCINDEX
*)cp
;
183 o
= p
->highpc
- p
->lowpc
;
184 if (p
->kcountsize
< (u_long
) o
)
187 s_scale
= ((float)p
->kcountsize
/ o
) * SCALE_1_TO_1
;
189 /* avoid floating point operations */
190 int quot
= o
/ p
->kcountsize
;
194 else if (quot
>= 0x100)
195 s_scale
= 0x10000 / quot
;
196 else if (o
>= 0x800000)
197 s_scale
= 0x1000000 / (o
/ (p
->kcountsize
>> 8));
199 s_scale
= 0x1000000 / ((o
<< 8) / p
->kcountsize
);
202 s_scale
= SCALE_1_TO_1
;
206 weak_alias (__monstartup
, monstartup
)
210 write_hist (int fd
, u_long load_address
)
212 u_char tag
= GMON_TAG_TIME_HIST
;
214 if (_gmonparam
.kcountsize
> 0)
216 struct real_gmon_hist_hdr
225 struct iovec iov
[3] =
227 { &tag
, sizeof (tag
) },
228 { &thdr
, sizeof (struct gmon_hist_hdr
) },
229 { _gmonparam
.kcount
, _gmonparam
.kcountsize
}
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
)))
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';
254 __writev_nocancel_nostatus (fd
, iov
, 3);
260 write_call_graph (int fd
, u_long load_address
)
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
;
269 struct iovec iov
[2 * NARCS_PER_WRITEV
];
272 for (nfilled
= 0; nfilled
< NARCS_PER_WRITEV
; ++nfilled
)
274 iov
[2 * nfilled
].iov_base
= &tag
;
275 iov
[2 * nfilled
].iov_len
= sizeof (tag
);
277 iov
[2 * nfilled
+ 1].iov_base
= &raw_arc
[nfilled
];
278 iov
[2 * nfilled
+ 1].iov_len
= sizeof (struct gmon_cg_arc_record
);
282 from_len
= _gmonparam
.fromssize
/ sizeof (*_gmonparam
.froms
);
283 for (from_index
= 0; from_index
< from_len
; ++from_index
)
285 if (_gmonparam
.froms
[from_index
] == 0)
288 frompc
= _gmonparam
.lowpc
;
289 frompc
+= (from_index
* _gmonparam
.hashfraction
290 * sizeof (*_gmonparam
.froms
));
291 for (to_index
= _gmonparam
.froms
[from_index
];
293 to_index
= _gmonparam
.tos
[to_index
].link
)
303 arc
.frompc
= (char *) frompc
- load_address
;
304 arc
.selfpc
= ((char *) _gmonparam
.tos
[to_index
].selfpc
306 arc
.count
= _gmonparam
.tos
[to_index
].count
;
307 memcpy (raw_arc
+ nfilled
, &arc
, sizeof (raw_arc
[0]));
309 if (++nfilled
== NARCS_PER_WRITEV
)
311 __writev_nocancel_nostatus (fd
, iov
, 2 * nfilled
);
317 __writev_nocancel_nostatus (fd
, iov
, 2 * nfilled
);
322 write_bb_counts (int fd
)
325 u_char tag
= GMON_TAG_BB_COUNT
;
329 struct iovec bbhead
[2] =
331 { &tag
, sizeof (tag
) },
332 { &ncounts
, sizeof (ncounts
) }
334 struct iovec bbbody
[8];
337 for (i
= 0; i
< (sizeof (bbbody
) / sizeof (bbbody
[0])); i
+= 2)
339 bbbody
[i
].iov_len
= sizeof (grp
->addresses
[0]);
340 bbbody
[i
+ 1].iov_len
= sizeof (grp
->counts
[0]);
343 /* Write each group of basic-block info (all basic-blocks in a
344 compilation unit form a single group). */
346 for (grp
= __bb_head
; grp
; grp
= grp
->next
)
348 ncounts
= grp
->ncounts
;
349 __writev_nocancel_nostatus (fd
, bbhead
, 2);
350 for (nfilled
= i
= 0; i
< ncounts
; ++i
)
352 if (nfilled
> (sizeof (bbbody
) / sizeof (bbbody
[0])) - 2)
354 __writev_nocancel_nostatus (fd
, bbbody
, nfilled
);
358 bbbody
[nfilled
++].iov_base
= (char *) &grp
->addresses
[i
];
359 bbbody
[nfilled
++].iov_base
= &grp
->counts
[i
];
362 __writev_nocancel_nostatus (fd
, bbbody
, nfilled
);
373 env
= getenv ("GMON_OUT_PREFIX");
374 if (env
!= NULL
&& !__libc_enable_secure
)
376 size_t len
= strlen (env
);
378 __snprintf (buf
, sizeof (buf
), "%s.%u", env
, __getpid ());
379 fd
= __open_nocancel (buf
, O_CREAT
|O_TRUNC
|O_WRONLY
|O_NOFOLLOW
, 0666);
384 fd
= __open_nocancel ("gmon.out", O_CREAT
|O_TRUNC
|O_WRONLY
|O_NOFOLLOW
,
390 __fxprintf (NULL
, "_mcleanup: gmon.out: %s\n",
391 __strerror_r (errnum
, buf
, sizeof buf
));
396 /* write gmon.out header: */
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
)))
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
));
414 /* Get load_address to profile PIE. */
415 u_long load_address
= 0;
417 __dl_iterate_phdr (callback
, &load_address
);
420 /* write PC histogram: */
421 write_hist (fd
, load_address
);
423 /* write call-graph: */
424 write_call_graph (fd
, load_address
);
426 /* write basic-block execution counts: */
427 write_bb_counts (fd
);
429 __close_nocancel_nostatus (fd
);
434 __write_profiling (void)
436 int save
= _gmonparam
.state
;
437 _gmonparam
.state
= GMON_PROF_OFF
;
438 if (save
== GMON_PROF_ON
)
440 _gmonparam
.state
= save
;
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. */
448 weak_alias (__write_profiling
, write_profiling
)
457 if (_gmonparam
.state
!= GMON_PROF_ERROR
&& _gmonparam
.tos
!= NULL
)
460 /* free the memory. */
461 free (_gmonparam
.tos
);
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
;