Català-Valencià - Catalan中文 - Chinese (Simplified)中文 - Chinese (Traditional)Česky - CzechDansk - DanishNederlands - DutchEnglish - EnglishSuomi - FinnishFrançais - FrenchDeutsch - Germanעברית - Hebrewहिंदी - HindiMagyar - HungarianBahasa Indonesia - IndonesianItaliano - Italian日本語 - Japanese한국어 - KoreanМакедонски - Macedonianमराठी - MarathiNorsk - NorwegianPolski - PolishPortuguês - PortuguesePortuguês - Portuguese (Brazil)Русский - RussianSlovenčina - SlovakSlovenščina - SlovenianEspañol - SpanishSvenska - SwedishTürkçe - TurkishУкраїнська - UkrainianOëzbekcha - Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /shark/branches/pj @ 2

  → /shark/tags/rel_0_2/ @ 35

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Ignore whitespace Rev 2 → Rev 35

/shark/tags/rel_0_2/kernel/oldmem.c
File deleted

/shark/tags/rel_0_2/kernel/init/pinit.c
File deleted

/shark/tags/rel_0_2/kernel/init/init1.c
File deleted

/shark/tags/rel_0_2/kernel/init/init2.c
File deleted

/shark/tags/rel_0_2/kernel/init/init3.c
File deleted

/shark/tags/rel_0_2/kernel/init/init4.c
File deleted

/shark/tags/rel_0_2/kernel/init/init5.c
File deleted

/shark/tags/rel_0_2/kernel/init/init6.c
File deleted

/shark/tags/rel_0_2/kernel/init/makefile
File deleted

/shark/tags/rel_0_2/kernel/init/initfs.c
File deleted

/shark/tags/rel_0_2/kernel/init/initblk.c
File deleted

/shark/tags/rel_0_2/kernel/init/rm1.c
File deleted

/shark/tags/rel_0_2/kernel/init/h3pi.c
File deleted

/shark/tags/rel_0_2/kernel/init/hartik3.c
File deleted

/shark/tags/rel_0_2/kernel/init/h3pips.c
File deleted

/shark/tags/rel_0_2/kernel/init/h3piss.c
File deleted

/shark/tags/rel_0_2/kernel/init/initg.c
File deleted

/shark/tags/rel_0_2/kernel/delay.c
File deleted

/shark/tags/rel_0_2/kernel/newmem.c
File deleted

/shark/tags/rel_0_2/kernel/qqueue.c
File deleted

/shark/tags/rel_0_2/kernel/queue.c
File deleted

/shark/tags/rel_0_2/kernel/int_sem.c
18,11 → 18,11
/**
------------
CVS : $Id: int_sem.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: int_sem.c,v 1.2 2002-11-11 08:34:08 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: 2002-11-11 08:34:08 $
------------
Internal semaphores.
68,7 → 68,7
void internal_sem_init(internal_sem_t *s, int value)
{
s->count = value;
qq_init(&s->blocked);
iq_init(&s->blocked,&freedesc,0);
}
void internal_sem_wait(internal_sem_t *s)
106,7 → 106,7
/* we insert the task in the semaphore queue */
proc_table[exec_shadow].status = INTERNAL_SEM_WAIT;
qq_insertlast(exec_shadow,&s->blocked);
iq_insertlast(exec_shadow,&s->blocked);
/* and finally we reschedule */
exec = exec_shadow = -1;
148,7 → 148,7
register PID p;
register LEVEL l;
p = qq_getfirst(&s->blocked);
p = iq_getfirst(&s->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);

/shark/tags/rel_0_2/kernel/activate.c
18,11 → 18,11
/**
------------
CVS : $Id: activate.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: activate.c,v 1.2 2002-10-28 07:58: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: 2002-10-28 07:58:19 $
------------
task_activate & group_activate
73,11 → 73,11
/* some controls on the task p */
if (p<0 || p>=MAX_PROC) {
errno = EUNVALID_TASK_ID;
errno = EINVALID_TASK_ID;
return -1;
}
if (proc_table[p].status == FREE) {
errno = EUNVALID_TASK_ID;
errno = EINVALID_TASK_ID;
return -1;
}
142,7 → 142,7
register LEVEL l; /* a level value */
if (g == 0) {
errno = EUNVALID_GROUP;
errno = EINVALID_GROUP;
return -1;
}

/shark/tags/rel_0_2/kernel/blkact.c
21,11 → 21,11
/**
------------
CVS : $Id: blkact.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: blkact.c,v 1.2 2002-10-28 07:58: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: 2002-10-28 07:58:19 $
------------
block_activations & co.
78,11 → 78,11
/* some controls on the task p */
if (p<0 || p>=MAX_PROC) {
errno = EUNVALID_TASK_ID;
errno = EINVALID_TASK_ID;
return -1;
}
if (proc_table[p].status == FREE) {
errno = EUNVALID_TASK_ID;
errno = EINVALID_TASK_ID;
return -1;
}
107,11 → 107,11
/* some controls on the task p */
if (p<0 || p>=MAX_PROC) {
errno = EUNVALID_TASK_ID;
errno = EINVALID_TASK_ID;
return -1;
}
if (proc_table[p].status == FREE) {
errno = EUNVALID_TASK_ID;
errno = EINVALID_TASK_ID;
return -1;
}

/shark/tags/rel_0_2/kernel/mqueue.c
18,11 → 18,11
/**
------------
CVS : $Id: mqueue.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: mqueue.c,v 1.2 2002-11-11 08:34:09 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: 2002-11-11 08:34:09 $
------------
POSIX message queues
90,8 → 90,8
correct bit is set */
/* the blocked processes queues */
QQUEUE blocked_send;
QQUEUE blocked_rcv;
IQUEUE blocked_send;
IQUEUE blocked_rcv;
int next; /* the mq queue */
} mq_table[MQ_OPEN_MAX];
105,7 → 105,7
if the task is not blocked...) */
} mqproc_table[MAX_PROC];
static QUEUE free_mq; /* Queue of free sem */
static int free_mq; /* Queue of free sem */
mqd_t mq_open(const char *name, int oflag, ...)
{
168,8 → 168,8
mq_table[mq].maxmsg = MQ_DEFAULT_MAXMSG;
mq_table[mq].msgsize = MQ_DEFAULT_MSGSIZE;
}
qq_init(&mq_table[mq].blocked_send);
qq_init(&mq_table[mq].blocked_rcv);
iq_init(&mq_table[mq].blocked_send, &freedesc, 0);
iq_init(&mq_table[mq].blocked_rcv, &freedesc, 0);
mq_table[mq].count = 0;
mq_table[mq].start = -1;
320,7 → 320,7
/* the task that have to be killed is waiting on a mq_send */
/* we have to extract the task from the blocked queue... */
qq_extract(i,&mq_table[mqproc_table[i].mqdes].blocked_send);
iq_extract(i,&mq_table[mqproc_table[i].mqdes].blocked_send);
/* and the task have to be reinserted into the ready queues, so it
will fall into task_testcancel */
334,7 → 334,7
/* the task that have to be killed is waiting on a mq_send */
/* we have to extract the task from the blocked queue... */
qq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_rcv);
iq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_rcv);
/* and the task have to be reinserted into the ready queues, so it
will fall into task_testcancel */
357,7 → 357,7
mqproc_table[exec_shadow].intsig = 1;
/* we have to extract the task from the blocked queue... */
qq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_send);
iq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_send);
/* and the task have to be reinserted into the ready queues, so it
will fall into task_testcancel */
373,7 → 373,7
mqproc_table[exec_shadow].intsig = 1;
/* we have to extract the task from the blocked queue... */
qq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_rcv);
iq_extract(i, &mq_table[mqproc_table[i].mqdes].blocked_rcv);
/* and the task have to be reinserted into the ready queues, so it
will fall into task_testcancel */
463,7 → 463,7
/* we insert the task in the message queue */
proc_table[exec_shadow].status = WAIT_MQSEND;
qq_insert(exec_shadow,&mq_table[mqdes].blocked_send);
iq_priority_insert(exec_shadow,&mq_table[mqdes].blocked_send);
/* and finally we reschedule */
exec = exec_shadow = -1;
504,7 → 504,7
/* the mq was empty */
PID p;
p = qq_getfirst(&mq_table[mqdes].blocked_rcv);
p = iq_getfirst(&mq_table[mqdes].blocked_rcv);
if ( p != NIL) {
/* The first blocked task has to be woken up */
629,7 → 629,7
/* we insert the task into the message queue */
proc_table[exec_shadow].status = WAIT_MQRECEIVE;
qq_insert(exec_shadow,&mq_table[mqdes].blocked_rcv);
iq_priority_insert(exec_shadow,&mq_table[mqdes].blocked_rcv);
/* and finally we reschedule */
exec = exec_shadow = -1;
671,7 → 671,7
returnvalue = mq_table[mqdes].mq_info[ msg ].msglen;
/* if the mq was full, there may be a task into blocked-send queue */
p = qq_getfirst(&mq_table[mqdes].blocked_send);
p = iq_getfirst(&mq_table[mqdes].blocked_send);
if ( p != NIL) {
/* The first blocked task on send has to be woken up */

/shark/tags/rel_0_2/kernel/printk.c
36,11 → 36,11
*/
/*
* CVS : $Id: printk.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
* CVS : $Id: printk.c,v 1.2 2002-10-28 07:56: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: 2002-10-28 07:56:49 $
*/
#include <ll/i386/cons.h>
84,6 → 84,7
f=kern_fsave();
cprintf("[%s] %s",levelname[level],buf);
/* if we called printk, and the string does not have a \n in it, add it */
if ((!flag)&&(!result)) cprintf("\n");
kern_frestore(f);

/shark/tags/rel_0_2/kernel/conditio.c
20,11 → 20,11
/**
------------
CVS : $Id: conditio.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: conditio.c,v 1.2 2002-11-11 08:34:08 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: 2002-11-11 08:34:08 $
------------
This file contains the condition variables handling functions.
59,6 → 59,7
#include <kernel/var.h>
#include <kernel/func.h>
#include <errno.h>
#include <kernel/iqueue.h>
/*---------------------------------------------------------------------*/
/* Condition variables */
76,8 → 77,8
/* if the task is waiting on a condition variable, we have to extract it
from the waiters queue, then set the KILL_REQUEST flag, and reinsert
the task into the ready queue so it can reaquire the mutex and die */
q_extract(i,&proc_table[i].cond_waiting->waiters);
if (proc_table[i].cond_waiting->waiters == NIL)
iq_extract(i,&proc_table[i].cond_waiting->waiters);
if (iq_isempty(&proc_table[i].cond_waiting->waiters))
proc_table[i].cond_waiting->used_for_waiting = NULL;
proc_table[i].cond_waiting = NULL;
102,7 → 103,8
register_cancellation_point(condition_cancellation_point, NULL);
}
cond->waiters = NIL;
iq_init (&cond->waiters, &freedesc, 0);
cond->used_for_waiting = NULL;
return 0;
110,7 → 112,7
int cond_destroy(cond_t *cond)
{
if (cond->waiters != NIL)
if (!iq_isempty(&cond->waiters))
return (EBUSY);
return 0;
123,8 → 125,8
proc_table[exec_shadow].context = kern_context_save();
if (cond->waiters != NIL) {
p = q_getfirst(&cond->waiters);
if (!iq_isempty(&cond->waiters)) {
p = iq_getfirst(&cond->waiters);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
143,13 → 145,13
proc_table[exec_shadow].context = kern_context_save();
if (cond->waiters != NIL) {
if (!iq_isempty(&cond->waiters)) {
do {
p = q_getfirst(&cond->waiters);
p = iq_getfirst(&cond->waiters);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
} while(cond->waiters != NIL);
} while(!iq_isempty(&cond->waiters));
scheduler();
}
214,7 → 216,7
/* we insert the task in the condition queue */
proc_table[exec_shadow].status = WAIT_COND;
q_insert(exec_shadow,&cond->waiters);
iq_priority_insert(exec_shadow,&cond->waiters);
/* then, we set into the processor descriptor the condition on that
the task is blocked... (if the task is killed while it is waiting
242,7 → 244,7
if (proc_table[exec_shadow].cond_waiting != NULL) {
proc_table[exec_shadow].cond_waiting = NULL;
if (cond->waiters == NIL) cond->used_for_waiting = NULL;
if (iq_isempty(&cond->waiters)) cond->used_for_waiting = NULL;
}
task_preempt();
268,8 → 270,8
PID p = (PID)arg;
LEVEL l;
q_extract(p,&proc_table[p].cond_waiting->waiters);
if (proc_table[p].cond_waiting->waiters == NIL)
iq_extract(p,&proc_table[p].cond_waiting->waiters);
if (iq_isempty(&proc_table[p].cond_waiting->waiters))
proc_table[p].cond_waiting->used_for_waiting = NULL;
proc_table[p].cond_waiting = NULL;
340,7 → 342,7
/* we insert the task in the condition queue */
proc_table[exec_shadow].status = WAIT_COND;
q_insert(exec_shadow,&cond->waiters);
iq_priority_insert(exec_shadow,&cond->waiters);
/* then, we set into the processor descriptor the condition on that
the task is blocked... (if the task is killed while it is waiting
379,7 → 381,7
if (proc_table[exec_shadow].cond_waiting != NULL) {
proc_table[exec_shadow].cond_waiting = NULL;
if (cond->waiters == NIL) cond->used_for_waiting = NULL;
if (iq_isempty(&cond->waiters)) cond->used_for_waiting = NULL;
}
else
/* cond_waiting == NULL if the task is killed or the timer has fired */

/shark/tags/rel_0_2/kernel/exchgrx.c
18,11 → 18,11
/**
------------
CVS : $Id: exchgrx.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: exchgrx.c,v 1.2 2002-10-28 07:58:04 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: 2002-10-28 07:58:04 $
------------
**/
90,7 → 90,7
{
if (myflag) {
kern_printf("\nS.Ha.R.K. Exception raised!!!"
"\nTime (s:ns) :%d:%d"
"\nTime (s:ns) :%ld:%ld"
"\nException number:%d"
"\nPID :%d\n",
mytime.tv_sec,

/shark/tags/rel_0_2/kernel/exchtxt.c
18,11 → 18,11
/**
------------
CVS : $Id: exchtxt.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: exchtxt.c,v 1.2 2002-11-11 08:34:08 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: 2002-11-11 08:34:08 $
------------
**/
75,7 → 75,7
kern_cli();
ll_gettime(TIME_EXACT, &t),
kern_printf("\nHartik Exception raised!!!"
"\nTime (s:ns) :%d:%d"
"\nTime (s:ns) :%ld:%ld"
"\nException number:%d"
"\nPID :%d\n",
t.tv_sec, t.tv_nsec, info->si_value.sival_int,

/shark/tags/rel_0_2/kernel/modules/edf2.c
File deleted

/shark/tags/rel_0_2/kernel/modules/old/trace.c
File deleted

/shark/tags/rel_0_2/kernel/modules/edf.c
20,11 → 20,11
/**
------------
CVS : $Id: edf.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: edf.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the scheduling module EDF (Earliest Deadline First)
67,7 → 67,6
/*+ Status used in the level +*/
#define EDF_READY MODULE_STATUS_BASE /*+ - Ready status +*/
#define EDF_DELAY MODULE_STATUS_BASE+1 /*+ - Delay status +*/
#define EDF_WCET_VIOLATED MODULE_STATUS_BASE+2 /*+ when wcet is finished +*/
#define EDF_WAIT MODULE_STATUS_BASE+3 /*+ to wait the deadline +*/
#define EDF_IDLE MODULE_STATUS_BASE+4 /*+ to wait the deadline +*/
90,7 → 89,7
/*+ used to manage the JOB_TASK_MODEL and the
periodicity +*/
QUEUE ready; /*+ the ready queue +*/
IQUEUE ready; /*+ the ready queue +*/
int flags; /*+ the init flags... +*/
106,7 → 105,6
switch (status) {
case EDF_READY : return "EDF_Ready";
case EDF_DELAY : return "EDF_Delay";
case EDF_WCET_VIOLATED: return "EDF_Wcet_Violated";
case EDF_WAIT : return "EDF_Sporadic_Wait";
case EDF_IDLE : return "EDF_Idle";
119,6 → 117,7
{
PID p = (PID) par;
EDF_level_des *lev;
struct timespec *temp;
edf_printf("$");
128,7 → 127,7
case EDF_ZOMBIE:
/* we finally put the task in the ready queue */
proc_table[p].status = FREE;
q_insertfirst(p,&freedesc);
iq_insertfirst(p,&freedesc);
/* and free the allocated bandwidth */
lev->U -= (MAX_BANDWIDTH/lev->period[p]) * proc_table[p].wcet;
break;
137,15 → 136,16
/* tracer stuff */
trc_logevent(TRC_INTACTIVATION,&p);
/* similar to EDF_task_activate */
temp = iq_query_timespec(p,&lev->ready);
TIMESPEC_ASSIGN(&proc_table[p].request_time,
&proc_table[p].timespec_priority);
ADDUSEC2TIMESPEC(lev->period[p], &proc_table[p].timespec_priority);
temp);
ADDUSEC2TIMESPEC(lev->period[p], temp);
proc_table[p].status = EDF_READY;
q_timespec_insert(p,&lev->ready);
lev->deadline_timer[p] = kern_event_post(&proc_table[p].timespec_priority,
iq_timespec_insert(p,&lev->ready);
lev->deadline_timer[p] = kern_event_post(temp,
EDF_timer_deadline,
(void *)p);
edf_printf("(dline p%d ev%d %d.%d)",(int)p,(int)lev->deadline_timer[p],(int)proc_table[p].timespec_priority.tv_sec,(int)proc_table[p].timespec_priority.tv_nsec/1000);
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 );
event_need_reschedule();
printk("el%d|",p);
172,23 → 172,6
kern_raise(XDEADLINE_MISS,p);
}
/*+ this function is called when a task finish his delay +*/
static void EDF_timer_delay(void *par)
{
PID p = (PID) par;
EDF_level_des *lev;
lev = (EDF_level_des *)level_table[proc_table[p].task_level];
proc_table[p].status = EDF_READY;
q_timespec_insert(p,&lev->ready);
proc_table[p].delay_timer = NIL; /* Paranoia */
event_need_reschedule();
}
static int EDF_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == HARD_PCLASS || m->pclass == (HARD_PCLASS | l)) {
221,7 → 204,7
static void EDF_level_status(LEVEL l)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
PID p = lev->ready;
PID p = iq_query_first(&lev->ready);
kern_printf("Wcet Check : %s\n",
onoff(lev->flags & EDF_ENABLE_WCET_CHECK));
239,10 → 222,10
proc_table[p].name,
lev->flag[p] & EDF_FLAG_SPORADIC ? "MinITime" : "Period ",
lev->period[p],
proc_table[p].timespec_priority.tv_sec,
proc_table[p].timespec_priority.tv_nsec/1000,
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 = proc_table[p].next;
p = iq_query_next(p, &lev->ready);
}
for (p=0; p<MAX_PROC; p++)
253,8 → 236,8
proc_table[p].name,
lev->flag[p] & EDF_FLAG_SPORADIC ? "MinITime" : "Period ",
lev->period[p],
proc_table[p].timespec_priority.tv_sec,
proc_table[p].timespec_priority.tv_nsec/1000,
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));
}
273,7 → 256,7
kern_printf(") ");
}
*/
return (PID)lev->ready;
return iq_query_first(&lev->ready);
}
/* The on-line guarantee is enabled only if the appropriate flag is set... */
365,14 → 348,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void EDF_task_dispatch(LEVEL l, PID p, int nostop)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
382,17 → 357,7
/* the task state is set EXE by the scheduler()
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
q_extract(p, &lev->ready);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds], &schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
iq_extract(p, &lev->ready);
}
static void EDF_task_epilogue(LEVEL l, PID p)
409,7 → 374,7
}
else {
/* the task has been preempted. it returns into the ready queue... */
q_timespec_insert(p,&lev->ready);
iq_timespec_insert(p,&lev->ready);
proc_table[p].status = EDF_READY;
}
}
417,6 → 382,7
static void EDF_task_activate(LEVEL l, PID p)
{
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
struct timespec *temp;
if (proc_table[p].status == EDF_WAIT) {
kern_raise(XACTIVATION,p);
433,19 → 399,19
/* see also EDF_timer_deadline */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
TIMESPEC_ASSIGN(&proc_table[p].timespec_priority,
&proc_table[p].request_time);
ADDUSEC2TIMESPEC(lev->period[p], &proc_table[p].timespec_priority);
temp = iq_query_timespec(p, &lev->ready);
TIMESPEC_ASSIGN(temp, &proc_table[p].request_time);
ADDUSEC2TIMESPEC(lev->period[p], temp);
/* Insert task in the correct position */
proc_table[p].status = EDF_READY;
q_timespec_insert(p,&lev->ready);
iq_timespec_insert(p,&lev->ready);
/* Set the deadline timer */
lev->deadline_timer[p] = kern_event_post(&proc_table[p].timespec_priority,
lev->deadline_timer[p] = kern_event_post(temp,
EDF_timer_deadline,
(void *)p);
edf_printf("(dline p%d ev%d %d.%d)",p,(int)lev->deadline_timer[p],(int)proc_table[p].timespec_priority.tv_sec,(int)proc_table[p].timespec_priority.tv_nsec/1000);
edf_printf("(dline p%d ev%d %d.%d)",p,(int)lev->deadline_timer[p],(int)temp->tv_sec,(int)temp->tv_nsec/1000);
}
static void EDF_task_insert(LEVEL l, PID p)
457,7 → 423,7
/* Insert task in the coEDFect position */
proc_table[p].status = EDF_READY;
q_timespec_insert(p,&lev->ready);
iq_timespec_insert(p,&lev->ready);
}
static void EDF_task_extract(LEVEL l, PID p)
518,22 → 484,7
correctly the task state to sleep... */
}
static void EDF_task_delay(LEVEL l, PID p, TIME usdelay)
{
struct timespec wakeuptime;
// EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
/* equal to EDF_task_endcycle */
proc_table[p].status = EDF_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT, &wakeuptime);
ADDUSEC2TIMESPEC(usdelay, &wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
EDF_timer_delay,
(void *)p);
}
/* Guest Functions
These functions manages a JOB_TASK_MODEL, that is used to put
a guest task in the EDF ready queue. */
546,7 → 497,7
/* if the EDF_guest_create is called, then the pclass must be a
valid pclass. */
TIMESPEC_ASSIGN(&proc_table[p].timespec_priority, &job->deadline);
*iq_query_timespec(p, &lev->ready) = job->deadline;
lev->deadline_timer[p] = -1;
577,7 → 528,7
/* the task state is set to EXE by the scheduler()
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
q_extract(p, &lev->ready);
iq_extract(p, &lev->ready);
}
static void EDF_guest_epilogue(LEVEL l, PID p)
585,7 → 536,7
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
/* the task has been preempted. it returns into the ready queue... */
q_timespec_insert(p,&lev->ready);
iq_timespec_insert(p,&lev->ready);
proc_table[p].status = EDF_READY;
}
594,12 → 545,12
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
/* Insert task in the correct position */
q_timespec_insert(p,&lev->ready);
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(&proc_table[p].timespec_priority,
lev->deadline_timer[p] = kern_event_post(iq_query_timespec(p, &lev->ready),
EDF_timer_guest_deadline,
(void *)p);
610,7 → 561,7
EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
/* Insert task in the correct position */
q_timespec_insert(p,&lev->ready);
iq_timespec_insert(p,&lev->ready);
proc_table[p].status = EDF_READY;
}
626,7 → 577,7
}
static void EDF_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void EDF_guest_end(LEVEL l, PID p)
{
635,13 → 586,9
//kern_printf("EDF_guest_end: dline timer %d\n",lev->deadline_timer[p]);
if (proc_table[p].status == EDF_READY)
{
q_extract(p, &lev->ready);
iq_extract(p, &lev->ready);
//kern_printf("(g_end rdy extr)");
}
else if (proc_table[p].status == EDF_DELAY) {
event_delete(proc_table[p].delay_timer);
proc_table[p].delay_timer = NIL; /* paranoia */
}
/* we remove the deadline timer, because the slice is finished */
if (lev->deadline_timer[p] != NIL) {
653,27 → 600,10
}
static void EDF_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void EDF_guest_delay(LEVEL l, PID p, TIME usdelay)
{
struct timespec wakeuptime;
// EDF_level_des *lev = (EDF_level_des *)(level_table[l]);
/* equal to EDF_task_endcycle */
proc_table[p].status = EDF_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT, &wakeuptime);
ADDUSEC2TIMESPEC(usdelay, &wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
EDF_timer_delay,
(void *)p);
}
/* Registration functions */
/*+ Registration function:
725,7 → 655,6
lev->l.task_endcycle = EDF_task_endcycle;
lev->l.task_end = EDF_task_end;
lev->l.task_sleep = EDF_task_sleep;
lev->l.task_delay = EDF_task_delay;
lev->l.guest_create = EDF_guest_create;
lev->l.guest_detach = EDF_guest_detach;
737,7 → 666,6
lev->l.guest_endcycle = EDF_guest_endcycle;
lev->l.guest_end = EDF_guest_end;
lev->l.guest_sleep = EDF_guest_sleep;
lev->l.guest_delay = EDF_guest_delay;
/* fill the EDF descriptor part */
for(i=0; i<MAX_PROC; i++) {
746,7 → 674,7
lev->flag[i] = 0;
}
lev->ready = NIL;
iq_init(&lev->ready, &freedesc, 0);
lev->flags = flags & 0x07;
lev->U = 0;
}

/shark/tags/rel_0_2/kernel/modules/posix.c
20,11 → 20,11
/**
------------
CVS : $Id: posix.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: posix.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the scheduling module compatible with POSIX
66,7 → 66,6
/*+ Status used in the level +*/
#define POSIX_READY MODULE_STATUS_BASE
#define POSIX_DELAY MODULE_STATUS_BASE+1
/*+ the level redefinition for the Round Robin level +*/
typedef struct {
73,8 → 72,10
level_des l; /*+ the standard level descriptor +*/
int nact[MAX_PROC]; /*+ number of pending activations +*/
int priority[MAX_PROC]; /*+ priority of each task +*/
QQUEUE *ready; /*+ the ready queue array +*/
IQUEUE *ready; /*+ the ready queue array +*/
int slice; /*+ the level's time slice +*/
94,30 → 95,10
switch (status) {
case POSIX_READY: return "POSIX_Ready";
case POSIX_DELAY: return "POSIX_Delay";
default : return "POSIX_Unknown";
}
}
/*+ this function is called when a task finish his delay +*/
static void POSIX_timer_delay(void *par)
{
PID p = (PID) par;
POSIX_level_des *lev;
lev = (POSIX_level_des *)level_table[proc_table[p].task_level];
proc_table[p].status = POSIX_READY;
qq_insertlast(p,&lev->ready[proc_table[p].priority]);
proc_table[p].delay_timer = NIL; /* Paranoia */
// kern_printf(" DELAY TIMER %d ", p);
event_need_reschedule();
}
static int POSIX_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == NRT_PCLASS || m->pclass == (NRT_PCLASS | l))
141,9 → 122,9
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: %3ld Status: %s\n",
kern_printf("Pid: %d\t Name: %20s Prio: %3d Status: %s\n",
p,proc_table[p].name,
proc_table[p].priority,
lev->priority[p],
POSIX_status_to_a(proc_table[p].status));
}
164,7 → 145,7
prio = lev->maxpriority;
for (;;) {
p = qq_queryfirst(&lev->ready[prio]);
p = iq_query_first(&lev->ready[prio]);
if (p == NIL) {
if (prio) {
prio--;
177,8 → 158,8
if ((proc_table[p].control & CONTROL_CAP) &&
(proc_table[p].avail_time <= 0)) {
proc_table[p].avail_time += proc_table[p].wcet;
qq_extract(p,&lev->ready[prio]);
qq_insertlast(p,&lev->ready[prio]);
iq_extract(p,&lev->ready[prio]);
iq_insertlast(p,&lev->ready[prio]);
}
else
return p;
208,7 → 189,7
proc_table[exec_shadow].task_level == l) {
/* We inherit the scheduling properties if the scheduling level
*is* the same */
proc_table[p].priority = proc_table[exec_shadow].priority;
lev->priority[p] = lev->priority[exec_shadow];
proc_table[p].avail_time = proc_table[exec_shadow].avail_time;
proc_table[p].wcet = proc_table[exec_shadow].wcet;
219,7 → 200,7
lev->nact[p] = (lev->nact[exec_shadow] == -1) ? -1 : 0;
}
else {
proc_table[p].priority = nrt->weight;
lev->priority[p] = nrt->weight;
if (nrt->slice) {
proc_table[p].avail_time = nrt->slice;
254,14 → 235,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void POSIX_task_dispatch(LEVEL l, PID p, int nostop)
{
POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
269,18 → 242,7
/* the task state is set EXE by the scheduler()
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
qq_extract(p, &lev->ready[proc_table[p].priority]);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds],&schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
iq_extract(p, &lev->ready[lev->priority[p]]);
}
static void POSIX_task_epilogue(LEVEL l, PID p)
289,7 → 251,7
if (lev->yielding) {
lev->yielding = 0;
qq_insertlast(p,&lev->ready[proc_table[p].priority]);
iq_insertlast(p,&lev->ready[lev->priority[p]]);
}
/* check if the slice is finished and insert the task in the coPOSIXect
qqueue position */
296,10 → 258,10
else if (proc_table[p].control & CONTROL_CAP &&
proc_table[p].avail_time <= 0) {
proc_table[p].avail_time += proc_table[p].wcet;
qq_insertlast(p,&lev->ready[proc_table[p].priority]);
iq_insertlast(p,&lev->ready[lev->priority[p]]);
}
else
qq_insertfirst(p,&lev->ready[proc_table[p].priority]);
iq_insertfirst(p,&lev->ready[lev->priority[p]]);
proc_table[p].status = POSIX_READY;
}
320,7 → 282,7
/* Insert task in the correct position */
proc_table[p].status = POSIX_READY;
qq_insertlast(p,&lev->ready[proc_table[p].priority]);
iq_insertlast(p,&lev->ready[lev->priority[p]]);
}
static void POSIX_task_insert(LEVEL l, PID p)
332,7 → 294,7
/* Insert task in the coPOSIXect position */
proc_table[p].status = POSIX_READY;
qq_insertlast(p,&lev->ready[proc_table[p].priority]);
iq_insertlast(p,&lev->ready[lev->priority[p]]);
}
static void POSIX_task_extract(LEVEL l, PID p)
355,7 → 317,7
/* continue!!!! */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
lev->nact[p]--;
qq_insertfirst(p,&lev->ready[proc_table[p].priority]);
iq_insertfirst(p,&lev->ready[lev->priority[p]]);
proc_table[p].status = POSIX_READY;
}
else
370,7 → 332,7
/* then, we insert the task in the free queue */
proc_table[p].status = FREE;
q_insert(p,&freedesc);
iq_priority_insert(p,&freedesc);
}
static void POSIX_task_sleep(LEVEL l, PID p)
380,59 → 342,39
proc_table[p].status = SLEEP;
}
static void POSIX_task_delay(LEVEL l, PID p, TIME usdelay)
{
// POSIX_level_des *lev = (POSIX_level_des *)(level_table[l]);
struct timespec wakeuptime;
/* equal to POSIX_task_endcycle */
proc_table[p].status = POSIX_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT,&wakeuptime);
ADDUSEC2TIMESPEC(usdelay,&wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
POSIX_timer_delay,
(void *)p);
}
static int POSIX_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void POSIX_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void POSIX_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/* Registration functions */
/*+ This init function install the "main" task +*/
518,7 → 460,6
lev->l.task_endcycle = POSIX_task_endcycle;
lev->l.task_end = POSIX_task_end;
lev->l.task_sleep = POSIX_task_sleep;
lev->l.task_delay = POSIX_task_delay;
lev->l.guest_create = POSIX_guest_create;
lev->l.guest_detach = POSIX_guest_detach;
530,7 → 471,6
lev->l.guest_endcycle = POSIX_guest_endcycle;
lev->l.guest_end = POSIX_guest_end;
lev->l.guest_sleep = POSIX_guest_sleep;
lev->l.guest_delay = POSIX_guest_delay;
/* fill the POSIX descriptor part */
for (i = 0; i < MAX_PROC; i++)
538,10 → 478,10
lev->maxpriority = prioritylevels -1;
lev->ready = (QQUEUE *)kern_alloc(sizeof(QQUEUE) * prioritylevels);
lev->ready = (IQUEUE *)kern_alloc(sizeof(IQUEUE) * prioritylevels);
for (x = 0; x < prioritylevels; x++)
qq_init(&lev->ready[x]);
iq_init(&lev->ready[x], &freedesc, 0);
if (slice < POSIX_MINIMUM_SLICE) slice = POSIX_MINIMUM_SLICE;
if (slice > POSIX_MAXIMUM_SLICE) slice = POSIX_MAXIMUM_SLICE;
614,7 → 554,7
else
*policy = NRT_FIFO_POLICY;
*priority = proc_table[p].priority;
*priority = ((POSIX_level_des *)(level_table[l]))->priority[p];
return 0;
}
644,14 → 584,14
else
return EINVAL;
if (proc_table[p].priority != priority) {
if (lev->priority[p] != priority) {
if (proc_table[p].status == POSIX_READY) {
qq_extract(p,&lev->ready[proc_table[p].priority]);
proc_table[p].priority = priority;
qq_insertlast(p,&lev->ready[priority]);
iq_extract(p,&lev->ready[lev->priority[p]]);
lev->priority[p] = priority;
iq_insertlast(p,&lev->ready[priority]);
}
else
proc_table[p].priority = priority;
lev->priority[p] = priority;
}
return 0;

/shark/tags/rel_0_2/kernel/modules/hartport.c
20,11 → 20,11
/**
------------
CVS : $Id: hartport.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: hartport.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the Hartik 3.3.1 Port functions
110,8 → 110,8
struct hash_port htable[MAX_HASH_ENTRY];
struct port_ker port_des[MAX_PORT];
struct port_com port_int[MAX_PORT_INT];
QUEUE freeportdes;
QUEUE freeportint;
int freeportdes;
int freeportint;
static int port_installed = 0;
548,7 → 548,7
return -1;
}
if (!pd->valid) {
errno = EPORT_UNVALID_DESCR;
errno = EPORT_INVALID_DESCR;
return -1;
}
596,7 → 596,7
return -1;
}
if (!pd->valid) {
errno = EPORT_UNVALID_DESCR;
errno = EPORT_INVALID_DESCR;
return -1;
}
#endif

/shark/tags/rel_0_2/kernel/modules/rr2.c
20,11 → 20,11
/**
------------
CVS : $Id: rr2.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: rr2.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the scheduling module RR2 (Round Robin) version 2
63,7 → 63,6
/*+ Status used in the level +*/
#define RR2_READY MODULE_STATUS_BASE
#define RR2_DELAY MODULE_STATUS_BASE+1
/*+ the level redefinition for the Round Robin level +*/
typedef struct {
71,7 → 70,7
int nact[MAX_PROC]; /*+ number of pending activations +*/
QQUEUE ready; /*+ the ready queue +*/
IQUEUE ready; /*+ the ready queue +*/
int slice; /*+ the level's time slice +*/
87,30 → 86,10
switch (status) {
case RR2_READY: return "RR2_Ready";
case RR2_DELAY: return "RR2_Delay";
default : return "RR2_Unknown";
}
}
/*+ this function is called when a task finish his delay +*/
static void RR2_timer_delay(void *par)
{
PID p = (PID) par;
RR2_level_des *lev;
lev = (RR2_level_des *)level_table[proc_table[p].task_level];
proc_table[p].status = RR2_READY;
qq_insertlast(p,&lev->ready);
proc_table[p].delay_timer = NIL; /* Paranoia */
// kern_printf(" DELAY TIMER %d ", p);
event_need_reschedule();
}
static int RR2_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == NRT_PCLASS || m->pclass == (NRT_PCLASS | l))
127,7 → 106,7
static void RR2_level_status(LEVEL l)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
PID p = qq_queryfirst(&lev->ready);
PID p = iq_query_first(&lev->ready);
kern_printf("Slice: %d \n", lev->slice);
134,7 → 113,7
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 = proc_table[p].next;
p = iq_query_next(p, &lev->ready);
}
for (p=0; p<MAX_PROC; p++)
157,14 → 136,14
PID p;
for (;;) {
p = qq_queryfirst(&lev->ready);
p = iq_query_first(&lev->ready);
if (p == -1)
return p;
if (proc_table[p].avail_time <= 0) {
proc_table[p].avail_time += proc_table[p].wcet;
qq_extract(p,&lev->ready);
qq_insertlast(p,&lev->ready);
iq_extract(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
else
return p;
222,14 → 201,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void RR2_task_dispatch(LEVEL l, PID p, int nostop)
{
RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
237,18 → 208,7
/* the task state is set EXE by the scheduler()
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
qq_extract(p, &lev->ready);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds],&schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
iq_extract(p, &lev->ready);
}
static void RR2_task_epilogue(LEVEL l, PID p)
259,11 → 219,11
qqueue position */
if (proc_table[p].avail_time <= 0) {
proc_table[p].avail_time += proc_table[p].wcet;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
else
/* cuRR2 is >0, so the running task have to run for another cuRR2 usec */
qq_insertfirst(p,&lev->ready);
iq_insertfirst(p,&lev->ready);
proc_table[p].status = RR2_READY;
}
284,7 → 244,7
/* Insert task in the coRR2ect position */
proc_table[p].status = RR2_READY;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
static void RR2_task_insert(LEVEL l, PID p)
296,7 → 256,7
/* Insert task in the coRR2ect position */
proc_table[p].status = RR2_READY;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
static void RR2_task_extract(LEVEL l, PID p)
319,7 → 279,7
/* continue!!!! */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
lev->nact[p]--;
qq_insertfirst(p,&lev->ready);
iq_insertfirst(p,&lev->ready);
proc_table[p].status = RR2_READY;
}
else
334,7 → 294,7
/* then, we insert the task in the free queue */
proc_table[p].status = FREE;
q_insert(p,&freedesc);
iq_insertlast(p,&freedesc);
}
static void RR2_task_sleep(LEVEL l, PID p)
344,59 → 304,39
proc_table[p].status = SLEEP;
}
static void RR2_task_delay(LEVEL l, PID p, TIME usdelay)
{
// RR2_level_des *lev = (RR2_level_des *)(level_table[l]);
struct timespec wakeuptime;
/* equal to RR2_task_endcycle */
proc_table[p].status = RR2_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT,&wakeuptime);
ADDUSEC2TIMESPEC(usdelay,&wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
RR2_timer_delay,
(void *)p);
}
static int RR2_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void RR2_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR2_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/* Registration functions */
/*+ This init function install the "main" task +*/
475,7 → 415,6
lev->l.task_endcycle = RR2_task_endcycle;
lev->l.task_end = RR2_task_end;
lev->l.task_sleep = RR2_task_sleep;
lev->l.task_delay = RR2_task_delay;
lev->l.guest_create = RR2_guest_create;
lev->l.guest_detach = RR2_guest_detach;
487,13 → 426,12
lev->l.guest_endcycle = RR2_guest_endcycle;
lev->l.guest_end = RR2_guest_end;
lev->l.guest_sleep = RR2_guest_sleep;
lev->l.guest_delay = RR2_guest_delay;
/* fill the RR2 descriptor part */
for (i = 0; i < MAX_PROC; i++)
lev->nact[i] = -1;
qq_init(&lev->ready);
iq_init(&lev->ready, &freedesc, 0);
if (slice < RR2_MINIMUM_SLICE) slice = RR2_MINIMUM_SLICE;
if (slice > RR2_MAXIMUM_SLICE) slice = RR2_MAXIMUM_SLICE;

/shark/tags/rel_0_2/kernel/modules/ds.c
20,11 → 20,11
/**
------------
CVS : $Id: ds.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: ds.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the aperiodic server DS (Deferrable Server)
83,7 → 83,7
int Cs; /*+ server capacity +*/
int availCs; /*+ server avail time +*/
QQUEUE wait; /*+ the wait queue of the DS +*/
IQUEUE wait; /*+ the wait queue of the DS +*/
PID activated; /*+ the task inserted in another queue +*/
int flags; /*+ the init flags... +*/
128,8 → 128,8
was not any other task to be put in the ready queue
... we are now activating the next task */
if (lev->availCs > 0 && lev->activated == NIL) {
if (qq_queryfirst(&lev->wait) != NIL) {
lev->activated = qq_getfirst(&lev->wait);
if (iq_query_first(&lev->wait) != NIL) {
lev->activated = iq_getfirst(&lev->wait);
DS_activation(lev);
event_need_reschedule();
}
178,7 → 178,7
static void DS_level_status(LEVEL l)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
PID p = qq_queryfirst(&lev->wait);
PID p = iq_query_first(&lev->wait);
kern_printf("On-line guarantee : %s\n",
onoff(lev->flags & DS_ENABLE_GUARANTEE_EDF ||
190,8 → 190,8
kern_printf("Activated: Pid: %2d Name: %10s Dl: %ld.%ld Nact: %d Stat: %s\n",
lev->activated,
proc_table[lev->activated].name,
proc_table[lev->activated].timespec_priority.tv_sec,
proc_table[lev->activated].timespec_priority.tv_nsec,
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));
200,7 → 200,7
p,
proc_table[p].name,
DS_status_to_a(proc_table[p].status));
p = proc_table[p].next;
p = iq_query_next(p, &lev->wait);
}
}
221,7 → 221,7
if (lev->flags & DS_BACKGROUND_BLOCK)
return NIL;
else
return qq_queryfirst(&lev->wait);
return iq_query_first(&lev->wait);
}
/* The on-line guarantee is enabled only if the appropriate flag is set... */
275,14 → 275,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void DS_task_dispatch(LEVEL l, PID p, int nostop)
{
DS_level_des *lev = (DS_level_des *)(level_table[l]);
294,7 → 286,7
to exe before calling task_dispatch. we have to check
lev->activated != p instead */
if (lev->activated != p) {
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
//kern_printf("#%d#",p);
}
else {
311,16 → 303,6
}
// kern_printf("(disp %d %d)",ty.tv_sec, ty.tv_nsec);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds], &schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
}
static void DS_task_epilogue(LEVEL l, PID p)
356,7 → 338,7
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = DS_WAIT;
lev->activated = NIL;
}
367,7 → 349,7
level_table[ lev->scheduling_level ]->
guest_epilogue(lev->scheduling_level,p);
} else { //kern_printf("Û2");
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = DS_WAIT;
}
}
388,7 → 370,7
DS_activation(lev);
}
else {
qq_insertlast(p, &lev->wait);
iq_insertlast(p, &lev->wait);
proc_table[p].status = DS_WAIT;
}
}
408,7 → 390,7
/* when we reinsert the task into the system, the server capacity
is always 0 because nobody executes with the DS before... */
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = DS_WAIT;
}
445,18 → 427,18
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
else
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
if (lev->nact[p] > 0)
{
lev->nact[p]--;
qq_insertlast(p, &lev->wait);
iq_insertlast(p, &lev->wait);
proc_table[p].status = DS_WAIT;
}
else
proc_table[p].status = SLEEP;
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
DS_activation(lev);
}
481,9 → 463,9
guest_end(lev->scheduling_level,p);
proc_table[p].status = FREE;
q_insertfirst(p,&freedesc);
iq_insertfirst(p,&freedesc);
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
DS_activation(lev);
}
509,72 → 491,49
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
else
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
proc_table[p].status = SLEEP;
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
DS_activation(lev);
}
static void DS_task_delay(LEVEL l, PID p, TIME usdelay)
{
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;
}
/* I hope no delay when owning a mutex... */
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_delay(lev->scheduling_level,p,usdelay);
}
static int DS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void DS_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void DS_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/* Registration functions */
647,7 → 606,6
lev->l.task_endcycle = DS_task_endcycle;
lev->l.task_end = DS_task_end;
lev->l.task_sleep = DS_task_sleep;
lev->l.task_delay = DS_task_delay;
lev->l.guest_create = DS_guest_create;
lev->l.guest_detach = DS_guest_detach;
659,7 → 617,6
lev->l.guest_endcycle = DS_guest_endcycle;
lev->l.guest_end = DS_guest_end;
lev->l.guest_sleep = DS_guest_sleep;
lev->l.guest_delay = DS_guest_delay;
/* fill the DS descriptor part */
671,7 → 628,7
lev->period = per;
qq_init(&lev->wait);
iq_init(&lev->wait, &freedesc, 0);
lev->activated = NIL;
lev->U = (MAX_BANDWIDTH / per) * Cs;

/shark/tags/rel_0_2/kernel/modules/cbs.c
20,11 → 20,11
/**
------------
CVS : $Id: cbs.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: cbs.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the aperiodic server CBS (Total Bandwidth Server)
76,7 → 76,6
/*+ Status used in the level +*/
#define CBS_IDLE APER_STATUS_BASE /*+ waiting the activation +*/
#define CBS_ZOMBIE APER_STATUS_BASE+1 /*+ waiting the period end +*/
#define CBS_DELAY APER_STATUS_BASE+2 /*+ waiting the delay end +*/
/*+ task flags +*/
#define CBS_SAVE_ARRIVALS 1
188,7 → 187,6
switch (status) {
case CBS_IDLE : return "CBS_Idle";
case CBS_ZOMBIE : return "CBS_Zombie";
case CBS_DELAY : return "CBS_Delay";
default : return "CBS_Unknown";
}
}
253,20 → 251,6
}
/*+ this function is called when a task finish his delay +*/
static void CBS_timer_delay(void *par)
{
PID p = (PID) par;
CBS_level_des *lev;
lev = (CBS_level_des *)level_table[proc_table[p].task_level];
CBS_activation(lev,p,&proc_table[p].timespec_priority);
event_need_reschedule();
}
/*+ this function is called when a killed or ended task reach the
period end +*/
static void CBS_timer_zombie(void *par)
278,7 → 262,7
/* we finally put the task in the ready queue */
proc_table[p].status = FREE;
q_insertfirst(p,&freedesc);
iq_insertfirst(p,&freedesc);
/* and free the allocated bandwidth */
lev->U -= (MAX_BANDWIDTH/lev->period[p]) * proc_table[p].wcet;
451,29 → 435,11
return 0;
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void CBS_task_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);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds], &schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
}
static void CBS_task_epilogue(LEVEL l, PID p)
639,68 → 605,37
lev->nact[p] = 0;
}
static void CBS_task_delay(LEVEL l, PID p, TIME usdelay)
{
struct timespec wakeuptime;
CBS_level_des *lev = (CBS_level_des *)(level_table[l]);
/* check if the wcet is finished... */
CBS_avail_time_check(lev, p);
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
proc_table[p].status = CBS_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT, &wakeuptime);
ADDUSEC2TIMESPEC(usdelay, &wakeuptime);
/* the timespec_priority field is used to store the time at witch the delay
timer raises */
TIMESPEC_ASSIGN(&proc_table[p].timespec_priority, &wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
CBS_timer_delay,
(void *)p);
}
static int CBS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void CBS_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void CBS_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/* Registration functions */
/*+ Registration function:
752,7 → 687,6
lev->l.task_endcycle = CBS_task_endcycle;
lev->l.task_end = CBS_task_end;
lev->l.task_sleep = CBS_task_sleep;
lev->l.task_delay = CBS_task_delay;
lev->l.guest_create = CBS_guest_create;
lev->l.guest_detach = CBS_guest_detach;
764,7 → 698,6
lev->l.guest_endcycle = CBS_guest_endcycle;
lev->l.guest_end = CBS_guest_end;
lev->l.guest_sleep = CBS_guest_sleep;
lev->l.guest_delay = CBS_guest_delay;
/* fill the CBS descriptor part */
for (i=0; i<MAX_PROC; i++) {

/shark/tags/rel_0_2/kernel/modules/nopm.c
20,11 → 20,11
/**
------------
CVS : $Id: nopm.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: nopm.c,v 1.2 2002-11-11 08:32:06 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: 2002-11-11 08:32:06 $
------------
See modules/nopm.h.
73,7 → 73,7
mutex_t structure */
typedef struct {
PID owner;
QQUEUE blocked;
IQUEUE blocked;
int counter;
} NOPM_mutex_t;
108,12 → 108,12
kern_printf("----------------------\n");
for(i=0;i<index;i++) {
ptr=table[i]->opt;
if (ptr->blocked.first!=NIL) {
if (!iq_isempty(&ptr->blocked)) {
kern_printf("%i blocks on 0x%p: ",ptr->owner,table[i]);
j=ptr->blocked.first;
j=iq_query_first(&ptr->blocked);
while (j!=NIL) {
kern_printf("%i ",(int)j);
j=proc_table[j].next;
j=iq_query_next(j, &ptr->blocked);
}
kern_printf("\n");
} else {
181,7 → 181,7
return (ENOMEM);
p->owner = NIL;
qq_init(&p->blocked);
iq_init(&p->blocked, &freedesc, 0);
p->counter=0;
m->mutexlevel = l;
254,7 → 254,7
/* we insert the task in the semaphore queue */
proc_table[exec_shadow].status = NOPM_WAIT;
qq_insertlast(exec_shadow,&p->blocked);
iq_insertlast(exec_shadow,&p->blocked);
/* and finally we reschedule */
exec = exec_shadow = -1;
327,7 → 327,7
/* the mutex is mine, pop the firsttask to extract */
for (;;) {
e = qq_getfirst(&p->blocked);
e = iq_getfirst(&p->blocked);
if (e == NIL) {
p->owner = NIL;
break;

/shark/tags/rel_0_2/kernel/modules/rm.c
20,11 → 20,11
/**
------------
CVS : $Id: rm.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: rm.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the scheduling module RM (Rate Monotonic)
71,7 → 71,6
/*+ Status used in the level +*/
#define RM_READY MODULE_STATUS_BASE /*+ - Ready status +*/
#define RM_DELAY MODULE_STATUS_BASE+1 /*+ - Delay status +*/
#define RM_WCET_VIOLATED MODULE_STATUS_BASE+2 /*+ when wcet is finished +*/
#define RM_WAIT MODULE_STATUS_BASE+3 /*+ to wait the deadline +*/
#define RM_IDLE MODULE_STATUS_BASE+4 /*+ to wait the deadline +*/
94,7 → 93,7
/*+ used to manage the JOB_TASK_MODEL and the
periodicity +*/
QUEUE ready; /*+ the ready queue +*/
IQUEUE ready; /*+ the ready queue +*/
int flags; /*+ the init flags... +*/
110,7 → 109,6
switch (status) {
case RM_READY : return "RM_Ready";
case RM_DELAY : return "RM_Delay";
case RM_WCET_VIOLATED: return "RM_Wcet_Violated";
case RM_WAIT : return "RM_Sporadic_Wait";
case RM_IDLE : return "RM_Idle";
123,8 → 121,8
{
PID p = (PID) par;
RM_level_des *lev;
struct timespec *temp;
lev = (RM_level_des *)level_table[proc_table[p].task_level];
switch (proc_table[p].status) {
131,7 → 129,7
case RM_ZOMBIE:
/* we finally put the task in the ready queue */
proc_table[p].status = FREE;
q_insertfirst(p,&freedesc);
iq_insertfirst(p,&freedesc);
/* and free the allocated bandwidth */
lev->U -= (MAX_BANDWIDTH/lev->period[p]) * proc_table[p].wcet;
break;
140,12 → 138,12
/* tracer stuff */
trc_logevent(TRC_INTACTIVATION,&p);
/* similar to RM_task_activate */
TIMESPEC_ASSIGN(&proc_table[p].request_time,
&proc_table[p].timespec_priority);
ADDUSEC2TIMESPEC(lev->period[p], &proc_table[p].timespec_priority);
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;
q_insert(p,&lev->ready);
lev->deadline_timer[p] = kern_event_post(&proc_table[p].timespec_priority,
iq_priority_insert(p,&lev->ready);
lev->deadline_timer[p] = kern_event_post(temp,
RM_timer_deadline,
(void *)p);
//printk("(d%d idle priority set to %d)",p,proc_table[p].priority );
173,23 → 171,6
kern_raise(XDEADLINE_MISS,p);
}
/*+ this function is called when a task finish his delay +*/
static void RM_timer_delay(void *par)
{
PID p = (PID) par;
RM_level_des *lev;
lev = (RM_level_des *)level_table[proc_table[p].task_level];
proc_table[p].status = RM_READY;
q_insert(p,&lev->ready);
proc_table[p].delay_timer = NIL; /* Paranoia */
event_need_reschedule();
}
static int RM_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == HARD_PCLASS || m->pclass == (HARD_PCLASS | l)) {
222,7 → 203,7
static void RM_level_status(LEVEL l)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
PID p = lev->ready;
PID p = iq_query_first(&lev->ready);
kern_printf("Wcet Check : %s\n",
onoff(lev->flags & RM_ENABLE_WCET_CHECK));
240,10 → 221,10
proc_table[p].name,
lev->flag[p] & RM_FLAG_SPORADIC ? "MinITime" : "Period ",
lev->period[p],
proc_table[p].timespec_priority.tv_sec,
proc_table[p].timespec_priority.tv_nsec/1000,
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 = proc_table[p].next;
p = iq_query_next(p, &lev->ready);
}
for (p=0; p<MAX_PROC; p++)
254,8 → 235,8
proc_table[p].name,
lev->flag[p] & RM_FLAG_SPORADIC ? "MinITime" : "Period ",
lev->period[p],
proc_table[p].timespec_priority.tv_sec,
proc_table[p].timespec_priority.tv_nsec/1000,
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));
}
274,7 → 255,7
kern_printf(") ");
}
*/
return (PID)lev->ready;
return iq_query_first(&lev->ready);
}
/* The on-line guarantee is enabled only if the appropriate flag is set... */
305,7 → 286,7
HARD_TASK_MODEL *h = (HARD_TASK_MODEL *)m;
proc_table[p].priority = lev->period[p] = h->mit;
*iq_query_priority(p, &lev->ready) = lev->period[p] = h->mit;
if (h->periodicity == APERIODIC)
lev->flag[p] = RM_FLAG_SPORADIC;
366,14 → 347,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void RM_task_dispatch(LEVEL l, PID p, int nostop)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
383,17 → 356,7
/* the task state is set EXE by the scheduler()
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
q_extract(p, &lev->ready);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds], &schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
iq_extract(p, &lev->ready);
}
static void RM_task_epilogue(LEVEL l, PID p)
410,7 → 373,7
}
else {
/* the task has been preempted. it returns into the ready queue... */
q_insert(p,&lev->ready);
iq_priority_insert(p,&lev->ready);
proc_table[p].status = RM_READY;
}
}
418,6 → 381,7
static void RM_task_activate(LEVEL l, PID p)
{
RM_level_des *lev = (RM_level_des *)(level_table[l]);
struct timespec *temp;
if (proc_table[p].status == RM_WAIT) {
kern_raise(XACTIVATION,p);
434,16 → 398,16
/* see also RM_timer_deadline */
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
TIMESPEC_ASSIGN(&proc_table[p].timespec_priority,
&proc_table[p].request_time);
ADDUSEC2TIMESPEC(lev->period[p], &proc_table[p].timespec_priority);
temp = iq_query_timespec(p, &lev->ready);
TIMESPEC_ASSIGN(temp, &proc_table[p].request_time);
ADDUSEC2TIMESPEC(lev->period[p], temp);
/* Insert task in the correct position */
proc_table[p].status = RM_READY;
q_insert(p,&lev->ready);
iq_priority_insert(p,&lev->ready);
/* Set the deadline timer */
lev->deadline_timer[p] = kern_event_post(&proc_table[p].timespec_priority,
lev->deadline_timer[p] = kern_event_post(temp,
RM_timer_deadline,
(void *)p);
}
457,7 → 421,7
/* Insert task in the correct position */
proc_table[p].status = RM_READY;
q_insert(p,&lev->ready);
iq_priority_insert(p,&lev->ready);
}
static void RM_task_extract(LEVEL l, PID p)
516,22 → 480,7
correctly the task state to sleep... */
}
static void RM_task_delay(LEVEL l, PID p, TIME usdelay)
{
struct timespec wakeuptime;
// RM_level_des *lev = (RM_level_des *)(level_table[l]);
/* equal to RM_task_endcycle */
proc_table[p].status = RM_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT, &wakeuptime);
ADDUSEC2TIMESPEC(usdelay, &wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
RM_timer_delay,
(void *)p);
}
/* Guest Functions
These functions manages a JOB_TASK_MODEL, that is used to put
a guest task in the RM ready queue. */
544,9 → 493,9
/* if the RM_guest_create is called, then the pclass must be a
valid pclass. */
*iq_query_timespec(p,&lev->ready) = job->deadline;
TIMESPEC_ASSIGN(&proc_table[p].timespec_priority, &job->deadline);
lev->deadline_timer[p] = -1;
if (job->noraiseexc)
554,7 → 503,7
else
lev->flag[p] = 0;
proc_table[p].priority = lev->period[p] = job->period;
*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... */
576,7 → 525,7
/* the task state is set to EXE by the scheduler()
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
q_extract(p, &lev->ready);
iq_extract(p, &lev->ready);
}
static void RM_guest_epilogue(LEVEL l, PID p)
584,7 → 533,7
RM_level_des *lev = (RM_level_des *)(level_table[l]);
/* the task has been preempted. it returns into the ready queue... */
q_insert(p,&lev->ready);
iq_priority_insert(p,&lev->ready);
proc_table[p].status = RM_READY;
}
593,15 → 542,14
RM_level_des *lev = (RM_level_des *)(level_table[l]);
/* Insert task in the correct position */
q_insert(p,&lev->ready);
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(&proc_table[p].timespec_priority,
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)
609,7 → 557,7
RM_level_des *lev = (RM_level_des *)(level_table[l]);
/* Insert task in the correct position */
q_insert(p,&lev->ready);
iq_priority_insert(p,&lev->ready);
proc_table[p].status = RM_READY;
}
625,7 → 573,7
}
static void RM_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RM_guest_end(LEVEL l, PID p)
{
634,13 → 582,9
//kern_printf("RM_guest_end: dline timer %d\n",lev->deadline_timer[p]);
if (proc_table[p].status == RM_READY)
{
q_extract(p, &lev->ready);
iq_extract(p, &lev->ready);
//kern_printf("(g_end rdy extr)");
}
else if (proc_table[p].status == RM_DELAY) {
event_delete(proc_table[p].delay_timer);
proc_table[p].delay_timer = NIL; /* paranoia */
}
/* we remove the deadline timer, because the slice is finished */
if (lev->deadline_timer[p] != NIL) {
652,27 → 596,11
}
static void RM_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RM_guest_delay(LEVEL l, PID p, TIME usdelay)
{
struct timespec wakeuptime;
// RM_level_des *lev = (RM_level_des *)(level_table[l]);
/* equal to RM_task_endcycle */
proc_table[p].status = RM_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT, &wakeuptime);
ADDUSEC2TIMESPEC(usdelay, &wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
RM_timer_delay,
(void *)p);
}
/* Registration functions */
/*+ Registration function:
722,7 → 650,6
lev->l.task_endcycle = RM_task_endcycle;
lev->l.task_end = RM_task_end;
lev->l.task_sleep = RM_task_sleep;
lev->l.task_delay = RM_task_delay;
lev->l.guest_create = RM_guest_create;
lev->l.guest_detach = RM_guest_detach;
734,7 → 661,6
lev->l.guest_endcycle = RM_guest_endcycle;
lev->l.guest_end = RM_guest_end;
lev->l.guest_sleep = RM_guest_sleep;
lev->l.guest_delay = RM_guest_delay;
/* fill the RM descriptor part */
for(i=0; i<MAX_PROC; i++) {
743,7 → 669,7
lev->flag[i] = 0;
}
lev->ready = NIL;
iq_init(&lev->ready, &freedesc, 0);
lev->flags = flags & 0x07;
lev->U = 0;
}

