/* Profiling of shared libraries.
- Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1997-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Based on the BSD mcount implementation.
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- 02111-1307 USA. */
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <stdint.h>
#include <ldsodefs.h>
#include <sys/gmon.h>
#include <sys/gmon_out.h>
#include <sys/mman.h>
#include <sys/param.h>
#include <sys/stat.h>
-#include <atomicity.h>
+#include <atomic.h>
+#include <not-cancel.h>
/* The LD_PROFILE feature has to be implemented different to the
normal profiling using the gmon/ functions. The problem is that an
entries in the call graph table and add it to the appropriate list. */
extern int __profile_frequency (void);
+libc_hidden_proto (__profile_frequency)
/* We define a special type to address the elements of the arc table.
This is basically the `gmon_cg_arc_record' format but it includes
{
uintptr_t from_pc;
uintptr_t self_pc;
- uint32_t count;
+ /* The count field is atomically incremented in _dl_mcount, which
+ requires it to be properly aligned for its type, and for this
+ alignment to be visible to the compiler. The amount of data
+ before an array of this structure is calculated as
+ expected_size in _dl_start_profile. Everything in that
+ calculation is a multiple of 4 bytes (in the case of
+ kcountsize, because it is derived from a subtraction of
+ page-aligned values, and the corresponding calculation in
+ __monstartup also ensures it is at least a multiple of the size
+ of u_long), so all copies of this field do in fact have the
+ appropriate alignment. */
+ uint32_t count __attribute__ ((aligned (__alignof__ (uint32_t))));
} __attribute__ ((packed));
static struct here_cg_arc_record *data;
+/* Nonzero if profiling is under way. */
+static int running;
+
/* This is the number of entry which have been incorporated in the toset. */
static uint32_t narcs;
/* This is a pointer to the object representing the number of entries
lists. */
static volatile uint32_t *narcsp;
-/* Description of the currently profiled object. */
-static long int state = GMON_PROF_OFF;
-
-static volatile uint16_t *kcount;
-static size_t kcountsize;
struct here_fromstruct
{
static uintptr_t lowpc;
static size_t textsize;
-static unsigned int hashfraction;
static unsigned int log_hashfraction;
/* Set up profiling data to profile object desribed by MAP. The output
file is found (or created) in OUTPUT_DIR. */
void
-internal_function
-_dl_start_profile (struct link_map *map, const char *output_dir)
+_dl_start_profile (void)
{
char *filename;
int fd;
const ElfW(Phdr) *ph;
ElfW(Addr) mapstart = ~((ElfW(Addr)) 0);
ElfW(Addr) mapend = 0;
- struct gmon_hdr gmon_hdr;
- struct gmon_hist_hdr hist_hdr;
char *hist, *cp;
size_t idx;
size_t tossize;
size_t fromssize;
uintptr_t highpc;
+ uint16_t *kcount;
+ size_t kcountsize;
struct gmon_hdr *addr = NULL;
off_t expected_size;
/* See profil(2) where this is described. */
int s_scale;
#define SCALE_1_TO_1 0x10000L
+ const char *errstr = NULL;
/* Compute the size of the sections which contain program code. */
- for (ph = map->l_phdr; ph < &map->l_phdr[map->l_phnum]; ++ph)
+ for (ph = GL(dl_profile_map)->l_phdr;
+ ph < &GL(dl_profile_map)->l_phdr[GL(dl_profile_map)->l_phnum]; ++ph)
if (ph->p_type == PT_LOAD && (ph->p_flags & PF_X))
{
- ElfW(Addr) start = (ph->p_vaddr & ~(_dl_pagesize - 1));
- ElfW(Addr) end = ((ph->p_vaddr + ph->p_memsz + _dl_pagesize - 1)
- & ~(_dl_pagesize - 1));
+ ElfW(Addr) start = (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1));
+ ElfW(Addr) end = ((ph->p_vaddr + ph->p_memsz + GLRO(dl_pagesize) - 1)
+ & ~(GLRO(dl_pagesize) - 1));
if (start < mapstart)
mapstart = start;
/* Now we can compute the size of the profiling data. This is done
with the same formulars as in `monstartup' (see gmon.c). */
- state = GMON_PROF_OFF;
- lowpc = ROUNDDOWN (mapstart + map->l_addr,
+ running = 0;
+ lowpc = ROUNDDOWN (mapstart + GL(dl_profile_map)->l_addr,
HISTFRACTION * sizeof (HISTCOUNTER));
- highpc = ROUNDUP (mapend + map->l_addr,
+ highpc = ROUNDUP (mapend + GL(dl_profile_map)->l_addr,
HISTFRACTION * sizeof (HISTCOUNTER));
textsize = highpc - lowpc;
kcountsize = textsize / HISTFRACTION;
- hashfraction = HASHFRACTION;
if ((HASHFRACTION & (HASHFRACTION - 1)) == 0)
- /* If HASHFRACTION is a power of two, mcount can use shifting
- instead of integer division. Precompute shift amount. */
- log_hashfraction = __ffs (hashfraction * sizeof (*froms)) - 1;
+ {
+ /* If HASHFRACTION is a power of two, mcount can use shifting
+ instead of integer division. Precompute shift amount.
+
+ This is a constant but the compiler cannot compile the
+ expression away since the __ffs implementation is not known
+ to the compiler. Help the compiler by precomputing the
+ usual cases. */
+ assert (HASHFRACTION == 2);
+
+ if (sizeof (*froms) == 8)
+ log_hashfraction = 4;
+ else if (sizeof (*froms) == 16)
+ log_hashfraction = 5;
+ else
+ log_hashfraction = __ffs (HASHFRACTION * sizeof (*froms)) - 1;
+ }
else
log_hashfraction = -1;
tossize = textsize / HASHFRACTION;
+ 4 + 4 + fromssize * sizeof (struct here_cg_arc_record));
/* Create the gmon_hdr we expect or write. */
- memset (&gmon_hdr, '\0', sizeof (struct gmon_hdr));
+ struct real_gmon_hdr
+ {
+ char cookie[4];
+ int32_t version;
+ char spare[3 * 4];
+ } gmon_hdr;
+ if (sizeof (gmon_hdr) != sizeof (struct gmon_hdr)
+ || (offsetof (struct real_gmon_hdr, cookie)
+ != offsetof (struct gmon_hdr, cookie))
+ || (offsetof (struct real_gmon_hdr, version)
+ != offsetof (struct gmon_hdr, version)))
+ abort ();
+
memcpy (&gmon_hdr.cookie[0], GMON_MAGIC, sizeof (gmon_hdr.cookie));
- *(int32_t *) gmon_hdr.version = GMON_SHOBJ_VERSION;
+ gmon_hdr.version = GMON_SHOBJ_VERSION;
+ memset (gmon_hdr.spare, '\0', sizeof (gmon_hdr.spare));
/* Create the hist_hdr we expect or write. */
- *(char **) hist_hdr.low_pc = (char *) mapstart;
- *(char **) hist_hdr.high_pc = (char *) mapend;
- *(int32_t *) hist_hdr.hist_size = kcountsize / sizeof (HISTCOUNTER);
- *(int32_t *) hist_hdr.prof_rate = __profile_frequency ();
- strncpy (hist_hdr.dimen, "seconds", sizeof (hist_hdr.dimen));
+ struct real_gmon_hist_hdr
+ {
+ char *low_pc;
+ char *high_pc;
+ int32_t hist_size;
+ int32_t prof_rate;
+ char dimen[15];
+ char dimen_abbrev;
+ } hist_hdr;
+ if (sizeof (hist_hdr) != sizeof (struct gmon_hist_hdr)
+ || (offsetof (struct real_gmon_hist_hdr, low_pc)
+ != offsetof (struct gmon_hist_hdr, low_pc))
+ || (offsetof (struct real_gmon_hist_hdr, high_pc)
+ != offsetof (struct gmon_hist_hdr, high_pc))
+ || (offsetof (struct real_gmon_hist_hdr, hist_size)
+ != offsetof (struct gmon_hist_hdr, hist_size))
+ || (offsetof (struct real_gmon_hist_hdr, prof_rate)
+ != offsetof (struct gmon_hist_hdr, prof_rate))
+ || (offsetof (struct real_gmon_hist_hdr, dimen)
+ != offsetof (struct gmon_hist_hdr, dimen))
+ || (offsetof (struct real_gmon_hist_hdr, dimen_abbrev)
+ != offsetof (struct gmon_hist_hdr, dimen_abbrev)))
+ abort ();
+
+ hist_hdr.low_pc = (char *) mapstart;
+ hist_hdr.high_pc = (char *) mapend;
+ hist_hdr.hist_size = kcountsize / sizeof (HISTCOUNTER);
+ hist_hdr.prof_rate = __profile_frequency ();
+ if (sizeof (hist_hdr.dimen) >= sizeof ("seconds"))
+ {
+ memcpy (hist_hdr.dimen, "seconds", sizeof ("seconds"));
+ memset (hist_hdr.dimen + sizeof ("seconds"), '\0',
+ sizeof (hist_hdr.dimen) - sizeof ("seconds"));
+ }
+ else
+ strncpy (hist_hdr.dimen, "seconds", sizeof (hist_hdr.dimen));
hist_hdr.dimen_abbrev = 's';
/* First determine the output name. We write in the directory
OUTPUT_DIR and the name is composed from the shared objects
soname (or the file name) and the ending ".profile". */
- filename = (char *) alloca (strlen (output_dir) + 1 + strlen (_dl_profile)
- + sizeof ".profile");
- cp = __stpcpy (filename, output_dir);
+ filename = (char *) alloca (strlen (GLRO(dl_profile_output)) + 1
+ + strlen (GLRO(dl_profile)) + sizeof ".profile");
+ cp = __stpcpy (filename, GLRO(dl_profile_output));
*cp++ = '/';
- __stpcpy (__stpcpy (cp, _dl_profile), ".profile");
+ __stpcpy (__stpcpy (cp, GLRO(dl_profile)), ".profile");
-#ifdef O_NOFOLLOW
-# define EXTRA_FLAGS | O_NOFOLLOW
-#else
-# define EXTRA_FLAGS
-#endif
- fd = __open (filename, O_RDWR | O_CREAT EXTRA_FLAGS, DEFFILEMODE);
+ fd = __open64_nocancel (filename, O_RDWR|O_CREAT|O_NOFOLLOW, DEFFILEMODE);
if (fd == -1)
{
- /* We cannot write the profiling data so don't do anything. */
char buf[400];
- _dl_error_printf ("%s: cannot open file: %s\n", filename,
- __strerror_r (errno, buf, sizeof buf));
+ int errnum;
+
+ /* We cannot write the profiling data so don't do anything. */
+ errstr = "%s: cannot open file: %s\n";
+ print_error:
+ errnum = errno;
+ if (fd != -1)
+ __close_nocancel (fd);
+ _dl_error_printf (errstr, filename,
+ __strerror_r (errnum, buf, sizeof buf));
return;
}
if (__fxstat64 (_STAT_VER, fd, &st) < 0 || !S_ISREG (st.st_mode))
{
/* Not stat'able or not a regular file => don't use it. */
- char buf[400];
- int errnum = errno;
- __close (fd);
- _dl_error_printf ("%s: cannot stat file: %s\n", filename,
- __strerror_r (errnum, buf, sizeof buf));
- return;
+ errstr = "%s: cannot stat file: %s\n";
+ goto print_error;
}
/* Test the size. If it does not match what we expect from the size
if (st.st_size == 0)
{
/* We have to create the file. */
- char buf[_dl_pagesize];
+ char buf[GLRO(dl_pagesize)];
- memset (buf, '\0', _dl_pagesize);
+ memset (buf, '\0', GLRO(dl_pagesize));
- if (__lseek (fd, expected_size & ~(_dl_pagesize - 1), SEEK_SET) == -1)
+ if (__lseek (fd, expected_size & ~(GLRO(dl_pagesize) - 1), SEEK_SET) == -1)
{
- char buf[400];
- int errnum;
cannot_create:
- errnum = errno;
- __close (fd);
- _dl_error_printf ("%s: cannot create file: %s\n", filename,
- __strerror_r (errnum, buf, sizeof buf));
- return;
+ errstr = "%s: cannot create file: %s\n";
+ goto print_error;
}
- if (TEMP_FAILURE_RETRY (__libc_write (fd, buf, (expected_size
- & (_dl_pagesize - 1))))
+ if (TEMP_FAILURE_RETRY
+ (__write_nocancel (fd, buf, (expected_size & (GLRO(dl_pagesize) - 1))))
< 0)
goto cannot_create;
}
else if (st.st_size != expected_size)
{
- __close (fd);
+ __close_nocancel (fd);
wrong_format:
if (addr != NULL)
__munmap ((void *) addr, expected_size);
_dl_error_printf ("%s: file is no correct profile data file for `%s'\n",
- filename, _dl_profile);
+ filename, GLRO(dl_profile));
return;
}
MAP_SHARED|MAP_FILE, fd, 0);
if (addr == (struct gmon_hdr *) MAP_FAILED)
{
- char buf[400];
- int errnum = errno;
- __close (fd);
- _dl_error_printf ("%s: cannot map file: %s\n", filename,
- __strerror_r (errnum, buf, sizeof buf));
- return;
+ errstr = "%s: cannot map file: %s\n";
+ goto print_error;
}
- /* We don't need the file desriptor anymore. */
- __close (fd);
+ /* We don't need the file descriptor anymore. */
+ __close_nocancel (fd);
/* Pointer to data after the header. */
hist = (char *) (addr + 1);
size_t to_index;
size_t newfromidx;
--idx;
- to_index = (data[idx].self_pc / (hashfraction * sizeof (*tos)));
+ to_index = (data[idx].self_pc / (HASHFRACTION * sizeof (*tos)));
newfromidx = fromidx++;
froms[newfromidx].here = &data[idx];
froms[newfromidx].link = tos[to_index];
__profil ((void *) kcount, kcountsize, lowpc, s_scale);
/* Turn on profiling. */
- state = GMON_PROF_ON;
+ running = 1;
}
size_t i, fromindex;
struct here_fromstruct *fromp;
-#if 0
- /* XXX I think this is now not necessary anymore. */
- if (! compare_and_swap (&state, GMON_PROF_ON, GMON_PROF_BUSY))
- return;
-#else
- if (state != GMON_PROF_ON)
+ if (! running)
return;
-#endif
/* Compute relative addresses. The shared object can be loaded at
any address. The value of frompc could be anything. We cannot
if ((HASHFRACTION & (HASHFRACTION - 1)) == 0)
i = selfpc >> log_hashfraction;
else
- i = selfpc / (hashfraction * sizeof (*tos));
+ i = selfpc / (HASHFRACTION * sizeof (*tos));
topcindex = &tos[i];
fromindex = *topcindex;
size_t to_index;
size_t newfromidx;
to_index = (data[narcs].self_pc
- / (hashfraction * sizeof (*tos)));
- newfromidx = exchange_and_add (&fromidx, 1) + 1;
+ / (HASHFRACTION * sizeof (*tos)));
+ newfromidx = catomic_exchange_and_add (&fromidx, 1) + 1;
froms[newfromidx].here = &data[narcs];
froms[newfromidx].link = tos[to_index];
tos[to_index] = newfromidx;
- atomic_add (&narcs, 1);
+ catomic_increment (&narcs);
}
/* If we still have no entry stop searching and insert. */
if (*topcindex == 0)
{
- uint_fast32_t newarc = exchange_and_add (narcsp, 1);
+ uint_fast32_t newarc = catomic_exchange_and_add (narcsp, 1);
/* In rare cases it could happen that all entries in FROMS are
occupied. So we cannot count this anymore. */
if (newarc >= fromlimit)
goto done;
- *topcindex = exchange_and_add (&fromidx, 1) + 1;
+ *topcindex = catomic_exchange_and_add (&fromidx, 1) + 1;
fromp = &froms[*topcindex];
fromp->here = &data[newarc];
data[newarc].self_pc = selfpc;
data[newarc].count = 0;
fromp->link = 0;
- atomic_add (&narcs, 1);
+ catomic_increment (&narcs);
break;
}
}
/* Increment the counter. */
- atomic_add (&fromp->here->count, 1);
+ catomic_increment (&fromp->here->count);
done:
-#if 0
- /* XXX See above, Shouldn't be necessary anymore. */
- state = GMON_PROF_ON;
-#else
;
-#endif
}
+rtld_hidden_def (_dl_mcount)
projects / thirdparty / glibc.git / blobdiff