0,0 → 1,362 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* 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) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
|
/** |
------------ |
CVS : $Id: pistar.c,v 1.1 2004-09-01 08:39:33 trimarchi Exp $ |
|
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2004-09-01 08:39:33 $ |
------------ |
|
Priority Inhertitance protocol. see pi.h for more details... |
|
**/ |
|
/* |
* Copyright (C) 2000 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 <pistar.h> |
|
#include <ll/ll.h> |
#include <ll/string.h> |
#include <ll/stdio.h> |
#include <kernel/const.h> |
#include <sys/types.h> |
#include <kernel/descr.h> |
#include <kernel/var.h> |
#include <kernel/func.h> |
#include <fsf_contract.h> |
#include <fsf_server.h> |
|
#include <tracer.h> |
|
/* The PISTAR resource level descriptor */ |
typedef struct { |
mutex_resource_des m; /*+ the mutex interface +*/ |
|
int nlocked[MAX_PROC]; /*+ how many mutex a task currently locks +*/ |
|
PID blocked[MAX_PROC]; /*+ blocked queue ... +*/ |
} PISTAR_mutex_resource_des; |
|
|
/* this is the structure normally pointed by the opt field in the |
mutex_t structure */ |
typedef struct { |
PID owner; |
int nblocked; |
PID firstblocked; |
TIME wcet; |
} PISTAR_mutex_t; |
|
|
|
#if 0 |
/*+ print resource protocol statistics...+*/ |
static void PISTAR_resource_status(RLEVEL r) |
{ |
PISTAR_mutex_resource_des *m = (PISTAR_mutex_resource_des *)(resource_table[r]); |
PID i; |
|
kern_printf("Resources owned by the tasks:\n"); |
for (i=0; i<MAX_PROC; i++) { |
kern_printf("%-4d", m->nlocked[i]); |
} |
} |
#endif |
|
static int PISTAR_res_register(RLEVEL l, PID p, RES_MODEL *r) |
{ |
/* priority inheritance works with all tasks without Resource parameters */ |
return -1; |
} |
|
static void PISTAR_res_detach(RLEVEL l, PID p) |
{ |
PISTAR_mutex_resource_des *m = (PISTAR_mutex_resource_des *)(resource_table[l]); |
|
if (m->nlocked[p]) |
kern_raise(XMUTEX_OWNER_KILLED, p); |
} |
|
static int PISTAR_init(RLEVEL l, mutex_t *m, const mutexattr_t *a) |
{ |
PISTAR_mutex_t *p; |
|
if (a->mclass != PISTAR_MCLASS) |
return -1; |
|
p = (PISTAR_mutex_t *) kern_alloc(sizeof(PISTAR_mutex_t)); |
|
/* control if there is enough memory; no control on init on a |
non- destroyed mutex */ |
|
if (!p) |
return (ENOMEM); |
|
p->owner = NIL; |
p->nblocked = 0; |
p->firstblocked = NIL; |
p->wcet = ((PISTAR_mutexattr_t *)a)->wcet; |
|
m->mutexlevel = l; |
m->opt = (void *)p; |
|
return 0; |
} |
|
|
static int PISTAR_destroy(RLEVEL l, mutex_t *m) |
{ |
// PISTAR_mutex_resource_des *lev = (PISTAR_mutex_resource_des *)(resource_table[l]); |
SYS_FLAGS f; |
|
if ( ((PISTAR_mutex_t *)m->opt)->nblocked) |
return (EBUSY); |
|
f = kern_fsave(); |
if (m->opt) { |
kern_free(m->opt,sizeof(PISTAR_mutex_t)); |
m->opt = NULL; |
} |
kern_frestore(f); |
|
return 0; |
} |
|
/* Note that in this approach, when unlocking we can't wake up only |
one thread, but we have to wake up all the blocked threads, because there |
is not a concept of priority between the task... Each woken thread have |
to retest he condition. |
Normally, they retest it only one time, because if many threads are |
unblocked, they are scheduled basing on their priority (unkown in this |
module!)... and if the slice is greather than the critical sections, |
they never block! |
*/ |
static int PISTAR_lock(RLEVEL l, mutex_t *m) |
{ |
PISTAR_mutex_resource_des *lev = (PISTAR_mutex_resource_des *)(resource_table[l]); |
PISTAR_mutex_t *p; |
SYS_FLAGS f; |
// return 0; |
int cond=0; |
fsf_server_id_t server; |
|
f = kern_fsave(); |
|
p = (PISTAR_mutex_t *)m->opt; |
if (!p) { |
/* if the mutex is not initialized, return an error! */ |
kern_frestore(f); |
return (EINVAL); |
} |
|
|
if (p->owner == exec_shadow) { |
/* the task already owns the mutex */ |
kern_frestore(f); |
return (EDEADLK); |
} |
do { |
while (p->owner != NIL) { |
/* the mutex is locked by someone, "block" the task ...*/ |
proc_table[exec_shadow].shadow = p->owner; |
lev->blocked[exec_shadow] = p->firstblocked; |
p->firstblocked = exec_shadow; |
p->nblocked++; |
// kern_printf("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"); |
/* ... call the scheduler... */ |
scheduler(); |
TRACER_LOGEVENT(FTrace_EVT_inheritance,(unsigned short int)proc_table[exec_shadow].context,(unsigned int)proc_table[exec].context); |
kern_context_load(proc_table[exec_shadow].context); |
|
/* ... and reaquire the cli() before the test... */ |
kern_cli(); |
} |
fsf_get_server(&server, exec_shadow); |
if (fsf_get_remain_budget(server)>p->wcet) cond=1; |
else { |
SERVER_disable_server(fsf_get_server_level(),server); |
scheduler(); |
kern_context_load(proc_table[exec_shadow].context); |
/* ... and reaquire the cli() before the test... */ |
kern_cli(); |
} |
|
} while(cond); |
|
/* if we are here, we have budget for critical section */ |
/* Set the task no preemptive for the localscheduler */ |
fsf_settask_nopreemptive(&server, exec_shadow); |
|
/* the mutex is free, We can lock it! */ |
lev->nlocked[exec_shadow]++; |
|
p->owner = exec_shadow; |
|
kern_frestore(f); |
|
return 0; |
} |
|
static int PISTAR_trylock(RLEVEL l, mutex_t *m) |
{ |
PISTAR_mutex_t *p; |
SYS_FLAGS f; |
|
f = kern_fsave(); |
|
p = (PISTAR_mutex_t *)m->opt; |
if (!p) { |
/* if the mutex is not initialized, return an error! */ |
kern_frestore(f); |
return (EINVAL); |
} |
|
if (p->owner != NIL) { |
/* a task already owns the mutex */ |
kern_frestore(f); |
return (EBUSY); |
} |
else { |
/* the mutex is free */ |
PISTAR_mutex_resource_des *lev = (PISTAR_mutex_resource_des *)(resource_table[l]); |
lev->nlocked[exec_shadow]++; |
|
p->owner = exec_shadow; |
|
kern_frestore(f); |
return 0; |
} |
} |
|
static int PISTAR_unlock(RLEVEL l, mutex_t *m) |
{ |
PISTAR_mutex_resource_des *lev; |
PISTAR_mutex_t *p; |
int i, j; |
fsf_server_id_t server; |
|
// return 0; |
p = (PISTAR_mutex_t *)m->opt; |
if (!p) |
return (EINVAL); |
|
if (p->owner != exec_shadow) { |
/* the mutex is owned by another task!!! */ |
kern_sti(); |
return (EPERM); |
} |
|
proc_table[exec_shadow].context = kern_context_save(); |
|
/* the mutex is mine */ |
lev = (PISTAR_mutex_resource_des *)(resource_table[l]); |
lev->nlocked[exec_shadow]--; |
|
p->owner = NIL; |
|
/* we unblock all the waiting tasks... */ |
i = p->firstblocked; |
p->firstblocked = NIL; |
|
while (i != NIL) { |
// kern_printf("<<%d>>", i); |
proc_table[i].shadow = j = i; |
i = lev->blocked[i]; |
lev->blocked[j] = NIL; |
} |
p->nblocked = 0; |
|
/* { |
int xxx; |
kern_printf("(PISTAR_unlock owner=%d ",p->owner); |
for (xxx = 0; xxx<5; xxx++) kern_printf("p%d s%d|",xxx, proc_table[xxx].shadow); |
kern_printf(")\n"); |
}*/ |
|
/* Set the task preemptive for the localscheduler */ |
fsf_get_server(&server, exec_shadow); |
fsf_settask_preemptive(&server, exec_shadow); |
|
scheduler(); |
TRACER_LOGEVENT(FTrace_EVT_inheritance,(unsigned short int)proc_table[exec_shadow].context,(unsigned int)proc_table[exec].context); |
kern_context_load(proc_table[exec_shadow].context); |
|
return 0; |
} |
|
RLEVEL PISTAR_register_module(void) |
{ |
RLEVEL l; /* the level that we register */ |
PISTAR_mutex_resource_des *m; /* for readableness only */ |
PID i; /* a counter */ |
|
printk("PISTAR_register_module\n"); |
|
/* request an entry in the level_table */ |
l = resource_alloc_descriptor(); |
|
/* alloc the space needed for the EDF_level_des */ |
m = (PISTAR_mutex_resource_des *)kern_alloc(sizeof(PISTAR_mutex_resource_des)); |
|
/* update the level_table with the new entry */ |
resource_table[l] = (resource_des *)m; |
|
/* fill the resource_des descriptor */ |
m->m.r.rtype = MUTEX_RTYPE; |
m->m.r.res_register = PISTAR_res_register; |
m->m.r.res_detach = PISTAR_res_detach; |
|
/* fill the mutex_resource_des descriptor */ |
m->m.init = PISTAR_init; |
m->m.destroy = PISTAR_destroy; |
m->m.lock = PISTAR_lock; |
m->m.trylock = PISTAR_trylock; |
m->m.unlock = PISTAR_unlock; |
|
/* fille the PISTAR_mutex_resource_des descriptor */ |
for (i=0; i<MAX_PROC; i++) { |
m->nlocked[i] = 0; |
m->blocked[i] = NIL; |
} |
|
return l; |
} |
|