/*---------------------------------------------------------------------------*/
static void
do_event(void)
{
static process_event_t ev;
static process_data_t data;
static struct process *receiver;
static struct process *p;
WDTE=0xac;
/*
* If there are any events in the queue, take the first one and walk
* through the list of processes to see if the event should be
* delivered to any of them. If so, we call the event handler
* function for the process. We only process one event at a time and
* call the poll handlers inbetween.
*/
if(nevents > 0) {
/* There are events that we should deliver. */
ev = events[fevent].ev;
data = events[fevent].data;
receiver = events[fevent].p;
/* Since we have seen the new event, we move pointer upwards
and decrese the number of events. */
fevent = (fevent + 1) % PROCESS_CONF_NUMEVENTS;
--nevents;
/* If this is a broadcast event, we deliver it to all events, in
order of their priority. */
if(receiver == PROCESS_BROADCAST) {
for(p = process_list; p != NULL; p = p->next) {
/* If we have been requested to poll a process, we do this in
between processing the broadcast event. */
if(poll_requested) {
do_poll();
}
call_process(p, ev, data);
}
} else {
/* This is not a broadcast event, so we deliver it to the
specified process. */
/* If the event was an INIT event, we should also update the
state of the process. */
if(ev == PROCESS_EVENT_INIT) {
receiver->state = PROCESS_STATE_RUNNING;
}
/* Make sure that the process actually is running. */
call_process(receiver, ev, data);
}
}
}
/*---------------------------------------------------------------------------*/
void
process_post_synch(struct process *p, process_event_t ev, process_data_t data)
{
struct process *caller = process_current;
call_process(p, ev, data);
process_current = caller;
}
/*---------------------------------------------------------------------------*/
static void
exit_process(struct process *p, struct process *fromprocess)
{
register struct process *q;
struct process *old_current = process_current;
WDTE=0xac;
PRINTF("process: exit_process '%s'\n", PROCESS_NAME_STRING(p));
/* Make sure the process is in the process list before we try to
exit it. */
for(q = process_list; q != p && q != NULL; q = q->next);
if(q == NULL) {
return;
}
if(process_is_running(p)) {
/* Process was running */
p->state = PROCESS_STATE_NONE;
/*
* Post a synchronous event to all processes to inform them that
* this process is about to exit. This will allow services to
* deallocate state associated with this process.
*/
for(q = process_list; q != NULL; q = q->next) {
if(p != q) {
call_process(q, PROCESS_EVENT_EXITED, (process_data_t)p);
}
}
if(p->thread != NULL && p != fromprocess) {
/* Post the exit event to the process that is about to exit. */
process_current = p;
p->thread(&p->pt, PROCESS_EVENT_EXIT, NULL);
}
}
if(p == process_list) {
process_list = process_list->next;
} else {
for(q = process_list; q != NULL; q = q->next) {
if(q->next == p) {
q->next = p->next;
break;
}
}
}
process_current = old_current;
}
/*---------------------------------------------------------------------------*/
static void
do_poll(void)
{
struct process *p;
poll_requested = 0;
/* Call the processes that needs to be polled. */
for(p = process_list; p != NULL; p = p->next) {
if(p->needspoll) {
p->state = PROCESS_STATE_RUNNING;
p->needspoll = 0;
call_process(p, PROCESS_EVENT_POLL, NULL);
}
}
}
/*Should not used in interrupt*/
RAW_U16 process_post_synch(struct process *p, process_event_t ev, process_data_t data)
{
struct process *caller = process_current;
if (raw_int_nesting) {
return RAW_NOT_CALLED_BY_ISR;
}
call_process(p, ev, data);
process_current = caller;
return RAW_SUCCESS;
}
static void do_poll(void)
{
struct process *p;
RAW_SR_ALLOC();
RAW_CRITICAL_ENTER();
poll_requested--;
RAW_CRITICAL_EXIT();
/* Call the processes that needs to be polled. */
for(p = process_list; p != 0; p = p->next) {
if(p->needspoll) {
p->state = PROCESS_STATE_RUNNING;
p->needspoll = 0;
call_process(p, PROCESS_EVENT_POLL, 0);
}
}
}
static void run_graph(MSFilter *f, MSTicker *s, MSList **unschedulable, bool_t force_schedule){
int i;
MSQueue *l;
if (f->last_tick!=s->ticks ){
if (filter_can_process(f,s->ticks) || force_schedule) {
/* this is a candidate */
f->last_tick=s->ticks;
call_process(f);
/* now recurse to next filters */
for(i=0;i<f->desc->noutputs;i++){
l=f->outputs[i];
if (l!=NULL){
run_graph(l->next.filter,s,unschedulable, force_schedule);
}
}
}else{
/* this filter has not all inputs that have been filled by filters before it. */
*unschedulable=ms_list_prepend(*unschedulable,f);
}
}
}
image_ptr process(cell_ptr& l)
{
return call_process(l, process_indices());
}