157 lines
3.1 KiB
C
157 lines
3.1 KiB
C
#
|
|
/*
|
|
*/
|
|
|
|
#include "../param.h"
|
|
#include "../systm.h"
|
|
#include "../user.h"
|
|
#include "../proc.h"
|
|
#include "../text.h"
|
|
#include "../inode.h"
|
|
|
|
/*
|
|
* Swap out process p.
|
|
* The ff flag causes its core to be freed--
|
|
* it may be off when called to create an image for a
|
|
* child process in newproc.
|
|
* Os is the old size of the data area of the process,
|
|
* and is supplied during core expansion swaps.
|
|
*
|
|
* panic: out of swap space
|
|
* panic: swap error -- IO error
|
|
*/
|
|
xswap(p, ff, os)
|
|
int *p;
|
|
{
|
|
register *rp, a;
|
|
|
|
rp = p;
|
|
if(os == 0)
|
|
os = rp->p_size;
|
|
a = malloc(swapmap, (rp->p_size+7)/8);
|
|
if(a == NULL)
|
|
panic("out of swap space");
|
|
xccdec(rp->p_textp);
|
|
rp->p_flag =| SLOCK;
|
|
if(swap(a, rp->p_addr, os, 0))
|
|
panic("swap error");
|
|
if(ff)
|
|
mfree(coremap, os, rp->p_addr);
|
|
rp->p_addr = a;
|
|
rp->p_flag =& ~(SLOAD|SLOCK);
|
|
rp->p_time = 0;
|
|
if(runout) {
|
|
runout = 0;
|
|
wakeup(&runout);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* relinquish use of the shared text segment
|
|
* of a process.
|
|
*/
|
|
xfree()
|
|
{
|
|
register *xp, *ip;
|
|
|
|
if((xp=u.u_procp->p_textp) != NULL) {
|
|
u.u_procp->p_textp = NULL;
|
|
xccdec(xp);
|
|
if(--xp->x_count == 0) {
|
|
ip = xp->x_iptr;
|
|
if((ip->i_mode&ISVTX) == 0) {
|
|
xp->x_iptr = NULL;
|
|
mfree(swapmap, (xp->x_size+7)/8, xp->x_daddr);
|
|
ip->i_flag =& ~ITEXT;
|
|
iput(ip);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Attach to a shared text segment.
|
|
* If there is no shared text, just return.
|
|
* If there is, hook up to it:
|
|
* if it is not currently being used, it has to be read
|
|
* in from the inode (ip) and established in the swap space.
|
|
* If it is being used, but is not currently in core,
|
|
* a swap has to be done to get it back.
|
|
* The full coroutine glory has to be invoked--
|
|
* see slp.c-- because if the calling process
|
|
* is misplaced in core the text image might not fit.
|
|
* Quite possibly the code after "out:" could check to
|
|
* see if the text does fit and simply swap it in.
|
|
*
|
|
* panic: out of swap space
|
|
*/
|
|
xalloc(ip)
|
|
int *ip;
|
|
{
|
|
register struct text *xp;
|
|
register *rp, ts;
|
|
|
|
if(u.u_arg[1] == 0)
|
|
return;
|
|
rp = NULL;
|
|
for(xp = &text[0]; xp < &text[NTEXT]; xp++)
|
|
if(xp->x_iptr == NULL) {
|
|
if(rp == NULL)
|
|
rp = xp;
|
|
} else
|
|
if(xp->x_iptr == ip) {
|
|
xp->x_count++;
|
|
u.u_procp->p_textp = xp;
|
|
goto out;
|
|
}
|
|
if((xp=rp) == NULL)
|
|
panic("out of text");
|
|
xp->x_count = 1;
|
|
xp->x_ccount = 0;
|
|
xp->x_iptr = ip;
|
|
ts = ((u.u_arg[1]+63)>>6) & 01777;
|
|
xp->x_size = ts;
|
|
if((xp->x_daddr = malloc(swapmap, (ts+7)/8)) == NULL)
|
|
panic("out of swap space");
|
|
expand(USIZE+ts);
|
|
estabur(0, ts, 0, 0);
|
|
u.u_count = u.u_arg[1];
|
|
u.u_offset[1] = 020;
|
|
u.u_base = 0;
|
|
readi(ip);
|
|
rp = u.u_procp;
|
|
rp->p_flag =| SLOCK;
|
|
swap(xp->x_daddr, rp->p_addr+USIZE, ts, 0);
|
|
rp->p_flag =& ~SLOCK;
|
|
rp->p_textp = xp;
|
|
rp = ip;
|
|
rp->i_flag =| ITEXT;
|
|
rp->i_count++;
|
|
expand(USIZE);
|
|
|
|
out:
|
|
if(xp->x_ccount == 0) {
|
|
savu(u.u_rsav);
|
|
savu(u.u_ssav);
|
|
xswap(u.u_procp, 1, 0);
|
|
u.u_procp->p_flag =| SSWAP;
|
|
swtch();
|
|
/* no return */
|
|
}
|
|
xp->x_ccount++;
|
|
}
|
|
|
|
/*
|
|
* Decrement the in-core usage count of a shared text segment.
|
|
* When it drops to zero, free the core space.
|
|
*/
|
|
xccdec(xp)
|
|
int *xp;
|
|
{
|
|
register *rp;
|
|
|
|
if((rp=xp)!=NULL && rp->x_ccount!=0)
|
|
if(--rp->x_ccount == 0)
|
|
mfree(coremap, rp->x_size, rp->x_caddr);
|
|
}
|