Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 37 → Rev 38

/shark/trunk/kernel/sleep.c
File deleted
/shark/trunk/kernel/endcycle.c
File deleted
/shark/trunk/kernel/kernold.s
File deleted
/shark/trunk/kernel/create.c
File deleted
/shark/trunk/kernel/exchtxt.c
File deleted
/shark/trunk/kernel/status.c
File deleted
/shark/trunk/kernel/exchgrx.c
File deleted
/shark/trunk/kernel/int_sem.c
18,11 → 18,11
 
/**
------------
CVS : $Id: int_sem.c,v 1.2 2002-11-11 08:34:08 pj Exp $
CVS : $Id: int_sem.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:34:08 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
Internal semaphores.
86,23 → 86,13
}
else { /* We must block exec task */
LEVEL l; /* for readableness only */
TIME tx; /* a dummy TIME for timespec operations */
struct timespec ty; /* a dummy timespec for timespec operations */
 
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);
 
/* we insert the task in the semaphore queue */
proc_table[exec_shadow].status = INTERNAL_SEM_WAIT;
150,7 → 140,7
 
p = iq_getfirst(&s->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
 
scheduler();
}
/shark/trunk/kernel/activate.c
18,11 → 18,11
 
/**
------------
CVS : $Id: activate.c,v 1.2 2002-10-28 07:58:19 pj Exp $
CVS : $Id: activate.c,v 1.3 2003-01-07 17:07:48 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-10-28 07:58:19 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:48 $
------------
 
task_activate & group_activate
91,7 → 91,7
proc_table[p].frozen_activations++;
else {
l = proc_table[p].task_level;
level_table[l]->task_activate(l,p);
level_table[l]->public_activate(l,p);
}
kern_frestore(f);
return 0;
106,7 → 106,7
proc_table[p].frozen_activations++;
else {
l = proc_table[p].task_level;
level_table[l]->task_activate(l,p);
level_table[l]->public_activate(l,p);
event_need_reschedule();
}
kern_frestore(f);
120,7 → 120,7
/* tracer stuff */
trc_logevent(TRC_ACTIVATE,&p);
l = proc_table[p].task_level;
level_table[l]->task_activate(l,p);
level_table[l]->public_activate(l,p);
/* Preempt if necessary */
scheduler();
162,7 → 162,7
/* tracer stuff */
trc_logevent(TRC_ACTIVATE,&i);
l = proc_table[i].task_level;
level_table[l]->task_activate(l,i);
level_table[l]->public_activate(l,i);
}
 
kern_frestore(f);
181,7 → 181,7
/* tracer stuff */
trc_logevent(TRC_ACTIVATE,&i);
l = proc_table[i].task_level;
level_table[l]->task_activate(l,i);
level_table[l]->public_activate(l,i);
}
event_need_reschedule();
kern_frestore(f);
196,7 → 196,7
continue;
}
l = proc_table[i].task_level;
level_table[l]->task_activate(l,i);
level_table[l]->public_activate(l,i);
/* tracer stuff */
trc_logevent(TRC_ACTIVATE,&i);
}
/shark/trunk/kernel/mqueue.c
18,11 → 18,11
 
/**
------------
CVS : $Id: mqueue.c,v 1.2 2002-11-11 08:34:09 pj Exp $
CVS : $Id: mqueue.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:34:09 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
POSIX message queues
325,7 → 325,7
/* 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;
}
339,7 → 339,7
/* 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;
}
362,7 → 362,7
/* 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;
}
378,7 → 378,7
/* 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,19 → 445,10
 
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;
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,19 → 600,10
 
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;
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();
/shark/trunk/kernel/mutex.c
18,11 → 18,11
 
/**
------------
CVS : $Id: mutex.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: mutex.c,v 1.2 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.2 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains the mutex and condition variables handling functions.
89,7 → 89,7
int mutex_init(mutex_t *mutex, const mutexattr_t *attr)
{
RLEVEL l;
int result = (EINVAL);
int result;
 
kern_cli();
mutex->mutexlevel = -1;
101,14 → 101,13
mutex_resource_des *m = (mutex_resource_des *)resource_table[l];
 
/* can the mutex level manage the mutexattr_t ? */
if (m->level_accept_mutexattr(l,attr) >=0) {
result = m->init(l, mutex, attr);
}
if ((result = m->init(l, mutex, attr)) >=0)
return result;
}
}
kern_sti();
 
return result;
return EINVAL;
}
 
 
/shark/trunk/kernel/init.c
18,24 → 18,16
 
/**
------------
CVS : $Id: init.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: init.c,v 1.2 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
Kernel module registration and miscellaneous functions
- Kernel module registration functions
- miscellaneous functions related to module registration, system init and end
 
This file contains:
 
level_alloc_descriptor
resource_alloc_descriptor
__compute_args__
__call_main__
sys_atinit
sys_atexit
 
**/
 
/*
72,6 → 64,10
#include <kernel/var.h>
#include <kernel/func.h>
 
/***********************************************************************
* Runlevel management
***********************************************************************/
 
/*+ List of function to call at each rnlevel;
they are posted with sys_atrunlevel +*/
static struct exit_func {
199,23 → 195,177
return 0;
}
 
/***********************************************************************
* Level Default Descriptor
***********************************************************************/
 
static void level_excfunc(LEVEL l)
{
printk(KERN_EMERG "unreg scheduling function called, level=%d!\n", l);
kern_raise(XINVALID_TASK, exec_shadow);
}
 
static int level_return1(void) { return 1; }
static int level_returnminus1(void) { return -1; }
static void level_nothing(void) { }
static int level_return0(void) { return 0; }
 
static level_des level_default_descriptor =
{
(void (*)(LEVEL,PID,TASK_MODEL *))level_excfunc, /* private_insert */
(void (*)(LEVEL,PID)) level_excfunc, /* private_extract */
(int (*)(LEVEL,PID)) level_return0, /* private_eligible */
(void (*)(LEVEL,PID, int)) level_excfunc, /* private_dispatch */
(void (*)(LEVEL,PID)) level_excfunc, /* private_epilogue */
(PID (*)(LEVEL)) level_returnminus1, /* pubvlic_scheduler */
(int (*)(LEVEL,bandwidth_t *)) level_return1, /* public_guarantee */
(int (*)(LEVEL,PID,TASK_MODEL *))level_returnminus1, /* public_create */
(void (*)(LEVEL,PID)) level_nothing, /* public_detach */
(void (*)(LEVEL,PID)) level_excfunc, /* public_end */
(int (*)(LEVEL,PID)) level_return0, /* public_eligible */
(void (*)(LEVEL,PID, int)) level_excfunc, /* public_dispatch */
(void (*)(LEVEL,PID)) level_excfunc, /* public_epilogue */
(void (*)(LEVEL,PID)) level_excfunc, /* public_activate */
(void (*)(LEVEL,PID)) level_excfunc, /* public_unblock */
(void (*)(LEVEL,PID)) level_excfunc, /* public_block */
(int (*)(LEVEL,PID,void *)) level_excfunc, /* public_message */
};
 
 
/***********************************************************************
* Module registration
***********************************************************************/
 
/* this function initializes all the data structures used by the level
registration functions */
void levels_init(void)
{
int l;
for (l=0; l<MAX_SCHED_LEVEL; l++) {
level_table[l] = &level_default_descriptor;
level_used[l] = 0;
level_next[l] = l+1;
level_prev[l] = l-1;
}
 
level_next[MAX_SCHED_LEVEL-1l] = -1;
level_prev[0] = -1;
level_first = -1;
level_last = -1;
level_free = 0;
}
 
/*+ This function returns a level_des **. the value returned shall be
used to register a level module. The function shall be called only at
module registration time. It assume that the system is not yet
initialized, so we shall not call sys_abort... +*/
LEVEL level_alloc_descriptor()
used to register a level module.
 
The function is usually called at module registration time. The
function can also be called when the system is already started, to
allow the implementation of dynamic module registration.
 
The argument must be the size of the data block that have to be allocated
 
The function returns the number of the descriptor allocated for the module
or -1 in case there are no free descriptors.
 
The function also reserves a descriptor with size s, initialized
with default function pointers.
 
+*/
LEVEL level_alloc_descriptor(size_t s)
{
if (sched_levels == MAX_SCHED_LEVEL)
{
printk("Too many scheduling levels!!!\n");
l1_exit(1);
LEVEL l;
/* try to find a free descriptor */
if (level_free == -1)
return -1;
 
/* alloc it */
l = level_free;
level_free = level_next[l];
 
level_used[l] = 1;
 
/* insert the module as the last in the scheduling module's list */
if (level_last == -1) {
level_first = l;
level_prev[l] = -1;
}
else {
level_next[level_last] = l;
level_prev[l] = level_last;
}
level_last = l;
level_next[l] = -1;
 
return sched_levels++;
/* allocate the descriptor! */
if (s < sizeof(level_des))
s = sizeof(level_des);
 
level_table[l] = (level_des *)kern_alloc(s);
 
*(level_table[l]) = level_default_descriptor;
 
level_size[l] = s;
 
/* return the descriptor index */
return l;
}
 
 
/*+ This function release a level descriptor previously allocated using
level_alloc_descriptor().
 
The function returns 0 if the level has been freed, or -1 if someone is
using it, -2 if the level has never been registered.
 
+*/
int level_free_descriptor(LEVEL l)
{
if (level_used[l] == 0)
return -2;
else if (level_used[l] > 1)
return -1;
 
/* we can free the descriptor */
level_used[l] = 0;
 
/* remove it from the "first" queue */
if (level_prev[l] == -1)
level_first = level_next[l];
else
level_next[level_prev[l]] = level_next[l];
if (level_next[l] == -1)
level_last = level_prev[l];
else
level_prev[level_next[l]] = level_prev[l];
/* ... and put it in the free queue */
level_prev[level_free] = l;
level_next[l] = level_free;
level_free = l;
 
/* finally, free the memory allocated to it */
kern_free(level_table[l], level_size[l]);
 
return 0;
}
 
/* Call this if you want to say that your module is using module l
(e.g., for calling its private functions) */
int level_use_descriptor(LEVEL l)
{
return ++level_used[l];
}
 
/* Call this when you no more need the module l */
int level_unuse_descriptor(LEVEL l)
{
return --level_used[l];
}
 
 
/*+ This function returns a resource_des **. the value returned shall be
used to register a resource module. The function shall be called only at
module registration time. It assume that the system is not yet
225,12 → 375,17
if (res_levels == MAX_RES_LEVEL)
{
printk("Too many resource levels!!!\n");
l1_exit(1);
sys_end();
}
 
return res_levels++;
}
 
 
/***********************************************************************
* Parameter parsing (argc, argv)
***********************************************************************/
 
/*+ This function compute the command line parameters from the multiboot_info
NOTE: this function modify the multiboot struct, so this function and
__call_main__ are mutually exclusives!!! +*/
/shark/trunk/kernel/conditio.c
20,11 → 20,11
 
/**
------------
CVS : $Id: conditio.c,v 1.2 2002-11-11 08:34:08 pj Exp $
CVS : $Id: conditio.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:34:08 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains the condition variables handling functions.
83,7 → 83,7
proc_table[i].cond_waiting = NULL;
 
l = proc_table[i].task_level;
level_table[l]->task_insert(l,i);
level_table[l]->public_unblock(l,i);
/* then, the kill_request flag is set, and when the task is rescheduled
it autokill itself... */
 
129,7 → 129,7
p = iq_getfirst(&cond->waiters);
 
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
 
scheduler();
}
150,7 → 150,7
p = iq_getfirst(&cond->waiters);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
} while(!iq_isempty(&cond->waiters));
 
scheduler();
162,8 → 162,6
int cond_wait(cond_t *cond, mutex_t *mutex)
{
LEVEL l;
struct timespec ty;
TIME tx;
 
/* Why I used task_nopreempt???... because we have to unlock the mutex,
and we can't call mutex_unlock after kern_context_save (the unlock
200,19 → 198,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);
 
/* we insert the task in the condition queue */
proc_table[exec_shadow].status = WAIT_COND;
278,7 → 267,7
proc_table[p].delay_timer = -1;
 
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
 
event_need_reschedule();
}
288,8 → 277,6
{
LEVEL l;
int returnvalue = 0;
struct timespec ty;
TIME tx;
 
/* Why I used task_nopreempt???... because we have to unlock the mutex,
and we can't call mutex_unlock after kern_context_save (the unlock
326,19 → 313,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);
 
/* we insert the task in the condition queue */
proc_table[exec_shadow].status = WAIT_COND;
361,7 → 339,7
ll_context_to(proc_table[exec_shadow].context);
 
if (proc_table[exec_shadow].delay_timer != -1)
event_delete(proc_table[exec_shadow].delay_timer);
kern_event_delete(proc_table[exec_shadow].delay_timer);
 
kern_sti();
 
/shark/trunk/kernel/nanoslp.c
18,11 → 18,11
 
/**
------------
CVS : $Id: nanoslp.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: nanoslp.c,v 1.2 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.2 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains the nanosleep function (posix 14.2.5) and related
82,13 → 82,13
/* the task that have to be killed is waiting on a nanosleep */
 
/* the nanosleep event have to be removed */
event_delete(proc_table[i].delay_timer);
kern_event_delete(proc_table[i].delay_timer);
proc_table[i].delay_timer = -1;
 
/* 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;
}
104,18 → 104,18
if (proc_table[i].status == WAIT_NANOSLEEP) {
/* the task is waiting on a nanosleep and it is still receiving a
signal... */
ll_gettime(TIME_EXACT,&t1);
kern_gettime(&t1);
SUBTIMESPEC(&nanosleep_table[i], &t1, &t2);
TIMESPEC_ASSIGN(&nanosleep_table[i], &t2);
 
/* the nanosleep event have to be removed */
event_delete(proc_table[i].delay_timer);
kern_event_delete(proc_table[i].delay_timer);
proc_table[i].delay_timer = -1;
 
/* 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;
}
133,7 → 133,7
proc_table[p].delay_timer = -1;
 
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
 
event_need_reschedule();
}
141,8 → 141,6
 
int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
{
struct timespec ty;
TIME tx;
LEVEL l;
 
if (rqtp->tv_sec < 0 || rqtp->tv_nsec > 1000000000)
158,20 → 156,11
register_interruptable_point(nanosleep_interrupted_by_signal, NULL);
}
 
/* 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();
 
/* now, we block the current task, waiting the end of the target task */
l = proc_table[exec_shadow].task_level;
level_table[l]->task_extract(l,exec_shadow);
level_table[l]->public_block(l,exec_shadow);
proc_table[exec_shadow].status = WAIT_NANOSLEEP;
 
ADDTIMESPEC(&schedule_time, rqtp, &nanosleep_table[exec_shadow]);
/shark/trunk/kernel/modules/edf.c
20,11 → 20,11
 
/**
------------
CVS : $Id: edf.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: edf.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the scheduling module EDF (Earliest Deadline First)
34,7 → 34,7
**/
 
/*
* Copyright (C) 2000 Paolo Gai
* Copyright (C) 2000,2002 Paolo Gai
*
* 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
62,8 → 62,8
#include <kernel/func.h>
#include <kernel/trace.h>
 
//#define edf_printf kern_printf
#define edf_printf printk
//#define EDFDEBUG
#define edf_printf kern_printf
 
/*+ Status used in the level +*/
#define EDF_READY MODULE_STATUS_BASE /*+ - Ready status +*/
98,21 → 98,6
} EDF_level_des;
 
 
static char *EDF_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case EDF_READY : return "EDF_Ready";
case EDF_WCET_VIOLATED: return "EDF_Wcet_Violated";
case EDF_WAIT : return "EDF_Sporadic_Wait";
case EDF_IDLE : return "EDF_Idle";
case EDF_ZOMBIE : return "EDF_Zombie";
default : return "EDF_Unknown";
}
}
 
static void EDF_timer_deadline(void *par)
{
PID p = (PID) par;
119,7 → 104,9
EDF_level_des *lev;
struct timespec *temp;
 
#ifdef EDFDEBUG
edf_printf("$");
#endif
 
lev = (EDF_level_des *)level_table[proc_table[p].task_level];
 
137,8 → 124,6
trc_logevent(TRC_INTACTIVATION,&p);
/* similar to EDF_task_activate */
temp = iq_query_timespec(p,&lev->ready);
TIMESPEC_ASSIGN(&proc_table[p].request_time,
temp);
ADDUSEC2TIMESPEC(lev->period[p], temp);
proc_table[p].status = EDF_READY;
iq_timespec_insert(p,&lev->ready);
145,10 → 130,10
lev->deadline_timer[p] = kern_event_post(temp,
EDF_timer_deadline,
(void *)p);
#ifdef EDFDEBUG
edf_printf("(dline p%d ev%d %d.%d)",(int)p,(int)lev->deadline_timer[p],(int)temp->tv_sec,(int)temp->tv_nsec/1000);
//printk("(d%d idle priority set to %d)",p,proc_table[p].priority );
#endif
event_need_reschedule();
printk("el%d|",p);
break;
 
case EDF_WAIT:
158,8 → 143,10
 
default:
/* else, a deadline miss occurred!!! */
#ifdef EDFDEBUG
edf_printf("\nstatus %d\n", (int)proc_table[p].status);
edf_printf("timer_deadline:AAARRRGGGHHH!!!");
#endif
kern_raise(XDEADLINE_MISS,p);
}
}
168,99 → 155,26
{
PID p = (PID) par;
 
#ifdef EDFDEBUG
edf_printf("AAARRRGGGHHH!!!");
#endif
kern_raise(XDEADLINE_MISS,p);
}
 
static int EDF_level_accept_task_model(LEVEL l, TASK_MODEL *m)
/* The scheduler only gets the first task in the queue */
static PID EDF_public_scheduler(LEVEL l)
{
if (m->pclass == HARD_PCLASS || m->pclass == (HARD_PCLASS | l)) {
HARD_TASK_MODEL *h = (HARD_TASK_MODEL *)m;
 
if (h->wcet && h->mit)
return 0;
}
 
return -1;
}
 
static int EDF_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == JOB_PCLASS || m->pclass == (JOB_PCLASS | l))
return 0;
else
return -1;
}
 
 
static char *onoff(int i)
{
if (i)
return "On ";
else
return "Off";
}
 
static void EDF_level_status(LEVEL l)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->ready);
 
kern_printf("Wcet Check : %s\n",
onoff(lev->flags & EDF_ENABLE_WCET_CHECK));
kern_printf("On-line guarantee : %s\n",
onoff(lev->flags & EDF_ENABLE_GUARANTEE));
kern_printf("Used Bandwidth : %u/%u\n",
lev->U, MAX_BANDWIDTH);
#ifdef EDFDEBUG
edf_printf("(s%d)", iq_query_first(&lev->ready));
#endif
 
while (p != NIL) {
if ((proc_table[p].pclass) == JOB_PCLASS)
kern_printf("Pid: %2d (GUEST)\n", p);
else
kern_printf("Pid: %2d Name: %10s %s: %9ld Dline: %9ld.%6ld Stat: %s\n",
p,
proc_table[p].name,
lev->flag[p] & EDF_FLAG_SPORADIC ? "MinITime" : "Period ",
lev->period[p],
iq_query_timespec(p, &lev->ready)->tv_sec,
iq_query_timespec(p, &lev->ready)->tv_nsec/1000,
EDF_status_to_a(proc_table[p].status));
p = iq_query_next(p, &lev->ready);
}
 
for (p=0; p<MAX_PROC; p++)
if (proc_table[p].task_level == l && proc_table[p].status != EDF_READY
&& proc_table[p].status != FREE )
kern_printf("Pid: %2d Name: %10s %s: %9ld Dline: %9ld.%6ld Stat: %s\n",
p,
proc_table[p].name,
lev->flag[p] & EDF_FLAG_SPORADIC ? "MinITime" : "Period ",
lev->period[p],
iq_query_timespec(p, &lev->ready)->tv_sec,
iq_query_timespec(p, &lev->ready)->tv_nsec/1000,
EDF_status_to_a(proc_table[p].status));
}
 
/* The scheduler only gets the first task in the queue */
static PID EDF_level_scheduler(LEVEL l)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
/* { // print 4 dbg the ready queue
PID p= lev->ready;
kern_printf("(s");
while (p != NIL) {
kern_printf("%d ",p);
p = proc_table[p].next;
}
kern_printf(") ");
}
*/
return iq_query_first(&lev->ready);
}
 
/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int EDF_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int EDF_public_guarantee(LEVEL l, bandwidth_t *freebandwidth)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
278,14 → 192,20
 
}
 
static int EDF_task_create(LEVEL l, PID p, TASK_MODEL *m)
static int EDF_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
HARD_TASK_MODEL *h;
 
/* if the EDF_task_create is called, then the pclass must be a
valid pclass. */
if (m->pclass != HARD_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
h = (HARD_TASK_MODEL *)m;
if (!h->wcet || !h->mit) return -1;
/* now we know that m is a valid model */
 
HARD_TASK_MODEL *h = (HARD_TASK_MODEL *)m;
#ifdef EDFDEBUG
edf_printf("(cr%d)", p);
#endif
 
lev->period[p] = h->mit;
 
329,7 → 249,7
return 0; /* OK, also if the task cannot be guaranteed... */
}
 
static void EDF_task_detach(LEVEL l, PID p)
static void EDF_public_detach(LEVEL l, PID p)
{
/* the EDF level doesn't introduce any dinamic allocated new field.
we have only to reset the NO_GUARANTEE FIELD and decrement the allocated
337,6 → 257,10
 
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
#ifdef EDFDEBUG
edf_printf("(det%d)", p);
#endif
 
if (lev->flags & EDF_FAILED_GUARANTEE)
lev->flags &= ~EDF_FAILED_GUARANTEE;
else
343,16 → 267,13
lev->U -= (MAX_BANDWIDTH / lev->period[p]) * proc_table[p].wcet;
}
 
static int EDF_task_eligible(LEVEL l, PID p)
static void EDF_public_dispatch(LEVEL l, PID p, int nostop)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void EDF_task_dispatch(LEVEL l, PID p, int nostop)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
#ifdef EDFDEBUG
edf_printf("(disp p%d %d.%d)",(int)p,(int)schedule_time.tv_sec,(int)schedule_time.tv_nsec/1000);
#endif
 
/* the task state is set EXE by the scheduler()
we extract the task from the ready queue
360,11 → 281,13
iq_extract(p, &lev->ready);
}
 
static void EDF_task_epilogue(LEVEL l, PID p)
static void EDF_public_epilogue(LEVEL l, PID p)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
#ifdef EDFDEBUG
edf_printf("(epil p%d %d.%d)",p,(int)schedule_time.tv_sec,(int)schedule_time.tv_nsec/1000);
#endif
 
/* check if the wcet is finished... */
if ((lev->flags & EDF_ENABLE_WCET_CHECK) && proc_table[p].avail_time <= 0) {
379,11 → 302,15
}
}
 
static void EDF_task_activate(LEVEL l, PID p)
static void EDF_public_activate(LEVEL l, PID p)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
struct timespec *temp;
 
#ifdef EDFDEBUG
edf_printf("(act%d)", p);
#endif
 
if (proc_table[p].status == EDF_WAIT) {
kern_raise(XACTIVATION,p);
return;
397,10 → 324,8
 
 
/* see also EDF_timer_deadline */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
 
temp = iq_query_timespec(p, &lev->ready);
TIMESPEC_ASSIGN(temp, &proc_table[p].request_time);
kern_gettime(temp);
ADDUSEC2TIMESPEC(lev->period[p], temp);
 
/* Insert task in the correct position */
411,15 → 336,17
lev->deadline_timer[p] = kern_event_post(temp,
EDF_timer_deadline,
(void *)p);
#ifdef EDFDEBUG
edf_printf("(dline p%d ev%d %d.%d)",p,(int)lev->deadline_timer[p],(int)temp->tv_sec,(int)temp->tv_nsec/1000);
#endif
}
 
static void EDF_task_insert(LEVEL l, PID p)
static void EDF_public_unblock(LEVEL l, PID p)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
/* Similar to EDF_task_activate, but we don't check in what state
the task is and we don't set the request_time*/
/* Similar to EDF_task_activate,
but we don't check in what state the task is */
 
/* Insert task in the coEDFect position */
proc_table[p].status = EDF_READY;
426,7 → 353,7
iq_timespec_insert(p,&lev->ready);
}
 
static void EDF_task_extract(LEVEL l, PID p)
static void EDF_public_block(LEVEL l, PID p)
{
/* Extract the running task from the level
. we have already extract it from the ready queue at the dispatch time.
439,30 → 366,35
*/
}
 
static void EDF_task_endcycle(LEVEL l, PID p)
static int EDF_public_message(LEVEL l, PID p, void *m)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
#ifdef EDFDEBUG
edf_printf("(ecyc p%d %d.%d)",p,(int)schedule_time.tv_sec,(int)schedule_time.tv_nsec/1000);
#endif
 
/* the task has terminated his job before it consume the wcet. All OK! */
if (lev->flag[p] & EDF_FLAG_SPORADIC)
if (!lev->flag[p] & EDF_FLAG_SPORADIC)
proc_table[p].status = EDF_IDLE;
else
proc_table[p].status = EDF_WAIT;
else /* pclass = sporadic_pclass */
proc_table[p].status = EDF_IDLE;
 
/* we reset the capacity counters... */
if (lev->flags & EDF_ENABLE_WCET_CHECK)
proc_table[p].avail_time = proc_table[p].wcet;
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
/* when the deadline timer fire, it recognize the situation and set
correctly all the stuffs (like reactivation, request_time, etc... ) */
correctly all the stuffs (like reactivation, sleep, etc... ) */
 
return 0;
}
 
static void EDF_task_end(LEVEL l, PID p)
static void EDF_public_end(LEVEL l, PID p)
{
// EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
proc_table[p].status = EDF_ZOMBIE;
 
/* When the deadline timer fire, it put the task descriptor in
469,60 → 401,40
the free queue, and free the allocated bandwidth... */
}
 
static void EDF_task_sleep(LEVEL l, PID p)
static void EDF_private_insert(LEVEL l, PID p, TASK_MODEL *m)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
JOB_TASK_MODEL *job;
 
/* the task has terminated his job before it consume the wcet. All OK! */
proc_table[p].status = EDF_WAIT;
if (m->pclass != JOB_PCLASS || (m->level != 0 && m->level != l) ) {
kern_raise(XINVALID_TASK, p);
return;
}
 
/* we reset the capacity counters... */
if (lev->flags & EDF_ENABLE_WCET_CHECK)
proc_table[p].avail_time = proc_table[p].wcet;
job = (JOB_TASK_MODEL *)m;
 
/* when the deadline timer fire, it recognize the situation and set
correctly the task state to sleep... */
}
 
 
/* Guest Functions
These functions manages a JOB_TASK_MODEL, that is used to put
a guest task in the EDF ready queue. */
 
static int EDF_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
JOB_TASK_MODEL *job = (JOB_TASK_MODEL *)m;
 
/* if the EDF_guest_create is called, then the pclass must be a
valid pclass. */
 
/* Insert task in the correct position */
*iq_query_timespec(p, &lev->ready) = job->deadline;
iq_timespec_insert(p,&lev->ready);
proc_table[p].status = EDF_READY;
lev->deadline_timer[p] = -1;
 
if (job->noraiseexc)
lev->period[p] = job->period;
 
/* Set the deadline timer */
if (!(job->noraiseexc))
lev->flag[p] = EDF_FLAG_NORAISEEXC;
else
else {
lev->flag[p] = 0;
 
lev->period[p] = job->period;
 
/* there is no bandwidth guarantee at this level, it is performed
by the level that inserts guest tasks... */
 
return 0; /* OK, also if the task cannot be guaranteed... */
lev->deadline_timer[p] = kern_event_post(iq_query_timespec(p, &lev->ready),
EDF_timer_guest_deadline,
(void *)p);
}
}
 
static void EDF_guest_detach(LEVEL l, PID p)
static void EDF_private_dispatch(LEVEL l, PID p, int nostop)
{
/* the EDF level doesn't introduce any dinamic allocated new field.
No guarantee is performed on guest tasks... so we don't have to reset
the NO_GUARANTEE FIELD */
}
 
static void EDF_guest_dispatch(LEVEL l, PID p, int nostop)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
/* the task state is set to EXE by the scheduler()
531,7 → 443,7
iq_extract(p, &lev->ready);
}
 
static void EDF_guest_epilogue(LEVEL l, PID p)
static void EDF_private_epilogue(LEVEL l, PID p)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
540,75 → 452,30
proc_table[p].status = EDF_READY;
}
 
static void EDF_guest_activate(LEVEL l, PID p)
static void EDF_private_extract(LEVEL l, PID p)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
/* Insert task in the correct position */
iq_timespec_insert(p,&lev->ready);
proc_table[p].status = EDF_READY;
 
/* Set the deadline timer */
if (!(lev->flag[p] & EDF_FLAG_NORAISEEXC))
lev->deadline_timer[p] = kern_event_post(iq_query_timespec(p, &lev->ready),
EDF_timer_guest_deadline,
(void *)p);
 
}
 
static void EDF_guest_insert(LEVEL l, PID p)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
/* Insert task in the correct position */
iq_timespec_insert(p,&lev->ready);
proc_table[p].status = EDF_READY;
}
 
static void EDF_guest_extract(LEVEL l, PID p)
{
/* Extract the running task from the level
. we have already extract it from the ready queue at the dispatch time.
. the state of the task is set by the calling function
. the deadline must remain...
 
So, we do nothing!!!
*/
}
 
static void EDF_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void EDF_guest_end(LEVEL l, PID p)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
 
//kern_printf("EDF_guest_end: dline timer %d\n",lev->deadline_timer[p]);
#ifdef EDFDEBUG
edf_printf("EDF_guest_end: dline timer %d\n",lev->deadline_timer[p]);
#endif
if (proc_table[p].status == EDF_READY)
{
iq_extract(p, &lev->ready);
//kern_printf("(g_end rdy extr)");
}
 
/* we remove the deadline timer, because the slice is finished */
if (lev->deadline_timer[p] != NIL) {
// kern_printf("EDF_guest_end: dline timer %d\n",lev->deadline_timer[p]);
event_delete(lev->deadline_timer[p]);
kern_event_delete(lev->deadline_timer[p]);
lev->deadline_timer[p] = NIL;
}
 
}
 
static void EDF_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
 
/* Registration functions */
 
