void test3 ()
{
int rd1, rd2;
int wr1;
kprintf("\nTest 3: test the basic priority inheritence\n");
lck = lcreate();
lck2 = lcreate();
kprintf("lck1: %d \t lck2: %d",lck,lck2);
rd1 = create(reader3, 2000, 25, "reader3", 2, "reader A", lck);
rd2 = create(reader3, 2000, 30, "reader3", 2, "reader B", lck2);
wr1 = create(writer3, 2000, 40, "writer3", 2, "writer C", lck);
kprintf("-start reader B, then sleep 1s. reader B(prio 30) blocked on the lock\n");
resume (rd2);
sleep (1);
kprintf("-start writer, then sleep 1s. lock granted to write (prio 20)\n");
resume(wr1);
sleep (1);
kprintf("-start reader A, then sleep 1s. reader A(prio 25) blocked on the lock\n");
resume(rd1);
assert(getprio(rd2)==40);
assert(getprio(rd1)==25);
assert(getprio(wr1)==40);
sleep (8);
kprintf ("Test 3 OK\n");
/*semaphore*/
kprintf("\n\nSEMAPHORE \n\n");
kprintf("\nTest 3: test the basic priority inheritence\n");
sem = screate(2);
sem2 = screate(1);
kprintf("lck1: %d \t lck2: %d",lck,lck2);
rd1 = create(readersem3, 2000, 25, "readersem3", 2, "reader A", sem);
rd2 = create(readersem3, 2000, 30, "readersem3", 2, "reader B", sem2);
wr1 = create(writersem3, 2000, 40, "writersem3", 2, "writer C", sem);
kprintf("-start reader B, then sleep 1s. reader B(prio 30) blocked on the lock\n");
resume (rd2);
sleep (1);
kprintf("-start writer, then sleep 1s. lock granted to write (prio 20)\n");
resume(wr1);
sleep (1);
kprintf("-start reader A, then sleep 1s. reader A(prio 25) blocked on the lock\n");
resume(rd1);
assert(getprio(rd2)==40);
assert(getprio(rd1)==25);
assert(getprio(wr1)==40);
sleep (8);
kprintf ("Test 3 OK\n");
}
DEVCALL ttyinit(struct devsw *devptr)
{
register struct tty *iptr;
int isconsole;
int ubrr = UBRR;
/* set up tty parameters */
iptr = &tty[devptr->dvminor];
devptr->dvioblk = (char *) iptr; /* fill tty control blk */
isconsole = (devptr->dvnum == CONSOLE); /* make console cooked */
iptr->unit = devptr->dvminor; /* USART_ptr index */
iptr->ihead = iptr->itail = 0; /* empty input queue */
iptr->isem = screate(0); /* chars. read so far=0 */
iptr->icnt = 0; /* " */
iptr->osem = screate(OBUFLEN); /* buffer available=all */
iptr->ocnt = 0; /* " */
iptr->odsend = 0; /* sends delayed so far */
iptr->ohead = iptr->otail = 0; /* output queue empty */
iptr->ehead = iptr->etail = 0; /* echo queue empty */
iptr->imode = (isconsole ? IMCOOKED : IMRAW);
iptr->iecho = iptr->evis = isconsole; /* echo console input */
iptr->ierase = iptr->ieback = isconsole;/* console honors erase */
// iptr->ierasec = BACKSP; /* delete character ^H */
iptr->ierasec = 0x7f; /* delete character */
iptr->ecrlf = iptr->icrlf = isconsole; /* map RETURN on input */
iptr->ocrlf = iptr->oflow = isconsole;
iptr->ieof = iptr->ikill = isconsole; /* set line kill == @ */
iptr->iintr = FALSE;
iptr->iintrc = INTRCH;
iptr->iintpid = BADPID;
iptr->ikillc = KILLCH;
iptr->ieofc = EOFC;
iptr->oheld = FALSE;
iptr->ostart = STRTCH;
iptr->ostop = STOPCH;
iptr->icursor = 0;
iptr->ifullc = TFULLC;
/* initialize libc stdin, stdout, and stderr */
// if (isconsole)
// {
// stdin = stdout = stderr = &kprint_out; /* unbuffered, polled output */
// }
/* set up the USART */
USART_Init(devptr->dvminor, ubrr); /* found in kprintf.c */
*USART[devptr->dvminor].UCSRB |= (1<<RXCIE0); /* set RX Complete Interrupt Enable */
*USART[devptr->dvminor].UCSRB &= ~(1<<UDRIE0); /* clear USART Data Register empty Interrupt Enable */
return (OK);
}
/*------------------------------------------------------------------------
* rfinit -- initialize remote file pseudo devices
*------------------------------------------------------------------------
*/
rfinit(struct devsw *pdev)
{
struct rfblk *rfptr;
pdev->dvioblk = (char *) (rfptr = &Rf.rftab[pdev->dvminor]);
rfptr->rf_dnum = pdev->dvnum;
rfptr->rf_name[0] = NULLCH;
rfptr->rf_state = RFREE;
rfptr->rf_mutex = screate(1);
rfptr->rf_pos = 0L;
if (pdev->dvminor == 0) { /* done just once */
Rf.device = RCLOSED;
Rf.rmutex = screate(1);
}
}
int main()
{
int tid1;
turnDebugOn();
smutex_init(&mutex);
printf("Códigos retornados:\n");
printf("swait(12): %d\n", swait(12));
printf("syield(): %d\n", syield());
printf("slock(&mutex): %d\n", slock(&mutex));
printf("sunlock(&mutex): %d\n", sunlock(&mutex));
printf("E finalmente inicializando...\n");
printf("tid1 = screate(1, f_thread, NULL);\n");
tid1 = screate(1, f_thread, NULL);
printf("tid1 : %d\n", tid1);
swait(tid1);
return 0;
}
SYSCALL mutex_lock(MUTEX_REC_PTR *mutex_var)
{
int nsem;
int ps, ans;
disable(ps);
if ((*mutex_var) == (MUTEX_REC_PTR)NULL)
{
nsem = screate(1);
if (nsem == SYSERR)
{
restore(ps);
return SYSERR;
} /* if */
(*mutex_var) = (MUTEX_REC_PTR)getmem(sizeof(MUTEX_REC));
(*mutex_var)->nsem = nsem;
} /* if */
ans = wait((*mutex_var)->nsem);
(*mutex_var)->pid = currpid;
restore(ps);
return ans;
} /* mutex_lock */
/*------------------------------------------------------------------------
* ospfifinit - initialize OSPF interface data
*------------------------------------------------------------------------
*/
void
ospfifinit(int aindex, unsigned ifn)
{
struct ospf_if *pif = &ospf_if[ifn];
struct ospf_nb *pnb;
int i;
pif->if_type = IFT_BROADCAST;
pif->if_state = IFS_DOWN;
pif->if_area = &ospf_ar[aindex];
pif->if_hintv = HELLOINTV;
pif->if_rdintv = DEADINTV;
pif->if_xdelay = 1;
pif->if_prio = 1;
pif->if_rid = nif[NI_PRIMARY].ni_ip;
pif->if_drid = pif->if_brid = 0;
pif->if_metric = 1;
pif->if_opts = NBO_E;
pif->if_rintv = RXMTINTV;
memset(pif->if_auth, 0, AUTHLEN);
pif->if_nbmutex = screate(0);
/* "neighbor" 0 is the entry for this interface */
pnb = &pif->if_nbtab[0];
pnb->nb_state = NBS_FULL;
++pnb;
for (i=1; i<MAXNBR; ++i, ++pnb)
pnb->nb_state = NBS_DOWN;
signal(pif->if_nbmutex);
if (ifn == NI_PRIMARY)
hgjoin(NI_PRIMARY, AllSPFRouters, TRUE);
}
static _ctx *
_create_ctx(void)
{
_ctx *ctx;
ctx = flget(flctx);
if (!ctx)
return NULL;
ctx->cs = screate(100);
if (!ctx->cs)
return NULL;
ctx->pits = htcreate(HT_PIT_SIZE);
if (!ctx->pits)
return NULL;
ctx->sched_cnt = 0;
ctx->id = 0;
ctx->tid = 0;
ctx->name = NULL;
ctx->t0 = tickcount();
ctx->rec_levels = htcreate(HT_RLEVEL_SIZE);
if (!ctx->rec_levels)
return NULL;
return ctx;
}
//------------------------------------------------------------------------
// mkpool -- allocate memory for a buffer pool and link together
//------------------------------------------------------------------------
SYSCALL
mkpool(int bufsiz, int numbufs)
{
int ps;
int poolid;
char *where;
if (unmarked(bpmark))
poolinit();
ps = disable();
if (bufsiz < BPMINB || bufsiz > BPMAXB
|| numbufs < 1 || numbufs > BPMAXN
|| nbpools >= NBPOOLS
|| (where = (char *)getmem((bufsiz + sizeof(int)) * numbufs)) == (char *)SYSERR) {
restore(ps);
return SYSERR;
}
poolid = nbpools++;
bptab[poolid].bpnext = where;
bptab[poolid].bpsize = bufsiz;
bptab[poolid].bpsem = screate(numbufs);
bufsiz += sizeof(int);
for (numbufs--; numbufs > 0; numbufs--, where += bufsiz)
*((int *)where) = (int) (where + bufsiz);
*((int *)where) = (int) NULL;
restore(ps);
return poolid;
}
/*------------------------------------------------------------------------
* cominit -- initialize a com device (NS16{4/5}50)
*------------------------------------------------------------------------
*/
int
cominit(struct devsw *pdev)
{
struct comsoft *pcom;
void *csr = pdev->dvcsr;
/* void comint(); */ /* not needed and conflicting PW */
pcom = &comtab[pdev->dvminor];
pcom->com_pdev = pdev;
set_evec(pdev->dvivec, comint);
#ifdef X86
outb(csr+LCR, LCR_DLAB);
outb(csr+DLL, 12); /* 9600 baud */
outb(csr+DLM, 0); /* 9600 baud */
outb(csr+LCR, LCR_W8); /* 8N1 */
/* raise DTR and RTS & enable interrupts */
outb(csr+MCR, MCR_DTR | MCR_RTS | MCR_OUT2);
#endif
pcom->com_osema = screate(COMBUFSZ);
#ifdef X86
outb(csr+IER, 0x0f); /* enable interrupts */
(void) inb(csr+IIR);
#endif
return OK;
}
/*------------------------------------------------------------------------
* ipfinit - initialize IP fragment queue data structures
*------------------------------------------------------------------------
*/
void ipfinit()
{
int i;
ipfmutex = screate(1);
for (i=0; i<IP_FQSIZE; ++i)
ipfqt[i].ipf_state = IPFF_FREE;
}
void
srv(Srv *srv)
{
Req *r;
fmtinstall('D', dirfmt);
fmtinstall('F', fcallfmt);
if(srv->fpool == nil)
srv->fpool = allocfidpool(srv->destroyfid);
if(srv->rpool == nil)
srv->rpool = allocreqpool(srv->destroyreq);
if(srv->msize == 0)
srv->msize = 8192+IOHDRSZ;
changemsize(srv, srv->msize);
srv->fpool->srv = srv;
srv->rpool->srv = srv;
while(r = getreq(srv)){
if(r->error){
respond(r, r->error);
continue;
}
switch(r->ifcall.type){
default:
respond(r, "unknown message");
break;
case Tversion: sversion(srv, r); break;
case Tauth: sauth(srv, r); break;
case Tattach: sattach(srv, r); break;
case Tflush: sflush(srv, r); break;
case Twalk: swalk(srv, r); break;
case Topen: sopen(srv, r); break;
case Tcreate: screate(srv, r); break;
case Tread: sread(srv, r); break;
case Twrite: swrite(srv, r); break;
case Tclunk: sclunk(srv, r); break;
case Tremove: sremove(srv, r); break;
case Tstat: sstat(srv, r); break;
case Twstat: swstat(srv, r); break;
}
}
free(srv->rbuf);
srv->rbuf = nil;
free(srv->wbuf);
srv->wbuf = nil;
srv->msize = 0;
freefidpool(srv->fpool);
srv->fpool = nil;
freereqpool(srv->rpool);
srv->rpool = nil;
if(srv->end)
srv->end(srv);
}
int main()
{
int t1, t2;
turnDebugOn();
smutex_init(&mutex);
global = 0;
t1 = screate(0, func1, NULL);
t2 = screate(0, func2, NULL);
swait(t1);
swait(t2);
return 0;
}
void arpinit(void)
{
struct arpent *atabptr;
int i, j;
Arp.atabsiz = 0;
Arp.atabnxt = 0;
Arp.arpsem = screate(1);
Arp.rarpsem= screate(1);
Arp.arppid = Arp.rarppid = BADPID;
for (i=0 ; i<AR_TAB ; i++) {
atabptr = &Arp.arptab[i];
atabptr->arp_state = AR_FREE;
for (j=0 ; j<EPADLEN ; j++)
atabptr->arp_Ead[j] = '\0';
atabptr->arp_dev = -1;
}
}
/*------------------------------------------------------------------------
* arpinit - initialize data structures for ARP processing
*------------------------------------------------------------------------
*/
void arpinit()
{
int i;
rarpsem = screate(1);
rarppid = BADPID;
for (i=0; i<ARP_TSIZE; ++i)
arptable[i].ae_state = AS_FREE;
}
/*------------------------------------------------------------------------
* dginit - initialize datagram protocol pseudo device marking it free
*------------------------------------------------------------------------
*/
int
dginit(struct devsw *pdev)
{
struct dgblk *pdg;
pdev->dvioblk = (char *) (pdg = &dgtab[pdev->dvminor]);
pdg->dg_dnum = pdev->dvnum;
pdg->dg_state = DGS_FREE;
dgmutex = screate(1);
return OK;
}
/*------------------------------------------------------------------------
* ttyinit - initialize buffers and modes for a tty line
*------------------------------------------------------------------------
*/
int ttyinit(struct devsw *devptr)
{
register struct tty *iptr;
register struct csr *cptr;
int junk, isconsole;
/* set up interrupt vector and interrupt dispatch table */
iptr = &tty[devptr->dvminor];
iosetvec(devptr->dvnum, (int)iptr, (int)iptr);
devptr->dvioblk = (char *)iptr; /* fill tty control blk */
isconsole = (devptr->dvnum == CONSOLE); /* make console cooked */
iptr->ioaddr = (struct csr *)devptr->dvcsr;/* copy in csr addr. */
iptr->ihead = iptr->itail = 0; /* empty input queue */
iptr->isem = screate(0); /* chars. read so far=0 */
iptr->osem = screate(OBUFLEN); /* buffer available=all */
iptr->odsend = 0; /* sends delayed so far */
iptr->ohead = iptr->otail = 0; /* output queue empty */
iptr->ehead = iptr->etail = 0; /* echo queue empty */
iptr->imode = (isconsole ? IMCOOKED : IMRAW);
iptr->iecho = iptr->evis = isconsole; /* echo console input */
iptr->ierase = iptr->ieback = isconsole;/* console honors erase */
iptr->ierasec = BACKSP; /* using ^h */
iptr->ecrlf = iptr->icrlf = isconsole; /* map RETURN on input */
iptr->ocrlf = iptr->oflow = isconsole; /* map RETURN on output */
iptr->ikill = isconsole; /* set line kill == @ */
iptr->ikillc = ATSIGN;
iptr->oheld = FALSE;
iptr->ostart = STRTCH;
iptr->ostop = STOPCH;
iptr->icursor = 0;
iptr->ifullc = TFULLC;
cptr = (struct csr *)devptr->dvcsr;
junk = cptr->crbuf; /* clear receiver and */
cptr->crstat = SLUENABLE; /* enable in. interrupts*/
cptr->ctstat = SLUDISABLE; /* disable out. " */
return;
}
/*------------------------------------------------------------------------
* ttynew - allocate and initialize a tty structure
*------------------------------------------------------------------------
*/
struct tty *
ttynew()
{
struct tty *ptty, *ttyalloc();
ptty = ttyalloc();
if(ptty == 0)
return 0;
ptty->tty_tchars = dfltchars; /* struct copy */
ptty->tty_cpid = getpid();
ptty->tty_isema = screate(0);
ptty->tty_iflags = 0;
ptty->tty_istart = 0;
ptty->tty_icount = 0;
ptty->tty_osema = screate(OBLEN);
ptty->tty_oflags = 0;
ptty->tty_ostart = 0;
ptty->tty_ocount = 0;
return ptty;
}
int main(void *arg)
{
int sem, i;
(void)arg;
assert(screate(-2) == -1);
assert((sem = screate(2)) >= 0);
assert(signaln(sem, -4) < 0);
assert(sreset(sem, -3) == -1);
assert(scount(sem) == 2);
assert(signaln(sem, 32760) == 0);
assert(signaln(sem, 6) == -2);
assert(scount(sem) == 32762);
assert(wait(sem) == 0);
assert(scount(sem) == 32761);
assert(signaln(sem, 30000) == -2);
assert(scount(sem) == 32761);
assert(wait(sem) == 0);
assert(scount(sem) == 32760);
assert(signaln(sem, -2) < 0);
assert(scount(sem) == 32760);
assert(wait(sem) == 0);
assert(scount(sem) == 32759);
assert(signaln(sem, 8) == 0);
assert(scount(sem) == 32767);
assert(signaln(sem, 1) == -2);
assert(scount(sem) == 32767);
assert(signal(sem) == -2);
assert(scount(sem) == 32767);
for (i=0; i<32767; i++) {
assert(wait(sem) == 0);
}
assert(try_wait(sem) == -3);
assert(scount(sem) == 0);
assert(sdelete(sem) == 0);
printf("ok.\n");
}
/*------------------------------------------------------------------------
* tcpinit - initialize TCP slave pseudo device marking it free
*------------------------------------------------------------------------
*/
int
tcpinit(struct devsw *pdev)
{
struct tcb *tcb;
if (unmarked(tcpmark)) {
mark(tcpmark);
tcps_tmutex = screate(1);
tcps_lqsize = 5; /* default listen Q size */
}
pdev->dvioblk = (char *) (tcb = &tcbtab[pdev->dvminor]);
tcb->tcb_dvnum = pdev->dvnum;
tcb->tcb_state = TCPS_FREE;
return OK;
}
// Basic Priority Inheritance Test (XINU semaphores)
void basic_pinh_sem_test() {
int sem;
int rd1;
int wr1, wr2;
int lp;
kprintf("\nBasic Priority Inheritance Test (XINU sem)\n"
"Verify Writer B and Reader C never receives semaphore\n"
"because Writer B (pprio 10) has priority less than\n"
"looper process (pprio 15)\n"
" lock acquisition is:\n"
"writer A\n");
// Create a semaphore that only allows one accessor at a time.
sem = screate(1);
// Create a process that is always ready to run at priority 15
lp = create(looper, 2000, 15, "looper", 0, NULL);
wr1 = create(swriter, 2000, 20, "writer", 3, "writer A p20", sem, 5);
wr1 = create(swriter, 2000, 20, "writer", 3, "writer A p20", sem, 5);
wr2 = create(swriter, 2000, 10, "writer", 3, "writer B p10", sem, 2);
rd1 = create(sreader, 2000, 40, "reader", 3, "reader C p40", sem, 1);
kprintf("-start writer A (pprio 20), then sleep 1s.\n");
resume(wr1);
sleep(1);
kprintf("-start writer B (pprio 10), then sleep 1s.\n");
resume(wr2);
sleep(1);
// This will guarantee that writer B will never get chosen unless
// we boost its priority. We don't do that for sems => lock
kprintf("-start looper process (pprio 15), then sleep 1s.\n");
resume(lp);
sleep(1);
kprintf("-start reader C (pprio 40), then sleep 1s.\n");
resume(rd1);
sleep(1);
sleep (10);
kprintf ("Test finished, verify writer B and reader C never recieved sem!\n");
}
/*
*------------------------------------------------------------------------
* clkinit - initialize the clock and sleep queue (called at startup)
*------------------------------------------------------------------------
*/
void clkinit()
{
preempt = QUANTUM; /* initial time quantum */
countTick = TICK; /* TICKs of a sec. counter */
clmutex = screate(1); /* semaphore for tod clock */
clktime = 0L; /* initially a low number */
ctr100 = 0L; /* timer (relative) */
slnempty = FALSE; /* initially, no process asleep */
clkdiff = 0; /* zero deferred ticks */
defclk = FALSE; /* clock is not deferred */
clkruns = 1;
clockq = newqueue();
/* Initialize timer 3 (System Clock) */
/* 100 Hz clock 16000000/256/(1+624) */
/* OCR3A set to 624 for CTC mode */
OCR3AH = hibyte(624); /* 0-624 => divide by 625 */
OCR3AL = lobyte(624); /* write high byte first! */
TCNT3L = 0x00;
TCNT3H = 0x00;
TCCR3A = 0x00; /* normal port operation, WGM31=0 WGM30=0 */
TCCR3B = (1<<CS32) | (0<<CS31) | (0<<CS30); /* (clock source/256) for 62500Hz */
TCCR3B |= (1 << WGM32); /* normal mode 4: CTC w/OCR3A */
TCCR3C = 0x00;
TIMSK3 |= (1<<OCF3A); /* Clear overflow flag bit */
TIMSK3 |= (1<<OCIE3A); /* Output Compare A Match Interrupt Enable */
/* Initialize timer 2 (RTC) */
TIMSK2 &= ~((1<<TOIE2)|(1<<OCIE2A)|(1<<OCIE2B)); //Disable TC2 interrupt
ASSR |= (1<<AS2); //set Timer/Counter2 to be asynchronous from the CPU clock
//with a second external clock(32.768kHz)driving it.
TCNT2 = 0x00;
TCCR2A = 0x00; //normal mode 0
TCCR2B = 0x05; //prescale the timer to be clock source / 128
//
//TIMER2 quit working on me 12/21/2013 -- change rtc & MAC Symbol counter!!!!!!!!!!!!!!!!!!
//
// while(ASSR&0x1F)
// while(ASSR&( (1<<TCR2BUB)|(1<<OCR2BUB)|(1<<TCN2UB) ))
// ; //Wait until TC0 is updated
// TIFR2 |= (1<<TOV2); //Clear overflow flag bit
// TIMSK2 |= (1<<TOIE2); //set 8-bit Timer/Counter0 Overflow Interrupt Enable
}
/*------------------------------------------------------------------------
* tcptimer - TCP timer process
*------------------------------------------------------------------------
*/
PROCESS
tcptimer(void)
{
long now, lastrun; /* times from system clock */
int delta; /* time since last iteration */
struct tqent *tq; /* temporary delta list ptr */
lastrun = ctr100; /* initialize to "now" */
tqmutex = screate(1); /* mutual exclusion semaphore */
tqpid = getpid(); /* record timer process id */
signal(Net.sema); /* start other network processes*/
while (TRUE) {
sleep10(TIMERGRAN); /* real-time delay */
if (tqhead == 0) /* block timer process if delta */
suspend(tqpid); /* list is empty */
wait(tqmutex);
now = ctr100;
delta = now - lastrun; /* compute elapsed time */
/* Note: check for possible clock reset (time moved */
/* backward or delay was over an order of magnitude too */
/* long) */
if (delta < 0 || delta > TIMERGRAN*100)
delta = TIMERGRAN*10; /* estimate the delay */
lastrun = now;
while (tqhead != 0 && tqhead->tq_timeleft <= delta) {
delta -= tqhead->tq_timeleft;
if (pcount(tqhead->tq_port) <= tqhead->tq_portlen)
psend(tqhead->tq_port,
(int)tqhead->tq_msg);
tq = tqhead;
tqhead = tqhead->tq_next;
freemem(tq, sizeof(struct tqent));
}
if (tqhead)
tqhead->tq_timeleft -=delta;
signal(tqmutex);
}
}
/*------------------------------------------------------------------------
* tcballoc - allocate a Transmission Control Block
*------------------------------------------------------------------------
*/
struct tcb *
tcballoc(void)
{
struct tcb *ptcb;
int slot;
wait(tcps_tmutex);
/* look for a free TCB */
for (ptcb=&tcbtab[0], slot=0; slot<Ntcp; ++slot, ++ptcb)
if (ptcb->tcb_state == TCPS_FREE)
break;
if (slot < Ntcp) {
ptcb->tcb_state = TCPS_CLOSED;
ptcb->tcb_mutex = screate(0);
} else
ptcb = (struct tcb *)SYSERR;
signal(tcps_tmutex);
return ptcb;
}
static int
_sgrow(_cstack * cs)
{
int i;
_cstack *dummy;
dummy = screate(cs->size*2);
if(!dummy)
return 0;
for(i=0; i<cs->size; i++) {
dummy->_items[i].ckey = cs->_items[i].ckey;
dummy->_items[i].t0 = cs->_items[i].t0;
}
yfree(cs->_items);
cs->_items = dummy->_items;
cs->size = dummy->size;
yfree(dummy);
return 1;
}
int
main (int argc, char **argv) {
if ((sema = screate(0)) == -1) {
perror("couldn't create semaphore");
exit(1);
}
write(STDOUT_FILENO, PARENT_MSG_1, LENGTH(PARENT_MSG_1));
sleep(1);
switch(fork(_child)) {
case -1:
perror("fork failed");
exit(1);
default:
swait(sema);
write(STDOUT_FILENO, PARENT_MSG_2, LENGTH(PARENT_MSG_2));
write(STDOUT_FILENO, TEST_MSG, LENGTH(TEST_MSG));
}
return 0;
}
void shmem_test() {
int p1, p2;
int sem;
kprintf("\nBasic shared memory test\n");
// Create semaphore
sem = screate(1);
// Create a process that is always ready to run at priority 15
p1 = create(shmemproducer, 2000, 20, "shmemproducer", 1, sem);
p2 = create(shmemconsumer, 2000, 20, "shmemconsumer", 1, sem);
// Start the task
kprintf("start producer (pprio 20), then sleep 1s.\n");
resume(p1);
//sleep(1);
// Start the task
kprintf("start consumer (pprio 20), then sleep 1s.\n");
resume(p2);
}
/*
*------------------------------------------------------------------------
* clkinit - initialize the clock and sleep queue (called at startup)
*------------------------------------------------------------------------
*/
void clkinit()
{
unsigned short intv;
int clkint();
set_evec(IRQBASE, (u_long)clkint);
/* clock rate is 1.190 Mhz; this is 10ms interrupt rate */
intv = 1190;
clkruns = 1;
clockq = newqueue();
preempt = QUANTUM; /* initial time quantum */
clmutex = screate(1);
/* set to: timer 0, 16-bit counter, rate generator mode,
counter is binary */
outb(CLKCNTL, 0x34);
/* must write LSB first, then MSB */
outb(CLOCK0, (char)intv);
outb(CLOCK0, intv>>8);
outb(CLOCK0, intv>>8);
}
/*------------------------------------------------------------------------
* netinit - initialize network data structures
*------------------------------------------------------------------------
*/
netinit()
{
struct netq *nqptr;
int i;
/* Initialize pool of network buffers and rest of Net structure */
if (clkruns == FALSE)
panic("net: no clock");
Net.netpool = mkpool(EMAXPAK, NETBUFS);
for (i=0 ; i<NETQS ; i++) {
nqptr = &Net.netqs[i];
nqptr->valid = FALSE;
nqptr->uport = -1;
nqptr->xport = pcreate(NETQLEN);
}
Net.mavalid = FALSE;
dtoIP(&Net.gateway, NETGATE);
Net.nxtprt = ULPORT;
Net.nmutex = screate(1);
Net.npacket = Net.ndrop = Net.nover = 0;
return(OK);
}
int main(int argc, char *argv[]) {
int i, pid[MAX_THR];
for (i = 0; i < MAX_THR; i++) {
pid[i] = screate((i%3), func, (void *)('A'+i));
if ( pid[i] == -1) {
printf("ERRO: criação de thread!\n");
exit(-1);
}
}
for (i = 0; i < MAX_THR; i++)
swait(pid[i]);
for (i = 0; i < MAX_SIZE; i++) {
if ( (i % 20) == 0 )
printf("\n");
printf("%c", (char)vetor[i]);
}
printf("\nConcluido vetor de letras com priuoridades...\n");
exit(0);
}
int main()
{
int lck, lrdm, lwrl, lwrh, sem, srdm, swrl, swrh, lloop, sloop;
kprintf("Start priority inversion test with lock\n");
lck = lcreate();
lloop = create(dowait, 2000, 25, "dowait", 1, 5);
lwrh = create(lwr, 2000, 30, "writer", 4, "writer H", lck, 20, 2);
lwrl = create(lwr, 2000, 10, "writer", 4, "writer L", lck, 20, 5);
lrdm = create(lrd, 2000, 20, "reader", 4, "reader M", lck, 20, 1);
kprintf("Start Writer L, then sleep 1s\n");
resume(lwrl);
sleep(1);
kprintf("Start Writer H, then sleep 1s\n");
resume(lwrh);
sleep(1);
kprintf("Start dowait, then sleep 1s\n");
resume(lloop);
sleep(1);
sleep(10);
kprintf ("Lock test finished!\n");
kprintf("Start priority inversion test with semaphore\n");
sem = screate(1);
sloop= create(dowait, 2000, 20, "dowait", 1, 5);
swrh = create(srw, 2000, 30, "writer", 3, "writer H", sem, 5);
swrl = create(srw, 2000, 10, "writer", 3, "writer L", sem, 3);
srdm = create(srw, 2000, 40, "reader", 3, "reader M", sem, 1);
kprintf("Start Writer L, then sleep 1s\n");
resume(swrl);
sleep(1);
kprintf("Start Writer H, then sleep 1s\n");
resume(swrh);
sleep(1);
kprintf("Start dowait, then sleep 1s\n");
resume(sloop);
sleep(1);
sleep(10);
kprintf ("Semaphore test finished!\n");
return 0;
}
