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

471 lines
11 KiB
C

/* This testcase is part of GDB, the GNU debugger.
Copyright 2010-2016 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <limits.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <sys/types.h>
#include <signal.h>
#include <unistd.h>
#include <asm/unistd.h>
#define gettid() syscall (__NR_gettid)
#define tgkill(tgid, tid, sig) syscall (__NR_tgkill, tgid, tid, sig)
/* Terminate always in the main task. It can lock up with SIGSTOPped
GDB otherwise. */
#define TIMEOUT (gettid () == getpid() ? 10 : 15)
static pid_t thread1_tid;
static pthread_cond_t thread1_tid_cond
= PTHREAD_COND_INITIALIZER;
static pthread_mutex_t thread1_tid_mutex
= PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
static int thread1_sigusr1_hit;
static int thread1_sigusr2_hit;
static pid_t thread2_tid;
static pthread_cond_t thread2_tid_cond
= PTHREAD_COND_INITIALIZER;
static pthread_mutex_t thread2_tid_mutex
= PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
static int thread2_sigusr1_hit;
static int thread2_sigusr2_hit;
static pthread_mutex_t terminate_mutex
= PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
static pthread_barrier_t threads_started_barrier;
/* Do not use alarm as it would create a ptrace event which would hang
us up if we are being traced by GDB, which we stopped
ourselves. */
static void
timed_mutex_lock (pthread_mutex_t *mutex)
{
int i;
struct timespec start, now;
i = clock_gettime (CLOCK_MONOTONIC, &start);
assert (i == 0);
do
{
i = pthread_mutex_trylock (mutex);
if (i == 0)
return;
assert (i == EBUSY);
i = clock_gettime (CLOCK_MONOTONIC, &now);
assert (i == 0);
assert (now.tv_sec >= start.tv_sec);
}
while (now.tv_sec - start.tv_sec < TIMEOUT);
fprintf (stderr, "Timed out waiting for internal lock!\n");
exit (EXIT_FAILURE);
}
static void
handler (int signo, siginfo_t *siginfo, void *exception)
{
int *varp;
assert (siginfo->si_signo == signo);
assert (siginfo->si_code == SI_TKILL);
assert (siginfo->si_pid == getpid ());
if (gettid () == thread1_tid)
{
if (signo == SIGUSR1)
varp = &thread1_sigusr1_hit;
else if (signo == SIGUSR2)
varp = &thread1_sigusr2_hit;
else
assert (0);
}
else if (gettid () == thread2_tid)
{
if (signo == SIGUSR1)
varp = &thread2_sigusr1_hit;
else if (signo == SIGUSR2)
varp = &thread2_sigusr2_hit;
else
assert (0);
}
else
assert (0);
if (*varp)
{
fprintf (stderr, "Signal %d for TID %lu has been already hit!\n", signo,
(unsigned long) gettid ());
exit (EXIT_FAILURE);
}
*varp = 1;
}
static void *
thread1_func (void *unused)
{
int i;
pthread_barrier_wait (&threads_started_barrier);
timed_mutex_lock (&thread1_tid_mutex);
/* THREAD1_TID_MUTEX must be already locked to avoid a race. */
thread1_tid = gettid ();
i = pthread_cond_signal (&thread1_tid_cond);
assert (i == 0);
i = pthread_mutex_unlock (&thread1_tid_mutex);
assert (i == 0);
/* Be sure the "t (tracing stop)" test can proceed for both
threads. */
timed_mutex_lock (&terminate_mutex);
i = pthread_mutex_unlock (&terminate_mutex);
assert (i == 0);
if (!thread1_sigusr1_hit)
{
fprintf (stderr, "Thread 1 signal SIGUSR1 not hit!\n");
exit (EXIT_FAILURE);
}
if (!thread1_sigusr2_hit)
{
fprintf (stderr, "Thread 1 signal SIGUSR2 not hit!\n");
exit (EXIT_FAILURE);
}
return NULL;
}
static void *
thread2_func (void *unused)
{
int i;
pthread_barrier_wait (&threads_started_barrier);
timed_mutex_lock (&thread2_tid_mutex);
/* THREAD2_TID_MUTEX must be already locked to avoid a race. */
thread2_tid = gettid ();
i = pthread_cond_signal (&thread2_tid_cond);
assert (i == 0);
i = pthread_mutex_unlock (&thread2_tid_mutex);
assert (i == 0);
/* Be sure the "t (tracing stop)" test can proceed for both
threads. */
timed_mutex_lock (&terminate_mutex);
i = pthread_mutex_unlock (&terminate_mutex);
assert (i == 0);
if (!thread2_sigusr1_hit)
{
fprintf (stderr, "Thread 2 signal SIGUSR1 not hit!\n");
exit (EXIT_FAILURE);
}
if (!thread2_sigusr2_hit)
{
fprintf (stderr, "Thread 2 signal SIGUSR2 not hit!\n");
exit (EXIT_FAILURE);
}
return NULL;
}
static const char *
proc_string (const char *filename, const char *line)
{
FILE *f;
static char buf[LINE_MAX];
size_t line_len = strlen (line);
f = fopen (filename, "r");
if (f == NULL)
{
fprintf (stderr, "fopen (\"%s\") for \"%s\": %s\n", filename, line,
strerror (errno));
exit (EXIT_FAILURE);
}
while (errno = 0, fgets (buf, sizeof (buf), f))
{
char *s;
s = strchr (buf, '\n');
assert (s != NULL);
*s = 0;
if (strncmp (buf, line, line_len) != 0)
continue;
if (fclose (f))
{
fprintf (stderr, "fclose (\"%s\") for \"%s\": %s\n", filename, line,
strerror (errno));
exit (EXIT_FAILURE);
}
return &buf[line_len];
}
if (errno != 0)
{
fprintf (stderr, "fgets (\"%s\": %s\n", filename, strerror (errno));
exit (EXIT_FAILURE);
}
fprintf (stderr, "\"%s\": No line \"%s\" found.\n", filename, line);
exit (EXIT_FAILURE);
}
static unsigned long
proc_ulong (const char *filename, const char *line)
{
const char *s = proc_string (filename, line);
long retval;
char *end;
errno = 0;
retval = strtol (s, &end, 10);
if (retval < 0 || retval >= LONG_MAX || (end && *end))
{
fprintf (stderr, "\"%s\":\"%s\": %ld, %s\n", filename, line, retval,
strerror (errno));
exit (EXIT_FAILURE);
}
return retval;
}
static void
state_wait (pid_t process, const char *wanted)
{
char *filename;
int i;
struct timespec start, now;
const char *state;
i = asprintf (&filename, "/proc/%lu/status", (unsigned long) process);
assert (i > 0);
i = clock_gettime (CLOCK_MONOTONIC, &start);
assert (i == 0);
do
{
state = proc_string (filename, "State:\t");
/* torvalds/linux-2.6.git 464763cf1c6df632dccc8f2f4c7e50163154a2c0
has changed "T (tracing stop)" to "t (tracing stop)". Make the GDB
testcase backward compatible with older Linux kernels. */
if (strcmp (state, "T (tracing stop)") == 0)
state = "t (tracing stop)";
if (strcmp (state, wanted) == 0)
{
free (filename);
return;
}
if (sched_yield ())
{
perror ("sched_yield()");
exit (EXIT_FAILURE);
}
i = clock_gettime (CLOCK_MONOTONIC, &now);
assert (i == 0);
assert (now.tv_sec >= start.tv_sec);
}
while (now.tv_sec - start.tv_sec < TIMEOUT);
fprintf (stderr, "Timed out waiting for PID %lu \"%s\" (now it is \"%s\")!\n",
(unsigned long) process, wanted, state);
exit (EXIT_FAILURE);
}
static volatile pid_t tracer = 0;
static pthread_t thread1, thread2;
static void
cleanup (void)
{
printf ("Resuming GDB PID %lu.\n", (unsigned long) tracer);
if (tracer)
{
int i;
int tracer_save = tracer;
tracer = 0;
i = kill (tracer_save, SIGCONT);
assert (i == 0);
}
}
int
main (int argc, char **argv)
{
int i;
int standalone = 0;
struct sigaction act;
if (argc == 2 && strcmp (argv[1], "-s") == 0)
standalone = 1;
else
assert (argc == 1);
setbuf (stdout, NULL);
timed_mutex_lock (&thread1_tid_mutex);
timed_mutex_lock (&thread2_tid_mutex);
timed_mutex_lock (&terminate_mutex);
errno = 0;
memset (&act, 0, sizeof (act));
act.sa_sigaction = handler;
act.sa_flags = SA_RESTART | SA_SIGINFO;
i = sigemptyset (&act.sa_mask);
assert_perror (errno);
assert (i == 0);
i = sigaction (SIGUSR1, &act, NULL);
assert_perror (errno);
assert (i == 0);
i = sigaction (SIGUSR2, &act, NULL);
assert_perror (errno);
assert (i == 0);
pthread_barrier_init (&threads_started_barrier, NULL, 3);
i = pthread_create (&thread1, NULL, thread1_func, NULL);
assert (i == 0);
i = pthread_create (&thread2, NULL, thread2_func, NULL);
assert (i == 0);
if (!standalone)
{
tracer = proc_ulong ("/proc/self/status", "TracerPid:\t");
if (tracer == 0)
{
fprintf (stderr, "The testcase must be run by GDB!\n");
exit (EXIT_FAILURE);
}
if (tracer != getppid ())
{
fprintf (stderr, "The testcase parent must be our GDB tracer!\n");
exit (EXIT_FAILURE);
}
}
/* SIGCONT our debugger in the case of our crash as we would deadlock
otherwise. */
atexit (cleanup);
/* Wait until all threads are seen running. On Linux (at least),
new threads start stopped, and the debugger must resume them.
Need to wait for that before stopping GDB. */
pthread_barrier_wait (&threads_started_barrier);
printf ("Stopping GDB PID %lu.\n", (unsigned long) tracer);
if (tracer)
{
i = kill (tracer, SIGSTOP);
assert (i == 0);
state_wait (tracer, "T (stopped)");
}
/* Threads are now waiting at timed_mutex_lock (thread1_tid_mutex)
and so they could not trigger the signals before GDB is unstopped
later. Threads get resumed by the pthread_cond_wait below. Use
`while' loops for protection against spurious pthread_cond_wait
wakeups. */
printf ("Waiting till the threads initialize their TIDs.\n");
while (thread1_tid == 0)
{
i = pthread_cond_wait (&thread1_tid_cond, &thread1_tid_mutex);
assert (i == 0);
}
while (thread2_tid == 0)
{
i = pthread_cond_wait (&thread2_tid_cond, &thread2_tid_mutex);
assert (i == 0);
}
printf ("Thread 1 TID = %lu, thread 2 TID = %lu, PID = %lu.\n",
(unsigned long) thread1_tid, (unsigned long) thread2_tid,
(unsigned long) getpid ());
errno = 0;
i = tgkill (getpid (), thread1_tid, SIGUSR1);
assert_perror (errno);
assert (i == 0);
i = tgkill (getpid (), thread1_tid, SIGUSR2);
assert_perror (errno);
assert (i == 0);
i = tgkill (getpid (), thread2_tid, SIGUSR1);
assert_perror (errno);
assert (i == 0);
i = tgkill (getpid (), thread2_tid, SIGUSR2);
assert_perror (errno);
assert (i == 0);
printf ("Waiting till the threads are trapped by the signals.\n");
if (tracer)
{
/* s390x-unknown-linux-gnu will fail with "R (running)". */
state_wait (thread1_tid, "t (tracing stop)");
state_wait (thread2_tid, "t (tracing stop)");
}
cleanup ();
printf ("Joining the threads.\n");
i = pthread_mutex_unlock (&terminate_mutex);
assert (i == 0);
i = pthread_join (thread1, NULL);
assert (i == 0);
i = pthread_join (thread2, NULL);
assert (i == 0);
printf ("Exiting.\n"); /* break-at-exit */
return EXIT_SUCCESS;
}