/*+ Registration function:
int flags the init flags ... see edf.h +*/
void EDF_register_level(int flags)
LEVEL EDF_register_level(int flags)
{
LEVEL l; /* the level that we register */
EDF_level_des *lev; /* for readableness only */
617,56 → 484,34
printk("EDF_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(EDF_level_des));
 
printk(" alloco descrittore %d %d\n",l,(int)sizeof(EDF_level_des));
lev = (EDF_level_des *)level_table[l];
 
/* alloc the space needed for the EDF_level_des */
lev = (EDF_level_des *)kern_alloc(sizeof(EDF_level_des));
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, EDF_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = EDF_LEVEL_CODE;
lev->l.level_version = EDF_LEVEL_VERSION;
lev->l.private_insert = EDF_private_insert;
lev->l.private_extract = EDF_private_extract;
lev->l.private_dispatch = EDF_private_dispatch;
lev->l.private_epilogue = EDF_private_epilogue;
 
lev->l.level_accept_task_model = EDF_level_accept_task_model;
lev->l.level_accept_guest_model = EDF_level_accept_guest_model;
lev->l.level_status = EDF_level_status;
lev->l.level_scheduler = EDF_level_scheduler;
 
lev->l.public_scheduler = EDF_public_scheduler;
if (flags & EDF_ENABLE_GUARANTEE)
lev->l.level_guarantee = EDF_level_guarantee;
lev->l.public_guarantee = EDF_public_guarantee;
else
lev->l.level_guarantee = NULL;
lev->l.public_guarantee = NULL;
 
lev->l.task_create = EDF_task_create;
lev->l.task_detach = EDF_task_detach;
lev->l.task_eligible = EDF_task_eligible;
lev->l.task_dispatch = EDF_task_dispatch;
lev->l.task_epilogue = EDF_task_epilogue;
lev->l.task_activate = EDF_task_activate;
lev->l.task_insert = EDF_task_insert;
lev->l.task_extract = EDF_task_extract;
lev->l.task_endcycle = EDF_task_endcycle;
lev->l.task_end = EDF_task_end;
lev->l.task_sleep = EDF_task_sleep;
lev->l.public_create = EDF_public_create;
lev->l.public_detach = EDF_public_detach;
lev->l.public_end = EDF_public_end;
lev->l.public_dispatch = EDF_public_dispatch;
lev->l.public_epilogue = EDF_public_epilogue;
lev->l.public_activate = EDF_public_activate;
lev->l.public_unblock = EDF_public_unblock;
lev->l.public_block = EDF_public_block;
lev->l.public_message = EDF_public_message;
 
lev->l.guest_create = EDF_guest_create;
lev->l.guest_detach = EDF_guest_detach;
lev->l.guest_dispatch = EDF_guest_dispatch;
lev->l.guest_epilogue = EDF_guest_epilogue;
lev->l.guest_activate = EDF_guest_activate;
lev->l.guest_insert = EDF_guest_insert;
lev->l.guest_extract = EDF_guest_extract;
lev->l.guest_endcycle = EDF_guest_endcycle;
lev->l.guest_end = EDF_guest_end;
lev->l.guest_sleep = EDF_guest_sleep;
 
/* fill the EDF descriptor part */
for(i=0; i<MAX_PROC; i++) {
lev->period[i] = 0;
677,15 → 522,14
iq_init(&lev->ready, &freedesc, 0);
lev->flags = flags & 0x07;
lev->U = 0;
 
return l;
}
 
bandwidth_t EDF_usedbandwidth(LEVEL l)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
if (lev->l.level_code == EDF_LEVEL_CODE &&
lev->l.level_version == EDF_LEVEL_VERSION)
return lev->U;
else
return 0;
 
return lev->U;
}
 
/shark/trunk/kernel/modules/trace.c
38,11 → 38,11
*/
 
/*
* CVS : $Id: trace.c,v 1.2 2002-10-21 10:13:56 pj Exp $
* CVS : $Id: trace.c,v 1.3 2003-01-07 17:07:51 pj Exp $
*
* File: $File$
* Revision: $Revision: 1.2 $
* Last update: $Date: 2002-10-21 10:13:56 $
* Revision: $Revision: 1.3 $
* Last update: $Date: 2003-01-07 17:07:51 $
*/
 
#include <ll/sys/types.h>
313,7 → 313,7
evt=queue->get(queue->data);
if (evt!=NULL) {
evt->event=event;
evt->time=ll_gettime(TIME_EXACT,NULL);
evt->time=kern_gettime(NULL);
memcpy(&evt->x,ptr,sizeof(trc_allevents_t));
queue->post(queue->data);
}
/shark/trunk/kernel/modules/posix.c
20,11 → 20,11
 
/**
------------
CVS : $Id: posix.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: posix.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the scheduling module compatible with POSIX
63,6 → 63,7
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
/*+ Status used in the level +*/
#define POSIX_READY MODULE_STATUS_BASE
88,53 → 89,11
 
} POSIX_level_des;
 
static char *POSIX_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case POSIX_READY: return "POSIX_Ready";
default : return "POSIX_Unknown";
}
}
 
static int POSIX_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == NRT_PCLASS || m->pclass == (NRT_PCLASS | l))
return 0;
else
return -1;
}
 
static int POSIX_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
return -1;
}
 
static void POSIX_level_status(LEVEL l)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
PID p;
 
kern_printf("Slice: %d \n", lev->slice);
 
for (p=0; p<MAX_PROC; p++)
if (proc_table[p].task_level == l && proc_table[p].status != POSIX_READY
&& proc_table[p].status != FREE )
kern_printf("Pid: %d\t Name: %20s Prio: %3d Status: %s\n",
p,proc_table[p].name,
lev->priority[p],
POSIX_status_to_a(proc_table[p].status));
 
}
 
 
/* This is not efficient but very fair :-)
The need of all this stuff is because if a task execute a long time
due to (shadow!) priority inheritance, then the task shall go to the
tail of the queue many times... */
static PID POSIX_level_scheduler(LEVEL l)
static PID POSIX_public_scheduler(LEVEL l)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
166,19 → 125,15
}
}
 
static int POSIX_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int POSIX_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
/* the POSIX level always guarantee... the function is defined because
there can be an aperiodic server at a level with less priority than
the POSIX that need guarantee (e.g., a TBS server) */
return 1;
}
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
NRT_TASK_MODEL *nrt;
 
if (m->pclass != NRT_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
 
static int POSIX_task_create(LEVEL l, PID p, TASK_MODEL *m)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
NRT_TASK_MODEL *nrt = (NRT_TASK_MODEL *)m;
nrt = (NRT_TASK_MODEL *)m;
 
/* the task state is set at SLEEP by the general task_create */
 
223,20 → 178,8
return 0; /* OK */
}
 
static void POSIX_task_detach(LEVEL l, PID p)
static void POSIX_public_dispatch(LEVEL l, PID p, int nostop)
{
/* the POSIX level doesn't introduce any new field in the TASK_MODEL
so, all detach stuffs are done by the task_create
The task state is set at FREE by the general task_create */
}
 
static int POSIX_task_eligible(LEVEL l, PID p)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void POSIX_task_dispatch(LEVEL l, PID p, int nostop)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
/* the task state is set EXE by the scheduler()
245,7 → 188,7
iq_extract(p, &lev->ready[lev->priority[p]]);
}
 
static void POSIX_task_epilogue(LEVEL l, PID p)
static void POSIX_public_epilogue(LEVEL l, PID p)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
266,7 → 209,7
proc_table[p].status = POSIX_READY;
}
 
static void POSIX_task_activate(LEVEL l, PID p)
static void POSIX_public_activate(LEVEL l, PID p)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
278,19 → 221,17
return;
}
 
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
 
/* Insert task in the correct position */
proc_table[p].status = POSIX_READY;
iq_insertlast(p,&lev->ready[lev->priority[p]]);
}
 
static void POSIX_task_insert(LEVEL l, PID p)
static void POSIX_public_unblock(LEVEL l, PID p)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
/* Similar to POSIX_task_activate, but we don't check in what state
the task is and we don't set the request_time */
the task is */
 
/* Insert task in the coPOSIXect position */
proc_table[p].status = POSIX_READY;
297,7 → 238,7
iq_insertlast(p,&lev->ready[lev->priority[p]]);
}
 
static void POSIX_task_extract(LEVEL l, PID p)
static void POSIX_public_block(LEVEL l, PID p)
{
/* Extract the running task from the level
. we have already extract it from the ready queue at the dispatch time.
309,13 → 250,12
*/
}
 
static void POSIX_task_endcycle(LEVEL l, PID p)
static int POSIX_public_message(LEVEL l, PID p, void *m)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
if (lev->nact[p] > 0) {
/* continue!!!! */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
lev->nact[p]--;
iq_insertfirst(p,&lev->ready[lev->priority[p]]);
proc_table[p].status = POSIX_READY;
322,9 → 262,14
}
else
proc_table[p].status = SLEEP;
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
return 0;
}
 
static void POSIX_task_end(LEVEL l, PID p)
static void POSIX_public_end(LEVEL l, PID p)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
335,46 → 280,6
iq_priority_insert(p,&freedesc);
}
 
static void POSIX_task_sleep(LEVEL l, PID p)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
lev->nact[p] = 0;
proc_table[p].status = SLEEP;
}
 
 
 
static int POSIX_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void POSIX_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void POSIX_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void POSIX_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void POSIX_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void POSIX_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void POSIX_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void POSIX_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void POSIX_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void POSIX_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
/* Registration functions */
 
/*+ This init function install the "main" task +*/
405,7 → 310,7
if (p == NIL)
printk("\nPanic!!! can't create main task...\n");
 
POSIX_task_activate(lev,p);
POSIX_public_activate(lev,p);
}
 
 
413,7 → 318,7
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void POSIX_register_level(TIME slice,
LEVEL POSIX_register_level(TIME slice,
int createmain,
struct multiboot_info *mb,
int prioritylevels)
425,53 → 330,23
 
printk("POSIX_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(POSIX_level_des));
 
printk(" alloco descrittore %d %d\n",l,(int)sizeof(POSIX_level_des));
lev = (POSIX_level_des *)level_table[l];
 
/* alloc the space needed for the POSIX_level_des */
lev = (POSIX_level_des *)kern_alloc(sizeof(POSIX_level_des));
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, POSIX_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = POSIX_LEVEL_CODE;
lev->l.level_version = POSIX_LEVEL_VERSION;
lev->l.public_scheduler = POSIX_public_scheduler;
lev->l.public_create = POSIX_public_create;
lev->l.public_end = POSIX_public_end;
lev->l.public_dispatch = POSIX_public_dispatch;
lev->l.public_epilogue = POSIX_public_epilogue;
lev->l.public_activate = POSIX_public_activate;
lev->l.public_unblock = POSIX_public_unblock;
lev->l.public_block = POSIX_public_block;
lev->l.public_message = POSIX_public_message;
 
lev->l.level_accept_task_model = POSIX_level_accept_task_model;
lev->l.level_accept_guest_model = POSIX_level_accept_guest_model;
lev->l.level_status = POSIX_level_status;
lev->l.level_scheduler = POSIX_level_scheduler;
lev->l.level_guarantee = POSIX_level_guarantee;
 
lev->l.task_create = POSIX_task_create;
lev->l.task_detach = POSIX_task_detach;
lev->l.task_eligible = POSIX_task_eligible;
lev->l.task_dispatch = POSIX_task_dispatch;
lev->l.task_epilogue = POSIX_task_epilogue;
lev->l.task_activate = POSIX_task_activate;
lev->l.task_insert = POSIX_task_insert;
lev->l.task_extract = POSIX_task_extract;
lev->l.task_endcycle = POSIX_task_endcycle;
lev->l.task_end = POSIX_task_end;
lev->l.task_sleep = POSIX_task_sleep;
 
lev->l.guest_create = POSIX_guest_create;
lev->l.guest_detach = POSIX_guest_detach;
lev->l.guest_dispatch = POSIX_guest_dispatch;
lev->l.guest_epilogue = POSIX_guest_epilogue;
lev->l.guest_activate = POSIX_guest_activate;
lev->l.guest_insert = POSIX_guest_insert;
lev->l.guest_extract = POSIX_guest_extract;
lev->l.guest_endcycle = POSIX_guest_endcycle;
lev->l.guest_end = POSIX_guest_end;
lev->l.guest_sleep = POSIX_guest_sleep;
 
/* fill the POSIX descriptor part */
for (i = 0; i < MAX_PROC; i++)
lev->nact[i] = -1;
491,6 → 366,8
 
if (createmain)
sys_atrunlevel(POSIX_call_main,(void *) l, RUNLEVEL_INIT);
 
return l;
}
 
/*+ this function forces the running task to go to his queue tail;
499,13 → 376,6
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
if (l < 0 || l >= sched_levels)
return -1;
 
if (level_table[l]->level_code != POSIX_LEVEL_CODE ||
level_table[l]->level_version != POSIX_LEVEL_VERSION )
return -1;
 
if (proc_table[exec_shadow].task_level != l)
return -1;
 
536,13 → 406,6
returns ENOSYS or ESRCH if there are problems +*/
int POSIX_getschedparam(LEVEL l, PID p, int *policy, int *priority)
{
if (l < 0 || l >= sched_levels)
return ENOSYS;
 
if (level_table[l]->level_code != POSIX_LEVEL_CODE ||
level_table[l]->level_version != POSIX_LEVEL_VERSION )
return ENOSYS;
 
if (p<0 || p>= MAX_PROC || proc_table[p].status == FREE)
return ESRCH;
 
564,13 → 427,6
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
 
if (l < 0 || l >= sched_levels)
return ENOSYS;
 
if (level_table[l]->level_code != POSIX_LEVEL_CODE ||
level_table[l]->level_version != POSIX_LEVEL_VERSION )
return ENOSYS;
 
if (p<0 || p>= MAX_PROC || proc_table[p].status == FREE)
return ESRCH;
 
/shark/trunk/kernel/modules/pc.c
20,11 → 20,11
 
/**
------------
CVS : $Id: pc.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: pc.c,v 1.2 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
Priority Ceiling protocol. see pc.h for more details...
57,7 → 57,6
#include <ll/string.h>
#include <ll/stdio.h>
#include <kernel/const.h>
#include <modules/codes.h>
#include <sys/types.h>
#include <kernel/var.h>
#include <kernel/func.h>
153,7 → 152,7
}
 
 
 
#if 0
/*+ print resource protocol statistics...+*/
static void PC_resource_status(RLEVEL r)
{
172,23 → 171,24
// in the future: print the status of the blocked semaphores!
 
}
#endif
 
static int PC_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
PC_mutex_resource_des *m = (PC_mutex_resource_des *)(resource_table[l]);
PC_RES_MODEL *pc;
 
static int PC_level_accept_resource_model(RLEVEL l, RES_MODEL *r)
{
if (r->rclass == PC_RCLASS || r->rclass == (PC_RCLASS | l) )
return 0;
else
if (r->rclass != PC_RCLASS)
return -1;
}
if (r->level && r->level !=l)
return -1;
 
static void PC_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
PC_mutex_resource_des *m = (PC_mutex_resource_des *)(resource_table[l]);
PC_RES_MODEL *pc = (PC_RES_MODEL *)r;
pc = (PC_RES_MODEL *)r;
 
m->priority[p] = pc->priority;
m->nlocked[p] = 0;
 
return 0;
}
 
static void PC_res_detach(RLEVEL l, PID p)
203,18 → 203,13
m->priority[p] = MAX_DWORD;
}
 
static int PC_level_accept_mutexattr(RLEVEL l, const mutexattr_t *a)
{
if (a->mclass == PC_MCLASS || a->mclass == (PC_MCLASS | l) )
return 0;
else
return -1;
}
 
static int PC_init(RLEVEL l, mutex_t *m, const mutexattr_t *a)
{
PC_mutex_t *p;
 
if (a->mclass != PC_MCLASS)
return -1;
 
p = (PC_mutex_t *) kern_alloc(sizeof(PC_mutex_t));
 
/* control if there is enough memory; no control on init on a
403,7 → 398,7
return 0;
}
 
void PC_register_module(void)
RLEVEL PC_register_module(void)
{
RLEVEL l; /* the level that we register */
PC_mutex_resource_des *m; /* for readableness only */
421,20 → 416,11
resource_table[l] = (resource_des *)m;
 
/* fill the resource_des descriptor */
strncpy(m->m.r.res_name, PC_MODULENAME, MAX_MODULENAME);
m->m.r.res_code = PC_MODULE_CODE;
m->m.r.res_version = PC_MODULE_VERSION;
 
m->m.r.rtype = MUTEX_RTYPE;
 
m->m.r.resource_status = PC_resource_status;
m->m.r.level_accept_resource_model = PC_level_accept_resource_model;
m->m.r.res_register = PC_res_register;
 
m->m.r.res_detach = PC_res_detach;
 
/* fill the mutex_resource_des descriptor */
m->m.level_accept_mutexattr = PC_level_accept_mutexattr;
m->m.init = PC_init;
m->m.destroy = PC_destroy;
m->m.lock = PC_lock;
447,6 → 433,8
 
m->mlist = NULL;
 
return l;
 
}
 
/*+ This function gets the ceiling of a PC mutex, and it have to be called
461,11 → 449,6
 
r = resource_table[mutex->mutexlevel];
 
if (r->rtype != MUTEX_RTYPE ||
r->res_code != PC_MODULE_CODE ||
r->res_version != PC_MODULE_VERSION)
return -1;
 
if (ceiling)
*ceiling = ((PC_mutex_t *)mutex->opt)->ceiling;
else
486,11 → 469,6
 
r = resource_table[mutex->mutexlevel];
 
if (r->rtype != MUTEX_RTYPE ||
r->res_code != PC_MODULE_CODE ||
r->res_version != PC_MODULE_VERSION)
return -1;
 
if (old_ceiling)
*old_ceiling = ((PC_mutex_t *)mutex->opt)->ceiling;
 
/shark/trunk/kernel/modules/bd_edf.c
38,11 → 38,11
*/
 
/*
* CVS : $Id: bd_edf.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
* CVS : $Id: bd_edf.c,v 1.2 2003-01-07 17:07:50 pj Exp $
*
* File: $File$
* Revision: $Revision: 1.1.1.1 $
* Last update: $Date: 2002-03-29 14:12:52 $
* Revision: $Revision: 1.2 $
* Last update: $Date: 2003-01-07 17:07:50 $
*/
 
#include <modules/bd_edf.h>
51,7 → 51,6
#include <ll/string.h>
#include <ll/stdio.h>
#include <kernel/const.h>
#include <modules/codes.h>
#include <sys/types.h>
#include <kernel/var.h>
#include <kernel/func.h>
74,12 → 73,21
return -1;
}
 
static void res_register(RLEVEL l, PID p, RES_MODEL *r)
static int res_register(RLEVEL l, PID p, RES_MODEL *r)
{
bd_edf_resource_des *m=(bd_edf_resource_des*)(resource_table[l]);
BDEDF_RES_MODEL *rm=(BDEDF_RES_MODEL*)r;
BDEDF_RES_MODEL *rm;
 
if (r->rclass!=BDEDF_RCLASS)
return -1;
if (r->level && r->level !=l)
return -1;
rm=(BDEDF_RES_MODEL*)r;
assertk(mylevel==l);
m->dl[p]=rm->dl;
 
return 0;
}
 
static void res_detach(RLEVEL l, PID p)
89,10 → 97,7
m->dl[p]=0;
}
 
static void res_resource_status(void)
{}
 
void BD_EDF_register_module(void)
RLEVEL BD_EDF_register_module(void)
{
RLEVEL l;
bd_edf_resource_des *m;
108,12 → 113,7
resource_table[l]=(resource_des*)m;
 
/* fill the resource_des descriptor */
strcpy(m->rd.res_name,BDEDF_MODULENAME);
m->rd.res_code=BDEDF_MODULE_CODE;
m->rd.res_version=BDEDF_MODULE_VERSION;
m->rd.rtype=DEFAULT_RTYPE;
m->rd.resource_status=res_resource_status;
m->rd.level_accept_resource_model=res_level_accept_resource_model;
m->rd.res_register=res_register;
m->rd.res_detach=res_detach;
 
121,6 → 121,8
assertk(mylevel==-1);
mylevel=l;
 
return l;
}
 
TIME bd_edf_getdl(void)
/shark/trunk/kernel/modules/srp.c
20,11 → 20,11
 
/**
------------
CVS : $Id: srp.c,v 1.2 2002-10-28 07:55:55 pj Exp $
CVS : $Id: srp.c,v 1.3 2003-01-07 17:07:51 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-10-28 07:55:55 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:51 $
------------
 
Stack Resource Policy. see srp.h for general details...
141,7 → 141,6
#include <ll/string.h>
#include <ll/stdio.h>
#include <kernel/const.h>
#include <modules/codes.h>
#include <sys/types.h>
#include <kernel/descr.h>
#include <kernel/var.h>
385,27 → 384,14
}
 
 
/*+ print resource protocol statistics...+*/
static void SRP_resource_status(RLEVEL r)
static int SRP_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
kern_printf("SRP status not implemented yet");
}
SRP_mutex_resource_des *m = (SRP_mutex_resource_des *)(resource_table[l]);
 
 
static int SRP_level_accept_resource_model(RLEVEL l, RES_MODEL *r)
{
if (r->rclass == SRP_RCLASS || r->rclass == (SRP_RCLASS | l) ||
r->rclass == SRP2_RCLASS || r->rclass == (SRP2_RCLASS | l))
return 0;
else
if (r->level && r->level !=l)
return -1;
}
 
static void SRP_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
SRP_mutex_resource_des *m = (SRP_mutex_resource_des *)(resource_table[l]);
 
if (r->rclass == SRP_RCLASS || r->rclass == (SRP_RCLASS | l)) {
if (r->rclass == SRP_RCLASS) {
/* SRP_RES_MODEL resource model */
// kern_printf("!%d %d",((SRP_RES_MODEL *)r)->preempt,p);
 
429,14 → 415,15
}
 
m->nlocked[p] = 0;
return 0;
}
else {
else if (r->rclass == SRP2_RCLASS) {
/* a mutex passed via SRP_useres() */
SRP_mutex_t *mut = (SRP_mutex_t *)r;
 
if (mut->use[p])
/* the mutex is already registered, do nothing! */
return;
return -1;
 
/* register the mutex for the task */
mut->use[p] = 1;
449,7 → 436,10
mut->ceiling = m->proc_preempt[p].preempt;
 
}
return 0;
}
else
return -1;
}
 
static void SRP_res_detach(RLEVEL l, PID p)
488,14 → 478,6
SRP_extract_tasklist(m, p);
}
 
static int SRP_level_accept_mutexattr(RLEVEL l, const mutexattr_t *a)
{
if (a->mclass == SRP_MCLASS || a->mclass == (SRP_MCLASS | l) )
return 0;
else
return -1;
}
 
static int SRP_init(RLEVEL l, mutex_t *m, const mutexattr_t *a)
{
SRP_mutex_resource_des *lev = (SRP_mutex_resource_des *)(resource_table[l]);
502,6 → 484,9
SRP_mutex_t *p;
PID x;
 
if (a->mclass != SRP_MCLASS)
return -1;
 
p = (SRP_mutex_t *) kern_alloc(sizeof(SRP_mutex_t));
 
/* control if there is enough memory; no control on init on a
719,7 → 704,7
/* activate the task if it was activated while in lobby list! */
if (task_unblock_activation(x)) {
LEVEL sl = proc_table[x].task_level;
level_table[sl]->task_activate(sl,x);
level_table[sl]->public_activate(sl,x);
// kern_printf("activate it!!!");
}
}
736,7 → 721,7
return 0;
}
 
void SRP_register_module(void)
RLEVEL SRP_register_module(void)
{
RLEVEL l; /* the level that we register */
SRP_mutex_resource_des *m; /* for readableness only */
754,20 → 739,11
resource_table[l] = (resource_des *)m;
 
/* fill the resource_des descriptor */
strncpy(m->m.r.res_name, SRP_MODULENAME, MAX_MODULENAME);
m->m.r.res_code = SRP_MODULE_CODE;
m->m.r.res_version = SRP_MODULE_VERSION;
 
m->m.r.rtype = MUTEX_RTYPE;
 
m->m.r.resource_status = SRP_resource_status;
m->m.r.level_accept_resource_model = SRP_level_accept_resource_model;
m->m.r.res_register = SRP_res_register;
 
m->m.r.res_detach = SRP_res_detach;
 
/* fill the mutex_resource_des descriptor */
m->m.level_accept_mutexattr = SRP_level_accept_mutexattr;
m->m.init = SRP_init;
m->m.destroy = SRP_destroy;
m->m.lock = SRP_lock;
789,5 → 765,7
m->srpstack = NULL;
m->srprecalc = NULL;
m->srplist = NULL;
 
return l;
}
 
/shark/trunk/kernel/modules/rr2.c
20,11 → 20,11
 
/**
------------
CVS : $Id: rr2.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: rr2.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the scheduling module RR2 (Round Robin) version 2
60,6 → 60,7
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
/*+ Status used in the level +*/
#define RR2_READY MODULE_STATUS_BASE
79,57 → 80,11
} RR2_level_des;
 
 
static char *RR2_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case RR2_READY: return "RR2_Ready";
default : return "RR2_Unknown";
}
}
 
static int RR2_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == NRT_PCLASS || m->pclass == (NRT_PCLASS | l))
return 0;
else
return -1;
}
 
static int RR2_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
return -1;
}
 
static void RR2_level_status(LEVEL l)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->ready);
 
kern_printf("Slice: %d \n", lev->slice);
 
while (p != NIL) {
kern_printf("Pid: %d\t Name: %20s Status: %s\n",p,proc_table[p].name,
RR2_status_to_a(proc_table[p].status));
p = iq_query_next(p, &lev->ready);
}
 
for (p=0; p<MAX_PROC; p++)
if (proc_table[p].task_level == l && proc_table[p].status != RR2_READY
&& proc_table[p].status != FREE )
kern_printf("Pid: %d\t Name: %20s Status: %s\n",p,proc_table[p].name,
RR2_status_to_a(proc_table[p].status));
 
}
 
 
/* This is not efficient but very fair :-)
The need of all this stuff is because if a task execute a long time
due to (shadow!) priority inheritance, then the task shall go to the
tail of the queue many times... */
static PID RR2_level_scheduler(LEVEL l)
static PID RR2_public_scheduler(LEVEL l)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
 
150,20 → 105,15
}
}
 
static int RR2_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int RR2_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
/* the RR2 level always guarantee... the function is defined because
there can be an aperiodic server at a level with less priority than
the RR2 that need guarantee (e.g., a TBS server) */
return 1;
}
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
NRT_TASK_MODEL *nrt;
 
if (m->pclass != NRT_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
nrt = (NRT_TASK_MODEL *)m;
 
static int RR2_task_create(LEVEL l, PID p, TASK_MODEL *m)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
NRT_TASK_MODEL *nrt = (NRT_TASK_MODEL *)m;
 
/* the task state is set at SLEEP by the general task_create
the only thing to set remains the capacity stuffs that are set
to the values passed in the model... */
189,20 → 139,8
return 0; /* OK */
}
 
static void RR2_task_detach(LEVEL l, PID p)
static void RR2_public_dispatch(LEVEL l, PID p, int nostop)
{
/* the RR2 level doesn't introduce any new field in the TASK_MODEL
so, all detach stuffs are done by the task_create
The task state is set at FREE by the general task_create */
}
 
static int RR2_task_eligible(LEVEL l, PID p)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void RR2_task_dispatch(LEVEL l, PID p, int nostop)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
 
/* the task state is set EXE by the scheduler()
211,7 → 149,7
iq_extract(p, &lev->ready);
}
 
static void RR2_task_epilogue(LEVEL l, PID p)
static void RR2_public_epilogue(LEVEL l, PID p)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
 
228,7 → 166,7
proc_table[p].status = RR2_READY;
}
 
static void RR2_task_activate(LEVEL l, PID p)
static void RR2_public_activate(LEVEL l, PID p)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
 
240,19 → 178,17
return;
}
 
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
 
/* Insert task in the coRR2ect position */
proc_table[p].status = RR2_READY;
iq_insertlast(p,&lev->ready);
}
 
static void RR2_task_insert(LEVEL l, PID p)
static void RR2_public_unblock(LEVEL l, PID p)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
 
/* Similar to RR2_task_activate, but we don't check in what state
the task is and we don't set the request_time */
/* Similar to RR2_task_activate,
but we don't check in what state the task is */
 
/* Insert task in the coRR2ect position */
proc_table[p].status = RR2_READY;
259,7 → 195,7
iq_insertlast(p,&lev->ready);
}
 
static void RR2_task_extract(LEVEL l, PID p)
static void RR2_public_block(LEVEL l, PID p)
{
/* Extract the running task from the level
. we have already extract it from the ready queue at the dispatch time.
271,13 → 207,12
*/
}
 
static void RR2_task_endcycle(LEVEL l, PID p)
static int RR2_public_message(LEVEL l, PID p, void *m)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
 
if (lev->nact[p] > 0) {
/* continue!!!! */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
lev->nact[p]--;
iq_insertfirst(p,&lev->ready);
proc_table[p].status = RR2_READY;
284,9 → 219,14
}
else
proc_table[p].status = SLEEP;
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
return 0;
}
 
static void RR2_task_end(LEVEL l, PID p)
static void RR2_public_end(LEVEL l, PID p)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
 
297,46 → 237,6
iq_insertlast(p,&freedesc);
}
 
static void RR2_task_sleep(LEVEL l, PID p)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
if (lev->nact[p] >= 0) lev->nact[p] = 0;
proc_table[p].status = SLEEP;
}
 
static int RR2_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void RR2_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR2_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR2_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR2_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR2_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR2_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR2_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR2_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR2_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
 
 
/* Registration functions */
 
/*+ This init function install the "main" task +*/
364,7 → 264,7
if (p == NIL)
printk("\nPanic!!! can't create main task...\n");
 
RR2_task_activate(lev,p);
RR2_public_activate(lev,p);
}
 
 
372,11 → 272,11
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void RR2_register_level(TIME slice,
LEVEL RR2_register_level(TIME slice,
int createmain,
struct multiboot_info *mb)
{
LEVEL l; /* the level that we register */
LEVEL l; /* the level that we register */
RR2_level_des *lev; /* for readableness only */
PID i;
 
383,50 → 283,23
printk("RR2_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(RR2_level_des));
 
/* alloc the space needed for the RR2_level_des */
lev = (RR2_level_des *)kern_alloc(sizeof(RR2_level_des));
lev = (RR2_level_des *)level_table[l];
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, RR2_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = RR2_LEVEL_CODE;
lev->l.level_version = RR2_LEVEL_VERSION;
lev->l.public_scheduler = RR2_public_scheduler;
lev->l.public_create = RR2_public_create;
lev->l.public_end = RR2_public_end;
lev->l.public_dispatch = RR2_public_dispatch;
lev->l.public_epilogue = RR2_public_epilogue;
lev->l.public_activate = RR2_public_activate;
lev->l.public_unblock = RR2_public_unblock;
lev->l.public_block = RR2_public_block;
lev->l.public_message = RR2_public_message;
 
lev->l.level_accept_task_model = RR2_level_accept_task_model;
lev->l.level_accept_guest_model = RR2_level_accept_guest_model;
lev->l.level_status = RR2_level_status;
lev->l.level_scheduler = RR2_level_scheduler;
lev->l.level_guarantee = RR2_level_guarantee;
 
lev->l.task_create = RR2_task_create;
lev->l.task_detach = RR2_task_detach;
lev->l.task_eligible = RR2_task_eligible;
lev->l.task_dispatch = RR2_task_dispatch;
lev->l.task_epilogue = RR2_task_epilogue;
lev->l.task_activate = RR2_task_activate;
lev->l.task_insert = RR2_task_insert;
lev->l.task_extract = RR2_task_extract;
lev->l.task_endcycle = RR2_task_endcycle;
lev->l.task_end = RR2_task_end;
lev->l.task_sleep = RR2_task_sleep;
 
lev->l.guest_create = RR2_guest_create;
lev->l.guest_detach = RR2_guest_detach;
lev->l.guest_dispatch = RR2_guest_dispatch;
lev->l.guest_epilogue = RR2_guest_epilogue;
lev->l.guest_activate = RR2_guest_activate;
lev->l.guest_insert = RR2_guest_insert;
lev->l.guest_extract = RR2_guest_extract;
lev->l.guest_endcycle = RR2_guest_endcycle;
lev->l.guest_end = RR2_guest_end;
lev->l.guest_sleep = RR2_guest_sleep;
 
/* fill the RR2 descriptor part */
for (i = 0; i < MAX_PROC; i++)
lev->nact[i] = -1;
441,6 → 314,8
 
if (createmain)
sys_atrunlevel(RR2_call_main,(void *) l, RUNLEVEL_INIT);
 
return l;
}
 
 
/shark/trunk/kernel/modules/ds.c
20,11 → 20,11
 
/**
------------
CVS : $Id: ds.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: ds.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the aperiodic server DS (Deferrable Server)
64,6 → 64,7
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
/*+ Status used in the level +*/
#define DS_WAIT APER_STATUS_BASE /*+ waiting the service +*/
106,8 → 107,7
m = lev->scheduling_level;
job_task_default_model(j,lev->lastdline);
job_task_def_period(j,lev->period);
level_table[m]->guest_create(m,p,(TASK_MODEL *)&j);
level_table[m]->guest_activate(m,p);
level_table[m]->private_insert(m,p,(TASK_MODEL *)&j);
// kern_printf("(%d %d)",lev->lastdline.tv_sec,lev->lastdline.tv_nsec);
}
 
139,80 → 139,8
// kern_printf("!");
}
 
