add plain C files from SYSIII
This commit is contained in:
Oliver Lehmann
parent
969b0473d0
commit
50bff6952f
|
|
@ -0,0 +1,109 @@
|
|||
#include "sys/param.h"
|
||||
#include "sys/systm.h"
|
||||
#include "sys/acct.h"
|
||||
#include "sys/dir.h"
|
||||
#include "sys/user.h"
|
||||
#include "sys/inode.h"
|
||||
|
||||
/*
|
||||
* Perform process accounting functions.
|
||||
*/
|
||||
|
||||
sysacct()
|
||||
{
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
char *fname;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if (!suser())
|
||||
return;
|
||||
if (uap->fname==NULL) {
|
||||
if (acctp) {
|
||||
plock(acctp);
|
||||
iput(acctp);
|
||||
acctp = NULL;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (acctp) {
|
||||
u.u_error = EBUSY;
|
||||
return;
|
||||
}
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if(ip == NULL)
|
||||
return;
|
||||
if((ip->i_mode & IFMT) != IFREG) {
|
||||
u.u_error = EACCES;
|
||||
iput(ip);
|
||||
return;
|
||||
}
|
||||
acctp = ip;
|
||||
prele(ip);
|
||||
}
|
||||
|
||||
/*
|
||||
* On exit, write a record on the accounting file.
|
||||
*/
|
||||
acct(st)
|
||||
{
|
||||
register struct inode *ip;
|
||||
off_t siz;
|
||||
|
||||
if ((ip=acctp)==NULL)
|
||||
return;
|
||||
plock(ip);
|
||||
bcopy(u.u_comm,acctbuf.ac_comm,sizeof(acctbuf.ac_comm));
|
||||
acctbuf.ac_btime = u.u_start;
|
||||
acctbuf.ac_utime = compress(u.u_utime);
|
||||
acctbuf.ac_stime = compress(u.u_stime);
|
||||
acctbuf.ac_etime = compress(lbolt - u.u_ticks);
|
||||
acctbuf.ac_mem = compress(u.u_mem);
|
||||
acctbuf.ac_io = compress(u.u_ioch);
|
||||
acctbuf.ac_rw = compress(u.u_ior+u.u_iow);
|
||||
acctbuf.ac_uid = u.u_ruid;
|
||||
acctbuf.ac_gid = u.u_rgid;
|
||||
acctbuf.ac_tty = u.u_ttyp ? u.u_ttyd : NODEV;
|
||||
acctbuf.ac_stat = st;
|
||||
acctbuf.ac_flag = u.u_acflag;
|
||||
siz = ip->i_size;
|
||||
u.u_offset = siz;
|
||||
u.u_base = (caddr_t)&acctbuf;
|
||||
u.u_count = sizeof(acctbuf);
|
||||
u.u_segflg = 1;
|
||||
u.u_error = 0;
|
||||
u.u_limit = (daddr_t)5000;
|
||||
writei(ip);
|
||||
if(u.u_error)
|
||||
ip->i_size = siz;
|
||||
prele(ip);
|
||||
}
|
||||
|
||||
/*
|
||||
* Produce a pseudo-floating point representation
|
||||
* with 3 bits base-8 exponent, 13 bits fraction.
|
||||
*/
|
||||
compress(t)
|
||||
register time_t t;
|
||||
{
|
||||
register exp = 0, round = 0;
|
||||
|
||||
while (t >= 8192) {
|
||||
exp++;
|
||||
round = t&04;
|
||||
t >>= 3;
|
||||
}
|
||||
if (round) {
|
||||
t++;
|
||||
if (t >= 8192) {
|
||||
t >>= 3;
|
||||
exp++;
|
||||
}
|
||||
}
|
||||
return((exp<<13) + t);
|
||||
}
|
||||
|
|
@ -0,0 +1,265 @@
|
|||
/******************************************************************************
|
||||
*******************************************************************************
|
||||
|
||||
W E G A - Quelle
|
||||
|
||||
KERN 3.2 Modul: nami.c
|
||||
|
||||
|
||||
Bearbeiter: O. Lehmann
|
||||
Datum: 17.05.08
|
||||
Version: 1.0
|
||||
|
||||
*******************************************************************************
|
||||
******************************************************************************/
|
||||
|
||||
char namiwstr[] = "@[$]nami.c Rev : 4.1 08/27/83 11:56:22";
|
||||
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/sysparm.h>
|
||||
#include <sys/sysinfo.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/mount.h>
|
||||
#include <sys/inode.h>
|
||||
#include <sys/dir.h>
|
||||
#include <sys/mmu.h>
|
||||
#include <sys/buf.h>
|
||||
#include <sys/conf.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/s.out.h>
|
||||
#include <sys/user.h>
|
||||
#include <sys/map.h>
|
||||
|
||||
/*
|
||||
* Convert a pathname into a pointer to
|
||||
* an inode. Note that the inode is locked.
|
||||
*
|
||||
* func = function called to get next char of name
|
||||
* &uchar if name is in user space
|
||||
* &schar if name is in system space
|
||||
* flag = 0 if name is sought
|
||||
* 1 if name is to be created
|
||||
* 2 if name is to be deleted
|
||||
*/
|
||||
struct inode *
|
||||
namei(func, flag)
|
||||
int (*func)();
|
||||
{
|
||||
register struct inode *dp;
|
||||
register c;
|
||||
register char *cp;
|
||||
struct buf *bp;
|
||||
int i;
|
||||
dev_t d;
|
||||
off_t eo;
|
||||
|
||||
/*
|
||||
* If name starts with '/' start from
|
||||
* root; otherwise start from current dir.
|
||||
*/
|
||||
|
||||
sysinfo.namei++;
|
||||
c = (*func)();
|
||||
if (c == '\0') {
|
||||
u.u_error = ENOENT;
|
||||
return(NULL);
|
||||
}
|
||||
if (c == '/') {
|
||||
if ((dp = u.u_rdir) == NULL)
|
||||
dp = rootdir;
|
||||
while(c == '/')
|
||||
c = (*func)();
|
||||
if(c == '\0' && flag != 0) {
|
||||
u.u_error = ENOENT;
|
||||
return(NULL);
|
||||
}
|
||||
} else
|
||||
dp = u.u_cdir;
|
||||
iget(dp->i_dev, dp->i_number);
|
||||
|
||||
cloop:
|
||||
/*
|
||||
* Here dp contains pointer
|
||||
* to last component matched.
|
||||
*/
|
||||
|
||||
if(u.u_error)
|
||||
goto out;
|
||||
if(c == '\0')
|
||||
return(dp);
|
||||
|
||||
/*
|
||||
* If there is another component,
|
||||
* gather up name into users' dir buffer.
|
||||
*/
|
||||
|
||||
|
||||
cp = &u.u_dent.d_name[0];
|
||||
while(c != '/' && c != '\0' && u.u_error == 0) {
|
||||
if(cp < &u.u_dent.d_name[DIRSIZ])
|
||||
*cp++ = c;
|
||||
c = (*func)();
|
||||
}
|
||||
while(cp < &u.u_dent.d_name[DIRSIZ])
|
||||
*cp++ = '\0';
|
||||
while(c == '/')
|
||||
c = (*func)();
|
||||
|
||||
seloop:
|
||||
/*
|
||||
* dp must be a directory and
|
||||
* must have X permission.
|
||||
*/
|
||||
if ((dp->i_mode&IFMT) != IFDIR || dp->i_nlink==0)
|
||||
u.u_error = ENOTDIR;
|
||||
else
|
||||
access(dp, IEXEC);
|
||||
if (u.u_error)
|
||||
goto out;
|
||||
|
||||
/*
|
||||
* set up to search a directory
|
||||
*/
|
||||
u.u_offset = 0;
|
||||
eo = 0;
|
||||
bp = NULL;
|
||||
if (dp == u.u_rdir)
|
||||
if (u.u_dent.d_name[0] == '.')
|
||||
if (u.u_dent.d_name[1] == '.')
|
||||
if (u.u_dent.d_name[2] == '\0')
|
||||
goto cloop;
|
||||
|
||||
eloop:
|
||||
|
||||
/*
|
||||
* If at the end of the directory,
|
||||
* the search failed. Report what
|
||||
* is appropriate as per flag.
|
||||
*/
|
||||
|
||||
if(u.u_offset >= dp->i_size) {
|
||||
if(bp != NULL)
|
||||
brelse(bp);
|
||||
if(flag==1 && c=='\0') {
|
||||
if(access(dp, IWRITE))
|
||||
goto out;
|
||||
u.u_pdir = dp;
|
||||
if (eo)
|
||||
u.u_offset = eo - sizeof(struct direct);
|
||||
bmap(dp, (daddr_t)(u.u_offset>>BSHIFT), B_WRITE);
|
||||
if (u.u_error)
|
||||
goto out;
|
||||
return(NULL);
|
||||
}
|
||||
u.u_error = ENOENT;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/*
|
||||
* If offset is on a block boundary,
|
||||
* read the next directory block.
|
||||
* Release previous if it exists.
|
||||
*/
|
||||
|
||||
if((u.u_offset&BMASK) == 0) {
|
||||
daddr_t bn;
|
||||
|
||||
if(bp != NULL)
|
||||
brelse(bp);
|
||||
sysinfo.dirblk++;
|
||||
bn = bmap(dp, (daddr_t)(u.u_offset>>BSHIFT), B_READ);
|
||||
if (u.u_error)
|
||||
goto out;
|
||||
if (bn < 0) {
|
||||
u.u_error = EIO;
|
||||
goto out;
|
||||
}
|
||||
bp = bread(dp->i_dev, bn);
|
||||
if (u.u_error) {
|
||||
brelse(bp);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Note first empty directory slot
|
||||
* in eo for possible creat.
|
||||
* String compare the directory entry
|
||||
* and the current component.
|
||||
* If they do not match, go back to eloop.
|
||||
*/
|
||||
|
||||
cp = bp->b_un.b_addr+(u.u_offset&BMASK);
|
||||
u.u_offset += sizeof(struct direct);
|
||||
u.u_dent.d_ino = ((struct direct *)cp)->d_ino;
|
||||
if(u.u_dent.d_ino == 0) {
|
||||
if(eo == 0)
|
||||
eo = u.u_offset;
|
||||
goto eloop;
|
||||
}
|
||||
cp = &((struct direct *)cp)->d_name[0];
|
||||
for(i=0; i<DIRSIZ; i++)
|
||||
if(*cp++ != u.u_dent.d_name[i])
|
||||
goto eloop;
|
||||
|
||||
/*
|
||||
* Here a component matched in a directory.
|
||||
* If there is more pathname, go back to
|
||||
* cloop, otherwise return.
|
||||
*/
|
||||
|
||||
if(bp != NULL)
|
||||
brelse(bp);
|
||||
if(flag==2 && c=='\0') {
|
||||
if(access(dp, IWRITE))
|
||||
goto out;
|
||||
return(dp);
|
||||
}
|
||||
d = dp->i_dev;
|
||||
if(u.u_dent.d_ino == ROOTINO)
|
||||
if(dp->i_number == ROOTINO)
|
||||
if(u.u_dent.d_name[1] == '.')
|
||||
for(i=1; i<NMOUNT; i++)
|
||||
if(mount[i].m_flags == MINUSE)
|
||||
if(mount[i].m_dev == d) {
|
||||
iput(dp);
|
||||
dp = mount[i].m_inodp;
|
||||
dp->i_count++;
|
||||
plock(dp);
|
||||
goto seloop;
|
||||
}
|
||||
iput(dp);
|
||||
dp = iget(d, u.u_dent.d_ino);
|
||||
if(dp == NULL)
|
||||
return(NULL);
|
||||
goto cloop;
|
||||
|
||||
out:
|
||||
iput(dp);
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the next character from the
|
||||
* kernel string pointed at by dirp.
|
||||
*/
|
||||
schar()
|
||||
{
|
||||
|
||||
return(u.u_dirp.left++ & 0377);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the next character from the
|
||||
* user string pointed at by dirp.
|
||||
*/
|
||||
uchar()
|
||||
{
|
||||
register c;
|
||||
|
||||
c = fubyte(u.u_dirp.left++);
|
||||
if(!c)
|
||||
u.u_error = EFAULT;
|
||||
return(c);
|
||||
}
|
||||
|
|
@ -0,0 +1,425 @@
|
|||
#include "sys/plexus.h"
|
||||
#include "sys/param.h"
|
||||
#include "sys/systm.h"
|
||||
#include "sys/dir.h"
|
||||
#include "sys/user.h"
|
||||
#include "sys/proc.h"
|
||||
#include "sys/inode.h"
|
||||
#include "sys/reg.h"
|
||||
#include "sys/text.h"
|
||||
#include "sys/seg.h"
|
||||
#include "sys/var.h"
|
||||
#include "sys/psl.h"
|
||||
|
||||
/*
|
||||
* Priority for tracing
|
||||
*/
|
||||
#define IPCPRI PZERO
|
||||
|
||||
/*
|
||||
* Tracing variables.
|
||||
* Used to pass trace command from
|
||||
* parent to child being traced.
|
||||
* This data base cannot be
|
||||
* shared and is locked
|
||||
* per user.
|
||||
*/
|
||||
struct
|
||||
{
|
||||
int ip_lock;
|
||||
int ip_req;
|
||||
int *ip_addr;
|
||||
int ip_data;
|
||||
} ipc;
|
||||
|
||||
/*
|
||||
* Send the specified signal to
|
||||
* all processes with 'pgrp' as
|
||||
* process group.
|
||||
* Called by tty.c for quits and
|
||||
* interrupts.
|
||||
*/
|
||||
signal(pgrp, sig)
|
||||
register pgrp;
|
||||
{
|
||||
register struct proc *p;
|
||||
|
||||
if(pgrp == 0)
|
||||
return;
|
||||
for(p = &proc[1]; p < (struct proc *)v.ve_proc; p++)
|
||||
if(p->p_pgrp == pgrp)
|
||||
psignal(p, sig);
|
||||
}
|
||||
|
||||
/*
|
||||
* Send the specified signal to
|
||||
* the specified process.
|
||||
*/
|
||||
psignal(p, sig)
|
||||
register struct proc *p;
|
||||
register sig;
|
||||
{
|
||||
|
||||
sig--;
|
||||
if (sig < 0 || sig >= NSIG)
|
||||
return;
|
||||
p->p_sig |= 1L<<sig;
|
||||
if(p->p_stat == SSLEEP && p->p_pri > PZERO) {
|
||||
if(p->p_pri > PUSER)
|
||||
p->p_pri = PUSER;
|
||||
setrun(p);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns true if the current
|
||||
* process has a signal to process.
|
||||
* This is asked at least once
|
||||
* each time a process enters the
|
||||
* system.
|
||||
* A signal does not do anything
|
||||
* directly to a process; it sets
|
||||
* a flag that asks the process to
|
||||
* do something to itself.
|
||||
*/
|
||||
issig()
|
||||
{
|
||||
register n;
|
||||
register struct proc *p, *q;
|
||||
|
||||
p = u.u_procp;
|
||||
while(p->p_sig) {
|
||||
n = fsig(p);
|
||||
if (n == SIGCLD) {
|
||||
if (u.u_signal[SIGCLD-1]&01) {
|
||||
for (q = &proc[1];
|
||||
q < (struct proc *)v.ve_proc; q++) {
|
||||
if (p->p_pid == q->p_ppid &&
|
||||
q->p_stat == SZOMB)
|
||||
freeproc(q, 0) ;
|
||||
}
|
||||
} else
|
||||
if (u.u_signal[SIGCLD-1])
|
||||
return(n) ;
|
||||
} else
|
||||
if((u.u_signal[n-1]&1) == 0 || (p->p_flag&STRC))
|
||||
return(n);
|
||||
p->p_sig &= ~(1L<<(n-1));
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Enter the tracing STOP state.
|
||||
* In this state, the parent is
|
||||
* informed and the process is able to
|
||||
* receive commands from the parent.
|
||||
*/
|
||||
stop()
|
||||
{
|
||||
register struct proc *pp, *cp;
|
||||
|
||||
loop:
|
||||
cp = u.u_procp;
|
||||
if(cp->p_ppid != 1)
|
||||
for (pp = &proc[0]; pp < (struct proc *)v.ve_proc; pp++)
|
||||
if (pp->p_pid == cp->p_ppid) {
|
||||
wakeup((caddr_t)pp);
|
||||
cp->p_stat = SSTOP;
|
||||
swtch();
|
||||
if ((cp->p_flag&STRC)==0 || procxmt())
|
||||
return;
|
||||
goto loop;
|
||||
}
|
||||
exit(fsig(u.u_procp));
|
||||
}
|
||||
|
||||
/*
|
||||
* Perform the action specified by
|
||||
* the current signal.
|
||||
* The usual sequence is:
|
||||
* if(issig())
|
||||
* psig();
|
||||
*/
|
||||
psig()
|
||||
{
|
||||
register n, p;
|
||||
register struct proc *rp;
|
||||
|
||||
rp = u.u_procp;
|
||||
if (rp->p_flag&STRC)
|
||||
stop();
|
||||
n = fsig(rp);
|
||||
if (n==0)
|
||||
return;
|
||||
rp->p_sig &= ~(1L<<(n-1));
|
||||
if((p=u.u_signal[n-1]) != 0) {
|
||||
u.u_error = 0;
|
||||
if(n != SIGILL && n != SIGTRAP)
|
||||
u.u_signal[n-1] = 0;
|
||||
sendsig(p, n);
|
||||
return;
|
||||
}
|
||||
switch(n) {
|
||||
|
||||
case SIGQUIT:
|
||||
case SIGILL:
|
||||
case SIGTRAP:
|
||||
case SIGIOT:
|
||||
case SIGEMT:
|
||||
case SIGFPE:
|
||||
case SIGBUS:
|
||||
case SIGSEGV:
|
||||
case SIGSYS:
|
||||
if(core())
|
||||
n += 0200;
|
||||
}
|
||||
exit(n);
|
||||
}
|
||||
|
||||
/*
|
||||
* find the signal in bit-position
|
||||
* representation in p_sig.
|
||||
*/
|
||||
fsig(p)
|
||||
struct proc *p;
|
||||
{
|
||||
register i;
|
||||
long n;
|
||||
|
||||
n = p->p_sig;
|
||||
for(i=1; i<=NSIG; i++) {
|
||||
if(n & 1L)
|
||||
return(i);
|
||||
n >>= 1;
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Create a core image on the file "core"
|
||||
*
|
||||
* It writes USIZE block of the
|
||||
* user.h area followed by the entire
|
||||
* data+stack segments.
|
||||
*/
|
||||
core()
|
||||
{
|
||||
register struct inode *ip;
|
||||
register unsigned s;
|
||||
extern schar();
|
||||
|
||||
if (u.u_uid != u.u_ruid)
|
||||
return(0);
|
||||
u.u_error = 0;
|
||||
u.u_dirp = "core";
|
||||
#ifndef PNETDFS
|
||||
ip = namei(schar, 1);
|
||||
#else
|
||||
ip = namei(schar, 1, NULL);
|
||||
#endif
|
||||
if(ip == NULL) {
|
||||
if(u.u_error)
|
||||
return(0);
|
||||
ip = maknode(0666);
|
||||
if (ip==NULL)
|
||||
return(0);
|
||||
}
|
||||
if(!access(ip, IWRITE) && (ip->i_mode&IFMT) == IFREG) {
|
||||
itrunc(ip);
|
||||
u.u_offset = 0;
|
||||
u.u_base = (caddr_t)&u;
|
||||
u.u_count = ctob(USIZE);
|
||||
u.u_segflg = 1;
|
||||
u.u_limit = (daddr_t)ctod(MAXMEM);
|
||||
writei(ip);
|
||||
s = u.u_procp->p_size - USIZE;
|
||||
estabur((unsigned)0, s, (unsigned)0, 0, RO);
|
||||
u.u_base = 0;
|
||||
u.u_count = ctob(s);
|
||||
u.u_segflg = 0;
|
||||
writei(ip);
|
||||
} else
|
||||
u.u_error = EACCES;
|
||||
iput(ip);
|
||||
return(u.u_error==0);
|
||||
}
|
||||
|
||||
/*
|
||||
* grow the stack to include the SP
|
||||
* true return if successful.
|
||||
*/
|
||||
|
||||
grow(sp)
|
||||
unsigned sp;
|
||||
{
|
||||
register si, i;
|
||||
register struct proc *p;
|
||||
register a;
|
||||
|
||||
si = btoc(USRSTACK-sp) - u.u_ssize;
|
||||
if(si <= 0)
|
||||
return(0);
|
||||
if(estabur(u.u_tsize, u.u_dsize, u.u_ssize+si, u.u_sep, RO))
|
||||
return(0);
|
||||
p = u.u_procp;
|
||||
expand(p->p_size+si);
|
||||
a = p->p_addr + p->p_size;
|
||||
for(i=u.u_ssize; i; i--) {
|
||||
a--;
|
||||
copyseg(a-si, a);
|
||||
}
|
||||
for(i=si; i; i--)
|
||||
clearseg(--a);
|
||||
u.u_ssize += si;
|
||||
return(1);
|
||||
}
|
||||
|
||||
/*
|
||||
* sys-trace system call.
|
||||
*/
|
||||
ptrace()
|
||||
{
|
||||
register struct proc *p;
|
||||
register struct a {
|
||||
int data;
|
||||
int pid;
|
||||
int *addr;
|
||||
int req;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if (uap->req <= 0) {
|
||||
u.u_procp->p_flag |= STRC;
|
||||
return;
|
||||
}
|
||||
for (p=proc; p < (struct proc *)v.ve_proc; p++)
|
||||
if (p->p_stat==SSTOP
|
||||
&& p->p_pid==uap->pid
|
||||
&& p->p_ppid==u.u_procp->p_pid)
|
||||
goto found;
|
||||
u.u_error = ESRCH;
|
||||
return;
|
||||
|
||||
found:
|
||||
while (ipc.ip_lock)
|
||||
sleep((caddr_t)&ipc, IPCPRI);
|
||||
ipc.ip_lock = p->p_pid;
|
||||
ipc.ip_data = uap->data;
|
||||
ipc.ip_addr = uap->addr;
|
||||
ipc.ip_req = uap->req;
|
||||
p->p_flag &= ~SWTED;
|
||||
setrun(p);
|
||||
while (ipc.ip_req > 0)
|
||||
sleep((caddr_t)&ipc, IPCPRI);
|
||||
u.u_rval1 = ipc.ip_data;
|
||||
if (ipc.ip_req < 0)
|
||||
u.u_error = EIO;
|
||||
ipc.ip_lock = 0;
|
||||
wakeup((caddr_t)&ipc);
|
||||
}
|
||||
|
||||
/*
|
||||
* Code that the child process
|
||||
* executes to implement the command
|
||||
* of the parent process in tracing.
|
||||
*/
|
||||
procxmt()
|
||||
{
|
||||
register int i;
|
||||
register *p;
|
||||
register struct text *xp;
|
||||
|
||||
if (ipc.ip_lock != u.u_procp->p_pid)
|
||||
return(0);
|
||||
i = ipc.ip_req;
|
||||
ipc.ip_req = 0;
|
||||
wakeup((caddr_t)&ipc);
|
||||
switch (i) {
|
||||
|
||||
/* read user I */
|
||||
case 1:
|
||||
ipc.ip_data = fuiword((caddr_t)ipc.ip_addr);
|
||||
break;
|
||||
|
||||
/* read user D */
|
||||
case 2:
|
||||
ipc.ip_data = fuword((caddr_t)ipc.ip_addr);
|
||||
break;
|
||||
|
||||
/* read u */
|
||||
case 3:
|
||||
i = (int)ipc.ip_addr;
|
||||
if (i<0 || i >= ctob(USIZE))
|
||||
goto error;
|
||||
ipc.ip_data = ((physadr)&u)->r[i>>1];
|
||||
break;
|
||||
|
||||
/* write user I */
|
||||
/* Must set up to allow writing */
|
||||
case 4:
|
||||
/*
|
||||
* If text, must assure exclusive use
|
||||
*/
|
||||
if (xp = u.u_procp->p_textp) {
|
||||
if (xp->x_count!=1 || xp->x_iptr->i_mode&ISVTX)
|
||||
goto error;
|
||||
xp->x_iptr->i_flag &= ~ITEXT;
|
||||
}
|
||||
estabur(u.u_tsize, u.u_dsize, u.u_ssize, u.u_sep, RW);
|
||||
i = suiword((caddr_t)ipc.ip_addr, 0);
|
||||
suiword((caddr_t)ipc.ip_addr, ipc.ip_data);
|
||||
estabur(u.u_tsize, u.u_dsize, u.u_ssize, u.u_sep, RO);
|
||||
if (i<0)
|
||||
goto error;
|
||||
if (xp)
|
||||
xp->x_flag |= XWRIT;
|
||||
break;
|
||||
|
||||
/* write user D */
|
||||
case 5:
|
||||
if (suword((caddr_t)ipc.ip_addr, 0) < 0)
|
||||
goto error;
|
||||
suword((caddr_t)ipc.ip_addr, ipc.ip_data);
|
||||
break;
|
||||
|
||||
/* write u */
|
||||
case 6:
|
||||
i = (int)ipc.ip_addr;
|
||||
p = (int *)&((physadr)&u)->r[i>>1];
|
||||
for (i=0; i<15; i++)
|
||||
if (p == &u.u_ar0[regloc[i]])
|
||||
goto ok;
|
||||
if (p == &u.u_ar0[PC])
|
||||
goto ok;
|
||||
if (p == &u.u_ar0[FCW]) {
|
||||
ipc.ip_data &= (M_FLGS << S_FLGS);
|
||||
ipc.ip_data |= (B_VI | B_NVI);
|
||||
goto ok;
|
||||
}
|
||||
goto error;
|
||||
|
||||
ok:
|
||||
*p = ipc.ip_data;
|
||||
break;
|
||||
|
||||
/* set signal and continue */
|
||||
/* one version causes a trace-trap */
|
||||
case 9:
|
||||
u.u_ar0[FCW] |= B_SINGL;
|
||||
case 7:
|
||||
u.u_procp->p_sig = 0;
|
||||
if (ipc.ip_data)
|
||||
psignal(u.u_procp, ipc.ip_data);
|
||||
return(1);
|
||||
|
||||
/* force exit */
|
||||
case 8:
|
||||
exit(fsig(u.u_procp));
|
||||
|
||||
default:
|
||||
error:
|
||||
ipc.ip_req = -1;
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
|
@ -0,0 +1,435 @@
|
|||
#include "sys/param.h"
|
||||
#include "sys/systm.h"
|
||||
#include "sys/dir.h"
|
||||
#include "sys/user.h"
|
||||
#include "sys/file.h"
|
||||
#include "sys/inode.h"
|
||||
#include "sys/sysinfo.h"
|
||||
#ifdef PNETDFS
|
||||
extern ddbug;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* read system call
|
||||
*/
|
||||
read()
|
||||
{
|
||||
rdwr(FREAD);
|
||||
}
|
||||
|
||||
/*
|
||||
* write system call
|
||||
*/
|
||||
write()
|
||||
{
|
||||
rdwr(FWRITE);
|
||||
}
|
||||
|
||||
/*
|
||||
* common code for read and write calls:
|
||||
* check permissions, set base, count, and offset,
|
||||
* and switch out to readi or writei code.
|
||||
*/
|
||||
rdwr(mode)
|
||||
register mode;
|
||||
{
|
||||
register struct file *fp;
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
int fdes;
|
||||
char *cbuf;
|
||||
unsigned count;
|
||||
} *uap;
|
||||
int type;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
fp = getf(uap->fdes);
|
||||
if (fp == NULL)
|
||||
return;
|
||||
if ((fp->f_flag&mode) == 0) {
|
||||
u.u_error = EBADF;
|
||||
return;
|
||||
}
|
||||
u.u_base = (caddr_t)uap->cbuf;
|
||||
u.u_count = uap->count;
|
||||
u.u_segflg = 0;
|
||||
u.u_fmode = fp->f_flag;
|
||||
ip = fp->f_inode;
|
||||
#ifdef PNETDFS
|
||||
if ( ip->i_flag & IRMT ) {
|
||||
rrdwr( ip, uap->fdes, mode );
|
||||
goto dfsout;
|
||||
}
|
||||
#endif
|
||||
type = ip->i_mode&IFMT;
|
||||
if (type==IFREG || type==IFDIR) {
|
||||
if ((u.u_fmode&FAPPEND) && (mode == FWRITE))
|
||||
fp->f_offset = ip->i_size;
|
||||
if (ip->i_locklist &&
|
||||
locked(1, ip, fp->f_offset, fp->f_offset + u.u_count))
|
||||
return;
|
||||
plock(ip);
|
||||
} else if (type == IFIFO) {
|
||||
fp->f_offset = 0;
|
||||
if (ip->i_locklist &&
|
||||
locked(1, ip, fp->f_offset, fp->f_offset + u.u_count))
|
||||
return;
|
||||
plock(ip);
|
||||
}
|
||||
u.u_offset = fp->f_offset;
|
||||
if (mode == FREAD)
|
||||
readi(ip);
|
||||
else
|
||||
writei(ip);
|
||||
if (type==IFREG || type==IFDIR || type==IFIFO)
|
||||
prele(ip);
|
||||
#ifdef PNETDFS
|
||||
dfsout:
|
||||
#endif
|
||||
fp->f_offset += uap->count-u.u_count;
|
||||
u.u_rval1 = uap->count-u.u_count;
|
||||
u.u_ioch += u.u_rval1;
|
||||
if (mode == FREAD)
|
||||
sysinfo.readch += u.u_rval1;
|
||||
else
|
||||
sysinfo.writech += u.u_rval1;
|
||||
}
|
||||
|
||||
/*
|
||||
* open system call
|
||||
*/
|
||||
open()
|
||||
{
|
||||
register struct a {
|
||||
char *fname;
|
||||
int mode;
|
||||
int crtmode;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
copen(uap->mode-FOPEN, uap->crtmode);
|
||||
}
|
||||
|
||||
/*
|
||||
* creat system call
|
||||
*/
|
||||
creat()
|
||||
{
|
||||
register struct a {
|
||||
char *fname;
|
||||
int fmode;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
copen(FWRITE|FCREAT|FTRUNC, uap->fmode);
|
||||
}
|
||||
|
||||
/*
|
||||
* common code for open and creat.
|
||||
* Check permissions, allocate an open file structure,
|
||||
* and call the device open routine if any.
|
||||
*/
|
||||
copen(mode, arg)
|
||||
register mode;
|
||||
{
|
||||
register struct inode *ip;
|
||||
register struct file *fp;
|
||||
int i;
|
||||
|
||||
if ((mode&(FREAD|FWRITE)) == 0) {
|
||||
u.u_error = EINVAL;
|
||||
return;
|
||||
}
|
||||
if (mode&FCREAT) {
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 1);
|
||||
#else
|
||||
ip = namei(uchar, 1, NULL);
|
||||
#endif
|
||||
if (ip == NULL) {
|
||||
if (u.u_error)
|
||||
return;
|
||||
ip = maknode(arg&07777&(~ISVTX));
|
||||
if (ip == NULL)
|
||||
return;
|
||||
mode &= ~FTRUNC;
|
||||
} else {
|
||||
if (ip->i_locklist != NULL &&
|
||||
(ip->i_flag & IFMT) == IFREG &&
|
||||
locked(2, ip, (long)(0L), (long)(1L<<30))) {
|
||||
iput(ip);
|
||||
return;
|
||||
}
|
||||
if (mode&FEXCL) {
|
||||
u.u_error = EEXIST;
|
||||
iput(ip);
|
||||
return;
|
||||
}
|
||||
mode &= ~FCREAT;
|
||||
}
|
||||
} else {
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if (ip == NULL)
|
||||
return;
|
||||
}
|
||||
if (!(mode&FCREAT)) {
|
||||
if (mode&FREAD)
|
||||
access(ip, IREAD);
|
||||
if (mode&(FWRITE|FTRUNC)) {
|
||||
access(ip, IWRITE);
|
||||
if ((ip->i_mode&IFMT) == IFDIR)
|
||||
u.u_error = EISDIR;
|
||||
}
|
||||
}
|
||||
if (u.u_error || (fp = falloc()) == NULL) {
|
||||
iput(ip);
|
||||
return;
|
||||
}
|
||||
if (mode&FTRUNC)
|
||||
itrunc(ip);
|
||||
prele(ip);
|
||||
fp->f_flag = mode&FMASK;
|
||||
fp->f_inode = ip;
|
||||
i = u.u_rval1;
|
||||
if (setjmp(u.u_qsav)) { /* catch half-opens */
|
||||
if (u.u_abreq)
|
||||
(*u.u_abreq)();
|
||||
if (u.u_error == 0)
|
||||
u.u_error = EINTR;
|
||||
closef(fp);
|
||||
u.u_ofile[i] = NULL;
|
||||
} else {
|
||||
openi(ip, mode);
|
||||
if (u.u_error == 0)
|
||||
return;
|
||||
u.u_ofile[i] = NULL;
|
||||
fp->f_count--;
|
||||
iput(ip);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* close system call
|
||||
*/
|
||||
close()
|
||||
{
|
||||
register struct file *fp;
|
||||
register struct a {
|
||||
int fdes;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
fp = getf(uap->fdes);
|
||||
if (fp == NULL)
|
||||
return;
|
||||
closef(fp);
|
||||
u.u_ofile[uap->fdes] = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* seek system call
|
||||
*/
|
||||
seek()
|
||||
{
|
||||
register struct file *fp;
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
int fdes;
|
||||
off_t off;
|
||||
int sbase;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
fp = getf(uap->fdes);
|
||||
if (fp == NULL)
|
||||
return;
|
||||
ip = fp->f_inode;
|
||||
if ((ip->i_mode&IFMT)==IFIFO) {
|
||||
u.u_error = ESPIPE;
|
||||
return;
|
||||
}
|
||||
#ifdef PNETDFS
|
||||
if ( ip->i_flag & IRMT ) {
|
||||
if ( ddbug ) {
|
||||
printf( "remote seek %x\n", ip );
|
||||
debug();
|
||||
}
|
||||
rseek( uap->fdes, uap->off, uap->sbase );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
if (uap->sbase == 1)
|
||||
uap->off += fp->f_offset;
|
||||
else if (uap->sbase == 2)
|
||||
uap->off += fp->f_inode->i_size;
|
||||
else if (uap->sbase != 0) {
|
||||
u.u_error = EINVAL;
|
||||
psignal(u.u_procp, SIGSYS);
|
||||
return;
|
||||
}
|
||||
if (uap->off < 0) {
|
||||
u.u_error = EINVAL;
|
||||
return;
|
||||
}
|
||||
fp->f_offset = uap->off;
|
||||
u.u_roff = uap->off;
|
||||
}
|
||||
|
||||
/*
|
||||
* link system call
|
||||
*/
|
||||
link()
|
||||
{
|
||||
register struct inode *ip, *xp;
|
||||
register struct a {
|
||||
char *target;
|
||||
char *linkname;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if (ip == NULL)
|
||||
return;
|
||||
if (ip->i_nlink >= MAXLINK) {
|
||||
u.u_error = EMLINK;
|
||||
goto out;
|
||||
}
|
||||
if ((ip->i_mode&IFMT)==IFDIR && !suser())
|
||||
goto out;
|
||||
/*
|
||||
* Unlock to avoid possibly hanging the namei.
|
||||
* Sadly, this means races. (Suppose someone
|
||||
* deletes the file in the meantime?)
|
||||
* Nor can it be locked again later
|
||||
* because then there will be deadly
|
||||
* embraces.
|
||||
*/
|
||||
prele(ip);
|
||||
u.u_dirp = (caddr_t)uap->linkname;
|
||||
#ifndef PNETDFS
|
||||
xp = namei(uchar, 1);
|
||||
#else
|
||||
xp = namei(uchar, 1, NULL);
|
||||
#endif
|
||||
if (xp != NULL) {
|
||||
u.u_error = EEXIST;
|
||||
iput(xp);
|
||||
goto out;
|
||||
}
|
||||
if (u.u_error)
|
||||
goto out;
|
||||
#ifdef PNETDFS
|
||||
if ( u.u_pdir && u.u_pdir->i_flag & IRMT ) {
|
||||
printf( "link on remote dfs, not there yet\n" );
|
||||
debug();
|
||||
u.u_error = EXDEV;
|
||||
iput( u.u_pdir );
|
||||
goto out;
|
||||
}
|
||||
#endif
|
||||
if (u.u_pdir->i_dev != ip->i_dev) {
|
||||
iput(u.u_pdir);
|
||||
u.u_error = EXDEV;
|
||||
goto out;
|
||||
}
|
||||
wdir(ip);
|
||||
if (u.u_error==0) {
|
||||
ip->i_nlink++;
|
||||
ip->i_flag |= ICHG;
|
||||
}
|
||||
|
||||
out:
|
||||
iput(ip);
|
||||
}
|
||||
|
||||
/*
|
||||
* mknod system call
|
||||
*/
|
||||
mknod()
|
||||
{
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
char *fname;
|
||||
int fmode;
|
||||
dev_t dev;
|
||||
} *uap;
|
||||
#ifdef PNETDFS
|
||||
struct inode *rmaknode();
|
||||
#endif
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if ((uap->fmode&IFMT) != IFIFO && !suser())
|
||||
return;
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 1);
|
||||
#else
|
||||
ip = namei(uchar, 1, NULL);
|
||||
#endif
|
||||
if (ip != NULL) {
|
||||
u.u_error = EEXIST;
|
||||
goto out;
|
||||
}
|
||||
if (u.u_error)
|
||||
return;
|
||||
#ifdef PNETDFS
|
||||
if ( u.u_pdir->i_flag & IRMT ) {
|
||||
ip = rmaknode( uap->fmode );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
ip = maknode(uap->fmode);
|
||||
if (ip == NULL)
|
||||
return;
|
||||
switch(ip->i_mode&IFMT) {
|
||||
case IFCHR:
|
||||
case IFBLK:
|
||||
ip->i_rdev = (dev_t)uap->dev;
|
||||
ip->i_flag |= ICHG;
|
||||
}
|
||||
|
||||
out:
|
||||
iput(ip);
|
||||
}
|
||||
|
||||
/*
|
||||
* access system call
|
||||
*/
|
||||
saccess()
|
||||
{
|
||||
register svuid, svgid;
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
char *fname;
|
||||
int fmode;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
svuid = u.u_uid;
|
||||
svgid = u.u_gid;
|
||||
u.u_uid = u.u_ruid;
|
||||
u.u_gid = u.u_rgid;
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if (ip != NULL) {
|
||||
if (uap->fmode&(IREAD>>6))
|
||||
access(ip, IREAD);
|
||||
if (uap->fmode&(IWRITE>>6))
|
||||
access(ip, IWRITE);
|
||||
if (uap->fmode&(IEXEC>>6))
|
||||
access(ip, IEXEC);
|
||||
iput(ip);
|
||||
}
|
||||
u.u_uid = svuid;
|
||||
u.u_gid = svgid;
|
||||
}
|
||||
|
|
@ -0,0 +1,428 @@
|
|||
#include "sys/param.h"
|
||||
#include "sys/systm.h"
|
||||
#include "sys/stat.h"
|
||||
#include "sys/mount.h"
|
||||
#include "sys/ino.h"
|
||||
#include "sys/buf.h"
|
||||
#include "sys/filsys.h"
|
||||
#include "sys/dir.h"
|
||||
#include "sys/user.h"
|
||||
#include "sys/inode.h"
|
||||
#include "sys/file.h"
|
||||
#include "sys/conf.h"
|
||||
#include "sys/ioctl.h"
|
||||
#include "sys/var.h"
|
||||
#ifdef PNETDFS
|
||||
extern ddbug;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* the fstat system call.
|
||||
*/
|
||||
fstat()
|
||||
{
|
||||
register struct file *fp;
|
||||
register struct a {
|
||||
int fdes;
|
||||
struct stat *sb;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
fp = getf(uap->fdes);
|
||||
if(fp == NULL)
|
||||
return;
|
||||
stat1(fp->f_inode, uap->sb);
|
||||
}
|
||||
|
||||
/*
|
||||
* the stat system call.
|
||||
*/
|
||||
stat()
|
||||
{
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
char *fname;
|
||||
struct stat *sb;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if(ip == NULL)
|
||||
return;
|
||||
stat1(ip, uap->sb);
|
||||
iput(ip);
|
||||
}
|
||||
|
||||
/*
|
||||
* The basic routine for fstat and stat:
|
||||
* get the inode and pass appropriate parts back.
|
||||
*/
|
||||
stat1(ip, ub)
|
||||
register struct inode *ip;
|
||||
struct stat *ub;
|
||||
{
|
||||
register struct buf *bp;
|
||||
struct stat ds;
|
||||
|
||||
#ifdef PNETDFS
|
||||
if ( ip->i_flag & IRMT ) {
|
||||
rstat1( ip, ub );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
if(ip->i_flag&(IACC|IUPD|ICHG))
|
||||
iupdat(ip, &time, &time);
|
||||
/*
|
||||
* first copy from inode table
|
||||
*/
|
||||
ds.st_dev = ip->i_dev;
|
||||
ds.st_ino = ip->i_number;
|
||||
ds.st_mode = ip->i_mode;
|
||||
ds.st_nlink = ip->i_nlink;
|
||||
ds.st_uid = ip->i_uid;
|
||||
ds.st_gid = ip->i_gid;
|
||||
ds.st_rdev = (dev_t)ip->i_rdev;
|
||||
ds.st_size = ip->i_size;
|
||||
/*
|
||||
* next the dates in the disk
|
||||
*/
|
||||
bp = bread(ip->i_dev, itod(ip->i_number));
|
||||
copyio(paddr(bp)+itoo(ip->i_number)*sizeof(struct dinode)
|
||||
+(long)(&((struct dinode *)0)->di_atime),
|
||||
&ds.st_atime, 3*sizeof(time_t), U_RKD);
|
||||
brelse(bp);
|
||||
if (copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)) < 0)
|
||||
u.u_error = EFAULT;
|
||||
}
|
||||
|
||||
/*
|
||||
* the dup system call.
|
||||
*
|
||||
* dup2 has been added to the stock SYSTEM III code for compatibility
|
||||
* with v7.
|
||||
*/
|
||||
dup()
|
||||
{
|
||||
register struct file *fp;
|
||||
register struct a {
|
||||
int fdes;
|
||||
int fdes2;
|
||||
} *uap;
|
||||
register i,m;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
m = uap->fdes & ~077;
|
||||
uap->fdes &= 077;
|
||||
fp = getf(uap->fdes);
|
||||
if(fp == NULL)
|
||||
return;
|
||||
if ((m&0100) == 0) {
|
||||
if ((i = ufalloc(0)) < 0)
|
||||
return;
|
||||
} else {
|
||||
i = uap->fdes2;
|
||||
if (i<0 || i>=NOFILE) {
|
||||
u.u_error = EBADF;
|
||||
return;
|
||||
}
|
||||
u.u_rval1 = i;
|
||||
}
|
||||
if (i!=uap->fdes) {
|
||||
if (u.u_ofile[i]!=NULL)
|
||||
closef(u.u_ofile[i]);
|
||||
u.u_ofile[i] = fp;
|
||||
fp->f_count++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* the file control system call.
|
||||
*/
|
||||
fcntl()
|
||||
{
|
||||
register struct file *fp;
|
||||
register struct a {
|
||||
int fdes;
|
||||
int cmd;
|
||||
int arg;
|
||||
} *uap;
|
||||
register i;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
fp = getf(uap->fdes);
|
||||
if (fp == NULL)
|
||||
return;
|
||||
switch(uap->cmd) {
|
||||
case 0:
|
||||
i = uap->arg;
|
||||
if (i < 0 || i > NOFILE) {
|
||||
u.u_error = EINVAL;
|
||||
return;
|
||||
}
|
||||
if ((i = ufalloc(i)) < 0)
|
||||
return;
|
||||
#ifdef PNETDFS
|
||||
if ( fp->f_inode->i_flag & IRMT ) {
|
||||
if ( ddbug ) {
|
||||
printf( "fcntl dup on remote file %x\n", fp );
|
||||
debug();
|
||||
}
|
||||
rfcntl( uap->fdes, i, 0, uap->arg );
|
||||
}
|
||||
#endif
|
||||
u.u_ofile[i] = fp;
|
||||
fp->f_count++;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
u.u_rval1 = u.u_pofile[uap->fdes];
|
||||
break;
|
||||
|
||||
case 2:
|
||||
u.u_pofile[uap->fdes] = uap->arg;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
u.u_rval1 = fp->f_flag+FOPEN;
|
||||
break;
|
||||
|
||||
case 4:
|
||||
fp->f_flag &= (FREAD|FWRITE);
|
||||
#ifdef PNETDFS
|
||||
if ( fp->f_inode->i_flag & IRMT ) {
|
||||
if ( ddbug ) {
|
||||
printf( "fcntl setfl on remote file %x\n", fp );
|
||||
debug();
|
||||
}
|
||||
rfcntl( uap->fdes, i, 4, uap->arg );
|
||||
}
|
||||
#endif
|
||||
fp->f_flag |= (uap->arg-FOPEN) & ~(FREAD|FWRITE);
|
||||
break;
|
||||
|
||||
default:
|
||||
u.u_error = EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* character special i/o control
|
||||
*/
|
||||
ioctl()
|
||||
{
|
||||
register struct file *fp;
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
int fdes;
|
||||
int cmd;
|
||||
int arg;
|
||||
} *uap;
|
||||
register dev_t dev;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if ((fp = getf(uap->fdes)) == NULL)
|
||||
return;
|
||||
ip = fp->f_inode;
|
||||
if ((ip->i_mode&IFMT) != IFCHR) {
|
||||
u.u_error = ENOTTY;
|
||||
return;
|
||||
}
|
||||
u.u_rval1 = 0;
|
||||
#ifdef PNETDFS
|
||||
if ( ip->i_flag & IRMT ) {
|
||||
rioctl( uap->fdes, uap->cmd, uap->arg );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
dev = (dev_t)ip->i_rdev;
|
||||
(*cdevsw[major(dev)].d_ioctl)(minor(dev),uap->cmd,uap->arg,fp->f_flag);
|
||||
}
|
||||
|
||||
/*
|
||||
* old stty and gtty
|
||||
*/
|
||||
stty()
|
||||
{
|
||||
register struct a {
|
||||
int fdes;
|
||||
int arg;
|
||||
int narg;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
uap->narg = uap->arg;
|
||||
uap->arg = TIOCSETP;
|
||||
ioctl();
|
||||
}
|
||||
|
||||
gtty()
|
||||
{
|
||||
register struct a {
|
||||
int fdes;
|
||||
int arg;
|
||||
int narg;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
uap->narg = uap->arg;
|
||||
uap->arg = TIOCGETP;
|
||||
ioctl();
|
||||
}
|
||||
|
||||
/*
|
||||
* the mount system call.
|
||||
*/
|
||||
smount()
|
||||
{
|
||||
dev_t dev;
|
||||
register struct inode *ip;
|
||||
register struct mount *mp;
|
||||
struct mount *smp;
|
||||
register struct filsys *fp;
|
||||
struct buf *bp;
|
||||
register struct a {
|
||||
char *fspec;
|
||||
char *freg;
|
||||
int ronly;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if(!suser())
|
||||
return;
|
||||
dev = getmdev();
|
||||
if(u.u_error)
|
||||
return;
|
||||
u.u_dirp = (caddr_t)uap->freg;
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if(ip == NULL)
|
||||
return;
|
||||
if ((ip->i_mode&IFMT) != IFDIR) {
|
||||
u.u_error = ENOTDIR;
|
||||
goto out;
|
||||
}
|
||||
if (ip->i_count != 1)
|
||||
goto out;
|
||||
if (ip->i_number == ROOTINO)
|
||||
goto out;
|
||||
smp = NULL;
|
||||
for(mp = &mount[0]; mp < (struct mount *)v.ve_mount; mp++) {
|
||||
if(mp->m_flags != MFREE) {
|
||||
if(dev == mp->m_dev)
|
||||
goto out;
|
||||
} else
|
||||
if(smp == NULL)
|
||||
smp = mp;
|
||||
}
|
||||
mp = smp;
|
||||
if(mp == NULL)
|
||||
goto out;
|
||||
mp->m_flags = MINTER;
|
||||
mp->m_dev = dev;
|
||||
(*bdevsw[major(dev)].d_open)(minor(dev), !uap->ronly);
|
||||
if(u.u_error)
|
||||
goto out1;
|
||||
bp = bread(dev, SUPERB);
|
||||
if(u.u_error) {
|
||||
brelse(bp);
|
||||
goto out1;
|
||||
}
|
||||
mp->m_inodp = ip;
|
||||
mp->m_bufp = getablk(1);
|
||||
fp = (struct filsys *)paddr(mp->m_bufp);
|
||||
copyio(paddr(bp), fp, sizeof(struct filsys), U_RKD);
|
||||
mp->m_flags = MINUSE;
|
||||
fp->s_ilock = 0;
|
||||
fp->s_flock = 0;
|
||||
fp->s_ninode = 0;
|
||||
fp->s_inode[0] = 0;
|
||||
fp->s_ronly = uap->ronly & 1;
|
||||
brelse(bp);
|
||||
ip->i_flag |= IMOUNT;
|
||||
prele(ip);
|
||||
return;
|
||||
|
||||
out1:
|
||||
mp->m_flags = MFREE;
|
||||
out:
|
||||
if (u.u_error == 0)
|
||||
u.u_error = EBUSY;
|
||||
iput(ip);
|
||||
}
|
||||
|
||||
/*
|
||||
* the umount system call.
|
||||
*/
|
||||
sumount()
|
||||
{
|
||||
dev_t dev;
|
||||
register struct inode *ip;
|
||||
register struct mount *mp;
|
||||
register struct a {
|
||||
char *fspec;
|
||||
};
|
||||
|
||||
if(!suser())
|
||||
return;
|
||||
dev = getmdev();
|
||||
if(u.u_error)
|
||||
return;
|
||||
xumount(dev); /* remove unused sticky files from text table */
|
||||
update();
|
||||
for(mp = &mount[0]; mp < (struct mount *)v.ve_mount; mp++)
|
||||
if(mp->m_flags == MINUSE && dev == mp->m_dev)
|
||||
goto found;
|
||||
u.u_error = EINVAL;
|
||||
return;
|
||||
|
||||
found:
|
||||
for(ip = &inode[0]; ip < (struct inode *)v.ve_inode; ip++)
|
||||
if(ip->i_number != 0 && dev == ip->i_dev) {
|
||||
u.u_error = EBUSY;
|
||||
return;
|
||||
}
|
||||
(*bdevsw[major(dev)].d_close)(minor(dev), 0);
|
||||
binval(dev);
|
||||
ip = mp->m_inodp;
|
||||
ip->i_flag &= ~IMOUNT;
|
||||
plock(ip);
|
||||
iput(ip);
|
||||
brelse(mp->m_bufp);
|
||||
mp->m_bufp = NULL;
|
||||
mp->m_flags = MFREE;
|
||||
}
|
||||
|
||||
/*
|
||||
* Common code for mount and umount.
|
||||
* Check that the user's argument is a reasonable
|
||||
* thing on which to mount, and return the device number if so.
|
||||
*/
|
||||
dev_t
|
||||
getmdev()
|
||||
{
|
||||
dev_t dev;
|
||||
register struct inode *ip;
|
||||
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if(ip == NULL)
|
||||
return(NODEV);
|
||||
if((ip->i_mode&IFMT) != IFBLK)
|
||||
u.u_error = ENOTBLK;
|
||||
dev = (dev_t)ip->i_rdev;
|
||||
if(major(dev) >= bdevcnt)
|
||||
u.u_error = ENXIO;
|
||||
iput(ip);
|
||||
return(dev);
|
||||
}
|
||||
|
|
@ -0,0 +1,531 @@
|
|||
#include "sys/param.h"
|
||||
#include "sys/plexus.h"
|
||||
#include "sys/systm.h"
|
||||
#include "sys/dir.h"
|
||||
#include "sys/user.h"
|
||||
#include "sys/inode.h"
|
||||
#include "sys/proc.h"
|
||||
#include "sys/var.h"
|
||||
|
||||
#ifdef PNETDFS
|
||||
extern int ddbug;
|
||||
#endif
|
||||
/*
|
||||
* Everything in this file is a routine implementing a system call.
|
||||
*/
|
||||
|
||||
gtime()
|
||||
{
|
||||
u.u_rtime = time;
|
||||
}
|
||||
|
||||
stime()
|
||||
{
|
||||
register struct a {
|
||||
time_t time;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if (suser()) {
|
||||
logtchg(uap->time);
|
||||
time = uap->time;
|
||||
puttod(time);
|
||||
}
|
||||
}
|
||||
|
||||
setuid()
|
||||
{
|
||||
register uid;
|
||||
register struct a {
|
||||
int uid;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
uid = uap->uid;
|
||||
if (uid >= MAXUID) {
|
||||
u.u_error = EINVAL;
|
||||
return;
|
||||
}
|
||||
if (u.u_ruid == uid || suser()) {
|
||||
u.u_uid = uid;
|
||||
u.u_procp->p_uid = uid;
|
||||
u.u_ruid = uid;
|
||||
}
|
||||
}
|
||||
|
||||
getuid()
|
||||
{
|
||||
|
||||
u.u_rval1 = u.u_ruid;
|
||||
u.u_rval2 = u.u_uid;
|
||||
}
|
||||
|
||||
setgid()
|
||||
{
|
||||
register gid;
|
||||
register struct a {
|
||||
int gid;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
gid = uap->gid;
|
||||
if (gid >= MAXUID) {
|
||||
u.u_error = EINVAL;
|
||||
return;
|
||||
}
|
||||
if (u.u_rgid == gid || suser()) {
|
||||
u.u_gid = gid;
|
||||
u.u_rgid = gid;
|
||||
}
|
||||
}
|
||||
|
||||
getgid()
|
||||
{
|
||||
|
||||
u.u_rval1 = u.u_rgid;
|
||||
u.u_rval2 = u.u_gid;
|
||||
}
|
||||
|
||||
getpid()
|
||||
{
|
||||
u.u_rval1 = u.u_procp->p_pid;
|
||||
u.u_rval2 = u.u_procp->p_ppid;
|
||||
}
|
||||
|
||||
setpgrp()
|
||||
{
|
||||
register struct a {
|
||||
int flag;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if (uap->flag) {
|
||||
u.u_procp->p_pgrp = u.u_procp->p_pid;
|
||||
u.u_ttyp = NULL;
|
||||
}
|
||||
u.u_rval1 = u.u_procp->p_pgrp;
|
||||
}
|
||||
|
||||
sync()
|
||||
{
|
||||
|
||||
update();
|
||||
}
|
||||
|
||||
nice()
|
||||
{
|
||||
register n;
|
||||
register struct a {
|
||||
int niceness;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
n = uap->niceness;
|
||||
if ((n < 0 || n > 2*NZERO) && !suser())
|
||||
n = 0;
|
||||
n += u.u_procp->p_nice;
|
||||
if (n >= 2*NZERO)
|
||||
n = 2*NZERO -1;
|
||||
if (n < 0)
|
||||
n = 0;
|
||||
u.u_procp->p_nice = n;
|
||||
u.u_rval1 = n - NZERO;
|
||||
}
|
||||
|
||||
/*
|
||||
* Unlink system call.
|
||||
* Hard to avoid races here, especially
|
||||
* in unlinking directories.
|
||||
*/
|
||||
unlink()
|
||||
{
|
||||
register struct inode *ip, *pp;
|
||||
struct a {
|
||||
char *fname;
|
||||
};
|
||||
|
||||
#ifndef PNETDFS
|
||||
pp = namei(uchar, 2);
|
||||
#else
|
||||
pp = namei(uchar, 2, NULL);
|
||||
#endif
|
||||
if (pp == NULL)
|
||||
return;
|
||||
#ifdef PNETDFS
|
||||
if ( pp->i_flag & IRMT ) {
|
||||
if ( ddbug ) {
|
||||
printf( "remote unlink, not there yet\n" );
|
||||
debug();
|
||||
}
|
||||
goto out1;
|
||||
}
|
||||
#endif
|
||||
/*
|
||||
* Check for unlink(".")
|
||||
* to avoid hanging on the iget
|
||||
*/
|
||||
if (pp->i_number == u.u_dent.d_ino) {
|
||||
ip = pp;
|
||||
ip->i_count++;
|
||||
} else
|
||||
ip = iget(pp->i_dev, u.u_dent.d_ino);
|
||||
if (ip == NULL)
|
||||
goto out1;
|
||||
if ((ip->i_mode&IFMT) == IFDIR && !suser())
|
||||
goto out;
|
||||
/*
|
||||
* Don't unlink a mounted file.
|
||||
*/
|
||||
if (ip->i_dev != pp->i_dev) {
|
||||
u.u_error = EBUSY;
|
||||
goto out;
|
||||
}
|
||||
if (ip->i_flag&ITEXT)
|
||||
xrele(ip); /* try once to free text */
|
||||
if (ip->i_flag&ITEXT && ip->i_nlink == 1) {
|
||||
u.u_error = ETXTBSY;
|
||||
goto out;
|
||||
}
|
||||
u.u_offset -= sizeof(struct direct);
|
||||
u.u_base = (caddr_t)&u.u_dent;
|
||||
u.u_count = sizeof(struct direct);
|
||||
u.u_dent.d_ino = 0;
|
||||
u.u_segflg = 1;
|
||||
writei(pp);
|
||||
if (u.u_error)
|
||||
goto out;
|
||||
ip->i_nlink--;
|
||||
ip->i_flag |= ICHG;
|
||||
|
||||
out:
|
||||
iput(ip);
|
||||
out1:
|
||||
iput(pp);
|
||||
}
|
||||
|
||||
chdir()
|
||||
{
|
||||
chdirec(&u.u_cdir);
|
||||
}
|
||||
|
||||
chroot()
|
||||
{
|
||||
if (!suser())
|
||||
return;
|
||||
chdirec(&u.u_rdir);
|
||||
}
|
||||
|
||||
chdirec(ipp)
|
||||
register struct inode **ipp;
|
||||
{
|
||||
register struct inode *ip;
|
||||
struct a {
|
||||
char *fname;
|
||||
};
|
||||
|
||||
#ifndef PNETDFS
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if (ip == NULL)
|
||||
return;
|
||||
if ((ip->i_mode&IFMT) != IFDIR) {
|
||||
u.u_error = ENOTDIR;
|
||||
goto bad;
|
||||
}
|
||||
if (access(ip, IEXEC))
|
||||
goto bad;
|
||||
prele(ip);
|
||||
if (*ipp) {
|
||||
plock(*ipp);
|
||||
iput(*ipp);
|
||||
}
|
||||
*ipp = ip;
|
||||
return;
|
||||
|
||||
bad:
|
||||
iput(ip);
|
||||
}
|
||||
|
||||
chmod()
|
||||
{
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
char *fname;
|
||||
int fmode;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if ((ip = owner()) == NULL)
|
||||
return;
|
||||
ip->i_mode &= ~07777;
|
||||
if (u.u_uid) {
|
||||
uap->fmode &= ~ISVTX;
|
||||
if (u.u_gid != ip->i_gid)
|
||||
uap->fmode &= ~ISGID;
|
||||
}
|
||||
#ifdef PNETDFS
|
||||
if ( ip->i_flag & IRMT ) {
|
||||
rchmod( ip, uap->fmode );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
ip->i_mode |= uap->fmode&07777;
|
||||
ip->i_flag |= ICHG;
|
||||
if (ip->i_flag&ITEXT && (ip->i_mode&ISVTX)==0)
|
||||
xrele(ip);
|
||||
iput(ip);
|
||||
}
|
||||
|
||||
chown()
|
||||
{
|
||||
register struct inode *ip;
|
||||
register struct a {
|
||||
char *fname;
|
||||
int uid;
|
||||
int gid;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if ((ip = owner()) == NULL)
|
||||
return;
|
||||
#ifdef PNETDFS
|
||||
if ( ip->i_flag & IRMT ) {
|
||||
rchown( ip, uap->uid, uap->gid );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
ip->i_uid = uap->uid;
|
||||
ip->i_gid = uap->gid;
|
||||
if (u.u_uid != 0)
|
||||
ip->i_mode &= ~(ISUID|ISGID);
|
||||
ip->i_flag |= ICHG;
|
||||
iput(ip);
|
||||
}
|
||||
|
||||
ssig()
|
||||
{
|
||||
register a;
|
||||
register struct proc *p;
|
||||
struct a {
|
||||
int signo;
|
||||
int fun;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
a = uap->signo;
|
||||
if (a <= 0 || a > NSIG || a == SIGKILL) {
|
||||
u.u_error = EINVAL;
|
||||
return;
|
||||
}
|
||||
u.u_rval1 = u.u_signal[a-1];
|
||||
u.u_signal[a-1] = uap->fun;
|
||||
u.u_procp->p_sig &= ~(1L<<(a-1));
|
||||
if (a == SIGCLD) {
|
||||
a = u.u_procp->p_pid;
|
||||
for (p = &proc[1]; p < (struct proc *)v.ve_proc; p++) {
|
||||
if (a == p->p_ppid && p->p_stat == SZOMB)
|
||||
psignal(u.u_procp, SIGCLD);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
kill()
|
||||
{
|
||||
register struct proc *p, *q;
|
||||
register arg;
|
||||
register struct a {
|
||||
int pid;
|
||||
int signo;
|
||||
} *uap;
|
||||
int f;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if (uap->signo < 0 || uap->signo > NSIG) {
|
||||
u.u_error = EINVAL;
|
||||
return;
|
||||
}
|
||||
f = 0;
|
||||
arg = uap->pid;
|
||||
if (arg > 0)
|
||||
p = &proc[1];
|
||||
else
|
||||
p = &proc[2];
|
||||
q = u.u_procp;
|
||||
if (arg == 0 && q->p_pgrp == 0) {
|
||||
u.u_error = ESRCH;
|
||||
return;
|
||||
}
|
||||
for(; p < (struct proc *)v.ve_proc; p++) {
|
||||
if (p->p_stat == NULL)
|
||||
continue;
|
||||
if (arg > 0 && p->p_pid != arg)
|
||||
continue;
|
||||
if (arg == 0 && p->p_pgrp != q->p_pgrp)
|
||||
continue;
|
||||
if (arg < -1 && p->p_pgrp != -arg)
|
||||
continue;
|
||||
if (u.u_uid != 0 && u.u_uid != p->p_uid && u.u_procp != p)
|
||||
if (arg > 0) {
|
||||
u.u_error = EPERM;
|
||||
return;
|
||||
} else
|
||||
continue;
|
||||
f++;
|
||||
if (uap->signo)
|
||||
psignal(p, uap->signo);
|
||||
if (arg > 0)
|
||||
break;
|
||||
}
|
||||
if (f == 0)
|
||||
u.u_error = ESRCH;
|
||||
}
|
||||
|
||||
times()
|
||||
{
|
||||
register struct a {
|
||||
time_t (*times)[4];
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if (copyout((caddr_t)&u.u_utime, (caddr_t)uap->times, sizeof(*uap->times)))
|
||||
u.u_error = EFAULT;
|
||||
spl7();
|
||||
u.u_rtime = lbolt;
|
||||
spl0();
|
||||
}
|
||||
|
||||
profil()
|
||||
{
|
||||
register struct a {
|
||||
short *bufbase;
|
||||
unsigned bufsize;
|
||||
unsigned pcoffset;
|
||||
unsigned pcscale;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
u.u_prof.pr_base = uap->bufbase;
|
||||
u.u_prof.pr_size = uap->bufsize;
|
||||
u.u_prof.pr_off = uap->pcoffset;
|
||||
u.u_prof.pr_scale = uap->pcscale;
|
||||
}
|
||||
|
||||
/*
|
||||
* alarm clock signal
|
||||
*/
|
||||
alarm()
|
||||
{
|
||||
register struct proc *p;
|
||||
register c;
|
||||
register struct a {
|
||||
int deltat;
|
||||
} *uap;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
p = u.u_procp;
|
||||
c = p->p_clktim;
|
||||
p->p_clktim = uap->deltat;
|
||||
u.u_rval1 = c;
|
||||
}
|
||||
|
||||
/*
|
||||
* indefinite wait.
|
||||
* no one should wakeup(&u)
|
||||
*/
|
||||
pause()
|
||||
{
|
||||
|
||||
for(;;)
|
||||
sleep((caddr_t)&u, PSLEP);
|
||||
}
|
||||
|
||||
/*
|
||||
* mode mask for creation of files
|
||||
*/
|
||||
umask()
|
||||
{
|
||||
register struct a {
|
||||
int mask;
|
||||
} *uap;
|
||||
register t;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
t = u.u_cmask;
|
||||
u.u_cmask = uap->mask & 0777;
|
||||
u.u_rval1 = t;
|
||||
}
|
||||
|
||||
/*
|
||||
* Set IUPD and IACC times on file.
|
||||
*/
|
||||
utime()
|
||||
{
|
||||
register struct a {
|
||||
char *fname;
|
||||
time_t *tptr;
|
||||
} *uap;
|
||||
register struct inode *ip;
|
||||
time_t tv[2];
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
if (uap->tptr != NULL) {
|
||||
if (copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof(tv))) {
|
||||
u.u_error = EFAULT;
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
tv[0] = time;
|
||||
tv[1] = time;
|
||||
}
|
||||
#ifndef
|
||||
ip = namei(uchar, 0);
|
||||
#else
|
||||
ip = namei(uchar, 0, NULL);
|
||||
#endif
|
||||
if (ip == NULL)
|
||||
return;
|
||||
if (u.u_uid != ip->i_uid && u.u_uid != 0) {
|
||||
if (uap->tptr != NULL)
|
||||
u.u_error = EPERM;
|
||||
else
|
||||
access(ip, IWRITE);
|
||||
}
|
||||
if (!u.u_error) {
|
||||
#ifdef PNETDFS
|
||||
if ( ip->i_flag & IRMT ) {
|
||||
rutime( ip, &tv[0], &tv[1] );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
ip->i_flag |= IACC|IUPD|ICHG;
|
||||
iupdat(ip, &tv[0], &tv[1]);
|
||||
}
|
||||
iput(ip);
|
||||
}
|
||||
|
||||
ulimit()
|
||||
{
|
||||
register struct a {
|
||||
int cmd;
|
||||
long arg;
|
||||
} *uap;
|
||||
|
||||
register brk, stk;
|
||||
|
||||
uap = (struct a *)u.u_ap;
|
||||
switch(uap->cmd) {
|
||||
case 2:
|
||||
if (uap->arg > u.u_limit && !suser())
|
||||
return;
|
||||
u.u_limit = uap->arg;
|
||||
case 1:
|
||||
u.u_roff = u.u_limit;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
u.u_roff = ctob((long)(NUMLOGPAGE - u.u_ssize));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
#include "sys/plexus.h"
|
||||
#include "sys/param.h"
|
||||
#include "sys/systm.h"
|
||||
#include "sys/dir.h"
|
||||
#include "sys/user.h"
|
||||
#include "sys/proc.h"
|
||||
#include "sys/text.h"
|
||||
#include "sys/seg.h"
|
||||
|
||||
/*
|
||||
* Load the user hardware segmentation
|
||||
* registers from the software prototype.
|
||||
* The software registers must have
|
||||
* been setup prior by estabur.
|
||||
*/
|
||||
sureg()
|
||||
{
|
||||
int taddr, daddr;
|
||||
register i, c;
|
||||
struct text *tp;
|
||||
int maptemp[NUMLOGPAGE];
|
||||
|
||||
taddr = daddr = u.u_procp->p_addr;
|
||||
if ((tp=u.u_procp->p_textp) != NULL)
|
||||
taddr = tp->x_caddr;
|
||||
|
||||
for (i = 0; i < NUMLOGPAGE; i++) {
|
||||
c = u.u_uisa[i];
|
||||
if ((c & B_IP) == 0)
|
||||
if (c & B_EX)
|
||||
c += taddr;
|
||||
else
|
||||
c += daddr;
|
||||
maptemp[i] = c;
|
||||
}
|
||||
copymout(maptemp, P_MUI0, NUMLOGPAGE << 1);
|
||||
|
||||
for (i = 0; i < NUMLOGPAGE; i++) {
|
||||
c = u.u_uisa[i + NUMLOGPAGE];
|
||||
if ((c & B_IP) == 0)
|
||||
if (c & B_EX)
|
||||
c += taddr;
|
||||
else
|
||||
c += daddr;
|
||||
maptemp[i] = c;
|
||||
}
|
||||
copymout(maptemp, P_MUD0, NUMLOGPAGE << 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Set up software prototype segmentation
|
||||
* registers to implement the 3 pseudo
|
||||
* text,data,stack segment sizes passed
|
||||
* as arguments.
|
||||
* The argument sep specifies if the
|
||||
* text and data+stack segments are to
|
||||
* be separated.
|
||||
* The last argument determines whether the text
|
||||
* segment is read-write or read-only.
|
||||
*/
|
||||
estabur(nt, nd, ns, sep, xrw)
|
||||
unsigned nt, nd, ns;
|
||||
{
|
||||
register a, *ap, i;
|
||||
|
||||
if (checkur(nt, nd, ns, sep))
|
||||
return(-1);
|
||||
a = 0;
|
||||
ap = &u.u_uisa[0];
|
||||
for (i = 0; i < nt; i++)
|
||||
*ap++ = a++ | B_EX | (xrw == RO ? B_RO : 0);
|
||||
if (sep)
|
||||
for (i = 0; i < (NUMLOGPAGE - nt); i++)
|
||||
*ap++ = B_IP | B_RO;
|
||||
a = USIZE;
|
||||
for (i = 0; i < nd; i++)
|
||||
*ap++ = a++;
|
||||
for (i = 0; i < (NUMLOGPAGE - nd - ns - ((!sep) ? nt : 0)); i++)
|
||||
*ap++ = B_IP | B_RO;
|
||||
for (i = 0; i < ns; i++)
|
||||
*ap++ = a++;
|
||||
if (!sep) {
|
||||
ap = &u.u_uisa[0];
|
||||
for (i = 0; i < NUMLOGPAGE; i++)
|
||||
ap[i + NUMLOGPAGE] = ap[i];
|
||||
}
|
||||
sureg();
|
||||
return(0);
|
||||
}
|
||||
|
||||
checkur(nt, nd, ns, sep)
|
||||
{
|
||||
if(sep) {
|
||||
if(ctos(nt) > NUMLOGPAGE || ctos(nd)+ctos(ns) > NUMLOGPAGE)
|
||||
goto err;
|
||||
} else {
|
||||
if(ctos(nt)+ctos(nd)+ctos(ns) > NUMLOGPAGE)
|
||||
goto err;
|
||||
}
|
||||
if(nt+nd+ns+USIZE > maxmem)
|
||||
goto err;
|
||||
return(0);
|
||||
|
||||
err:
|
||||
u.u_error = ENOMEM;
|
||||
return(-1);
|
||||
}
|
||||
Loading…
Reference in New Issue