20,11 → 20,11 |
|
/** |
------------ |
CVS : $Id: srp.c,v 1.2 2002-10-28 07:55:55 pj Exp $ |
CVS : $Id: srp.c,v 1.3 2003-01-07 17:07:51 pj Exp $ |
|
File: $File$ |
Revision: $Revision: 1.2 $ |
Last update: $Date: 2002-10-28 07:55:55 $ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2003-01-07 17:07:51 $ |
------------ |
|
Stack Resource Policy. see srp.h for general details... |
141,7 → 141,6 |
#include <ll/string.h> |
#include <ll/stdio.h> |
#include <kernel/const.h> |
#include <modules/codes.h> |
#include <sys/types.h> |
#include <kernel/descr.h> |
#include <kernel/var.h> |
385,27 → 384,14 |
} |
|
|
/*+ print resource protocol statistics...+*/ |
static void SRP_resource_status(RLEVEL r) |
static int SRP_res_register(RLEVEL l, PID p, RES_MODEL *r) |
{ |
kern_printf("SRP status not implemented yet"); |
} |
SRP_mutex_resource_des *m = (SRP_mutex_resource_des *)(resource_table[l]); |
|
|
static int SRP_level_accept_resource_model(RLEVEL l, RES_MODEL *r) |
{ |
if (r->rclass == SRP_RCLASS || r->rclass == (SRP_RCLASS | l) || |
r->rclass == SRP2_RCLASS || r->rclass == (SRP2_RCLASS | l)) |
return 0; |
else |
if (r->level && r->level !=l) |
return -1; |
} |
|
static void SRP_res_register(RLEVEL l, PID p, RES_MODEL *r) |
{ |
SRP_mutex_resource_des *m = (SRP_mutex_resource_des *)(resource_table[l]); |
|
if (r->rclass == SRP_RCLASS || r->rclass == (SRP_RCLASS | l)) { |
if (r->rclass == SRP_RCLASS) { |
/* SRP_RES_MODEL resource model */ |
// kern_printf("!%d %d",((SRP_RES_MODEL *)r)->preempt,p); |
|
429,14 → 415,15 |
} |
|
m->nlocked[p] = 0; |
return 0; |
} |
else { |
else if (r->rclass == SRP2_RCLASS) { |
/* a mutex passed via SRP_useres() */ |
SRP_mutex_t *mut = (SRP_mutex_t *)r; |
|
if (mut->use[p]) |
/* the mutex is already registered, do nothing! */ |
return; |
return -1; |
|
/* register the mutex for the task */ |
mut->use[p] = 1; |
449,7 → 436,10 |
mut->ceiling = m->proc_preempt[p].preempt; |
|
} |
return 0; |
} |
else |
return -1; |
} |
|
static void SRP_res_detach(RLEVEL l, PID p) |
488,14 → 478,6 |
SRP_extract_tasklist(m, p); |
} |
|
static int SRP_level_accept_mutexattr(RLEVEL l, const mutexattr_t *a) |
{ |
if (a->mclass == SRP_MCLASS || a->mclass == (SRP_MCLASS | l) ) |
return 0; |
else |
return -1; |
} |
|
static int SRP_init(RLEVEL l, mutex_t *m, const mutexattr_t *a) |
{ |
SRP_mutex_resource_des *lev = (SRP_mutex_resource_des *)(resource_table[l]); |
502,6 → 484,9 |
SRP_mutex_t *p; |
PID x; |
|
if (a->mclass != SRP_MCLASS) |
return -1; |
|
p = (SRP_mutex_t *) kern_alloc(sizeof(SRP_mutex_t)); |
|
/* control if there is enough memory; no control on init on a |
719,7 → 704,7 |
/* activate the task if it was activated while in lobby list! */ |
if (task_unblock_activation(x)) { |
LEVEL sl = proc_table[x].task_level; |
level_table[sl]->task_activate(sl,x); |
level_table[sl]->public_activate(sl,x); |
// kern_printf("activate it!!!"); |
} |
} |
736,7 → 721,7 |
return 0; |
} |
|
void SRP_register_module(void) |
RLEVEL SRP_register_module(void) |
{ |
RLEVEL l; /* the level that we register */ |
SRP_mutex_resource_des *m; /* for readableness only */ |
754,20 → 739,11 |
resource_table[l] = (resource_des *)m; |
|
/* fill the resource_des descriptor */ |
strncpy(m->m.r.res_name, SRP_MODULENAME, MAX_MODULENAME); |
m->m.r.res_code = SRP_MODULE_CODE; |
m->m.r.res_version = SRP_MODULE_VERSION; |
|
m->m.r.rtype = MUTEX_RTYPE; |
|
m->m.r.resource_status = SRP_resource_status; |
m->m.r.level_accept_resource_model = SRP_level_accept_resource_model; |
m->m.r.res_register = SRP_res_register; |
|
m->m.r.res_detach = SRP_res_detach; |
|
/* fill the mutex_resource_des descriptor */ |
m->m.level_accept_mutexattr = SRP_level_accept_mutexattr; |
m->m.init = SRP_init; |
m->m.destroy = SRP_destroy; |
m->m.lock = SRP_lock; |
789,5 → 765,7 |
m->srpstack = NULL; |
m->srprecalc = NULL; |
m->srplist = NULL; |
|
return l; |
} |
|