20,11 → 20,11 |
|
/** |
------------ |
CVS : $Id: pc.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $ |
CVS : $Id: pc.c,v 1.2 2003-01-07 17:07:50 pj Exp $ |
|
File: $File$ |
Revision: $Revision: 1.1.1.1 $ |
Last update: $Date: 2002-03-29 14:12:52 $ |
Revision: $Revision: 1.2 $ |
Last update: $Date: 2003-01-07 17:07:50 $ |
------------ |
|
Priority Ceiling protocol. see pc.h for more details... |
57,7 → 57,6 |
#include <ll/string.h> |
#include <ll/stdio.h> |
#include <kernel/const.h> |
#include <modules/codes.h> |
#include <sys/types.h> |
#include <kernel/var.h> |
#include <kernel/func.h> |
153,7 → 152,7 |
} |
|
|
|
#if 0 |
/*+ print resource protocol statistics...+*/ |
static void PC_resource_status(RLEVEL r) |
{ |
172,23 → 171,24 |
// in the future: print the status of the blocked semaphores! |
|
} |
#endif |
|
static int PC_res_register(RLEVEL l, PID p, RES_MODEL *r) |
{ |
PC_mutex_resource_des *m = (PC_mutex_resource_des *)(resource_table[l]); |
PC_RES_MODEL *pc; |
|
static int PC_level_accept_resource_model(RLEVEL l, RES_MODEL *r) |
{ |
if (r->rclass == PC_RCLASS || r->rclass == (PC_RCLASS | l) ) |
return 0; |
else |
if (r->rclass != PC_RCLASS) |
return -1; |
} |
if (r->level && r->level !=l) |
return -1; |
|
static void PC_res_register(RLEVEL l, PID p, RES_MODEL *r) |
{ |
PC_mutex_resource_des *m = (PC_mutex_resource_des *)(resource_table[l]); |
PC_RES_MODEL *pc = (PC_RES_MODEL *)r; |
pc = (PC_RES_MODEL *)r; |
|
m->priority[p] = pc->priority; |
m->nlocked[p] = 0; |
|
return 0; |
} |
|
static void PC_res_detach(RLEVEL l, PID p) |
203,18 → 203,13 |
m->priority[p] = MAX_DWORD; |
} |
|
static int PC_level_accept_mutexattr(RLEVEL l, const mutexattr_t *a) |
{ |
if (a->mclass == PC_MCLASS || a->mclass == (PC_MCLASS | l) ) |
return 0; |
else |
return -1; |
} |
|
static int PC_init(RLEVEL l, mutex_t *m, const mutexattr_t *a) |
{ |
PC_mutex_t *p; |
|
if (a->mclass != PC_MCLASS) |
return -1; |
|
p = (PC_mutex_t *) kern_alloc(sizeof(PC_mutex_t)); |
|
/* control if there is enough memory; no control on init on a |
403,7 → 398,7 |
return 0; |
} |
|
void PC_register_module(void) |
RLEVEL PC_register_module(void) |
{ |
RLEVEL l; /* the level that we register */ |
PC_mutex_resource_des *m; /* for readableness only */ |
421,20 → 416,11 |
resource_table[l] = (resource_des *)m; |
|
/* fill the resource_des descriptor */ |
strncpy(m->m.r.res_name, PC_MODULENAME, MAX_MODULENAME); |
m->m.r.res_code = PC_MODULE_CODE; |
m->m.r.res_version = PC_MODULE_VERSION; |
|
m->m.r.rtype = MUTEX_RTYPE; |
|
m->m.r.resource_status = PC_resource_status; |
m->m.r.level_accept_resource_model = PC_level_accept_resource_model; |
m->m.r.res_register = PC_res_register; |
|
m->m.r.res_detach = PC_res_detach; |
|
/* fill the mutex_resource_des descriptor */ |
m->m.level_accept_mutexattr = PC_level_accept_mutexattr; |
m->m.init = PC_init; |
m->m.destroy = PC_destroy; |
m->m.lock = PC_lock; |
447,6 → 433,8 |
|
m->mlist = NULL; |
|
return l; |
|
} |
|
/*+ This function gets the ceiling of a PC mutex, and it have to be called |
461,11 → 449,6 |
|
r = resource_table[mutex->mutexlevel]; |
|
if (r->rtype != MUTEX_RTYPE || |
r->res_code != PC_MODULE_CODE || |
r->res_version != PC_MODULE_VERSION) |
return -1; |
|
if (ceiling) |
*ceiling = ((PC_mutex_t *)mutex->opt)->ceiling; |
else |
486,11 → 469,6 |
|
r = resource_table[mutex->mutexlevel]; |
|
if (r->rtype != MUTEX_RTYPE || |
r->res_code != PC_MODULE_CODE || |
r->res_version != PC_MODULE_VERSION) |
return -1; |
|
if (old_ceiling) |
*old_ceiling = ((PC_mutex_t *)mutex->opt)->ceiling; |
|