malloc/tst-malloc-thread-exit.c

   1 /* Test malloc with concurrent thread termination.
   2    Copyright (C) 2015-2016 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    <http://www.gnu.org/licenses/>.  */
  18
  19 /* This thread spawns a number of outer threads, equal to the arena
  20    limit.  The outer threads run a loop which start and join two
  21    different kinds of threads: the first kind allocates (attaching an
  22    arena to the thread; malloc_first_thread) and waits, the second
  23    kind waits and allocates (wait_first_threads).  Both kinds of
  24    threads exit immediately after waiting.  The hope is that this will
  25    exhibit races in thread termination and arena management,
  26    particularly related to the arena free list.  */
  27
  28 #include <errno.h>
  29 #include <malloc.h>
  30 #include <pthread.h>
  31 #include <stdbool.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35
  36 static int do_test (void);
  37
  38 #define TEST_FUNCTION do_test ()
  39 #include "../test-skeleton.c"
  40
  41 static bool termination_requested;
  42 static int inner_thread_count = 4;
  43 static size_t malloc_size = 32;
  44
  45 static void
  46 __attribute__ ((noinline, noclone))
  47 unoptimized_free (void *ptr)
  48 {
  49   free (ptr);
  50 }
  51
  52 static void *
  53 malloc_first_thread (void * closure)
  54 {
  55   pthread_barrier_t *barrier = closure;
  56   void *ptr = malloc (malloc_size);
  57   if (ptr == NULL)
  58     {
  59       printf ("error: malloc: %m\n");
  60       abort ();
  61     }
  62   int ret = pthread_barrier_wait (barrier);
  63   if (ret != 0 && ret != PTHREAD_BARRIER_SERIAL_THREAD)
  64     {
  65       errno = ret;
  66       printf ("error: pthread_barrier_wait: %m\n");
  67       abort ();
  68     }
  69   unoptimized_free (ptr);
  70   return NULL;
  71 }
  72
  73 static void *
  74 wait_first_thread (void * closure)
  75 {
  76   pthread_barrier_t *barrier = closure;
  77   int ret = pthread_barrier_wait (barrier);
  78   if (ret != 0 && ret != PTHREAD_BARRIER_SERIAL_THREAD)
  79     {
  80       errno = ret;
  81       printf ("error: pthread_barrier_wait: %m\n");
  82       abort ();
  83     }
  84   void *ptr = malloc (malloc_size);
  85   if (ptr == NULL)
  86     {
  87       printf ("error: malloc: %m\n");
  88       abort ();
  89     }
  90   unoptimized_free (ptr);
  91   return NULL;
  92 }
  93
  94 static void *
  95 outer_thread (void *closure)
  96 {
  97   pthread_t *threads = calloc (sizeof (*threads), inner_thread_count);
  98   if (threads == NULL)
  99     {
 100       printf ("error: calloc: %m\n");
 101       abort ();
 102     }
 103
 104   while (!__atomic_load_n (&termination_requested, __ATOMIC_RELAXED))
 105     {
 106       pthread_barrier_t barrier;
 107       int ret = pthread_barrier_init (&barrier, NULL, inner_thread_count + 1);
 108       if (ret != 0)
 109         {
 110           errno = ret;
 111           printf ("pthread_barrier_init: %m\n");
 112           abort ();
 113         }
 114       for (int i = 0; i < inner_thread_count; ++i)
 115         {
 116           void *(*func) (void *);
 117           if ((i  % 2) == 0)
 118             func = malloc_first_thread;
 119           else
 120             func = wait_first_thread;
 121           ret = pthread_create (threads + i, NULL, func, &barrier);
 122           if (ret != 0)
 123             {
 124               errno = ret;
 125               printf ("error: pthread_create: %m\n");
 126               abort ();
 127             }
 128         }
 129       ret = pthread_barrier_wait (&barrier);
 130       if (ret != 0 && ret != PTHREAD_BARRIER_SERIAL_THREAD)
 131         {
 132           errno = ret;
 133           printf ("pthread_wait: %m\n");
 134           abort ();
 135         }
 136       for (int i = 0; i < inner_thread_count; ++i)
 137         {
 138           ret = pthread_join (threads[i], NULL);
 139           if (ret != 0)
 140             {
 141               ret = errno;
 142               printf ("error: pthread_join: %m\n");
 143               abort ();
 144             }
 145         }
 146       ret = pthread_barrier_destroy (&barrier);
 147       if (ret != 0)
 148         {
 149           ret = errno;
 150           printf ("pthread_barrier_destroy: %m\n");
 151           abort ();
 152         }
 153     }
 154
 155   free (threads);
 156
 157   return NULL;
 158 }
 159
 160 static int
 161 do_test (void)
 162 {
 163   /* The number of threads should be smaller than the number of
 164      arenas, so that there will be some free arenas to add to the
 165      arena free list.  */
 166   enum { outer_thread_count = 2 };
 167   if (mallopt (M_ARENA_MAX, 8) == 0)
 168     {
 169       printf ("error: mallopt (M_ARENA_MAX) failed\n");
 170       return 1;
 171     }
 172
 173   /* Leave some room for shutting down all threads gracefully.  */
 174   int timeout = 3;
 175   if (timeout > TIMEOUT)
 176     timeout = TIMEOUT - 1;
 177
 178   pthread_t *threads = calloc (sizeof (*threads), outer_thread_count);
 179   if (threads == NULL)
 180     {
 181       printf ("error: calloc: %m\n");
 182       abort ();
 183     }
 184
 185   for (long i = 0; i < outer_thread_count; ++i)
 186     {
 187       int ret = pthread_create (threads + i, NULL, outer_thread, NULL);
 188       if (ret != 0)
 189         {
 190           errno = ret;
 191           printf ("error: pthread_create: %m\n");
 192           abort ();
 193         }
 194     }
 195
 196   struct timespec ts = {timeout, 0};
 197   if (nanosleep (&ts, NULL))
 198     {
 199       printf ("error: error: nanosleep: %m\n");
 200       abort ();
 201     }
 202
 203   __atomic_store_n (&termination_requested, true, __ATOMIC_RELAXED);
 204
 205   for (long i = 0; i < outer_thread_count; ++i)
 206     {
 207       int ret = pthread_join (threads[i], NULL);
 208       if (ret != 0)
 209         {
 210           errno = ret;
 211           printf ("error: pthread_join: %m\n");
 212           abort ();
 213         }
 214     }
 215   free (threads);
 216
 217   return 0;
 218 }