Subversion Repositories shark

Compare Revisions

Regard whitespace Rev 317 → Rev 316

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