gdb/testsuite/gdb.threads/siginfo-threads.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2010-2015 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 #define _GNU_SOURCE
  19 #include <pthread.h>
  20 #include <stdio.h>
  21 #include <limits.h>
  22 #include <errno.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <assert.h>
  26 #include <sys/types.h>
  27 #include <signal.h>
  28 #include <unistd.h>
  29 #include <asm/unistd.h>
  30
  31 #define gettid() syscall (__NR_gettid)
  32 #define tgkill(tgid, tid, sig) syscall (__NR_tgkill, tgid, tid, sig)
  33
  34 /* Terminate always in the main task.  It can lock up with SIGSTOPped
  35    GDB otherwise.  */
  36 #define TIMEOUT (gettid () == getpid() ? 10 : 15)
  37
  38 static pid_t thread1_tid;
  39 static pthread_cond_t thread1_tid_cond
  40   = PTHREAD_COND_INITIALIZER;
  41 static pthread_mutex_t thread1_tid_mutex
  42   = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
  43 static int thread1_sigusr1_hit;
  44 static int thread1_sigusr2_hit;
  45
  46 static pid_t thread2_tid;
  47 static pthread_cond_t thread2_tid_cond
  48   = PTHREAD_COND_INITIALIZER;
  49 static pthread_mutex_t thread2_tid_mutex
  50   = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
  51 static int thread2_sigusr1_hit;
  52 static int thread2_sigusr2_hit;
  53
  54 static pthread_mutex_t terminate_mutex
  55   = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
  56
  57 /* Do not use alarm as it would create a ptrace event which would hang
  58    us up if we are being traced by GDB, which we stopped
  59    ourselves.  */
  60
  61 static void
  62 timed_mutex_lock (pthread_mutex_t *mutex)
  63 {
  64   int i;
  65   struct timespec start, now;
  66
  67   i = clock_gettime (CLOCK_MONOTONIC, &start);
  68   assert (i == 0);
  69
  70   do
  71     {
  72       i = pthread_mutex_trylock (mutex);
  73       if (i == 0)
  74         return;
  75       assert (i == EBUSY);
  76
  77       i = clock_gettime (CLOCK_MONOTONIC, &now);
  78       assert (i == 0);
  79       assert (now.tv_sec >= start.tv_sec);
  80     }
  81   while (now.tv_sec - start.tv_sec < TIMEOUT);
  82
  83   fprintf (stderr, "Timed out waiting for internal lock!\n");
  84   exit (EXIT_FAILURE);
  85 }
  86
  87 static void
  88 handler (int signo, siginfo_t *siginfo, void *exception)
  89 {
  90   int *varp;
  91
  92   assert (siginfo->si_signo == signo);
  93   assert (siginfo->si_code == SI_TKILL);
  94   assert (siginfo->si_pid == getpid ());
  95
  96   if (gettid () == thread1_tid)
  97     {
  98       if (signo == SIGUSR1)
  99         varp = &thread1_sigusr1_hit;
 100       else if (signo == SIGUSR2)
 101         varp = &thread1_sigusr2_hit;
 102       else
 103         assert (0);
 104     }
 105   else if (gettid () == thread2_tid)
 106     {
 107       if (signo == SIGUSR1)
 108         varp = &thread2_sigusr1_hit;
 109       else if (signo == SIGUSR2)
 110         varp = &thread2_sigusr2_hit;
 111       else
 112         assert (0);
 113     }
 114   else
 115     assert (0);
 116
 117   if (*varp)
 118     {
 119       fprintf (stderr, "Signal %d for TID %lu has been already hit!\n", signo,
 120                (unsigned long) gettid ());
 121       exit (EXIT_FAILURE);
 122     }
 123   *varp = 1;
 124 }
 125
 126 static void *
 127 thread1_func (void *unused)
 128 {
 129   int i;
 130
 131   timed_mutex_lock (&thread1_tid_mutex);
 132
 133   /* THREAD1_TID_MUTEX must be already locked to avoid a race.  */
 134   thread1_tid = gettid ();
 135
 136   i = pthread_cond_signal (&thread1_tid_cond);
 137   assert (i == 0);
 138   i = pthread_mutex_unlock (&thread1_tid_mutex);
 139   assert (i == 0);
 140
 141   /* Be sure the "t (tracing stop)" test can proceed for both
 142      threads.  */
 143   timed_mutex_lock (&terminate_mutex);
 144   i = pthread_mutex_unlock (&terminate_mutex);
 145   assert (i == 0);
 146
 147   if (!thread1_sigusr1_hit)
 148     {
 149       fprintf (stderr, "Thread 1 signal SIGUSR1 not hit!\n");
 150       exit (EXIT_FAILURE);
 151     }
 152   if (!thread1_sigusr2_hit)
 153     {
 154       fprintf (stderr, "Thread 1 signal SIGUSR2 not hit!\n");
 155       exit (EXIT_FAILURE);
 156     }
 157
 158   return NULL;
 159 }
 160
 161 static void *
 162 thread2_func (void *unused)
 163 {
 164   int i;
 165
 166   timed_mutex_lock (&thread2_tid_mutex);
 167
 168   /* THREAD2_TID_MUTEX must be already locked to avoid a race.  */
 169   thread2_tid = gettid ();
 170
 171   i = pthread_cond_signal (&thread2_tid_cond);
 172   assert (i == 0);
 173   i = pthread_mutex_unlock (&thread2_tid_mutex);
 174   assert (i == 0);
 175
 176   /* Be sure the "t (tracing stop)" test can proceed for both
 177      threads.  */
 178   timed_mutex_lock (&terminate_mutex);
 179   i = pthread_mutex_unlock (&terminate_mutex);
 180   assert (i == 0);
 181
 182   if (!thread2_sigusr1_hit)
 183     {
 184       fprintf (stderr, "Thread 2 signal SIGUSR1 not hit!\n");
 185       exit (EXIT_FAILURE);
 186     }
 187   if (!thread2_sigusr2_hit)
 188     {
 189       fprintf (stderr, "Thread 2 signal SIGUSR2 not hit!\n");
 190       exit (EXIT_FAILURE);
 191     }
 192
 193   return NULL;
 194 }
 195
 196 static const char *
 197 proc_string (const char *filename, const char *line)
 198 {
 199   FILE *f;
 200   static char buf[LINE_MAX];
 201   size_t line_len = strlen (line);
 202
 203   f = fopen (filename, "r");
 204   if (f == NULL)
 205     {
 206       fprintf (stderr, "fopen (\"%s\") for \"%s\": %s\n", filename, line,
 207                strerror (errno));
 208       exit (EXIT_FAILURE);
 209     }
 210   while (errno = 0, fgets (buf, sizeof (buf), f))
 211     {
 212       char *s;
 213
 214       s = strchr (buf, '\n');
 215       assert (s != NULL);
 216       *s = 0;
 217
 218       if (strncmp (buf, line, line_len) != 0)
 219         continue;
 220
 221       if (fclose (f))
 222         {
 223           fprintf (stderr, "fclose (\"%s\") for \"%s\": %s\n", filename, line,
 224                    strerror (errno));
 225           exit (EXIT_FAILURE);
 226         }
 227
 228       return &buf[line_len];
 229     }
 230   if (errno != 0)
 231     {
 232       fprintf (stderr, "fgets (\"%s\": %s\n", filename, strerror (errno));
 233       exit (EXIT_FAILURE);
 234     }
 235   fprintf (stderr, "\"%s\": No line \"%s\" found.\n", filename, line);
 236   exit (EXIT_FAILURE);
 237 }
 238
 239 static unsigned long
 240 proc_ulong (const char *filename, const char *line)
 241 {
 242   const char *s = proc_string (filename, line);
 243   long retval;
 244   char *end;
 245
 246   errno = 0;
 247   retval = strtol (s, &end, 10);
 248   if (retval < 0 || retval >= LONG_MAX || (end && *end))
 249     {
 250       fprintf (stderr, "\"%s\":\"%s\": %ld, %s\n", filename, line, retval,
 251                strerror (errno));
 252       exit (EXIT_FAILURE);
 253     }
 254   return retval;
 255 }
 256
 257 static void
 258 state_wait (pid_t process, const char *wanted)
 259 {
 260   char *filename;
 261   int i;
 262   struct timespec start, now;
 263   const char *state;
 264
 265   i = asprintf (&filename, "/proc/%lu/status", (unsigned long) process);
 266   assert (i > 0);
 267
 268   i = clock_gettime (CLOCK_MONOTONIC, &start);
 269   assert (i == 0);
 270
 271   do
 272     {
 273       state = proc_string (filename, "State:\t");
 274
 275       /* torvalds/linux-2.6.git 464763cf1c6df632dccc8f2f4c7e50163154a2c0
 276          has changed "T (tracing stop)" to "t (tracing stop)".  Make the GDB
 277          testcase backward compatible with older Linux kernels.  */
 278       if (strcmp (state, "T (tracing stop)") == 0)
 279         state = "t (tracing stop)";
 280
 281       if (strcmp (state, wanted) == 0)
 282         {
 283           free (filename);
 284           return;
 285         }
 286
 287       if (sched_yield ())
 288         {
 289           perror ("sched_yield()");
 290           exit (EXIT_FAILURE);
 291         }
 292
 293       i = clock_gettime (CLOCK_MONOTONIC, &now);
 294       assert (i == 0);
 295       assert (now.tv_sec >= start.tv_sec);
 296     }
 297   while (now.tv_sec - start.tv_sec < TIMEOUT);
 298
 299   fprintf (stderr, "Timed out waiting for PID %lu \"%s\" (now it is \"%s\")!\n",
 300            (unsigned long) process, wanted, state);
 301   exit (EXIT_FAILURE);
 302 }
 303
 304 static volatile pid_t tracer = 0;
 305 static pthread_t thread1, thread2;
 306
 307 static void
 308 cleanup (void)
 309 {
 310   printf ("Resuming GDB PID %lu.\n", (unsigned long) tracer);
 311
 312   if (tracer)
 313     {
 314       int i;
 315       int tracer_save = tracer;
 316
 317       tracer = 0;
 318
 319       i = kill (tracer_save, SIGCONT);
 320       assert (i == 0);
 321     }
 322 }
 323
 324 int
 325 main (int argc, char **argv)
 326 {
 327   int i;
 328   int standalone = 0;
 329   struct sigaction act;
 330
 331   if (argc == 2 && strcmp (argv[1], "-s") == 0)
 332     standalone = 1;
 333   else
 334     assert (argc == 1);
 335
 336   setbuf (stdout, NULL);
 337
 338   timed_mutex_lock (&thread1_tid_mutex);
 339   timed_mutex_lock (&thread2_tid_mutex);
 340
 341   timed_mutex_lock (&terminate_mutex);
 342
 343   errno = 0;
 344   memset (&act, 0, sizeof (act));
 345   act.sa_sigaction = handler;
 346   act.sa_flags = SA_RESTART | SA_SIGINFO;
 347   i = sigemptyset (&act.sa_mask);
 348   assert_perror (errno);
 349   assert (i == 0);
 350   i = sigaction (SIGUSR1, &act, NULL);
 351   assert_perror (errno);
 352   assert (i == 0);
 353   i = sigaction (SIGUSR2, &act, NULL);
 354   assert_perror (errno);
 355   assert (i == 0);
 356
 357   i = pthread_create (&thread1, NULL, thread1_func, NULL);
 358   assert (i == 0);
 359
 360   i = pthread_create (&thread2, NULL, thread2_func, NULL);
 361   assert (i == 0);
 362
 363   if (!standalone)
 364     {
 365       tracer = proc_ulong ("/proc/self/status", "TracerPid:\t");
 366       if (tracer == 0)
 367         {
 368           fprintf (stderr, "The testcase must be run by GDB!\n");
 369           exit (EXIT_FAILURE);
 370         }
 371       if (tracer != getppid ())
 372         {
 373           fprintf (stderr, "The testcase parent must be our GDB tracer!\n");
 374           exit (EXIT_FAILURE);
 375         }
 376     }
 377
 378   /* SIGCONT our debugger in the case of our crash as we would deadlock
 379      otherwise.  */
 380
 381   atexit (cleanup);
 382
 383   printf ("Stopping GDB PID %lu.\n", (unsigned long) tracer);
 384
 385   if (tracer)
 386     {
 387       i = kill (tracer, SIGSTOP);
 388       assert (i == 0);
 389       state_wait (tracer, "T (stopped)");
 390     }
 391
 392   /* Threads are now waiting at timed_mutex_lock (thread1_tid_mutex)
 393      and so they could not trigger the signals before GDB is unstopped
 394      later.  Threads get resumed by the pthread_cond_wait below.  Use
 395      `while' loops for protection against spurious pthread_cond_wait
 396      wakeups.  */
 397
 398   printf ("Waiting till the threads initialize their TIDs.\n");
 399
 400   while (thread1_tid == 0)
 401     {
 402       i = pthread_cond_wait (&thread1_tid_cond, &thread1_tid_mutex);
 403       assert (i == 0);
 404     }
 405
 406   while (thread2_tid == 0)
 407     {
 408       i = pthread_cond_wait (&thread2_tid_cond, &thread2_tid_mutex);
 409       assert (i == 0);
 410     }
 411
 412   printf ("Thread 1 TID = %lu, thread 2 TID = %lu, PID = %lu.\n",
 413           (unsigned long) thread1_tid, (unsigned long) thread2_tid,
 414           (unsigned long) getpid ());
 415
 416   errno = 0;
 417   i = tgkill (getpid (), thread1_tid, SIGUSR1);
 418   assert_perror (errno);
 419   assert (i == 0);
 420   i = tgkill (getpid (), thread1_tid, SIGUSR2);
 421   assert_perror (errno);
 422   assert (i == 0);
 423   i = tgkill (getpid (), thread2_tid, SIGUSR1);
 424   assert_perror (errno);
 425   assert (i == 0);
 426   i = tgkill (getpid (), thread2_tid, SIGUSR2);
 427   assert_perror (errno);
 428   assert (i == 0);
 429
 430   printf ("Waiting till the threads are trapped by the signals.\n");
 431
 432   if (tracer)
 433     {
 434       /* s390x-unknown-linux-gnu will fail with "R (running)".  */
 435
 436       state_wait (thread1_tid, "t (tracing stop)");
 437
 438       state_wait (thread2_tid, "t (tracing stop)");
 439     }
 440
 441   cleanup ();
 442
 443   printf ("Joining the threads.\n");
 444
 445   i = pthread_mutex_unlock (&terminate_mutex);
 446   assert (i == 0);
 447
 448   i = pthread_join (thread1, NULL);
 449   assert (i == 0);
 450
 451   i = pthread_join (thread2, NULL);
 452   assert (i == 0);
 453
 454   printf ("Exiting.\n");        /* break-at-exit */
 455
 456   return EXIT_SUCCESS;
 457 }