/*------------------------------------------------------------------------
* 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;
}
/*------------------------------------------------------------------------
* alarmwakeup - Called by clock interrupt handler to awaken processes to call alarm handler
*------------------------------------------------------------------------
*/
void alarmwakeup(void)
{
/* LAB 4Q3 Awaken all processes that have no more time to sleep */
resched_cntl(DEFER_START);
while (alarmnonempty(alarmq) && (alarmfirstkey(alarmq) <= 0)) {
pid32 timeoutProcess = alarmdequeue(alarmq);
// LAB 4Q3 If current process then just invoke the callback function
if (timeoutProcess == currpid) {
struct procent *prptr = &proctab[currpid];
void (*alarmFunction) () = prptr->alarmfunc;
prptr->alarmtime = 0;
prptr->alarmTimeOut = FALSE;
alarmFunction();
prptr->alarmfunc = NULL;
} else {
// LAB 4Q3 if not the current process then ready the process frocibly in order to run the
// alarm callback function context switch in.
struct procent *prptr = &proctab[timeoutProcess];
prptr->alarmTimeOut = TRUE;
if (prptr->prstate == PR_SLEEP) {
unsleep(timeoutProcess);
ready(timeoutProcess);
}
}
}
resched_cntl(DEFER_STOP);
return;
}
/*------------------------------------------------------------------------
* 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);
}
void MicroStepper::sleep() {
if (!locked) {
display_name("sleep pin: ");
basic_pins->set_pin_low("sleep");
} else {
unsleep();
}
}
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;
}
/*------------------------------------------------------------------------
* 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);
}
/**
* @ingroup threads
*
* Kill a thread and remove it from the system
* @param tid target thread
* @return OK on success, SYSERR otherwise
*/
syscall kill(tid_typ tid)
{
register struct thrent *thrptr; /* thread control block */
irqmask im;
im = disable();
if (isbadtid(tid) || (NULLTHREAD == tid))
{
restore(im);
return SYSERR;
}
thrptr = &thrtab[tid];
if (--thrcount <= 1)
{
xdone();
}
#ifdef UHEAP_SIZE
/* reclaim used memory regions */
memRegionReclaim(tid);
#endif /* UHEAP_SIZE */
send(thrptr->parent, tid);
stkfree(thrptr->stkbase, thrptr->stklen);
switch (thrptr->state)
{
case THRSLEEP:
unsleep(tid);
thrptr->state = THRFREE;
break;
case THRCURR:
thrptr->state = THRFREE; /* suicide */
resched();
case THRWAIT:
semtab[thrptr->sem].count++;
case THRREADY:
getitem(tid); /* removes from queue */
default:
thrptr->state = THRFREE;
}
restore(im);
return OK;
}
/*------------------------------------------------------------------------
* send -- send a message to another process
*------------------------------------------------------------------------
*/
SYSCALL send(int pid, WORD msg)
{
// added for PA0 tracing
int start_time;
int curridx = 12;
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) || ( (pptr= &proctab[pid])->pstate == PRFREE)
|| pptr->phasmsg != 0) {
restore(ps);
// added for PA0 tracing
if(syscall_trace_on == 1) {
syscall_time[currpid][curridx] += ctr1000 - start_time;
}
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);
// added for PA0 tracing
if(syscall_trace_on == 1) {
syscall_time[currpid][curridx] += ctr1000 - start_time;
}
return(OK);
}
/*------------------------------------------------------------------------
* send -- send a message to another process
*------------------------------------------------------------------------
*/
SYSCALL
send(int pid, WORD msg)
{
STATWORD ps;
struct pentry *pptr;
disable(ps);
if (isbadpid(pid) || ( (pptr= &proctab[pid])->pstate == PRFREE)
|| pptr->phasmsg != 0) {
restore(ps);
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);
return(OK);
}
//------------------------------------------------------------------------
// sendf -- sendf a message to another process, forcing delivery
//------------------------------------------------------------------------
SYSCALL
sendf(int pid, int msg)
{
struct pentry *pptr;
int ps;
ps = disable();
if (isbadpid(pid) || ((pptr = &proctab[pid])->pstate == PRFREE)) {
restore(ps);
return SYSERR;
}
pptr->pmsg = msg;
pptr->phasmsg = TRUE;
if (pptr->pstate == PRRECV)
readysched(pid);
else if (pptr->pstate == PRTRECV) {
unsleep(pid);
readysched(pid);
}
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, i;
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);
for(i = 0; i < NBS; i++)
{
bs_map_t *bs_ptr = &pptr->loc_bsm[i];
if(bs_ptr->bs_status == BSM_MAPPED){
bsm_unmap(pid,bs_ptr->bs_vpno, bs_ptr->bs_private);
}
free_bsm(i);
}
int source = pptr->pdbr/NBPG - FRAME0;
free_frm(source);
for(i = 0; i < NFRAMES; i++)
{
if(frm_tab[i].fr_pid == pid && frm_tab[i].fr_status == FRM_MAPPED){
//kprintf("freeing the frame %d for pid %d\n",i,pid);
frm_tab[i].fr_status = FRM_UNMAPPED;
frm_tab[i].fr_pid = UNDEFINED;
frm_tab[i].fr_type = UNDEFINED;
frm_tab[i].fr_refcnt = 0;
frm_tab[i].fr_loadtime = UNDEFINED;
frm_tab[i].fr_vpno = UNDEFINED;
fifo_t *tmp = &fifo_head,*curr;
while(tmp){
curr = tmp;
tmp = tmp->fr_next;
/*if(tmp && tmp->fr_id == -1)
curr->fr_next = tmp->fr_next;*/
if(tmp && tmp->fr_id == i){
curr->fr_next = tmp->fr_next;
//tmp->fr_next = NULL;
break;
}
}
}
}
fifo_t *tmp = &fifo_head,*curr;
while(tmp){
curr = tmp;
tmp = tmp->fr_next;
/*if(tmp && tmp->fr_id == -1)
curr->fr_next = tmp->fr_next;*/
if(tmp && (pid == frm_tab[tmp->fr_id].fr_pid)){
curr->fr_next = tmp->fr_next;
//tmp->fr_next = NULL;
}
}
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(int pid)
{
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;
bs_map_t *temp;
int i;
for (i=0;i<16;i++)
{
temp = &bsm_tab[i];
while(temp !=NULL)
{
if(temp->bs_pid == currpid)
{
xmunmap(temp->bs_vpno);
if(temp->bs_private_heap == 1)
release_bs(i);
return OK;
}
temp=temp->next;
}
} }
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' table entry */
int32 i; /* index into descriptors */
struct pipent *pipptr; /* ptr to pipe entry */
mask = disable();
if (isbadpid(pid) || (pid == NULLPROC)
|| ((prptr = &proctab[pid])->prstate) == PR_FREE) {
restore(mask);
return SYSERR;
}
if (--prcount <= 1) { /* last user process completes */
xdone();
}
for(i = 0 ; i < NPIPE ; i++) {
pipptr = &piptab[i];
if(pipptr->owner == (pid32) getpid) {
pipptr->pipstate = PIPE_FREE;
memset(piptab[i].buff, '\0', PIPE_SIZE);
pipptr->owner = -1;
pipptr->reader = -1;
pipptr->writer = -1;
pipcount--;
}
}
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;
}
/*------------------------------------------------------------------------
* 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' table entry */
int32 i; /* Index into descriptors */
mask = disable();
if (isbadpid(pid) || (pid == NULLPROC)
|| ((prptr = &proctab[pid])->prstate) == PR_FREE) {
restore(mask);
return SYSERR;
}
/*
* Virtual memory-related cleanup section.
*/
/* If backing store was allocated, close and deallocate it */
int retries = 4;
bsd_t bs = (bsd_t) -1;
if(prptr->prbs == -1) {
bs = 0;
}
while(bs == -1 && retries > 0) {
bs = deallocate_bs(close_bs(prptr->prbs));
retries --;
}
if(bs == -1) {
kprintf("!!Warning: could not close and deallocate the backing store of pid %d. ",pid);
}
/* Deallocate all physical frames that the current process holds */
free_proc_frames(pid);
/* Free virtual memory free list */
struct vmemblk *next, *cur = prptr->prvmemlist;
while(cur!=NULL) {
next = cur->mnext;
freemem((char*)cur, sizeof(struct vmemblk));
cur = next;
}
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;
}
/*------------------------------------------------------------------------
* 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 i, 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:
for (i = 0; i < NLOCKS; i++) {
if (proctab[pid].locktype[i] != LNONE)
release(pid,i);
}
pptr->pstate = PRFREE; /* suicide */
resched();
case PRWAIT:
semaph[pptr->psem].semcnt++;
case PRREADY:
for (i = 0; i < NLOCKS; i++) {
if (proctab[pid].locktype[i] != LNONE)
release(pid,i);
}
dequeue(pid);
pptr->pstate = PRFREE;
break;
case PRSLEEP:
case PRTRECV:
unsleep(pid);
/* fall through */
default:
pptr->pstate = PRFREE;
for (i = 0; i < NLOCKS; i++) {
if (proctab[pid].locktype[i] != LNONE)
release(pid,i);
}
}
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, i;
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);
kill_frames(pid);
for (i = 0; i < NBS; i++) {
if (bsm_tab[i].bs_status == BSM_MAPPED) {
struct bs_proc_map_t *head = bsm_tab[i].mapping;
while (head != NULL) {
if ((head->pid == pid) && (head == bsm_tab[i].mapping)) {
head = head->next;
bsm_tab[i].mapping = head;
break;
} else if (head->next != NULL) {
if (head->next->pid == pid) {
head->next = head->next->next;
break;
}
}
head = head->next;
}
if (bsm_tab[i].mapping == NULL) {
bsm_tab[i].bs_status = BSM_UNMAPPED;
free_bsm(i);
}
}
}
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: //kprintf("killing pid %d in sleep\n",pid);
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;
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;
}
release_bs(proctab[pid].store);
int i = 0;
for(i = 0; i < NFRAMES; i++)
{
if(frm_tab[i].fr_pid == pid)
{
if(frm_tab[i].fr_type == FR_PAGE)
update_frm_fifo(i);
frm_tab[i].cookie = 0;
frm_tab[i].fr_dirty = 0;
frm_tab[i].fr_loadtime = 0;
frm_tab[i].fr_pid = -1;
frm_tab[i].fr_refcnt = 0;
frm_tab[i].fr_status = FRM_UNMAPPED;
frm_tab[i].fr_type = FR_PAGE;
frm_tab[i].fr_vpno = BASE_VIRTUAL_PAGE;
frm_tab[i].next_frame = -1;
}
}
restore(ps);
return(OK);
}
SYSCALL kill(int pid)
{
STATWORD ps;
struct pentry *pptr; /* points to proc. table for pid*/
int dev, i, callResched, lockID;
callResched = RESCHNO;
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);
for( i=0; i<NLOCKS; i++)
{
if( locktab[i].acquiredby[pid] == 1) //this process has acquired some lock and holding it, so release it and resched
{
//kprintf("\n Kill is holding lock %s", proctab[pid].pname);
callResched = RESCHYES;
relLock(pid, i, 0);
}
}
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++;
//if this proc is in wait queue of any lock i, remove it ... a proc can be in waiting q of any one lock only
/* for( i=0; i<NLOCKS; i++)
{
if( (proctab[pid].procLockType[i]!=DELETED) && (locktab[i].acquiredby[pid]!=1) )
{
kprintf("Killed Process %d waiting on lock %d", pid, i);
locktab[j].effectOfPriorityInheritance = 1;
rampUpPriority(j, proctab[i].pprio);
}
} */
lockID = getLockID(pptr->lockID);
if( !isbadlock(lockID) || locktab[lockID].lstate != LOCKFREE )
{
//dequeue(pid);
//kprintf("\nKill proc getting called in PRWAIT, releasing wait lock %d..%d", lockID, pid);
proctab[pid].pprio = -1;
proctab[pid].mainPrio = -1;
relLock(pid, lockID, 1);
//dequeue(pid);
}
case PRREADY: dequeue(pid);
pptr->pstate = PRFREE;
break;
case PRSLEEP:
case PRTRECV: unsleep(pid);
/* fall through */
default: pptr->pstate = PRFREE;
}
if(callResched)
{
//kprintf("\n About to call resched");
//indicates that this proc was holding lock and is deleted
//in between so now it should release lock and call resched
resched();
}
restore(ps);
return(OK);
}
syscall kill(
pid32 pid /* ID of process to kill */
)
{
intmask mask; /* Saved interrupt mask */
int32 i; /* Index into descriptors */
struct procent *prptr = &proctab[currpid]; /* Ptr to process' table entry */\
struct memblkentry *prevmemblkptr = prptr->prmemblklist;
struct memblkentry *memblkptr = prevmemblkptr->next;
//kprintf("in here homie bad zone\n");
mask = disable();
if (isbadpid(pid) || (pid == NULLPROC)
|| ((prptr = &proctab[pid])->prstate) == PR_FREE) {
restore(mask);
return SYSERR;
}
while(memblkptr != NULL){
prevmemblkptr = memblkptr;
memblkptr = memblkptr->next;
}
//kprintf("prptr->prmemblklist->size before :%d\n",prptr->prmemblklist->size);
prevmemblkptr->size = 0;
prptr->prmemblklist->size = prevmemblkptr->size;
prevmemblkptr->next = NULL;
//kprintf("prptr->prmemblklist->size after :%d\n",prptr->prmemblklist->size);
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;
}
kprintf("prptr->prmemblklist->size %d\n",prevmemblkptr->size);
restore(mask);
return OK;
}
