Warning: That file was not part of the compilation database. It may have many parsing errors.

1/* Minimal malloc implementation for interposition tests.
2 Copyright (C) 2016-2019 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 License as
7 published by the Free Software Foundation; either version 2.1 of the
8 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; see the file COPYING.LIB. If
17 not, see <http://www.gnu.org/licenses/>. */
18
19#include "tst-interpose-aux.h"
20
21#include <errno.h>
22#include <stdarg.h>
23#include <stddef.h>
24#include <stdint.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <sys/mman.h>
29#include <sys/uio.h>
30#include <unistd.h>
31
32#if INTERPOSE_THREADS
33#include <pthread.h>
34#endif
35
36/* Print the error message and terminate the process with status 1. */
37__attribute__ ((noreturn))
38__attribute__ ((format (printf, 1, 2)))
39static void *
40fail (const char *format, ...)
41{
42 /* This assumes that vsnprintf will not call malloc. It does not do
43 so for the format strings we use. */
44 char message[4096];
45 va_list ap;
46 va_start (ap, format);
47 vsnprintf (message, sizeof (message), format, ap);
48 va_end (ap);
49
50 enum { count = 3 };
51 struct iovec iov[count];
52
53 iov[0].iov_base = (char *) "error: ";
54 iov[1].iov_base = (char *) message;
55 iov[2].iov_base = (char *) "\n";
56
57 for (int i = 0; i < count; ++i)
58 iov[i].iov_len = strlen (iov[i].iov_base);
59
60 int unused __attribute__ ((unused));
61 unused = writev (STDOUT_FILENO, iov, count);
62 _exit (1);
63}
64
65#if INTERPOSE_THREADS
66static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
67#endif
68
69static void
70lock (void)
71{
72#if INTERPOSE_THREADS
73 int ret = pthread_mutex_lock (&mutex);
74 if (ret != 0)
75 {
76 errno = ret;
77 fail ("pthread_mutex_lock: %m");
78 }
79#endif
80}
81
82static void
83unlock (void)
84{
85#if INTERPOSE_THREADS
86 int ret = pthread_mutex_unlock (&mutex);
87 if (ret != 0)
88 {
89 errno = ret;
90 fail ("pthread_mutex_unlock: %m");
91 }
92#endif
93}
94
95struct __attribute__ ((aligned (__alignof__ (max_align_t)))) allocation_header
96{
97 size_t allocation_index;
98 size_t allocation_size;
99};
100
101/* Array of known allocations, to track invalid frees. */
102enum { max_allocations = 65536 };
103static struct allocation_header *allocations[max_allocations];
104static size_t allocation_index;
105static size_t deallocation_count;
106
107/* Sanity check for successful malloc interposition. */
108__attribute__ ((destructor))
109static void
110check_for_allocations (void)
111{
112 if (allocation_index == 0)
113 {
114 /* Make sure that malloc is called at least once from libc. */
115 void *volatile ptr = strdup ("ptr");
116 /* Compiler barrier. The strdup function calls malloc, which
117 updates allocation_index, but strdup is marked __THROW, so
118 the compiler could optimize away the reload. */
119 __asm__ volatile ("" ::: "memory");
120 free (ptr);
121 /* If the allocation count is still zero, it means we did not
122 interpose malloc successfully. */
123 if (allocation_index == 0)
124 fail ("malloc does not seem to have been interposed");
125 }
126}
127
128static struct allocation_header *get_header (const char *op, void *ptr)
129{
130 struct allocation_header *header = ((struct allocation_header *) ptr) - 1;
131 if (header->allocation_index >= allocation_index)
132 fail ("%s: %p: invalid allocation index: %zu (not less than %zu)",
133 op, ptr, header->allocation_index, allocation_index);
134 if (allocations[header->allocation_index] != header)
135 fail ("%s: %p: allocation pointer does not point to header, but %p",
136 op, ptr, allocations[header->allocation_index]);
137 return header;
138}
139
140/* Internal helper functions. Those must be called while the lock is
141 acquired. */
142
143static void *
144malloc_internal (size_t size)
145{
146 if (allocation_index == max_allocations)
147 {
148 errno = ENOMEM;
149 return NULL;
150 }
151 size_t allocation_size = size + sizeof (struct allocation_header);
152 if (allocation_size < size)
153 {
154 errno = ENOMEM;
155 return NULL;
156 }
157
158 size_t index = allocation_index++;
159 void *result = mmap (NULL, allocation_size, PROT_READ | PROT_WRITE,
160 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
161 if (result == MAP_FAILED)
162 return NULL;
163 allocations[index] = result;
164 *allocations[index] = (struct allocation_header)
165 {
166 .allocation_index = index,
167 .allocation_size = allocation_size
168 };
169 return allocations[index] + 1;
170}
171
172static void
173free_internal (const char *op, struct allocation_header *header)
174{
175 size_t index = header->allocation_index;
176 int result = mprotect (header, header->allocation_size, PROT_NONE);
177 if (result != 0)
178 fail ("%s: mprotect (%p, %zu): %m", op, header, header->allocation_size);
179 /* Catch double-free issues. */
180 allocations[index] = NULL;
181 ++deallocation_count;
182}
183
184static void *
185realloc_internal (void *ptr, size_t new_size)
186{
187 struct allocation_header *header = get_header ("realloc", ptr);
188 size_t old_size = header->allocation_size - sizeof (struct allocation_header);
189 if (old_size >= new_size)
190 return ptr;
191
192 void *newptr = malloc_internal (new_size);
193 if (newptr == NULL)
194 return NULL;
195 memcpy (newptr, ptr, old_size);
196 free_internal ("realloc", header);
197 return newptr;
198}
199
200/* Public interfaces. These functions must perform locking. */
201
202size_t
203malloc_allocation_count (void)
204{
205 lock ();
206 size_t count = allocation_index;
207 unlock ();
208 return count;
209}
210
211size_t
212malloc_deallocation_count (void)
213{
214 lock ();
215 size_t count = deallocation_count;
216 unlock ();
217 return count;
218}
219void *
220malloc (size_t size)
221{
222 lock ();
223 void *result = malloc_internal (size);
224 unlock ();
225 return result;
226}
227
228void
229free (void *ptr)
230{
231 if (ptr == NULL)
232 return;
233 lock ();
234 struct allocation_header *header = get_header ("free", ptr);
235 free_internal ("free", header);
236 unlock ();
237}
238
239void *
240calloc (size_t a, size_t b)
241{
242 if (b > 0 && a > SIZE_MAX / b)
243 {
244 errno = ENOMEM;
245 return NULL;
246 }
247 lock ();
248 /* malloc_internal uses mmap, so the memory is zeroed. */
249 void *result = malloc_internal (a * b);
250 unlock ();
251 return result;
252}
253
254void *
255realloc (void *ptr, size_t n)
256{
257 if (n ==0)
258 {
259 free (ptr);
260 return NULL;
261 }
262 else if (ptr == NULL)
263 return malloc (n);
264 else
265 {
266 lock ();
267 void *result = realloc_internal (ptr, n);
268 unlock ();
269 return result;
270 }
271}
272

Warning: That file was not part of the compilation database. It may have many parsing errors.