/shark/trunk/kernel/modules/hartport.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: hartport.c,v 1.3 2002-11-11 08:32:06 pj Exp $ |
CVS : $Id: hartport.c,v 1.4 2003-11-05 15:04:14 giacomo Exp $ |
File: $File$ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2002-11-11 08:32:06 $ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-11-05 15:04:14 $ |
------------ |
This file contains the Hartik 3.3.1 Port functions |
175,16 → 175,17 |
static int getfreedes(void) |
{ |
int p; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
if (freeportdes == NIL) { |
errno = EPORT_NO_MORE_DESCR; |
kern_sti(); |
kern_frestore(f); |
return -1; |
} |
p = freeportdes; |
freeportdes = port_des[p].next; |
kern_sti(); |
kern_frestore(f); |
return(p); |
} |
193,10 → 194,12 |
/*----------------------------------------------------------------------*/ |
static void ungetdes(int pd) |
{ |
kern_cli(); |
SYS_FLAGS f; |
f = kern_fsave(); |
port_des[pd].next = freeportdes; |
freeportdes = pd; |
kern_sti(); |
kern_frestore(f); |
} |
/*----------------------------------------------------------------------*/ |
205,16 → 208,16 |
static int getfreeint(void) |
{ |
int p; |
kern_cli(); |
SYS_FLAGS f; |
f = kern_fsave(); |
if (freeportint == NIL) { |
errno = EPORT_NO_MORE_INTERF; |
kern_sti(); |
kern_frestore(f); |
return -1; |
} |
p = freeportint; |
freeportint = port_int[p].next; |
kern_sti(); |
kern_frestore(f); |
return(p); |
} |
223,10 → 226,12 |
/*----------------------------------------------------------------------*/ |
static void ungetint(int pi) |
{ |
kern_cli(); |
SYS_FLAGS f; |
f = kern_fsave(); |
port_int[pi].next = freeportint; |
freeportint = pi; |
kern_sti(); |
kern_frestore(f); |
} |
/*----------------------------------------------------------------------*/ |
240,6 → 245,7 |
int i, pd, pi; |
WORD letti = 0; |
BYTE flag = FALSE; |
SYS_FLAGS f; |
/* |
Prendo un descrittore di porta. |
303,9 → 309,9 |
if (type == STICK) port_des[pd].dim_block = dim_mes; |
else port_des[pd].dim_block = dim_mes * num_mes; |
kern_cli(); |
f = kern_fsave(); |
port_des[pd].mem_block = kern_alloc(port_des[pd].dim_block); |
kern_sti(); |
kern_frestore(f); |
if (port_des[pd].mem_block == NULL) { |
errno = EPORT_2_CONNECT; |
sem_post(&hash_mutex); |
496,6 → 502,7 |
int i; |
struct port_ker *pd; |
struct port_com *pp; |
SYS_FLAGS f; |
pp = &port_int[pi]; |
sem_wait(&hash_mutex); |
506,9 → 513,9 |
sem_destroy(&pd->pieno); |
sem_destroy(&pd->vuoto); |
kern_cli(); |
f = kern_fsave(); |
kern_free(pd->mem_block, pd->dim_block); |
kern_sti(); |
kern_frestore(f); |
ungetdes(htable[i].port_index); |
pp->valid = FALSE; |
/shark/trunk/kernel/modules/nopm.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: nopm.c,v 1.3 2003-01-07 17:07:50 pj Exp $ |
CVS : $Id: nopm.c,v 1.4 2003-11-05 15:04:14 giacomo Exp $ |
File: $File$ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2003-01-07 17:07:50 $ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-11-05 15:04:14 $ |
------------ |
See modules/nopm.h. |
179,16 → 179,17 |
static int NOPM_destroy(RLEVEL l, mutex_t *m) |
{ |
// NOPM_mutex_resource_des *lev = (NOPM_mutex_resource_des *)(resource_table[l]); |
SYS_FLAGS f; |
if ( ((NOPM_mutex_t *)m->opt)->owner != NIL) |
return (EBUSY); |
kern_cli(); |
f = kern_fsave(); |
if (m->opt) { |
kern_free(m->opt,sizeof(NOPM_mutex_t)); |
m->opt = NULL; |
} |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
196,8 → 197,9 |
static int NOPM_lock(RLEVEL l, mutex_t *m) |
{ |
NOPM_mutex_t *p; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
p = (NOPM_mutex_t *)m->opt; |
if (!p) { |
210,7 → 212,7 |
if (p->owner == exec_shadow) { |
/* the task already owns the mutex */ |
p->counter++; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
236,7 → 238,7 |
/* the mutex is free, We can lock it! */ |
p->owner = exec_shadow; |
p->counter++; |
kern_sti(); |
kern_frestore(f); |
} |
return 0; |
245,8 → 247,9 |
static int NOPM_trylock(RLEVEL l, mutex_t *m) |
{ |
NOPM_mutex_t *p; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
p = (NOPM_mutex_t *)m->opt; |
if (!p) { |
258,7 → 261,7 |
if (p->owner != NIL) { |
/* a task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EBUSY); |
} |
else { |
265,7 → 268,7 |
/* the mutex is free, We can lock it! */ |
p->owner = exec_shadow; |
p->counter++; |
kern_sti(); |
kern_frestore(f); |
} |
return 0; |
283,7 → 286,6 |
if (p->owner != exec_shadow) { |
/* the mutex is owned by another task!!! */ |
kern_printf("wrongunlock<owner=%i,unlocker=%i>",p->owner,exec_shadow); |
kern_sti(); |
return (EPERM); |
} |
290,7 → 292,6 |
p->counter--; |
if (p->counter!=0) { |
/* we have multiple lock on this mutex */ |
kern_sti(); |
return 0; |
} |
/shark/trunk/kernel/modules/npp.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: npp.c,v 1.2 2003-01-07 17:07:50 pj Exp $ |
CVS : $Id: npp.c,v 1.3 2003-11-05 15:04:14 giacomo Exp $ |
File: $File$ |
Revision: $Revision: 1.2 $ |
Last update: $Date: 2003-01-07 17:07:50 $ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2003-11-05 15:04:14 $ |
------------ |
Non Preemptive Protocol. see npp.h for more details... |
119,12 → 119,13 |
static int NPP_lock(RLEVEL l, mutex_t *m) |
{ |
NPP_mutex_resource_des *lev; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
if (((PID)m->opt) == exec_shadow) { |
/* the task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EDEADLK); |
} |
139,7 → 140,7 |
m->opt = (void *)exec_shadow; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
/shark/trunk/kernel/modules/pc.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: pc.c,v 1.3 2003-09-12 10:10:41 giacomo Exp $ |
CVS : $Id: pc.c,v 1.4 2003-11-05 15:04:14 giacomo Exp $ |
File: $File$ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2003-09-12 10:10:41 $ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-11-05 15:04:14 $ |
------------ |
Priority Ceiling protocol. see pc.h for more details... |
236,16 → 236,17 |
static int PC_destroy(RLEVEL l, mutex_t *m) |
{ |
// PC_mutex_resource_des *lev = (PC_mutex_resource_des *)(resource_table[l]); |
SYS_FLAGS f; |
if ( ((PC_mutex_t *)m->opt)->nblocked) |
return (EBUSY); |
kern_cli(); |
f = kern_fsave(); |
if (m->opt) { |
kern_free(m->opt,sizeof(PC_mutex_t)); |
m->opt = NULL; |
} |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
255,25 → 256,26 |
{ |
PC_mutex_resource_des *lev = (PC_mutex_resource_des *)(resource_table[l]); |
PC_mutex_t *p; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
p = (PC_mutex_t *)m->opt; |
if (!p) { |
/* if the mutex is not initialized, return an error! */ |
kern_sti(); |
kern_frestore(f); |
return (EINVAL); |
} |
if (p->owner == exec_shadow) { |
/* the task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EDEADLK); |
} |
if (p->ceiling > lev->priority[exec_shadow]) { |
/* see POSIX standard p. 258 */ |
kern_sti(); |
kern_frestore(f); |
return (EINVAL); |
} |
295,7 → 297,7 |
kern_context_load(proc_table[exec_shadow].context); |
/* ... and reaquire the cli() before the test... */ |
kern_cli(); |
f = kern_fsave(); |
} |
/* the mutex is free, We can lock it! */ |
306,7 → 308,7 |
PC_insert(lev, p); |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
315,31 → 317,32 |
{ |
PC_mutex_resource_des *lev = (PC_mutex_resource_des *)(resource_table[l]); |
PC_mutex_t *p; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
p = (PC_mutex_t *)m->opt; |
if (!p) { |
/* if the mutex is not initialized, return an error! */ |
kern_sti(); |
kern_frestore(f); |
return (EINVAL); |
} |
if (p->owner == exec_shadow) { |
/* the task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EDEADLK); |
} |
if (p->ceiling < lev->priority[exec_shadow]) { |
/* see POSIX standard p. 258 */ |
kern_sti(); |
kern_frestore(f); |
return (EINVAL); |
} |
while (!PC_accept(lev, lev->priority[exec_shadow])) { |
/* a task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EBUSY); |
} |
351,7 → 354,7 |
PC_insert(lev, p); |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
368,7 → 371,6 |
if (p->owner != exec_shadow) { |
/* the mutex is owned by another task!!! */ |
kern_sti(); |
return (EPERM); |
} |
/shark/trunk/kernel/modules/srp.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: srp.c,v 1.3 2003-01-07 17:07:51 pj Exp $ |
CVS : $Id: srp.c,v 1.4 2003-11-05 15:04:15 giacomo Exp $ |
File: $File$ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2003-01-07 17:07:51 $ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-11-05 15:04:15 $ |
------------ |
Stack Resource Policy. see srp.h for general details... |
525,6 → 525,7 |
{ |
SRP_mutex_resource_des *lev = (SRP_mutex_resource_des *)(resource_table[l]); |
SRP_mutex_t *mut; |
SYS_FLAGS f; |
mut = m->opt; |
531,7 → 532,7 |
if (mut->owner != NIL) |
return (EBUSY); |
kern_cli(); |
f = kern_fsave(); |
/* the mutex isn't in the srpstack, because it is not busy */ |
546,7 → 547,7 |
kern_free(m->opt,sizeof(SRP_mutex_t)); |
m->opt = NULL; |
} |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
556,19 → 557,20 |
SRP_mutex_resource_des *lev = (SRP_mutex_resource_des *)(resource_table[l]); |
SRP_mutex_t *mut; |
DWORD oldsysceiling; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
mut = (SRP_mutex_t *)m->opt; |
if (!mut) { |
/* if the mutex is not initialized */ |
kern_sti(); |
kern_frestore(f); |
return (EINVAL); |
} |
if (mut->owner == exec_shadow) { |
/* the task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EDEADLK); |
} |
581,7 → 583,7 |
// mut->use[exec_shadow], |
// lev->proc_preempt[exec_shadow].preempt,exec_shadow); |
kern_raise(XSRP_INVALID_LOCK, exec_shadow); |
kern_sti(); |
kern_frestore(f); |
return (EINVAL); |
} |
637,7 → 639,7 |
} |
} |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
658,13 → 660,11 |
if (mut->owner != exec_shadow) { |
/* the mutex is owned by another task!!! */ |
kern_sti(); |
return (EPERM); |
} |
if (!lev->srpstack || lev->srpstack != mut) { |
/* the mutex is not the top of the stack!!! (erroneous nesting!) */ |
kern_sti(); |
return (EINVAL); |
} |
/shark/trunk/kernel/modules/pi.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: pi.c,v 1.2 2003-01-07 17:07:50 pj Exp $ |
CVS : $Id: pi.c,v 1.3 2003-11-05 15:04:14 giacomo Exp $ |
File: $File$ |
Revision: $Revision: 1.2 $ |
Last update: $Date: 2003-01-07 17:07:50 $ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2003-11-05 15:04:14 $ |
------------ |
Priority Inhertitance protocol. see pi.h for more details... |
139,16 → 139,17 |
static int PI_destroy(RLEVEL l, mutex_t *m) |
{ |
// PI_mutex_resource_des *lev = (PI_mutex_resource_des *)(resource_table[l]); |
SYS_FLAGS f; |
if ( ((PI_mutex_t *)m->opt)->nblocked) |
return (EBUSY); |
kern_cli(); |
f = kern_fsave(); |
if (m->opt) { |
kern_free(m->opt,sizeof(PI_mutex_t)); |
m->opt = NULL; |
} |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
166,9 → 167,11 |
{ |
PI_mutex_resource_des *lev = (PI_mutex_resource_des *)(resource_table[l]); |
PI_mutex_t *p; |
SYS_FLAGS f; |
// return 0; |
kern_cli(); |
f = kern_fsave(); |
p = (PI_mutex_t *)m->opt; |
if (!p) { |
/* if the mutex is not initialized, initialize it! */ |
180,7 → 183,7 |
if (p->owner == exec_shadow) { |
/* the task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EDEADLK); |
} |
196,7 → 199,7 |
kern_context_load(proc_table[exec_shadow].context); |
/* ... and reaquire the cli() before the test... */ |
kern_cli(); |
kern_frestore(f); |
} |
/* the mutex is free, We can lock it! */ |
204,7 → 207,7 |
p->owner = exec_shadow; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
212,8 → 215,9 |
static int PI_trylock(RLEVEL l, mutex_t *m) |
{ |
PI_mutex_t *p; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
p = (PI_mutex_t *)m->opt; |
if (!p) { |
225,7 → 229,7 |
if (p->owner != NIL) { |
/* a task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EBUSY); |
} |
else { |
235,7 → 239,7 |
p->owner = exec_shadow; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
} |
245,6 → 249,7 |
PI_mutex_resource_des *lev; |
PI_mutex_t *p; |
int i, j; |
// return 0; |
p = (PI_mutex_t *)m->opt; |
if (!p) |
252,7 → 257,6 |
if (p->owner != exec_shadow) { |
/* the mutex is owned by another task!!! */ |
kern_sti(); |
return (EPERM); |
} |
/shark/trunk/kernel/modules/sem.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: sem.c,v 1.3 2003-01-07 17:07:51 pj Exp $ |
CVS : $Id: sem.c,v 1.4 2003-11-05 15:04:15 giacomo Exp $ |
File: $File$ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2003-01-07 17:07:51 $ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-11-05 15:04:15 $ |
------------ |
This file contains the Hartik 3.3.1 Semaphore functions |
151,10 → 151,12 |
// the pshared parameter is NRQ for PSE52 |
int sem_init(sem_t *sem, int pshared, unsigned int value) |
{ |
SYS_FLAGS f; |
if (value > SEM_VALUE_MAX) |
return EINVAL; |
kern_cli(); |
f = kern_fsave(); |
*sem = free_sem; |
if (*sem != NIL) { |
free_sem = sem_table[*sem].next; |
165,10 → 167,10 |
} |
else { |
errno = ENOSPC; |
kern_sti(); |
kern_frestore(f); |
return -1; |
} |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
177,17 → 179,19 |
/*----------------------------------------------------------------------*/ |
int sem_destroy(sem_t *sem) |
{ |
kern_cli(); |
SYS_FLAGS f; |
f = kern_fsave(); |
if (*sem < 0 || *sem >= SEM_NSEMS_MAX || !sem_table[*sem].used) { |
errno = EINVAL; |
kern_sti(); |
kern_frestore(f); |
return -1; |
} |
if (sem_table[*sem].blocked.first != NIL) { |
errno = EBUSY; |
kern_sti(); |
kern_frestore(f); |
return -1; |
} |
195,7 → 199,7 |
sem_table[*sem].next = free_sem; |
free_sem = *sem; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
210,8 → 214,9 |
int found = 0; |
mode_t m; |
sem_t sem; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
for (i = 0; i < SEM_NSEMS_MAX; i++) |
if (sem_table[i].used) { |
223,16 → 228,16 |
if (found) { |
if (oflag == (O_CREAT | O_EXCL)) { |
errno = EEXIST; |
kern_sti(); |
kern_frestore(f); |
return SEM_FAILED; |
} else { |
kern_sti(); |
kern_frestore(f); |
return &sem_table[i].index; |
} |
} else { |
if (!(oflag & O_CREAT)) { |
errno = ENOENT; |
kern_sti(); |
kern_frestore(f); |
return SEM_FAILED; |
} else { |
va_list l; |
244,7 → 249,7 |
if (j > SEM_VALUE_MAX) { |
errno = EINVAL; |
kern_sti(); |
kern_frestore(f); |
return SEM_FAILED; |
} |
256,12 → 261,12 |
sem_table[sem].count = j; |
iq_init(&sem_table[sem].blocked, &freedesc, 0); |
sem_table[sem].used = 1; |
kern_sti(); |
kern_frestore(f); |
return &sem_table[sem].index; |
} |
else { |
errno = ENOSPC; |
kern_sti(); |
kern_frestore(f); |
return SEM_FAILED; |
} |
} |
273,11 → 278,13 |
/*----------------------------------------------------------------------*/ |
int sem_close(sem_t *sem) |
{ |
kern_cli(); |
SYS_FLAGS f; |
f = kern_fsave(); |
if (*sem < 0 || *sem >= SEM_NSEMS_MAX || !sem_table[*sem].used) { |
errno = EINVAL; |
kern_sti(); |
kern_frestore(f); |
return -1; |
} |
293,7 → 300,7 |
sem_table[*sem].next = free_sem; |
free_sem = *sem; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
304,8 → 311,9 |
{ |
int i; |
int found = 0; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
for (i = 0; i < SEM_NSEMS_MAX; i++) |
if (sem_table[i].used) { |
319,11 → 327,11 |
sem_table[i].used = 0; |
sem_table[i].next = free_sem; |
free_sem = i; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} else { |
errno = ENOENT; |
kern_sti(); |
kern_frestore(f); |
return SEM_FAILED; |
} |
} |
393,6 → 401,7 |
int sem_trywait(sem_t *s) |
{ |
struct sem_des *s1; /* It speeds up access */ |
SYS_FLAGS f; |
if (*s < 0 || *s >= SEM_NSEMS_MAX || !sem_table[*s].used) { |
errno = EINVAL; |
399,7 → 408,7 |
return -1; |
} |
kern_cli(); |
f = kern_fsave(); |
s1 = &sem_table[*s]; |
408,13 → 417,13 |
if (s1->blocked.first != NIL || s1->count == 0) { |
errno = EAGAIN; |
kern_sti(); |
kern_frestore(f); |
return -1; |
} |
else |
s1->count--; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
426,7 → 435,11 |
int sem_xwait(sem_t *s, int n, int wait) |
{ |
struct sem_des *s1; /* It speeds up access */ |
SYS_FLAGS f; |
f = kern_fsave(); |
kern_frestore(f); |
if (*s < 0 || *s >= SEM_NSEMS_MAX || !sem_table[*s].used) { |
errno = EINVAL; |
return -1; |
434,7 → 447,7 |
/* We do not need to save context if we are sure we shall not block! */ |
if (wait == NON_BLOCK) |
kern_cli(); |
f = kern_fsave(); |
else |
proc_table[exec_shadow].context = kern_context_save(); |
448,13 → 461,13 |
if (s1->blocked.first != NIL || s1->count < n) { |
errno = EAGAIN; |
kern_sti(); |
kern_frestore(f); |
return -1; |
} |
else |
s1->count -= n; |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
/* The blocking wait is more complex... */ |
665,6 → 678,7 |
int sem_getvalue(sem_t *sem, int *sval) |
{ |
PID p; |
SYS_FLAGS f; |
if (*sem < 0 || *sem >= SEM_NSEMS_MAX || !sem_table[*sem].used) { |
errno = EINVAL; |
671,7 → 685,7 |
return -1; |
} |
kern_cli(); |
f = kern_fsave(); |
if (iq_isempty(&sem_table[*sem].blocked)) |
/* the sem is free */ |
686,7 → 700,7 |
} while (p != NIL); |
} |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
/shark/trunk/kernel/modules/nop.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: nop.c,v 1.3 2003-01-07 17:07:50 pj Exp $ |
CVS : $Id: nop.c,v 1.4 2003-11-05 15:04:14 giacomo Exp $ |
File: $File$ |
Revision: $Revision: 1.3 $ |
Last update: $Date: 2003-01-07 17:07:50 $ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-11-05 15:04:14 $ |
------------ |
Binary Semaphores. see nop.h for more details... |
116,16 → 116,17 |
static int NOP_destroy(RLEVEL l, mutex_t *m) |
{ |
// NOP_mutex_resource_des *lev = (NOP_mutex_resource_des *)(resource_table[l]); |
SYS_FLAGS f; |
if ( ((NOP_mutex_t *)m->opt)->owner != NIL) |
return (EBUSY); |
kern_cli(); |
f = kern_fsave(); |
if (m->opt) { |
kern_free(m->opt,sizeof(NOP_mutex_t)); |
m->opt = NULL; |
} |
kern_sti(); |
kern_frestore(f); |
return 0; |
} |
133,8 → 134,9 |
static int NOP_lock(RLEVEL l, mutex_t *m) |
{ |
NOP_mutex_t *p; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
p = (NOP_mutex_t *)m->opt; |
if (!p) { |
146,7 → 148,7 |
if (p->owner == exec_shadow) { |
/* the task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EDEADLK); |
} |
171,7 → 173,7 |
else { |
/* the mutex is free, We can lock it! */ |
p->owner = exec_shadow; |
kern_sti(); |
kern_frestore(f); |
} |
return 0; |
180,8 → 182,9 |
static int NOP_trylock(RLEVEL l, mutex_t *m) |
{ |
NOP_mutex_t *p; |
SYS_FLAGS f; |
kern_cli(); |
f = kern_fsave(); |
p = (NOP_mutex_t *)m->opt; |
if (!p) { |
193,13 → 196,13 |
if (p->owner != NIL) { |
/* a task already owns the mutex */ |
kern_sti(); |
kern_frestore(f); |
return (EBUSY); |
} |
else { |
/* the mutex is free, We can lock it! */ |
p->owner = exec_shadow; |
kern_sti(); |
kern_frestore(f); |
} |
return 0; |
215,7 → 218,6 |
if (p->owner != exec_shadow) { |
/* the mutex is owned by another task!!! */ |
kern_sti(); |
return (EPERM); |
} |
/shark/trunk/oslib/kl/advtimer.c |
---|
69,8 → 69,6 |
unsigned int start_8253, end_8253, delta_8253; |
cli(); |
outp(0x61, (inp(0x61) & ~0x02) | 0x01); |
outp(0x43,0xB0); /* binary, mode 0, LSB/MSB, Ch 2 */ |
124,8 → 122,6 |
message("Calibrated Clk_per_msec = %10d\n",clk_per_msec); |
sti(); |
} |
#define CMOS_INIT 0 |
142,8 → 138,6 |
unsigned char set; |
cli(); |
CMOS_READ(0x0C,set); |
barrier(); |
163,8 → 157,6 |
cmos_calibrate_status = CMOS_BEGIN; |
} |
sti(); |
} |
//TSC Calibration using RTC |
173,8 → 165,6 |
unsigned long long dtsc; |
cli(); |
irq_bind(8, calibrate_tsc_IRQ8, INT_FORCE); |
CMOS_READ(0x0A,save_CMOS_regA); |
191,6 → 181,8 |
barrier(); |
} |
cli(); |
dtsc = irq8_end - irq8_start; |
clk_per_msec = dtsc / 500; |
197,15 → 189,11 |
message("Calibrated CPU Clk/msec = %10d\n",clk_per_msec); |
cli(); |
irq_mask(8); |
CMOS_WRITE(0x0A,save_CMOS_regA); |
CMOS_WRITE(0x0B,save_CMOS_regB); |
sti(); |
} |
int apic_get_maxlvt(void) |
361,8 → 349,6 |
unsigned long long tsc_start = 0, tsc_end = 0, dtsc; |
unsigned int tmp_value; |
cli(); |
tmp_value = SET_APIC_TIMER_BASE(APIC_TIMER_BASE_DIV) | LOCAL_TIMER_VECTOR; |
apic_write_around(APIC_LVTT, tmp_value); |
391,8 → 377,6 |
disable_APIC_timer(); |
sti(); |
dtsc = tsc_end - tsc_start; |
dapic = apic_start - apic_end; |