static char *DS_status_to_a(WORD status)
static PID DS_public_schedulerbackground(LEVEL l)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case DS_WAIT : return "DS_Wait";
default : return "DS_Unknown";
}
}
 
 
static int DS_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == SOFT_PCLASS || m->pclass == (SOFT_PCLASS | l) ) {
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m;
 
if (s->periodicity == APERIODIC)
return 0;
}
return -1;
}
 
static int DS_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
return -1;
}
 
static char *onoff(int i)
{
if (i)
return "On ";
else
return "Off";
}
 
static void DS_level_status(LEVEL l)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->wait);
 
kern_printf("On-line guarantee : %s\n",
onoff(lev->flags & DS_ENABLE_GUARANTEE_EDF ||
lev->flags & DS_ENABLE_GUARANTEE_RM ));
kern_printf("Used Bandwidth : %u/%u\n",
lev->U, MAX_BANDWIDTH);
 
if (lev->activated != -1)
kern_printf("Activated: Pid: %2d Name: %10s Dl: %ld.%ld Nact: %d Stat: %s\n",
lev->activated,
proc_table[lev->activated].name,
iq_query_timespec(lev->activated,&lev->wait)->tv_sec,
iq_query_timespec(lev->activated,&lev->wait)->tv_nsec,
lev->nact[lev->activated],
DS_status_to_a(proc_table[lev->activated].status));
 
while (p != NIL) {
kern_printf("Pid: %2d Name: %10s Stat: %s\n",
p,
proc_table[p].name,
DS_status_to_a(proc_table[p].status));
p = iq_query_next(p, &lev->wait);
}
}
 
static PID DS_level_scheduler(LEVEL l)
{
/* the DS don't schedule anything...
it's an EDF level or similar that do it! */
return NIL;
}
 
static PID DS_level_schedulerbackground(LEVEL l)
{
/* the DS catch the background time to exec aperiodic activities */
DS_level_des *lev = (DS_level_des *)(level_table[l]);
 
225,7 → 153,7
}
 
/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int DS_level_guaranteeEDF(LEVEL l, bandwidth_t *freebandwidth)
static int DS_public_guaranteeEDF(LEVEL l, bandwidth_t *freebandwidth)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
 
237,7 → 165,7
return 0;
}
 
static int DS_level_guaranteeRM(LEVEL l, bandwidth_t *freebandwidth)
static int DS_public_guaranteeRM(LEVEL l, bandwidth_t *freebandwidth)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
 
249,14 → 177,19
return 0;
}
 
static int DS_task_create(LEVEL l, PID p, TASK_MODEL *m)
static int DS_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
 
/* if the DS_task_create is called, then the pclass must be a
valid pclass. */
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m;
SOFT_TASK_MODEL *s;
 
if (m->pclass != SOFT_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
s = (SOFT_TASK_MODEL *)m;
if (s->periodicity != APERIODIC) return -1;
s = (SOFT_TASK_MODEL *)m;
 
if (s->arrivals == SAVE_ARRIVALS)
lev->nact[p] = 0;
else
265,18 → 198,8
return 0; /* OK, also if the task cannot be guaranteed... */
}
 
static void DS_task_detach(LEVEL l, PID p)
static void DS_public_dispatch(LEVEL l, PID p, int nostop)
{
/* the DS level doesn't introduce any dinamic allocated new field. */
}
 
static int DS_task_eligible(LEVEL l, PID p)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void DS_task_dispatch(LEVEL l, PID p, int nostop)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
struct timespec ty;
 
292,7 → 215,7
else {
//if (nostop) kern_printf("(gd status=%d)",proc_table[p].status);
level_table[ lev->scheduling_level ]->
guest_dispatch(lev->scheduling_level,p,nostop);
private_dispatch(lev->scheduling_level,p,nostop);
}
 
/* set the capacity timer */
305,7 → 228,7
// kern_printf("(disp %d %d)",ty.tv_sec, ty.tv_nsec);
}
 
static void DS_task_epilogue(LEVEL l, PID p)
static void DS_public_epilogue(LEVEL l, PID p)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
struct timespec ty;
337,7 → 260,7
task point the shadow to it!!!*/
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = DS_WAIT;
lev->activated = NIL;
347,7 → 270,7
wait queue by calling the guest_epilogue... */
if (lev->activated == p) {//kern_printf("Û1");
level_table[ lev->scheduling_level ]->
guest_epilogue(lev->scheduling_level,p);
private_epilogue(lev->scheduling_level,p);
} else { //kern_printf("Û2");
iq_insertfirst(p, &lev->wait);
proc_table[p].status = DS_WAIT;
354,7 → 277,7
}
}
 
static void DS_task_activate(LEVEL l, PID p)
static void DS_public_activate(LEVEL l, PID p)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
 
363,7 → 286,6
lev->nact[p]++;
}
else if (proc_table[p].status == SLEEP) {
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
 
if (lev->activated == NIL && lev->availCs > 0) {
lev->activated = p;
380,7 → 302,7
 
}
 
static void DS_task_insert(LEVEL l, PID p)
static void DS_public_unblock(LEVEL l, PID p)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
 
394,7 → 316,7
proc_table[p].status = DS_WAIT;
}
 
static void DS_task_extract(LEVEL l, PID p)
static void DS_public_block(LEVEL l, PID p)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
 
405,10 → 327,10
 
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
}
 
static void DS_task_endcycle(LEVEL l, PID p)
static int DS_public_message(LEVEL l, PID p, void *m)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
struct timespec ty;
425,7 → 347,7
 
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
else
iq_extract(p, &lev->wait);
 
441,9 → 363,14
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
DS_activation(lev);
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
return 0;
}
 
static void DS_task_end(LEVEL l, PID p)
static void DS_public_end(LEVEL l, PID p)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
struct timespec ty;
460,7 → 387,7
 
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
 
proc_table[p].status = FREE;
iq_insertfirst(p,&freedesc);
470,70 → 397,6
DS_activation(lev);
}
 
static void DS_task_sleep(LEVEL l, PID p)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
struct timespec ty;
TIME tx;
 
/* update the server capacity */
if (lev->flags & DS_BACKGROUND)
lev->flags &= ~DS_BACKGROUND;
else {
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
lev->availCs -= tx;
}
 
if (lev->nact[p] >= 0) lev->nact[p] = 0;
 
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
else
iq_extract(p, &lev->wait);
 
proc_table[p].status = SLEEP;
 
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
DS_activation(lev);
}
 
 
static int DS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void DS_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void DS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void DS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void DS_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void DS_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void DS_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void DS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void DS_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void DS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
 
 
/* Registration functions */
 
 
543,7 → 406,7
{
DS_level_des *lev = (DS_level_des *)(level_table[(LEVEL)l]);
 
ll_gettime(TIME_EXACT,&lev->lastdline);
kern_gettime(&lev->lastdline);
ADDUSEC2TIMESPEC(lev->period, &lev->lastdline);
 
kern_event_post(&lev->lastdline, DS_deadline_timer, l);
553,7 → 416,7
 
/*+ Registration function:
int flags the init flags ... see DS.h +*/
void DS_register_level(int flags, LEVEL master, int Cs, int per)
LEVEL DS_register_level(int flags, LEVEL master, int Cs, int per)
{
LEVEL l; /* the level that we register */
DS_level_des *lev; /* for readableness only */
562,62 → 425,33
printk("DS_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(DS_level_des));
 
printk(" alloco descrittore %d %d\n",l,(int)sizeof(DS_level_des));
lev = (DS_level_des *)level_table[l];
 
/* alloc the space needed for the DS_level_des */
lev = (DS_level_des *)kern_alloc(sizeof(DS_level_des));
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, DS_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = DS_LEVEL_CODE;
lev->l.level_version = DS_LEVEL_VERSION;
 
lev->l.level_accept_task_model = DS_level_accept_task_model;
lev->l.level_accept_guest_model = DS_level_accept_guest_model;
lev->l.level_status = DS_level_status;
 
if (flags & DS_ENABLE_BACKGROUND)
lev->l.level_scheduler = DS_level_schedulerbackground;
else
lev->l.level_scheduler = DS_level_scheduler;
lev->l.public_scheduler = DS_public_schedulerbackground;
 
if (flags & DS_ENABLE_GUARANTEE_EDF)
lev->l.level_guarantee = DS_level_guaranteeEDF;
lev->l.public_guarantee = DS_public_guaranteeEDF;
else if (flags & DS_ENABLE_GUARANTEE_RM)
lev->l.level_guarantee = DS_level_guaranteeRM;
lev->l.public_guarantee = DS_public_guaranteeRM;
else
lev->l.level_guarantee = NULL;
lev->l.public_guarantee = NULL;
 
lev->l.task_create = DS_task_create;
lev->l.task_detach = DS_task_detach;
lev->l.task_eligible = DS_task_eligible;
lev->l.task_dispatch = DS_task_dispatch;
lev->l.task_epilogue = DS_task_epilogue;
lev->l.task_activate = DS_task_activate;
lev->l.task_insert = DS_task_insert;
lev->l.task_extract = DS_task_extract;
lev->l.task_endcycle = DS_task_endcycle;
lev->l.task_end = DS_task_end;
lev->l.task_sleep = DS_task_sleep;
lev->l.public_create = DS_public_create;
lev->l.public_end = DS_public_end;
lev->l.public_dispatch = DS_public_dispatch;
lev->l.public_epilogue = DS_public_epilogue;
lev->l.public_activate = DS_public_activate;
lev->l.public_unblock = DS_public_unblock;
lev->l.public_block = DS_public_block;
lev->l.public_message = DS_public_message;
 
lev->l.guest_create = DS_guest_create;
lev->l.guest_detach = DS_guest_detach;
lev->l.guest_dispatch = DS_guest_dispatch;
lev->l.guest_epilogue = DS_guest_epilogue;
lev->l.guest_activate = DS_guest_activate;
lev->l.guest_insert = DS_guest_insert;
lev->l.guest_extract = DS_guest_extract;
lev->l.guest_endcycle = DS_guest_endcycle;
lev->l.guest_end = DS_guest_end;
lev->l.guest_sleep = DS_guest_sleep;
 
/* fill the DS descriptor part */
 
for (i=0; i<MAX_PROC; i++)
638,15 → 472,13
lev->flags = flags & 0x07;
 
sys_atrunlevel(DS_dline_install,(void *) l, RUNLEVEL_INIT);
 
return l;
}
 
bandwidth_t DS_usedbandwidth(LEVEL l)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
if (lev->l.level_code == DS_LEVEL_CODE &&
lev->l.level_version == DS_LEVEL_VERSION)
return lev->U;
else
return 0;
return lev->U;
}
 
/shark/trunk/kernel/modules/cbs.c
20,11 → 20,11
 
/**
------------
CVS : $Id: cbs.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: cbs.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the aperiodic server CBS (Total Bandwidth Server)
172,25 → 172,9
job_task_default_model(job, lev->cbs_dline[p]);
job_task_def_noexc(job);
level_table[ lev->scheduling_level ]->
guest_create(lev->scheduling_level, p, (TASK_MODEL *)&job);
level_table[ lev->scheduling_level ]->
guest_activate(lev->scheduling_level, p);
 
private_insert(lev->scheduling_level, p, (TASK_MODEL *)&job);
}
 
 
static char *CBS_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case CBS_IDLE : return "CBS_Idle";
case CBS_ZOMBIE : return "CBS_Zombie";
default : return "CBS_Unknown";
}
}
 
static void CBS_avail_time_check(CBS_level_des *lev, PID p)
{
/* there is a while because if the wcet is << than the system tick
270,60 → 254,8
}
 
 
static int CBS_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == SOFT_PCLASS || m->pclass == (SOFT_PCLASS | l)) {
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m;
if (s->met && s->period)
return 0;
}
 
return -1;
}
 
static int CBS_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
return -1;
}
 
static char *onoff(int i)
{
if (i)
return "On ";
else
return "Off";
}
 
static void CBS_level_status(LEVEL l)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
PID p;
 
kern_printf("On-line guarantee : %s\n",
onoff(lev->flags & CBS_ENABLE_GUARANTEE));
kern_printf("Used Bandwidth : %u/%u\n",
lev->U, MAX_BANDWIDTH);
 
for (p=0; p<MAX_PROC; p++)
if (proc_table[p].task_level == l && proc_table[p].status != FREE )
kern_printf("Pid: %2d Name: %10s Period: %9ld Dline: %9ld.%6ld Stat: %s\n",
p,
proc_table[p].name,
lev->period[p],
lev->cbs_dline[p].tv_sec,
lev->cbs_dline[p].tv_nsec/1000,
CBS_status_to_a(proc_table[p].status));
}
 
static PID CBS_level_scheduler(LEVEL l)
{
/* the CBS don't schedule anything...
it's an EDF level or similar that do it! */
return NIL;
}
 
/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int CBS_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int CBS_public_guarantee(LEVEL l, bandwidth_t *freebandwidth)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
 
340,14 → 272,18
return 0;
}
 
static int CBS_task_create(LEVEL l, PID p, TASK_MODEL *m)
static int CBS_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
SOFT_TASK_MODEL *soft;
 
/* if the CBS_task_create is called, then the pclass must be a
valid pclass. */
SOFT_TASK_MODEL *soft = (SOFT_TASK_MODEL *)m;
if (m->pclass != SOFT_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
soft = (SOFT_TASK_MODEL *)m;
if (!(soft->met && soft->period)) return -1;
 
soft = (SOFT_TASK_MODEL *)m;
 
/* Enable wcet check */
proc_table[p].avail_time = soft->met;
proc_table[p].wcet = soft->met;
383,7 → 319,7
return 0; /* OK, also if the task cannot be guaranteed... */
}
 
static void CBS_task_detach(LEVEL l, PID p)
static void CBS_public_detach(LEVEL l, PID p)
{
/* the CBS level doesn't introduce any dinamic allocated new field.
we have only to reset the NO_GUARANTEE FIELD and decrement the allocated
397,7 → 333,7
lev->U -= (MAX_BANDWIDTH / lev->period[p]) * proc_table[p].wcet;
}
 
static int CBS_task_eligible(LEVEL l, PID p)
static int CBS_public_eligible(LEVEL l, PID p)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
JOB_TASK_MODEL job;
412,7 → 348,7
if ( TIMESPEC_A_LT_B(&lev->cbs_dline[p], &schedule_time) ) {
/* we kill the current activation */
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level, p);
private_extract(lev->scheduling_level, p);
 
/* we modify the deadline ... */
TIMESPEC_ASSIGN(&lev->cbs_dline[p], &schedule_time);
425,9 → 361,7
job_task_default_model(job, lev->cbs_dline[p]);
job_task_def_noexc(job);
level_table[ lev->scheduling_level ]->
guest_create(lev->scheduling_level, p, (TASK_MODEL *)&job);
level_table[ lev->scheduling_level ]->
guest_activate(lev->scheduling_level, p);
private_insert(lev->scheduling_level, p, (TASK_MODEL *)&job);
 
return -1;
}
435,14 → 369,14
return 0;
}
 
static void CBS_task_dispatch(LEVEL l, PID p, int nostop)
static void CBS_public_dispatch(LEVEL l, PID p, int nostop)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
level_table[ lev->scheduling_level ]->
guest_dispatch(lev->scheduling_level,p,nostop);
private_dispatch(lev->scheduling_level,p,nostop);
}
 
static void CBS_task_epilogue(LEVEL l, PID p)
static void CBS_public_epilogue(LEVEL l, PID p)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
JOB_TASK_MODEL job;
451,7 → 385,7
if ( proc_table[p].avail_time <= 0) {
/* we kill the current activation */
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level, p);
private_extract(lev->scheduling_level, p);
 
/* we modify the deadline according to rule 4 ... */
CBS_avail_time_check(lev, p);
460,9 → 394,7
job_task_default_model(job, lev->cbs_dline[p]);
job_task_def_noexc(job);
level_table[ lev->scheduling_level ]->
guest_create(lev->scheduling_level, p, (TASK_MODEL *)&job);
level_table[ lev->scheduling_level ]->
guest_activate(lev->scheduling_level, p);
private_insert(lev->scheduling_level, p, (TASK_MODEL *)&job);
// kern_printf("epil : dl %d per %d p %d |\n",
// lev->cbs_dline[p].tv_nsec/1000,lev->period[p],p);
 
471,12 → 403,13
/* the task has been preempted. it returns into the ready queue by
calling the guest_epilogue... */
level_table[ lev->scheduling_level ]->
guest_epilogue(lev->scheduling_level,p);
private_epilogue(lev->scheduling_level,p);
}
 
static void CBS_task_activate(LEVEL l, PID p)
static void CBS_public_activate(LEVEL l, PID p)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
struct timespec t;
 
/* save activation (only if needed... */
if (proc_table[p].status != SLEEP) {
485,9 → 418,9
return;
}
 
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
kern_gettime(&t);
 
CBS_activation(lev, p, &proc_table[p].request_time);
CBS_activation(lev, p, &t);
 
/* Set the reactivation timer */
if (!(lev->flag[p] & CBS_APERIODIC))
496,7 → 429,7
the deadline may be != from actual_time + period
(if we call the task_activate after a task_sleep, and the
deadline was postponed a lot...) */
TIMESPEC_ASSIGN(&lev->reactivation_time[p], &proc_table[p].request_time);
TIMESPEC_ASSIGN(&lev->reactivation_time[p], &t);
ADDUSEC2TIMESPEC(lev->period[p], &lev->reactivation_time[p]);
// TIMESPEC_ASSIGN(&lev->reactivation_time[p], &lev->cbs_dline[p]);
lev->reactivation_timer[p] = kern_event_post(&lev->reactivation_time[p],
509,17 → 442,17
// kern_printf("act : %d %d |",lev->cbs_dline[p].tv_nsec/1000,p);
}
 
static void CBS_task_insert(LEVEL l, PID p)
static void CBS_public_unblock(LEVEL l, PID p)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
struct timespec acttime;
 
ll_gettime(TIME_EXACT, &acttime);
kern_gettime(&acttime);
 
CBS_activation(lev,p,&acttime);
}
 
static void CBS_task_extract(LEVEL l, PID p)
static void CBS_public_block(LEVEL l, PID p)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
 
527,10 → 460,10
CBS_avail_time_check(lev, p);
 
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
}
 
static void CBS_task_endcycle(LEVEL l, PID p)
static int CBS_public_message(LEVEL l, PID p, void *m)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
 
539,24 → 472,27
 
if (lev->nact[p]) {
/* continue!!!! */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
lev->nact[p]--;
level_table[ lev->scheduling_level ]->
guest_epilogue(lev->scheduling_level,p);
private_epilogue(lev->scheduling_level,p);
}
else {
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
 
if (lev->flag[p] & CBS_APERIODIC)
proc_table[p].status = SLEEP;
else /* the task is soft_periodic */
proc_table[p].status = CBS_IDLE;
}
 
}
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
return 0;
}
 
static void CBS_task_end(LEVEL l, PID p)
static void CBS_public_end(LEVEL l, PID p)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
 
564,11 → 500,11
CBS_avail_time_check(lev, p);
 
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
 
/* we delete the reactivation timer */
if (!(lev->flag[p] & CBS_APERIODIC)) {
event_delete(lev->reactivation_timer[p]);
kern_event_delete(lev->reactivation_timer[p]);
lev->reactivation_timer[p] = -1;
}
 
580,67 → 516,11
(void *)p);
}
 
static void CBS_task_sleep(LEVEL l, PID p)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
 
/* check if the wcet is finished... */
CBS_avail_time_check(lev, p);
 
/* a task activation is finished, but we are using a JOB_TASK_MODEL
that implements a single activation, so we have to call
the guest_end, that representsa single activation... */
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
 
/* we delete the reactivation timer */
if (!(lev->flag[p] & CBS_APERIODIC)) {
event_delete(lev->reactivation_timer[p]);
lev->reactivation_timer[p] = -1;
}
 
proc_table[p].status = SLEEP;
 
/* the sleep forgets pending activations... */
lev->nact[p] = 0;
}
 
static int CBS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void CBS_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void CBS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void CBS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void CBS_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void CBS_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void CBS_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void CBS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void CBS_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void CBS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
/* Registration functions */
 
/*+ Registration function:
int flags the init flags ... see CBS.h +*/
void CBS_register_level(int flags, LEVEL master)
LEVEL CBS_register_level(int flags, LEVEL master)
{
LEVEL l; /* the level that we register */
CBS_level_des *lev; /* for readableness only */
649,56 → 529,28
printk("CBS_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(CBS_level_des));
 
printk(" alloco descrittore %d %d\n",l,(int)sizeof(CBS_level_des));
lev = (CBS_level_des *)level_table[l];
 
/* alloc the space needed for the CBS_level_des */
lev = (CBS_level_des *)kern_alloc(sizeof(CBS_level_des));
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, CBS_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = CBS_LEVEL_CODE;
lev->l.level_version = CBS_LEVEL_VERSION;
 
lev->l.level_accept_task_model = CBS_level_accept_task_model;
lev->l.level_accept_guest_model = CBS_level_accept_guest_model;
lev->l.level_status = CBS_level_status;
lev->l.level_scheduler = CBS_level_scheduler;
 
if (flags & CBS_ENABLE_GUARANTEE)
lev->l.level_guarantee = CBS_level_guarantee;
lev->l.public_guarantee = CBS_public_guarantee;
else
lev->l.level_guarantee = NULL;
lev->l.public_guarantee = NULL;
lev->l.public_create = CBS_public_create;
lev->l.public_detach = CBS_public_detach;
lev->l.public_end = CBS_public_end;
lev->l.public_eligible = CBS_public_eligible;
lev->l.public_dispatch = CBS_public_dispatch;
lev->l.public_epilogue = CBS_public_epilogue;
lev->l.public_activate = CBS_public_activate;
lev->l.public_unblock = CBS_public_unblock;
lev->l.public_block = CBS_public_block;
lev->l.public_message = CBS_public_message;
 
lev->l.task_create = CBS_task_create;
lev->l.task_detach = CBS_task_detach;
lev->l.task_eligible = CBS_task_eligible;
lev->l.task_dispatch = CBS_task_dispatch;
lev->l.task_epilogue = CBS_task_epilogue;
lev->l.task_activate = CBS_task_activate;
lev->l.task_insert = CBS_task_insert;
lev->l.task_extract = CBS_task_extract;
lev->l.task_endcycle = CBS_task_endcycle;
lev->l.task_end = CBS_task_end;
lev->l.task_sleep = CBS_task_sleep;
 
lev->l.guest_create = CBS_guest_create;
lev->l.guest_detach = CBS_guest_detach;
lev->l.guest_dispatch = CBS_guest_dispatch;
lev->l.guest_epilogue = CBS_guest_epilogue;
lev->l.guest_activate = CBS_guest_activate;
lev->l.guest_insert = CBS_guest_insert;
lev->l.guest_extract = CBS_guest_extract;
lev->l.guest_endcycle = CBS_guest_endcycle;
lev->l.guest_end = CBS_guest_end;
lev->l.guest_sleep = CBS_guest_sleep;
 
/* fill the CBS descriptor part */
for (i=0; i<MAX_PROC; i++) {
NULL_TIMESPEC(&lev->cbs_dline[i]);
715,16 → 567,15
lev->scheduling_level = master;
 
lev->flags = flags & 0x01;
 
return l;
}
 
bandwidth_t CBS_usedbandwidth(LEVEL l)
{
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
if (lev->l.level_code == CBS_LEVEL_CODE &&
lev->l.level_version == CBS_LEVEL_VERSION)
return lev->U;
else
return 0;
 
return lev->U;
}
 
int CBS_get_nact(LEVEL l, PID p)
/shark/trunk/kernel/modules/pi.c
20,11 → 20,11
 
/**
------------
CVS : $Id: pi.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: pi.c,v 1.2 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
Priority Inhertitance protocol. see pi.h for more details...
56,7 → 56,6
#include <ll/ll.h>
#include <ll/string.h>
#include <ll/stdio.h>
#include <modules/codes.h>
#include <kernel/const.h>
#include <sys/types.h>
#include <kernel/descr.h>
83,6 → 82,7
 
 
 
#if 0
/*+ print resource protocol statistics...+*/
static void PI_resource_status(RLEVEL r)
{
94,19 → 94,14
kern_printf("%-4d", m->nlocked[i]);
}
}
#endif
 
 
static int PI_level_accept_resource_model(RLEVEL l, RES_MODEL *r)
static int PI_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
/* priority inheritance works with all tasks without Resource parameters */
return -1;
}
 
static void PI_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
/* never called!!! */
}
 
static void PI_res_detach(RLEVEL l, PID p)
{
PI_mutex_resource_des *m = (PI_mutex_resource_des *)(resource_table[l]);
115,18 → 110,13
kern_raise(XMUTEX_OWNER_KILLED, p);
}
 
static int PI_level_accept_mutexattr(RLEVEL l, const mutexattr_t *a)
{
if (a->mclass == PI_MCLASS || a->mclass == (PI_MCLASS | l) )
return 0;
else
return -1;
}
 
static int PI_init(RLEVEL l, mutex_t *m, const mutexattr_t *a)
{
PI_mutex_t *p;
 
if (a->mclass != PI_MCLASS)
return -1;
 
p = (PI_mutex_t *) kern_alloc(sizeof(PI_mutex_t));
 
/* control if there is enough memory; no control on init on a
299,7 → 289,7
return 0;
}
 
void PI_register_module(void)
RLEVEL PI_register_module(void)
{
RLEVEL l; /* the level that we register */
PI_mutex_resource_des *m; /* for readableness only */
317,20 → 307,11
resource_table[l] = (resource_des *)m;
 
/* fill the resource_des descriptor */
strncpy(m->m.r.res_name, PI_MODULENAME, MAX_MODULENAME);
m->m.r.res_code = PI_MODULE_CODE;
m->m.r.res_version = PI_MODULE_VERSION;
 
m->m.r.rtype = MUTEX_RTYPE;
 
m->m.r.resource_status = PI_resource_status;
m->m.r.level_accept_resource_model = PI_level_accept_resource_model;
m->m.r.res_register = PI_res_register;
 
m->m.r.res_detach = PI_res_detach;
 
/* fill the mutex_resource_des descriptor */
m->m.level_accept_mutexattr = PI_level_accept_mutexattr;
m->m.init = PI_init;
m->m.destroy = PI_destroy;
m->m.lock = PI_lock;
342,5 → 323,7
m->nlocked[i] = 0;
m->blocked[i] = NIL;
}
return l;
}
 
/shark/trunk/kernel/modules/trcfixed.c
107,9 → 107,6
if (queue->filename==NULL) trc_create_name("fix",queue->uniq,pathname);
else trc_create_name(queue->filename,0,pathname);
 
//sys_status(SCHED_STATUS);
//task_delay(250000);
h=open("/TEMP/FIX1",O_CREAT|O_TRUNC|O_WRONLY);
if (h!=-1) {
write(h,queue->table,queue->index*sizeof(trc_event_t));
/shark/trunk/kernel/modules/nopm.c
20,11 → 20,11
 
/**
------------
CVS : $Id: nopm.c,v 1.2 2002-11-11 08:32:06 pj Exp $
CVS : $Id: nopm.c,v 1.3 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
See modules/nopm.h.
58,7 → 58,6
#include <ll/string.h>
#include <kernel/const.h>
#include <sys/types.h>
#include <modules/codes.h>
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
138,40 → 137,23
#define NOPM_WAIT LIB_STATUS_BASE
 
 
/*+ print resource protocol statistics...+*/
static void NOPM_resource_status(RLEVEL r)
{
kern_printf("No status for NOPM module\n");
}
 
 
static int NOPM_level_accept_resource_model(RLEVEL l, RES_MODEL *r)
static int NOPM_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
/* priority inheritance works with all tasks without Resource parameters */
return -1;
}
 
static void NOPM_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
/* never called!!! */
}
 
static void NOPM_res_detach(RLEVEL l, PID p)
{
}
 
static int NOPM_level_accept_mutexattr(RLEVEL l, const mutexattr_t *a)
{
if (a->mclass == NOPM_MCLASS || a->mclass == (NOPM_MCLASS | l) )
return 0;
else
return -1;
}
 
static int NOPM_init(RLEVEL l, mutex_t *m, const mutexattr_t *a)
{
NOPM_mutex_t *p;
 
if (a->mclass != NOPM_MCLASS)
return -1;
 
p = (NOPM_mutex_t *) kern_alloc(sizeof(NOPM_mutex_t));
 
/* control if there is enough memory; no control on init on a
234,23 → 216,12
 
if (p->owner != NIL) { /* We must block exec task */
LEVEL l; /* for readableness only */
TIME tx; /* a dummy TIME for timespec operations */
struct timespec ty; /* a dummy timespec for timespec operations */
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);
 
/* we insert the task in the semaphore queue */
proc_table[exec_shadow].status = NOPM_WAIT;
333,7 → 304,7
break;
} else if (proc_table[e].status == NOPM_WAIT) {
l = proc_table[e].task_level;
level_table[l]->task_insert(l,e);
level_table[l]->public_unblock(l,e);
p->counter++;
break;
}
348,7 → 319,7
return 0;
}
 
void NOPM_register_module(void)
RLEVEL NOPM_register_module(void)
{
RLEVEL l; /* the level that we register */
NOPM_mutex_resource_des *m; /* for readableness only */
365,20 → 336,11
resource_table[l] = (resource_des *)m;
 
/* fill the resource_des descriptor */
strncpy(m->m.r.res_name, NOPM_MODULENAME, MAX_MODULENAME);
m->m.r.res_code = NOPM_MODULE_CODE;
m->m.r.res_version = NOPM_MODULE_VERSION;
 
m->m.r.rtype = MUTEX_RTYPE;
 
m->m.r.resource_status = NOPM_resource_status;
m->m.r.level_accept_resource_model = NOPM_level_accept_resource_model;
m->m.r.res_register = NOPM_res_register;
 
m->m.r.res_detach = NOPM_res_detach;
 
/* fill the mutex_resource_des descriptor */
m->m.level_accept_mutexattr = NOPM_level_accept_mutexattr;
m->m.init = NOPM_init;
m->m.destroy = NOPM_destroy;
m->m.lock = NOPM_lock;
385,5 → 347,6
m->m.trylock = NOPM_trylock;
m->m.unlock = NOPM_unlock;
 
return l;
}
 
