gdb/testsuite/gdb.server/exit-multiple-threads.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2020-2022 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program 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
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include <pthread.h>
  19 #include <sys/types.h>
  20 #include <stdio.h>
  21 #include <unistd.h>
  22 #include <stdlib.h>
  23 #include <pthread.h>
  24
  25 /* The number of threads to create.  */
  26 int thread_count = 3;
  27
  28 /* Counter accessed from threads to ensure that all threads have been
  29    started.  Is initialised to THREAD_COUNT and each thread decrements it
  30    upon startup.  */
  31 volatile int counter;
  32
  33 /* Lock guarding COUNTER. */
  34 pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
  35
  36 /* Is initialised with our pid, GDB will read this.  */
  37 pid_t global_pid;
  38
  39 /* Just somewhere to put a breakpoint.  */
  40 static void
  41 breakpt ()
  42 {
  43   /* Nothing.  */
  44 }
  45
  46 /* Thread safe decrement of the COUNTER global.  */
  47 static void
  48 decrement_counter ()
  49 {
  50   if (pthread_mutex_lock (&counter_mutex) != 0)
  51     abort ();
  52   --counter;
  53   if (pthread_mutex_unlock (&counter_mutex) != 0)
  54     abort ();
  55 }
  56
  57 /* Thread safe read of the COUNTER global.  */
  58 static int
  59 read_counter ()
  60 {
  61   int val;
  62
  63   if (pthread_mutex_lock (&counter_mutex) != 0)
  64     abort ();
  65   val = counter;
  66   if (pthread_mutex_unlock (&counter_mutex) != 0)
  67     abort ();
  68
  69   return val;
  70 }
  71
  72 #if defined DO_EXIT_TEST
  73
  74 /* Thread entry point.  ARG is a pointer to a single integer, the ID for
  75    this thread numbered 1 to THREAD_COUNT (a global).  */
  76 static void *
  77 thread_worker_exiting (void *arg)
  78 {
  79   int id;
  80
  81   id = *((int *) arg);
  82
  83   decrement_counter ();
  84
  85   if (id != thread_count)
  86     {
  87       int i;
  88
  89       /* All threads except the last one will wait here while the test is
  90          carried out.  Don't wait forever though, just in case the test
  91          goes wrong.  */
  92       for (i = 0; i < 60; ++i)
  93         sleep (1);
  94     }
  95   else
  96     {
  97       /* The last thread waits here until all other threads have been
  98          created.  */
  99       while (read_counter () > 0)
 100         sleep (1);
 101
 102       /* Hit the breakpoint so GDB can stop.  */
 103       breakpt ();
 104
 105       /* And exit all threads.  */
 106       exit (0);
 107     }
 108
 109   return NULL;
 110 }
 111
 112 #define thread_worker thread_worker_exiting
 113
 114 #elif defined DO_SIGNAL_TEST
 115
 116 /* Thread entry point.  ARG is a pointer to a single integer, the ID for
 117    this thread numbered 1 to THREAD_COUNT (a global).  */
 118 static void *
 119 thread_worker_signalling (void *arg)
 120 {
 121   int i, id;
 122
 123   id = *((int *) arg);
 124
 125   decrement_counter ();
 126
 127   if (id == thread_count)
 128     {
 129       /* The last thread waits here until all other threads have been
 130          created.  */
 131       while (read_counter () > 0)
 132         sleep (1);
 133
 134       /* Hit the breakpoint so GDB can stop.  */
 135       breakpt ();
 136     }
 137
 138   /* All threads wait here while the testsuite sends us a signal.  Don't
 139      block forever though, just in case the test goes wrong.  */
 140   for (i = 0; i < 60; ++i)
 141     sleep (1);
 142
 143   return NULL;
 144 }
 145
 146 #define thread_worker thread_worker_signalling
 147
 148 #else
 149
 150 #error "Compile with DO_EXIT_TEST or DO_SIGNAL_TEST defined"
 151
 152 #endif
 153
 154 struct thread_info
 155 {
 156   pthread_t thread;
 157   int id;
 158 };
 159
 160 int
 161 main ()
 162 {
 163   int i, max = thread_count;
 164
 165   /* Put the pid somewhere easy for GDB to read.  */
 166   global_pid = getpid ();
 167
 168   /* Space to hold all of the thread_info objects.  */
 169   struct thread_info *info = malloc (sizeof (struct thread_info) * max);
 170   if (info == NULL)
 171     abort ();
 172
 173   /* Initialise the counter.  Don't do this under lock as we only have the
 174      main thread at this point.  */
 175   counter = thread_count;
 176
 177   /* Create all of the threads.  */
 178   for (i = 0; i < max; ++i)
 179     {
 180       struct thread_info *thr = &info[i];
 181       thr->id = i + 1;
 182       if (pthread_create (&thr->thread, NULL, thread_worker, &thr->id) != 0)
 183         abort ();
 184     }
 185
 186   /* Gather in all of the threads.  This never completes, as the
 187      final thread created will exit the process, and all of the other
 188      threads block forever.  Still, it gives the main thread something to
 189      do.  */
 190   for (i = 0; i < max; ++i)
 191     {
 192       struct thread_info *thr = &info[i];
 193       if (pthread_join (thr->thread, NULL) != 0)
 194         abort ();
 195     }
 196
 197   free (info);
 198
 199   /* Return non-zero.  We should never get here, but if we do make sure we
 200      indicate something has gone wrong.  */
 201   return 1;
 202 }