xfnw/plan9fox
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

kernel: apply uintptr for ulong when a pointer is stored

Browse source 
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 2014-01-20 00:47:55 +01:00
parent b99ecee6cd
commit 6c2e983d32
34 changed files with 656 additions and 552 deletions
Download patch file Download diff file Expand all files Collapse all files

2
sys/src/9/alphapc/mmu.c
View file

@ -274,7 +274,7 @@ upafree(ulong, int)
} }
void void
checkmmu(ulong, ulong) checkmmu(uintptr, uintptr)
{ {
} }

10
sys/src/9/alphapc/trap.c
View file

@ -728,7 +728,7 @@ syscall(Ureg *aur)
up->s = *((Sargs*)(sp+2*BY2WD)); up->s = *((Sargs*)(sp+2*BY2WD));
up->psstate = sysctab[scallnr]; up->psstate = sysctab[scallnr];
ret = systab[scallnr](up->s.args); ret = systab[scallnr]((va_list)up->s.args);
poperror(); poperror();
}else{ }else{
/* failure: save the error buffer for errstr */ /* failure: save the error buffer for errstr */
@ -794,8 +794,8 @@ kprocchild(Proc *p, void (*func)(void*), void *arg)
p->kparg = arg; p->kparg = arg;
} }
long uintptr
execregs(ulong entry, ulong ssize, ulong nargs) execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
Ureg *ur; Ureg *ur;
ulong *sp; ulong *sp;
@ -809,7 +809,7 @@ execregs(ulong entry, ulong ssize, ulong nargs)
return USTKTOP-BY2WD; /* address of user-level clock */ return USTKTOP-BY2WD; /* address of user-level clock */
} }
ulong uintptr
userpc(void) userpc(void)
{ {
Ureg *ur; Ureg *ur;
@ -842,7 +842,7 @@ setkernur(Ureg *xp, Proc *p)
xp->r26 = (ulong)sched; xp->r26 = (ulong)sched;
} }
ulong uintptr
dbgpc(Proc *p) dbgpc(Proc *p)
{ {
Ureg *ur; Ureg *ur;

2
sys/src/9/bitsy/mmu.c
View file

@ -523,7 +523,7 @@ peekmmu(ulong va)
} }
void void
checkmmu(ulong, ulong) checkmmu(uintptr, uintptr)
{ {
} }

10
sys/src/9/bitsy/trap.c
View file

@ -557,7 +557,7 @@ syscall(Ureg* ureg)
up->s = *((Sargs*)(sp+BY2WD)); up->s = *((Sargs*)(sp+BY2WD));
up->psstate = sysctab[scallnr]; up->psstate = sysctab[scallnr];
ret = systab[scallnr](up->s.args); ret = systab[scallnr]((va_list)up->s.args);
poperror(); poperror();
}else{ }else{
/* failure: save the error buffer for errstr */ /* failure: save the error buffer for errstr */
@ -757,7 +757,7 @@ setkernur(Ureg *ureg, Proc *p)
/* /*
* return the userpc the last exception happened at * return the userpc the last exception happened at
*/ */
ulong uintptr
userpc(void) userpc(void)
{ {
Ureg *ureg; 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. * setup stack, initial PC, and any arch dependent regs for an execing user proc.
*/ */
long uintptr
execregs(ulong entry, ulong ssize, ulong nargs) execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
ulong *sp; ulong *sp;
Ureg *ureg; Ureg *ureg;
@ -901,7 +901,7 @@ dumpstack(void)
/* /*
* pc output by ps * pc output by ps
*/ */
ulong uintptr
dbgpc(Proc *p) dbgpc(Proc *p)
{ {
Ureg *ureg; Ureg *ureg;

2
sys/src/9/boot/boot.c
View file

@ -30,7 +30,7 @@ boot(int argc, char *argv[])
print("argc=%d\n", argc); print("argc=%d\n", argc);
for(i = 0; i < argc; i++) for(i = 0; i < argc; i++)
print("%lux %s ", (ulong)argv[i], argv[i]); print("%p %s ", argv[i], argv[i]);
print("\n"); print("\n");
} }
USED(argc); USED(argc);

6
sys/src/9/kw/syscall.c
View file

@ -224,7 +224,7 @@ syscall(Ureg* ureg)
/* iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */ /* 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(); poperror();
}else{ }else{
/* failure: save the error buffer for errstr */ /* failure: save the error buffer for errstr */
@ -275,8 +275,8 @@ syscall(Ureg* ureg)
kexit(ureg); kexit(ureg);
} }
long uintptr
execregs(ulong entry, ulong ssize, ulong nargs) execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
ulong *sp; ulong *sp;
Ureg *ureg; Ureg *ureg;

2
sys/src/9/mtx/mmu.c
View file

@ -235,7 +235,7 @@ putmmu(ulong va, ulong pa, Page *pg)
} }
void void
checkmmu(ulong, ulong) checkmmu(uintptr, uintptr)
{ {
} }

8
sys/src/9/mtx/trap.c
View file

@ -533,8 +533,8 @@ evenaddr(ulong addr)
} }
} }
long uintptr
execregs(ulong entry, ulong ssize, ulong nargs) execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
ulong *sp; ulong *sp;
Ureg *ureg; Ureg *ureg;
@ -566,7 +566,7 @@ forkchild(Proc *p, Ureg *ur)
p->insyscall = 0; p->insyscall = 0;
} }
ulong uintptr
userpc(void) userpc(void)
{ {
Ureg *ureg; Ureg *ureg;
@ -600,7 +600,7 @@ setkernur(Ureg* ureg, Proc* p)
ureg->sp = p->sched.sp+4; ureg->sp = p->sched.sp+4;
} }
ulong uintptr
dbgpc(Proc *p) dbgpc(Proc *p)
{ {
Ureg *ureg; Ureg *ureg;

7
sys/src/9/omap/syscall.c
View file

@ -222,7 +222,7 @@ syscall(Ureg* ureg)
/* iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */ /* 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(); poperror();
}else{ }else{
/* failure: save the error buffer for errstr */ /* failure: save the error buffer for errstr */
@ -271,8 +271,9 @@ syscall(Ureg* ureg)
kexit(ureg); kexit(ureg);
} }
long /* void* */
execregs(ulong entry, ulong ssize, ulong nargs) uintptr
execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
ulong *sp; ulong *sp;
Ureg *ureg; Ureg *ureg;

8
sys/src/9/omap4/arch.c
View file

@ -11,13 +11,13 @@
void (*proctrace)(Proc *, int, vlong); void (*proctrace)(Proc *, int, vlong);
ulong uintptr
userpc(void) userpc(void)
{ {
return dbgpc(up); return dbgpc(up);
} }
ulong uintptr
dbgpc(Proc *p) dbgpc(Proc *p)
{ {
Ureg *ureg; Ureg *ureg;
@ -101,8 +101,8 @@ forkchild(Proc *p, Ureg *ureg)
p->insyscall = 0; p->insyscall = 0;
} }
long uintptr
execregs(ulong entry, ulong ssize, ulong nargs) execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
ulong *sp; ulong *sp;
Ureg *ureg; Ureg *ureg;

2
sys/src/9/pc/dat.h
View file

@ -38,7 +38,7 @@ struct Lock
{ {
ulong key; ulong key;
ulong sr; ulong sr;
ulong pc; uintptr pc;
Proc *p; Proc *p;
Mach *m; Mach *m;
ushort isilock; ushort isilock;

4
sys/src/9/pc/mmu.c
View file

@ -475,14 +475,14 @@ putmmu(ulong va, ulong pa, Page*)
* Error checking only. * Error checking only.
*/ */
void void
checkmmu(ulong va, ulong pa) checkmmu(uintptr va, uintptr pa)
{ {
if(up->mmupdb == 0) if(up->mmupdb == 0)
return; return;
if(!(vpd[PDX(va)]&PTEVALID) || !(vpt[VPTX(va)]&PTEVALID)) if(!(vpd[PDX(va)]&PTEVALID) || !(vpt[VPTX(va)]&PTEVALID))
return; return;
if(PPN(vpt[VPTX(va)]) != pa) 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, up->pid, up->text,
va, pa, vpt[VPTX(va)]); va, pa, vpt[VPTX(va)]);
} }

9
sys/src/9/pc/trap.c
View file

