18,11 → 18,11 |
|
/** |
------------ |
CVS : $Id: mqueue.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $ |
CVS : $Id: mqueue.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 $ |
------------ |
|
POSIX message queues |
90,8 → 90,8 |
correct bit is set */ |
|
/* the blocked processes queues */ |
QQUEUE blocked_send; |
QQUEUE blocked_rcv; |
IQUEUE blocked_send; |
IQUEUE blocked_rcv; |
|
int next; /* the mq queue */ |
} mq_table[MQ_OPEN_MAX]; |
105,7 → 105,7 |
if the task is not blocked...) */ |
} mqproc_table[MAX_PROC]; |
|
static QUEUE free_mq; /* Queue of free sem */ |
static int free_mq; /* Queue of free sem */ |
|
mqd_t mq_open(const char *name, int oflag, ...) |
{ |
168,8 → 168,8 |
mq_table[mq].maxmsg = MQ_DEFAULT_MAXMSG; |
mq_table[mq].msgsize = MQ_DEFAULT_MSGSIZE; |
} |
qq_init(&mq_table[mq].blocked_send); |
qq_init(&mq_table[mq].blocked_rcv); |
iq_init(&mq_table[mq].blocked_send, &freedesc, 0); |
iq_init(&mq_table[mq].blocked_rcv, &freedesc, 0); |
|
mq_table[mq].count = 0; |
mq_table[mq].start = -1; |
320,12 → 320,12 |
/* the task that have to be killed is waiting on a mq_send */ |
|
/* we have to extract the task from the blocked queue... */ |
qq_extract(i,&mq_table[mqproc_table[i].mqdes].blocked_send); |
iq_extract(i,&mq_table[mqproc_table[i].mqdes].blocked_send); |
|
/* and the task have to be reinserted into the ready queues, so it |
will fall into task_testcancel */ |
l = proc_table[i].task_level; |
level_table[l]->task_insert(l,i); |
level_table[l]->public_unblock(l,i); |
|
return 1; |
} |
334,12 → 334,12 |
/* the task that have to be killed is waiting on a mq_send */ |
|
/* we have to extract the task from the blocked queue... */ |
qq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_rcv); |
iq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_rcv); |
|
/* and the task have to be reinserted into the ready queues, so it |
will fall into task_testcancel */ |
l = proc_table[i].task_level; |
level_table[l]->task_insert(l,i); |
level_table[l]->public_unblock(l,i); |
|
return 1; |
} |
357,12 → 357,12 |
mqproc_table[exec_shadow].intsig = 1; |
|
/* we have to extract the task from the blocked queue... */ |
qq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_send); |
iq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_send); |
|
/* and the task have to be reinserted into the ready queues, so it |
will fall into task_testcancel */ |
l = proc_table[i].task_level; |
level_table[l]->task_insert(l,i); |
level_table[l]->public_unblock(l,i); |
|
return 1; |
} |
373,12 → 373,12 |
mqproc_table[exec_shadow].intsig = 1; |
|
/* we have to extract the task from the blocked queue... */ |
qq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_rcv); |
iq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_rcv); |
|
/* and the task have to be reinserted into the ready queues, so it |
will fall into task_testcancel */ |
l = proc_table[i].task_level; |
level_table[l]->task_insert(l,i); |
level_table[l]->public_unblock(l,i); |
|
return 1; |
} |
437,8 → 437,6 |
} |
else { |
LEVEL l; |
struct timespec ty; |
TIME tx; |
|
/* we block the task until: |
- a message is received, or |
447,23 → 445,14 |
|
mqproc_table[exec_shadow].intsig = 0; |
|
/* 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); |
|
/* we insert the task in the message queue */ |
proc_table[exec_shadow].status = WAIT_MQSEND; |
qq_insert(exec_shadow,&mq_table[mqdes].blocked_send); |
iq_priority_insert(exec_shadow,&mq_table[mqdes].blocked_send); |
|
/* and finally we reschedule */ |
exec = exec_shadow = -1; |
504,7 → 493,7 |
/* the mq was empty */ |
PID p; |
|
p = qq_getfirst(&mq_table[mqdes].blocked_rcv); |
p = iq_getfirst(&mq_table[mqdes].blocked_rcv); |
|
if ( p != NIL) { |
/* The first blocked task has to be woken up */ |
513,7 → 502,7 |
proc_table[exec_shadow].context = ll_context_from(); |
|
l = proc_table[p].task_level; |
level_table[l]->task_insert(l,p); |
level_table[l]->public_unblock(l,p); |
|
/* Preempt if necessary */ |
scheduler(); |
603,8 → 592,6 |
} |
else { |
LEVEL l; |
struct timespec ty; |
TIME tx; |
|
/* we block the task until: |
- a message arrives, or |
613,23 → 600,14 |
|
mqproc_table[exec_shadow].intsig = 0; |
|
/* 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); |
|
/* we insert the task into the message queue */ |
proc_table[exec_shadow].status = WAIT_MQRECEIVE; |
qq_insert(exec_shadow,&mq_table[mqdes].blocked_rcv); |
iq_priority_insert(exec_shadow,&mq_table[mqdes].blocked_rcv); |
|
/* and finally we reschedule */ |
exec = exec_shadow = -1; |
671,7 → 649,7 |
returnvalue = mq_table[mqdes].mq_info[ msg ].msglen; |
|
/* if the mq was full, there may be a task into blocked-send queue */ |
p = qq_getfirst(&mq_table[mqdes].blocked_send); |
p = iq_getfirst(&mq_table[mqdes].blocked_send); |
|
if ( p != NIL) { |
/* The first blocked task on send has to be woken up */ |
680,7 → 658,7 |
proc_table[exec_shadow].context = ll_context_from(); |
|
l = proc_table[p].task_level; |
level_table[l]->task_insert(l,p); |
level_table[l]->public_unblock(l,p); |
|
/* Preempt if necessary */ |
scheduler(); |