diff options
Diffstat (limited to 'mit-pthreads/machdep/engine-i386-sco-3.2v5.c')
| -rwxr-xr-x | mit-pthreads/machdep/engine-i386-sco-3.2v5.c | 1072 |
1 files changed, 1072 insertions, 0 deletions
diff --git a/mit-pthreads/machdep/engine-i386-sco-3.2v5.c b/mit-pthreads/machdep/engine-i386-sco-3.2v5.c new file mode 100755 index 00000000000..95f0d757585 --- /dev/null +++ b/mit-pthreads/machdep/engine-i386-sco-3.2v5.c @@ -0,0 +1,1072 @@ + +/* ==== machdep.c ============================================================ + * Copyright (c) 1995 by Chris Provenzano, proven@mit.edu + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Chris Provenzano. + * 4. The name of Chris Provenzano may not be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY CHRIS PROVENZANO ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL CHRIS PROVENZANO BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * Description : Machine dependent functions for SCO3.2v5 on i386 + * + * 1.00 96/11/21 proven + * -Started coding this file. + */ + +#ifndef lint +static const char rcsid[] = "engine-i386-freebsd-2.0.c,v 1.1 1995/03/01 01:21:20 proven Exp"; +#endif + +#include <pthread.h> +#include <sys/types.h> +#include <sys/timeb.h> +#include <sys/stat.h> +#include <stropts.h> +#include <sys/socket.h> +#include <stdlib.h> +#include <fcntl.h> +#include <stdio.h> +#include <errno.h> +#include <sys/unistd.h> +#include <sys/utsname.h> +#include <sys/sysi86.h> + +void machdep_sys_abort(char*fname,int lineno) + +{ + char buf[128]; + + sprintf(buf,"panic: %s => %d\n", fname, lineno); + machdep_sys_write(1, buf, strlen(buf)); + abort(); +} + +#if 0 +int setitimer(int which, struct itimerval* value, struct itimerval* ovalue) + +{ + register int ret; + if ((ret = machdep_sys_setitimer(which,value,ovalue))<0) { + errno = -ret; + return -1; + } + else { + return 0; + } +} +#endif + +/* ========================================================================== + * machdep_save_state() + */ +int machdep_save_state(void) +{ + return(setjmp(pthread_run->machdep_data.machdep_state)); +} + +/* ========================================================================== + * machdep_save_state() + */ +int machdep_save_float_state(struct pthread * pthread) +{ + char * fdata = (char *)pthread->machdep_data.machdep_float_state; + __asm__ ("fsave %0"::"m" (*fdata)); +} + +/* ========================================================================== + * machdep_restore_state() + */ +void machdep_restore_state(void) +{ + longjmp(pthread_run->machdep_data.machdep_state, 1); +} + +/* ========================================================================== + * machdep_restore_float_state() + */ +int machdep_restore_float_state(void) +{ + char * fdata = (char *)pthread_run->machdep_data.machdep_float_state; + __asm__ ("frstor %0"::"m" (*fdata)); +} + +/* ========================================================================== + * machdep_set_thread_timer() + */ +void machdep_set_thread_timer(struct machdep_pthread *machdep_pthread) +{ + if (machdep_sys_setitimer(ITIMER_VIRTUAL, &(machdep_pthread->machdep_timer), NULL)) { + PANIC(); + } +} + +/* ========================================================================== + * machdep_unset_thread_timer() + */ +void machdep_unset_thread_timer(struct machdep_pthread *machdep_pthread) +{ + struct itimerval zeroval = { { 0, 0 }, { 0, 0 } }; + int ret; + + if (machdep_pthread) { + ret = machdep_sys_setitimer(ITIMER_VIRTUAL, &zeroval, + &(machdep_pthread->machdep_timer)); + } else { + ret = machdep_sys_setitimer(ITIMER_VIRTUAL, &zeroval, NULL); + } + + if (ret) { + PANIC(); + } +} + +/* ========================================================================== + * machdep_pthread_cleanup() + */ +void *machdep_pthread_cleanup(struct machdep_pthread *machdep_pthread) +{ + return(machdep_pthread->machdep_stack); +} + +/* ========================================================================== + * machdep_pthread_start() + */ +void machdep_pthread_start(void) +{ + context_switch_done(); + pthread_sched_resume(); + + /* Run current threads start routine with argument */ + pthread_exit(pthread_run->machdep_data.start_routine + (pthread_run->machdep_data.start_argument)); + + /* should never reach here */ + PANIC(); +} + +/* ========================================================================== + * __machdep_stack_free() + */ +void __machdep_stack_free(void * stack) +{ + free(stack); +} + +/* ========================================================================== + * __machdep_stack_alloc() + */ +void * __machdep_stack_alloc(size_t size) +{ + void * stack; + + return(malloc(size)); +} + +/* ========================================================================== + * __machdep_pthread_create() + */ +void __machdep_pthread_create(struct machdep_pthread *machdep_pthread, + void *(* start_routine)(), void *start_argument, + long stack_size, long nsec, long flags) +{ + machdep_pthread->start_routine = start_routine; + machdep_pthread->start_argument = start_argument; + + machdep_pthread->machdep_timer.it_value.tv_sec = 0; + machdep_pthread->machdep_timer.it_interval.tv_sec = 0; + machdep_pthread->machdep_timer.it_interval.tv_usec = 0; + machdep_pthread->machdep_timer.it_value.tv_usec = nsec / 1000; + + setjmp(machdep_pthread->machdep_state); + /* + * Set up new stact frame so that it looks like it + * returned from a longjmp() to the beginning of + * machdep_pthread_start(). + */ + machdep_pthread->machdep_state[JB_PC] = (int)machdep_pthread_start; + + /* Stack starts high and builds down. */ + machdep_pthread->machdep_state[JB_SP] = + (int)machdep_pthread->machdep_stack + stack_size; +} + +/* ========================================================================== + * machdep_sys_wait3() + */ +machdep_sys_wait3(int * b, int c, int * d) +{ +#if 0 + return(machdep_sys_wait4(0, b, c, d)); +#else + return -ENOSYS; +#endif +} + +/* ========================================================================== + * machdep_sys_fstat() + */ +machdep_sys_fstat(int f, struct stat* b) +{ + return machdep_sys_fxstat(0x33, f, b); +} + +/* ========================================================================== + * machdep_sys_dup2() + */ +machdep_sys_dup2(int a, int b) +{ + machdep_sys_close(b); + return machdep_sys_fcntl(a, F_DUPFD, b); +} + +/* ========================================================================== + * machdep_sys_getdtablesize() + */ +machdep_sys_getdtablesize() + +{ + register int ret; + if ((ret = machdep_sys_sysconf(_SC_OPEN_MAX))<0) + PANIC(); + return ret; +} + +/* ========================================================================== + * machdep_sys_fchown() + */ +machdep_sys_fchown(int fd,uid_t owner,gid_t group) + +{ + return -ENOSYS; +} + +/* ========================================================================== + * machdep_sys_fchmod() + */ +machdep_sys_fchmod(int fd,mode_t mode) + +{ + return -ENOSYS; +} + +/* ========================================================================== + * machdep_sys_getdirentries() + */ +int machdep_sys_getdirentries(int fd, char * buf, int len, int * seek) +{ + return(machdep_sys_getdents(fd, buf, len)); +} + +/* ========================================================================== + * SCO Socket calls are a bit different + * ========================================================================== + * machdep_sys_socket() + */ +int machdep_sys_socket(int domain, int type, int protocol) +{ + register int s, fd, ret; + struct socksysreq req; + + if ((s = machdep_sys_open("/dev/socksys", 0))<0) + return s; + + req.args[0] = SO_SOCKET; + req.args[1] = (int)domain; + req.args[2] = (int)type; + req.args[3] = (int)protocol; + if ((fd = machdep_sys_ioctl(s, SIOCSOCKSYS, &req))<0) { + machdep_sys_close(s); + return fd; + } + + if ((ret=machdep_sys_dup2(fd, s))<0) { + machdep_sys_close(fd); + return ret; + } + + machdep_sys_close(fd); + return s; + +} + +/* ========================================================================== + * machdep_sys_accept() + */ +int machdep_sys_accept(int s, struct sockaddr * b, int * c) +{ + struct socksysreq req; + + req.args[0] = SO_ACCEPT; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_bind() + */ +int machdep_sys_bind(int s, const struct sockaddr * b, int c) +{ + struct socksysreq req; + + req.args[0] = SO_BIND; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_connect() + */ +int machdep_sys_connect(int s, const struct sockaddr * b, int c) +{ + struct socksysreq req; + + req.args[0] = SO_CONNECT; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_listen() + */ +int machdep_sys_listen(int s, int backlog) +{ + struct socksysreq req; + + req.args[0] = SO_LISTEN; + req.args[1] = (int)s; + req.args[2] = (int)backlog; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_shutdown() + */ +int machdep_sys_shutdown(int s, int b) +{ + struct socksysreq req; + + req.args[0] = SO_SHUTDOWN; + req.args[1] = (int)s; + req.args[2] = (int)b; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_getsockopt() + */ +int machdep_sys_getsockopt(int s, int b, int c, char *d, int *e) +{ + struct socksysreq req; + + req.args[0] = SO_GETSOCKOPT; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + req.args[4] = (int)d; + req.args[5] = (int)e; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_setsockopt() + */ +int machdep_sys_setsockopt(int s, int b, int c, char *d, int e) +{ + struct socksysreq req; + + req.args[0] = SO_SETSOCKOPT; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + req.args[4] = (int)d; + req.args[5] = (int)e; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_getpeername() + */ +int machdep_sys_getpeername(int s, struct sockaddr *b, int *c) +{ + struct socksysreq req; + + req.args[0] = SO_GETPEERNAME; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_send() + */ +int machdep_sys_send(int s, char *b, int c, int d) +{ + struct socksysreq req; + + req.args[0] = SO_SEND; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + req.args[4] = (int)d; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_sendto() + */ +int machdep_sys_sendto(int s, char *b, int c, int d, + struct sockaddr *e, int f) +{ + struct socksysreq req; + + req.args[0] = SO_SENDTO; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + req.args[4] = (int)d; + req.args[5] = (int)e; + req.args[6] = (int)f; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_recv() + */ +int machdep_sys_recv(int s, char *b, int c, int d) +{ + struct socksysreq req; + + req.args[0] = SO_RECV; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + req.args[4] = (int)d; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_recvfrom() + */ +int machdep_sys_recvfrom(int s, char *buf, int len, int flags, + struct sockaddr *from, int *fromlen) +{ + struct socksysreq req; + + req.args[0] = SO_RECVFROM; + req.args[1] = (int)s; + req.args[2] = (int)buf; + req.args[3] = (int)len; + req.args[4] = (int)flags; + req.args[5] = (int)from; + req.args[6] = (int)fromlen; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +/* ========================================================================== + * machdep_sys_socketpair() + */ +int machdep_sys_socketpair(int d, int type, int protocol, int sv[2]) + +{ + register int s1, s2; + register int ret; + struct socksysreq req; + + if (d != AF_UNIX) + return -EPROTONOSUPPORT; + if ((s1=machdep_sys_socket(d,type,protocol))<0) { + return s1; + } + if ((s2=machdep_sys_socket(d,type,protocol))<0) { + machdep_sys_close(s1); + return s2; + } + req.args[0] = SO_SOCKPAIR; + req.args[1] = s1; + req.args[2] = s2; + if ((ret=machdep_sys_ioctl(s1,SIOCSOCKSYS,&req))<0) { + machdep_sys_close(s1); + machdep_sys_close(s2); + return ret; + } + sv[0] = s1; + sv[1] = s2; + return 0; +} + +/* ========================================================================== + * machdep_sys_getsockname() + */ +int machdep_sys_getsockname(int s, char * b, int * c) +{ + struct socksysreq req; + + req.args[0] = SO_GETSOCKNAME; + req.args[1] = (int)s; + req.args[2] = (int)b; + req.args[3] = (int)c; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +int machdep_sys_sendmsg(int s, const struct msghdr *msg, int flags) + +{ + struct socksysreq req; + + req.args[0] = SO_SENDMSG; + req.args[1] = (int)s; + req.args[2] = (int)msg; + req.args[3] = (int)flags; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +int machdep_sys_recvmsg(int s, struct msghdr *msg, int flags) + +{ + struct socksysreq req; + + req.args[0] = SO_RECVMSG; + req.args[1] = (int)s; + req.args[2] = (int)msg; + req.args[3] = (int)flags; + + return(machdep_sys_ioctl(s, SIOCSOCKSYS, &req)); +} + +u_short ntohs(u_short n) + +{ + union { + unsigned char u_nc[4]; + u_short u_ns; + } ns; + register unsigned char* p = &ns.u_nc[0]; + + ns.u_ns = n; + return (p[0]<<8)|p[1]; +} + +u_short htons(u_short h) + +{ + union { + unsigned char u_nc[2]; + u_short u_ns; + } ns; + register unsigned char* p = &ns.u_nc[0]; + p[0] = (h>>8)&0xFF; + p[1] = (h&0xFF); + return ns.u_ns; +} + + +u_long ntohl(u_long n) + +{ + union { + unsigned char u_nc[4]; + u_long u_nl; + } nl; + register unsigned char* p = &nl.u_nc[0]; + + nl.u_nl = n; + return (p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3]; +} + +u_long htonl(u_long h) + +{ + union { + unsigned char u_nc[4]; + u_long u_nl; + } nl; + register unsigned char* p = &nl.u_nc[0]; + p[0] = (h>>24)&0xFF; + p[1] = (h>>16)&0xFF; + p[2] = (h>>8)&0xFF; + p[3] = (h&0xFF); + return nl.u_nl; +} + +int getdomainname(char* domain,int len) + +{ + /* edi = len */ + struct socksysreq req; + register int ret, fd; + if (len>MAXHOSTNAMELEN) + len = MAXHOSTNAMELEN; + + if ((fd = machdep_sys_open("/dev/socksys", 0)) < 0) + return fd; + + req.args[0] = SO_GETIPDOMAIN; + req.args[1] = (int)domain; + req.args[2] = (int)len; + if((ret=machdep_sys_ioctl(fd, SIOCSOCKSYS, &req))<0) { + machdep_sys_close(fd); + return ret; + } + + machdep_sys_close(fd); + domain[len-1] = '\0'; + return 0; +} + +int gethostname(char* name, int namelen) + +{ + struct utsname uts; + register int ret, len; + char domain[MAXHOSTNAMELEN+1]; + + if (name==NULL) + return -EFAULT; + if ((ret=machdep_sys_uname(&uts))<0) + return ret; + if (namelen<(len=strlen(uts.nodename))) + return -EFAULT; + strncpy(name,uts.nodename,len); + if (namelen>len) + name[len] = '\0'; + if ((ret=getdomainname(domain, namelen - len))<0) + return ret; + if (domain[0]=='\0') + return 0; + if (len + strlen(domain) + 2 > namelen) + return -EFAULT; + strcat(name, "."); + strcat(name, domain); + return 0; +} + +int gettimeofday(struct timeval* tp, struct timezone* tz) + +{ + register int ret; + if ((ret = machdep_sys_gettimeofday(tp, NULL))<0) { + errno = -ret; + return -1; + } + else { + return 0; + } +} + +int kill(pid_t pid, int signo) + +{ + register int ret; + if ((ret = machdep_sys_kill(pid,signo))<0) { + errno = -ret; + return -1; + } + else { + return 0; + } +} + +typedef void (*signal_t(int signo, void (*func)(int)))(int); + +signal_t* _libc_signal = NULL; + +void (*signal(int signo, void (*func)(int)))(int) + +{ + int ret; + void (*oldfunc)(int); + extern void (*machdep_sys_signal(int signo, void (*func)(int),int* r))(int); + if (_libc_signal!=NULL) + return (*_libc_signal)(signo, func); + + oldfunc = machdep_sys_signal(signo, func, &ret); + if (ret!=0) { + errno = ret; + return SIG_ERR; + } + else { + return oldfunc; + } +} + +int (*_libc_sigaction)(int ,const struct sigaction *, struct sigaction *) = NULL; +int sigaction(int sig,const struct sigaction *act, struct sigaction *oact) + +{ + register int ret; + if (_libc_sigaction!=NULL) + return (*_libc_sigaction)(sig,act,oact); + if ((ret = machdep_sys_sigaction(sig,act,oact))<0) { + errno = -ret; + return -1; + } + else { + return 0; + } +} + +int (*_libc_sigprocmask)(int, const sigset_t *, sigset_t *) = NULL; + +int sigprocmask(int how, const sigset_t *set, sigset_t * oset) + +{ + register int ret; + if (_libc_sigprocmask!=NULL) + return (*_libc_sigprocmask)(how,set,oset); + if ((ret = machdep_sys_sigprocmask(how,set,oset))<0) { + errno = -ret; + return -1; + } + else { + return 0; + } +} + +int (*_libc_sigsuspend)(const sigset_t *) = NULL; + +int sigsuspend(const sigset_t *set) +{ + register int ret; + if (_libc_sigsuspend!=NULL) + return (*_libc_sigsuspend)(set); + if ((ret = machdep_sys_sigsuspend(set))<0) { + errno = -ret; + return -1; + } + else { + return 0; + } +} + +int _sigrelse(sig) +int sig; + +{ + sigset_t mask; + sigemptyset(&mask); + sigaddset(&mask, sig); + return sigprocmask(SIG_UNBLOCK,&mask,NULL); +} + +int _sighold(sig) +int sig; + +{ + sigset_t mask; + sigemptyset(&mask); + sigaddset(&mask, sig); + return sigprocmask(SIG_BLOCK,&mask,NULL); +} + +void (*sigset(int sig, void (*func)(int)))(int) +{ + return signal(sig, func); +} + + +int (*_libc_getmsg)(int , struct strbuf *, struct strbuf *, int *) = NULL; + +int getmsg(int fd, struct strbuf * ctlptr, struct strbuf * dataptr, + int * flags) +{ + register int ret; + if (_libc_getmsg != NULL) + return (*_libc_getmsg)(fd,ctlptr,dataptr,flags); + else if ((ret=machdep_sys_getmsg(fd,ctlptr,dataptr,flags))<0) { + errno = -ret; + return -1; + } + else + return ret; +} + +int (*_libc_putmsg)(int , const struct strbuf *, const struct strbuf *, int) = NULL; + +int putmsg(int fd, const struct strbuf * ctlptr, const struct strbuf * dataptr, + int flags) +{ + register int ret; + if (_libc_putmsg != NULL) + return (*_libc_putmsg)(fd,ctlptr,dataptr,flags); + else if ((ret=machdep_sys_putmsg(fd,ctlptr,dataptr,flags))<0) { + errno = -ret; + return -1; + } + else + return ret; +} + +int ftime(struct timeb* tp) + +{ + register int ret; + if ((ret=machdep_sys_ftime(tp))<0) { + errno = -ret; + return NOTOK; + } + return 0; +} + +int getpagesize() + +{ + register int ret; +#if 0 + if ((ret = machdep_sys_sysconf(_SC_PAGE_SIZE))<0) { + PANIC(); + SET_ERRNO(-ret); + return -1; + } + else { + return 0; + } +#else + return PAGESIZE; +#endif +} + +static pthread_mutex_t machdep_mutex = +{ MUTEX_TYPE_COUNTING_FAST, PTHREAD_QUEUE_INITIALIZER, \ + NULL, SEMAPHORE_CLEAR, { NULL }, MUTEX_FLAGS_INITED }; + +static pthread_mutex_t malloc_mutex = +{ MUTEX_TYPE_COUNTING_FAST, PTHREAD_QUEUE_INITIALIZER, \ + NULL, SEMAPHORE_CLEAR, { NULL }, MUTEX_FLAGS_INITED }; + +struct stdlock { + volatile long init; + pthread_mutex_t* mutex; +}; + +static void machdep_stdinitlock(struct stdlock* lock) + +{ + if (lock==0) PANIC(); + pthread_mutex_lock(&machdep_mutex); + if (!lock->init) { + register pthread_mutex_t* mutex; + pthread_mutexattr_t attr; + + lock->init = 1; + lock->mutex = &machdep_mutex; + mutex = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t)); + pthread_mutexattr_init (&attr); + pthread_mutexattr_settype (&attr, MUTEX_TYPE_COUNTING_FAST); + pthread_mutex_init(mutex, &attr); + lock->mutex = mutex; + } + pthread_mutex_unlock(&machdep_mutex); +} + +void machdep_stdlock(struct stdlock* lock) + +{ + if (lock==0) PANIC(); + if (!lock->init) + machdep_stdinitlock(lock); + pthread_mutex_lock(lock->mutex); +} + +void machdep_stdunlock(struct stdlock* lock) + +{ + if (lock==0) PANIC(); + if (!lock->init) + machdep_stdinitlock(lock); + pthread_mutex_unlock(lock->mutex); +} + +int machdep_stdtrylock(struct stdlock* lock) + +{ + if (lock==0) PANIC(); + if (!lock->init) + machdep_stdinitlock(lock); + return pthread_mutex_trylock(lock->mutex); +} + +int machdep_stdtryunlock(struct stdlock* lock) + +{ + if (lock==0) PANIC(); + if (!lock->init) + machdep_stdinitlock(lock); + if (pthread_mutex_trylock(lock->mutex)) + return pthread_mutex_unlock(lock->mutex); + return 0; +} + +extern void (*_libc_stdlock)(struct stdlock* lock); +extern void (*_libc_stdunlock)(struct stdlock* lock); +extern int (*_libc_stdtrylock)(struct stdlock* lock); +extern int (*_libc_stdtryunlock)(struct stdlock* lock); + +int machdep_sys_init() + +{ + typedef void (*voidfunc_t)(); + extern voidfunc_t _libc_read; + extern voidfunc_t _libc_write; + extern voidfunc_t _libc_readv; + extern voidfunc_t _libc_writev; + extern voidfunc_t _libc_open; + extern voidfunc_t _libc_close; + extern voidfunc_t _libc_fork; + extern voidfunc_t _libc_fcntl; + extern voidfunc_t _libc_dup; + extern voidfunc_t _libc_pipe; + extern voidfunc_t _libc_select; + extern voidfunc_t _libc_malloc; + extern voidfunc_t _libc_realloc; + extern voidfunc_t _libc_free; + extern ssize_t pthread_read (int , char*, int ); + extern ssize_t pthread_write (int , char*, int ); + extern int pthread_close (int); + extern int pthread_dup (int); + extern int pthread_fork (); + extern int pthread_pipe (int*); + extern int pthread_fcntl(int, int, ...); + extern int pthread_open(const char *, int, ...); + extern ssize_t pthread_readv (int , const struct iovec *, int ); + extern ssize_t pthread_writev (int , const struct iovec *, int ); + extern int pthread_select(int, fd_set *, fd_set *, fd_set *, struct timeval *); + extern int pthread_getmsg(int , struct strbuf *, struct strbuf *,int*); + extern int pthread_putmsg(int , const struct strbuf *, const struct strbuf *,int); + extern void (*pthread_signal(int , void (*)(int)))(int); + extern int pthread_sigaction(int,const struct sigaction *, struct sigaction *); + extern int pthread_sigprocmask(int, const sigset_t *, sigset_t *); + extern int pthread_sigsuspend(const sigset_t *); + + + static struct { + voidfunc_t *p; + voidfunc_t f; + } maptable[] = { + {(voidfunc_t*)&_libc_read, (voidfunc_t) pthread_read}, + {(voidfunc_t*)&_libc_write, (voidfunc_t) pthread_write}, + {(voidfunc_t*)&_libc_readv, (voidfunc_t) pthread_readv}, + {(voidfunc_t*)&_libc_writev, (voidfunc_t) pthread_writev}, + {(voidfunc_t*)&_libc_open, (voidfunc_t) pthread_open}, + {(voidfunc_t*)&_libc_close, (voidfunc_t) pthread_close}, + {(voidfunc_t*)&_libc_fork, (voidfunc_t) pthread_fork}, + {(voidfunc_t*)&_libc_fcntl, (voidfunc_t) pthread_fcntl}, + {(voidfunc_t*)&_libc_dup, (voidfunc_t) pthread_dup}, + {(voidfunc_t*)&_libc_pipe, (voidfunc_t) pthread_pipe}, + {(voidfunc_t*)&_libc_select, (voidfunc_t) pthread_select}, + {(voidfunc_t*)&_libc_getmsg, (voidfunc_t) pthread_getmsg}, + {(voidfunc_t*)&_libc_putmsg, (voidfunc_t) pthread_putmsg}, + {(voidfunc_t*)&_libc_signal, (voidfunc_t) pthread_signal}, + {(voidfunc_t*)&_libc_sigaction, (voidfunc_t) pthread_sigaction}, + {(voidfunc_t*)&_libc_sigprocmask, (voidfunc_t) pthread_sigprocmask}, + {(voidfunc_t*)&_libc_sigsuspend, (voidfunc_t) pthread_sigsuspend}, + {(voidfunc_t*) 0, (voidfunc_t) 0} + }; + register int i; + + for (i=0; maptable[i].p; i++) + *maptable[i].p = maptable[i].f; + + _libc_stdlock = machdep_stdlock; + _libc_stdunlock = machdep_stdunlock; + _libc_stdtrylock = machdep_stdtrylock; + _libc_stdtryunlock = machdep_stdtryunlock; + return 0; +} + +#if 0 +extern end; +char* nd = (char*) &end; +char* brk(const char* endds) + +{ + register int ret; + + if ((ret = machdep_sys_brk((char*)endds))<0) { + SET_ERRNO(-ret); + return (char*) -1; + } + else { + nd = (char*) endds; + return 0; + } +} + +char *sbrk(int incr) + +{ + register char* ret; + if (incr!=0 && (ret=brk(nd + incr))!=0) + return ret; + else + return nd - incr; +} +#endif + +sigset_t sigmask(int sig) + +{ + sigset_t oset; + sigemptyset(&oset); + sigaddset(&oset, sig); + return oset; +} + +sigset_t sigsetmask(sigset_t set) + +{ + sigset_t oset; + sigprocmask(SIG_SETMASK,&set,&oset); + return oset; +} + +sigset_t sigblock(sigset_t set) + +{ + sigset_t oset; + sigprocmask(SIG_BLOCK,&set,&oset); + return oset; +} |