diff options
Diffstat (limited to 'lib/libpthread/uthread')
30 files changed, 1040 insertions, 295 deletions
diff --git a/lib/libpthread/uthread/Makefile.inc b/lib/libpthread/uthread/Makefile.inc index 0e285297a0b..196cddca170 100644 --- a/lib/libpthread/uthread/Makefile.inc +++ b/lib/libpthread/uthread/Makefile.inc @@ -1,5 +1,5 @@ -# $Id: Makefile.inc,v 1.1 1998/08/27 09:00:49 d Exp $ -# $OpenBSD: Makefile.inc,v 1.1 1998/08/27 09:00:49 d Exp $ +# $Id: Makefile.inc,v 1.2 1998/11/09 03:13:18 d Exp $ +# $OpenBSD: Makefile.inc,v 1.2 1998/11/09 03:13:18 d Exp $ # uthread sources .PATH: ${.CURDIR}/uthread @@ -42,6 +42,7 @@ SRCS+= \ uthread_fstat.c \ uthread_fstatfs.c \ uthread_fsync.c \ + uthread_gc.c \ uthread_getdirentries.c \ uthread_getpeername.c \ uthread_getprio.c \ @@ -69,6 +70,8 @@ SRCS+= \ uthread_recvfrom.c \ uthread_recvmsg.c \ uthread_resume_np.c \ + uthread_rwlock.c \ + uthread_rwlockattr.c \ uthread_select.c \ uthread_self.c \ uthread_sendmsg.c \ @@ -79,6 +82,7 @@ SRCS+= \ uthread_shutdown.c \ uthread_sig.c \ uthread_sigaction.c \ + uthread_sigaltstack.c \ uthread_sigblock.c \ uthread_sigmask.c \ uthread_sigprocmask.c \ @@ -91,6 +95,7 @@ SRCS+= \ uthread_spec.c \ uthread_spinlock.c \ uthread_suspend_np.c \ + uthread_vfork.c \ uthread_wait4.c \ uthread_write.c \ uthread_writev.c \ diff --git a/lib/libpthread/uthread/pthread_private.h b/lib/libpthread/uthread/pthread_private.h index ce7da3da5c4..2197bb709f6 100644 --- a/lib/libpthread/uthread/pthread_private.h +++ b/lib/libpthread/uthread/pthread_private.h @@ -56,8 +56,8 @@ #define PANIC(string) _thread_exit(__FILE__,__LINE__,string) /* Output debug messages like this: */ -#define stdout_debug(_x) _write(1,_x,strlen(_x)); -#define stderr_debug(_x) _write(2,_x,strlen(_x)); +#define stdout_debug(_x) _thread_sys_write(1,_x,strlen(_x)); +#define stderr_debug(_x) _thread_sys_write(2,_x,strlen(_x)); /* * State change macro: @@ -218,6 +218,18 @@ struct pthread_key { void (*destructor) (); }; +struct pthread_rwlockattr { + int pshared; +}; + +struct pthread_rwlock { + pthread_mutex_t lock; /* monitor lock */ + int state; /* 0 = idle >0 = # of readers -1 = writer */ + pthread_cond_t read_signal; + pthread_cond_t write_signal; + int blocked_writers; +}; + /* * Thread states. */ @@ -234,6 +246,7 @@ enum pthread_state { PS_SELECT_WAIT, PS_SLEEP_WAIT, PS_WAIT_WAIT, + PS_SIGSUSPEND, PS_SIGWAIT, PS_JOIN, PS_SUSPENDED, @@ -264,9 +277,9 @@ struct fd_table_entry { struct pthread_queue w_queue; /* Write queue. */ struct pthread *r_owner; /* Ptr to thread owning read lock. */ struct pthread *w_owner; /* Ptr to thread owning write lock. */ - char *r_fname; /* Ptr to read lock source file name */ + const char *r_fname; /* Ptr to read lock source file name */ int r_lineno; /* Read lock source line number. */ - char *w_fname; /* Ptr to write lock source file name */ + const char *w_fname; /* Ptr to write lock source file name */ int w_lineno; /* Write lock source line number. */ int r_lockcount; /* Count for FILE read locks. */ int w_lockcount; /* Count for FILE write locks. */ @@ -287,7 +300,7 @@ union pthread_wait_data { struct { short fd; /* Used when thread waiting on fd */ short branch; /* Line number, for debugging. */ - char *fname; /* Source file name for debugging.*/ + const char *fname; /* Source file name for debugging.*/ } fd; struct pthread_select_data * select_data; }; @@ -315,6 +328,11 @@ struct pthread { struct pthread *nxt; /* + * Pointer to the next thread in the dead thread linked list. + */ + struct pthread *nxt_dead; + + /* * Thread start routine, argument, stack pointer and thread * attributes. */ @@ -426,7 +444,7 @@ struct pthread { /* Cleanup handlers Link List */ struct pthread_cleanup *cleanup; - char *fname; /* Ptr to source file name */ + const char *fname; /* Ptr to source file name */ int lineno; /* Source line number. */ }; @@ -486,6 +504,10 @@ extern int _pthread_stdio_flags[3]; extern struct fd_table_entry **_thread_fd_table; extern int _thread_dtablesize; +/* Garbage collector mutex and condition variable. */ +extern pthread_mutex_t _gc_mutex; +extern pthread_cond_t _gc_cond; + /* * Array of signal actions for this process. */ @@ -514,24 +536,23 @@ int _find_dead_thread(pthread_t); int _find_thread(pthread_t); int _thread_create(pthread_t *,const pthread_attr_t *,void *(*start_routine)(void *),void *,pthread_t); int _thread_fd_lock(int, int, struct timespec *); -int _thread_fd_lock_debug(int, int, struct timespec *,char *fname,int lineno); +int _thread_fd_lock_debug(int, int, struct timespec *,const char *fname,int lineno); void _dispatch_signals(void); void _thread_signal(pthread_t, int); -void _lock_dead_thread_list(void); void _lock_thread(void); void _lock_thread_list(void); -void _unlock_dead_thread_list(void); void _unlock_thread(void); void _unlock_thread_list(void); -void _thread_exit(char *, int, char *); +void _thread_exit(char *, int, char *) + __attribute__((noreturn)); void _thread_fd_unlock(int, int); void _thread_fd_unlock_debug(int, int, char *, int); void *_thread_cleanup(pthread_t); void _thread_cleanupspecific(void); void _thread_dump_info(void); -void _thread_init(void) __attribute__((constructor)); +void _thread_init(void) /* __attribute__((constructor)) */; void _thread_kern_sched(struct sigcontext *); -void _thread_kern_sched_state(enum pthread_state,char *fname,int lineno); +void _thread_kern_sched_state(enum pthread_state,const char *fname,int lineno); void _thread_kern_set_timeout(struct timespec *); void _thread_sig_handler(int, int, struct sigcontext *); void _thread_start(void); @@ -543,6 +564,8 @@ int _thread_queue_remove(struct pthread_queue *, struct pthread *); int _thread_fd_table_init(int fd); struct pthread *_thread_queue_get(struct pthread_queue *); struct pthread *_thread_queue_deq(struct pthread_queue *); +pthread_addr_t _thread_gc(pthread_addr_t); + /* #include <signal.h> */ #ifdef _USER_SIGNAL_H @@ -553,7 +576,7 @@ int _thread_sys_sigsuspend(const sigset_t *); int _thread_sys_siginterrupt(int, int); int _thread_sys_sigpause(int); int _thread_sys_sigreturn(struct sigcontext *); -int _thread_sys_sigstack(const struct sigstack *, struct sigstack *); +int _thread_sys_sigaltstack(const struct sigaltstack *, struct sigaltstack *); int _thread_sys_sigvec(int, struct sigvec *, struct sigvec *); void _thread_sys_psignal(unsigned int, const char *); void (*_thread_sys_signal(int, void (*)(int)))(int); @@ -675,7 +698,8 @@ pid_t _thread_sys_fork(void); pid_t _thread_sys_tcgetpgrp(int); ssize_t _thread_sys_read(int, void *, size_t); ssize_t _thread_sys_write(int, const void *, size_t); -void _thread_sys__exit(int); +void _thread_sys__exit(int) + __attribute__((noreturn)); #endif /* #include <fcntl.h> */ diff --git a/lib/libpthread/uthread/uthread_close.c b/lib/libpthread/uthread/uthread_close.c index 7e21853223e..4bc4999ebda 100644 --- a/lib/libpthread/uthread/uthread_close.c +++ b/lib/libpthread/uthread/uthread_close.c @@ -43,7 +43,6 @@ close(int fd) { int flags; int ret; - int status; struct stat sb; /* Lock the file descriptor while the file is closed: */ diff --git a/lib/libpthread/uthread/uthread_cond.c b/lib/libpthread/uthread/uthread_cond.c index fae12ebb68b..aedc36b4b31 100644 --- a/lib/libpthread/uthread/uthread_cond.c +++ b/lib/libpthread/uthread/uthread_cond.c @@ -126,7 +126,6 @@ int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex) { int rval = 0; - int status; if (cond == NULL) rval = EINVAL; @@ -190,7 +189,6 @@ pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex, const struct timespec * abstime) { int rval = 0; - int status; if (cond == NULL) rval = EINVAL; @@ -270,7 +268,6 @@ int pthread_cond_signal(pthread_cond_t * cond) { int rval = 0; - int status; pthread_t pthread; if (cond == NULL || *cond == NULL) @@ -309,7 +306,6 @@ int pthread_cond_broadcast(pthread_cond_t * cond) { int rval = 0; - int status; pthread_t pthread; if (cond == NULL || *cond == NULL) diff --git a/lib/libpthread/uthread/uthread_create.c b/lib/libpthread/uthread/uthread_create.c index 53759d8f440..68db603cac2 100644 --- a/lib/libpthread/uthread/uthread_create.c +++ b/lib/libpthread/uthread/uthread_create.c @@ -44,9 +44,9 @@ int pthread_create(pthread_t * thread, const pthread_attr_t * attr, void *(*start_routine) (void *), void *arg) { - int i; + int f_gc = 0; int ret = 0; - int status; + pthread_t gc_thread; pthread_t new_thread; pthread_attr_t pattr; void *stack; @@ -149,6 +149,12 @@ pthread_create(pthread_t * thread, const pthread_attr_t * attr, /* Lock the thread list: */ _lock_thread_list(); + /* + * Check if the garbage collector thread + * needs to be started. + */ + f_gc = (_thread_link_list == _thread_initial); + /* Add the thread to the linked list of all threads: */ new_thread->nxt = _thread_link_list; _thread_link_list = new_thread; @@ -161,6 +167,14 @@ pthread_create(pthread_t * thread, const pthread_attr_t * attr, /* Schedule the new user thread: */ _thread_kern_sched(NULL); + + /* + * Start a garbage collector thread + * if necessary. + */ + if (f_gc && pthread_create(&gc_thread,NULL, + _thread_gc,NULL) != 0) + PANIC("Can't create gc thread"); } } @@ -171,6 +185,9 @@ pthread_create(pthread_t * thread, const pthread_attr_t * attr, void _thread_start(void) { + /* We just left the scheduler via longjmp: */ + _thread_kern_in_sched = 0; + /* Run the current thread's start routine with argument: */ pthread_exit(_thread_run->start_routine(_thread_run->arg)); diff --git a/lib/libpthread/uthread/uthread_detach.c b/lib/libpthread/uthread/uthread_detach.c index da456bfbab9..d471da6f068 100644 --- a/lib/libpthread/uthread/uthread_detach.c +++ b/lib/libpthread/uthread/uthread_detach.c @@ -39,7 +39,6 @@ int pthread_detach(pthread_t pthread) { int rval = 0; - int status; pthread_t next_thread; /* Check for invalid calling parameters: */ diff --git a/lib/libpthread/uthread/uthread_dup2.c b/lib/libpthread/uthread/uthread_dup2.c index e9edddd35c1..3e4ed27d359 100644 --- a/lib/libpthread/uthread/uthread_dup2.c +++ b/lib/libpthread/uthread/uthread_dup2.c @@ -30,6 +30,7 @@ * SUCH DAMAGE. * */ +#include <errno.h> #include <unistd.h> #ifdef _THREAD_SAFE #include <pthread.h> @@ -39,11 +40,20 @@ int dup2(int fd, int newfd) { int ret; + int newfd_opened; + + /* Check if the file descriptor is out of range: */ + if (newfd < 0 || newfd >= _thread_dtablesize) { + /* Return a bad file descriptor error: */ + errno = EBADF; + ret = -1; + } /* Lock the file descriptor: */ - if ((ret = _FD_LOCK(fd, FD_RDWR, NULL)) == 0) { + else if ((ret = _FD_LOCK(fd, FD_RDWR, NULL)) == 0) { /* Lock the file descriptor: */ - if ((ret = _FD_LOCK(newfd, FD_RDWR, NULL)) == 0) { + if (!(newfd_opened = (_thread_fd_table[newfd] != NULL)) || + (ret = _FD_LOCK(newfd, FD_RDWR, NULL)) == 0) { /* Perform the 'dup2' syscall: */ if ((ret = _thread_sys_dup2(fd, newfd)) < 0) { } @@ -63,7 +73,8 @@ dup2(int fd, int newfd) } /* Unlock the file descriptor: */ - _FD_UNLOCK(newfd, FD_RDWR); + if (newfd_opened) + _FD_UNLOCK(newfd, FD_RDWR); } /* Unlock the file descriptor: */ _FD_UNLOCK(fd, FD_RDWR); diff --git a/lib/libpthread/uthread/uthread_execve.c b/lib/libpthread/uthread/uthread_execve.c index 5f40e1c560e..0d289a44ab9 100644 --- a/lib/libpthread/uthread/uthread_execve.c +++ b/lib/libpthread/uthread/uthread_execve.c @@ -97,7 +97,7 @@ execve(const char *name, char *const * argv, char *const * envp) } } - /* Execute the process: */ + /* Set the signal mask: */ _thread_sys_sigprocmask(SIG_SETMASK, &_thread_run->sigmask, NULL); /* Execute the process: */ diff --git a/lib/libpthread/uthread/uthread_exit.c b/lib/libpthread/uthread/uthread_exit.c index 0083f2b0169..bc061e0fa6a 100644 --- a/lib/libpthread/uthread/uthread_exit.c +++ b/lib/libpthread/uthread/uthread_exit.c @@ -34,10 +34,13 @@ #include <unistd.h> #include <fcntl.h> #include <string.h> +#include <stdio.h> +#include <stdlib.h> #ifdef _THREAD_SAFE #include <pthread.h> #include "pthread_private.h" +void _exit(int) __attribute__((noreturn)); void _exit(int status) { int flags; @@ -98,14 +101,12 @@ _thread_exit(char *fname, int lineno, char *string) void pthread_exit(void *status) { - int sig; - long l; pthread_t pthread; /* Check if this thread is already in the process of exiting: */ if ((_thread_run->flags & PTHREAD_EXITING) != 0) { char msg[128]; - snprintf(msg,"Thread %p has called pthread_exit() from a destructor. POSIX 1003.1 1996 s16.2.5.2 does not allow this!",_thread_run); + snprintf(msg,sizeof msg,"Thread %p has called pthread_exit() from a destructor. POSIX 1003.1 1996 s16.2.5.2 does not allow this!",_thread_run); PANIC(msg); } @@ -133,56 +134,29 @@ pthread_exit(void *status) PTHREAD_NEW_STATE(pthread,PS_RUNNING); } - /* Lock the thread list: */ - _lock_thread_list(); - - /* Check if the running thread is at the head of the linked list: */ - if (_thread_link_list == _thread_run) { - /* There is no previous thread: */ - _thread_link_list = _thread_run->nxt; - } else { - /* Point to the first thread in the list: */ - pthread = _thread_link_list; - - /* - * Enter a loop to find the thread in the linked list before - * the running thread: - */ - while (pthread != NULL && pthread->nxt != _thread_run) { - /* Point to the next thread: */ - pthread = pthread->nxt; - } - - /* Check that a previous thread was found: */ - if (pthread != NULL) { - /* - * Point the previous thread to the one after the - * running thread: - */ - pthread->nxt = _thread_run->nxt; - } - } - - /* Unlock the thread list: */ - _unlock_thread_list(); - - /* Lock the dead thread list: */ - _lock_dead_thread_list(); - /* - * This thread will never run again. Add it to the list of dead - * threads: + * Lock the garbage collector mutex to ensure that the garbage + * collector is not using the dead thread list. */ - _thread_run->nxt = _thread_dead; - _thread_dead = _thread_run; + if (pthread_mutex_lock(&_gc_mutex) != 0) + PANIC("Cannot lock gc mutex"); - /* Unlock the dead thread list: */ - _unlock_dead_thread_list(); + /* Add this thread to the list of dead threads. */ + _thread_run->nxt_dead = _thread_dead; + _thread_dead = _thread_run; /* - * The running thread is no longer in the thread link list so it will - * now die: + * Signal the garbage collector thread that there is something + * to clean up. */ + if (pthread_cond_signal(&_gc_cond) != 0) + PANIC("Cannot signal gc cond"); + + /* Unlock the garbage collector mutex: */ + if (pthread_mutex_unlock(&_gc_mutex) != 0) + PANIC("Cannot lock gc mutex"); + + /* This this thread will never be re-scheduled. */ _thread_kern_sched_state(PS_DEAD, __FILE__, __LINE__); /* This point should not be reached. */ diff --git a/lib/libpthread/uthread/uthread_fcntl.c b/lib/libpthread/uthread/uthread_fcntl.c index eecda60d8ae..6ea013afe5d 100644 --- a/lib/libpthread/uthread/uthread_fcntl.c +++ b/lib/libpthread/uthread/uthread_fcntl.c @@ -44,7 +44,6 @@ fcntl(int fd, int cmd,...) int nonblock; int oldfd; int ret; - int status; va_list ap; /* Lock the file descriptor: */ diff --git a/lib/libpthread/uthread/uthread_fd.c b/lib/libpthread/uthread/uthread_fd.c index 1e4495e6ef9..0c2b10a7d8a 100644 --- a/lib/libpthread/uthread/uthread_fd.c +++ b/lib/libpthread/uthread/uthread_fd.c @@ -29,8 +29,8 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: uthread_fd.c,v 1.1 1998/08/27 09:01:01 d Exp $ - * $OpenBSD: uthread_fd.c,v 1.1 1998/08/27 09:01:01 d Exp $ + * $Id: uthread_fd.c,v 1.2 1998/11/09 03:13:19 d Exp $ + * $OpenBSD: uthread_fd.c,v 1.2 1998/11/09 03:13:19 d Exp $ * */ #include <errno.h> @@ -56,6 +56,7 @@ _thread_fd_table_init(int fd) { int ret = 0; struct fd_table_entry *entry; + int saved_errno; /* Check if the file descriptor is out of range: */ if (fd < 0 || fd >= _thread_dtablesize) { @@ -117,8 +118,10 @@ _thread_fd_table_init(int fd) * not support non-blocking calls, or if the * driver is naturally non-blocking. */ + saved_errno = errno; _thread_sys_fcntl(fd, F_SETFL, entry->flags | O_NONBLOCK); + errno = saved_errno; /* Lock the file descriptor table: */ _SPINLOCK(&fd_table_lock); @@ -531,7 +534,7 @@ _thread_fd_unlock_debug(int fd, int lock_type, char *fname, int lineno) int _thread_fd_lock_debug(int fd, int lock_type, struct timespec * timeout, - char *fname, int lineno) + const char *fname, int lineno) { int ret; diff --git a/lib/libpthread/uthread/uthread_file.c b/lib/libpthread/uthread/uthread_file.c index 71fecfea217..26f0835ec1c 100644 --- a/lib/libpthread/uthread/uthread_file.c +++ b/lib/libpthread/uthread/uthread_file.c @@ -29,8 +29,8 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: uthread_file.c,v 1.1 1998/08/27 09:01:02 d Exp $ - * $OpenBSD: uthread_file.c,v 1.1 1998/08/27 09:01:02 d Exp $ + * $Id: uthread_file.c,v 1.2 1998/11/09 03:13:19 d Exp $ + * $OpenBSD: uthread_file.c,v 1.2 1998/11/09 03:13:19 d Exp $ * * POSIX stdio FILE locking functions. These assume that the locking * is only required at FILE structure level, not at file descriptor @@ -46,13 +46,6 @@ #include "pthread_private.h" /* - * Weak symbols for externally visible functions in this file: - */ -#pragma weak flockfile=_flockfile -#pragma weak ftrylockfile=_ftrylockfile -#pragma weak funlockfile=_funlockfile - -/* * The FILE lock structure. The FILE *fp is locked if the owner is * not NULL. If not locked, the file lock structure can be * reassigned to a different file by setting fp. @@ -83,7 +76,7 @@ struct file_lock { * structures. If there is a collision, a linear search of the * dynamic list of locks linked to each static lock is perfomed. */ -#define file_idx(_p) ((((long) _p) >> sizeof(void *)) % NUM_HEADS) +#define file_idx(_p) ((((u_long) _p) >> sizeof(void *)) % NUM_HEADS) /* * Global array of file locks. The first lock for each hash bucket is @@ -123,7 +116,7 @@ find_lock(int idx, FILE *fp) * Loop through the dynamic locks looking for the * target file: */ - while (p != NULL && p->fp != fp && p->owner != NULL) + while (p != NULL && (p->fp != fp || p->owner == NULL)) /* Not this file, try the next: */ p = p->entry.le_next; } @@ -180,10 +173,8 @@ do_lock(int idx, FILE *fp) } void -_flockfile_debug(FILE * fp, char *fname, int lineno) +_flockfile_debug(FILE * fp, const char *fname, int lineno) { - int fd, flags; - int status; int idx = file_idx(fp); struct file_lock *p; @@ -246,17 +237,16 @@ _flockfile_debug(FILE * fp, char *fname, int lineno) } void -_flockfile(FILE * fp) +flockfile(FILE * fp) { - _flockfile_debug(fp, __FILE__, __LINE__); + _flockfile_debug(fp, "?", 1); return; } int -_ftrylockfile(FILE * fp) +ftrylockfile(FILE * fp) { int ret = -1; - int status; int idx = file_idx(fp); struct file_lock *p; @@ -306,9 +296,8 @@ _ftrylockfile(FILE * fp) } void -_funlockfile(FILE * fp) +funlockfile(FILE * fp) { - int status; int idx = file_idx(fp); struct file_lock *p; diff --git a/lib/libpthread/uthread/uthread_find_thread.c b/lib/libpthread/uthread/uthread_find_thread.c index 99e302306d2..e4a59a0d83f 100644 --- a/lib/libpthread/uthread/uthread_find_thread.c +++ b/lib/libpthread/uthread/uthread_find_thread.c @@ -76,8 +76,12 @@ _find_dead_thread(pthread_t pthread) /* Invalid thread: */ return(EINVAL); - /* Lock the dead thread list: */ - _lock_dead_thread_list(); + /* + * Lock the garbage collector mutex to ensure that the garbage + * collector is not using the dead thread list. + */ + if (pthread_mutex_lock(&_gc_mutex) != 0) + PANIC("Cannot lock gc mutex"); /* Point to the first thread in the list: */ pthread1 = _thread_dead; @@ -85,11 +89,12 @@ _find_dead_thread(pthread_t pthread) /* Search for the thread to join to: */ while (pthread1 != NULL && pthread1 != pthread) { /* Point to the next thread: */ - pthread1 = pthread1->nxt; + pthread1 = pthread1->nxt_dead; } - /* Unlock the dead thread list: */ - _unlock_dead_thread_list(); + /* Unlock the garbage collector mutex: */ + if (pthread_mutex_unlock(&_gc_mutex) != 0) + PANIC("Cannot lock gc mutex"); /* Return zero if the thread exists: */ return ((pthread1 != NULL) ? 0:ESRCH); diff --git a/lib/libpthread/uthread/uthread_fork.c b/lib/libpthread/uthread/uthread_fork.c index b62990a1a50..c9b5cee5f90 100644 --- a/lib/libpthread/uthread/uthread_fork.c +++ b/lib/libpthread/uthread/uthread_fork.c @@ -33,8 +33,8 @@ #include <errno.h> #include <string.h> #include <unistd.h> -#include <stdlib.h> #include <fcntl.h> +#include <stdlib.h> #ifdef _THREAD_SAFE #include <pthread.h> #include "pthread_private.h" @@ -43,7 +43,6 @@ pid_t fork(void) { int flags; - int status; pid_t ret; pthread_t pthread; pthread_t pthread_next; @@ -105,15 +104,16 @@ fork(void) pthread->nxt = NULL; } else { if (pthread->attr.stackaddr_attr == - NULL && pthread->stack != NULL) { + NULL && pthread->stack != NULL) /* * Free the stack of the * dead thread: */ free(pthread->stack); - } + if (pthread->specific_data != NULL) free(pthread->specific_data); + free(pthread); } diff --git a/lib/libpthread/uthread/uthread_gc.c b/lib/libpthread/uthread/uthread_gc.c new file mode 100644 index 00000000000..32d79b5dfac --- /dev/null +++ b/lib/libpthread/uthread/uthread_gc.c @@ -0,0 +1,278 @@ +/* + * Copyright (c) 1998 John Birrell <jb@cimlogic.com.au> + * 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 John Birrell. + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. + * + * $Id: uthread_gc.c,v 1.1 1998/11/09 03:13:19 d Exp $ + * $OpenBSD: uthread_gc.c,v 1.1 1998/11/09 03:13:19 d Exp $ + * + * Garbage collector thread. Frees memory allocated for dead threads. + * + */ +#include <errno.h> +#include <time.h> +#include <unistd.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/time.h> +#ifdef _THREAD_SAFE +#include <pthread.h> +#include <pthread_np.h> +#include "pthread_private.h" + +pthread_addr_t +_thread_gc(pthread_addr_t arg) +{ + int f_debug; + int f_done = 0; + int ret; + pthread_t pthread; + pthread_t pthread_cln; + pthread_t pthread_nxt; + pthread_t pthread_prv; + struct timespec abstime; + void *p_stack; + + /* Set a debug flag based on an environment variable. */ + f_debug = (getenv("LIBC_R_DEBUG") != NULL); + + /* Set the name of this thread. */ + pthread_set_name_np(_thread_run,"GC"); + + while (!f_done) { + /* Check if debugging this application. */ + if (f_debug) + /* Dump thread info to file. */ + _thread_dump_info(); + + /* Lock the thread list: */ + _lock_thread_list(); + + /* Check if this is the last running thread: */ + if (_thread_link_list == _thread_run && + _thread_link_list->nxt == NULL) + /* + * This is the last thread, so it can exit + * now. + */ + f_done = 1; + + /* Unlock the thread list: */ + _unlock_thread_list(); + + /* + * Lock the garbage collector mutex which ensures that + * this thread sees another thread exit: + */ + if (pthread_mutex_lock(&_gc_mutex) != 0) + PANIC("Cannot lock gc mutex"); + + /* No stack of thread structure to free yet: */ + p_stack = NULL; + pthread_cln = NULL; + + /* Point to the first dead thread (if there are any): */ + pthread = _thread_dead; + + /* There is no previous dead thread: */ + pthread_prv = NULL; + + /* + * Enter a loop to search for the first dead thread that + * has memory to free. + */ + while (p_stack == NULL && pthread_cln == NULL && + pthread != NULL) { + /* Save a pointer to the next thread: */ + pthread_nxt = pthread->nxt_dead; + + /* Check if the initial thread: */ + if (pthread == _thread_initial) + /* Don't destroy the initial thread. */ + pthread_prv = pthread; + + /* + * Check if this thread has detached: + */ + else if ((pthread->attr.flags & + PTHREAD_DETACHED) != 0) { + /* + * Check if there is no previous dead + * thread: + */ + if (pthread_prv == NULL) + /* + * The dead thread is at the head + * of the list: + */ + _thread_dead = pthread_nxt; + else + /* + * The dead thread is not at the + * head of the list: + */ + pthread_prv->nxt_dead = + pthread->nxt_dead; + + /* + * Check if the stack was not specified by + * the caller to pthread_create and has not + * been destroyed yet: + */ + if (pthread->attr.stackaddr_attr == NULL && + pthread->stack != NULL) { + /* + * Point to the stack that must + * be freed outside the locks: + */ + p_stack = pthread->stack; + } + + /* + * Point to the thread structure that must + * be freed outside the locks: + */ + pthread_cln = pthread; + } else { + /* + * This thread has not detached, so do + * not destroy it: + */ + pthread_prv = pthread; + + /* + * Check if the stack was not specified by + * the caller to pthread_create and has not + * been destroyed yet: + */ + if (pthread->attr.stackaddr_attr == NULL && + pthread->stack != NULL) { + /* + * Point to the stack that must + * be freed outside the locks: + */ + p_stack = pthread->stack; + + /* + * NULL the stack pointer now + * that the memory has been freed: + */ + pthread->stack = NULL; + } + } + + /* Point to the next thread: */ + pthread = pthread_nxt; + } + + /* + * Check if this is not the last thread and there is no + * memory to free this time around. + */ + if (!f_done && p_stack == NULL && pthread_cln == NULL) { + /* Get the current time. */ + if (clock_gettime(CLOCK_REALTIME,&abstime) != 0) + PANIC("gc cannot get time"); + + /* + * Do a backup poll in 10 seconds if no threads + * die before then. + */ + abstime.tv_sec += 10; + + /* + * Wait for a signal from a dying thread or a + * timeout (for a backup poll). + */ + if ((ret = pthread_cond_timedwait(&_gc_cond, + &_gc_mutex, &abstime)) != 0 && ret != ETIMEDOUT) + PANIC("gc cannot wait for a signal"); + } + + /* Unlock the garbage collector mutex: */ + if (pthread_mutex_unlock(&_gc_mutex) != 0) + PANIC("Cannot unlock gc mutex"); + + /* + * If there is memory to free, do it now. The call to + * free() might block, so this must be done outside the + * locks. + */ + if (p_stack != NULL) + free(p_stack); + if (pthread_cln != NULL) { + /* Lock the thread list: */ + _lock_thread_list(); + + /* + * Check if the thread is at the head of the + * linked list. + */ + if (_thread_link_list == pthread_cln) + /* There is no previous thread: */ + _thread_link_list = pthread_cln->nxt; + else { + /* Point to the first thread in the list: */ + pthread = _thread_link_list; + + /* + * Enter a loop to find the thread in the + * linked list before the thread that is + * about to be freed. + */ + while (pthread != NULL && + pthread->nxt != pthread_cln) + /* Point to the next thread: */ + pthread = pthread->nxt; + + /* Check that a previous thread was found: */ + if (pthread != NULL) { + /* + * Point the previous thread to + * the one after the thread being + * freed: + */ + pthread->nxt = pthread_cln->nxt; + } + } + + /* Unlock the thread list: */ + _unlock_thread_list(); + + /* + * Free the memory allocated for the thread + * structure. + */ + free(pthread_cln); + } + + } + return (NULL); +} +#endif /* _THREAD_SAFE */ diff --git a/lib/libpthread/uthread/uthread_info.c b/lib/libpthread/uthread/uthread_info.c index bd829e8be55..9db574e7521 100644 --- a/lib/libpthread/uthread/uthread_info.c +++ b/lib/libpthread/uthread/uthread_info.c @@ -57,6 +57,7 @@ static const struct s_thread_info thread_info[] = { {PS_SELECT_WAIT , "Waiting on select"}, {PS_SLEEP_WAIT , "Sleeping"}, {PS_WAIT_WAIT , "Waiting process"}, + {PS_SIGSUSPEND , "Suspended, waiting for a signal"}, {PS_SIGWAIT , "Waiting for a signal"}, {PS_JOIN , "Waiting to join"}, {PS_SUSPENDED , "Suspended"}, @@ -67,7 +68,7 @@ static const struct s_thread_info thread_info[] = { void _thread_dump_info(void) { - char s[128]; + char s[512]; int fd; int i; int j; @@ -85,14 +86,20 @@ _thread_dump_info(void) _thread_sys_write(fd, s, strlen(s)); /* Enter a loop to report each thread in the global list: */ - for (pthread = _thread_link_list; pthread != NULL; pthread = pthread->nxt) { + for (pthread = _thread_link_list; pthread != NULL; + pthread = pthread->nxt) { /* Find the state: */ - for (j = 0; j < (sizeof(thread_info) / sizeof(struct s_thread_info)) - 1; j++) + for (j = 0; j < (sizeof(thread_info) / + sizeof(struct s_thread_info)) - 1; j++) if (thread_info[j].state == pthread->state) break; /* Output a record for the current thread: */ - sprintf(s, "--------------------\nThread %p (%s) prio %3d state %s [%s:%d]\n", - pthread, (pthread->name == NULL) ? "":pthread->name, pthread->pthread_priority, thread_info[j].name,pthread->fname,pthread->lineno); + snprintf(s, sizeof(s), + "--------------------\nThread %p (%s) prio %3d state %s [%s:%d]\n", + pthread, (pthread->name == NULL) ? + "":pthread->name, pthread->pthread_priority, + thread_info[j].name, + pthread->fname,pthread->lineno); _thread_sys_write(fd, s, strlen(s)); /* Check if this is the running thread: */ @@ -115,13 +122,19 @@ _thread_dump_info(void) case PS_FDR_WAIT: case PS_FDW_WAIT: /* Write the lock details: */ - sprintf(s, "fd %d[%s:%d]", pthread->data.fd.fd, pthread->data.fd.fname, pthread->data.fd.branch); + snprintf(s, sizeof(s), "fd %d[%s:%d]", + pthread->data.fd.fd, + pthread->data.fd.fname, + pthread->data.fd.branch); _thread_sys_write(fd, s, strlen(s)); - sprintf(s, "owner %pr/%pw\n", _thread_fd_table[pthread->data.fd.fd]->r_owner, _thread_fd_table[pthread->data.fd.fd]->w_owner); + snprintf(s, sizeof(s), "owner %pr/%pw\n", + _thread_fd_table[pthread->data.fd.fd]->r_owner, + _thread_fd_table[pthread->data.fd.fd]->w_owner); _thread_sys_write(fd, s, strlen(s)); break; case PS_SIGWAIT: - sprintf(s, "sigmask 0x%08lx\n", (unsigned long)pthread->sigmask); + snprintf(s, sizeof(s), "sigmask 0x%08lx\n", + (unsigned long)pthread->sigmask); _thread_sys_write(fd, s, strlen(s)); break; @@ -149,9 +162,13 @@ _thread_dump_info(void) * Enter a loop to report each thread in the global * dead thread list: */ - for (pthread = _thread_dead; pthread != NULL; pthread = pthread->nxt) { + for (pthread = _thread_dead; pthread != NULL; + pthread = pthread->nxt_dead) { /* Output a record for the current thread: */ - sprintf(s, "Thread %p prio %3d [%s:%d]\n", pthread, pthread->pthread_priority,pthread->fname,pthread->lineno); + snprintf(s, sizeof(s), + "Thread %p prio %3d [%s:%d]\n", + pthread, pthread->pthread_priority, + pthread->fname,pthread->lineno); _thread_sys_write(fd, s, strlen(s)); } } @@ -168,7 +185,8 @@ _thread_dump_info(void) */ if (_thread_fd_table[i] != NULL) { /* Report the file descriptor lock status: */ - sprintf(s, "fd[%3d] read owner %p count %d [%s:%d]\n write owner %p count %d [%s:%d]\n", + snprintf(s, sizeof(s), + "fd[%3d] read owner %p count %d [%s:%d]\n write owner %p count %d [%s:%d]\n", i, _thread_fd_table[i]->r_owner, _thread_fd_table[i]->r_lockcount, diff --git a/lib/libpthread/uthread/uthread_init.c b/lib/libpthread/uthread/uthread_init.c index 40922f5b64b..95bc34e2797 100644 --- a/lib/libpthread/uthread/uthread_init.c +++ b/lib/libpthread/uthread/uthread_init.c @@ -35,10 +35,12 @@ #include <stdlib.h> #include <string.h> #include <fcntl.h> +#include <paths.h> #include <unistd.h> #include <sys/time.h> -#include <paths.h> +#include <sys/ttycom.h> #include <sys/param.h> +#include <sys/ioctl.h> #include <signal.h> #ifdef _THREAD_SAFE #include <machine/reg.h> @@ -78,6 +80,8 @@ struct pthread_cond_attr pthread_condattr_default = { int _pthread_stdio_flags[3]; struct fd_table_entry ** _thread_fd_table = NULL; int _thread_dtablesize = NOFILE_MAX; +pthread_mutex_t _gc_mutex = NULL; +pthread_cond_t _gc_cond = NULL; struct sigaction _thread_sigact[NSIG]; #ifdef GCC_2_8_MADE_THREAD_AWARE @@ -112,6 +116,7 @@ static void ***dynamic_allocator_handler_fn() void _thread_init(void) { + int fd; int flags; int i; struct sigaction act; @@ -121,13 +126,11 @@ _thread_init(void) /* Only initialise the threaded application once. */ return; -#ifdef __FreeBSD__ /* * Check for the special case of this process running as * or in place of init as pid = 1: */ if (getpid() == 1) { - int fd; /* * Setup a new session for this process which is * assumed to be running as root. @@ -147,7 +150,6 @@ _thread_init(void) _thread_sys_dup2(fd,2) == -1) PANIC("Can't dup2"); } -#endif __FreeBSD__ /* Get the standard I/O flags before messing with them : */ for (i = 0; i < 3; i++) @@ -287,22 +289,29 @@ _thread_init(void) __set_dynamic_handler_allocator( dynamic_allocator_handler_fn ); #endif /* GCC_2_8_MADE_THREAD_AWARE */ + /* Initialise the garbage collector mutex and condition variable. */ + if (pthread_mutex_init(&_gc_mutex,NULL) != 0 || + pthread_cond_init(&_gc_cond,NULL) != 0) + PANIC("Failed to initialise garbage collector mutex or condvar"); + return; } -#if 0 /* - * Special start up code for NetBSD/Alpha + * Use the a.out .init symbol to start the thread package going */ -int -main(int argc, char *argv[], char *env); +extern void __init_threads __P((void)) asm(".init"); +void __init_threads() { + _thread_init(); +} -int -_thread_main(int argc, char *argv[], char *env) -{ +/* + * Use elf's ld.so _init symbol to start the thread package going + */ +extern int _init __P((void)); +int _init() { _thread_init(); - return (main(argc, argv, env)); + return 0; } -#endif alpha_special_code #endif _THREAD_SAFE diff --git a/lib/libpthread/uthread/uthread_kern.c b/lib/libpthread/uthread/uthread_kern.c index 9a0f7828f7e..f2c54f69a51 100644 --- a/lib/libpthread/uthread/uthread_kern.c +++ b/lib/libpthread/uthread/uthread_kern.c @@ -29,8 +29,8 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: uthread_kern.c,v 1.1 1998/08/27 09:01:08 d Exp $ - * $OpenBSD: uthread_kern.c,v 1.1 1998/08/27 09:01:08 d Exp $ + * $Id: uthread_kern.c,v 1.2 1998/11/09 03:13:20 d Exp $ + * $OpenBSD: uthread_kern.c,v 1.2 1998/11/09 03:13:20 d Exp $ * */ #include <errno.h> @@ -60,8 +60,6 @@ _thread_kern_sched(struct sigcontext * scp) int prio = -1; pthread_t pthread; pthread_t pthread_h = NULL; - pthread_t pthread_nxt = NULL; - pthread_t pthread_prv = NULL; pthread_t pthread_s = NULL; struct itimerval itimer; struct timespec ts; @@ -91,7 +89,7 @@ _thread_kern_sched(struct sigcontext * scp) _thread_run->sig_saved = 1; } /* Save the state of the current thread: */ - else if (setjmp(_thread_run->saved_jmp_buf) != 0) { + else if (_thread_machdep_setjmp(_thread_run->saved_jmp_buf) != 0) { /* * This point is reached when a longjmp() is called to * restore the state of a thread. @@ -106,89 +104,13 @@ _thread_kern_sched(struct sigcontext * scp) */ _dispatch_signals(); return; - } else { + } else /* Flag the jump buffer was the last state saved: */ _thread_run->sig_saved = 0; - } /* Save errno. */ _thread_run->error = errno; - /* Point to the first dead thread (if there are any): */ - pthread = _thread_dead; - - /* There is no previous dead thread: */ - pthread_prv = NULL; - - /* Enter a loop to cleanup after dead threads: */ - while (pthread != NULL) { - /* Save a pointer to the next thread: */ - pthread_nxt = pthread->nxt; - - /* Check if this thread is one which is running: */ - if (pthread == _thread_run || pthread == _thread_initial) { - /* - * Don't destroy the running thread or the initial - * thread. - */ - pthread_prv = pthread; - } - /* - * Check if this thread has detached: - */ - else if ((pthread->attr.flags & PTHREAD_DETACHED) != 0) { - /* Check if there is no previous dead thread: */ - if (pthread_prv == NULL) { - /* - * The dead thread is at the head of the - * list: - */ - _thread_dead = pthread_nxt; - } else { - /* - * The dead thread is not at the head of the - * list: - */ - pthread_prv->nxt = pthread->nxt; - } - - /* - * Check if the stack was not specified by the caller - * to pthread_create and has not been destroyed yet: - */ - if (pthread->attr.stackaddr_attr == NULL && pthread->stack != NULL) { - /* Free the stack of the dead thread: */ - free(pthread->stack); - } - /* Free the memory allocated to the thread structure: */ - free(pthread); - } else { - /* - * This thread has not detached, so do not destroy - * it: - */ - pthread_prv = pthread; - - /* - * Check if the stack was not specified by the caller - * to pthread_create and has not been destroyed yet: - */ - if (pthread->attr.stackaddr_attr == NULL && pthread->stack != NULL) { - /* Free the stack of the dead thread: */ - free(pthread->stack); - - /* - * NULL the stack pointer now that the memory - * has been freed: - */ - pthread->stack = NULL; - } - } - - /* Point to the next thread: */ - pthread = pthread_nxt; - } - /* * Enter a the scheduling loop that finds the next thread that is * ready to run. This loop completes when there are no more threads @@ -280,10 +202,12 @@ _thread_kern_sched(struct sigcontext * scp) * Accumulate the number of microseconds that this * thread has run for: */ - _thread_run->slice_usec += (_thread_run->last_inactive.tv_sec - - _thread_run->last_active.tv_sec) * 1000000 + - _thread_run->last_inactive.tv_usec - - _thread_run->last_active.tv_usec; + if (_thread_run->slice_usec != -1) { + _thread_run->slice_usec += (_thread_run->last_inactive.tv_sec - + _thread_run->last_active.tv_sec) * 1000000 + + _thread_run->last_inactive.tv_usec - + _thread_run->last_active.tv_usec; + } /* * Check if this thread has reached its allocated @@ -316,7 +240,7 @@ _thread_kern_sched(struct sigcontext * scp) * the last incremental priority check was * made: */ - else if (timercmp(&_thread_run->last_inactive, &kern_inc_prio_time, <)) { + else if (timercmp(&pthread->last_inactive, &kern_inc_prio_time, <)) { /* * Increment the incremental priority * for this thread in the hope that @@ -657,7 +581,7 @@ _thread_kern_sched(struct sigcontext * scp) * was context switched out (by a longjmp to * a different thread): */ - longjmp(_thread_run->saved_jmp_buf, 1); + _thread_machdep_longjmp(_thread_run->saved_jmp_buf, 1); /* This point should not be reached. */ PANIC("Thread has returned from sigreturn or longjmp"); @@ -669,7 +593,7 @@ _thread_kern_sched(struct sigcontext * scp) } void -_thread_kern_sched_state(enum pthread_state state, char *fname, int lineno) +_thread_kern_sched_state(enum pthread_state state, const char *fname, int lineno) { /* Change the state of the current thread: */ _thread_run->state = state; @@ -750,6 +674,7 @@ _thread_kern_select(int wait_reqd) case PS_STATE_MAX: case PS_WAIT_WAIT: case PS_SUSPENDED: + case PS_SIGSUSPEND: /* Nothing to do here. */ break; @@ -1080,6 +1005,7 @@ _thread_kern_select(int wait_reqd) case PS_SIGTHREAD: case PS_STATE_MAX: case PS_SUSPENDED: + case PS_SIGSUSPEND: /* Nothing to do here. */ break; diff --git a/lib/libpthread/uthread/uthread_kill.c b/lib/libpthread/uthread/uthread_kill.c index 98b3a2d39b9..292ba5caf8f 100644 --- a/lib/libpthread/uthread/uthread_kill.c +++ b/lib/libpthread/uthread/uthread_kill.c @@ -46,18 +46,48 @@ pthread_kill(pthread_t pthread, int sig) /* Invalid signal: */ ret = EINVAL; + /* Ignored signals get dropped on the floor. */ + else if (_thread_sigact[sig - 1].sa_handler == SIG_IGN) + ret = 0; + /* Find the thread in the list of active threads: */ else if ((ret = _find_thread(pthread)) == 0) { - if ((pthread->state == PS_SIGWAIT) && - sigismember(&pthread->sigmask, sig)) { - /* Change the state of the thread to run: */ - PTHREAD_NEW_STATE(pthread,PS_RUNNING); + switch (pthread->state) { + case PS_SIGSUSPEND: + /* + * Only wake up the thread if the signal is unblocked + * and there is a handler installed for the signal. + */ + if (!sigismember(&pthread->sigmask, sig) && + _thread_sigact[sig - 1].sa_handler != SIG_DFL) { + /* Change the state of the thread to run: */ + PTHREAD_NEW_STATE(pthread,PS_RUNNING); + + /* Return the signal number: */ + pthread->signo = sig; + } + /* Increment the pending signal count: */ + sigaddset(&pthread->sigpend,sig); + break; + + case PS_SIGWAIT: + /* Wake up the thread if the signal is blocked. */ + if (sigismember(pthread->data.sigwait, sig)) { + /* Change the state of the thread to run: */ + PTHREAD_NEW_STATE(pthread,PS_RUNNING); + + /* Return the signal number: */ + pthread->signo = sig; + } else + /* Increment the pending signal count. */ + sigaddset(&pthread->sigpend,sig); + break; - /* Return the signal number: */ - pthread->signo = sig; - } else + default: /* Increment the pending signal count: */ sigaddset(&pthread->sigpend,sig); + break; + } } /* Return the completion status: */ diff --git a/lib/libpthread/uthread/uthread_rwlock.c b/lib/libpthread/uthread/uthread_rwlock.c new file mode 100644 index 00000000000..bfdd0b61fc1 --- /dev/null +++ b/lib/libpthread/uthread/uthread_rwlock.c @@ -0,0 +1,336 @@ +/*- + * Copyright (c) 1998 Alex Nash + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR CONTRIBUTORS 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. + * + * $OpenBSD: uthread_rwlock.c,v 1.1 1998/11/09 03:13:20 d Exp $ + * $Id: uthread_rwlock.c,v 1.1 1998/11/09 03:13:20 d Exp $ + */ + +#ifdef _THREAD_SAFE +#include <errno.h> +#include <limits.h> +#include <stdlib.h> + +#include <pthread.h> +#include "pthread_private.h" + +/* maximum number of times a read lock may be obtained */ +#define MAX_READ_LOCKS (INT_MAX - 1) + +static int init_static (pthread_rwlock_t *rwlock); + +static spinlock_t static_init_lock = _SPINLOCK_INITIALIZER; + +static int +init_static (pthread_rwlock_t *rwlock) +{ + int ret; + + _SPINLOCK(&static_init_lock); + + if (*rwlock == NULL) + ret = pthread_rwlock_init(rwlock, NULL); + else + ret = 0; + + _SPINUNLOCK(&static_init_lock); + + return(ret); +} + +int +pthread_rwlock_destroy (pthread_rwlock_t *rwlock) +{ + int ret; + + if (rwlock == NULL) + ret = EINVAL; + else { + pthread_rwlock_t prwlock; + + prwlock = *rwlock; + + pthread_mutex_destroy(&prwlock->lock); + pthread_cond_destroy(&prwlock->read_signal); + pthread_cond_destroy(&prwlock->write_signal); + free(prwlock); + + *rwlock = NULL; + + ret = 0; + } + + return(ret); +} + +int +pthread_rwlock_init (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) +{ + pthread_rwlock_t prwlock; + int ret; + + /* allocate rwlock object */ + prwlock = (pthread_rwlock_t)malloc(sizeof(struct pthread_rwlock)); + + if (prwlock == NULL) + return(ENOMEM); + + /* initialize the lock */ + if ((ret = pthread_mutex_init(&prwlock->lock, NULL)) != 0) + free(prwlock); + else { + /* initialize the read condition signal */ + ret = pthread_cond_init(&prwlock->read_signal, NULL); + + if (ret != 0) { + pthread_mutex_destroy(&prwlock->lock); + free(prwlock); + } else { + /* initialize the write condition signal */ + ret = pthread_cond_init(&prwlock->write_signal, NULL); + + if (ret != 0) { + pthread_cond_destroy(&prwlock->read_signal); + pthread_mutex_destroy(&prwlock->lock); + free(prwlock); + } else { + /* success */ + prwlock->state = 0; + prwlock->blocked_writers = 0; + + *rwlock = prwlock; + } + } + } + + return(ret); +} + +int +pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) +{ + pthread_rwlock_t prwlock; + int ret; + + if (rwlock == NULL) + return(EINVAL); + + prwlock = *rwlock; + + /* check for static initialization */ + if (prwlock == NULL) { + if ((ret = init_static(rwlock)) != 0) + return(ret); + + prwlock = *rwlock; + } + + /* grab the monitor lock */ + if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + return(ret); + + /* give writers priority over readers */ + while (prwlock->blocked_writers || prwlock->state < 0) { + ret = pthread_cond_wait(&prwlock->read_signal, &prwlock->lock); + + if (ret != 0) { + /* can't do a whole lot if this fails */ + pthread_mutex_unlock(&prwlock->lock); + return(ret); + } + } + + /* check lock count */ + if (prwlock->state == MAX_READ_LOCKS) + ret = EAGAIN; + else + ++prwlock->state; /* indicate we are locked for reading */ + + /* + * Something is really wrong if this call fails. Returning + * error won't do because we've already obtained the read + * lock. Decrementing 'state' is no good because we probably + * don't have the monitor lock. + */ + pthread_mutex_unlock(&prwlock->lock); + + return(ret); +} + +int +pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) +{ + pthread_rwlock_t prwlock; + int ret; + + if (rwlock == NULL) + return(EINVAL); + + prwlock = *rwlock; + + /* check for static initialization */ + if (prwlock == NULL) { + if ((ret = init_static(rwlock)) != 0) + return(ret); + + prwlock = *rwlock; + } + + /* grab the monitor lock */ + if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + return(ret); + + /* give writers priority over readers */ + if (prwlock->blocked_writers || prwlock->state < 0) + ret = EWOULDBLOCK; + else if (prwlock->state == MAX_READ_LOCKS) + ret = EAGAIN; /* too many read locks acquired */ + else + ++prwlock->state; /* indicate we are locked for reading */ + + /* see the comment on this in pthread_rwlock_rdlock */ + pthread_mutex_unlock(&prwlock->lock); + + return(ret); +} + +int +pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) +{ + pthread_rwlock_t prwlock; + int ret; + + if (rwlock == NULL) + return(EINVAL); + + prwlock = *rwlock; + + /* check for static initialization */ + if (prwlock == NULL) { + if ((ret = init_static(rwlock)) != 0) + return(ret); + + prwlock = *rwlock; + } + + /* grab the monitor lock */ + if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + return(ret); + + if (prwlock->state != 0) + ret = EWOULDBLOCK; + else + /* indicate we are locked for writing */ + prwlock->state = -1; + + /* see the comment on this in pthread_rwlock_rdlock */ + pthread_mutex_unlock(&prwlock->lock); + + return(ret); +} + +int +pthread_rwlock_unlock (pthread_rwlock_t *rwlock) +{ + pthread_rwlock_t prwlock; + int ret; + + if (rwlock == NULL) + return(EINVAL); + + prwlock = *rwlock; + + if (prwlock == NULL) + return(EINVAL); + + /* grab the monitor lock */ + if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + return(ret); + + if (prwlock->state > 0) { + if (--prwlock->state == 0 && prwlock->blocked_writers) + ret = pthread_cond_signal(&prwlock->write_signal); + } else if (prwlock->state < 0) { + prwlock->state = 0; + + if (prwlock->blocked_writers) + ret = pthread_cond_signal(&prwlock->write_signal); + else + ret = pthread_cond_broadcast(&prwlock->read_signal); + } else + ret = EINVAL; + + /* see the comment on this in pthread_rwlock_rdlock */ + pthread_mutex_unlock(&prwlock->lock); + + return(ret); +} + +int +pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) +{ + pthread_rwlock_t prwlock; + int ret; + + if (rwlock == NULL) + return(EINVAL); + + prwlock = *rwlock; + + /* check for static initialization */ + if (prwlock == NULL) { + if ((ret = init_static(rwlock)) != 0) + return(ret); + + prwlock = *rwlock; + } + + /* grab the monitor lock */ + if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + return(ret); + + while (prwlock->state != 0) { + ++prwlock->blocked_writers; + + ret = pthread_cond_wait(&prwlock->write_signal, &prwlock->lock); + + if (ret != 0) { + --prwlock->blocked_writers; + pthread_mutex_unlock(&prwlock->lock); + return(ret); + } + + --prwlock->blocked_writers; + } + + /* indicate we are locked for writing */ + prwlock->state = -1; + + /* see the comment on this in pthread_rwlock_rdlock */ + pthread_mutex_unlock(&prwlock->lock); + + return(ret); +} + +#endif /* _THREAD_SAFE */ diff --git a/lib/libpthread/uthread/uthread_rwlockattr.c b/lib/libpthread/uthread/uthread_rwlockattr.c new file mode 100644 index 00000000000..3c16b77b8f5 --- /dev/null +++ b/lib/libpthread/uthread/uthread_rwlockattr.c @@ -0,0 +1,99 @@ +/*- + * Copyright (c) 1998 Alex Nash + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR CONTRIBUTORS 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. + * + * $Id: uthread_rwlockattr.c,v 1.1 1998/11/09 03:13:20 d Exp $ + * $OpenBSD: uthread_rwlockattr.c,v 1.1 1998/11/09 03:13:20 d Exp $ + */ + +#ifdef _THREAD_SAFE +#include <errno.h> +#include <stdlib.h> + +#include <pthread.h> +#include "pthread_private.h" + +int +pthread_rwlockattr_destroy (pthread_rwlockattr_t *rwlockattr) +{ + pthread_rwlockattr_t prwlockattr; + + if (rwlockattr == NULL) + return(EINVAL); + + prwlockattr = *rwlockattr; + + if (prwlockattr == NULL) + return(EINVAL); + + free(prwlockattr); + + return(0); +} + +int +pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *rwlockattr, + int *pshared) +{ + *pshared = (*rwlockattr)->pshared; + + return(0); +} + +int +pthread_rwlockattr_init (pthread_rwlockattr_t *rwlockattr) +{ + pthread_rwlockattr_t prwlockattr; + + if (rwlockattr == NULL) + return(EINVAL); + + prwlockattr = (pthread_rwlockattr_t) + malloc(sizeof(struct pthread_rwlockattr)); + + if (prwlockattr == NULL) + return(ENOMEM); + + prwlockattr->pshared = PTHREAD_PROCESS_PRIVATE; + *rwlockattr = prwlockattr; + + return(0); +} + +int +pthread_rwlockattr_setpshared (pthread_rwlockattr_t *rwlockattr, + int *pshared) +{ + int ps = *pshared; + + /* only PTHREAD_PROCESS_PRIVATE is supported */ + if (ps != PTHREAD_PROCESS_PRIVATE) + return(EINVAL); + + (*rwlockattr)->pshared = ps; + + return(0); +} + +#endif /* _THREAD_SAFE */ diff --git a/lib/libpthread/uthread/uthread_sig.c b/lib/libpthread/uthread/uthread_sig.c index 7f13cd6dde1..3e55d6505a3 100644 --- a/lib/libpthread/uthread/uthread_sig.c +++ b/lib/libpthread/uthread/uthread_sig.c @@ -39,9 +39,7 @@ #include "pthread_private.h" /* Static variables: */ -static int volatile yield_on_unlock_dead = 0; static int volatile yield_on_unlock_thread = 0; -static spinlock_t thread_dead_lock = _SPINLOCK_INITIALIZER; static spinlock_t thread_link_list_lock = _SPINLOCK_INITIALIZER; /* Lock the thread list: */ @@ -52,14 +50,6 @@ _lock_thread_list() _SPINLOCK(&thread_link_list_lock); } -/* Lock the dead thread list: */ -void -_lock_dead_thread_list() -{ - /* Lock the dead thread list: */ - _SPINLOCK(&thread_dead_lock); -} - /* Lock the thread list: */ void _unlock_thread_list() @@ -80,26 +70,6 @@ _unlock_thread_list() } } -/* Lock the dead thread list: */ -void -_unlock_dead_thread_list() -{ - /* Unlock the dead thread list: */ - _SPINUNLOCK(&thread_dead_lock); - - /* - * Check if a scheduler interrupt occurred while the dead - * thread list was locked: - */ - if (yield_on_unlock_dead) { - /* Reset the interrupt flag: */ - yield_on_unlock_dead = 0; - - /* This thread has overstayed it's welcome: */ - sched_yield(); - } -} - void _thread_sig_handler(int sig, int code, struct sigcontext * scp) { @@ -144,18 +114,6 @@ _thread_sig_handler(int sig, int code, struct sigcontext * scp) */ yield_on_unlock_thread = 1; - /* Check if the scheduler interrupt has come at an - * unfortunate time which one of the threads is - * modifying the dead thread list: - */ - if (thread_dead_lock.access_lock) - /* - * Set a flag so that the thread that has - * the lock yields when it unlocks the - * dead thread list: - */ - yield_on_unlock_dead = 1; - /* * Check if the kernel has not been interrupted while * executing scheduler code: @@ -198,7 +156,7 @@ _thread_sig_handler(int sig, int code, struct sigcontext * scp) /* * POSIX says that pending SIGCONT signals are - * discarded when one of there signals occurs. + * discarded when one of these signals occurs. */ if (sig == SIGTSTP || sig == SIGTTIN || sig == SIGTTOU) { /* @@ -221,7 +179,7 @@ _thread_sig_handler(int sig, int code, struct sigcontext * scp) for (pthread = _thread_link_list; pthread != NULL; pthread = pthread->nxt) { if ((pthread->state == PS_SIGWAIT) && - sigismember(&pthread->sigmask, sig)) { + sigismember(pthread->data.sigwait, sig)) { /* Change the state of the thread to run: */ PTHREAD_NEW_STATE(pthread,PS_RUNNING); @@ -325,6 +283,21 @@ _thread_signal(pthread_t pthread, int sig) pthread->signo = sig; } break; + + case PS_SIGSUSPEND: + /* + * Only wake up the thread if the signal is unblocked + * and there is a handler installed for the signal. + */ + if (!sigismember(&pthread->sigmask, sig) && + _thread_sigact[sig - 1].sa_handler != SIG_DFL) { + /* Change the state of the thread to run: */ + PTHREAD_NEW_STATE(pthread,PS_RUNNING); + + /* Return the signal number: */ + pthread->signo = sig; + } + break; } } diff --git a/lib/libpthread/uthread/uthread_sigaction.c b/lib/libpthread/uthread/uthread_sigaction.c index 3538f276eba..40f3850008e 100644 --- a/lib/libpthread/uthread/uthread_sigaction.c +++ b/lib/libpthread/uthread/uthread_sigaction.c @@ -75,7 +75,7 @@ sigaction(int sig, const struct sigaction * act, struct sigaction * oact) sig != SIGINFO) { /* Initialise the global signal action structure: */ gact.sa_mask = act->sa_mask; - gact.sa_flags = act->sa_flags | SA_RESTART; + gact.sa_flags = 0; /* * Check if the signal handler is being set to diff --git a/lib/libpthread/uthread/uthread_sigaltstack.c b/lib/libpthread/uthread/uthread_sigaltstack.c new file mode 100644 index 00000000000..9a1f9614542 --- /dev/null +++ b/lib/libpthread/uthread/uthread_sigaltstack.c @@ -0,0 +1,21 @@ +/* + * $OpenBSD: uthread_sigaltstack.c,v 1.1 1998/11/09 03:13:20 d Exp $ + */ + +#include <signal.h> +#include <errno.h> +#ifdef _THREAD_SAFE +#include <pthread.h> +#include "pthread_private.h" + +/* + * placeholder for sigaltstack XXX impl to be done + */ + +int +sigaltstack(const struct sigaltstack *ss, struct sigaltstack *oss) +{ + errno = EINVAL; + return (-1); +} +#endif /* _THREAD_SAFE */ diff --git a/lib/libpthread/uthread/uthread_signal.c b/lib/libpthread/uthread/uthread_signal.c index cef725f7360..c9ece329762 100644 --- a/lib/libpthread/uthread/uthread_signal.c +++ b/lib/libpthread/uthread/uthread_signal.c @@ -44,7 +44,7 @@ _thread_sys_signal(int s, sig_t a) /* Initialise the signal action structure: */ sigemptyset(&sa.sa_mask); sa.sa_handler = a; - sa.sa_flags = SA_RESTART; + sa.sa_flags = 0; /* Perform the sigaction syscall: */ if (_thread_sys_sigaction(s, &sa, &osa) < 0) { diff --git a/lib/libpthread/uthread/uthread_sigsuspend.c b/lib/libpthread/uthread/uthread_sigsuspend.c index f7a7b123e34..0ae9a4f7b3e 100644 --- a/lib/libpthread/uthread/uthread_sigsuspend.c +++ b/lib/libpthread/uthread/uthread_sigsuspend.c @@ -44,14 +44,14 @@ sigsuspend(const sigset_t * set) /* Check if a new signal set was provided by the caller: */ if (set != NULL) { - /* Save the current sigmal mask: */ + /* Save the current signal mask: */ oset = _thread_run->sigmask; - /* Combine the caller's mask with the current one: */ - _thread_run->sigmask |= *set; + /* Change the caller's mask: */ + _thread_run->sigmask = *set; /* Wait for a signal: */ - _thread_kern_sched_state(PS_SIGWAIT, __FILE__, __LINE__); + _thread_kern_sched_state(PS_SIGSUSPEND, __FILE__, __LINE__); /* Always return an interrupted error: */ errno = EINTR; diff --git a/lib/libpthread/uthread/uthread_sigwait.c b/lib/libpthread/uthread/uthread_sigwait.c index f441fa3b731..e8d6d4ae0ca 100644 --- a/lib/libpthread/uthread/uthread_sigwait.c +++ b/lib/libpthread/uthread/uthread_sigwait.c @@ -41,7 +41,7 @@ sigwait(const sigset_t * set, int *sig) { int ret = 0; int i; - sigset_t oset; + sigset_t tempset; struct sigaction act; /* @@ -60,31 +60,48 @@ sigwait(const sigset_t * set, int *sig) sigdelset(&act.sa_mask, SIGCHLD); sigdelset(&act.sa_mask, SIGINFO); + /* Check to see if a pending signal is in the wait mask. */ + if ((tempset = (_thread_run->sigpend & act.sa_mask))) { + /* Enter a loop to find a pending signal: */ + for (i = 1; i < NSIG; i++) { + if (sigismember (&tempset, i)) + break; + } + + /* Clear the pending signal: */ + sigdelset(&_thread_run->sigpend,i); + + /* Return the signal number to the caller: */ + *sig = i; + + return (0); + } + /* * Enter a loop to find the signals that are SIG_DFL. For * these signals we must install a dummy signal handler in * order for the kernel to pass them in to us. POSIX says * that the application must explicitly install a dummy * handler for signals that are SIG_IGN in order to sigwait - * on them, so we ignore SIG_IGN signals. + * on them. Note that SIG_IGN signals are left in the + * mask because a subsequent sigaction could enable an + * ignored signal. */ for (i = 1; i < NSIG; i++) { if (sigismember(&act.sa_mask, i)) { - if (_thread_sigact[i - 1].sa_handler == SIG_DFL) { + if (_thread_sigact[i - 1].sa_handler == SIG_DFL) if (_thread_sys_sigaction(i,&act,NULL) != 0) ret = -1; - } - else if (_thread_sigact[i - 1].sa_handler == SIG_IGN) - sigdelset(&act.sa_mask, i); } } if (ret == 0) { - /* Save the current signal mask: */ - oset = _thread_run->sigmask; - - /* Combine the caller's mask with the current one: */ - _thread_run->sigmask |= act.sa_mask; + /* + * Save the wait signal mask. The wait signal + * mask is independent of the threads signal mask + * and requires separate storage. + */ + _thread_run->data.sigwait = &act.sa_mask; /* Wait for a signal: */ _thread_kern_sched_state(PS_SIGWAIT, __FILE__, __LINE__); @@ -92,8 +109,11 @@ sigwait(const sigset_t * set, int *sig) /* Return the signal number to the caller: */ *sig = _thread_run->signo; - /* Restore the signal mask: */ - _thread_run->sigmask = oset; + /* + * Probably unnecessary, but since it's in a union struct + * we don't know how it could be used in the future. + */ + _thread_run->data.sigwait = NULL; } /* Restore the sigactions: */ diff --git a/lib/libpthread/uthread/uthread_spec.c b/lib/libpthread/uthread/uthread_spec.c index 081a000788d..1fe789e6201 100644 --- a/lib/libpthread/uthread/uthread_spec.c +++ b/lib/libpthread/uthread/uthread_spec.c @@ -119,10 +119,12 @@ _thread_cleanupspecific(void) destructor(data); } else { free(_thread_run->specific_data); + _thread_run->specific_data = NULL; return; } } } + _thread_run->specific_data = NULL; free(_thread_run->specific_data); } diff --git a/lib/libpthread/uthread/uthread_spinlock.c b/lib/libpthread/uthread/uthread_spinlock.c index 1863bdfef9a..559f2d4c4b4 100644 --- a/lib/libpthread/uthread/uthread_spinlock.c +++ b/lib/libpthread/uthread/uthread_spinlock.c @@ -29,16 +29,16 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: uthread_spinlock.c,v 1.1 1998/08/27 09:01:25 d Exp $ - * $OpenBSD: uthread_spinlock.c,v 1.1 1998/08/27 09:01:25 d Exp $ + * $Id: uthread_spinlock.c,v 1.2 1998/11/09 03:13:21 d Exp $ + * $OpenBSD: uthread_spinlock.c,v 1.2 1998/11/09 03:13:21 d Exp $ * */ #include <stdio.h> #include <sched.h> #include <unistd.h> -#include <string.h> #include <pthread.h> +#include <string.h> #include "pthread_private.h" extern char *__progname; @@ -80,7 +80,7 @@ _spinlock(spinlock_t *lck) * returning. */ void -_spinlock_debug(spinlock_t *lck, char *fname, int lineno) +_spinlock_debug(spinlock_t *lck, const char *fname, int lineno) { /* * Try to grab the lock and loop if another thread grabs diff --git a/lib/libpthread/uthread/uthread_vfork.c b/lib/libpthread/uthread/uthread_vfork.c new file mode 100644 index 00000000000..a3b0ee5bb06 --- /dev/null +++ b/lib/libpthread/uthread/uthread_vfork.c @@ -0,0 +1,12 @@ +/* + * $OpenBSD: uthread_vfork.c,v 1.1 1998/11/09 03:13:21 d Exp $ + */ +#include <unistd.h> +#ifdef _THREAD_SAFE + +int +vfork(void) +{ + return (fork()); +} +#endif /* _THREAD_SAFE */ |