/*! Cancel sleep
* - handle return values and errno;
* - thread must be handled elsewhere - with source of interrupt (signal?)
*/
static void kclock_interrupt_sleep ( kthread_t *kthread, void *param )
{
ktimer_t *ktimer;
timespec_t *remain;
itimerspec_t irem;
ASSERT ( kthread && param );
ASSERT ( kthread_check_kthread ( kthread ) ); /* is this valid thread */
ASSERT ( kthread_is_suspended ( kthread, NULL, NULL ) );
ktimer = param;
remain = ktimer->param;
if ( remain )
{
/* save remaining time */
timespec_t now;
kclock_gettime ( CLOCK_REALTIME, &now );
ktimer_gettime ( ktimer, &irem );
*remain = irem.it_value;
time_sub ( remain, &now );
}
ktimer_delete (ktimer);
kthread_set_syscall_retval ( kthread, EXIT_FAILURE );
kthread_set_errno ( kthread, EINTR );
}
/*!
* Resume suspended thread (called on timer activation)
* \param sigval Thread that should be released
*/
static void kclock_wake_thread ( sigval_t sigval )
{
kthread_t *kthread;
ktimer_t *ktimer;
int retval = 0;
kthread = sigval.sival_ptr;
ASSERT ( kthread );
ASSERT ( kthread_check_kthread ( kthread ) ); /* is this valid thread */
ASSERT ( kthread_is_suspended ( kthread, NULL, NULL ) );
ktimer = kthread_get_private_param ( kthread );
timespec_t *remain = ktimer->param;
if ( remain )
TIME_RESET ( remain ); /* timer expired */
kthread_move_to_ready ( kthread, LAST );
retval += ktimer_delete ( ktimer );
ASSERT ( retval == EXIT_SUCCESS );
kthreads_schedule ();
}
/*! Send signal to target thread */
int ksignal_queue ( kthread_t *kthread, siginfo_t *sig )
{
int enqueue = FALSE;
int retval = EXIT_SUCCESS;
int schedule = FALSE;
ksignal_handling_t *sh;
sigaction_t *act;
void (*func) (kthread_t *, void *), *param;
kprocess_t *proc;
siginfo_t *us;
param_t param1, param2, param3;
ASSERT ( kthread );
ASSERT ( kthread_check_kthread ( kthread ) );
ASSERT ( sig->si_signo > 0 && sig->si_signo <= SIGMAX );
if ( !kthread_is_alive ( kthread ) )
return ESRCH;
sh = kthread_get_sigparams ( kthread );
/* is thread suspended and waits for this signal? */
if (
kthread_is_suspended ( kthread, (void **) &func, ¶m ) &&
((void *) func) == ((void *) ksignal_received_signal)
)
{
/* thread is waiting for signal */
if ( !ksignal_received_signal ( kthread, sig ) )
{
/* waited for this signal */
/* do not process this signal further */
return EXIT_SUCCESS;
}
}
/*
* If thread is in interruptable state and signal is not masked:
* - process signal
* - otherwise queue it
*/
if (
kthread_get_interruptable ( kthread ) &&
!sigtestset ( sh->mask, sig->si_signo )
)
{
act = &sh->act[sig->si_signo];
if ( act->sa_flags != SA_SIGINFO )
return ENOTSUP; /* not supported without SA_SIGINFO! */
if ( act->sa_sigaction == SIG_ERR ||
act->sa_sigaction == SIG_DFL ||
act->sa_sigaction == SIG_IGN ||
act->sa_sigaction == SIG_HOLD )
{
return ENOTSUP; /* not yet supported */
}
if ( !kthread_is_ready ( kthread ) )
{
/*
* thread is suspended/blocked on something else
*
* 1. handle interruption:
* a) we break suspend/wait state
* (call cancel function)
* b) set errno = EINTR
* c) set return value = FAILURE
* 2. create new thread state
* a) process signal in this state
*/
void (*func) (kthread_t *, void *), *param;
kthread_is_suspended (kthread, (void **) &func, ¶m);
if ( func )
func ( kthread, param );
kthread_move_to_ready ( kthread, LAST );
kthread_set_errno ( kthread, EINTR );
kthread_set_syscall_retval ( kthread, EXIT_FAILURE );
/* thread is unsuspended, but signal
* handler will be added first */
schedule = TRUE;
}
/* copy sig to user space */
proc = kthread_get_process ( kthread );
us = kprocess_stack_alloc ( proc );
ASSERT (us);
/*if ( !us )
return ENOMEM;*/
*us = *sig;
kthread_create_new_state ( kthread, act->sa_sigaction,
K2U_GET_ADR ( us, proc ), NULL,
HANDLER_STACK_SIZE, TRUE );
param1.p_ptr = proc;
param2.p_ptr = us;
param3.p_ptr = NULL;
kthread_add_cleanup ( kthread, kprocess_stack_free,
param1, param2, param3 );
/* mask signal in thread mask */
sigaddset ( sh->mask, sig->si_signo );
/* mask additional signals in thread mask */
sigaddsets ( sh->mask, &act->sa_mask );
}
else {
enqueue = TRUE;
}
if ( enqueue )
{
ksignal_add_to_pending ( sh, sig );
retval = EAGAIN;
}
if ( schedule )
kthreads_schedule ();
return retval;
}
/*! Send signal to target thread */
int ksignal_queue ( kthread_t *kthread, siginfo_t *sig )
{
int enqueue = FALSE;
int retval = EXIT_SUCCESS;
int schedule = FALSE;
ksignal_handling_t *sh;
sigaction_t *act;
void (*func) (kthread_t *, void *), *param;
kprocess_t *proc;
siginfo_t *us;
param_t param1, param2, param3;
ksiginfo_t *ksig;
ASSERT ( kthread );
ASSERT ( kthread_check_kthread ( kthread ) );
ASSERT ( sig->si_signo > 0 && sig->si_signo <= SIGMAX );
if ( !kthread_is_alive ( kthread ) )
return ESRCH;
sh = kthread_get_sigparams ( kthread );
/* is thread suspended and waits for this signal? */
if ( kthread_is_suspended ( kthread, (void **) &func, ¶m ) )
{
if ( ((void *) func) == ((void *) ksignal_received_signal) )
{
/* thread is waiting for signal */
if ( !ksignal_received_signal ( kthread, sig ) )
{
/* waited for this signal */
/* should continue with signal handler also? */
/* do not process this signal further */
return EXIT_SUCCESS;
}
}
/* else {
* thread is waiting for something else;
* deal with this later (in next "if")
* } */
}
/* if signal is not masked in thread signal mask, deliver signal */
if ( !sigtestset ( sh->mask, sig->si_signo ) )
{
act = &sh->act[sig->si_signo];
if ( act->sa_flags != SA_SIGINFO )
return ENOTSUP; /* not supported without SA_SIGINFO! */
if ( act->sa_sigaction == SIG_ERR ||
act->sa_sigaction == SIG_DFL ||
act->sa_sigaction == SIG_IGN ||
act->sa_sigaction == SIG_HOLD )
{
return ENOTSUP; /* not yet supported */
}
/* current implementation
* - if thread is active or ready
* -- save old context in list
* -- create new context
* - else
* -- enqueue signal or cancel wait state (todo)
*
* on sys__exit check if its handler or thread!!!
*/
if ( !kthread_is_ready ( kthread ) )
{
void (*func) (kthread_t *, void *), *param;
if ( kthread_is_suspended ( kthread,
(void **) &func, ¶m ) )
{
/*
* thread is suspended on something
* else; interrupt it or not?
*
* -handle interruption (kernel part)
* -interrupt it (resume)
* -process signal
*
* to do above just move thread to
* ready, set errno & retval
*/
if ( func )
func ( kthread, param );
kthread_move_to_ready ( kthread, LAST );
kthread_set_errno ( kthread, EINTR );
kthread_set_syscall_retval(kthread,EXIT_FAILURE);
/* thread is unsuspended, but signal
* handler will be added first */
schedule = TRUE;
}
else {
/* what else? this is error */
ASSERT ( FALSE );
}
}
/* copy sig to user space */
proc = kthread_get_process ( kthread );
us = ffs_alloc(proc->stack_pool, sizeof (siginfo_t));
ASSERT (us);
/*if ( !us )
return ENOMEM;*/
*us = *sig;
kthread_create_new_state ( kthread, act->sa_sigaction,
K2U_GET_ADR ( us, proc ), NULL,
HANDLER_STACK_SIZE, TRUE );
param1.p_ptr = proc->stack_pool;
param2.p_ptr = us;
param3.p_ptr = NULL;
kthread_add_cleanup ( kthread, kthread_param_free,
param1, param2, param3 );
/* mask signal in thread mask */
sigaddset ( sh->mask, sig->si_signo );
/* mask additional signals in thread mask */
sigaddsets ( sh->mask, &act->sa_mask );
}
else {
enqueue = TRUE;
}
if ( enqueue )
{
/* mask signal in thread mask */
sigaddset ( sh->mask, sig->si_signo );
/* add signal to list of pending signals */
ksig = kmalloc ( sizeof (ksiginfo_t) );
ksig->siginfo = *sig;
list_append ( &sh->pending_signals, ksig, &ksig->list );
/* list_sort_add ( &sh->pending_signals, ksig, &ksig->list,
ksignal_compare ); */
retval = EAGAIN;
}
if ( schedule )
kthreads_schedule ();
return retval;
}