| 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; |
| } |
| |