extern void checkpages(void);
extern void checkpagerefs(void);
-long
-sysr1(ulong*)
+uintptr
+sysr1(va_list)
{
if(!iseve())
error(Eperm);
pexit("fork aborted", 1);
}
-long
-sysrfork(ulong *arg)
+uintptr
+sysrfork(va_list list)
{
Proc *p;
int n, i;
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);
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, align;
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);
+ args = elem = nil;
+ 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);
- free(a);
+ free(args);
/* Disaster after commit */
if(!up->seg[SSEG])
pexit(up->errstr, 1);
nexterror();
}
+ align = BY2PG;
indir = 0;
file = file0;
for(;;){
text = l2be(exec.text);
entry = l2be(exec.entry);
if(n==sizeof(Exec) && (magic == AOUT_MAGIC)){
- if(text >= USTKTOP-UTZERO
+ if(magic == S_MAGIC){
+ text += 8;
+ align = 0x200000ull; /* 2MB segment alignment for amd64 */
+ }
+ if(text >= (USTKTOP-USTKSIZE)-(UTZERO+sizeof(Exec))
|| entry < UTZERO+sizeof(Exec)
|| entry >= UTZERO+sizeof(Exec)+text)
error(Ebadexec);
*/
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);
data = l2be(exec.data);
bss = l2be(exec.bss);
- t = (UTZERO+sizeof(Exec)+text+(BY2PG-1)) & ~(BY2PG-1);
- d = (t + data + (BY2PG-1)) & ~(BY2PG-1);
+ align--;
+ t = (UTZERO+sizeof(Exec)+text+align) & ~align;
+ align = BY2PG-1;
+ d = (t + data + align) & ~align;
bssend = t + data + bss;
- b = (bssend + (BY2PG-1)) & ~(BY2PG-1);
- if(t >= KZERO || d >= KZERO || b >= KZERO)
+ b = (bssend + align) & ~align;
+ if(t >= (USTKTOP-USTKSIZE) || d >= (USTKTOP-USTKSIZE) || b >= (USTKTOP-USTKSIZE))
error(Ebadexec);
/*
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++;
}
* 8-byte align SP for those (e.g. sparc) that need it.
* execregs() will subtract another 4 bytes for argc.
*/
- if((ssize+4) & 7)
+ if(BY2WD == 4 && (ssize+4) & 7)
ssize += 4;
if(PGROUND(ssize) >= USTKSIZE)
argv = (char**)(tstk - ssize);
charp = (char*)(tstk - nbytes);
- args = charp;
+ a = charp;
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;
}
/* copy args; easiest from new process's stack */
- n = charp - args;
+ n = charp - a;
if(n > 128) /* don't waste too much space on huge arg lists */
n = 128;
- a = smalloc(n);
- memmove(a, args, n);
- if(n>0 && a[n-1]!='\0'){
+ args = smalloc(n);
+ memmove(args, a, n);
+ if(n>0 && args[n-1]!='\0'){
/* make sure last arg is NUL-terminated */
/* put NUL at UTF-8 character boundary */
for(i=n-1; i>0; --i)
- if(fullrune(a+i, n-i))
+ if(fullrune(args+i, n-i))
break;
- a[i] = 0;
+ args[i] = 0;
n = i+1;
}
free(up->text);
up->text = elem;
free(up->args);
- up->args = a;
+ up->args = args;
up->nargs = n;
up->setargs = 0;
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 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;
}
pexit(status, 1);
- return 0; /* not reached */
+ return 0; /* not reached */
}
-long
-sys_wait(ulong *arg)
+uintptr
+sys_wait(va_list list)
{
- int pid;
+ ulong 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];
+ ow = va_arg(list, OWaitmsg*);
+ if(ow == nil)
+ pid = pwait(nil);
+ else {
+ validaddr((uintptr)ow, sizeof(OWaitmsg), 1);
+ evenaddr((uintptr)ow);
+ pid = pwait(&w);
+ }
+ if(ow != nil){
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);
return pid;
}
-long
-sysawait(ulong *arg)
+uintptr
+sysawait(va_list list)
{
- int i;
- int pid;
+ char *p;
Waitmsg w;
- ulong n;
-
- n = arg[1];
- validaddr(arg[0], n, 1);
- pid = pwait(&w);
- if(pid < 0)
- return -1;
- i = snprint((char*)arg[0], n, "%d %lud %lud %lud %q",
+ uint n;
+
+ p = va_arg(list, char*);
+ n = va_arg(list, uint);
+ validaddr((uintptr)p, n, 1);
+ pwait(&w);
+ return (uintptr)snprint(p, n, "%d %lud %lud %lud %q",
w.pid,
w.time[TUser], w.time[TSys], w.time[TReal],
w.msg);
-
- return i;
}
void
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);
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)
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);
}
s = 0;
- addr = arg[0];
for(i = 0; i < NSEG; i++)
if(s = up->seg[i]) {
qlock(&s->lk);
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) {
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);
if(p->rendtag == tag) {
*l = p->rendhash;
val = p->rendval;
- p->rendval = arg[1];
+ p->rendval = new;
unlock(up->rgrp);
ready(p);
/* Going to sleep here */
up->rendtag = tag;
- up->rendval = arg[1];
+ up->rendval = new;
up->rendhash = *l;
*l = up;
up->state = Rendezvous;
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);
+}
+
+/* For binary compatibility */
+uintptr
+sys_nsec(va_list list)
+{
+ vlong *v;
+
+ v = va_arg(list, vlong*);
+ evenaddr((uintptr)v);
+ validaddr((uintptr)v, sizeof(vlong), 1);
+ *v = todget(nil);
+ return 0;
}
projects / plan9front.git / blobdiff