Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 38 → Rev 102

/shark/tags/rel_0_5/kernel/signal.c
18,11 → 18,11
 
/**
------------
CVS : $Id: signal.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: signal.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains:
108,7 → 108,7
* A queue of all threads waiting in sigwait.
* It is not static because it is used into the task_kill...ð
*/
static QUEUE sigwaiters;
static IQUEUE sigwaiters;
 
 
/*+ An array of queues of pending signals posted with sigqueue(). +*/
331,10 → 331,10
LEVEL l;
 
/* Reactivate the task... */
q_extract(p, &sigwaiters);
iq_extract(p, &sigwaiters);
 
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
 
}
 
469,9 → 469,9
* in sigwait will have blocked the signals being waited for).
*/
 
for (task = sigwaiters;
for (task = iq_query_first(&sigwaiters);
task != NIL;
task = proc_table[task].next) {
task = iq_query_next(task, &sigwaiters)) {
if (sigismember(&proc_table[task].sigwaiting, signo)) {
LEVEL l;
 
479,12 → 479,12
sigaddset(&proc_table[task].sigpending, signo);
 
/* Reactivate the task... */
q_extract(task, &sigwaiters);
iq_extract(task, &sigwaiters);
l = proc_table[task].task_level;
level_table[l]->task_insert(l,task);
level_table[l]->public_unblock(l,task);
 
if (proc_table[task].delay_timer != -1) {
event_delete(proc_table[task].delay_timer);
kern_event_delete(proc_table[task].delay_timer);
proc_table[task].delay_timer = -1;
}
 
614,9 → 614,9
* the FIFO order, and how to prevent lost signals in the case that
* a thread calls sigwait before the woken thread runs and gets it.
*/
for (task = sigwaiters;
for (task = iq_query_first(&sigwaiters);
task != NIL;
task = proc_table[task].next) {
task = iq_query_next(task, &sigwaiters)) {
if (sigismember(&proc_table[task].sigwaiting, signo)) {
LEVEL l;
 
624,13 → 624,13
sigaddset(&proc_table[task].sigpending, signo);
 
/* Reactivate the task... */
q_extract(task, &sigwaiters);
iq_extract(task, &sigwaiters);
 
l = proc_table[task].task_level;
level_table[l]->task_insert(l,task);
level_table[l]->public_unblock(l,task);
 
if (proc_table[task].delay_timer != -1) {
event_delete(proc_table[task].delay_timer);
kern_event_delete(proc_table[task].delay_timer);
proc_table[task].delay_timer = -1;
}
 
697,10 → 697,10
proc_table[p].control |= SIGTIMEOUT_EXPIRED;
 
/* insert the task into the ready queue and extract it from the waiters */
q_extract(p, &sigwaiters);
iq_extract(p, &sigwaiters);
 
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
 
event_need_reschedule();
}
718,8 → 718,6
proc_des *pthread = &proc_table[exec_shadow];
int thissig;
 
struct timespec ty;
TIME tx;
LEVEL l;
 
task_testcancel();
754,7 → 752,7
* Grab the first queue entry.
*/
sos = sigqueued[thissig];
sigqueued[thissig] = sig_queue[sigqueued[thissig]].next;
sigqueued[thissig] = sig_queue[sos].next;
 
/*
* If that was the last one, reset the process procsigpending.
814,18 → 812,10
/* now, we really block the task... */
proc_table[exec_shadow].context = kern_context_save();
/* SAME AS SCHEDULER... manage the capacity event and the load_info */
ll_gettime(TIME_EXACT, &schedule_time);
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
proc_table[exec_shadow].avail_time -= tx;
jet_update_slice(tx);
if (cap_timer != NIL) {
event_delete(cap_timer);
cap_timer = NIL;
}
kern_epilogue_macro();
 
l = proc_table[exec_shadow].task_level;
level_table[l]->task_extract(l,exec_shadow);
level_table[l]->public_block(l,exec_shadow);
/*
* Add this thread to the list of threads in sigwait. Once that is
834,7 → 824,7
* find a thread in sigwait, but it will not be able to wake it up
* until the waitlock is released in the switch code.
*/
q_insertfirst(exec_shadow, &sigwaiters);
iq_insertfirst(exec_shadow, &sigwaiters);
proc_table[exec_shadow].status = WAIT_SIG;
 
if (timeout) {
841,7 → 831,7
/* we can use the delaytimer because if we are here we are not in a
task_delay */
struct timespec t, abstime;
ll_gettime(TIME_EXACT, &t);
kern_gettime(&t);
ADDTIMESPEC(&t, timeout, &abstime);
 
proc_table[exec_shadow].delay_timer =
890,7 → 880,8
/*
* Grab the first queue entry.
*/
sos = q_getfirst(&sigqueued[thissig]);
sos = sigqueued[thissig];
sigqueued[thissig] = sig_queue[sos].next;
 
/*
* If that was the last one, reset the process procsigpending.
1026,8 → 1017,6
{
proc_des *pthread = &proc_table[exec_shadow];
 
struct timespec ty;
TIME tx;
LEVEL l;
 
task_testcancel();
1055,20 → 1044,11
/* now, we really block the task... */
proc_table[exec_shadow].context = kern_context_save();
/* SAME AS SCHEDULER... manage the capacity event and the load_info */
ll_gettime(TIME_EXACT, &schedule_time);
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
proc_table[exec_shadow].avail_time -= tx;
jet_update_slice(tx);
if (cap_timer != NIL) {
event_delete(cap_timer);
cap_timer = NIL;
}
kern_epilogue_macro();
l = proc_table[exec_shadow].task_level;
level_table[l]->task_extract(l,exec_shadow);
level_table[l]->public_block(l,exec_shadow);
 
q_insertfirst(exec_shadow, &sigwaiters);
iq_insertfirst(exec_shadow, &sigwaiters);
proc_table[exec_shadow].status = WAIT_SIGSUSPEND;
 
/* and finally we reschedule */
1115,7 → 1095,7
 
kern_cli();
 
ll_gettime(TIME_EXACT, &temp);
kern_gettime(&temp);
 
if (alarm_timer == -1)
returnvalue.tv_sec = 0;
1122,7 → 1102,7
else {
SUBTIMESPEC(&alarm_time, &temp, &returnvalue);
 
event_delete(alarm_timer);
kern_event_delete(alarm_timer);
}
 
if (seconds) {
1496,14 → 1476,14
if (proc_table[i].status == WAIT_SIG) {
 
if (proc_table[i].delay_timer != -1) {
event_delete(proc_table[i].delay_timer);
kern_event_delete(proc_table[i].delay_timer);
proc_table[i].delay_timer = -1;
}
 
q_extract(i, &sigwaiters);
iq_extract(i, &sigwaiters);
 
l = proc_table[i].task_level;
level_table[l]->task_insert(l,i);
level_table[l]->public_unblock(l,i);
 
return 1;
}
1510,7 → 1490,7
else if (proc_table[i].status == WAIT_SIGSUSPEND) {
 
l = proc_table[i].task_level;
level_table[l]->task_insert(l,i);
level_table[l]->public_unblock(l,i);
 
return 1;
}
1544,7 → 1524,7
 
procsigpending = 0;
 
sigwaiters = NIL;
iq_init(&sigwaiters, &freedesc, 0);
alarm_timer = -1;
 
/* Interrupt handling init */