/shark/trunk/kernel/modules/bd_pscan.c
38,11 → 38,11
*/
 
/*
* CVS : $Id: bd_pscan.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
* CVS : $Id: bd_pscan.c,v 1.2 2003-01-07 17:07:50 pj Exp $
*
* File: $File$
* Revision: $Revision: 1.1.1.1 $
* Last update: $Date: 2002-03-29 14:12:52 $
* Revision: $Revision: 1.2 $
* Last update: $Date: 2003-01-07 17:07:50 $
*/
 
#include <modules/bd_pscan.h>
51,7 → 51,6
#include <ll/string.h>
#include <ll/stdio.h>
#include <kernel/const.h>
#include <modules/codes.h>
#include <sys/types.h>
#include <kernel/var.h>
#include <kernel/func.h>
68,21 → 67,21
int priority[MAX_PROC];
} bd_pscan_resource_des;
 
static int res_level_accept_resource_model(RLEVEL l, RES_MODEL *r)
static int res_register(RLEVEL l, PID p, RES_MODEL *r)
{
assertk(mylevel==l);
if (r->rclass==BDPSCAN_RCLASS||r->rclass==(BDPSCAN_RCLASS|l))
return 0;
else
bd_pscan_resource_des *m=(bd_pscan_resource_des*)(resource_table[l]);
BDPSCAN_RES_MODEL *rm;
 
if (r->rclass!=BDEDF_RCLASS)
return -1;
}
 
static void res_register(RLEVEL l, PID p, RES_MODEL *r)
{
bd_pscan_resource_des *m=(bd_pscan_resource_des*)(resource_table[l]);
BDPSCAN_RES_MODEL *rm=(BDPSCAN_RES_MODEL*)r;
if (r->level && r->level !=l)
return -1;
rm=(BDPSCAN_RES_MODEL*)r;
assertk(mylevel==l);
m->priority[p]=rm->priority;
 
return 0;
}
 
static void res_detach(RLEVEL l, PID p)
92,10 → 91,7
m->priority[p]=LOWESTPRIORITY;
}
 
static void res_resource_status(void)
{}
 
void BD_PSCAN_register_module(void)
RLEVEL BD_PSCAN_register_module(void)
{
RLEVEL l;
bd_pscan_resource_des *m;
111,12 → 107,7
resource_table[l]=(resource_des*)m;
 
/* fill the resource_des descriptor */
strcpy(m->rd.res_name,BDPSCAN_MODULENAME);
m->rd.res_code=BDPSCAN_MODULE_CODE;
m->rd.res_version=BDPSCAN_MODULE_VERSION;
m->rd.rtype=DEFAULT_RTYPE;
m->rd.resource_status=res_resource_status;
m->rd.level_accept_resource_model=res_level_accept_resource_model;
m->rd.res_register=res_register;
m->rd.res_detach=res_detach;
 
124,6 → 115,8
assertk(mylevel==-1);
mylevel=l;
 
return l;
}
 
int bd_pscan_getpriority(void)
/shark/trunk/kernel/modules/rm.c
20,11 → 20,11
 
/**
------------
CVS : $Id: rm.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: rm.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the scheduling module RM (Rate Monotonic)
41,7 → 41,7
**/
 
/*
* Copyright (C) 2000 Paolo Gai
* Copyright (C) 2000,2002 Paolo Gai
*
* 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
102,21 → 102,6
} RM_level_des;
 
 
static char *RM_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case RM_READY : return "RM_Ready";
case RM_WCET_VIOLATED: return "RM_Wcet_Violated";
case RM_WAIT : return "RM_Sporadic_Wait";
case RM_IDLE : return "RM_Idle";
case RM_ZOMBIE : return "RM_Zombie";
default : return "RM_Unknown";
}
}
 
static void RM_timer_deadline(void *par)
{
PID p = (PID) par;
139,7 → 124,6
trc_logevent(TRC_INTACTIVATION,&p);
/* similar to RM_task_activate */
temp = iq_query_timespec(p, &lev->ready);
TIMESPEC_ASSIGN(&proc_table[p].request_time, temp);
ADDUSEC2TIMESPEC(lev->period[p], temp);
proc_table[p].status = RM_READY;
iq_priority_insert(p,&lev->ready);
171,95 → 155,16
kern_raise(XDEADLINE_MISS,p);
}
 
static int RM_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == HARD_PCLASS || m->pclass == (HARD_PCLASS | l)) {
HARD_TASK_MODEL *h = (HARD_TASK_MODEL *)m;
 
if (h->wcet && h->mit)
return 0;
}
 
return -1;
}
 
static int RM_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == JOB_PCLASS || m->pclass == (JOB_PCLASS | l))
return 0;
else
return -1;
}
 
 
static char *onoff(int i)
{
if (i)
return "On ";
else
return "Off";
}
 
static void RM_level_status(LEVEL l)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->ready);
 
kern_printf("Wcet Check : %s\n",
onoff(lev->flags & RM_ENABLE_WCET_CHECK));
kern_printf("On-line guarantee : %s\n",
onoff(lev->flags & RM_ENABLE_GUARANTEE));
kern_printf("Used Bandwidth : %u/%u\n",
lev->U, MAX_BANDWIDTH);
 
while (p != NIL) {
if ((proc_table[p].pclass) == JOB_PCLASS)
kern_printf("Pid: %2d (GUEST)\n", p);
else
kern_printf("Pid: %2d Name: %10s %s: %9ld Dline: %9ld.%6ld Stat: %s\n",
p,
proc_table[p].name,
lev->flag[p] & RM_FLAG_SPORADIC ? "MinITime" : "Period ",
lev->period[p],
iq_query_timespec(p, &lev->ready)->tv_sec,
iq_query_timespec(p, &lev->ready)->tv_nsec/1000,
RM_status_to_a(proc_table[p].status));
p = iq_query_next(p, &lev->ready);
}
 
for (p=0; p<MAX_PROC; p++)
if (proc_table[p].task_level == l && proc_table[p].status != RM_READY
&& proc_table[p].status != FREE )
kern_printf("Pid: %2d Name: %10s %s: %9ld Dline: %9ld.%6ld Stat: %s\n",
p,
proc_table[p].name,
lev->flag[p] & RM_FLAG_SPORADIC ? "MinITime" : "Period ",
lev->period[p],
iq_query_timespec(p, &lev->ready)->tv_sec,
iq_query_timespec(p, &lev->ready)->tv_nsec/1000,
RM_status_to_a(proc_table[p].status));
}
 
/* The scheduler only gets the first task in the queue */
static PID RM_level_scheduler(LEVEL l)
static PID RM_public_scheduler(LEVEL l)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
/* { // print 4 dbg the ready queue
PID p= lev->ready;
kern_printf("(s");
while (p != NIL) {
kern_printf("%d ",p);
p = proc_table[p].next;
}
kern_printf(") ");
}
*/
return iq_query_first(&lev->ready);
}
 
/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int RM_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int RM_public_guarantee(LEVEL l, bandwidth_t *freebandwidth)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
277,14 → 182,17
 
}
 
static int RM_task_create(LEVEL l, PID p, TASK_MODEL *m)
static int RM_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
/* if the RM_task_create is called, then the pclass must be a
valid pclass. */
HARD_TASK_MODEL *h;
 
HARD_TASK_MODEL *h = (HARD_TASK_MODEL *)m;
if (m->pclass != HARD_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
h = (HARD_TASK_MODEL *)m;
if (!h->wcet || !h->mit) return -1;
/* now we know that m is a valid model */
 
*iq_query_priority(p, &lev->ready) = lev->period[p] = h->mit;
 
328,7 → 236,7
return 0; /* OK, also if the task cannot be guaranteed... */
}
 
static void RM_task_detach(LEVEL l, PID p)
static void RM_public_detach(LEVEL l, PID p)
{
/* the RM level doesn't introduce any dinamic allocated new field.
we have only to reset the NO_GUARANTEE FIELD and decrement the allocated
342,13 → 250,8
lev->U -= (MAX_BANDWIDTH / lev->period[p]) * proc_table[p].wcet;
}
 
static int RM_task_eligible(LEVEL l, PID p)
static void RM_public_dispatch(LEVEL l, PID p, int nostop)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void RM_task_dispatch(LEVEL l, PID p, int nostop)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
// kern_printf("(disp %d)",p);
359,7 → 262,7
iq_extract(p, &lev->ready);
}
 
static void RM_task_epilogue(LEVEL l, PID p)
static void RM_public_epilogue(LEVEL l, PID p)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
378,7 → 281,7
}
}
 
static void RM_task_activate(LEVEL l, PID p)
static void RM_public_activate(LEVEL l, PID p)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
struct timespec *temp;
396,10 → 299,8
 
 
/* see also RM_timer_deadline */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
 
temp = iq_query_timespec(p, &lev->ready);
TIMESPEC_ASSIGN(temp, &proc_table[p].request_time);
kern_gettime(temp);
ADDUSEC2TIMESPEC(lev->period[p], temp);
 
/* Insert task in the correct position */
412,12 → 313,12
(void *)p);
}
 
static void RM_task_insert(LEVEL l, PID p)
static void RM_public_unblock(LEVEL l, PID p)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
/* Similar to RM_task_activate, but we don't check in what state
the task is and we don't set the request_time*/
/* Similar to RM_task_activate,
but we don't check in what state the task is */
 
/* Insert task in the correct position */
proc_table[p].status = RM_READY;
424,7 → 325,7
iq_priority_insert(p,&lev->ready);
}
 
static void RM_task_extract(LEVEL l, PID p)
static void RM_public_block(LEVEL l, PID p)
{
/* Extract the running task from the level
. we have already extract it from the ready queue at the dispatch time.
437,7 → 338,7
*/
}
 
static void RM_task_endcycle(LEVEL l, PID p)
static int RM_public_message(LEVEL l, PID p, void *m)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
451,14 → 352,17
if (lev->flags & RM_ENABLE_WCET_CHECK)
proc_table[p].avail_time = proc_table[p].wcet;
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
/* when the deadline timer fire, it recognize the situation and set
correctly all the stuffs (like reactivation, request_time, etc... ) */
correctly all the stuffs (like reactivation, sleep, etc... ) */
 
return 0;
}
 
static void RM_task_end(LEVEL l, PID p)
static void RM_public_end(LEVEL l, PID p)
{
// RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
proc_table[p].status = RM_ZOMBIE;
 
/* When the deadline timer fire, it put the task descriptor in
465,61 → 369,39
the free queue, and free the allocated bandwidth... */
}
 
static void RM_task_sleep(LEVEL l, PID p)
static void RM_private_insert(LEVEL l, PID p, TASK_MODEL *m)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
JOB_TASK_MODEL *job;
 
/* the task has terminated his job before it consume the wcet. All OK! */
proc_table[p].status = RM_WAIT;
if (m->pclass != JOB_PCLASS || (m->level != 0 && m->level != l) ) {
kern_raise(XINVALID_TASK, p);
return;
}
 
/* we reset the capacity counters... */
if (lev->flags & RM_ENABLE_WCET_CHECK)
proc_table[p].avail_time = proc_table[p].wcet;
job = (JOB_TASK_MODEL *)m;
 
/* when the deadline timer fire, it recognize the situation and set
correctly the task state to sleep... */
}
 
 
/* Guest Functions
These functions manages a JOB_TASK_MODEL, that is used to put
a guest task in the RM ready queue. */
 
static int RM_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
JOB_TASK_MODEL *job = (JOB_TASK_MODEL *)m;
 
/* if the RM_guest_create is called, then the pclass must be a
valid pclass. */
 
 
*iq_query_timespec(p,&lev->ready) = job->deadline;
*iq_query_priority(p, &lev->ready) = lev->period[p] = job->period;
lev->deadline_timer[p] = -1;
 
/* Insert task in the correct position */
iq_priority_insert(p,&lev->ready);
proc_table[p].status = RM_READY;
 
if (job->noraiseexc)
lev->flag[p] = RM_FLAG_NORAISEEXC;
else
else {
lev->flag[p] = 0;
 
*iq_query_priority(p, &lev->ready) = lev->period[p] = job->period;
 
/* there is no bandwidth guarantee at this level, it is performed
by the level that inserts guest tasks... */
 
return 0; /* OK, also if the task cannot be guaranteed... */
lev->deadline_timer[p] = kern_event_post(iq_query_timespec(p, &lev->ready),
RM_timer_guest_deadline,
(void *)p);
}
}
 
static void RM_guest_detach(LEVEL l, PID p)
static void RM_private_dispatch(LEVEL l, PID p, int nostop)
{
/* the RM level doesn't introduce any dinamic allocated new field.
No guarantee is performed on guest tasks... so we don't have to reset
the NO_GUARANTEE FIELD */
}
 
static void RM_guest_dispatch(LEVEL l, PID p, int nostop)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
/* the task state is set to EXE by the scheduler()
528,7 → 410,7
iq_extract(p, &lev->ready);
}
 
static void RM_guest_epilogue(LEVEL l, PID p)
static void RM_private_epilogue(LEVEL l, PID p)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
537,48 → 419,10
proc_table[p].status = RM_READY;
}
 
static void RM_guest_activate(LEVEL l, PID p)
static void RM_private_extract(LEVEL l, PID p)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
/* Insert task in the correct position */
iq_priority_insert(p,&lev->ready);
proc_table[p].status = RM_READY;
 
/* Set the deadline timer */
if (!(lev->flag[p] & RM_FLAG_NORAISEEXC))
lev->deadline_timer[p] = kern_event_post(iq_query_timespec(p, &lev->ready),
RM_timer_guest_deadline,
(void *)p);
}
 
static void RM_guest_insert(LEVEL l, PID p)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
/* Insert task in the correct position */
iq_priority_insert(p,&lev->ready);
proc_table[p].status = RM_READY;
}
 
static void RM_guest_extract(LEVEL l, PID p)
{
/* Extract the running task from the level
. we have already extract it from the ready queue at the dispatch time.
. the state of the task is set by the calling function
. the deadline must remain...
 
So, we do nothing!!!
*/
}
 
static void RM_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RM_guest_end(LEVEL l, PID p)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
 
//kern_printf("RM_guest_end: dline timer %d\n",lev->deadline_timer[p]);
if (proc_table[p].status == RM_READY)
{
589,23 → 433,17
/* we remove the deadline timer, because the slice is finished */
if (lev->deadline_timer[p] != NIL) {
// kern_printf("RM_guest_end: dline timer %d\n",lev->deadline_timer[p]);
event_delete(lev->deadline_timer[p]);
kern_event_delete(lev->deadline_timer[p]);
lev->deadline_timer[p] = NIL;
}
 
}
 
static void RM_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
 
 
/* Registration functions */
 
/*+ Registration function:
int flags the init flags ... see rm.h +*/
void RM_register_level(int flags)
LEVEL RM_register_level(int flags)
{
LEVEL l; /* the level that we register */
RM_level_des *lev; /* for readableness only */
614,54 → 452,34
printk("RM_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(RM_level_des));
 
/* alloc the space needed for the RM_level_des */
lev = (RM_level_des *)kern_alloc(sizeof(RM_level_des));
lev = (RM_level_des *)level_table[l];
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, RM_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = RM_LEVEL_CODE;
lev->l.level_version = RM_LEVEL_VERSION;
lev->l.private_insert = RM_private_insert;
lev->l.private_extract = RM_private_extract;
lev->l.private_dispatch = RM_private_dispatch;
lev->l.private_epilogue = RM_private_epilogue;
 
lev->l.level_accept_task_model = RM_level_accept_task_model;
lev->l.level_accept_guest_model = RM_level_accept_guest_model;
lev->l.level_status = RM_level_status;
lev->l.level_scheduler = RM_level_scheduler;
 
lev->l.public_scheduler = RM_public_scheduler;
if (flags & RM_ENABLE_GUARANTEE)
lev->l.level_guarantee = RM_level_guarantee;
lev->l.public_guarantee = RM_public_guarantee;
else
lev->l.level_guarantee = NULL;
lev->l.public_guarantee = NULL;
 
lev->l.task_create = RM_task_create;
lev->l.task_detach = RM_task_detach;
lev->l.task_eligible = RM_task_eligible;
lev->l.task_dispatch = RM_task_dispatch;
lev->l.task_epilogue = RM_task_epilogue;
lev->l.task_activate = RM_task_activate;
lev->l.task_insert = RM_task_insert;
lev->l.task_extract = RM_task_extract;
lev->l.task_endcycle = RM_task_endcycle;
lev->l.task_end = RM_task_end;
lev->l.task_sleep = RM_task_sleep;
lev->l.public_create = RM_public_create;
lev->l.public_detach = RM_public_detach;
lev->l.public_end = RM_public_end;
lev->l.public_dispatch = RM_public_dispatch;
lev->l.public_epilogue = RM_public_epilogue;
lev->l.public_activate = RM_public_activate;
lev->l.public_unblock = RM_public_unblock;
lev->l.public_block = RM_public_block;
lev->l.public_message = RM_public_message;
 
lev->l.guest_create = RM_guest_create;
lev->l.guest_detach = RM_guest_detach;
lev->l.guest_dispatch = RM_guest_dispatch;
lev->l.guest_epilogue = RM_guest_epilogue;
lev->l.guest_activate = RM_guest_activate;
lev->l.guest_insert = RM_guest_insert;
lev->l.guest_extract = RM_guest_extract;
lev->l.guest_endcycle = RM_guest_endcycle;
lev->l.guest_end = RM_guest_end;
lev->l.guest_sleep = RM_guest_sleep;
 
/* fill the RM descriptor part */
for(i=0; i<MAX_PROC; i++) {
lev->period[i] = 0;
672,15 → 490,14
iq_init(&lev->ready, &freedesc, 0);
lev->flags = flags & 0x07;
lev->U = 0;
 
return l;
}
 
bandwidth_t RM_usedbandwidth(LEVEL l)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
if (lev->l.level_code == RM_LEVEL_CODE &&
lev->l.level_version == RM_LEVEL_VERSION)
return lev->U;
else
return 0;
 
return lev->U;
}
 
/shark/trunk/kernel/modules/rrsoft.c
20,11 → 20,11
 
/**
------------
CVS : $Id: rrsoft.c,v 1.3 2002-11-11 08:32:07 pj Exp $
CVS : $Id: rrsoft.c,v 1.4 2003-01-07 17:07:51 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:07 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:51 $
------------
 
This file contains the scheduling module RRSOFT (Round Robin)
60,6 → 60,7
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
/*+ Status used in the level +*/
#define RRSOFT_READY MODULE_STATUS_BASE
92,19 → 93,6
} RRSOFT_level_des;
 
 
static char *RRSOFT_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case RRSOFT_READY: return "RRSOFT_Ready";
case RRSOFT_IDLE : return "RRSOFT_Idle";
default : return "RRSOFT_Unknown";
}
}
 
 
/* this is the periodic reactivation of the task... it is posted only
if the task is a periodic task */
static void RRSOFT_timer_reactivate(void *par)
137,53 → 125,11
// trc_logevent(TRC_INTACTIVATION,&p);
}
 
 
static int RRSOFT_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
if ((m->pclass == NRT_PCLASS || m->pclass == (NRT_PCLASS | l)) && lev->models & RRSOFT_ONLY_NRT)
return 0;
else if ((m->pclass == SOFT_PCLASS || m->pclass == (SOFT_PCLASS | l)) && lev->models & RRSOFT_ONLY_SOFT)
return 0;
else if ((m->pclass == HARD_PCLASS || m->pclass == (HARD_PCLASS | l)) && lev->models & RRSOFT_ONLY_HARD)
return 0;
else
return -1;
}
 
static int RRSOFT_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
return -1;
}
 
static void RRSOFT_level_status(LEVEL l)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->ready);
 
kern_printf("Slice: %d \n", lev->slice);
 
while (p != NIL) {
kern_printf("Pid: %d\t Name: %20s Status: %s\n",p,proc_table[p].name,
RRSOFT_status_to_a(proc_table[p].status));
p = iq_query_next(p, &lev->ready);
}
 
for (p=0; p<MAX_PROC; p++)
if (proc_table[p].task_level == l && proc_table[p].status != RRSOFT_READY
&& proc_table[p].status != FREE )
kern_printf("Pid: %d\t Name: %20s Status: %s\n",p,proc_table[p].name,
RRSOFT_status_to_a(proc_table[p].status));
 
}
 
 
/* This is not efficient but very fair :-)
The need of all this stuff is because if a task execute a long time
due to (shadow!) priority inheritance, then the task shall go to the
tail of the queue many times... */
static PID RRSOFT_level_scheduler(LEVEL l)
static PID RRSOFT_public_scheduler(LEVEL l)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
208,17 → 154,8
}
}
 
static int RRSOFT_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int RRSOFT_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
/* the RRSOFT level always guarantee... the function is defined because
there can be an aperiodic server at a level with less priority than
the RRSOFT that need guarantee (e.g., a TBS server) */
return 1;
}
 
 
static int RRSOFT_task_create(LEVEL l, PID p, TASK_MODEL *m)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
// kern_printf("create %d mod %d\n",p,m->pclass);
226,6 → 163,11
the only thing to set remains the capacity stuffs that are set
to the values passed in the model... */
 
if ( !(m->pclass==NRT_PCLASS && lev->models & RRSOFT_ONLY_NRT ) ) return -1;
if ( !(m->pclass==SOFT_PCLASS && lev->models & RRSOFT_ONLY_SOFT) ) return -1;
if ( !(m->pclass==HARD_PCLASS && lev->models & RRSOFT_ONLY_HARD) ) return -1;
if (m->level != 0 && m->level != l) return -1;
 
/* I used the wcet field because using wcet can account if a task
consume more than the timeslice... */
 
289,22 → 231,9
return 0; /* OK */
}
 
static void RRSOFT_task_detach(LEVEL l, PID p)
static void RRSOFT_public_dispatch(LEVEL l, PID p, int nostop)
{
/* the RRSOFT level doesn't introduce any new field in the TASK_MODEL
so, all detach stuffs are done by the task_create
The task state is set at FREE by the general task_create */
}
 
static int RRSOFT_task_eligible(LEVEL l, PID p)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void RRSOFT_task_dispatch(LEVEL l, PID p, int nostop)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
//static int p2count=0;
 
/* the task state is set EXE by the scheduler()
we extract the task from the ready queue
312,7 → 241,7
iq_extract(p, &lev->ready);
}
 
static void RRSOFT_task_epilogue(LEVEL l, PID p)
static void RRSOFT_public_epilogue(LEVEL l, PID p)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
329,7 → 258,7
proc_table[p].status = RRSOFT_READY;
}
 
static void RRSOFT_task_activate(LEVEL l, PID p)
static void RRSOFT_public_activate(LEVEL l, PID p)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
341,9 → 270,7
return;
}
 
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
 
/* Insert task in the coRRSOFTect position */
/* Insert task in the correct position */
proc_table[p].status = RRSOFT_READY;
iq_insertlast(p,&lev->ready);
 
350,9 → 277,8
/* Set the reactivation timer */
if (lev->periodic[p])
{
TIMESPEC_ASSIGN(&lev->reactivation_time[p], &proc_table[p].request_time);
kern_gettime(&lev->reactivation_time[p]);
ADDUSEC2TIMESPEC(lev->period[p], &lev->reactivation_time[p]);
// TIMESPEC_ASSIGN(&lev->reactivation_time[p], &lev->cbs_dline[p]);
lev->reactivation_timer[p] = kern_event_post(&lev->reactivation_time[p],
RRSOFT_timer_reactivate,
(void *)p);
359,12 → 285,12
}
}
 
static void RRSOFT_task_insert(LEVEL l, PID p)
static void RRSOFT_public_unblock(LEVEL l, PID p)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
/* Similar to RRSOFT_task_activate, but we don't check in what state
the task is and we don't set the request_time */
the task is */
 
/* Insert task in the coRRSOFTect position */
proc_table[p].status = RRSOFT_READY;
371,7 → 297,7
iq_insertlast(p,&lev->ready);
}
 
static void RRSOFT_task_extract(LEVEL l, PID p)
static void RRSOFT_public_block(LEVEL l, PID p)
{
/* Extract the running task from the level
. we have already extract it from the ready queue at the dispatch time.
383,13 → 309,12
*/
}
 
static void RRSOFT_task_endcycle(LEVEL l, PID p)
static int RRSOFT_public_message(LEVEL l, PID p, void *m)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
if (lev->nact[p] > 0) {
/* continue!!!! */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
lev->nact[p]--;
// qq_insertlast(p,&lev->ready);
iq_insertfirst(p,&lev->ready);
397,9 → 322,14
}
else
proc_table[p].status = RRSOFT_IDLE;
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
return 0;
}
 
static void RRSOFT_task_end(LEVEL l, PID p)
static void RRSOFT_public_end(LEVEL l, PID p)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
407,7 → 337,7
 
/* we delete the reactivation timer */
if (lev->periodic[p]) {
event_delete(lev->reactivation_timer[p]);
kern_event_delete(lev->reactivation_timer[p]);
lev->reactivation_timer[p] = -1;
}
 
416,53 → 346,6
iq_insertlast(p,&freedesc);
}
 
static void RRSOFT_task_sleep(LEVEL l, PID p)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
 
if (lev->nact[p] >= 0) lev->nact[p] = 0;
 
/* we delete the reactivation timer */
if (lev->periodic[p]) {
event_delete(lev->reactivation_timer[p]);
lev->reactivation_timer[p] = -1;
}
 
proc_table[p].status = SLEEP;
}
 
static int RRSOFT_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void RRSOFT_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RRSOFT_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RRSOFT_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RRSOFT_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RRSOFT_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RRSOFT_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RRSOFT_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RRSOFT_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RRSOFT_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
 
/* Registration functions */
 
/*+ This init function install the "main" task +*/
490,7 → 373,7
if (p == NIL)
printk("\nPanic!!! can't create main task...\n");
 
RRSOFT_task_activate(lev,p);
RRSOFT_public_activate(lev,p);
}
 
 
498,7 → 381,7
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void RRSOFT_register_level(TIME slice,
LEVEL RRSOFT_register_level(TIME slice,
int createmain,
struct multiboot_info *mb,
BYTE models)
510,50 → 393,23
printk("RRSOFT_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(RRSOFT_level_des));
 
/* alloc the space needed for the RRSOFT_level_des */
lev = (RRSOFT_level_des *)kern_alloc(sizeof(RRSOFT_level_des));
lev = (RRSOFT_level_des *)level_table[l];
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, RRSOFT_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = RRSOFT_LEVEL_CODE;
lev->l.level_version = RRSOFT_LEVEL_VERSION;
lev->l.public_scheduler = RRSOFT_public_scheduler;
lev->l.public_create = RRSOFT_public_create;
lev->l.public_end = RRSOFT_public_end;
lev->l.public_dispatch = RRSOFT_public_dispatch;
lev->l.public_epilogue = RRSOFT_public_epilogue;
lev->l.public_activate = RRSOFT_public_activate;
lev->l.public_unblock = RRSOFT_public_unblock;
lev->l.public_block = RRSOFT_public_block;
lev->l.public_message = RRSOFT_public_message;
 
lev->l.level_accept_task_model = RRSOFT_level_accept_task_model;
lev->l.level_accept_guest_model = RRSOFT_level_accept_guest_model;
lev->l.level_status = RRSOFT_level_status;
lev->l.level_scheduler = RRSOFT_level_scheduler;
lev->l.level_guarantee = RRSOFT_level_guarantee;
 
lev->l.task_create = RRSOFT_task_create;
lev->l.task_detach = RRSOFT_task_detach;
lev->l.task_eligible = RRSOFT_task_eligible;
lev->l.task_dispatch = RRSOFT_task_dispatch;
lev->l.task_epilogue = RRSOFT_task_epilogue;
lev->l.task_activate = RRSOFT_task_activate;
lev->l.task_insert = RRSOFT_task_insert;
lev->l.task_extract = RRSOFT_task_extract;
lev->l.task_endcycle = RRSOFT_task_endcycle;
lev->l.task_end = RRSOFT_task_end;
lev->l.task_sleep = RRSOFT_task_sleep;
 
lev->l.guest_create = RRSOFT_guest_create;
lev->l.guest_detach = RRSOFT_guest_detach;
lev->l.guest_dispatch = RRSOFT_guest_dispatch;
lev->l.guest_epilogue = RRSOFT_guest_epilogue;
lev->l.guest_activate = RRSOFT_guest_activate;
lev->l.guest_insert = RRSOFT_guest_insert;
lev->l.guest_extract = RRSOFT_guest_extract;
lev->l.guest_endcycle = RRSOFT_guest_endcycle;
lev->l.guest_end = RRSOFT_guest_end;
lev->l.guest_sleep = RRSOFT_guest_sleep;
 
/* fill the RRSOFT descriptor part */
for (i = 0; i < MAX_PROC; i++) {
lev->nact[i] = -1;
575,6 → 431,8
 
if (createmain)
sys_atrunlevel(RRSOFT_call_main,(void *) l, RUNLEVEL_INIT);
 
return l;
}
 
 
/shark/trunk/kernel/modules/ps.c
20,11 → 20,11
 
/**
------------
CVS : $Id: ps.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: ps.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the aperiodic server PS (Polling Server)
103,6 → 103,7
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
/*+ Status used in the level +*/
#define PS_WAIT APER_STATUS_BASE /*+ waiting the service +*/
145,8 → 146,7
m = lev->scheduling_level;
job_task_default_model(j,lev->lastdline);
job_task_def_period(j,lev->period);
level_table[m]->guest_create(m,p,(TASK_MODEL *)&j);
level_table[m]->guest_activate(m,p);
level_table[m]->private_insert(m,p,(TASK_MODEL *)&j);
// kern_printf("(%d %d)",lev->lastdline.tv_sec,lev->lastdline.tv_nsec);
}
 
180,80 → 180,8
// kern_printf("!");
}
 
static char *PS_status_to_a(WORD status)
static PID PS_public_schedulerbackground(LEVEL l)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case PS_WAIT : return "PS_Wait";
default : return "PS_Unknown";
}
}
 
 
static int PS_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == SOFT_PCLASS || m->pclass == (SOFT_PCLASS | l) ) {
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m;
 
if (s->periodicity == APERIODIC)
return 0;
}
return -1;
}
 
static int PS_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
return -1;
}
 
static char *onoff(int i)
{
if (i)
return "On ";
else
return "Off";
}
 
static void PS_level_status(LEVEL l)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->wait);
 
kern_printf("On-line guarantee : %s\n",
onoff(lev->flags & PS_ENABLE_GUARANTEE_EDF ||
lev->flags & PS_ENABLE_GUARANTEE_RM ));
kern_printf("Used Bandwidth : %u/%u\n",
lev->U, MAX_BANDWIDTH);
 
