/* Copyright 2022-2024 Free Software Foundation, Inc.
This file is part of GDB.
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 . */
#include
#include
#include
#include
#define NUM_THREADS 2
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
/* Some global variables to poke, just for something to do. */
volatile int global_var_0 = 0;
volatile int global_var_1 = 0;
/* This flag is updated from GDB. */
volatile int raise_signal = 0;
/* Implement the breakpoint condition function. Release the other thread
and try to give the other thread a chance to run. Then return ANSWER. */
int
condition_core_func (int answer)
{
/* This unlock should release the other thread. */
if (pthread_mutex_unlock (&mutex) != 0)
abort ();
/* And this yield and sleep should (hopefully) give the other thread a
chance to run. This isn't guaranteed of course, but once the other
thread does run it should hit a breakpoint, which GDB should
(temporarily) ignore, so there's no easy way for us to know the other
thread has done what it needs to, thus, yielding and sleeping is the
best we can do. */
sched_yield ();
sleep (2);
return answer;
}
void
stop_marker ()
{
int a = 100; /* Final breakpoint here. */
}
/* A breakpoint condition function that always returns true. */
int
condition_true_func ()
{
return condition_core_func (1);
}
/* A breakpoint condition function that always returns false. */
int
condition_false_func ()
{
return condition_core_func (0);
}
void *
worker_func (void *arg)
{
volatile int *ptr = 0;
int tid = *((int *) arg);
switch (tid)
{
case 0:
global_var_0 = 11; /* First thread breakpoint. */
break;
case 1:
if (pthread_mutex_lock (&mutex) != 0)
abort ();
if (raise_signal)
global_var_1 = *ptr; /* Signal here. */
else
global_var_1 = 99; /* Other thread breakpoint. */
break;
default:
abort ();
}
return NULL;
}
int
main ()
{
pthread_t threads[NUM_THREADS];
int args[NUM_THREADS];
/* Set an alarm, just in case the test deadlocks. */
alarm (300);
/* We want the mutex to start locked. */
if (pthread_mutex_lock (&mutex) != 0)
abort ();
for (int i = 0; i < NUM_THREADS; i++)
{
args[i] = i;
pthread_create (&threads[i], NULL, worker_func, &args[i]);
}
for (int i = 0; i < NUM_THREADS; i++)
{
void *retval;
pthread_join (threads[i], &retval);
}
/* Unlock once we're done, just for cleanliness. */
if (pthread_mutex_unlock (&mutex) != 0)
abort ();
stop_marker ();
return 0;
}