1 /* Profiling of shared libraries.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
5 Based on the BSD mcount implementation.
7 The GNU C Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Library General Public License as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
12 The GNU C Library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Library General Public License for more details.
17 You should have received a copy of the GNU Library General Public
18 License along with the GNU C Library; see the file COPYING.LIB. If not,
19 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
32 #include <sys/gmon_out.h>
34 #include <sys/param.h>
36 #include <atomicity.h>
38 /* The LD_PROFILE feature has to be implemented different to the
39 normal profiling using the gmon/ functions. The problem is that an
40 arbitrary amount of processes simulataneously can be run using
41 profiling and all write the results in the same file. To provide
42 this mechanism one could implement a complicated mechanism to merge
43 the content of two profiling runs or one could extend the file
44 format to allow more than one data set. For the second solution we
45 would have the problem that the file can grow in size beyond any
46 limit and both solutions have the problem that the concurrency of
47 writing the results is a big problem.
49 Another much simpler method is to use mmap to map the same file in
50 all using programs and modify the data in the mmap'ed area and so
51 also automatically on the disk. Using the MAP_SHARED option of
52 mmap(2) this can be done without big problems in more than one
55 This approach is very different from the normal profiling. We have
56 to use the profiling data in exactly the way they are expected to
57 be written to disk. But the normal format used by gprof is not usable
58 to do this. It is optimized for size. It writes the tags as single
59 bytes but this means that the following 32/64 bit values are
62 Therefore we use a new format. This will look like this
64 0 1 2 3 <- byte is 32 bit word
66 0004 *version* <- GMON_SHOBJ_VERSION
71 0014 *tag* <- GMON_TAG_TIME_HIST
73 ?? ?? ?? ?? <- 32/64 bit LowPC
75 ?? ?? ?? ?? <- 32/64 bit HighPC
84 0030+2*A ?? ?? ?? ?? <- Count data
86 0030+2*A+K ?? ?? ?? ??
88 0030+2*A+K *tag* <- GMON_TAG_CG_ARC
90 0038+2*A+K ?? ?? ?? ??
91 ?? ?? ?? ?? <- FromPC#1
92 0038+3*A+K ?? ?? ?? ??
94 0038+4*A+K ?? ?? ?? ?? <- Count#1
96 0038+(2*(CN-1)+2)*A+(CN-1)*4+K ?? ?? ?? ??
97 ?? ?? ?? ?? <- FromPC#CGN
98 0038+(2*(CN-1)+3)*A+(CN-1)*4+K ?? ?? ?? ??
99 ?? ?? ?? ?? <- ToPC#CGN
100 0038+(2*CN+2)*A+(CN-1)*4+K ?? ?? ?? ?? <- Count#CGN
102 We put (for now?) no basic block information in the file since this would
103 introduce rase conditions among all the processes who want to write them.
105 `K' is the number of count entries which is computed as
107 textsize / HISTFRACTION
109 `CG' in the above table is the number of call graph arcs. Normally,
110 the table is sparse and the profiling code writes out only the those
111 entries which are really used in the program run. But since we must
112 not extend this table (the profiling file) we'll keep them all here.
113 So CN can be executed in advance as
115 MINARCS <= textsize*(ARCDENSITY/100) <= MAXARCS
117 Now the remaining question is: how to build the data structures we can
118 work with from this data. We need the from set and must associate the
119 froms with all the associated tos. We will do this by constructing this
120 data structures at the program start. To do this we'll simply visit all
121 entries in the call graph table and add it to the appropriate list. */
123 extern int __profile_frequency (void);
125 /* We define a special type to address the elements of the arc table.
126 This is basically the `gmon_cg_arc_record' format but it includes
127 the room for the tag and it uses real types. */
128 struct here_cg_arc_record
133 } __attribute__ ((packed
));
135 static struct here_cg_arc_record
*data
;
137 /* This is the number of entry which have been incorporated in the toset. */
138 static uint32_t narcs
;
139 /* This is a pointer to the object representing the number of entries
140 currently in the mmaped file. At no point of time this has to be the
141 same as NARCS. If it is equal all entries from the file are in our
143 static volatile uint32_t *narcsp
;
145 /* Description of the currently profiled object. */
146 static long int state
= GMON_PROF_OFF
;
148 static volatile uint16_t *kcount
;
149 static size_t kcountsize
;
151 struct here_fromstruct
153 struct here_cg_arc_record
volatile *here
;
157 static volatile uint16_t *tos
;
159 static struct here_fromstruct
*froms
;
160 static uint32_t fromlimit
;
161 static volatile uint32_t fromidx
;
163 static uintptr_t lowpc
;
164 static size_t textsize
;
165 static unsigned int hashfraction
;
166 static unsigned int log_hashfraction
;
170 /* Set up profiling data to profile object desribed by MAP. The output
171 file is found (or created) in OUTPUT_DIR. */
174 _dl_start_profile (struct link_map
*map
, const char *output_dir
)
179 const ElfW(Phdr
) *ph
;
180 ElfW(Addr
) mapstart
= ~((ElfW(Addr
)) 0);
181 ElfW(Addr
) mapend
= 0;
182 struct gmon_hdr gmon_hdr
;
183 struct gmon_hist_hdr hist_hdr
;
189 struct gmon_hdr
*addr
= NULL
;
191 /* See profil(2) where this is described. */
193 #define SCALE_1_TO_1 0x10000L
195 /* Compute the size of the sections which contain program code. */
196 for (ph
= map
->l_phdr
; ph
< &map
->l_phdr
[map
->l_phnum
]; ++ph
)
197 if (ph
->p_type
== PT_LOAD
&& (ph
->p_flags
& PF_X
))
199 ElfW(Addr
) start
= (ph
->p_vaddr
& ~(_dl_pagesize
- 1));
200 ElfW(Addr
) end
= ((ph
->p_vaddr
+ ph
->p_memsz
+ _dl_pagesize
- 1)
201 & ~(_dl_pagesize
- 1));
203 if (start
< mapstart
)
209 /* Now we can compute the size of the profiling data. This is done
210 with the same formulars as in `monstartup' (see gmon.c). */
211 state
= GMON_PROF_OFF
;
212 lowpc
= ROUNDDOWN (mapstart
+ map
->l_addr
,
213 HISTFRACTION
* sizeof (HISTCOUNTER
));
214 highpc
= ROUNDUP (mapend
+ map
->l_addr
,
215 HISTFRACTION
* sizeof (HISTCOUNTER
));
216 textsize
= highpc
- lowpc
;
217 kcountsize
= textsize
/ HISTFRACTION
;
218 hashfraction
= HASHFRACTION
;
219 if ((HASHFRACTION
& (HASHFRACTION
- 1)) == 0)
220 /* If HASHFRACTION is a power of two, mcount can use shifting
221 instead of integer division. Precompute shift amount. */
222 log_hashfraction
= __ffs (hashfraction
* sizeof (*froms
)) - 1;
224 log_hashfraction
= -1;
225 tossize
= textsize
/ HASHFRACTION
;
226 fromlimit
= textsize
* ARCDENSITY
/ 100;
227 if (fromlimit
< MINARCS
)
229 if (fromlimit
> MAXARCS
)
231 fromssize
= fromlimit
* sizeof (struct here_fromstruct
);
233 expected_size
= (sizeof (struct gmon_hdr
)
234 + 4 + sizeof (struct gmon_hist_hdr
) + kcountsize
235 + 4 + 4 + fromssize
* sizeof (struct here_cg_arc_record
));
237 /* Create the gmon_hdr we expect or write. */
238 memset (&gmon_hdr
, '\0', sizeof (struct gmon_hdr
));
239 memcpy (&gmon_hdr
.cookie
[0], GMON_MAGIC
, sizeof (gmon_hdr
.cookie
));
240 *(int32_t *) gmon_hdr
.version
= GMON_SHOBJ_VERSION
;
242 /* Create the hist_hdr we expect or write. */
243 *(char **) hist_hdr
.low_pc
= (char *) mapstart
;
244 *(char **) hist_hdr
.high_pc
= (char *) mapend
;
245 *(int32_t *) hist_hdr
.hist_size
= kcountsize
/ sizeof (HISTCOUNTER
);
246 *(int32_t *) hist_hdr
.prof_rate
= __profile_frequency ();
247 strncpy (hist_hdr
.dimen
, "seconds", sizeof (hist_hdr
.dimen
));
248 hist_hdr
.dimen_abbrev
= 's';
250 /* First determine the output name. We write in the directory
251 OUTPUT_DIR and the name is composed from the shared objects
252 soname (or the file name) and the ending ".profile". */
253 filename
= (char *) alloca (strlen (output_dir
) + 1 + strlen (_dl_profile
)
254 + sizeof ".profile");
255 cp
= __stpcpy (filename
, output_dir
);
257 __stpcpy (__stpcpy (cp
, _dl_profile
), ".profile");
260 # define EXTRA_FLAGS | O_NOFOLLOW
264 fd
= __open (filename
, O_RDWR
| O_CREAT EXTRA_FLAGS
, DEFFILEMODE
);
267 /* We cannot write the profiling data so don't do anything. */
269 _dl_error_printf ("%s: cannot open file: %s\n", filename
,
270 __strerror_r (errno
, buf
, sizeof buf
));
274 if (__fxstat64 (_STAT_VER
, fd
, &st
) < 0 || !S_ISREG (st
.st_mode
))
276 /* Not stat'able or not a regular file => don't use it. */
280 _dl_error_printf ("%s: cannot stat file: %s\n", filename
,
281 __strerror_r (errnum
, buf
, sizeof buf
));
285 /* Test the size. If it does not match what we expect from the size
286 values in the map MAP we don't use it and warn the user. */
289 /* We have to create the file. */
290 char buf
[_dl_pagesize
];
292 memset (buf
, '\0', _dl_pagesize
);
294 if (__lseek (fd
, expected_size
& ~(_dl_pagesize
- 1), SEEK_SET
) == -1)
301 _dl_error_printf ("%s: cannot create file: %s\n", filename
,
302 __strerror_r (errnum
, buf
, sizeof buf
));
306 if (TEMP_FAILURE_RETRY (__libc_write (fd
, buf
, (expected_size
307 & (_dl_pagesize
- 1))))
311 else if (st
.st_size
!= expected_size
)
317 __munmap ((void *) addr
, expected_size
);
319 _dl_error_printf ("%s: file is no correct profile data file for `%s'\n",
320 filename
, _dl_profile
);
324 addr
= (struct gmon_hdr
*) __mmap (NULL
, expected_size
, PROT_READ
|PROT_WRITE
,
325 MAP_SHARED
|MAP_FILE
, fd
, 0);
326 if (addr
== (struct gmon_hdr
*) MAP_FAILED
)
331 _dl_error_printf ("%s: cannot map file: %s\n", filename
,
332 __strerror_r (errnum
, buf
, sizeof buf
));
336 /* We don't need the file desriptor anymore. */
339 /* Pointer to data after the header. */
340 hist
= (char *) (addr
+ 1);
341 kcount
= (uint16_t *) ((char *) hist
+ sizeof (uint32_t)
342 + sizeof (struct gmon_hist_hdr
));
344 /* Compute pointer to array of the arc information. */
345 narcsp
= (uint32_t *) ((char *) kcount
+ kcountsize
+ sizeof (uint32_t));
346 data
= (struct here_cg_arc_record
*) ((char *) narcsp
+ sizeof (uint32_t));
350 /* Create the signature. */
351 memcpy (addr
, &gmon_hdr
, sizeof (struct gmon_hdr
));
353 *(uint32_t *) hist
= GMON_TAG_TIME_HIST
;
354 memcpy (hist
+ sizeof (uint32_t), &hist_hdr
,
355 sizeof (struct gmon_hist_hdr
));
357 narcsp
[-1] = GMON_TAG_CG_ARC
;
361 /* Test the signature in the file. */
362 if (memcmp (addr
, &gmon_hdr
, sizeof (struct gmon_hdr
)) != 0
363 || *(uint32_t *) hist
!= GMON_TAG_TIME_HIST
364 || memcmp (hist
+ sizeof (uint32_t), &hist_hdr
,
365 sizeof (struct gmon_hist_hdr
)) != 0
366 || narcsp
[-1] != GMON_TAG_CG_ARC
)
370 /* Allocate memory for the froms data and the pointer to the tos records. */
371 tos
= (uint16_t *) calloc (tossize
+ fromssize
, 1);
374 __munmap ((void *) addr
, expected_size
);
375 _dl_fatal_printf ("Out of memory while initializing profiler\n");
379 froms
= (struct here_fromstruct
*) ((char *) tos
+ tossize
);
382 /* Now we have to process all the arc count entries. BTW: it is
383 not critical whether the *NARCSP value changes meanwhile. Before
384 we enter a new entry in to toset we will check that everything is
385 available in TOS. This happens in _dl_mcount.
387 Loading the entries in reverse order should help to get the most
388 frequently used entries at the front of the list. */
389 for (idx
= narcs
= MIN (*narcsp
, fromlimit
); idx
> 0; )
394 to_index
= (data
[idx
].self_pc
/ (hashfraction
* sizeof (*tos
)));
395 newfromidx
= fromidx
++;
396 froms
[newfromidx
].here
= &data
[idx
];
397 froms
[newfromidx
].link
= tos
[to_index
];
398 tos
[to_index
] = newfromidx
;
401 /* Setup counting data. */
402 if (kcountsize
< highpc
- lowpc
)
405 s_scale
= ((double) kcountsize
/ (highpc
- lowpc
)) * SCALE_1_TO_1
;
407 size_t range
= highpc
- lowpc
;
408 size_t quot
= range
/ kcountsize
;
410 if (quot
>= SCALE_1_TO_1
)
412 else if (quot
>= SCALE_1_TO_1
/ 256)
413 s_scale
= SCALE_1_TO_1
/ quot
;
414 else if (range
> ULONG_MAX
/ 256)
415 s_scale
= (SCALE_1_TO_1
* 256) / (range
/ (kcountsize
/ 256));
417 s_scale
= (SCALE_1_TO_1
* 256) / ((range
* 256) / kcountsize
);
421 s_scale
= SCALE_1_TO_1
;
423 /* Start the profiler. */
424 __profil ((void *) kcount
, kcountsize
, lowpc
, s_scale
);
426 /* Turn on profiling. */
427 state
= GMON_PROF_ON
;
432 _dl_mcount (ElfW(Addr
) frompc
, ElfW(Addr
) selfpc
)
434 volatile uint16_t *topcindex
;
436 struct here_fromstruct
*fromp
;
439 /* XXX I think this is now not necessary anymore. */
440 if (! compare_and_swap (&state
, GMON_PROF_ON
, GMON_PROF_BUSY
))
444 /* Compute relative addresses. The shared object can be loaded at
445 any address. The value of frompc could be anything. We cannot
446 restrict it in any way, just set to a fixed value (0) in case it
447 is outside the allowed range. These calls show up as calls from
448 <external> in the gprof output. */
450 if (frompc
>= textsize
)
453 if (selfpc
>= textsize
)
456 /* Getting here we now have to find out whether the location was
457 already used. If yes we are lucky and only have to increment a
458 counter (this also has to be atomic). If the entry is new things
459 are getting complicated... */
461 /* Avoid integer divide if possible. */
462 if ((HASHFRACTION
& (HASHFRACTION
- 1)) == 0)
463 i
= selfpc
>> log_hashfraction
;
465 i
= selfpc
/ (hashfraction
* sizeof (*tos
));
468 fromindex
= *topcindex
;
471 goto check_new_or_add
;
473 fromp
= &froms
[fromindex
];
475 /* We have to look through the chain of arcs whether there is already
476 an entry for our arc. */
477 while (fromp
->here
->from_pc
!= frompc
)
479 if (fromp
->link
!= 0)
481 fromp
= &froms
[fromp
->link
];
482 while (fromp
->link
!= 0 && fromp
->here
->from_pc
!= frompc
);
484 if (fromp
->here
->from_pc
!= frompc
)
486 topcindex
= &fromp
->link
;
489 /* Our entry is not among the entries we read so far from the
490 data file. Now see whether we have to update the list. */
491 while (narcs
!= *narcsp
&& narcs
< fromlimit
)
495 to_index
= (data
[narcs
].self_pc
496 / (hashfraction
* sizeof (*tos
)));
497 newfromidx
= exchange_and_add (&fromidx
, 1) + 1;
498 froms
[newfromidx
].here
= &data
[narcs
];
499 froms
[newfromidx
].link
= tos
[to_index
];
500 tos
[to_index
] = newfromidx
;
501 atomic_add (&narcs
, 1);
504 /* If we still have no entry stop searching and insert. */
507 uint_fast32_t newarc
= 1 + exchange_and_add (narcsp
, 1);
509 /* In rare cases it could happen that all entries in FROMS are
510 occupied. So we cannot count this anymore. */
511 if (newarc
>= fromlimit
)
514 *topcindex
= exchange_and_add (&fromidx
, 1) + 1;
515 fromp
= &froms
[*topcindex
];
517 fromp
->here
= &data
[newarc
];
518 data
[newarc
].from_pc
= frompc
;
519 data
[newarc
].self_pc
= selfpc
;
520 data
[newarc
].count
= 0;
522 atomic_add (&narcs
, 1);
527 fromp
= &froms
[*topcindex
];
534 /* Increment the counter. */
535 atomic_add (&fromp
->here
->count
, 1);
539 /* XXX See above, Shouldn't be necessary anymore. */
540 state
= GMON_PROF_ON
;