if (lev->activated != -1)
kern_printf("Activated: Pid: %2d Name: %10s Dl: %ld.%ld Nact: %d Stat: %s\n",
lev->activated,
proc_table[lev->activated].name,
iq_query_timespec(lev->activated,&lev->wait)->tv_sec,
iq_query_timespec(lev->activated,&lev->wait)->tv_nsec,
lev->nact[lev->activated],
PS_status_to_a(proc_table[lev->activated].status));
 
while (p != NIL) {
kern_printf("Pid: %2d Name: %10s Stat: %s\n",
p,
proc_table[p].name,
PS_status_to_a(proc_table[p].status));
p = iq_query_next(p, &lev->wait);
}
}
 
static PID PS_level_scheduler(LEVEL l)
{
/* the PS don't schedule anything...
it's an EDF level or similar that do it! */
return NIL;
}
 
static PID PS_level_schedulerbackground(LEVEL l)
{
/* the PS catch the background time to exec aperiodic activities */
PS_level_des *lev = (PS_level_des *)(level_table[l]);
 
266,7 → 194,7
}
 
/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int PS_level_guaranteeEDF(LEVEL l, bandwidth_t *freebandwidth)
static int PS_public_guaranteeEDF(LEVEL l, bandwidth_t *freebandwidth)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
 
278,7 → 206,7
return 0;
}
 
static int PS_level_guaranteeRM(LEVEL l, bandwidth_t *freebandwidth)
static int PS_public_guaranteeRM(LEVEL l, bandwidth_t *freebandwidth)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
 
290,13 → 218,17
return 0;
}
 
static int PS_task_create(LEVEL l, PID p, TASK_MODEL *m)
static int PS_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
SOFT_TASK_MODEL *s;
 
/* if the PS_task_create is called, then the pclass must be a
valid pclass. */
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m;
if (m->pclass != SOFT_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
s = (SOFT_TASK_MODEL *)m;
if (s->periodicity != APERIODIC) return -1;
s = (SOFT_TASK_MODEL *)m;
 
if (s->arrivals == SAVE_ARRIVALS)
lev->nact[p] = 0;
306,18 → 238,8
return 0; /* OK, also if the task cannot be guaranteed... */
}
 
static void PS_task_detach(LEVEL l, PID p)
static void PS_public_dispatch(LEVEL l, PID p, int nostop)
{
/* the PS level doesn't introduce any dinamic allocated new field. */
}
 
static int PS_task_eligible(LEVEL l, PID p)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void PS_task_dispatch(LEVEL l, PID p, int nostop)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
struct timespec ty;
 
333,7 → 255,7
else {
//if (nostop) kern_printf("(gd status=%d)",proc_table[p].status);
level_table[ lev->scheduling_level ]->
guest_dispatch(lev->scheduling_level,p,nostop);
private_dispatch(lev->scheduling_level,p,nostop);
}
 
/* set the capacity timer */
346,7 → 268,7
// kern_printf("(disp %d %d)",ty.tv_sec, ty.tv_nsec);
}
 
static void PS_task_epilogue(LEVEL l, PID p)
static void PS_public_epilogue(LEVEL l, PID p)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
struct timespec ty;
378,7 → 300,7
task point the shadow to it!!!*/
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = PS_WAIT;
lev->activated = NIL;
388,7 → 310,7
wait queue by calling the guest_epilogue... */
if (lev->activated == p) {//kern_printf("Û1");
level_table[ lev->scheduling_level ]->
guest_epilogue(lev->scheduling_level,p);
private_epilogue(lev->scheduling_level,p);
} else { //kern_printf("Û2");
iq_insertfirst(p, &lev->wait);
proc_table[p].status = PS_WAIT;
395,7 → 317,7
}
}
 
static void PS_task_activate(LEVEL l, PID p)
static void PS_public_activate(LEVEL l, PID p)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
 
404,7 → 326,6
lev->nact[p]++;
}
else if (proc_table[p].status == SLEEP) {
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
 
if (lev->activated == NIL && lev->availCs > 0) {
lev->activated = p;
421,7 → 342,7
 
}
 
static void PS_task_insert(LEVEL l, PID p)
static void PS_public_unblock(LEVEL l, PID p)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
 
435,7 → 356,7
proc_table[p].status = PS_WAIT;
}
 
static void PS_task_extract(LEVEL l, PID p)
static void PS_public_block(LEVEL l, PID p)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
 
446,10 → 367,10
 
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
}
 
static void PS_task_endcycle(LEVEL l, PID p)
static int PS_public_message(LEVEL l, PID p, void *m)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
struct timespec ty;
466,7 → 387,7
 
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
else
iq_extract(p, &lev->wait);
 
484,9 → 405,14
lev->availCs = 0; /* see note (*) at the begin of the file */
else
PS_activation(lev);
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
return 0;
}
 
static void PS_task_end(LEVEL l, PID p)
static void PS_public_end(LEVEL l, PID p)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
struct timespec ty;
503,7 → 429,7
 
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
 
proc_table[p].status = FREE;
iq_insertfirst(p,&freedesc);
515,72 → 441,6
PS_activation(lev);
}
 
static void PS_task_sleep(LEVEL l, PID p)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
struct timespec ty;
TIME tx;
 
/* update the server capacity */
if (lev->flags & PS_BACKGROUND)
lev->flags &= ~PS_BACKGROUND;
else {
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
lev->availCs -= tx;
}
 
if (lev->nact[p] >= 0) lev->nact[p] = 0;
 
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
else
iq_extract(p, &lev->wait);
 
proc_table[p].status = SLEEP;
 
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated == NIL)
lev->availCs = 0; /* see note (*) at the begin of the file */
else
PS_activation(lev);
}
 
 
static int PS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void PS_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void PS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void PS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void PS_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void PS_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void PS_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void PS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void PS_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void PS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
 
 
/* Registration functions */
 
 
590,7 → 450,7
{
PS_level_des *lev = (PS_level_des *)(level_table[(LEVEL)l]);
 
ll_gettime(TIME_EXACT,&lev->lastdline);
kern_gettime(&lev->lastdline);
ADDUSEC2TIMESPEC(lev->period, &lev->lastdline);
 
kern_event_post(&lev->lastdline, PS_deadline_timer, l);
600,7 → 460,7
 
/*+ Registration function:
int flags the init flags ... see PS.h +*/
void PS_register_level(int flags, LEVEL master, int Cs, int per)
LEVEL PS_register_level(int flags, LEVEL master, int Cs, int per)
{
LEVEL l; /* the level that we register */
PS_level_des *lev; /* for readableness only */
609,62 → 469,33
printk("PS_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(PS_level_des));
 
printk(" alloco descrittore %d %d\n",l,(int)sizeof(PS_level_des));
lev = (PS_level_des *)level_table[l];
 
/* alloc the space needed for the PS_level_des */
lev = (PS_level_des *)kern_alloc(sizeof(PS_level_des));
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, PS_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = PS_LEVEL_CODE;
lev->l.level_version = PS_LEVEL_VERSION;
 
lev->l.level_accept_task_model = PS_level_accept_task_model;
lev->l.level_accept_guest_model = PS_level_accept_guest_model;
lev->l.level_status = PS_level_status;
 
if (flags & PS_ENABLE_BACKGROUND)
lev->l.level_scheduler = PS_level_schedulerbackground;
else
lev->l.level_scheduler = PS_level_scheduler;
lev->l.public_scheduler = PS_public_schedulerbackground;
 
if (flags & PS_ENABLE_GUARANTEE_EDF)
lev->l.level_guarantee = PS_level_guaranteeEDF;
lev->l.public_guarantee = PS_public_guaranteeEDF;
else if (flags & PS_ENABLE_GUARANTEE_RM)
lev->l.level_guarantee = PS_level_guaranteeRM;
lev->l.public_guarantee = PS_public_guaranteeRM;
else
lev->l.level_guarantee = NULL;
lev->l.public_guarantee = NULL;
 
lev->l.task_create = PS_task_create;
lev->l.task_detach = PS_task_detach;
lev->l.task_eligible = PS_task_eligible;
lev->l.task_dispatch = PS_task_dispatch;
lev->l.task_epilogue = PS_task_epilogue;
lev->l.task_activate = PS_task_activate;
lev->l.task_insert = PS_task_insert;
lev->l.task_extract = PS_task_extract;
lev->l.task_endcycle = PS_task_endcycle;
lev->l.task_end = PS_task_end;
lev->l.task_sleep = PS_task_sleep;
lev->l.public_create = PS_public_create;
lev->l.public_end = PS_public_end;
lev->l.public_dispatch = PS_public_dispatch;
lev->l.public_epilogue = PS_public_epilogue;
lev->l.public_activate = PS_public_activate;
lev->l.public_unblock = PS_public_unblock;
lev->l.public_block = PS_public_block;
lev->l.public_message = PS_public_message;
 
lev->l.guest_create = PS_guest_create;
lev->l.guest_detach = PS_guest_detach;
lev->l.guest_dispatch = PS_guest_dispatch;
lev->l.guest_epilogue = PS_guest_epilogue;
lev->l.guest_activate = PS_guest_activate;
lev->l.guest_insert = PS_guest_insert;
lev->l.guest_extract = PS_guest_extract;
lev->l.guest_endcycle = PS_guest_endcycle;
lev->l.guest_end = PS_guest_end;
lev->l.guest_sleep = PS_guest_sleep;
 
/* fill the PS descriptor part */
 
for (i=0; i<MAX_PROC; i++)
685,15 → 516,14
lev->flags = flags & 0x07;
 
sys_atrunlevel(PS_dline_install,(void *) l, RUNLEVEL_INIT);
 
return l;
}
 
bandwidth_t PS_usedbandwidth(LEVEL l)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
if (lev->l.level_code == PS_LEVEL_CODE &&
lev->l.level_version == PS_LEVEL_VERSION)
return lev->U;
else
return 0;
return lev->U;
}
 
/shark/trunk/kernel/modules/rr.c
20,11 → 20,11
 
/**
------------
CVS : $Id: rr.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: rr.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the scheduling module RR (Round Robin)
60,7 → 60,12
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
//#define RRDEBUG
 
#define rr_printf kern_printf
 
/*+ Status used in the level +*/
#define RR_READY MODULE_STATUS_BASE
 
76,67 → 81,29
the main task +*/
} RR_level_des;
 
 
static char *RR_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case RR_READY: return "RR_Ready";
default : return "RR_Unknown";
}
}
 
static int RR_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == NRT_PCLASS || m->pclass == (NRT_PCLASS | l))
return 0;
else
return -1;
}
 
static int RR_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
return -1;
}
 
static void RR_level_status(LEVEL l)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->ready);
 
kern_printf("Slice: %d \n", lev->slice);
 
while (p != NIL) {
kern_printf("Pid: %d\t Name: %20s Status: %s\n",p,proc_table[p].name,
RR_status_to_a(proc_table[p].status));
p = iq_query_next(p,&lev->ready);
}
 
for (p=0; p<MAX_PROC; p++)
if (proc_table[p].task_level == l && proc_table[p].status != RR_READY
&& proc_table[p].status != FREE )
kern_printf("Pid: %d\t Name: %20s Status: %s\n",p,proc_table[p].name,
RR_status_to_a(proc_table[p].status));
 
}
 
 
/* This is not efficient but very fair :-)
The need of all this stuff is because if a task execute a long time
due to (shadow!) priority inheritance, then the task shall go to the
tail of the queue many times... */
static PID RR_level_scheduler(LEVEL l)
static PID RR_public_scheduler(LEVEL l)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
 
PID p;
 
#ifdef RRDEBUG
rr_printf("(RRs",p);
#endif
 
for (;;) {
p = iq_query_first(&lev->ready);
if (p == -1)
 
if (p == -1) {
#ifdef RRDEBUG
rr_printf(" %d)",p);
#endif
return p;
}
 
if (proc_table[p].avail_time <= 0) {
proc_table[p].avail_time += proc_table[p].wcet;
143,25 → 110,28
iq_extract(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
else
else {
#ifdef RRDEBUG
rr_printf(" %d)",p);
#endif
return p;
}
}
}
 
static int RR_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int RR_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
/* the RR level always guarantee... the function is defined because
there can be an aperiodic server at a level with less priority than
the RR that need guarantee (e.g., a TBS server) */
return 1;
}
RR_level_des *lev = (RR_level_des *)(level_table[l]);
NRT_TASK_MODEL *nrt;
 
#ifdef RRDEBUG
rr_printf("(create %d!!!!)",p);
#endif
 
static int RR_task_create(LEVEL l, PID p, TASK_MODEL *m)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
NRT_TASK_MODEL *nrt = (NRT_TASK_MODEL *)m;
if (m->pclass != NRT_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
 
nrt = (NRT_TASK_MODEL *)m;
/* the task state is set at SLEEP by the general task_create
the only thing to set remains the capacity stuffs that are set
to the values passed in the model... */
179,23 → 149,14
}
proc_table[p].control |= CONTROL_CAP;
 
#ifdef RRDEBUG
rr_printf("(c%d av%d w%d )",p,proc_table[p].avail_time,proc_table[p].wcet);
#endif
return 0; /* OK */
}
 
static void RR_task_detach(LEVEL l, PID p)
static void RR_public_dispatch(LEVEL l, PID p, int nostop)
{
/* the RR level doesn't introduce any new field in the TASK_MODEL
so, all detach stuffs are done by the task_create
The task state is set at FREE by the general task_create */
}
 
static int RR_task_eligible(LEVEL l, PID p)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void RR_task_dispatch(LEVEL l, PID p, int nostop)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
 
/* the task state is set EXE by the scheduler()
202,9 → 163,13
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
iq_extract(p, &lev->ready);
 
#ifdef RRDEBUG
rr_printf("(dis%d)",p);
#endif
}
 
static void RR_task_epilogue(LEVEL l, PID p)
static void RR_public_epilogue(LEVEL l, PID p)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
 
219,9 → 184,13
iq_insertfirst(p,&lev->ready);
 
proc_table[p].status = RR_READY;
 
#ifdef RRDEBUG
rr_printf("(epi%d)",p);
#endif
}
 
static void RR_task_activate(LEVEL l, PID p)
static void RR_public_activate(LEVEL l, PID p)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
 
230,26 → 199,33
if (proc_table[p].status != SLEEP)
return;
 
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
 
/* Insert task in the correct position */
proc_table[p].status = RR_READY;
iq_insertlast(p,&lev->ready);
 
#ifdef RRDEBUG
rr_printf("(act%d)",p);
#endif
 
}
 
static void RR_task_insert(LEVEL l, PID p)
static void RR_public_unblock(LEVEL l, PID p)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
 
/* Similar to RR_task_activate, but we don't check in what state
the task is and we don't set the request_time */
/* Similar to RR_task_activate,
but we don't check in what state the task is */
 
/* Insert task in the correct position */
proc_table[p].status = RR_READY;
iq_insertlast(p,&lev->ready);
 
#ifdef RRDEBUG
rr_printf("(ubl%d)",p);
#endif
}
 
static void RR_task_extract(LEVEL l, PID p)
static void RR_public_block(LEVEL l, PID p)
{
/* Extract the running task from the level
. we have already extract it from the ready queue at the dispatch time.
259,64 → 235,36
 
So, we do nothing!!!
*/
#ifdef RRDEBUG
rr_printf("(bl%d)",p);
#endif
}
 
static void RR_task_endcycle(LEVEL l, PID p)
static int RR_public_message(LEVEL l, PID p, void *m)
{
// RR_level_des *lev = (RR_level_des *)(level_table[l]);
proc_table[p].status = SLEEP;
 
/* this function is equal to the RR_task_extract, except that
the task fall asleep... */
proc_table[p].status = SLEEP;
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
#ifdef RRDEBUG
rr_printf("(msg%d)",p);
#endif
return 0;
}
 
static void RR_task_end(LEVEL l, PID p)
static void RR_public_end(LEVEL l, PID p)
{
// RR_level_des *lev = (RR_level_des *)(level_table[l]);
 
/* we insert the task in the free queue */
proc_table[p].status = FREE;
iq_insertlast(p,&freedesc);
}
 
static void RR_task_sleep(LEVEL l, PID p)
{
proc_table[p].status = SLEEP;
#ifdef RRDEBUG
rr_printf("(end%d)",p);
#endif
}
 
static int RR_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void RR_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void RR_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
 
 
/* Registration functions */
 
/*+ This init function install the "main" task +*/
342,9 → 290,13
p = task_create("Main", __init__, (TASK_MODEL *)&m, NULL);
 
if (p == NIL)
kern_printf("\nPanic!!! can't create main task... errno =%d\n",errno);
printk(KERN_EMERG "Panic!!! can't create main task... errno =%d\n",errno);
 
RR_task_activate(lev,p);
RR_public_activate(lev,p);
 
#ifdef RRDEBUG
rr_printf("(main created %d)",p);
#endif
}
 
 
352,7 → 304,7
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void RR_register_level(TIME slice,
LEVEL RR_register_level(TIME slice,
int createmain,
struct multiboot_info *mb)
{
362,50 → 314,23
printk("RR_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(RR_level_des));
 
/* alloc the space needed for the RR_level_des */
lev = (RR_level_des *)kern_alloc(sizeof(RR_level_des));
lev = (RR_level_des *)level_table[l];
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, RR_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = RR_LEVEL_CODE;
lev->l.level_version = RR_LEVEL_VERSION;
lev->l.public_scheduler = RR_public_scheduler;
lev->l.public_create = RR_public_create;
lev->l.public_end = RR_public_end;
lev->l.public_dispatch = RR_public_dispatch;
lev->l.public_epilogue = RR_public_epilogue;
lev->l.public_activate = RR_public_activate;
lev->l.public_unblock = RR_public_unblock;
lev->l.public_block = RR_public_block;
lev->l.public_message = RR_public_message;
 
lev->l.level_accept_task_model = RR_level_accept_task_model;
lev->l.level_accept_guest_model = RR_level_accept_guest_model;
lev->l.level_status = RR_level_status;
lev->l.level_scheduler = RR_level_scheduler;
lev->l.level_guarantee = RR_level_guarantee;
 
lev->l.task_create = RR_task_create;
lev->l.task_detach = RR_task_detach;
lev->l.task_eligible = RR_task_eligible;
lev->l.task_dispatch = RR_task_dispatch;
lev->l.task_epilogue = RR_task_epilogue;
lev->l.task_activate = RR_task_activate;
lev->l.task_insert = RR_task_insert;
lev->l.task_extract = RR_task_extract;
lev->l.task_endcycle = RR_task_endcycle;
lev->l.task_end = RR_task_end;
lev->l.task_sleep = RR_task_sleep;
 
lev->l.guest_create = RR_guest_create;
lev->l.guest_detach = RR_guest_detach;
lev->l.guest_dispatch = RR_guest_dispatch;
lev->l.guest_epilogue = RR_guest_epilogue;
lev->l.guest_activate = RR_guest_activate;
lev->l.guest_insert = RR_guest_insert;
lev->l.guest_extract = RR_guest_extract;
lev->l.guest_endcycle = RR_guest_endcycle;
lev->l.guest_end = RR_guest_end;
lev->l.guest_sleep = RR_guest_sleep;
 
/* fill the RR descriptor part */
iq_init(&lev->ready, &freedesc, 0);
 
417,6 → 342,6
 
if (createmain)
sys_atrunlevel(RR_call_main,(void *) l, RUNLEVEL_INIT);
 
return l;
}
 
 
/shark/trunk/kernel/modules/sem.c
20,11 → 20,11
 
/**
------------
CVS : $Id: sem.c,v 1.2 2002-11-11 08:32:07 pj Exp $
CVS : $Id: sem.c,v 1.3 2003-01-07 17:07:51 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:32:07 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:51 $
------------
 
This file contains the Hartik 3.3.1 Semaphore functions
115,7 → 115,7
iq_extract(i,&sem_table[ sp_table[i].sem ].blocked);
 
l = proc_table[i].task_level;
level_table[l]->task_insert(l,i);
level_table[l]->public_unblock(l,i);
 
return 1;
}
350,25 → 350,14
if (s1->blocked.first != NIL || s1->count == 0) {
/* We must block exec task */
LEVEL l; /* for readableness only */
TIME tx; /* a dummy TIME for timespec operations */
struct timespec ty; /* a dummy timespec for timespec operations */
 
/* tracer stuff */
trc_logevent(TRC_SEM_WAIT,s);
 
/* 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 semaphore queue */
proc_table[exec_shadow].status = WAIT_SEM;
476,25 → 465,14
if (s1->blocked.first != NIL || s1->count < n) {
/* We must block exec task */
LEVEL l; /* for readableness only */
TIME tx; /* a dummy TIME for timespec operations */
struct timespec ty; /* a dummy timespec for timespec operations */
 
/* tracer */
trc_logevent(TRC_SEM_WAIT,s);
 
/* 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 semaphore queue */
proc_table[exec_shadow].status = WAIT_SEM;
557,7 → 535,7
iq_extract(p,&s1->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
/* only a task can be awaken */
/* Preempt if necessary */
event_need_reschedule();
582,7 → 560,7
iq_extract(p,&s1->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
/* only a task can be awaken */
/* Preempt if necessary */
scheduler();
630,7 → 608,7
iq_extract(p,&s1->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
/* Next task to wake */
p = s1->blocked.first;
660,7 → 638,7
iq_extract(p,&s1->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
/* Next task to wake */
p = s1->blocked.first;
/shark/trunk/kernel/modules/ss.c
20,11 → 20,11
 
/**
------------
CVS : $Id: ss.c,v 1.3 2002-11-11 08:32:07 pj Exp $
CVS : $Id: ss.c,v 1.4 2003-01-07 17:07:51 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:07 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:51 $
------------
 
This file contains the aperiodic Sporadic Server (SS).
125,6 → 125,7
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
/* For debugging purpose */
//#define DEBUG 1
174,7 → 175,7
} SS_level_des;
 
/*+ function prototypes +*/
void SS_level_status(LEVEL l);
void SS_internal_status(LEVEL l);
static void SS_replenish_timer(void *arg);
/*-------------------------------------------------------------------*/
 
313,7 → 314,7
if(ssq_inslast(l, lev->replenish_amount) == NIL) {
kern_printf("SS: no more space to post replenishment\n");
kern_printf("You should recompile setting higher SS_MAX_REPLENISH into include/modules/ss.h\n");
SS_level_status(l);
SS_internal_status(l);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
324,7 → 325,7
}
else {
kern_printf("SS not active when posting R.A.\n");
SS_level_status(l);
SS_internal_status(l);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
368,8 → 369,7
 
job_task_default_model(j,lev->lastdline);
job_task_def_period(j,lev->period);
level_table[m]->guest_create(m,p,(TASK_MODEL *)&j);
level_table[m]->guest_activate(m,p);
level_table[m]->private_insert(m,p,(TASK_MODEL *)&j);
 
#ifdef DEBUG
kern_printf("PID:%p lastdl:%d.%d ",p,lev->lastdline.tv_sec,lev->lastdline.tv_nsec);
400,7 → 400,7
if(ssq_inslast(l, tx+lev->replenish_amount) == NIL) {
kern_printf("SS: no more space to post replenishment\n");
kern_printf(" You should recompile setting higher SS_MAX_REPLENISH into include/modules/ss.h\n");
SS_level_status(l);
SS_internal_status(l);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
456,7 → 456,7
else {
/* replenish queue is empty */
kern_printf("Replenish Timer fires but no Replenish Amount defined\n");
SS_level_status(l);
SS_internal_status(l);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
471,7 → 471,7
if (lev->server_active == SS_SERVER_NOTACTIVE) {
lev->server_active = SS_SERVER_ACTIVE;
/* set replenish time */
ll_gettime(TIME_EXACT, &ty);
kern_gettime(&ty);
ADDUSEC2TIMESPEC(lev->period, &ty);
TIMESPEC_ASSIGN(&lev->lastdline, &ty);
#ifdef DEBUG
488,7 → 488,7
static char *SS_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
return "Unavailable"; //status_to_a(status);
 
switch (status) {
case SS_WAIT : return "SS_Wait";
501,40 → 501,8
 
/*** Level functions ***/
 
 
static int SS_level_accept_task_model(LEVEL l, TASK_MODEL *m)
void SS_internal_status(LEVEL l)
{
#ifdef DEBUG
kern_printf("SS_levacctm cl=%d ",m->pclass);
#endif
 
if (m->pclass == SOFT_PCLASS || m->pclass == (SOFT_PCLASS | l) ) {
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m;
 
if (s->periodicity == APERIODIC) {
#ifdef DEBUG
kern_printf("AcceptApe ");
#endif
return 0;
}
#ifdef DEBUG
kern_printf("NAcceptApe ");
#endif
}
#ifdef DEBUG
kern_printf("NAccept ");
#endif
return -1;
}
 
static int SS_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
/* SS doesn't handles guest tasks */
return -1;
}
 
void SS_level_status(LEVEL l)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->wait);
 
568,19 → 536,8
}
}
 
static PID SS_level_scheduler(LEVEL l)
static PID SS_public_schedulerbackground(LEVEL l)
{
#ifdef DEBUG
kern_printf("SS_levsch ");
#endif
 
/* the SS don't schedule anything...
it's an RM level or similar that do it! */
return NIL;
}
 
static PID SS_level_schedulerbackground(LEVEL l)
{
/* the SS catch the background time to exec aperiodic activities */
SS_level_des *lev = (SS_level_des *)(level_table[l]);
 
597,7 → 554,7
}
 
/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int SS_level_guaranteeEDF(LEVEL l, bandwidth_t *freebandwidth)
static int SS_public_guaranteeEDF(LEVEL l, bandwidth_t *freebandwidth)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
 
613,7 → 570,7
return 0;
}
 
static int SS_level_guaranteeRM(LEVEL l, bandwidth_t *freebandwidth)
static int SS_public_guaranteeRM(LEVEL l, bandwidth_t *freebandwidth)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
 
634,17 → 591,22
/*** Task functions ***/
 
 
static int SS_task_create(LEVEL l, PID p, TASK_MODEL *m)
static int SS_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m; /* if the SS_task_create is
called, the pclass must
be a valid pclass. */
SOFT_TASK_MODEL *s;
 
#ifdef DEBUG
kern_printf("SS_taskcre ");
#endif
 
if (m->pclass != SOFT_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
s = (SOFT_TASK_MODEL *)m;
if (s->periodicity != APERIODIC) return -1;
s = (SOFT_TASK_MODEL *)m;
 
if (s->arrivals == SAVE_ARRIVALS)
lev->nact[p] = 0;
else
653,19 → 615,8
return 0; /* OK, also if the task cannot be guaranteed */
}
 
static void SS_task_detach(LEVEL l, PID p)
static void SS_public_dispatch(LEVEL l, PID p, int nostop)
{
/* No cleanups to do here.
SS level doesn't introduce any dynamic allocated field. */
}
 
static int SS_task_eligible(LEVEL l, PID p)
{
return 0; /* If the task p is chosen, it is always eligible */
}
 
static void SS_task_dispatch(LEVEL l, PID p, int nostop)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
struct timespec ty;
 
706,7 → 657,7
if (nostop) kern_printf("(gd status=%d)",proc_table[p].status);
#endif
level_table[lev->scheduling_level]->
guest_dispatch(lev->scheduling_level,p,nostop);
private_dispatch(lev->scheduling_level,p,nostop);
}
 
/* set capacity timer */
723,7 → 674,7
}
}
 
static void SS_task_epilogue(LEVEL l, PID p) {
static void SS_public_epilogue(LEVEL l, PID p) {
 
SS_level_des *lev = (SS_level_des *)(level_table[l]);
struct timespec ty;
765,7 → 716,7
if(ssq_inslast(l, lev->replenish_amount) == NIL) {
kern_printf("SS: no more space to post replenishment\n");
kern_printf("You should recompile setting higher SS_MAX_REPLENISH into include/modules/ss.h\n");
SS_level_status(l);
SS_internal_status(l);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
777,7 → 728,7
}
 
if (lev->activated == p)
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
level_table[lev->scheduling_level]->private_extract(lev->scheduling_level,p);
 
iq_insertfirst(p, &lev->wait);
proc_table[p].status = SS_WAIT;
786,11 → 737,11
else {
/* The task has been preempted.
It returns into the ready queue or to the
wait queue by calling the guest_epilogue... */
wait queue by calling the private_epilogue... */
 
if (lev->activated == p) { /* goes into ready queue */
level_table[ lev->scheduling_level ]->
guest_epilogue(lev->scheduling_level,p);
private_epilogue(lev->scheduling_level,p);
}
else { /* goes into wait queue */
iq_insertfirst(p, &lev->wait);
799,7 → 750,7
}
}
 
static void SS_task_activate(LEVEL l, PID p)
static void SS_public_activate(LEVEL l, PID p)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
struct timespec ty;
812,8 → 763,6
if (lev->nact[p] != -1) lev->nact[p]++;
}
else if (proc_table[p].status == SLEEP) {
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
// kern_printf("-%d.%d- ",proc_table[p].request_time.tv_sec,proc_table[p].request_time.tv_nsec);
if (lev->activated == NIL && lev->availCs > 0) {
if(!BACKGROUND_ON) {
/* if server is active, replenish time already set */
820,7 → 769,7
if (lev->server_active == SS_SERVER_NOTACTIVE) {
lev->server_active = SS_SERVER_ACTIVE;
/* set replenish time */
TIMESPEC_ASSIGN(&ty, &proc_table[p].request_time);
kern_gettime(&ty);
ADDUSEC2TIMESPEC(lev->period, &ty);
TIMESPEC_ASSIGN(&lev->lastdline, &ty);
#ifdef DEBUG
847,7 → 796,7
}
}
 
static void SS_task_insert(LEVEL l, PID p)
static void SS_public_unblock(LEVEL l, PID p)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
 
864,7 → 813,7
proc_table[p].status = SS_WAIT;
}
 
static void SS_task_extract(LEVEL l, PID p)
static void SS_public_block(LEVEL l, PID p)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
 
883,10 → 832,10
lev->flags |= SS_BACKGROUND_BLOCK;
 
if (lev->activated == p)
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
level_table[lev->scheduling_level]->private_extract(lev->scheduling_level,p);
}
 
static void SS_task_endcycle(LEVEL l, PID p)
static int SS_public_message(LEVEL l, PID p, void *m)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
struct timespec ty;
910,7 → 859,7
}
 
if (lev->activated == p)
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
level_table[lev->scheduling_level]->private_extract(lev->scheduling_level,p);
else
iq_extract(p, &lev->wait);
 
933,9 → 882,14
SS_set_ra(l);
}
}
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
return 0;
}
 
static void SS_task_end(LEVEL l, PID p)
static void SS_public_end(LEVEL l, PID p)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
struct timespec ty;
959,7 → 913,7
}
 
if (lev->activated == p)
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
level_table[lev->scheduling_level]->private_extract(lev->scheduling_level,p);
 
proc_table[p].status = FREE;
iq_insertfirst(p,&freedesc);
976,97 → 930,14
}
}
 
static void SS_task_sleep(LEVEL l, PID p)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
struct timespec ty;
int tx;
 
#ifdef DEBUG
kern_printf("SS_tasksle ");
#endif
 
/* update the server capacity */
if (BACKGROUND_ON)
lev->flags &= ~SS_BACKGROUND;
else {
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
lev->availCs -= tx;
lev->replenish_amount += tx;
#ifdef DEBUG
kern_printf("PID:%d RA=%d ",p,lev->replenish_amount);
#endif
}
 
