include/rtld-malloc.h

   1 /* Redirection of malloc inside the dynamic linker.
   2    Copyright (C) 2020-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 /* The dynamic linker needs to use its own minimal malloc before libc
  20    has been relocated, and the libc malloc afterwards.  The active
  21    malloc implementation is reached via the __rtld_* function pointers
  22    declared below.  They are initialized to the minimal malloc by
  23    __rtld_malloc_init_stubs, and set to the final implementation by
  24    __rtld_malloc_init_real.  */
  25
  26 #ifndef _RTLD_MALLOC_H
  27 #define _RTLD_MALLOC_H
  28
  29 #if IS_IN (rtld)
  30
  31 extern __typeof (calloc) *__rtld_calloc attribute_hidden;
  32 extern __typeof (free) *__rtld_free attribute_hidden;
  33 extern __typeof (malloc) *__rtld_malloc attribute_hidden;
  34 extern __typeof (realloc) *__rtld_realloc attribute_hidden;
  35
  36 /* Wrapper functions which call through the function pointers above.
  37    Note that it is not supported to take the address of those
  38    functions.  Instead the function pointers must be used
  39    directly.  */
  40
  41 __extern_inline void *
  42 calloc (size_t a, size_t b)
  43 {
  44   return __rtld_calloc (a, b);
  45 }
  46
  47 __extern_inline void
  48 free (void *ptr)
  49 {
  50    __rtld_free (ptr);
  51 }
  52
  53 __extern_inline void *
  54 malloc (size_t size)
  55 {
  56   return __rtld_malloc (size);
  57 }
  58
  59 __extern_inline void *
  60 realloc (void *ptr, size_t size)
  61 {
  62   return __rtld_realloc (ptr, size);
  63 }
  64
  65 /* Called after the first self-relocation to activate the minimal malloc
  66    implementation.  */
  67 void __rtld_malloc_init_stubs (void) attribute_hidden;
  68
  69 /* Return false if the active malloc is the ld.so minimal malloc, true
  70    if it is the full implementation from libc.so.  */
  71 _Bool __rtld_malloc_is_complete (void) attribute_hidden;
  72
  73 /* Called shortly before the final self-relocation (when RELRO
  74    variables are still writable) to activate the real malloc
  75    implementation.  MAIN_MAP is the link map of the executable.  */
  76 struct link_map;
  77 void __rtld_malloc_init_real (struct link_map *main_map) attribute_hidden;
  78
  79 #else /* !IS_IN (rtld) */
  80
  81 /* This allows static/non-rtld builds to get a pointer to the
  82    functions, in the same way that is required inside rtld.  */
  83 # define __rtld_calloc (&calloc)
  84 # define __rtld_free (&free)
  85 # define __rtld_malloc (&malloc)
  86 # define __rtld_realloc (&realloc)
  87
  88 #endif /* !IS_IN (rtld) */
  89 #endif /* _RTLD_MALLOC_H */