pthread_kill() with invalid thread - c

Question

I'd like to determine if a particular thread 'exists'.
pthread_kill() appears to be suited to this task, at least according to its man page.
If sig is 0, then no signal is sent, but error checking is still performed.
Or, as my system's man page puts it:
If sig is 0, then no signal is sent, but error checking is still performed; this can be used to check for the existence of a thread ID.
However when I attempt to pass in an uninitialized pthread_t, the application invariably SEGFAULTs.
Digging into this, the following snippet from pthread_kill.c (from my toolchain) appears to do no error checking, and simply attempts to de-reference threadid (the de-reference is at pd->tid).
int
__pthread_kill (threadid, signo)
pthread_t threadid;
int signo;
{
struct pthread *pd = (struct pthread *) threadid;
/* Make sure the descriptor is valid. */
if (DEBUGGING_P && INVALID_TD_P (pd))
/* Not a valid thread handle. */
return ESRCH;
/* Force load of pd->tid into local variable or register. Otherwise
if a thread exits between ESRCH test and tgkill, we might return
EINVAL, because pd->tid would be cleared by the kernel. */
pid_t tid = atomic_forced_read (pd->tid);
if (__builtin_expect (tid <= 0, 0))
/* Not a valid thread handle. */
return ESRCH;
We can't even rely on zero being a good initializer, because of the following:
# define DEBUGGING_P 0
/* Simplified test. This will not catch all invalid descriptors but
is better than nothing. And if the test triggers the thread
descriptor is guaranteed to be invalid. */
# define INVALID_TD_P(pd) __builtin_expect ((pd)->tid <= 0, 0)
Additionally, I noticed the following in the linked man page (but not on my system's):
POSIX.1-2008 recommends that if an implementation detects the use of a thread ID after the end of its lifetime, pthread_kill() should return the error ESRCH. The glibc implementation returns this error in the cases where an invalid thread ID can be detected. But note also that POSIX says that an attempt to use a thread ID whose lifetime has ended produces undefined behavior, and an attempt to use an invalid thread ID in a call to pthread_kill() can, for example, cause a segmentation fault.
As outlined here by R.., I'm asking for the dreaded undefined behavior.
It would appear that the manual is indeed misleading - particularly so on my system.
Is there a good / reliable way to ask find out if a thread exists? (presumably by not using pthread_kill())
Is there a good value that can be used to initialize pthread_t type variables, even if we have to catch them ourselves?
I'm suspecting that the answer is to employ pthread_cleanup_push() and keep an is_running flag of my own, but would like to hear thoughts from others.

Answer 1

I think I've come to a realisation while driving home, and I suspect that many others may find this useful too...
It would appear that I've been treating the worker (the thread), and the task (what the thread is doing) as one and the same, when in fact, they are not.
As I've already established from the code snippets in the question, it is unreasonable to ask "does this thread exist" as the pthread_t is likely just a pointer (it certainly is on my target). It's almost certainly the wrong question.
The same goes for process IDs, file handles, malloc()'d memory, etc... they don't use unique and never repeating identifiers, and thus are not unique 'entities' that can be tested for their existence.
The suspicions that I raised in the question are likely true - I'm going to have to use something like an is_running flag for the task (not thread).
One approach that I've thought about is to use a semaphore initialized to one, sem_trywait(), sem_post() and pthread_cleanup_push(), as in the example below (cleanup missing for brevity).
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <semaphore.h>
#include <pthread.h>
struct my_task {
sem_t can_start;
pthread_t tid;
/* task-related stuff */
};
void *my_task_worker(void *arg) {
struct my_task *task = arg;
pthread_cleanup_push(sem_post, &(task->can_start));
fprintf(stderr, "--- task starting!\n");
usleep(2500000);
fprintf(stderr, "--- task ending!\n");
pthread_cleanup_pop(1);
return NULL;
}
void my_task_start(struct my_task *task) {
int ret;
ret = sem_trywait(&(task->can_start));
if (ret != 0) {
if (errno != EAGAIN) {
perror("sem_trywait()");
exit(1);
}
fprintf(stderr, ">>> task already running...\n");
return;
}
ret = pthread_create(&(task->tid), NULL, my_task_worker, task);
if (ret != 0) {
perror("pthread_create()");
exit(1);
}
fprintf(stderr, ">>> started task!\n");
return;
}
int main(int argc, char *argv[]) {
int ret;
struct my_task task;
int i;
memset(&task, 0, sizeof(0));
ret = sem_init(&(task.can_start), 0, 1);
if (ret != 0)
{
perror("sem_init()");
return 1;
}
for (i = 0; i < 10; i++) {
my_task_start(&task);
sleep(1);
}
return 0;
}
Output:
>>> started task!
--- task starting!
>>> task already running...
>>> task already running...
--- task ending!
>>> started task!
--- task starting!
>>> task already running...
>>> task already running...
--- task ending!
>>> started task!
--- task starting!
>>> task already running...
>>> task already running...
--- task ending!
>>> started task!
--- task starting!