about summary refs log tree commit diff
path: root/src/thread/synccall.c
blob: d58c851fcff4ad60e0abae520cf023802676993b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include "pthread_impl.h"
#include <semaphore.h>
#include <string.h>

static void dummy_0(void)
{
}

weak_alias(dummy_0, __tl_lock);
weak_alias(dummy_0, __tl_unlock);

static int target_tid;
static void (*callback)(void *), *context;
static sem_t target_sem, caller_sem;

static void dummy(void *p)
{
}

static void handler(int sig)
{
	if (__pthread_self()->tid != target_tid) return;

	int old_errno = errno;

	/* Inform caller we have received signal and wait for
	 * the caller to let us make the callback. */
	sem_post(&caller_sem);
	sem_wait(&target_sem);

	callback(context);

	/* Inform caller we've complered the callback and wait
	 * for the caller to release us to return. */
	sem_post(&caller_sem);
	sem_wait(&target_sem);

	/* Inform caller we are returning and state is destroyable. */
	sem_post(&caller_sem);

	errno = old_errno;
}

void __synccall(void (*func)(void *), void *ctx)
{
	sigset_t oldmask;
	int cs, i, r;
	struct sigaction sa = { .sa_flags = SA_RESTART, .sa_handler = handler };
	pthread_t self = __pthread_self(), td;
	int count = 0;

	/* Blocking signals in two steps, first only app-level signals
	 * before taking the lock, then all signals after taking the lock,
	 * is necessary to achieve AS-safety. Blocking them all first would
	 * deadlock if multiple threads called __synccall. Waiting to block
	 * any until after the lock would allow re-entry in the same thread
	 * with the lock already held. */
	__block_app_sigs(&oldmask);
	__tl_lock();
	__block_all_sigs(0);
	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);

	sem_init(&target_sem, 0, 0);
	sem_init(&caller_sem, 0, 0);

	if (!libc.threads_minus_1 || __syscall(SYS_gettid) != self->tid)
		goto single_threaded;

	callback = func;
	context = ctx;

	/* Block even implementation-internal signals, so that nothing
	 * interrupts the SIGSYNCCALL handlers. The main possible source
	 * of trouble is asynchronous cancellation. */
	memset(&sa.sa_mask, -1, sizeof sa.sa_mask);
	__libc_sigaction(SIGSYNCCALL, &sa, 0);


	for (td=self->next; td!=self; td=td->next) {
		target_tid = td->tid;
		while ((r = -__syscall(SYS_tkill, td->tid, SIGSYNCCALL)) == EAGAIN);
		if (r) {
			/* If we failed to signal any thread, nop out the
			 * callback to abort the synccall and just release
			 * any threads already caught. */
			callback = func = dummy;
			break;
		}
		sem_wait(&caller_sem);
		count++;
	}
	target_tid = 0;

	/* Serialize execution of callback in caught threads, or just
	 * release them all if synccall is being aborted. */
	for (i=0; i<count; i++) {
		sem_post(&target_sem);
		sem_wait(&caller_sem);
	}

	sa.sa_handler = SIG_IGN;
	__libc_sigaction(SIGSYNCCALL, &sa, 0);

single_threaded:
	func(ctx);

	/* Only release the caught threads once all threads, including the
	 * caller, have returned from the callback function. */
	for (i=0; i<count; i++)
		sem_post(&target_sem);
	for (i=0; i<count; i++)
		sem_wait(&caller_sem);

	sem_destroy(&caller_sem);
	sem_destroy(&target_sem);

	pthread_setcancelstate(cs, 0);
	__tl_unlock();
	__restore_sigs(&oldmask);
}