1#include "pthread_impl.h"
  2#include <semaphore.h>
  3#include <string.h>
  4
  5static void dummy_0(void)
  6{
  7}
  8
  9weak_alias(dummy_0, __tl_lock);
 10weak_alias(dummy_0, __tl_unlock);
 11
 12static int target_tid;
 13static void (*callback)(void *), *context;
 14static sem_t target_sem, caller_sem, exit_sem;
 15
 16static void dummy(void *p)
 17{
 18}
 19
 20static void handler(int sig)
 21{
 22	if (__pthread_self()->tid != target_tid) return;
 23
 24	int old_errno = errno;
 25
 26	/* Inform caller we have received signal and wait for
 27	 * the caller to let us make the callback. */
 28	sem_post(&caller_sem);
 29	sem_wait(&target_sem);
 30
 31	callback(context);
 32
 33	/* Inform caller we've complered the callback and wait
 34	 * for the caller to release us to return. */
 35	sem_post(&caller_sem);
 36	sem_wait(&exit_sem);
 37
 38	/* Inform caller we are returning and state is destroyable. */
 39	sem_post(&caller_sem);
 40
 41	errno = old_errno;
 42}
 43
 44void __synccall(void (*func)(void *), void *ctx)
 45{
 46	sigset_t oldmask;
 47	int cs, i, r;
 48	struct sigaction sa = { .sa_flags = SA_RESTART | SA_ONSTACK, .sa_handler = handler };
 49	pthread_t self = __pthread_self(), td;
 50	int count = 0;
 51
 52	/* Blocking signals in two steps, first only app-level signals
 53	 * before taking the lock, then all signals after taking the lock,
 54	 * is necessary to achieve AS-safety. Blocking them all first would
 55	 * deadlock if multiple threads called __synccall. Waiting to block
 56	 * any until after the lock would allow re-entry in the same thread
 57	 * with the lock already held. */
 58	__block_app_sigs(&oldmask);
 59	__tl_lock();
 60	__block_all_sigs(0);
 61	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
 62
 63	sem_init(&target_sem, 0, 0);
 64	sem_init(&caller_sem, 0, 0);
 65	sem_init(&exit_sem, 0, 0);
 66
 67	if (!libc.threads_minus_1 || __syscall(SYS_gettid) != self->tid)
 68		goto single_threaded;
 69
 70	callback = func;
 71	context = ctx;
 72
 73	/* Block even implementation-internal signals, so that nothing
 74	 * interrupts the SIGSYNCCALL handlers. The main possible source
 75	 * of trouble is asynchronous cancellation. */
 76	memset(&sa.sa_mask, -1, sizeof sa.sa_mask);
 77	__libc_sigaction(SIGSYNCCALL, &sa, 0);
 78
 79
 80	for (td=self->next; td!=self; td=td->next) {
 81		target_tid = td->tid;
 82		while ((r = -__syscall(SYS_tkill, td->tid, SIGSYNCCALL)) == EAGAIN);
 83		if (r) {
 84			/* If we failed to signal any thread, nop out the
 85			 * callback to abort the synccall and just release
 86			 * any threads already caught. */
 87			callback = func = dummy;
 88			break;
 89		}
 90		sem_wait(&caller_sem);
 91		count++;
 92	}
 93	target_tid = 0;
 94
 95	/* Serialize execution of callback in caught threads, or just
 96	 * release them all if synccall is being aborted. */
 97	for (i=0; i<count; i++) {
 98		sem_post(&target_sem);
 99		sem_wait(&caller_sem);
100	}
101
102	sa.sa_handler = SIG_IGN;
103	__libc_sigaction(SIGSYNCCALL, &sa, 0);
104
105single_threaded:
106	func(ctx);
107
108	/* Only release the caught threads once all threads, including the
109	 * caller, have returned from the callback function. */
110	for (i=0; i<count; i++)
111		sem_post(&exit_sem);
112	for (i=0; i<count; i++)
113		sem_wait(&caller_sem);
114
115	sem_destroy(&caller_sem);
116	sem_destroy(&target_sem);
117	sem_destroy(&exit_sem);
118
119	pthread_setcancelstate(cs, 0);
120	__tl_unlock();
121	__restore_sigs(&oldmask);
122}