kernel: apply uintptr for ulong when a pointer is stored
this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
This commit is contained in:
cinap_lenrek
parent
b99ecee6cd
commit
6c2e983d32
34 changed files with 656 additions and 552 deletions
|
|
@ -274,7 +274,7 @@ upafree(ulong, int)
|
|||
}
|
||||
|
||||
void
|
||||
checkmmu(ulong, ulong)
|
||||
checkmmu(uintptr, uintptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -728,7 +728,7 @@ syscall(Ureg *aur)
|
|||
|
||||
up->s = *((Sargs*)(sp+2*BY2WD));
|
||||
up->psstate = sysctab[scallnr];
|
||||
ret = systab[scallnr](up->s.args);
|
||||
ret = systab[scallnr]((va_list)up->s.args);
|
||||
poperror();
|
||||
}else{
|
||||
/* failure: save the error buffer for errstr */
|
||||
|
|
@ -794,8 +794,8 @@ kprocchild(Proc *p, void (*func)(void*), void *arg)
|
|||
p->kparg = arg;
|
||||
}
|
||||
|
||||
long
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
Ureg *ur;
|
||||
ulong *sp;
|
||||
|
|
@ -809,7 +809,7 @@ execregs(ulong entry, ulong ssize, ulong nargs)
|
|||
return USTKTOP-BY2WD; /* address of user-level clock */
|
||||
}
|
||||
|
||||
ulong
|
||||
uintptr
|
||||
userpc(void)
|
||||
{
|
||||
Ureg *ur;
|
||||
|
|
@ -842,7 +842,7 @@ setkernur(Ureg *xp, Proc *p)
|
|||
xp->r26 = (ulong)sched;
|
||||
}
|
||||
|
||||
ulong
|
||||
uintptr
|
||||
dbgpc(Proc *p)
|
||||
{
|
||||
Ureg *ur;
|
||||
|
|
|
|||
|
|
@ -523,7 +523,7 @@ peekmmu(ulong va)
|
|||
}
|
||||
|
||||
void
|
||||
checkmmu(ulong, ulong)
|
||||
checkmmu(uintptr, uintptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -557,7 +557,7 @@ syscall(Ureg* ureg)
|
|||
up->s = *((Sargs*)(sp+BY2WD));
|
||||
up->psstate = sysctab[scallnr];
|
||||
|
||||
ret = systab[scallnr](up->s.args);
|
||||
ret = systab[scallnr]((va_list)up->s.args);
|
||||
poperror();
|
||||
}else{
|
||||
/* failure: save the error buffer for errstr */
|
||||
|
|
@ -757,7 +757,7 @@ setkernur(Ureg *ureg, Proc *p)
|
|||
/*
|
||||
* return the userpc the last exception happened at
|
||||
*/
|
||||
ulong
|
||||
uintptr
|
||||
userpc(void)
|
||||
{
|
||||
Ureg *ureg;
|
||||
|
|
@ -829,8 +829,8 @@ forkchild(Proc *p, Ureg *ureg)
|
|||
/*
|
||||
* setup stack, initial PC, and any arch dependent regs for an execing user proc.
|
||||
*/
|
||||
long
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
ulong *sp;
|
||||
Ureg *ureg;
|
||||
|
|
@ -901,7 +901,7 @@ dumpstack(void)
|
|||
/*
|
||||
* pc output by ps
|
||||
*/
|
||||
ulong
|
||||
uintptr
|
||||
dbgpc(Proc *p)
|
||||
{
|
||||
Ureg *ureg;
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ boot(int argc, char *argv[])
|
|||
|
||||
print("argc=%d\n", argc);
|
||||
for(i = 0; i < argc; i++)
|
||||
print("%lux %s ", (ulong)argv[i], argv[i]);
|
||||
print("%p %s ", argv[i], argv[i]);
|
||||
print("\n");
|
||||
}
|
||||
USED(argc);
|
||||
|
|
|
|||
|
|
@ -224,7 +224,7 @@ syscall(Ureg* ureg)
|
|||
|
||||
/* iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
|
||||
|
||||
ret = systab[scallnr](up->s.args);
|
||||
ret = systab[scallnr]((va_list)up->s.args);
|
||||
poperror();
|
||||
}else{
|
||||
/* failure: save the error buffer for errstr */
|
||||
|
|
@ -275,8 +275,8 @@ syscall(Ureg* ureg)
|
|||
kexit(ureg);
|
||||
}
|
||||
|
||||
long
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
ulong *sp;
|
||||
Ureg *ureg;
|
||||
|
|
|
|||
|
|
@ -235,7 +235,7 @@ putmmu(ulong va, ulong pa, Page *pg)
|
|||
}
|
||||
|
||||
void
|
||||
checkmmu(ulong, ulong)
|
||||
checkmmu(uintptr, uintptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -533,8 +533,8 @@ evenaddr(ulong addr)
|
|||
}
|
||||
}
|
||||
|
||||
long
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
ulong *sp;
|
||||
Ureg *ureg;
|
||||
|
|
@ -566,7 +566,7 @@ forkchild(Proc *p, Ureg *ur)
|
|||
p->insyscall = 0;
|
||||
}
|
||||
|
||||
ulong
|
||||
uintptr
|
||||
userpc(void)
|
||||
{
|
||||
Ureg *ureg;
|
||||
|
|
@ -600,7 +600,7 @@ setkernur(Ureg* ureg, Proc* p)
|
|||
ureg->sp = p->sched.sp+4;
|
||||
}
|
||||
|
||||
ulong
|
||||
uintptr
|
||||
dbgpc(Proc *p)
|
||||
{
|
||||
Ureg *ureg;
|
||||
|
|
|
|||
|
|
@ -222,7 +222,7 @@ syscall(Ureg* ureg)
|
|||
|
||||
/* iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
|
||||
|
||||
ret = systab[scallnr](up->s.args);
|
||||
ret = systab[scallnr]((va_list)up->s.args);
|
||||
poperror();
|
||||
}else{
|
||||
/* failure: save the error buffer for errstr */
|
||||
|
|
@ -271,8 +271,9 @@ syscall(Ureg* ureg)
|
|||
kexit(ureg);
|
||||
}
|
||||
|
||||
long /* void* */
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
ulong *sp;
|
||||
Ureg *ureg;
|
||||
|
|
|
|||
|
|
@ -11,13 +11,13 @@
|
|||
|
||||
void (*proctrace)(Proc *, int, vlong);
|
||||
|
||||
ulong
|
||||
uintptr
|
||||
userpc(void)
|
||||
{
|
||||
return dbgpc(up);
|
||||
}
|
||||
|
||||
ulong
|
||||
uintptr
|
||||
dbgpc(Proc *p)
|
||||
{
|
||||
Ureg *ureg;
|
||||
|
|
@ -101,8 +101,8 @@ forkchild(Proc *p, Ureg *ureg)
|
|||
p->insyscall = 0;
|
||||
}
|
||||
|
||||
long
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
ulong *sp;
|
||||
Ureg *ureg;
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ struct Lock
|
|||
{
|
||||
ulong key;
|
||||
ulong sr;
|
||||
ulong pc;
|
||||
uintptr pc;
|
||||
Proc *p;
|
||||
Mach *m;
|
||||
ushort isilock;
|
||||
|
|
|
|||
|
|
@ -475,14 +475,14 @@ putmmu(ulong va, ulong pa, Page*)
|
|||
* Error checking only.
|
||||
*/
|
||||
void
|
||||
checkmmu(ulong va, ulong pa)
|
||||
checkmmu(uintptr va, uintptr pa)
|
||||
{
|
||||
if(up->mmupdb == 0)
|
||||
return;
|
||||
if(!(vpd[PDX(va)]&PTEVALID) || !(vpt[VPTX(va)]&PTEVALID))
|
||||
return;
|
||||
if(PPN(vpt[VPTX(va)]) != pa)
|
||||
print("%ld %s: va=%#08lux pa=%#08lux pte=%#08lux\n",
|
||||
print("%ld %s: va=%#p pa=%#p pte=%#08lux\n",
|
||||
up->pid, up->text,
|
||||
va, pa, vpt[VPTX(va)]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -760,8 +760,7 @@ syscall(Ureg* ureg)
|
|||
error(Ebadarg);
|
||||
}
|
||||
up->psstate = sysctab[scallnr];
|
||||
|
||||
ret = systab[scallnr](up->s.args);
|
||||
ret = systab[scallnr]((va_list)up->s.args);
|
||||
poperror();
|
||||
}else{
|
||||
/* failure: save the error buffer for errstr */
|
||||
|
|
@ -975,8 +974,8 @@ if(0) print("%s %lud: noted %.8lux %.8lux\n",
|
|||
}
|
||||
}
|
||||
|
||||
long
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
ulong *sp;
|
||||
Ureg *ureg;
|
||||
|
|
@ -996,7 +995,7 @@ execregs(ulong entry, ulong ssize, ulong nargs)
|
|||
/*
|
||||
* return the userpc the last exception happened at
|
||||
*/
|
||||
ulong
|
||||
uintptr
|
||||
userpc(void)
|
||||
{
|
||||
Ureg *ureg;
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ static Block*
|
|||
_allocb(int size)
|
||||
{
|
||||
Block *b;
|
||||
ulong addr;
|
||||
uintptr addr;
|
||||
|
||||
if((b = mallocz(sizeof(Block)+size+Hdrspc, 0)) == nil)
|
||||
return nil;
|
||||
|
|
@ -34,13 +34,13 @@ _allocb(int size)
|
|||
_xinc(&b->ref);
|
||||
|
||||
/* align start of data portion by rounding up */
|
||||
addr = (ulong)b;
|
||||
addr = (uintptr)b;
|
||||
addr = ROUND(addr + sizeof(Block), BLOCKALIGN);
|
||||
b->base = (uchar*)addr;
|
||||
|
||||
/* align end of data portion by rounding down */
|
||||
b->lim = ((uchar*)b) + msize(b);
|
||||
addr = (ulong)(b->lim);
|
||||
addr = (uintptr)(b->lim);
|
||||
addr = addr & ~(BLOCKALIGN-1);
|
||||
b->lim = (uchar*)addr;
|
||||
|
||||
|
|
|
|||
|
|
@ -19,59 +19,68 @@ iseve(void)
|
|||
return strcmp(eve, up->user) == 0;
|
||||
}
|
||||
|
||||
long
|
||||
sysfversion(ulong *arg)
|
||||
uintptr
|
||||
sysfversion(va_list list)
|
||||
{
|
||||
uint msize, arglen;
|
||||
char *vers;
|
||||
uint arglen, m, msize;
|
||||
Chan *c;
|
||||
int fd;
|
||||
|
||||
msize = arg[1];
|
||||
vers = (char*)arg[2];
|
||||
arglen = arg[3];
|
||||
validaddr(arg[2], arglen, 1);
|
||||
fd = va_arg(list, int);
|
||||
msize = va_arg(list, uint);
|
||||
vers = va_arg(list, char*);
|
||||
arglen = va_arg(list, uint);
|
||||
validaddr((uintptr)vers, arglen, 1);
|
||||
/* check there's a NUL in the version string */
|
||||
if(arglen==0 || memchr(vers, 0, arglen)==0)
|
||||
error(Ebadarg);
|
||||
c = fdtochan(arg[0], ORDWR, 0, 1);
|
||||
c = fdtochan(fd, ORDWR, 0, 1);
|
||||
if(waserror()){
|
||||
cclose(c);
|
||||
nexterror();
|
||||
}
|
||||
|
||||
m = mntversion(c, vers, msize, arglen);
|
||||
|
||||
msize = mntversion(c, vers, msize, arglen);
|
||||
cclose(c);
|
||||
poperror();
|
||||
return m;
|
||||
return msize;
|
||||
}
|
||||
|
||||
long
|
||||
sys_fsession(ulong *arg)
|
||||
uintptr
|
||||
sys_fsession(va_list list)
|
||||
{
|
||||
/* deprecated; backwards compatibility only */
|
||||
int fd;
|
||||
char *str;
|
||||
uint len;
|
||||
|
||||
if(arg[2] == 0)
|
||||
/* deprecated; backwards compatibility only */
|
||||
fd = va_arg(list, int);
|
||||
str = va_arg(list, char*);
|
||||
len = va_arg(list, uint);
|
||||
if(len == 0)
|
||||
error(Ebadarg);
|
||||
validaddr(arg[1], arg[2], 1);
|
||||
((uchar*)arg[1])[0] = '\0';
|
||||
validaddr((uintptr)str, len, 1);
|
||||
*str = '\0';
|
||||
USED(fd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
sysfauth(ulong *arg)
|
||||
uintptr
|
||||
sysfauth(va_list list)
|
||||
{
|
||||
Chan *c, *ac;
|
||||
char *aname;
|
||||
int fd;
|
||||
|
||||
validaddr(arg[1], 1, 0);
|
||||
aname = validnamedup((char*)arg[1], 1);
|
||||
fd = va_arg(list, int);
|
||||
aname = va_arg(list, char*);
|
||||
validaddr((uintptr)aname, 1, 0);
|
||||
aname = validnamedup(aname, 1);
|
||||
if(waserror()){
|
||||
free(aname);
|
||||
nexterror();
|
||||
}
|
||||
c = fdtochan(arg[0], ORDWR, 0, 1);
|
||||
c = fdtochan(fd, ORDWR, 0, 1);
|
||||
if(waserror()){
|
||||
cclose(c);
|
||||
nexterror();
|
||||
|
|
@ -96,8 +105,7 @@ sysfauth(ulong *arg)
|
|||
|
||||
/* always mark it close on exec */
|
||||
ac->flag |= CCEXEC;
|
||||
|
||||
return fd;
|
||||
return (uintptr)fd;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -1721,14 +1721,14 @@ char isfrog[256]={
|
|||
* to access unchecked addresses.)
|
||||
*/
|
||||
static char*
|
||||
validname0(char *aname, int slashok, int dup, ulong pc)
|
||||
validname0(char *aname, int slashok, int dup, uintptr pc)
|
||||
{
|
||||
char *ename, *name, *s;
|
||||
int c, n;
|
||||
Rune r;
|
||||
|
||||
name = aname;
|
||||
if((ulong)name < KZERO){
|
||||
if((uintptr)name < KZERO){
|
||||
if(!dup)
|
||||
print("warning: validname called from %#p with user pointer", pc);
|
||||
ename = vmemchr(name, 0, (1<<16));
|
||||
|
|
|
|||
|
|
@ -11,8 +11,8 @@
|
|||
|
||||
struct
|
||||
{
|
||||
int minpc;
|
||||
int maxpc;
|
||||
uintptr minpc;
|
||||
uintptr maxpc;
|
||||
int nbuf;
|
||||
int time;
|
||||
ulong *buf;
|
||||
|
|
@ -30,7 +30,7 @@ Dirtab kproftab[]={
|
|||
};
|
||||
|
||||
static void
|
||||
_kproftimer(ulong pc)
|
||||
_kproftimer(uintptr pc)
|
||||
{
|
||||
extern void spldone(void);
|
||||
|
||||
|
|
@ -40,7 +40,7 @@ _kproftimer(ulong pc)
|
|||
* if the pc is coming out of spllo or splx,
|
||||
* use the pc saved when we went splhi.
|
||||
*/
|
||||
if(pc>=(ulong)spllo && pc<=(ulong)spldone)
|
||||
if(pc>=(uintptr)spllo && pc<=(uintptr)spldone)
|
||||
pc = m->splpc;
|
||||
|
||||
kprof.buf[0] += TK2MS(1);
|
||||
|
|
@ -67,7 +67,7 @@ kprofattach(char *spec)
|
|||
|
||||
/* allocate when first used */
|
||||
kprof.minpc = KTZERO;
|
||||
kprof.maxpc = (ulong)etext;
|
||||
kprof.maxpc = (uintptr)etext;
|
||||
kprof.nbuf = (kprof.maxpc-kprof.minpc) >> LRES;
|
||||
n = kprof.nbuf*SZ;
|
||||
if(kprof.buf == 0) {
|
||||
|
|
|
|||
|
|
@ -152,7 +152,7 @@ static char *sname[]={ "Text", "Data", "Bss", "Stack", "Shared", "Phys", };
|
|||
#define NOTEID(q) ((q).vers)
|
||||
|
||||
void procctlreq(Proc*, char*, int);
|
||||
int procctlmemio(Proc*, ulong, int, void*, int);
|
||||
int procctlmemio(Proc*, uintptr, int, void*, int);
|
||||
Chan* proctext(Chan*, Proc*);
|
||||
Segment* txt2data(Proc*, Segment*);
|
||||
int procstopped(void*);
|
||||
|
|
@ -699,7 +699,7 @@ procread(Chan *c, void *va, long n, vlong off)
|
|||
int i, j, m, navail, ne, rsize;
|
||||
long l;
|
||||
uchar *rptr;
|
||||
ulong offset;
|
||||
uintptr offset;
|
||||
Confmem *cm;
|
||||
Mntwalk *mw;
|
||||
Proc *p;
|
||||
|
|
@ -766,9 +766,9 @@ procread(Chan *c, void *va, long n, vlong off)
|
|||
error(Eperm);
|
||||
|
||||
/* validate kernel addresses */
|
||||
if(offset < (ulong)end) {
|
||||
if(offset+n > (ulong)end)
|
||||
n = (ulong)end - offset;
|
||||
if(offset < (uintptr)end) {
|
||||
if(offset+n > (uintptr)end)
|
||||
n = (uintptr)end - offset;
|
||||
memmove(a, (char*)offset, n);
|
||||
return n;
|
||||
}
|
||||
|
|
@ -910,7 +910,7 @@ procread(Chan *c, void *va, long n, vlong off)
|
|||
sg = p->seg[i];
|
||||
if(sg == 0)
|
||||
continue;
|
||||
j += sprint(statbuf+j, "%-6s %c%c %.8lux %.8lux %4ld\n",
|
||||
j += sprint(statbuf+j, "%-6s %c%c %p %p %4ld\n",
|
||||
sname[sg->type&SG_TYPE],
|
||||
sg->type&SG_RONLY ? 'R' : ' ',
|
||||
sg->profile ? 'P' : ' ',
|
||||
|
|
@ -1533,13 +1533,13 @@ procstopped(void *a)
|
|||
}
|
||||
|
||||
int
|
||||
procctlmemio(Proc *p, ulong offset, int n, void *va, int read)
|
||||
procctlmemio(Proc *p, uintptr offset, int n, void *va, int read)
|
||||
{
|
||||
KMap *k;
|
||||
Pte *pte;
|
||||
Page *pg;
|
||||
Segment *s;
|
||||
ulong soff, l;
|
||||
uintptr soff, l;
|
||||
char *a = va, *b;
|
||||
|
||||
for(;;) {
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
#include "../port/error.h"
|
||||
|
||||
int
|
||||
fault(ulong addr, int read)
|
||||
fault(uintptr addr, int read)
|
||||
{
|
||||
Segment *s;
|
||||
char *sps;
|
||||
|
|
@ -70,18 +70,19 @@ faulterror(char *s, Chan *c, int freemem)
|
|||
pexit(s, freemem);
|
||||
}
|
||||
|
||||
void (*checkaddr)(ulong, Segment *, Page *);
|
||||
ulong addr2check;
|
||||
void (*checkaddr)(uintptr, Segment *, Page *);
|
||||
uintptr addr2check;
|
||||
|
||||
int
|
||||
fixfault(Segment *s, ulong addr, int read, int doputmmu)
|
||||
fixfault(Segment *s, uintptr addr, int read, int doputmmu)
|
||||
{
|
||||
int type;
|
||||
int ref;
|
||||
Pte **p, *etp;
|
||||
ulong mmuphys=0, soff;
|
||||
ulong mmuphys=0;
|
||||
uintptr soff;
|
||||
Page **pg, *lkp, *new;
|
||||
Page *(*fn)(Segment*, ulong);
|
||||
Page *(*fn)(Segment*, uintptr);
|
||||
|
||||
addr &= ~(BY2PG-1);
|
||||
soff = addr-s->base;
|
||||
|
|
@ -198,14 +199,14 @@ fixfault(Segment *s, ulong addr, int read, int doputmmu)
|
|||
}
|
||||
|
||||
void
|
||||
pio(Segment *s, ulong addr, ulong soff, Page **p)
|
||||
pio(Segment *s, uintptr addr, uintptr soff, Page **p)
|
||||
{
|
||||
Page *new;
|
||||
KMap *k;
|
||||
Chan *c;
|
||||
int n, ask;
|
||||
char *kaddr;
|
||||
ulong daddr;
|
||||
uintptr daddr;
|
||||
Page *loadrec;
|
||||
|
||||
retry:
|
||||
|
|
@ -310,7 +311,7 @@ done:
|
|||
* Called only in a system call
|
||||
*/
|
||||
int
|
||||
okaddr(ulong addr, ulong len, int write)
|
||||
okaddr(uintptr addr, ulong len, int write)
|
||||
{
|
||||
Segment *s;
|
||||
|
||||
|
|
@ -332,10 +333,10 @@ okaddr(ulong addr, ulong len, int write)
|
|||
}
|
||||
|
||||
void
|
||||
validaddr(ulong addr, ulong len, int write)
|
||||
validaddr(uintptr addr, ulong len, int write)
|
||||
{
|
||||
if(!okaddr(addr, len, write)){
|
||||
pprint("suicide: invalid address %#lux/%lud in sys call pc=%#lux\n", addr, len, userpc());
|
||||
pprint("suicide: invalid address %#p/%lud in sys call pc=%#p\n", addr, len, userpc());
|
||||
postnote(up, 1, "sys: bad address in syscall", NDebug);
|
||||
error(Ebadarg);
|
||||
}
|
||||
|
|
@ -348,10 +349,10 @@ void*
|
|||
vmemchr(void *s, int c, int n)
|
||||
{
|
||||
int m;
|
||||
ulong a;
|
||||
uintptr a;
|
||||
void *t;
|
||||
|
||||
a = (ulong)s;
|
||||
a = (uintptr)s;
|
||||
while(PGROUND(a) != PGROUND(a+n-1)){
|
||||
/* spans pages; handle this page */
|
||||
m = BY2PG - (a & (BY2PG-1));
|
||||
|
|
@ -369,7 +370,7 @@ vmemchr(void *s, int c, int n)
|
|||
}
|
||||
|
||||
Segment*
|
||||
seg(Proc *p, ulong addr, int dolock)
|
||||
seg(Proc *p, uintptr addr, int dolock)
|
||||
{
|
||||
Segment **s, **et, *n;
|
||||
|
||||
|
|
@ -392,12 +393,13 @@ seg(Proc *p, ulong addr, int dolock)
|
|||
return 0;
|
||||
}
|
||||
|
||||
extern void checkmmu(ulong, ulong);
|
||||
extern void checkmmu(uintptr, uintptr);
|
||||
|
||||
void
|
||||
checkpages(void)
|
||||
{
|
||||
int checked;
|
||||
ulong addr, off;
|
||||
uintptr addr, off;
|
||||
Pte *p;
|
||||
Page *pg;
|
||||
Segment **sp, **ep, *s;
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ file=/sys/src/libc/9syscall/sys.h
|
|||
cat <<'!'
|
||||
#include "/sys/src/libc/9syscall/sys.h"
|
||||
|
||||
typedef long Syscall(ulong*);
|
||||
typedef uintptr Syscall(va_list);
|
||||
|
||||
!
|
||||
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ pagechainhead(Page *p)
|
|||
}
|
||||
|
||||
Page*
|
||||
newpage(int clear, Segment **s, ulong va)
|
||||
newpage(int clear, Segment **s, uintptr va)
|
||||
{
|
||||
Page *p;
|
||||
KMap *k;
|
||||
|
|
@ -409,7 +409,7 @@ cachepage(Page *p, Image *i)
|
|||
}
|
||||
|
||||
void
|
||||
cachedel(Image *i, ulong daddr)
|
||||
cachedel(Image *i, uintptr daddr)
|
||||
{
|
||||
Page *f;
|
||||
|
||||
|
|
@ -434,7 +434,7 @@ retry:
|
|||
}
|
||||
|
||||
Page *
|
||||
lookpage(Image *i, ulong daddr)
|
||||
lookpage(Image *i, uintptr daddr)
|
||||
{
|
||||
Page *f;
|
||||
|
||||
|
|
@ -574,7 +574,7 @@ checkpagerefs(void)
|
|||
nwrong = 0;
|
||||
for(i=0; i<np; i++){
|
||||
if(palloc.pages[i].ref != ref[i]){
|
||||
iprint("page %#.8lux ref %d actual %lud\n",
|
||||
iprint("page %#p ref %d actual %lud\n",
|
||||
palloc.pages[i].pa, palloc.pages[i].ref, ref[i]);
|
||||
ref[i] = 1;
|
||||
nwrong++;
|
||||
|
|
@ -627,7 +627,7 @@ portcountpagerefs(ulong *ref, int print)
|
|||
continue;
|
||||
if(print){
|
||||
if(ref[pagenumber(entry)])
|
||||
iprint("page %#.8lux in segment %#p\n", entry->pa, s);
|
||||
iprint("page %#p in segment %#p\n", entry->pa, s);
|
||||
continue;
|
||||
}
|
||||
if(ref[pagenumber(entry)]++ == 0)
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ struct RWlock
|
|||
Lock use;
|
||||
Proc *head; /* list of waiting processes */
|
||||
Proc *tail;
|
||||
ulong wpc; /* pc of writer */
|
||||
uintptr wpc; /* pc of writer */
|
||||
Proc *wproc; /* writing proc */
|
||||
int readers; /* number of readers */
|
||||
int writer; /* number of writers */
|
||||
|
|
@ -97,7 +97,7 @@ struct Alarms
|
|||
|
||||
struct Sargs
|
||||
{
|
||||
ulong args[MAXSYSARG];
|
||||
uchar args[MAXSYSARG*BY2WD];
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -313,9 +313,9 @@ enum
|
|||
struct Page
|
||||
{
|
||||
Lock;
|
||||
ulong pa; /* Physical address in memory */
|
||||
ulong va; /* Virtual address for user */
|
||||
ulong daddr; /* Disc address on swap */
|
||||
uintptr pa; /* Physical address in memory */
|
||||
uintptr va; /* Virtual address for user */
|
||||
uintptr daddr; /* Disc address on swap */
|
||||
ulong gen; /* Generation counter for swap */
|
||||
ushort ref; /* Reference count */
|
||||
char modref; /* Simulated modify/reference bits */
|
||||
|
|
@ -378,9 +378,9 @@ enum
|
|||
};
|
||||
|
||||
#define PG_ONSWAP 1
|
||||
#define onswap(s) (((ulong)s)&PG_ONSWAP)
|
||||
#define pagedout(s) (((ulong)s)==0 || onswap(s))
|
||||
#define swapaddr(s) (((ulong)s)&~PG_ONSWAP)
|
||||
#define onswap(s) (((uintptr)s)&PG_ONSWAP)
|
||||
#define pagedout(s) (((uintptr)s)==0 || onswap(s))
|
||||
#define swapaddr(s) (((uintptr)s)&~PG_ONSWAP)
|
||||
|
||||
#define SEGMAXSIZE (SEGMAPSIZE*PTEMAPMEM)
|
||||
|
||||
|
|
@ -388,9 +388,9 @@ struct Physseg
|
|||
{
|
||||
ulong attr; /* Segment attributes */
|
||||
char *name; /* Attach name */
|
||||
ulong pa; /* Physical address */
|
||||
uintptr pa; /* Physical address */
|
||||
ulong size; /* Maximum segment size in pages */
|
||||
Page *(*pgalloc)(Segment*, ulong); /* Allocation if we need it */
|
||||
Page *(*pgalloc)(Segment*, uintptr); /* Allocation if we need it */
|
||||
void (*pgfree)(Page*);
|
||||
};
|
||||
|
||||
|
|
@ -409,11 +409,11 @@ struct Segment
|
|||
QLock lk;
|
||||
ushort steal; /* Page stealer lock */
|
||||
ushort type; /* segment type */
|
||||
ulong base; /* virtual base */
|
||||
ulong top; /* virtual top */
|
||||
uintptr base; /* virtual base */
|
||||
uintptr top; /* virtual top */
|
||||
ulong size; /* size in pages */
|
||||
ulong fstart; /* start address in file for demand load */
|
||||
ulong flen; /* length of segment in file */
|
||||
uintptr fstart; /* start address in file for demand load */
|
||||
uintptr flen; /* length of segment in file */
|
||||
int flushme; /* maintain icache for this segment */
|
||||
Image *image; /* text in file attached to this segment */
|
||||
Physseg *pseg;
|
||||
|
|
@ -490,8 +490,8 @@ enum
|
|||
|
||||
struct Pallocmem
|
||||
{
|
||||
ulong base;
|
||||
ulong npage;
|
||||
uintptr base;
|
||||
ulong npage;
|
||||
};
|
||||
|
||||
struct Palloc
|
||||
|
|
@ -671,7 +671,7 @@ struct Proc
|
|||
ulong privatemem; /* proc does not let anyone read mem */
|
||||
int hang; /* hang at next exec for debug */
|
||||
int procctl; /* Control for /proc debugging */
|
||||
ulong pc; /* DEBUG only */
|
||||
uintptr pc; /* DEBUG only */
|
||||
|
||||
Lock rlock; /* sync sleep/wakeup with postnote */
|
||||
Rendez *r; /* rendezvous point slept on */
|
||||
|
|
@ -734,7 +734,7 @@ struct Proc
|
|||
Edf *edf; /* if non-null, real-time proc, edf contains scheduling params */
|
||||
int trace; /* process being traced? */
|
||||
|
||||
ulong qpc; /* pc calling last blocking qlock */
|
||||
uintptr qpc; /* pc calling last blocking qlock */
|
||||
QLock *eql; /* interruptable eqlock */
|
||||
|
||||
int setargs; /* process changed its args */
|
||||
|
|
|
|||
|
|
@ -9,12 +9,12 @@ void alarmkproc(void*);
|
|||
Block* allocb(int);
|
||||
int anyhigher(void);
|
||||
int anyready(void);
|
||||
Image* attachimage(int, Chan*, ulong, ulong);
|
||||
Image* attachimage(int, Chan*, uintptr, ulong);
|
||||
Page* auxpage(void);
|
||||
Block* bl2mem(uchar*, Block*, int);
|
||||
int blocklen(Block*);
|
||||
void bootlinks(void);
|
||||
void cachedel(Image*, ulong);
|
||||
void cachedel(Image*, uintptr);
|
||||
void cachepage(Page*, Image*);
|
||||
void callwithureg(void(*)(Ureg*));
|
||||
char* chanpath(Chan*);
|
||||
|
|
@ -51,7 +51,7 @@ int cread(Chan*, uchar*, int, vlong);
|
|||
void cunmount(Chan*, Chan*);
|
||||
void cupdate(Chan*, uchar*, int, vlong);
|
||||
void cwrite(Chan*, uchar*, int, vlong);
|
||||
ulong dbgpc(Proc*);
|
||||
uintptr dbgpc(Proc*);
|
||||
long decref(Ref*);
|
||||
int decrypt(void*, void*, int);
|
||||
void delay(int);
|
||||
|
|
@ -99,17 +99,17 @@ int eqchantdqid(Chan*, int, int, Qid, int);
|
|||
int eqqid(Qid, Qid);
|
||||
void error(char*);
|
||||
void eqlock(QLock*);
|
||||
long execregs(ulong, ulong, ulong);
|
||||
uintptr execregs(uintptr, ulong, ulong);
|
||||
void exhausted(char*);
|
||||
void exit(int);
|
||||
uvlong fastticks(uvlong*);
|
||||
uvlong fastticks2ns(uvlong);
|
||||
uvlong fastticks2us(uvlong);
|
||||
int fault(ulong, int);
|
||||
int fault(uintptr, int);
|
||||
void fdclose(int, int);
|
||||
Chan* fdtochan(int, int, int, int);
|
||||
int findmount(Chan**, Mhead**, int, int, Qid);
|
||||
int fixfault(Segment*, ulong, int, int);
|
||||
int fixfault(Segment*, uintptr, int, int);
|
||||
void flushmmu(void);
|
||||
void forceclosefgrp(void);
|
||||
void forkchild(Proc*, Ureg*);
|
||||
|
|
@ -120,8 +120,8 @@ void freeblist(Block*);
|
|||
int freebroken(void);
|
||||
void freepte(Segment*, Pte*);
|
||||
void getcolor(ulong, ulong*, ulong*, ulong*);
|
||||
ulong getmalloctag(void*);
|
||||
ulong getrealloctag(void*);
|
||||
uintptr getmalloctag(void*);
|
||||
uintptr getrealloctag(void*);
|
||||
void gotolabel(Label*);
|
||||
char* getconfenv(void);
|
||||
long hostdomainwrite(char*, int);
|
||||
|
|
@ -129,7 +129,7 @@ long hostownerwrite(char*, int);
|
|||
void hzsched(void);
|
||||
Block* iallocb(int);
|
||||
void iallocsummary(void);
|
||||
long ibrk(ulong, int);
|
||||
long ibrk(uintptr, int);
|
||||
void ilock(Lock*);
|
||||
void iunlock(Lock*);
|
||||
long incref(Ref*);
|
||||
|
|
@ -138,7 +138,7 @@ int iprint(char*, ...);
|
|||
void isdir(Chan*);
|
||||
int iseve(void);
|
||||
int islo(void);
|
||||
Segment* isoverlap(Proc*, ulong, int);
|
||||
Segment* isoverlap(Proc*, uintptr, int);
|
||||
int ispages(void*);
|
||||
int isphysseg(char*);
|
||||
void ixsummary(void);
|
||||
|
|
@ -146,7 +146,7 @@ void kickpager(void);
|
|||
void killbig(char*);
|
||||
void kproc(char*, void(*)(void*), void*);
|
||||
void kprocchild(Proc*, void (*)(void*), void*);
|
||||
void (*kproftimer)(ulong);
|
||||
void (*kproftimer)(uintptr);
|
||||
void ksetenv(char*, char*, int);
|
||||
void kstrcpy(char*, char*, int);
|
||||
void kstrdup(char**, char*);
|
||||
|
|
@ -158,7 +158,7 @@ void logn(Log*, int, void*, int);
|
|||
long logread(Log*, void*, ulong, long);
|
||||
void log(Log*, int, char*, ...);
|
||||
Cmdtab* lookupcmd(Cmdbuf*, Cmdtab*, int);
|
||||
Page* lookpage(Image*, ulong);
|
||||
Page* lookpage(Image*, uintptr);
|
||||
#define MS2NS(n) (((vlong)(n))*1000000LL)
|
||||
void machinit(void);
|
||||
void* mallocz(ulong, int);
|
||||
|
|
@ -167,7 +167,7 @@ void* mallocalign(ulong, ulong, long, ulong);
|
|||
void mallocsummary(void);
|
||||
Block* mem2bl(uchar*, int);
|
||||
int mcountseg(Segment*);
|
||||
void mfreeseg(Segment*, ulong, int);
|
||||
void mfreeseg(Segment*, uintptr, int);
|
||||
void microdelay(int);
|
||||
uvlong mk64fract(uvlong, uvlong);
|
||||
void mkqid(Qid*, vlong, ulong, int);
|
||||
|
|
@ -189,7 +189,7 @@ Chan* newchan(void);
|
|||
int newfd(Chan*);
|
||||
Mhead* newmhead(Chan*);
|
||||
Mount* newmount(Mhead*, Chan*, int, char*);
|
||||
Page* newpage(int, Segment **, ulong);
|
||||
Page* newpage(int, Segment **, uintptr);
|
||||
Path* newpath(char*);
|
||||
Pgrp* newpgrp(void);
|
||||
Rgrp* newrgrp(void);
|
||||
|
|
@ -198,7 +198,7 @@ void nexterror(void);
|
|||
int notify(Ureg*);
|
||||
int nrand(int);
|
||||
uvlong ns2fastticks(uvlong);
|
||||
int okaddr(ulong, ulong, int);
|
||||
int okaddr(uintptr, ulong, int);
|
||||
int openmode(ulong);
|
||||
Block* packblock(Block*);
|
||||
Block* padblock(Block*, int);
|
||||
|
|
@ -214,7 +214,7 @@ void pexit(char*, int);
|
|||
void pgrpcpy(Pgrp*, Pgrp*);
|
||||
void pgrpnote(ulong, char*, long, int);
|
||||
int pidalloc(Proc*);
|
||||
void pio(Segment *, ulong, ulong, Page **);
|
||||
void pio(Segment *, uintptr, uintptr, Page **);
|
||||
#define poperror() up->nerrlab--
|
||||
void portcountpagerefs(ulong*, int);
|
||||
int postnote(Proc*, int, char*, int);
|
||||
|
|
@ -287,7 +287,7 @@ void ready(Proc*);
|
|||
void* realloc(void *v, ulong size);
|
||||
void rebootcmd(int, char**);
|
||||
void reboot(void*, void*, ulong);
|
||||
void relocateseg(Segment*, ulong);
|
||||
void relocateseg(Segment*, uintptr);
|
||||
void renameuser(char*, char*);
|
||||
void resched(char*);
|
||||
void resrcwait(char*);
|
||||
|
|
@ -302,14 +302,14 @@ void scheddump(void);
|
|||
void schedinit(void);
|
||||
void (*screenputs)(char*, int);
|
||||
long seconds(void);
|
||||
ulong segattach(Proc*, ulong, char *, ulong, ulong);
|
||||
void segclock(ulong);
|
||||
uintptr segattach(Proc*, ulong, char *, uintptr, ulong);
|
||||
void segclock(uintptr);
|
||||
void segpage(Segment*, Page*);
|
||||
int setcolor(ulong, ulong, ulong, ulong);
|
||||
void setkernur(Ureg*, Proc*);
|
||||
int setlabel(Label*);
|
||||
void setmalloctag(void*, ulong);
|
||||
void setrealloctag(void*, ulong);
|
||||
void setmalloctag(void*, uintptr);
|
||||
void setrealloctag(void*, uintptr);
|
||||
void setregisters(Ureg*, char*, char*, int);
|
||||
void setswapchan(Chan*);
|
||||
char* skipslash(char*);
|
||||
|
|
@ -322,11 +322,11 @@ void splxpc(int);
|
|||
char* srvname(Chan*);
|
||||
void srvrenameuser(char*, char*);
|
||||
void shrrenameuser(char*, char*);
|
||||
int swapcount(ulong);
|
||||
int swapcount(uintptr);
|
||||
int swapfull(void);
|
||||
void swapinit(void);
|
||||
void syscallfmt(ulong syscallno, ulong pc, va_list list);
|
||||
void sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop);
|
||||
void syscallfmt(ulong syscallno, uintptr pc, va_list list);
|
||||
void sysretfmt(ulong syscallno, va_list list, uintptr ret, uvlong start, uvlong stop);
|
||||
void timeradd(Timer*);
|
||||
void timerdel(Timer*);
|
||||
void timersinit(void);
|
||||
|
|
@ -356,9 +356,9 @@ long unionread(Chan*, void*, long);
|
|||
void unlock(Lock*);
|
||||
uvlong us2fastticks(uvlong);
|
||||
void userinit(void);
|
||||
ulong userpc(void);
|
||||
uintptr userpc(void);
|
||||
long userwrite(char*, int);
|
||||
void validaddr(ulong, ulong, int);
|
||||
void validaddr(uintptr, ulong, int);
|
||||
void validname(char*, int);
|
||||
char* validnamedup(char*, int);
|
||||
void validstat(uchar*, int);
|
||||
|
|
@ -378,8 +378,8 @@ void xsummary(void);
|
|||
void yield(void);
|
||||
Segment* data2txt(Segment*);
|
||||
Segment* dupseg(Segment**, int, int);
|
||||
Segment* newseg(int, ulong, ulong);
|
||||
Segment* seg(Proc*, ulong, int);
|
||||
Segment* newseg(int, uintptr, ulong);
|
||||
Segment* seg(Proc*, uintptr, int);
|
||||
void hnputv(void*, uvlong);
|
||||
void hnputl(void*, uint);
|
||||
void hnputs(void*, ushort);
|
||||
|
|
|
|||
|
|
@ -743,7 +743,7 @@ sleep(Rendez *r, int (*f)(void*), void *arg)
|
|||
s = splhi();
|
||||
|
||||
if(up->nlocks.ref)
|
||||
print("process %lud sleeps with %lud locks held, last lock %#p locked at pc %#lux, sleep called from %#p\n",
|
||||
print("process %lud sleeps with %lud locks held, last lock %#p locked at pc %#p, sleep called from %#p\n",
|
||||
up->pid, up->nlocks.ref, up->lastlock, up->lastlock->pc, getcallerpc(&r));
|
||||
lock(r);
|
||||
lock(&up->rlock);
|
||||
|
|
@ -1283,9 +1283,10 @@ dumpaproc(Proc *p)
|
|||
s = p->psstate;
|
||||
if(s == 0)
|
||||
s = statename[p->state];
|
||||
print("%3lud:%10s pc %8lux dbgpc %8lux %8s (%s) ut %ld st %ld bss %lux qpc %lux nl %lud nd %lud lpc %lux pri %lud\n",
|
||||
print("%3lud:%10s pc %#p dbgpc %#p %8s (%s) ut %ld st %ld bss %lux qpc %#p nl %lud nd %lud lpc %#p pri %lud\n",
|
||||
p->pid, p->text, p->pc, dbgpc(p), s, statename[p->state],
|
||||
p->time[0], p->time[1], bss, p->qpc, p->nlocks.ref, p->delaysched, p->lastlock ? p->lastlock->pc : 0, p->priority);
|
||||
p->time[0], p->time[1], bss, p->qpc, p->nlocks.ref, p->delaysched,
|
||||
p->lastlock ? p->lastlock->pc : 0, p->priority);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ initseg(void)
|
|||
}
|
||||
|
||||
Segment *
|
||||
newseg(int type, ulong base, ulong size)
|
||||
newseg(int type, uintptr base, ulong size)
|
||||
{
|
||||
Segment *s;
|
||||
int mapsize;
|
||||
|
|
@ -125,7 +125,7 @@ putseg(Segment *s)
|
|||
}
|
||||
|
||||
void
|
||||
relocateseg(Segment *s, ulong offset)
|
||||
relocateseg(Segment *s, uintptr offset)
|
||||
{
|
||||
Page **pg, *x;
|
||||
Pte *pte, **p, **endpte;
|
||||
|
|
@ -214,7 +214,7 @@ void
|
|||
segpage(Segment *s, Page *p)
|
||||
{
|
||||
Pte **pte;
|
||||
ulong off;
|
||||
uintptr off;
|
||||
Page **pg;
|
||||
|
||||
if(p->va < s->base || p->va >= s->top)
|
||||
|
|
@ -234,7 +234,7 @@ segpage(Segment *s, Page *p)
|
|||
}
|
||||
|
||||
Image*
|
||||
attachimage(int type, Chan *c, ulong base, ulong len)
|
||||
attachimage(int type, Chan *c, uintptr base, ulong len)
|
||||
{
|
||||
Image *i, **l;
|
||||
|
||||
|
|
@ -392,10 +392,11 @@ putimage(Image *i)
|
|||
}
|
||||
|
||||
long
|
||||
ibrk(ulong addr, int seg)
|
||||
ibrk(uintptr addr, int seg)
|
||||
{
|
||||
Segment *s, *ns;
|
||||
ulong newtop, newsize;
|
||||
uintptr newtop;
|
||||
ulong newsize;
|
||||
int i, mapsize;
|
||||
Pte **map;
|
||||
|
||||
|
|
@ -492,10 +493,10 @@ mcountseg(Segment *s)
|
|||
* called with s->lk locked
|
||||
*/
|
||||
void
|
||||
mfreeseg(Segment *s, ulong start, int pages)
|
||||
mfreeseg(Segment *s, uintptr start, int pages)
|
||||
{
|
||||
int i, j, size;
|
||||
ulong soff;
|
||||
uintptr soff;
|
||||
Page *pg;
|
||||
Page *list;
|
||||
|
||||
|
|
@ -553,11 +554,11 @@ out:
|
|||
}
|
||||
|
||||
Segment*
|
||||
isoverlap(Proc *p, ulong va, int len)
|
||||
isoverlap(Proc *p, uintptr va, int len)
|
||||
{
|
||||
int i;
|
||||
Segment *ns;
|
||||
ulong newtop;
|
||||
uintptr newtop;
|
||||
|
||||
newtop = va+len;
|
||||
for(i = 0; i < NSEG; i++) {
|
||||
|
|
@ -615,8 +616,8 @@ isphysseg(char *name)
|
|||
return rv;
|
||||
}
|
||||
|
||||
ulong
|
||||
segattach(Proc *p, ulong attr, char *name, ulong va, ulong len)
|
||||
uintptr
|
||||
segattach(Proc *p, ulong attr, char *name, uintptr va, ulong len)
|
||||
{
|
||||
int sno;
|
||||
Segment *s, *os;
|
||||
|
|
@ -625,7 +626,7 @@ segattach(Proc *p, ulong attr, char *name, ulong va, ulong len)
|
|||
if(va != 0 && va >= USTKTOP)
|
||||
error(Ebadarg);
|
||||
|
||||
validaddr((ulong)name, 1, 0);
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
vmemchr(name, 0, ~0);
|
||||
|
||||
for(sno = 0; sno < NSEG; sno++)
|
||||
|
|
@ -708,16 +709,17 @@ pteflush(Pte *pte, int s, int e)
|
|||
}
|
||||
}
|
||||
|
||||
long
|
||||
syssegflush(ulong *arg)
|
||||
uintptr
|
||||
syssegflush(va_list list)
|
||||
{
|
||||
Segment *s;
|
||||
ulong addr, l;
|
||||
ulong len, l;
|
||||
Pte *pte;
|
||||
int chunk, ps, pe, len;
|
||||
int chunk, ps, pe;
|
||||
uintptr addr;
|
||||
|
||||
addr = arg[0];
|
||||
len = arg[1];
|
||||
addr = va_arg(list, uintptr);
|
||||
len = va_arg(list, ulong);
|
||||
|
||||
while(len > 0) {
|
||||
s = seg(up, addr, 1);
|
||||
|
|
@ -760,7 +762,7 @@ syssegflush(ulong *arg)
|
|||
}
|
||||
|
||||
void
|
||||
segclock(ulong pc)
|
||||
segclock(uintptr pc)
|
||||
{
|
||||
Segment *s;
|
||||
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ putswap(Page *p)
|
|||
uchar *idx;
|
||||
|
||||
lock(&swapalloc);
|
||||
idx = &swapalloc.swmap[((ulong)p)/BY2PG];
|
||||
idx = &swapalloc.swmap[((uintptr)p)/BY2PG];
|
||||
if(*idx == 0)
|
||||
panic("putswap %#p ref == 0", p);
|
||||
|
||||
|
|
@ -111,7 +111,7 @@ dupswap(Page *p)
|
|||
uchar *idx;
|
||||
|
||||
lock(&swapalloc);
|
||||
idx = &swapalloc.swmap[((ulong)p)/BY2PG];
|
||||
idx = &swapalloc.swmap[((uintptr)p)/BY2PG];
|
||||
if(*idx == 255)
|
||||
swapalloc.xref++;
|
||||
else {
|
||||
|
|
@ -122,7 +122,7 @@ dupswap(Page *p)
|
|||
}
|
||||
|
||||
int
|
||||
swapcount(ulong daddr)
|
||||
swapcount(uintptr daddr)
|
||||
{
|
||||
return swapalloc.swmap[daddr/BY2PG];
|
||||
}
|
||||
|
|
@ -309,7 +309,7 @@ canflush(Proc *p, Segment *s)
|
|||
static void
|
||||
pagepte(int type, Page **pg)
|
||||
{
|
||||
ulong daddr;
|
||||
uintptr daddr;
|
||||
Page *outp;
|
||||
|
||||
outp = *pg;
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ fmtrwdata(Fmt* f, char* a, int n, char* suffix)
|
|||
fmtprint(f, "0x0%s", suffix);
|
||||
return;
|
||||
}
|
||||
validaddr((ulong)a, n, 0);
|
||||
validaddr((uintptr)a, n, 0);
|
||||
t = smalloc(n+1);
|
||||
t[n] = 0;
|
||||
for(i = 0; i < n; i++)
|
||||
|
|
@ -43,7 +43,7 @@ fmtuserstring(Fmt* f, char* a, char* suffix)
|
|||
fmtprint(f, "0/\"\"%s", suffix);
|
||||
return;
|
||||
}
|
||||
validaddr((ulong)a, 1, 0);
|
||||
validaddr((uintptr)a, 1, 0);
|
||||
n = ((char*)vmemchr(a, 0, 0x7fffffff) - a) + 1;
|
||||
t = smalloc(n+1);
|
||||
memmove(t, a, n);
|
||||
|
|
@ -53,7 +53,7 @@ fmtuserstring(Fmt* f, char* a, char* suffix)
|
|||
}
|
||||
|
||||
void
|
||||
syscallfmt(ulong syscallno, ulong pc, va_list list)
|
||||
syscallfmt(ulong syscallno, uintptr pc, va_list list)
|
||||
{
|
||||
long l;
|
||||
Fmt fmt;
|
||||
|
|
@ -72,7 +72,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
|
|||
fmtprint(&fmt, "%s ", sysctab[syscallno]?
|
||||
sysctab[syscallno]: "huh?");
|
||||
|
||||
fmtprint(&fmt, "%ulx ", pc);
|
||||
fmtprint(&fmt, "%p ", pc);
|
||||
switch(syscallno){
|
||||
case SYSR1:
|
||||
p = va_arg(list, uintptr);
|
||||
|
|
@ -113,7 +113,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
|
|||
argv = va_arg(list, char**);
|
||||
evenaddr(PTR2UINT(argv));
|
||||
for(;;){
|
||||
validaddr((ulong)argv, sizeof(char**), 0);
|
||||
validaddr((uintptr)argv, sizeof(char**), 0);
|
||||
a = *(char **)argv;
|
||||
if(a == nil)
|
||||
break;
|
||||
|
|
@ -307,7 +307,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
|
|||
}
|
||||
|
||||
void
|
||||
sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
|
||||
sysretfmt(ulong syscallno, va_list list, uintptr ret, uvlong start, uvlong stop)
|
||||
{
|
||||
long l;
|
||||
void* v;
|
||||
|
|
@ -324,9 +324,9 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
|
|||
case ALARM:
|
||||
case _WRITE:
|
||||
case PWRITE:
|
||||
if(ret == -1)
|
||||
if((long)ret == -1)
|
||||
errstr = up->syserrstr;
|
||||
fmtprint(&fmt, " = %ld", ret);
|
||||
fmtprint(&fmt, " = %ld", (long)ret);
|
||||
break;
|
||||
case EXEC:
|
||||
case SEGBRK:
|
||||
|
|
@ -341,10 +341,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
|
|||
l = va_arg(list, unsigned long);
|
||||
if(ret > 0){
|
||||
fmtuserstring(&fmt, a, " ");
|
||||
fmtprint(&fmt, "%lud = %ld", l, ret);
|
||||
fmtprint(&fmt, "%lud = %ld", l, (long)ret);
|
||||
}
|
||||
else{
|
||||
fmtprint(&fmt, "%#p/\"\" %lud = %ld", a, l, ret);
|
||||
fmtprint(&fmt, "%#p/\"\" %lud = %ld", a, l, (long)ret);
|
||||
errstr = up->syserrstr;
|
||||
}
|
||||
break;
|
||||
|
|
@ -357,10 +357,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
|
|||
l = va_arg(list, unsigned long);
|
||||
if(ret > 0){
|
||||
fmtuserstring(&fmt, a, " ");
|
||||
fmtprint(&fmt, "%lud = %ld", l, ret);
|
||||
fmtprint(&fmt, "%lud = %ld", l, (long)ret);
|
||||
}
|
||||
else{
|
||||
fmtprint(&fmt, "\"\" %lud = %ld", l, ret);
|
||||
fmtprint(&fmt, "\"\" %lud = %ld", l, (long)ret);
|
||||
errstr = up->syserrstr;
|
||||
}
|
||||
break;
|
||||
|
|
@ -371,10 +371,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
|
|||
l = va_arg(list, unsigned long);
|
||||
if(ret > 0){
|
||||
fmtuserstring(&fmt, a, " ");
|
||||
fmtprint(&fmt, "%lud = %ld", l, ret);
|
||||
fmtprint(&fmt, "%lud = %ld", l, (long)ret);
|
||||
}
|
||||
else{
|
||||
fmtprint(&fmt, "\"\" %lud = %ld", l, ret);
|
||||
fmtprint(&fmt, "\"\" %lud = %ld", l, (long)ret);
|
||||
errstr = up->syserrstr;
|
||||
}
|
||||
break;
|
||||
|
|
@ -397,7 +397,7 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
|
|||
vl = va_arg(list, vlong);
|
||||
fmtprint(&fmt, " %lld", vl);
|
||||
}
|
||||
fmtprint(&fmt, " = %ld", ret);
|
||||
fmtprint(&fmt, " = %ld", (long)ret);
|
||||
break;
|
||||
}
|
||||
fmtprint(&fmt, " %s %#llud %#llud\n", errstr, start, stop);
|
||||
|
|
|
|||
|
|
@ -113,7 +113,6 @@ newfd2(int fd[2], Chan *c[2])
|
|||
f->fd[fd[0]] = c[0];
|
||||
f->fd[fd[1]] = c[1];
|
||||
unlockfgrp(f);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -155,7 +154,6 @@ fdtochan(int fd, int mode, int chkmnt, int iref)
|
|||
cclose(c);
|
||||
error(Ebadusefd);
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
|
@ -170,29 +168,36 @@ openmode(ulong o)
|
|||
return o;
|
||||
}
|
||||
|
||||
long
|
||||
sysfd2path(ulong *arg)
|
||||
uintptr
|
||||
sysfd2path(va_list list)
|
||||
{
|
||||
Chan *c;
|
||||
char *buf;
|
||||
uint len;
|
||||
int fd;
|
||||
|
||||
validaddr(arg[1], arg[2], 1);
|
||||
|
||||
c = fdtochan(arg[0], -1, 0, 1);
|
||||
snprint((char*)arg[1], arg[2], "%s", chanpath(c));
|
||||
fd = va_arg(list, int);
|
||||
buf = va_arg(list, char*);
|
||||
len = va_arg(list, uint);
|
||||
validaddr((uintptr)buf, len, 1);
|
||||
c = fdtochan(fd, -1, 0, 1);
|
||||
snprint(buf, len, "%s", chanpath(c));
|
||||
cclose(c);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
syspipe(ulong *arg)
|
||||
uintptr
|
||||
syspipe(va_list list)
|
||||
{
|
||||
int fd[2];
|
||||
int *fd;
|
||||
Chan *c[2];
|
||||
Dev *d;
|
||||
static char *datastr[] = {"data", "data1"};
|
||||
|
||||
validaddr(arg[0], 2*BY2WD, 1);
|
||||
evenaddr(arg[0]);
|
||||
fd = va_arg(list, int*);
|
||||
validaddr((uintptr)fd, 2*sizeof(int), 1);
|
||||
evenaddr((uintptr)fd);
|
||||
|
||||
d = devtab[devno('|', 0)];
|
||||
c[0] = namec("#|", Atodir, 0, 0);
|
||||
c[1] = 0;
|
||||
|
|
@ -215,24 +220,23 @@ syspipe(ulong *arg)
|
|||
if(newfd2(fd, c) < 0)
|
||||
error(Enofd);
|
||||
poperror();
|
||||
|
||||
((long*)arg[0])[0] = fd[0];
|
||||
((long*)arg[0])[1] = fd[1];
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
sysdup(ulong *arg)
|
||||
uintptr
|
||||
sysdup(va_list list)
|
||||
{
|
||||
int fd;
|
||||
Chan *c, *oc;
|
||||
Fgrp *f = up->fgrp;
|
||||
|
||||
fd = va_arg(list, int);
|
||||
|
||||
/*
|
||||
* Close after dup'ing, so date > #d/1 works
|
||||
*/
|
||||
c = fdtochan(arg[0], -1, 0, 1);
|
||||
fd = arg[1];
|
||||
c = fdtochan(fd, -1, 0, 1);
|
||||
fd = va_arg(list, int);
|
||||
if(fd != -1){
|
||||
lock(f);
|
||||
if(fd<0 || growfd(f, fd)<0) {
|
||||
|
|
@ -258,19 +262,22 @@ sysdup(ulong *arg)
|
|||
error(Enofd);
|
||||
poperror();
|
||||
}
|
||||
|
||||
return fd;
|
||||
return (uintptr)fd;
|
||||
}
|
||||
|
||||
long
|
||||
sysopen(ulong *arg)
|
||||
uintptr
|
||||
sysopen(va_list list)
|
||||
{
|
||||
int fd;
|
||||
Chan *c;
|
||||
char *name;
|
||||
ulong mode;
|
||||
|
||||
openmode(arg[1]); /* error check only */
|
||||
validaddr(arg[0], 1, 0);
|
||||
c = namec((char*)arg[0], Aopen, arg[1], 0);
|
||||
name = va_arg(list, char*);
|
||||
mode = va_arg(list, ulong);
|
||||
openmode(mode); /* error check only */
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
c = namec(name, Aopen, mode, 0);
|
||||
if(waserror()){
|
||||
cclose(c);
|
||||
nexterror();
|
||||
|
|
@ -279,7 +286,7 @@ sysopen(ulong *arg)
|
|||
if(fd < 0)
|
||||
error(Enofd);
|
||||
poperror();
|
||||
return fd;
|
||||
return (uintptr)fd;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -311,12 +318,14 @@ fdclose(int fd, int flag)
|
|||
cclose(c);
|
||||
}
|
||||
|
||||
long
|
||||
sysclose(ulong *arg)
|
||||
uintptr
|
||||
sysclose(va_list list)
|
||||
{
|
||||
fdtochan(arg[0], -1, 0, 0);
|
||||
fdclose(arg[0], 0);
|
||||
int fd;
|
||||
|
||||
fd = va_arg(list, int);
|
||||
fdtochan(fd, -1, 0, 0);
|
||||
fdclose(fd, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -625,17 +634,14 @@ mountfix(Chan *c, uchar *op, long n, long maxn)
|
|||
}
|
||||
|
||||
static long
|
||||
read(ulong *arg, vlong *offp)
|
||||
read(int fd, uchar *p, long n, vlong *offp)
|
||||
{
|
||||
long n, nn, nnn;
|
||||
uchar *p;
|
||||
long nn, nnn;
|
||||
Chan *c;
|
||||
vlong off;
|
||||
|
||||
n = arg[2];
|
||||
validaddr(arg[1], n, 1);
|
||||
p = (void*)arg[1];
|
||||
c = fdtochan(arg[0], OREAD, 1, 1);
|
||||
validaddr((uintptr)p, n, 1);
|
||||
c = fdtochan(fd, OREAD, 1, 1);
|
||||
|
||||
if(waserror()){
|
||||
cclose(c);
|
||||
|
|
@ -688,43 +694,51 @@ read(ulong *arg, vlong *offp)
|
|||
|
||||
poperror();
|
||||
cclose(c);
|
||||
|
||||
return nnn;
|
||||
}
|
||||
|
||||
long
|
||||
sys_read(ulong *arg)
|
||||
uintptr
|
||||
sys_read(va_list list)
|
||||
{
|
||||
return read(arg, nil);
|
||||
int fd;
|
||||
void *buf;
|
||||
long len;
|
||||
|
||||
fd = va_arg(list, int);
|
||||
buf = va_arg(list, void*);
|
||||
len = va_arg(list, long);
|
||||
return (uintptr)read(fd, buf, len, nil);
|
||||
}
|
||||
|
||||
long
|
||||
syspread(ulong *arg)
|
||||
uintptr
|
||||
syspread(va_list list)
|
||||
{
|
||||
vlong v;
|
||||
va_list list;
|
||||
int fd;
|
||||
void *buf;
|
||||
long len;
|
||||
vlong off, *offp;
|
||||
|
||||
/* use varargs to guarantee alignment of vlong */
|
||||
va_start(list, arg[2]);
|
||||
v = va_arg(list, vlong);
|
||||
va_end(list);
|
||||
|
||||
if(v == ~0ULL)
|
||||
return read(arg, nil);
|
||||
|
||||
return read(arg, &v);
|
||||
fd = va_arg(list, int);
|
||||
buf = va_arg(list, void*);
|
||||
len = va_arg(list, long);
|
||||
off = va_arg(list, vlong);
|
||||
if(off != ~0ULL)
|
||||
offp = &off;
|
||||
else
|
||||
offp = nil;
|
||||
return (uintptr)read(fd, buf, len, offp);
|
||||
}
|
||||
|
||||
static long
|
||||
write(ulong *arg, vlong *offp)
|
||||
write(int fd, void *buf, long len, vlong *offp)
|
||||
{
|
||||
Chan *c;
|
||||
long m, n;
|
||||
vlong off;
|
||||
|
||||
validaddr(arg[1], arg[2], 0);
|
||||
validaddr((uintptr)buf, len, 0);
|
||||
n = 0;
|
||||
c = fdtochan(arg[0], OWRITE, 1, 1);
|
||||
c = fdtochan(fd, OWRITE, 1, 1);
|
||||
if(waserror()) {
|
||||
if(offp == nil){
|
||||
lock(c);
|
||||
|
|
@ -738,7 +752,7 @@ write(ulong *arg, vlong *offp)
|
|||
if(c->qid.type & QTDIR)
|
||||
error(Eisdir);
|
||||
|
||||
n = arg[2];
|
||||
n = len;
|
||||
|
||||
if(offp == nil){ /* use and maintain channel's offset */
|
||||
lock(c);
|
||||
|
|
@ -751,8 +765,7 @@ write(ulong *arg, vlong *offp)
|
|||
if(off < 0)
|
||||
error(Enegoff);
|
||||
|
||||
m = devtab[c->type]->write(c, (void*)arg[1], n, off);
|
||||
|
||||
m = devtab[c->type]->write(c, buf, n, off);
|
||||
if(offp == nil && m < n){
|
||||
lock(c);
|
||||
c->offset -= n - m;
|
||||
|
|
@ -761,47 +774,51 @@ write(ulong *arg, vlong *offp)
|
|||
|
||||
poperror();
|
||||
cclose(c);
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
long
|
||||
sys_write(ulong *arg)
|
||||
uintptr
|
||||
sys_write(va_list list)
|
||||
{
|
||||
return write(arg, nil);
|
||||
int fd;
|
||||
void *buf;
|
||||
long len;
|
||||
|
||||
fd = va_arg(list, int);
|
||||
buf = va_arg(list, void*);
|
||||
len = va_arg(list, long);
|
||||
return (uintptr)write(fd, buf, len, nil);
|
||||
}
|
||||
|
||||
long
|
||||
syspwrite(ulong *arg)
|
||||
uintptr
|
||||
syspwrite(va_list list)
|
||||
{
|
||||
vlong v;
|
||||
va_list list;
|
||||
int fd;
|
||||
void *buf;
|
||||
long len;
|
||||
vlong off, *offp;
|
||||
|
||||
/* use varargs to guarantee alignment of vlong */
|
||||
va_start(list, arg[2]);
|
||||
v = va_arg(list, vlong);
|
||||
va_end(list);
|
||||
|
||||
if(v == ~0ULL)
|
||||
return write(arg, nil);
|
||||
|
||||
return write(arg, &v);
|
||||
fd = va_arg(list, int);
|
||||
buf = va_arg(list, void*);
|
||||
len = va_arg(list, long);
|
||||
off = va_arg(list, vlong);
|
||||
if(off != ~0ULL)
|
||||
offp = &off;
|
||||
else
|
||||
offp = nil;
|
||||
return (uintptr)write(fd, buf, len, offp);
|
||||
}
|
||||
|
||||
static void
|
||||
sseek(ulong *arg)
|
||||
static vlong
|
||||
sseek(int fd, vlong o, int type)
|
||||
{
|
||||
Chan *c;
|
||||
uchar buf[sizeof(Dir)+100];
|
||||
Dir dir;
|
||||
int n;
|
||||
vlong off;
|
||||
union {
|
||||
vlong v;
|
||||
ulong u[2];
|
||||
} o;
|
||||
|
||||
c = fdtochan(arg[1], -1, 1, 1);
|
||||
c = fdtochan(fd, -1, 1, 1);
|
||||
if(waserror()){
|
||||
cclose(c);
|
||||
nexterror();
|
||||
|
|
@ -810,11 +827,9 @@ sseek(ulong *arg)
|
|||
error(Eisstream);
|
||||
|
||||
off = 0;
|
||||
o.u[0] = arg[2];
|
||||
o.u[1] = arg[3];
|
||||
switch(arg[4]){
|
||||
switch(type){
|
||||
case 0:
|
||||
off = o.v;
|
||||
off = o;
|
||||
if((c->qid.type & QTDIR) && off != 0)
|
||||
error(Eisdir);
|
||||
if(off < 0)
|
||||
|
|
@ -826,7 +841,7 @@ sseek(ulong *arg)
|
|||
if(c->qid.type & QTDIR)
|
||||
error(Eisdir);
|
||||
lock(c); /* lock for read/write update */
|
||||
off = o.v + c->offset;
|
||||
off = o + c->offset;
|
||||
if(off < 0){
|
||||
unlock(c);
|
||||
error(Enegoff);
|
||||
|
|
@ -841,7 +856,7 @@ sseek(ulong *arg)
|
|||
n = devtab[c->type]->stat(c, buf, sizeof buf);
|
||||
if(convM2D(buf, n, &dir, nil) == 0)
|
||||
error("internal error: stat error in seek");
|
||||
off = dir.length + o.v;
|
||||
off = dir.length + o;
|
||||
if(off < 0)
|
||||
error(Enegoff);
|
||||
c->offset = off;
|
||||
|
|
@ -850,38 +865,41 @@ sseek(ulong *arg)
|
|||
default:
|
||||
error(Ebadarg);
|
||||
}
|
||||
*(vlong*)arg[0] = off;
|
||||
c->uri = 0;
|
||||
c->dri = 0;
|
||||
cclose(c);
|
||||
poperror();
|
||||
return off;
|
||||
}
|
||||
|
||||
long
|
||||
sysseek(ulong *arg)
|
||||
uintptr
|
||||
sysseek(va_list list)
|
||||
{
|
||||
validaddr(arg[0], BY2V, 1);
|
||||
sseek(arg);
|
||||
int fd, t;
|
||||
vlong n, *v;
|
||||
|
||||
v = va_arg(list, vlong*);
|
||||
validaddr((uintptr)v, sizeof(vlong), 1);
|
||||
|
||||
fd = va_arg(list, int);
|
||||
n = va_arg(list, vlong);
|
||||
t = va_arg(list, int);
|
||||
|
||||
*v = sseek(fd, n, t);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
sysoseek(ulong *arg)
|
||||
uintptr
|
||||
sysoseek(va_list list)
|
||||
{
|
||||
union {
|
||||
vlong v;
|
||||
ulong u[2];
|
||||
} o;
|
||||
ulong a[5];
|
||||
int fd, t;
|
||||
long n;
|
||||
|
||||
o.v = (long)arg[1];
|
||||
a[0] = (ulong)&o.v;
|
||||
a[1] = arg[0];
|
||||
a[2] = o.u[0];
|
||||
a[3] = o.u[1];
|
||||
a[4] = arg[2];
|
||||
sseek(a);
|
||||
return o.v;
|
||||
fd = va_arg(list, int);
|
||||
n = va_arg(list, long);
|
||||
t = va_arg(list, int);
|
||||
return (uintptr)sseek(fd, n, t);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -926,58 +944,67 @@ pathlast(Path *p)
|
|||
return p->s;
|
||||
}
|
||||
|
||||
long
|
||||
sysfstat(ulong *arg)
|
||||
uintptr
|
||||
sysfstat(va_list list)
|
||||
{
|
||||
Chan *c;
|
||||
int fd;
|
||||
uint l;
|
||||
uchar *s;
|
||||
|
||||
l = arg[2];
|
||||
validaddr(arg[1], l, 1);
|
||||
c = fdtochan(arg[0], -1, 0, 1);
|
||||
fd = va_arg(list, int);
|
||||
s = va_arg(list, uchar*);
|
||||
l = va_arg(list, uint);
|
||||
validaddr((uintptr)s, l, 1);
|
||||
|
||||
c = fdtochan(fd, -1, 0, 1);
|
||||
if(waserror()) {
|
||||
cclose(c);
|
||||
nexterror();
|
||||
}
|
||||
l = devtab[c->type]->stat(c, (uchar*)arg[1], l);
|
||||
l = devtab[c->type]->stat(c, s, l);
|
||||
poperror();
|
||||
cclose(c);
|
||||
return l;
|
||||
}
|
||||
|
||||
long
|
||||
sysstat(ulong *arg)
|
||||
uintptr
|
||||
sysstat(va_list list)
|
||||
{
|
||||
char *name;
|
||||
Chan *c;
|
||||
uint l;
|
||||
uint l, r;
|
||||
uchar *s;
|
||||
|
||||
l = arg[2];
|
||||
validaddr(arg[1], l, 1);
|
||||
validaddr(arg[0], 1, 0);
|
||||
c = namec((char*)arg[0], Aaccess, 0, 0);
|
||||
name = va_arg(list, char*);
|
||||
s = va_arg(list, uchar*);
|
||||
l = va_arg(list, uint);
|
||||
validaddr((uintptr)s, l, 1);
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
c = namec(name, Aaccess, 0, 0);
|
||||
if(waserror()){
|
||||
cclose(c);
|
||||
nexterror();
|
||||
}
|
||||
l = devtab[c->type]->stat(c, (uchar*)arg[1], l);
|
||||
r = devtab[c->type]->stat(c, s, l);
|
||||
name = pathlast(c->path);
|
||||
if(name)
|
||||
l = dirsetname(name, strlen(name), (uchar*)arg[1], l, arg[2]);
|
||||
r = dirsetname(name, strlen(name), s, r, l);
|
||||
|
||||
poperror();
|
||||
cclose(c);
|
||||
return l;
|
||||
return r;
|
||||
}
|
||||
|
||||
long
|
||||
syschdir(ulong *arg)
|
||||
uintptr
|
||||
syschdir(va_list list)
|
||||
{
|
||||
Chan *c;
|
||||
char *name;
|
||||
|
||||
validaddr(arg[0], 1, 0);
|
||||
|
||||
c = namec((char*)arg[0], Atodir, 0, 0);
|
||||
name = va_arg(list, char*);
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
c = namec(name, Atodir, 0, 0);
|
||||
cclose(up->dot);
|
||||
up->dot = c;
|
||||
return 0;
|
||||
|
|
@ -999,7 +1026,7 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
|
|||
error(Ebadarg);
|
||||
|
||||
if(ismount){
|
||||
validaddr((ulong)spec, 1, 0);
|
||||
validaddr((uintptr)spec, 1, 0);
|
||||
spec = validnamedup(spec, 1);
|
||||
if(waserror()){
|
||||
free(spec);
|
||||
|
|
@ -1033,7 +1060,7 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
|
|||
cclose(bc);
|
||||
}else{
|
||||
spec = 0;
|
||||
validaddr((ulong)arg0, 1, 0);
|
||||
validaddr((uintptr)arg0, 1, 0);
|
||||
c0 = namec(arg0, Abind, 0, 0);
|
||||
}
|
||||
|
||||
|
|
@ -1042,7 +1069,7 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
|
|||
nexterror();
|
||||
}
|
||||
|
||||
validaddr((ulong)arg1, 1, 0);
|
||||
validaddr((uintptr)arg1, 1, 0);
|
||||
c1 = namec(arg1, Amount, 0, 0);
|
||||
if(waserror()){
|
||||
cclose(c1);
|
||||
|
|
@ -1063,33 +1090,59 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
|
|||
return ret;
|
||||
}
|
||||
|
||||
long
|
||||
sysbind(ulong *arg)
|
||||
uintptr
|
||||
sysbind(va_list list)
|
||||
{
|
||||
return bindmount(0, -1, -1, (char*)arg[0], (char*)arg[1], arg[2], nil);
|
||||
char *arg0, *arg1;
|
||||
ulong flag;
|
||||
|
||||
arg0 = va_arg(list, char*);
|
||||
arg1 = va_arg(list, char*);
|
||||
flag = va_arg(list, ulong);
|
||||
return (uintptr)bindmount(0, -1, -1, arg0, arg1, flag, nil);
|
||||
}
|
||||
|
||||
long
|
||||
sysmount(ulong *arg)
|
||||
uintptr
|
||||
sysmount(va_list list)
|
||||
{
|
||||
return bindmount(1, arg[0], arg[1], nil, (char*)arg[2], arg[3], (char*)arg[4]);
|
||||
char *arg1, *spec;
|
||||
ulong flag;
|
||||
int fd, afd;
|
||||
|
||||
fd = va_arg(list, int);
|
||||
afd = va_arg(list, int);
|
||||
arg1 = va_arg(list, char*);
|
||||
flag = va_arg(list, ulong);
|
||||
spec = va_arg(list, char*);
|
||||
return (uintptr)bindmount(1, fd, afd, nil, arg1, flag, spec);
|
||||
}
|
||||
|
||||
long
|
||||
sys_mount(ulong *arg)
|
||||
uintptr
|
||||
sys_mount(va_list list)
|
||||
{
|
||||
return bindmount(1, arg[0], -1, nil, (char*)arg[1], arg[2], (char*)arg[3]);
|
||||
char *arg1, *spec;
|
||||
ulong flag;
|
||||
int fd;
|
||||
|
||||
fd = va_arg(list, int);
|
||||
arg1 = va_arg(list, char*);
|
||||
flag = va_arg(list, ulong);
|
||||
spec = va_arg(list, char*);
|
||||
return (uintptr)bindmount(1, fd, -1, nil, arg1, flag, spec);
|
||||
}
|
||||
|
||||
long
|
||||
sysunmount(ulong *arg)
|
||||
uintptr
|
||||
sysunmount(va_list list)
|
||||
{
|
||||
Chan *cmount, *cmounted;
|
||||
char *name, *old;
|
||||
|
||||
name = va_arg(list, char*);
|
||||
old = va_arg(list, char*);
|
||||
|
||||
cmounted = 0;
|
||||
|
||||
validaddr(arg[1], 1, 0);
|
||||
cmount = namec((char *)arg[1], Amount, 0, 0);
|
||||
validaddr((uintptr)old, 1, 0);
|
||||
cmount = namec(old, Amount, 0, 0);
|
||||
if(waserror()) {
|
||||
cclose(cmount);
|
||||
if(cmounted)
|
||||
|
|
@ -1097,15 +1150,15 @@ sysunmount(ulong *arg)
|
|||
nexterror();
|
||||
}
|
||||
|
||||
if(arg[0]) {
|
||||
if(name) {
|
||||
/*
|
||||
* This has to be namec(..., Aopen, ...) because
|
||||
* if arg[0] is something like /srv/cs or /fd/0,
|
||||
* opening it is the only way to get at the real
|
||||
* Chan underneath.
|
||||
*/
|
||||
validaddr(arg[0], 1, 0);
|
||||
cmounted = namec((char*)arg[0], Aopen, OREAD, 0);
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
cmounted = namec(name, Aopen, OREAD, 0);
|
||||
}
|
||||
cunmount(cmount, cmounted);
|
||||
poperror();
|
||||
|
|
@ -1115,15 +1168,19 @@ sysunmount(ulong *arg)
|
|||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
syscreate(ulong *arg)
|
||||
uintptr
|
||||
syscreate(va_list list)
|
||||
{
|
||||
int fd;
|
||||
int fd, mode, perm;
|
||||
char *name;
|
||||
Chan *c;
|
||||
|
||||
openmode(arg[1]&~OEXCL); /* error check only; OEXCL okay here */
|
||||
validaddr(arg[0], 1, 0);
|
||||
c = namec((char*)arg[0], Acreate, arg[1], arg[2]);
|
||||
name = va_arg(list, char*);
|
||||
mode = va_arg(list, int);
|
||||
perm = va_arg(list, int);
|
||||
openmode(mode&~OEXCL); /* error check only; OEXCL okay here */
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
c = namec(name, Acreate, mode, perm);
|
||||
if(waserror()) {
|
||||
cclose(c);
|
||||
nexterror();
|
||||
|
|
@ -1132,16 +1189,18 @@ syscreate(ulong *arg)
|
|||
if(fd < 0)
|
||||
error(Enofd);
|
||||
poperror();
|
||||
return fd;
|
||||
return (uintptr)fd;
|
||||
}
|
||||
|
||||
long
|
||||
sysremove(ulong *arg)
|
||||
uintptr
|
||||
sysremove(va_list list)
|
||||
{
|
||||
char *name;
|
||||
Chan *c;
|
||||
|
||||
validaddr(arg[0], 1, 0);
|
||||
c = namec((char*)arg[0], Aremove, 0, 0);
|
||||
name = va_arg(list, char*);
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
c = namec(name, Aremove, 0, 0);
|
||||
/*
|
||||
* Removing mount points is disallowed to avoid surprises
|
||||
* (which should be removed: the mount point or the mounted Chan?).
|
||||
|
|
@ -1191,31 +1250,39 @@ wstat(Chan *c, uchar *d, int nd)
|
|||
return l;
|
||||
}
|
||||
|
||||
long
|
||||
syswstat(ulong *arg)
|
||||
uintptr
|
||||
syswstat(va_list list)
|
||||
{
|
||||
char *name;
|
||||
uchar *s;
|
||||
Chan *c;
|
||||
uint l;
|
||||
|
||||
l = arg[2];
|
||||
validaddr(arg[1], l, 0);
|
||||
validstat((uchar*)arg[1], l);
|
||||
validaddr(arg[0], 1, 0);
|
||||
c = namec((char*)arg[0], Aaccess, 0, 0);
|
||||
return wstat(c, (uchar*)arg[1], l);
|
||||
name = va_arg(list, char*);
|
||||
s = va_arg(list, uchar*);
|
||||
l = va_arg(list, uint);
|
||||
validaddr((uintptr)s, l, 0);
|
||||
validstat(s, l);
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
c = namec(name, Aaccess, 0, 0);
|
||||
return (uintptr)wstat(c, s, l);
|
||||
}
|
||||
|
||||
long
|
||||
sysfwstat(ulong *arg)
|
||||
uintptr
|
||||
sysfwstat(va_list list)
|
||||
{
|
||||
uchar *s;
|
||||
Chan *c;
|
||||
uint l;
|
||||
int fd;
|
||||
|
||||
l = arg[2];
|
||||
validaddr(arg[1], l, 0);
|
||||
validstat((uchar*)arg[1], l);
|
||||
c = fdtochan(arg[0], -1, 1, 1);
|
||||
return wstat(c, (uchar*)arg[1], l);
|
||||
fd = va_arg(list, int);
|
||||
s = va_arg(list, uchar*);
|
||||
l = va_arg(list, uint);
|
||||
validaddr((uintptr)s, l, 0);
|
||||
validstat(s, l);
|
||||
c = fdtochan(fd, -1, 1, 1);
|
||||
return (uintptr)wstat(c, s, l);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -1252,19 +1319,21 @@ packoldstat(uchar *buf, Dir *d)
|
|||
PBIT16(p, d->dev);
|
||||
}
|
||||
|
||||
long
|
||||
sys_stat(ulong *arg)
|
||||
uintptr
|
||||
sys_stat(va_list list)
|
||||
{
|
||||
Chan *c;
|
||||
uint l;
|
||||
uchar buf[128]; /* old DIRLEN plus a little should be plenty */
|
||||
uchar *s, buf[128]; /* old DIRLEN plus a little should be plenty */
|
||||
char strs[128], *name;
|
||||
Dir d;
|
||||
char old[] = "old stat system call - recompile";
|
||||
|
||||
validaddr(arg[1], 116, 1);
|
||||
validaddr(arg[0], 1, 0);
|
||||
c = namec((char*)arg[0], Aaccess, 0, 0);
|
||||
name = va_arg(list, char*);
|
||||
s = va_arg(list, uchar*);
|
||||
validaddr((uintptr)s, 116, 1);
|
||||
validaddr((uintptr)name, 1, 0);
|
||||
c = namec(name, Aaccess, 0, 0);
|
||||
if(waserror()){
|
||||
cclose(c);
|
||||
nexterror();
|
||||
|
|
@ -1279,26 +1348,29 @@ sys_stat(ulong *arg)
|
|||
l = convM2D(buf, l, &d, strs);
|
||||
if(l == 0)
|
||||
error(old);
|
||||
packoldstat((uchar*)arg[1], &d);
|
||||
packoldstat(s, &d);
|
||||
|
||||
poperror();
|
||||
cclose(c);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
sys_fstat(ulong *arg)
|
||||
uintptr
|
||||
sys_fstat(va_list list)
|
||||
{
|
||||
Chan *c;
|
||||
char *name;
|
||||
uint l;
|
||||
uchar buf[128]; /* old DIRLEN plus a little should be plenty */
|
||||
uchar *s, buf[128]; /* old DIRLEN plus a little should be plenty */
|
||||
char strs[128];
|
||||
Dir d;
|
||||
char old[] = "old fstat system call - recompile";
|
||||
int fd;
|
||||
|
||||
validaddr(arg[1], 116, 1);
|
||||
c = fdtochan(arg[0], -1, 0, 1);
|
||||
fd = va_arg(list, int);
|
||||
s = va_arg(list, uchar*);
|
||||
validaddr((uintptr)s, 116, 1);
|
||||
c = fdtochan(fd, -1, 0, 1);
|
||||
if(waserror()){
|
||||
cclose(c);
|
||||
nexterror();
|
||||
|
|
@ -1313,23 +1385,23 @@ sys_fstat(ulong *arg)
|
|||
l = convM2D(buf, l, &d, strs);
|
||||
if(l == 0)
|
||||
error(old);
|
||||
packoldstat((uchar*)arg[1], &d);
|
||||
packoldstat(s, &d);
|
||||
|
||||
poperror();
|
||||
cclose(c);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
sys_wstat(ulong *)
|
||||
uintptr
|
||||
sys_wstat(va_list)
|
||||
{
|
||||
error("old wstat system call - recompile");
|
||||
return -1;
|
||||
return (uintptr)-1;
|
||||
}
|
||||
|
||||
long
|
||||
sys_fwstat(ulong *)
|
||||
uintptr
|
||||
sys_fwstat(va_list)
|
||||
{
|
||||
error("old fwstat system call - recompile");
|
||||
return -1;
|
||||
return (uintptr)-1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,8 +14,8 @@ int shargs(char*, int, char**);
|
|||
extern void checkpages(void);
|
||||
extern void checkpagerefs(void);
|
||||
|
||||
long
|
||||
sysr1(ulong*)
|
||||
uintptr
|
||||
sysr1(va_list)
|
||||
{
|
||||
if(!iseve())
|
||||
error(Eperm);
|
||||
|
|
@ -29,8 +29,8 @@ abortion(void*)
|
|||
pexit("fork aborted", 1);
|
||||
}
|
||||
|
||||
long
|
||||
sysrfork(ulong *arg)
|
||||
uintptr
|
||||
sysrfork(va_list list)
|
||||
{
|
||||
Proc *p;
|
||||
int n, i;
|
||||
|
|
@ -41,7 +41,7 @@ sysrfork(ulong *arg)
|
|||
ulong pid, flag;
|
||||
Mach *wm;
|
||||
|
||||
flag = arg[0];
|
||||
flag = va_arg(list, ulong);
|
||||
/* Check flags before we commit */
|
||||
if((flag & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
|
||||
error(Ebadarg);
|
||||
|
|
@ -221,7 +221,7 @@ sysrfork(ulong *arg)
|
|||
procwired(p, wm->machno);
|
||||
ready(p);
|
||||
sched();
|
||||
return pid;
|
||||
return (uintptr)pid;
|
||||
}
|
||||
|
||||
static ulong
|
||||
|
|
@ -233,29 +233,30 @@ l2be(long l)
|
|||
return (cp[0]<<24) | (cp[1]<<16) | (cp[2]<<8) | cp[3];
|
||||
}
|
||||
|
||||
long
|
||||
sysexec(ulong *arg)
|
||||
uintptr
|
||||
sysexec(va_list list)
|
||||
{
|
||||
Segment *s, *ts;
|
||||
ulong t, d, b;
|
||||
int i;
|
||||
Chan *tc;
|
||||
char **argv, **argp;
|
||||
char **argv, **argp, **argp0;
|
||||
char *a, *charp, *args, *file, *file0;
|
||||
char *progarg[sizeof(Exec)/2+1], *elem, progelem[64];
|
||||
ulong ssize, tstk, nargs, nbytes, n, bssend;
|
||||
ulong magic, ssize, nargs, nbytes, n;
|
||||
uintptr t, d, b, entry, bssend, text, data, bss, tstk;
|
||||
int indir;
|
||||
Exec exec;
|
||||
char line[sizeof(Exec)];
|
||||
Fgrp *f;
|
||||
Image *img;
|
||||
ulong magic, text, entry, data, bss;
|
||||
Tos *tos;
|
||||
|
||||
a = nil;
|
||||
elem = nil;
|
||||
validaddr(arg[0], 1, 0);
|
||||
file0 = validnamedup((char*)arg[0], 1);
|
||||
file0 = va_arg(list, char*);
|
||||
validaddr((uintptr)file0, 1, 0);
|
||||
argp0 = va_arg(list, char**);
|
||||
file0 = validnamedup(file0, 1);
|
||||
if(waserror()){
|
||||
free(file0);
|
||||
free(elem);
|
||||
|
|
@ -305,8 +306,7 @@ sysexec(ulong *arg)
|
|||
*/
|
||||
progarg[n++] = file;
|
||||
progarg[n] = 0;
|
||||
validaddr(arg[1], BY2WD, 1);
|
||||
arg[1] += BY2WD;
|
||||
argp0++;
|
||||
file = progarg[0];
|
||||
if(strlen(elem) >= sizeof progelem)
|
||||
error(Ebadexec);
|
||||
|
|
@ -338,14 +338,14 @@ sysexec(ulong *arg)
|
|||
nargs++;
|
||||
}
|
||||
}
|
||||
evenaddr(arg[1]);
|
||||
argp = (char**)arg[1];
|
||||
validaddr((ulong)argp, BY2WD, 0);
|
||||
argp = argp0;
|
||||
evenaddr((uintptr)argp);
|
||||
validaddr((uintptr)argp, BY2WD, 0);
|
||||
while(*argp){
|
||||
a = *argp++;
|
||||
if(((ulong)argp&(BY2PG-1)) < BY2WD)
|
||||
validaddr((ulong)argp, BY2WD, 0);
|
||||
validaddr((ulong)a, 1, 0);
|
||||
if(((uintptr)argp&(BY2PG-1)) < BY2WD)
|
||||
validaddr((uintptr)argp, BY2WD, 0);
|
||||
validaddr((uintptr)a, 1, 0);
|
||||
nbytes += ((char*)vmemchr(a, 0, 0x7FFFFFFF) - a) + 1;
|
||||
nargs++;
|
||||
}
|
||||
|
|
@ -393,12 +393,12 @@ sysexec(ulong *arg)
|
|||
if(indir)
|
||||
argp = progarg;
|
||||
else
|
||||
argp = (char**)arg[1];
|
||||
argp = argp0;
|
||||
|
||||
for(i=0; i<nargs; i++){
|
||||
if(indir && *argp==0) {
|
||||
indir = 0;
|
||||
argp = (char**)arg[1];
|
||||
argp = argp0;
|
||||
}
|
||||
*argv++ = charp + (USTKTOP-tstk);
|
||||
n = strlen(*argp) + 1;
|
||||
|
|
@ -557,45 +557,45 @@ return0(void*)
|
|||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
syssleep(ulong *arg)
|
||||
uintptr
|
||||
syssleep(va_list list)
|
||||
{
|
||||
long ms;
|
||||
|
||||
int n;
|
||||
|
||||
n = arg[0];
|
||||
if(n <= 0) {
|
||||
ms = va_arg(list, long);
|
||||
if(ms <= 0) {
|
||||
if (up->edf && (up->edf->flags & Admitted))
|
||||
edfyield();
|
||||
else
|
||||
yield();
|
||||
return 0;
|
||||
} else {
|
||||
if(ms < TK2MS(1))
|
||||
ms = TK2MS(1);
|
||||
tsleep(&up->sleep, return0, 0, ms);
|
||||
}
|
||||
if(n < TK2MS(1))
|
||||
n = TK2MS(1);
|
||||
tsleep(&up->sleep, return0, 0, n);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
sysalarm(ulong *arg)
|
||||
uintptr
|
||||
sysalarm(va_list list)
|
||||
{
|
||||
return procalarm(arg[0]);
|
||||
return (uintptr)procalarm(va_arg(list, ulong));
|
||||
}
|
||||
|
||||
long
|
||||
sysexits(ulong *arg)
|
||||
|
||||
uintptr
|
||||
sysexits(va_list list)
|
||||
{
|
||||
char *status;
|
||||
char *inval = "invalid exit string";
|
||||
char buf[ERRMAX];
|
||||
|
||||
status = (char*)arg[0];
|
||||
status = va_arg(list, char*);
|
||||
if(status){
|
||||
if(waserror())
|
||||
status = inval;
|
||||
else{
|
||||
validaddr((ulong)status, 1, 0);
|
||||
validaddr((uintptr)status, 1, 0);
|
||||
if(vmemchr(status, 0, ERRMAX) == 0){
|
||||
memmove(buf, status, ERRMAX);
|
||||
buf[ERRMAX-1] = 0;
|
||||
|
|
@ -606,53 +606,57 @@ sysexits(ulong *arg)
|
|||
|
||||
}
|
||||
pexit(status, 1);
|
||||
return 0; /* not reached */
|
||||
return 0; /* not reached */
|
||||
}
|
||||
|
||||
long
|
||||
sys_wait(ulong *arg)
|
||||
uintptr
|
||||
sys_wait(va_list list)
|
||||
{
|
||||
int pid;
|
||||
Waitmsg w;
|
||||
OWaitmsg *ow;
|
||||
|
||||
if(arg[0] == 0)
|
||||
return pwait(nil);
|
||||
|
||||
validaddr(arg[0], sizeof(OWaitmsg), 1);
|
||||
evenaddr(arg[0]);
|
||||
pid = pwait(&w);
|
||||
if(pid >= 0){
|
||||
ow = (OWaitmsg*)arg[0];
|
||||
readnum(0, ow->pid, NUMSIZE, w.pid, NUMSIZE);
|
||||
readnum(0, ow->time+TUser*NUMSIZE, NUMSIZE, w.time[TUser], NUMSIZE);
|
||||
readnum(0, ow->time+TSys*NUMSIZE, NUMSIZE, w.time[TSys], NUMSIZE);
|
||||
readnum(0, ow->time+TReal*NUMSIZE, NUMSIZE, w.time[TReal], NUMSIZE);
|
||||
strncpy(ow->msg, w.msg, sizeof(ow->msg)-1);
|
||||
ow->msg[sizeof(ow->msg)-1] = '\0';
|
||||
ow = va_arg(list, OWaitmsg*);
|
||||
if(ow == 0)
|
||||
pid = pwait(nil);
|
||||
else {
|
||||
validaddr((uintptr)ow, sizeof(OWaitmsg), 1);
|
||||
evenaddr((uintptr)ow);
|
||||
pid = pwait(&w);
|
||||
if(pid >= 0){
|
||||
readnum(0, ow->pid, NUMSIZE, w.pid, NUMSIZE);
|
||||
readnum(0, ow->time+TUser*NUMSIZE, NUMSIZE, w.time[TUser], NUMSIZE);
|
||||
readnum(0, ow->time+TSys*NUMSIZE, NUMSIZE, w.time[TSys], NUMSIZE);
|
||||
readnum(0, ow->time+TReal*NUMSIZE, NUMSIZE, w.time[TReal], NUMSIZE);
|
||||
strncpy(ow->msg, w.msg, sizeof(ow->msg)-1);
|
||||
ow->msg[sizeof(ow->msg)-1] = '\0';
|
||||
}
|
||||
}
|
||||
return pid;
|
||||
return (uintptr)pid;
|
||||
}
|
||||
|
||||
long
|
||||
sysawait(ulong *arg)
|
||||
uintptr
|
||||
sysawait(va_list list)
|
||||
{
|
||||
int i;
|
||||
int pid;
|
||||
char *p;
|
||||
Waitmsg w;
|
||||
ulong n;
|
||||
uint n;
|
||||
|
||||
n = arg[1];
|
||||
validaddr(arg[0], n, 1);
|
||||
p = va_arg(list, char*);
|
||||
n = va_arg(list, uint);
|
||||
validaddr((uintptr)p, n, 1);
|
||||
pid = pwait(&w);
|
||||
if(pid < 0)
|
||||
return -1;
|
||||
i = snprint((char*)arg[0], n, "%d %lud %lud %lud %q",
|
||||
w.pid,
|
||||
w.time[TUser], w.time[TSys], w.time[TReal],
|
||||
w.msg);
|
||||
|
||||
return i;
|
||||
i = -1;
|
||||
else {
|
||||
i = snprint(p, n, "%d %lud %lud %lud %q",
|
||||
w.pid,
|
||||
w.time[TUser], w.time[TSys], w.time[TReal],
|
||||
w.msg);
|
||||
}
|
||||
return (uintptr)i;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -668,14 +672,14 @@ werrstr(char *fmt, ...)
|
|||
va_end(va);
|
||||
}
|
||||
|
||||
static long
|
||||
static int
|
||||
generrstr(char *buf, uint nbuf)
|
||||
{
|
||||
char tmp[ERRMAX];
|
||||
|
||||
if(nbuf == 0)
|
||||
error(Ebadarg);
|
||||
validaddr((ulong)buf, nbuf, 1);
|
||||
validaddr((uintptr)buf, nbuf, 1);
|
||||
if(nbuf > sizeof tmp)
|
||||
nbuf = sizeof tmp;
|
||||
memmove(tmp, buf, nbuf);
|
||||
|
|
@ -688,44 +692,51 @@ generrstr(char *buf, uint nbuf)
|
|||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
syserrstr(ulong *arg)
|
||||
uintptr
|
||||
syserrstr(va_list list)
|
||||
{
|
||||
return generrstr((char*)arg[0], arg[1]);
|
||||
char *buf;
|
||||
uint len;
|
||||
|
||||
buf = va_arg(list, char*);
|
||||
len = va_arg(list, uint);
|
||||
return (uintptr)generrstr(buf, len);
|
||||
}
|
||||
|
||||
/* compatibility for old binaries */
|
||||
long
|
||||
sys_errstr(ulong *arg)
|
||||
uintptr
|
||||
sys_errstr(va_list list)
|
||||
{
|
||||
return generrstr((char*)arg[0], 64);
|
||||
return (uintptr)generrstr(va_arg(list, char*), 64);
|
||||
}
|
||||
|
||||
long
|
||||
sysnotify(ulong *arg)
|
||||
uintptr
|
||||
sysnotify(va_list list)
|
||||
{
|
||||
if(arg[0] != 0)
|
||||
validaddr(arg[0], sizeof(ulong), 0);
|
||||
up->notify = (int(*)(void*, char*))(arg[0]);
|
||||
int (*f)(void*, char*);
|
||||
f = va_arg(list, void*);
|
||||
if(f != 0)
|
||||
validaddr((uintptr)f, sizeof(void*), 0);
|
||||
up->notify = f;
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
sysnoted(ulong *arg)
|
||||
uintptr
|
||||
sysnoted(va_list list)
|
||||
{
|
||||
if(arg[0]!=NRSTR && !up->notified)
|
||||
if(va_arg(list, int) !=NRSTR && !up->notified)
|
||||
error(Egreg);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
syssegbrk(ulong *arg)
|
||||
uintptr
|
||||
syssegbrk(va_list list)
|
||||
{
|
||||
int i;
|
||||
ulong addr;
|
||||
uintptr addr;
|
||||
Segment *s;
|
||||
|
||||
addr = arg[0];
|
||||
addr = va_arg(list, uintptr);
|
||||
for(i = 0; i < NSEG; i++) {
|
||||
s = up->seg[i];
|
||||
if(s == 0 || addr < s->base || addr >= s->top)
|
||||
|
|
@ -736,27 +747,37 @@ syssegbrk(ulong *arg)
|
|||
case SG_STACK:
|
||||
error(Ebadarg);
|
||||
default:
|
||||
return ibrk(arg[1], i);
|
||||
return (uintptr)ibrk(va_arg(list, uintptr), i);
|
||||
}
|
||||
}
|
||||
|
||||
error(Ebadarg);
|
||||
return 0; /* not reached */
|
||||
return 0; /* not reached */
|
||||
}
|
||||
|
||||
long
|
||||
syssegattach(ulong *arg)
|
||||
uintptr
|
||||
syssegattach(va_list list)
|
||||
{
|
||||
return segattach(up, arg[0], (char*)arg[1], arg[2], arg[3]);
|
||||
ulong attr;
|
||||
char *name;
|
||||
uintptr va;
|
||||
ulong len;
|
||||
|
||||
attr = va_arg(list, ulong);
|
||||
name = va_arg(list, char*);
|
||||
va = va_arg(list, uintptr);
|
||||
len = va_arg(list, ulong);
|
||||
return segattach(up, attr, name, va, len);
|
||||
}
|
||||
|
||||
long
|
||||
syssegdetach(ulong *arg)
|
||||
uintptr
|
||||
syssegdetach(va_list list)
|
||||
{
|
||||
int i;
|
||||
ulong addr;
|
||||
uintptr addr;
|
||||
Segment *s;
|
||||
|
||||
addr = va_arg(list, uintptr);
|
||||
|
||||
qlock(&up->seglock);
|
||||
if(waserror()){
|
||||
qunlock(&up->seglock);
|
||||
|
|
@ -764,7 +785,6 @@ syssegdetach(ulong *arg)
|
|||
}
|
||||
|
||||
s = 0;
|
||||
addr = arg[0];
|
||||
for(i = 0; i < NSEG; i++)
|
||||
if(s = up->seg[i]) {
|
||||
qlock(&s->lk);
|
||||
|
|
@ -795,17 +815,19 @@ found:
|
|||
return 0;
|
||||
}
|
||||
|
||||
long
|
||||
syssegfree(ulong *arg)
|
||||
uintptr
|
||||
syssegfree(va_list list)
|
||||
{
|
||||
Segment *s;
|
||||
ulong from, to;
|
||||
uintptr from, to;
|
||||
|
||||
from = arg[0];
|
||||
from = va_arg(list, uintptr);
|
||||
s = seg(up, from, 1);
|
||||
if(s == nil)
|
||||
error(Ebadarg);
|
||||
to = (from + arg[1]) & ~(BY2PG-1);
|
||||
to = va_arg(list, ulong);
|
||||
to += from;
|
||||
to &= ~(BY2PG-1);
|
||||
from = PGROUND(from);
|
||||
|
||||
if(to > s->top) {
|
||||
|
|
@ -816,24 +838,24 @@ syssegfree(ulong *arg)
|
|||
mfreeseg(s, from, (to - from) / BY2PG);
|
||||
qunlock(&s->lk);
|
||||
flushmmu();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* For binary compatibility */
|
||||
long
|
||||
sysbrk_(ulong *arg)
|
||||
uintptr
|
||||
sysbrk_(va_list list)
|
||||
{
|
||||
return ibrk(arg[0], BSEG);
|
||||
return (uintptr)ibrk(va_arg(list, uintptr), BSEG);
|
||||
}
|
||||
|
||||
long
|
||||
sysrendezvous(ulong *arg)
|
||||
uintptr
|
||||
sysrendezvous(va_list list)
|
||||
{
|
||||
uintptr tag, val;
|
||||
uintptr tag, val, new;
|
||||
Proc *p, **l;
|
||||
|
||||
tag = arg[0];
|
||||
tag = va_arg(list, uintptr);
|
||||
new = va_arg(list, uintptr);
|
||||
l = &REND(up->rgrp, tag);
|
||||
|
||||
lock(up->rgrp);
|
||||
|
|
@ -841,7 +863,7 @@ sysrendezvous(ulong *arg)
|
|||
if(p->rendtag == tag) {
|
||||
*l = p->rendhash;
|
||||
val = p->rendval;
|
||||
p->rendval = arg[1];
|
||||
p->rendval = new;
|
||||
unlock(up->rgrp);
|
||||
|
||||
ready(p);
|
||||
|
|
@ -853,7 +875,7 @@ sysrendezvous(ulong *arg)
|
|||
|
||||
/* Going to sleep here */
|
||||
up->rendtag = tag;
|
||||
up->rendval = arg[1];
|
||||
up->rendval = new;
|
||||
up->rendhash = *l;
|
||||
*l = up;
|
||||
up->state = Rendezvous;
|
||||
|
|
@ -1102,65 +1124,62 @@ tsemacquire(Segment *s, long *addr, ulong ms)
|
|||
return 1;
|
||||
}
|
||||
|
||||
long
|
||||
syssemacquire(ulong *arg)
|
||||
uintptr
|
||||
syssemacquire(va_list list)
|
||||
{
|
||||
int block;
|
||||
long *addr;
|
||||
Segment *s;
|
||||
|
||||
evenaddr(arg[0]);
|
||||
addr = (long*)arg[0];
|
||||
block = arg[1];
|
||||
|
||||
s = seg(up, (ulong)addr, 0);
|
||||
if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){
|
||||
validaddr((ulong)addr, sizeof(long), 1);
|
||||
addr = va_arg(list, long*);
|
||||
block = va_arg(list, int);
|
||||
evenaddr((uintptr)addr);
|
||||
s = seg(up, (uintptr)addr, 0);
|
||||
if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
|
||||
validaddr((uintptr)addr, sizeof(long), 1);
|
||||
error(Ebadarg);
|
||||
}
|
||||
if(*addr < 0)
|
||||
error(Ebadarg);
|
||||
return semacquire(s, addr, block);
|
||||
return (uintptr)semacquire(s, addr, block);
|
||||
}
|
||||
|
||||
long
|
||||
systsemacquire(ulong *arg)
|
||||
uintptr
|
||||
systsemacquire(va_list list)
|
||||
{
|
||||
long *addr;
|
||||
ulong ms;
|
||||
Segment *s;
|
||||
|
||||
evenaddr(arg[0]);
|
||||
addr = (long*)arg[0];
|
||||
ms = arg[1];
|
||||
|
||||
s = seg(up, (ulong)addr, 0);
|
||||
if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){
|
||||
validaddr((ulong)addr, sizeof(long), 1);
|
||||
addr = va_arg(list, long*);
|
||||
ms = va_arg(list, ulong);
|
||||
evenaddr((uintptr)addr);
|
||||
s = seg(up, (uintptr)addr, 0);
|
||||
if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
|
||||
validaddr((uintptr)addr, sizeof(long), 1);
|
||||
error(Ebadarg);
|
||||
}
|
||||
if(*addr < 0)
|
||||
error(Ebadarg);
|
||||
return tsemacquire(s, addr, ms);
|
||||
return (uintptr)tsemacquire(s, addr, ms);
|
||||
}
|
||||
|
||||
long
|
||||
syssemrelease(ulong *arg)
|
||||
uintptr
|
||||
syssemrelease(va_list list)
|
||||
{
|
||||
long *addr, delta;
|
||||
Segment *s;
|
||||
|
||||
evenaddr(arg[0]);
|
||||
addr = (long*)arg[0];
|
||||
delta = arg[1];
|
||||
|
||||
s = seg(up, (ulong)addr, 0);
|
||||
if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){
|
||||
validaddr((ulong)addr, sizeof(long), 1);
|
||||
addr = va_arg(list, long*);
|
||||
delta = va_arg(list, long);
|
||||
evenaddr((uintptr)addr);
|
||||
s = seg(up, (uintptr)addr, 0);
|
||||
if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
|
||||
validaddr((uintptr)addr, sizeof(long), 1);
|
||||
error(Ebadarg);
|
||||
}
|
||||
/* delta == 0 is a no-op, not a release */
|
||||
if(delta < 0 || *addr < 0)
|
||||
error(Ebadarg);
|
||||
return semrelease(s, addr, delta);
|
||||
return (uintptr)semrelease(s, addr, delta);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#include "/sys/src/libc/9syscall/sys.h"
|
||||
|
||||
typedef long Syscall(ulong*);
|
||||
typedef uintptr Syscall(va_list);
|
||||
|
||||
Syscall sysr1;
|
||||
Syscall sys_errstr;
|
||||
|
|
|
|||
|
|
@ -51,12 +51,12 @@ dumplockmem(char *tag, Lock *l)
|
|||
}
|
||||
|
||||
void
|
||||
lockloop(Lock *l, ulong pc)
|
||||
lockloop(Lock *l, uintptr pc)
|
||||
{
|
||||
Proc *p;
|
||||
|
||||
p = l->p;
|
||||
print("lock %#p loop key %#lux pc %#lux held by pc %#lux proc %lud\n",
|
||||
print("lock %#p loop key %#lux pc %#p held by pc %#p proc %lud\n",
|
||||
l, l->key, pc, l->pc, p ? p->pid : 0);
|
||||
dumpaproc(up);
|
||||
if(p != nil)
|
||||
|
|
@ -67,7 +67,7 @@ int
|
|||
lock(Lock *l)
|
||||
{
|
||||
int i;
|
||||
ulong pc;
|
||||
uintptr pc;
|
||||
|
||||
pc = getcallerpc(&l);
|
||||
|
||||
|
|
@ -98,7 +98,7 @@ lock(Lock *l)
|
|||
* Priority inversion, yield on a uniprocessor; on a
|
||||
* multiprocessor, the other processor will unlock
|
||||
*/
|
||||
print("inversion %#p pc %#lux proc %lud held by pc %#lux proc %lud\n",
|
||||
print("inversion %#p pc %#p proc %lud held by pc %#p proc %lud\n",
|
||||
l, pc, up ? up->pid : 0, l->pc, l->p ? l->p->pid : 0);
|
||||
up->edf->d = todget(nil); /* yield to process with lock */
|
||||
}
|
||||
|
|
@ -129,7 +129,7 @@ void
|
|||
ilock(Lock *l)
|
||||
{
|
||||
ulong x;
|
||||
ulong pc;
|
||||
uintptr pc;
|
||||
|
||||
pc = getcallerpc(&l);
|
||||
lockstats.locks++;
|
||||
|
|
@ -203,9 +203,9 @@ unlock(Lock *l)
|
|||
if(l->key == 0)
|
||||
print("unlock: not locked: pc %#p\n", getcallerpc(&l));
|
||||
if(l->isilock)
|
||||
print("unlock of ilock: pc %lux, held by %lux\n", getcallerpc(&l), l->pc);
|
||||
print("unlock of ilock: pc %#p, held by %#p\n", getcallerpc(&l), l->pc);
|
||||
if(l->p != up)
|
||||
print("unlock: up changed: pc %#p, acquired at pc %lux, lock p %#p, unlock up %#p\n", getcallerpc(&l), l->pc, l->p, up);
|
||||
print("unlock: up changed: pc %#p, acquired at pc %#p, lock p %#p, unlock up %#p\n", getcallerpc(&l), l->pc, l->p, up);
|
||||
l->m = nil;
|
||||
l->key = 0;
|
||||
coherence();
|
||||
|
|
@ -240,9 +240,9 @@ iunlock(Lock *l)
|
|||
if(l->key == 0)
|
||||
print("iunlock: not locked: pc %#p\n", getcallerpc(&l));
|
||||
if(!l->isilock)
|
||||
print("iunlock of lock: pc %#p, held by %#lux\n", getcallerpc(&l), l->pc);
|
||||
print("iunlock of lock: pc %#p, held by %#p\n", getcallerpc(&l), l->pc);
|
||||
if(islo())
|
||||
print("iunlock while lo: pc %#p, held by %#lux\n", getcallerpc(&l), l->pc);
|
||||
print("iunlock while lo: pc %#p, held by %#p\n", getcallerpc(&l), l->pc);
|
||||
|
||||
sr = l->sr;
|
||||
l->m = nil;
|
||||
|
|
|
|||
|
|
@ -262,7 +262,7 @@ putmmu(ulong va, ulong pa, Page *pg)
|
|||
}
|
||||
|
||||
void
|
||||
checkmmu(ulong, ulong)
|
||||
checkmmu(uintptr, uintptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -525,8 +525,8 @@ evenaddr(ulong addr)
|
|||
}
|
||||
}
|
||||
|
||||
long
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
ulong *sp;
|
||||
Ureg *ureg;
|
||||
|
|
@ -559,7 +559,7 @@ forkchild(Proc *p, Ureg *ur)
|
|||
p->insyscall = 0;
|
||||
}
|
||||
|
||||
ulong
|
||||
uintptr
|
||||
userpc(void)
|
||||
{
|
||||
Ureg *ureg;
|
||||
|
|
@ -593,7 +593,7 @@ setkernur(Ureg* ureg, Proc* p)
|
|||
ureg->sp = p->sched.sp+4;
|
||||
}
|
||||
|
||||
ulong
|
||||
uintptr
|
||||
dbgpc(Proc *p)
|
||||
{
|
||||
Ureg *ureg;
|
||||
|
|
@ -651,7 +651,7 @@ syscall(Ureg* ureg)
|
|||
up->s = *((Sargs*)(sp+BY2WD));
|
||||
up->psstate = sysctab[scallnr];
|
||||
|
||||
ret = systab[scallnr](up->s.args);
|
||||
ret = systab[scallnr]((va_list)up->s.args);
|
||||
poperror();
|
||||
}else{
|
||||
/* failure: save the error buffer for errstr */
|
||||
|
|
|
|||
|
|
@ -248,7 +248,7 @@ syscall(Ureg* ureg)
|
|||
|
||||
/* iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
|
||||
|
||||
ret = systab[scallnr](up->s.args);
|
||||
ret = systab[scallnr]((va_list)up->s.args);
|
||||
poperror();
|
||||
}else{
|
||||
/* failure: save the error buffer for errstr */
|
||||
|
|
@ -304,8 +304,8 @@ syscall(Ureg* ureg)
|
|||
kexit(ureg);
|
||||
}
|
||||
|
||||
long
|
||||
execregs(ulong entry, ulong ssize, ulong nargs)
|
||||
uintptr
|
||||
execregs(uintptr entry, ulong ssize, ulong nargs)
|
||||
{
|
||||
ulong *sp;
|
||||
Ureg *ureg;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue