1 /* Test case for async-signal-safe fork (with respect to malloc).
2 Copyright (C) 2016-2019 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
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/>. */
19 /* This test will fail if the process is multi-threaded because we
20 only have an async-signal-safe fork in the single-threaded case
21 (where we skip acquiring the malloc heap locks).
23 This test only checks async-signal-safety with regards to malloc;
24 other, more rarely-used glibc subsystems could have locks which
25 still make fork unsafe, even in single-threaded processes. */
37 #include <array_length.h>
38 #include <support/check.h>
39 #include <support/support.h>
40 #include <support/xthread.h>
41 #include <support/xunistd.h>
43 /* How many malloc objects to keep arond. */
44 enum { malloc_objects
= 1009 };
46 /* The maximum size of an object. */
47 enum { malloc_maximum_size
= 70000 };
49 /* How many iterations the test performs before exiting. */
50 enum { iterations
= 10000 };
52 /* Barrier for synchronization with the processes sending SIGUSR1
53 signals, to make it more likely that the signals arrive during a
54 fork/free/malloc call. */
55 static struct { pthread_barrier_t barrier
; } *shared
;
57 /* Set to 1 if SIGUSR1 is received. Used to detect a signal during
59 static volatile sig_atomic_t sigusr1_received
;
61 /* Periodically set to 1, to indicate that the process is making
62 progress. Checked by liveness_signal_handler. */
63 static volatile sig_atomic_t progress_indicator
= 1;
66 sigusr1_handler (int signo
)
70 /* Perform a fork with a trivial subprocess. */
74 write_message ("error: fork\n");
80 int ret
= TEMP_FAILURE_RETRY (waitpid (pid
, &status
, 0));
83 write_message ("error: waitpid\n");
88 write_message ("error: unexpected exit status from subprocess\n");
94 liveness_signal_handler (int signo
)
96 if (progress_indicator
)
97 progress_indicator
= 0;
99 write_message ("warning: process seems to be stuck\n");
102 /* Send SIGNO to the parent process. If SLEEP, wait a second between
103 signals, otherwise use barriers to delay sending signals. */
105 __attribute__ ((noreturn
))
106 signal_sender (int signo
, bool sleep
)
108 pid_t target
= getppid ();
112 xpthread_barrier_wait (&shared
->barrier
);
113 if (kill (target
, signo
) != 0)
115 dprintf (STDOUT_FILENO
, "error: kill: %m\n");
119 usleep (1 * 1000 * 1000);
121 xpthread_barrier_wait (&shared
->barrier
);
128 /* shared->barrier is intialized along with sigusr1_sender_pids
130 shared
= support_shared_allocate (sizeof (*shared
));
132 struct sigaction action
=
134 .sa_handler
= sigusr1_handler
,
136 sigemptyset (&action
.sa_mask
);
138 if (sigaction (SIGUSR1
, &action
, NULL
) != 0)
140 printf ("error: sigaction: %m");
144 action
.sa_handler
= liveness_signal_handler
;
145 if (sigaction (SIGUSR2
, &action
, NULL
) != 0)
147 printf ("error: sigaction: %m");
151 pid_t sigusr2_sender_pid
= xfork ();
152 if (sigusr2_sender_pid
== 0)
153 signal_sender (SIGUSR2
, true);
155 /* Send SIGUSR1 signals from several processes. Hopefully, one
156 signal will hit one of the ciritical functions. Use a barrier to
157 avoid sending signals while not running fork/free/malloc. */
158 pid_t sigusr1_sender_pids
[5];
160 pthread_barrierattr_t attr
;
161 xpthread_barrierattr_init (&attr
);
162 xpthread_barrierattr_setpshared (&attr
, PTHREAD_PROCESS_SHARED
);
163 xpthread_barrier_init (&shared
->barrier
, &attr
,
164 array_length (sigusr1_sender_pids
) + 1);
165 xpthread_barrierattr_destroy (&attr
);
167 for (size_t i
= 0; i
< array_length (sigusr1_sender_pids
); ++i
)
169 sigusr1_sender_pids
[i
] = fork ();
170 if (sigusr1_sender_pids
[i
] == 0)
171 signal_sender (SIGUSR1
, false);
174 void *objects
[malloc_objects
] = {};
175 unsigned int fork_signals
= 0;
176 unsigned int free_signals
= 0;
177 unsigned int malloc_signals
= 0;
179 for (int i
= 0; i
< iterations
; ++i
)
181 progress_indicator
= 1;
182 int slot
= rand_r (&seed
) % malloc_objects
;
183 size_t size
= rand_r (&seed
) % malloc_maximum_size
;
185 /* Occasionally do a fork first, to catch deadlocks there as
186 well (see bug 24161). */
187 bool do_fork
= (rand_r (&seed
) % 7) == 0;
189 xpthread_barrier_wait (&shared
->barrier
);
192 sigusr1_received
= 0;
193 pid_t pid
= xfork ();
194 if (sigusr1_received
)
199 int ret
= TEMP_FAILURE_RETRY (waitpid (pid
, &status
, 0));
201 FAIL_EXIT1 ("waitpid: %m");
202 TEST_COMPARE (status
, 0);
204 sigusr1_received
= 0;
205 free (objects
[slot
]);
206 if (sigusr1_received
)
208 sigusr1_received
= 0;
209 objects
[slot
] = malloc (size
);
210 if (sigusr1_received
)
212 xpthread_barrier_wait (&shared
->barrier
);
214 if (objects
[slot
] == NULL
)
216 printf ("error: malloc: %m\n");
217 for (size_t i
= 0; i
< array_length (sigusr1_sender_pids
); ++i
)
218 kill (sigusr1_sender_pids
[i
], SIGKILL
);
219 kill (sigusr2_sender_pid
, SIGKILL
);
224 /* Clean up allocations. */
225 for (int slot
= 0; slot
< malloc_objects
; ++slot
)
226 free (objects
[slot
]);
228 for (size_t i
= 0; i
< array_length (sigusr1_sender_pids
); ++i
)
229 kill (sigusr1_sender_pids
[i
], SIGKILL
);
230 kill (sigusr2_sender_pid
, SIGKILL
);
232 printf ("info: signals received during fork: %u\n", fork_signals
);
233 printf ("info: signals received during free: %u\n", free_signals
);
234 printf ("info: signals received during malloc: %u\n", malloc_signals
);
236 /* Do not destroy the barrier because of the SIGKILL above, which
237 may have left the barrier in an inconsistent state. */
238 support_shared_free (shared
);
244 #include <support/test-driver.c>