lev->nact[p] = 0;
 
if (lev->activated == p)
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
else
iq_extract(p, &lev->wait);
 
proc_table[p].status = SLEEP;
 
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL) {
SS_activation(lev);
}
else {
if(!(BACKGROUND_ON)){
/* No more task to schedule; set replenish amount */
SS_set_ra(l);
}
}
}
 
 
/*-------------------------------------------------------------------*/
 
/*** Guest functions ***/
 
 
/* SS doesn't handles guest tasks */
 
static int SS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void SS_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void SS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void SS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void SS_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void SS_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void SS_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void SS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void SS_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void SS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
/*-------------------------------------------------------------------*/
 
/*** Registration functions ***/
 
 
/*+ Registration function:
int flags the init flags ... see SS.h +*/
void SS_register_level(int flags, LEVEL master, int Cs, int per)
LEVEL SS_register_level(int flags, LEVEL master, int Cs, int per)
{
LEVEL l; /* the level that we register */
SS_level_des *lev; /* for readableness only */
1073,61 → 944,33
PID i; /* a counter */
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
#ifdef DEBUG
kern_printf("Alloc des %d ",l);
#endif
l = level_alloc_descriptor(sizeof(SS_level_des));
 
/* alloc the space needed for the SS_level_des */
lev = (SS_level_des *)kern_alloc(sizeof(SS_level_des));
lev = (SS_level_des *)level_table[l];
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
printk(" lev=%d\n",(int)lev);
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, SS_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = SS_LEVEL_CODE;
lev->l.level_version = SS_LEVEL_VERSION;
 
lev->l.level_accept_task_model = SS_level_accept_task_model;
lev->l.level_accept_guest_model = SS_level_accept_guest_model;
lev->l.level_status = SS_level_status;
 
if (flags & SS_ENABLE_BACKGROUND)
lev->l.level_scheduler = SS_level_schedulerbackground;
else
lev->l.level_scheduler = SS_level_scheduler;
lev->l.public_scheduler = SS_public_schedulerbackground;
 
if (flags & SS_ENABLE_GUARANTEE_EDF)
lev->l.level_guarantee = SS_level_guaranteeEDF;
lev->l.public_guarantee = SS_public_guaranteeEDF;
else if (flags & SS_ENABLE_GUARANTEE_RM)
lev->l.level_guarantee = SS_level_guaranteeRM;
lev->l.public_guarantee = SS_public_guaranteeRM;
else
lev->l.level_guarantee = NULL;
lev->l.public_guarantee = NULL;
 
lev->l.task_create = SS_task_create;
lev->l.task_detach = SS_task_detach;
lev->l.task_eligible = SS_task_eligible;
lev->l.task_dispatch = SS_task_dispatch;
lev->l.task_epilogue = SS_task_epilogue;
lev->l.task_activate = SS_task_activate;
lev->l.task_insert = SS_task_insert;
lev->l.task_extract = SS_task_extract;
lev->l.task_endcycle = SS_task_endcycle;
lev->l.task_end = SS_task_end;
lev->l.task_sleep = SS_task_sleep;
lev->l.public_create = SS_public_create;
lev->l.public_end = SS_public_end;
lev->l.public_dispatch = SS_public_dispatch;
lev->l.public_epilogue = SS_public_epilogue;
lev->l.public_activate = SS_public_activate;
lev->l.public_unblock = SS_public_unblock;
lev->l.public_block = SS_public_block;
lev->l.public_message = SS_public_message;
 
lev->l.guest_create = SS_guest_create;
lev->l.guest_detach = SS_guest_detach;
lev->l.guest_dispatch = SS_guest_dispatch;
lev->l.guest_epilogue = SS_guest_epilogue;
lev->l.guest_activate = SS_guest_activate;
lev->l.guest_insert = SS_guest_insert;
lev->l.guest_extract = SS_guest_extract;
lev->l.guest_endcycle = SS_guest_endcycle;
lev->l.guest_end = SS_guest_end;
lev->l.guest_sleep = SS_guest_sleep;
 
/* fill the SS descriptor part */
 
for (i=0; i<MAX_PROC; i++)
1156,23 → 999,19
lev->rcount=0;
lev->replenish_amount=0;
lev->server_active=SS_SERVER_NOTACTIVE;
 
return l;
}
 
bandwidth_t SS_usedbandwidth(LEVEL l)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
if (lev->l.level_code == SS_LEVEL_CODE &&
lev->l.level_version == SS_LEVEL_VERSION)
return lev->U;
else
return 0;
 
return lev->U;
}
 
int SS_availCs(LEVEL l) {
SS_level_des *lev = (SS_level_des *)(level_table[l]);
if (lev->l.level_code == SS_LEVEL_CODE &&
lev->l.level_version == SS_LEVEL_VERSION)
return lev->availCs;
else
return 0;
 
return lev->availCs;
}
/shark/trunk/kernel/modules/tbs.c
20,11 → 20,11
 
/**
------------
CVS : $Id: tbs.c,v 1.3 2002-11-11 08:32:07 pj Exp $
CVS : $Id: tbs.c,v 1.4 2003-01-07 17:07:51 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:07 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:51 $
------------
 
This file contains the aperiodic server TBS (Total Bandwidth Server)
60,6 → 60,7
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
/*+ 4 debug purposes +*/
#undef TBS_TEST
97,19 → 98,6
 
} TBS_level_des;
 
 
static char *TBS_status_to_a(WORD status)
{
if (status < MODULE_STATUS_BASE)
return status_to_a(status);
 
switch (status) {
case TBS_WCET_VIOLATED: return "TBS_Wcet_Violated";
case TBS_WAIT : return "TBS_Wait";
default : return "TBS_Unknown";
}
}
 
#ifdef TESTG
#include "drivers/glib.h"
#endif
131,9 → 119,6
/* we compute a suitable deadline for the task */
drel = (proc_table[p].wcet * lev->band_den) / lev->band_num;
 
if (TIMESPEC_A_GT_B(&proc_table[p].request_time, &lev->lastdline))
TIMESPEC_ASSIGN(&lev->lastdline, &proc_table[p].request_time );
 
ADDUSEC2TIMESPEC(drel, &lev->lastdline);
 
#ifdef TESTG
147,8 → 132,7
/* and we insert the task in another level */
m = lev->scheduling_level;
job_task_default_model(j,lev->lastdline);
level_table[m]->guest_create(m,p,(TASK_MODEL *)&j);
level_table[m]->guest_activate(m,p);
level_table[m]->private_insert(m,p,(TASK_MODEL *)&j);
 
#ifdef TBS_TEST
kern_printf("TBS_activation: lastdline %ds %dns\n",lev->lastdline.tv_sec,lev->lastdline.tv_nsec);
176,74 → 160,8
#endif
}
 
 
 
static int TBS_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == SOFT_PCLASS || m->pclass == (SOFT_PCLASS | l) ) {
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m;
 
if (s->wcet && s->periodicity == APERIODIC)
return 0;
}
 
return -1;
}
 
static int TBS_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
return -1;
}
 
static char *onoff(int i)
{
if (i)
return "On ";
else
return "Off";
}
 
static void TBS_level_status(LEVEL l)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
PID p = iq_query_first(&lev->wait);
 
kern_printf("Wcet Check : %s\n",
onoff(lev->flags & TBS_ENABLE_WCET_CHECK));
kern_printf("On-line guarantee : %s\n",
onoff(lev->flags & TBS_ENABLE_GUARANTEE));
kern_printf("Used Bandwidth : %u/%u\n",
lev->U, MAX_BANDWIDTH);
kern_printf("Last deadline : %lds %ldns\n",lev->lastdline.tv_sec,
lev->lastdline.tv_nsec);
 
if (lev->activated != -1)
kern_printf("Activated: Pid: %2d Name: %10s Dl: %ld.%9ld nact: %d Stat: %s\n",
lev->activated,
proc_table[lev->activated].name,
iq_query_timespec(lev->activated, &lev->wait)->tv_sec,
iq_query_timespec(lev->activated, &lev->wait)->tv_nsec,
lev->nact[lev->activated],
TBS_status_to_a(proc_table[lev->activated].status));
 
while (p != NIL) {
kern_printf("Pid: %2d Name: %10s Stat: %s\n",
p,
proc_table[p].name,
TBS_status_to_a(proc_table[p].status));
p = iq_query_next(p, &lev->wait);
}
}
 
static PID TBS_level_scheduler(LEVEL l)
{
/* the TBS don't schedule anything...
it's an EDF level or similar that do it! */
return NIL;
}
 
/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int TBS_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int TBS_public_guarantee(LEVEL l, bandwidth_t *freebandwidth)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
 
255,14 → 173,19
return 0;
}
 
static int TBS_task_create(LEVEL l, PID p, TASK_MODEL *m)
static int TBS_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
 
/* if the TBS_task_create is called, then the pclass must be a
valid pclass. */
SOFT_TASK_MODEL *s = (SOFT_TASK_MODEL *)m;
SOFT_TASK_MODEL *s;
 
if (m->pclass != SOFT_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
s = (SOFT_TASK_MODEL *)m;
if (!(s->wcet && s->periodicity == APERIODIC)) return -1;
proc_table[p].wcet = s->wcet;
 
/* Enable wcet check */
278,18 → 201,8
return 0; /* OK, also if the task cannot be guaranteed... */
}
 
static void TBS_task_detach(LEVEL l, PID p)
static void TBS_public_dispatch(LEVEL l, PID p, int nostop)
{
/* the TBS level doesn't introduce any dinamic allocated new field. */
}
 
static int TBS_task_eligible(LEVEL l, PID p)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
static void TBS_task_dispatch(LEVEL l, PID p, int nostop)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
 
/* there is at least one task ready inserted in an EDF or similar
296,10 → 209,10
level */
 
level_table[ lev->scheduling_level ]->
guest_dispatch(lev->scheduling_level,p,nostop);
private_dispatch(lev->scheduling_level,p,nostop);
}
 
static void TBS_task_epilogue(LEVEL l, PID p)
static void TBS_public_epilogue(LEVEL l, PID p)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
 
313,7 → 226,7
have to be put in place... this code is identical to the
TBS_task_end */
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
 
/* we reclaim an avail time that can be <0 due to the timer
approximations -> we have to postpone the deadline a little!
335,18 → 248,22
/* the task has been preempted. it returns into the ready queue by
calling the guest_epilogue... */
level_table[ lev->scheduling_level ]->
guest_epilogue(lev->scheduling_level,p);
private_epilogue(lev->scheduling_level,p);
}
 
static void TBS_task_activate(LEVEL l, PID p)
static void TBS_public_activate(LEVEL l, PID p)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
struct timespec t;
 
if (proc_table[p].status == SLEEP ||
proc_table[p].status == TBS_WCET_VIOLATED) {
 
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
kern_gettime(&t);
if (TIMESPEC_A_GT_B(&t, &lev->lastdline))
TIMESPEC_ASSIGN(&lev->lastdline, &t );
 
 
if (lev->activated == NIL) {
/* This is the first task in the level, so we activate it immediately */
lev->activated = p;
363,23 → 280,25
kern_printf("TBSREJ!!!");*/
}
 
static void TBS_task_insert(LEVEL l, PID p)
static void TBS_public_unblock(LEVEL l, PID p)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
JOB_TASK_MODEL j;
 
level_table[ lev->scheduling_level ]->
guest_insert(lev->scheduling_level,p);
job_task_default_model(j,lev->lastdline);
level_table[lev->scheduling_level]->
private_insert(lev->scheduling_level,p,(TASK_MODEL *)&j);
}
 
static void TBS_task_extract(LEVEL l, PID p)
static void TBS_public_block(LEVEL l, PID p)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
 
level_table[ lev->scheduling_level ]->
guest_extract(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
}
 
static void TBS_task_endcycle(LEVEL l, PID p)
static int TBS_public_message(LEVEL l, PID p, void *m)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
 
387,7 → 306,7
that implements a single activation, so we have to call
the guest_end, that representsa single activation... */
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
 
TBS_bandwidth_reclaiming(lev,p);
 
408,14 → 327,18
if (lev->activated != NIL)
TBS_activation(lev);
 
jet_update_endcycle(); /* Update the Jet data... */
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */
 
return 0;
}
 
static void TBS_task_end(LEVEL l, PID p)
static void TBS_public_end(LEVEL l, PID p)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
 
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
private_extract(lev->scheduling_level,p);
 
TBS_bandwidth_reclaiming(lev,p);
 
427,65 → 350,6
TBS_activation(lev);
}
 
static void TBS_task_sleep(LEVEL l, PID p)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
 
/* a task activation is finished, but we are using a JOB_TASK_MODEL
that implements a single activation, so we have to call
the guest_end, that representsa single activation... */
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
 
TBS_bandwidth_reclaiming(lev,p);
 
/* we reset the capacity counters... */
if (lev->flags & TBS_ENABLE_WCET_CHECK)
proc_table[p].avail_time = proc_table[p].wcet;
 
proc_table[p].status = SLEEP;
 
lev->nact[p] = 0;
 
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
TBS_activation(lev);
 
}
 
