lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-07-29 11:41:21 +03:00
Code Activity

mtrace: Wean away from malloc hooks

Browse Source 
Wean mtrace away from the malloc hooks and move them into the debug
DSO.  Split the API away from the implementation so that we can add
the API to libc.so as well as libc_malloc_debug.so, with the libc
implementations being empty.

Update localplt data since memalign no longer has any callers after
this change.

Reviewed-by: Carlos O'Donell <carlos@redhat.com>
Tested-by: Carlos O'Donell <carlos@redhat.com>
This commit is contained in:
Siddhesh Poyarekar
2021-07-22 18:38:06 +05:30
parent cc35896ea3
commit 9dad716d4d
60 changed files with 319 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

314
malloc/mtrace.c
View File

@ -1,4 +1,4 @@
/* More debugging hooks for `malloc'.
/* mtrace API for `malloc'.
Copyright (C) 1991-2021 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Written April 2, 1991 by John Gilmore of Cygnus Support.
@ -18,40 +18,14 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#ifndef _MALLOC_INTERNAL
# define _MALLOC_INTERNAL
# include <malloc.h>
# include <mcheck.h>
# include <malloc-internal.h>
# include <libc-lock.h>
#if !IS_IN (libc)
# include "mtrace-impl.c"
#else
# include <shlib-compat.h>
# include <libc-symbols.h>
#endif
#include <dlfcn.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <_itoa.h>
#include <libc-internal.h>
#include <dso_handle.h>
#include <libio/iolibio.h>
#define setvbuf(s, b, f, l) _IO_setvbuf (s, b, f, l)
#define fwrite(buf, size, count, fp) _IO_fwrite (buf, size, count, fp)
#include <kernel-features.h>
#define TRACE_BUFFER_SIZE 512
static FILE *mallstream;
static const char mallenv[] = "MALLOC_TRACE";
static char *malloc_trace_buffer;
__libc_lock_define_initialized (static, lock);
#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_34)
#if IS_IN (libc) && SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_34)
/* Compatibility symbols that were introduced to help break at allocation sites
for specific memory allocations. This is unusable with ASLR, although gdb
may allow predictable allocation addresses. Even then, gdb has watchpoint
@ -71,282 +45,18 @@ compat_symbol (libc, tr_break, tr_break, GLIBC_2_0);
#endif
/* Old hook values. */
static void (*tr_old_free_hook) (void *ptr, const void *);
static void *(*tr_old_malloc_hook) (size_t size, const void *);
static void *(*tr_old_realloc_hook) (void *ptr, size_t size,
const void *);
static void *(*tr_old_memalign_hook) (size_t __alignment, size_t __size,
const void *);
static void
tr_where (const void *caller, Dl_info *info)
{
if (caller != NULL)
{
if (info != NULL)
{
char *buf = (char *) "";
if (info->dli_sname != NULL)
{
size_t len = strlen (info->dli_sname);
buf = alloca (len + 6 + 2 * sizeof (void *));
buf[0] = '(';
__stpcpy (_fitoa (caller >= (const void *) info->dli_saddr
? caller - (const void *) info->dli_saddr
: (const void *) info->dli_saddr - caller,
__stpcpy (__mempcpy (buf + 1, info->dli_sname,
len),
caller >= (void *) info->dli_saddr
? "+0x" : "-0x"),
16, 0),
")");
}
fprintf (mallstream, "@ %s%s%s[%p] ",
info->dli_fname ? : "", info->dli_fname ? ":" : "",
buf, caller);
}
else
fprintf (mallstream, "@ [%p] ", caller);
}
}
static Dl_info *
lock_and_info (const void *caller, Dl_info *mem)
{
if (caller == NULL)
return NULL;
Dl_info *res = _dl_addr (caller, mem, NULL, NULL) ? mem : NULL;
__libc_lock_lock (lock);
return res;
}
static void tr_freehook (void *, const void *);
static void * tr_mallochook (size_t, const void *);
static void * tr_reallochook (void *, size_t, const void *);
static void * tr_memalignhook (size_t, size_t, const void *);
/* Set all the default non-trace hooks. */
static __always_inline void
set_default_hooks (void)
{
__free_hook = tr_old_free_hook;
__malloc_hook = tr_old_malloc_hook;
__realloc_hook = tr_old_realloc_hook;
__memalign_hook = tr_old_memalign_hook;
}
/* Set all of the tracing hooks used for mtrace. */
static __always_inline void
set_trace_hooks (void)
{
__free_hook = tr_freehook;
__malloc_hook = tr_mallochook;
__realloc_hook = tr_reallochook;
__memalign_hook = tr_memalignhook;
}
/* Save the current set of hooks as the default hooks. */
static __always_inline void
save_default_hooks (void)
{
tr_old_free_hook = __free_hook;
tr_old_malloc_hook = __malloc_hook;
tr_old_realloc_hook = __realloc_hook;
tr_old_memalign_hook = __memalign_hook;
}
static void
tr_freehook (void *ptr, const void *caller)
{
if (ptr == NULL)
return;
Dl_info mem;
Dl_info *info = lock_and_info (caller, &mem);
tr_where (caller, info);
/* Be sure to print it first. */
fprintf (mallstream, "- %p\n", ptr);
set_default_hooks ();
if (tr_old_free_hook != NULL)
(*tr_old_free_hook)(ptr, caller);
else
free (ptr);
set_trace_hooks ();
__libc_lock_unlock (lock);
}
static void *
tr_mallochook (size_t size, const void *caller)
{
void *hdr;
Dl_info mem;
Dl_info *info = lock_and_info (caller, &mem);
set_default_hooks ();
if (tr_old_malloc_hook != NULL)
hdr = (void *) (*tr_old_malloc_hook)(size, caller);
else
hdr = (void *) malloc (size);
set_trace_hooks ();
tr_where (caller, info);
/* We could be printing a NULL here; that's OK. */
fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
__libc_lock_unlock (lock);
return hdr;
}
static void *
tr_reallochook (void *ptr, size_t size, const void *caller)
{
void *hdr;
Dl_info mem;
Dl_info *info = lock_and_info (caller, &mem);
set_default_hooks ();
if (tr_old_realloc_hook != NULL)
hdr = (void *) (*tr_old_realloc_hook)(ptr, size, caller);
else
hdr = (void *) realloc (ptr, size);
set_trace_hooks ();
tr_where (caller, info);
if (hdr == NULL)
{
if (size != 0)
/* Failed realloc. */
fprintf (mallstream, "! %p %#lx\n", ptr, (unsigned long int) size);
else
fprintf (mallstream, "- %p\n", ptr);
}
else if (ptr == NULL)
fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
else
{
fprintf (mallstream, "< %p\n", ptr);
tr_where (caller, info);
fprintf (mallstream, "> %p %#lx\n", hdr, (unsigned long int) size);
}
__libc_lock_unlock (lock);
return hdr;
}
static void *
tr_memalignhook (size_t alignment, size_t size, const void *caller)
{
void *hdr;
Dl_info mem;
Dl_info *info = lock_and_info (caller, &mem);
set_default_hooks ();
if (tr_old_memalign_hook != NULL)
hdr = (void *) (*tr_old_memalign_hook)(alignment, size, caller);
else
hdr = (void *) memalign (alignment, size);
set_trace_hooks ();
tr_where (caller, info);
/* We could be printing a NULL here; that's OK. */
fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
__libc_lock_unlock (lock);
return hdr;
}
#ifdef _LIBC
/* This function gets called to make sure all memory the library
allocates get freed and so does not irritate the user when studying
the mtrace output. */
static void __libc_freeres_fn_section
release_libc_mem (void)
{
/* Only call the free function if we still are running in mtrace mode. */
if (mallstream != NULL)
__libc_freeres ();
}
#endif
/* We enable tracing if the environment variable MALLOC_TRACE is set. */
void
mtrace (void)
{
#ifdef _LIBC
static int added_atexit_handler;
#if !IS_IN (libc)
do_mtrace ();
#endif
char *mallfile;
/* Don't panic if we're called more than once. */
if (mallstream != NULL)
return;
#ifdef _LIBC
/* When compiling the GNU libc we use the secure getenv function
which prevents the misuse in case of SUID or SGID enabled
programs. */
mallfile = __libc_secure_getenv (mallenv);
#else
mallfile = getenv (mallenv);
#endif
if (mallfile != NULL)
{
char *mtb = malloc (TRACE_BUFFER_SIZE);
if (mtb == NULL)
return;
mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "wce");
if (mallstream != NULL)
{
/* Be sure it doesn't malloc its buffer! */
malloc_trace_buffer = mtb;
setvbuf (mallstream, malloc_trace_buffer, _IOFBF, TRACE_BUFFER_SIZE);
fprintf (mallstream, "= Start\n");
save_default_hooks ();
set_trace_hooks ();
#ifdef _LIBC
if (!added_atexit_handler)
{
added_atexit_handler = 1;
__cxa_atexit ((void (*)(void *))release_libc_mem, NULL,
__dso_handle);
}
#endif
}
else
free (mtb);
}
}
void
muntrace (void)
{
if (mallstream == NULL)
return;
/* Do the reverse of what done in mtrace: first reset the hooks and
MALLSTREAM, and only after that write the trailer and close the
file. */
FILE *f = mallstream;
mallstream = NULL;
set_default_hooks ();
fprintf (f, "= End\n");
fclose (f);
#if !IS_IN (libc)
do_muntrace ();
#endif
}