[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.threads / watchthreads-reorder.c

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

   Copyright 2009-2020 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;

static pthread_barrier_t threads_started_barrier;

/* These variables must have lower in-memory addresses than thread1_rwatch and
   thread2_rwatch so that they take their watchpoint slots.  */

static int unused1_rwatch;
static int unused2_rwatch;

static volatile int thread1_rwatch;
static volatile int thread2_rwatch;

/* 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 *
thread1_func (void *unused)
{
  int i;
  volatile int rwatch_store;

  pthread_barrier_wait (&threads_started_barrier);

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

  rwatch_store = thread1_rwatch;

  /* 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 void *
thread2_func (void *unused)
{
  int i;
  volatile int rwatch_store;

  pthread_barrier_wait (&threads_started_barrier);

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

  rwatch_store = thread2_rwatch;

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

  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 watchpoints 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 watchpoints.\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 */

  /* Just prevent compiler `warning: unusedX_rwatch defined but not used'.  */
  unused1_rwatch = 1;
  unused2_rwatch = 2;

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