2.9BSD/usr/src/sys/sys/sys1.c
/*
* SCCS id @(#)sys1.c 2.1 (Berkeley) 9/4/83
*/
#include "param.h"
#include <sys/systm.h>
#include <sys/map.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/reg.h>
#include <sys/inode.h>
#include <sys/seg.h>
#include <sys/acct.h>
#include <sys/file.h>
#include <wait.h>
/*
* exec system call, with and without environments.
*/
struct execa {
char *fname;
char **argp;
char **envp;
};
exec()
{
((struct execa *)u.u_ap)->envp = NULL;
exece();
}
exece()
{
register nc;
register char *cp;
register struct buf *bp;
register struct execa *uap;
memaddr bno;
int na, ne, ucp, ap, c;
struct inode *ip;
#ifdef UCB_SCRIPT
#define SCRMAG '#!'
extern int schar();
int uid, gid, indir;
#endif
#ifndef UCB_SYMLINKS
if ((ip = namei(uchar, LOOKUP)) == NULL)
#else
if ((ip = namei(uchar, LOOKUP, 1)) == NULL)
#endif
return;
bno = 0;
bp = (struct buf *) NULL;
#ifdef UCB_SCRIPT
indir = 0;
uid = u.u_uid;
gid = u.u_gid;
if (ip->i_mode&ISUID)
uid = ip->i_uid;
if (ip->i_mode&ISGID)
gid = ip->i_gid;
again:
#endif
if (access(ip, IEXEC))
goto bad;
if ((ip->i_mode & IFMT) != IFREG ||
(ip->i_mode & (IEXEC | (IEXEC >> 3) | (IEXEC >> 6))) == 0) {
u.u_error = EACCES;
goto bad;
}
#ifdef UCB_SCRIPT
/* moved from getxfile() */
u.u_base = (caddr_t) &u.u_exdata;
u.u_count = sizeof u.u_exdata;
u.u_offset = 0;
u.u_segflg = 1;
readi(ip);
u.u_segflg = 0;
if (u.u_error)
goto bad;
/* check if script. one level only */
if (indir == 0
&& u.u_exdata.ux_mag == SCRMAG
&& u.u_count < sizeof u.u_exdata - sizeof u.u_exdata.ux_mag)
{
indir++;
cp = (char *) &u.u_exdata + sizeof u.u_exdata.ux_mag;
while (*cp == ' ' && cp < (char *)&u.u_exdata + sizeof u.u_exdata-1)
cp++;
u.u_dirp = cp;
while (cp < (char *) &u.u_exdata + sizeof u.u_exdata - 1
&& *cp != '\n')
cp++;
*cp = '\0';
iput(ip);
#ifndef UCB_SYMLINKS
if ((ip = namei(schar, LOOKUP)) == NULL)
#else
if ((ip = namei(schar, LOOKUP, 1)) == NULL)
#endif
return;
goto again;
}
/*other magic numbers are described in getxfile()*/
#endif
/*
* Collect arguments on "file" in swap space.
*/
na = 0;
ne = 0;
nc = 0;
uap = (struct execa *)u.u_ap;
#ifndef UCB_NKB
if ((bno = malloc(swapmap, (NCARGS + BSIZE - 1) / BSIZE)) == 0)
panic("Out of swap");
#else UCB_NKB
if ((bno = malloc(swapmap, ctod((int) btoc(NCARGS + BSIZE)))) == 0)
panic("Out of swap");
#endif UCB_NKB
if (uap->argp) for (;;) {
ap = NULL;
#ifdef UCB_SCRIPT
/* insert script path name as first arg */
if (indir && na == 1)
ap = uap->fname;
else
#endif
if (uap->argp) {
ap = fuword((caddr_t)uap->argp);
uap->argp++;
}
if (ap==NULL && uap->envp) {
uap->argp = NULL;
if ((ap = fuword((caddr_t)uap->envp)) == NULL)
break;
uap->envp++;
ne++;
}
if (ap==NULL)
break;
na++;
if (ap == -1)
u.u_error = EFAULT;
do {
if (nc >= NCARGS - 1)
u.u_error = E2BIG;
if ((c = fubyte((caddr_t) ap++)) < 0)
u.u_error = EFAULT;
if (u.u_error)
goto bad;
if ((nc & BMASK) == 0) {
if (bp) {
mapout(bp);
bdwrite(bp);
}
#ifndef UCB_NKB
bp = getblk(swapdev, swplo + bno + (nc >> BSHIFT));
#else
bp = getblk(swapdev,
dbtofsb(clrnd(swplo + bno)) + (nc >> BSHIFT));
#endif
cp = mapin(bp);
}
nc++;
*cp++ = c;
} while (c > 0);
}
if (bp) {
mapout(bp);
bdwrite(bp);
}
bp = 0;
nc = (nc + NBPW - 1) & ~(NBPW - 1);
#ifndef UCB_SCRIPT
if (getxfile(ip, (na * NBPW) + nc) || u.u_error)
goto bad;
#else
if (getxfile(ip, (na * NBPW) + nc, uid, gid) || u.u_error)
goto bad;
#endif
/*
* copy back arglist
*/
ucp = -nc - NBPW;
ap = ucp - na * NBPW - 3 * NBPW;
u.u_ar0[R6] = ap;
suword((caddr_t)ap, na - ne);
nc = 0;
for (;;) {
ap += NBPW;
if (na == ne) {
suword((caddr_t)ap, 0);
ap += NBPW;
}
if (--na < 0)
break;
suword((caddr_t)ap, ucp);
do {
if ((nc & BMASK) == 0) {
if (bp) {
mapout(bp);
bp->b_flags |= B_AGE;
brelse(bp);
}
#ifndef UCB_NKB
bp = bread(swapdev, swplo + bno + (nc>>BSHIFT));
#else
bp = bread(swapdev,
dbtofsb(clrnd(swplo + bno)) + (nc >> BSHIFT));
#endif
bp->b_flags &= ~B_DELWRI;
cp = mapin(bp);
#ifdef UCB_SCRIPT
/* stick in interpreter name for accounting */
if (indir && nc == 0)
bcopy(cp, (caddr_t)u.u_dbuf, DIRSIZ);
#endif
}
subyte((caddr_t)ucp++, (c = *cp++));
nc++;
} while(c & 0377);
}
suword((caddr_t) ap, 0);
suword((caddr_t) (-NBPW), 0);
if (bp) {
mapout(bp);
bp->b_flags |= B_AGE;
brelse(bp);
bp = 0;
}
setregs();
bad:
if (bp) {
mapout(bp);
bp->b_flags |= B_AGE;
brelse(bp);
}
if (bno)
#ifndef UCB_NKB
mfree(swapmap, (NCARGS + BSIZE - 1) / BSIZE, bno);
#else
mfree(swapmap, ctod((int) btoc(NCARGS + BSIZE)), bno);
#endif
iput(ip);
}
/*
* Read in and set up memory for executed file.
* Zero return is normal;
* non-zero means only the text is being replaced
*/
#ifdef UCB_SCRIPT
getxfile(ip, nargc, uid, gid)
int nargc, uid, gid;
#else
getxfile(ip, nargc)
#endif
register struct inode *ip;
{
register unsigned ds;
register sep;
register unsigned ts, ss;
register i, overlay;
#ifdef MENLO_OVLY
register ovflag,ovmax;
struct u_ovd sovdata;
unsigned ovhead[1 + NOVL];
#endif
long lsize;
#ifndef UCB_SCRIPT
/*
* read in first few bytes
* of file for segment
* sizes:
* ux_mag = A_MAGIC1/A_MAGIC2/A_MAGIC3/A_MAGIC4
* A_MAGIC1 is plain executable
* A_MAGIC2 is RO text
* A_MAGIC3 is separated ID
* A_MAGIC4 is overlaid text
*/
#ifdef MENLO_OVLY
/*
* ux_mag = A_MAGIC1/A_MAGIC2/A_MAGIC3/A_MAGIC4/A_MAGIC5/A_MAGIC6
* A_MAGIC5 is nonseparate auto-overlay
* A_MAGIC6 is separate auto overlay
*/
#endif
u.u_base = (caddr_t) &u.u_exdata;
u.u_count = sizeof(u.u_exdata);
u.u_offset = 0;
u.u_segflg = 1;
readi(ip);
u.u_segflg = 0;
if (u.u_error)
goto bad;
if (u.u_count != 0) {
u.u_error = ENOEXEC;
goto bad;
}
#endif
sep = 0;
overlay = 0;
#ifdef MENLO_OVLY
ovflag = 0;
#endif
if (u.u_exdata.ux_mag == A_MAGIC1) {
lsize = (long) u.u_exdata.ux_dsize + u.u_exdata.ux_tsize;
u.u_exdata.ux_dsize = lsize;
if (lsize != u.u_exdata.ux_dsize) { /* check overflow */
u.u_error = ENOMEM;
goto bad;
}
u.u_exdata.ux_tsize = 0;
} else if (u.u_exdata.ux_mag == A_MAGIC3)
sep++;
else if (u.u_exdata.ux_mag == A_MAGIC4)
overlay++;
#ifdef MENLO_OVLY
else if (u.u_exdata.ux_mag == A_MAGIC5)
ovflag++;
else if (u.u_exdata.ux_mag == A_MAGIC6) {
sep++;
ovflag++;
}
#endif
else if (u.u_exdata.ux_mag != A_MAGIC2) {
u.u_error = ENOEXEC;
goto bad;
}
if (u.u_exdata.ux_tsize!=0 && (ip->i_flag&ITEXT)==0 && ip->i_count!=1) {
u.u_error = ETXTBSY;
goto bad;
}
/*
* find text and data sizes
* try them out for possible
* overflow of max sizes
*/
ts = btoc(u.u_exdata.ux_tsize);
lsize = (long) u.u_exdata.ux_dsize + u.u_exdata.ux_bsize;
if (lsize != (unsigned) lsize) {
u.u_error = ENOMEM;
goto bad;
}
ds = btoc(lsize);
ss = SSIZE + btoc(nargc);
#ifdef MENLO_OVLY
/*
* if auto overlay get second header
*/
sovdata = u.u_ovdata;
u.u_ovdata.uo_ovbase = 0;
u.u_ovdata.uo_curov = 0;
if (ovflag) {
u.u_base = (caddr_t) ovhead;
u.u_count = sizeof(ovhead);
u.u_offset = sizeof(u.u_exdata);
u.u_segflg = 1;
readi(ip);
u.u_segflg = 0;
if (u.u_count != 0)
u.u_error = ENOEXEC;
if (u.u_error) {
u.u_ovdata = sovdata;
goto bad;
}
/* set beginning of overlay segment */
u.u_ovdata.uo_ovbase = ctos(ts);
/* 0th entry is max size of the overlays */
ovmax = btoc(ovhead[0]);
/* set max number of segm. registers to be used */
u.u_ovdata.uo_nseg = ctos(ovmax);
/* set base of data space */
u.u_ovdata.uo_dbase = stoc(u.u_ovdata.uo_ovbase + u.u_ovdata.uo_nseg);
/*
* Set up a table of offsets to each of the
* overlay segements. The ith overlay runs
* from ov_offst[i-1] to ov_offst[i].
*/
u.u_ovdata.uo_ov_offst[0] = ts;
for (i = 1; i < 1 + NOVL; i++) {
register t;
/* check if any overlay is larger than ovmax */
if ((t=btoc(ovhead[i])) > ovmax) {
u.u_error = ENOEXEC;
u.u_ovdata = sovdata;
goto bad;
}
u.u_ovdata.uo_ov_offst[i] =
t + u.u_ovdata.uo_ov_offst[i - 1];
}
}
#endif
if (overlay) {
if (u.u_sep == 0 && ctos(ts) != ctos(u.u_tsize) || nargc) {
u.u_error = ENOMEM;
goto bad;
}
ds = u.u_dsize;
ss = u.u_ssize;
sep = u.u_sep;
xfree();
xalloc(ip);
u.u_ar0[PC] = u.u_exdata.ux_entloc & ~01;
} else {
if (estabur(ts, ds, ss, sep, RO)) {
#ifdef MENLO_OVLY
u.u_ovdata = sovdata;
#endif
goto bad;
}
/*
* allocate and clear core
* at this point, committed
* to the new image
*/
u.u_prof.pr_scale = 0;
#ifdef VIRUS_VFORK
if (u.u_procp->p_flag & SVFORK)
endvfork();
else
xfree();
expand(ds, S_DATA);
clear(u.u_procp->p_daddr, ds);
expand(ss,S_STACK);
clear(u.u_procp->p_saddr, ss);
#else
xfree();
i = USIZE + ds + ss;
expand(i);
clear(u.u_procp->p_addr + USIZE, i - USIZE);
#endif
xalloc(ip);
/*
* read in data segment
*/
estabur((unsigned)0, ds, (unsigned)0, 0, RO);
u.u_base = 0;
#ifndef MENLO_OVLY
u.u_offset = sizeof(u.u_exdata) + u.u_exdata.ux_tsize;
#else
u.u_offset = sizeof(u.u_exdata);
if (ovflag) {
u.u_offset += sizeof(ovhead);
u.u_offset += (((long)u.u_ovdata.uo_ov_offst[NOVL]) << 6);
}
else
u.u_offset += u.u_exdata.ux_tsize;
#endif
u.u_count = u.u_exdata.ux_dsize;
readi(ip);
/*
* set SUID/SGID protections, if no tracing
*/
if ((u.u_procp->p_flag & STRC) == 0) {
#ifndef UCB_SCRIPT
if (ip->i_mode & ISUID)
if (u.u_uid != 0) {
u.u_uid = ip->i_uid;
u.u_procp->p_uid = ip->i_uid;
}
if (ip->i_mode&ISGID)
u.u_gid = ip->i_gid;
#else
u.u_uid = uid;
u.u_procp->p_uid = uid;
u.u_gid = gid;
#endif
} else
psignal(u.u_procp, SIGTRAP);
}
u.u_tsize = ts;
u.u_dsize = ds;
u.u_ssize = ss;
u.u_sep = sep;
estabur(ts, ds, ss, sep, RO);
bad:
return(overlay);
}
/*
* Clear registers on exec
*/
setregs()
{
#ifdef MENLO_JCL
register int (**rp)();
long sigmask;
#else
register int *rp;
#endif
register char *cp;
register i;
#ifndef MENLO_JCL
for(rp = &u.u_signal[0]; rp < &u.u_signal[NSIG]; rp++)
if ((*rp & 1) == 0)
*rp = 0;
#else
u.u_procp->p_flag &= ~SNUSIG;
for(rp = &u.u_signal[1], sigmask = 1L; rp < &u.u_signal[NSIG];
sigmask <<= 1, rp++) {
switch (*rp) {
case SIG_HOLD:
u.u_procp->p_flag |= SNUSIG;
continue;
case SIG_IGN:
case SIG_DFL:
continue;
default:
/*
* Normal or deferring catch; revert to default.
*/
(void) _spl6();
*rp = SIG_DFL;
if ((int)SIG_DFL & 1)
u.u_procp->p_siga0 |= sigmask;
else
u.u_procp->p_siga0 &= ~sigmask;
if ((int)SIG_DFL & 2)
u.u_procp->p_siga1 |= sigmask;
else
u.u_procp->p_siga1 &= ~sigmask;
(void) _spl0();
continue;
}
}
#endif
for(cp = ®loc[0]; cp < ®loc[6];)
u.u_ar0[*cp++] = 0;
u.u_ar0[PC] = u.u_exdata.ux_entloc & ~01;
#ifndef NONFP
for(rp = (int *)&u.u_fps; rp < (int *)&u.u_fps.u_fpregs[6];)
*rp++ = 0;
#endif
for(i=0; i<NOFILE; i++) {
if (u.u_pofile[i]&EXCLOSE) {
#ifndef UCB_NET
closef(u.u_ofile[i]);
#else
closef(u.u_ofile[i],1);
#endif
u.u_ofile[i] = NULL;
u.u_pofile[i] &= ~EXCLOSE;
}
}
#ifdef ACCT
u.u_acflag &= ~AFORK;
#endif
/*
* Remember file name.
*/
bcopy((caddr_t)u.u_dbuf, (caddr_t)u.u_comm, DIRSIZ);
}
/*
* exit system call:
* pass back caller's arg
*/
rexit()
{
register struct a {
int rval;
} *uap;
uap = (struct a *)u.u_ap;
exit((uap->rval & 0377) << 8);
}
/*
* Release resources.
* Save u. area for parent to look at.
* Enter zombie state.
* Wake up parent and init processes,
* and dispose of children.
*/
exit(rv)
{
register int i;
register struct proc *p, *q;
register struct file *f;
p = u.u_procp;
p->p_flag &= ~(STRC|SULOCK);
p->p_clktim = 0;
#ifdef CGL_RTP
/*
* if this a "real time" process that is dying
* remove the rtpp flag.
*/
if (rtpp != NULL && rtpp == p)
rtpp = NULL;
#endif
#ifdef MENLO_JCL
(void) _spl6();
if ((int)SIG_IGN & 1)
p->p_siga0 = ~0L;
else
p->p_siga0 = 0L;
if ((int)SIG_IGN & 2)
p->p_siga1 = ~0L;
else
p->p_siga1 = 0L;
(void) _spl0();
#endif
for(i=0; i<NSIG; i++)
u.u_signal[i] = SIG_IGN;
for(i=0; i<NOFILE; i++) {
f = u.u_ofile[i];
u.u_ofile[i] = NULL;
#ifndef UCB_NET
closef(f);
#else
closef(f,1);
#endif
}
plock(u.u_cdir);
iput(u.u_cdir);
if (u.u_rdir) {
plock(u.u_rdir);
iput(u.u_rdir);
}
#ifdef ACCT
acct();
#endif ACCT
#ifdef VIRUS_VFORK
if (p->p_flag & SVFORK) {
endvfork();
} else {
xfree();
mfree(coremap, p->p_dsize, p->p_daddr);
mfree(coremap, p->p_ssize, p->p_saddr);
}
mfree(coremap, USIZE, p->p_addr);
#else VIRUS_VFORK
xfree();
mfree(coremap, p->p_size, p->p_addr);
#endif VIRUS_VFORK
p->p_stat = SZOMB;
if (p->p_pid == 1) {
/*
* If /etc/init is not found by the icode,
* the stack size will still be zero when it exits.
* Don't panic: we're unlikely to find init after a reboot,
* either.
*/
if (u.u_ssize == 0) {
printf("Can't exec /etc/init\n");
for (;;)
idle();
}
else
panic("init died");
}
p->p_un.xp_xstat = rv;
p->p_un.xp_utime = u.u_cutime + u.u_utime;
p->p_un.xp_stime = u.u_cstime + u.u_stime;
#ifdef UCB_LOGIN
p->p_un.xp_login = u.u_login;
#endif
#ifdef MENLO_JCL
for(q = &proc[0]; q <= maxproc; q++)
if (q->p_pptr == p) {
q->p_pptr = &proc[1];
q->p_ppid = 1;
wakeup((caddr_t)&proc[1]);
/*
* Traced processes are killed
* since their existence means someone is screwing up.
* Stopped processes are sent a hangup and a continue.
* This is designed to be ``safe'' for setuid
* processes since they must be willing to tolerate
* hangups anyways.
*/
if (q->p_flag&STRC) {
q->p_flag &= ~STRC;
psignal(q, SIGKILL);
} else if (q->p_stat == SSTOP) {
psignal(q, SIGHUP);
psignal(q, SIGCONT);
}
/*
* Protect this process from future
* tty signals, clear TSTP/TTIN/TTOU if pending,
* and set SDETACH bit on procs.
*/
spgrp(q, -1);
}
wakeup((caddr_t)p->p_pptr);
psignal(p->p_pptr, SIGCHLD);
#else
for(q = &proc[0]; q <= maxproc; q++)
if (q->p_ppid == p->p_pid) {
wakeup((caddr_t)&proc[1]);
q->p_ppid = 1;
if (q->p_stat==SSTOP)
setrun(q);
}
for(q = &proc[0]; q <= maxproc; q++)
if (p->p_ppid == q->p_pid) {
wakeup((caddr_t)q);
swtch();
/* no return */
}
#endif
swtch();
}
/*
* Wait system call.
* Search for a terminated (zombie) child,
* finally lay it to rest, and collect its status.
* Look also for stopped (traced) children,
* and pass back status from them.
*/
wait()
{
register f;
register struct proc *p;
#ifdef MENLO_JCL
register options;
options = (u.u_ar0[RPS] & PS_ALLCC) == PS_ALLCC ? u.u_ar0[R0] : 0;
#endif
f = 0;
loop:
for(p = &proc[0]; p <= maxproc; p++)
#ifdef MENLO_JCL
if (p->p_pptr == u.u_procp)
#else
if (p->p_ppid == u.u_procp->p_pid)
#endif
{
f++;
if (p->p_stat == SZOMB) {
u.u_r.r_val1 = p->p_pid;
u.u_r.r_val2 = p->p_un.xp_xstat;
#ifdef MENLO_JCL
p->p_un.xp_xstat = 0;
p->p_pptr = 0;
p->p_siga0 = 0L;
p->p_siga1 = 0L;
p->p_cursig = 0;
#endif
u.u_cutime += p->p_un.xp_utime;
u.u_cstime += p->p_un.xp_stime;
p->p_pid = 0;
p->p_ppid = 0;
p->p_pgrp = 0;
p->p_sig = 0;
p->p_flag = 0;
p->p_wchan = 0;
p->p_stat = NULL;
if (p == maxproc)
while (maxproc->p_stat == NULL)
maxproc--;
return;
}
if (p->p_stat == SSTOP && (p->p_flag & SWTED) == 0 &&
(p->p_flag & STRC
#ifdef MENLO_JCL
|| options & WUNTRACED
#endif
)){
p->p_flag |= SWTED;
u.u_r.r_val1 = p->p_pid;
#ifdef MENLO_JCL
u.u_r.r_val2 = (p->p_cursig << 8) | 0177;
#else
u.u_r.r_val2 = (fsig(p) << 8) | 0177;
#endif
return;
}
}
if (f) {
#ifdef MENLO_JCL
if (options & WNOHANG) {
u.u_r.r_val1 = 0;
return;
} else {
if ((u.u_procp->p_flag & SNUSIG) && save(u.u_qsav)) {
u.u_eosys = RESTARTSYS;
return;
}
sleep((caddr_t)u.u_procp, PWAIT);
goto loop;
}
#else
sleep((caddr_t) u.u_procp, PWAIT);
goto loop;
#endif
}
u.u_error = ECHILD;
}
/*
* fork system call.
*/
#ifdef VIRUS_VFORK
fork()
{
fork1(0);
}
/*
* vfork system call
*/
vfork()
{
fork1(1);
}
fork1(isvfork)
#else VIRUS_VFORK
fork()
#endif
{
#ifdef UCB_PGRP
register struct proc *p1;
struct proc *p2;
register a, pg;
#else
register struct proc *p1, *p2;
register a;
#endif
/*
* Make sure there's enough swap space for max
* core image, thus reducing chances of running out
*/
if ((a = malloc(swapmap, ctod(maxmem))) == 0) {
u.u_error = ENOMEM;
goto out;
}
mfree(swapmap, ctod(maxmem), a);
a = 0;
#ifdef UCB_PGRP
pg = u.u_procp->p_pgrp; /* process group number */
#endif
p2 = NULL;
for(p1 = proc; p1 < procNPROC; p1++) {
if (p1->p_stat==NULL && p2==NULL)
p2 = p1;
else {
/*
* Exempt low positive uids (0-15) for users like uucp
* and network, which shouldn't lose limits.
*/
#ifdef UCB_PGRP
if (p1->p_pgrp==pg && (unsigned) u.u_uid>=16
&& p1->p_stat!=NULL)
a++;
#else
if ((p1->p_uid==u.u_uid && p1->p_stat!=NULL)
&& ((unsigned) u.u_uid >= 16))
a++;
#endif
}
}
/*
* Disallow if
* No processes at all;
* not su and too many procs owned (or in pgrp, if UCB_PGRP set);
* or not su and would take last slot.
*/
if (p2 == NULL)
tablefull("proc");
if (p2 == NULL || (u.u_uid != 0 && (p2 == procNPROC-1 || a > MAXUPRC))){
u.u_error = EAGAIN;
goto out;
}
p1 = u.u_procp;
#ifdef VIRUS_VFORK
if (newproc(isvfork))
#else
if (newproc())
#endif
{
u.u_r.r_val1 = p1->p_pid;
u.u_start = time;
u.u_cstime = 0;
u.u_stime = 0;
u.u_cutime = 0;
u.u_utime = 0;
#ifdef UCB_LOGIN
u.u_login = 0;
#endif
#ifdef ACCT
u.u_acflag = AFORK;
#endif
return;
}
u.u_r.r_val1 = p2->p_pid;
out:
u.u_ar0[R7] += NBPW;
}
/*
* break system call.
* -- bad planning: "break" is a dirty word in C.
*/
sbreak()
{
struct a {
char *nsiz;
};
register a, n, d;
int i;
/*
* set n to new data size
* set d to new-old
* set n to new total size
*/
n = btoc((int) ((struct a *) u.u_ap)->nsiz);
if (!u.u_sep)
#ifdef MENLO_OVLY
if (u.u_ovdata.uo_ovbase)
n -= u.u_ovdata.uo_dbase;
else
n -= ctos(u.u_tsize) * stoc(1);
#else
n -= ctos(u.u_tsize) * stoc(1);
#endif
if (n < 0)
n = 0;
#ifdef VIRUS_VFORK
d = n - u.u_dsize;
if (estabur(u.u_tsize, n, u.u_ssize, u.u_sep, RO))
return;
expand(n,S_DATA);
if (d > 0)
clear(u.u_procp->p_daddr + u.u_dsize, d);
u.u_dsize = n;
#else VIRUS_VFORK
d = n - u.u_dsize;
n += USIZE+u.u_ssize;
if (estabur(u.u_tsize, u.u_dsize+d, u.u_ssize, u.u_sep, RO))
return;
u.u_dsize += d;
if (d > 0)
goto bigger;
a = u.u_procp->p_addr + n - u.u_ssize;
copy(a-d, a, u.u_ssize); /* d is negative */
expand(n);
return;
bigger:
expand(n);
a = u.u_procp->p_addr + n - u.u_ssize - d;
n = u.u_ssize;
while (n >= d) {
n -= d;
copy(a+n, a+n+d, d);
}
copy(a, a+d, n);
clear(a, d);
#endif VIRUS_VFORK
}