[thirdparty/binutils-gdb.git] / gdb / testsuite / gdb.threads / ia64-sigill.c

/* This testcase is part of GDB, the GNU debugger.

   Copyright 2010-2013 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)

/* 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 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 pthread_mutex_t terminate_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;

/* Do not use alarm as it would create a ptrace event which would hang up us 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 *
thread_func (void *threadno_voidp)
{
  int threadno = (intptr_t) threadno_voidp;
  int i;

  switch (threadno)
  {
    case 1:
      timed_mutex_lock (&thread1_tid_mutex);

      /* THREAD1_TID_MUTEX must be already locked to avoid race.  */
      thread1_tid = gettid ();

      i = pthread_cond_signal (&thread1_tid_cond);
      assert (i == 0);
      i = pthread_mutex_unlock (&thread1_tid_mutex);
      assert (i == 0);

      break;

    case 2:
      timed_mutex_lock (&thread2_tid_mutex);

      /* THREAD2_TID_MUTEX must be already locked to avoid race.  */
      thread2_tid = gettid ();

      i = pthread_cond_signal (&thread2_tid_cond);
      assert (i == 0);
      i = pthread_mutex_unlock (&thread2_tid_mutex);
      assert (i == 0);

      break;

    default:
      assert (0);
  }

#ifdef __ia64__
  asm volatile ("label:\n"
		"nop.m 0\n"
		"nop.i 0\n"
		"nop.b 0\n");
