172 lines
3.1 KiB
C
172 lines
3.1 KiB
C
/******************************************************************************
|
|
*******************************************************************************
|
|
|
|
W E G A - Quelle
|
|
|
|
KERN 3.2 Modul: break.c
|
|
|
|
|
|
Bearbeiter: O. Lehmann
|
|
Datum: 30.05.08
|
|
Version: 1.0
|
|
|
|
*******************************************************************************
|
|
******************************************************************************/
|
|
|
|
char breakwstr[] = "@[$]break.c Rev : 4.1 08/27/83 11:54:02";
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/sysparm.h>
|
|
#include <sys/sysinfo.h>
|
|
#include <sys/systm.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>
|
|
|
|
sbreak()
|
|
{
|
|
register int l,r;
|
|
register unsigned i;
|
|
struct a {
|
|
saddr_t segaddr;
|
|
} *uap;
|
|
|
|
uap = (struct a *)u.u_ap;
|
|
r = lbtoc((long)uap->segaddr.right);
|
|
if(u.u_segmented) {
|
|
if(!uap->segaddr.l) {
|
|
for(i=0;i<u.u_nsegs;i++) {
|
|
if (((int)u.u_segno[i] & 0x80) == 0){
|
|
u.u_r.r_val1 = u.u_segno[i]<<8;
|
|
u.u_r.r_val2 = (u.u_segmts[i].sg_limit+1)<<8;
|
|
}
|
|
}
|
|
return;
|
|
} else {
|
|
l = uap->segaddr.left >> 8;
|
|
for(i=0;i<u.u_nsegs;i++) {
|
|
if(u.u_segno[i] == l)
|
|
break;
|
|
}
|
|
if(i==u.u_nsegs) {
|
|
u.u_error = ENOMEM;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
break_handler(l,r,i);
|
|
}
|
|
|
|
ssgbrk()
|
|
{
|
|
register int a,j,b,i;
|
|
struct a {
|
|
int par1;
|
|
unsigned par2;
|
|
} *uap;
|
|
|
|
uap = (struct a *)u.u_ap;
|
|
j = uap->par1;
|
|
|
|
for(i=0;i<u.u_nsegs;i++) {
|
|
if(u.u_segno[i] == j)
|
|
break;
|
|
}
|
|
if(i==u.u_nsegs) {
|
|
u.u_error = ENOMEM;
|
|
return;
|
|
}
|
|
if(!u.u_segmts[i].sg_limit && u.u_segmts[i].sg_attr&0x14)
|
|
b=0;
|
|
else
|
|
b=(u.u_segmts[i].sg_limit&0xff)+1;
|
|
a=lbtoc((long)uap->par2);
|
|
if(a) {
|
|
break_handler(j,b+a,i);
|
|
if(u.u_error)
|
|
return;
|
|
}
|
|
u.u_r.r_val1 = uap->par1<<8;
|
|
u.u_r.r_val2 = b<<8;
|
|
}
|
|
|
|
break_handler(l,r,i)
|
|
register int l;
|
|
register unsigned r;
|
|
register int i;
|
|
{
|
|
register int foo1,foo2,b;
|
|
int size;
|
|
struct proc *p;
|
|
|
|
p = u.u_procp;
|
|
if(r > 0x100) {
|
|
u.u_error = ENOMEM;
|
|
return;
|
|
}
|
|
if(u.u_segmented) {
|
|
if(!u.u_segmts[i].sg_limit && u.u_segmts[i].sg_attr&0x14)
|
|
b=r;
|
|
else
|
|
b=r-(u.u_segmts[i].sg_limit+1);
|
|
if((u.u_tsize + USIZE + u.u_dsize + u.u_ssize + b) > umemory) {
|
|
u.u_error = ENOMEM;
|
|
return;
|
|
}
|
|
size = p->p_addr + p->p_size;
|
|
if(!u.u_segmts[i].sg_limit && u.u_segmts[i].sg_attr&0x14)
|
|
size -= u.u_segmts[i].sg_base;
|
|
else
|
|
size -= u.u_segmts[i].sg_base+u.u_segmts[i].sg_limit+1;
|
|
sestabur(r,u.u_segno[i],i,0);
|
|
if(u.u_error)
|
|
return;
|
|
|
|
u.u_dsize += b;
|
|
shufflecore(p->p_size+b,p->p_size,size);
|
|
} else {
|
|
b = r - u.u_dsize;
|
|
if(estabur(u.u_tsize,r,u.u_ssize,1))
|
|
return;
|
|
u.u_dsize = r;
|
|
shufflecore(p->p_size+b,p->p_size,u.u_ssize);
|
|
}
|
|
}
|
|
|
|
shufflecore(a,b,c)
|
|
register a,b,c;
|
|
{
|
|
register d,e;
|
|
|
|
e=a-b;
|
|
if(e>0) {
|
|
expand(a);
|
|
d=u.u_procp->p_addr+a;
|
|
while(c--) {
|
|
d--;
|
|
copyseg(d-e,d);
|
|
}
|
|
while(e--){
|
|
d--;
|
|
clearseg(d);
|
|
}
|
|
} else {
|
|
if(e<0) {
|
|
while(c--) {
|
|
copyseg((u.u_procp->p_addr+b-1)-c,(u.u_procp->p_addr+a-1)-c);
|
|
}
|
|
expand(a);
|
|
}
|
|
}
|
|
|
|
if(!u.u_segmented)
|
|
return;
|
|
invsdrs();
|
|
segureg();
|
|
}
|