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.4 2003-01-07 17:07:50 pj Exp $ |
|
File: $File$ |
Revision: $Revision: 1.1.1.1 $ |
Last update: $Date: 2002-03-29 14:12:52 $ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-01-07 17:07:50 $ |
------------ |
|
This file contains the Dummy scheduling module |
58,7 → 58,6 |
#include <ll/string.h> |
#include <kernel/config.h> |
#include <sys/types.h> |
#include <modules/codes.h> |
#include <kernel/model.h> |
#include <kernel/descr.h> |
#include <kernel/var.h> |
74,42 → 73,21 |
} dummy_level_des; |
|
|
static int dummy_level_accept_task_model(LEVEL l, TASK_MODEL *m) |
static PID dummy_public_scheduler(LEVEL l) |
{ |
dummy_level_des *lev = (dummy_level_des *)(level_table[l]); |
|
if ((m->pclass == DUMMY_PCLASS || m->pclass == (DUMMY_PCLASS | l)) |
&& lev->dummy == -1) |
return 0; |
else |
return -1; |
//kern_printf("DUMMYsched!!! %d", lev->dummy); |
return lev->dummy; |
} |
|
static int dummy_level_accept_guest_model(LEVEL l, TASK_MODEL *m) |
static int dummy_public_create(LEVEL l, PID p, TASK_MODEL *m) |
{ |
return -1; |
} |
|
static void dummy_level_status(LEVEL l) |
{ |
dummy_level_des *lev = (dummy_level_des *)(level_table[l]); |
|
kern_printf("dummy PID: %d\n", lev->dummy); |
}; |
if (m->pclass != DUMMY_PCLASS) return -1; |
if (m->level != 0 && m->level != l) return -1; |
if (lev->dummy != -1) return -1; |
|
|
static PID dummy_level_scheduler(LEVEL l) |
{ |
dummy_level_des *lev = (dummy_level_des *)(level_table[l]); |
//kern_printf("DUMMYsched!!! %d", lev->dummy); |
return lev->dummy; |
} |
|
/* There is not guarantee on this level!!! -> the entry must be null |
int (*level_guarantee)(LEVEL l, DWORD *freebandwidth); */ |
|
static int dummy_task_create(LEVEL l, PID p, TASK_MODEL *m) |
{ |
/* the dummy level doesn't introduce any new field in the TASK_MODEL |
so, all initialization stuffs are done by the task_create. |
the task state is set at SLEEP by the general task_create */ |
116,100 → 94,16 |
return 0; /* OK */ |
} |
|
static void dummy_task_detach(LEVEL l, PID p) |
static void dummy_public_dispatch(LEVEL l, PID p, int nostop) |
{ |
/* the dummy level doesn't introduce any new field in the TASK_MODEL |
so, all detach stuffs are done by the task_create |
The task state is set at FREE by the general task_create */ |
} |
|
static int dummy_task_eligible(LEVEL l, PID p) |
{ |
return 0; /* if the task p is chosen, it is always eligible */ |
} |
|
extern int testactive; |
extern struct timespec s_stime[]; |
extern TIME s_curr[]; |
extern TIME s_PID[]; |
extern int useds; |
static void dummy_task_dispatch(LEVEL l, PID p, int nostop) |
{ |
/* nothing... the dummy hangs the cpu waiting for interrupts... */ |
if (0)//testactive) |
{ |
s_stime[useds]= schedule_time; |
s_curr[useds] = -1; |
s_PID[useds] = p; |
useds++; |
} |
|
//kern_printf("ÛDUMMYÛ"); |
|
} |
|
static void dummy_task_epilogue(LEVEL l, PID p) |
static void dummy_public_epilogue(LEVEL l, PID p) |
{ |
proc_table[p].status = SLEEP; /* Paranoia */ |
} |
|
static void dummy_task_activate(LEVEL l, PID p) |
{ kern_printf("Dummy1"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); } |
|
static void dummy_task_insert(LEVEL l, PID p) |
{ kern_printf("Dummy2"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); } |
|
static void dummy_task_extract(LEVEL l, PID p) |
{ kern_printf("Dummy3"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); } |
|
static void dummy_task_endcycle(LEVEL l, PID p) |
{ kern_printf("Dummy4"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); } |
|
static void dummy_task_end(LEVEL l, PID p) |
{ kern_printf("Dummy5"); kern_raise(XUNVALID_DUMMY_OP,exec_shadow); } |
|
static void dummy_task_sleep(LEVEL l, PID p) |
{ kern_printf("Dummy6"); kern_raise(XUNVALID_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; } |
|
static void dummy_guest_detach(LEVEL l, PID p) |
{ kern_printf("Dummy9"); kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void dummy_guest_dispatch(LEVEL l, PID p, int nostop) |
{ kern_printf("Dummy0"); kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void dummy_guest_epilogue(LEVEL l, PID p) |
{ kern_printf("Dummya"); kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void dummy_guest_activate(LEVEL l, PID p) |
{ kern_printf("Dummyb"); kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void dummy_guest_insert(LEVEL l, PID p) |
{ kern_printf("Dummyc"); kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void dummy_guest_extract(LEVEL l, PID p) |
{ kern_printf("Dummyd"); kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void dummy_guest_endcycle(LEVEL l, PID p) |
{ kern_printf("Dummye"); kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void dummy_guest_end(LEVEL l, PID p) |
{ kern_printf("Dummyf"); kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void dummy_guest_sleep(LEVEL l, PID p) |
{ kern_printf("Dummyg"); kern_raise(XUNVALID_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() |
{ |
252,7 → 146,7 |
if (p == NIL) |
printk("\nPanic!!! can't create dummy task...\n"); |
|
/* dummy must block all tasks... */ |
/* dummy must block all signals... */ |
proc_table[p].sigmask = 0xFFFFFFFF; |
} |
|
261,57 → 155,27 |
TIME slice the slice for the Round Robin queue |
int createmain 1 if the level creates the main task 0 otherwise |
struct multiboot_info *mb used if createmain specified +*/ |
void dummy_register_level() |
LEVEL dummy_register_level() |
{ |
LEVEL l; /* the level that we register */ |
dummy_level_des *lev; /* for readableness only */ |
|
printk("Entro in dummy_register_level\n"); |
printk("Inside dummy_register_level\n"); |
|
/* request an entry in the level_table */ |
l = level_alloc_descriptor(); |
l = level_alloc_descriptor(sizeof(dummy_level_des)); |
|
/* alloc the space needed for the dummy_level_des */ |
lev = (dummy_level_des *)kern_alloc(sizeof(dummy_level_des)); |
lev = (dummy_level_des *)level_table[l]; |
|
/* update the level_table with the new entry */ |
level_table[l] = (level_des *)lev; |
printk(" lev=%d\n",(int)lev); |
|
/* fill the standard descriptor */ |
strncpy(lev->l.level_name, DUMMY_LEVELNAME, MAX_LEVELNAME); |
lev->l.level_code = DUMMY_LEVEL_CODE; |
lev->l.level_version = DUMMY_LEVEL_VERSION; |
lev->l.public_scheduler = dummy_public_scheduler; |
lev->l.public_guarantee = NULL; |
lev->l.public_create = dummy_public_create; |
lev->l.public_dispatch = dummy_public_dispatch; |
lev->l.public_epilogue = dummy_public_epilogue; |
|
lev->l.level_accept_task_model = dummy_level_accept_task_model; |
lev->l.level_accept_guest_model = dummy_level_accept_guest_model; |
lev->l.level_status = dummy_level_status; |
lev->l.level_scheduler = dummy_level_scheduler; |
lev->l.level_guarantee = NULL; /* No guarantee! */ |
|
lev->l.task_create = dummy_task_create; |
lev->l.task_detach = dummy_task_detach; |
lev->l.task_eligible = dummy_task_eligible; |
lev->l.task_dispatch = dummy_task_dispatch; |
lev->l.task_epilogue = dummy_task_epilogue; |
lev->l.task_activate = dummy_task_activate; |
lev->l.task_insert = dummy_task_insert; |
lev->l.task_extract = dummy_task_extract; |
lev->l.task_endcycle = dummy_task_endcycle; |
lev->l.task_end = dummy_task_end; |
lev->l.task_sleep = dummy_task_sleep; |
lev->l.task_delay = dummy_task_delay; |
|
lev->l.guest_create = dummy_guest_create; |
lev->l.guest_detach = dummy_guest_detach; |
lev->l.guest_dispatch = dummy_guest_dispatch; |
lev->l.guest_epilogue = dummy_guest_epilogue; |
lev->l.guest_activate = dummy_guest_activate; |
lev->l.guest_insert = dummy_guest_insert; |
lev->l.guest_extract = dummy_guest_extract; |
lev->l.guest_endcycle = dummy_guest_endcycle; |
lev->l.guest_end = dummy_guest_end; |
lev->l.guest_sleep = dummy_guest_sleep; |
lev->l.guest_delay = dummy_guest_delay; |
|
/* the dummy process will be created at init_time. |
see also dummy_level_accept_model,dummy_create */ |
lev->dummy = -1; |
319,4 → 183,6 |
printk("\tPosto dummy_create\n"); |
|
sys_atrunlevel(dummy_create,(void *) l, RUNLEVEL_INIT); |
|
return l; |
} |