/shark/tags/rel_0_2/kernel/modules/rrsoft.c
20,11 → 20,11
/**
------------
CVS : $Id: rrsoft.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: rrsoft.c,v 1.3 2002-11-11 08:32:07 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:07 $
------------
This file contains the scheduling module RRSOFT (Round Robin)
63,7 → 63,6
/*+ Status used in the level +*/
#define RRSOFT_READY MODULE_STATUS_BASE
#define RRSOFT_DELAY MODULE_STATUS_BASE+1
#define RRSOFT_IDLE MODULE_STATUS_BASE+2
/*+ the level redefinition for the Round Robin level +*/
72,7 → 71,7
int nact[MAX_PROC]; /*+ number of pending activations +*/
QQUEUE ready; /*+ the ready queue +*/
IQUEUE ready; /*+ the ready queue +*/
int slice; /*+ the level's time slice +*/
100,7 → 99,6
switch (status) {
case RRSOFT_READY: return "RRSOFT_Ready";
case RRSOFT_DELAY: return "RRSOFT_Delay";
case RRSOFT_IDLE : return "RRSOFT_Idle";
default : return "RRSOFT_Unknown";
}
121,7 → 119,7
/* the task has finished the current activation and must be
reactivated */
proc_table[p].status = RRSOFT_READY;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
event_need_reschedule();
}
140,25 → 138,6
}
/*+ this function is called when a task finish his delay +*/
static void RRSOFT_timer_delay(void *par)
{
PID p = (PID) par;
RRSOFT_level_des *lev;
lev = (RRSOFT_level_des *)level_table[proc_table[p].task_level];
proc_table[p].status = RRSOFT_READY;
qq_insertlast(p,&lev->ready);
proc_table[p].delay_timer = NIL; /* Paranoia */
// kern_printf(" DELAY TIMER %d ", p);
event_need_reschedule();
}
static int RRSOFT_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
181,7 → 160,7
static void RRSOFT_level_status(LEVEL l)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
PID p = qq_queryfirst(&lev->ready);
PID p = iq_query_first(&lev->ready);
kern_printf("Slice: %d \n", lev->slice);
188,7 → 167,7
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 = proc_table[p].next;
p = iq_query_next(p, &lev->ready);
}
for (p=0; p<MAX_PROC; p++)
211,7 → 190,7
PID p;
for (;;) {
p = qq_queryfirst(&lev->ready);
p = iq_query_first(&lev->ready);
if (p == -1)
return p;
//{kern_printf("(s%d)",p); return p;}
219,8 → 198,8
// kern_printf("(p=%d l=%d avail=%d wcet =%d)\n",p,l,proc_table[p].avail_time, proc_table[p].wcet);
if (proc_table[p].avail_time <= 0) {
proc_table[p].avail_time += proc_table[p].wcet;
qq_extract(p,&lev->ready);
qq_insertlast(p,&lev->ready);
iq_extract(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
else
//{kern_printf("(s%d)",p); return p;}
322,14 → 301,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void RRSOFT_task_dispatch(LEVEL l, PID p, int nostop)
{
RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
338,18 → 309,7
/* the task state is set EXE by the scheduler()
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
qq_extract(p, &lev->ready);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds],&schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
iq_extract(p, &lev->ready);
}
static void RRSOFT_task_epilogue(LEVEL l, PID p)
360,11 → 320,11
qqueue position */
if (proc_table[p].avail_time <= 0) {
proc_table[p].avail_time += proc_table[p].wcet;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
else
/* curr is >0, so the running task have to run for another cuRRSOFT usec */
qq_insertfirst(p,&lev->ready);
iq_insertfirst(p,&lev->ready);
proc_table[p].status = RRSOFT_READY;
}
385,7 → 345,7
/* Insert task in the coRRSOFTect position */
proc_table[p].status = RRSOFT_READY;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
/* Set the reactivation timer */
if (lev->periodic[p])
408,7 → 368,7
/* Insert task in the coRRSOFTect position */
proc_table[p].status = RRSOFT_READY;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
static void RRSOFT_task_extract(LEVEL l, PID p)
432,7 → 392,7
ll_gettime(TIME_EXACT, &proc_table[p].request_time);
lev->nact[p]--;
// qq_insertlast(p,&lev->ready);
qq_insertfirst(p,&lev->ready);
iq_insertfirst(p,&lev->ready);
proc_table[p].status = RRSOFT_READY;
}
else
453,7 → 413,7
/* then, we insert the task in the free queue */
proc_table[p].status = FREE;
q_insert(p,&freedesc);
iq_insertlast(p,&freedesc);
}
static void RRSOFT_task_sleep(LEVEL l, PID p)
471,59 → 431,38
proc_table[p].status = SLEEP;
}
static void RRSOFT_task_delay(LEVEL l, PID p, TIME usdelay)
{
// RRSOFT_level_des *lev = (RRSOFT_level_des *)(level_table[l]);
struct timespec wakeuptime;
/* equal to RRSOFT_task_endcycle */
proc_table[p].status = RRSOFT_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT,&wakeuptime);
ADDUSEC2TIMESPEC(usdelay,&wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
RRSOFT_timer_delay,
(void *)p);
}
static int RRSOFT_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void RRSOFT_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RRSOFT_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/* Registration functions */
/*+ This init function install the "main" task +*/
603,7 → 542,6
lev->l.task_endcycle = RRSOFT_task_endcycle;
lev->l.task_end = RRSOFT_task_end;
lev->l.task_sleep = RRSOFT_task_sleep;
lev->l.task_delay = RRSOFT_task_delay;
lev->l.guest_create = RRSOFT_guest_create;
lev->l.guest_detach = RRSOFT_guest_detach;
615,7 → 553,6
lev->l.guest_endcycle = RRSOFT_guest_endcycle;
lev->l.guest_end = RRSOFT_guest_end;
lev->l.guest_sleep = RRSOFT_guest_sleep;
lev->l.guest_delay = RRSOFT_guest_delay;
/* fill the RRSOFT descriptor part */
for (i = 0; i < MAX_PROC; i++) {
626,7 → 563,7
lev->period[i] = 0;
}
qq_init(&lev->ready);
iq_init(&lev->ready, &freedesc, 0);
if (slice < RRSOFT_MINIMUM_SLICE) slice = RRSOFT_MINIMUM_SLICE;
if (slice > RRSOFT_MAXIMUM_SLICE) slice = RRSOFT_MAXIMUM_SLICE;

/shark/tags/rel_0_2/kernel/modules/ps.c
20,11 → 20,11
/**
------------
CVS : $Id: ps.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: ps.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the aperiodic server PS (Polling Server)
122,7 → 122,7
int Cs; /*+ server capacity +*/
int availCs; /*+ server avail time +*/
QQUEUE wait; /*+ the wait queue of the PS +*/
IQUEUE wait; /*+ the wait queue of the PS +*/
PID activated; /*+ the task inserted in another queue +*/
int flags; /*+ the init flags... +*/
167,8 → 167,8
was not any other task to be put in the ready queue
... we are now activating the next task */
if (lev->availCs > 0 && lev->activated == NIL) {
if (qq_queryfirst(&lev->wait) != NIL) {
lev->activated = qq_getfirst(&lev->wait);
if (iq_query_first(&lev->wait) != NIL) {
lev->activated = iq_getfirst(&lev->wait);
PS_activation(lev);
event_need_reschedule();
}
219,7 → 219,7
static void PS_level_status(LEVEL l)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
PID p = qq_queryfirst(&lev->wait);
PID p = iq_query_first(&lev->wait);
kern_printf("On-line guarantee : %s\n",
onoff(lev->flags & PS_ENABLE_GUARANTEE_EDF ||
231,8 → 231,8
kern_printf("Activated: Pid: %2d Name: %10s Dl: %ld.%ld Nact: %d Stat: %s\n",
lev->activated,
proc_table[lev->activated].name,
proc_table[lev->activated].timespec_priority.tv_sec,
proc_table[lev->activated].timespec_priority.tv_nsec,
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));
241,7 → 241,7
p,
proc_table[p].name,
PS_status_to_a(proc_table[p].status));
p = proc_table[p].next;
p = iq_query_next(p, &lev->wait);
}
}
262,7 → 262,7
if (lev->flags & PS_BACKGROUND_BLOCK)
return NIL;
else
return qq_queryfirst(&lev->wait);
return iq_query_first(&lev->wait);
}
/* The on-line guarantee is enabled only if the appropriate flag is set... */
316,14 → 316,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void PS_task_dispatch(LEVEL l, PID p, int nostop)
{
PS_level_des *lev = (PS_level_des *)(level_table[l]);
335,7 → 327,7
to exe before calling task_dispatch. we have to check
lev->activated != p instead */
if (lev->activated != p) {
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
//kern_printf("#%d#",p);
}
else {
352,16 → 344,6
}
// kern_printf("(disp %d %d)",ty.tv_sec, ty.tv_nsec);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds], &schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
}
static void PS_task_epilogue(LEVEL l, PID p)
397,7 → 379,7
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = PS_WAIT;
lev->activated = NIL;
}
408,7 → 390,7
level_table[ lev->scheduling_level ]->
guest_epilogue(lev->scheduling_level,p);
} else { //kern_printf("Û2");
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = PS_WAIT;
}
}
429,7 → 411,7
PS_activation(lev);
}
else {
qq_insertlast(p, &lev->wait);
iq_insertlast(p, &lev->wait);
proc_table[p].status = PS_WAIT;
}
}
449,7 → 431,7
/* when we reinsert the task into the system, the server capacity
is always 0 because nobody executes with the PS before... */
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = PS_WAIT;
}
486,18 → 468,18
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
else
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
if (lev->nact[p] > 0)
{
lev->nact[p]--;
qq_insertlast(p, &lev->wait);
iq_insertlast(p, &lev->wait);
proc_table[p].status = PS_WAIT;
}
else
proc_table[p].status = SLEEP;
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated == NIL)
lev->availCs = 0; /* see note (*) at the begin of the file */
else
524,9 → 506,9
guest_end(lev->scheduling_level,p);
proc_table[p].status = FREE;
q_insertfirst(p,&freedesc);
iq_insertfirst(p,&freedesc);
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated == NIL)
lev->availCs = 0; /* see note (*) at the begin of the file */
else
554,74 → 536,51
level_table[ lev->scheduling_level ]->
guest_end(lev->scheduling_level,p);
else
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
proc_table[p].status = SLEEP;
lev->activated = qq_getfirst(&lev->wait);
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 void PS_task_delay(LEVEL l, PID p, TIME usdelay)
{
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;
}
/* I hope no delay when owning a mutex... */
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_delay(lev->scheduling_level,p,usdelay);
}
static int PS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void PS_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void PS_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/* Registration functions */
694,7 → 653,6
lev->l.task_endcycle = PS_task_endcycle;
lev->l.task_end = PS_task_end;
lev->l.task_sleep = PS_task_sleep;
lev->l.task_delay = PS_task_delay;
lev->l.guest_create = PS_guest_create;
lev->l.guest_detach = PS_guest_detach;
706,7 → 664,6
lev->l.guest_endcycle = PS_guest_endcycle;
lev->l.guest_end = PS_guest_end;
lev->l.guest_sleep = PS_guest_sleep;
lev->l.guest_delay = PS_guest_delay;
/* fill the PS descriptor part */
718,7 → 675,7
lev->period = per;
qq_init(&lev->wait);
iq_init(&lev->wait, &freedesc, 0);
lev->activated = NIL;
lev->U = (MAX_BANDWIDTH / per) * Cs;

/shark/tags/rel_0_2/kernel/modules/rr.c
20,11 → 20,11
/**
------------
CVS : $Id: rr.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: rr.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the scheduling module RR (Round Robin)
63,13 → 63,12
/*+ Status used in the level +*/
#define RR_READY MODULE_STATUS_BASE
#define RR_DELAY MODULE_STATUS_BASE+1
/*+ the level redefinition for the Round Robin level +*/
typedef struct {
level_des l; /*+ the standard level descriptor +*/
QQUEUE ready; /*+ the ready queue +*/
IQUEUE ready; /*+ the ready queue +*/
int slice; /*+ the level's time slice +*/
85,30 → 84,10
switch (status) {
case RR_READY: return "RR_Ready";
case RR_DELAY: return "RR_Delay";
default : return "RR_Unknown";
}
}
/*+ this function is called when a task finish his delay +*/
static void RR_timer_delay(void *par)
{
PID p = (PID) par;
RR_level_des *lev;
lev = (RR_level_des *)level_table[proc_table[p].task_level];
proc_table[p].status = RR_READY;
qq_insertlast(p,&lev->ready);
proc_table[p].delay_timer = NIL; /* Paranoia */
// kern_printf(" DELAY TIMER %d ", p);
event_need_reschedule();
}
static int RR_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
if (m->pclass == NRT_PCLASS || m->pclass == (NRT_PCLASS | l))
125,7 → 104,7
static void RR_level_status(LEVEL l)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
PID p = qq_queryfirst(&lev->ready);
PID p = iq_query_first(&lev->ready);
kern_printf("Slice: %d \n", lev->slice);
132,7 → 111,7
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 = proc_table[p].next;
p = iq_query_next(p,&lev->ready);
}
for (p=0; p<MAX_PROC; p++)
155,14 → 134,14
PID p;
for (;;) {
p = qq_queryfirst(&lev->ready);
p = iq_query_first(&lev->ready);
if (p == -1)
return p;
if (proc_table[p].avail_time <= 0) {
proc_table[p].avail_time += proc_table[p].wcet;
qq_extract(p,&lev->ready);
qq_insertlast(p,&lev->ready);
iq_extract(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
else
return p;
215,14 → 194,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void RR_task_dispatch(LEVEL l, PID p, int nostop)
{
RR_level_des *lev = (RR_level_des *)(level_table[l]);
230,20 → 201,7
/* the task state is set EXE by the scheduler()
we extract the task from the ready queue
NB: we can't assume that p is the first task in the queue!!! */
qq_extract(p, &lev->ready);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds],&schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
// if (nostop) kern_printf("Û");
// kern_printf("(RR d %d)",nostop);
iq_extract(p, &lev->ready);
}
static void RR_task_epilogue(LEVEL l, PID p)
254,11 → 212,11
qqueue position */
if (proc_table[p].avail_time <= 0) {
proc_table[p].avail_time += proc_table[p].wcet;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
else
/* curr is >0, so the running task have to run for another curr usec */
qq_insertfirst(p,&lev->ready);
iq_insertfirst(p,&lev->ready);
proc_table[p].status = RR_READY;
}
276,7 → 234,7
/* Insert task in the correct position */
proc_table[p].status = RR_READY;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
static void RR_task_insert(LEVEL l, PID p)
288,7 → 246,7
/* Insert task in the correct position */
proc_table[p].status = RR_READY;
qq_insertlast(p,&lev->ready);
iq_insertlast(p,&lev->ready);
}
static void RR_task_extract(LEVEL l, PID p)
318,7 → 276,7
/* we insert the task in the free queue */
proc_table[p].status = FREE;
q_insert(p,&freedesc);
iq_insertlast(p,&freedesc);
}
static void RR_task_sleep(LEVEL l, PID p)
326,59 → 284,39
proc_table[p].status = SLEEP;
}
static void RR_task_delay(LEVEL l, PID p, TIME usdelay)
{
// RR_level_des *lev = (RR_level_des *)(level_table[l]);
struct timespec wakeuptime;
/* equal to RR_task_endcycle */
proc_table[p].status = RR_DELAY;
/* we need to delete this event if we kill the task while it is sleeping */
ll_gettime(TIME_EXACT,&wakeuptime);
ADDUSEC2TIMESPEC(usdelay,&wakeuptime);
proc_table[p].delay_timer = kern_event_post(&wakeuptime,
RR_timer_delay,
(void *)p);
}
static int RR_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void RR_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void RR_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/* Registration functions */
/*+ This init function install the "main" task +*/
456,7 → 394,6
lev->l.task_endcycle = RR_task_endcycle;
lev->l.task_end = RR_task_end;
lev->l.task_sleep = RR_task_sleep;
lev->l.task_delay = RR_task_delay;
lev->l.guest_create = RR_guest_create;
lev->l.guest_detach = RR_guest_detach;
468,10 → 405,9
lev->l.guest_endcycle = RR_guest_endcycle;
lev->l.guest_end = RR_guest_end;
lev->l.guest_sleep = RR_guest_sleep;
lev->l.guest_delay = RR_guest_delay;
/* fill the RR descriptor part */
qq_init(&lev->ready);
iq_init(&lev->ready, &freedesc, 0);
if (slice < RR_MINIMUM_SLICE) slice = RR_MINIMUM_SLICE;
if (slice > RR_MAXIMUM_SLICE) slice = RR_MAXIMUM_SLICE;

