/*
|
* Copyright (C) 2013 Philippe Gerum <rpm@xenomai.org>.
|
*
|
* This program is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU General Public License as
|
* published by the Free Software Foundation; either version 2 of the
|
* License, or (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
*/
|
#include <linux/sched.h>
|
#include <cobalt/kernel/assert.h>
|
#include <cobalt/kernel/compat.h>
|
#include <cobalt/kernel/time.h>
|
#include "internal.h"
|
#include "signal.h"
|
#include "thread.h"
|
#include "timer.h"
|
#include "clock.h"
|
|
static void *sigpending_mem;
|
|
static LIST_HEAD(sigpending_pool);
|
|
/*
|
* How many signal notifications which may be pending at any given
|
* time, except timers. Cobalt signals are always thread directed,
|
* and we assume that in practice, each signal number is processed by
|
* a dedicated thread. We provide for up to three real-time signal
|
* events to pile up, and a single notification pending for other
|
* signals. Timers use a fast queuing logic maintaining a count of
|
* overruns, and therefore do not consume any memory from this pool.
|
*/
|
#define __SIGPOOL_SIZE (sizeof(struct cobalt_sigpending) * \
|
(_NSIG + (SIGRTMAX - SIGRTMIN) * 2))
|
|
static int cobalt_signal_deliver(struct cobalt_thread *thread,
|
struct cobalt_sigpending *sigp,
|
int group)
|
{ /* nklocked, IRQs off */
|
struct cobalt_sigwait_context *swc;
|
struct xnthread_wait_context *wc;
|
struct list_head *sigwaiters;
|
int sig, ret;
|
|
sig = sigp->si.si_signo;
|
XENO_BUG_ON(COBALT, sig < 1 || sig > _NSIG);
|
|
/*
|
* Attempt to deliver the signal immediately to the initial
|
* target that waits for it.
|
*/
|
if (xnsynch_pended_p(&thread->sigwait)) {
|
wc = xnthread_get_wait_context(&thread->threadbase);
|
swc = container_of(wc, struct cobalt_sigwait_context, wc);
|
if (sigismember(swc->set, sig))
|
goto deliver;
|
}
|
|
/*
|
* If that does not work out and we are sending to a thread
|
* group, try to deliver to any thread from the same process
|
* waiting for that signal.
|
*/
|
sigwaiters = &thread->process->sigwaiters;
|
if (!group || list_empty(sigwaiters))
|
return 0;
|
|
list_for_each_entry(thread, sigwaiters, signext) {
|
wc = xnthread_get_wait_context(&thread->threadbase);
|
swc = container_of(wc, struct cobalt_sigwait_context, wc);
|
if (sigismember(swc->set, sig))
|
goto deliver;
|
}
|
|
return 0;
|
deliver:
|
cobalt_copy_siginfo(sigp->si.si_code, swc->si, &sigp->si);
|
cobalt_call_extension(signal_deliver, &thread->extref,
|
ret, swc->si, sigp);
|
xnthread_complete_wait(&swc->wc);
|
xnsynch_wakeup_one_sleeper(&thread->sigwait);
|
list_del(&thread->signext);
|
|
/*
|
* This is an immediate delivery bypassing any queuing, so we
|
* have to release the sigpending data right away before
|
* leaving.
|
*/
|
cobalt_signal_free(sigp);
|
|
return 1;
|
}
|
|
int cobalt_signal_send(struct cobalt_thread *thread,
|
struct cobalt_sigpending *sigp,
|
int group)
|
{ /* nklocked, IRQs off */
|
struct list_head *sigq;
|
int sig, ret;
|
|
/* Can we deliver this signal immediately? */
|
ret = cobalt_signal_deliver(thread, sigp, group);
|
if (ret)
|
return ret; /* Yep, done. */
|
|
/*
|
* Nope, attempt to queue it. We start by calling any Cobalt
|
* extension for queuing the signal first.
|
*/
|
if (cobalt_call_extension(signal_queue, &thread->extref, ret, sigp)) {
|
if (ret)
|
/* Queuing done remotely or error. */
|
return ret;
|
}
|
|
sig = sigp->si.si_signo;
|
sigq = thread->sigqueues + sig - 1;
|
if (!list_empty(sigq)) {
|
/* Queue non-rt signals only once. */
|
if (sig < SIGRTMIN)
|
return 0;
|
/* Queue rt signal source only once (SI_TIMER). */
|
if (!list_empty(&sigp->next))
|
return 0;
|
}
|
|
sigaddset(&thread->sigpending, sig);
|
list_add_tail(&sigp->next, sigq);
|
|
return 1;
|
}
|
EXPORT_SYMBOL_GPL(cobalt_signal_send);
|
|
int cobalt_signal_send_pid(pid_t pid, struct cobalt_sigpending *sigp)
|
{ /* nklocked, IRQs off */
|
struct cobalt_thread *thread;
|
|
thread = cobalt_thread_find(pid);
|
if (thread)
|
return cobalt_signal_send(thread, sigp, 0);
|
|
return -ESRCH;
|
}
|
EXPORT_SYMBOL_GPL(cobalt_signal_send_pid);
|
|
struct cobalt_sigpending *cobalt_signal_alloc(void)
|
{ /* nklocked, IRQs off */
|
struct cobalt_sigpending *sigp;
|
|
if (list_empty(&sigpending_pool)) {
|
if (xnclock_ratelimit())
|
printk(XENO_WARNING "signal bucket pool underflows\n");
|
return NULL;
|
}
|
|
sigp = list_get_entry(&sigpending_pool, struct cobalt_sigpending, next);
|
INIT_LIST_HEAD(&sigp->next);
|
|
return sigp;
|
}
|
EXPORT_SYMBOL_GPL(cobalt_signal_alloc);
|
|
void cobalt_signal_free(struct cobalt_sigpending *sigp)
|
{ /* nklocked, IRQs off */
|
if ((void *)sigp >= sigpending_mem &&
|
(void *)sigp < sigpending_mem + __SIGPOOL_SIZE)
|
list_add_tail(&sigp->next, &sigpending_pool);
|
}
|
EXPORT_SYMBOL_GPL(cobalt_signal_free);
|
|
void cobalt_signal_flush(struct cobalt_thread *thread)
|
{
|
struct cobalt_sigpending *sigp, *tmp;
|
struct list_head *sigq;
|
spl_t s;
|
int n;
|
|
/*
|
* TCB is not accessible from userland anymore, no locking
|
* required.
|
*/
|
if (sigisemptyset(&thread->sigpending))
|
return;
|
|
for (n = 0; n < _NSIG; n++) {
|
sigq = thread->sigqueues + n;
|
if (list_empty(sigq))
|
continue;
|
/*
|
* sigpending blocks must be unlinked so that we
|
* detect this fact when deleting their respective
|
* owners.
|
*/
|
list_for_each_entry_safe(sigp, tmp, sigq, next) {
|
list_del_init(&sigp->next);
|
if ((void *)sigp >= sigpending_mem &&
|
(void *)sigp < sigpending_mem + __SIGPOOL_SIZE) {
|
xnlock_get_irqsave(&nklock, s);
|
list_add_tail(&sigp->next, &sigpending_pool);
|
xnlock_put_irqrestore(&nklock, s);
|
}
|
}
|
}
|
|
sigemptyset(&thread->sigpending);
|
}
|
|
static int signal_put_siginfo(void __user *u_si, const struct siginfo *si,
|
int overrun)
|
{
|
struct siginfo __user *u_p = u_si;
|
int ret;
|
|
ret = __xn_put_user(si->si_signo, &u_p->si_signo);
|
ret |= __xn_put_user(si->si_errno, &u_p->si_errno);
|
ret |= __xn_put_user(si->si_code, &u_p->si_code);
|
|
/*
|
* Copy the generic/standard siginfo bits to userland.
|
*/
|
switch (si->si_code) {
|
case SI_TIMER:
|
ret |= __xn_put_user(si->si_tid, &u_p->si_tid);
|
ret |= __xn_put_user(si->si_ptr, &u_p->si_ptr);
|
ret |= __xn_put_user(overrun, &u_p->si_overrun);
|
break;
|
case SI_QUEUE:
|
case SI_MESGQ:
|
ret |= __xn_put_user(si->si_ptr, &u_p->si_ptr);
|
fallthrough;
|
case SI_USER:
|
ret |= __xn_put_user(si->si_pid, &u_p->si_pid);
|
ret |= __xn_put_user(si->si_uid, &u_p->si_uid);
|
}
|
|
return ret;
|
}
|
|
static int signal_wait(sigset_t *set, xnticks_t timeout,
|
void __user *u_si, bool compat)
|
{
|
struct cobalt_sigpending *sigp = NULL;
|
struct cobalt_sigwait_context swc;
|
struct cobalt_thread *curr;
|
int ret, sig, n, overrun;
|
unsigned long *p, *t, m;
|
struct siginfo si, *sip;
|
struct list_head *sigq;
|
spl_t s;
|
|
curr = cobalt_current_thread();
|
XENO_BUG_ON(COBALT, curr == NULL);
|
|
if (u_si && !access_wok(u_si, sizeof(*u_si)))
|
return -EFAULT;
|
|
xnlock_get_irqsave(&nklock, s);
|
|
check:
|
if (sigisemptyset(&curr->sigpending))
|
/* Most common/fast path. */
|
goto wait;
|
|
p = curr->sigpending.sig; /* pending */
|
t = set->sig; /* tested */
|
|
for (n = 0, sig = 0; n < _NSIG_WORDS; ++n) {
|
m = *p++ & *t++;
|
if (m == 0)
|
continue;
|
sig = ffz(~m) + n *_NSIG_BPW + 1;
|
break;
|
}
|
|
if (sig) {
|
sigq = curr->sigqueues + sig - 1;
|
if (list_empty(sigq)) {
|
sigdelset(&curr->sigpending, sig);
|
goto check;
|
}
|
sigp = list_get_entry(sigq, struct cobalt_sigpending, next);
|
INIT_LIST_HEAD(&sigp->next); /* Mark sigp as unlinked. */
|
if (list_empty(sigq))
|
sigdelset(&curr->sigpending, sig);
|
sip = &sigp->si;
|
ret = 0;
|
goto done;
|
}
|
|
wait:
|
if (timeout == XN_NONBLOCK) {
|
ret = -EAGAIN;
|
goto fail;
|
}
|
swc.set = set;
|
swc.si = &si;
|
xnthread_prepare_wait(&swc.wc);
|
list_add_tail(&curr->signext, &curr->process->sigwaiters);
|
ret = xnsynch_sleep_on(&curr->sigwait, timeout, XN_RELATIVE);
|
if (ret) {
|
list_del(&curr->signext);
|
ret = ret & XNBREAK ? -EINTR : -EAGAIN;
|
goto fail;
|
}
|
sig = si.si_signo;
|
sip = &si;
|
done:
|
/*
|
* si_overrun raises a nasty issue since we have to
|
* collect+clear it atomically before we drop the lock,
|
* although we don't know in advance if any extension would
|
* use it along with the additional si_codes it may provide,
|
* but we must drop the lock before running the
|
* signal_copyinfo handler.
|
*
|
* Observing that si_overrun is likely the only "unstable"
|
* data from the signal information which might change under
|
* our feet while we copy the bits to userland, we collect it
|
* here from the atomic section for all unknown si_codes,
|
* then pass its value to the signal_copyinfo handler.
|
*/
|
switch (sip->si_code) {
|
case SI_TIMER:
|
overrun = cobalt_timer_deliver(curr, sip->si_tid);
|
break;
|
case SI_USER:
|
case SI_MESGQ:
|
case SI_QUEUE:
|
overrun = 0;
|
break;
|
default:
|
overrun = sip->si_overrun;
|
if (overrun)
|
sip->si_overrun = 0;
|
}
|
|
xnlock_put_irqrestore(&nklock, s);
|
|
if (u_si == NULL)
|
goto out; /* Return signo only. */
|
|
#ifdef CONFIG_XENO_ARCH_SYS3264
|
if (compat) {
|
ret = sys32_put_siginfo(u_si, sip, overrun);
|
if (!ret)
|
/* Allow an extended target to receive more data. */
|
cobalt_call_extension(signal_copyinfo_compat,
|
&curr->extref, ret, u_si, sip,
|
overrun);
|
} else
|
#endif
|
{
|
ret = signal_put_siginfo(u_si, sip, overrun);
|
if (!ret)
|
/* Allow an extended target to receive more data. */
|
cobalt_call_extension(signal_copyinfo, &curr->extref,
|
ret, u_si, sip, overrun);
|
}
|
|
out:
|
/*
|
* If we pulled the signal information from a sigpending
|
* block, release it to the free pool if applicable.
|
*/
|
if (sigp &&
|
(void *)sigp >= sigpending_mem &&
|
(void *)sigp < sigpending_mem + __SIGPOOL_SIZE) {
|
xnlock_get_irqsave(&nklock, s);
|
list_add_tail(&sigp->next, &sigpending_pool);
|
xnlock_put_irqrestore(&nklock, s);
|
/* no more ref. to sigp beyond this point. */
|
}
|
|
return ret ? -EFAULT : sig;
|
fail:
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
int __cobalt_sigwait(sigset_t *set)
|
{
|
return signal_wait(set, XN_INFINITE, NULL, false);
|
}
|
|
COBALT_SYSCALL(sigwait, primary,
|
(const sigset_t __user *u_set, int __user *u_sig))
|
{
|
sigset_t set;
|
int sig;
|
|
if (cobalt_copy_from_user(&set, u_set, sizeof(set)))
|
return -EFAULT;
|
|
sig = signal_wait(&set, XN_INFINITE, NULL, false);
|
if (sig < 0)
|
return sig;
|
|
return cobalt_copy_to_user(u_sig, &sig, sizeof(*u_sig));
|
}
|
|
int __cobalt_sigtimedwait(sigset_t *set,
|
const struct timespec64 *timeout,
|
void __user *u_si,
|
bool compat)
|
{
|
xnticks_t ticks;
|
|
if (!timespec64_valid(timeout))
|
return -EINVAL;
|
ticks = ts2ns(timeout);
|
if (ticks++ == 0)
|
ticks = XN_NONBLOCK;
|
|
return signal_wait(set, ticks, u_si, compat);
|
}
|
|
COBALT_SYSCALL(sigtimedwait, nonrestartable,
|
(const sigset_t __user *u_set,
|
struct siginfo __user *u_si,
|
const struct __user_old_timespec __user *u_timeout))
|
{
|
struct timespec64 timeout;
|
sigset_t set;
|
|
if (cobalt_copy_from_user(&set, u_set, sizeof(set)))
|
return -EFAULT;
|
|
if (cobalt_copy_from_user(&timeout, u_timeout, sizeof(timeout)))
|
return -EFAULT;
|
|
return __cobalt_sigtimedwait(&set, &timeout, u_si, false);
|
}
|
|
COBALT_SYSCALL(sigtimedwait64, nonrestartable,
|
(const sigset_t __user *u_set,
|
struct siginfo __user *u_si,
|
const struct __kernel_timespec __user *u_timeout))
|
{
|
struct timespec64 timeout;
|
sigset_t set;
|
|
if (cobalt_copy_from_user(&set, u_set, sizeof(set)))
|
return -EFAULT;
|
|
if (cobalt_get_timespec64(&timeout, u_timeout))
|
return -EFAULT;
|
|
return __cobalt_sigtimedwait(&set, &timeout, u_si, false);
|
}
|
|
int __cobalt_sigwaitinfo(sigset_t *set,
|
void __user *u_si,
|
bool compat)
|
{
|
return signal_wait(set, XN_INFINITE, u_si, compat);
|
}
|
|
COBALT_SYSCALL(sigwaitinfo, nonrestartable,
|
(const sigset_t __user *u_set, struct siginfo __user *u_si))
|
{
|
sigset_t set;
|
|
if (cobalt_copy_from_user(&set, u_set, sizeof(set)))
|
return -EFAULT;
|
|
return __cobalt_sigwaitinfo(&set, u_si, false);
|
}
|
|
COBALT_SYSCALL(sigpending, primary, (old_sigset_t __user *u_set))
|
{
|
struct cobalt_thread *curr = cobalt_current_thread();
|
|
return cobalt_copy_to_user(u_set, &curr->sigpending, sizeof(*u_set));
|
}
|
|
int __cobalt_kill(struct cobalt_thread *thread, int sig, int group) /* nklocked, IRQs off */
|
{
|
struct cobalt_sigpending *sigp;
|
int ret = 0;
|
|
/*
|
* We have undocumented pseudo-signals to suspend/resume/unblock
|
* threads, force them out of primary mode or even demote them
|
* to the weak scheduling class/priority. Process them early,
|
* before anyone can notice...
|
*/
|
switch(sig) {
|
case 0:
|
/* Check for existence only. */
|
break;
|
case SIGSUSP:
|
/*
|
* All callers shall be tagged as conforming calls, so
|
* self-directed suspension can only happen from
|
* primary mode. Yummie.
|
*/
|
xnthread_suspend(&thread->threadbase, XNSUSP,
|
XN_INFINITE, XN_RELATIVE, NULL);
|
if (&thread->threadbase == xnthread_current() &&
|
xnthread_test_info(&thread->threadbase, XNBREAK))
|
ret = -EINTR;
|
break;
|
case SIGRESM:
|
xnthread_resume(&thread->threadbase, XNSUSP);
|
goto resched;
|
case SIGRELS:
|
xnthread_unblock(&thread->threadbase);
|
goto resched;
|
case SIGKICK:
|
xnthread_kick(&thread->threadbase);
|
goto resched;
|
case SIGDEMT:
|
xnthread_demote(&thread->threadbase);
|
goto resched;
|
case 1 ... _NSIG:
|
sigp = cobalt_signal_alloc();
|
if (sigp) {
|
sigp->si.si_signo = sig;
|
sigp->si.si_errno = 0;
|
sigp->si.si_code = SI_USER;
|
sigp->si.si_pid = task_pid_nr(current);
|
sigp->si.si_uid = get_current_uuid();
|
if (cobalt_signal_send(thread, sigp, group) <= 0)
|
cobalt_signal_free(sigp);
|
}
|
resched:
|
xnsched_run();
|
break;
|
default:
|
ret = -EINVAL;
|
}
|
|
return ret;
|
}
|
|
COBALT_SYSCALL(kill, conforming, (pid_t pid, int sig))
|
{
|
struct cobalt_thread *thread;
|
int ret;
|
spl_t s;
|
|
xnlock_get_irqsave(&nklock, s);
|
|
thread = cobalt_thread_find(pid);
|
if (thread == NULL)
|
ret = -ESRCH;
|
else
|
ret = __cobalt_kill(thread, sig, 1);
|
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
int __cobalt_sigqueue(pid_t pid, int sig, const union sigval *value)
|
{
|
struct cobalt_sigpending *sigp;
|
struct cobalt_thread *thread;
|
int ret = 0;
|
spl_t s;
|
|
xnlock_get_irqsave(&nklock, s);
|
|
thread = cobalt_thread_find(pid);
|
if (thread == NULL) {
|
ret = -ESRCH;
|
goto out;
|
}
|
|
switch(sig) {
|
case 0:
|
/* Check for existence only. */
|
break;
|
case 1 ... _NSIG:
|
sigp = cobalt_signal_alloc();
|
if (sigp) {
|
sigp->si.si_signo = sig;
|
sigp->si.si_errno = 0;
|
sigp->si.si_code = SI_QUEUE;
|
sigp->si.si_pid = task_pid_nr(current);
|
sigp->si.si_uid = get_current_uuid();
|
sigp->si.si_value = *value;
|
if (cobalt_signal_send(thread, sigp, 1) <= 0)
|
cobalt_signal_free(sigp);
|
else
|
xnsched_run();
|
}
|
break;
|
default:
|
/* Cobalt pseudo-signals are never process-directed. */
|
ret = __cobalt_kill(thread, sig, 0);
|
}
|
out:
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
EXPORT_SYMBOL_GPL(__cobalt_sigqueue);
|
|
COBALT_SYSCALL(sigqueue, conforming,
|
(pid_t pid, int sig, const union sigval __user *u_value))
|
{
|
union sigval val;
|
int ret;
|
|
ret = cobalt_copy_from_user(&val, u_value, sizeof(val));
|
|
return ret ?: __cobalt_sigqueue(pid, sig, &val);
|
}
|
|
__init int cobalt_signal_init(void)
|
{
|
struct cobalt_sigpending *sigp;
|
|
sigpending_mem = xnheap_vmalloc(__SIGPOOL_SIZE);
|
if (sigpending_mem == NULL)
|
return -ENOMEM;
|
|
for (sigp = sigpending_mem;
|
(void *)sigp < sigpending_mem + __SIGPOOL_SIZE; sigp++)
|
list_add_tail(&sigp->next, &sigpending_pool);
|
|
return 0;
|
}
|
|
__init void cobalt_signal_cleanup(void)
|
{
|
xnheap_vfree(sigpending_mem);
|
}
|