static int TBS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void TBS_guest_detach(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void TBS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void TBS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void TBS_guest_activate(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void TBS_guest_insert(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void TBS_guest_extract(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void TBS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void TBS_guest_end(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void TBS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
 
 
/* Registration functions */
 
/*+ Registration function:
499,56 → 363,28
printk("TBS_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(TBS_level_des));
 
printk(" alloco descrittore %d %d\n",l,(int)sizeof(TBS_level_des));
lev = (TBS_level_des *)level_table[l];
 
/* alloc the space needed for the TBS_level_des */
lev = (TBS_level_des *)kern_alloc(sizeof(TBS_level_des));
 
printk(" lev=%d\n",(int)lev);
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, TBS_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = TBS_LEVEL_CODE;
lev->l.level_version = TBS_LEVEL_VERSION;
 
lev->l.level_accept_task_model = TBS_level_accept_task_model;
lev->l.level_accept_guest_model = TBS_level_accept_guest_model;
lev->l.level_status = TBS_level_status;
lev->l.level_scheduler = TBS_level_scheduler;
 
if (flags & TBS_ENABLE_GUARANTEE)
lev->l.level_guarantee = TBS_level_guarantee;
lev->l.public_guarantee = TBS_public_guarantee;
else
lev->l.level_guarantee = NULL;
lev->l.public_guarantee = NULL;
 
lev->l.task_create = TBS_task_create;
lev->l.task_detach = TBS_task_detach;
lev->l.task_eligible = TBS_task_eligible;
lev->l.task_dispatch = TBS_task_dispatch;
lev->l.task_epilogue = TBS_task_epilogue;
lev->l.task_activate = TBS_task_activate;
lev->l.task_insert = TBS_task_insert;
lev->l.task_extract = TBS_task_extract;
lev->l.task_endcycle = TBS_task_endcycle;
lev->l.task_end = TBS_task_end;
lev->l.task_sleep = TBS_task_sleep;
lev->l.public_guarantee = TBS_public_guarantee;
lev->l.public_create = TBS_public_create;
lev->l.public_end = TBS_public_end;
lev->l.public_dispatch = TBS_public_dispatch;
lev->l.public_epilogue = TBS_public_epilogue;
lev->l.public_activate = TBS_public_activate;
lev->l.public_unblock = TBS_public_unblock;
lev->l.public_block = TBS_public_block;
lev->l.public_message = TBS_public_message;
 
lev->l.guest_create = TBS_guest_create;
lev->l.guest_detach = TBS_guest_detach;
lev->l.guest_dispatch = TBS_guest_dispatch;
lev->l.guest_epilogue = TBS_guest_epilogue;
lev->l.guest_activate = TBS_guest_activate;
lev->l.guest_insert = TBS_guest_insert;
lev->l.guest_extract = TBS_guest_extract;
lev->l.guest_endcycle = TBS_guest_endcycle;
lev->l.guest_end = TBS_guest_end;
lev->l.guest_sleep = TBS_guest_sleep;
 
/* fill the TBS descriptor part */
 
for (i = 0; i < MAX_PROC; i++) {
573,20 → 409,14
bandwidth_t TBS_usedbandwidth(LEVEL l)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
if (lev->l.level_code == TBS_LEVEL_CODE &&
lev->l.level_version == TBS_LEVEL_VERSION)
return lev->U;
else
return 0;
 
return lev->U;
}
 
int TBS_get_nact(LEVEL l, PID p)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
if (lev->l.level_code == TBS_LEVEL_CODE &&
lev->l.level_version == TBS_LEVEL_VERSION)
return lev->nact[p];
else
return -1;
 
return lev->nact[p];
}
 
/shark/trunk/kernel/modules/dummy.c
20,11 → 20,11
 
/**
------------
CVS : $Id: dummy.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: dummy.c,v 1.4 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
This file contains the Dummy scheduling module
58,7 → 58,6
#include <ll/string.h>
#include <kernel/config.h>
#include <sys/types.h>
#include <modules/codes.h>
#include <kernel/model.h>
#include <kernel/descr.h>
#include <kernel/var.h>
74,42 → 73,21
} dummy_level_des;
 
 
static int dummy_level_accept_task_model(LEVEL l, TASK_MODEL *m)
static PID dummy_public_scheduler(LEVEL l)
{
dummy_level_des *lev = (dummy_level_des *)(level_table[l]);
 
if ((m->pclass == DUMMY_PCLASS || m->pclass == (DUMMY_PCLASS | l))
&& lev->dummy == -1)
return 0;
else
return -1;
//kern_printf("DUMMYsched!!! %d", lev->dummy);
return lev->dummy;
}
 
static int dummy_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
static int dummy_public_create(LEVEL l, PID p, TASK_MODEL *m)
{
return -1;
}
 
static void dummy_level_status(LEVEL l)
{
dummy_level_des *lev = (dummy_level_des *)(level_table[l]);
 
kern_printf("dummy PID: %d\n", lev->dummy);
};
if (m->pclass != DUMMY_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
if (lev->dummy != -1) return -1;
 
 
static PID dummy_level_scheduler(LEVEL l)
{
dummy_level_des *lev = (dummy_level_des *)(level_table[l]);
//kern_printf("DUMMYsched!!! %d", lev->dummy);
return lev->dummy;
}
 
/* There is not guarantee on this level!!! -> the entry must be null
int (*level_guarantee)(LEVEL l, DWORD *freebandwidth); */
 
static int dummy_task_create(LEVEL l, PID p, TASK_MODEL *m)
{
/* the dummy level doesn't introduce any new field in the TASK_MODEL
so, all initialization stuffs are done by the task_create.
the task state is set at SLEEP by the general task_create */
116,92 → 94,16
return 0; /* OK */
}
 
static void dummy_task_detach(LEVEL l, PID p)
static void dummy_public_dispatch(LEVEL l, PID p, int nostop)
{
/* the dummy level doesn't introduce any new field in the TASK_MODEL
so, all detach stuffs are done by the task_create
The task state is set at FREE by the general task_create */
}
 
static int dummy_task_eligible(LEVEL l, PID p)
{
return 0; /* if the task p is chosen, it is always eligible */
}
 
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
static void dummy_task_dispatch(LEVEL l, PID p, int nostop)
{
/* nothing... the dummy hangs the cpu waiting for interrupts... */
if (0)//testactive)
{
s_stime[useds]= schedule_time;
s_curr[useds] = -1;
s_PID[useds] = p;
useds++;
}
 
//kern_printf("ÛDUMMYÛ");
 
}
 
static void dummy_task_epilogue(LEVEL l, PID p)
static void dummy_public_epilogue(LEVEL l, PID p)
{
proc_table[p].status = SLEEP; /* Paranoia */
}
 
static void dummy_task_activate(LEVEL l, PID p)
{ kern_printf("Dummy1"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
 
static void dummy_task_insert(LEVEL l, PID p)
{ kern_printf("Dummy2"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
 
static void dummy_task_extract(LEVEL l, PID p)
{ kern_printf("Dummy3"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
 
static void dummy_task_endcycle(LEVEL l, PID p)
{ kern_printf("Dummy4"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
 
static void dummy_task_end(LEVEL l, PID p)
{ kern_printf("Dummy5"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
 
static void dummy_task_sleep(LEVEL l, PID p)
{ kern_printf("Dummy6"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
 
static int dummy_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_printf("Dummy8"); kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
 
static void dummy_guest_detach(LEVEL l, PID p)
{ kern_printf("Dummy9"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void dummy_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_printf("Dummy0"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void dummy_guest_epilogue(LEVEL l, PID p)
{ kern_printf("Dummya"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void dummy_guest_activate(LEVEL l, PID p)
{ kern_printf("Dummyb"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void dummy_guest_insert(LEVEL l, PID p)
{ kern_printf("Dummyc"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void dummy_guest_extract(LEVEL l, PID p)
{ kern_printf("Dummyd"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void dummy_guest_endcycle(LEVEL l, PID p)
{ kern_printf("Dummye"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void dummy_guest_end(LEVEL l, PID p)
{ kern_printf("Dummyf"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
static void dummy_guest_sleep(LEVEL l, PID p)
{ kern_printf("Dummyg"); kern_raise(XINVALID_GUEST,exec_shadow); }
 
 
/*+ Dummy task must be present & cannot be killed; +*/
static TASK dummy()
{
244,7 → 146,7
if (p == NIL)
printk("\nPanic!!! can't create dummy task...\n");
 
/* dummy must block all tasks... */
/* dummy must block all signals... */
proc_table[p].sigmask = 0xFFFFFFFF;
}
 
253,55 → 155,27
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void dummy_register_level()
LEVEL dummy_register_level()
{
LEVEL l; /* the level that we register */
dummy_level_des *lev; /* for readableness only */
 
printk("Entro in dummy_register_level\n");
printk("Inside dummy_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor();
l = level_alloc_descriptor(sizeof(dummy_level_des));
 
/* alloc the space needed for the dummy_level_des */
lev = (dummy_level_des *)kern_alloc(sizeof(dummy_level_des));
lev = (dummy_level_des *)level_table[l];
 
/* update the level_table with the new entry */
level_table[l] = (level_des *)lev;
printk(" lev=%d\n",(int)lev);
 
/* fill the standard descriptor */
strncpy(lev->l.level_name, DUMMY_LEVELNAME, MAX_LEVELNAME);
lev->l.level_code = DUMMY_LEVEL_CODE;
lev->l.level_version = DUMMY_LEVEL_VERSION;
lev->l.public_scheduler = dummy_public_scheduler;
lev->l.public_guarantee = NULL;
lev->l.public_create = dummy_public_create;
lev->l.public_dispatch = dummy_public_dispatch;
lev->l.public_epilogue = dummy_public_epilogue;
 
lev->l.level_accept_task_model = dummy_level_accept_task_model;
lev->l.level_accept_guest_model = dummy_level_accept_guest_model;
lev->l.level_status = dummy_level_status;
lev->l.level_scheduler = dummy_level_scheduler;
lev->l.level_guarantee = NULL; /* No guarantee! */
 
lev->l.task_create = dummy_task_create;
lev->l.task_detach = dummy_task_detach;
lev->l.task_eligible = dummy_task_eligible;
lev->l.task_dispatch = dummy_task_dispatch;
lev->l.task_epilogue = dummy_task_epilogue;
lev->l.task_activate = dummy_task_activate;
lev->l.task_insert = dummy_task_insert;
lev->l.task_extract = dummy_task_extract;
lev->l.task_endcycle = dummy_task_endcycle;
lev->l.task_end = dummy_task_end;
lev->l.task_sleep = dummy_task_sleep;
 
lev->l.guest_create = dummy_guest_create;
lev->l.guest_detach = dummy_guest_detach;
lev->l.guest_dispatch = dummy_guest_dispatch;
lev->l.guest_epilogue = dummy_guest_epilogue;
lev->l.guest_activate = dummy_guest_activate;
lev->l.guest_insert = dummy_guest_insert;
lev->l.guest_extract = dummy_guest_extract;
lev->l.guest_endcycle = dummy_guest_endcycle;
lev->l.guest_end = dummy_guest_end;
lev->l.guest_sleep = dummy_guest_sleep;
 
/* the dummy process will be created at init_time.
see also dummy_level_accept_model,dummy_create */
lev->dummy = -1;
309,4 → 183,6
printk("\tPosto dummy_create\n");
 
sys_atrunlevel(dummy_create,(void *) l, RUNLEVEL_INIT);
 
return l;
}
/shark/trunk/kernel/modules/nop.c
20,11 → 20,11
 
/**
------------
CVS : $Id: nop.c,v 1.2 2002-11-11 08:32:06 pj Exp $
CVS : $Id: nop.c,v 1.3 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
Binary Semaphores. see nop.h for more details...
58,7 → 58,6
#include <ll/string.h>
#include <kernel/const.h>
#include <sys/types.h>
#include <modules/codes.h>
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>
80,40 → 79,21
/* Wait status for this library */
#define NOP_WAIT LIB_STATUS_BASE
 
 
/*+ print resource protocol statistics...+*/
static void NOP_resource_status(RLEVEL r)
static int NOP_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
kern_printf("No status for NOP module\n");
}
 
 
static int NOP_level_accept_resource_model(RLEVEL l, RES_MODEL *r)
{
/* priority inheritance works with all tasks without Resource parameters */
return -1;
}
 
static void NOP_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
/* never called!!! */
}
 
static void NOP_res_detach(RLEVEL l, PID p)
{
}
 
static int NOP_level_accept_mutexattr(RLEVEL l, const mutexattr_t *a)
{
if (a->mclass == NOP_MCLASS || a->mclass == (NOP_MCLASS | l) )
return 0;
else
return -1;
}
 
static int NOP_init(RLEVEL l, mutex_t *m, const mutexattr_t *a)
{
NOP_mutex_t *p;
if (a->mclass != NOP_MCLASS)
return -1;
 
p = (NOP_mutex_t *) kern_alloc(sizeof(NOP_mutex_t));
 
172,23 → 152,12
 
if (p->owner != NIL) { /* We must block exec task */
LEVEL l; /* for readableness only */
TIME tx; /* a dummy TIME for timespec operations */
struct timespec ty; /* a dummy timespec for timespec operations */
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);
 
/* we insert the task in the semaphore queue */
proc_table[exec_shadow].status = NOP_WAIT;
256,7 → 225,7
p->owner = iq_getfirst(&p->blocked);
if (p->owner != NIL) {
l = proc_table[p->owner].task_level;
level_table[l]->task_insert(l,p->owner);
level_table[l]->public_unblock(l,p->owner);
}
 
scheduler();
265,7 → 234,7
return 0;
}
 
void NOP_register_module(void)
RLEVEL NOP_register_module(void)
{
RLEVEL l; /* the level that we register */
NOP_mutex_resource_des *m; /* for readableness only */
282,20 → 251,11
resource_table[l] = (resource_des *)m;
 
/* fill the resource_des descriptor */
strncpy(m->m.r.res_name, NOP_MODULENAME, MAX_MODULENAME);
m->m.r.res_code = NOP_MODULE_CODE;
m->m.r.res_version = NOP_MODULE_VERSION;
 
m->m.r.rtype = MUTEX_RTYPE;
 
m->m.r.resource_status = NOP_resource_status;
m->m.r.level_accept_resource_model = NOP_level_accept_resource_model;
m->m.r.res_register = NOP_res_register;
 
m->m.r.res_detach = NOP_res_detach;
 
/* fill the mutex_resource_des descriptor */
m->m.level_accept_mutexattr = NOP_level_accept_mutexattr;
m->m.init = NOP_init;
m->m.destroy = NOP_destroy;
m->m.lock = NOP_lock;
302,5 → 262,6
m->m.trylock = NOP_trylock;
m->m.unlock = NOP_unlock;
 
return l;
}
 
/shark/trunk/kernel/modules/npp.c
20,11 → 20,11
 
/**
------------
CVS : $Id: npp.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: npp.c,v 1.2 2003-01-07 17:07:50 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:07:50 $
------------
 
Non Preemptive Protocol. see npp.h for more details...
56,7 → 56,6
#include <ll/ll.h>
#include <ll/string.h>
#include <ll/stdio.h>
#include <modules/codes.h>
#include <kernel/const.h>
#include <sys/types.h>
#include <kernel/descr.h>
71,6 → 70,7
} NPP_mutex_resource_des;
 
 
#if 0
/*+ print resource protocol statistics...+*/
static void NPP_resource_status(RLEVEL r)
{
78,18 → 78,14
 
kern_printf("%d Resources owned by the tasks %d\n", m->nlocked, exec_shadow);
}
#endif
 
static int NPP_level_accept_resource_model(RLEVEL l, RES_MODEL *r)
static int NPP_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
/* NPP works with all tasks without Resource parameters */
return -1;
}
 
static void NPP_res_register(RLEVEL l, PID p, RES_MODEL *r)
{
/* never called!!! */
}
 
static void NPP_res_detach(RLEVEL l, PID p)
{
NPP_mutex_resource_des *m = (NPP_mutex_resource_des *)(resource_table[l]);
98,16 → 94,11
kern_raise(XMUTEX_OWNER_KILLED, p);
}
 
static int NPP_level_accept_mutexattr(RLEVEL l, const mutexattr_t *a)
static int NPP_init(RLEVEL l, mutex_t *m, const mutexattr_t *a)
{
if (a->mclass == NPP_MCLASS || a->mclass == (NPP_MCLASS | l) )
return 0;
else
if (a->mclass != NPP_MCLASS)
return -1;
}
 
static int NPP_init(RLEVEL l, mutex_t *m, const mutexattr_t *a)
{
m->mutexlevel = l;
m->opt = (void *)NIL;
 
187,20 → 178,11
resource_table[l] = (resource_des *)m;
 
/* fill the resource_des descriptor */
strncpy(m->m.r.res_name, NPP_MODULENAME, MAX_MODULENAME);
m->m.r.res_code = NPP_MODULE_CODE;
m->m.r.res_version = NPP_MODULE_VERSION;
 
m->m.r.rtype = MUTEX_RTYPE;
 
m->m.r.resource_status = NPP_resource_status;
m->m.r.level_accept_resource_model = NPP_level_accept_resource_model;
m->m.r.res_register = NPP_res_register;
 
m->m.r.res_detach = NPP_res_detach;
 
/* fill the mutex_resource_des descriptor */
m->m.level_accept_mutexattr = NPP_level_accept_mutexattr;
m->m.init = NPP_init;
m->m.destroy = NPP_destroy;
m->m.lock = NPP_lock;
/shark/trunk/kernel/kill.c
18,11 → 18,11
 
/**
------------
CVS : $Id: kill.c,v 1.2 2002-10-28 07:58:19 pj Exp $
CVS : $Id: kill.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-10-28 07:58:19 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains:
128,7 → 128,7
 
x = proc_table[i].waiting_for_me;
l = proc_table[x].task_level;
level_table[l]->task_insert(l,x);
level_table[l]->public_unblock(l,x);
 
proc_table[x].shadow = x;
}
181,7 → 181,7
resource_table[l]->res_detach(l,i);
 
lev = proc_table[i].task_level;
level_table[lev]->task_end(lev,i);
level_table[lev]->public_end(lev,i);
 
/* THIS ASSIGNMENT MUST STAY HERE!!!
if we move it near the scheduler (after the counter checks)
207,16 → 207,9
sys_end();
}
 
/* SAME AS SCHEDULE, but not complete!!! */
ll_gettime(TIME_EXACT, &schedule_time);
/* we don't have to manage the capacity... because we are killing
ourselves */
if (cap_timer != NIL) {
event_delete(cap_timer);
cap_timer = NIL;
}
kern_epilogue_macro();
/* there is no epilogue... */
 
scheduler();
}
 
/shark/trunk/kernel/time.c
18,11 → 18,11
 
/**
------------
CVS : $Id: time.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: time.c,v 1.2 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.2 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains the functions defined in time.h
212,7 → 212,7
 
/* delete the event if the timer is armed */
if (timer_table[timerid].event != -1)
event_delete(timer_table[timerid].event);
kern_event_delete(timer_table[timerid].event);
 
if (timer_table[timerid].evp.sigev_notify == SIGEV_SIGNAL) {
if (!(sig_queue[ timer_table[timerid].signal ].flags & SIGNAL_POSTED)) {
354,7 → 354,7
NULL_TIMESPEC(&ovalue->it_value);
else {
/* the timer is armed, return the remaining expiration time */
ll_gettime(TIME_EXACT, &ct);
kern_gettime(&ct);
ct_read = 1;
SUBTIMESPEC(&timer_table[timerid].current, &ct, &ovalue->it_value);
}
365,7 → 365,7
/* if it_value is 0, the timer shall be disarmed; if != 0, the timer is
armed: in all the cases, the event must be deleted... */
if (timer_table[timerid].event != -1)
event_delete(timer_table[timerid].event);
kern_event_delete(timer_table[timerid].event);
 
if (value->it_value.tv_sec != 0 || value->it_value.tv_nsec != 0) {
/* it_value != 0 -> arm the timer! */
377,7 → 377,7
else {
/* the time is relative to current time */
if (!ct_read)
ll_gettime(TIME_EXACT, &ct);
kern_gettime(&ct);
ADDTIMESPEC(&ct, &value->it_value, &timer_table[timerid].current);
}
timer_table[timerid].event =
415,7 → 415,7
NULL_TIMESPEC(&value->it_value);
else {
/* the timer is armed, return the remaining expiration time */
ll_gettime(TIME_EXACT, &ct);
kern_gettime(&ct);
SUBTIMESPEC(&timer_table[timerid].current, &ct, &value->it_value);
}
/* and return the reactivation period */
/shark/trunk/kernel/kern.c
18,11 → 18,11
 
/**
------------
CVS : $Id: kern.c,v 1.2 2002-11-11 08:34:08 pj Exp $
CVS : $Id: kern.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:34:08 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains:
117,9 → 117,26
/*+ Process descriptor table +*/
proc_des proc_table[MAX_PROC];
 
/*+ Level descriptor table +*/
/* Scheduling modules descriptor table */
/* ------------------------------------------------------------------------ */
 
/* the descriptor table */
level_des *level_table[MAX_SCHED_LEVEL];
/* ... and the size of each descriptor */
size_t level_size[MAX_SCHED_LEVEL];
 
/* an utilization counter incremented if a level is used by another module */
int level_used[MAX_SCHED_LEVEL];
/* these data structures (first, last, free, next & prev)
are used to implement a double linked list of scheduling modules.
That list is used by the scheduler to call the module's schedulers. */
int level_first; /* first module in the list */
int level_last; /* last module in the list */
int level_free; /* free single linked list of free module descriptors. */
int level_next[MAX_SCHED_LEVEL];
int level_prev[MAX_SCHED_LEVEL];
/* ------------------------------------------------------------------------ */
 
/*+ Resource descriptor table +*/
resource_des *resource_table[MAX_RES_LEVEL];
 
197,7 → 214,6
void scheduler(void)
{
LEVEL l; /* a counter */
TIME tx; /* a dummy used for time computation */
struct timespec ty; /* a dummy used for time computation */
 
PID p; /* p is the task chosen by the level scheduler */
211,6 → 227,8
(proc_table[exec_shadow].control & NO_PREEMPT) ) )
return;
 
// kern_printf("(!");
 
/*
exec_shadow = exec = -1 only if the scheduler is called from:
. task_endcycle
229,48 → 247,38
- call an epilogue
*/
 
/* then, we call the epilogue. the epilogue tipically checks the
avail_time field... */
if (exec_shadow != -1) {
// ok is set 4 debug :-(
ok = ll_gettime(TIME_EXACT, &schedule_time);
// kern_printf("(%d sched s%d ns%d)", ok, schedule_time.tv_sec, schedule_time.tv_nsec);
kern_epilogue_macro();
 
/* manage the capacity event */
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
proc_table[exec_shadow].avail_time -= tx;
jet_update_slice(tx);
 
/* if the event didn't fire before, we delete it. */
if (cap_timer != NIL) {
event_delete(cap_timer);
cap_timer = NIL;
}
 
/* then, we call the epilogue. the epilogue tipically checks the
avail_time field... */
 
// kern_printf("(e%d)",exec_shadow);
 
l = proc_table[exec_shadow].task_level;
level_table[l]->task_epilogue(l,exec_shadow);
level_table[l]->public_epilogue(l,exec_shadow);
}
 
l = 0;
// kern_printf("[");
 
l = level_first;
for(;;) {
do {
p = level_table[l]->level_scheduler(l);
p = level_table[l]->public_scheduler(l);
// kern_printf("p=%d",p);
if (p != NIL)
ok = level_table[ proc_table[p].task_level ]->
task_eligible(proc_table[p].task_level,p);
public_eligible(proc_table[p].task_level,p);
else
ok = 0;
// kern_printf(" ok=%d",ok);
} while (ok < 0); /* repeat the level scheduler if the task isn't
eligible... (ex. in the aperiodic servers...) */
if (p != NIL) break;
 
l++; /* THERE MUST BE a level with a task to schedule */
l = level_next[l]; /* THERE MUST BE a level with a task to schedule */
// kern_printf(" l=%d",l);
};
 
// kern_printf("]");
 
/* tracer stuff */
//trc_logevent(exec,TRC_SCHEDULE,NULL,0);
 
284,15 → 292,17
//trc_logevent(exec_shadow,TRC_DISPATCH,NULL,0);
if (old_exec_shadow!=exec_shadow)
trc_logevent(TRC_SCHEDULE,&exec_shadow);
// kern_printf("[%i->%i]",old_exec_shadow,exec_shadow);
// kern_printf("[%i->%i]",old_exec_shadow,exec_shadow);
 
/* we control the correctness of the shadows when we kill */
proc_table[exec_shadow].status = EXE;
//kern_printf("(d%d)",exec_shadow);
// kern_printf("(d%d)",exec_shadow);
l = proc_table[exec_shadow].task_level;
level_table[l]->task_dispatch(l, exec_shadow, exec!=exec_shadow);
level_table[l]->public_dispatch(l, exec_shadow, exec!=exec_shadow);
 
// kern_printf("*");
 
/* Finally,we post the capacity event, BUT
. only if the task require that
. only if exec==exec_shadow (if a task is blocked we don't want
301,13 → 311,13
&& exec==exec_shadow) {
TIMESPEC_ASSIGN(&ty, &schedule_time);
ADDUSEC2TIMESPEC(proc_table[exec_shadow].avail_time,&ty);
// kern_printf("³s%d ns%d sched s%d ns%d³",ty.tv_sec,ty.tv_nsec, schedule_time.tv_sec, schedule_time.tv_nsec);
// kern_printf("³s%d ns%d sched s%d ns%d³",ty.tv_sec,ty.tv_nsec, schedule_time.tv_sec, schedule_time.tv_nsec);
cap_timer = kern_event_post(&ty, capacity_timer, NULL);
}
/* set the time at witch the task is scheduled */
TIMESPEC_ASSIGN(&cap_lasttime, &schedule_time);
 
//if (runlevel != 1) kern_printf("(s%d)",exec_shadow);
// kern_printf("(s%d)",exec_shadow);
}
 
 
325,8 → 335,8
bandwidth_t num=MAX_BANDWIDTH;
int l;
 
for (l =0; l<MAX_SCHED_LEVEL && level_table[l]->level_guarantee; l++)
if (!level_table[l]->level_guarantee(l,&num))
for (l =0; l<MAX_SCHED_LEVEL && level_table[l]->public_guarantee; l++)
if (!level_table[l]->public_guarantee(l,&num))
return -1;
 
return 0; /* OK */
378,7 → 388,7
*
*/
 
runlevel = 0;
runlevel = RUNLEVEL_STARTUP;
 
/* The kernel startup MUST proceed with int disabled! */
kern_cli();
400,7 → 410,6
proc_table[i].frozen_activations = 0;
proc_table[i].sigmask = 0;
proc_table[i].sigpending = 0;
NULL_TIMESPEC(&proc_table[i].request_time);
proc_table[i].avail_time = 0;
proc_table[i].shadow = i;
proc_table[i].cleanup_stack= NULL;
456,7 → 465,11
/* Init VM layer (Interrupts, levels & memory management) */
/* for old exception handling, use excirq_init() */
signals_init();
set_default_exception_handler();
 
/* Clear scheduling modules registration data */
levels_init();
 
sys_tick = __kernel_register_levels__(multiboot);
 
/* tracer stuff */
481,7 → 494,7
parms.tick = sys_tick;
 
/*
* Runlevel 1: Let's go!!!!
* Runlevel INIT: Let's go!!!!
*
*
*/
497,6 → 510,17
/* call the init functions */
call_runlevel_func(RUNLEVEL_INIT, 0);
 
 
 
 
/*
* Runlevel RUNNING: Hoping that all works fine ;-)
*
*
*/
 
runlevel = RUNLEVEL_RUNNING;
 
/* reset keyboard after exit */
// sys_atexit((void(*)(void *))C8042_restore,NULL,AFTER_EXIT);
 
504,7 → 528,7
trc_resume();
/* exec and exec_shadow are already = -1 */
ll_gettime(TIME_EXACT, &schedule_time);
kern_gettime(&schedule_time);
scheduler();
global_context = ll_context_from(); /* It will be used by sys_end */
ll_context_to(proc_table[exec_shadow].context);
519,7 → 543,7
 
 
/*
* Runlevel 2: Shutting down the system... :-(
* Runlevel SHUTDOWN: Shutting down the system... :-(
*
*
*/
535,13 → 559,11
/* 1 when the error code is != 0 */
aborting = global_errnumber > 0;
 
//kern_printf("after - system_counter=%d, task_counter = %d\n",
// system_counter,task_counter);
//kern_printf("after - system_counter=%d, task_counter = %d\n", system_counter,task_counter);
call_runlevel_func(RUNLEVEL_SHUTDOWN, aborting);
//kern_printf("before - system_counter=%d, task_counter = %d\n",
// system_counter,task_counter);
//kern_printf("before - system_counter=%d, task_counter = %d\n", system_counter,task_counter);
 
if (system_counter) {
/* To shutdown the kernel correctly, we have to wait that all the SYSTEM
552,15 → 574,15
We do nothing for user tasks that remain active (because, for example,
they have the cancelability set to deferred) when the system goes to
runlevel 3 */
//kern_printf("Û%lu",ll_gettime(TIME_EXACT,NULL));
//kern_printf("Û%lu",kern_gettime(NULL));
kill_user_tasks();
//kern_printf("Û%lu",ll_gettime(TIME_EXACT,NULL));
//kern_printf("Û%lu",kern_gettime(NULL));
 
/* we have to go again in multitasking mode!!! */
mustexit = 0;
 
/* exec and exec_shadow are already = -1 */
ll_gettime(TIME_EXACT, &schedule_time);
kern_gettime(&schedule_time);
global_context = ll_context_from(); /* It will be used by sys_end */
scheduler();
 
573,7 → 595,7
 
 
/*
* Runlevel 3: Before Halting the system
* Runlevel BEFORE_EXIT: Before Halting the system
*
*
*/
597,7 → 619,7
 
 
/*
* Runlevel 4: After halting...
* Runlevel AFTER_EXIT: After halting...
*
*
*/
620,47 → 642,48
 
}
 
/* IMPORTANT!!!
I'm almost sure the shutdown procedure does not work into interrupts. */
void internal_sys_end(int i)
{
LEVEL l; /* a counter */
TIME tx; /* a dummy used for time computation */
struct timespec ty; /* a dummy used for time computation */
 
/* if something goes wron during the real mode */
if (runlevel==RUNLEVEL_STARTUP || runlevel==RUNLEVEL_AFTER_EXIT)
l1_exit(i);
//kern_printf("mustexit=%d",mustexit);
if (!mustexit) {
if (!ll_ActiveInt())
proc_table[exec_shadow].context = kern_context_save();
global_errnumber = i;
if (mustexit)
return;
 
mustexit = 1;
mustexit = 1;
 
global_errnumber = i;
 
 
if (!ll_ActiveInt()) {
proc_table[exec_shadow].context = kern_context_save();
if (exec_shadow != -1) {
ll_gettime(TIME_EXACT, &schedule_time);
/* manage the capacity event */
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
proc_table[exec_shadow].avail_time -= tx;
jet_update_slice(tx);
/* if the event didn't fire before, we delete it. */
if (cap_timer != NIL) {
event_delete(cap_timer);
cap_timer = NIL;
}
kern_gettime(&schedule_time);
 
kern_epilogue_macro();
/* then, we call the epilogue. the epilogue tipically checks the
avail_time field... */
avail_time field... */
l = proc_table[exec_shadow].task_level;
level_table[l]->task_epilogue(l,exec_shadow);
 
level_table[l]->public_epilogue(l,exec_shadow);
exec_shadow = exec = -1;
}
kern_context_load(global_context);
}
 
if (ll_ActiveInt())
ll_context_to(global_context);
else
kern_context_load(global_context);
if (ll_ActiveInt()) {
ll_context_to(global_context);
/* The context change will be done when all the interrupts end!!! */
}
 
//kern_printf("fine sysend");
 
/* the control reach this line only if we call sys_end() into an event
669,64 → 692,29
}
 
 
/*+ Close the system & return to HOST OS.
Can be called from all the tasks...
The first time it is called it jumps to the global context
The second time it jumps only if there are no system task remaining
The error code passed is 0... (it is saved on the first call!!!) +*/
void sys_end(void)
/*
Close the system & return to HOST OS.
Can be called from tasks and from ISRS
 
*/
void sys_abort(int err)
{
SYS_FLAGS f;
 
/* the sys_end change the context to the global context.
when the first time is called, it simply kills all the users tasks
and waits the system tasks to end... */
 
/*kern_printf("°sys_end %d°",exec_shadow);*/
/*return;*/
f = kern_fsave();
if (runlevel != RUNLEVEL_INIT && system_counter) {
kern_frestore(f);
return;
}
 
internal_sys_end(0);
internal_sys_end(err);
kern_frestore(f);
}
 
/*+ Close the system & return to HOST OS.
Can be called from all the tasks...
The first time it is called it works as the sys_end
The second time it jumps every time
The error code passed is 0... +*/
void sys_abort(int err)
void sys_end(void)
{
/* the sys_end change the context to the global context.
when the first time is called, it simply kills all the users tasks
and waits the system tasks to end... */
 
internal_sys_end(err);
sys_abort(0);
}
 
/*+ equal to sys_end! +*/
void _exit(int status)
{
SYS_FLAGS f;
 
/* the sys_end change the context to the global context.
when the first time is called, it simply kills all the users tasks
and waits the system tasks to end... */
 
/*kern_printf("°sys_end %d°",exec_shadow);*/
/*return;*/
f = kern_fsave();
if (runlevel != RUNLEVEL_INIT && system_counter) {
kern_frestore(f);
return;
}
 
internal_sys_end(status);
kern_frestore(f);
sys_abort(status);
}
 
 
746,7 → 734,7
TIME x;
 
f = kern_fsave();
x = ll_gettime(TIME_EXACT,t);
x = kern_gettime(t);
kern_frestore(f);
 
return x;
/shark/trunk/kernel/join.c
18,11 → 18,11
 
/**
------------
CVS : $Id: join.c,v 1.2 2002-11-11 08:34:08 pj Exp $
CVS : $Id: join.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:34:08 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
task join and related primitives
80,7 → 80,7
proc_table[i].shadow = i;
 
l = proc_table[i].task_level;
level_table[l]->task_insert(l,i);
level_table[l]->public_unblock(l,i);
 
return 1;
}
96,8 → 96,6
{
PID x; /* used to follow the shadow chain */
int blocked = 0; /* a flag */
struct timespec ty;
TIME tx;
LEVEL l;
 
/* task_join is a cancellation point... if the task is suspended
153,20 → 151,11
proc_table[p].waiting_for_me = exec_shadow;
proc_table[exec_shadow].shadow = p;
 
/* 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();
 
/* now, we block the current task, waiting the end of the target task */
l = proc_table[exec_shadow].task_level;
level_table[l]->task_extract(l,exec_shadow);
level_table[l]->public_block(l,exec_shadow);
proc_table[exec_shadow].status = WAIT_JOIN;
 
exec = exec_shadow = -1;
/shark/trunk/kernel/tpreempt.c
18,11 → 18,11
 
/**
------------
CVS : $Id: tpreempt.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: tpreempt.c,v 1.2 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.2 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
task_preempt and task_nopreempt
72,7 → 72,7
kern_cli();
proc_table[exec_shadow].control |= NO_PREEMPT;
if (cap_timer != NIL) {
event_delete(cap_timer);
kern_event_delete(cap_timer);
cap_timer = NIL;
}
kern_sti();
/shark/trunk/kernel/grpcreat.c
18,11 → 18,11
 
/**
------------
CVS : $Id: grpcreat.c,v 1.2 2002-11-11 08:34:08 pj Exp $
CVS : $Id: grpcreat.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:34:08 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains:
168,7 → 168,6
- master_level (initialized later, modified by l[]->task_create() )
- task_level (initialized later in this function)
- context, stack (initialized at the end of this function)
- request_time (initialized when a request (activation) is issued)
- additional stuff like priority & co. have to be init. only if used...)
- delay_timer (initialized in __kernel_init__ and mantained coherent
by the scheduling modules...)
176,10 → 175,11
*/
 
/* search for a level that can manage the task model */
for (l=0; l<sched_levels; l++)
if (level_table[l]->level_accept_task_model(l,m) >= 0)
for (l=level_first; l != -1; l=level_next[l])
if (level_table[l]->public_create(l,i,m) >= 0)
break;
if (l == sched_levels) {
 
if (l == -1) {
/* no level can accept the task_model, exit!!! */
proc_table[i].status = FREE;
iq_insertfirst(i,&freedesc);
190,15 → 190,6
/* initialize task level */
proc_table[i].task_level = l;
 
/* calls the task-oriented function task_create */
if (level_table[l]->task_create(l,i,m) < 0) {
/* an error occurred in the task_create */
proc_table[i].status = FREE;
iq_insertfirst(i,&freedesc);
errno = ETASK_CREATE;
return -1;
}
 
/* register all the resource models passed */
for (;;) {
r = va_arg(rlist,RES_MODEL *);
207,10 → 198,8
 
/* search for a level that can manage the resource model */
for (l_res=0; l_res<res_levels; l_res++)
if (resource_table[l_res]->level_accept_resource_model(l_res,r) >= 0) {
resource_table[l_res]->res_register(l_res, i, r);
if (resource_table[l_res]->res_register(l_res, i, r) >= 0)
break;
}
if (l_res == res_levels) {
/* no level can accept the resource_model, exit!!! */
/* detach the resources and the task */
340,7 → 329,7
resource_table[lr]->res_detach(lr,i);
 
l = proc_table[i].task_level;
level_table[l]->task_detach(l,i);
level_table[l]->public_detach(l,i);
proc_table[i].status = FREE;
379,7 → 368,7
va_end(rlist);
 
if (p != NIL) {
if (level_table[proc_table[p].task_level]->level_guarantee)
if (level_table[proc_table[p].task_level]->public_guarantee)
if (guarantee() < 0) {
group_create_reject(p);
errno = ENO_GUARANTEE;
/shark/trunk/kernel/tskmsg.c
0,0 → 1,104
/*
* Project: S.Ha.R.K.
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Paolo Gai <pj@gandalf.sssup.it>
* (see the web pages for full authors list)
*
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*/
 
/**
------------
CVS : $Id: tskmsg.c,v 1.1 2003-01-07 17:09:24 pj Exp $
 
File: $File$
Revision: $Revision: 1.1 $
Last update: $Date: 2003-01-07 17:09:24 $
------------
 
**/
 
/*
* Copyright (C) 2002 Paolo Gai
*
* 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 <stdarg.h>
#include <ll/ll.h>
#include <ll/stdlib.h>
#include <ll/stdio.h>
#include <ll/string.h>
#include <kernel/config.h>
#include <kernel/model.h>
#include <kernel/const.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <kernel/descr.h>
#include <errno.h>
#include <kernel/var.h>
#include <kernel/func.h>
#include <kernel/trace.h>
 
 
/*
The running task (pointed by exec_shadow) sent a message m to the
scheduling module that handle the task p.
 
If the message has value NULL the behavior should be the
task_endcycle primitive behavior, and an endcycle tracer event is
generated.
 
*/
int task_message(void *m, int reschedule)
{
LEVEL l; /* for readableness only */
 
int retvalue;
 
if (reschedule) {
proc_table[exec_shadow].context = kern_context_save();
 
kern_epilogue_macro();
 
l = proc_table[exec_shadow].task_level;
retvalue = level_table[l]->public_message(l,exec_shadow,m);
 
exec = exec_shadow = -1;
scheduler();
 
kern_context_load(proc_table[exec_shadow].context);
 
} else {
SYS_FLAGS f;
 
f = kern_fsave();
l = proc_table[exec_shadow].task_level;
retvalue = level_table[l]->public_message(l,exec_shadow,m);
kern_frestore(f);
}
 
return retvalue;
}
/shark/trunk/kernel/exchand.c
0,0 → 1,104
/*
* Project: S.Ha.R.K.
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Paolo Gai <pj@gandalf.sssup.it>
* (see the web pages for full authors list)
*
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*/
 
/**
------------
CVS : $Id: exchand.c,v 1.1 2003-01-07 17:09:23 pj Exp $
 
File: $File$
Revision: $Revision: 1.1 $
Last update: $Date: 2003-01-07 17:09:23 $
------------
**/
 
/*
* Copyright (C) 2000 Paolo Gai
*
* 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 <kernel/kern.h>
 
static int myflag;
static siginfo_t myinfo;
static struct timespec mytime;
 
static void thehandler(int signo, siginfo_t *info, void *extra);
static void theend(void *arg);
 
/*
This exception handler should be good for text applications that do NOT
use graphics
*/
int set_default_exception_handler(void)
{
struct sigaction action;
 
myflag = 0;
 
sys_atrunlevel(theend, NULL, RUNLEVEL_AFTER_EXIT);
 
/* Init the standard S.Ha.R.K. exception handler */
action.sa_flags = SA_SIGINFO; /* Set the signal action */
action.sa_sigaction = thehandler;
action.sa_handler = 0;
sigfillset(&action.sa_mask); /* we block all the other signals... */
 
return sigaction(SIGHEXC, &action, NULL); /* set the signal */
}
 
static void thehandler(int signo, siginfo_t *info, void *extra)
{
if (!myflag) {
myflag = 1;
myinfo = *info;
sys_gettime(&mytime),
 
sys_abort(AHEXC);
}
}
 
static void theend(void *arg)
{
if (myflag) {
kern_printf("\nS.Ha.R.K. Exception raised!!!"
"\nTime (s:ns) :%ld:%ld"
"\nException number:%d"
"\nPID :%d\n",
mytime.tv_sec,
mytime.tv_nsec,
myinfo.si_value.sival_int,
myinfo.si_task);
}
}
 
 
 
/shark/trunk/kernel/signal.c
18,11 → 18,11
 
/**
------------
CVS : $Id: signal.c,v 1.2 2002-11-11 08:34:09 pj Exp $
CVS : $Id: signal.c,v 1.3 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:34:09 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains:
334,7 → 334,7
iq_extract(p, &sigwaiters);
 
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
level_table[l]->public_unblock(l,p);
 
}
 
481,10 → 481,10
/* Reactivate the task... */
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;
}
 
627,10 → 627,10
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;
}
 
700,7 → 700,7
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();
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
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 =
1027,8 → 1017,6
{
proc_des *pthread = &proc_table[exec_shadow];
 
struct timespec ty;
TIME tx;
LEVEL l;
 
task_testcancel();
1056,18 → 1044,9
/* 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);
 
iq_insertfirst(exec_shadow, &sigwaiters);
proc_table[exec_shadow].status = WAIT_SIGSUSPEND;
1116,7 → 1095,7
 
kern_cli();
 
ll_gettime(TIME_EXACT, &temp);
kern_gettime(&temp);
 
if (alarm_timer == -1)
returnvalue.tv_sec = 0;
1123,7 → 1102,7
else {
SUBTIMESPEC(&alarm_time, &temp, &returnvalue);
 
event_delete(alarm_timer);
kern_event_delete(alarm_timer);
}
 
if (seconds) {
1497,7 → 1476,7
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;
}
 
1504,7 → 1483,7
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;
}
1511,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;
}
/shark/trunk/kernel/event.c
18,11 → 18,11
 
/**
------------
CVS : $Id: event.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: event.c,v 1.2 2003-01-07 17:07:49 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:07:49 $
------------
 
This file contains the functions to be used into events:
94,7 → 94,7
/* we have to change context ONLY IF the sys_end primitive was not called
before (e.g., in a exception raise called by a task_epilogue called by
the scheduler. */
if (mustexit == 0) {
if (!mustexit) {
scheduler();
ll_context_to(proc_table[exec_shadow].context);
}
111,7 → 111,7
extern void perftest_epilogue(void);
 
if (perftime_count < 10000) {
perftime_prol[perftime_count] = ll_gettime(TIME_EXACT, NULL);
perftime_prol[perftime_count] = kern_gettime(NULL);
}
event_setepilogue(perftest_epilogue);
#else
128,7 → 128,7
reschedule();
 
if (perftime_count < 10000){
perftime_epil[perftime_count] = ll_gettime(TIME_EXACT, NULL);
perftime_epil[perftime_count] = kern_gettime(NULL);
perftime_count++;
}
}
140,7 → 140,7
 
 
if (perftime_count < 10000) {
perftime_epil[perftime_count] = ll_gettime(TIME_EXACT, NULL);
perftime_epil[perftime_count] = kern_gettime(NULL);
perftime_count++;
}
}
/shark/trunk/kernel/makefile
16,10 → 16,8
blkact.o \
cancel.o \
conditio.o \
endcycle.o \
event.o \
exchtxt.o \
exchgrx.o \
exchand.o \
grpcreat.o \
jet.o \
join.o \
38,12 → 36,10
pthread.o \
iqueue.o \
signal.o \
sleep.o \
status.o \
time.o \
tpreempt.o \
trace.o
# create.o # look at kernel/create.c and kernel/grpcreat.c for more info
trace.o \
tskmsg.o
 
include $(BASE)/config/lib.mk
 
/shark/trunk/include/kernel/func.h
21,11 → 21,11
 
/**
------------
CVS : $Id: func.h,v 1.2 2002-11-11 08:36:01 pj Exp $
CVS : $Id: func.h,v 1.3 2003-01-07 17:12:19 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:36:01 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:12:19 $
------------
 
Kernel functions:
98,11 → 98,39
TIME __kernel_register_levels__(void *arg);
 
/*+ This function returns a level_des **. the value returned shall be
used to register a level module. The function shall be called only at
module registration time. It assume that the system is not yet
initialized, so we shall not call sys_abort... +*/
LEVEL level_alloc_descriptor();
used to register a level module.
 
The function is usually called at module registration time. The
function can also be called when the system is already started, to
allow the implementation of dynamic module registration.
 
The argument must be the size of the data block that have to be allocated
 
The function returns the number of the descriptor allocated for the module
or -1 in case there are no free descriptors.
 
The function also reserves a descriptor with size s, initialized
with default function pointers.
 
+*/
LEVEL level_alloc_descriptor(size_t s);
 
/*+ This function release a level descriptor previously allocated using
level_alloc_descriptor().
 
The function returns 0 if the level has been freed, or -1 if someone is
using it, -2 if the level has never been registered.
 
+*/
int level_free_descriptor(LEVEL l);
 
/* Call this if you want to say that your module is using module l
(e.g., for calling its private functions) */
int level_use_descriptor(LEVEL l);
 
/* Call this when you no more need the module l */
int level_unuse_descriptor(LEVEL l);
 
/*+ This function returns a resource_des **. the value returned shall be
used to register a resource module. The function shall be called only at
module registration time. It assume that the system is not yet
128,13 → 156,6
(when uses some defines contained in const.h) +*/
int sys_atrunlevel(void (*func_code)(void *),void *parm, BYTE when);
 
/*+ These functions can be used to set a nice (I hope) default
signal handler. If not used, they are not linked.
They returns -1 if an error occurred, as done by the
sigaction primitive. +*/
int set_exchandler_grx();
int set_exchandler_text();
 
/*---------------------------------------------------------------------*/
/* Kernel global functions: scheduler, */
/*---------------------------------------------------------------------*/
153,6 → 174,8
 
int guarantee();
 
void levels_init(void); /* see init.c */
 
void runlevel_init();
void call_runlevel_func(int runlevel, int aborting);
 
234,6 → 257,8
return e;
}
 
#define kern_event_delete event_delete
 
/*+ the default capacity timer used by the kernel... +*/
void capacity_timer(void *arg);
 
240,17 → 265,17
 
#define kern_printf message
 
extern __inline__ TIME kern_gettime(struct timespec *t)
{
return ll_gettime(TIME_EXACT, t);
}
 
 
 
/*---------------------------------------------------------------------*/
/* Kernel global functions: IRQ, errors and exception handling */
/* Kernel global functions: IRQ handling */
/*---------------------------------------------------------------------*/
 
/*+ Generic exception trapping routine +*/
void act_exc(int code);
 
/*
* User level interrupt/exception primitives
*/
 
/*+ Interrupt handler installation +*/
int handler_set(int no, void (*fast)(int), PID pi);
 
288,18 → 313,6
/*+ prints an error message (see perror.c) +*/
void perror (const char *s);
 
/*+ Convert a status in a string. Useful for sys_status and level_status +*/
char *status_to_a(WORD status);
 
/*+ this primitive prints the status of the system. cw contains a set of
the statuses to be prompted... see const.h +*/
void sys_status(DWORD cw);
 
/*+ sys_status flags +*/
#define CLOCK_STATUS 1
#define SCHED_STATUS 2
#define MEM_STATUS 4
 
/*+ this primitive returns the time read from the system timer +*/
TIME sys_gettime(struct timespec *t);
 
345,6 → 358,34
void jet_update_endcycle();
 
/*---------------------------------------------------------------------*/
/* Internal Macros */
/*---------------------------------------------------------------------*/
 
extern __inline__ void kern_epilogue_macro(void)
{
TIME tx; /* a dummy used for time computation */
struct timespec ty; /* a dummy used for time computation */
 
kern_gettime(&schedule_time);
/* manage the capacity event */
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
proc_table[exec_shadow].avail_time -= tx;
jet_update_slice(tx);
 
/* if the event didn't fire before, we delete it. */
if (cap_timer != NIL) {
kern_event_delete(cap_timer);
cap_timer = NIL;
}
}
 
/* This function is called by the kernel into kern.c to register a default
exception handler */
int set_default_exception_handler(void);
 
/*---------------------------------------------------------------------*/
/* Task management primitives */
/*---------------------------------------------------------------------*/
 
487,16 → 528,18
/*+ Enable the preemption mechanism on the task. +*/
void task_preempt(void);
 
/*+ sends a message to the scheduling module that is handling the task +*/
int task_message(void *m, int reschedule);
 
/*+ This function signals to the kernel that the current istance of
the task (periodic or aperiodic) is ended; so the task can be
suspended until it is activated again. Pending activations may be saved
depending on the task model +*/
void task_endcycle(void);
extern __inline__ void task_endcycle(void)
{
task_message(NULL, 1);
}
 
/*+ This function suspend the actual task until an explicit activation
Pending activations are discarded +*/
void task_sleep(void);
 
/*+ This primitives refers the group id which is supplied
by the application, not by the kernel +*/
int group_activate(WORD g);
/shark/trunk/include/kernel/model.h
21,11 → 21,11
 
/**
------------
CVS : $Id: model.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: model.h,v 1.2 2003-01-07 17:12:19 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:19 $
------------
 
This file contains the definitions of the task and resource models.
55,8 → 55,8
#define __KERNEL_MODEL_H__
 
#include "ll/ll.h"
#include "kernel/types.h"
 
 
/* -----------------------------------------------------------------------
-----------------------------------------------------------------------
-----------------------------------------------------------------------
165,6 → 165,7
 
typedef struct {
WORD pclass;
LEVEL level;
size_t stacksize;
void *stackaddr;
WORD group;
210,13 → 211,13
 
/* Some macros to set various task-model parameters */
#define task_default_model(m,p) (m).pclass = (p), \
(m).level = 0; \
(m).stacksize = 4096, \
(m).stackaddr = NULL, \
(m).group = 0, \
(m).arg = NULL,\
(m).control = 0
#define task_def_level(m,l) (m).pclass = ((m).pclass & 0xFF00) | \
((l) & 0xFF)
#define task_def_level(m,l) (m).level = (l)
#define task_def_arg(m,a) (m).arg = (a)
#define task_def_stack(m,s) (m).stacksize = (s)
#define task_def_stackaddr(m,s) (m).stackaddr = (s)
237,16 → 238,13
PCLASS values
----------------------------------------------------------------------- */
 
/*+ These are the value for the pclass field;
a level l that accept a task model with pclass p
accept also the alias pclass (p | l)
=> the LSByte MUST be 0 (256 levels maximum) +*/
/* These are the value for the pclass field */
 
#define DUMMY_PCLASS 0x0000
#define HARD_PCLASS 0x0100
#define SOFT_PCLASS 0x0200
#define NRT_PCLASS 0x0300
#define JOB_PCLASS 0x0400
#define DUMMY_PCLASS 0
#define HARD_PCLASS 1
#define SOFT_PCLASS 2
#define NRT_PCLASS 3
#define JOB_PCLASS 4
 
 
/* -----------------------------------------------------------------------
559,11 → 557,12
+*/
 
typedef struct {
int rclass; // protocollo a cui si riferisce il modello di task
int rclass; /* protocol */
RLEVEL level; /* level */
} RES_MODEL;
 
#define res_default_model(r, p) (r).rclass = (p)
#define res_def_level(r,l) (r).rclass = ((r).rclass & 0xFF00) | (l)
#define res_default_model(r, p) (r).rclass = (p), (r).level = 0
#define res_def_level(r,l) (r).level = (l)
 
 
 
/shark/trunk/include/kernel/descr.h
21,11 → 21,11
 
/**
------------
CVS : $Id: descr.h,v 1.2 2002-11-11 08:36:01 pj Exp $
CVS : $Id: descr.h,v 1.3 2003-01-07 17:12:19 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:36:01 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:12:19 $
------------
 
Kernel main data structures
130,8 → 130,6
int sigpending; /*+ The signal pending mask +*/
int sigwaiting; /*+ The signal waiting mask +*/
 
struct timespec request_time;
/*+ Last request time for the task +*/
int avail_time; /*+ the time the task can execute before a
timer fire. see also the control field
and bits related in model.h +*/
193,133 → 191,107
All the informations that depends on the particular module are put
in the level module files.
 
The initialization of a level is splitted in two parts:
- the registration -> called before the system initialization, typically
AFTER the resource registration
- the level_init -> called during the system initialization,
BEFORE the resource_init(s)
Here a small description of the various functions:
 
-------------------------------------------------------------------
- PUBLIC Functions:
on one side, a module should export an interface to the Generic
Kernel, giving a set of functions that the Generic Kernel can use
to ask a service to the module. That is, the Public Functions are
called ONLY by the Generic Kernel.
 
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
- PRIVATE Functions: on the other side, a module can export an
interface to the public part of the same or of another
module. That is, Private Functions are called ONLY by Public and
Private Functions.
-------------------------------------------------------------------
 
typedef struct {
char level_name[MAX_LEVELNAME]; /*+ for statistical pourposes +*/
WORD level_code; /*+ level identification code +*/
BYTE level_version; /*+ level version +*/
int (*private_insert )(LEVEL l, PID p, TASK_MODEL *m);
Inserts a task into the internal module data structure.
void (*private_extract )(LEVEL l, PID p);
Removes a task from the internal module data structure.
 
/* LEVEL CALLS */
int (*level_accept_task_model)(LEVEL l, TASK_MODEL *m);
/*+ models that a task can manage. returns
0 if the level can manage the model,
-1 if not +*/
int (*private_eligible)(LEVEL l, PID p);
A task inserted into the internal module data structure needs to be
scheduled. returns 0 if it can be scheduled, -1 if not.
 
int (*level_accept_guest_model)(LEVEL l, TASK_MODEL *m);
/*+ models that a task can manage as guest
tasks. returns
0 if the level can manage the model,
-1 if not +*/
void (*private_dispatch)(LEVEL l, PID p, int nostop);
A task inserted into the internal module data structure has been dispatched.
 
void (*level_status)(LEVEL l);/*+ print level statistics... +*/
void (*private_epilogue)(LEVEL l, PID p);
A task inserted into the internal module data structure has been preempted.
 
PID (*level_scheduler)(LEVEL l);
/*+ the level scheduler returns a task
chosen among those belonging to the
level +*/
 
int (*level_guarantee)(LEVEL l, bandwidth_t *freebandwidth);
/*+ 0 if the level is guaranteed, -1 if not
no guarantee if (*f)()=null
the function updates the parameter
(see guarantee() ) +*/
 
/* TASK CALLS */
int (*task_create)(LEVEL l, PID p, TASK_MODEL *m);
/*+ the task p is created into the level
returns 0->ok, -1->error +*/
void (*task_detach)(LEVEL l, PID p);
/*+ there is an error in the task_create
after the task call task_create.
The function delete all the informations
about the task in the level.
For the resources levels there is the
res_detach: res_detach is called also
when killing a task +*/
int (*task_eligible)(LEVEL l, PID p);
/*+ correctness control when a task is
chosen by a level scheduler (used with
aperiodic servers) 0->ok, -1->no +*/
void (*task_dispatch)(LEVEL l, PID p, int nostop);
/*+ a task go in the EXEC status (called
by dispatch() ) +*/
void (*task_epilogue)(LEVEL l, PID p);
/*+ a task has finished the current slice+*/
PID (*public_scheduler)(LEVEL l);
returns a task to schedule, or -1 if no tasks are ready
 
void (*task_activate)(LEVEL l, PID p);
/*+ the task is activated... +*/
int (*public_guarantee)(LEVEL l, bandwidth_t *freebandwidth);
returns 0 if the level is guaranteed, -1 if not
no guarantee if (*f)()=null
the function updates the parameter freebandwidth (see guarantee() )
int (*public_create )(LEVEL l, PID p, TASK_MODEL *m);
the task p is created into the module
returns 0->ok, -1->error
 
void (*task_insert)(LEVEL l, PID p);
/*+ opposite to task_extract +*/
void (*task_extract)(LEVEL l, PID p);
/*+ remove the task from the "ready" (if any)
queue +*/
void (*public_detach )(LEVEL l, PID p);
there is an error in the public_create. The function removes all the
informations about the task in the module.
 
void (*task_endcycle)(LEVEL l, PID p);
/*+ the (periodic) task finish the cycle +*/
void (*task_end)(LEVEL l, PID p);
/*+ the task is killed; we have to remove
it from the level queues, test if it
is in the exec state, etc... it can
modify the state of the task (-> FREE,
ZOMBIE...), but
cannot call the scheduler directly (it
is called by the task_makefree.
Note: the task can be in a state
different from those managed by the
level because the task may be blocked.
the res_detach is in any case called
AFTER the task_end. +*/
void (*public_end )(LEVEL l, PID p);
the task has been killed, or it ended regularly
 
void (*task_sleep)(LEVEL l, PID p);
/*+ this function will fall asleep the
task in the EXE state. +*/
int (*public_eligible )(LEVEL l, PID p);
A task needs to be scheduled. returns 0 if it can be scheduled, -1 if not.
void (*public_dispatch )(LEVEL l, PID p, int nostop);
A task has been dispatched.
 
void (*public_epilogue )(LEVEL l, PID p);
A task has been preempted (or its capacity is exausted).
 
/* guest CALLS:
these functions are called from an Aperiodic Server Level for the task
that are inserted in the local queues */
int (*guest_create)(LEVEL l, PID p, TASK_MODEL *m);
/*+ the task is already created in another
level and it is inserted in the current
level; returns 0->ok, -1->error +*/
void (*guest_detach)(LEVEL l, PID p);
/*+ there is an error in a task creation
of a task made by an aperiodic server
The function delete all the informations
about the task in the level. +*/
void (*guest_dispatch)(LEVEL l, PID p, int nostop);
/*+ a task belonging to another level but
inserted in the current level go in the
EXEC status (called by dispatch() ) +*/
void (*guest_epilogue)(LEVEL l, PID p);
/*+ a task has finished the current slice+*/
void (*public_activate )(LEVEL l, PID p);
A task has been activated.
 
void (*guest_activate)(LEVEL l, PID p);
/*+ the task is activated... +*/
void (*public_unblock )(LEVEL l, PID p);
void (*public_block )(LEVEL l, PID p);
A task has been unblocked/blocked on a synchronization point
(e.g. a semaphore, a mailbox, a nanosleep).
 
void (*guest_insert)(LEVEL l, PID p);
/*+ remove the task from the "ready" (if any)
queue +*/
void (*guest_extract)(LEVEL l, PID p);
/*+ opposite to guest_insert +*/
int (*public_message )(LEVEL l, PID p, void *m);
A task sent a message m to the module.
 
If the message has value NULL the
behavior should be the task_endcycle primitive behavior.
 
void (*guest_endcycle)(LEVEL l, PID p);
/*+ the task finish the cycle +*/
void (*guest_end)(LEVEL l, PID p);
/*+ the task is killed +*/
The function returns an integer to the user.
 
void (*guest_sleep)(LEVEL l, PID p);
If you want to avoid the call to public_epilogue, after public_message,
just write exec = exec_shadow = -1; in your public_message code.
 
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
typedef struct {
void (*private_insert )(LEVEL l, PID p, TASK_MODEL *m);
void (*private_extract )(LEVEL l, PID p);
int (*private_eligible)(LEVEL l, PID p);
void (*private_dispatch)(LEVEL l, PID p, int nostop);
void (*private_epilogue)(LEVEL l, PID p);
 
PID (*public_scheduler)(LEVEL l);
int (*public_guarantee)(LEVEL l, bandwidth_t *freebandwidth);
int (*public_create )(LEVEL l, PID p, TASK_MODEL *m);
void (*public_detach )(LEVEL l, PID p);
void (*public_end )(LEVEL l, PID p);
int (*public_eligible )(LEVEL l, PID p);
void (*public_dispatch )(LEVEL l, PID p, int nostop);
void (*public_epilogue )(LEVEL l, PID p);
void (*public_activate )(LEVEL l, PID p);
void (*public_unblock )(LEVEL l, PID p);
void (*public_block )(LEVEL l, PID p);
int (*public_message )(LEVEL l, PID p, void *m);
} level_des;
 
 
344,27 → 316,18
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
typedef struct {
char res_name[MAX_MODULENAME];/*+ for statistical pourposes +*/
WORD res_code; /*+ resource module identification code +*/
BYTE res_version; /*+ resource module version +*/
 
int rtype; /*+ resource module extented interface
code (see model.h) +*/
 
void (*resource_status)(); /*+ print resource protocol statistics...+*/
int (*res_register)(RLEVEL l, PID p, RES_MODEL *r);
/*+ When the system knows that a
resource model can be registered
by a level, it calls this
function. It registers all the
information about the task and the
model. returns 0 if the model
can be handled, -1 otherwise+*/
 
int (*level_accept_resource_model)(RLEVEL l, RES_MODEL *r);
/*+ this function is called when the process
is created. it returns 0 if the RES_MODEL
can be managed by the level,-1 if not+*/
 
void (*res_register)(RLEVEL l, PID p, RES_MODEL *r);
/*+ When the system knows that a resource
model can be registered by a level,
it calls this function. It registers all
the information about the task and the
model. +*/
 
void (*res_detach)(RLEVEL l, PID p);
/*+ this function is called when the task
is killed or some error is occurred
411,13 → 374,10
typedef struct {
resource_des r;
 
int (*level_accept_mutexattr)(RLEVEL l, const mutexattr_t *a);
/*+ this function is called when a mutex
is created. it returns 0 if the
mutexattr_t
can be managed by the level,-1 if not+*/
 
int (*init) (RLEVEL l, mutex_t *m, const mutexattr_t *a);
/*+ this function is called when a mutex is created. it returns
>=0 if the mutexattr_t can be managed by the level (=0 Ok, an
error otherwise), -1 otherwise +*/
int (*destroy)(RLEVEL l, mutex_t *m);
int (*lock) (RLEVEL l, mutex_t *m);
int (*trylock)(RLEVEL l, mutex_t *m);
/shark/trunk/include/kernel/const.h
16,11 → 16,11
 
/**
------------
CVS : $Id: const.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: const.h,v 1.2 2003-01-07 17:12:19 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:19 $
------------
 
System constants:
156,17 → 156,13
 
/*+ sys_atrunlevel status bit values: used to signal that the function
has to be called +*/
#define RUNLEVEL_STARTUP 0 /*+ startup in real mode +*/
#define RUNLEVEL_INIT 1 /*+ init time +*/
#define RUNLEVEL_SHUTDOWN 2 /*+ shutting down the system +*/
#define RUNLEVEL_BEFORE_EXIT 3 /*+ before the kernel has been terminated +*/
#define RUNLEVEL_AFTER_EXIT 4 /*+ after the kernel has been terminated +*/
#define RUNLEVEL_RUNNING 2 /*+ system is running!!! +*/
#define RUNLEVEL_SHUTDOWN 3 /*+ shutting down the system +*/
#define RUNLEVEL_BEFORE_EXIT 4 /*+ before the kernel has been terminated +*/
#define RUNLEVEL_AFTER_EXIT 5 /*+ after the kernel has been terminated +*/
#define NO_AT_ABORT 8 /*+ only when sys_end is called +*/
 
/*
#define EXC_CLEAR 0
#define EXC_INSTALLED 1
#define EXC_ACTIVE 2
#define EXC_MASKED 4
*/
#endif /* __CONST_H__ */
 
/shark/trunk/include/kernel/var.h
21,11 → 21,11
 
/**
------------
CVS : $Id: var.h,v 1.2 2002-11-11 08:36:01 pj Exp $
CVS : $Id: var.h,v 1.3 2003-01-07 17:12:19 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-11-11 08:36:01 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:12:19 $
------------
 
Kernel global variables
63,7 → 63,17
/*---------------------------------------------------------------------*/
 
extern proc_des proc_table[]; /*+ Process descriptor table +*/
 
extern level_des *level_table[]; /*+ Level descriptor table +*/
/* for a description of the following fields, look in kernel/kern.c */
extern size_t level_size[];
extern int level_used[];
extern int level_first;
extern int level_last;
extern int level_free;
extern int level_next[];
extern int level_prev[];
 
extern resource_des *resource_table[]; /*+ Resource descriptor table +*/
 
 
84,7 → 94,6
event is posted. Normally, it is
equal to schedule_time +*/
 
extern DWORD sched_levels; /*+ Schedule levels active in the system +*/
extern DWORD res_levels; /*+ Resource levels active in the system +*/
 
extern int task_counter; /*+ Application task counter. It represent
/shark/trunk/include/modules/codes.h
File deleted
/shark/trunk/include/modules/dummy.h
21,11 → 21,11
 
/**
------------
CVS : $Id: dummy.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: dummy.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the scheduling module RR (Round Robin)
78,6 → 78,8
#ifndef __DUMMY_H__
#define __DUMMY_H__
 
#include <kernel/types.h>
 
/*+
On upper Intel CPUs it is possible to avoid CPU power consumption
when the system is idle issuing the hlt instruction.
86,7 → 88,10
+*/
#define __HLT_WORKS__
 
/*+ Registration function +*/
void dummy_register_level();
/*+ Registration function
 
returns the level number at which the module has been registered.
+*/
LEVEL dummy_register_level();
 
#endif
/shark/trunk/include/modules/nop.h
21,11 → 21,11
 
/**
------------
CVS : $Id: nop.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: nop.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the No Protocol (NOP) implementation of mutexes
79,6 → 79,8
#ifndef __NOP_H__
#define __NOP_H__
 
void NOP_register_module(void);
#include <kernel/types.h>
 
RLEVEL NOP_register_module(void);
 
#endif
/shark/trunk/include/modules/edf.h
21,11 → 21,11
 
/**
------------
CVS : $Id: edf.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: edf.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the scheduling module EDF (Earliest Deadline First)
123,7 → 123,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
 
/*+ flags... +*/
137,9 → 136,12
 
 
/*+ Registration function:
int flag Options to be used in this level instance... +*/
void EDF_register_level(int flag);
int flag Options to be used in this level instance...
 
returns the level number at which the module has been registered.
+*/
LEVEL EDF_register_level(int flag);
 
/*+ Returns the used bandwidth of a level +*/
bandwidth_t EDF_usedbandwidth(LEVEL l);
 
/shark/trunk/include/modules/posix.h
21,11 → 21,11
 
/**
------------
CVS : $Id: posix.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: posix.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the scheduling module compatible with POSIX
96,7 → 96,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
extern TASK __init__(void *arg);
 
112,8 → 111,11
/*+ Registration function:
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void POSIX_register_level(TIME slice,
struct multiboot_info *mb used if createmain specified
 
returns the level number at which the module has been registered.
+*/
LEVEL POSIX_register_level(TIME slice,
int createmain,
struct multiboot_info *mb,
int prioritylevels);
/shark/trunk/include/modules/pc.h
21,11 → 21,11
 
/**
------------
CVS : $Id: pc.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: pc.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the Priority Ceiling (PC) Protocol
93,7 → 93,7
#include <kernel/types.h>
#include <kernel/descr.h>
 
void PC_register_module(void);
RLEVEL PC_register_module(void);
 
/*+ This function gets the ceiling of a PC mutex, and it have to be called
only by a task that owns the mutex.
/shark/trunk/include/modules/bd_edf.h
38,11 → 38,11
*/
 
/*
* CVS : $Id: bd_edf.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
* CVS : $Id: bd_edf.h,v 1.2 2003-01-07 17:12:19 pj Exp $
*
* File: $File$
* Revision: $Revision: 1.1.1.1 $
* Last update: $Date: 2002-03-29 14:12:51 $
* Revision: $Revision: 1.2 $
* Last update: $Date: 2003-01-07 17:12:19 $
*/
 
#ifndef __BD_EDF_H__
51,7 → 51,7
#include <kernel/types.h>
#include <kernel/descr.h>
 
void BD_EDF_register_module(void);
RLEVEL BD_EDF_register_module(void);
 
TIME bd_edf_getdl(void);
 
/shark/trunk/include/modules/srp.h
21,11 → 21,11
 
/**
------------
CVS : $Id: srp.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: srp.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the Stack Resource Policy (SRP) Protocol
108,7 → 108,7
#include <kernel/model.h>
#include <kernel/descr.h>
 
void SRP_register_module(void);
RLEVEL SRP_register_module(void);
 
extern __inline__ RES_MODEL *SRP_usemutex(mutex_t *m) {
return (RES_MODEL *)m->opt;
/shark/trunk/include/modules/rr2.h
21,11 → 21,11
 
/**
------------
CVS : $Id: rr2.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: rr2.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the scheduling module RR (Round Robin)
94,7 → 94,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
extern TASK __init__(void *arg);
 
110,8 → 109,11
/*+ Registration function:
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void RR2_register_level(TIME slice,
struct multiboot_info *b used if createmain specified
returns the level number at which the module has been registered.
+*/
LEVEL RR2_register_level(TIME slice,
int createmain,
struct multiboot_info *mb);
 
/shark/trunk/include/modules/ds.h
21,11 → 21,11
 
/**
------------
CVS : $Id: ds.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: ds.h,v 1.2 2003-01-07 17:12:19 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:19 $
------------
 
This file contains the aperiodic server DS (Polling Server)
92,7 → 92,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
/*+ 1 - ln(2) +*/
#ifndef RM_MINFREEBANDWIDTH
119,9 → 118,12
int flags Options to be used in this level instance...
LEVEL master the level that must be used as master level for the
TBS tasks
int num,den used to compute the TBS bandwidth +*/
void DS_register_level(int flags, LEVEL master, int Cs, int per);
int num,den used to compute the TBS bandwidth
 
returns the level number at which the module has been registered.
+*/
LEVEL DS_register_level(int flags, LEVEL master, int Cs, int per);
 
/*+ Returns the used bandwidth of a level +*/
bandwidth_t DS_usedbandwidth(LEVEL l);
 
/shark/trunk/include/modules/cbs.h
21,11 → 21,11
 
/**
------------
CVS : $Id: cbs.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: cbs.h,v 1.2 2003-01-07 17:12:19 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:19 $
------------
 
This file contains the aperiodic server CBS (Total Bandwidth Server)
103,7 → 103,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
/*+ flags... +*/
#define CBS_DISABLE_ALL 0 /*+ Task Guarantee enabled +*/
117,8 → 116,10
int flags Options to be used in this level instance...
LEVEL master the level that must be used as master level for the
CBS tasks
 
returns the level number at which the module has been registered.
+*/
void CBS_register_level(int flags, LEVEL master);
LEVEL CBS_register_level(int flags, LEVEL master);
 
/*+ Returns the used bandwidth of a level +*/
bandwidth_t CBS_usedbandwidth(LEVEL l);
/shark/trunk/include/modules/pi.h
21,11 → 21,11
 
/**
------------
CVS : $Id: pi.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: pi.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the Priority Inheritance (PI) Protocol
89,6 → 89,8
#ifndef __PI_H__
#define __PI_H__
 
void PI_register_module(void);
#include <kernel/types.h>
 
RLEVEL PI_register_module(void);
 
#endif
/shark/trunk/include/modules/bd_pscan.h
39,11 → 39,11
*/
 
/*
* CVS : $Id: bd_pscan.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
* CVS : $Id: bd_pscan.h,v 1.2 2003-01-07 17:12:19 pj Exp $
*
* File: $File$
* Revision: $Revision: 1.1.1.1 $
* Last update: $Date: 2002-03-29 14:12:51 $
* Revision: $Revision: 1.2 $
* Last update: $Date: 2003-01-07 17:12:19 $
*/
 
#ifndef __BD_PSCAN_H__
52,7 → 52,7
#include <kernel/types.h>
#include <kernel/descr.h>
 
void BD_PSCAN_register_module(void);
RLEVEL BD_PSCAN_register_module(void);
 
int bd_pscan_getpriority(void);
 
/shark/trunk/include/modules/rm.h
21,11 → 21,11
 
/**
------------
CVS : $Id: rm.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: rm.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the scheduling module RM (Rate Monotonic)
122,7 → 122,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
/*+ 1 - ln(2) +*/
 
143,9 → 142,12
 
 
/*+ Registration function:
int flag Options to be used in this level instance... +*/
void RM_register_level(int flag);
int flag Options to be used in this level instance...
 
returns the level number at which the module has been registered.
+*/
LEVEL RM_register_level(int flag);
 
/*+ Returns the used bandwidth of a level +*/
bandwidth_t RM_usedbandwidth(LEVEL l);
 
/shark/trunk/include/modules/rrsoft.h
21,11 → 21,11
 
/**
------------
CVS : $Id: rrsoft.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: rrsoft.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the scheduling module RRSOFT (Round Robin for
103,7 → 103,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
extern TASK __init__(void *arg);
 
124,8 → 123,12
/*+ Registration function:
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void RRSOFT_register_level(TIME slice,
struct multiboot_info *mb used if createmain specified
 
returns the level number at which the module has been registered.
+*/
 
LEVEL RRSOFT_register_level(TIME slice,
int createmain,
struct multiboot_info *mb,
BYTE models);
/shark/trunk/include/modules/ps.h
21,11 → 21,11
 
/**
------------
CVS : $Id: ps.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: ps.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the aperiodic server PS (Polling Server)
93,7 → 93,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
/*+ 1 - ln(2) +*/
#ifndef RM_MINFREEBANDWIDTH
120,9 → 119,12
int flags Options to be used in this level instance...
LEVEL master the level that must be used as master level for the
TBS tasks
int num,den used to compute the TBS bandwidth +*/
void PS_register_level(int flags, LEVEL master, int Cs, int per);
int num,den used to compute the TBS bandwidth
 
returns the level number at which the module has been registered.
+*/
LEVEL PS_register_level(int flags, LEVEL master, int Cs, int per);
 
/*+ Returns the used bandwidth of a level +*/
bandwidth_t PS_usedbandwidth(LEVEL l);
 
/shark/trunk/include/modules/rr.h
21,11 → 21,11
 
/**
------------
CVS : $Id: rr.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: rr.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the scheduling module RR (Round Robin)
95,7 → 95,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
extern TASK __init__(void *arg);
 
111,8 → 110,11
/*+ Registration function:
TIME slice the slice for the Round Robin queue
int createmain 1 if the level creates the main task 0 otherwise
struct multiboot_info *mb used if createmain specified +*/
void RR_register_level(TIME slice,
struct multiboot_info *mb used if createmain specified
 
returns the level number at which the module has been registered.
+*/
LEVEL RR_register_level(TIME slice,
int createmain,
struct multiboot_info *mb);
 
/shark/trunk/include/modules/ss.h
21,11 → 21,11
 
/**
------------
CVS : $Id: ss.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: ss.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the aperiodic server SS (Sporadic Server)
103,7 → 103,6
#include <kernel/config.h>
#include <kernel/types.h>
#include <sys/types.h>
#include <modules/codes.h>
 
/*+ 1 - ln(2) +*/
#ifndef RM_MINFREEBANDWIDTH
151,9 → 150,12
int flags Options to be used in this level instance...
LEVEL master The level that must be used as master level
int Cs Server capacity
int per Server period +*/
void SS_register_level(int flags, LEVEL master, int Cs, int per);
int per Server period
 
returns the level number at which the module has been registered.
+*/
LEVEL SS_register_level(int flags, LEVEL master, int Cs, int per);
 
/*+ Returns the used bandwidth of a level +*/
bandwidth_t SS_usedbandwidth(LEVEL l);
 
/shark/trunk/include/modules/tbs.h
21,11 → 21,11
 
/**
------------
CVS : $Id: tbs.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: tbs.h,v 1.2 2003-01-07 17:12:20 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:51 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:12:20 $
------------
 
This file contains the aperiodic server TBS (Total Bandwidth Server)
126,7 → 126,6
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
 
/*+ flags... +*/
#define TBS_DISABLE_ALL 0
/shark/trunk/include/bits/errno.h
20,11 → 20,11
 
/**
------------
CVS : $Id: errno.h,v 1.2 2002-10-28 07:53:00 pj Exp $
CVS : $Id: errno.h,v 1.3 2003-01-07 17:12:19 pj Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2002-10-28 07:53:00 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:12:19 $
------------
 
- error codes used as values for errno
104,11 → 104,11
 
#define LAST_EXC_NUMBER 19
 
#define XDOUBLE_EXCEPTION 1 /* in act_exc */
// NOW UNUSED: XDOUBLE_EXCEPTION 1
#define XINVALID_KILL_SHADOW 2 /* task_makefree */
#define XNOMORE_CLEANUPS 3 /* task_cleanup_push */
#define XINVALID_TASK 4 /* invalid operation for a task */
#define XINVALID_GUEST 5 /* invalid operation for a guest task */
// NOW UNUSED: XINVALID_GUEST 5 /* invalid operation for a guest task */
#define XNOMORE_EVENTS 6 /* too many events posted... */
 
#define XDEADLINE_MISS 7 /* PERIODIC_PCLASS, SPORADIC_PCLASS */
149,7 → 149,7
#define ETOOMUCH_EXITFUNC (5 + LAST_STDERRNO) /* sys_atexit */
#define ENO_AVAIL_TASK (6 + LAST_STDERRNO) /* task_create */
#define ENO_AVAIL_SCHEDLEVEL (7 + LAST_STDERRNO) /* task_create */
#define ETASK_CREATE (8 + LAST_STDERRNO) /* task_create */
/* NOW UNUSED: ETASK_CREATE (8 + LAST_STDERRNO) task_create */
#define ENO_AVAIL_RESLEVEL (9 + LAST_STDERRNO) /* task_create */
#define ENO_GUARANTEE (10 + LAST_STDERRNO) /* task_create */
#define ENO_AVAIL_STACK_MEM (11 + LAST_STDERRNO) /* task_create */
/shark/trunk/fs/fs.c
34,11 → 34,11
*/
 
/*
* CVS : $Id: fs.c,v 1.1.1.1 2002-03-29 14:12:50 pj Exp $
* CVS : $Id: fs.c,v 1.2 2003-01-07 17:14:05 pj Exp $
*
* File: $File$
* Revision: $Revision: 1.1.1.1 $
* Last update: $Date: 2002-03-29 14:12:50 $
* Revision: $Revision: 1.2 $
* Last update: $Date: 2003-01-07 17:14:05 $
*/
 
#include "dentry.h"
761,8 → 761,6
return (void*)-1;
}
 
//sys_status(SCHED_STATUS);
printkc("fs_shut: END");
 
return (void*)0;
/shark/trunk/drivers/pxc/pxc.c
261,7 → 261,7
proc_table[p].frozen_activations++;
else {
l = proc_table[p].task_level;
level_table[l]->task_activate(l,p);
level_table[l]->public_activate(l,p);
event_need_reschedule();
}
 
/shark/trunk/drivers/char/scom.c
20,11 → 20,11
 
/**
------------
CVS : $Id: scom.c,v 1.1.1.1 2002-03-29 14:12:49 pj Exp $
CVS : $Id: scom.c,v 1.2 2003-01-07 17:14:05 pj Exp $
 
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:49 $
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:14:05 $
------------
 
Author: Massimiliano Giorgi
482,7 → 482,6
task_activate(p3);
task_endcycle();
sys_end();
sys_status(NORM_STATUS);
#ifdef __DEBUG_SERIAL__
cprintf("RxServer was activated %d times\n",rx_time);
cprintf("TxServer was activated %d times\n",tx_time);