From 37da2899f40661e3e9631e497da8dc59b971cbd0 Mon Sep 17 00:00:00 2001 From: "Charles.Forsyth" Date: Fri, 22 Dec 2006 17:07:39 +0000 Subject: 20060303a --- emu/MacOSX/NOTE | 2 + emu/MacOSX/NOTICE | 2 + emu/MacOSX/asm-power.s | 36 +++ emu/MacOSX/cmd.c | 205 ++++++++++++++++ emu/MacOSX/deveia.c | 154 ++++++++++++ emu/MacOSX/devfs.c | 1 + emu/MacOSX/emu | 108 +++++++++ emu/MacOSX/emu-g | 96 ++++++++ emu/MacOSX/ipif.c | 1 + emu/MacOSX/mkfile | 63 +++++ emu/MacOSX/mkfile-g | 62 +++++ emu/MacOSX/os.c | 647 +++++++++++++++++++++++++++++++++++++++++++++++++ 12 files changed, 1377 insertions(+) create mode 100644 emu/MacOSX/NOTE create mode 100644 emu/MacOSX/NOTICE create mode 100644 emu/MacOSX/asm-power.s create mode 100644 emu/MacOSX/cmd.c create mode 100644 emu/MacOSX/deveia.c create mode 100644 emu/MacOSX/devfs.c create mode 100644 emu/MacOSX/emu create mode 100644 emu/MacOSX/emu-g create mode 100644 emu/MacOSX/ipif.c create mode 100644 emu/MacOSX/mkfile create mode 100644 emu/MacOSX/mkfile-g create mode 100644 emu/MacOSX/os.c (limited to 'emu/MacOSX') diff --git a/emu/MacOSX/NOTE b/emu/MacOSX/NOTE new file mode 100644 index 00000000..990d4ea3 --- /dev/null +++ b/emu/MacOSX/NOTE @@ -0,0 +1,2 @@ +- still interp mode only, jit not complete +- uses X11R6 from Apple diff --git a/emu/MacOSX/NOTICE b/emu/MacOSX/NOTICE new file mode 100644 index 00000000..cf4f254f --- /dev/null +++ b/emu/MacOSX/NOTICE @@ -0,0 +1,2 @@ +MacOSX port Copyright © 2001-2003 Corpus Callosum Corporation, +with portions Copyright © 2001-2003 Geoff Collyer diff --git a/emu/MacOSX/asm-power.s b/emu/MacOSX/asm-power.s new file mode 100644 index 00000000..d7db8188 --- /dev/null +++ b/emu/MacOSX/asm-power.s @@ -0,0 +1,36 @@ +/* + * File: asm-power.s + * + * Copyright (c) 2003, Corpus Callosum Corporation. All rights reserved. + */ + +#include + +.text + +LEAF(_FPsave) + mffs f0 + stfd f0,0(r3) + blr +END(_FPsave) + +LEAF(_FPrestore) + lfd f0,0(r3) + mtfsf 0xff,f0 + blr +END(_FPrestore) + +LEAF(__tas) + sync + mr r4,r3 + addi r5,0,0x1 +1: + lwarx r3,0,r4 + cmpwi r3,0x0 + bne- 2f + stwcx. r5,0,r4 + bne- 1b /* Lost reservation, try again */ +2: + sync + blr +END(__tas) diff --git a/emu/MacOSX/cmd.c b/emu/MacOSX/cmd.c new file mode 100644 index 00000000..49825f3c --- /dev/null +++ b/emu/MacOSX/cmd.c @@ -0,0 +1,205 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "dat.h" +#include "fns.h" +#include "error.h" + +enum +{ + Debug = 0 +}; + +/* + * os-specific devcmd support. + * this version should be reasonably portable across Unix systems. + */ +typedef struct Targ Targ; +struct Targ +{ + int fd[2]; /* fd[0] is standard input, fd[1] is standard output */ + char** args; + char* dir; + int pid; + int wfd; /* child writes errors that occur after the fork or on exec */ + int uid; + int gid; +}; + +extern int gidnobody; +extern int uidnobody; + +static int +childproc(Targ *t) +{ + int i, nfd; + + if(Debug) + print("devcmd: '%s'", t->args[0]); + + nfd = getdtablesize(); + for(i = 0; i < nfd; i++) + if(i != t->fd[0] && i != t->fd[1] && i != t->wfd) + close(i); + + dup2(t->fd[0], 0); + dup2(t->fd[1], 1); + dup2(t->fd[1], 2); + close(t->fd[0]); + close(t->fd[1]); + + if(t->gid != -1){ + if(setgid(t->gid) < 0 && getegid() == 0){ + fprint(t->wfd, "can't set gid %d: %s", t->gid, strerror(errno)); + _exit(1); + } + } + + if(t->uid != -1){ + if(setuid(t->uid) < 0 && geteuid() == 0){ + fprint(t->wfd, "can't set uid %d: %s", t->uid, strerror(errno)); + _exit(1); + } + } + + if(t->dir != nil && chdir(t->dir) < 0){ + fprint(t->wfd, "can't chdir to %s: %s", t->dir, strerror(errno)); + _exit(1); + } + + signal(SIGPIPE, SIG_DFL); + + execvp(t->args[0], t->args); + if(Debug) + print("execvp: %s\n",strerror(errno)); + fprint(t->wfd, "exec failed: %s", strerror(errno)); + + _exit(1); +} + +void* +oscmd(char **args, int nice, char *dir, int *rfd, int *sfd) +{ + Targ *t; + int r, fd0[2], fd1[2], wfd[2], n, pid; + + t = mallocz(sizeof(*t), 1); + if(t == nil) + return nil; + + fd0[0] = fd0[1] = -1; + fd1[0] = fd1[1] = -1; + wfd[0] = wfd[1] = -1; + if(pipe(fd0) < 0 || pipe(fd1) < 0 || pipe(wfd) < 0) + goto Error; + if(fcntl(wfd[1], F_SETFD, FD_CLOEXEC) < 0) /* close on exec to give end of file on success */ + goto Error; + + t->fd[0] = fd0[0]; + t->fd[1] = fd1[1]; + t->wfd = wfd[1]; + t->args = args; + t->dir = dir; + t->gid = up->env->gid; + if(t->gid == -1) + t->gid = gidnobody; + t->uid = up->env->uid; + if(t->uid == -1) + t->uid = uidnobody; + + signal(SIGCHLD, SIG_DFL); + switch(pid = fork()) { + case -1: + goto Error; + case 0: + setpgid(0, getpid()); + if(nice) + oslopri(); + childproc(t); + _exit(1); + default: + t->pid = pid; + if(Debug) + print("cmd pid %d\n", t->pid); + break; + } + + close(fd0[0]); + close(fd1[1]); + close(wfd[1]); + + n = read(wfd[0], up->genbuf, sizeof(up->genbuf)-1); + close(wfd[0]); + if(n > 0){ + close(fd0[1]); + close(fd1[0]); + free(t); + up->genbuf[n] = 0; + if(Debug) + print("oscmd: bad exec: %q\n", up->genbuf); + error(up->genbuf); + return nil; + } + + *sfd = fd0[1]; + *rfd = fd1[0]; + return t; + +Error: + r = errno; + if(Debug) + print("oscmd: %q\n",strerror(r)); + close(fd0[0]); + close(fd0[1]); + close(fd1[0]); + close(fd1[1]); + close(wfd[0]); + close(wfd[1]); + error(strerror(r)); + return nil; +} + +int +oscmdkill(void *a) +{ + Targ *t = a; + + if(Debug) + print("kill: %d\n", t->pid); + return kill(-t->pid, SIGTERM); +} + +int +oscmdwait(void *a, char *buf, int n) +{ + Targ *t = a; + int s; + + if(waitpid(t->pid, &s, 0) == -1){ + if(Debug) + print("wait error: %d [in %d] %q\n", t->pid, getpid(), strerror(errno)); + return -1; + } + if(WIFEXITED(s)){ + if(WEXITSTATUS(s) == 0) + return snprint(buf, n, "%d 0 0 0 ''", t->pid); + return snprint(buf, n, "%d 0 0 0 'exit: %d'", t->pid, WEXITSTATUS(s)); + } + if(WIFSIGNALED(s)){ + if(WTERMSIG(s) == SIGTERM || WTERMSIG(s) == SIGKILL) + return snprint(buf, n, "%d 0 0 0 killed", t->pid); + return snprint(buf, n, "%d 0 0 0 'signal: %d'", t->pid, WTERMSIG(s)); + } + return snprint(buf, n, "%d 0 0 0 'odd status: 0x%x'", t->pid, s); +} + +void +oscmdfree(void *a) +{ + free(a); +} diff --git a/emu/MacOSX/deveia.c b/emu/MacOSX/deveia.c new file mode 100644 index 00000000..bb7a01c6 --- /dev/null +++ b/emu/MacOSX/deveia.c @@ -0,0 +1,154 @@ +/* + * Darwin serial port definitions, uses IOKit to build sysdev + * Loosely based on FreeBSD/deveia.c + * Copyright © 1998, 1999 Lucent Technologies Inc. All rights reserved. + * Revisions Copyright © 1999, 2000 Vita Nuova Limited. All rights reserved. + * Revisions Copyright © 2003 Corpus Callosum Corporation. All rights reserved. +*/ + +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include + +#define B14400 14400 +#define B28800 28800 +#define B57600 57600 +#define B76800 76800 +#define B115200 115200 +#define B230400 230400 + +extern int vflag; + +#define MAXDEV 8 +static char *sysdev[MAXDEV]; + +#include +#include + +static void _buildsysdev(void); +#define buildsysdev() _buildsysdev() /* for devfs-posix.c */ + +static void +_buildsysdev(void) +{ + kern_return_t kernResult; + mach_port_t masterPort; + CFMutableDictionaryRef classesToMatch; + io_iterator_t serialPortIterator; + io_object_t serialDevice; + CFMutableArrayRef array; + CFIndex idx; + + kernResult = IOMasterPort(MACH_PORT_NULL, &masterPort); + if (KERN_SUCCESS != kernResult) + { + printf("IOMasterPort returned %d\n", kernResult); + } else { + classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue); + if (classesToMatch == NULL) + { + printf("IOServiceMatching returned a NULL dictionary.\n"); + } else { + CFDictionarySetValue(classesToMatch, + CFSTR(kIOSerialBSDTypeKey), + CFSTR(kIOSerialBSDAllTypes)); + } + + kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch, &serialPortIterator); + if (KERN_SUCCESS != kernResult) + { + printf("IOServiceGetMatchingServices returned %d\n", kernResult); + } else { + array = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks); + + while ((serialDevice = IOIteratorNext(serialPortIterator))) { + CFTypeRef bsdPathAsCFString; + bsdPathAsCFString = IORegistryEntryCreateCFProperty(serialDevice, + CFSTR(kIOCalloutDeviceKey), + kCFAllocatorDefault, + 0); + if (bsdPathAsCFString) { + CFArrayAppendValue(array, bsdPathAsCFString); + } + + (void) IOObjectRelease(serialDevice); + } + + idx = CFArrayGetCount(array); + if (idx > 0) { + Boolean result; + char bsdPath[MAXPATHLEN]; + char *tmpsysdev[idx+1]; + CFIndex i; + + for (i=0; i +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include +#include +#include + +#if defined(__ppc__) +#include +#endif + +enum +{ + DELETE = 0x7F +}; +char *hosttype = "MacOSX"; +char *cputype = "power"; + +static pthread_key_t prdakey; + +extern int dflag; + +Proc * +getup(void) { + return (Proc *)pthread_getspecific(prdakey); +} + +/* Pthread version */ +void +pexit(char *msg, int t) +{ + Osenv *e; + Proc *p; + + USED(t); + USED(msg); + + lock(&procs.l); + p = up; + if(p->prev) + p->prev->next = p->next; + else + procs.head = p->next; + + if(p->next) + p->next->prev = p->prev; + else + procs.tail = p->prev; + unlock(&procs.l); + + if(0) + print("pexit: %s: %s\n", p->text, msg); + + e = p->env; + if(e != nil) { + closefgrp(e->fgrp); + closepgrp(e->pgrp); + closeegrp(e->egrp); + closesigs(e->sigs); + } + free(e->user); + free(p->prog); + free(p); + pthread_exit(0); +} + +void +trapBUS(int signo) +{ + USED(signo); + disfault(nil, "Bus error"); +} + +void +trapUSR1(int signo) +{ + USED(signo); + + if(up->type != Interp) /* Used to unblock pending I/O */ + return; + if(up->intwait == 0) /* Not posted so its a sync error */ + disfault(nil, Eintr); /* Should never happen */ + + up->intwait = 0; /* Clear it so the proc can continue */ +} + +void +trapILL(int signo) +{ + USED(signo); + disfault(nil, "Illegal instruction"); +} + +/* from geoff collyer's port */ +void +printILL(int sig, siginfo_t *siginfo, void *v) +{ + USED(sig); + USED(v); + panic("Illegal instruction with code=%d at address=%x, opcode=%x.\n" + ,siginfo->si_code, siginfo->si_addr,*(char*)siginfo->si_addr); +} + +void +trapSEGV(int signo) +{ + USED(signo); + disfault(nil, "Segmentation violation"); +} + +void +trapFPE(int signo) +{ + USED(signo); + disfault(nil, "Floating point exception"); +} + +static void +setsigs(void) +{ + struct sigaction act; + + memset(&act, 0 , sizeof(act)); + + /* + * For the correct functioning of devcmd in the + * face of exiting slaves + */ + signal(SIGPIPE, SIG_IGN); + if(signal(SIGTERM, SIG_IGN) != SIG_IGN) + signal(SIGTERM, cleanexit); + + act.sa_handler=trapUSR1; + sigaction(SIGUSR1, &act, nil); + + if(sflag == 0) { + act.sa_handler = trapBUS; + sigaction(SIGBUS, &act, nil); + act.sa_handler = trapILL; + sigaction(SIGILL, &act, nil); + act.sa_handler = trapSEGV; + sigaction(SIGSEGV, &act, nil); + act.sa_handler = trapFPE; + sigaction(SIGFPE, &act, nil); + if(signal(SIGINT, SIG_IGN) != SIG_IGN) + signal(SIGINT, cleanexit); + } else { + act.sa_sigaction = printILL; + act.sa_flags=SA_SIGINFO; + sigaction(SIGILL, &act, nil); + } +} + + +void * +tramp(void *arg) +{ + Proc *p = arg; + p->sigid = (int)pthread_self(); + if(pthread_setspecific(prdakey, arg)) { + print("set specific data failed in tramp\n"); + pthread_exit(0); + } + p->func(p->arg); + pexit("{Tramp}", 0); + return NULL; +} + +int +kproc(char *name, void (*func)(void*), void *arg, int flags) +{ + pthread_t thread; + Proc *p; + Pgrp *pg; + Fgrp *fg; + Egrp *eg; + + pthread_attr_t attr; + + p = newproc(); + if(p == nil) + panic("kproc: no memory"); + + if(flags & KPDUPPG) { + pg = up->env->pgrp; + incref(&pg->r); + p->env->pgrp = pg; + } + if(flags & KPDUPFDG) { + fg = up->env->fgrp; + incref(&fg->r); + p->env->fgrp = fg; + } + if(flags & KPDUPENVG) { + eg = up->env->egrp; + incref(&eg->r); + p->env->egrp = eg; + } + + p->env->uid = up->env->uid; + p->env->gid = up->env->gid; + kstrdup(&p->env->user, up->env->user); + + strcpy(p->text, name); + + p->func = func; + p->arg = arg; + + lock(&procs.l); + if(procs.tail != nil) { + p->prev = procs.tail; + procs.tail->next = p; + } else { + procs.head = p; + p->prev = nil; + } + procs.tail = p; + unlock(&procs.l); + + up->kid = p; + + if((pthread_attr_init(&attr))== -1) + panic("pthread_attr_init failed"); + + errno=0; + pthread_attr_setschedpolicy(&attr,SCHED_OTHER); + if(errno) + panic("pthread_attr_setschedpolicy failed"); + + pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + + if(pthread_create(&thread, &attr, tramp, p)) + panic("thr_create failed\n"); + pthread_attr_destroy(&attr); + + return (int)thread; +} + +int +segflush(void *va, ulong len) +{ + kern_return_t err; + vm_machine_attribute_val_t value = MATTR_VAL_ICACHE_FLUSH; + + err = vm_machine_attribute( (vm_map_t)mach_task_self(), + (vm_address_t)va, + (vm_size_t)len, + MATTR_CACHE, + &value); + if (err != KERN_SUCCESS) { + print("segflush: failure (%d) address %lud\n", err, va); + } + return (int)err; +} + +/* from geoff collyer's port +invalidate instruction cache and write back data cache from a to a+n-1, +at least. + +void +segflush(void *a, ulong n) +{ + ulong *p; + + // paranoia, flush the world + __asm__("isync\n\t" + "eieio\n\t" + : // no output + : + ); + // cache blocks are often eight words (32 bytes) long, sometimes 16 bytes. + // need to determine it dynamically? + for (p = (ulong *)((ulong)a & ~3UL); (char *)p < (char *)a + n; p++) + __asm__("dcbst 0,%0\n\t" // not dcbf, which writes back, then invalidates + "icbi 0,%0\n\t" + : // no output + : "ar" (p) + ); + __asm__("isync\n\t" + "eieio\n\t" + : // no output + : + ); +} +*/ + +void +oshostintr(Proc *p) +{ + pthread_kill((pthread_t)p->sigid, SIGUSR1); +} + +static ulong erendezvous(void*, ulong); + +void +osblock(void) +{ + erendezvous(up, 0); +} + +void +osready(Proc *p) +{ + erendezvous(p, 0); +} + +void +oslongjmp(void *regs, osjmpbuf env, int val) +{ + USED(regs); + siglongjmp(env, val); +} + +struct termios tinit; + +static void +termset(void) +{ + struct termios t; + + tcgetattr(0, &t); + tinit = t; + t.c_lflag &= ~(ICANON|ECHO|ISIG); + t.c_cc[VMIN] = 1; + t.c_cc[VTIME] = 0; + tcsetattr(0, TCSANOW, &t); +} + +static void +termrestore(void) +{ + tcsetattr(0, TCSANOW, &tinit); +} + + +void +cleanexit(int x) +{ + USED(x); + + if(up->intwait) { + up->intwait = 0; + return; + } + + if(dflag == 0) + termrestore(); + + exit(0); +} + +void +osreboot(char *file, char **argv) +{ + if(dflag == 0) + termrestore(); + execvp(file, argv); + panic("reboot failure"); +} + +int gidnobody= -1, uidnobody= -1; + +void +getnobody() +{ + struct passwd *pwd; + + if((pwd = getpwnam("nobody"))) { + uidnobody = pwd->pw_uid; + gidnobody = pwd->pw_gid; + } +} + +/* Pthread version */ +static pthread_mutex_t rendezvouslock; +static pthread_mutexattr_t *pthread_mutexattr_default = NULL; + +void +libinit(char *imod) +{ + struct passwd *pw; + Proc *p; + char sys[64]; + + setsid(); + + // setup personality + gethostname(sys, sizeof(sys)); + kstrdup(&ossysname, sys); + getnobody(); + + if(dflag == 0) + termset(); + + setsigs(); + + if(pthread_mutex_init(&rendezvouslock, pthread_mutexattr_default)) + panic("pthread_mutex_init"); + + if(pthread_key_create(&prdakey,NULL)) + print("key_create failed\n"); + + p = newproc(); + if(pthread_setspecific(prdakey, p)) + panic("set specific thread data failed\n"); + + pw = getpwuid(getuid()); + if(pw != nil) + kstrdup(&eve, pw->pw_name); + else + print("cannot getpwuid\n"); + + up->env->uid = getuid(); + up->env->gid = getgid(); + + emuinit(imod); +} + +int +readkbd(void) +{ + int n; + char buf[1]; + + n = read(0, buf, sizeof(buf)); + if(n < 0) + print("keyboard close (n=%d, %s)\n", n, strerror(errno)); + if(n <= 0) + pexit("keyboard thread", 0); + + switch(buf[0]) { + case '\r': + buf[0] = '\n'; + break; + case DELETE: + cleanexit(0); + break; + } + return buf[0]; +} + +enum +{ + NHLOG = 7, + NHASH = (1<next) { + if(t->tag == tag) { + rval = t->val; + t->val = value; + t->tag = 0; + pthread_mutex_unlock(&rendezvouslock); +// unlock(&hlock); + if(pthread_cond_signal(&(t->cv))) + panic("pthread_cond_signal"); + return rval; + } + } + + t = ft; + if(t == 0) { + t = malloc(sizeof(Tag)); + if(t == nil) + panic("rendezvous: no memory"); + if(pthread_cond_init(&(t->cv), NULL)) { + print("pthread_cond_init (errno: %s) \n", strerror(errno)); + panic("pthread_cond_init"); + } + } else + ft = t->next; + + t->tag = tag; + t->val = value; + t->next = *l; + *l = t; +// pthread_mutex_unlock(&rendezvouslock); +// unlock(&hlock); + + while(t->tag != nil) + pthread_cond_wait(&(t->cv),&rendezvouslock); + +// pthread_mutex_lock(&rendezvouslock); +// lock(&hlock); + rval = t->val; + for(f = *l; f; f = f->next){ + if(f == t) { + *l = f->next; + break; + } + l = &f->next; + } + t->next = ft; + ft = t; + pthread_mutex_unlock(&rendezvouslock); +// unlock(&hlock); + + return rval; +} + +/* + * Return an abitrary millisecond clock time + */ +long +osmillisec(void) +{ + static long sec0 = 0, usec0; + struct timeval t; + + if(gettimeofday(&t, NULL)<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); +} + +/* + * Return the time since the epoch in nanoseconds and microseconds + * The epoch is defined at 1 Jan 1970 + */ +vlong +osnsec(void) +{ + struct timeval t; + + gettimeofday(&t, nil); + return (vlong)t.tv_sec*1000000000L + t.tv_usec*1000; +} + +vlong +osusectime(void) +{ + struct timeval t; + + gettimeofday(&t, nil); + return (vlong)t.tv_sec * 1000000 + t.tv_usec; +} + + +int +osmillisleep(ulong milsec) +{ + struct timespec time; + time.tv_sec = milsec / 1000; + time.tv_nsec = (milsec % 1000) * 1000000; + nanosleep(&time, nil); + return 0; +} + +int +limbosleep(ulong milsec) +{ + return osmillisleep(milsec); +} + +void +osyield(void) +{ + pthread_yield_np(); + // sched_yield(); +} + +void +ospause(void) +{ + for(;;) + pause(); +} + +void +oslopri(void) +{ +// pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param); + setpriority(PRIO_PROCESS, 0, getpriority(PRIO_PROCESS,0)+4); +} + +__typeof__(sbrk(0)) +sbrk(int size) +{ + void *brk; + kern_return_t err; + + err = vm_allocate( (vm_map_t) mach_task_self(), + (vm_address_t *)&brk, + size, + VM_FLAGS_ANYWHERE); + if (err != KERN_SUCCESS) + brk = (void*)-1; + + return brk; +} -- cgit v1.2.3