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