@ -760,8 +760,7 @@ syscall(Ureg* ureg)
error(Ebadarg); error(Ebadarg);
} }
up->psstate = sysctab[scallnr]; up->psstate = sysctab[scallnr];
ret = systab[scallnr]((va_list)up->s.args);
ret = systab[scallnr](up->s.args);
poperror(); poperror();
}else{ }else{
/* failure: save the error buffer for errstr */ /* failure: save the error buffer for errstr */
@ -975,8 +974,8 @@ if(0) print("%s %lud: noted %.8lux %.8lux\n",
} }
} }
long uintptr
execregs(ulong entry, ulong ssize, ulong nargs) execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
ulong *sp; ulong *sp;
Ureg *ureg; Ureg *ureg;
@ -996,7 +995,7 @@ execregs(ulong entry, ulong ssize, ulong nargs)
/* /*
* return the userpc the last exception happened at * return the userpc the last exception happened at
*/ */
ulong uintptr
userpc(void) userpc(void)
{ {
Ureg *ureg; Ureg *ureg;

6
sys/src/9/port/allocb.c
View file

@ -21,7 +21,7 @@ static Block*
_allocb(int size) _allocb(int size)
{ {
Block *b; Block *b;
ulong addr; uintptr addr;
if((b = mallocz(sizeof(Block)+size+Hdrspc, 0)) == nil) if((b = mallocz(sizeof(Block)+size+Hdrspc, 0)) == nil)
return nil; return nil;
@ -34,13 +34,13 @@ _allocb(int size)
_xinc(&b->ref); _xinc(&b->ref);
/* align start of data portion by rounding up */ /* align start of data portion by rounding up */
addr = (ulong)b; addr = (uintptr)b;
addr = ROUND(addr + sizeof(Block), BLOCKALIGN); addr = ROUND(addr + sizeof(Block), BLOCKALIGN);
b->base = (uchar*)addr; b->base = (uchar*)addr;
/* align end of data portion by rounding down */ /* align end of data portion by rounding down */
b->lim = ((uchar*)b) + msize(b); b->lim = ((uchar*)b) + msize(b);
addr = (ulong)(b->lim); addr = (uintptr)(b->lim);
addr = addr & ~(BLOCKALIGN-1); addr = addr & ~(BLOCKALIGN-1);
b->lim = (uchar*)addr; b->lim = (uchar*)addr;

58
sys/src/9/port/auth.c
View file

@ -19,59 +19,68 @@ iseve(void)
return strcmp(eve, up->user) == 0; return strcmp(eve, up->user) == 0;
} }
long uintptr
sysfversion(ulong *arg) sysfversion(va_list list)
{ {
uint msize, arglen;
char *vers; char *vers;
uint arglen, m, msize;
Chan *c; Chan *c;
int fd;
msize = arg[1]; fd = va_arg(list, int);
vers = (char*)arg[2]; msize = va_arg(list, uint);
arglen = arg[3]; vers = va_arg(list, char*);
validaddr(arg[2], arglen, 1); arglen = va_arg(list, uint);
validaddr((uintptr)vers, arglen, 1);
/* check there's a NUL in the version string */ /* check there's a NUL in the version string */
if(arglen==0 || memchr(vers, 0, arglen)==0) if(arglen==0 || memchr(vers, 0, arglen)==0)
error(Ebadarg); error(Ebadarg);
c = fdtochan(arg[0], ORDWR, 0, 1); c = fdtochan(fd, ORDWR, 0, 1);
if(waserror()){ if(waserror()){
cclose(c); cclose(c);
nexterror(); nexterror();
} }
msize = mntversion(c, vers, msize, arglen);
m = mntversion(c, vers, msize, arglen);
cclose(c); cclose(c);
poperror(); poperror();
return m; return msize;
} }
long uintptr
sys_fsession(ulong *arg) 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); error(Ebadarg);
validaddr(arg[1], arg[2], 1); validaddr((uintptr)str, len, 1);
((uchar*)arg[1])[0] = '\0'; *str = '\0';
USED(fd);
return 0; return 0;
} }
long uintptr
sysfauth(ulong *arg) sysfauth(va_list list)
{ {
Chan *c, *ac; Chan *c, *ac;
char *aname; char *aname;
int fd; int fd;
validaddr(arg[1], 1, 0); fd = va_arg(list, int);
aname = validnamedup((char*)arg[1], 1); aname = va_arg(list, char*);
validaddr((uintptr)aname, 1, 0);
aname = validnamedup(aname, 1);
if(waserror()){ if(waserror()){
free(aname); free(aname);
nexterror(); nexterror();
} }
c = fdtochan(arg[0], ORDWR, 0, 1); c = fdtochan(fd, ORDWR, 0, 1);
if(waserror()){ if(waserror()){
cclose(c); cclose(c);
nexterror(); nexterror();
@ -96,8 +105,7 @@ sysfauth(ulong *arg)
/* always mark it close on exec */ /* always mark it close on exec */
ac->flag |= CCEXEC; ac->flag |= CCEXEC;
return (uintptr)fd;
return fd;
} }
/* /*

4
sys/src/9/port/chan.c
View file

@ -1721,14 +1721,14 @@ char isfrog[256]={
* to access unchecked addresses.) * to access unchecked addresses.)
*/ */
static char* static char*
validname0(char *aname, int slashok, int dup, ulong pc) validname0(char *aname, int slashok, int dup, uintptr pc)
{ {
char *ename, *name, *s; char *ename, *name, *s;
int c, n; int c, n;
Rune r; Rune r;
name = aname; name = aname;
if((ulong)name < KZERO){ if((uintptr)name < KZERO){
if(!dup) if(!dup)
print("warning: validname called from %#p with user pointer", pc); print("warning: validname called from %#p with user pointer", pc);
ename = vmemchr(name, 0, (1<<16)); ename = vmemchr(name, 0, (1<<16));

10
sys/src/9/port/devkprof.c
View file

@ -11,8 +11,8 @@
struct struct
{ {
int minpc; uintptr minpc;
int maxpc; uintptr maxpc;
int nbuf; int nbuf;
int time; int time;
ulong *buf; ulong *buf;
@ -30,7 +30,7 @@ Dirtab kproftab[]={
}; };
static void static void
_kproftimer(ulong pc) _kproftimer(uintptr pc)
{ {
extern void spldone(void); extern void spldone(void);
@ -40,7 +40,7 @@ _kproftimer(ulong pc)
* if the pc is coming out of spllo or splx, * if the pc is coming out of spllo or splx,
* use the pc saved when we went splhi. * 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; pc = m->splpc;
kprof.buf[0] += TK2MS(1); kprof.buf[0] += TK2MS(1);
@ -67,7 +67,7 @@ kprofattach(char *spec)
/* allocate when first used */ /* allocate when first used */
kprof.minpc = KTZERO; kprof.minpc = KTZERO;
kprof.maxpc = (ulong)etext; kprof.maxpc = (uintptr)etext;
kprof.nbuf = (kprof.maxpc-kprof.minpc) >> LRES; kprof.nbuf = (kprof.maxpc-kprof.minpc) >> LRES;
n = kprof.nbuf*SZ; n = kprof.nbuf*SZ;
if(kprof.buf == 0) { if(kprof.buf == 0) {

16
sys/src/9/port/devproc.c
View file

@ -152,7 +152,7 @@ static char *sname[]={ "Text", "Data", "Bss", "Stack", "Shared", "Phys", };
#define NOTEID(q) ((q).vers) #define NOTEID(q) ((q).vers)
void procctlreq(Proc*, char*, int); void procctlreq(Proc*, char*, int);
int procctlmemio(Proc*, ulong, int, void*, int); int procctlmemio(Proc*, uintptr, int, void*, int);
Chan* proctext(Chan*, Proc*); Chan* proctext(Chan*, Proc*);
Segment* txt2data(Proc*, Segment*); Segment* txt2data(Proc*, Segment*);
int procstopped(void*); int procstopped(void*);
@ -699,7 +699,7 @@ procread(Chan *c, void *va, long n, vlong off)
int i, j, m, navail, ne, rsize; int i, j, m, navail, ne, rsize;
long l; long l;
uchar *rptr; uchar *rptr;
ulong offset; uintptr offset;
Confmem *cm; Confmem *cm;
Mntwalk *mw; Mntwalk *mw;
Proc *p; Proc *p;
@ -766,9 +766,9 @@ procread(Chan *c, void *va, long n, vlong off)
error(Eperm); error(Eperm);
/* validate kernel addresses */ /* validate kernel addresses */
if(offset < (ulong)end) { if(offset < (uintptr)end) {
if(offset+n > (ulong)end) if(offset+n > (uintptr)end)
n = (ulong)end - offset; n = (uintptr)end - offset;
memmove(a, (char*)offset, n); memmove(a, (char*)offset, n);
return n; return n;
} }
@ -910,7 +910,7 @@ procread(Chan *c, void *va, long n, vlong off)
sg = p->seg[i]; sg = p->seg[i];
if(sg == 0) if(sg == 0)
continue; 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], sname[sg->type&SG_TYPE],
sg->type&SG_RONLY ? 'R' : ' ', sg->type&SG_RONLY ? 'R' : ' ',
sg->profile ? 'P' : ' ', sg->profile ? 'P' : ' ',
@ -1533,13 +1533,13 @@ procstopped(void *a)
} }
int 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; KMap *k;
Pte *pte; Pte *pte;
Page *pg; Page *pg;
Segment *s; Segment *s;
ulong soff, l; uintptr soff, l;
char *a = va, *b; char *a = va, *b;
for(;;) { for(;;) {

34
sys/src/9/port/fault.c
View file

@ -6,7 +6,7 @@
#include "../port/error.h" #include "../port/error.h"
int int
fault(ulong addr, int read) fault(uintptr addr, int read)
{ {
Segment *s; Segment *s;
char *sps; char *sps;
@ -70,18 +70,19 @@ faulterror(char *s, Chan *c, int freemem)
pexit(s, freemem); pexit(s, freemem);
} }
void (*checkaddr)(ulong, Segment *, Page *); void (*checkaddr)(uintptr, Segment *, Page *);
ulong addr2check; uintptr addr2check;
int int
fixfault(Segment *s, ulong addr, int read, int doputmmu) fixfault(Segment *s, uintptr addr, int read, int doputmmu)
{ {
int type; int type;
int ref; int ref;
Pte **p, *etp; Pte **p, *etp;
ulong mmuphys=0, soff; ulong mmuphys=0;
uintptr soff;
Page **pg, *lkp, *new; Page **pg, *lkp, *new;
Page *(*fn)(Segment*, ulong); Page *(*fn)(Segment*, uintptr);
addr &= ~(BY2PG-1); addr &= ~(BY2PG-1);
soff = addr-s->base; soff = addr-s->base;
@ -198,14 +199,14 @@ fixfault(Segment *s, ulong addr, int read, int doputmmu)
} }
void void
pio(Segment *s, ulong addr, ulong soff, Page **p) pio(Segment *s, uintptr addr, uintptr soff, Page **p)
{ {
Page *new; Page *new;
KMap *k; KMap *k;
Chan *c; Chan *c;
int n, ask; int n, ask;
char *kaddr; char *kaddr;
ulong daddr; uintptr daddr;
Page *loadrec; Page *loadrec;
retry: retry:
@ -310,7 +311,7 @@ done:
* Called only in a system call * Called only in a system call
*/ */
int int
okaddr(ulong addr, ulong len, int write) okaddr(uintptr addr, ulong len, int write)
{ {
Segment *s; Segment *s;
@ -332,10 +333,10 @@ okaddr(ulong addr, ulong len, int write)
} }
void void
validaddr(ulong addr, ulong len, int write) validaddr(uintptr addr, ulong len, int write)
{ {
if(!okaddr(addr, len, 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); postnote(up, 1, "sys: bad address in syscall", NDebug);
error(Ebadarg); error(Ebadarg);
} }
@ -348,10 +349,10 @@ void*
vmemchr(void *s, int c, int n) vmemchr(void *s, int c, int n)
{ {
int m; int m;
ulong a; uintptr a;
void *t; void *t;
a = (ulong)s; a = (uintptr)s;
while(PGROUND(a) != PGROUND(a+n-1)){ while(PGROUND(a) != PGROUND(a+n-1)){
/* spans pages; handle this page */ /* spans pages; handle this page */
m = BY2PG - (a & (BY2PG-1)); m = BY2PG - (a & (BY2PG-1));
@ -369,7 +370,7 @@ vmemchr(void *s, int c, int n)
} }
Segment* Segment*
seg(Proc *p, ulong addr, int dolock) seg(Proc *p, uintptr addr, int dolock)
{ {
Segment **s, **et, *n; Segment **s, **et, *n;
@ -392,12 +393,13 @@ seg(Proc *p, ulong addr, int dolock)
return 0; return 0;
} }
extern void checkmmu(ulong, ulong); extern void checkmmu(uintptr, uintptr);
void void
checkpages(void) checkpages(void)
{ {
int checked; int checked;
ulong addr, off; uintptr addr, off;
Pte *p; Pte *p;
Page *pg; Page *pg;
Segment **sp, **ep, *s; Segment **sp, **ep, *s;

2
sys/src/9/port/mksystab
View file

@ -5,7 +5,7 @@ file=/sys/src/libc/9syscall/sys.h
cat <<'!' cat <<'!'
#include "/sys/src/libc/9syscall/sys.h" #include "/sys/src/libc/9syscall/sys.h"
typedef long Syscall(ulong*); typedef uintptr Syscall(va_list);
! !

10
sys/src/9/port/page.c
View file

@ -118,7 +118,7 @@ pagechainhead(Page *p)
} }
Page* Page*
newpage(int clear, Segment **s, ulong va) newpage(int clear, Segment **s, uintptr va)
{ {
Page *p; Page *p;
KMap *k; KMap *k;
@ -409,7 +409,7 @@ cachepage(Page *p, Image *i)
} }
void void
cachedel(Image *i, ulong daddr) cachedel(Image *i, uintptr daddr)
{ {
Page *f; Page *f;
@ -434,7 +434,7 @@ retry:
} }
Page * Page *
lookpage(Image *i, ulong daddr) lookpage(Image *i, uintptr daddr)
{ {
Page *f; Page *f;
@ -574,7 +574,7 @@ checkpagerefs(void)
nwrong = 0; nwrong = 0;
for(i=0; i<np; i++){ for(i=0; i<np; i++){
if(palloc.pages[i].ref != ref[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]); palloc.pages[i].pa, palloc.pages[i].ref, ref[i]);
ref[i] = 1; ref[i] = 1;
nwrong++; nwrong++;
@ -627,7 +627,7 @@ portcountpagerefs(ulong *ref, int print)
continue; continue;
if(print){ if(print){
if(ref[pagenumber(entry)]) 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; continue;
} }
if(ref[pagenumber(entry)]++ == 0) if(ref[pagenumber(entry)]++ == 0)

36
sys/src/9/port/portdat.h
View file

@ -83,7 +83,7 @@ struct RWlock
Lock use; Lock use;
Proc *head; /* list of waiting processes */ Proc *head; /* list of waiting processes */
Proc *tail; Proc *tail;
ulong wpc; /* pc of writer */ uintptr wpc; /* pc of writer */
Proc *wproc; /* writing proc */ Proc *wproc; /* writing proc */
int readers; /* number of readers */ int readers; /* number of readers */
int writer; /* number of writers */ int writer; /* number of writers */
@ -97,7 +97,7 @@ struct Alarms
struct Sargs struct Sargs
{ {
ulong args[MAXSYSARG]; uchar args[MAXSYSARG*BY2WD];
}; };
/* /*
@ -313,9 +313,9 @@ enum
struct Page struct Page
{ {
Lock; Lock;
ulong pa; /* Physical address in memory */ uintptr pa; /* Physical address in memory */
ulong va; /* Virtual address for user */ uintptr va; /* Virtual address for user */
ulong daddr; /* Disc address on swap */ uintptr daddr; /* Disc address on swap */
ulong gen; /* Generation counter for swap */ ulong gen; /* Generation counter for swap */
ushort ref; /* Reference count */ ushort ref; /* Reference count */
char modref; /* Simulated modify/reference bits */ char modref; /* Simulated modify/reference bits */
@ -378,9 +378,9 @@ enum
}; };
#define PG_ONSWAP 1 #define PG_ONSWAP 1
#define onswap(s) (((ulong)s)&PG_ONSWAP) #define onswap(s) (((uintptr)s)&PG_ONSWAP)
#define pagedout(s) (((ulong)s)==0 || onswap(s)) #define pagedout(s) (((uintptr)s)==0 || onswap(s))
#define swapaddr(s) (((ulong)s)&~PG_ONSWAP) #define swapaddr(s) (((uintptr)s)&~PG_ONSWAP)
#define SEGMAXSIZE (SEGMAPSIZE*PTEMAPMEM) #define SEGMAXSIZE (SEGMAPSIZE*PTEMAPMEM)
@ -388,9 +388,9 @@ struct Physseg
{ {
ulong attr; /* Segment attributes */ ulong attr; /* Segment attributes */
char *name; /* Attach name */ char *name; /* Attach name */
ulong pa; /* Physical address */ uintptr pa; /* Physical address */
ulong size; /* Maximum segment size in pages */ 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*); void (*pgfree)(Page*);
}; };
@ -409,11 +409,11 @@ struct Segment
QLock lk; QLock lk;
ushort steal; /* Page stealer lock */ ushort steal; /* Page stealer lock */
ushort type; /* segment type */ ushort type; /* segment type */
ulong base; /* virtual base */ uintptr base; /* virtual base */
ulong top; /* virtual top */ uintptr top; /* virtual top */
ulong size; /* size in pages */ ulong size; /* size in pages */
ulong fstart; /* start address in file for demand load */ uintptr fstart; /* start address in file for demand load */
ulong flen; /* length of segment in file */ uintptr flen; /* length of segment in file */
int flushme; /* maintain icache for this segment */ int flushme; /* maintain icache for this segment */
Image *image; /* text in file attached to this segment */ Image *image; /* text in file attached to this segment */
Physseg *pseg; Physseg *pseg;
@ -490,8 +490,8 @@ enum
struct Pallocmem struct Pallocmem
{ {
ulong base; uintptr base;
ulong npage; ulong npage;
}; };
struct Palloc struct Palloc
@ -671,7 +671,7 @@ struct Proc
ulong privatemem; /* proc does not let anyone read mem */ ulong privatemem; /* proc does not let anyone read mem */
int hang; /* hang at next exec for debug */ int hang; /* hang at next exec for debug */
int procctl; /* Control for /proc debugging */ int procctl; /* Control for /proc debugging */
ulong pc; /* DEBUG only */ uintptr pc; /* DEBUG only */
Lock rlock; /* sync sleep/wakeup with postnote */ Lock rlock; /* sync sleep/wakeup with postnote */
Rendez *r; /* rendezvous point slept on */ Rendez *r; /* rendezvous point slept on */
@ -734,7 +734,7 @@ struct Proc
Edf *edf; /* if non-null, real-time proc, edf contains scheduling params */ Edf *edf; /* if non-null, real-time proc, edf contains scheduling params */
int trace; /* process being traced? */ int trace; /* process being traced? */
ulong qpc; /* pc calling last blocking qlock */ uintptr qpc; /* pc calling last blocking qlock */
QLock *eql; /* interruptable eqlock */ QLock *eql; /* interruptable eqlock */
int setargs; /* process changed its args */ int setargs; /* process changed its args */

56
sys/src/9/port/portfns.h
View file

@ -9,12 +9,12 @@ void alarmkproc(void*);
Block* allocb(int); Block* allocb(int);
int anyhigher(void); int anyhigher(void);
int anyready(void); int anyready(void);
Image* attachimage(int, Chan*, ulong, ulong); Image* attachimage(int, Chan*, uintptr, ulong);
Page* auxpage(void); Page* auxpage(void);
Block* bl2mem(uchar*, Block*, int); Block* bl2mem(uchar*, Block*, int);
int blocklen(Block*); int blocklen(Block*);
void bootlinks(void); void bootlinks(void);
void cachedel(Image*, ulong); void cachedel(Image*, uintptr);
void cachepage(Page*, Image*); void cachepage(Page*, Image*);
void callwithureg(void(*)(Ureg*)); void callwithureg(void(*)(Ureg*));
char* chanpath(Chan*); char* chanpath(Chan*);
@ -51,7 +51,7 @@ int cread(Chan*, uchar*, int, vlong);
void cunmount(Chan*, Chan*); void cunmount(Chan*, Chan*);
void cupdate(Chan*, uchar*, int, vlong); void cupdate(Chan*, uchar*, int, vlong);
void cwrite(Chan*, uchar*, int, vlong); void cwrite(Chan*, uchar*, int, vlong);
ulong dbgpc(Proc*); uintptr dbgpc(Proc*);
long decref(Ref*); long decref(Ref*);
int decrypt(void*, void*, int); int decrypt(void*, void*, int);
void delay(int); void delay(int);
@ -99,17 +99,17 @@ int eqchantdqid(Chan*, int, int, Qid, int);
int eqqid(Qid, Qid); int eqqid(Qid, Qid);
void error(char*); void error(char*);
void eqlock(QLock*); void eqlock(QLock*);
long execregs(ulong, ulong, ulong); uintptr execregs(uintptr, ulong, ulong);
void exhausted(char*); void exhausted(char*);
void exit(int); void exit(int);
uvlong fastticks(uvlong*); uvlong fastticks(uvlong*);
uvlong fastticks2ns(uvlong); uvlong fastticks2ns(uvlong);
uvlong fastticks2us(uvlong); uvlong fastticks2us(uvlong);
int fault(ulong, int); int fault(uintptr, int);
void fdclose(int, int); void fdclose(int, int);
Chan* fdtochan(int, int, int, int); Chan* fdtochan(int, int, int, int);
int findmount(Chan**, Mhead**, int, int, Qid); int findmount(Chan**, Mhead**, int, int, Qid);
int fixfault(Segment*, ulong, int, int); int fixfault(Segment*, uintptr, int, int);
void flushmmu(void); void flushmmu(void);
void forceclosefgrp(void); void forceclosefgrp(void);
void forkchild(Proc*, Ureg*); void forkchild(Proc*, Ureg*);
@ -120,8 +120,8 @@ void freeblist(Block*);
int freebroken(void); int freebroken(void);
void freepte(Segment*, Pte*); void freepte(Segment*, Pte*);
void getcolor(ulong, ulong*, ulong*, ulong*); void getcolor(ulong, ulong*, ulong*, ulong*);
ulong getmalloctag(void*); uintptr getmalloctag(void*);
ulong getrealloctag(void*); uintptr getrealloctag(void*);
void gotolabel(Label*); void gotolabel(Label*);
char* getconfenv(void); char* getconfenv(void);
long hostdomainwrite(char*, int); long hostdomainwrite(char*, int);
@ -129,7 +129,7 @@ long hostownerwrite(char*, int);
void hzsched(void); void hzsched(void);
Block* iallocb(int); Block* iallocb(int);
void iallocsummary(void); void iallocsummary(void);
long ibrk(ulong, int); long ibrk(uintptr, int);
void ilock(Lock*); void ilock(Lock*);
void iunlock(Lock*); void iunlock(Lock*);
long incref(Ref*); long incref(Ref*);
@ -138,7 +138,7 @@ int iprint(char*, ...);
void isdir(Chan*); void isdir(Chan*);
int iseve(void); int iseve(void);
int islo(void); int islo(void);
Segment* isoverlap(Proc*, ulong, int); Segment* isoverlap(Proc*, uintptr, int);
int ispages(void*); int ispages(void*);
int isphysseg(char*); int isphysseg(char*);
void ixsummary(void); void ixsummary(void);
@ -146,7 +146,7 @@ void kickpager(void);
void killbig(char*); void killbig(char*);
void kproc(char*, void(*)(void*), void*); void kproc(char*, void(*)(void*), void*);
void kprocchild(Proc*, void (*)(void*), void*); void kprocchild(Proc*, void (*)(void*), void*);
void (*kproftimer)(ulong); void (*kproftimer)(uintptr);
void ksetenv(char*, char*, int); void ksetenv(char*, char*, int);
void kstrcpy(char*, char*, int); void kstrcpy(char*, char*, int);
void kstrdup(char**, char*); void kstrdup(char**, char*);
@ -158,7 +158,7 @@ void logn(Log*, int, void*, int);
long logread(Log*, void*, ulong, long); long logread(Log*, void*, ulong, long);
void log(Log*, int, char*, ...); void log(Log*, int, char*, ...);
Cmdtab* lookupcmd(Cmdbuf*, Cmdtab*, int); Cmdtab* lookupcmd(Cmdbuf*, Cmdtab*, int);
Page* lookpage(Image*, ulong); Page* lookpage(Image*, uintptr);
#define MS2NS(n) (((vlong)(n))*1000000LL) #define MS2NS(n) (((vlong)(n))*1000000LL)
void machinit(void); void machinit(void);
void* mallocz(ulong, int); void* mallocz(ulong, int);
@ -167,7 +167,7 @@ void* mallocalign(ulong, ulong, long, ulong);
void mallocsummary(void); void mallocsummary(void);
Block* mem2bl(uchar*, int); Block* mem2bl(uchar*, int);
int mcountseg(Segment*); int mcountseg(Segment*);
void mfreeseg(Segment*, ulong, int); void mfreeseg(Segment*, uintptr, int);
void microdelay(int); void microdelay(int);
uvlong mk64fract(uvlong, uvlong); uvlong mk64fract(uvlong, uvlong);
void mkqid(Qid*, vlong, ulong, int); void mkqid(Qid*, vlong, ulong, int);
@ -189,7 +189,7 @@ Chan* newchan(void);
int newfd(Chan*); int newfd(Chan*);
Mhead* newmhead(Chan*); Mhead* newmhead(Chan*);
Mount* newmount(Mhead*, Chan*, int, char*); Mount* newmount(Mhead*, Chan*, int, char*);
Page* newpage(int, Segment **, ulong); Page* newpage(int, Segment **, uintptr);
Path* newpath(char*); Path* newpath(char*);
Pgrp* newpgrp(void); Pgrp* newpgrp(void);
Rgrp* newrgrp(void); Rgrp* newrgrp(void);
@ -198,7 +198,7 @@ void nexterror(void);
int notify(Ureg*); int notify(Ureg*);
int nrand(int); int nrand(int);
uvlong ns2fastticks(uvlong); uvlong ns2fastticks(uvlong);
int okaddr(ulong, ulong, int); int okaddr(uintptr, ulong, int);
int openmode(ulong); int openmode(ulong);
Block* packblock(Block*); Block* packblock(Block*);
Block* padblock(Block*, int); Block* padblock(Block*, int);
@ -214,7 +214,7 @@ void pexit(char*, int);
void pgrpcpy(Pgrp*, Pgrp*); void pgrpcpy(Pgrp*, Pgrp*);
void pgrpnote(ulong, char*, long, int); void pgrpnote(ulong, char*, long, int);
int pidalloc(Proc*); int pidalloc(Proc*);
void pio(Segment *, ulong, ulong, Page **); void pio(Segment *, uintptr, uintptr, Page **);
#define poperror() up->nerrlab-- #define poperror() up->nerrlab--
void portcountpagerefs(ulong*, int); void portcountpagerefs(ulong*, int);
int postnote(Proc*, int, char*, int); int postnote(Proc*, int, char*, int);
@ -287,7 +287,7 @@ void ready(Proc*);
void* realloc(void *v, ulong size); void* realloc(void *v, ulong size);
void rebootcmd(int, char**); void rebootcmd(int, char**);
void reboot(void*, void*, ulong); void reboot(void*, void*, ulong);
void relocateseg(Segment*, ulong); void relocateseg(Segment*, uintptr);
void renameuser(char*, char*); void renameuser(char*, char*);
void resched(char*); void resched(char*);
void resrcwait(char*); void resrcwait(char*);
@ -302,14 +302,14 @@ void scheddump(void);
void schedinit(void); void schedinit(void);
void (*screenputs)(char*, int); void (*screenputs)(char*, int);
long seconds(void); long seconds(void);
ulong segattach(Proc*, ulong, char *, ulong, ulong); uintptr segattach(Proc*, ulong, char *, uintptr, ulong);
void segclock(ulong); void segclock(uintptr);
void segpage(Segment*, Page*); void segpage(Segment*, Page*);
int setcolor(ulong, ulong, ulong, ulong); int setcolor(ulong, ulong, ulong, ulong);
void setkernur(Ureg*, Proc*); void setkernur(Ureg*, Proc*);
int setlabel(Label*); int setlabel(Label*);
void setmalloctag(void*, ulong); void setmalloctag(void*, uintptr);
void setrealloctag(void*, ulong); void setrealloctag(void*, uintptr);
void setregisters(Ureg*, char*, char*, int); void setregisters(Ureg*, char*, char*, int);
void setswapchan(Chan*); void setswapchan(Chan*);
char* skipslash(char*); char* skipslash(char*);
@ -322,11 +322,11 @@ void splxpc(int);
char* srvname(Chan*); char* srvname(Chan*);
void srvrenameuser(char*, char*); void srvrenameuser(char*, char*);
void shrrenameuser(char*, char*); void shrrenameuser(char*, char*);
int swapcount(ulong); int swapcount(uintptr);
int swapfull(void); int swapfull(void);
void swapinit(void); void swapinit(void);
void syscallfmt(ulong syscallno, ulong pc, va_list list); void syscallfmt(ulong syscallno, uintptr pc, va_list list);
void sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop); void sysretfmt(ulong syscallno, va_list list, uintptr ret, uvlong start, uvlong stop);
void timeradd(Timer*); void timeradd(Timer*);
void timerdel(Timer*); void timerdel(Timer*);
void timersinit(void); void timersinit(void);
@ -356,9 +356,9 @@ long unionread(Chan*, void*, long);
void unlock(Lock*); void unlock(Lock*);
uvlong us2fastticks(uvlong); uvlong us2fastticks(uvlong);
void userinit(void); void userinit(void);
ulong userpc(void); uintptr userpc(void);
long userwrite(char*, int); long userwrite(char*, int);
void validaddr(ulong, ulong, int); void validaddr(uintptr, ulong, int);
void validname(char*, int); void validname(char*, int);
char* validnamedup(char*, int); char* validnamedup(char*, int);
void validstat(uchar*, int); void validstat(uchar*, int);
@ -378,8 +378,8 @@ void xsummary(void);
void yield(void); void yield(void);
Segment* data2txt(Segment*); Segment* data2txt(Segment*);
Segment* dupseg(Segment**, int, int); Segment* dupseg(Segment**, int, int);
Segment* newseg(int, ulong, ulong); Segment* newseg(int, uintptr, ulong);
Segment* seg(Proc*, ulong, int); Segment* seg(Proc*, uintptr, int);
void hnputv(void*, uvlong); void hnputv(void*, uvlong);
void hnputl(void*, uint); void hnputl(void*, uint);
void hnputs(void*, ushort); void hnputs(void*, ushort);

7
sys/src/9/port/proc.c
View file

@ -743,7 +743,7 @@ sleep(Rendez *r, int (*f)(void*), void *arg)
s = splhi(); s = splhi();
if(up->nlocks.ref) 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)); up->pid, up->nlocks.ref, up->lastlock, up->lastlock->pc, getcallerpc(&r));
lock(r); lock(r);
lock(&up->rlock); lock(&up->rlock);
@ -1283,9 +1283,10 @@ dumpaproc(Proc *p)
s = p->psstate; s = p->psstate;
if(s == 0) if(s == 0)
s = statename[p->state]; 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->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 void

42
sys/src/9/port/segment.c
View file

@ -47,7 +47,7 @@ initseg(void)
} }
Segment * Segment *
newseg(int type, ulong base, ulong size) newseg(int type, uintptr base, ulong size)
{ {
Segment *s; Segment *s;
int mapsize; int mapsize;
@ -125,7 +125,7 @@ putseg(Segment *s)
} }
void void
relocateseg(Segment *s, ulong offset) relocateseg(Segment *s, uintptr offset)
{ {
Page **pg, *x; Page **pg, *x;
Pte *pte, **p, **endpte; Pte *pte, **p, **endpte;
@ -214,7 +214,7 @@ void
segpage(Segment *s, Page *p) segpage(Segment *s, Page *p)
{ {
Pte **pte; Pte **pte;
ulong off; uintptr off;
Page **pg; Page **pg;
if(p->va < s->base || p->va >= s->top) if(p->va < s->base || p->va >= s->top)
@ -234,7 +234,7 @@ segpage(Segment *s, Page *p)
} }
Image* Image*
attachimage(int type, Chan *c, ulong base, ulong len) attachimage(int type, Chan *c, uintptr base, ulong len)
{ {
Image *i, **l; Image *i, **l;
@ -392,10 +392,11 @@ putimage(Image *i)
} }
long long
ibrk(ulong addr, int seg) ibrk(uintptr addr, int seg)
{ {
Segment *s, *ns; Segment *s, *ns;
ulong newtop, newsize; uintptr newtop;
ulong newsize;
int i, mapsize; int i, mapsize;
Pte **map; Pte **map;
@ -492,10 +493,10 @@ mcountseg(Segment *s)
* called with s->lk locked * called with s->lk locked
*/ */
void void
mfreeseg(Segment *s, ulong start, int pages) mfreeseg(Segment *s, uintptr start, int pages)
{ {
int i, j, size; int i, j, size;
ulong soff; uintptr soff;
Page *pg; Page *pg;
Page *list; Page *list;
@ -553,11 +554,11 @@ out:
} }
Segment* Segment*
isoverlap(Proc *p, ulong va, int len) isoverlap(Proc *p, uintptr va, int len)
{ {
int i; int i;
Segment *ns; Segment *ns;
ulong newtop; uintptr newtop;
newtop = va+len; newtop = va+len;
for(i = 0; i < NSEG; i++) { for(i = 0; i < NSEG; i++) {
@ -615,8 +616,8 @@ isphysseg(char *name)
return rv; return rv;
} }
ulong uintptr
segattach(Proc *p, ulong attr, char *name, ulong va, ulong len) segattach(Proc *p, ulong attr, char *name, uintptr va, ulong len)
{ {
int sno; int sno;
Segment *s, *os; Segment *s, *os;
@ -625,7 +626,7 @@ segattach(Proc *p, ulong attr, char *name, ulong va, ulong len)
if(va != 0 && va >= USTKTOP) if(va != 0 && va >= USTKTOP)
error(Ebadarg); error(Ebadarg);
validaddr((ulong)name, 1, 0); validaddr((uintptr)name, 1, 0);
vmemchr(name, 0, ~0); vmemchr(name, 0, ~0);
for(sno = 0; sno < NSEG; sno++) for(sno = 0; sno < NSEG; sno++)
@ -708,16 +709,17 @@ pteflush(Pte *pte, int s, int e)
} }
} }
long uintptr
syssegflush(ulong *arg) syssegflush(va_list list)
{ {
Segment *s; Segment *s;
ulong addr, l; ulong len, l;
Pte *pte; Pte *pte;
int chunk, ps, pe, len; int chunk, ps, pe;
uintptr addr;
addr = arg[0]; addr = va_arg(list, uintptr);
len = arg[1]; len = va_arg(list, ulong);
while(len > 0) { while(len > 0) {
s = seg(up, addr, 1); s = seg(up, addr, 1);
@ -760,7 +762,7 @@ syssegflush(ulong *arg)
} }
void void
segclock(ulong pc) segclock(uintptr pc)
{ {
Segment *s; Segment *s;

8
sys/src/9/port/swap.c
View file

@ -77,7 +77,7 @@ putswap(Page *p)
uchar *idx; uchar *idx;
lock(&swapalloc); lock(&swapalloc);
idx = &swapalloc.swmap[((ulong)p)/BY2PG]; idx = &swapalloc.swmap[((uintptr)p)/BY2PG];
if(*idx == 0) if(*idx == 0)
panic("putswap %#p ref == 0", p); panic("putswap %#p ref == 0", p);
@ -111,7 +111,7 @@ dupswap(Page *p)
uchar *idx; uchar *idx;
lock(&swapalloc); lock(&swapalloc);
idx = &swapalloc.swmap[((ulong)p)/BY2PG]; idx = &swapalloc.swmap[((uintptr)p)/BY2PG];
if(*idx == 255) if(*idx == 255)
swapalloc.xref++; swapalloc.xref++;
else { else {
@ -122,7 +122,7 @@ dupswap(Page *p)
} }
int int
swapcount(ulong daddr) swapcount(uintptr daddr)
{ {
return swapalloc.swmap[daddr/BY2PG]; return swapalloc.swmap[daddr/BY2PG];
} }
@ -309,7 +309,7 @@ canflush(Proc *p, Segment *s)
static void static void
pagepte(int type, Page **pg) pagepte(int type, Page **pg)
{ {
ulong daddr; uintptr daddr;
Page *outp; Page *outp;
outp = *pg; outp = *pg;

30
sys/src/9/port/syscallfmt.c
View file

@ -20,7 +20,7 @@ fmtrwdata(Fmt* f, char* a, int n, char* suffix)
fmtprint(f, "0x0%s", suffix); fmtprint(f, "0x0%s", suffix);
return; return;
} }
validaddr((ulong)a, n, 0); validaddr((uintptr)a, n, 0);
t = smalloc(n+1); t = smalloc(n+1);
t[n] = 0; t[n] = 0;
for(i = 0; i < n; i++) for(i = 0; i < n; i++)
@ -43,7 +43,7 @@ fmtuserstring(Fmt* f, char* a, char* suffix)
fmtprint(f, "0/\"\"%s", suffix); fmtprint(f, "0/\"\"%s", suffix);
return; return;
} }
validaddr((ulong)a, 1, 0); validaddr((uintptr)a, 1, 0);
n = ((char*)vmemchr(a, 0, 0x7fffffff) - a) + 1; n = ((char*)vmemchr(a, 0, 0x7fffffff) - a) + 1;
t = smalloc(n+1); t = smalloc(n+1);
memmove(t, a, n); memmove(t, a, n);
@ -53,7 +53,7 @@ fmtuserstring(Fmt* f, char* a, char* suffix)
} }
void void
syscallfmt(ulong syscallno, ulong pc, va_list list) syscallfmt(ulong syscallno, uintptr pc, va_list list)
{ {
long l; long l;
Fmt fmt; Fmt fmt;
@ -72,7 +72,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
fmtprint(&fmt, "%s ", sysctab[syscallno]? fmtprint(&fmt, "%s ", sysctab[syscallno]?
sysctab[syscallno]: "huh?"); sysctab[syscallno]: "huh?");
fmtprint(&fmt, "%ulx ", pc); fmtprint(&fmt, "%p ", pc);
switch(syscallno){ switch(syscallno){
case SYSR1: case SYSR1:
p = va_arg(list, uintptr); p = va_arg(list, uintptr);
@ -113,7 +113,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
argv = va_arg(list, char**); argv = va_arg(list, char**);
evenaddr(PTR2UINT(argv)); evenaddr(PTR2UINT(argv));
for(;;){ for(;;){
validaddr((ulong)argv, sizeof(char**), 0); validaddr((uintptr)argv, sizeof(char**), 0);
a = *(char **)argv; a = *(char **)argv;
if(a == nil) if(a == nil)
break; break;
@ -307,7 +307,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
} }
void 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; long l;
void* v; void* v;
@ -324,9 +324,9 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
case ALARM: case ALARM:
case _WRITE: case _WRITE:
case PWRITE: case PWRITE:
if(ret == -1) if((long)ret == -1)
errstr = up->syserrstr; errstr = up->syserrstr;
fmtprint(&fmt, " = %ld", ret); fmtprint(&fmt, " = %ld", (long)ret);
break; break;
case EXEC: case EXEC:
case SEGBRK: case SEGBRK:
@ -341,10 +341,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
l = va_arg(list, unsigned long); l = va_arg(list, unsigned long);
if(ret > 0){ if(ret > 0){
fmtuserstring(&fmt, a, " "); fmtuserstring(&fmt, a, " ");
fmtprint(&fmt, "%lud = %ld", l, ret); fmtprint(&fmt, "%lud = %ld", l, (long)ret);
} }
else{ else{
fmtprint(&fmt, "%#p/\"\" %lud = %ld", a, l, ret); fmtprint(&fmt, "%#p/\"\" %lud = %ld", a, l, (long)ret);
errstr = up->syserrstr; errstr = up->syserrstr;
} }
break; break;
@ -357,10 +357,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
l = va_arg(list, unsigned long); l = va_arg(list, unsigned long);
if(ret > 0){ if(ret > 0){
fmtuserstring(&fmt, a, " "); fmtuserstring(&fmt, a, " ");
fmtprint(&fmt, "%lud = %ld", l, ret); fmtprint(&fmt, "%lud = %ld", l, (long)ret);
} }
else{ else{
fmtprint(&fmt, "\"\" %lud = %ld", l, ret); fmtprint(&fmt, "\"\" %lud = %ld", l, (long)ret);
errstr = up->syserrstr; errstr = up->syserrstr;
} }
break; break;
@ -371,10 +371,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
l = va_arg(list, unsigned long); l = va_arg(list, unsigned long);
if(ret > 0){ if(ret > 0){
fmtuserstring(&fmt, a, " "); fmtuserstring(&fmt, a, " ");
fmtprint(&fmt, "%lud = %ld", l, ret); fmtprint(&fmt, "%lud = %ld", l, (long)ret);
} }
else{ else{
fmtprint(&fmt, "\"\" %lud = %ld", l, ret); fmtprint(&fmt, "\"\" %lud = %ld", l, (long)ret);
errstr = up->syserrstr; errstr = up->syserrstr;
} }
break; break;
@ -397,7 +397,7 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
vl = va_arg(list, vlong); vl = va_arg(list, vlong);
fmtprint(&fmt, " %lld", vl); fmtprint(&fmt, " %lld", vl);
} }
fmtprint(&fmt, " = %ld", ret); fmtprint(&fmt, " = %ld", (long)ret);
break; break;
} }
fmtprint(&fmt, " %s %#llud %#llud\n", errstr, start, stop); fmtprint(&fmt, " %s %#llud %#llud\n", errstr, start, stop);

468
sys/src/9/port/sysfile.c
View file

@ -113,7 +113,6 @@ newfd2(int fd[2], Chan *c[2])
f->fd[fd[0]] = c[0]; f->fd[fd[0]] = c[0];
f->fd[fd[1]] = c[1]; f->fd[fd[1]] = c[1];
unlockfgrp(f); unlockfgrp(f);
return 0; return 0;
} }
@ -155,7 +154,6 @@ fdtochan(int fd, int mode, int chkmnt, int iref)
cclose(c); cclose(c);
error(Ebadusefd); error(Ebadusefd);
} }
return c; return c;
} }
@ -170,29 +168,36 @@ openmode(ulong o)
return o; return o;
} }
long uintptr
sysfd2path(ulong *arg) sysfd2path(va_list list)
{ {
Chan *c; Chan *c;
char *buf;
uint len;
int fd;
validaddr(arg[1], arg[2], 1); fd = va_arg(list, int);
buf = va_arg(list, char*);
c = fdtochan(arg[0], -1, 0, 1); len = va_arg(list, uint);
snprint((char*)arg[1], arg[2], "%s", chanpath(c)); validaddr((uintptr)buf, len, 1);
c = fdtochan(fd, -1, 0, 1);
snprint(buf, len, "%s", chanpath(c));
cclose(c); cclose(c);
return 0; return 0;
} }
long uintptr
syspipe(ulong *arg) syspipe(va_list list)
{ {
int fd[2]; int *fd;
Chan *c[2]; Chan *c[2];
Dev *d; Dev *d;
static char *datastr[] = {"data", "data1"}; static char *datastr[] = {"data", "data1"};
validaddr(arg[0], 2*BY2WD, 1); fd = va_arg(list, int*);
evenaddr(arg[0]); validaddr((uintptr)fd, 2*sizeof(int), 1);
evenaddr((uintptr)fd);
d = devtab[devno('|', 0)]; d = devtab[devno('|', 0)];
c[0] = namec("#|", Atodir, 0, 0); c[0] = namec("#|", Atodir, 0, 0);
c[1] = 0; c[1] = 0;
@ -215,24 +220,23 @@ syspipe(ulong *arg)
if(newfd2(fd, c) < 0) if(newfd2(fd, c) < 0)
error(Enofd); error(Enofd);
poperror(); poperror();
((long*)arg[0])[0] = fd[0];
((long*)arg[0])[1] = fd[1];
return 0; return 0;
} }
long uintptr
sysdup(ulong *arg) sysdup(va_list list)
{ {
int fd; int fd;
Chan *c, *oc; Chan *c, *oc;
Fgrp *f = up->fgrp; Fgrp *f = up->fgrp;
fd = va_arg(list, int);
/* /*
* Close after dup'ing, so date > #d/1 works * Close after dup'ing, so date > #d/1 works
*/ */
c = fdtochan(arg[0], -1, 0, 1); c = fdtochan(fd, -1, 0, 1);
fd = arg[1]; fd = va_arg(list, int);
if(fd != -1){ if(fd != -1){
lock(f); lock(f);
if(fd<0 || growfd(f, fd)<0) { if(fd<0 || growfd(f, fd)<0) {
@ -258,19 +262,22 @@ sysdup(ulong *arg)
error(Enofd); error(Enofd);
poperror(); poperror();
} }
return (uintptr)fd;
return fd;
} }
long uintptr
sysopen(ulong *arg) sysopen(va_list list)
{ {
int fd; int fd;
Chan *c; Chan *c;
char *name;
ulong mode;
openmode(arg[1]); /* error check only */ name = va_arg(list, char*);
validaddr(arg[0], 1, 0); mode = va_arg(list, ulong);
c = namec((char*)arg[0], Aopen, arg[1], 0); openmode(mode); /* error check only */
validaddr((uintptr)name, 1, 0);
c = namec(name, Aopen, mode, 0);
if(waserror()){ if(waserror()){
cclose(c); cclose(c);
nexterror(); nexterror();
@ -279,7 +286,7 @@ sysopen(ulong *arg)
if(fd < 0) if(fd < 0)
error(Enofd); error(Enofd);
poperror(); poperror();
return fd; return (uintptr)fd;
} }
void void
@ -311,12 +318,14 @@ fdclose(int fd, int flag)
cclose(c); cclose(c);
} }
long uintptr
sysclose(ulong *arg) sysclose(va_list list)
{ {
fdtochan(arg[0], -1, 0, 0); int fd;
fdclose(arg[0], 0);
fd = va_arg(list, int);
fdtochan(fd, -1, 0, 0);
fdclose(fd, 0);
return 0; return 0;
} }
@ -625,17 +634,14 @@ mountfix(Chan *c, uchar *op, long n, long maxn)
} }
static long static long
read(ulong *arg, vlong *offp) read(int fd, uchar *p, long n, vlong *offp)
{ {
long n, nn, nnn; long nn, nnn;
uchar *p;
Chan *c; Chan *c;
vlong off; vlong off;
n = arg[2]; validaddr((uintptr)p, n, 1);
validaddr(arg[1], n, 1); c = fdtochan(fd, OREAD, 1, 1);
p = (void*)arg[1];
c = fdtochan(arg[0], OREAD, 1, 1);
if(waserror()){ if(waserror()){
cclose(c); cclose(c);
@ -688,43 +694,51 @@ read(ulong *arg, vlong *offp)
poperror(); poperror();
cclose(c); cclose(c);
return nnn; return nnn;
} }
long uintptr
sys_read(ulong *arg) 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 uintptr
syspread(ulong *arg) syspread(va_list list)
{ {
vlong v; int fd;
va_list list; void *buf;
long len;
vlong off, *offp;
/* use varargs to guarantee alignment of vlong */ fd = va_arg(list, int);
va_start(list, arg[2]); buf = va_arg(list, void*);
v = va_arg(list, vlong); len = va_arg(list, long);
va_end(list); off = va_arg(list, vlong);
if(off != ~0ULL)
if(v == ~0ULL) offp = &off;
return read(arg, nil); else
offp = nil;
return read(arg, &v); return (uintptr)read(fd, buf, len, offp);
} }
static long static long
write(ulong *arg, vlong *offp) write(int fd, void *buf, long len, vlong *offp)
{ {
Chan *c; Chan *c;
long m, n; long m, n;
vlong off; vlong off;
validaddr(arg[1], arg[2], 0); validaddr((uintptr)buf, len, 0);
n = 0; n = 0;
c = fdtochan(arg[0], OWRITE, 1, 1); c = fdtochan(fd, OWRITE, 1, 1);
if(waserror()) { if(waserror()) {
if(offp == nil){ if(offp == nil){
lock(c); lock(c);
@ -738,7 +752,7 @@ write(ulong *arg, vlong *offp)
if(c->qid.type & QTDIR) if(c->qid.type & QTDIR)
error(Eisdir); error(Eisdir);
n = arg[2]; n = len;
if(offp == nil){ /* use and maintain channel's offset */ if(offp == nil){ /* use and maintain channel's offset */
lock(c); lock(c);
@ -751,8 +765,7 @@ write(ulong *arg, vlong *offp)
if(off < 0) if(off < 0)
error(Enegoff); 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){ if(offp == nil && m < n){
lock(c); lock(c);
c->offset -= n - m; c->offset -= n - m;
@ -761,47 +774,51 @@ write(ulong *arg, vlong *offp)
poperror(); poperror();
cclose(c); cclose(c);
return m; return m;
} }
long uintptr
sys_write(ulong *arg) 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 uintptr
syspwrite(ulong *arg) syspwrite(va_list list)
{ {
vlong v; int fd;
va_list list; void *buf;
long len;
vlong off, *offp;
/* use varargs to guarantee alignment of vlong */ fd = va_arg(list, int);
va_start(list, arg[2]); buf = va_arg(list, void*);
v = va_arg(list, vlong); len = va_arg(list, long);
va_end(list); off = va_arg(list, vlong);
if(off != ~0ULL)
if(v == ~0ULL) offp = &off;
return write(arg, nil); else
offp = nil;
return write(arg, &v); return (uintptr)write(fd, buf, len, offp);
} }
static void static vlong
sseek(ulong *arg) sseek(int fd, vlong o, int type)
{ {
Chan *c; Chan *c;
uchar buf[sizeof(Dir)+100]; uchar buf[sizeof(Dir)+100];
Dir dir; Dir dir;
int n; int n;
vlong off; vlong off;
union {
vlong v;
ulong u[2];
} o;
c = fdtochan(arg[1], -1, 1, 1); c = fdtochan(fd, -1, 1, 1);
if(waserror()){ if(waserror()){
cclose(c); cclose(c);
nexterror(); nexterror();
@ -810,11 +827,9 @@ sseek(ulong *arg)
error(Eisstream); error(Eisstream);
off = 0; off = 0;
o.u[0] = arg[2]; switch(type){
o.u[1] = arg[3];
switch(arg[4]){
case 0: case 0:
off = o.v; off = o;
if((c->qid.type & QTDIR) && off != 0) if((c->qid.type & QTDIR) && off != 0)
error(Eisdir); error(Eisdir);
if(off < 0) if(off < 0)
@ -826,7 +841,7 @@ sseek(ulong *arg)
if(c->qid.type & QTDIR) if(c->qid.type & QTDIR)
error(Eisdir); error(Eisdir);
lock(c); /* lock for read/write update */ lock(c); /* lock for read/write update */
off = o.v + c->offset; off = o + c->offset;
if(off < 0){ if(off < 0){
unlock(c); unlock(c);
error(Enegoff); error(Enegoff);
@ -841,7 +856,7 @@ sseek(ulong *arg)
n = devtab[c->type]->stat(c, buf, sizeof buf); n = devtab[c->type]->stat(c, buf, sizeof buf);
if(convM2D(buf, n, &dir, nil) == 0) if(convM2D(buf, n, &dir, nil) == 0)
error("internal error: stat error in seek"); error("internal error: stat error in seek");
off = dir.length + o.v; off = dir.length + o;
if(off < 0) if(off < 0)
error(Enegoff); error(Enegoff);
c->offset = off; c->offset = off;
@ -850,38 +865,41 @@ sseek(ulong *arg)
default: default:
error(Ebadarg); error(Ebadarg);
} }
*(vlong*)arg[0] = off;
c->uri = 0; c->uri = 0;
c->dri = 0; c->dri = 0;
cclose(c); cclose(c);
poperror(); poperror();
return off;
} }
long uintptr
sysseek(ulong *arg) sysseek(va_list list)
{ {
validaddr(arg[0], BY2V, 1); int fd, t;
sseek(arg); 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; return 0;
} }
long uintptr
sysoseek(ulong *arg) sysoseek(va_list list)
{ {
union { int fd, t;
vlong v; long n;
ulong u[2];
} o;
ulong a[5];
o.v = (long)arg[1]; fd = va_arg(list, int);
a[0] = (ulong)&o.v; n = va_arg(list, long);
a[1] = arg[0]; t = va_arg(list, int);
a[2] = o.u[0]; return (uintptr)sseek(fd, n, t);
a[3] = o.u[1];
a[4] = arg[2];
sseek(a);
return o.v;
} }
void void
@ -926,58 +944,67 @@ pathlast(Path *p)
return p->s; return p->s;
} }
long uintptr
sysfstat(ulong *arg) sysfstat(va_list list)
{ {
Chan *c; Chan *c;
int fd;
uint l; uint l;
uchar *s;
l = arg[2]; fd = va_arg(list, int);
validaddr(arg[1], l, 1); s = va_arg(list, uchar*);
c = fdtochan(arg[0], -1, 0, 1); l = va_arg(list, uint);
validaddr((uintptr)s, l, 1);
c = fdtochan(fd, -1, 0, 1);
if(waserror()) { if(waserror()) {
cclose(c); cclose(c);
nexterror(); nexterror();
} }
l = devtab[c->type]->stat(c, (uchar*)arg[1], l); l = devtab[c->type]->stat(c, s, l);
poperror(); poperror();
cclose(c); cclose(c);
return l; return l;
} }
long uintptr
sysstat(ulong *arg) sysstat(va_list list)
{ {
char *name; char *name;
Chan *c; Chan *c;
uint l; uint l, r;
uchar *s;
l = arg[2]; name = va_arg(list, char*);
validaddr(arg[1], l, 1); s = va_arg(list, uchar*);
validaddr(arg[0], 1, 0); l = va_arg(list, uint);
c = namec((char*)arg[0], Aaccess, 0, 0); validaddr((uintptr)s, l, 1);
validaddr((uintptr)name, 1, 0);
c = namec(name, Aaccess, 0, 0);
if(waserror()){ if(waserror()){
cclose(c); cclose(c);
nexterror(); nexterror();
} }
l = devtab[c->type]->stat(c, (uchar*)arg[1], l); r = devtab[c->type]->stat(c, s, l);
name = pathlast(c->path); name = pathlast(c->path);
if(name) if(name)
l = dirsetname(name, strlen(name), (uchar*)arg[1], l, arg[2]); r = dirsetname(name, strlen(name), s, r, l);
poperror(); poperror();
cclose(c); cclose(c);
return l; return r;
} }
long uintptr
syschdir(ulong *arg) syschdir(va_list list)
{ {
Chan *c; Chan *c;
char *name;
validaddr(arg[0], 1, 0); name = va_arg(list, char*);
validaddr((uintptr)name, 1, 0);
c = namec((char*)arg[0], Atodir, 0, 0); c = namec(name, Atodir, 0, 0);
cclose(up->dot); cclose(up->dot);
up->dot = c; up->dot = c;
return 0; return 0;
@ -999,7 +1026,7 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
error(Ebadarg); error(Ebadarg);
if(ismount){ if(ismount){
validaddr((ulong)spec, 1, 0); validaddr((uintptr)spec, 1, 0);
spec = validnamedup(spec, 1); spec = validnamedup(spec, 1);
if(waserror()){ if(waserror()){
free(spec); free(spec);
@ -1033,7 +1060,7 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
cclose(bc); cclose(bc);
}else{ }else{
spec = 0; spec = 0;
validaddr((ulong)arg0, 1, 0); validaddr((uintptr)arg0, 1, 0);
c0 = namec(arg0, Abind, 0, 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(); nexterror();
} }
validaddr((ulong)arg1, 1, 0); validaddr((uintptr)arg1, 1, 0);
c1 = namec(arg1, Amount, 0, 0); c1 = namec(arg1, Amount, 0, 0);
if(waserror()){ if(waserror()){
cclose(c1); cclose(c1);
@ -1063,33 +1090,59 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
return ret; return ret;
} }
long uintptr
sysbind(ulong *arg) 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 uintptr
sysmount(ulong *arg) 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 uintptr
sys_mount(ulong *arg) 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 uintptr
sysunmount(ulong *arg) sysunmount(va_list list)
{ {
Chan *cmount, *cmounted; Chan *cmount, *cmounted;
char *name, *old;
name = va_arg(list, char*);
old = va_arg(list, char*);
cmounted = 0; cmounted = 0;
validaddr((uintptr)old, 1, 0);
validaddr(arg[1], 1, 0); cmount = namec(old, Amount, 0, 0);
cmount = namec((char *)arg[1], Amount, 0, 0);
if(waserror()) { if(waserror()) {
cclose(cmount); cclose(cmount);
if(cmounted) if(cmounted)
@ -1097,15 +1150,15 @@ sysunmount(ulong *arg)
nexterror(); nexterror();
} }
if(arg[0]) { if(name) {
/* /*
* This has to be namec(..., Aopen, ...) because * This has to be namec(..., Aopen, ...) because
* if arg[0] is something like /srv/cs or /fd/0, * if arg[0] is something like /srv/cs or /fd/0,
* opening it is the only way to get at the real * opening it is the only way to get at the real
* Chan underneath. * Chan underneath.
*/ */
validaddr(arg[0], 1, 0); validaddr((uintptr)name, 1, 0);
cmounted = namec((char*)arg[0], Aopen, OREAD, 0); cmounted = namec(name, Aopen, OREAD, 0);
} }
cunmount(cmount, cmounted); cunmount(cmount, cmounted);
poperror(); poperror();
@ -1115,15 +1168,19 @@ sysunmount(ulong *arg)
return 0; return 0;
} }
long uintptr
syscreate(ulong *arg) syscreate(va_list list)
{ {
int fd; int fd, mode, perm;
char *name;
Chan *c; Chan *c;
openmode(arg[1]&~OEXCL); /* error check only; OEXCL okay here */ name = va_arg(list, char*);
validaddr(arg[0], 1, 0); mode = va_arg(list, int);
c = namec((char*)arg[0], Acreate, arg[1], arg[2]); 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()) { if(waserror()) {
cclose(c); cclose(c);
nexterror(); nexterror();
@ -1132,16 +1189,18 @@ syscreate(ulong *arg)
if(fd < 0) if(fd < 0)
error(Enofd); error(Enofd);
poperror(); poperror();
return fd; return (uintptr)fd;
} }
long uintptr
sysremove(ulong *arg) sysremove(va_list list)
{ {
char *name;
Chan *c; Chan *c;
validaddr(arg[0], 1, 0); name = va_arg(list, char*);
c = namec((char*)arg[0], Aremove, 0, 0); validaddr((uintptr)name, 1, 0);
c = namec(name, Aremove, 0, 0);
/* /*
* Removing mount points is disallowed to avoid surprises * Removing mount points is disallowed to avoid surprises
* (which should be removed: the mount point or the mounted Chan?). * (which should be removed: the mount point or the mounted Chan?).
@ -1191,31 +1250,39 @@ wstat(Chan *c, uchar *d, int nd)
return l; return l;
} }
long uintptr
syswstat(ulong *arg) syswstat(va_list list)
{ {
char *name;
uchar *s;
Chan *c; Chan *c;
uint l; uint l;
l = arg[2]; name = va_arg(list, char*);
validaddr(arg[1], l, 0); s = va_arg(list, uchar*);
validstat((uchar*)arg[1], l); l = va_arg(list, uint);
validaddr(arg[0], 1, 0); validaddr((uintptr)s, l, 0);
c = namec((char*)arg[0], Aaccess, 0, 0); validstat(s, l);
return wstat(c, (uchar*)arg[1], l); validaddr((uintptr)name, 1, 0);
c = namec(name, Aaccess, 0, 0);
return (uintptr)wstat(c, s, l);
} }
long uintptr
sysfwstat(ulong *arg) sysfwstat(va_list list)
{ {
uchar *s;
Chan *c; Chan *c;
uint l; uint l;
int fd;
l = arg[2]; fd = va_arg(list, int);
validaddr(arg[1], l, 0); s = va_arg(list, uchar*);
validstat((uchar*)arg[1], l); l = va_arg(list, uint);
c = fdtochan(arg[0], -1, 1, 1); validaddr((uintptr)s, l, 0);
return wstat(c, (uchar*)arg[1], l); validstat(s, l);
c = fdtochan(fd, -1, 1, 1);
return (uintptr)wstat(c, s, l);
} }
static void static void
@ -1252,19 +1319,21 @@ packoldstat(uchar *buf, Dir *d)
PBIT16(p, d->dev); PBIT16(p, d->dev);
} }
long uintptr
sys_stat(ulong *arg) sys_stat(va_list list)
{ {
Chan *c; Chan *c;
uint l; 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; char strs[128], *name;
Dir d; Dir d;
char old[] = "old stat system call - recompile"; char old[] = "old stat system call - recompile";
validaddr(arg[1], 116, 1); name = va_arg(list, char*);
validaddr(arg[0], 1, 0); s = va_arg(list, uchar*);
c = namec((char*)arg[0], Aaccess, 0, 0); validaddr((uintptr)s, 116, 1);
validaddr((uintptr)name, 1, 0);
c = namec(name, Aaccess, 0, 0);
if(waserror()){ if(waserror()){
cclose(c); cclose(c);
nexterror(); nexterror();
@ -1279,26 +1348,29 @@ sys_stat(ulong *arg)
l = convM2D(buf, l, &d, strs); l = convM2D(buf, l, &d, strs);
if(l == 0) if(l == 0)
error(old); error(old);
packoldstat((uchar*)arg[1], &d); packoldstat(s, &d);
poperror(); poperror();
cclose(c); cclose(c);
return 0; return 0;
} }
long uintptr
sys_fstat(ulong *arg) sys_fstat(va_list list)
{ {
Chan *c; Chan *c;
char *name; char *name;
uint l; 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]; char strs[128];
Dir d; Dir d;
char old[] = "old fstat system call - recompile"; char old[] = "old fstat system call - recompile";
int fd;
validaddr(arg[1], 116, 1); fd = va_arg(list, int);
c = fdtochan(arg[0], -1, 0, 1); s = va_arg(list, uchar*);
validaddr((uintptr)s, 116, 1);
c = fdtochan(fd, -1, 0, 1);
if(waserror()){ if(waserror()){
cclose(c); cclose(c);
nexterror(); nexterror();
@ -1313,23 +1385,23 @@ sys_fstat(ulong *arg)
l = convM2D(buf, l, &d, strs); l = convM2D(buf, l, &d, strs);
if(l == 0) if(l == 0)
error(old); error(old);
packoldstat((uchar*)arg[1], &d); packoldstat(s, &d);
poperror(); poperror();
cclose(c); cclose(c);
return 0; return 0;
} }
long uintptr
sys_wstat(ulong *) sys_wstat(va_list)
{ {
error("old wstat system call - recompile"); error("old wstat system call - recompile");
return -1; return (uintptr)-1;
} }
long uintptr
sys_fwstat(ulong *) sys_fwstat(va_list)
{ {
error("old fwstat system call - recompile"); error("old fwstat system call - recompile");
return -1; return (uintptr)-1;
} }

311
sys/src/9/port/sysproc.c
View file

@ -14,8 +14,8 @@ int shargs(char*, int, char**);
extern void checkpages(void); extern void checkpages(void);
extern void checkpagerefs(void); extern void checkpagerefs(void);
long uintptr
sysr1(ulong*) sysr1(va_list)
{ {
if(!iseve()) if(!iseve())
error(Eperm); error(Eperm);
@ -29,8 +29,8 @@ abortion(void*)
pexit("fork aborted", 1); pexit("fork aborted", 1);
} }
long uintptr
sysrfork(ulong *arg) sysrfork(va_list list)
{ {
Proc *p; Proc *p;
int n, i; int n, i;
@ -41,7 +41,7 @@ sysrfork(ulong *arg)
ulong pid, flag; ulong pid, flag;
Mach *wm; Mach *wm;
flag = arg[0]; flag = va_arg(list, ulong);
/* Check flags before we commit */ /* Check flags before we commit */
if((flag & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG)) if((flag & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
error(Ebadarg); error(Ebadarg);
@ -221,7 +221,7 @@ sysrfork(ulong *arg)
procwired(p, wm->machno); procwired(p, wm->machno);
ready(p); ready(p);
sched(); sched();
return pid; return (uintptr)pid;
} }
static ulong static ulong
@ -233,29 +233,30 @@ l2be(long l)
return (cp[0]<<24) | (cp[1]<<16) | (cp[2]<<8) | cp[3]; return (cp[0]<<24) | (cp[1]<<16) | (cp[2]<<8) | cp[3];
} }
long uintptr
sysexec(ulong *arg) sysexec(va_list list)
{ {
Segment *s, *ts; Segment *s, *ts;
ulong t, d, b;
int i; int i;
Chan *tc; Chan *tc;
char **argv, **argp; char **argv, **argp, **argp0;
char *a, *charp, *args, *file, *file0; char *a, *charp, *args, *file, *file0;
char *progarg[sizeof(Exec)/2+1], *elem, progelem[64]; 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; int indir;
Exec exec; Exec exec;
char line[sizeof(Exec)]; char line[sizeof(Exec)];
Fgrp *f; Fgrp *f;
Image *img; Image *img;
ulong magic, text, entry, data, bss;
Tos *tos; Tos *tos;
a = nil; a = nil;
elem = nil; elem = nil;
validaddr(arg[0], 1, 0); file0 = va_arg(list, char*);
file0 = validnamedup((char*)arg[0], 1); validaddr((uintptr)file0, 1, 0);
argp0 = va_arg(list, char**);
file0 = validnamedup(file0, 1);
if(waserror()){ if(waserror()){
free(file0); free(file0);
free(elem); free(elem);
@ -305,8 +306,7 @@ sysexec(ulong *arg)
*/ */
progarg[n++] = file; progarg[n++] = file;
progarg[n] = 0; progarg[n] = 0;
validaddr(arg[1], BY2WD, 1); argp0++;
arg[1] += BY2WD;
file = progarg[0]; file = progarg[0];
if(strlen(elem) >= sizeof progelem) if(strlen(elem) >= sizeof progelem)
error(Ebadexec); error(Ebadexec);
@ -338,14 +338,14 @@ sysexec(ulong *arg)
nargs++; nargs++;
} }
} }
evenaddr(arg[1]); argp = argp0;
argp = (char**)arg[1]; evenaddr((uintptr)argp);
validaddr((ulong)argp, BY2WD, 0); validaddr((uintptr)argp, BY2WD, 0);
while(*argp){ while(*argp){
a = *argp++; a = *argp++;
if(((ulong)argp&(BY2PG-1)) < BY2WD) if(((uintptr)argp&(BY2PG-1)) < BY2WD)
validaddr((ulong)argp, BY2WD, 0); validaddr((uintptr)argp, BY2WD, 0);
validaddr((ulong)a, 1, 0); validaddr((uintptr)a, 1, 0);
nbytes += ((char*)vmemchr(a, 0, 0x7FFFFFFF) - a) + 1; nbytes += ((char*)vmemchr(a, 0, 0x7FFFFFFF) - a) + 1;
nargs++; nargs++;
} }
@ -393,12 +393,12 @@ sysexec(ulong *arg)
if(indir) if(indir)
argp = progarg; argp = progarg;
else else
argp = (char**)arg[1]; argp = argp0;
for(i=0; i<nargs; i++){ for(i=0; i<nargs; i++){
if(indir && *argp==0) { if(indir && *argp==0) {
indir = 0; indir = 0;
argp = (char**)arg[1]; argp = argp0;
} }
*argv++ = charp + (USTKTOP-tstk); *argv++ = charp + (USTKTOP-tstk);
n = strlen(*argp) + 1; n = strlen(*argp) + 1;
@ -557,45 +557,45 @@ return0(void*)
return 0; return 0;
} }
long uintptr
syssleep(ulong *arg) syssleep(va_list list)
{ {
long ms;
int n; ms = va_arg(list, long);
if(ms <= 0) {
n = arg[0];
if(n <= 0) {
if (up->edf && (up->edf->flags & Admitted)) if (up->edf && (up->edf->flags & Admitted))
edfyield(); edfyield();
else else
yield(); 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; return 0;
} }
long uintptr
sysalarm(ulong *arg) 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 *status;
char *inval = "invalid exit string"; char *inval = "invalid exit string";
char buf[ERRMAX]; char buf[ERRMAX];
status = (char*)arg[0]; status = va_arg(list, char*);
if(status){ if(status){
if(waserror()) if(waserror())
status = inval; status = inval;
else{ else{
validaddr((ulong)status, 1, 0); validaddr((uintptr)status, 1, 0);
if(vmemchr(status, 0, ERRMAX) == 0){ if(vmemchr(status, 0, ERRMAX) == 0){
memmove(buf, status, ERRMAX); memmove(buf, status, ERRMAX);
buf[ERRMAX-1] = 0; buf[ERRMAX-1] = 0;
@ -606,53 +606,57 @@ sysexits(ulong *arg)
} }
pexit(status, 1); pexit(status, 1);
return 0; /* not reached */ return 0; /* not reached */
} }
long uintptr
sys_wait(ulong *arg) sys_wait(va_list list)
{ {
int pid; int pid;
Waitmsg w; Waitmsg w;
OWaitmsg *ow; OWaitmsg *ow;
if(arg[0] == 0) ow = va_arg(list, OWaitmsg*);
return pwait(nil); if(ow == 0)
pid = pwait(nil);
validaddr(arg[0], sizeof(OWaitmsg), 1); else {
evenaddr(arg[0]); validaddr((uintptr)ow, sizeof(OWaitmsg), 1);
pid = pwait(&w); evenaddr((uintptr)ow);
if(pid >= 0){ pid = pwait(&w);
ow = (OWaitmsg*)arg[0]; if(pid >= 0){
readnum(0, ow->pid, NUMSIZE, w.pid, NUMSIZE); readnum(0, ow->pid, NUMSIZE, w.pid, NUMSIZE);
readnum(0, ow->time+TUser*NUMSIZE, NUMSIZE, w.time[TUser], 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+TSys*NUMSIZE, NUMSIZE, w.time[TSys], NUMSIZE);
readnum(0, ow->time+TReal*NUMSIZE, NUMSIZE, w.time[TReal], NUMSIZE); readnum(0, ow->time+TReal*NUMSIZE, NUMSIZE, w.time[TReal], NUMSIZE);
strncpy(ow->msg, w.msg, sizeof(ow->msg)-1); strncpy(ow->msg, w.msg, sizeof(ow->msg)-1);
ow->msg[sizeof(ow->msg)-1] = '\0'; ow->msg[sizeof(ow->msg)-1] = '\0';
}
} }
return pid; return (uintptr)pid;
} }
long uintptr
sysawait(ulong *arg) sysawait(va_list list)
{ {
int i; int i;
int pid; int pid;
char *p;
Waitmsg w; Waitmsg w;
ulong n; uint n;
n = arg[1]; p = va_arg(list, char*);
validaddr(arg[0], n, 1); n = va_arg(list, uint);
validaddr((uintptr)p, n, 1);
pid = pwait(&w); pid = pwait(&w);
if(pid < 0) if(pid < 0)
return -1; i = -1;
i = snprint((char*)arg[0], n, "%d %lud %lud %lud %q", else {
w.pid, i = snprint(p, n, "%d %lud %lud %lud %q",
w.time[TUser], w.time[TSys], w.time[TReal], w.pid,
w.msg); w.time[TUser], w.time[TSys], w.time[TReal],
w.msg);
return i; }
return (uintptr)i;
} }
void void
@ -668,14 +672,14 @@ werrstr(char *fmt, ...)
va_end(va); va_end(va);
} }
static long static int
generrstr(char *buf, uint nbuf) generrstr(char *buf, uint nbuf)
{ {
char tmp[ERRMAX]; char tmp[ERRMAX];
if(nbuf == 0) if(nbuf == 0)
error(Ebadarg); error(Ebadarg);
validaddr((ulong)buf, nbuf, 1); validaddr((uintptr)buf, nbuf, 1);
if(nbuf > sizeof tmp) if(nbuf > sizeof tmp)
nbuf = sizeof tmp; nbuf = sizeof tmp;
memmove(tmp, buf, nbuf); memmove(tmp, buf, nbuf);
@ -688,44 +692,51 @@ generrstr(char *buf, uint nbuf)
return 0; return 0;
} }
long uintptr
syserrstr(ulong *arg) 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 */ /* compatibility for old binaries */
long uintptr
sys_errstr(ulong *arg) sys_errstr(va_list list)
{ {
return generrstr((char*)arg[0], 64); return (uintptr)generrstr(va_arg(list, char*), 64);
} }
long uintptr
sysnotify(ulong *arg) sysnotify(va_list list)
{ {
if(arg[0] != 0) int (*f)(void*, char*);
validaddr(arg[0], sizeof(ulong), 0); f = va_arg(list, void*);
up->notify = (int(*)(void*, char*))(arg[0]); if(f != 0)
validaddr((uintptr)f, sizeof(void*), 0);
up->notify = f;
return 0; return 0;
} }
long uintptr
sysnoted(ulong *arg) sysnoted(va_list list)
{ {
if(arg[0]!=NRSTR && !up->notified) if(va_arg(list, int) !=NRSTR && !up->notified)
error(Egreg); error(Egreg);
return 0; return 0;
} }
long uintptr
syssegbrk(ulong *arg) syssegbrk(va_list list)
{ {
int i; int i;
ulong addr; uintptr addr;
Segment *s; Segment *s;
addr = arg[0]; addr = va_arg(list, uintptr);
for(i = 0; i < NSEG; i++) { for(i = 0; i < NSEG; i++) {
s = up->seg[i]; s = up->seg[i];
if(s == 0 || addr < s->base || addr >= s->top) if(s == 0 || addr < s->base || addr >= s->top)
@ -736,27 +747,37 @@ syssegbrk(ulong *arg)
case SG_STACK: case SG_STACK:
error(Ebadarg); error(Ebadarg);
default: default:
return ibrk(arg[1], i); return (uintptr)ibrk(va_arg(list, uintptr), i);
} }
} }
error(Ebadarg); error(Ebadarg);
return 0; /* not reached */ return 0; /* not reached */
} }
long uintptr
syssegattach(ulong *arg) 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 uintptr
syssegdetach(ulong *arg) syssegdetach(va_list list)
{ {
int i; int i;
ulong addr; uintptr addr;
Segment *s; Segment *s;
addr = va_arg(list, uintptr);
qlock(&up->seglock); qlock(&up->seglock);
if(waserror()){ if(waserror()){
qunlock(&up->seglock); qunlock(&up->seglock);
@ -764,7 +785,6 @@ syssegdetach(ulong *arg)
} }
s = 0; s = 0;
addr = arg[0];
for(i = 0; i < NSEG; i++) for(i = 0; i < NSEG; i++)
if(s = up->seg[i]) { if(s = up->seg[i]) {
qlock(&s->lk); qlock(&s->lk);
@ -795,17 +815,19 @@ found:
return 0; return 0;
} }
long uintptr
syssegfree(ulong *arg) syssegfree(va_list list)
{ {
Segment *s; Segment *s;
ulong from, to; uintptr from, to;
from = arg[0]; from = va_arg(list, uintptr);
s = seg(up, from, 1); s = seg(up, from, 1);
if(s == nil) if(s == nil)
error(Ebadarg); error(Ebadarg);
to = (from + arg[1]) & ~(BY2PG-1); to = va_arg(list, ulong);
to += from;
to &= ~(BY2PG-1);
from = PGROUND(from); from = PGROUND(from);
if(to > s->top) { if(to > s->top) {
@ -816,24 +838,24 @@ syssegfree(ulong *arg)
mfreeseg(s, from, (to - from) / BY2PG); mfreeseg(s, from, (to - from) / BY2PG);
qunlock(&s->lk); qunlock(&s->lk);
flushmmu(); flushmmu();
return 0; return 0;
} }
/* For binary compatibility */ /* For binary compatibility */
long uintptr
sysbrk_(ulong *arg) sysbrk_(va_list list)
{ {
return ibrk(arg[0], BSEG); return (uintptr)ibrk(va_arg(list, uintptr), BSEG);
} }
long uintptr
sysrendezvous(ulong *arg) sysrendezvous(va_list list)
{ {
uintptr tag, val; uintptr tag, val, new;
Proc *p, **l; Proc *p, **l;
tag = arg[0]; tag = va_arg(list, uintptr);
new = va_arg(list, uintptr);
l = &REND(up->rgrp, tag); l = &REND(up->rgrp, tag);
lock(up->rgrp); lock(up->rgrp);
@ -841,7 +863,7 @@ sysrendezvous(ulong *arg)
if(p->rendtag == tag) { if(p->rendtag == tag) {
*l = p->rendhash; *l = p->rendhash;
val = p->rendval; val = p->rendval;
p->rendval = arg[1]; p->rendval = new;
unlock(up->rgrp); unlock(up->rgrp);
ready(p); ready(p);
@ -853,7 +875,7 @@ sysrendezvous(ulong *arg)
/* Going to sleep here */ /* Going to sleep here */
up->rendtag = tag; up->rendtag = tag;
up->rendval = arg[1]; up->rendval = new;
up->rendhash = *l; up->rendhash = *l;
*l = up; *l = up;
up->state = Rendezvous; up->state = Rendezvous;
@ -1102,65 +1124,62 @@ tsemacquire(Segment *s, long *addr, ulong ms)
return 1; return 1;
} }
long uintptr
syssemacquire(ulong *arg) syssemacquire(va_list list)
{ {
int block; int block;
long *addr; long *addr;
Segment *s; Segment *s;
evenaddr(arg[0]); addr = va_arg(list, long*);
addr = (long*)arg[0]; block = va_arg(list, int);
block = arg[1]; evenaddr((uintptr)addr);
s = seg(up, (uintptr)addr, 0);
s = seg(up, (ulong)addr, 0); if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){ validaddr((uintptr)addr, sizeof(long), 1);
validaddr((ulong)addr, sizeof(long), 1);
error(Ebadarg); error(Ebadarg);
} }
if(*addr < 0) if(*addr < 0)
error(Ebadarg); error(Ebadarg);
return semacquire(s, addr, block); return (uintptr)semacquire(s, addr, block);
} }
long uintptr
systsemacquire(ulong *arg) systsemacquire(va_list list)
{ {
long *addr; long *addr;
ulong ms; ulong ms;
Segment *s; Segment *s;
evenaddr(arg[0]); addr = va_arg(list, long*);
addr = (long*)arg[0]; ms = va_arg(list, ulong);
ms = arg[1]; evenaddr((uintptr)addr);
s = seg(up, (uintptr)addr, 0);
s = seg(up, (ulong)addr, 0); if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){ validaddr((uintptr)addr, sizeof(long), 1);
validaddr((ulong)addr, sizeof(long), 1);
error(Ebadarg); error(Ebadarg);
} }
if(*addr < 0) if(*addr < 0)
error(Ebadarg); error(Ebadarg);
return tsemacquire(s, addr, ms); return (uintptr)tsemacquire(s, addr, ms);
} }
long uintptr
syssemrelease(ulong *arg) syssemrelease(va_list list)
{ {
long *addr, delta; long *addr, delta;
Segment *s; Segment *s;
evenaddr(arg[0]); addr = va_arg(list, long*);
addr = (long*)arg[0]; delta = va_arg(list, long);
delta = arg[1]; evenaddr((uintptr)addr);
s = seg(up, (uintptr)addr, 0);
s = seg(up, (ulong)addr, 0); if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){ validaddr((uintptr)addr, sizeof(long), 1);
validaddr((ulong)addr, sizeof(long), 1);
error(Ebadarg); error(Ebadarg);
} }
/* delta == 0 is a no-op, not a release */ /* delta == 0 is a no-op, not a release */
if(delta < 0 || *addr < 0) if(delta < 0 || *addr < 0)
error(Ebadarg); error(Ebadarg);
return semrelease(s, addr, delta); return (uintptr)semrelease(s, addr, delta);
} }

2
sys/src/9/port/systab.h
View file

@ -1,6 +1,6 @@
#include "/sys/src/libc/9syscall/sys.h" #include "/sys/src/libc/9syscall/sys.h"
typedef long Syscall(ulong*); typedef uintptr Syscall(va_list);
Syscall sysr1; Syscall sysr1;
Syscall sys_errstr; Syscall sys_errstr;

18
sys/src/9/port/taslock.c
View file

@ -51,12 +51,12 @@ dumplockmem(char *tag, Lock *l)
} }
void void
lockloop(Lock *l, ulong pc) lockloop(Lock *l, uintptr pc)
{ {
Proc *p; Proc *p;
p = l->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); l, l->key, pc, l->pc, p ? p->pid : 0);
dumpaproc(up); dumpaproc(up);
if(p != nil) if(p != nil)
@ -67,7 +67,7 @@ int
lock(Lock *l) lock(Lock *l)
{ {
int i; int i;
ulong pc; uintptr pc;
pc = getcallerpc(&l); pc = getcallerpc(&l);
@ -98,7 +98,7 @@ lock(Lock *l)
* Priority inversion, yield on a uniprocessor; on a * Priority inversion, yield on a uniprocessor; on a
* multiprocessor, the other processor will unlock * 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); l, pc, up ? up->pid : 0, l->pc, l->p ? l->p->pid : 0);
up->edf->d = todget(nil); /* yield to process with lock */ up->edf->d = todget(nil); /* yield to process with lock */
} }
@ -129,7 +129,7 @@ void
ilock(Lock *l) ilock(Lock *l)
{ {
ulong x; ulong x;
ulong pc; uintptr pc;
pc = getcallerpc(&l); pc = getcallerpc(&l);
lockstats.locks++; lockstats.locks++;
@ -203,9 +203,9 @@ unlock(Lock *l)
if(l->key == 0) if(l->key == 0)
print("unlock: not locked: pc %#p\n", getcallerpc(&l)); print("unlock: not locked: pc %#p\n", getcallerpc(&l));
if(l->isilock) 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) 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->m = nil;
l->key = 0; l->key = 0;
coherence(); coherence();
@ -240,9 +240,9 @@ iunlock(Lock *l)
if(l->key == 0) if(l->key == 0)
print("iunlock: not locked: pc %#p\n", getcallerpc(&l)); print("iunlock: not locked: pc %#p\n", getcallerpc(&l));
if(!l->isilock) 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()) 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; sr = l->sr;
l->m = nil; l->m = nil;

2
sys/src/9/ppc/mmu.c
View file

@ -262,7 +262,7 @@ putmmu(ulong va, ulong pa, Page *pg)
} }
void void
checkmmu(ulong, ulong) checkmmu(uintptr, uintptr)
{ {
} }

10
sys/src/9/ppc/trap.c
View file

@ -525,8 +525,8 @@ evenaddr(ulong addr)
} }
} }
long uintptr
execregs(ulong entry, ulong ssize, ulong nargs) execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
ulong *sp; ulong *sp;
Ureg *ureg; Ureg *ureg;
@ -559,7 +559,7 @@ forkchild(Proc *p, Ureg *ur)
p->insyscall = 0; p->insyscall = 0;
} }
ulong uintptr
userpc(void) userpc(void)
{ {
Ureg *ureg; Ureg *ureg;
@ -593,7 +593,7 @@ setkernur(Ureg* ureg, Proc* p)
ureg->sp = p->sched.sp+4; ureg->sp = p->sched.sp+4;
} }
ulong uintptr
dbgpc(Proc *p) dbgpc(Proc *p)
{ {
Ureg *ureg; Ureg *ureg;
@ -651,7 +651,7 @@ syscall(Ureg* ureg)
up->s = *((Sargs*)(sp+BY2WD)); up->s = *((Sargs*)(sp+BY2WD));
up->psstate = sysctab[scallnr]; up->psstate = sysctab[scallnr];
ret = systab[scallnr](up->s.args); ret = systab[scallnr]((va_list)up->s.args);
poperror(); poperror();
}else{ }else{
/* failure: save the error buffer for errstr */ /* failure: save the error buffer for errstr */

6
sys/src/9/teg2/syscall.c
View file

@ -248,7 +248,7 @@ syscall(Ureg* ureg)
/* iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */ /* 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(); poperror();
}else{ }else{
/* failure: save the error buffer for errstr */ /* failure: save the error buffer for errstr */
@ -304,8 +304,8 @@ syscall(Ureg* ureg)
kexit(ureg); kexit(ureg);
} }
long uintptr
execregs(ulong entry, ulong ssize, ulong nargs) execregs(uintptr entry, ulong ssize, ulong nargs)
{ {
ulong *sp; ulong *sp;
Ureg *ureg; Ureg *ureg;