Index: head/lib/libc_r/uthread/uthread_create.c =================================================================== --- head/lib/libc_r/uthread/uthread_create.c (revision 123116) +++ head/lib/libc_r/uthread/uthread_create.c (revision 123117) @@ -1,279 +1,284 @@ /* * Copyright (c) 1995-1998 John Birrell * 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 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. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include "namespace.h" #include #include "un-namespace.h" #include "pthread_private.h" #include "libc_private.h" static u_int64_t next_uniqueid = 1; #define OFF(f) offsetof(struct pthread, f) int _thread_next_offset = OFF(tle.tqe_next); int _thread_uniqueid_offset = OFF(uniqueid); int _thread_state_offset = OFF(state); int _thread_name_offset = OFF(name); int _thread_ctx_offset = OFF(ctx); #undef OFF int _thread_PS_RUNNING_value = PS_RUNNING; int _thread_PS_DEAD_value = PS_DEAD; __weak_reference(_pthread_create, pthread_create); int _pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg) { struct pthread *curthread = _get_curthread(); struct itimerval itimer; int f_gc = 0; int ret = 0; pthread_t gc_thread; pthread_t new_thread; pthread_attr_t pattr; void *stack; +#if !defined(__ia64__) + u_long stackp; +#endif if (thread == NULL) return(EINVAL); /* * Locking functions in libc are required when there are * threads other than the initial thread. */ __isthreaded = 1; /* Allocate memory for the thread structure: */ if ((new_thread = (pthread_t) malloc(sizeof(struct pthread))) == NULL) { /* Insufficient memory to create a thread: */ ret = EAGAIN; } else { /* Check if default thread attributes are required: */ if (attr == NULL || *attr == NULL) { /* Use the default thread attributes: */ pattr = &_pthread_attr_default; } else { pattr = *attr; } /* Check if a stack was specified in the thread attributes: */ if ((stack = pattr->stackaddr_attr) != NULL) { } /* Allocate a stack: */ else { stack = _thread_stack_alloc(pattr->stacksize_attr, pattr->guardsize_attr); if (stack == NULL) { ret = EAGAIN; free(new_thread); } } /* Check for errors: */ if (ret != 0) { } else { /* Initialise the thread structure: */ memset(new_thread, 0, sizeof(struct pthread)); new_thread->slice_usec = -1; new_thread->stack = stack; new_thread->start_routine = start_routine; new_thread->arg = arg; new_thread->cancelflags = PTHREAD_CANCEL_ENABLE | PTHREAD_CANCEL_DEFERRED; /* * Write a magic value to the thread structure * to help identify valid ones: */ new_thread->magic = PTHREAD_MAGIC; /* Initialise the thread for signals: */ new_thread->sigmask = curthread->sigmask; new_thread->sigmask_seqno = 0; /* Initialize the signal frame: */ new_thread->curframe = NULL; /* Initialise the jump buffer: */ _setjmp(new_thread->ctx.jb); /* * Set up new stack frame so that it looks like it * returned from a longjmp() to the beginning of * _thread_start(). */ SET_RETURN_ADDR_JB(new_thread->ctx.jb, _thread_start); #if !defined(__ia64__) + stackp = (long)new_thread->stack + pattr->stacksize_attr - sizeof(double); +#if defined(__amd64__) + stackp &= ~0xFUL; +#endif /* The stack starts high and builds down: */ - SET_STACK_JB(new_thread->ctx.jb, - (long)new_thread->stack + pattr->stacksize_attr - - sizeof(double)); + SET_STACK_JB(new_thread->ctx.jb, stackp); #else SET_STACK_JB(new_thread->ctx.jb, (long)new_thread->stack, pattr->stacksize_attr); #endif /* Copy the thread attributes: */ memcpy(&new_thread->attr, pattr, sizeof(struct pthread_attr)); /* * Check if this thread is to inherit the scheduling * attributes from its parent: */ if (new_thread->attr.flags & PTHREAD_INHERIT_SCHED) { /* Copy the scheduling attributes: */ new_thread->base_priority = curthread->base_priority & ~PTHREAD_SIGNAL_PRIORITY; new_thread->attr.prio = curthread->base_priority & ~PTHREAD_SIGNAL_PRIORITY; new_thread->attr.sched_policy = curthread->attr.sched_policy; } else { /* * Use just the thread priority, leaving the * other scheduling attributes as their * default values: */ new_thread->base_priority = new_thread->attr.prio; } new_thread->active_priority = new_thread->base_priority; new_thread->inherited_priority = 0; /* Initialize joiner to NULL (no joiner): */ new_thread->joiner = NULL; /* Initialize the mutex queue: */ TAILQ_INIT(&new_thread->mutexq); /* Initialise hooks in the thread structure: */ new_thread->specific = NULL; new_thread->cleanup = NULL; new_thread->flags = 0; new_thread->poll_data.nfds = 0; new_thread->poll_data.fds = NULL; new_thread->continuation = NULL; /* * Defer signals to protect the scheduling queues * from access by the signal handler: */ _thread_kern_sig_defer(); /* * Initialise the unique id which GDB uses to * track threads. */ new_thread->uniqueid = next_uniqueid++; /* * Check if the garbage collector thread * needs to be started. */ f_gc = (TAILQ_FIRST(&_thread_list) == _thread_initial); /* Add the thread to the linked list of all threads: */ TAILQ_INSERT_HEAD(&_thread_list, new_thread, tle); if (pattr->suspend == PTHREAD_CREATE_SUSPENDED) { new_thread->flags |= PTHREAD_FLAGS_SUSPENDED; new_thread->state = PS_SUSPENDED; } else { new_thread->state = PS_RUNNING; PTHREAD_PRIOQ_INSERT_TAIL(new_thread); } /* * Undefer and handle pending signals, yielding * if necessary. */ _thread_kern_sig_undefer(); /* Return a pointer to the thread structure: */ (*thread) = new_thread; if (f_gc != 0) { /* Install the scheduling timer: */ itimer.it_interval.tv_sec = 0; itimer.it_interval.tv_usec = _clock_res_usec; itimer.it_value = itimer.it_interval; if (setitimer(_ITIMER_SCHED_TIMER, &itimer, NULL) != 0) PANIC("Cannot set interval timer"); } /* 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"); } } /* Return the status: */ return (ret); } void _thread_start(void) { struct pthread *curthread = _get_curthread(); /* We just left the scheduler via longjmp: */ _thread_kern_in_sched = 0; /* Run the current thread's start routine with argument: */ _pthread_exit(curthread->start_routine(curthread->arg)); /* This point should never be reached. */ PANIC("Thread has resumed after exit"); } Index: head/lib/libc_r/uthread/uthread_init.c =================================================================== --- head/lib/libc_r/uthread/uthread_init.c (revision 123116) +++ head/lib/libc_r/uthread/uthread_init.c (revision 123117) @@ -1,561 +1,567 @@ /* * Copyright (c) 1995-1998 John Birrell * 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 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. * * $FreeBSD$ */ /* Allocate space for global thread variables here: */ #define GLOBAL_PTHREAD_PRIVATE #include "namespace.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "un-namespace.h" #include "libc_private.h" #include "pthread_private.h" int __pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *); int __pthread_mutex_lock(pthread_mutex_t *); int __pthread_mutex_trylock(pthread_mutex_t *); /* * All weak references used within libc should be in this table. * This allows static libraries to work. */ static void *references[] = { &_accept, &_bind, &_close, &_connect, &_dup, &_dup2, &_execve, &_fcntl, &_flock, &_flockfile, &_fstat, &_fstatfs, &_fsync, &_funlockfile, &_getdirentries, &_getlogin, &_getpeername, &_getsockname, &_getsockopt, &_ioctl, &_kevent, &_listen, &_nanosleep, &_open, &_pthread_cond_destroy, &_pthread_cond_init, &_pthread_cond_signal, &_pthread_cond_wait, &_pthread_getspecific, &_pthread_key_create, &_pthread_key_delete, &_pthread_mutex_destroy, &_pthread_mutex_init, &_pthread_mutex_lock, &_pthread_mutex_trylock, &_pthread_mutex_unlock, &_pthread_mutexattr_init, &_pthread_mutexattr_destroy, &_pthread_mutexattr_settype, &_pthread_once, &_pthread_setspecific, &_read, &_readv, &_recvfrom, &_recvmsg, &_select, &_sendmsg, &_sendto, &_setsockopt, &_sigaction, &_sigprocmask, &_sigsuspend, &_socket, &_socketpair, &_wait4, &_write, &_writev }; /* * These are needed when linking statically. All references within * libgcc (and libc) to these routines are weak, but if they are not * (strongly) referenced by the application or other libraries, then * the actual functions will not be loaded. */ static void *libgcc_references[] = { &_pthread_once, &_pthread_key_create, &_pthread_key_delete, &_pthread_getspecific, &_pthread_setspecific, &_pthread_mutex_init, &_pthread_mutex_destroy, &_pthread_mutex_lock, &_pthread_mutex_trylock, &_pthread_mutex_unlock }; #define DUAL_ENTRY(entry) \ (pthread_func_t)entry, (pthread_func_t)entry static pthread_func_t jmp_table[][2] = { {DUAL_ENTRY(_pthread_cond_broadcast)}, /* PJT_COND_BROADCAST */ {DUAL_ENTRY(_pthread_cond_destroy)}, /* PJT_COND_DESTROY */ {DUAL_ENTRY(_pthread_cond_init)}, /* PJT_COND_INIT */ {DUAL_ENTRY(_pthread_cond_signal)}, /* PJT_COND_SIGNAL */ {(pthread_func_t)__pthread_cond_wait, (pthread_func_t)_pthread_cond_wait}, /* PJT_COND_WAIT */ {DUAL_ENTRY(_pthread_getspecific)}, /* PJT_GETSPECIFIC */ {DUAL_ENTRY(_pthread_key_create)}, /* PJT_KEY_CREATE */ {DUAL_ENTRY(_pthread_key_delete)}, /* PJT_KEY_DELETE*/ {DUAL_ENTRY(_pthread_main_np)}, /* PJT_MAIN_NP */ {DUAL_ENTRY(_pthread_mutex_destroy)}, /* PJT_MUTEX_DESTROY */ {DUAL_ENTRY(_pthread_mutex_init)}, /* PJT_MUTEX_INIT */ {(pthread_func_t)__pthread_mutex_lock, (pthread_func_t)_pthread_mutex_lock}, /* PJT_MUTEX_LOCK */ {(pthread_func_t)__pthread_mutex_trylock, (pthread_func_t)_pthread_mutex_trylock},/* PJT_MUTEX_TRYLOCK */ {DUAL_ENTRY(_pthread_mutex_unlock)}, /* PJT_MUTEX_UNLOCK */ {DUAL_ENTRY(_pthread_mutexattr_destroy)}, /* PJT_MUTEXATTR_DESTROY */ {DUAL_ENTRY(_pthread_mutexattr_init)}, /* PJT_MUTEXATTR_INIT */ {DUAL_ENTRY(_pthread_mutexattr_settype)}, /* PJT_MUTEXATTR_SETTYPE */ {DUAL_ENTRY(_pthread_once)}, /* PJT_ONCE */ {DUAL_ENTRY(_pthread_rwlock_destroy)}, /* PJT_RWLOCK_DESTROY */ {DUAL_ENTRY(_pthread_rwlock_init)}, /* PJT_RWLOCK_INIT */ {DUAL_ENTRY(_pthread_rwlock_rdlock)}, /* PJT_RWLOCK_RDLOCK */ {DUAL_ENTRY(_pthread_rwlock_tryrdlock)},/* PJT_RWLOCK_TRYRDLOCK */ {DUAL_ENTRY(_pthread_rwlock_trywrlock)},/* PJT_RWLOCK_TRYWRLOCK */ {DUAL_ENTRY(_pthread_rwlock_unlock)}, /* PJT_RWLOCK_UNLOCK */ {DUAL_ENTRY(_pthread_rwlock_wrlock)}, /* PJT_RWLOCK_WRLOCK */ {DUAL_ENTRY(_pthread_self)}, /* PJT_SELF */ {DUAL_ENTRY(_pthread_setspecific)}, /* PJT_SETSPECIFIC */ {DUAL_ENTRY(_pthread_sigmask)} /* PJT_SIGMASK */ }; int _pthread_guard_default; int _pthread_page_size; /* * Threaded process initialization */ void _thread_init(void) { int fd; int flags; int i; size_t len; int mib[2]; int sched_stack_size; /* Size of scheduler stack. */ +#if !defined(__ia64__) + u_long stackp; +#endif struct clockinfo clockinfo; struct sigaction act; /* Check if this function has already been called: */ if (_thread_initial) /* Only initialise the threaded application once. */ return; _pthread_page_size = getpagesize();; _pthread_guard_default = _pthread_page_size; sched_stack_size = 4 * _pthread_page_size; _pthread_attr_default.guardsize_attr = _pthread_guard_default; /* * Make gcc quiescent about {,libgcc_}references not being * referenced: */ if ((references[0] == NULL) || (libgcc_references[0] == NULL)) PANIC("Failed loading mandatory references in _thread_init"); /* * Check the size of the jump table to make sure it is preset * with the correct number of entries. */ if (sizeof(jmp_table) != (sizeof(pthread_func_t) * PJT_MAX * 2)) PANIC("Thread jump table not properly initialized"); memcpy(__thr_jtable, jmp_table, sizeof(jmp_table)); /* * Check for the special case of this process running as * or in place of init as pid = 1: */ if (getpid() == 1) { /* * Setup a new session for this process which is * assumed to be running as root. */ if (setsid() == -1) PANIC("Can't set session ID"); if (revoke(_PATH_CONSOLE) != 0) PANIC("Can't revoke console"); if ((fd = __sys_open(_PATH_CONSOLE, O_RDWR)) < 0) PANIC("Can't open console"); if (setlogin("root") == -1) PANIC("Can't set login to root"); if (__sys_ioctl(fd, TIOCSCTTY, (char *) NULL) == -1) PANIC("Can't set controlling terminal"); if (__sys_dup2(fd, 0) == -1 || __sys_dup2(fd, 1) == -1 || __sys_dup2(fd, 2) == -1) PANIC("Can't dup2"); } /* Get the standard I/O flags before messing with them : */ for (i = 0; i < 3; i++) { if (((_pthread_stdio_flags[i] = __sys_fcntl(i, F_GETFL, NULL)) == -1) && (errno != EBADF)) PANIC("Cannot get stdio flags"); } /* * Create a pipe that is written to by the signal handler to prevent * signals being missed in calls to _select: */ if (__sys_pipe(_thread_kern_pipe) != 0) { /* Cannot create pipe, so abort: */ PANIC("Cannot create kernel pipe"); } /* * Make sure the pipe does not get in the way of stdio: */ for (i = 0; i < 2; i++) { if (_thread_kern_pipe[i] < 3) { fd = __sys_fcntl(_thread_kern_pipe[i], F_DUPFD, 3); if (fd == -1) PANIC("Cannot create kernel pipe"); __sys_close(_thread_kern_pipe[i]); _thread_kern_pipe[i] = fd; } } /* Get the flags for the read pipe: */ if ((flags = __sys_fcntl(_thread_kern_pipe[0], F_GETFL, NULL)) == -1) { /* Abort this application: */ PANIC("Cannot get kernel read pipe flags"); } /* Make the read pipe non-blocking: */ else if (__sys_fcntl(_thread_kern_pipe[0], F_SETFL, flags | O_NONBLOCK) == -1) { /* Abort this application: */ PANIC("Cannot make kernel read pipe non-blocking"); } /* Get the flags for the write pipe: */ else if ((flags = __sys_fcntl(_thread_kern_pipe[1], F_GETFL, NULL)) == -1) { /* Abort this application: */ PANIC("Cannot get kernel write pipe flags"); } /* Make the write pipe non-blocking: */ else if (__sys_fcntl(_thread_kern_pipe[1], F_SETFL, flags | O_NONBLOCK) == -1) { /* Abort this application: */ PANIC("Cannot get kernel write pipe flags"); } /* Allocate and initialize the ready queue: */ else if (_pq_alloc(&_readyq, PTHREAD_MIN_PRIORITY, PTHREAD_LAST_PRIORITY) != 0) { /* Abort this application: */ PANIC("Cannot allocate priority ready queue."); } /* Allocate memory for the thread structure of the initial thread: */ else if ((_thread_initial = (pthread_t) malloc(sizeof(struct pthread))) == NULL) { /* * Insufficient memory to initialise this application, so * abort: */ PANIC("Cannot allocate memory for initial thread"); } /* Allocate memory for the scheduler stack: */ else if ((_thread_kern_sched_stack = malloc(sched_stack_size)) == NULL) PANIC("Failed to allocate stack for scheduler"); else { /* Zero the global kernel thread structure: */ memset(&_thread_kern_thread, 0, sizeof(struct pthread)); _thread_kern_thread.flags = PTHREAD_FLAGS_PRIVATE; memset(_thread_initial, 0, sizeof(struct pthread)); /* Initialize the waiting and work queues: */ TAILQ_INIT(&_waitingq); TAILQ_INIT(&_workq); /* Initialize the scheduling switch hook routine: */ _sched_switch_hook = NULL; /* Give this thread default attributes: */ memcpy((void *) &_thread_initial->attr, &_pthread_attr_default, sizeof(struct pthread_attr)); /* Find the stack top */ mib[0] = CTL_KERN; mib[1] = KERN_USRSTACK; len = sizeof (_usrstack); if (sysctl(mib, 2, &_usrstack, &len, NULL, 0) == -1) _usrstack = (void *)USRSTACK; /* * Create a red zone below the main stack. All other stacks are * constrained to a maximum size by the paramters passed to * mmap(), but this stack is only limited by resource limits, so * this stack needs an explicitly mapped red zone to protect the * thread stack that is just beyond. */ if (mmap(_usrstack - PTHREAD_STACK_INITIAL - _pthread_guard_default, _pthread_guard_default, 0, MAP_ANON, -1, 0) == MAP_FAILED) PANIC("Cannot allocate red zone for initial thread"); /* Set the main thread stack pointer. */ _thread_initial->stack = _usrstack - PTHREAD_STACK_INITIAL; /* Set the stack attributes: */ _thread_initial->attr.stackaddr_attr = _thread_initial->stack; _thread_initial->attr.stacksize_attr = PTHREAD_STACK_INITIAL; /* Setup the context for the scheduler: */ _setjmp(_thread_kern_sched_jb); #if !defined(__ia64__) - SET_STACK_JB(_thread_kern_sched_jb, _thread_kern_sched_stack + - sched_stack_size - sizeof(double)); + stackp = (long)_thread_kern_sched_stack + sched_stack_size - sizeof(double); +#if defined(__amd64__) + stackp &= ~0xFUL; +#endif + SET_STACK_JB(_thread_kern_sched_jb, stackp); #else SET_STACK_JB(_thread_kern_sched_jb, _thread_kern_sched_stack, sched_stack_size); #endif SET_RETURN_ADDR_JB(_thread_kern_sched_jb, _thread_kern_scheduler); /* * Write a magic value to the thread structure * to help identify valid ones: */ _thread_initial->magic = PTHREAD_MAGIC; /* Set the initial cancel state */ _thread_initial->cancelflags = PTHREAD_CANCEL_ENABLE | PTHREAD_CANCEL_DEFERRED; /* Default the priority of the initial thread: */ _thread_initial->base_priority = PTHREAD_DEFAULT_PRIORITY; _thread_initial->active_priority = PTHREAD_DEFAULT_PRIORITY; _thread_initial->inherited_priority = 0; /* Initialise the state of the initial thread: */ _thread_initial->state = PS_RUNNING; /* Set the name of the thread: */ _thread_initial->name = strdup("_thread_initial"); /* Initialize joiner to NULL (no joiner): */ _thread_initial->joiner = NULL; /* Initialize the owned mutex queue and count: */ TAILQ_INIT(&(_thread_initial->mutexq)); _thread_initial->priority_mutex_count = 0; /* Initialize the global scheduling time: */ _sched_ticks = 0; gettimeofday((struct timeval *) &_sched_tod, NULL); /* Initialize last active: */ _thread_initial->last_active = (long) _sched_ticks; /* Initialize the initial context: */ _thread_initial->curframe = NULL; /* Initialise the rest of the fields: */ _thread_initial->poll_data.nfds = 0; _thread_initial->poll_data.fds = NULL; _thread_initial->sig_defer_count = 0; _thread_initial->yield_on_sig_undefer = 0; _thread_initial->specific = NULL; _thread_initial->cleanup = NULL; _thread_initial->flags = 0; _thread_initial->error = 0; TAILQ_INIT(&_thread_list); TAILQ_INSERT_HEAD(&_thread_list, _thread_initial, tle); _set_curthread(_thread_initial); /* Initialise the global signal action structure: */ sigfillset(&act.sa_mask); act.sa_handler = (void (*) ()) _thread_sig_handler; act.sa_flags = SA_SIGINFO | SA_RESTART; /* Clear pending signals for the process: */ sigemptyset(&_process_sigpending); /* Clear the signal queue: */ memset(_thread_sigq, 0, sizeof(_thread_sigq)); /* Enter a loop to get the existing signal status: */ for (i = 1; i < NSIG; i++) { /* Check for signals which cannot be trapped: */ if (i == SIGKILL || i == SIGSTOP) { } /* Get the signal handler details: */ else if (__sys_sigaction(i, NULL, &_thread_sigact[i - 1]) != 0) { /* * Abort this process if signal * initialisation fails: */ PANIC("Cannot read signal handler info"); } /* Initialize the SIG_DFL dummy handler count. */ _thread_dfl_count[i] = 0; } /* * Install the signal handler for the most important * signals that the user-thread kernel needs. Actually * SIGINFO isn't really needed, but it is nice to have. */ if (__sys_sigaction(_SCHED_SIGNAL, &act, NULL) != 0 || __sys_sigaction(SIGINFO, &act, NULL) != 0 || __sys_sigaction(SIGCHLD, &act, NULL) != 0) { /* * Abort this process if signal initialisation fails: */ PANIC("Cannot initialise signal handler"); } _thread_sigact[_SCHED_SIGNAL - 1].sa_flags = SA_SIGINFO; _thread_sigact[SIGINFO - 1].sa_flags = SA_SIGINFO; _thread_sigact[SIGCHLD - 1].sa_flags = SA_SIGINFO; /* Get the process signal mask: */ __sys_sigprocmask(SIG_SETMASK, NULL, &_process_sigmask); /* Get the kernel clockrate: */ mib[0] = CTL_KERN; mib[1] = KERN_CLOCKRATE; len = sizeof (struct clockinfo); if (sysctl(mib, 2, &clockinfo, &len, NULL, 0) == 0) _clock_res_usec = clockinfo.tick > CLOCK_RES_USEC_MIN ? clockinfo.tick : CLOCK_RES_USEC_MIN; /* Get the table size: */ if ((_thread_dtablesize = getdtablesize()) < 0) { /* * Cannot get the system defined table size, so abort * this process. */ PANIC("Cannot get dtablesize"); } /* Allocate memory for the file descriptor table: */ if ((_thread_fd_table = (struct fd_table_entry **) malloc(sizeof(struct fd_table_entry *) * _thread_dtablesize)) == NULL) { /* Avoid accesses to file descriptor table on exit: */ _thread_dtablesize = 0; /* * Cannot allocate memory for the file descriptor * table, so abort this process. */ PANIC("Cannot allocate memory for file descriptor table"); } /* Allocate memory for the pollfd table: */ if ((_thread_pfd_table = (struct pollfd *) malloc(sizeof(struct pollfd) * _thread_dtablesize)) == NULL) { /* * Cannot allocate memory for the file descriptor * table, so abort this process. */ PANIC("Cannot allocate memory for pollfd table"); } else { /* * Enter a loop to initialise the file descriptor * table: */ for (i = 0; i < _thread_dtablesize; i++) { /* Initialise the file descriptor table: */ _thread_fd_table[i] = NULL; } /* Initialize stdio file descriptor table entries: */ for (i = 0; i < 3; i++) { if ((_thread_fd_table_init(i) != 0) && (errno != EBADF)) PANIC("Cannot initialize stdio file " "descriptor table entry"); } } } /* 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"); } /* * Special start up code for NetBSD/Alpha */ #if defined(__NetBSD__) && defined(__alpha__) int main(int argc, char *argv[], char *env); int _thread_main(int argc, char *argv[], char *env) { _thread_init(); return (main(argc, argv, env)); } #endif Index: head/lib/libc_r/uthread/uthread_sig.c =================================================================== --- head/lib/libc_r/uthread/uthread_sig.c (revision 123116) +++ head/lib/libc_r/uthread/uthread_sig.c (revision 123117) @@ -1,1137 +1,1147 @@ /* * Copyright (c) 1995-1998 John Birrell * 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 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. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include "pthread_private.h" /* Prototypes: */ static void thread_sig_add(struct pthread *pthread, int sig, int has_args); static void thread_sig_check_state(struct pthread *pthread, int sig); static struct pthread *thread_sig_find(int sig); static void thread_sig_handle_special(int sig); static void thread_sigframe_add(struct pthread *thread, int sig, int has_args); static void thread_sigframe_save(struct pthread *thread, struct pthread_signal_frame *psf); static void thread_sig_invoke_handler(int sig, siginfo_t *info, ucontext_t *ucp); /*#define DEBUG_SIGNAL*/ #ifdef DEBUG_SIGNAL #define DBG_MSG stdout_debug #else #define DBG_MSG(x...) #endif #if defined(_PTHREADS_INVARIANTS) #define SIG_SET_ACTIVE() _sig_in_handler = 1 #define SIG_SET_INACTIVE() _sig_in_handler = 0 #else #define SIG_SET_ACTIVE() #define SIG_SET_INACTIVE() #endif void _thread_sig_handler(int sig, siginfo_t *info, ucontext_t *ucp) { struct pthread *curthread = _get_curthread(); struct pthread *pthread, *pthread_h; int in_sched = _thread_kern_in_sched; char c; if (ucp == NULL) PANIC("Thread signal handler received null context"); DBG_MSG("Got signal %d, current thread %p\n", sig, curthread); /* Check if an interval timer signal: */ if (sig == _SCHED_SIGNAL) { /* Update the scheduling clock: */ gettimeofday((struct timeval *)&_sched_tod, NULL); _sched_ticks++; if (in_sched != 0) { /* * The scheduler is already running; ignore this * signal. */ } /* * Check if the scheduler interrupt has come when * the currently running thread has deferred thread * signals. */ else if (curthread->sig_defer_count > 0) curthread->yield_on_sig_undefer = 1; else { /* Schedule the next thread: */ _thread_kern_sched(ucp); /* * This point should not be reached, so abort the * process: */ PANIC("Returned to signal function from scheduler"); } } /* * Check if the kernel has been interrupted while the scheduler * is accessing the scheduling queues or if there is a currently * running thread that has deferred signals. */ else if ((in_sched != 0) || (curthread->sig_defer_count > 0)) { /* Cast the signal number to a character variable: */ c = sig; /* * Write the signal number to the kernel pipe so that it will * be ready to read when this signal handler returns. */ if (_queue_signals != 0) { __sys_write(_thread_kern_pipe[1], &c, 1); DBG_MSG("Got signal %d, queueing to kernel pipe\n", sig); } if (_thread_sigq[sig - 1].blocked == 0) { DBG_MSG("Got signal %d, adding to _thread_sigq\n", sig); /* * Do not block this signal; it will be blocked * when the pending signals are run down. */ /* _thread_sigq[sig - 1].blocked = 1; */ /* * Queue the signal, saving siginfo and sigcontext * (ucontext). * * XXX - Do we need to copy siginfo and ucp? */ _thread_sigq[sig - 1].signo = sig; if (info != NULL) memcpy(&_thread_sigq[sig - 1].siginfo, info, sizeof(*info)); memcpy(&_thread_sigq[sig - 1].uc, ucp, sizeof(*ucp)); /* Indicate that there are queued signals: */ _thread_sigq[sig - 1].pending = 1; _sigq_check_reqd = 1; } /* These signals need special handling: */ else if (sig == SIGCHLD || sig == SIGTSTP || sig == SIGTTIN || sig == SIGTTOU) { _thread_sigq[sig - 1].pending = 1; _thread_sigq[sig - 1].signo = sig; _sigq_check_reqd = 1; } else DBG_MSG("Got signal %d, ignored.\n", sig); } /* * The signal handlers should have been installed so that they * cannot be interrupted by other signals. */ else if (_thread_sigq[sig - 1].blocked == 0) { /* * The signal is not blocked; handle the signal. * * Ignore subsequent occurrences of this signal * until the current signal is handled: */ _thread_sigq[sig - 1].blocked = 1; /* This signal will be handled; clear the pending flag: */ _thread_sigq[sig - 1].pending = 0; /* * Save siginfo and sigcontext (ucontext). * * XXX - Do we need to copy siginfo and ucp? */ _thread_sigq[sig - 1].signo = sig; if (info != NULL) memcpy(&_thread_sigq[sig - 1].siginfo, info, sizeof(*info)); memcpy(&_thread_sigq[sig - 1].uc, ucp, sizeof(*ucp)); SIG_SET_ACTIVE(); /* Handle special signals: */ thread_sig_handle_special(sig); pthread_h = NULL; if ((pthread = thread_sig_find(sig)) == NULL) DBG_MSG("No thread to handle signal %d\n", sig); else if (pthread == curthread) { /* * Unblock the signal and restore the process signal * mask in case we don't return from the handler: */ _thread_sigq[sig - 1].blocked = 0; __sys_sigprocmask(SIG_SETMASK, &_process_sigmask, NULL); /* Call the signal handler for the current thread: */ thread_sig_invoke_handler(sig, info, ucp); /* * Set the process signal mask in the context; it * could have changed by the handler. */ ucp->uc_sigmask = _process_sigmask; /* Resume the interrupted thread: */ __sys_sigreturn(ucp); } else { DBG_MSG("Got signal %d, adding frame to thread %p\n", sig, pthread); /* Setup the target thread to receive the signal: */ thread_sig_add(pthread, sig, /*has_args*/ 1); /* Take a peek at the next ready to run thread: */ pthread_h = PTHREAD_PRIOQ_FIRST(); DBG_MSG("Finished adding frame, head of prio list %p\n", pthread_h); } SIG_SET_INACTIVE(); /* * Switch to a different context if the currently running * thread takes a signal, or if another thread takes a * signal and the currently running thread is not in a * signal handler. */ if ((pthread_h != NULL) && (pthread_h->active_priority > curthread->active_priority)) { /* Enter the kernel scheduler: */ _thread_kern_sched(ucp); } } else { SIG_SET_ACTIVE(); thread_sig_handle_special(sig); SIG_SET_INACTIVE(); } } static void thread_sig_invoke_handler(int sig, siginfo_t *info, ucontext_t *ucp) { struct pthread *curthread = _get_curthread(); void (*sigfunc)(int, siginfo_t *, void *); int saved_seqno; sigset_t saved_sigmask; /* Invoke the signal handler without going through the scheduler: */ DBG_MSG("Got signal %d, calling handler for current thread %p\n", sig, curthread); /* Save the threads signal mask: */ saved_sigmask = curthread->sigmask; saved_seqno = curthread->sigmask_seqno; /* Setup the threads signal mask: */ SIGSETOR(curthread->sigmask, _thread_sigact[sig - 1].sa_mask); sigaddset(&curthread->sigmask, sig); /* * Check that a custom handler is installed and if * the signal is not blocked: */ sigfunc = _thread_sigact[sig - 1].sa_sigaction; if (((__sighandler_t *)sigfunc != SIG_DFL) && ((__sighandler_t *)sigfunc != SIG_IGN)) { if (((_thread_sigact[sig - 1].sa_flags & SA_SIGINFO) != 0) || (info == NULL)) (*(sigfunc))(sig, info, ucp); else (*(sigfunc))(sig, (void*)(intptr_t)info->si_code, ucp); } /* * Only restore the signal mask if it hasn't been changed by the * application during invocation of the signal handler: */ if (curthread->sigmask_seqno == saved_seqno) curthread->sigmask = saved_sigmask; } /* * Find a thread that can handle the signal. */ struct pthread * thread_sig_find(int sig) { struct pthread *curthread = _get_curthread(); int handler_installed; struct pthread *pthread, *pthread_next; struct pthread *suspended_thread, *signaled_thread; DBG_MSG("Looking for thread to handle signal %d\n", sig); /* Check if the signal requires a dump of thread information: */ if (sig == SIGINFO) { /* Dump thread information to file: */ _thread_dump_info(); /* Unblock this signal to allow further dumps: */ _thread_sigq[sig - 1].blocked = 0; } /* Check if an interval timer signal: */ else if (sig == _SCHED_SIGNAL) { /* * This shouldn't ever occur (should this panic?). */ } else { /* * Enter a loop to look for threads that have the signal * unmasked. POSIX specifies that a thread in a sigwait * will get the signal over any other threads. Second * preference will be threads in in a sigsuspend. Third * preference will be the current thread. If none of the * above, then the signal is delivered to the first thread * that is found. Note that if a custom handler is not * installed, the signal only affects threads in sigwait. */ suspended_thread = NULL; if ((curthread != &_thread_kern_thread) && !sigismember(&curthread->sigmask, sig)) signaled_thread = curthread; else signaled_thread = NULL; if ((_thread_sigact[sig - 1].sa_handler == SIG_IGN) || (_thread_sigact[sig - 1].sa_handler == SIG_DFL)) handler_installed = 0; else handler_installed = 1; for (pthread = TAILQ_FIRST(&_waitingq); pthread != NULL; pthread = pthread_next) { /* * Grab the next thread before possibly destroying * the link entry. */ pthread_next = TAILQ_NEXT(pthread, pqe); if ((pthread->state == PS_SIGWAIT) && sigismember(pthread->data.sigwait, sig)) { /* Change the state of the thread to run: */ PTHREAD_NEW_STATE(pthread,PS_RUNNING); /* * A signal handler is not invoked for threads * in sigwait. Clear the blocked and pending * flags. */ _thread_sigq[sig - 1].blocked = 0; _thread_sigq[sig - 1].pending = 0; /* Return the signal number: */ pthread->signo = sig; /* * POSIX doesn't doesn't specify which thread * will get the signal if there are multiple * waiters, so we give it to the first thread * we find. * * Do not attempt to deliver this signal * to other threads and do not add the signal * to the process pending set. */ return (NULL); } else if ((handler_installed != 0) && !sigismember(&pthread->sigmask, sig) && ((pthread->flags & PTHREAD_FLAGS_SUSPENDED) == 0)) { if (pthread->state == PS_SIGSUSPEND) { if (suspended_thread == NULL) suspended_thread = pthread; } else if (signaled_thread == NULL) signaled_thread = pthread; } } /* * Only perform wakeups and signal delivery if there is a * custom handler installed: */ if (handler_installed == 0) { /* * There is no handler installed. Unblock the * signal so that if a handler _is_ installed, any * subsequent signals can be handled. */ _thread_sigq[sig - 1].blocked = 0; } else { /* * If we didn't find a thread in the waiting queue, * check the all threads queue: */ if (suspended_thread == NULL && signaled_thread == NULL) { /* * Enter a loop to look for other threads * capable of receiving the signal: */ TAILQ_FOREACH(pthread, &_thread_list, tle) { if (!sigismember(&pthread->sigmask, sig)) { signaled_thread = pthread; break; } } } if (suspended_thread == NULL && signaled_thread == NULL) /* * Add it to the set of signals pending * on the process: */ sigaddset(&_process_sigpending, sig); else { /* * We only deliver the signal to one thread; * give preference to the suspended thread: */ if (suspended_thread != NULL) pthread = suspended_thread; else pthread = signaled_thread; return (pthread); } } } /* Returns nothing. */ return (NULL); } void _thread_sig_check_pending(struct pthread *pthread) { sigset_t sigset; int i; /* * Check if there are pending signals for the running * thread or process that aren't blocked: */ sigset = pthread->sigpend; SIGSETOR(sigset, _process_sigpending); SIGSETNAND(sigset, pthread->sigmask); if (SIGNOTEMPTY(sigset)) { for (i = 1; i < NSIG; i++) { if (sigismember(&sigset, i) != 0) { if (sigismember(&pthread->sigpend, i) != 0) thread_sig_add(pthread, i, /*has_args*/ 0); else { thread_sig_add(pthread, i, /*has_args*/ 1); sigdelset(&_process_sigpending, i); } } } } } /* * This can only be called from the kernel scheduler. It assumes that * all thread contexts are saved and that a signal frame can safely be * added to any user thread. */ void _thread_sig_handle_pending(void) { struct pthread *pthread; int i, sig; PTHREAD_ASSERT(_thread_kern_in_sched != 0, "_thread_sig_handle_pending called from outside kernel schedule"); /* * Check the array of pending signals: */ for (i = 0; i < NSIG; i++) { if (_thread_sigq[i].pending != 0) { /* This signal is no longer pending. */ _thread_sigq[i].pending = 0; sig = _thread_sigq[i].signo; /* Some signals need special handling: */ thread_sig_handle_special(sig); if (_thread_sigq[i].blocked == 0) { /* * Block future signals until this one * is handled: */ _thread_sigq[i].blocked = 1; if ((pthread = thread_sig_find(sig)) != NULL) { /* * Setup the target thread to receive * the signal: */ thread_sig_add(pthread, sig, /*has_args*/ 1); } } } } } static void thread_sig_handle_special(int sig) { struct pthread *pthread, *pthread_next; int i; switch (sig) { case SIGCHLD: /* * Go through the file list and set all files * to non-blocking again in case the child * set some of them to block. Sigh. */ for (i = 0; i < _thread_dtablesize; i++) { /* Check if this file is used: */ if (_thread_fd_table[i] != NULL) { /* * Set the file descriptor to non-blocking: */ __sys_fcntl(i, F_SETFL, _thread_fd_getflags(i) | O_NONBLOCK); } } /* * Enter a loop to wake up all threads waiting * for a process to complete: */ for (pthread = TAILQ_FIRST(&_waitingq); pthread != NULL; pthread = pthread_next) { /* * Grab the next thread before possibly * destroying the link entry: */ pthread_next = TAILQ_NEXT(pthread, pqe); /* * If this thread is waiting for a child * process to complete, wake it up: */ if (pthread->state == PS_WAIT_WAIT) { /* Make the thread runnable: */ PTHREAD_NEW_STATE(pthread,PS_RUNNING); /* Return the signal number: */ pthread->signo = sig; } } break; /* * POSIX says that pending SIGCONT signals are * discarded when one of these signals occurs. */ case SIGTSTP: case SIGTTIN: case SIGTTOU: /* * Enter a loop to discard pending SIGCONT * signals: */ TAILQ_FOREACH(pthread, &_thread_list, tle) { sigdelset(&pthread->sigpend, SIGCONT); } break; default: break; } } /* * Perform thread specific actions in response to a signal. * This function is only called if there is a handler installed * for the signal, and if the target thread has the signal * unmasked. */ static void thread_sig_add(struct pthread *pthread, int sig, int has_args) { int restart; int suppress_handler = 0; int thread_is_active = 0; restart = _thread_sigact[sig - 1].sa_flags & SA_RESTART; /* Make sure this signal isn't still in the pending set: */ sigdelset(&pthread->sigpend, sig); /* * Process according to thread state: */ switch (pthread->state) { /* * States which do not change when a signal is trapped: */ case PS_DEAD: case PS_DEADLOCK: case PS_STATE_MAX: case PS_SIGTHREAD: /* * You can't call a signal handler for threads in these * states. */ suppress_handler = 1; break; /* * States which do not need any cleanup handling when signals * occur: */ case PS_RUNNING: /* * Remove the thread from the queue before changing its * priority: */ if ((pthread->flags & PTHREAD_FLAGS_IN_PRIOQ) != 0) PTHREAD_PRIOQ_REMOVE(pthread); else /* * This thread is running; avoid placing it in * the run queue: */ thread_is_active = 1; break; case PS_SUSPENDED: break; case PS_SPINBLOCK: /* Remove the thread from the workq and waitq: */ PTHREAD_WORKQ_REMOVE(pthread); PTHREAD_WAITQ_REMOVE(pthread); /* Make the thread runnable: */ PTHREAD_SET_STATE(pthread, PS_RUNNING); break; case PS_SIGWAIT: /* The signal handler is not called for threads in SIGWAIT. */ suppress_handler = 1; /* 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; /* * The wait state is a special case due to the handling of * SIGCHLD signals. */ case PS_WAIT_WAIT: if (sig == SIGCHLD) { /* Change the state of the thread to run: */ PTHREAD_WAITQ_REMOVE(pthread); PTHREAD_SET_STATE(pthread, PS_RUNNING); /* Return the signal number: */ pthread->signo = sig; } else { /* * Mark the thread as interrupted only if the * restart flag is not set on the signal action: */ if (restart == 0) pthread->interrupted = 1; PTHREAD_WAITQ_REMOVE(pthread); PTHREAD_SET_STATE(pthread, PS_RUNNING); } break; /* * States which cannot be interrupted but still require the * signal handler to run: */ case PS_COND_WAIT: case PS_MUTEX_WAIT: /* * Remove the thread from the wait queue. It will * be added back to the wait queue once all signal * handlers have been invoked. */ PTHREAD_WAITQ_REMOVE(pthread); break; case PS_JOIN: /* * Remove the thread from the wait queue. It will * be added back to the wait queue once all signal * handlers have been invoked. */ PTHREAD_WAITQ_REMOVE(pthread); /* Make the thread runnable: */ PTHREAD_SET_STATE(pthread, PS_RUNNING); break; /* * States which are interruptible but may need to be removed * from queues before any signal handler is called. * * XXX - We may not need to handle this condition, but will * mark it as a potential problem. */ case PS_FDLR_WAIT: case PS_FDLW_WAIT: case PS_FILE_WAIT: if (restart == 0) pthread->interrupted = 1; /* * Remove the thread from the wait queue. Our * signal handler hook will remove this thread * from the fd or file queue before invoking * the actual handler. */ PTHREAD_WAITQ_REMOVE(pthread); break; /* * States which are interruptible: */ case PS_FDR_WAIT: case PS_FDW_WAIT: if (restart == 0) { /* * Flag the operation as interrupted and * set the state to running: */ pthread->interrupted = 1; PTHREAD_SET_STATE(pthread, PS_RUNNING); } PTHREAD_WORKQ_REMOVE(pthread); PTHREAD_WAITQ_REMOVE(pthread); break; case PS_POLL_WAIT: case PS_SELECT_WAIT: case PS_SLEEP_WAIT: /* * Unmasked signals always cause poll, select, and sleep * to terminate early, regardless of SA_RESTART: */ pthread->interrupted = 1; /* Remove threads in poll and select from the workq: */ if ((pthread->flags & PTHREAD_FLAGS_IN_WORKQ) != 0) PTHREAD_WORKQ_REMOVE(pthread); PTHREAD_WAITQ_REMOVE(pthread); PTHREAD_SET_STATE(pthread, PS_RUNNING); break; case PS_SIGSUSPEND: PTHREAD_WAITQ_REMOVE(pthread); PTHREAD_SET_STATE(pthread, PS_RUNNING); break; } if (suppress_handler == 0) { /* Setup a signal frame and save the current threads state: */ thread_sigframe_add(pthread, sig, has_args); /* * Signals are deferred until just before the threads * signal handler is invoked: */ pthread->sig_defer_count = 1; /* Make sure the thread is runnable: */ if (pthread->state != PS_RUNNING) PTHREAD_SET_STATE(pthread, PS_RUNNING); /* * The thread should be removed from all scheduling * queues at this point. Raise the priority and place * the thread in the run queue. It is also possible * for a signal to be sent to a suspended thread, * mostly via pthread_kill(). If a thread is suspended, * don't insert it into the priority queue; just set * its state to suspended and it will run the signal * handler when it is resumed. */ pthread->active_priority |= PTHREAD_SIGNAL_PRIORITY; if ((pthread->flags & PTHREAD_FLAGS_SUSPENDED) != 0) PTHREAD_SET_STATE(pthread, PS_SUSPENDED); else if (thread_is_active == 0) PTHREAD_PRIOQ_INSERT_TAIL(pthread); } } static void thread_sig_check_state(struct pthread *pthread, int sig) { /* * Process according to thread state: */ switch (pthread->state) { /* * States which do not change when a signal is trapped: */ case PS_DEAD: case PS_DEADLOCK: case PS_STATE_MAX: case PS_SIGTHREAD: case PS_RUNNING: case PS_SUSPENDED: case PS_SPINBLOCK: case PS_COND_WAIT: case PS_JOIN: case PS_MUTEX_WAIT: 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; /* * The wait state is a special case due to the handling of * SIGCHLD signals. */ case PS_WAIT_WAIT: if (sig == SIGCHLD) { /* * Remove the thread from the wait queue and * make it runnable: */ PTHREAD_NEW_STATE(pthread, PS_RUNNING); /* Return the signal number: */ pthread->signo = sig; } break; case PS_FDLR_WAIT: case PS_FDLW_WAIT: case PS_SIGSUSPEND: case PS_SLEEP_WAIT: /* * Remove the thread from the wait queue and make it * runnable: */ PTHREAD_NEW_STATE(pthread, PS_RUNNING); /* Flag the operation as interrupted: */ pthread->interrupted = 1; break; /* * These states are additionally in the work queue: */ case PS_FDR_WAIT: case PS_FDW_WAIT: case PS_FILE_WAIT: case PS_POLL_WAIT: case PS_SELECT_WAIT: /* * Remove the thread from the wait and work queues, and * make it runnable: */ PTHREAD_WORKQ_REMOVE(pthread); PTHREAD_NEW_STATE(pthread, PS_RUNNING); /* Flag the operation as interrupted: */ pthread->interrupted = 1; break; } } /* * Send a signal to a specific thread (ala pthread_kill): */ void _thread_sig_send(struct pthread *pthread, int sig) { struct pthread *curthread = _get_curthread(); /* Check for signals whose actions are SIG_DFL: */ if (_thread_sigact[sig - 1].sa_handler == SIG_DFL) { /* * Check to see if a temporary signal handler is * installed for sigwaiters: */ if (_thread_dfl_count[sig] == 0) /* * Deliver the signal to the process if a handler * is not installed: */ kill(getpid(), sig); /* * Assuming we're still running after the above kill(), * make any necessary state changes to the thread: */ thread_sig_check_state(pthread, sig); } /* * Check that the signal is not being ignored: */ else if (_thread_sigact[sig - 1].sa_handler != SIG_IGN) { if (pthread->state == PS_SIGWAIT && 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 if (sigismember(&pthread->sigmask, sig)) /* Add the signal to the pending set: */ sigaddset(&pthread->sigpend, sig); else if (pthread == curthread) /* Call the signal handler for the current thread: */ thread_sig_invoke_handler(sig, NULL, NULL); else { /* Protect the scheduling queues: */ _thread_kern_sig_defer(); /* * Perform any state changes due to signal * arrival: */ thread_sig_add(pthread, sig, /* has args */ 0); /* Unprotect the scheduling queues: */ _thread_kern_sig_undefer(); } } } /* * User thread signal handler wrapper. * * thread - current running thread */ void _thread_sig_wrapper(void) { struct pthread_signal_frame *psf; struct pthread *thread = _get_curthread(); /* Get the current frame and state: */ psf = thread->curframe; thread->curframe = NULL; PTHREAD_ASSERT(psf != NULL, "Invalid signal frame in signal handler"); /* * We're coming from the kernel scheduler; clear the in * scheduler flag: */ _thread_kern_in_sched = 0; /* Check the threads previous state: */ if (psf->saved_state.psd_state != PS_RUNNING) { /* * Do a little cleanup handling for those threads in * queues before calling the signal handler. Signals * for these threads are temporarily blocked until * after cleanup handling. */ switch (psf->saved_state.psd_state) { case PS_FDLR_WAIT: case PS_FDLW_WAIT: _fd_lock_backout(thread); psf->saved_state.psd_state = PS_RUNNING; break; case PS_COND_WAIT: _cond_wait_backout(thread); psf->saved_state.psd_state = PS_RUNNING; break; case PS_MUTEX_WAIT: _mutex_lock_backout(thread); psf->saved_state.psd_state = PS_RUNNING; break; default: break; } } /* Unblock the signal in case we don't return from the handler: */ _thread_sigq[psf->signo - 1].blocked = 0; /* * Lower the priority before calling the handler in case * it never returns (longjmps back): */ thread->active_priority &= ~PTHREAD_SIGNAL_PRIORITY; /* * Reenable interruptions without checking for the need to * context switch: */ thread->sig_defer_count = 0; /* * Dispatch the signal via the custom signal handler: */ if (psf->sig_has_args == 0) thread_sig_invoke_handler(psf->signo, NULL, NULL); else thread_sig_invoke_handler(psf->signo, &psf->siginfo, &psf->uc); /* * Call the kernel scheduler to safely restore the frame and * schedule the next thread: */ _thread_kern_sched_frame(psf); } static void thread_sigframe_add(struct pthread *thread, int sig, int has_args) { struct pthread_signal_frame *psf = NULL; unsigned long stackp; /* Get the top of the threads stack: */ stackp = GET_STACK_JB(thread->ctx.jb); #if !defined(__ia64__) /* * Leave a little space on the stack and round down to the * nearest aligned word: */ +#if defined(__amd64__) + stackp -= 128; /* Skip over 128 byte red-zone */ +#endif stackp -= sizeof(double); +#if defined(__amd64__) + stackp &= ~0xFUL; +#else stackp &= ~0x3UL; #endif +#endif /* Allocate room on top of the stack for a new signal frame: */ stackp -= sizeof(struct pthread_signal_frame); -#if defined(__ia64__) +#if defined(__ia64__) || defined(__amd64__) stackp &= ~0xFUL; #endif psf = (struct pthread_signal_frame *) stackp; /* Save the current context in the signal frame: */ thread_sigframe_save(thread, psf); /* Set handler specific information: */ psf->sig_has_args = has_args; psf->signo = sig; if (has_args) { /* Copy the signal handler arguments to the signal frame: */ memcpy(&psf->uc, &_thread_sigq[psf->signo - 1].uc, sizeof(psf->uc)); memcpy(&psf->siginfo, &_thread_sigq[psf->signo - 1].siginfo, sizeof(psf->siginfo)); } /* Setup the signal mask: */ SIGSETOR(thread->sigmask, _thread_sigact[sig - 1].sa_mask); sigaddset(&thread->sigmask, sig); /* Set up the new frame: */ thread->curframe = psf; thread->flags &= PTHREAD_FLAGS_PRIVATE | PTHREAD_FLAGS_TRACE | PTHREAD_FLAGS_IN_SYNCQ; /* * Set up the context: */ #if !defined(__ia64__) stackp -= sizeof(double); +#if defined(__amd64__) + stackp &= ~0xFUL; +#endif #endif _setjmp(thread->ctx.jb); #if !defined(__ia64__) SET_STACK_JB(thread->ctx.jb, stackp); #else UPD_STACK_JB(thread->ctx.jb, stackp - 16); #endif SET_RETURN_ADDR_JB(thread->ctx.jb, _thread_sig_wrapper); } void _thread_sigframe_restore(struct pthread *thread, struct pthread_signal_frame *psf) { memcpy(&thread->ctx, &psf->ctx, sizeof(thread->ctx)); /* * Only restore the signal mask if it hasn't been changed * by the application during invocation of the signal handler: */ if (thread->sigmask_seqno == psf->saved_state.psd_sigmask_seqno) thread->sigmask = psf->saved_state.psd_sigmask; thread->curframe = psf->saved_state.psd_curframe; thread->wakeup_time = psf->saved_state.psd_wakeup_time; thread->data = psf->saved_state.psd_wait_data; thread->state = psf->saved_state.psd_state; thread->flags = psf->saved_state.psd_flags; thread->interrupted = psf->saved_state.psd_interrupted; thread->signo = psf->saved_state.psd_signo; thread->sig_defer_count = psf->saved_state.psd_sig_defer_count; } static void thread_sigframe_save(struct pthread *thread, struct pthread_signal_frame *psf) { memcpy(&psf->ctx, &thread->ctx, sizeof(thread->ctx)); psf->saved_state.psd_sigmask = thread->sigmask; psf->saved_state.psd_curframe = thread->curframe; psf->saved_state.psd_wakeup_time = thread->wakeup_time; psf->saved_state.psd_wait_data = thread->data; psf->saved_state.psd_state = thread->state; psf->saved_state.psd_flags = thread->flags & (PTHREAD_FLAGS_PRIVATE | PTHREAD_FLAGS_TRACE); psf->saved_state.psd_interrupted = thread->interrupted; psf->saved_state.psd_sigmask_seqno = thread->sigmask_seqno; psf->saved_state.psd_signo = thread->signo; psf->saved_state.psd_sig_defer_count = thread->sig_defer_count; }