/shark/tags/rel_0_2/kernel/modules/sem.c
20,11 → 20,11
/**
------------
CVS : $Id: sem.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: sem.c,v 1.2 2002-11-11 08:32:07 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: 2002-11-11 08:32:07 $
------------
This file contains the Hartik 3.3.1 Semaphore functions
79,7 → 79,7
char *name; /* a name, for named semaphores */
int index; /* an index for sem_open, containing the sem number */
int count; /* the semaphore counter */
QQUEUE blocked; /* the blocked processes queue */
IQUEUE blocked; /* the blocked processes queue */
int next; /* the semaphore queue */
BYTE used; /* 1 if the semaphore is used */
} sem_table[SEM_NSEMS_MAX];
91,7 → 91,7
int sem; /* the semaphore on whitch the process is blocked */
} sp_table[MAX_PROC];
static QUEUE free_sem; /* Queue of free sem */
static int free_sem; /* Queue of free sem */
112,7 → 112,7
task_testcancel */
/* extract the process from the semaphore queue... */
qq_extract(i,&sem_table[ sp_table[i].sem ].blocked);
iq_extract(i,&sem_table[ sp_table[i].sem ].blocked);
l = proc_table[i].task_level;
level_table[l]->task_insert(l,i);
134,7 → 134,7
sem_table[i].name = NULL;
sem_table[i].index = i;
sem_table[i].count = 0;
qq_init(&sem_table[i].blocked);
iq_init(&sem_table[i].blocked, &freedesc, 0);
sem_table[i].next = i+1;
sem_table[i].used = 0;
}
160,7 → 160,7
free_sem = sem_table[*sem].next;
sem_table[*sem].name = NULL;
sem_table[*sem].count = value;
qq_init(&sem_table[*sem].blocked);
iq_init(&sem_table[*sem].blocked, &freedesc, 0);
sem_table[*sem].used = 1;
}
else {
254,7 → 254,7
sem_table[sem].name = kern_alloc(strlen((char *)name)+1);
strcpy(sem_table[sem].name, (char *)name);
sem_table[sem].count = j;
qq_init(&sem_table[sem].blocked);
iq_init(&sem_table[sem].blocked, &freedesc, 0);
sem_table[sem].used = 1;
kern_sti();
return &sem_table[sem].index;
378,7 → 378,7
sp_table[exec_shadow].sem = *s;
/* ...and put it in sem queue */
qq_insertlast(exec_shadow,&s1->blocked);
iq_insertlast(exec_shadow,&s1->blocked);
/* and finally we reschedule */
exec = exec_shadow = -1;
504,7 → 504,7
sp_table[exec_shadow].sem = *s;
/* ...and put it in sem queue */
qq_insertlast(exec_shadow,&s1->blocked);
iq_insertlast(exec_shadow,&s1->blocked);
/* and finally we reschedule */
exec = exec_shadow = -1;
554,7 → 554,7
s1->count -= sp_table[p].decsem;
/* Get task from blocked queue */
qq_extract(p,&s1->blocked);
iq_extract(p,&s1->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
579,7 → 579,7
s1->count -= sp_table[p].decsem;
/* Get task from blocked queue */
qq_extract(p,&s1->blocked);
iq_extract(p,&s1->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
627,7 → 627,7
s1->count -= sp_table[p].decsem;
/* Get task from blocked queue */
qq_extract(p,&s1->blocked);
iq_extract(p,&s1->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
657,7 → 657,7
s1->count -= sp_table[p].decsem;
/* Get task from blocked queue */
qq_extract(p,&s1->blocked);
iq_extract(p,&s1->blocked);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
695,16 → 695,16
kern_cli();
if (sem_table[*sem].blocked.first == NIL)
if (iq_isempty(&sem_table[*sem].blocked))
/* the sem is free */
*sval = sem_table[*sem].count;
else {
/* the sem is busy */
*sval = 0;
p = sem_table[*sem].blocked.first;
p = iq_query_first(&sem_table[*sem].blocked);
do {
(*sval)--;
p = proc_table[p].next;
p = iq_query_next(p, &sem_table[*sem].blocked);
} while (p != NIL);
}

/shark/tags/rel_0_2/kernel/modules/ss.c
20,11 → 20,11
/**
------------
CVS : $Id: ss.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: ss.c,v 1.3 2002-11-11 08:32:07 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:07 $
------------
This file contains the aperiodic Sporadic Server (SS).
155,7 → 155,7
bandwidth_t U; /*+ the used bandwidth by the server +*/
QQUEUE wait; /*+ the wait queue of the SS +*/
IQUEUE wait; /*+ the wait queue of the SS +*/
PID activated; /*+ the task inserted in another queue +*/
int flags; /*+ the init flags... +*/
314,7 → 314,7
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);
kern_raise(XUNVALID_SS_REPLENISH,exec_shadow);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
exit(-1);
325,7 → 325,7
else {
kern_printf("SS not active when posting R.A.\n");
SS_level_status(l);
kern_raise(XUNVALID_SS_REPLENISH,exec_shadow);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
exit(-1);
401,7 → 401,7
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);
kern_raise(XUNVALID_SS_REPLENISH,exec_shadow);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
exit(-1);
457,7 → 457,7
/* replenish queue is empty */
kern_printf("Replenish Timer fires but no Replenish Amount defined\n");
SS_level_status(l);
kern_raise(XUNVALID_SS_REPLENISH,exec_shadow);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
exit(-1);
465,8 → 465,8
}
if (lev->availCs > 0 && lev->activated == NIL) {
if (qq_queryfirst(&lev->wait) != NIL) {
lev->activated = qq_getfirst(&lev->wait);
if (iq_query_first(&lev->wait) != NIL) {
lev->activated = iq_getfirst(&lev->wait);
/* if server is active, replenish time already set */
if (lev->server_active == SS_SERVER_NOTACTIVE) {
lev->server_active = SS_SERVER_ACTIVE;
536,7 → 536,7
void SS_level_status(LEVEL l)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
PID p = qq_queryfirst(&lev->wait);
PID p = iq_query_first(&lev->wait);
kern_printf("On-line guarantee : %s\n",
(lev->flags & SS_ENABLE_GUARANTEE_EDF ||
554,8 → 554,8
kern_printf("Activated: Pid: %d Name: %10s Dl: %ld.%ld Nact: %d Stat: %s\n",
lev->activated,
proc_table[lev->activated].name,
proc_table[lev->activated].timespec_priority.tv_sec,
proc_table[lev->activated].timespec_priority.tv_nsec,
iq_query_timespec(lev->activated,&lev->wait)->tv_sec,
iq_query_timespec(lev->activated,&lev->wait)->tv_nsec,
lev->nact[lev->activated],
SS_status_to_a(proc_table[lev->activated].status));
564,7 → 564,7
p,
proc_table[p].name,
SS_status_to_a(proc_table[p].status));
p = proc_table[p].next;
p = iq_query_next(p, &lev->wait);
}
}
593,7 → 593,7
if (lev->flags & SS_BACKGROUND_BLOCK)
return NIL;
else
return qq_queryfirst(&lev->wait);
return iq_query_first(&lev->wait);
}
/* The on-line guarantee is enabled only if the appropriate flag is set... */
696,7 → 696,7
to exe before calling task_dispatch.
We have to check lev->activated != p instead */
if (lev->activated != p) {
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
#ifdef DEBUG
kern_printf("extr task:%d ",p);
#endif
766,7 → 766,7
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);
kern_raise(XUNVALID_SS_REPLENISH,exec_shadow);
kern_raise(XINVALID_SS_REPLENISH,exec_shadow);
#ifdef DEBUG
sys_abort(-1);
exit(-1);
779,7 → 779,7
if (lev->activated == p)
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = SS_WAIT;
lev->activated = NIL;
}
793,7 → 793,7
guest_epilogue(lev->scheduling_level,p);
}
else { /* goes into wait queue */
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = SS_WAIT;
}
}
833,7 → 833,7
SS_activation(lev);
}
else {
qq_insertlast(p, &lev->wait);
iq_insertlast(p, &lev->wait);
proc_table[p].status = SS_WAIT;
}
}
860,7 → 860,7
/* when we reinsert the task into the system, the server capacity
is always 0 because nobody executes with the SS before... */
qq_insertfirst(p, &lev->wait);
iq_insertfirst(p, &lev->wait);
proc_table[p].status = SS_WAIT;
}
912,11 → 912,11
if (lev->activated == p)
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
else
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
if (lev->nact[p] > 0) {
lev->nact[p]--;
qq_insertlast(p, &lev->wait);
iq_insertlast(p, &lev->wait);
proc_table[p].status = SS_WAIT;
}
else {
923,7 → 923,7
proc_table[p].status = SLEEP;
}
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL) {
SS_activation(lev);
}
962,9 → 962,9
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
proc_table[p].status = FREE;
q_insertfirst(p,&freedesc);
iq_insertfirst(p,&freedesc);
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL) {
SS_activation(lev);
}
1004,11 → 1004,11
if (lev->activated == p)
level_table[lev->scheduling_level]->guest_end(lev->scheduling_level,p);
else
qq_extract(p, &lev->wait);
iq_extract(p, &lev->wait);
proc_table[p].status = SLEEP;
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL) {
SS_activation(lev);
}
1020,41 → 1020,7
}
}
static void SS_task_delay(LEVEL l, PID p, TIME usdelay)
{
SS_level_des *lev = (SS_level_des *)(level_table[l]);
struct timespec ty;
int tx;
#ifdef DEBUG
kern_printf("SS_tdelay ");
#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
/* Here set replenish amount because delay may be too long and
replenish time could arrive */
SS_set_ra(l);
}
/* I hope no delay when owning a mutex... */
if (lev->activated == p)
level_table[ lev->scheduling_level ]->
guest_delay(lev->scheduling_level,p,usdelay);
}
/*-------------------------------------------------------------------*/
/*** Guest functions ***/
1063,39 → 1029,36
/* SS doesn't handles guest tasks */
static int SS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void SS_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void SS_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/*-------------------------------------------------------------------*/
/*** Registration functions ***/
1153,7 → 1116,6
lev->l.task_endcycle = SS_task_endcycle;
lev->l.task_end = SS_task_end;
lev->l.task_sleep = SS_task_sleep;
lev->l.task_delay = SS_task_delay;
lev->l.guest_create = SS_guest_create;
lev->l.guest_detach = SS_guest_detach;
1165,7 → 1127,6
lev->l.guest_endcycle = SS_guest_endcycle;
lev->l.guest_end = SS_guest_end;
lev->l.guest_sleep = SS_guest_sleep;
lev->l.guest_delay = SS_guest_delay;
/* fill the SS descriptor part */
1177,7 → 1138,7
lev->period = per;
qq_init(&lev->wait);
iq_init(&lev->wait, &freedesc, 0);
lev->activated = NIL;
lev->U = (MAX_BANDWIDTH / per) * Cs;

