/*------------------------------------------------------------------------
* chprio -- change the scheduling priority of a process
*------------------------------------------------------------------------
*/
SYSCALL
chprio(int pid, unsigned newprio)
{
STATWORD ps;
int oldprio;
struct pentry *pptr;
disable(ps);
if (isbadpid(pid) ||
(pptr = &proctab[pid])->pstate == PRFREE) {
restore(ps);
return SYSERR;
}
oldprio = pptr->pprio;
pptr->pprio = newprio;
switch (pptr->pstate) {
case PRREADY:
insert( dequeue(pid), rdyhead, newprio);
case PRCURR:
resched();
default:
break;
}
restore(ps);
return oldprio;
}
/*------------------------------------------------------------------------
* chprio -- change the scheduling priority of a process
*------------------------------------------------------------------------
*/
SYSCALL chprio(int pid, int newprio)
{
STATWORD ps;
struct pentry *pptr;
disable(ps);
if (isbadpid(pid) || newprio<=0 ||
(pptr = &proctab[pid])->pstate == PRFREE) {
restore(ps);
return(SYSERR);
}
pptr->pprio = newprio;
// If we are currently using the aging scheduler...
if (getschedclass() == AGINGSCHED) {
// We want to updated the queue priority now
// (the linux-like scheduler will do that itself)
q[pid].qkey = newprio;
// If this priority is in the ready queue...
if (isinqueue(pid, rdyhead)) {
// Then we need to remove it from the queue
dequeue(pid);
// And put it back in so that the queue
// will remain sorted
insert(pid, rdyhead, newprio);
}
}
restore(ps);
return(newprio);
}
/*------------------------------------------------------------------------
* suspend -- suspend a process, placing it in hibernation
*------------------------------------------------------------------------
*/
SYSCALL suspend(int pid)
{
STATWORD ps;
struct pentry *pptr; /* pointer to proc. tab. entry */
int prio; /* priority returned */
unsigned long stime = ctr1000;
UPDATE_SCALL_FREQ(currpid, SCALL_SUSPEND);
disable(ps);
if (isbadpid(pid) || pid==NULLPROC ||
((pptr= &proctab[pid])->pstate!=PRCURR && pptr->pstate!=PRREADY)) {
restore(ps);
UPDATE_SCALL_TIME(currpid, SCALL_SUSPEND, stime);
return(SYSERR);
}
if (pptr->pstate == PRREADY) {
pptr->pstate = PRSUSP;
dequeue(pid);
}
else {
pptr->pstate = PRSUSP;
resched();
}
prio = pptr->pprio;
restore(ps);
UPDATE_SCALL_TIME(currpid, SCALL_SUSPEND, stime);
return(prio);
}
/*------------------------------------------------------------------------
* unsleep -- remove process from the sleep queue prematurely
*------------------------------------------------------------------------
*/
SYSCALL unsleep(int pid)
{
STATWORD ps;
struct pentry *pptr;
struct qent *qptr;
int remain;
int next;
unsigned long stime = ctr1000;
UPDATE_SCALL_FREQ(currpid, SCALL_UNSLEEP);
disable(ps);
if (isbadpid(pid) ||
( (pptr = &proctab[pid])->pstate != PRSLEEP &&
pptr->pstate != PRTRECV) ) {
restore(ps);
UPDATE_SCALL_TIME(currpid, SCALL_UNSLEEP, stime);
return(SYSERR);
}
qptr = &q[pid];
remain = qptr->qkey;
if ( (next=qptr->qnext) < NPROC)
q[next].qkey += remain;
dequeue(pid);
if ( (next=q[clockq].qnext) < NPROC)
sltop = (int *) & q[next].qkey;
else
slnempty = FALSE;
restore(ps);
UPDATE_SCALL_TIME(currpid, SCALL_UNSLEEP, stime);
return(OK);
}
/*------------------------------------------------------------------------
* chprio -- change the scheduling priority of a process
*------------------------------------------------------------------------
*/
SYSCALL chprio(int pid, int newprio)
{
int start_time;
int curridx = 1;
if(syscall_trace_on == 1) {
syscall_used[currpid] = 1;
syscall_cnt[currpid][curridx]++;
start_time = ctr1000;
}
STATWORD ps;
struct pentry *pptr;
disable(ps);
if (isbadpid(pid) || newprio<=0 ||
(pptr = &proctab[pid])->pstate == PRFREE) {
restore(ps);
if(syscall_trace_on == 1) {
syscall_time[currpid][curridx] += ctr1000 - start_time;
}
return(SYSERR);
}
pptr->pprio = newprio;
restore(ps);
if(syscall_trace_on == 1) {
syscall_time[currpid][curridx] += ctr1000 - start_time;
}
return(newprio);
}
/*------------------------------------------------------------------------
* unsleep -- remove process from the sleep queue prematurely
*------------------------------------------------------------------------
*/
SYSCALL unsleep(int pid)
{
STATWORD ps;
struct pentry *pptr;
struct qent *qptr;
int remain;
int next;
disable(ps);
if (isbadpid(pid) ||
( (pptr = &proctab[pid])->pstate != PRSLEEP &&
pptr->pstate != PRTRECV) ) {
restore(ps);
return(SYSERR);
}
qptr = &q[pid];
remain = qptr->qkey;
if ( (next=qptr->qnext) < NPROC)
q[next].qkey += remain;
dequeue(pid);
if ( (next=q[clockq].qnext) < NPROC)
sltop = (int *) & q[next].qkey;
else
slnempty = FALSE;
restore(ps);
return(OK);
}
/*------------------------------------------------------------------------
* ready - Make a process eligible for CPU service
*------------------------------------------------------------------------
*/
status ready(
pid32 pid /* ID of process to make ready */
)
{
register struct procent *prptr;
if (isbadpid(pid)) {
return SYSERR;
}
/* Set process state to indicate ready and add to ready list */
prptr = &proctab[pid];
record_cpuqdata(pid); /* call function to record process state time data */
/* (actual recording is controlled by EV_CPUQDATA env var and choice of scheduler) */
prptr->prstate = PR_READY;
readycount++; /* increase the readylist count tracker */
/* assigns a new adjusted priority based on the scheduler currently active */
prptr->prprio = setprio(pid);
insert(pid, readylist, prptr->prprio);
resched();
return OK;
}
/*------------------------------------------------------------------------
* send - pass a message to a process and start recipient if waiting
*------------------------------------------------------------------------
*/
syscall send(
pid32 pid, /* ID of recipient process */
umsg32 msg /* contents of message */
)
{
intmask mask; /* saved interrupt mask */
struct procent *prptr; /* ptr to process' table entry */
mask = disable();
if (isbadpid(pid)) {
restore(mask);
return SYSERR;
}
prptr = &proctab[pid];
if ((prptr->prstate == PR_FREE) || prptr->prhasmsg) {
restore(mask);
return SYSERR;
}
prptr->prmsg = msg; /* deliver message */
prptr->prhasmsg = TRUE; /* indicate message is waiting */
/* If recipient waiting or in timed-wait make it ready */
if (prptr->prstate == PR_RECV) {
ready(pid, RESCHED_YES);
} else if (prptr->prstate == PR_RECTIM) {
unsleep(pid);
ready(pid, RESCHED_YES);
}
restore(mask); /* restore interrupts */
return OK;
}
/* Name: l_clear_pidmaps
*
* Desc: Clears all the entries corresponding to the pid in all available
* lid's pidmaps. This is usually called when a process is killed.
*
* Params:
* pid - process ID of the process whose pid-bit is to be cleared
*
* Returns: int
* OK - on success
* SYSERR - on error
*/
int
l_clear_pidmaps(int pid)
{
int lid = EMPTY;
STATWORD ps;
disable(ps);
DTRACE_START;
if (isbadpid(pid)) {
DTRACE("DBG$ %d %s> bad pid %d\n", currpid, __func__, pid);
goto RETURN_ERROR;
}
/* Go thru all the locks and clear the pid-bit on all the pidmaps. */
for (lid = 0; lid < NLOCKS; ++lid) {
l_pidmap_oper(lid, pid, L_MAP_DELETE, L_MAP_CLR);
l_pidmap_oper(lid, pid, L_MAP_RELEASE, L_MAP_CLR);
l_pidmap_oper(lid, pid, L_MAP_LOG, L_MAP_CLR);
}
DTRACE_END;
restore(ps);
return OK;
RETURN_ERROR:
DTRACE_END;
restore(ps);
return SYSERR;
}
/*------------------------------------------------------------------------
* send -- send a message to another process
*------------------------------------------------------------------------
*/
SYSCALL send(int pid, WORD msg)
{
int start;
if(activated == 1)
start = ctr1000;
STATWORD ps;
struct pentry *pptr;
disable(ps);
if (isbadpid(pid) || ( (pptr= &proctab[pid])->pstate == PRFREE)
|| pptr->phasmsg != 0) {
restore(ps);
if(activated == 1)
{
Info[currpid][SEND].freq++;
Info[currpid][SEND].time += (ctr1000 - start);
}
return(SYSERR);
}
pptr->pmsg = msg;
pptr->phasmsg = TRUE;
if (pptr->pstate == PRRECV) /* if receiver waits, start it */
ready(pid, RESCHYES);
else if (pptr->pstate == PRTRECV) {
unsleep(pid);
ready(pid, RESCHYES);
}
restore(ps);
if(activated == 1)
{
Info[currpid][SEND].freq++;
Info[currpid][SEND].time += (ctr1000 - start);
}
return(OK);
}
/*------------------------------------------------------------------------
* insert - Insert a process into a queue in descending key order
*------------------------------------------------------------------------
*/
status insert_real(
pid32 pid, /* ID of process to insert */
qid16 q, /* ID of queue to use */
double key /* Key for the inserted process */
)
{
int16 curr; /* Runs through items in a queue*/
int16 prev; /* Holds previous node index */
if (isbadqid(q) || isbadpid(pid)) {
return SYSERR;
}
curr = firstid(q);
while (queuetab[curr].real_qkey >= key) {
curr = queuetab[curr].qnext;
}
/* Insert process between curr node and previous node */
prev = queuetab[curr].qprev; /* Get index of previous node */
queuetab[pid].qnext = curr;
queuetab[pid].qprev = prev;
queuetab[pid].real_qkey = key;
queuetab[prev].qnext = pid;
queuetab[curr].qprev = pid;
return OK;
}
/*------------------------------------------------------------------------
* chprio -- change the scheduling priority of a process
*------------------------------------------------------------------------
*/
SYSCALL chprio(int pid, int newprio)
{
STATWORD ps;
struct pentry *pptr;
disable(ps);
if (isbadpid(pid) || newprio<=0 ||
(pptr = &proctab[pid])->pstate == PRFREE) {
restore(ps);
return(SYSERR);
}
pptr->pprio = newprio;
if(pptr -> pstate == PRREADY) {
dequeue(pid);
insert(pid, rdyhead, pptr -> pprio);
}
// Update the processes priority inheritance
update_priority(pid);
// If the process is waiting for a lock then update the lock
if (pptr->pstate == PRLOCK) {
// Update lppriomax for the lock (max priority of all waiting procs)
update_lppriomax(LOCK_INDEX(pptr->plock));
// Update pinh for all procs that hold this lock.
update_pinh(LOCK_INDEX(pptr->plock));
}
restore(ps);
return(newprio);
}
/*******************************************************************************
* Name: remove_pgd
*
* Desc: Removes the pgd of a proc and frees the frame.
*
* Params:
* pid - pid whose pgd has to be removed
*
* Returns: Nothing.
******************************************************************************/
void
remove_pgd(int pid)
{
int pgd_fr_id = EMPTY;
STATWORD ps;
disable(ps);
DTRACE_START;
if (isbadpid(pid) || (PRFREE == P_GET_PSTATE(pid))) {
DTRACE("DBG$ %d %s> bad pid %d or bad state %d\n", \
currpid, __func__, pid, P_GET_PSTATE(pid));
goto RESTORE_AND_RETURN;
}
/* Each process has a pdir whose base addr is stored in pgdir field of
* the PCB. This is hosted on a frame and we need to free that frame as the
* process is being killed.
*/
pgd_fr_id = FR_PA_TO_ID(P_GET_PDIR(pid));
free_frm(pgd_fr_id);
RESTORE_AND_RETURN:
DTRACE_END;
restore(ps);
return;
}
/*------------------------------------------------------------------------
* insertd - Insert a process in delta list using delay as the key
*------------------------------------------------------------------------
*/
status insertd( /* assumes interrupts disabled */
pid32 pid, /* ID of process to insert */
qid16 q, /* ID of queue to use */
int32 key /* delay from "now" (in ms.) */
)
{
int next; /* runs through the delta list */
int prev; /* follows next through the list*/
if (isbadqid(q) || isbadpid(pid)) {
return SYSERR;
}
prev = queuehead(q);
next = queuetab[queuehead(q)].qnext;
while ((next != queuetail(q)) && (queuetab[next].qkey <= key)) {
key -= queuetab[next].qkey;
prev = next;
next = queuetab[next].qnext;
}
/* Insert new node between prev and next nodes */
queuetab[pid].qnext = next;
queuetab[pid].qprev = prev;
queuetab[pid].qkey = key;
queuetab[prev].qnext = pid;
queuetab[next].qprev = pid;
if (next != queuetail(q)) {
queuetab[next].qkey -= key;
}
return OK;
}
/*------------------------------------------------------------------------
* ready - Make a process eligible for CPU service
*------------------------------------------------------------------------
*/
status ready(
pid32 pid, /* ID of process to make ready */
bool8 resch /* reschedule afterward? */
)
{
register struct procent *prptr;
int rrChecker = 1 ; /* variable to check if round robin should run */
if (isbadpid(pid)) {
return(SYSERR);
}
/* Set process state to indicate ready and add to ready list */
prptr = &proctab[pid];
prptr->prstate = PR_READY;
if (rrChecker != 1) {
insert(pid, readylist, prptr->prprio);
} else if (rrChecker == ROUND_ROBIN) {
insert(pid, readylist, prptr->prprio);
}
if (resch == RESCHED_YES) {
resched();
}
return OK;
}
//------------------------------------------------------------------------
// rarp_in - handle RARP packet coming in from Ethernet network
//------------------------------------------------------------------------
int
rarp_in(struct epacket *packet, int dev)
{
int ps;
int pid;
int ret;
struct arppak *apacptr;
struct etblk *etptr;
apacptr = (struct arppak *)packet->ep_data;
ret = SYSERR;
if (net2hs(apacptr->ar_op) == AR_RRLY) {
etptr = (struct etblk *)devtab[dev].iobuf;
if (memcmp(apacptr->ar_tha, etptr->etpaddr, EPADLEN) == 0) {
memmove(Net.myaddr, apacptr->ar_tpa, IPLEN);
netnum(Net.mynet, Net.myaddr);
ps = disable();
Net.mavalid = TRUE;
pid = Arp.rarppid;
if (!isbadpid(pid)) {
Arp.rarppid = BADPID;
send(pid, OK);
}
restore(ps);
}
ret = OK;
}
freebuf(packet);
return ret;
}
/*------------------------------------------------------------------------
* ready - Make a process eligible for CPU service
*------------------------------------------------------------------------
*/
status ready(
pid32 pid, /* ID of process to make ready */
bool8 resch /* reschedule afterward? */
)
{
register struct procent *prptr;
if (isbadpid(pid)) {
return(SYSERR);
}
/* Set process state to indicate ready and add to ready list */
prptr = &proctab[pid];
prptr->prstate = PR_READY;
if (ROUND_ROBIN == 1)
{
enqueue(pid, readylist);
}
else
{
insert(pid, readylist, prptr->prprio);
}
if (resch == RESCHED_YES) {
resched();
}
return OK;
}
/*------------------------------------------------------------------------
* chprio -- change the scheduling priority of a process
*------------------------------------------------------------------------
*/
SYSCALL chprio(int pid, int newprio)
{
unsigned long timer_start_value=ctr1000;
if(start_summary==1)
{
summary_tab[currpid][1].syscall_name="sys_chprio";
summary_tab[currpid][1].frequency+=1;
}
STATWORD ps;
struct pentry *pptr;
disable(ps);
if (isbadpid(pid) || newprio<=0 ||
(pptr = &proctab[pid])->pstate == PRFREE) {
restore(ps);
summary_tab[currpid][1].time+=ctr1000-timer_start_value;
return(SYSERR);
}
pptr->pprio = newprio;
restore(ps);
summary_tab[currpid][1].time+=ctr1000-timer_start_value;
return(newprio);
}
/**
* Remove a process from anywhere in a queue
* @param pid process ID to remove
* @return process id of removed process
*/
short remove(short pid)
{
if (isbadpid(pid)) { return SYSERR; }
queuetab[queuetab[pid].prev].next = queuetab[pid].next;
queuetab[queuetab[pid].next].prev = queuetab[pid].prev;
return pid;
}
syscall sendb(
pid32 pid, /* ID of recipient process */
umsg32 msg /* contents of message */
)
{
intmask mask; /* saved interrupt mask */
struct procent *prptr; /* ptr to process' table entry */
mask = disable();
if (isbadpid(pid)) {
restore(mask);
return SYSERR;
}
prptr = &proctab[pid];
if (prptr->prstate == PR_FREE) {
restore(mask);
return SYSERR;
}
/* another pointer to process table */
/* CONDITIONS:
* if process has a message
* - sendflag = true
* - state changes to pr send
* else
* - state of prhasmsg is true
*/
if( prptr -> prhasmsg){
struct procent *sendMessage;
sendMessage = &proctab[currpid];
sendMessage -> prstate = PR_SND; /* setting the message state to PR_SEND */
sendMessage -> sndmsg = msg;
sendMessage -> sndflag = TRUE; /* message to send */
enqueue(currpid, prptr -> messagesQueue);
resched();
}
prptr->prmsg = msg; /* deliver message */
prptr->prhasmsg = TRUE; /* indicate message is waiting */
if (prptr->prstate == PR_RECV) { ready(pid, RESCHED_YES );
}
else if (prptr->prstate == PR_RECTIM) {
unsleep(pid);
ready(pid, RESCHED_YES);
}
restore(mask); /* restore interrupts */
return OK;
}
/*------------------------------------------------------------------------
* kill -- kill a process and remove it from the system
*------------------------------------------------------------------------
*/
SYSCALL kill(int pid)
{
STATWORD ps;
struct pentry *pptr; /* points to proc. table for pid*/
int dev;
inversion(pid);
disable(ps);
if (isbadpid(pid) || (pptr= &proctab[pid])->pstate==PRFREE) {
restore(ps);
return(SYSERR);
}
if (--numproc == 0)
xdone();
dev = pptr->pdevs[0];
if (! isbaddev(dev) )
close(dev);
dev = pptr->pdevs[1];
if (! isbaddev(dev) )
close(dev);
dev = pptr->ppagedev;
if (! isbaddev(dev) )
close(dev);
send(pptr->pnxtkin, pid);
freestk(pptr->pbase, pptr->pstklen);
switch (pptr->pstate) {
case PRCURR: pptr->pstate = PRFREE; /* suicide */
resched();
case PRWAIT: semaph[pptr->psem].semcnt++;
int i;
for(i=0;i<NLOCKS;i++)
{
if(proctab[pid].holding_lock[i].type != -1)
{
lockarr[i].lockcnt--;
lockarr[i].process_lock[pid]=-1;
if(proctab[pid].holding_lock[i].type==READ)
lockarr[i].read_count--;
}
}
case PRREADY: dequeue(pid);
pptr->pstate = PRFREE;
break;
case PRSLEEP:
case PRTRECV: unsleep(pid);
/* fall through */
default: pptr->pstate = PRFREE;
}
restore(ps);
return(OK);
}
/*------------------------------------------------------------------------
* kill -- kill a process and remove it from the system
*------------------------------------------------------------------------
*/
SYSCALL kill(int pid)
{
STATWORD ps;
struct pentry *pptr; /* points to proc. table for pid*/
int dev;
int i;
disable(ps);
if (isbadpid(pid) || (pptr= &proctab[pid])->pstate==PRFREE) {
restore(ps);
return(SYSERR);
}
#ifdef ENABLE_LOCKS
for (i = 0; i < NLOCKS; i++){
if (locktab[i].procs[pid].lstate == LOCKED)
release_lock(CREATELDESC(i, locktab[i].procs[pid].lage), pid);
locktab[i].procs[pid].lstate = UNLOCKED;
}
#endif
if (--numproc == 0)
xdone();
dev = pptr->pdevs[0];
if (! isbaddev(dev) )
close(dev);
dev = pptr->pdevs[1];
if (! isbaddev(dev) )
close(dev);
dev = pptr->ppagedev;
if (! isbaddev(dev) )
close(dev);
send(pptr->pnxtkin, pid);
freestk(pptr->pbase, pptr->pstklen);
switch (pptr->pstate) {
case PRCURR: pptr->pstate = PRFREE; /* suicide */
resched();
case PRWAIT: semaph[pptr->psem].semcnt++;
case PRLOCK:
case PRREADY: dequeue(pid);
pptr->pstate = PRFREE;
break;
case PRSLEEP:
case PRTRECV: unsleep(pid);
/* fall through */
default: pptr->pstate = PRFREE;
}
restore(ps);
return(OK);
}
/*------------------------------------------------------------------------
* kill -- kill a process and remove it from the system
*------------------------------------------------------------------------
*/
SYSCALL kill(int pid)
{
extern int flag;
if(flag==1){
extern int freq[6][NPROC];
freq[2][currpid]++;
kprintf("########################################\n");
kprintf("System Call(2) 'kill' being called by \"%s\" (pid=%d)\n", proctab[currpid].pname, currpid);
kprintf("########################################\n");
}
STATWORD ps;
struct pentry *pptr; /* points to proc. table for pid*/
int dev;
disable(ps);
if (isbadpid(pid) || (pptr= &proctab[pid])->pstate==PRFREE) {
restore(ps);
return(SYSERR);
}
if (--numproc == 0)
xdone();
dev = pptr->pdevs[0];
if (! isbaddev(dev) )
close(dev);
dev = pptr->pdevs[1];
if (! isbaddev(dev) )
close(dev);
dev = pptr->ppagedev;
if (! isbaddev(dev) )
close(dev);
send(pptr->pnxtkin, pid);
freestk(pptr->pbase, pptr->pstklen);
switch (pptr->pstate) {
case PRCURR: pptr->pstate = PRFREE; /* suicide */
resched();
case PRWAIT: semaph[pptr->psem].semcnt++;
case PRREADY: dequeue(pid);
pptr->pstate = PRFREE;
break;
case PRSLEEP:
case PRTRECV: unsleep(pid);
/* fall through */
default: pptr->pstate = PRFREE;
}
restore(ps);
return(OK);
}
/*------------------------------------------------------------------------
* kill - Kill a process and remove it from the system
*------------------------------------------------------------------------
*/
syscall kill(
pid32 pid /* ID of process to kill */
)
{
intmask mask; /* Saved interrupt mask */
struct procent *prptr; /* Ptr to process's table entry */
int32 i; /* Index into descriptors */
mask = disable();
if (isbadpid(pid) || (pid == NULLPROC)
|| ((prptr = &proctab[pid])->prstate) == PR_FREE) {
restore(mask);
return SYSERR;
}
if (prptr->prcleanup != NULL){
prptr->prcleanup();
}
if (--prcount <= 1) { /* Last user process completes */
xdone();
}
send(prptr->prparent, pid);
for (i=0; i<3; i++) {
close(prptr->prdesc[i]);
}
freestk(prptr->prstkbase, prptr->prstklen);
switch (prptr->prstate) {
case PR_CURR:
prptr->prstate = PR_FREE; /* Suicide */
resched();
case PR_SLEEP:
case PR_RECTIM:
unsleep(pid);
prptr->prstate = PR_FREE;
break;
case PR_WAIT:
semtab[prptr->prsem].scount++;
/* Fall through */
case PR_READY:
getitem(pid); /* Remove from queue */
/* Fall through */
default:
prptr->prstate = PR_FREE;
}
restore(mask);
return OK;
}
/*------------------------------------------------------------------------
* setdev - set the two device entries in the process table entry
*------------------------------------------------------------------------
*/
SYSCALL setdev(int pid, int dev1, int dev2)
{
short *nxtdev;
if (isbadpid(pid))
return(SYSERR);
nxtdev = (short *) proctab[pid].pdevs;
*nxtdev++ = dev1;
*nxtdev = dev2;
return(OK);
}
/*------------------------------------------------------------------------
* kill -- kill a process and remove it from the system
*------------------------------------------------------------------------
*/
SYSCALL kill(int pid)
{
STATWORD ps;
struct pentry *pptr; /* points to proc. table for pid*/
int dev, pdbr;
disable(ps);
if (isbadpid(pid) || (pptr= &proctab[pid])->pstate==PRFREE) {
restore(ps);
return(SYSERR);
}
if (--numproc == 0)
xdone();
dev = pptr->pdevs[0];
if (! isbaddev(dev) )
close(dev);
dev = pptr->pdevs[1];
if (! isbaddev(dev) )
close(dev);
dev = pptr->ppagedev;
if (! isbaddev(dev) )
close(dev);
send(pptr->pnxtkin, pid);
proc_dies_clean_bs(pid);
pdbr = proctab[pid].pdbr;
//kprintf("\nFreeing frame in kill %d", (pdbr-FRAME0));
free_frm((pdbr-FRAME0));
freestk(pptr->pbase, pptr->pstklen);
switch (pptr->pstate) {
case PRCURR: pptr->pstate = PRFREE; /* suicide */
resched();
case PRWAIT: semaph[pptr->psem].semcnt++;
case PRREADY: dequeue(pid);
pptr->pstate = PRFREE;
break;
case PRSLEEP:
case PRTRECV: unsleep(pid);
/* fall through */
default: pptr->pstate = PRFREE;
}
restore(ps);
return(OK);
}
/*------------------------------------------------------------------------
* pipconnect -- Connect a pipe with a reader and writer process
*------------------------------------------------------------------------
*/
syscall pipconnect(pipid32 pip, pid32 writer, pid32 reader)
{
intmask mask; /* saved interrupt mask */
//kprintf("inside pipconnect \n\r");
mask = disable();
if (isbadpip(pip) || isbadpid(writer) || isbadpid(reader) || (reader == writer) ) {
restore(mask);
return SYSERR;
}
if ((piptab[pip].pipstate == PIPE_CONNECTED) || (piptab[pip].pipstate == PIPE_FREE)) {
restore(mask);
return SYSERR;
}
piptab[pip].pipstate = PIPE_CONNECTED;
piptab[pip].rdend = reader;
piptab[pip].wrtend = writer;
// create process table entry for pipe state
//pipedetails(pip);
restore(mask);
return OK;
}
/*------------------------------------------------------------------------
* ready -- make a process eligible for CPU service
*------------------------------------------------------------------------
*/
int ready(int pid, int resch)
{
register struct pentry *pptr;
if (isbadpid(pid))
return(SYSERR);
pptr = &proctab[pid];
pptr->pstate = PRREADY;
insert(pid,rdyhead,pptr->pgoodness);
if (resch)
resched();
return(OK);
}
/*------------------------------------------------------------------------
* getprio -- return the scheduling priority of a given process
*------------------------------------------------------------------------
*/
SYSCALL getprio(int pid)
{
struct pentry *pptr;
sigset_t ps;
disable(ps);
if (isbadpid(pid) || (pptr = &proctab[pid])->pstate == PRFREE) {
restore(ps);
return(SYSERR);
}
restore(ps);
return(pptr->pprio);
}
/*------------------------------------------------------------------------
* myenqueue - Insert a process at the tail of a queue
*------------------------------------------------------------------------
*/
pid32 myenqueue(
pid32 pid, /* ID of process to insert */
qid16 q /* ID of queue to use */
)
{
int tail, prev; /* Tail & previous node indexes */
if (myisbadqid(q) || isbadpid(pid)) {
if(myisbadqid(q))
kprintf("BAD QID \n");
if(isbadpid(pid))
kprintf("BAD PID \n");
return SYSERR;
}
tail = myqueuetail(q);
prev = myqueuetab[tail].qprev;
myqueuetab[pid].qnext = tail; /* Insert just before tail node */
myqueuetab[pid].qprev = prev;
myqueuetab[prev].qnext = pid;
myqueuetab[tail].qprev = pid;
return pid;
}
