From: DJ Delorie <dj@redhat.com>
To: Siddhesh Poyarekar <siddhesh@sourceware.org>
Cc: libc-alpha@sourceware.org, carlos@redhat.com, fweimer@redhat.com
Subject: Re: [PATCH 6/8] Remove malloc hooks
Date: Thu, 24 Jun 2021 19:31:50 -0400 [thread overview]
Message-ID: <xnzgve6dqx.fsf@greed.delorie.com> (raw)
In-Reply-To: <20210624182312.236596-7-siddhesh@sourceware.org>
Siddhesh Poyarekar <siddhesh@sourceware.org> writes:
> Make malloc hooks symbols compat-only so that new applications cannot
> link against them and remove the declarations from the API. The
> existing hooks variables are not used in the library anymore.
>
> Legacy applications that need hooks functionality need to preload a
> new DSO libmalloc_compathooks.so, which interposes the libc malloc
> functions to execute hooks if they exist.
>
> Also remove all references to the malloc hooks in the manual. Mention
> the removal in NEWS and also warn that libmalloc_compathooks.so is a
> temporary measure and may be removed in a future version of glibc.
>
> memalign makes a comeback as a PLT reference since the initialization
> hooks use them. tst-mallocstate now needs libmalloc_compathooks.so
> since it uses __malloc_initialize_hook to set up initial heap state to
> emumate emacs.
> diff --git a/Makeconfig b/Makeconfig
> index 407df9e6a1..991d6d3e99 100644
> --- a/Makeconfig
> +++ b/Makeconfig
> @@ -951,7 +951,7 @@ libio-include = -I$(..)libio
> built-modules = iconvprogs iconvdata ldconfig lddlibc4 libmemusage \
> libSegFault libpcprofile librpcsvc locale-programs \
> memusagestat nonlib nscd extramodules libnldbl libsupport \
> - testsuite
> + testsuite libmalloc_compathooks
New library, ok.
> diff --git a/NEWS b/NEWS
> index 536e80721a..8a7226aef2 100644
> --- a/NEWS
> +++ b/NEWS
> @@ -68,6 +68,15 @@ Deprecated and removed features, and other changes affecting compatibility:
> mtrace. Similar functionality can be achieved by using conditional
> breakpoints within mtrace functions from within gdb.
>
> +* The deprecated memory allocation hooks __malloc_hook, __realloc_hook,
> + __memalign_hook and __free_hook are now removed from the API. Compatibility
> + symbols are present to support legacy programs but new applications can no
> + longer link to these symbols. Further, the hooks no longer have any effect
> + on glibc functionality. A compatibility DSO libmalloc_compathooks.so has
> + been provided as a transitional measure to get hook functionality back for
> + legacy programs until they are updated to remove references to the memory
> + allocation hooks.
> +
Ok.
> diff --git a/malloc/Makefile b/malloc/Makefile
> index f9433af880..7d07b94a03 100644
> --- a/malloc/Makefile
> +++ b/malloc/Makefile
> @@ -41,6 +41,7 @@ tests := mallocbug tst-malloc tst-valloc tst-calloc tst-obstack \
> tst-malloc-stats-cancellation \
> tst-tcfree1 tst-tcfree2 tst-tcfree3 \
> tst-safe-linking \
> + tst-compathooks-off tst-compathooks-on
Ok.
> -# Additional library.
> -extra-libs = libmemusage
> +# Additional libraries.
> +extra-libs = libmemusage libmalloc_compathooks
> extra-libs-others = $(extra-libs)
Ok.
> @@ -128,6 +129,9 @@ test-extras = \
> libmemusage-routines = memusage
> libmemusage-inhibit-o = $(filter-out .os,$(object-suffixes))
>
> +libmalloc_compathooks-routines = malloc-compathooks
> +libmalloc_compathooks-inhibit-o = $(filter-out .os,$(object-suffixes))
Ok.
> @@ -313,3 +317,10 @@ $(objpfx)tst-mallocfork2-mcheck: $(shared-thread-library)
> $(objpfx)tst-malloc-tcache-leak-malloc-check: $(shared-thread-library)
> $(objpfx)tst-malloc_info-malloc-check: $(shared-thread-library)
> $(objpfx)tst-mallocfork2-malloc-check: $(shared-thread-library)
> +
> +tst-compathooks-on-ENV = LD_PRELOAD=$(objpfx)libmalloc_compathooks.so
> +tst-compathooks-on-mcheck-ENV = LD_PRELOAD=$(objpfx)libmalloc_compathooks.so
> +tst-compathooks-on-malloc-check-ENV = \
> + LD_PRELOAD=$(objpfx)libmalloc_compathooks.so
> +tst-mallocstate-ENV = LD_PRELOAD=$(objpfx)libmalloc_compathooks.so
> +tst-mallocstate-malloc-check-ENV = LD_PRELOAD=$(objpfx)libmalloc_compathooks.so
Ok.
> diff --git a/malloc/arena.c b/malloc/arena.c
> index a8500a25c9..8591c8ea56 100644
> --- a/malloc/arena.c
> +++ b/malloc/arena.c
> @@ -408,11 +408,6 @@ ptmalloc_init (void)
> __mcheck_initialize (NULL, false);
> #endif
>
> -#if HAVE_MALLOC_INIT_HOOK
> - void (*hook) (void) = atomic_forced_read (__malloc_initialize_hook);
> - if (hook != NULL)
> - (*hook)();
> -#endif
> __malloc_initialized = 1;
> }
Ok.
> diff --git a/malloc/hooks.c b/malloc/hooks.c
> index 492e9aac63..cc9ffc8b63 100644
> --- a/malloc/hooks.c
> +++ b/malloc/hooks.c
> @@ -42,23 +42,84 @@ enum malloc_debug_hooks
> static unsigned __malloc_debugging_hooks;
>
> /* Forward declarations. */
> +static void ptmalloc_init (void);
>
> -#if HAVE_MALLOC_INIT_HOOK
> +#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_24)
2_24? Not 2_34?
> void (*__malloc_initialize_hook) (void) __attribute__ ((nocommon));
> compat_symbol (libc, __malloc_initialize_hook,
> __malloc_initialize_hook, GLIBC_2_0);
> +
> +# define MALLOC_INIT_HOOK() ({ \
> + void (*hook) (void) = atomic_forced_read (__malloc_initialize_hook); \
> + if (hook != NULL) \
> + (*hook)(); \
> +})
> +#else
> +# define MALLOC_INIT_HOOK()
> #endif
Ok.
> +#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_34)
> +
> +static void *malloc_hook_ini (size_t, const void *) __THROW;
> +static void *realloc_hook_ini (void *, size_t, const void *) __THROW;
> +static void *memalign_hook_ini (size_t, size_t, const void *) __THROW;
> +
> void weak_variable (*__free_hook) (void *__ptr,
> const void *) = NULL;
> void *weak_variable (*__malloc_hook)
> - (size_t __size, const void *) = NULL;
> + (size_t __size, const void *) = malloc_hook_ini;
> void *weak_variable (*__realloc_hook)
> - (void *__ptr, size_t __size, const void *) = NULL;
> + (void *__ptr, size_t __size, const void *) = realloc_hook_ini;
> void *weak_variable (*__memalign_hook)
> - (size_t __alignment, size_t __size, const void *) = NULL;
> + (size_t __alignment, size_t __size, const void *) = memalign_hook_ini;
>
> -static void ptmalloc_init (void);
> +compat_symbol (libc, __free_hook, __free_hook, GLIBC_2_0);
> +compat_symbol (libc, __malloc_hook, __malloc_hook, GLIBC_2_0);
> +compat_symbol (libc, __realloc_hook, __realloc_hook, GLIBC_2_0);
> +compat_symbol (libc, __memalign_hook, __memalign_hook, GLIBC_2_0);
> +
> +/* These hooks will get executed only through the interposed allocator
> + functions in libmalloc_compathooks. This means that the calls to malloc,
> + realloc, etc. will lead back into the interposed functions, which is what we
> + want.
> +
> + These initial hooks are assumed to be called in a single-threaded context,
> + so it is safe to reset all hooks at once upon initialization. */
> +
> +static void
> +generic_hook_ini (void)
> +{
> + __malloc_hook = NULL;
> + __realloc_hook = NULL;
> + __memalign_hook = NULL;
> + if (__malloc_initialized < 0)
> + {
> + ptmalloc_init ();
> + MALLOC_INIT_HOOK ();
> + }
> +}
> +
> +static void *
> +malloc_hook_ini (size_t sz, const void *caller)
> +{
> + generic_hook_ini ();
> + return malloc (sz);
> +}
> +
> +static void *
> +realloc_hook_ini (void *ptr, size_t sz, const void *caller)
> +{
> + generic_hook_ini ();
> + return realloc (ptr, sz);
> +}
> +
> +static void *
> +memalign_hook_ini (size_t alignment, size_t sz, const void *caller)
> +{
> + generic_hook_ini ();
> + return memalign (alignment, sz);
> +}
> +#endif
Ok. Why not free_hook?
> __is_malloc_debug_enabled (enum malloc_debug_hooks flag)
> @@ -88,14 +149,6 @@ _malloc_debug_before (size_t *bytesp, void **victimp, const void *address)
> _Static_assert (PTRDIFF_MAX <= SIZE_MAX / 2,
> "PTRDIFF_MAX is not more than half of SIZE_MAX");
>
> - void *(*hook) (size_t, const void *)
> - = atomic_forced_read (__malloc_hook);
> - if (__builtin_expect (hook != NULL, 0))
> - {
> - *victimp = (*hook)(*bytesp, address);
> - return true;
> - }
> -
Yay! Ok.
> @@ -126,14 +179,6 @@ _malloc_debug_after (void *mem, size_t bytes, const void *address)
> static __always_inline bool
> _free_debug_before (void **mem, const void *address)
> {
> - void (*hook) (void *, const void *)
> - = atomic_forced_read (__free_hook);
> - if (__builtin_expect (hook != NULL, 0))
> - {
> - (*hook)(*mem, address);
> - return true;
> - }
> -
Ok.
> @@ -153,14 +198,6 @@ static __always_inline bool
> _realloc_debug_before (void **oldmem, size_t *bytesp, size_t *oldsize,
> void **victimp, const void *address)
> {
> - void *(*hook) (void *, size_t, const void *) =
> - atomic_forced_read (__realloc_hook);
> - if (__builtin_expect (hook != NULL, 0))
> - {
> - *victimp = (*hook)(*oldmem, *bytesp, address);
> - return true;
> - }
> -
Ok.
> @@ -194,13 +231,6 @@ static __always_inline bool
> _memalign_debug_before (size_t alignment, size_t *bytesp, void **victimp,
> const void *address)
> {
> - void *(*hook) (size_t, size_t, const void *) =
> - atomic_forced_read (__memalign_hook);
> - if (__builtin_expect (hook != NULL, 0))
> - {
> - *victimp = (*hook)(alignment, *bytesp, address);
> - return true;
> - }
Ok.
> if (__glibc_unlikely (__malloc_debugging_hooks))
> {
> if (__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK)
> @@ -233,18 +263,6 @@ _memalign_debug_after (void *mem, size_t alignment, size_t bytes,
> static __always_inline bool
> _calloc_debug_before (size_t *bytesp, void **victimp, const void *address)
> {
> - void *(*hook) (size_t, const void *) =
> - atomic_forced_read (__malloc_hook);
> - if (__builtin_expect (hook != NULL, 0))
> - {
> - *victimp = (*hook)(*bytesp, address);
> -
> - if (*victimp != NULL)
> - memset (*victimp, 0, *bytesp);
> -
> - return true;
> - }
> -
Ok.
> diff --git a/malloc/malloc-compathooks.c b/malloc/malloc-compathooks.c
> new file mode 100644
> index 0000000000..6d1eaab774
> --- /dev/null
> +++ b/malloc/malloc-compathooks.c
> @@ -0,0 +1,166 @@
> +/* Malloc hooks compatibility DSO.
> + Copyright (C) 2021 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + The GNU C Library is free software; you can redistribute it and/or
> + modify it under the terms of the GNU Lesser General Public License as
> + published by the Free Software Foundation; either version 2.1 of the
> + License, or (at your option) any later version.
> +
> + The GNU C Library is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + 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; see the file COPYING.LIB. If
> + not, see <https://www.gnu.org/licenses/>. */
> +
> +#include <atomic.h>
> +#include <libc-symbols.h>
> +#include <shlib-compat.h>
> +#include <string.h>
> +#include <unistd.h>
> +
> +extern void (*__free_hook) (void *__ptr, const void *);
> +compat_symbol_reference (libc, __free_hook, __free_hook, GLIBC_2_0);
> +extern void * (*__malloc_hook) (size_t __size, const void *);
> +compat_symbol_reference (libc, __malloc_hook, __malloc_hook, GLIBC_2_0);
> +extern void * (*__realloc_hook)
> + (void *__ptr, size_t __size, const void *);
> +compat_symbol_reference (libc, __realloc_hook, __realloc_hook, GLIBC_2_0);
> +extern void * (*__memalign_hook)
> + (size_t __alignment, size_t __size, const void *);
> +compat_symbol_reference (libc, __memalign_hook, __memalign_hook, GLIBC_2_0);
> +
> +/* Support only the glibc allocators. */
> +extern void *__libc_malloc (size_t);
> +extern void __libc_free (void *);
> +extern void *__libc_realloc (void *, size_t);
> +extern void *__libc_memalign (size_t, size_t);
> +extern void *__libc_valloc (size_t);
> +extern void *__libc_pvalloc (size_t);
> +extern void *__libc_calloc (size_t, size_t);
Ok.
> +static size_t pagesize;
Ok.
> +/* The allocator functions. */
> +
> +static void *
> +__compathook_malloc (size_t bytes)
> +{
> + void *(*hook) (size_t, const void *) = atomic_forced_read (__malloc_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + return (*hook)(bytes, RETURN_ADDRESS (0));
> +
> + return __libc_malloc (bytes);
> +}
> +strong_alias (__compathook_malloc, malloc)
Ok.
> +static void
> +__compathook_free (void *mem)
> +{
> + void (*hook) (void *, const void *) = atomic_forced_read (__free_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + {
> + (*hook)(mem, RETURN_ADDRESS (0));
> + return;
> + }
> + __libc_free (mem);
> +}
> +strong_alias (__compathook_free, free)
Ok.
> +static void *
> +__compathook_realloc (void *oldmem, size_t bytes)
> +{
> + void *(*hook) (void *, size_t, const void *) =
> + atomic_forced_read (__realloc_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + return (*hook)(oldmem, bytes, RETURN_ADDRESS (0));
> +
> + return __libc_realloc (oldmem, bytes);
> +}
> +strong_alias (__compathook_realloc, realloc)
Ok.
> +static void *
> +__compathook_memalign (size_t alignment, size_t bytes)
> +{
> + void *(*hook) (size_t, size_t, const void *) =
> + atomic_forced_read (__memalign_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + return (*hook)(alignment, bytes, RETURN_ADDRESS (0));
> +
> + return __libc_memalign (alignment, bytes);
> +}
> +strong_alias (__compathook_memalign, memalign)
Ok.
> +static void *
> +__compathook_pvalloc (size_t bytes)
> +{
> + void *(*hook) (size_t, size_t, const void *) =
> + atomic_forced_read (__memalign_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + {
> + size_t rounded_bytes;
> +
> + if (!pagesize)
> + pagesize = sysconf (_SC_PAGESIZE);
> +
> + /* ALIGN_UP with overflow check. */
> + if (__glibc_unlikely (__builtin_add_overflow (bytes,
> + pagesize - 1,
> + &rounded_bytes)))
> + {
> + errno = ENOMEM;
> + return NULL;
> + }
> + rounded_bytes = rounded_bytes & -(pagesize - 1);
> + return (*hook)(pagesize, rounded_bytes, RETURN_ADDRESS (0));
> + }
> +
> + return __libc_pvalloc (bytes);
> +}
> +strong_alias (__compathook_pvalloc, pvalloc)
Ok.
> +static void *
> +__compathook_valloc (size_t bytes)
> +{
> + void *(*hook) (size_t, size_t, const void *) =
> + atomic_forced_read (__memalign_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + {
> + if (!pagesize)
> + pagesize = sysconf (_SC_PAGESIZE);
> +
> + return (*hook)(pagesize, bytes, RETURN_ADDRESS (0));
> + }
> +
> + return __libc_valloc (bytes);
> +}
> +strong_alias (__compathook_valloc, valloc)
Ok.
> +static void *
> +__compathook_calloc (size_t nmemb, size_t size)
> +{
> + void *(*hook) (size_t, const void *) = atomic_forced_read (__malloc_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + {
> + size_t bytes;
> +
> + if (__glibc_unlikely (__builtin_mul_overflow (nmemb, size, &bytes)))
> + {
> + errno = ENOMEM;
> + return NULL;
> + }
> +
> + void *mem = (*hook)(bytes, RETURN_ADDRESS (0));
> +
> + if (mem != NULL)
> + memset (mem, 0, bytes);
> +
> + return mem;
> + }
> +
> + return __libc_calloc (nmemb, size);
> +}
> +strong_alias (__compathook_calloc, calloc)
Ok.
> diff --git a/malloc/malloc.c b/malloc/malloc.c
> index 5ea12d1d3b..16ad933c66 100644
> --- a/malloc/malloc.c
> +++ b/malloc/malloc.c
> @@ -570,16 +570,6 @@ tag_at (void *ptr)
> #define HAVE_MREMAP 0
> #endif
>
> -/* We may need to support __malloc_initialize_hook for backwards
> - compatibility. */
> -
> -#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_24)
> -# define HAVE_MALLOC_INIT_HOOK 1
> -#else
> -# define HAVE_MALLOC_INIT_HOOK 0
> -#endif
> -
> -
Ok.
> diff --git a/malloc/malloc.h b/malloc/malloc.h
> index c1c0896d29..709fa454b5 100644
> --- a/malloc/malloc.h
> +++ b/malloc/malloc.h
> @@ -165,20 +165,6 @@ extern void malloc_stats (void) __THROW;
> extern int malloc_info (int __options, FILE *__fp) __THROW;
>
> /* Hooks for debugging and user-defined versions. */
> -extern void (*__MALLOC_HOOK_VOLATILE __free_hook) (void *__ptr,
> - const void *)
> -__MALLOC_DEPRECATED;
> -extern void *(*__MALLOC_HOOK_VOLATILE __malloc_hook)(size_t __size,
> - const void *)
> -__MALLOC_DEPRECATED;
> -extern void *(*__MALLOC_HOOK_VOLATILE __realloc_hook)(void *__ptr,
> - size_t __size,
> - const void *)
> -__MALLOC_DEPRECATED;
> -extern void *(*__MALLOC_HOOK_VOLATILE __memalign_hook)(size_t __alignment,
> - size_t __size,
> - const void *)
> -__MALLOC_DEPRECATED;
> extern void (*__MALLOC_HOOK_VOLATILE __after_morecore_hook) (void)
> __MALLOC_DEPRECATED;
Ok.
> diff --git a/manual/memory.texi b/manual/memory.texi
> index 28ec2e4e63..e66ecd582d 100644
> --- a/manual/memory.texi
> +++ b/manual/memory.texi
> @@ -328,8 +328,6 @@ any time (or never).
> * Malloc Tunable Parameters:: Use @code{mallopt} to adjust allocation
> parameters.
> * Heap Consistency Checking:: Automatic checking for errors.
> -* Hooks for Malloc:: You can use these hooks for debugging
> - programs that use @code{malloc}.
> * Statistics of Malloc:: Getting information about how much
> memory your program is using.
> * Summary of Malloc:: Summary of @code{malloc} and related functions.
> @@ -1388,170 +1386,6 @@ compatibility. Both @code{MALLOC_CHECK_} and @samp{-lmcheck} should
> uncover the same bugs - but using @code{MALLOC_CHECK_} you don't need to
> recompile your application.
>
> -@node Hooks for Malloc
> -@subsubsection Memory Allocation Hooks
> -@cindex allocation hooks, for @code{malloc}
> -
> . . .
> -The @code{mcheck} function (@pxref{Heap Consistency Checking}) works by
> -installing such hooks.
> -
Ok.
> @@ -1686,19 +1520,6 @@ Tell @code{malloc} to perform occasional consistency checks on
> dynamically allocated memory, and to call @var{abortfn} when an
> inconsistency is found. @xref{Heap Consistency Checking}.
>
> -@item void *(*__malloc_hook) (size_t @var{size}, const void *@var{caller})
> -A pointer to a function that @code{malloc} uses whenever it is called.
> -
> -@item void *(*__realloc_hook) (void *@var{ptr}, size_t @var{size}, const void *@var{caller})
> -A pointer to a function that @code{realloc} uses whenever it is called.
> -
> -@item void (*__free_hook) (void *@var{ptr}, const void *@var{caller})
> -A pointer to a function that @code{free} uses whenever it is called.
> -
> -@item void (*__memalign_hook) (size_t @var{size}, size_t @var{alignment}, const void *@var{caller})
> -A pointer to a function that @code{aligned_alloc}, @code{memalign},
> -@code{posix_memalign} and @code{valloc} use whenever they are called.
> -
Ok.
> @@ -1733,7 +1554,7 @@ penalties for the program if the debugging mode is not enabled.
>
> @deftypefun void mtrace (void)
> @standards{GNU, mcheck.h}
> -@safety{@prelim{}@mtunsafe{@mtsenv{} @mtasurace{:mtrace} @mtasuconst{:malloc_hooks} @mtuinit{}}@asunsafe{@asuinit{} @ascuheap{} @asucorrupt{} @asulock{}}@acunsafe{@acuinit{} @acucorrupt{} @aculock{} @acsfd{} @acsmem{}}}
> +@safety{@prelim{}@mtunsafe{@mtsenv{} @mtasurace{:mtrace} @mtuinit{}}@asunsafe{@asuinit{} @ascuheap{} @asucorrupt{} @asulock{}}@acunsafe{@acuinit{} @acucorrupt{} @aculock{} @acsfd{} @acsmem{}}}
Ok.
> @@ -1758,10 +1579,10 @@ with the SUID or SGID bit set.
>
> If the named file is successfully opened, @code{mtrace} installs special
> handlers for the functions @code{malloc}, @code{realloc}, and
> -@code{free} (@pxref{Hooks for Malloc}). From then on, all uses of these
> -functions are traced and protocolled into the file. There is now of
> -course a speed penalty for all calls to the traced functions so tracing
> -should not be enabled during normal use.
> +@code{free}. From then on, all uses of these functions are traced and
> +protocolled into the file. There is now of course a speed penalty for all
> +calls to the traced functions so tracing should not be enabled during normal
> +use.
Ok.
> @@ -1769,7 +1590,7 @@ systems. The prototype can be found in @file{mcheck.h}.
>
> @deftypefun void muntrace (void)
> @standards{GNU, mcheck.h}
> -@safety{@prelim{}@mtunsafe{@mtasurace{:mtrace} @mtasuconst{:malloc_hooks} @mtslocale{}}@asunsafe{@asucorrupt{} @ascuheap{}}@acunsafe{@acucorrupt{} @acsmem{} @aculock{} @acsfd{}}}
> +@safety{@prelim{}@mtunsafe{@mtasurace{:mtrace} @mtslocale{}}@asunsafe{@asucorrupt{} @ascuheap{}}@acunsafe{@acucorrupt{} @acsmem{} @aculock{} @acsfd{}}}
Ok.
next prev parent reply other threads:[~2021-06-24 23:31 UTC|newest]
Thread overview: 21+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-06-24 18:23 [PATCH 0/8] " Siddhesh Poyarekar
2021-06-24 18:23 ` [PATCH 1/8] Move glibc.malloc.check implementation into its own file Siddhesh Poyarekar
2021-06-24 19:57 ` DJ Delorie
2021-06-28 4:34 ` Siddhesh Poyarekar
2021-06-24 18:23 ` [PATCH 2/8] malloc: Move malloc hook references to hooks.c Siddhesh Poyarekar
2021-06-24 21:10 ` DJ Delorie
2021-06-24 18:23 ` [PATCH 3/8] glibc.malloc.check: Wean away from malloc hooks Siddhesh Poyarekar
2021-06-24 21:43 ` DJ Delorie
2021-06-24 18:23 ` [PATCH 4/8] mcheck: " Siddhesh Poyarekar
2021-06-24 22:51 ` DJ Delorie
2021-06-28 6:22 ` Siddhesh Poyarekar
2021-06-24 18:23 ` [PATCH 5/8] mtrace: " Siddhesh Poyarekar
2021-06-24 23:13 ` DJ Delorie
2021-06-28 6:25 ` Siddhesh Poyarekar
2021-06-24 18:23 ` [PATCH 6/8] Remove " Siddhesh Poyarekar
2021-06-24 23:31 ` DJ Delorie [this message]
2021-06-28 6:37 ` Siddhesh Poyarekar
2021-06-24 18:23 ` [PATCH 7/8] Remove __after_morecore_hook Siddhesh Poyarekar
2021-06-24 23:33 ` DJ Delorie
2021-06-24 18:23 ` [PATCH 8/8] Remove __morecore and __default_morecore Siddhesh Poyarekar
2021-06-24 23:38 ` DJ Delorie
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=xnzgve6dqx.fsf@greed.delorie.com \
--to=dj@redhat.com \
--cc=carlos@redhat.com \
--cc=fweimer@redhat.com \
--cc=libc-alpha@sourceware.org \
--cc=siddhesh@sourceware.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).