/shark/tags/rel_0_2/kernel/modules/tbs.c
20,11 → 20,11
/**
------------
CVS : $Id: tbs.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: tbs.c,v 1.3 2002-11-11 08:32:07 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:07 $
------------
This file contains the aperiodic server TBS (Total Bandwidth Server)
84,7 → 84,7
struct timespec lastdline; /*+ the last deadline assigned to
a TBS task +*/
QQUEUE wait; /*+ the wait queue of the TBS +*/
IQUEUE wait; /*+ the wait queue of the TBS +*/
PID activated; /*+ the task inserted in another queue +*/
int flags; /*+ the init flags... +*/
206,7 → 206,7
static void TBS_level_status(LEVEL l)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
PID p = qq_queryfirst(&lev->wait);
PID p = iq_query_first(&lev->wait);
kern_printf("Wcet Check : %s\n",
onoff(lev->flags & TBS_ENABLE_WCET_CHECK));
221,8 → 221,8
kern_printf("Activated: Pid: %2d Name: %10s Dl: %ld.%9ld nact: %d Stat: %s\n",
lev->activated,
proc_table[lev->activated].name,
proc_table[lev->activated].timespec_priority.tv_sec,
proc_table[lev->activated].timespec_priority.tv_nsec,
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));
231,7 → 231,7
p,
proc_table[p].name,
TBS_status_to_a(proc_table[p].status));
p = proc_table[p].next;
p = iq_query_next(p, &lev->wait);
}
}
288,14 → 288,6
return 0; /* if the task p is chosen, it is always eligible */
}
#ifdef __TEST1__
extern int testactive;
extern struct timespec s_stime[];
extern TIME s_curr[];
extern TIME s_PID[];
extern int useds;
#endif
static void TBS_task_dispatch(LEVEL l, PID p, int nostop)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
305,16 → 297,6
level_table[ lev->scheduling_level ]->
guest_dispatch(lev->scheduling_level,p,nostop);
#ifdef __TEST1__
if (testactive)
{
TIMESPEC_ASSIGN(&s_stime[useds], &schedule_time);
s_curr[useds] = proc_table[p].avail_time;
s_PID[useds] = p;
useds++;
}
#endif
}
static void TBS_task_epilogue(LEVEL l, PID p)
345,7 → 327,7
lev->lastdline.tv_sec, lev->lastdline.tv_nsec);
#endif
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
TBS_activation(lev);
}
372,7 → 354,7
}
else {
proc_table[p].status = TBS_WAIT;
qq_insertlast(p, &lev->wait);
iq_insertlast(p, &lev->wait);
}
}
else if (lev->flag[p] & TBS_SAVE_ARRIVALS)
417,12 → 399,12
// lev->nact[p] can be >0 only if the SAVE_ARRIVALS bit is set
lev->nact[p]--;
proc_table[p].status = TBS_WAIT;
qq_insertlast(p, &lev->wait);
iq_insertlast(p, &lev->wait);
}
else
proc_table[p].status = SLEEP;
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
TBS_activation(lev);
438,9 → 420,9
TBS_bandwidth_reclaiming(lev,p);
proc_table[p].status = FREE;
q_insertfirst(p,&freedesc);
iq_insertfirst(p,&freedesc);
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
TBS_activation(lev);
}
465,57 → 447,45
lev->nact[p] = 0;
lev->activated = qq_getfirst(&lev->wait);
lev->activated = iq_getfirst(&lev->wait);
if (lev->activated != NIL)
TBS_activation(lev);
}
static void TBS_task_delay(LEVEL l, PID p, TIME usdelay)
{
TBS_level_des *lev = (TBS_level_des *)(level_table[l]);
level_table[ lev->scheduling_level ]->
guest_delay(lev->scheduling_level,p,usdelay);
}
static int TBS_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ kern_raise(XINVALID_GUEST,exec_shadow); return 0; }
static void TBS_guest_detach(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_dispatch(LEVEL l, PID p, int nostop)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_epilogue(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_activate(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_insert(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_extract(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_endcycle(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_end(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_sleep(LEVEL l, PID p)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_raise(XINVALID_GUEST,exec_shadow); }
static void TBS_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_raise(XUNVALID_GUEST,exec_shadow); }
/* Registration functions */
/*+ Registration function:
567,7 → 537,6
lev->l.task_endcycle = TBS_task_endcycle;
lev->l.task_end = TBS_task_end;
lev->l.task_sleep = TBS_task_sleep;
lev->l.task_delay = TBS_task_delay;
lev->l.guest_create = TBS_guest_create;
lev->l.guest_detach = TBS_guest_detach;
579,7 → 548,6
lev->l.guest_endcycle = TBS_guest_endcycle;
lev->l.guest_end = TBS_guest_end;
lev->l.guest_sleep = TBS_guest_sleep;
lev->l.guest_delay = TBS_guest_delay;
/* fill the TBS descriptor part */
590,7 → 558,7
NULL_TIMESPEC(&lev->lastdline);
qq_init(&lev->wait);
iq_init(&lev->wait, &freedesc, 0);
lev->activated = NIL;
lev->U = (MAX_BANDWIDTH / den) * num;

/shark/tags/rel_0_2/kernel/modules/dummy.c
20,11 → 20,11
/**
------------
CVS : $Id: dummy.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: dummy.c,v 1.3 2002-11-11 08:32:06 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:52 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
------------
This file contains the Dummy scheduling module
154,62 → 154,54
}
static void dummy_task_activate(LEVEL l, PID p)
{ kern_printf("Dummy1"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); }
{ kern_printf("Dummy1"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
static void dummy_task_insert(LEVEL l, PID p)
{ kern_printf("Dummy2"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); }
{ kern_printf("Dummy2"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
static void dummy_task_extract(LEVEL l, PID p)
{ kern_printf("Dummy3"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); }
{ kern_printf("Dummy3"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
static void dummy_task_endcycle(LEVEL l, PID p)
{ kern_printf("Dummy4"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); }
{ kern_printf("Dummy4"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
static void dummy_task_end(LEVEL l, PID p)
{ kern_printf("Dummy5"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); }
{ kern_printf("Dummy5"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
static void dummy_task_sleep(LEVEL l, PID p)
{ kern_printf("Dummy6"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); }
{ kern_printf("Dummy6"); kern_raise(XINVALID_DUMMY_OP,exec_shadow); }
static void dummy_task_delay(LEVEL l, PID p, TIME tickdelay)
{ kern_printf("Dummy7"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); }
static int dummy_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{ kern_printf("Dummy8"); kern_raise(XUNVALID_GUEST,exec_shadow); return 0; }
{ 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(XUNVALID_GUEST,exec_shadow); }
{ 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(XUNVALID_GUEST,exec_shadow); }
{ kern_printf("Dummy0"); kern_raise(XINVALID_GUEST,exec_shadow); }
static void dummy_guest_epilogue(LEVEL l, PID p)
{ kern_printf("Dummya"); kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_printf("Dummya"); kern_raise(XINVALID_GUEST,exec_shadow); }
static void dummy_guest_activate(LEVEL l, PID p)
{ kern_printf("Dummyb"); kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_printf("Dummyb"); kern_raise(XINVALID_GUEST,exec_shadow); }
static void dummy_guest_insert(LEVEL l, PID p)
{ kern_printf("Dummyc"); kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_printf("Dummyc"); kern_raise(XINVALID_GUEST,exec_shadow); }
static void dummy_guest_extract(LEVEL l, PID p)
{ kern_printf("Dummyd"); kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_printf("Dummyd"); kern_raise(XINVALID_GUEST,exec_shadow); }
static void dummy_guest_endcycle(LEVEL l, PID p)
{ kern_printf("Dummye"); kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_printf("Dummye"); kern_raise(XINVALID_GUEST,exec_shadow); }
static void dummy_guest_end(LEVEL l, PID p)
{ kern_printf("Dummyf"); kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_printf("Dummyf"); kern_raise(XINVALID_GUEST,exec_shadow); }
static void dummy_guest_sleep(LEVEL l, PID p)
{ kern_printf("Dummyg"); kern_raise(XUNVALID_GUEST,exec_shadow); }
{ kern_printf("Dummyg"); kern_raise(XINVALID_GUEST,exec_shadow); }
static void dummy_guest_delay(LEVEL l, PID p,DWORD tickdelay)
{ kern_printf("Dummyh"); kern_raise(XUNVALID_GUEST,exec_shadow); }
/*+ Dummy task must be present & cannot be killed; +*/
static TASK dummy()
{
298,7 → 290,6
lev->l.task_endcycle = dummy_task_endcycle;
lev->l.task_end = dummy_task_end;
lev->l.task_sleep = dummy_task_sleep;
lev->l.task_delay = dummy_task_delay;
lev->l.guest_create = dummy_guest_create;
lev->l.guest_detach = dummy_guest_detach;
310,7 → 301,6
lev->l.guest_endcycle = dummy_guest_endcycle;
lev->l.guest_end = dummy_guest_end;
lev->l.guest_sleep = dummy_guest_sleep;
lev->l.guest_delay = dummy_guest_delay;
/* the dummy process will be created at init_time.
see also dummy_level_accept_model,dummy_create */

/shark/tags/rel_0_2/kernel/modules/nop.c
20,11 → 20,11
/**
------------
CVS : $Id: nop.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: nop.c,v 1.2 2002-11-11 08:32:06 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: 2002-11-11 08:32:06 $
------------
Binary Semaphores. see nop.h for more details...
73,7 → 73,7
mutex_t structure */
typedef struct {
PID owner;
QQUEUE blocked;
IQUEUE blocked;
} NOP_mutex_t;
124,7 → 124,7
return (ENOMEM);
p->owner = NIL;
qq_init(&p->blocked);
iq_init(&p->blocked, &freedesc, 0);
m->mutexlevel = l;
m->opt = (void *)p;
192,7 → 192,7
/* we insert the task in the semaphore queue */
proc_table[exec_shadow].status = NOP_WAIT;
qq_insertlast(exec_shadow,&p->blocked);
iq_insertlast(exec_shadow,&p->blocked);
/* and finally we reschedule */
exec = exec_shadow = -1;
253,7 → 253,7
proc_table[exec_shadow].context = kern_context_save();
/* the mutex is mine, pop the firsttask to extract */
p->owner = qq_getfirst(&p->blocked);
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);

/shark/tags/rel_0_2/kernel/modules/trcudp.c
6,7 → 6,9
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Paolo Gai <pj@gandalf.sssup.it>
* Massimiliano Giorgi <massy@gandalf.sssup.it>
* Luca Abeni <luca@gandalf.sssup.it>
* (see the web pages for full authors list)
*
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
16,6 → 18,26
* http://shark.sssup.it
*/
/*
* 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
*
* CVS : $Id: trcudp.c,v 1.3 2002-10-28 10:11:38 pj Exp $
*/
#include <ll/sys/types.h>
#include <ll/stdlib.h>
23,73 → 45,217
#include <kernel/mem.h>
#include <kernel/log.h>
#include <drivers/udpip.h>
#include <trace/types.h>
#include <trace/trace.h>
#include <trace/queues.h>
#include <fs/fs.h>
//#define DEBUG_TRCUDP
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#define TRCUDP_MAXEVENTS (1500/sizeof(trc_event_t))
//#define TRCUDP_MAXEVENTS 10
typedef struct TAGudp_queue_t {
UDP_ADDR addr;
trc_event_t evt;
} udp_queue_t;
/* Well... this file is very similar to trccirc.c! */
static trc_event_t *udp_get(udp_queue_t *queue)
typedef struct TAGtrcudp_queue_t {
/*+ size of the queue +*/
int size;
/*+ index of the next insertion into the queue +*/
int index;
/*+ index of the next item to write (if online_tracer activated) +*/
int windex;
/*+ number of events lost (if online_tracer activated) +*/
long hoops;
/*+ local and remote IP numbers +*/
UDP_ADDR local, remote;
/*+ unique number that identify the queue +*/
int uniq;
/*+ =1 when the system shuts down +*/
int mustgodown;
TASK_MODEL *m;
/*+ dummy, needed for creating a valid packet (dirty trick ;-) +*/
short int dummy;
/*+ events table +*/
trc_event_t table[0];
} trcudp_queue_t;
static TASK online_tracer(trcudp_queue_t *queue)
{
return &queue->evt;
int s; /* the socket */
int newwindex; /* new write index after sending the packet */
int n; /* number of packets to send */
short int *pkt;
s = udp_bind(&queue->local, NULL);
for (;;) {
if (queue->index<queue->windex) {
if (queue->windex+TRCUDP_MAXEVENTS < queue->size) {
newwindex = queue->windex+TRCUDP_MAXEVENTS;
n = TRCUDP_MAXEVENTS;
} else {
newwindex = 0;
n = queue->size-queue->windex;
}
} else {
if (queue->windex+TRCUDP_MAXEVENTS < queue->index) {
newwindex = queue->windex+TRCUDP_MAXEVENTS;
n = TRCUDP_MAXEVENTS;
} else {
newwindex = queue->index;
n = queue->index-queue->windex;
}
}
if (n) {
/* set the number of events into the UDP packet. It works
because the event entry before windex is always empty, or
because we use the dummy field into the struct */
pkt = ((short int *)(queue->table+queue->windex))-1;
*pkt = (short int)n;
udp_sendto(s,(char *)pkt,
n*sizeof(trc_event_t)+2,&queue->remote);
#ifdef DEBUG_TRCUDP
printk(KERN_DEBUG "UDP: SEND %d events,"
" index %d windex %d new %d!!!\n",n,
queue->index, queue->windex, newwindex);
#endif
queue->windex = newwindex;
}
if (queue->mustgodown) {
if (queue->windex == queue->index)
break;
}
else
task_endcycle();
}
return NULL;
}
static int udp_post(udp_queue_t *queue)
static trc_event_t *trcudp_get(trcudp_queue_t *queue)
{
//int s=0;
/* s ??? */
//udp_sendto(s,&queue->evt,sizeof(trc_event_t),&queue->addr);
if (queue->mustgodown)
return NULL;
if (queue->index==queue->size-1) {
if (queue->windex==0) {
queue->hoops++;
return NULL;
}
queue->index=0;
return &queue->table[queue->size-1];
}
if (queue->index+1==queue->windex) {
queue->hoops++;
return NULL;
}
return &queue->table[queue->index++];
}
static int trcudp_post(trcudp_queue_t *queue)
{
return 0;
}
static int udp_create(trc_queue_t *queue, TRC_UDP_PARMS *args)
static void trcudp_shutdown(trcudp_queue_t *queue);
static int trcudp_create(trc_queue_t *p, TRC_UDP_PARMS *args)
{
udp_queue_t *ptr;
trcudp_queue_t *queue;
if (args==NULL) return -1;
if (args==NULL) {
printk(KERN_ERR "trcudp_create: you must specify a non-NULL parameter!");
return -1;
}
ptr=(udp_queue_t*)kern_alloc(sizeof(udp_queue_t));
if (ptr==NULL) return -1;
queue->get=(trc_event_t*(*)(void*))udp_get;
queue->post=(int(*)(void*))udp_post;
queue->data=ptr;
queue=(trcudp_queue_t*)kern_alloc(sizeof(trcudp_queue_t)+
sizeof(trc_event_t)*args->size);
if (queue==NULL) {
printk(KERN_ERR "trcudp_create: error during memory allocation!");
return -1;
}
memcpy(&ptr->addr,&args->addr,sizeof(UDP_ADDR));
p->get=(trc_event_t*(*)(void*))trcudp_get;
p->post=(int(*)(void*))trcudp_post;
p->data=queue;
queue->size=args->size;
queue->windex=queue->index=0;
queue->hoops=0;
queue->local=args->local;
queue->remote=args->remote;
/* uniq initialized in trcudp_activate */
queue->mustgodown=0;
queue->m = args->model;
/* dummy unused */
/* AFTER exit because in that way we can hope to be back in text mode... */
sys_atrunlevel((void (*)(void *))trcudp_shutdown, (void *)queue, RUNLEVEL_AFTER_EXIT);
return 0;
}
static int udp_activate(udp_queue_t *queue)
static int trcudp_activate(trcudp_queue_t *queue, int uniq)
{
SOFT_TASK_MODEL model;
TASK_MODEL *m;
PID pid;
queue->uniq=uniq;
if (!queue->m) {
soft_task_default_model(model);
soft_task_def_system(model);
/* soft_task_def_notrace(model); Should we trace the tracer? */
soft_task_def_periodic(model);
soft_task_def_period(model,250000);
soft_task_def_met(model,10000);
soft_task_def_wcet(model,10000);
/* soft_task_def_nokill(model); NOOOOOOO!!!! */
soft_task_def_arg(model,queue);
m = (TASK_MODEL *)&model;
}
else {
m = queue->m;
task_def_arg(*m,queue);
}
pid=task_create("trcUDP",online_tracer,m,NULL);
if (pid==-1) {
printk(KERN_ERR "can't start tracer online trcudp trace task");
} else
task_activate(pid);
return 0;
}
static int udp_terminate(udp_queue_t *queue)
static int trcudp_terminate(trcudp_queue_t *queue)
{
queue->mustgodown = 1;
return 0;
}
static void trcudp_shutdown(trcudp_queue_t *queue)
{
printk(KERN_NOTICE "tracer: %li events lost into UDP queue %d",
queue->hoops, queue->uniq);
}
int trc_register_udp_queue(void)
{
int res;
res=trc_register_queuetype(TRC_UDP_QUEUE,
(int(*)(trc_queue_t*,void*))udp_create,
(int(*)(void*))udp_activate,
(int(*)(void*))udp_terminate
);
if (res!=0) printk(KERN_WARNING "can't register tracer udp queue");
(int(*)(trc_queue_t*,void*))trcudp_create,
(int(*)(void*,int))trcudp_activate,
(int(*)(void*))trcudp_terminate
);
if (res!=0) printk(KERN_WARNING "can't register tracer trcudp queue");
return res;
}

/shark/tags/rel_0_2/kernel/modules/cabs.c
20,11 → 20,11
/**
------------
CVS : $Id: cabs.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: cabs.c,v 1.2 2002-10-28 07:55:54 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: 2002-10-28 07:55:54 $
------------
Date: 2/7/96
95,7 → 95,7
static int checkcab(CAB id)
{
if (id >= MAX_CAB) {
errno = ECAB_UNVALID_ID;
errno = ECAB_INVALID_ID;
return -1;
}
if (cabs[id].busy == TRUE) return TRUE;
117,7 → 117,7
}
cabs[MAX_CAB-1].next_cab_free = NIL;
cabs[MAX_CAB-1].busy = FALSE;
// for (i = CAB_UNVALID_MSG_NUM; i <= CAB_CLOSED; i++)
// for (i = CAB_INVALID_MSG_NUM; i <= CAB_CLOSED; i++)
// exc_set(i,cab_exception);
}
139,7 → 139,7
/* solleva l'eccezioni */
if (num_mes < 1) {
errno = ECAB_UNVALID_MSG_NUM;
errno = ECAB_INVALID_MSG_NUM;
kern_frestore(f);
return -1;
}

/shark/tags/rel_0_2/kernel/modules/srp.c
20,11 → 20,11
/**
------------
CVS : $Id: srp.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: srp.c,v 1.2 2002-10-28 07:55:55 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: 2002-10-28 07:55:55 $
------------
Stack Resource Policy. see srp.h for general details...
595,7 → 595,7
// lev, mut->owner,
// mut->use[exec_shadow],
// lev->proc_preempt[exec_shadow].preempt,exec_shadow);
kern_raise(XSRP_UNVALID_LOCK, exec_shadow);
kern_raise(XSRP_INVALID_LOCK, exec_shadow);
kern_sti();
return (EINVAL);
}

/shark/tags/rel_0_2/kernel/modules/makefile
42,10 → 42,10
TRC_OBJ = trace.o \
trcdummy.o \
trcfixed.o \
trccirc.o
trccirc.o \
trcdfix.o \
trcudp.o
# trcudp.o
OBJS = $(SCHED_OBJ) $(APER_OBJ) $(RES_OBJ) $(TRC_OBJ)
include $(BASE)/config/lib.mk

/shark/tags/rel_0_2/kernel/modules/trace.c
38,11 → 38,11
*/
/*
* CVS : $Id: trace.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
* CVS : $Id: trace.c,v 1.2 2002-10-21 10:13:56 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: 2002-10-21 10:13:56 $
*/
#include <ll/sys/types.h>
58,6 → 58,7
#include <bits/limits.h>
/* maximum number of different queues where we want to log our events */
#define TRC_MAXQUEUES 5
/*
64,8 → 65,11
*
*/
/* this is the base path that is used as a prologue for all the
filenames that are passed to the tracer */
static char basepath[PATH_MAX];
/* used to create the name for a tracer file */
void trc_create_name(char *basename, int uniq, char *pathname)
{
if (uniq) sprintf(pathname,"%s/%s%i",basepath,basename,uniq);
76,27 → 80,42
*
*/
/* the flag used to discriminate if an event have to be traced or not */
#define FLAG_NOTRACE 0x01
typedef struct TAGtrc_evtinfo_t {
trc_queue_t *queue;
unsigned flags;
trc_queue_t *queue; /* the queue responsible for the logging of an event */
unsigned flags; /* if = FLAG_NOTRACE the event must not be logged */
} trc_evtinfo_t;
/* -- */
/* one entry for each event; this array says for each event the queue to use
and if it must be logged */
trc_evtinfo_t eventstable[TRC_NUMEVENTS];
/* For each kind of queue (see include/tracer/queues.h) there is a set of
pointers to the functions that a queue should implement */
int (*createqueue[TRC_QUEUETYPESNUMBER])(trc_queue_t *, void *);
int (*activatequeue[TRC_QUEUETYPESNUMBER])(void *,int);
int (*terminatequeue[TRC_QUEUETYPESNUMBER])(void *);
/* for each queue registered in the system,
the functions used to get/post an event
The elements of this table are initialized with calls to createqueue[type]()
(see include/trace/queues.h) */
trc_queue_t queuetable[TRC_MAXQUEUES];
/* initialized as a dummy queue, the default value of all the queues */
trc_queue_t queuesink;
/* number of registered queues in the system */
int numqueues;
/* -- */
/* The Dummy queue */
static trc_event_t *dummy_get(void *foo)
{
return NULL;
127,6 → 146,8
/* -- */
/* this function simply register the functions that are used to
handle a queue */
int trc_register_queuetype(int queuetype,
int(*creat)(trc_queue_t *, void *),
int(*activate)(void *,int),
139,6 → 160,11
return 0;
}
/* this function register a queue in the system.
It uses the type to access to the queue handling functions registered
with the previous function (trc_register_queuetype)
numqueue is incremented!
*/
int trc_create_queue(int queuetype, void *args)
{
int res;
186,20 → 212,28
printk(KERN_INFO "initializing tracer...");
/* all the queues are initialized to the dummy queue (sink!) */
for (i=0;i<TRC_QUEUETYPESNUMBER;i++) {
createqueue[i]=dummy_createqueue;
terminatequeue[i]=dummy_terminatequeue;
}
/* the sink queue is initialized */
dummy_createqueue(&queuesink,NULL);
/* no queues registered yet */
numqueues=0;
/* all the events are initialized to put to the sink queue */
for (i=0;i<TRC_NUMEVENTS;i++) {
eventstable[i].queue=&queuesink;
eventstable[i].flags=FLAG_NOTRACE;
}
/* this will end the tracer at shutdown */
i=sys_atrunlevel(trc_end,NULL,RUNLEVEL_SHUTDOWN);
/* initialize the parameters if not initialized */
{
TRC_PARMS m;
trc_default_parms(m);
212,10 → 246,13
trc_suspend=internal_trc_suspend;
trc_resume=internal_trc_resume;
/* start the tracer */
trc_resume();
return 0;
}
/* this function simply activates all the registered queues.
This is usually called into the init() tasks!!! */
int TRC_init_phase2(void)
{
int i;
224,6 → 261,8
return 0;
}
/* saves the current logevent function and set it as
the internal_trc_logevent */
static int internal_trc_resume(void)
{
SYS_FLAGS f;
238,6 → 277,8
return ret;
}
/* restores the saved logevent function (initially, the logevent function is
a dummy function) */
static int internal_trc_suspend(void)
{
SYS_FLAGS f;
258,8 → 299,10
trc_queue_t *queue;
SYS_FLAGS f;
/* disables interrupts (this function can be called also into a task */
f=kern_fsave();
/* check if the event has to be logged */
if (eventstable[event].flags&FLAG_NOTRACE) {
kern_frestore(f);
return;
266,6 → 309,7
}
queue=eventstable[event].queue;
/* gets a free event descriptor, fills it and post it */
evt=queue->get(queue->data);
if (evt!=NULL) {
evt->event=event;
283,6 → 327,10
*
*/
/* these set of functions can be used to trace or not single event and classes.
They make use of the classtable structure, that is used to discriminate
the indexes occupied by every class */
int classtable[TRC_NUMCLASSES+1]={
TRC_F_TRACER,
TRC_F_SYSTEM,
353,21 → 401,29
{
int qf,qc;
int res;
/* initialize the trace */
res=TRC_init_phase1(NULL);
if (res) return res;
/* register two kinds of queues, fixed and circular */
res=trc_register_circular_queue();
if (res) return res;
res=trc_register_fixed_queue();
if (res) return res;
/* creates two queues:
a circular queue for the system events,
a fixed queue
*/
qc=trc_create_queue(TRC_CIRCULAR_QUEUE,NULL);
qf=trc_create_queue(TRC_FIXED_QUEUE,NULL);
if (qc==-1||qf==-1) return -97;
/* We want to trace all the system events */
res=trc_trace_class(TRC_CLASS_SYSTEM);
if (res) return res;
/* All the system events must be traced into the circular queue */
res=trc_assign_class_to_queue(TRC_CLASS_SYSTEM,qc);
if (res) return res;

/shark/tags/rel_0_2/kernel/modules/trcfixed.c
33,6 → 33,13
#include <fcntl.h>
#include <limits.h>
/* this file implement a fixed queue, that is simply an array that
is filled with the events until it is full. After that, all the other
events are discarded. */
typedef struct TAGfixed_queue_t {
int size;
int index;
39,9 → 46,13
char *filename;
int uniq;
trc_event_t table[0];
trc_event_t table[0];
/* Yes, 0!... the elements are allocated
in a dirty way into the kern_alloc into fixed_create */
} fixed_queue_t;
/* This function simply return an event to fill (only if the fixed table
is not yet full) */
static trc_event_t *fixed_get(fixed_queue_t *queue)
{
if (queue->index>=queue->size) return NULL;
48,6 → 59,8
return &queue->table[queue->index++];
}
/* since get returns the correct event address,
the post function does nothing... */
static int fixed_post(fixed_queue_t *queue)
{
return 0;
60,6 → 73,7
{
fixed_queue_t *ptr;
/* initialize the default arguments for the fixed queue */
if (!once) {
/* well... this func is called when the system is not running! */
once=1;
67,11 → 81,12
}
if (args==NULL) args=&defaultargs;
/* allocate the fixed queue data structure plus the array of events */
ptr=(fixed_queue_t*)kern_alloc(sizeof(fixed_queue_t)+
sizeof(trc_event_t)*(args->size+1));
if (ptr==NULL) return -1;
/* set the current queue pointers and data */
queue->get=(trc_event_t*(*)(void*))fixed_get;
queue->post=(int(*)(void*))fixed_post;
queue->data=ptr;

/shark/tags/rel_0_2/kernel/modules/trcdfix.c
0,0 → 1,152
/*
* Project: S.Ha.R.K.
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Massimiliano Giorgi <massy@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
*/
#include <ll/sys/types.h>
#include <ll/stdlib.h>
#include <kernel/func.h>
#include <kernel/mem.h>
#include <kernel/log.h>
#include <trace/types.h>
#include <trace/trace.h>
#include <trace/queues.h>
#include <ll/i386/x-dos.h>
/* this file implement a fixed queue, that is simply an array that
is filled with the events until it is full. After that, all the other
events are discarded. It uses the DOSFS Filesystem to write all the data
This file is derived from the trcfixed.c file; I used a different file
because including trcfixed.c in the executable would have implied the
linking of all the filesystem...
*/
typedef struct TAGfixed_queue_t {
int size;
int index;
char *filename;
int uniq;
trc_event_t table[0];
/* Yes, 0!... the elements are allocated
in a dirty way into the kern_alloc into fixed_create */
} dosfs_fixed_queue_t;
/* This function simply return an event to fill (only if the fixed table
is not yet full) */
static trc_event_t *dosfs_fixed_get(dosfs_fixed_queue_t *queue)
{
if (queue->index>=queue->size) return NULL;
return &queue->table[queue->index++];
}
/* since get returns the correct event address,
the post function does nothing... */
static int dosfs_fixed_post(dosfs_fixed_queue_t *queue)
{
return 0;
}
static TRC_FIXED_PARMS defaultargs;
static int once=0;
static void dosfs_fixed_flush(void *arg);
static int dosfs_fixed_create(trc_queue_t *queue, TRC_FIXED_PARMS *args)
{
dosfs_fixed_queue_t *ptr;
/* initialize the default arguments for the fixed queue */
if (!once) {
/* well... this func is called when the system is not running! */
once=1;
trc_fixed_default_parms(defaultargs);
}
if (args==NULL) args=&defaultargs;
/* allocate the fixed queue data structure plus the array of events */
ptr=(dosfs_fixed_queue_t*)kern_alloc(sizeof(dosfs_fixed_queue_t)+
sizeof(trc_event_t)*(args->size+1));
if (ptr==NULL) return -1;
/* set the current queue pointers and data */
queue->get=(trc_event_t*(*)(void*))dosfs_fixed_get;
queue->post=(int(*)(void*))dosfs_fixed_post;
queue->data=ptr;
ptr->size=args->size;
ptr->index=0;
ptr->filename=args->filename;
/* prepare for shutdown ;-) */
sys_atrunlevel(dosfs_fixed_flush, (void *)ptr, RUNLEVEL_AFTER_EXIT);
return 0;
}
static void dosfs_fixed_flush(void *arg)
{
DOS_FILE *f;
dosfs_fixed_queue_t *queue = (dosfs_fixed_queue_t *)arg;
char pathname[100]; /* it should be PATH_MAX, but we do not use the
filesystem, so the symbol is not defined */
if (queue->filename==NULL) trc_create_name("fix",queue->uniq,pathname);
else trc_create_name(queue->filename,0,pathname);
printk(KERN_DEBUG "tracer flush index= %d pathname=%s\n",
queue->index, pathname);
f = DOS_fopen(pathname,"w");
DOS_fwrite(queue->table,1,queue->index*sizeof(trc_event_t),f);
DOS_fclose(f);
}
static int dosfs_fixed_activate(dosfs_fixed_queue_t *queue, int uniq)
{
queue->uniq=uniq;
return 0;
}
static int dosfs_fixed_terminate(dosfs_fixed_queue_t *queue)
{
return 0;
}
int trc_register_dosfs_fixed_queue(void)
{
int res;
res=trc_register_queuetype(TRC_DOSFS_FIXED_QUEUE,
(int(*)(trc_queue_t*,void*))dosfs_fixed_create,
(int(*)(void*,int))dosfs_fixed_activate,
(int(*)(void*))dosfs_fixed_terminate
);
if (res!=0) printk(KERN_WARNING "can't register tracer DOSFS fixed queue");
return res;
}

/shark/tags/rel_0_2/kernel/kill.c
18,11 → 18,11
/**
------------
CVS : $Id: kill.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: kill.c,v 1.2 2002-10-28 07:58:19 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: 2002-10-28 07:58:19 $
------------
This file contains:
145,7 → 145,7
the task being canceled... */
for (p = 0; p<MAX_PROC; p++)
if (p != i && proc_table[p].shadow == i) {
kern_raise(XUNVALID_KILL_SHADOW,i);
kern_raise(XINVALID_KILL_SHADOW,i);
return;
}
250,7 → 250,7
kern_cli();
if (proc_table[i].control & NO_KILL ||
proc_table[i].status == FREE) {
errno = EUNVALID_KILL;
errno = EINVALID_KILL;
kern_sti();
return -1;
}
296,7 → 296,7
int j; /* a counter */
if (g == 0) {
errno = EUNVALID_GROUP;
errno = EINVALID_GROUP;
return -1;
}

/shark/tags/rel_0_2/kernel/join.c
18,11 → 18,11
/**
------------
CVS : $Id: join.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: join.c,v 1.2 2002-11-11 08:34:08 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: 2002-11-11 08:34:08 $
------------
task join and related primitives
188,7 → 188,7
queue */
proc_table[p].control &= ~WAIT_FOR_JOIN;
if (proc_table[p].control & DESCRIPTOR_DISCARDED)
q_insertfirst(p, &freedesc);
iq_insertfirst(p, &freedesc);
if (value)
*value = proc_table[p].return_value;

/shark/tags/rel_0_2/kernel/kern.c
18,11 → 18,11
/**
------------
CVS : $Id: kern.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: kern.c,v 1.2 2002-11-11 08:34:08 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: 2002-11-11 08:34:08 $
------------
This file contains:
96,7 → 96,7
PID exec; /*+ Task advised by the scheduler +*/
PID exec_shadow; /*+ Currently executing task +*/
QUEUE freedesc; /*+ Free descriptor handled as a queue +*/
IQUEUE freedesc; /*+ Free descriptor handled as a queue +*/
DWORD sys_tick; /*+ System tick (in usec) +*/
struct timespec schedule_time;
405,8 → 405,8
proc_table[i].shadow = i;
proc_table[i].cleanup_stack= NULL;
proc_table[i].errnumber = 0;
proc_table[i].priority = 0;
NULL_TIMESPEC(&proc_table[i].timespec_priority);
//proc_table[i].priority = 0;
//NULL_TIMESPEC(&proc_table[i].timespec_priority);
proc_table[i].delay_timer = -1;
proc_table[i].wcet = -1;
424,12 → 424,17
for (j=0; j<PTHREAD_KEYS_MAX; j++)
proc_table[i].keys[j] = NULL;
}
for (i = 0; i < MAX_PROC-1; i++) proc_table[i].next = i+1;
proc_table[MAX_PROC-1].next = NIL;
for (i = MAX_PROC-1; i > 0; i--) proc_table[i].prev = i-1;
proc_table[0].prev = NIL;
freedesc = 0;
/* set up the free descriptor queue */
// for (i = 0; i < MAX_PROC-1; i++) proc_table[i].next = i+1;
// proc_table[MAX_PROC-1].next = NIL;
// for (i = MAX_PROC-1; i > 0; i--) proc_table[i].prev = i-1;
// proc_table[0].prev = NIL;
// freedesc = 0;
iq_init(&freedesc, NULL, 0);
for (i = 0; i < MAX_PROC; i++)
iq_insertlast(i,&freedesc);
/* Set up the varius stuff */
global_errnumber = 0;
task_counter = 0;

/shark/tags/rel_0_2/kernel/grpcreat.c
18,11 → 18,11
/**
------------
CVS : $Id: grpcreat.c,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: grpcreat.c,v 1.2 2002-11-11 08:34:08 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: 2002-11-11 08:34:08 $
------------
This file contains:
116,7 → 116,7
/* Get a free descriptor */
for (;;) {
i = q_getfirst(&freedesc);
i = iq_getfirst(&freedesc);
/* If no one is available abort the system */
if (i == NIL) {
145,7 → 145,7
proc_table[i].sigpending = 0; /* No pending signal for new tasks*/
proc_table[i].shadow = i;
proc_table[i].cleanup_stack = NULL;
proc_table[i].next = proc_table[i].prev = NIL;
// proc_table[i].next = proc_table[i].prev = NIL;
proc_table[i].errnumber = 0; /* meaningless value */
/* Fill jet info */
182,7 → 182,7
if (l == sched_levels) {
/* no level can accept the task_model, exit!!! */
proc_table[i].status = FREE;
q_insertfirst(i,&freedesc);
iq_insertfirst(i,&freedesc);
errno = ENO_AVAIL_SCHEDLEVEL;
return -1;
}
194,7 → 194,7
if (level_table[l]->task_create(l,i,m) < 0) {
/* an error occurred in the task_create */
proc_table[i].status = FREE;
q_insertfirst(i,&freedesc);
iq_insertfirst(i,&freedesc);
errno = ETASK_CREATE;
return -1;
}
344,7 → 344,7
proc_table[i].status = FREE;
q_insertfirst(i,&freedesc);
iq_insertfirst(i,&freedesc);
}

/shark/tags/rel_0_2/kernel/signal.c
18,11 → 18,11
/**
------------
CVS : $Id: signal.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
CVS : $Id: signal.c,v 1.2 2002-11-11 08:34:09 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: 2002-11-11 08:34:09 $
------------
This file contains:
108,7 → 108,7
* A queue of all threads waiting in sigwait.
* It is not static because it is used into the task_kill...ð
*/
static QUEUE sigwaiters;
static IQUEUE sigwaiters;
/*+ An array of queues of pending signals posted with sigqueue(). +*/
331,7 → 331,7
LEVEL l;
/* Reactivate the task... */
q_extract(p, &sigwaiters);
iq_extract(p, &sigwaiters);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
469,9 → 469,9
* in sigwait will have blocked the signals being waited for).
*/
for (task = sigwaiters;
for (task = iq_query_first(&sigwaiters);
task != NIL;
task = proc_table[task].next) {
task = iq_query_next(task, &sigwaiters)) {
if (sigismember(&proc_table[task].sigwaiting, signo)) {
LEVEL l;
479,7 → 479,7
sigaddset(&proc_table[task].sigpending, signo);
/* Reactivate the task... */
q_extract(task, &sigwaiters);
iq_extract(task, &sigwaiters);
l = proc_table[task].task_level;
level_table[l]->task_insert(l,task);
614,9 → 614,9
* the FIFO order, and how to prevent lost signals in the case that
* a thread calls sigwait before the woken thread runs and gets it.
*/
for (task = sigwaiters;
for (task = iq_query_first(&sigwaiters);
task != NIL;
task = proc_table[task].next) {
task = iq_query_next(task, &sigwaiters)) {
if (sigismember(&proc_table[task].sigwaiting, signo)) {
LEVEL l;
624,7 → 624,7
sigaddset(&proc_table[task].sigpending, signo);
/* Reactivate the task... */
q_extract(task, &sigwaiters);
iq_extract(task, &sigwaiters);
l = proc_table[task].task_level;
level_table[l]->task_insert(l,task);
697,7 → 697,7
proc_table[p].control |= SIGTIMEOUT_EXPIRED;
/* insert the task into the ready queue and extract it from the waiters */
q_extract(p, &sigwaiters);
iq_extract(p, &sigwaiters);
l = proc_table[p].task_level;
level_table[l]->task_insert(l,p);
754,7 → 754,7
* Grab the first queue entry.
*/
sos = sigqueued[thissig];
sigqueued[thissig] = sig_queue[sigqueued[thissig]].next;
sigqueued[thissig] = sig_queue[sos].next;
/*
* If that was the last one, reset the process procsigpending.
834,7 → 834,7
* find a thread in sigwait, but it will not be able to wake it up
* until the waitlock is released in the switch code.
*/
q_insertfirst(exec_shadow, &sigwaiters);
iq_insertfirst(exec_shadow, &sigwaiters);
proc_table[exec_shadow].status = WAIT_SIG;
if (timeout) {
890,7 → 890,8
/*
* Grab the first queue entry.
*/
sos = q_getfirst(&sigqueued[thissig]);
sos = sigqueued[thissig];
sigqueued[thissig] = sig_queue[sos].next;
/*
* If that was the last one, reset the process procsigpending.
1068,7 → 1069,7
l = proc_table[exec_shadow].task_level;
level_table[l]->task_extract(l,exec_shadow);
q_insertfirst(exec_shadow, &sigwaiters);
iq_insertfirst(exec_shadow, &sigwaiters);
proc_table[exec_shadow].status = WAIT_SIGSUSPEND;
/* and finally we reschedule */
1500,7 → 1501,7
proc_table[i].delay_timer = -1;
}
q_extract(i, &sigwaiters);
iq_extract(i, &sigwaiters);
l = proc_table[i].task_level;
level_table[l]->task_insert(l,i);
1544,7 → 1545,7
procsigpending = 0;
sigwaiters = NIL;
iq_init(&sigwaiters, &freedesc, 0);
alarm_timer = -1;
/* Interrupt handling init */

/shark/tags/rel_0_2/kernel/makefile
16,7 → 16,6
blkact.o \
cancel.o \
conditio.o \
delay.o \
endcycle.o \
event.o \
exchtxt.o \
37,8 → 36,7
printk.o \
perror.o \
pthread.o \
qqueue.o \
queue.o \
iqueue.o \
signal.o \
sleep.o \
status.o \
50,7 → 48,6
include $(BASE)/config/lib.mk
install all clean cleanall depend::
make -C init $@
make -C modules $@
make -C mem $@

/shark/tags/rel_0_2/kernel/iqueue.c
0,0 → 1,221
/*
* 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: iqueue.c,v 1.1 2002-11-11 08:34:08 pj Exp $
File: $File$
Revision: $Revision: 1.1 $
Last update: $Date: 2002-11-11 08:34:08 $
------------
*/
/*
* 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 <kernel/iqueue.h>
#include <kernel/mem.h>
void iq_init (IQUEUE *q, IQUEUE *share, int flags)
{
q->first = NIL;
q->last = NIL;
if (share)
q->s = share->s;
else {
q->s = (struct IQUEUE_shared *)kern_alloc(sizeof(struct IQUEUE_shared));
if (!(flags & IQUEUE_NO_PRIORITY))
q->s->priority = (DWORD *)kern_alloc(sizeof(DWORD) * MAX_PROC);
if (!(flags & IQUEUE_NO_TIMESPEC))
q->s->timespec_priority = (struct timespec *)
kern_alloc(sizeof(struct timespec) * MAX_PROC);
}
}
/*+
This function insert the task with PID i in the queue que.
The insertion is made respecting the priority field.
(the first item in the queue have the less priority)
+*/
void iq_priority_insert (PID i, IQUEUE *que)
{
DWORD prio;
PID p,q;
p = NIL;
q = que->first;
prio = que->s->priority[i];
while ((q != NIL) && (prio >= que->s->priority[q])) {
p = q;
q = que->s->next[q];
}
if (p != NIL)
que->s->next[p] = i;
else
que->first = i;
if (q != NIL)
que->s->prev[q] = i;
else
que->last = i;
que->s->next[i] = q;
que->s->prev[i] = p;
}
/*
This function insert the task with PID i in the queue que.
The insertion is made respecting the timespec priority field.
(the first item in the queue have the less priority)
*/
void iq_timespec_insert(PID i, IQUEUE *que)
{
struct timespec prio;
PID p,q;
p = NIL;
q = que->first;
TIMESPEC_ASSIGN(&prio, &que->s->timespec_priority[i]);
while ((q != NIL) &&
!TIMESPEC_A_LT_B(&prio, &que->s->timespec_priority[q])) {
p = q;
q = que->s->next[q];
}
if (p != NIL)
que->s->next[p] = i;
else
que->first = i;
if (q != NIL)
que->s->prev[q] = i;
else
que->last = i;
que->s->next[i] = q;
que->s->prev[i] = p;
}
void iq_insertfirst(PID p, IQUEUE *q)
{
if (q->first != NIL) {
q->s->next[p] = q->first;
q->s->prev[q->first] = p;
}
else {
q->last = p;
q->s->next[p] = NIL;
}
q->s->prev[p] = NIL;
q->first = p;
}
void iq_insertlast(PID p, IQUEUE *q)
{
if (q->last != NIL) {
q->s->prev[p] = q->last;
q->s->next[q->last] = p;
}
else {
q->first = p;
q->s->prev[p] = NIL;
}
q->s->next[p] = NIL;
q->last = p;
}
void iq_extract(PID i, IQUEUE *que)
{
PID p,q;
p = que->s->prev[i];
q = que->s->next[i];
if (p != NIL)
que->s->next[p] = que->s->next[i];
else
que->first = q;
if (q != NIL)
que->s->prev[q] = que->s->prev[i];
else
que->last = p;
}
PID iq_getfirst(IQUEUE *q)
{
PID p = q->first;
if (p == NIL)
return NIL;
q->first = q->s->next[q->first];
if (q->first != NIL)
q->s->prev[q->first] = NIL;
else
q->last = NIL;
return p;
}
PID iq_getlast(IQUEUE *q)
{
PID p = q->last;
if (p == NIL)
return NIL;
q->last = q->s->prev[q->last];
if (q->last != NIL)
q->s->next[q->last] = NIL;
else
q->first = NIL;
return p;
}

/shark/tags/rel_0_2/include/kernel/func.h
21,11 → 21,11
/**
------------
CVS : $Id: func.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: func.h,v 1.2 2002-11-11 08:36:01 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: 2002-11-11 08:36:01 $
------------
Kernel functions:
89,15 → 89,6
/* if a source use printk() it should include log.h not func.h */
#include <kernel/log.h>
#if 0
#ifdef __DEBUG_ON__
#define printk(fmt,args...) \
VM_printf(fmt,##args)
#else
#define printk(fmt,args...)
#endif
#endif
/*---------------------------------------------------------------------*/
/* Kernel global functions: initialization & termination... */
/*---------------------------------------------------------------------*/
145,7 → 136,7
int set_exchandler_text();
/*---------------------------------------------------------------------*/
/* Kernel global functions: scheduler, queues */
/* Kernel global functions: scheduler, */
/*---------------------------------------------------------------------*/
/*+ This is the generic scheduler.
157,26 → 148,6
the end of an event list +*/
void event_need_reschedule();
/* Simple QUEUE management functions */
void q_insert (PID p, QUEUE *q);
void q_timespec_insert (PID p, QUEUE *q);
void q_extract (PID p, QUEUE *q);
PID q_getfirst ( QUEUE *q);
void q_insertfirst (PID p, QUEUE *q);
/* QQUEUE management functions */
void qq_init ( QQUEUE *q);
void qq_insert (PID p, QQUEUE *q);
void qq_timespec_insert (PID p, QQUEUE *q);
void qq_extract (PID p, QQUEUE *q);
PID qq_getfirst ( QQUEUE *q);
void qq_insertfirst (PID p, QQUEUE *q);
void qq_insertlast (PID p, QQUEUE *q);
PID qq_queryfirst ( QQUEUE *q);
PID qq_querylast ( QQUEUE *q);
void task_makefree(void *ret);
void check_killed_async(void);
221,15 → 192,6
return ll_context_from();
}
#ifdef __TEST1__
extern int useds;
extern int testactive;
extern struct timespec s_send[];
#endif
/*+ this functions are called every time a context is changed +*/
void kern_after_dispatch(void);
243,10 → 205,6
{
ll_context_to(c);
kern_after_dispatch();
#ifdef __TEST1__
if (testactive) ll_gettime(TIME_EXACT,&s_send[useds-1] );
#endif
sti();
}
539,9 → 497,6
Pending activations are discarded +*/
void task_sleep(void);
/*+ This function suspend the actual task for a minimum delay time +*/
void task_delay(DWORD delay);
/*+ This primitives refers the group id which is supplied
by the application, not by the kernel +*/
int group_activate(WORD g);

/shark/tags/rel_0_2/include/kernel/iqueue.h
0,0 → 1,197
/*
* 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: iqueue.h,v 1.1 2002-11-11 08:36:01 pj Exp $
File: $File$
Revision: $Revision: 1.1 $
Last update: $Date: 2002-11-11 08:36:01 $
------------
*/
/*
* 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
*
*/
/*
IQUEUEs
This file contains functions that helps to manage task queues.
These functions are different from the functions that manages the
QUEUE and QQUEUE types. In particular, these functions no more relies
on the prev & next fields of the task descriptor. In that way, tasks
can be inserted in more than one queue at a time.
Basically, an IQUEUE has an "I"nternal prev/next structure, that may
be shared between one or more queue. Of course, the user MUST
guarantee that the same task will not be inserted in two IQUEUEs that
share the same prev/next buffer.
The queue insertion is made by the following functions:
iq_insert -> insertion based on the priority field.
iq_timespec_insert -> same as above but use the timespec_priority field
iq_insertfirst -> insert in the first position of the queue
*/
#include <ll/ll.h>
#include <kernel/const.h>
#include <kernel/types.h>
#ifndef __KERNEL_IQUEUE_H__
#define __KERNEL_IQUEUE_H__
#define IQUEUE_NO_PRIORITY 1
#define IQUEUE_NO_TIMESPEC 2
struct IQUEUE_shared {
PID prev[MAX_PROC];
PID next[MAX_PROC];
struct timespec *timespec_priority;
DWORD *priority;
};
typedef struct {
PID first;
PID last;
struct IQUEUE_shared *s;
} IQUEUE;
/* Internal queue initialization:
share = &x -> the internal data structure of the IQUEUE x is used
to enqueue the tasks.
share = NULL -> an internal data structure to handle prev/next
pairs is dynamically allocated (The amount of
memory that is allocated can be reduced using the
flags).
flags can be used to reduce the memory usage of an IQUEUE when share=NULL:
IQUEUE_NO_PRIORITY -> the iqueue do not provide internally a priority field
IQUEUE_NO_TIMESPEC -> the iqueue do not provide internally a timespec field
- note that, if these flags are used, the corresponding insert
functions will not work!
- the default value for the flags is, of course, 0
*/
void iq_init (IQUEUE *q, IQUEUE *share, int flags);
/* Queue insert functions:
- inserts a p into the q. p must not be already inserted into q.
- four versions of the function;
- iq_priority_insert -> ordered insertion using the priority field
- iq_timespec_insert -> ordered insertion using the timespec field
- iq_insertfirst -> insert at the first position of the queue
- iq_insertlast -> insert at the last position of the queue
*/
void iq_priority_insert (PID p, IQUEUE *q);
void iq_timespec_insert (PID p, IQUEUE *q);
void iq_insertfirst (PID p, IQUEUE *q);
void iq_insertlast (PID p, IQUEUE *q);
/* Queue extract functions:
- extracts a task p from the queue q.
- three versions of the function;
- iq_extract -> extracts given a task p
(that must be inserted in the queue)
- iq_getfirst -> extracts the first task in the queue,
NIL if the queue is empty
- iq_getlast -> extracts the last task in the queue,
NIL if the queue is empty
*/
void iq_extract (PID p, IQUEUE *q);
PID iq_getfirst ( IQUEUE *q);
PID iq_getlast ( IQUEUE *q);
/* Queue query functions:
The first two functions return the first and the last task in the queue,
NIL if the queue is empty.
The second two functions can be used to get/set the priority or the
timespec field used when queuing.
*/
static __inline__ PID iq_query_first(IQUEUE *q)
{
return q->first;
}
static __inline__ PID iq_query_last(IQUEUE *q)
{
return q->last;
}
static __inline__ struct timespec *iq_query_timespec(PID p, IQUEUE *q)
{
return &q->s->timespec_priority[p];
}
static __inline__ DWORD *iq_query_priority (PID p, IQUEUE *q)
{
return &q->s->priority[p];
}
/* Queue iterators */
/* sometimes it is useful to go through the list. For that reason
You can use the following two functions... */
static __inline__ PID iq_query_next (PID p, IQUEUE *q)
{
return q->s->next[p];
}
static __inline__ PID iq_query_prev (PID p, IQUEUE *q)
{
return q->s->prev[p];
}
/* Queue test functions */
static __inline__ int iq_isempty (IQUEUE *q)
{
return q->first == NIL;
}
#endif

/shark/tags/rel_0_2/include/kernel/int_sem.h
21,11 → 21,11
/**
------------
CVS : $Id: int_sem.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: int_sem.h,v 1.2 2002-11-11 08:36:01 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: 2002-11-11 08:36:01 $
------------
Internal semaphores.
63,12 → 63,13
#define __INT_SEM_H__
#include <kernel/types.h>
#include <kernel/iqueue.h>
/* this is the structure normally pointed by the opt field in the
mutex_t structure */
typedef struct {
int count;
QQUEUE blocked;
IQUEUE blocked;
} internal_sem_t;

/shark/tags/rel_0_2/include/kernel/kern.h
21,11 → 21,11
/**
------------
CVS : $Id: kern.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: kern.h,v 1.2 2002-11-11 08:36:01 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: 2002-11-11 08:36:01 $
------------
Main kernel include file.
67,6 → 67,8
//#include <kernel/err.h>
//#include <kernel/exc.h>
#include <kernel/var.h>
#include <kernel/iqueue.h>
#include <kernel/func.h>

/shark/tags/rel_0_2/include/kernel/descr.h
21,11 → 21,11
/**
------------
CVS : $Id: descr.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: descr.h,v 1.2 2002-11-11 08:36:01 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: 2002-11-11 08:36:01 $
------------
Kernel main data structures
70,6 → 70,7
#include <ll/ll.h>
#include <kernel/model.h>
#include <kernel/types.h>
#include <kernel/iqueue.h>
#include <limits.h>
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
140,8 → 141,8
struct _task_handler_rec *cleanup_stack;
/*+ The cleanup stack +*/
QUEUE next,prev; /*+ Next/Prev Index in the queue +*/
int errnumber;
/* Job Execution Time fields */
174,8 → 175,7
* the generic kernel, with exclusion of delay_timer that is used
* also in cond_timedwait
*/
DWORD priority; /*+ A priority field +*/
struct timespec timespec_priority; /*+ Another priority field +*/
int delay_timer; /*+ A field useful to store the delay timer +*/
int wcet; /*+ a worst case time execution +*/
219,8 → 219,6
0 if the level can manage the model,
-1 if not +*/
// void (*level_init)(); /*+ initialization of the level module +*/
// void (*level_end)(); /*+ level termination (at system end... +*/
void (*level_status)(LEVEL l);/*+ print level statistics... +*/
PID (*level_scheduler)(LEVEL l);
286,9 → 284,6
task in the EXE state. +*/
void (*task_delay)(LEVEL l, PID p,DWORD tickdelay);
/* guest CALLS:
these functions are called from an Aperiodic Server Level for the task
that are inserted in the local queues */
324,7 → 319,6
/*+ the task is killed +*/
void (*guest_sleep)(LEVEL l, PID p);
void (*guest_delay)(LEVEL l, PID p, TIME tickdelay);
} level_des;
438,7 → 432,7
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
typedef struct condition_struct {
QUEUE waiters; /*+ queue for tasks waiting on the condition +*/
IQUEUE waiters; /*+ queue for tasks waiting on the condition +*/
mutex_t *used_for_waiting;
} cond_t;

/shark/tags/rel_0_2/include/kernel/types.h
21,11 → 21,11
/**
------------
CVS : $Id: types.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: types.h,v 1.2 2002-11-11 08:36:01 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: 2002-11-11 08:36:01 $
------------
**/
49,27 → 49,9
*
*/
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
HARTIK SYSTEM TYPES
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
#ifndef __KERNEL_TYPES_H__
#define __KERNEL_TYPES_H__
/*+ Used to manage task queues +*/
typedef int QUEUE;
/*+ Used to manage task queues with tail +*/
typedef struct {
int first; /*+ first element of a task queue, NIL if empty +*/
int last; /*+ last element of a task qqueue, NIL if empty +*/
} QQUEUE;
/*+ Used to manage mutex queues +*/
//typedef int MQUEUE;
#define TASK void *
/*+ ... a task index +*/

/shark/tags/rel_0_2/include/kernel/config.h
21,11 → 21,11
/**
------------
CVS : $Id: config.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: config.h,v 1.2 2002-11-11 08:36:01 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: 2002-11-11 08:36:01 $
------------
Kernel configuration macros:
57,28 → 57,6
#ifndef __KERNEL_CONFIG_H__
#define __KERNEL_CONFIG_H__
/*+ Define this if you use the CABs... +*/
#define __CAB__
/*+ Define this if you use the ports... +*/
#define __PORT__
/*+ Define this if you use the tracer... +*/
#define __TRACE__
//#undef __TRACE__
/*+ Define this if you want the printk messages... +*/
#define __DEBUG_ON__
#undef __DEBUG_ON__
/*+ checks the Memory at the kern_mem_init... +*/
#undef __MEM_DEBUG__
/*+ defined if we are compiling test1.c with init1.c +*/
//#define __TEST1__
/*+ defined if we are compiling testG.c +*/
//#define TESTG

/shark/tags/rel_0_2/include/kernel/var.h
21,11 → 21,11
/**
------------
CVS : $Id: var.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: var.h,v 1.2 2002-11-11 08:36:01 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: 2002-11-11 08:36:01 $
------------
Kernel global variables
70,7 → 70,7
extern PID exec; /*+ task suggested by the scheduler +*/
extern PID exec_shadow; /*+ task really executed +*/
extern QUEUE freedesc; /*+ Free descriptor handled as a queue +*/
extern IQUEUE freedesc; /*+ Free descriptor handled as a queue +*/
extern TIME sys_tick; /*+ System tick (in usec) +*/
extern struct timespec schedule_time;

/shark/tags/rel_0_2/include/trace/qudp.h
21,16 → 21,26
#ifndef __TRACE_QUDP_H
#define __TRACE_QUDP_H
#include <kernel/model.h>
#include <drivers/udpip.h>
typedef struct TAGtrc_udp_queue_args_t {
UDP_ADDR addr;
int size;
UDP_ADDR local,remote;
TASK_MODEL *model;
} TRC_UDP_PARMS;
#define trc_udp_default_parms(m)
#define trc_udp_default_parms(m,l,r) (m).size=8192, \
(m).model = NULL, \
(m).local = (l), \
(m).remote = (r);
#define trc_udp_def_addr(m,addr)
#define trc_udp_def_size(m,s) (m).size=(s)
#define trc_udp_def_local(m,l) (m).local=(l)
#define trc_udp_def_remote(m,r) (m).remote=(r)
#define trc_udp_def_model(m,mod) (m).model=(mod)
int trc_register_udp_queue(void);
#endif

/shark/tags/rel_0_2/include/trace/queues.h
38,11 → 38,11
*/
/*
* CVS : $Id: queues.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
* CVS : $Id: queues.h,v 1.3 2002-10-28 07:53:40 pj Exp $
*
* File: $File$
* Revision: $Revision: 1.1.1.1 $
* Last update: $Date: 2002-03-29 14:12:51 $
* Revision: $Revision: 1.3 $
* Last update: $Date: 2002-10-28 07:53:40 $
*/
#ifndef __TRACE_QUEUES_H
58,19 → 58,20
void *data;
} trc_queue_t;
#define TRC_DUMMY_QUEUE 0
#define TRC_DUMMY_QUEUE 0
#include <trace/qdummy.h>
#define TRC_FIXED_QUEUE 1
#define TRC_FIXED_QUEUE 1
#define TRC_DOSFS_FIXED_QUEUE 2
#include <trace/qfixed.h>
#define TRC_CIRCULAR_QUEUE 2
#define TRC_CIRCULAR_QUEUE 3
#include <trace/qcirc.h>
#define TRC_UDP_QUEUE 3
#define TRC_UDP_QUEUE 4
#include <trace/qudp.h>
#define TRC_QUEUETYPESNUMBER 4
#define TRC_QUEUETYPESNUMBER 5
/* uniq!=0 append a this unique number to name */
void trc_create_name(char *basename, int uniq, char *pathname);

/shark/tags/rel_0_2/include/trace/trace.h
38,11 → 38,11
*/
/*
* CVS : $Id: trace.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
* CVS : $Id: trace.h,v 1.2 2002-10-21 10:17:26 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: 2002-10-21 10:17:26 $
*/
#ifndef __TRACE_TRACE_H
68,6 → 68,8
/* -- */
/* Register a "standard" tracer configuration; requires FAT16 filesystem
(see documentation) */
int TRC_init_phase1_standard(void);
int TRC_init_phase2_standard(void);

/shark/tags/rel_0_2/include/trace/qfixed.h
31,7 → 31,12
#define trc_fixed_def_filename(m,s) (m).filename=(s)
#define trc_fixed_def_size(m,s) (m).size=(s)
/* Fixed queue, FAT16 filesystem (see kernel/modules/trcfixed.c) */
int trc_register_fixed_queue(void);
/* Fixed queue, DOSFS filesystem (see kernel/modules/trcdfix.c)
Note: You MUST specify a valid filename... */
int trc_register_dosfs_fixed_queue(void);
#endif

/shark/tags/rel_0_2/include/bits/errno.h
20,11 → 20,11
/**
------------
CVS : $Id: errno.h,v 1.1.1.1 2002-03-29 14:12:51 pj Exp $
CVS : $Id: errno.h,v 1.2 2002-10-28 07:53:00 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: 2002-10-28 07:53:00 $
------------
- error codes used as values for errno
105,10 → 105,10
#define LAST_EXC_NUMBER 19
#define XDOUBLE_EXCEPTION 1 /* in act_exc */
#define XUNVALID_KILL_SHADOW 2 /* task_makefree */
#define XINVALID_KILL_SHADOW 2 /* task_makefree */
#define XNOMORE_CLEANUPS 3 /* task_cleanup_push */
#define XUNVALID_TASK 4 /* invalid operation for a task */
#define XUNVALID_GUEST 5 /* invalid operation for a guest task */
#define XINVALID_TASK 4 /* invalid operation for a task */
#define 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 */
116,10 → 116,10
#define XACTIVATION 9 /* PERIODIC_PCLASS, SPORADIC_PCLASS */
#define XMUTEX_OWNER_KILLED 10 /* Mutex */
#define XSRP_UNVALID_LOCK 11 /* SRP */
#define XSRP_INVALID_LOCK 11 /* SRP */
#define XUNVALID_DUMMY_OP 12 /* dummy.h hope it will never called... */
#define XUNVALID_SS_REPLENISH 13 /* kernel/mosules/ss.c */
#define XINVALID_DUMMY_OP 12 /* dummy.h hope it will never called... */
#define XINVALID_SS_REPLENISH 13 /* kernel/mosules/ss.c */
#define XARP_TABLE_FULL 14 /* drivers/net/arp.c */
154,9 → 154,9
#define ENO_GUARANTEE (10 + LAST_STDERRNO) /* task_create */
#define ENO_AVAIL_STACK_MEM (11 + LAST_STDERRNO) /* task_create */
#define ENO_AVAIL_TSS (12 + LAST_STDERRNO) /* task_create */
#define EUNVALID_KILL (13 + LAST_STDERRNO) /* task_kill */
#define EUNVALID_TASK_ID (14 + LAST_STDERRNO) /* task_activate */
#define EUNVALID_GROUP (15 + LAST_STDERRNO) /* group_activate e group_kill */
#define EINVALID_KILL (13 + LAST_STDERRNO) /* task_kill */
#define EINVALID_TASK_ID (14 + LAST_STDERRNO) /* task_activate */
#define EINVALID_GROUP (15 + LAST_STDERRNO) /* group_activate e group_kill */
#define EPORT_NO_MORE_DESCR (16 + LAST_STDERRNO)
#define EPORT_NO_MORE_INTERF (17 + LAST_STDERRNO)
167,11 → 167,11
#define EPORT_UNSUPPORTED_ACC (22 + LAST_STDERRNO)
#define EPORT_WRONG_OP (23 + LAST_STDERRNO)
#define EPORT_WRONG_TYPE (24 + LAST_STDERRNO)
#define EPORT_UNVALID_DESCR (25 + LAST_STDERRNO)
#define EPORT_INVALID_DESCR (25 + LAST_STDERRNO)
#define ECAB_UNVALID_ID (26 + LAST_STDERRNO)
#define ECAB_INVALID_ID (26 + LAST_STDERRNO)
#define ECAB_CLOSED (27 + LAST_STDERRNO)
#define ECAB_UNVALID_MSG_NUM (28 + LAST_STDERRNO)
#define ECAB_INVALID_MSG_NUM (28 + LAST_STDERRNO)
#define ECAB_NO_MORE_ENTRY (29 + LAST_STDERRNO)
#define ECAB_TOO_MUCH_MSG (30 + LAST_STDERRNO)

/shark/tags/rel_0_2/include/drivers/parport.h
0,0 → 1,241
/*
* Project:
* Parallel Port S.Ha.R.K. Project
*
* Module:
* ppDrv.h
*
* Description:
* file contents description
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors:
* Andrea Battistotti <btandrea@libero.it>
* Armando Leggio <a_leggio@hotmail.com>
*
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*
*/
/* PPDrv.h
header file for par port communication...
*/
/*
* Copyright (C) 2002 Andrea Battistotti , Armando Leggio
*
* 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
*
* CVS : $Id: parport.h,v 1.1 2002-10-28 07:52:11 pj Exp $
*/
#include <kernel/kern.h>
#include <drivers/glib.h>
#include <drivers/keyb.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <kernel/func.h>
#include <string.h>
#include <ll/ll.h>
#include <kernel/types.h>
#include <kernel/descr.h>
#include <math.h>
/* general defs... */
#define PP_DEBUG 1 /* 1/0 Activate/Disactive internal debugs... */
#define PP_STATS 1 /* 1/0 Activate/Disactive internal statistics... */
/* return value... */
#define FALSE 0
#define TRUE 1
#define TIMEOUT 2
#define PP_BASE_ADR 0x0378 /* std addr for LPT1 */
#define BYTE unsigned char
#define BOOL unsigned char
#define BUF_IDX unsigned int
#define BUF_PNTR unsigned int
#define PIN_MASK unsigned int
#define clock() sys_gettime(NULL)
enum PIN_STATUS { PIN_OFF , PIN_ON } ; /* positive logic: off==0, on==1 */
/*********************************************************************************/
/* PART 1 : LOW LIVEL FUNC */
/* defs used in ppPinDrv....*/
/* for std & pin use of pp... */
#define PP_DATA_REG (PP_BASE_ADR+0) // address of data register
#define PP_STATUS_REG (PP_BASE_ADR+1) // address of status register
#define PP_CONTR_REG (PP_BASE_ADR+2) // address of control regist
/* out data pins... */
#define PP_PIN_D0 0x01 /* pin 2 */
#define PP_PIN_D1 0x02 /* pin 3 */
#define PP_PIN_D2 0x04 /* pin 4 */
#define PP_PIN_D3 0x08 /* pin 5 */
#define PP_PIN_D4 0x10 /* pin 6 */
#define PP_PIN_D5 0x20 /* pin 7 */
#define PP_PIN_D6 0x40 /* pin 8 */
#define PP_PIN_D7 0x80 /* pin 9 */
/* status pins... */
#define PP_PIN_ERROR 0x08 /* pin 15 */
#define PP_PIN_SELECTED 0x10 /* pin 13 */
#define PP_PIN_PAPEROUT 0x20 /* pin 12 */
#define PP_PIN_ACK 0x40 /* pin 10 */
#define PP_PIN_BUSY 0x80 /* pin 11 */
/* control pins... */
#define PP_PIN_DATASTROBE 0x01 /* pin 1 */
#define PP_PIN_AUTOFEED 0x02 /* pin 14 */
#define PP_PIN_INITOUT 0x04 /* pin 16 */
#define PP_PIN_SELECT 0x08 /* pin 17 */
/* Data i/o */
#define ppSetDataByte(a) outp(PP_DATA_REG,a)
#define ppReadDataByte() inp(PP_DATA_REG)
/* this is NOT bidirectional actually: simply read value that I myself wrote on parport early...*/
/* in std lpt you cannot lay down electric pin D0,D1,..D7 from extern and read value in pc...*/
/* this (in std lpt) will broke down lpt port!... */
/* there are obviously also bi-dir port on 8 bit (ECC & ECP) but ctrl & status pins have */
/* different meaning so we don't manage them... See docs. */
/* Data pins */
void ppSetDataPin(int state, PIN_MASK pin); /* in ppPinDrv.c */
#define ppSetPin_D0(a) ppSetDataPin(a,PP_PIN_D0) /* On ==1 , Off == 0 */
#define ppSetPin_D1(a) ppSetDataPin(a,PP_PIN_D1)
#define ppSetPin_D2(a) ppSetDataPin(a,PP_PIN_D2)
#define ppSetPin_D3(a) ppSetDataPin(a,PP_PIN_D3)
#define ppSetPin_D4(a) ppSetDataPin(a,PP_PIN_D4)
#define ppSetPin_D5(a) ppSetDataPin(a,PP_PIN_D5)
#define ppSetPin_D6(a) ppSetDataPin(a,PP_PIN_D6)
#define ppSetPin_D7(a) ppSetDataPin(a,PP_PIN_D7)
/* Status pins */
#define ppCheckPin_Error() (inp(PP_STATUS_REG & PP_PIN_ERROR)!=0?1:0)
#define ppCheckPin_Selected() (inp(PP_STATUS_REG & PP_PIN_SELECTED)!=0?1:0)
#define ppCheckPin_PaperOut() (inp(PP_STATUS_REG & PP_PIN_PAPEROUT)!=0?1:0)
#define ppCheckPin_Acknowledge() (inp(PP_STATUS_REG & PP_PIN_ACK)!=0?1:0)
#define ppCheckPin_Busy() (inp(PP_STATUS_REG & PP_PIN_BUSY)!=0?0:1) /* act low...*/
/* Control pins */
/* Control i/o */
#define ppSetCtrlByte(a) outp(PP_CONTR_REG,a)
#define ppReadCtrlByte() inp(PP_CONTR_REG)
/* idem...*/
void ppSetCtrlPin(int state, PIN_MASK pin); /* in ppPinDrv.c */
#define ppSetPin_DataStrobe(a) ppSetCtrlPin(!a,PP_PIN_DATASTROBE) /* low active...*/
#define ppSetPin_Autofeed(a) ppSetCtrlPin(!a,PP_PIN_AUTOFEED) /* low active...*/
#define ppSetPin_InitOut(a) ppSetCtrlPin(a,PP_PIN_INITOUT)
#define ppSetPin_Select(a) ppSetCtrlPin(!a,PP_PIN_SELECT) /* low active...*/
/*********************************************************************************/
/* PART 2 : DATA TRANSFER BETWEEN PC */
/* defs used in ppDrv & ppNRTDrv... */
#define PPDRV_PERIOD 1000 /* 300000 ok for debug...*/
#define PPDRV_WCET 150 /* lower bound: 120; more if debug & stats are on...*/
#define PP_BUF_LEN 1024 /* between 2^2 and 2^16 (64k) */
#define CLK_TIMEOUT 55000 /* timeout for sync pc-pc...*/
/* for laplink use of std pp... */
#define TX_PORT PP_BASE_ADR /* transmit port */
#define RX_PORT TX_PORT+1 /* receive port */
/* laplink bit mask */
#define TX_DATA 0x0F /* 0000 1111 pin 2,3,4,5 */
#define TX_CTR 0x10 /* 0001 0000 bit 4 port TX pin 6*/
#define RX_DATA 0x78 /* 0111 1000 pin 15,13,12,10 */
#define RX_CTR 0x80 /* 1000 0000 bit 7 port RX pin 11*/
#define LSN 0x0F /* 0000 1111 low significative nibble */
#define MSN 0xF0 /* 1111 0000 most significative nibble */
#define BYTE_CTR 0xAF /* 1010 1111 control char */
/* comm protocol */
#define ppSendRTS() ppSetOnPinTX_CTR()
#define ppIsRTS() ppReadIfPinRX_CTRIsOn()
#define ppSendOTS() ppSetOnPinTX_CTR()
#define ppIsOTS() ppReadIfPinRX_CTRIsOn()
#define ppSendDR() ppSetOffPinTX_CTR()
#define ppIsDR() ppReadIfPinRX_CTRIsOff()
#define ppSendER() ppSetOffPinTX_CTR()
#define ppIsER() ppReadIfPinRX_CTRIsOff()
#define ppSetOnPinTX_CTR() outp(TX_PORT,(inp(TX_PORT)|TX_CTR)) /* used by: ppSendRTS ppSendOTS */
#define ppSetOffPinTX_CTR() outp(TX_PORT,(inp(TX_PORT)&(~TX_CTR))) /* used by: ppSendDR ppSendER */
#define ppReadIfPinRX_CTRIsOn() ((((~inp(RX_PORT))&RX_CTR)==0)?FALSE:TRUE)
#define ppReadIfPinRX_CTRIsOff() (((BYTE)((~RX_CTR)|(~inp(RX_PORT)))==0x7F)?TRUE:FALSE)
/* Funct Return Code */
enum PP_COMM_RTR_CODE {
PP_COMM_OK,
PP_COMM_NOREADYBYTES_EXC,
PP_COMM_NOFREEBYTES_EXC
};
/* Funct Return Code */
enum PP_SYSMSG_RTR_CODE {
PP_SYSMSG_OK,
PP_NOSYSMSG_EXC,
PP_NOFREEMSG_EXC
};
/* NON REAL TIME (== BLOCK) functions...*/
/* from ppNRTDrv.c...*/
BOOL ppNRTOpenComm(void);
BOOL ppNRTWaitRTS(void);
BOOL ppNRTWaitDR(void);
BOOL ppNRTWaitOTS(void);
BOOL ppNRTWaitER(void);
BOOL ppNRTTxOneByte(BYTE c);
BOOL ppNRTRxOneByte(BYTE *c);
/* REAL TIME (== NON BLOCK) POLLING SERVER */
/* from ppDrv.c... */
void ppInitDrv(void (*pf)(char *)); /* NRT: to be called before start ppPollingSrv...*/
TASK ppPollingSvr(void *arg); /* periodic task to be started before any call to Rx/Tx...*/
/* input output function */
int ppRxOneByte(BYTE *c); /* retrive 1 byte */
int ppTxOneByte(BYTE c); /* send 1 byte */
int ppRxBytes(BYTE *c, unsigned int nbyte); /* retrive n byte... */
int ppTxBytes(BYTE *c, unsigned int nbyte); /* send n byte... */
/* System msg */
#define SYS_MSG_COLS 33
#define SYS_MSG_LINS 15
int ppReadSysMsg(char * buf);
int ppWriteSysMsg(char * buf, ...);

/shark/tags/rel_0_2/config/libdep.mk
151,6 → 151,11
LIB_DEP += $(LIB_PATH)/lib6025e.a
endif
# Parport
ifeq ($(LIB_PATH)/libpport.a,$(wildcard $(LIB_PATH)/libpport.a))
LINK_LIB += -lpport
LIB_DEP += $(LIB_PATH)/libpport.a
endif

/shark/tags/rel_0_2/config/hconf/hconf
File deleted
\ No newline at end of file

/shark/tags/rel_0_2/config/hconf/old/ppp
File deleted

/shark/tags/rel_0_2/config/hconf/old/shower.c
File deleted

/shark/tags/rel_0_2/lib/readme
0,0 → 1,0
This force directory existence

/shark/tags/rel_0_2/ports/fftw/makefile
1,12 → 1,6
.PHONY: all install clean cleanall depend
all install::
@echo
@echo These files have been ported to Hartik
@echo You have to expect some warnings!!!
@echo
all install clean cleanall depend::
make -C rfftw $@
make -C fftw $@

/shark/tags/rel_0_2/ports/mpg123/mpg123.h
1,4 → 1,3
#define exit l1_exit
/*
* mpg123 defines
* used source: musicout.h from mpegaudio package
5,6 → 4,7
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <math.h>

/shark/tags/rel_0_2/ports/makefile
1,5 → 1,5
dirs := $(filter-out CVS makefile, $(wildcard *))
dirs := $(filter-out CVS cvs makefile, $(wildcard *))
p_all := $(addprefix prefixall_, $(dirs))
p_install := $(addprefix prefixinstall_, $(dirs))
p_clean := $(addprefix prefixclean_, $(dirs))

/shark/tags/rel_0_2/fs/msdos/msdos_i.c
34,11 → 34,11
*/
/*
* CVS : $Id: msdos_i.c,v 1.1.1.1 2002-03-29 14:12:50 pj Exp $
* CVS : $Id: msdos_i.c,v 1.2 2002-10-28 08:24:43 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: 2002-10-28 08:24:43 $
*/
#include <fs/types.h>
58,7 → 58,7
*/
#define DEBUG_ADDCLUSTER KERN_DEBUG
#undef DEBUG_ADDCLUSTER KERN_DEBUG
#undef DEBUG_ADDCLUSTER
#define DEBUG_ADDCLUSTER_EXTRA KERN_DEBUG
#undef DEBUG_ADDCLUSTER_EXTRA

/shark/tags/rel_0_2/fs/fs.h
34,11 → 34,11
*/
/*
* CVS : $Id: fs.h,v 1.1.1.1 2002-03-29 14:12:50 pj Exp $
* CVS : $Id: fs.h,v 1.2 2002-11-11 08:40:44 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: 2002-11-11 08:40:44 $
*/
/***
51,6 → 51,7
#include <fs/types.h>
#include <fs/mount.h>
#include <time.h>
#include "mutex.h"
#include "semaph.h"
222,10 → 223,13
#ifdef SHUTDOWNTIMEOUT
{
int counter;
struct timespec delay;
delay.tv_sec=SHUTDOWNSLICE/1000000;
delay.tv_nsec=(SHUTDOWNSLICE%1000000)*1000;
counter=0;
while (counter<SHUTDOWNCOUNTER&&__fs_sem_trywait(&fssyssync)) {
counter++;
task_delay(SHUTDOWNSLICE);
nanosleep(&delay, NULL);
}
if (counter>=SHUTDOWNCOUNTER) {
printk(KERN_NOTICE "filesystem shutdown timeout... aborting!");

/shark/tags/rel_0_2/makefile
1,15 → 1,16
#
# Main HARTIK makefile
# Main S.Ha.R.K. makefile
#
ifndef BASE
BASE=.
endif
include $(BASE)/config/config.mk
#
.PHONY: install all clean cleanall depend test
.PHONY: install all clean cleanall depend
install all clean cleanall depend:
make -C oslib $@
18,21 → 19,3
make -C fs $@
make -C libc $@
make -C ports $@
test:
make -C examples $@
#
# some usefull hidden target (made by Paolo)
#
ifeq ($(SYSNAME),MS-DOS)
.PHONY: e
e:
dir /s *.err >errlist
list errlist
endif

/shark/tags/rel_0_2/drivers/net/ne.c
227,12 → 227,12
}
if (!pdev)
continue;
printk(KERN_INFO "ne.c: PCI BIOS reports %s at i/o %#x, irq %d.\n",
printk(KERN_INFO "ne.c: PCI BIOS reports %s at i/o %x, irq %d.\n",
pci_clone_list[i].name,
pci_ioaddr, pci_irq_line);
printk("*\n* Use of the PCI-NE2000 driver with this card is recommended!\n*\n");
if (ne_probe1(dev, pci_ioaddr) != 0) { /* Shouldn't happen. */
printk(KERN_ERR "ne.c: Probe of PCI card at %#x failed.\n", pci_ioaddr);
printk(KERN_ERR "ne.c: Probe of PCI card at %x failed.\n", pci_ioaddr);
pci_irq_line = 0;
return -ENXIO;
}
285,7 → 285,7
if (ei_debug && version_printed++ == 0)
printk(version);
printk(KERN_INFO "NE*000 ethercard probe at %#3x:", ioaddr);
printk(KERN_INFO "NE*000 ethercard probe at %3x:", ioaddr);
/* A user with a poor card that fails to ack the reset, or that
does not have a valid 0x57,0x57 signature can still use this
473,7 → 473,7
dev->dev_addr[i] = SA_prom[i];
}
printk("\n%s: %s found at %#x, using IRQ %d.\n",
printk("\n%s: %s found at %x, using IRQ %d.\n",
dev->name, name, ioaddr, dev->irq);
ei_status.name = name;
638,7 → 638,7
} while (--tries > 0);
if (tries <= 0)
printk(KERN_WARNING "%s: RX transfer address mismatch,"
"%#4.4x (expected) vs. %#4.4x (actual).\n",
"%4.4x (expected) vs. %4.4x (actual).\n",
dev->name, ring_offset + xfer_count, addr);
}
#endif

/shark/tags/rel_0_2/drivers/net/eth.c
20,11 → 20,11
/**
------------
CVS : $Id: eth.c,v 1.1.1.1 2002-03-29 14:12:50 pj Exp $
CVS : $Id: eth.c,v 1.3 2002-11-11 08:41:31 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-03-29 14:12:50 $
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:41:31 $
------------
**/
74,6 → 74,8
/*#include "lowlev.h"
//#include "3com.h" */
//#define DEBUG_ETH
#define ETH_PAGE 5
struct eth_service{
131,7 → 133,7
void dev_tint(struct device *dev)
{
cprintf("Warning!!!! dev_tint called!!! (Why???)\n");
printk(KERN_WARNING "Warning!!!! dev_tint called!!! (Why?)\n");
sys_abort(201);
}
145,7 → 147,7
{
//cprintf("DENTRO netif_rx, skbuf=%p\n",skb->data);
if (nettask_pid == NIL) {
cprintf("Net receives packets, but the driver doesn't exist!!!\n");
printk(KERN_CRIT "Net receives packets, but the driver doesn't exist!!!\n");
sys_abort(300);
}
200,7 → 202,7
/* formatted print of an ethernet header */
void eth_printHeader(struct eth_header *p)
{
cprintf("Dest : %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x \n",p->dest.ad[0],
cprintf("Dest : %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x \n",p->dest.ad[0],
p->dest.ad[1],
p->dest.ad[2],
p->dest.ad[3],
338,27 → 340,27
{
int p;
if (err != ETH_BUFFERS_FULL) cprintf("Ethernet : ");
if (err != ETH_BUFFERS_FULL) printk(KERN_ERR "Ethernet : ");
switch (err) {
case ETH_DRIVER_NOT_FOUND :
cprintf("NET PANIC --> Etherlink not found.\n");
printk(KERN_ERR "NET PANIC --> Etherlink not found.\n");
return 0;
case ETH_RXERROR :
cprintf("Receive error (vero dramma!!!).\n");
printk(KERN_ERR "Receive error (vero dramma!!!).\n");
return 0;
case ETH_TXERROR :
cprintf("Transimit error: N. Max Retry.\n");
printk(KERN_ERR "Transimit error: N. Max Retry.\n");
return 0;
case ETH_PROTOCOL_ERROR :
cprintf("Too much protocols.\n");
printk(KERN_ERR "Too much protocols.\n");
return 0;
case ETH_BUFFERS_FULL:
cprintf("Buffers full: frame lost!\n");
printk(KERN_ERR "Buffers full: frame lost!\n");
return 1;
case ETH_NULLPROTOCOL_EXC:
cprintf("Null protocol called!!!\n");
printk(KERN_ERR "Null protocol called!!!\n");
for (p = 0; p < ETH_MAX_PROTOCOLS; p++) {
cprintf("%d: %d\n", p, eth_table[p].type);
printk(KERN_ERR "%d: %d\n", p, eth_table[p].type);
}
return 0;
default :
377,7 → 379,7
int linux_found = 0;
if (!ethIsInstalled) {
cprintf(" Hartik Net lib\n\n");
printk(KERN_INFO "Hartik/Shark Net lib");
/* Scan the devices connected to the PCI bus */
cardtype = NONE;
391,24 → 393,30
soft_task_def_aperiodic(m_soft);
soft_task_def_system(m_soft);
soft_task_def_nokill(m_soft);
m = &m_soft;
m = (TASK_MODEL *)&m_soft;
}
nettask_pid = task_create("rxProc", net_extern_driver, m, NULL);
if (nettask_pid == NIL) {
cprintf("Can't create extern driver!!!\n");
return 0;
printk(KERN_ERR "Can't create extern driver!!!\n");
return 0;
}
task_activate(nettask_pid);
if (pci_init() == 1) {
linuxpci_init();
// pci_show();
cprintf("LF %d\n", linux_found);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
linux_found += (rtl8139_probe(&device0) == 0);
cprintf("LF %d\n", linux_found);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
linux_found += (tc59x_probe(&device0) == 0);
cprintf("LF %d\n", linux_found);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
#if 0
ndev = pci_scan_bus(pci_devs);
#ifdef __ETH_DBG__
434,7 → 442,7
} else {
lowlev_send = vortex_send_mem;
}
cprintf("PCI Ethlink card found:\n");
printk(KERN_INFO "PCI Ethlink card found:\n");
lowlev_info(r);
cardtype = VORTEX;
}
460,10 → 468,14
#else
}
if (linux_found == 0) {
linux_found += (el3_probe(&device0) == 0);
cprintf("LF %d\n", linux_found);
linux_found += (ne_probe(&device0) == 0);
cprintf("LF %d\n", linux_found);
linux_found += (el3_probe(&device0) == 0);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
linux_found += (ne_probe(&device0) == 0);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
}
/*
474,9 → 486,9
*/
if (linux_found) {
device0.open(&device0);
cprintf("Net card found!!!\n");
printk(KERN_INFO "Net card found!!!\n");
} else {
cprintf("No card found... \n");
printk(KERN_INFO "No card found... \n");
/* cprintf("No card found... Installing loopback device\n");
loopback_init(&device0);
device0.open(&device0);*/
497,7 → 509,7
sys_atrunlevel(eth_close,NULL,RUNLEVEL_BEFORE_EXIT);
} else {
cprintf("Ethernet already installed!!!\n");
printk(KERN_INFO "Ethernet already installed!!!\n");
return 0;
}
return 1;
505,10 → 517,12
void eth_close(void *a)
{
kern_printf("CLOSE!!!!\n");
if (ethIsInstalled == TRUE) {
device0.stop(&device0); /*This seems to break everithing...
// lowlev_close(eth_dev.BaseAddress);*/
ethIsInstalled = FALSE;
}
#ifdef DEBUG_ETH
printk(KERN_DEBUG "CLOSE!!!!\n");
#endif
if (ethIsInstalled == TRUE) {
device0.stop(&device0); /*This seems to break everithing...
// lowlev_close(eth_dev.BaseAddress);*/
ethIsInstalled = FALSE;
}
}

/shark/tags/rel_0_2/drivers/net/net.c
20,11 → 20,11
/**
------------
CVS : $Id: net.c,v 1.1.1.1 2002-03-29 14:12:50 pj Exp $
CVS : $Id: net.c,v 1.2 2002-10-28 08:01:36 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: 2002-10-28 08:01:36 $
------------
**/
63,6 → 63,8
#include <drivers/net.h>
#include "eth_priv.h"
//#define DEBUG_NET
/* OKKIO!!!!! net_base must change if you change NET_MAX_PROTOCOLS!!!! */
struct net_model net_base = {0, 0, {NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
88,8 → 90,10
}
/* Then, the high level layers */
for(i = 0; i < m->numprotocol; i++) {
cprintf("Protocol %d init \n", i);
m->protocol[i].initfun(m->protocol[i].initparms);
#ifdef DEBUG_NET
printk(KERN_DEBUG "Protocol %d init \n", i);
#endif
m->protocol[i].initfun(m->protocol[i].initparms);
}
return 1;

/shark/tags/rel_0_2/drivers/parport/ppnrtdrv.c
0,0 → 1,295
/*
*
* Project:
* Parallel Port S.Ha.R.K. Project
*
* Module:
* ppNRTDrv.c
*
* Description:
* file contents description
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors:
* Andrea Battistotti <btandrea@libero.it>
* Armando Leggio <a_leggio@hotmail.com>
*
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*
*/
/*************************************************************************
* Module : ppNRTDrv.c
* Author : Andrea Battistotti , Armando Leggio
* Description: Set On/Off single pin of LPT1...
* 2002 @ Pavia - GNU Copyrights
*******************************************************************************************/
/*
* Copyright (C) 2002 Andrea Battistotti , Armando Leggio
*
* 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
*
* CVS : $Id: ppnrtdrv.c,v 1.1 2002-10-28 08:03:54 pj Exp $
*/
/*******************************************************************************************
* A standard PC provides for three printer ports, at the following base addresses:
*
* LPT1 = 0x0378 or 0x03BC
* LPT2 = 0x0278 or 0x0378
* LPT3 = 0x0278
*
* This module assumes that LPT1 is at 0x0378.
*
* The printer port has three 8-bit registers:
*
* Data Register (base + 0) ........ outputs
*
* 7 6 5 4 3 2 1 0
* . . . . . . . * D0 ........... (pin 2), 1=High, 0=Low (true)
* . . . . . . * . D1 ........... (pin 3), 1=High, 0=Low (true)
* . . . . . * . . D2 ........... (pin 4), 1=High, 0=Low (true)
* . . . . * . . . D3 ........... (pin 5), 1=High, 0=Low (true)
* . . . * . . . . D4 ........... (pin 6), 1=High, 0=Low (true)
* . . * . . . . . D5 ........... (pin 7), 1=High, 0=Low (true)
* . * . . . . . . D6 ........... (pin 8), 1=High, 0=Low (true)
* * . . . . . . . D7 ........... (pin 9), 1=High, 0=Low (true)
*
* Status Register (base + 1) ...... inputs
*
* 7 6 5 4 3 2 1 0
* . . . . . * * * Undefined
* . . . . * . . . Error ........ (pin 15), high=1, low=0 (true)
* . . . * . . . . Selected ..... (pin 13), high=1, low=0 (true)
* . . * . . . . . No paper ..... (pin 12), high=1, low=0 (true)
* . * . . . . . . Ack .......... (pin 10), high=1, low=0 (true)
* * . . . . . . . Busy ......... (pin 11), high=0, low=1 (inverted)
*
* Control Register (base + 2) ..... outputs
*
* 7 6 5 4 3 2 1 0
* . . . . . . . * Strobe ....... (pin 1), 1=low, 0=high (inverted)
* . . . . . . * . Auto Feed .... (pin 14), 1=low, 0=high (inverted)
* . . . . . * . . Initialize ... (pin 16), 1=high, 0=low (true)
* . . . . * . . . Select ....... (pin 17), 1=low, 0=high (inverted)
* * * * * . . . . Unused
*
* Pins 18-25 are ground.
********************************************************************************************/
#include <drivers/parport.h>
/*************************************************************************/
BOOL ppNRTWaitRTS(void)
{
BYTE port;
TIME start = clock();
do
{
port = ~inp(RX_PORT); /* port status */
port = port & RX_CTR; /* test cntr read bit*/
if(clock() > start + CLK_TIMEOUT) return TIMEOUT;
} while(port == 0);
return TRUE;
}
/*************************************************************************/
BOOL ppNRTWaitDR(void)
{
BYTE port;
TIME start = clock(); /* start */
do {
port = (~inp(RX_PORT)) | (~RX_CTR); /* test cntr read bit*/
if(clock() > start + CLK_TIMEOUT) return TIMEOUT;
} while(port != 0x7F); /* 0111 1111 */
return TRUE;
}
/*************************************************************************/
BOOL ppNRTWaitOTS(void)
{
BYTE port;
TIME start = clock(); /* start time */
do
{
port = ~inp(RX_PORT); /* read port status */
port = port & RX_CTR; /* test cntr read bit*/
if(clock() > start + CLK_TIMEOUT) return TIMEOUT;
} while(port == 0);
return TRUE;
}
/*************************************************************************/
BOOL ppNRTWaitER(void)
{
BYTE port;
TIME start = clock(); /* start */
do
{
port = ~inp(RX_PORT); /* read port status */
port = port | (~RX_CTR); /* test cntr read bit*/
if(clock() > start + CLK_TIMEOUT) return TIMEOUT;
} while(port != 0x7F); /* 0111 1111 */
return TRUE;
}
/**************************************************************************/
BOOL ppNRTTxOneByte(BYTE c)
{
BYTE port;
/*------------------------- Least Significative Nibble */
ppSendRTS(); /* Request To Send */
port = inp(TX_PORT); /* read port status */
port = port & (~TX_DATA); /* set tx bits == 0 */
port = port | (c & LSN); /* set bit 0..3 with LSN */
#if PP_DEBUG == 1
kern_printf("ppNRTTxOneByte: SendRTS, before WaitOTS\n");
#endif
if(ppNRTWaitOTS()!=TRUE) return TIMEOUT;
outp(TX_PORT,port);
ppSendDR(); /* Data Ready */
#if PP_DEBUG == 1
kern_printf("ppNRTTxOneByte: SendDR, before WaitER\n");
#endif
if(ppNRTWaitER() !=TRUE) return TIMEOUT;
/*------------------------- More Significative Nibble */
ppSendRTS(); /* Request To Send */
port = inp(TX_PORT); /* read port status */
port = port & (~TX_DATA); /* set off trasmission bits... */
port = port | (c >> 4); /* set bit 0..3 with MSN */
#if PP_DEBUG == 1
kern_printf("ppNRTTxOneByte: SendRTS, before WaitOTS\n");
#endif
if(ppNRTWaitOTS()!=TRUE) return TIMEOUT;
outp(TX_PORT,port); /* send data nibble... */
ppSendDR(); /* Data Ready */
#if PP_DEBUG == 1
kern_printf("ppNRTTxOneByte: SendDR, before WaitER\n");
#endif
if(ppNRTWaitER() !=TRUE) return TIMEOUT;
return TRUE;
}
/**************************************************************************/
BOOL ppNRTRxOneByte(BYTE *c)
{
BYTE port;
if(ppIsRTS() == FALSE) return FALSE;
ppSendOTS(); /* Ok To Send */
#if PP_DEBUG == 1
kern_printf("ppNRTRxOneByte: IsRTS, SendOTS, before WaitDR\n");
#endif
if(ppNRTWaitDR() != TRUE) return TIMEOUT;
port = inp(RX_PORT); /* read nibble */
ppSendER(); /* End Read */
*c = (port >> 3); /* read LSN */
#if PP_DEBUG == 1
kern_printf("ppNRTRxOneByte: SendER, before WaitRTS\n");
#endif
if(ppNRTWaitRTS() != TRUE) return TIMEOUT;
ppSendOTS();
#if PP_DEBUG == 1
kern_printf("ppNRTRxOneByte: SendOTS, before WaitDR\n");
#endif
if(ppNRTWaitDR() != TRUE) return TIMEOUT;
#if PP_DEBUG == 1
kern_printf("ppNRTRxOneByte: DR received, send ER\n");
#endif
port = inp(RX_PORT); /* read nibble */
ppSendER(); /* End Read */
*c = (*c & ~MSN); /* set 0 c MSN nibble... */
*c = (*c | ((port >> 3) << 4)); /* read MSN */
return TRUE;
}
/*************************************************************************
------------------------------------------------------------------------*/
BOOL ppNRTOpenComm(void)
{
BYTE c,port,rx,tx;
TIME start = clock();
outp(TX_PORT,0);
outp(TX_CTR,0);
do
{
port = inp(RX_PORT); /* read nibble */
/* x4321x xx */
c = (port >> 3); /* xxxx 4321 */
c = c & 0xF; /* 0000 4321 */
if(clock() > start + CLK_TIMEOUT*20) return TIMEOUT;
} while (c != 0); /* test nibble 4321 == 0000 */
/* the other also is laying down his TX_PORT (==my RX_PORT...) */
rx = FALSE; tx = FALSE; start = clock();
do /* try if it also on line... */
{
if((rx == FALSE) && (ppNRTRxOneByte(&c)==TRUE) && (c == BYTE_CTR)) rx = TRUE;
if((tx == FALSE) && (ppNRTTxOneByte(BYTE_CTR) == TRUE)) tx = TRUE;
if(clock() > start + CLK_TIMEOUT*20) return TIMEOUT;
} while(tx==FALSE || rx==FALSE);
ppSendER();
ppNRTWaitER();
return TRUE;
}

/shark/tags/rel_0_2/drivers/parport/pppindrv.c
0,0 → 1,127
/*
*
* Project:
* Parallel Port S.Ha.R.K. Project
*
* Module:
* ppPinDrv.c
*
* Description:
* file contents description
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors:
* Andrea Battistotti <btandrea@libero.it>
* Armando Leggio <a_leggio@hotmail.com>
*
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*
*/
/*******************************************************************************************
* Module : ppPinDrv.c
* Author : Andrea Battistotti , Armando Leggio
* Description: Set On/Off single pin of LPT1...
* 2002 @ Pavia - GNU Copyrights
*******************************************************************************************/
/*
* Copyright (C) 2002 Andrea Battistotti , Armando Leggio
*
* 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
*
* CVS : $Id: pppindrv.c,v 1.1 2002-10-28 08:03:55 pj Exp $
*/
/*******************************************************************************************
* A standard PC provides for three printer ports, at the following base addresses:
*
* LPT1 = 0x0378 or 0x03BC
* LPT2 = 0x0278 or 0x0378
* LPT3 = 0x0278
*
* This module assumes that LPT1 is at 0x0378.
*
* The printer port has three 8-bit registers:
*
* Data Register (base + 0) ........ outputs
*
* 7 6 5 4 3 2 1 0
* . . . . . . . * D0 ........... (pin 2), 1=High, 0=Low (true)
* . . . . . . * . D1 ........... (pin 3), 1=High, 0=Low (true)
* . . . . . * . . D2 ........... (pin 4), 1=High, 0=Low (true)
* . . . . * . . . D3 ........... (pin 5), 1=High, 0=Low (true)
* . . . * . . . . D4 ........... (pin 6), 1=High, 0=Low (true)
* . . * . . . . . D5 ........... (pin 7), 1=High, 0=Low (true)
* . * . . . . . . D6 ........... (pin 8), 1=High, 0=Low (true)
* * . . . . . . . D7 ........... (pin 9), 1=High, 0=Low (true)
*
* Status Register (base + 1) ...... inputs
*
* 7 6 5 4 3 2 1 0
* . . . . . * * * Undefined
* . . . . * . . . Error ........ (pin 15), high=1, low=0 (true)
* . . . * . . . . Selected ..... (pin 13), high=1, low=0 (true)
* . . * . . . . . No paper ..... (pin 12), high=1, low=0 (true)
* . * . . . . . . Ack .......... (pin 10), high=1, low=0 (true)
* * . . . . . . . Busy ......... (pin 11), high=0, low=1 (inverted)
*
* Control Register (base + 2) ..... outputs
*
* 7 6 5 4 3 2 1 0
* . . . . . . . * Strobe ....... (pin 1), 1=low, 0=high (inverted)
* . . . . . . * . Auto Feed .... (pin 14), 1=low, 0=high (inverted)
* . . . . . * . . Initialize ... (pin 16), 1=high, 0=low (true)
* . . . . * . . . Select ....... (pin 17), 1=low, 0=high (inverted)
* * * * * . . . . Unused
*
* Pins 18-25 are ground.
********************************************************************************************/
#include <drivers/parport.h>
void ppSetDataPin(int state, PIN_MASK pin)
{
BYTE port;
port=ppReadDataByte();
switch (state)
{
case PIN_OFF: port &= ~pin;
case PIN_ON: port |= pin;
}
ppSetDataByte(port);
}
void ppSetCtrlPin(int state, PIN_MASK pin)
{
BYTE port;
port=ppReadCtrlByte();
switch (state)
{
case PIN_OFF: port &= ~pin;
case PIN_ON: port |= pin;
}
ppSetCtrlByte(port);
}

/shark/tags/rel_0_2/drivers/parport/ppdrv.c
0,0 → 1,543
/*
* Project:
* Parallel Port S.Ha.R.K. Project
*
* Module:
* ppDrv.c
*
* Description:
* file contents description
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors:
* Andrea Battistotti <btandrea@libero.it>
* Armando Leggio <a_leggio@hotmail.com>
*
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*
*/
/**********************************************************************************************************
* Module : ppDrv.c Author : Andrea Battistotti , Armando Leggio
* Description: Tranfer Byte via LPT1 laplink cable... 2002 @ Pavia -
* GNU Copyrights */
/*
* Copyright (C) 2002 Andrea Battistotti , Armando Leggio
*
* 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
*
* CVS : $Id: ppdrv.c,v 1.1 2002-10-28 08:03:54 pj Exp $
*/
#include <drivers/parport.h>
/* internal */
BYTE RxBuf[PP_BUF_LEN]; /* Received bytes buffer */
BYTE TxBuf[PP_BUF_LEN]; /* To transmit bytes buffer */
unsigned int nextByteReadyToRx; /* pointer to first byte to read by ppOneByteRx(BYTE *c) ... */
unsigned int nextByteReadyToTx; /* when ppbTransmit had to send a byte, send this...*/
unsigned int nextByteFreeRx; /* when polling complete reading a byte, will save it in this loc...*/
unsigned int nextByteFreeTx; /* when ppbTransmit had to write a byte, write it here...*/
/* define inline macro */
/* these are for cicle buffer mamagement */
#define RxPointerGap (nextByteFreeRx-nextByteReadyToRx)
#define bytesReadyToRx ((RxPointerGap)>=0? (RxPointerGap):PP_BUF_LEN+(RxPointerGap))
#define TxPointerGap (nextByteFreeTx-nextByteReadyToTx)
#define bytesReadyToTx ((TxPointerGap)>=0? (TxPointerGap):PP_BUF_LEN+(TxPointerGap))
#define freeBytesInRxBuffer (PP_BUF_LEN-bytesReadyToRx)
#define freeBytesInTxBuffer (PP_BUF_LEN-bytesReadyToTx)
/* for pp sys msg */
char SysMsg[SYS_MSG_COLS+1][SYS_MSG_LINS+1]; /* space for sys msgs... */
char bufMsg[SYS_MSG_COLS+1]; /* to build msgs... */
unsigned int nextMsgToRead;
unsigned int nextMsgFreeToWrite;
/* define inline macro */
/* these are for cicle buffer mamagement */
#define msgPointerGap (nextMsgFreeToWrite-nextMsgToRead)
#define msgReadyToRead ((msgPointerGap)>=0? (msgPointerGap):SYS_MSG_LINS+(msgPointerGap))
#define freeMsgInBuffer (SYS_MSG_LINS-msgReadyToRead)
/* status ... */
enum ppReadingAvailableStates
{
ppNoAllowReading, /* writing is on...*/
ppNoReading,
ppWaitingDR_Nibble1,
ppWaitingRTS_Nibble2,
ppWaitingDR_Nibble2,
};
enum ppWritingAvailableStates
{
ppNoAllowWriting, /* reading is on...*/
ppNoWriting,
ppWaitingOTS_Nibble1,
ppWaitingER_Nibble1,
ppWaitingOTS_Nibble2,
ppWaitingER_Nibble2
};
int ppStatusReading;
int ppStatusWriting;
BYTE ppReceivingByte;
BYTE ppTransmittingByte;
#if PP_STATS == 1
/* for internal statistic ...if activate...*/
long statReading[ppWaitingDR_Nibble2+1];
long statWriting[ppWaitingER_Nibble2+1];
#endif
/*********************************************/
/* sys msg managment */
/*********************************************/
int ppReadSysMsg(char * buf)
{
if (!msgReadyToRead) /* there is nothing to read...*/
{
return (PP_NOSYSMSG_EXC);
}
else
{int i=0;
while (i<SYS_MSG_COLS && SysMsg[nextMsgToRead][i]) /* !='\0'...*/
*buf++=SysMsg[nextMsgToRead][i++]; /* read char */
*buf='\0';
nextMsgToRead=++nextMsgToRead%SYS_MSG_LINS; /* circular buffer increment */
return (PP_SYSMSG_OK);
}
}
int ppWriteSysMsg(char * buf, ...)
{
char * pbufMsg=bufMsg;
va_list args;
bufMsg[0]='\0';
va_start(args, buf);
vsprintf(bufMsg,buf,args); /* Not garatee msg len... */
va_end(args);
if (freeMsgInBuffer < 1)
{
return (PP_NOFREEMSG_EXC);
}
else
{int i=0;
while ((i<SYS_MSG_COLS) && (*pbufMsg) ) /* !='\0'...*/
SysMsg[nextMsgFreeToWrite][i++]=*pbufMsg++;
SysMsg[nextMsgFreeToWrite][i-1]='\n';
SysMsg[nextMsgFreeToWrite][i]='\0';
nextMsgFreeToWrite=++nextMsgFreeToWrite%SYS_MSG_LINS; /* circular buffer pointer increment */
return (PP_SYSMSG_OK);
}
}
/******************************************/
/* Inizialization: this is NRT task... */
/******************************************/
void ppInitDrv(void (*pf)(char *))
{
/* set to zero all pointer & buffer & status... */
while(ppNRTOpenComm()!=TRUE) // not real-time....
{
if (pf!=NULL) (*pf)("Waiting Open Communcation...\n");
ppSendER();
}
if (pf!=NULL) (*pf)("Open Communcation OK!\n");
}
/******************************************/
/* TX RX funtions... */
/******************************************/
int ppRxOneByte(BYTE *c)
{
if (!bytesReadyToRx) /* there is nothing to read...*/
{
return (PP_COMM_NOREADYBYTES_EXC);
}
else
{
*c=RxBuf[nextByteReadyToRx]; /* read byte */
nextByteReadyToRx=++nextByteReadyToRx%PP_BUF_LEN; /* circular buffer increment */
return (PP_COMM_OK);
}
}
int ppTxOneByte(BYTE c)
{
if (freeBytesInTxBuffer < 1)
{
return (PP_COMM_NOFREEBYTES_EXC);
}
else
{
TxBuf[nextByteFreeTx]=c;
nextByteFreeTx=++nextByteFreeTx%PP_BUF_LEN; /* circular buffer pointer increment */
return (PP_COMM_OK);
}
}
int ppTxBytes(BYTE * c, unsigned int nbyte)
{
if (freeBytesInTxBuffer<nbyte) /* if there are less than nbyte return nothing...*/
{
return (PP_COMM_NOFREEBYTES_EXC);
}
else
{ unsigned int i;
for (i=0;i<nbyte;i++)
{
TxBuf[nextByteFreeTx]=*c++;
nextByteFreeTx=++nextByteFreeTx%PP_BUF_LEN; /* circular buffer pointer increment */
}
return (PP_COMM_OK);
}
}
int ppRxBytes(BYTE * c, unsigned int nbyte)
{
if (bytesReadyToRx<nbyte) /* if there are less than nbyte return nothing...*/
{
return (PP_COMM_NOREADYBYTES_EXC);
}
else
{ unsigned int i;
for (i=0;i<nbyte;i++)
{
*c++=RxBuf[nextByteReadyToRx]; /* read byte */
#if PP_DEBUG == 1
ppWriteSysMsg("Received value: %i %i of %i \n",RxBuf[nextByteReadyToRx],i,nbyte);
#endif
nextByteReadyToRx=++nextByteReadyToRx%PP_BUF_LEN; /* circular buffer increment */
}
return (PP_COMM_OK);
}
}
/* polling server ... */
TASK ppPollingSvr(void *arg)
{
BYTE port;
nextByteReadyToRx=0;
nextByteReadyToTx=0;
nextByteFreeRx=0;
nextByteFreeTx=0;
nextMsgToRead=0;
nextMsgFreeToWrite=0;
ppStatusReading=ppNoReading;
ppStatusWriting=ppNoWriting;
ppWriteSysMsg("Polling Server started...\n");
task_endcycle();
while (1)
{
/* case ppReading: read ... */
switch (ppStatusReading)
{
case ppNoAllowReading: break;
case ppNoReading:
ppStatusWriting=ppNoWriting;
if(!ppIsRTS()) break;
ppSendOTS(); /* Set Ok To Send - the other one can send... */
#if PP_DEBUG == 1
ppWriteSysMsg(" %i : Received RTS...\n", ppStatusReading);
#endif
ppStatusWriting=ppNoAllowWriting;
ppStatusReading=ppWaitingDR_Nibble1;
case ppWaitingDR_Nibble1:
#if PP_STATS == 1 /* for internal statistic ...*/
statReading[ppStatusReading]++;
#endif
#if PP_DEBUG == 1
ppWriteSysMsg("Send OTS\n");
ppWriteSysMsg("Waiting DR Nibble1\n");
#endif
if(!ppIsDR()) break; /* data no ready: read it next period...*/
port = inp(RX_PORT); /* read nibble */
ppSendER(); /* send a End Read */
ppReceivingByte = (port >> 3); /* read LSN */
ppStatusReading=ppWaitingRTS_Nibble2;
case ppWaitingRTS_Nibble2:
#if PP_STATS == 1 /* for internal statistic ...*/
statReading[ppStatusReading]++;
#endif
#if PP_DEBUG == 1
ppWriteSysMsg("Received DR Nibble1\n");
ppWriteSysMsg("Send ER Nibble1\n");
ppWriteSysMsg("Waiting RTS Nibble2\n");
#endif
if(!ppIsRTS()) break; /* */
ppSendOTS(); /* Ok To Send - the other one can send... */
ppStatusReading=ppWaitingDR_Nibble2;
case ppWaitingDR_Nibble2:
#if PP_STATS == 1 /* for internal statistic ...*/
statReading[ppStatusReading]++;
#endif
#if PP_DEBUG == 1
ppWriteSysMsg("Received RTS Nibble2\n");
ppWriteSysMsg("Send OTS Nibble2\n");
ppWriteSysMsg("Waiting DR Nibble2\n");
#endif
if(!ppIsDR()) break;
port = inp(RX_PORT); /* read nibble */
ppSendER(); /* send a End Read */
#if PP_DEBUG == 1
ppWriteSysMsg("Received DR Nibble2\n");
ppWriteSysMsg("Read Nibble2\n");
ppWriteSysMsg("Send ER Nibble2\n");
#endif
ppReceivingByte = (ppReceivingByte & ~MSN); /* set to zero c MSN */
ppReceivingByte = (ppReceivingByte | ((port >> 3) << 4)); /* read MSN */
/* here is possible insert some ctrl ... */
/* byte is ok, so now make it available to ppRxOneByte() */
RxBuf[nextByteFreeRx]=ppReceivingByte;
nextByteFreeRx=++nextByteFreeRx%PP_BUF_LEN; /* circular buffer pointer increment */
#if PP_STATS == 1
ppWriteSysMsg("Trasmission :\n");
ppWriteSysMsg("W_DR_1 : %d\n",statReading[ppWaitingDR_Nibble1]);
ppWriteSysMsg("W_RTS_2 : %d\n",statReading[ppWaitingRTS_Nibble2]);
ppWriteSysMsg("W_DR_2 : %d\n",statReading[ppWaitingDR_Nibble2]);
ppWriteSysMsg("Received byte : %i\n",ppReceivingByte);
statReading[ppWaitingDR_Nibble1]=0;
statReading[ppWaitingRTS_Nibble2]=0;
statReading[ppWaitingDR_Nibble2]=0;
#endif
/* end reading so reset status... */
ppStatusReading=ppNoReading;
//ppStatusWriting=ppNoWriting;
break;
}
/* case Writing: can only if this cycle not is reading... */
switch (ppStatusWriting)
{
case ppNoAllowWriting: break;
case ppNoWriting:
ppStatusReading=ppNoReading;
if(!bytesReadyToTx)
{
break;
#if PP_DEBUG == 1
ppWriteSysMsg("Writin break\n");
#endif
}
else
{
#if PP_DEBUG == 1
ppWriteSysMsg("NO Writin break\n");
ppWriteSysMsg("TX Gap: %i \n",TxPointerGap);
ppWriteSysMsg("nextByteFreeTx: %i\n",nextByteFreeTx);
ppWriteSysMsg("nextByteReadyToTx: %i\n",nextByteReadyToTx);
#endif
}
ppSendRTS(); /* Set On RequestToSend bit */
ppTransmittingByte=TxBuf[nextByteReadyToTx];
#if PP_DEBUG == 1
ppWriteSysMsg("pllsvr: ppTransmittingByte : %i %c \n",ppTransmittingByte,ppTransmittingByte);
#endif
port = inp(TX_PORT) & (~TX_DATA); /* set to zero trasmission bits */
port = port | (ppTransmittingByte & LSN); /* set bits 0..3 with LSN */
ppStatusWriting=ppWaitingOTS_Nibble1;
ppStatusReading=ppNoAllowWriting;
case ppWaitingOTS_Nibble1:
#if PP_STATS == 1
statWriting[ppStatusWriting]++;
#endif
#if PP_DEBUG == 1
ppWriteSysMsg(" Send RTS Nibble1\n");
ppWriteSysMsg(" Waiting OTS Nibble1\n");
#endif
if(!ppIsOTS()) break;
outp(TX_PORT,port); /* send nibble 1 */
ppSendDR(); /* set on Data Ready bit */
ppStatusWriting=ppWaitingER_Nibble1;
case ppWaitingER_Nibble1:
#if PP_STATS == 1
statWriting[ppStatusWriting]++;
#endif
#if PP_DEBUG == 1
ppWriteSysMsg(" Send Nibble1\n");
ppWriteSysMsg(" Send DR Nibble1\n");
ppWriteSysMsg(" Waiting ER Nibble1\n");
#endif
if(!ppIsER()) break;
ppSendRTS(); /* send trasmission request */
port = inp(TX_PORT) & (~TX_DATA); /* set to zero bit trasmission bits */
port = port | (ppTransmittingByte >> 4); /* set bits 0..3 with MSN */
ppStatusWriting=ppWaitingOTS_Nibble2;
case ppWaitingOTS_Nibble2:
#if PP_STATS == 1
statWriting[ppStatusWriting]++;
#endif
#if PP_DEBUG == 1
ppWriteSysMsg(" Received ER Nibble1\n");
ppWriteSysMsg(" Send RTS Nibble2\n");
ppWriteSysMsg(" Waiting OTS Nibble2\n");
#endif
if(!ppIsOTS()) break;
outp(TX_PORT,port); /* send nibble 2 */
ppSendDR(); /* set on Data Ready bit */
ppStatusWriting=ppWaitingER_Nibble2;
case ppWaitingER_Nibble2:
#if PP_STATS == 1
statWriting[ppStatusWriting]++;
#endif
#if PP_DEBUG == 1
ppWriteSysMsg(" Received OTS Nibble2\n");
ppWriteSysMsg(" Write Nibble2\n");
ppWriteSysMsg(" Send DR Nibble2\n");
ppWriteSysMsg(" Waiting ER Nibble2\n");
#endif
if(!ppIsER()) break;
/* byte is ok, so move pointer to next byte to be send... */
nextByteReadyToTx=++nextByteReadyToTx%PP_BUF_LEN; /* circular buffer pointer increment */
#if PP_STATS == 1
ppWriteSysMsg("Reception :\n");
ppWriteSysMsg("W_OTS_1 : %ld\n",statWriting[ppWaitingOTS_Nibble1]);
ppWriteSysMsg("W_ER_2 : %ld\n",statWriting[ppWaitingER_Nibble2]);
ppWriteSysMsg("W_OTS_2 : %ld\n",statWriting[ppWaitingOTS_Nibble2]);
statWriting[ppWaitingOTS_Nibble1]=0;
statWriting[ppWaitingER_Nibble2]=0;
statWriting[ppWaitingOTS_Nibble2]=0;
#endif
/* end writing. so reset status... */
ppStatusReading=ppNoReading;
ppStatusWriting=ppNoWriting;
}
task_endcycle();
}
return (0);
}

/shark/tags/rel_0_2/drivers/parport/makefile
0,0 → 1,15
# The Parallel Port Library, by Andrea Battistotti & Armando Leggio
ifndef BASE
BASE=../..
endif
include $(BASE)/config/config.mk
LIBRARY = pport
OBJS_PATH = $(BASE)/drivers/parport
OBJS = ppdrv.o ppnrtdrv.o pppindrv.o
include $(BASE)/config/lib.mk

/shark/tags/rel_0_2/drivers/pci/pci_scan.c
3,17 → 3,15
#include <ll/i386/hw-arch.h>
#include <ll/i386/hw-io.h>
#include <ll/i386/cons.h>
#include <ll/i386/error.h>
#include <ll/i386/mem.h>
#include <ll/stdlib.h>
#include <drivers/llpci.h>
#include <drivers/pci.h>
#include <drivers/linuxpci.h>
#include <kernel/log.h>
//#define DEBUG_PCISCAN
static struct pci_dev pci_devs[N_MAX_DEVS];
static struct pci_bus pci_root;
146,7 → 144,9
*/
child = kmalloc(sizeof(*child), GFP_ATOMIC);
if(child==NULL) {
error(KERN_ERR "pci: out of memory for bridge.\n");
#ifdef DEBUG_PCISCAN
printk(KERN_ERR "pci: out of memory for bridge.\n");
#endif
continue;
}
memset(child, 0, sizeof(*child));
221,11 → 221,15
pcibios_init();
if (!pci_present()) {
error("PCI: No PCI bus detected\n");
#ifdef DEBUG_PCISCAN
printk("PCI: No PCI bus detected\n");
#endif
return;
}
error("PCI: Probing PCI hardware\n");
#ifdef DEBUG_PCISCAN
printk("PCI: Probing PCI hardware\n");
#endif
memset(&pci_root, 0, sizeof(pci_root));
pci_root.subordinate = pci_scan_bus(&pci_root);
}

/shark/tags/rel_0_2/drivers/pci/pci.c
3,15 → 3,13
#include <ll/i386/hw-arch.h>
#include <ll/i386/hw-io.h>
#include <ll/i386/cons.h>
#include <ll/stdlib.h>
#include <drivers/llpci.h>
#include <drivers/pci.h>
#include <drivers/linuxpci.h>
#include <kernel/log.h>
static int ndev = 0;
static struct pci_des pci_devs[N_MAX_DEVS];
108,7 → 106,10
{
if (pci_class(class_code, index, bus, dev) != NULL) {
cprintf("PCIBIOS_FIND_CLASS: found at bus %d, dev %d\n", *bus, *dev);
#ifdef DEBUG_PCI
printk(KERN_DEBUG "PCIBIOS_FIND_CLASS:"
"found at bus %d, dev %d\n", *bus, *dev);
#endif
return PCIBIOS_SUCCESSFUL;
} else {
return PCIBIOS_DEVICE_NOT_FOUND;
122,14 → 123,15
int i;
struct pci_regs *r;
cprintf(" DevLib PCI support\n\n");
cprintf(" PCI config type %d\n", pcibios_present());
cprintf(" %d PCI devices found:\n\n", ndev);
printk(KERN_INFO "DevLib PCI support\n\n");
printk(KERN_INFO "PCI config type %d\n", pcibios_present());
printk(KERN_INFO "%d PCI devices found:\n\n", ndev);
for(i = 0; i < ndev; i++) {
cprintf(" %d: bus %d dev %d\n",i , pci_devs[i].bus, pci_devs[i].dev);
r = (struct pci_regs *) pci_devs[i].mem;
cprintf(" Vendor: %s", pci_strvendor(r->VendorId));
cprintf(" Class: %s\n", pci_strclass(r->ClassCode << 8));
printk(KERN_INFO "%d: bus %d dev %d\n",
i, pci_devs[i].bus, pci_devs[i].dev);
printk(KERN_INFO "Vendor: %s", pci_strvendor(r->VendorId));
printk(KERN_INFO "Class: %s\n", pci_strclass(r->ClassCode << 8));
}
}

/shark/tags/rel_0_2/drivers/char/sermouse.c
20,11 → 20,11
/**
------------
CVS : $Id: sermouse.c,v 1.1.1.1 2002-03-29 14:12:49 pj Exp $
CVS : $Id: sermouse.c,v 1.2 2002-11-11 08:41:31 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: 2002-11-11 08:41:31 $
------------
Author: Gerardo Lamastra
84,6 → 84,7
//#include <cons.h>
#include <kernel/kern.h>
#include <time.h>
//#include "sys/sys.h"
//#include "vm.h"
//#include "kern.h"
405,15 → 406,19
int port;
int ret;
int found;
struct timespec delay;
delay.tv_sec = 0;
delay.tv_nsec = 500000000;
found=0;
for (port=COM1;port<=COM4;port++) {
ret=com_open(port,1200,NONE,7,1);
if (ret==1) {
com_write(port,MCR,0x0e);
task_delay(500000l); /* necessary? */
nanosleep(&delay,NULL); /* necessary? */
com_write(port,MCR,0x0f);
task_delay(500000l); /* necessary? */
nanosleep(&delay,NULL); /* necessary? */
ret=sem_wait(&com_link[mouse_port].rx_sem);
if (ret==TRUE) {
if (*(com_link[mouse_port].rx_buf)=='M') found=1;

/shark/tags/rel_0_2/drivers/char/rtc.c
20,11 → 20,11
/**
------------
CVS : $Id: rtc.c,v 1.1.1.1 2002-03-29 14:12:49 pj Exp $
CVS : $Id: rtc.c,v 1.2 2002-11-11 08:41:31 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: 2002-11-11 08:41:31 $
------------
Author: Massimiliano Giorgi
183,7 → 183,7
SYS_FLAGS flags;
unsigned char ctrl;
unsigned retries=0;
unsigned delay;
struct timespec delay;
/*
* read RTC once any update in progress is done. The update
201,8 → 201,9
barrier();
*/
delay=1000;
while (rtc_is_updating()&&++retries<=5) task_delay(delay);
delay.tv_nsec = 1000000;
delay.tv_sec = 0;
while (rtc_is_updating()&&++retries<=5) nanosleep(&delay, NULL);
if (retries>5) return -1;
/*

/shark/tags/rel_0_2/drivers/char/8042.c
20,11 → 20,11
/**
------------
CVS : $Id: 8042.c,v 1.1.1.1 2002-03-29 14:12:49 pj Exp $
CVS : $Id: 8042.c,v 1.2 2002-11-11 08:41:31 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: 2002-11-11 08:41:31 $
------------
8042.h
348,7 → 348,7
static int C8042_reset(void)
{
int c;
int c=0;
int retries=16;
trace("8042 reset START");

/shark/tags/rel_0_2/drivers/makefile
1,5 → 1,5
dirs := $(filter-out CVS makefile, $(wildcard *))
dirs := $(filter-out CVS cvs makefile, $(wildcard *))
p_all := $(addprefix prefixall_, $(dirs))
p_install := $(addprefix prefixinstall_, $(dirs))
p_clean := $(addprefix prefixclean_, $(dirs))

/shark/tags/rel_0_2/drivers/linuxcom/include/linux/netdevice.h
8,12 → 8,21
#include <linux/skbuff.h>
#include <linux/notifier.h>
#include <time.h>
// for 3c59x.c (!!!)
#define le32_to_cpu(val) (val)
#define cpu_to_le32(val) (val)
#define test_and_set_bit(val, addr) set_bit(val, addr)
#define mdelay(x) task_delay((x)*1000)
static __inline__ void mdelay(int x)
{
struct timespec delay;
delay.tv_sec=x/1000;
delay.tv_nsec=(x%1000)*1000000;
nanosleep(&delay, NULL);
}
#define kfree(x) { }
#define ioremap(a,b) \
(((a)<0x100000) ? (void *)((u_long)(a)) : vremap(a,b))

/shark/tags/rel_0_2/drivers/linuxcom/include/linux/compatib.h
56,7 → 56,7
/* Linux kernel call emulation */
#define kmalloc(a,b) malloc(a)
#define printk cprintf
//#define printk cprintf I would like to use the kernel printk if possible...
#define check_region(a,b) 0
#define request_region(a,b,c)

/shark/tags/rel_0_2/drivers/linuxcom/auto_irq.c
1,5 → 1,6
#include<asm/bitops.h>
#include<kernel/kern.h>
#include <time.h>
struct device *irq2dev_map[16] = {0, 0, /* ... zeroed */};
17,6 → 18,7
int autoirq_setup(int waittime)
{
int i;
struct timespec delay;
handled = 0;
27,7 → 29,9
}
/* Hang out at least <waittime> jiffies waiting for bogus IRQ hits. */
task_delay(waittime);
delay.tv_sec = waittime/1000000;
delay.tv_nsec = (waittime%1000000)*1000;
nanosleep(&delay, NULL);
return handled;
}
34,10 → 38,13
int autoirq_report(int waittime)
{
struct timespec delay;
int i;
/* Hang out at least <waittime> jiffies waiting for the IRQ. */
task_delay(waittime);
delay.tv_sec=waittime/1000000;
delay.tv_nsec=(waittime%1000000)*1000;
nanosleep(&delay, NULL);
/* Retract the irq handlers that we installed. */
for (i = 0; i < 16; i++) {