1 /* Redirection of malloc inside the dynamic linker.
2 Copyright (C) 2020-2022 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 *
calloc(size_t a,size_t b)42 calloc (size_t a, size_t b)
43 {
44 return __rtld_calloc (a, b);
45 }
46
47 __extern_inline void
free(void * ptr)48 free (void *ptr)
49 {
50 __rtld_free (ptr);
51 }
52
53 __extern_inline void *
malloc(size_t size)54 malloc (size_t size)
55 {
56 return __rtld_malloc (size);
57 }
58
59 __extern_inline void *
realloc(void * ptr,size_t size)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 */
90