/*------------------------------------------------------------------------
* 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(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);
}
/**
* Associate a TTY with a hardware device.
* @param pdev TTY device table entry
* @param ap 2nd argument is the device number for the hardware device
* @return OK if TTY is opened properly, otherwise SYSERR
*/
devcall ttyOpen(device *pdev, va_list ap)
{
struct tty *ptty = NULL;
int dvnum = 0;
/* Check if TTY is already open */
if (pdev->controlblk)
{ return OK; }
/* Allocate a tty */
ptty = (struct tty *)ttyAlloc();
ASSERT(NULL != ptty);
/* Mutually link tty record with device table entry */
pdev->controlblk = (char *)ptty;
ptty->tty_dev = pdev;
/* Initialize input buffer */
ptty->iflags = 0;
ptty->istart = 0;
ptty->icount = 0;
/* Initialize output flags */
ptty->oflags = 0;
/* Second arg should be device index for physical hardware */
dvnum = va_arg(ap, int);
ASSERT(!isbaddev(dvnum));
ptty->tty_phw = &devtab[dvnum];
return OK;
}
/**
* getc - get one character from a device
* @param descrp definition of device from which to acquire character
* @return function to get character on success, SYSERR on failure
*/
devcall getc(ushort descrp)
{
device *devptr;
if ( isbaddev(descrp) ) { return SYSERR; }
devptr = &devtab[descrp];
return ( (*devptr->getc)(devptr) );
}
/**
* read - read one or more bytes from a device
* @param descrp definition of device from which to read
* @param *buffer pointer into read-to location
* @param count length of buffer
* @return function to read from device on success, SYSERR on failure
*/
devcall read(ushort descrp, void *buffer, long count)
{
device *devptr;
if ( isbaddev(descrp) ) { return SYSERR; }
devptr = &devtab[descrp];
return ( (*devptr->read)(devptr, buffer, count) );
}
/*------------------------------------------------------------------------
* lflistdir - List all valid files within the XINU flat file system
*------------------------------------------------------------------------
*/
syscall lflistdir(
did32 diskdev /* ID of device to read from */
)
{
intmask mask; /* saved interrupt mask */
int32 retval; /* value to return to caller */
struct dentry *devptr; /* entry in device switch table */
mask = disable();
if (isbaddev(diskdev)) {
restore(mask);
return SYSERR;
}
devptr = (struct dentry *) &devtab[diskdev];
/* obtain copy of directory if not already in memory */
struct lfdir *dirptr; /* ptr to in-memory directory */
dirptr = &Lf_data.lf_dir;
wait(Lf_data.lf_mutex);
if (! Lf_data.lf_dirpresent)
{
retval = read(Lf_data.lf_dskdev, (char *)dirptr,LF_AREA_DIR);
if (retval == SYSERR )
{
signal(Lf_data.lf_mutex);
restore(mask);
return SYSERR;
}
Lf_data.lf_dirpresent = TRUE;
}
/* list all files in directory */
if (dirptr->lfd_nfiles == 0)
{
kprintf("No files\r\n");
}
int32 i; /* general loop index */
struct ldentry *ldptr; /* ptr to an entry in directory */
for (i = 0; i < dirptr->lfd_nfiles; i++)
{
ldptr = &dirptr->lfd_files[i];
kprintf("%s\r\n", ldptr->ld_name);
}
signal(Lf_data.lf_mutex);
restore(mask);
return OK;
}
DEVCALL reads(int descrp, void *p, int block_no, int count) {
struct devsw *devptr;
if(isbaddev(descrp))
return SYSERR;
devptr = &devtab[descrp];
return ((*devptr -> dvread)(devptr, p, block_no, count));
}
SYSCALL read(int descrp, unsigned char *buff, int count)
{
struct devsw *devptr;
if (isbaddev(descrp) )
return(SYSERR);
devptr = &devtab[descrp];
return( (*devptr->dvread)(devptr,buff,count) );
}
/*------------------------------------------------------------------------
* write - write 1 or more bytes to a device
*------------------------------------------------------------------------
*/
SYSCALL write(int descrp, void *p, int count)
{
struct devsw *devptr;
if (isbaddev(descrp) )
return(SYSERR);
devptr = &devtab[descrp];
return( (*devptr->dvwrite)(devptr,p,count) );
}
/*------------------------------------------------------------------------
* write - write 1 or more bytes to a device
*------------------------------------------------------------------------
*/
int
write(int descrp, const void *buff, unsigned count)
{
struct devsw *pdev;
if (isbaddev(descrp) )
return SYSERR;
pdev = &devtab[descrp];
return (*pdev->dvwrite)(pdev, buff, count);
}
/*------------------------------------------------------------------------
* close - close a device
*------------------------------------------------------------------------
*/
SYSCALL
close(int descrp)
{
struct devsw *devptr;
if (isbaddev(descrp) )
return(SYSERR);
devptr = &devtab[descrp];
return( (*devptr->dvclose)(devptr));
}
/*------------------------------------------------------------------------
* init_dev - initialize a device
*------------------------------------------------------------------------
*/
DEVCALL init_dev(int descrp)
{
struct devsw *pdev;
if (isbaddev(descrp) ) {
return(SYSERR);
}
pdev = &devtab[descrp];
return((pdev->dvinit)(pdev));
}
//------------------------------------------------------------------------
// putc - write a single character to a device
//------------------------------------------------------------------------
SYSCALL
putc(int descrp, int ch)
{
struct devsw *devptr;
if (isbaddev(descrp))
return SYSERR;
devptr = &devtab[descrp];
return (*devptr->putc)(devptr, ch);
}
/**
* read one or more bytes from a device
* @param descrp definition of device from which to read
* @param *buffer pointer into read-to location
* @param count length of buffer
* @return function to read from device on success, SYSERR on failure
*/
devcall read(int descrp, void *buffer, uint count)
{
device *devptr;
if (isbaddev(descrp))
{
return SYSERR;
}
devptr = (device *)&devtab[descrp];
return ((*devptr->read) (devptr, buffer, count));
}
//------------------------------------------------------------------------
// init - initialize a device
//------------------------------------------------------------------------
int
init(int descrp)
{
struct devsw *devptr;
if (isbaddev(descrp))
return SYSERR;
devptr = &devtab[descrp];
(*devptr->init)(devptr);
return OK;
}
//------------------------------------------------------------------------
// seek -- position a device (very common special case of control)
//------------------------------------------------------------------------
SYSCALL
seek(int descrp, long pos)
{
struct devsw *devptr;
if (isbaddev(descrp))
return SYSERR;
devptr = &devtab[descrp];
return (*devptr->seek)(devptr, pos);
}
/*------------------------------------------------------------------------
* putc - write a single character to a device
*------------------------------------------------------------------------
*/
SYSCALL putc( int descrp, char ch )
{
struct devsw *devptr;
if ( isbaddev( descrp ) )
return (SYSERR );
devptr = &devtab[descrp];
return ( ( *devptr->dvputc )( devptr, ch ) );
}
//------------------------------------------------------------------------
// write - write 1 or more bytes to a device
//------------------------------------------------------------------------
SYSCALL
write(int descrp, const void *buff, int count)
{
struct devsw *devptr;
if (isbaddev(descrp))
return SYSERR;
devptr = &devtab[descrp];
return (*devptr->write)(devptr, buff, count);
}
/**
* @ingroup telnet
*
* Associate TELNET with a hardware device.
* @param devptr TELNET device table entry
* @param ap 2nd argument is the device number for the hardware device
* @return OK if TELNET is opened properly, otherwise SYSERR
*/
devcall telnetOpen(device *devptr, va_list ap)
{
struct telnet *tntptr = NULL;
int dvnum = 0;
irqmask im;
im = disable();
/* Second arg should be device index for physical hardware */
dvnum = va_arg(ap, int);
TELNET_TRACE("Open(%d) dvnum = %d", devptr->minor, dvnum);
if (isbaddev(dvnum))
{
restore(im);
return SYSERR;
}
/* Setup pointer to telnet */
tntptr = &telnettab[devptr->minor];
/* Check if TELNET is already open */
if ((TELNET_STATE_FREE != tntptr->state) &&
(TELNET_STATE_ALLOC != tntptr->state))
{
TELNET_TRACE("state = %d", tntptr->state);
restore(im);
return SYSERR;
}
tntptr->state = TELNET_STATE_OPEN;
/* Initialize input buffer */
tntptr->istart = 0;
tntptr->icount = 0;
tntptr->idelim = FALSE;
/* Initialize output buffer */
tntptr->ocount = 0;
tntptr->ostart = 0;
/* Initialize flags */
tntptr->flags = 0;
tntptr->ieof = FALSE;
tntptr->phw = (device *)&devtab[dvnum];
/* Initialize states and mutex semaphoress */
tntptr->echoState = TELNET_ECHO_SENT_WILL;
tntptr->isem = semcreate(1);
tntptr->osem = semcreate(1);
/* Restore interrupts after making changes to telnet device structure */
restore(im);
return OK;
}
//------------------------------------------------------------------------
// iosetvec -- fill in interrupt vectors and dispatch table entries
//------------------------------------------------------------------------
int
iosetvec(int dev, void (*handler)(void), void *arg)
{
struct devsw *devptr;
void (**vptr)(void) = (void (**)(void))VECTORS;
if (isbaddev(dev))
return SYSERR;
devptr = &devtab[dev];
if (devptr->ivec == 0) // No interrupt support.
return OK;
vptr[devptr->ivec] = handler; // fill in input interrupt
intrargs[devptr->ivec] = arg; // fill in handler argument
return OK;
}
/*------------------------------------------------------------------------
* mount - Add a prefix mapping to the name space
*------------------------------------------------------------------------
*/
syscall mount(
char *prefix, /* prefix to add */
char *replace, /* replacement string */
did32 device /* device ID to use */
)
{
intmask mask; /* saved interrupt mask */
struct nmentry *namptr; /* pointer to unused table entry*/
int32 psiz, rsiz; /* sizes of prefix & replacement*/
int32 i; /* counter for copy loop */
mask = disable();
psiz = namlen(prefix, NM_PRELEN);
rsiz = namlen(replace, NM_REPLLEN);
if ((psiz == SYSERR) || (rsiz == SYSERR) || isbaddev(device)) {
restore(mask);
return SYSERR;
}
if (nnames >= NNAMES) { /* if table full return error */
restore(mask);
return SYSERR;
}
/* allocate a slot in the table */
namptr = &nametab[nnames]; /* next unused entry in table */
/* copy prefix and replacement strings and record device ID */
for (i=0; i<psiz; i++) { /* copy prefix into table entry */
namptr->nprefix[i] = *prefix++;
}
for (i=0; i<rsiz; i++) { /* copy replacement into entry */
namptr->nreplace[i] = *replace++;
}
namptr->ndevice = device; /* record the device ID */
nnames++; /* increment number of names */
restore(mask);
return OK;
}
/*------------------------------------------------------------------------
* control - control a device (e.g., set the mode)
*------------------------------------------------------------------------
*/
SYSCALL
control(int descrp, int func, ...)
{
va_list ap;
struct devsw *pdev;
void *arg1, *arg2;
int rv;
va_start(ap, func);
if (isbaddev(descrp) )
return SYSERR;
pdev = &devtab[descrp];
arg1 = va_arg(ap, void *);
arg2 = va_arg(ap, void *);
rv = (*pdev->dvcntl)(pdev, func, arg1, arg2);
va_end(ap);
return rv;
}
/*------------------------------------------------------------------------
* getc - Obtain one byte from a device
*------------------------------------------------------------------------
*/
syscall getc(
did32 descrp /* Descriptor for device */
)
{
intmask mask; /* Saved interrupt mask */
struct dentry *devptr; /* Entry in device switch table */
int32 retval; /* Value to return to caller */
mask = disable();
if (isbaddev(descrp)) {
restore(mask);
return SYSERR;
}
devptr = (struct dentry *) &devtab[descrp];
retval = (*devptr->dvgetc) (devptr);
restore(mask);
return retval;
}
/*------------------------------------------------------------------------
* seek - position a random access device
*------------------------------------------------------------------------
*/
syscall seek(
did32 descrp, /* descriptor for device */
uint32 pos /* position */
)
{
intmask mask; /* saved interrupt mask */
struct dentry *devptr; /* entry in device switch table */
int32 retval; /* value to return to caller */
mask = disable();
if (isbaddev(descrp)) {
restore(mask);
return SYSERR;
}
devptr = (struct dentry *) &devtab[descrp];
retval = (*devptr->dvseek) (devptr, pos);
restore(mask);
return retval;
}
/*------------------------------------------------------------------------
* read - read one or more bytes from a device
*------------------------------------------------------------------------
*/
syscall read(
did32 descrp, /* descriptor for device */
char *buffer, /* address of buffer */
uint32 count /* length of buffer */
)
{
intmask mask; /* saved interrupt mask */
struct dentry *devptr; /* entry in device switch table */
int32 retval; /* value to return to caller */
mask = disable();
if (isbaddev(descrp)) {
restore(mask);
return SYSERR;
}
devptr = (struct dentry *) &devtab[descrp];
retval = (*devptr->dvread) (devptr, buffer, count);
restore(mask);
return retval;
}
/*------------------------------------------------------------------------
* open - Open a device (some devices ignore name and mode parameters)
*------------------------------------------------------------------------
*/
syscall open(
did32 descrp, /* Descriptor for device */
char *name, /* Name to use, if any */
char *mode /* Mode for device, if any */
)
{
intmask mask; /* Saved interrupt mask */
struct dentry *devptr; /* Entry in device switch table */
int32 retval; /* Value to return to caller */
mask = disable();
if (isbaddev(descrp)) {
restore(mask);
return SYSERR;
}
devptr = (struct dentry *) &devtab[descrp];
retval = (*devptr->dvopen) (devptr, name, mode);
restore(mask);
return retval;
}
/*------------------------------------------------------------------------
* control - Control a device or a driver (e.g., set the driver mode)
*------------------------------------------------------------------------
*/
syscall control(
did32 descrp, /* Descriptor for device */
int32 func, /* Specific control function */
int32 arg1, /* Specific argument for func */
int32 arg2 /* Specific argument for func */
)
{
intmask mask; /* Saved interrupt mask */
struct dentry *devptr; /* Entry in device switch table */
int32 retval; /* Value to return to caller */
mask = disable();
if (isbaddev(descrp)) {
restore(mask);
return SYSERR;
}
devptr = (struct dentry *) &devtab[descrp];
retval = (*devptr->dvcntl) (devptr, func, arg1, arg2);
restore(mask);
return retval;
}
/*------------------------------------------------------------------------
* 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);
}
