ref: a374e069c66850906eaa241b8fcc0e312ff298bd
dir: /kern/sysproc.c/
#include "u.h"
#include "lib.h"
#include "dat.h"
#include "fns.h"
#include "error.h"
#include "user.h"
#include "mem.h"
#include <a.out.h>
#include <signal.h>
#include <sys/mman.h>
#undef rfork
static void
nop(int x)
{
USED(x);
}
int
sysrfork(int flags)
{
int pid, status;
int p[2];
int n;
char buf[128], *q;
extern char **environ;
struct sigaction oldchld;
memset(&oldchld, 0, sizeof oldchld);
if((flags&(RFPROC|RFFDG|RFMEM)) == (RFPROC|RFFDG)){
/* check other flags before we commit */
flags &= ~(RFPROC|RFFDG|RFENVG);
n = (flags & ~(RFNOTEG|RFNAMEG|RFNOWAIT|RFCENVG));
if(n){
werrstr("unknown flags %08ux in rfork", n);
return -1;
}
if(flags&RFNOWAIT){
sigaction(SIGCHLD, nil, &oldchld);
signal(SIGCHLD, nop);
if(pipe(p) < 0)
return -1;
}
pid = fork();
if(pid == -1)
return -1;
if(flags&RFNOWAIT){
flags &= ~RFNOWAIT;
if(pid){
/*
* Parent - wait for child to fork wait-free child.
* Then read pid from pipe. Assume pipe buffer can absorb the write.
*/
close(p[1]);
status = 0;
if(wait4(pid, &status, 0, 0) < 0){
werrstr("pipe dance - wait4 - %r");
close(p[0]);
return -1;
}
n = readn(p[0], buf, sizeof buf-1);
close(p[0]);
if(!WIFEXITED(status) || WEXITSTATUS(status)!=0 || n <= 0){
if(!WIFEXITED(status))
werrstr("pipe dance - !exited 0x%ux", status);
else if(WEXITSTATUS(status) != 0)
werrstr("pipe dance - non-zero status 0x%ux", status);
else if(n < 0)
werrstr("pipe dance - pipe read error - %r");
else if(n == 0)
werrstr("pipe dance - pipe read eof");
else
werrstr("pipe dance - unknown failure");
return -1;
}
buf[n] = 0;
if(buf[0] == 'x'){
werrstr("%s", buf+2);
return -1;
}
pid = strtol(buf, &q, 0);
}else{
/*
* Child - fork a new child whose wait message can't
* get back to the parent because we're going to exit!
*/
signal(SIGCHLD, SIG_IGN);
close(p[0]);
pid = fork();
if(pid){
/* Child parent - send status over pipe and exit. */
if(pid > 0)
fprint(p[1], "%d", pid);
else
fprint(p[1], "x %r");
close(p[1]);
_exit(0);
}else{
/* Child child - close pipe. */
close(p[1]);
}
}
sigaction(SIGCHLD, &oldchld, nil);
}
if(pid != 0)
return pid;
if(flags&RFCENVG)
if(environ)
*environ = nil;
}
if(flags&RFPROC){
werrstr("cannot use rfork for shared memory -- use libthread");
return -1;
}
if(flags&RFNAMEG){
/* XXX set $NAMESPACE to a new directory */
flags &= ~RFNAMEG;
}
if(flags&RFNOTEG){
setpgid(0, getpid());
flags &= ~RFNOTEG;
}
if(flags&RFNOWAIT){
werrstr("cannot use RFNOWAIT without RFPROC");
return -1;
}
if(flags){
werrstr("unknown flags %08ux in rfork", flags);
return -1;
}
return 0;
}
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];
}
void
evenaddr(uintptr addr)
{
if(addr & 3){
postnote(up, 1, "sys: odd address", NDebug);
error(Ebadarg);
}
}
/*
* &s[0] is known to be a valid address.
*/
void*
vmemchr(void *s, int c, ulong n)
{
uintptr a;
ulong m, i;
void *t;
i = n;
a = (uintptr)s;
for(;;){
m = BY2PG - (a & (BY2PG-1));
if(i <= m)
break;
/* spans pages; handle this page */
t = memchr((void*)a, c, m);
if(t != nil)
return t;
a += m;
i -= m;
if(a < KZERO)
validaddr(a, 1, 0);
}
/* fits in one page */
return memchr((void*)a, c, i);
}
#undef read
int
sysexec(int argc, char **argv)
{
union {
struct {
Exec ex;
uvlong hdr[1];
} ehdr;
char buf[256];
} u;
char line[256];
char *progarg[32+1];
char *file, *elem;
Chan *tc;
ulong magic;
uintptr align, bssend;
int n, indir;
elem = nil;
align = BY2PG-1;
indir = 0;
file = argv[0];
up->bin = mallocz(sizeof(Binary*), 1);
for(;;){
tc = namec(file, Aopen, OEXEC, 0);
if(waserror()){
cclose(tc);
nexterror();
}
if(!indir)
kstrdup(&elem, up->genbuf);
// TODO: Triple check this for accurate text/entry. Ensure they are right, our ts should not be the same each time, for example
n = devtab[tc->type]->read(tc, u.buf, sizeof(u.buf), 0);
if (n >= sizeof(Exec)){
magic = beswal(u.ehdr.ex.magic);
if(magic & AOUT_MAGIC) {
if(magic & HDR_MAGIC){
if(n < sizeof(u.ehdr))
error(Ebadexec);
up->bin->entry = beswav(u.ehdr.hdr[0]);
up->bin->ts = UTZERO+sizeof(u.ehdr);
} else {
up->bin->entry = beswal(u.ehdr.ex.entry);
up->bin->ts = UTZERO+sizeof(Exec);
}
if(up->bin->entry < up->bin->ts)
error(Ebadexec);
up->bin->ts += beswal(u.ehdr.ex.text);
if(up->bin->ts <= up->bin->entry || up->bin->ts >= (uintptr)(USTKTOP-USTKSIZE))
error(Ebadexec);
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;
}
up->arg = argv;
argv[argc] = nil;
break; /* for binary */
}
}
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);
progarg[n++] = file;
progarg[n] = nil;
argv++;
file = progarg[0];
progarg[0] = elem;
strcpy(up->text, elem);
poperror();
cclose(tc);
// Check the actual sysproc, there's some missing bits here still
up->arg = progarg;
}
up->bin->ds = beswal(u.ehdr.ex.data);
up->bin->bs = beswal(u.ehdr.ex.bss);
up->bin->text = align;
up->bin->ts -= UTZERO;
align = BY2PG-1;
up->bin->data = ((up->bin->ts+align) & ~align) / BY2WD;
bssend = up->bin->ts + up->bin->ds + up->bin->bs;
up->bin->bss = ((bssend + align) & ~align) / BY2WD;
up->bin->bss -= up->bin->bs;
/* Set up text, data, and bss. Patch syscalls. OS dependent. */
osbuildtext(tc);
if(waserror()){
print("%s\n", up->errstr);
osclrmem();
nexterror();
}
ospatchtext();
if(waserror()){
print("%s\n", up->errstr);
osclrmem();
nexterror();
}
osbuilddata(tc);
if(waserror()){
print("%s\n", up->errstr);
osclrmem();
nexterror();
}
osbuildbss(tc);
if(waserror()){
print("%s\n", up->errstr);
osclrmem();
nexterror();
}
/* Run binary. OS dependent. */
osexec(up);
print("Exiting sysproc\n");
/* Clean up */
osclrmem();
up->arg = nil;
free(up->bin);
poperror(); /* osbuildtext */
poperror(); /* ospatchtext */
poperror(); /* osbuilddata */
poperror(); /* osbuildbss */
cclose(tc);
return 0;
}