int sigprocmask(int how, const sigset_t * set, sigset_t * oldset)
{
if (set &&
#if (SIG_BLOCK == 0) && (SIG_UNBLOCK == 1) && (SIG_SETMASK == 2)
(((unsigned int) how) > 2)
#else
#warning "compile time assumption violated.. slow path..."
((how != SIG_BLOCK) && (how != SIG_UNBLOCK)
&& (how != SIG_SETMASK))
#endif
) {
__set_errno(EINVAL);
return -1;
}
return __rt_sigprocmask(how, set, oldset, _NSIG / 8);
}
int sigprocmask(int how, const sigset_t* bionic_new_set, sigset_t* bionic_old_set) {
kernel_sigset_t new_set;
kernel_sigset_t* new_set_ptr = NULL;
if (bionic_new_set != NULL) {
new_set.set(bionic_new_set);
new_set_ptr = &new_set;
}
kernel_sigset_t old_set;
if (__rt_sigprocmask(how, new_set_ptr, &old_set, sizeof(old_set)) == -1) {
return -1;
}
if (bionic_old_set != NULL) {
*bionic_old_set = old_set.bionic;
}
return 0;
}
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset) {
return __rt_sigprocmask(how, set, oldset, _NSIG/8);
}
// http://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_create.html
int timer_create(clockid_t clock_id, sigevent* evp, timer_t* timer_id) {
PosixTimer* timer = reinterpret_cast<PosixTimer*>(malloc(sizeof(PosixTimer)));
if (timer == nullptr) {
return -1;
}
timer->sigev_notify = (evp == nullptr) ? SIGEV_SIGNAL : evp->sigev_notify;
// If not a SIGEV_THREAD timer, the kernel can handle it without our help.
if (timer->sigev_notify != SIGEV_THREAD) {
if (__timer_create(clock_id, evp, &timer->kernel_timer_id) == -1) {
free(timer);
return -1;
}
*timer_id = timer;
return 0;
}
// Otherwise, this must be SIGEV_THREAD timer...
timer->callback = evp->sigev_notify_function;
timer->callback_argument = evp->sigev_value;
atomic_init(&timer->deleted, false);
// Check arguments that the kernel doesn't care about but we do.
if (timer->callback == nullptr) {
free(timer);
errno = EINVAL;
return -1;
}
// Create this timer's thread.
pthread_attr_t thread_attributes;
if (evp->sigev_notify_attributes == nullptr) {
pthread_attr_init(&thread_attributes);
} else {
thread_attributes = *reinterpret_cast<pthread_attr_t*>(evp->sigev_notify_attributes);
}
pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_DETACHED);
// We start the thread with TIMER_SIGNAL blocked by blocking the signal here and letting it
// inherit. If it tried to block the signal itself, there would be a race.
sigset64_t sigset = {};
sigaddset64(&sigset, TIMER_SIGNAL);
sigset64_t old_sigset;
// Use __rt_sigprocmask instead of sigprocmask64 to avoid filtering out TIMER_SIGNAL.
__rt_sigprocmask(SIG_BLOCK, &sigset, &old_sigset, sizeof(sigset));
int rc = pthread_create(&timer->callback_thread, &thread_attributes, __timer_thread_start, timer);
__rt_sigprocmask(SIG_SETMASK, &old_sigset, nullptr, sizeof(old_sigset));
if (rc != 0) {
free(timer);
errno = rc;
return -1;
}
sigevent se = *evp;
se.sigev_signo = TIMER_SIGNAL;
se.sigev_notify = SIGEV_THREAD_ID;
se.sigev_notify_thread_id = pthread_gettid_np(timer->callback_thread);
if (__timer_create(clock_id, &se, &timer->kernel_timer_id) == -1) {
__timer_thread_stop(timer);
return -1;
}
// Give the thread a specific meaningful name.
// It can't do this itself because the kernel timer isn't created until after it's running.
char name[16]; // 16 is the kernel-imposed limit.
snprintf(name, sizeof(name), "POSIX timer %d", to_kernel_timer_id(timer));
pthread_setname_np(timer->callback_thread, name);
*timer_id = timer;
return 0;
}
