How do I suspend another thread (not the current one)?

Question

I'm trying to implement a simulation of a microcontroller. This simulation is not meant to do a clock cycle precise representation of one specific microcontroller but check the general correctness of the code.

I thought of having a "main thread" executing normal code and a second thread executing ISR code. Whenever an ISR needs to be run, the ISR thread suspends the "main thread".

Of course, I want to have a feature to block interrupts. I thought of solving this with a mutex that the ISR thread holds whenever it executes ISR code while the main thread holds it as long as "interrupts are blocked".

A POR (power on reset) can then be implemented by not only suspending but killing the main thread (and starting a new one executing the POR function).

The windows API provides the necessary functions. But it seems to be impossible to do the above with posix threads (on linux).

I don't want to change the actual hardware independent microcontroller code. So inserting anything to check for pending interrupts is not an option.

Receiving interrupts at non well behaved points is desirable, as this also happens on microcontrollers (unless you block interrupts).

Is there a way to suspend another thread on linux? (Debuggers must use that option somehow, I think.)

Please, don't tell me this is a bad idea. I know that is true in most circumstances. But the main code does not use standard libs or lock/mutexes/semaphores.

Answer 1

SIGSTOP does not work - it always stops the entire process. Instead you can use some other signals, say SIGUSR1 for suspending and SIGUSR2 for resuming:

// at process start call init_pthread_suspending to install the handlers
// to suspend a thread use pthread_kill(thread_id, SUSPEND_SIG)
// to resume a thread use pthread_kill(thread_id, RESUME_SIG)

#include <signal.h>

#define RESUME_SIG SIGUSR2
#define SUSPEND_SIG SIGUSR1

static sigset_t wait_mask;
static __thread int suspended; // per-thread flag

void resume_handler(int sig)
{
    suspended = 0;
}

void suspend_handler(int sig)
{
    if (suspended) return;
    suspended = 1;
    do sigsuspend(&wait_mask); while (suspended);
}

void init_pthread_suspending()
{
    struct sigaction sa;

    sigfillset(&wait_mask);
    sigdelset(&wait_mask, SUSPEND_SIG)
    sigdelset(&wait_mask, RESUME_SIG);

    sigfillset(&sa.sa_mask);
    sa.sa_flags = 0;
    sa.sa_handler = resume_handler;
    sigaction(RESUME_SIG, &sa, NULL);

    sa.sa_handler = suspend_handler;
    sigaction(SUSPEND_SIG, &sa, NULL);
}

I am very annoyed by replies like "you should not suspend another thread, that is bad". Guys why do you assume others are idiots and don't know what they are doing? Imagine that others, too, have heard about deadlocking and still, in full consciousness, want to suspend other threads. If you don't have a real answer to their question why do you waste your and the readers' time.

An yes, IMO pthreads are very short-sighted api, a disgrace for POSIX.