1 /* Test allocation function behavior on allocation failure.
2 Copyright (C) 2015-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 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 <https://www.gnu.org/licenses/>. */
18
19 /* This test case attempts to trigger various unusual conditions
20 related to allocation failures, notably switching to a different
21 arena, and falling back to mmap (via sysmalloc). */
22
23 #include <errno.h>
24 #include <malloc.h>
25 #include <pthread.h>
26 #include <stdbool.h>
27 #include <stdint.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <sys/resource.h>
31 #include <sys/wait.h>
32 #include <unistd.h>
33
34 /* Wrapper for calloc with an optimization barrier. */
35 static void *
36 __attribute__ ((noinline, noclone))
37 allocate_zeroed (size_t a, size_t b)
38 {
39 return calloc (a, b);
40 }
41
42 /* System page size, as determined by sysconf (_SC_PAGE_SIZE). */
43 static unsigned long page_size;
44
45 /* Test parameters. */
46 static size_t allocation_size;
47 static size_t alignment;
48 static enum {
49 with_malloc,
50 with_realloc,
51 with_aligned_alloc,
52 with_memalign,
53 with_posix_memalign,
54 with_valloc,
55 with_pvalloc,
56 with_calloc,
57 last_allocation_function = with_calloc
58 } allocation_function;
59
60 /* True if an allocation function uses the alignment test
61 parameter. */
62 const static bool alignment_sensitive[last_allocation_function + 1] =
63 {
64 [with_aligned_alloc] = true,
65 [with_memalign] = true,
66 [with_posix_memalign] = true,
67 };
68
69 /* Combined pointer/expected alignment result of an allocation
70 function. */
71 struct allocate_result {
72 void *pointer;
73 size_t alignment;
74 };
75
76 /* Call the allocation function specified by allocation_function, with
77 allocation_size and alignment (if applicable) as arguments. No
78 alignment check. */
79 static struct allocate_result
80 allocate_1 (void)
81 {
82 switch (allocation_function)
83 {
84 case with_malloc:
85 return (struct allocate_result)
86 {malloc (allocation_size), _Alignof (max_align_t)};
87 case with_realloc:
88 {
89 void *p = realloc (NULL, 16);
90 void *q;
91 if (p == NULL)
92 q = NULL;
93 else
94 {
95 q = realloc (p, allocation_size);
96 if (q == NULL)
97 free (p);
98 }
99 return (struct allocate_result) {q, _Alignof (max_align_t)};
100 }
101 case with_aligned_alloc:
102 {
103 void *p = aligned_alloc (alignment, allocation_size);
104 return (struct allocate_result) {p, alignment};
105 }
106 case with_memalign:
107 {
108 void *p = memalign (alignment, allocation_size);
109 return (struct allocate_result) {p, alignment};
110 }
111 case with_posix_memalign:
112 {
113 void *p;
114 if (posix_memalign (&p, alignment, allocation_size))
115 {
116 if (errno == ENOMEM)
117 p = NULL;
118 else
119 {
120 printf ("error: posix_memalign (p, %zu, %zu): %m\n",
121 alignment, allocation_size);
122 abort ();
123 }
124 }
125 return (struct allocate_result) {p, alignment};
126 }
127 case with_valloc:
128 {
129 void *p = valloc (allocation_size);
130 return (struct allocate_result) {p, page_size};
131 }
132 case with_pvalloc:
133 {
134 void *p = pvalloc (allocation_size);
135 return (struct allocate_result) {p, page_size};
136 }
137 case with_calloc:
138 {
139 char *p = allocate_zeroed (1, allocation_size);
140 /* Check for non-zero bytes. */
141 if (p != NULL)
142 for (size_t i = 0; i < allocation_size; ++i)
143 if (p[i] != 0)
144 {
145 printf ("error: non-zero byte at offset %zu\n", i);
146 abort ();
147 }
148 return (struct allocate_result) {p, _Alignof (max_align_t)};
149 }
150 }
151 abort ();
152 }
153
154 /* Call allocate_1 and perform the alignment check on the result. */
155 static void *
156 allocate (void)
157 {
158 struct allocate_result r = allocate_1 ();
159 if ((((uintptr_t) r.pointer) & (r.alignment - 1)) != 0)
160 {
161 printf ("error: allocation function %d, size %zu not aligned to %zu\n",
162 (int) allocation_function, allocation_size, r.alignment);
163 abort ();
164 }
165 return r.pointer;
166 }
167
168 /* Barriers to synchronize thread creation and termination. */
169 static pthread_barrier_t start_barrier;
170 static pthread_barrier_t end_barrier;
171
172 /* Thread function which performs the allocation test. Called by
173 pthread_create and from the main thread. */
174 static void *
175 allocate_thread (void *closure)
176 {
177 /* Wait for the creation of all threads. */
178 {
179 int ret = pthread_barrier_wait (&start_barrier);
180 if (ret != 0 && ret != PTHREAD_BARRIER_SERIAL_THREAD)
181 {
182 errno = ret;
183 printf ("error: pthread_barrier_wait: %m\n");
184 abort ();
185 }
186 }
187
188 /* Allocate until we run out of memory, creating a single-linked
189 list. */
190 struct list {
191 struct list *next;
192 };
193 struct list *head = NULL;
194 while (true)
195 {
196 struct list *e = allocate ();
197 if (e == NULL)
198 break;
199
200 e->next = head;
201 head = e;
202 }
203
204 /* Wait for the allocation of all available memory. */
205 {
206 int ret = pthread_barrier_wait (&end_barrier);
207 if (ret != 0 && ret != PTHREAD_BARRIER_SERIAL_THREAD)
208 {
209 errno = ret;
210 printf ("error: pthread_barrier_wait: %m\n");
211 abort ();
212 }
213 }
214
215 /* Free the allocated memory. */
216 while (head != NULL)
217 {
218 struct list *next = head->next;
219 free (head);
220 head = next;
221 }
222
223 return NULL;
224 }
225
226 /* Number of threads (plus the main thread. */
227 enum { thread_count = 8 };
228
229 /* Thread attribute to request creation of threads with a non-default
230 stack size which is rather small. This avoids interfering with the
231 configured address space limit. */
232 static pthread_attr_t small_stack;
233
234 /* Runs one test in multiple threads, all in a subprocess so that
235 subsequent tests do not interfere with each other. */
236 static void
237 run_one (void)
238 {
239 /* Isolate the tests in a subprocess, so that we can start over
240 from scratch. */
241 pid_t pid = fork ();
242 if (pid == 0)
243 {
244 /* In the child process. Create the allocation threads. */
245 pthread_t threads[thread_count];
246
247 for (unsigned i = 0; i < thread_count; ++i)
248 {
249 int ret = pthread_create (threads + i, &small_stack, allocate_thread, NULL);
250 if (ret != 0)
251 {
252 errno = ret;
253 printf ("error: pthread_create: %m\n");
254 abort ();
255 }
256 }
257
258 /* Also run the test on the main thread. */
259 allocate_thread (NULL);
260
261 for (unsigned i = 0; i < thread_count; ++i)
262 {
263 int ret = pthread_join (threads[i], NULL);
264 if (ret != 0)
265 {
266 errno = ret;
267 printf ("error: pthread_join: %m\n");
268 abort ();
269 }
270 }
271 _exit (0);
272 }
273 else if (pid < 0)
274 {
275 printf ("error: fork: %m\n");
276 abort ();
277 }
278
279 /* In the parent process. Wait for the child process to exit. */
280 int status;
281 if (waitpid (pid, &status, 0) < 0)
282 {
283 printf ("error: waitpid: %m\n");
284 abort ();
285 }
286 if (status != 0)
287 {
288 printf ("error: exit status %d from child process\n", status);
289 exit (1);
290 }
291 }
292
293 /* Run all applicable allocation functions for the current test
294 parameters. */
295 static void
296 run_allocation_functions (void)
297 {
298 for (int af = 0; af <= last_allocation_function; ++af)
299 {
300 /* Run alignment-sensitive functions for non-default
301 alignments. */
302 if (alignment_sensitive[af] != (alignment != 0))
303 continue;
304 allocation_function = af;
305 run_one ();
306 }
307 }
308
309 int
310 do_test (void)
311 {
312 /* Limit the number of malloc arenas. We use a very low number so
313 that despute the address space limit configured below, all
314 requested arenas a can be created. */
315 if (mallopt (M_ARENA_MAX, 2) == 0)
316 {
317 printf ("error: mallopt (M_ARENA_MAX) failed\n");
318 return 1;
319 }
320
321 /* Determine the page size. */
322 {
323 long ret = sysconf (_SC_PAGE_SIZE);
324 if (ret < 0)
325 {
326 printf ("error: sysconf (_SC_PAGE_SIZE): %m\n");
327 return 1;
328 }
329 page_size = ret;
330 }
331
332 /* Limit the size of the process, so that memory allocation in
333 allocate_thread will eventually fail, without impacting the
334 entire system. */
335 {
336 struct rlimit limit;
337 if (getrlimit (RLIMIT_AS, &limit) != 0)
338 {
339 printf ("getrlimit (RLIMIT_AS) failed: %m\n");
340 return 1;
341 }
342 long target = 200 * 1024 * 1024;
343 if (limit.rlim_cur == RLIM_INFINITY || limit.rlim_cur > target)
344 {
345 limit.rlim_cur = target;
346 if (setrlimit (RLIMIT_AS, &limit) != 0)
347 {
348 printf ("setrlimit (RLIMIT_AS) failed: %m\n");
349 return 1;
350 }
351 }
352 }
353
354 /* Initialize thread attribute with a reduced stack size. */
355 {
356 int ret = pthread_attr_init (&small_stack);
357 if (ret != 0)
358 {
359 errno = ret;
360 printf ("error: pthread_attr_init: %m\n");
361 abort ();
362 }
363 unsigned long stack_size = ((256 * 1024) / page_size) * page_size;
364 if (stack_size < 4 * page_size)
365 stack_size = 8 * page_size;
366 ret = pthread_attr_setstacksize (&small_stack, stack_size);
367 if (ret != 0)
368 {
369 errno = ret;
370 printf ("error: pthread_attr_setstacksize: %m\n");
371 abort ();
372 }
373 }
374
375 /* Initialize the barriers. We run thread_count threads, plus 1 for
376 the main thread. */
377 {
378 int ret = pthread_barrier_init (&start_barrier, NULL, thread_count + 1);
379 if (ret != 0)
380 {
381 errno = ret;
382 printf ("error: pthread_barrier_init: %m\n");
383 abort ();
384 }
385
386 ret = pthread_barrier_init (&end_barrier, NULL, thread_count + 1);
387 if (ret != 0)
388 {
389 errno = ret;
390 printf ("error: pthread_barrier_init: %m\n");
391 abort ();
392 }
393 }
394
395 allocation_size = 144;
396 run_allocation_functions ();
397 allocation_size = page_size;
398 run_allocation_functions ();
399
400 alignment = 128;
401 allocation_size = 512;
402 run_allocation_functions ();
403
404 allocation_size = page_size;
405 run_allocation_functions ();
406
407 allocation_size = 17 * page_size;
408 run_allocation_functions ();
409
410 /* Deallocation the barriers and the thread attribute. */
411 {
412 int ret = pthread_barrier_destroy (&end_barrier);
413 if (ret != 0)
414 {
415 errno = ret;
416 printf ("error: pthread_barrier_destroy: %m\n");
417 return 1;
418 }
419 ret = pthread_barrier_destroy (&start_barrier);
420 if (ret != 0)
421 {
422 errno = ret;
423 printf ("error: pthread_barrier_destroy: %m\n");
424 return 1;
425 }
426 ret = pthread_attr_destroy (&small_stack);
427 if (ret != 0)
428 {
429 errno = ret;
430 printf ("error: pthread_attr_destroy: %m\n");
431 return 1;
432 }
433 }
434
435 return 0;
436 }
437
438 /* The repeated allocations take some time on slow machines. */
439 #define TIMEOUT 100
440
441 #define TEST_FUNCTION do_test ()
442 #include "../test-skeleton.c"