shithub: drawcpu

ref: 8df6746590a6bf6ebebbbc5509c6bbf5da889c59
dir: /kern/posix.c/

/*
 * Posix generic OS implementation for drawcpu.
 */

#include "u.h"

#ifndef _XOPEN_SOURCE	/* for Apple and OpenBSD; not sure if needed */
#define _XOPEN_SOURCE 500
#endif

#include <pthread.h>
#include <time.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/select.h>

#if defined (__APPLE__)
#include <mach/mach.h>
#include <mach/vm_map.h>
#include <mach/mach_error.h>
#include <mach/mach_vm.h> 
#ifdef panic
#undef panic
#endif
mach_port_t task;
#endif

#include <sys/mman.h>
#include <signal.h>
#include <pwd.h>
#include <errno.h>
#include <termios.h>

#include "lib.h"
#include "dat.h"
#include "fns.h"
#include "mem.h"
#include <a.out.h>

typedef struct Oproc Oproc;
struct Oproc
{
	int nsleep;
	int nwakeup;
	pthread_mutex_t mutex;
	pthread_cond_t cond;
};

static pthread_key_t prdakey;

Proc*
_getproc(void)
{
	void *v;

	if((v = pthread_getspecific(prdakey)) == nil)
		panic("cannot getspecific");
	return v;
}

void
_setproc(Proc *p)
{
	if(pthread_setspecific(prdakey, p) != 0)
		panic("cannot setspecific");
}

void
osinit(void)
{
	if(pthread_key_create(&prdakey, 0))
		panic("cannot pthread_key_create");

#if defined __APPLE__
    task = mach_task_self();
#endif

	signal(SIGPIPE, SIG_IGN);
}

void
osnewproc(Proc *p)
{
	Oproc *op;
	pthread_mutexattr_t attr;

	op = (Oproc*)p->oproc;
	pthread_mutexattr_init(&attr);
	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&op->mutex, &attr);
	pthread_mutexattr_destroy(&attr);
	pthread_cond_init(&op->cond, 0);
}

void
osmsleep(int ms)
{
	struct timeval tv;

	tv.tv_sec = ms / 1000;
	tv.tv_usec = (ms % 1000) * 1000; /* micro */
	if(select(0, NULL, NULL, NULL, &tv) < 0)
		panic("select");
}

void
osyield(void)
{
	sched_yield();
}

void
oserrstr(void)
{
	char *p;

	if((p = strerror(errno)) != nil)
		strecpy(up->errstr, up->errstr+ERRMAX, p);
	else
		snprint(up->errstr, ERRMAX, "unix error %d", errno);
}

void
oserror(void)
{
	oserrstr();
	nexterror();
}

static void*
tramp(void *vp)
{
	Proc *p;
	p = vp;
	if(pthread_setspecific(prdakey, p))
		panic("cannot setspecific");
	(*p->fn)(p->arg);
	pexit("", 0);
	return 0;
}

void
osproc(Proc *p)
{
	pthread_t pid;

	if(pthread_create(&pid, nil, tramp, p)){
		oserrstr();
		panic("osproc: %r");
	}
	sched_yield();
}

void
osexit(void)
{
	pthread_setspecific(prdakey, 0);
	pthread_exit(0);
}

void
procsleep(void)
{
	Proc *p;
	Oproc *op;

	p = up;
	op = (Oproc*)p->oproc;
	pthread_mutex_lock(&op->mutex);
	op->nsleep++;
	while(op->nsleep > op->nwakeup)
		pthread_cond_wait(&op->cond, &op->mutex);
	pthread_mutex_unlock(&op->mutex);
}

void
procwakeup(Proc *p)
{
	Oproc *op;

	op = (Oproc*)p->oproc;
	pthread_mutex_lock(&op->mutex);
	op->nwakeup++;
	if(op->nwakeup == op->nsleep)
		pthread_cond_signal(&op->cond);
	pthread_mutex_unlock(&op->mutex);
}

#undef chdir
#undef pipe
#undef fork
#undef close
void*
oscmd(char **argv, int nice, char *dir, Chan **fd)
{
	int p[3][2];
	int i, pid;

	for(i = 0; i<3; i++){
		if(pipe(p[i]) < 0){
			while(--i >= 0){
				close(p[i][0]);
				close(p[i][1]);
			}
			oserror();
		}
	}
	if(waserror()){
		for(i = 0; i < 3; i++){
			close(p[i][0]);
			close(p[i][1]);
		}
		nexterror();
	}
	pid = fork();
	if(pid == -1)
		oserror();
	if(pid == 0){
		setsid();
		dup2(p[0][0], 0);
		dup2(p[1][1], 1);
		dup2(p[2][1], 2);
		for(i = 3; i < 1000; i++)
			close(i);
		if(chdir(dir) < 0){
			perror("chdir");
			_exit(1);
		}
		execvp(argv[0], argv);
		perror("exec");
		_exit(1);
	}
	poperror();
	close(p[0][0]);
	close(p[1][1]);
	close(p[2][1]);

	fd[0] = lfdchan((void*)(uintptr)p[0][1]);
	fd[1] = lfdchan((void*)(uintptr)p[1][0]);
	fd[2] = lfdchan((void*)(uintptr)p[2][0]);

	return (void*)(uintptr)pid;
}