#endif
  /* break-here */

  /* 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);

  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;

  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);

  i = pthread_create (&thread1, NULL, thread_func, (void *) (intptr_t) 1);
  assert (i == 0);

  i = pthread_create (&thread2, NULL, thread_func, (void *) (intptr_t) 2);
  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);

  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 breakpoint before GDB gets unstopped later.
     Threads get resumed at 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 ());

  printf ("Waiting till the threads get trapped by the breakpoint.\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;
}
Commit	Line	Data
26ab7092 JK	1	/* This testcase is part of GDB, the GNU debugger.
26ab7092 JK	2
8acc9f48	3	Copyright 2010-2013 Free Software Foundation, Inc.
26ab7092 JK	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
	33	/* Terminate always in the main task, it can lock up with SIGSTOPped GDB
	34	otherwise. */
	35	#define TIMEOUT (gettid () == getpid() ? 10 : 15)
	36
	37	static pid_t thread1_tid;
	38	static pthread_cond_t thread1_tid_cond = PTHREAD_COND_INITIALIZER;
	39	static pthread_mutex_t thread1_tid_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
	40
	41	static pid_t thread2_tid;
	42	static pthread_cond_t thread2_tid_cond = PTHREAD_COND_INITIALIZER;
	43	static pthread_mutex_t thread2_tid_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
	44
	45	static pthread_mutex_t terminate_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
	46
	47	/* Do not use alarm as it would create a ptrace event which would hang up us if
	48	we are being traced by GDB which we stopped ourselves. */
	49
	50	static void timed_mutex_lock (pthread_mutex_t *mutex)
	51	{
	52	int i;
	53	struct timespec start, now;
	54
	55	i = clock_gettime (CLOCK_MONOTONIC, &start);
	56	assert (i == 0);
	57
	58	do
	59	{
	60	i = pthread_mutex_trylock (mutex);
	61	if (i == 0)
	62	return;
	63	assert (i == EBUSY);
	64
	65	i = clock_gettime (CLOCK_MONOTONIC, &now);
	66	assert (i == 0);
	67	assert (now.tv_sec >= start.tv_sec);
68	}
69	while (now.tv_sec - start.tv_sec < TIMEOUT);
70
71	fprintf (stderr, "Timed out waiting for internal lock!\n");
72	exit (EXIT_FAILURE);
73	}
74
75	static void *
76	thread_func (void *threadno_voidp)
77	{
78	int threadno = (intptr_t) threadno_voidp;
79	int i;
80
81	switch (threadno)
82	{
83	case 1:
84	timed_mutex_lock (&thread1_tid_mutex);
85
86	/* THREAD1_TID_MUTEX must be already locked to avoid race. */
87	thread1_tid = gettid ();
88
89	i = pthread_cond_signal (&thread1_tid_cond);
90	assert (i == 0);
91	i = pthread_mutex_unlock (&thread1_tid_mutex);
92	assert (i == 0);
93
94	break;
95
96	case 2:
97	timed_mutex_lock (&thread2_tid_mutex);
98
99	/* THREAD2_TID_MUTEX must be already locked to avoid race. */
100	thread2_tid = gettid ();
101
102	i = pthread_cond_signal (&thread2_tid_cond);
103	assert (i == 0);
104	i = pthread_mutex_unlock (&thread2_tid_mutex);
105	assert (i == 0);
106
107	break;
108
109	default:
110	assert (0);
111	}
112
113	#ifdef __ia64__
114	asm volatile ("label:\n"
115	"nop.m 0\n"
116	"nop.i 0\n"
117	"nop.b 0\n");
118	#endif
119	/* break-here */
120
121	/* Be sure the "t (tracing stop)" test can proceed for both threads. */
122	timed_mutex_lock (&terminate_mutex);
123	i = pthread_mutex_unlock (&terminate_mutex);
124	assert (i == 0);
125
126	return NULL;
127	}
128
129	static const char *
130	proc_string (const char filename, const char line)
131	{
132	FILE *f;
133	static char buf[LINE_MAX];
134	size_t line_len = strlen (line);
135
136	f = fopen (filename, "r");
137	if (f == NULL)
138	{
139	fprintf (stderr, "fopen (\"%s\") for \"%s\": %s\n", filename, line,
140	strerror (errno));
141	exit (EXIT_FAILURE);
142	}
143	while (errno = 0, fgets (buf, sizeof (buf), f))
144	{
145	char *s;
146
147	s = strchr (buf, '\n');
148	assert (s != NULL);
149	*s = 0;
150
151	if (strncmp (buf, line, line_len) != 0)
152	continue;
153
154	if (fclose (f))
155	{
156	fprintf (stderr, "fclose (\"%s\") for \"%s\": %s\n", filename, line,
157	strerror (errno));
158	exit (EXIT_FAILURE);
159	}
160
161	return &buf[line_len];
162	}
163	if (errno != 0)
164	{
165	fprintf (stderr, "fgets (\"%s\": %s\n", filename, strerror (errno));
166	exit (EXIT_FAILURE);
167	}
168	fprintf (stderr, "\"%s\": No line \"%s\" found.\n", filename, line);
169	exit (EXIT_FAILURE);
170	}
171
172	static unsigned long
173	proc_ulong (const char filename, const char line)
174	{
175	const char *s = proc_string (filename, line);
176	long retval;
177	char *end;
178
179	errno = 0;
180	retval = strtol (s, &end, 10);
181	if (retval < 0 \|\| retval >= LONG_MAX \|\| (end && *end))
182	{
183	fprintf (stderr, "\"%s\":\"%s\": %ld, %s\n", filename, line, retval,
184	strerror (errno));
185	exit (EXIT_FAILURE);
186	}
187	return retval;
188	}
189
190	static void
191	state_wait (pid_t process, const char *wanted)
192	{
193	char *filename;
194	int i;
195	struct timespec start, now;
196	const char *state;
197
198	i = asprintf (&filename, "/proc/%lu/status", (unsigned long) process);
199	assert (i > 0);
200
201	i = clock_gettime (CLOCK_MONOTONIC, &start);
202	assert (i == 0);
203
204	do
205	{
206	state = proc_string (filename, "State:\t");
207
208	/* torvalds/linux-2.6.git 464763cf1c6df632dccc8f2f4c7e50163154a2c0
209	has changed "T (tracing stop)" to "t (tracing stop)". Make the GDB
210	testcase backward compatible with older Linux kernels. */
211	if (strcmp (state, "T (tracing stop)") == 0)
212	state = "t (tracing stop)";
213
214	if (strcmp (state, wanted) == 0)
215	{
216	free (filename);
217	return;
218	}
219
220	if (sched_yield ())
221	{
222	perror ("sched_yield()");
223	exit (EXIT_FAILURE);
224	}
225
226	i = clock_gettime (CLOCK_MONOTONIC, &now);
227	assert (i == 0);
228	assert (now.tv_sec >= start.tv_sec);
229	}
230	while (now.tv_sec - start.tv_sec < TIMEOUT);
231
232	fprintf (stderr, "Timed out waiting for PID %lu \"%s\" (now it is \"%s\")!\n",
233	(unsigned long) process, wanted, state);
234	exit (EXIT_FAILURE);
235	}
236
237	static volatile pid_t tracer = 0;
238	static pthread_t thread1, thread2;
239
240	static void
241	cleanup (void)
242	{
243	printf ("Resuming GDB PID %lu.\n", (unsigned long) tracer);
244
245	if (tracer)
246	{
247	int i;
248	int tracer_save = tracer;
249
250	tracer = 0;
251
252	i = kill (tracer_save, SIGCONT);
253	assert (i == 0);
254	}
255	}
256
257	int
258	main (int argc, char **argv)
259	{
260	int i;
261	int standalone = 0;
262
263	if (argc == 2 && strcmp (argv[1], "-s") == 0)
264	standalone = 1;
265	else
266	assert (argc == 1);
267
268	setbuf (stdout, NULL);
269
270	timed_mutex_lock (&thread1_tid_mutex);
271	timed_mutex_lock (&thread2_tid_mutex);
272
273	timed_mutex_lock (&terminate_mutex);
274
275	i = pthread_create (&thread1, NULL, thread_func, (void *) (intptr_t) 1);
276	assert (i == 0);
277
278	i = pthread_create (&thread2, NULL, thread_func, (void *) (intptr_t) 2);
279	assert (i == 0);
280
281	if (!standalone)
282	{
283	tracer = proc_ulong ("/proc/self/status", "TracerPid:\t");
284	if (tracer == 0)
285	{
286	fprintf (stderr, "The testcase must be run by GDB!\n");
287	exit (EXIT_FAILURE);
288	}
289	if (tracer != getppid ())
290	{
291	fprintf (stderr, "The testcase parent must be our GDB tracer!\n");
292	exit (EXIT_FAILURE);
293	}
294	}
295
296	/* SIGCONT our debugger in the case of our crash as we would deadlock
297	otherwise. */
298
299	atexit (cleanup);
300
301	printf ("Stopping GDB PID %lu.\n", (unsigned long) tracer);
302
303	if (tracer)
304	{
305	i = kill (tracer, SIGSTOP);
306	assert (i == 0);
307	state_wait (tracer, "T (stopped)");
308	}
309
310	/* Threads are now waiting at timed_mutex_lock (thread1_tid_mutex) and so
311	they could not trigger the breakpoint before GDB gets unstopped later.
312	Threads get resumed at pthread_cond_wait below. Use `while' loops for
313	protection against spurious pthread_cond_wait wakeups. */
314
315	printf ("Waiting till the threads initialize their TIDs.\n");
316
317	while (thread1_tid == 0)
318	{
319	i = pthread_cond_wait (&thread1_tid_cond, &thread1_tid_mutex);
320	assert (i == 0);
321	}
322
323	while (thread2_tid == 0)
324	{
325	i = pthread_cond_wait (&thread2_tid_cond, &thread2_tid_mutex);
326	assert (i == 0);
327	}
328
329	printf ("Thread 1 TID = %lu, thread 2 TID = %lu, PID = %lu.\n",
330	(unsigned long) thread1_tid, (unsigned long) thread2_tid,
331	(unsigned long) getpid ());
332
333	printf ("Waiting till the threads get trapped by the breakpoint.\n");
334
335	if (tracer)
336	{
337	/* s390x-unknown-linux-gnu will fail with "R (running)". */
338
339	state_wait (thread1_tid, "t (tracing stop)");
340
341	state_wait (thread2_tid, "t (tracing stop)");
342	}
343
344	cleanup ();
345
346	printf ("Joining the threads.\n");
347
348	i = pthread_mutex_unlock (&terminate_mutex);
349	assert (i == 0);
350
351	i = pthread_join (thread1, NULL);
352	assert (i == 0);
353
354	i = pthread_join (thread2, NULL);
355	assert (i == 0);
356
357	printf ("Exiting.\n"); /* break-at-exit */
358
359	return EXIT_SUCCESS;
360	}