shithub: elf-loader

Download patch

ref: e5e12f806ecf322946c093fe59d909beb9160d0c
author: kws <kws@cirno>
date: Sun Aug 4 16:50:18 EDT 2024 

elf loader


--- /dev/null
+++ b/bind.rc
@@ -1,0 +1,4 @@
+#!/bin/rc
+
+bind -b sys/include /sys/include
+bind -bc sys/src/9/port /sys/src/9/port
--- /dev/null
+++ b/hello/Makefile
@@ -1,0 +1,23 @@
+CFLAGS=\
+	-O2\
+	-Wall\
+	-fno-pie\
+	-mno-mmx\
+	-mno-sse\
+	-mno-sse2\
+	-ffreestanding
+
+LDFLAGS=\
+	-nostdlib\
+	-no-pie\
+	-Tlinker.ld
+
+hello.elf:	l.o hello.o linker.ld
+	$(LD) -o $@ l.o hello.o $(LDFLAGS)
+
+CC=	x86_64-elf-gcc
+AS=	x86_64-elf-as
+LD=	x86_64-elf-ld
+
+clean:
+	rm -f *.o hello.elf
--- /dev/null
+++ b/hello/hello.c
@@ -1,0 +1,44 @@
+#define SYS_EXITS	8
+#define SYS_PWRITE	51
+
+typedef long long	vlong;
+
+extern vlong syscall(vlong, ...);
+
+_Noreturn
+void
+exits(char *msg)
+{
+	syscall(SYS_EXITS, msg);
+	__builtin_unreachable();
+}
+
+long
+pwrite(int fd, void *buf, long nbytes, vlong offset)
+{
+	return syscall(SYS_PWRITE, fd, buf, nbytes, offset);
+}
+
+long
+strlen(char *s)
+{
+	char *p;
+	for(p = s; *s; s++);
+	return s-p;
+}
+
+void
+puts(char *s)
+{
+	pwrite(1, s, strlen(s), -1LL);
+	pwrite(1, "\n", 1, -1LL);
+}
+
+_Noreturn
+void
+main(char *argv[])
+{
+	while(*argv)
+		puts(*argv++);
+	exits(0);
+}
--- /dev/null
+++ b/hello/l.s
@@ -1,0 +1,23 @@
+	.global _start
+_start:
+	lea	0x08(%rsp), %rdi
+	call	main
+1:	jmp	1b
+
+	.global syscall
+syscall:
+	sub	$0x40, %rsp
+	mov	%rbp, 0x28(%rsp)
+	mov	%rbx, 0x30(%rsp)
+
+	mov	%rdi, %rbp
+	mov	%rsi, 0x08(%rsp)
+	mov	%rdx, 0x10(%rsp)
+	mov	%rcx, 0x18(%rsp)
+	mov	%r8, 0x20(%rsp)
+	syscall
+
+	mov	0x28(%rsp), %rbp
+	mov	0x30(%rsp), %rbx
+	add	$0x40, %rsp
+	ret
--- /dev/null
+++ b/hello/linker.ld
@@ -1,0 +1,33 @@
+OUTPUT_FORMAT(elf64-x86-64)
+
+PHDRS {
+	text	PT_LOAD FILEHDR PHDRS;
+	data	PT_LOAD;
+}
+
+UTZERO = 0x200000;
+MAXPAGESIZE = 2M;
+
+SECTIONS {
+	. = UTZERO + SIZEOF_HEADERS;
+
+	.text : {
+		*(.text*)
+	} :text
+
+	. = ALIGN(MAXPAGESIZE);
+
+	.data : {
+		*(.rodata*)
+		*(.data*)
+	} :data
+
+	.bss : {
+		*(.bss*)
+	} :data
+
+	/DISCARD/ : {
+		*(.comment*)
+		*(.eh_frame*)
+	}
+}
--- /dev/null
+++ b/sys/include/elf.h
@@ -1,0 +1,47 @@
+typedef struct Elfhdr	Elfhdr;
+typedef struct Elfphdr	Elfphdr;
+
+#define ELF_MAGIC	0x7f454c46
+
+enum {
+	EI_NIDENT	= 16,
+
+	EM_X86_64	= 62,
+	EM_AARCH64	= 183,
+};
+
+struct Elfhdr {
+	uchar	ident[16];
+	u16int	type;
+	u16int	machine;
+	u32int	version;
+	usize	entry;
+	usize	phoff;
+	usize	shoff;
+	u32int	flags;
+	u16int	ehsize;
+	u16int	phentsize;
+	u16int	phnum;
+	u16int	shentsize;
+	u16int	shnum;
+	u16int	shstrndx;
+};
+
+struct Elfphdr {
+	u32int	type;
+	u32int	flags;
+	usize	off;
+	usize	vaddr;
+	usize	paddr;
+	usize	filesz;
+	usize	memsz;
+	usize	align;
+};
+
+enum {
+	PT_LOAD	= 1,
+
+	PF_X	= 1<<0,
+	PF_W	= 1<<1,
+	PF_R	= 1<<2,
+};
--- /dev/null
+++ b/sys/src/9/port/sysproc.c
@@ -1,0 +1,1301 @@
+#include	"u.h"
+#include	"tos.h"
+#include	"../port/lib.h"
+#include	"mem.h"
+#include	"dat.h"
+#include	"fns.h"
+#include	"../port/error.h"
+#include	"edf.h"
+
+#include	<a.out.h>
+#include	<elf.h>
+
+uintptr
+sysr1(va_list)
+{
+	if(!iseve())
+		error(Eperm);
+	return 0;
+}
+
+static void
+abortion(void)
+{
+	pexit("fork aborted", 1);
+}
+
+uintptr
+sysrfork(va_list list)
+{
+	Proc *p;
+	int n, i;
+	Fgrp *ofg;
+	Pgrp *opg;
+	Rgrp *org;
+	Egrp *oeg;
+	ulong pid, flag;
+	char *devs;
+
+	flag = va_arg(list, ulong);
+	/* Check flags before we commit */
+	if((flag & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
+		error(Ebadarg);
+	if((flag & (RFNAMEG|RFCNAMEG)) == (RFNAMEG|RFCNAMEG))
+		error(Ebadarg);
+	if((flag & (RFENVG|RFCENVG)) == (RFENVG|RFCENVG))
+		error(Ebadarg);
+
+	/*
+	 * Code using RFNOMNT expects to block all but
+	 * the following devices.
+	 */
+	devs = "|decp";
+	if((flag&RFPROC) == 0) {
+		if(flag & (RFMEM|RFNOWAIT))
+			error(Ebadarg);
+		if(flag & (RFFDG|RFCFDG)) {
+			ofg = up->fgrp;
+			if(flag & RFFDG)
+				up->fgrp = dupfgrp(ofg);
+			else
+				up->fgrp = dupfgrp(nil);
+			closefgrp(ofg);
+		}
+		if(flag & (RFNAMEG|RFCNAMEG)) {
+			opg = up->pgrp;
+			up->pgrp = newpgrp();
+			if(flag & RFNAMEG)
+				pgrpcpy(up->pgrp, opg);
+			/* inherit notallowed */
+			memmove(up->pgrp->notallowed, opg->notallowed, sizeof up->pgrp->notallowed);
+			closepgrp(opg);
+		}
+		if(flag & RFNOMNT)
+			devmask(up->pgrp, 1, devs);
+		if(flag & RFREND) {
+			org = up->rgrp;
+			up->rgrp = newrgrp();
+			closergrp(org);
+		}
+		if(flag & (RFENVG|RFCENVG)) {
+			oeg = up->egrp;
+			up->egrp = smalloc(sizeof(Egrp));
+			up->egrp->ref = 1;
+			if(flag & RFENVG)
+				envcpy(up->egrp, oeg);
+			closeegrp(oeg);
+		}
+		if(flag & RFNOTEG){
+			qlock(&up->debug);
+			setnoteid(up, 0);	/* can't error() with 0 argument */
+			qunlock(&up->debug);
+		}
+		return 0;
+	}
+
+	if((p = newproc()) == nil)
+		error("no procs");
+
+	qlock(&up->debug);
+	qlock(&p->debug);
+
+	p->scallnr = up->scallnr;
+	p->s = up->s;
+	p->slash = up->slash;
+	p->dot = up->dot;
+	incref(p->dot);
+
+	p->nnote = 0;
+ 	p->notify = up->notify;
+	p->notified = 0;
+	p->notepending = 0;
+	p->lastnote = nil;
+
+	if((flag & RFNOTEG) == 0)
+		p->noteid = up->noteid;
+
+	p->procmode = up->procmode;
+	p->privatemem = up->privatemem;
+	p->noswap = up->noswap;
+	p->hang = up->hang;
+	if(up->procctl == Proc_tracesyscall)
+		p->procctl = Proc_tracesyscall;
+	p->kp = 0;
+
+	/*
+	 * Craft a return frame which will cause the child to pop out of
+	 * the scheduler in user mode with the return register zero
+	 */
+	forkchild(p, up->dbgreg);
+
+	kstrdup(&p->text, up->text);
+	kstrdup(&p->user, up->user);
+	kstrdup(&p->args, "");
+	p->nargs = 0;
+	p->setargs = 0;
+
+	p->insyscall = 0;
+	memset(p->time, 0, sizeof(p->time));
+	p->time[TReal] = MACHP(0)->ticks;
+	p->kentry = up->kentry;
+	p->pcycles = -p->kentry;
+
+	pid = pidalloc(p);
+
+	qunlock(&p->debug);
+	qunlock(&up->debug);
+
+	/* Abort the child process on error */
+	if(waserror()){
+		p->kp = 1;
+		kprocchild(p, abortion);
+		ready(p);
+		nexterror();
+	}
+
+	/* Make a new set of memory segments */
+	n = flag & RFMEM;
+	qlock(&p->seglock);
+	if(waserror()){
+		qunlock(&p->seglock);
+		nexterror();
+	}
+	for(i = 0; i < NSEG; i++)
+		if(up->seg[i] != nil)
+			p->seg[i] = dupseg(up->seg, i, n);
+	qunlock(&p->seglock);
+	poperror();
+
+	/* File descriptors */
+	if(flag & (RFFDG|RFCFDG)) {
+		if(flag & RFFDG)
+			p->fgrp = dupfgrp(up->fgrp);
+		else
+			p->fgrp = dupfgrp(nil);
+	}
+	else {
+		p->fgrp = up->fgrp;
+		incref(p->fgrp);
+	}
+
+	/* Process groups */
+	if(flag & (RFNAMEG|RFCNAMEG)) {
+		p->pgrp = newpgrp();
+		if(flag & RFNAMEG)
+			pgrpcpy(p->pgrp, up->pgrp);
+		/* inherit notallowed */
+		memmove(p->pgrp->notallowed, up->pgrp->notallowed, sizeof p->pgrp->notallowed);
+	}
+	else {
+		p->pgrp = up->pgrp;
+		incref(p->pgrp);
+	}
+	if(flag & RFNOMNT)
+		devmask(p->pgrp, 1, devs);
+
+	if(flag & RFREND)
+		p->rgrp = newrgrp();
+	else {
+		incref(up->rgrp);
+		p->rgrp = up->rgrp;
+	}
+
+	/* Environment group */
+	if(flag & (RFENVG|RFCENVG)) {
+		p->egrp = smalloc(sizeof(Egrp));
+		p->egrp->ref = 1;
+		if(flag & RFENVG)
+			envcpy(p->egrp, up->egrp);
+	}
+	else {
+		p->egrp = up->egrp;
+		incref(p->egrp);
+	}
+
+	procfork(p);
+
+	poperror();	/* abortion */
+
+	if((flag&RFNOWAIT) == 0){
+		p->parent = up;
+		lock(&up->exl);
+		up->nchild++;
+		unlock(&up->exl);
+	}
+
+	/*
+	 *  since the bss/data segments are now shareable,
+	 *  any mmu info about this process is now stale
+	 *  (i.e. has bad properties) and has to be discarded.
+	 */
+	flushmmu();
+
+	procpriority(p, up->basepri, up->fixedpri);
+	if(up->wired)
+		procwired(p, up->affinity);
+
+	ready(p);
+	sched();
+	return pid;
+}
+
+static int
+shargs(char *s, int n, char **ap, int nap)
+{
+	char *p;
+	int i;
+
+	if(n <= 2 || s[0] != '#' || s[1] != '!')
+		return -1;
+	s += 2;
+	n -= 2;		/* skip #! */
+	if((p = memchr(s, '\n', n)) == nil)
+		return 0;
+	*p = 0;
+	i = tokenize(s, ap, nap-1);
+	ap[i] = nil;
+	return i;
+}
+
+ulong
+beswal(ulong l)
+{
+	uchar *p;
+
+	p = (uchar*)&l;
+	return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
+}
+
+uvlong
+beswav(uvlong v)
+{
+	uchar *p;
+
+	p = (uchar*)&v;
+	return ((uvlong)p[0]<<56) | ((uvlong)p[1]<<48) | ((uvlong)p[2]<<40)
+				  | ((uvlong)p[3]<<32) | ((uvlong)p[4]<<24)
+				  | ((uvlong)p[5]<<16) | ((uvlong)p[6]<<8)
+				  | (uvlong)p[7];
+}
+
+uintptr
+sysexec(va_list list)
+{
+	union {
+		struct {
+			Exec;
+			uvlong	hdr[1];
+		} ehdr;
+		struct {
+			Elfhdr	ehdr;
+			Elfphdr	phdrs[2];
+		} elf;
+		char buf[256];
+	} u;
+	char line[256];
+	char *progarg[32+1];
+	volatile char *args, *elem, *file0;
+	char **argv, **argp, **argp0;
+	char *a, *e, *charp, *file;
+	int i, n, indir;
+	ulong magic, ssize, nargs, nbytes;
+	uintptr t, d, b, entry, text, data, bss, bssend, tstk, align;
+	uintptr textoff, dataoff;
+	Segment *s, *ts;
+	Image *img;
+	Tos *tos;
+	Chan *tc;
+	Fgrp *f;
+
+	textoff = 0;
+	dataoff = 0;
+	args = elem = nil;
+	file0 = va_arg(list, char*);
+	validaddr((uintptr)file0, 1, 0);
+	argp0 = va_arg(list, char**);
+	evenaddr((uintptr)argp0);
+	validaddr((uintptr)argp0, 2*BY2WD, 0);
+	if(*argp0 == nil)
+		error(Ebadarg);
+	file0 = validnamedup(file0, 1);
+	if(waserror()){
+		free(file0);
+		free(elem);
+		free(args);
+		/* Disaster after commit */
+		if(up->seg[SSEG] == nil)
+			pexit(up->errstr, 1);
+		nexterror();
+	}
+	align = BY2PG-1;
+	indir = 0;
+	file = file0;
+	for(;;){
+		tc = namec(file, Aopen, OEXEC, 0);
+		if(waserror()){
+			cclose(tc);
+			nexterror();
+		}
+		if(!indir)
+			kstrdup(&elem, up->genbuf);
+
+		n = devtab[tc->type]->read(tc, u.buf, sizeof(u.buf), 0);
+		if(n < 4)
+			error(Ebadexec);
+		magic = beswal(u.ehdr.magic);
+		if(magic == AOUT_MAGIC){
+			if(n < sizeof(Exec))
+				error(Ebadexec);
+			if(magic & HDR_MAGIC) {
+				if(n < sizeof(u.ehdr))
+					error(Ebadexec);
+				entry = beswav(u.ehdr.hdr[0]);
+				text = UTZERO+sizeof(u.ehdr);
+			} else {
+				entry = beswal(u.ehdr.entry);
+				text = UTZERO+sizeof(Exec);
+			}
+			if(entry < text)
+				error(Ebadexec);
+			text += beswal(u.ehdr.text);
+			dataoff = text-UTZERO;
+			if(text <= entry || text >= (USTKTOP-USTKSIZE))
+				error(Ebadexec);
+			data = beswal(u.ehdr.data);
+			bss = beswal(u.ehdr.bss);
+			switch(magic){
+			case S_MAGIC:	/* 2MB segment alignment for amd64 */
+				align = 0x1fffff;
+				break;
+			case P_MAGIC:	/* 16K segment alignment for spim */
+			case V_MAGIC:	/* 16K segment alignment for mips */
+				align = 0x3fff;
+				break;
+			case R_MAGIC:	/* 64K segment alignment for arm64 */
+				align = 0xffff;
+				break;
+			}
+			break; /* for binary */
+		}
+		if(magic == ELF_MAGIC){
+			if(n < sizeof(u.elf))
+				error(Ebadexec);
+			if(u.elf.ehdr.phnum != 2)
+				error(Ebadexec);
+			if(u.elf.phdrs[0].flags != (PF_X|PF_R) || u.elf.phdrs[1].flags != (PF_R|PF_W))
+				error(Ebadexec);
+			entry = u.elf.ehdr.entry;
+			text = UTZERO+u.elf.phdrs[0].filesz;
+			textoff = u.elf.phdrs[0].off;
+			data = u.elf.phdrs[1].filesz;
+			dataoff = u.elf.phdrs[1].off;
+			bss = u.elf.phdrs[1].memsz - u.elf.phdrs[1].filesz;
+			switch(u.elf.ehdr.machine){
+			case EM_X86_64:		/* 2MB segment alignment for amd64 */
+				align = 0x1fffff;
+				break;
+			case EM_AARCH64:	/* 64K segment alignment for arm64 */
+				align = 0xffff;
+				break;
+			}
+			break;
+		}
+
+		if(indir++)
+			error(Ebadexec);
+
+		/*
+		 * Process #! /bin/sh args ...
+		 */
+		memmove(line, u.buf, n);
+		n = shargs(line, n, progarg, nelem(progarg));
+		if(n < 1)
+			error(Ebadexec);
+		/*
+		 * First arg becomes complete file name
+		 */
+		progarg[n++] = file;
+		progarg[n] = nil;
+		argp0++;
+		file = progarg[0];
+		progarg[0] = elem;
+		poperror();
+		cclose(tc);
+	}
+
+	t = (text+align) & ~align;
+	text -= UTZERO;
+	align = BY2PG-1;
+	d = (t + data + align) & ~align;
+	bssend = t + data + bss;
+	b = (bssend + align) & ~align;
+	if(t >= (USTKTOP-USTKSIZE) || d >= (USTKTOP-USTKSIZE) || b >= (USTKTOP-USTKSIZE))
+		error(Ebadexec);
+
+	/*
+	 * Args: pass 1: count
+	 */
+	nbytes = sizeof(Tos);		/* hole for profiling clock at top of stack (and more) */
+	nargs = 0;
+	if(indir){
+		argp = progarg;
+		while(*argp != nil){
+			a = *argp++;
+			nbytes += strlen(a) + 1;
+			nargs++;
+		}
+	}
+	argp = argp0;
+	while(*argp != nil){
+		a = *argp++;
+		if(((uintptr)argp&(BY2PG-1)) < BY2WD)
+			validaddr((uintptr)argp, BY2WD, 0);
+		validaddr((uintptr)a, 1, 0);
+		e = vmemchr(a, 0, USTKSIZE);
+		if(e == nil)
+			error(Ebadarg);
+		nbytes += (e - a) + 1;
+		if(nbytes >= USTKSIZE)
+			error(Enovmem);
+		nargs++;
+	}
+	ssize = BY2WD*(nargs+1) + ((nbytes+(BY2WD-1)) & ~(BY2WD-1));
+
+	/*
+	 * 8-byte align SP for those (e.g. sparc) that need it.
+	 * execregs() will subtract another 4 bytes for argc.
+	 */
+	if(BY2WD == 4 && (ssize+4) & 7)
+		ssize += 4;
+
+	if(PGROUND(ssize) >= USTKSIZE)
+		error(Enovmem);
+
+	/*
+	 * Build the stack segment, putting it in kernel virtual for the moment
+	 */
+	qlock(&up->seglock);
+	if(waserror()){
+		s = up->seg[ESEG];
+		if(s != nil){
+			up->seg[ESEG] = nil;
+			putseg(s);
+		}
+		qunlock(&up->seglock);
+		nexterror();
+	}
+
+	s = up->seg[SSEG];
+	do {
+		tstk = s->base;
+		if(tstk <= USTKSIZE)
+			error(Enovmem);
+	} while((s = isoverlap(tstk-USTKSIZE, USTKSIZE)) != nil);
+	up->seg[ESEG] = newseg(SG_STACK | SG_NOEXEC, tstk-USTKSIZE, USTKSIZE/BY2PG);
+
+	/*
+	 * Args: pass 2: assemble; the pages will be faulted in
+	 */
+	tos = (Tos*)(tstk - sizeof(Tos));
+	tos->cyclefreq = m->cyclefreq;
+	tos->kcycles = 0;
+	tos->pcycles = 0;
+	tos->clock = 0;
+
+	argv = (char**)(tstk - ssize);
+	charp = (char*)(tstk - nbytes);
+	if(indir)
+		argp = progarg;
+	else
+		argp = argp0;
+
+	for(i=0; i<nargs; i++){
+		if(indir && *argp==nil) {
+			indir = 0;
+			argp = argp0;
+		}
+		*argv++ = charp + (USTKTOP-tstk);
+		a = *argp++;
+		if(indir)
+			e = strchr(a, 0);
+		else {
+			if(charp >= (char*)tos)
+				error(Ebadarg);
+			validaddr((uintptr)a, 1, 0);
+			e = vmemchr(a, 0, (char*)tos - charp);
+			if(e == nil)
+				error(Ebadarg);
+		}
+		n = (e - a) + 1;
+		memmove(charp, a, n);
+		charp += n;
+	}
+
+	/* copy args; easiest from new process's stack */
+	a = (char*)(tstk - nbytes);
+	n = charp - a;
+	if(n > 128)	/* don't waste too much space on huge arg lists */
+		n = 128;
+	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(args+i, n-i))
+				break;
+		args[i] = 0;
+		n = i+1;
+	}
+
+	/*
+	 * Committed.
+	 * Free old memory.
+	 * Special segments are maintained across exec
+	 */
+	for(i = SSEG; i <= BSEG; i++) {
+		s = up->seg[i];
+		if(s != nil) {
+			/* prevent a second free if we have an error */
+			up->seg[i] = nil;
+			putseg(s);
+		}
+	}
+	for(i = ESEG+1; i < NSEG; i++) {
+		s = up->seg[i];
+		if(s != nil && (s->type&SG_CEXEC) != 0) {
+			up->seg[i] = nil;
+			putseg(s);
+		}
+	}
+
+	/* Text.  Shared. Attaches to cache image if possible */
+	/* attachimage returns a locked cache image */
+	img = attachimage(SG_TEXT | SG_RONLY, tc, UTZERO, (t-UTZERO)>>PGSHIFT);
+	ts = img->s;
+	up->seg[TSEG] = ts;
+	ts->flushme = 1;
+	ts->fstart = textoff;
+	ts->flen = text;
+	unlock(img);
+
+	/* Data. Shared. */
+	s = newseg(SG_DATA, t, (d-t)>>PGSHIFT);
+	up->seg[DSEG] = s;
+
+	/* Attached by hand */
+	incref(img);
+	s->image = img;
+	s->fstart = dataoff;
+	s->flen = data;
+
+	/* BSS. Zero fill on demand */
+	up->seg[BSEG] = newseg(SG_BSS, d, (b-d)>>PGSHIFT);
+
+	/*
+	 * Move the stack
+	 */
+	s = up->seg[ESEG];
+	up->seg[ESEG] = nil;
+	s->base = USTKTOP-USTKSIZE;
+	s->top = USTKTOP;
+	relocateseg(s, USTKTOP-tstk);
+	up->seg[SSEG] = s;
+	qunlock(&up->seglock);
+	poperror();	/* seglock */
+
+	/*
+	 * Close on exec
+	 */
+	if((f = up->fgrp) != nil) {
+		for(i=0; i<=f->maxfd; i++)
+			fdclose(i, CCEXEC);
+	}
+
+	poperror();	/* tc */
+	cclose(tc);
+	poperror();	/* file0 */
+	free(file0);
+
+	qlock(&up->debug);
+	free(up->text);
+	up->text = elem;
+	free(up->args);
+	up->args = args;
+	up->nargs = n;
+	up->setargs = 0;
+
+	freenotes(up);
+	freenote(up->lastnote);
+	up->lastnote = nil;
+	up->notify = nil;
+	up->notified = 0;
+	up->ureg = nil;
+	up->privatemem = 0;
+	up->noswap = 0;
+	up->pcycles = -up->kentry;
+	procsetup(up);
+	qunlock(&up->debug);
+
+	up->errbuf0[0] = '\0';
+	up->errbuf1[0] = '\0';
+
+	/*
+	 *  At this point, the mmu contains info about the old address
+	 *  space and needs to be flushed
+	 */
+	flushmmu();
+
+	if(up->hang)
+		up->procctl = Proc_stopme;
+	return execregs(entry, ssize, nargs);
+}
+
+int
+return0(void*)
+{
+	return 0;
+}
+
+uintptr
+syssleep(va_list list)
+{
+	long ms;
+
+	ms = va_arg(list, long);
+	if(ms <= 0) {
+		if (up->edf != nil && (up->edf->flags & Admitted))
+			edfyield();
+		else
+			yield();
+	} else {
+		tsleep(&up->sleep, return0, 0, ms);
+	}
+	return 0;
+}
+
+uintptr
+sysalarm(va_list list)
+{
+	return procalarm(va_arg(list, ulong));
+}
+
+
+uintptr
+sysexits(va_list list)
+{
+	char *status;
+	char *inval = "invalid exit string";
+	char buf[ERRMAX];
+
+	status = va_arg(list, char*);
+	if(status != nil){
+		if(waserror())
+			status = inval;
+		else{
+			validaddr((uintptr)status, 1, 0);
+			if(vmemchr(status, 0, ERRMAX) == nil){
+				memmove(buf, status, ERRMAX);
+				buf[ERRMAX-1] = 0;
+				status = buf;
+			}
+			poperror();
+		}
+
+	}
+	pexit(status, 1);
+}
+
+uintptr
+sys_wait(va_list list)
+{
+	ulong pid;
+	Waitmsg w;
+	OWaitmsg *ow;
+
+	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);
+		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;
+}
+
+uintptr
+sysawait(va_list list)
+{
+	char *p;
+	Waitmsg w;
+	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);
+}
+
+void
+werrstr(char *fmt, ...)
+{
+	va_list va;
+
+	if(up == nil)
+		return;
+
+	va_start(va, fmt);
+	vseprint(up->syserrstr, up->syserrstr+ERRMAX, fmt, va);
+	va_end(va);
+}
+
+static int
+generrstr(char *buf, uint nbuf)
+{
+	char *err;
+
+	if(nbuf == 0)
+		error(Ebadarg);
+	if(nbuf > ERRMAX)
+		nbuf = ERRMAX;
+	validaddr((uintptr)buf, nbuf, 1);
+
+	err = up->errstr;
+	utfecpy(err, err+nbuf, buf);
+	utfecpy(buf, buf+nbuf, up->syserrstr);
+
+	up->errstr = up->syserrstr;
+	up->syserrstr = err;
+	
+	return 0;
+}
+
+uintptr
+syserrstr(va_list list)
+{
+	char *buf;
+	uint len;
+
+	buf = va_arg(list, char*);
+	len = va_arg(list, uint);
+	return (uintptr)generrstr(buf, len);
+}
+
+/* compatibility for old binaries */
+uintptr
+sys_errstr(va_list list)
+{
+	return (uintptr)generrstr(va_arg(list, char*), 64);
+}
+
+uintptr
+sysnotify(va_list list)
+{
+	int (*f)(void*, char*);
+	f = va_arg(list, void*);
+	if(f != nil)
+		validaddr((uintptr)f, sizeof(void*), 0);
+	up->notify = f;
+	return 0;
+}
+
+uintptr
+sysnoted(va_list list)
+{
+	if(va_arg(list, int) != NRSTR && !up->notified)
+		error(Egreg);
+	return 0;
+}
+
+uintptr
+syssegbrk(va_list list)
+{
+	int i;
+	uintptr addr;
+	Segment *s;
+
+	addr = va_arg(list, uintptr);
+	for(i = 0; i < NSEG; i++) {
+		s = up->seg[i];
+		if(s == nil || addr < s->base || addr >= s->top)
+			continue;
+		switch(s->type&SG_TYPE) {
+		case SG_TEXT:
+		case SG_DATA:
+		case SG_STACK:
+		case SG_PHYSICAL:
+		case SG_FIXED:
+		case SG_STICKY:
+			error(Ebadarg);
+		default:
+			return ibrk(va_arg(list, uintptr), i);
+		}
+	}
+	error(Ebadarg);
+}
+
+uintptr
+syssegattach(va_list list)
+{
+	int attr;
+	char *name;
+	uintptr va;
+	ulong len;
+
+	attr = va_arg(list, int);
+	name = va_arg(list, char*);
+	va = va_arg(list, uintptr);
+	len = va_arg(list, ulong);
+	validaddr((uintptr)name, 1, 0);
+	name = validnamedup(name, 1);
+	if(waserror()){
+		free(name);
+		nexterror();
+	}
+	va = segattach(attr, name, va, len);
+	free(name);
+	poperror();
+	return va;
+}
+
+uintptr
+syssegdetach(va_list list)
+{
+	int i;
+	uintptr addr;
+	Segment *s;
+
+	addr = va_arg(list, uintptr);
+
+	qlock(&up->seglock);
+	if(waserror()){
+		qunlock(&up->seglock);
+		nexterror();
+	}
+
+	for(i = 0; i < NSEG; i++)
+		if((s = up->seg[i]) != nil) {
+			qlock(s);
+			if((addr >= s->base && addr < s->top) ||
+			   (s->top == s->base && addr == s->base))
+				goto found;
+			qunlock(s);
+		}
+
+	error(Ebadarg);
+
+found:
+	/*
+	 * Check we are not detaching the initial stack segment.
+	 */
+	if(s == up->seg[SSEG]){
+		qunlock(s);
+		error(Ebadarg);
+	}
+	up->seg[i] = nil;
+	qunlock(s);
+	putseg(s);
+	qunlock(&up->seglock);
+	poperror();
+
+	/* Ensure we flush any entries from the lost segment */
+	flushmmu();
+	return 0;
+}
+
+uintptr
+syssegfree(va_list list)
+{
+	Segment *s;
+	uintptr from, to;
+
+	from = va_arg(list, uintptr);
+	to = va_arg(list, ulong);
+	to += from;
+	if(to < from)
+		error(Ebadarg);
+	s = seg(up, from, 1);
+	if(s == nil)
+		error(Ebadarg);
+	to &= ~(BY2PG-1);
+	from = PGROUND(from);
+	if(from >= to) {
+		qunlock(s);
+		return 0;
+	}
+	if(to > s->top) {
+		qunlock(s);
+		error(Ebadarg);
+	}
+	mfreeseg(s, from, (to - from) / BY2PG);
+	qunlock(s);
+	flushmmu();
+	return 0;
+}
+
+/* For binary compatibility */
+uintptr
+sysbrk_(va_list list)
+{
+	return ibrk(va_arg(list, uintptr), BSEG);
+}
+
+uintptr
+sysrendezvous(va_list list)
+{
+	uintptr tag, val, new;
+	Proc *p, **l;
+
+	tag = va_arg(list, uintptr);
+	new = va_arg(list, uintptr);
+	l = &REND(up->rgrp, tag);
+
+	lock(up->rgrp);
+	for(p = *l; p != nil; p = p->rendhash) {
+		if(p->rendtag == tag) {
+			*l = p->rendhash;
+			val = p->rendval;
+			p->rendval = new;
+			unlock(up->rgrp);
+
+			ready(p);
+
+			return val;
+		}
+		l = &p->rendhash;
+	}
+
+	/* Going to sleep here */
+	up->rendtag = tag;
+	up->rendval = new;
+	up->rendhash = *l;
+	*l = up;
+	up->state = Rendezvous;
+	unlock(up->rgrp);
+
+	sched();
+
+	return up->rendval;
+}
+
+/*
+ * The implementation of semaphores is complicated by needing
+ * to avoid rescheduling in syssemrelease, so that it is safe
+ * to call from real-time processes.  This means syssemrelease
+ * cannot acquire any qlocks, only spin locks.
+ * 
+ * Semacquire and semrelease must both manipulate the semaphore
+ * wait list.  Lock-free linked lists only exist in theory, not
+ * in practice, so the wait list is protected by a spin lock.
+ * 
+ * The semaphore value *addr is stored in user memory, so it
+ * cannot be read or written while holding spin locks.
+ * 
+ * Thus, we can access the list only when holding the lock, and
+ * we can access the semaphore only when not holding the lock.
+ * This makes things interesting.  Note that sleep's condition function
+ * is called while holding two locks - r and up->rlock - so it cannot
+ * access the semaphore value either.
+ * 
+ * An acquirer announces its intention to try for the semaphore
+ * by putting a Sema structure onto the wait list and then
+ * setting Sema.waiting.  After one last check of semaphore,
+ * the acquirer sleeps until Sema.waiting==0.  A releaser of n
+ * must wake up n acquirers who have Sema.waiting set.  It does
+ * this by clearing Sema.waiting and then calling wakeup.
+ * 
+ * There are three interesting races here.  
+ 
+ * The first is that in this particular sleep/wakeup usage, a single
+ * wakeup can rouse a process from two consecutive sleeps!  
+ * The ordering is:
+ * 
+ * 	(a) set Sema.waiting = 1
+ * 	(a) call sleep
+ * 	(b) set Sema.waiting = 0
+ * 	(a) check Sema.waiting inside sleep, return w/o sleeping
+ * 	(a) try for semaphore, fail
+ * 	(a) set Sema.waiting = 1
+ * 	(a) call sleep
+ * 	(b) call wakeup(a)
+ * 	(a) wake up again
+ * 
+ * This is okay - semacquire will just go around the loop
+ * again.  It does mean that at the top of the for(;;) loop in
+ * semacquire, phore.waiting might already be set to 1.
+ * 
+ * The second is that a releaser might wake an acquirer who is
+ * interrupted before he can acquire the lock.  Since
+ * release(n) issues only n wakeup calls -- only n can be used
+ * anyway -- if the interrupted process is not going to use his
+ * wakeup call he must pass it on to another acquirer.
+ * 
+ * The third race is similar to the second but more subtle.  An
+ * acquirer sets waiting=1 and then does a final canacquire()
+ * before going to sleep.  The opposite order would result in
+ * missing wakeups that happen between canacquire and
+ * waiting=1.  (In fact, the whole point of Sema.waiting is to
+ * avoid missing wakeups between canacquire() and sleep().) But
+ * there can be spurious wakeups between a successful
+ * canacquire() and the following semdequeue().  This wakeup is
+ * not useful to the acquirer, since he has already acquired
+ * the semaphore.  Like in the previous case, though, the
+ * acquirer must pass the wakeup call along.
+ * 
+ * This is all rather subtle.  The code below has been verified
+ * with the spin model /sys/src/9/port/semaphore.p.  The
+ * original code anticipated the second race but not the first
+ * or third, which were caught only with spin.  The first race
+ * is mentioned in /sys/doc/sleep.ps, but I'd forgotten about it.
+ * It was lucky that my abstract model of sleep/wakeup still managed
+ * to preserve that behavior.
+ *
+ * I remain slightly concerned about memory coherence
+ * outside of locks.  The spin model does not take 
+ * queued processor writes into account so we have to
+ * think hard.  The only variables accessed outside locks
+ * are the semaphore value itself and the boolean flag
+ * Sema.waiting.  The value is only accessed with cmpswap,
+ * whose job description includes doing the right thing as
+ * far as memory coherence across processors.  That leaves
+ * Sema.waiting.  To handle it, we call coherence() before each
+ * read and after each write.		- rsc
+ */
+
+/* Add semaphore p with addr a to list in seg. */
+static void
+semqueue(Segment *s, long *a, Sema *p)
+{
+	memset(p, 0, sizeof *p);
+	p->addr = a;
+	lock(&s->sema);	/* uses s->sema.Rendez.Lock, but no one else is */
+	p->next = &s->sema;
+	p->prev = s->sema.prev;
+	p->next->prev = p;
+	p->prev->next = p;
+	unlock(&s->sema);
+}
+
+/* Remove semaphore p from list in seg. */
+static void
+semdequeue(Segment *s, Sema *p)
+{
+	lock(&s->sema);
+	p->next->prev = p->prev;
+	p->prev->next = p->next;
+	unlock(&s->sema);
+}
+
+/* Wake up n waiters with addr a on list in seg. */
+static void
+semwakeup(Segment *s, long *a, long n)
+{
+	Sema *p;
+	
+	lock(&s->sema);
+	for(p=s->sema.next; p!=&s->sema && n>0; p=p->next){
+		if(p->addr == a && p->waiting){
+			p->waiting = 0;
+			coherence();
+			wakeup(p);
+			n--;
+		}
+	}
+	unlock(&s->sema);
+}
+
+/* Add delta to semaphore and wake up waiters as appropriate. */
+static long
+semrelease(Segment *s, long *addr, long delta)
+{
+	long value;
+
+	do
+		value = *addr;
+	while(!cmpswap(addr, value, value+delta));
+	semwakeup(s, addr, delta);
+	return value+delta;
+}
+
+/* Try to acquire semaphore using compare-and-swap */
+static int
+canacquire(long *addr)
+{
+	long value;
+	
+	while((value=*addr) > 0)
+		if(cmpswap(addr, value, value-1))
+			return 1;
+	return 0;
+}		
+
+/* Should we wake up? */
+static int
+semawoke(void *p)
+{
+	coherence();
+	return !((Sema*)p)->waiting;
+}
+
+/* Acquire semaphore (subtract 1). */
+static int
+semacquire(Segment *s, long *addr, int block)
+{
+	int acquired;
+	Sema phore;
+
+	if(canacquire(addr))
+		return 1;
+	if(!block)
+		return 0;
+	semqueue(s, addr, &phore);
+	if(acquired = !waserror()){
+		for(;;){
+			phore.waiting = 1;
+			coherence();
+			if(canacquire(addr))
+				break;
+			sleep(&phore, semawoke, &phore);
+		}
+		poperror();
+	}
+	semdequeue(s, &phore);
+	coherence();	/* not strictly necessary due to lock in semdequeue */
+	if(!phore.waiting)
+		semwakeup(s, addr, 1);
+	if(!acquired)
+		nexterror();
+	return 1;
+}
+
+/* Acquire semaphore or time-out */
+static int
+tsemacquire(Segment *s, long *addr, ulong ms)
+{
+	int timedout, acquired;
+	ulong t;
+	Sema phore;
+
+	if(canacquire(addr))
+		return 1;
+	if(ms == 0)
+		return 0;
+	timedout = 0;
+	semqueue(s, addr, &phore);
+	if(acquired = !waserror()){
+		for(;;){
+			phore.waiting = 1;
+			coherence();
+			if(canacquire(addr))
+				break;
+			t = MACHP(0)->ticks;
+			tsleep(&phore, semawoke, &phore, ms);
+			t = TK2MS(MACHP(0)->ticks - t);
+			if(t >= ms){
+				timedout = 1;
+				break;
+			}
+			ms -= t;
+		}
+		poperror();
+	}
+	semdequeue(s, &phore);
+	coherence();	/* not strictly necessary due to lock in semdequeue */
+	if(!phore.waiting)
+		semwakeup(s, addr, 1);
+	if(!acquired)
+		nexterror();
+	return !timedout;
+}
+
+uintptr
+syssemacquire(va_list list)
+{
+	int block;
+	long *addr;
+	Segment *s;
+
+	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 (uintptr)semacquire(s, addr, block);
+}
+
+uintptr
+systsemacquire(va_list list)
+{
+	long *addr;
+	ulong ms;
+	Segment *s;
+
+	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 (uintptr)tsemacquire(s, addr, ms);
+}
+
+uintptr
+syssemrelease(va_list list)
+{
+	long *addr, delta;
+	Segment *s;
+
+	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 (uintptr)semrelease(s, addr, delta);
+}
+
+/* For binary compatibility */
+uintptr
+sys_nsec(va_list list)
+{
+	vlong *v;
+
+	/* return in register on 64bit machine */
+	if(sizeof(uintptr) == sizeof(vlong)){
+		USED(list);
+		return (uintptr)todget(nil);
+	}
+
+	v = va_arg(list, vlong*);
+	evenaddr((uintptr)v);
+	validaddr((uintptr)v, sizeof(vlong), 1);
+	*v = todget(nil);
+	return 0;
+}