int
oscmdwait(void *c, char *status, int nstatus)
{
	int pid = (int)(uintptr)c;
	int s = -1;

	if(waitpid(pid, &s, 0) < 0)
		return -1;
	if(WIFEXITED(s)){
		if((s = WEXITSTATUS(s)) == 0)
			return snprint(status, nstatus, "%d 0 0 0 ''", pid);
		return snprint(status, nstatus, "%d 0 0 0 'exit: %d'", pid, s);
	}
	if(WIFSIGNALED(s)){
		switch(s = WTERMSIG(s)){
		case SIGTERM:
		case SIGKILL:
			return snprint(status, nstatus, "%d 0 0 0 killed", pid);
		}
		return snprint(status, nstatus, "%d 0 0 0 'signal: %d'", pid, s);
	}
	return snprint(status, nstatus, "%d 0 0 0 'odd status: 0x%x'", pid, s);
}

void
osclrmem(uintptr mem, uintptr ms)
{

	if(mem)
#if defined __APPLE__
		mach_vm_deallocate(task, (mach_vm_address_t)mem, (mach_vm_size_t)ms);
#else
		munmap((void*)mem, ms);
#endif
}

void *
osbuildmem(Chan *tc, uintptr ts, uintptr ds, uintptr bss, int offset, uintptr align)
{
    int n;
    void *exec, *binary;
    size_t total_size;

    /* Read in initial datum */
    exec = mallocz(ts+ds, 1);
    n = devtab[tc->type]->read(tc, exec, ts+ds, offset);
    if(!exec || n < (ts+ds) || n < 0)
        error("read error: %r");

#if defined __APPLE__
    kern_return_t kr;
    mach_vm_address_t base = 0;
    mach_vm_size_t size = (mach_vm_size_t)(n + bss + align);

    kr = mach_vm_allocate(task, &base, size, VM_FLAGS_ANYWHERE);
    if(kr != KERN_SUCCESS) 
		error("unable to allocate: %r");
    
    binary = (void*)base;
#else
    /* Contiguous memory block - start with RW for setup */
    binary = mmap(nil, n+bss+align, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    if(binary == MAP_FAILED)
        error("Failed: %r");
#endif
    /* Copy the binary data (text + data sections) */
    memcpy(binary, exec, n);
    free(exec);
    return binary;
}

void
osprepmem(void *base, uintptr b, uintptr text, uintptr data, uintptr bss)
{
	uintptr *ptr, end, offset;

	end = (uintptr)b+text+data;
	offset = (uintptr)b;

	/* If we needed to align, copy the data to the aligned location */
	if(b != (uintptr)base)
		memmove((void*)b, base, text+data);

	/* Zero out BSS section at aligned location */
	memset((void*)b + text + data, 0, bss);

	/* Patch the text + data sections to meet our new base */
    for(ptr = (uintptr*)b; (uintptr)ptr < end; ptr++) {
        uintptr val = *ptr;
        if(val >= UTZERO && val <= (UTZERO + text + data)) {
            *ptr = val + offset;
        }
    }

#if defined __APPLE__
    kern_return_t kr;
    kr = mach_vm_protect(task, (mach_vm_address_t)b, (mach_vm_size_t)text, FALSE, VM_PROT_READ|VM_PROT_EXECUTE);
    if(kr != KERN_SUCCESS)
        print("Unable to vm_protect aligned text section: %s\n", mach_error_string(kr));
#else
	/* Set proper memory permissions for aligned sections */
	if(mprotect((void*)b, text, PROT_READ|PROT_EXEC) != 0)
		print("Unable to mprotect aligned text section: %r\n");
#endif
}

int
oscmdkill(void *c)
{
	int pid = (int)(uintptr)c;
	return kill(pid, SIGTERM);
}

void
oscmdfree(void *c)
{
	USED(c);
}

static int randfd;
#undef open
void
randominit(void)
{
	if((randfd = open("/dev/urandom", OREAD)) < 0)
	if((randfd = open("/dev/random", OREAD)) < 0)
		panic("open /dev/random: %r");
}

#undef read
ulong
randomread(void *v, ulong n)
{
	int m;

	if((m = read(randfd, v, n)) != n)
		panic("short read from /dev/random: %d but %d", n, m);
	return m;
}

#undef time
long
seconds(void)
{
	return time(0);
}

ulong
ticks(void)
{
	static long sec0 = 0, usec0;
	struct timeval t;

	if(gettimeofday(&t, nil) < 0)
		return 0;
	if(sec0 == 0){
		sec0 = t.tv_sec;
		usec0 = t.tv_usec;
	}
	return (t.tv_sec-sec0)*1000+(t.tv_usec-usec0+500)/1000;
}

long
showfilewrite(char *a, int n)
{
	error("not implemented");
	return -1;
}

void
setterm(int raw)
{
	struct termios t;

	if(tcgetattr(0, &t) < 0)
		return;
	if(raw)
		t.c_lflag &= ~(ECHO|ICANON);
	else
		t.c_lflag |= (ECHO|ICANON);
	tcsetattr(0, TCSAFLUSH, &t);
}