malloc/tst-mallocfork3.c

   1 /* Test case for async-signal-safe _Fork (with respect to malloc).
   2    Copyright (C) 2021-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 is similar to tst-mallocfork2.c, but specifically stress
  20    the async-signal-safeness of _Fork on multithread environment.  */
  21
  22 #include <array_length.h>
  23 #include <errno.h>
  24 #include <stdbool.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <support/check.h>
  28 #include <support/support.h>
  29 #include <support/xsignal.h>
  30 #include <support/xthread.h>
  31 #include <support/xunistd.h>
  32 #include <sys/wait.h>
  33
  34 /* How many malloc objects to keep arond.  */
  35 enum { malloc_objects = 1009 };
  36
  37 /* The maximum size of an object.  */
  38 enum { malloc_maximum_size = 70000 };
  39
  40 /* How many iterations the test performs before exiting.  */
  41 enum { iterations = 10000 };
  42
  43 /* Barrier for synchronization with the threads sending SIGUSR1
  44    signals, to make it more likely that the signals arrive during a
  45    fork/free/malloc call.  */
  46 static pthread_barrier_t barrier;
  47
  48 /* Set to 1 if SIGUSR1 is received.  Used to detect a signal during
  49    fork/free/malloc.  */
  50 static volatile sig_atomic_t sigusr1_received;
  51
  52 /* Periodically set to 1, to indicate that the thread is making
  53    progress.  Checked by liveness_signal_handler.  */
  54 static volatile sig_atomic_t progress_indicator = 1;
  55
  56 /* Set to 1 if an error occurs in the signal handler.  */
  57 static volatile sig_atomic_t error_indicator = 0;
  58
  59 static void
  60 sigusr1_handler (int signo)
  61 {
  62   sigusr1_received = 1;
  63
  64   /* Perform a fork with a trivial subprocess.  */
  65   pid_t pid = _Fork ();
  66   if (pid == -1)
  67     {
  68       write_message ("error: fork\n");
  69       error_indicator = 1;
  70       return;
  71     }
  72   if (pid == 0)
  73     _exit (0);
  74   int status;
  75   int ret = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
  76   if (ret < 0)
  77     {
  78       write_message ("error: waitpid\n");
  79       error_indicator = 1;
  80       return;
  81     }
  82   if (status != 0)
  83     {
  84       write_message ("error: unexpected exit status from subprocess\n");
  85       error_indicator = 1;
  86       return;
  87     }
  88 }
  89
  90 static void
  91 liveness_signal_handler (int signo)
  92 {
  93   if (progress_indicator)
  94     progress_indicator = 0;
  95   else
  96     write_message ("warning: thread seems to be stuck\n");
  97 }
  98
  99 struct signal_send_args
 100 {
 101   pthread_t target;
 102   int signo;
 103   bool sleep;
 104 };
 105 #define SIGNAL_SEND_GET_ARG(arg, field) \
 106   (((struct signal_send_args *)(arg))->field)
 107
 108 /* Send SIGNO to the parent thread.  If SLEEP, wait a second between
 109    signals, otherwise use barriers to delay sending signals.  */
 110 static void *
 111 signal_sender (void *args)
 112 {
 113   int signo = SIGNAL_SEND_GET_ARG (args, signo);
 114   bool sleep = SIGNAL_SEND_GET_ARG (args, sleep);
 115
 116   pthread_t target = SIGNAL_SEND_GET_ARG (args, target);
 117   while (true)
 118     {
 119       if (!sleep)
 120         xpthread_barrier_wait (&barrier);
 121       xpthread_kill (target, signo);
 122       if (sleep)
 123         usleep (1 * 1000 * 1000);
 124       else
 125         xpthread_barrier_wait (&barrier);
 126     }
 127   return NULL;
 128 }
 129
 130 static pthread_t sigusr1_sender[5];
 131 static pthread_t sigusr2_sender;
 132
 133 static int
 134 do_test (void)
 135 {
 136   xsignal (SIGUSR1, sigusr1_handler);
 137   xsignal (SIGUSR2, liveness_signal_handler);
 138
 139   pthread_t self = pthread_self ();
 140
 141   struct signal_send_args sigusr2_args = { self, SIGUSR2, true };
 142   sigusr2_sender = xpthread_create (NULL, signal_sender, &sigusr2_args);
 143
 144   /* Send SIGUSR1 signals from several threads.  Hopefully, one
 145      signal will hit one of the critical functions.  Use a barrier to
 146      avoid sending signals while not running fork/free/malloc.  */
 147   struct signal_send_args sigusr1_args = { self, SIGUSR1, false };
 148   xpthread_barrier_init (&barrier, NULL,
 149                          array_length (sigusr1_sender) + 1);
 150   for (size_t i = 0; i < array_length (sigusr1_sender); ++i)
 151     sigusr1_sender[i] = xpthread_create (NULL, signal_sender, &sigusr1_args);
 152
 153   void *objects[malloc_objects] = {};
 154   unsigned int fork_signals = 0;
 155   unsigned int free_signals = 0;
 156   unsigned int malloc_signals = 0;
 157   unsigned int seed = 1;
 158   for (int i = 0; i < iterations; ++i)
 159     {
 160       progress_indicator = 1;
 161       int slot = rand_r (&seed) % malloc_objects;
 162       size_t size = rand_r (&seed) % malloc_maximum_size;
 163
 164       /* Occasionally do a fork first, to catch deadlocks there as
 165          well (see bug 24161).  */
 166       bool do_fork = (rand_r (&seed) % 7) == 0;
 167
 168       xpthread_barrier_wait (&barrier);
 169       if (do_fork)
 170         {
 171           sigusr1_received = 0;
 172           pid_t pid = _Fork ();
 173           TEST_VERIFY_EXIT (pid != -1);
 174           if (sigusr1_received)
 175             ++fork_signals;
 176           if (pid == 0)
 177             _exit (0);
 178           int status;
 179           int ret = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
 180           if (ret < 0)
 181             FAIL_EXIT1 ("waitpid: %m");
 182           TEST_COMPARE (status, 0);
 183         }
 184       sigusr1_received = 0;
 185       free (objects[slot]);
 186       if (sigusr1_received)
 187         ++free_signals;
 188       sigusr1_received = 0;
 189       objects[slot] = malloc (size);
 190       if (sigusr1_received)
 191         ++malloc_signals;
 192       xpthread_barrier_wait (&barrier);
 193
 194       if (objects[slot] == NULL || error_indicator != 0)
 195         {
 196           printf ("error: malloc: %m\n");
 197           return 1;
 198         }
 199     }
 200
 201   /* Clean up allocations.  */
 202   for (int slot = 0; slot < malloc_objects; ++slot)
 203     free (objects[slot]);
 204
 205   printf ("info: signals received during fork: %u\n", fork_signals);
 206   printf ("info: signals received during free: %u\n", free_signals);
 207   printf ("info: signals received during malloc: %u\n", malloc_signals);
 208
 209   return 0;
 210 }
 211
 212 #define TIMEOUT 100
 213 #include <support/test-driver.c>