diff options
Diffstat (limited to 'libthreads/cprocs.c')
| -rw-r--r-- | libthreads/cprocs.c | 1214 |
1 files changed, 0 insertions, 1214 deletions
diff --git a/libthreads/cprocs.c b/libthreads/cprocs.c deleted file mode 100644 index 5fb138d2..00000000 --- a/libthreads/cprocs.c +++ /dev/null @@ -1,1214 +0,0 @@ -/* - * Mach Operating System - * Copyright (c) 1993-1989 Carnegie Mellon University - * All Rights Reserved. - * - * Permission to use, copy, modify and distribute this software and its - * documentation is hereby granted, provided that both the copyright - * notice and this permission notice appear in all copies of the - * software, derivative works or modified versions, and any portions - * thereof, and that both notices appear in supporting documentation. - * - * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" - * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR - * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. - * - * Carnegie Mellon requests users of this software to return to - * - * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU - * School of Computer Science - * Carnegie Mellon University - * Pittsburgh PA 15213-3890 - * - * any improvements or extensions that they make and grant Carnegie Mellon - * the rights to redistribute these changes. - */ -/* - * HISTORY - * 26-Oct-94 Johannes Helander (jvh) Helsinki University of Technology - * Set the wait_type field. - * - * $Log: cprocs.c,v $ - * Revision 1.16 2002/05/27 02:50:10 roland - * 2002-05-26 Roland McGrath <roland@frob.com> - * - * Changes merged from CMU MK83a version: - * * cthreads.h, options.h: Various cleanups. - * * call.c, cthread_data.c, sync.c, mig_support.c: Likewise. - * * i386/cthreads.h, i386/thread.c, i386/lock.s: Likewise. - * * cthread_internals.h: Add decls for internal functions. - * (struct cproc): Use vm_offset_t for stack_base and stack_size members. - * Use natural_t for context member. - * * cprocs.c: Use prototypes for all defns. - * * cthreads.c: Likewise. - * (cthread_exit): Cast any_t to integer_t before int. - * - * Revision 2.18 93/03/09 10:59:10 danner - * Lint. - * [93/03/06 af] - * - * Revision 2.17 93/01/19 08:55:44 danner - * Added missing spin_lock_t type from cproc_list_lock decl. - * [92/12/30 af] - * - * - * Revision 2.16 93/01/14 18:04:46 danner - * Convert file to ANSI C. - * [92/12/18 pds] - * 64bit cleanup. - * [92/12/10 21:08:32 af] - * - * Revision 2.15 92/03/06 14:09:31 rpd - * Replaced swtch_pri with yield. - * [92/03/06 rpd] - * - * Revision 2.14 91/08/28 11:19:16 jsb - * Fixed the loop in cproc_fork_child that frees cprocs. - * [91/08/23 rpd] - * - * Revision 2.13 91/07/31 18:33:04 dbg - * Fix some more bad types. Ints are NOT pointers. - * - * Fix argument type mismatch in cproc_create. - * [91/07/30 17:32:59 dbg] - * - * Revision 2.12 91/05/14 17:56:11 mrt - * Correcting copyright - * - * Revision 2.11 91/02/14 14:19:26 mrt - * Added new Mach copyright - * [91/02/13 12:40:50 mrt] - * - * Revision 2.10 90/11/05 14:36:41 rpd - * Added cproc_fork_{prepare,parent,child}. - * [90/11/02 rwd] - * - * Fix for positive stack growth. - * [90/11/01 rwd] - * - * Add spin_lock_t. - * [90/10/31 rwd] - * - * Revision 2.9 90/10/12 13:07:12 rpd - * Fix type - * [90/10/10 15:09:59 rwd] - * - * Comment code. - * [90/10/02 rwd] - * - * Revision 2.8 90/09/09 14:34:44 rpd - * Remove special mutex. Remove thread_calls and debug_mutex - * [90/08/24 rwd] - * Fix up old call to cthread_msg_busy to new format. - * [90/08/22 rwd] - * - * Revision 2.7 90/08/06 15:09:17 rwd - * Fixed arguments to cthread_mach_msg. - * [90/06/26 rwd] - * Add additional STATISTICS. - * [90/06/07 rwd] - * - * Attempt to reduce number of times a cthread is released to to a - * msg_receive by adding min/max instead of single number to - * cthread_msg calls. - * [90/06/06 rwd] - * - * Revision 2.6 90/06/02 15:13:36 rpd - * Converted to new IPC. - * [90/03/20 20:46:16 rpd] - * - * Revision 2.5 90/05/29 18:40:11 rwd - * Don't incr special field until the mutex grab is successful. - * [90/05/09 rwd] - * - * Revision 2.4 90/03/14 21:12:02 rwd - * Added WAIT_DEBUG code for deadlock debugging. - * [90/03/01 rwd] - * Insert cprocs in cproc_list as allocated. - * [90/03/01 10:20:16 rwd] - * - * Revision 2.3 90/01/19 14:36:57 rwd - * Make cthread_msg_busy only release new thread if this is still - * busy. Ie don't release two on back to back calls. - * [90/01/11 rwd] - * Add THREAD_CALL code. Add CPROC_ARUN state. - * [90/01/03 rwd] - * Add new cthread_msg_rpc call - * [89/12/20 rwd] - * Change cproc_self pointer to top of stack. Now need to change - * the stack of the first thread. - * [89/12/12 rwd] - * - * Revision 2.2 89/12/08 19:53:13 rwd - * Added CPROC_CONDWAIT state to deal with lock held - * across mutex_unlock problem. - * [89/11/29 rwd] - * Changed mutexes to not hand off. MUTEX_EXTRA conditional is - * now obsolete. - * [89/11/27 rwd] - * - * Add MUTEX_EXTRA code for extra kernel threads to serve special - * mutexes in time of need. - * [89/11/25 rwd] - * Add MUTEX_SPECIAL and DEBUG_MUTEX code - * [89/11/24 rwd] - * Changed mutex_lock to mutex_lock_solid. Mutex_lock is now a - * macro which tries the spin_lock before making a subroutine call. - * Mutex_unlock is now a macro with mutex_unlock_solid for worst case. - * [89/11/13 rwd] - * - * Rewrite most to merge coroutine and thread implementation. - * New routines are cthread_set_kernel_limit, cthread_kernel_limit, - * cthread_wire, cthread_unwire, and cthread_receive. - * [89/10/23 rwd] - * - * Revision 2.1 89/08/03 17:07:10 rwd - * Created. - * - * 11-Apr-89 David Golub (dbg) at Carnegie-Mellon University - * Made condition_yield loop break if swtch_pri returns TRUE (in - * case we fix it). - * - * 31-Mar-89 David Golub (dbg) at Carnegie-Mellon University - * Change cond_signal, cond_broadcast, and cproc_continue so that - * the condition's spin lock is not held while continuing the - * process. - * - * 16-Jan-89 David Golub (dbg) at Carnegie-Mellon University - * Changes for stand-alone library to run on pure kernel: - * . made IPC_WAIT standard, as calls that are used if IPC_WAIT == 0 - * vanished a year ago. - * . Removed (as much as possible) references to stdio or other U*X - * features. - * - * - * 01-Apr-88 Eric Cooper (ecc) at Carnegie Mellon University - * Changed condition_clear(c) to acquire c->lock, - * to serialize after any threads still doing condition_signal(c). - * Suggested by Dan Julin. - * - * 19-Feb-88 Eric Cooper (ecc) at Carnegie Mellon University - * Extended the inline scripts to handle spin_unlock() and mutex_unlock(). - * - * 28-Jan-88 David Golub (dbg) at Carnegie Mellon University - * Removed thread_data argument from thread_create - * and converted to new thread_set_state call. - * - * 01-Dec-87 Eric Cooper (ecc) at Carnegie Mellon University - * Added inline expansion for cthread_sp() function. - * - * 21-Aug-87 Eric Cooper (ecc) at Carnegie Mellon University - * Fixed uninitialized reply_port in cproc_alloc() (found by rds). - * - * 14-Aug-87 Eric Cooper (ecc) at Carnegie Mellon University - * Tried using return value of swtch() to guide condition_wait(). - * Performance was worse than using a hybrid spin/yield/block - * scheme, so the version using swtch() was commented out. - * Disabled IPC_WAIT in released version. - * - * 13-Aug-87 Eric Cooper (ecc) at Carnegie Mellon University - * Added IPC_WAIT option. - * If defined, thread synchronization (condition_wait() and - * cproc_continue()) are implemented using msg_receive() and - * msg_send() instead of thread_suspend() and thread_resume(). - * - * 11-Aug-87 Eric Cooper (ecc) at Carnegie Mellon University - * Moved thread reply port to cproc structure in cthread_internals.h, - * because mig calls are made while cproc is idle (no cthread structure). - * Changed cproc_switch() and cproc_start (COROUTINE implementation) - * to use address of saved context, rather than address of enclosing cproc, - * to eliminate dependency on cproc layout. - */ -/* - * File: cprocs.c - * Author: Eric Cooper, Carnegie Mellon University - * Date: Aug, 1987 - * - * Implementation of cprocs (lightweight processes) - * and primitive synchronization operations. - */ - - -#include <cthreads.h> -#include "cthread_internals.h" -#include <mach/message.h> -#include <hurd/threadvar.h> /* GNU */ -#include <assert-backtrace.h> - -/* - * Port_entry's are used by cthread_mach_msg to store information - * about each port/port_set for which it is managing threads - */ - -typedef struct port_entry { - struct port_entry *next; /* next port_entry */ - mach_port_t port; /* which port/port_set */ - struct cthread_queue queue; /* queue of runnable threads for - this port/port_set */ - int min; /* minimum number of kernel threads - to be used by this port/port_set */ - int max; /* maximum number of kernel threads - to be used by this port/port_set */ - int held; /* actual number of kernel threads - currentlt in use */ - spin_lock_t lock; /* lock governing all above fields */ -} *port_entry_t; - -#define PORT_ENTRY_NULL ((port_entry_t) 0) - -/* Available to outside for statistics */ - -int cthread_wait_stack_size = 8192; /* stack size for idle threads */ -int cthread_max_kernel_threads = 0; /* max kernel threads */ -int cthread_kernel_threads = 0; /* current kernel threads */ -private spin_lock_t n_kern_lock = SPIN_LOCK_INITIALIZER; - /* lock for 2 above */ -#ifdef STATISTICS -int cthread_ready = 0; /* currently runnable */ -int cthread_running = 1; /* currently running */ -int cthread_waiting = 0; /* currently waiting */ -int cthread_wired = 0; /* currently wired */ -private spin_lock_t wired_lock = SPIN_LOCK_INITIALIZER; - /* lock for above */ -int cthread_wait_stacks = 0; /* total cthread waiting stacks */ -int cthread_waiters = 0; /* total of watiers */ -int cthread_wakeup = 0; /* total times woken when starting to - block */ -int cthread_blocked = 0; /* total blocked */ -int cthread_rnone = 0; /* total times no cthread available - to meet minimum for port_entry */ -int cthread_yields = 0; /* total cthread_yields */ -int cthread_none = 0; /* total idle wakeups w/o runnable */ -int cthread_switches = 0; /* total number of cproc_switches */ -int cthread_no_mutex = 0; /* total number times woken to get - mutex and couldn't */ -private spin_lock_t mutex_count_lock = SPIN_LOCK_INITIALIZER; - /* lock for above */ -#endif /* STATISTICS */ - -cproc_t cproc_list = NO_CPROC; /* list of all cprocs */ -private spin_lock_t cproc_list_lock = SPIN_LOCK_INITIALIZER; - /* lock for above */ -private int cprocs_started = FALSE; /* initialized? */ -private struct cthread_queue ready = QUEUE_INITIALIZER; - /* ready queue */ -private int ready_count = 0; /* number of ready threads on ready - queue - number of messages sent */ -private spin_lock_t ready_lock = SPIN_LOCK_INITIALIZER; - /* lock for 2 above */ -private mach_port_t wait_port = MACH_PORT_NULL; - /* port on which idle threads wait */ -private int wait_count = 0; /* number of waiters - messages pending - to wake them */ -private struct cthread_queue waiters = QUEUE_INITIALIZER; - /* queue of cthreads to run as idle */ -private spin_lock_t waiters_lock = SPIN_LOCK_INITIALIZER; - /* lock for 2 above */ -private port_entry_t port_list = PORT_ENTRY_NULL; - /* master list of port_entries */ -private spin_lock_t port_lock = SPIN_LOCK_INITIALIZER; - /* lock for above queue */ -private mach_msg_header_t wakeup_msg; /* prebuilt message used by idle - threads */ - -/* - * Return current value for max kernel threads - * Note: 0 means no limit - */ -int -cthread_kernel_limit(void) -{ - return cthread_max_kernel_threads; -} - -/* - * Set max number of kernel threads - * Note: This will not currently terminate existing threads - * over maximum. - */ - -void -cthread_set_kernel_limit(int n) -{ - cthread_max_kernel_threads = n; -} - -/* - * Wire a cthread to its current kernel thread - */ - -void -cthread_wire(void) -{ - register cproc_t p = cproc_self(); - - /* In GNU, we wire all threads on creation (in cproc_alloc). */ - assert_backtrace (p->wired != MACH_PORT_NULL); -} - -/* - * Unwire a cthread. Deallocate its wait port. - */ - -void -cthread_unwire(void) -{ - register cproc_t p = cproc_self(); - - /* This is bad juju in GNU, where all cthreads must be wired. */ - abort(); -#if 0 - if (p->wired != MACH_PORT_NULL) { - MACH_CALL(mach_port_mod_refs(mach_task_self(), p->wired, - MACH_PORT_RIGHT_SEND, -1), r); - MACH_CALL(mach_port_mod_refs(mach_task_self(), p->wired, - MACH_PORT_RIGHT_RECEIVE, -1), r); - p->wired = MACH_PORT_NULL; -#ifdef STATISTICS - spin_lock(&wired_lock); - cthread_wired--; - spin_unlock(&wired_lock); -#endif /* STATISTICS */ - } -#endif -} - -private cproc_t -cproc_alloc(void) -{ - register cproc_t p = (cproc_t) malloc(sizeof(struct cproc)); - kern_return_t r; - - p->incarnation = NO_CTHREAD; -#if 0 - /* This member is not used in GNU. */ - p->reply_port = MACH_PORT_NULL; -#endif - - spin_lock_init(&p->lock); - p->state = CPROC_RUNNING; - p->busy = 0; - - /* - * In GNU, every cthread must be wired. So we just - * initialize P->wired on creation. - * - * A wired thread has a port associated with it for all - * of its wait/block cases. We also prebuild a wakeup - * message. - */ - - MACH_CALL(mach_port_allocate(mach_task_self(), - MACH_PORT_RIGHT_RECEIVE, - &p->wired), r); - MACH_CALL(mach_port_insert_right(mach_task_self(), - p->wired, p->wired, - MACH_MSG_TYPE_MAKE_SEND), r); - p->msg.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0); - p->msg.msgh_size = 0; /* initialized in call */ - p->msg.msgh_remote_port = p->wired; - p->msg.msgh_local_port = MACH_PORT_NULL; - p->msg.msgh_kind = MACH_MSGH_KIND_NORMAL; - p->msg.msgh_id = 0; - - spin_lock(&cproc_list_lock); - p->list = cproc_list; - cproc_list = p; - spin_unlock(&cproc_list_lock); - - return p; -} - -/* - * Called by cthread_init to set up initial data structures. - */ - -vm_offset_t -cproc_init(void) -{ - kern_return_t r; - - cproc_t p = cproc_alloc(); - - cthread_kernel_threads = 1; - - MACH_CALL(mach_port_allocate(mach_task_self(), - MACH_PORT_RIGHT_RECEIVE, - &wait_port), r); - MACH_CALL(mach_port_insert_right(mach_task_self(), - wait_port, wait_port, - MACH_MSG_TYPE_MAKE_SEND), r); - - wakeup_msg.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0); - wakeup_msg.msgh_size = 0; /* initialized in call */ - wakeup_msg.msgh_remote_port = wait_port; - wakeup_msg.msgh_local_port = MACH_PORT_NULL; - wakeup_msg.msgh_kind = MACH_MSGH_KIND_NORMAL; - wakeup_msg.msgh_id = 0; - - cprocs_started = TRUE; - - - /* - * We pass back the new stack which should be switched to - * by crt0. This guarantess correct size and alignment. - */ - return (stack_init(p)); -} - -/* - * Insert cproc on ready queue. Make sure it is ready for queue by - * synching on its lock. Just send message to wired cproc. - */ - -private boolean_t cproc_ready(register cproc_t p, register int preq) -{ - register cproc_t s=cproc_self(); - kern_return_t r; - - if (p->wired != MACH_PORT_NULL) { - r = mach_msg(&p->msg, MACH_SEND_MSG, - sizeof p->msg, 0, MACH_PORT_NULL, - MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); -#ifdef CHECK_STATUS - if (r != MACH_MSG_SUCCESS) { - mach_error("mach_msg", r); - exit(1); - } -#endif /* CHECK_STATUS */ - return TRUE; - } - spin_lock(&p->lock); /* is it ready to be queued? It - can appear on a queue before - being switched from. This lock - is released by cproc_switch as - its last operation. */ - if (p->state & CPROC_SWITCHING) { - /* - * We caught it early on. Just set to RUNNING - * and we will save a lot of time. - */ - p->state = (p->state & ~CPROC_SWITCHING) | CPROC_RUNNING; - spin_unlock(&p->lock); - return TRUE; - } - spin_unlock(&p->lock); - - spin_lock(&ready_lock); - - if (preq) { - cthread_queue_preq(&ready, p); - } else { - cthread_queue_enq(&ready, p); - } -#ifdef STATISTICS - cthread_ready++; -#endif /* STATISTICS */ - ready_count++; - - if ((s->state & CPROC_CONDWAIT) && !(s->wired)) { - /* - * This is an optimiztion. Don't bother waking anyone to grab - * this guy off the ready queue since my thread will block - * momentarily for the condition wait. - */ - - spin_unlock(&ready_lock); - return TRUE; - } - - if ((ready_count > 0) && wait_count) { - wait_count--; - ready_count--; - spin_unlock(&ready_lock); - r = mach_msg(&wakeup_msg, MACH_SEND_MSG, - sizeof wakeup_msg, 0, MACH_PORT_NULL, - MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); -#ifdef CHECK_STATUS - if (r != MACH_MSG_SUCCESS) { - mach_error("mach_msg", r); - exit(1); - } -#endif /* CHECK_STATUS */ - return TRUE; - } - spin_unlock(&ready_lock); - return FALSE; -} - -/* - * This is only run on a partial "waiting" stack and called from - * cproc_start_wait - */ - -void -cproc_waiting(cproc_t p) -{ - mach_msg_header_t msg; - register cproc_t new; - kern_return_t r; - -#ifdef STATISTICS - spin_lock(&ready_lock); - cthread_waiting++; - cthread_waiters++; - spin_unlock(&ready_lock); -#endif /* STATISTICS */ - for (;;) { - MACH_CALL(mach_msg(&msg, MACH_RCV_MSG, - 0, sizeof msg, wait_port, - MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL), r); - spin_lock(&ready_lock); - cthread_queue_deq(&ready, cproc_t, new); - if (new != NO_CPROC) break; - wait_count++; - ready_count++; -#ifdef STATISTICS - cthread_none++; -#endif /* STATISTICS */ - spin_unlock(&ready_lock); - } -#ifdef STATISTICS - cthread_ready--; - cthread_running++; - cthread_waiting--; -#endif /* STATISTICS */ - spin_unlock(&ready_lock); - spin_lock(&new->lock); - new->state = CPROC_RUNNING; - spin_unlock(&new->lock); - spin_lock(&waiters_lock); - cthread_queue_enq(&waiters, p); - spin_lock(&p->lock); - spin_unlock(&waiters_lock); - cproc_switch(&p->context,&new->context,&p->lock); -} - -/* - * Get a waiter with stack - * - */ - -private cproc_t -cproc_waiter(void) -{ - register cproc_t waiter; - - spin_lock(&waiters_lock); - cthread_queue_deq(&waiters, cproc_t, waiter); - spin_unlock(&waiters_lock); - if (waiter == NO_CPROC) { - vm_address_t base; - kern_return_t r; -#ifdef STATISTICS - spin_lock(&waiters_lock); - cthread_wait_stacks++; - spin_unlock(&waiters_lock); -#endif /* STATISTICS */ - waiter = cproc_alloc(); - MACH_CALL(vm_allocate(mach_task_self(), &base, - cthread_wait_stack_size, TRUE), r); - waiter->stack_base = base; - waiter->stack_size = cthread_wait_stack_size; - } - return (waiter); -} - - -/* - * Current cproc is blocked so switch to any ready cprocs, or, if - * none, go into the wait state. - * - * You must hold cproc_self()->lock when called. - */ - -void -cproc_block(void) -{ - extern unsigned int __hurd_threadvar_max; /* GNU */ - register cproc_t waiter, new, p = cproc_self(); - - if (p->wired != MACH_PORT_NULL) { - mach_msg_header_t msg; - kern_return_t r; - - spin_unlock(&p->lock); - MACH_CALL(mach_msg(&msg, MACH_RCV_MSG, - 0, sizeof msg, p->wired, - MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL), r); - return; - } - p->state = CPROC_SWITCHING; - spin_unlock(&p->lock); - spin_lock(&ready_lock); -#ifdef STATISTICS - cthread_blocked++; -#endif /* STATISTICS */ - cthread_queue_deq(&ready, cproc_t, new); - if (new) { -#ifdef STATISTICS - cthread_ready--; - cthread_switches++; -#endif /* STATISTICS */ - ready_count--; - spin_unlock(&ready_lock); - spin_lock(&p->lock); - if (p->state == CPROC_RUNNING) { /* have we been saved */ - spin_unlock(&p->lock); -#ifdef STATISTICS - spin_lock(&ready_lock); - cthread_wakeup++; - cthread_switches--; - spin_unlock(&ready_lock); -#endif /* STATISTICS */ - cproc_ready(new, 1); /* requeue at head were it was */ - } else { - p->state = CPROC_BLOCKED; - spin_lock(&new->lock); /* incase still switching */ - new->state = CPROC_RUNNING; - spin_unlock(&new->lock); - cproc_switch(&p->context,&new->context,&p->lock); - } - } else { - wait_count++; -#ifdef STATISTICS - cthread_running--; -#endif /* STATISTICS */ - spin_unlock(&ready_lock); - waiter = cproc_waiter(); - spin_lock(&p->lock); - if (p->state == CPROC_RUNNING) { /* we have been saved */ - spin_unlock(&p->lock); - spin_lock(&ready_lock); - wait_count--; -#ifdef STATISTICS - cthread_running++; - cthread_wakeup++; -#endif /* STATISTICS */ - spin_unlock(&ready_lock); - spin_lock(&waiters_lock); - cthread_queue_preq(&waiters, waiter); - spin_unlock(&waiters_lock); - } else { - p->state = CPROC_BLOCKED; - spin_lock(&waiter->lock); /* in case still switching */ - spin_unlock(&waiter->lock); - cproc_start_wait - (&p->context, waiter, - cproc_stack_base(waiter, - sizeof(ur_cthread_t *) + - /* Account for GNU per-thread - variables. */ - __hurd_threadvar_max * - sizeof (long int)), - &p->lock); - } - } -} - -/* - * Implement C threads using MACH threads. - */ -cproc_t -cproc_create(void) -{ - register cproc_t child = cproc_alloc(); - register kern_return_t r; - extern void cproc_setup(); - extern void cproc_prepare(); - extern void cthread_body(); - thread_t n; - - alloc_stack(child); - spin_lock(&n_kern_lock); - if (cthread_max_kernel_threads == 0 || - cthread_kernel_threads < cthread_max_kernel_threads) { - tcbhead_t *tcb = _dl_allocate_tls(NULL); - cthread_kernel_threads++; - spin_unlock(&n_kern_lock); - MACH_CALL(thread_create(mach_task_self(), &n), r); - cproc_setup(child, n, tcb, cthread_body); /* machine dependent */ - MACH_CALL(thread_resume(n), r); -#ifdef STATISTICS - spin_lock(&ready_lock); - cthread_running++; - spin_unlock(&ready_lock); -#endif /* STATISTICS */ - } else { - vm_offset_t stack; - spin_unlock(&n_kern_lock); - child->state = CPROC_BLOCKED; - /* The original CMU code does the excessively clever - optimization of putting CHILD at the base of the stack - and setting up to be the argument to cthread_body in the - same place (by passing zero as the second arg to - cproc_stack_base here).. This doesn't fly for GNU, - because we need some more space allocated at the base of - the stack, after the cproc_self pointer (where CHILD is - stored). */ - stack = cproc_stack_base(child, - sizeof(ur_cthread_t *) + - /* Account for GNU per-thread - variables. */ - __hurd_threadvar_max * - sizeof (long int)); - cproc_prepare(child, &child->context, stack, &cthread_body); - /* Set up the cproc_self ptr at the base of CHILD's stack. */ - ur_cthread_ptr(stack) = (ur_cthread_t) child; - cproc_ready(child,0); - } - return child; -} - -void -condition_wait(condition_t c, mutex_t m) -{ - register cproc_t p = cproc_self(); - - p->state = CPROC_CONDWAIT | CPROC_SWITCHING; - - spin_lock(&c->lock); - cthread_queue_enq(&c->queue, p); - spin_unlock(&c->lock); -#ifdef WAIT_DEBUG - p->waiting_for = (char *)c; -#endif /* WAIT_DEBUG */ - - mutex_unlock(m); - - spin_lock(&p->lock); - if (p->state & CPROC_SWITCHING) { - cproc_block(); - } else { - p->state = CPROC_RUNNING; - spin_unlock(&p->lock); - } - - -#ifdef WAIT_DEBUG - p->waiting_for = (char *)0; -#endif /* WAIT_DEBUG */ - - /* - * Re-acquire the mutex and return. - */ - mutex_lock(m); -} - -/* Declare that IMPLICATOR should consider IMPLICATAND's waiter queue - to be an extension of its own queue. It is an error for either - condition to be deallocated as long as the implication persists. */ -void -condition_implies (condition_t implicator, condition_t implicatand) -{ - struct cond_imp *imp; - - imp = malloc (sizeof (struct cond_imp)); - imp->implicatand = implicatand; - imp->next = implicator->implications; - implicator->implications = imp; -} - -/* Declare that the implication relationship from IMPLICATOR to - IMPLICATAND should cease. */ -void -condition_unimplies (condition_t implicator, condition_t implicatand) -{ - struct cond_imp **impp; - - for (impp = &implicator->implications; *impp; impp = &(*impp)->next) - { - if ((*impp)->implicatand == implicatand) - { - struct cond_imp *tmp = *impp; - *impp = (*impp)->next; - free (tmp); - return; - } - } -} - -/* Signal one waiter on C. If there were no waiters at all, return - 0, else return 1. */ -int -cond_signal(condition_t c) -{ - register cproc_t p; - struct cond_imp *imp; - - spin_lock(&c->lock); - cthread_queue_deq(&c->queue, cproc_t, p); - spin_unlock(&c->lock); - if (p != NO_CPROC) { - cproc_ready(p,0); - return 1; - } - else { - for (imp = c->implications; imp; imp = imp->next) - if (cond_signal (imp->implicatand)) - return 1; - } - return 0; -} - -void -cond_broadcast(condition_t c) -{ - register cproc_t p; - struct cthread_queue blocked_queue; - struct cond_imp *imp; - - cthread_queue_init(&blocked_queue); - - spin_lock(&c->lock); - for (;;) { - cthread_queue_deq(&c->queue, cproc_t, p); - if (p == NO_CPROC) - break; - cthread_queue_enq(&blocked_queue, p); - } - spin_unlock(&c->lock); - - for(;;) { - cthread_queue_deq(&blocked_queue, cproc_t, p); - if (p == NO_CPROC) - break; - cproc_ready(p,0); - } - - for (imp = c->implications; imp; imp = imp->next) - condition_broadcast (imp->implicatand); -} - -void -cthread_yield(void) -{ - register cproc_t new, p = cproc_self(); - - if (p->wired != MACH_PORT_NULL) { - yield(); - return; - } - spin_lock(&ready_lock); -#ifdef STATISTICS - cthread_yields++; -#endif /* STATISTICS */ - cthread_queue_deq(&ready, cproc_t, new); - if (new) { - cthread_queue_enq(&ready, p); - spin_lock(&p->lock); - p->state = CPROC_BLOCKED; - spin_unlock(&ready_lock); - spin_lock(&new->lock); - new->state = CPROC_RUNNING; - spin_unlock(&new->lock); - cproc_switch(&p->context,&new->context,&p->lock); - } else { - spin_unlock(&ready_lock); - yield(); - } -} - -/* - * Mutex objects. - */ - -void -__mutex_lock_solid(void *ptr) -{ - register mutex_t m = ptr; - register cproc_t p = cproc_self(); - register int queued; - register int tried = 0; - -#ifdef WAIT_DEBUG - p->waiting_for = (char *)m; -#endif /* WAIT_DEBUG */ - while (1) { - spin_lock(&m->lock); - if (cthread_queue_head(&m->queue, cproc_t) == NO_CPROC) { - cthread_queue_enq(&m->queue, p); - queued = 1; - } else { - queued = 0; - } - if (spin_try_lock(&m->held)) { - if (queued) cthread_queue_deq(&m->queue, cproc_t, p); - spin_unlock(&m->lock); -#ifdef WAIT_DEBUG - p->waiting_for = (char *)0; -#endif /* WAIT_DEBUG */ - return; - } else { - if (!queued) cthread_queue_enq(&m->queue, p); - spin_lock(&p->lock); - spin_unlock(&m->lock); - cproc_block(); - if (spin_try_lock(&m->held)) { -#ifdef WAIT_DEBUG - p->waiting_for = (char *)0; -#endif /* WAIT_DEBUG */ - return; - } -#ifdef STATISTICS - spin_lock(&mutex_count_lock); - cthread_no_mutex++; - spin_unlock(&mutex_count_lock); -#endif /* STATISTICS */ - } - } -} - -void -__mutex_unlock_solid(void *ptr) -{ - register mutex_t m = ptr; - register cproc_t new; - - if (!spin_try_lock(&m->held)) - return; - spin_lock(&m->lock); - cthread_queue_deq(&m->queue, cproc_t, new); - spin_unlock(&m->held); - spin_unlock(&m->lock); - if (new) { - cproc_ready(new,0); - } -} - - -/* - * Use instead of mach_msg in a multi-threaded server so as not - * to tie up excessive kernel threads. This uses a simple linked list for - * ports since this should never be more than a few. - */ - -/* - * A cthread holds a reference to a port_entry even after it receives a - * message. This reference is not released until the thread does a - * cthread_msg_busy. This allows the fast case of a single mach_msg - * call to occur as often as is possible. - */ - -private port_entry_t -get_port_entry(mach_port_t port, int min, int max) -{ - register port_entry_t i; - - spin_lock(&port_lock); - for(i=port_list;i!=PORT_ENTRY_NULL;i=i->next) - if (i->port == port) { - spin_unlock(&port_lock); - return i; - } - i = (port_entry_t)malloc(sizeof(struct port_entry)); - cthread_queue_init(&i->queue); - i->port = port; - i->next = port_list; - port_list = i; - i->min = min; - i->max = max; - i->held = 0; - spin_lock_init(&i->lock); - spin_unlock(&port_lock); - return i; -} - -void -cthread_msg_busy(mach_port_t port, int min, int max) -{ - register port_entry_t port_entry; - register cproc_t new, p = cproc_self(); - - if (p->busy) { - port_entry = get_port_entry(port, min, max); - spin_lock(&port_entry->lock); - p->busy = 0; - if (port_entry->held <= port_entry->min) { - cthread_queue_deq(&port_entry->queue, cproc_t, new); - if (new != NO_CPROC){ - spin_unlock(&port_entry->lock); - cproc_ready(new,0); - } else { - port_entry->held--; - spin_unlock(&port_entry->lock); -#ifdef STATISTICS - spin_lock(&port_lock); - cthread_rnone++; - spin_unlock(&port_lock); -#endif /* STATISTICS */ - } - } else { - port_entry->held--; - spin_unlock(&port_entry->lock); - } - } - -} - -void -cthread_msg_active(mach_port_t port, int min, int max) -{ - register cproc_t p = cproc_self(); - register port_entry_t port_entry; - - if (!p->busy) { - port_entry = get_port_entry(port, min, max); - if (port_entry == 0) return; - spin_lock(&port_entry->lock); - if (port_entry->held < port_entry->max) { - port_entry->held++; - p->busy = port_entry; - } - spin_unlock(&port_entry->lock); - } -} - -mach_msg_return_t -cthread_mach_msg(register mach_msg_header_t *header, - register mach_msg_option_t option, mach_msg_size_t send_size, - mach_msg_size_t rcv_size, register mach_port_t rcv_name, - mach_msg_timeout_t timeout, mach_port_t notify, int min, - int max) -{ - register port_entry_t port_entry; - register cproc_t p = cproc_self(); - register int sent=0; - mach_msg_return_t r; - port_entry_t op = (port_entry_t)p->busy; - - port_entry = get_port_entry(rcv_name, min, max); - - if (op && (port_entry_t)op != port_entry) - cthread_msg_busy(op->port, op->min, op->max); - spin_lock(&port_entry->lock); - if (!(port_entry == (port_entry_t)p->busy)) { - if (port_entry->held >= max) { - if (option & MACH_SEND_MSG) { - spin_unlock(&port_entry->lock); - r = mach_msg(header, option &~ MACH_RCV_MSG, - send_size, 0, MACH_PORT_NULL, - timeout, notify); - if (r != MACH_MSG_SUCCESS) return r; - spin_lock(&port_entry->lock); - sent=1; - } - if (port_entry->held >= max) { - spin_lock(&p->lock); - cthread_queue_preq(&port_entry->queue, p); - spin_unlock(&port_entry->lock); -#ifdef WAIT_DEBUG - p->waiting_for = (char *)port_entry; -#endif /* WAIT_DEBUG */ - cproc_block(); - } else { - port_entry->held++; - spin_unlock(&port_entry->lock); - } - } else { - port_entry->held++; - spin_unlock(&port_entry->lock); - } - } else { - spin_unlock(&port_entry->lock); - } -#ifdef WAIT_DEBUG - p->waiting_for = (char *)0; -#endif /* WAIT_DEBUG */ - p->busy = port_entry; - if ((option & MACH_SEND_MSG) && !sent) { - r = mach_msg(header, option, - send_size, rcv_size, rcv_name, - timeout, notify); - } else { - r = mach_msg(header, option &~ MACH_SEND_MSG, - 0, rcv_size, rcv_name, - timeout, notify); - } - return r; -} - -void -cproc_fork_prepare(void) -{ - register cproc_t p = cproc_self(); - - vm_inherit(mach_task_self(),p->stack_base, p->stack_size, VM_INHERIT_COPY); - spin_lock(&port_lock); - spin_lock(&cproc_list_lock); -} - -void -cproc_fork_parent(void) -{ - register cproc_t p = cproc_self(); - - spin_unlock(&cproc_list_lock); - spin_unlock(&port_lock); - vm_inherit(mach_task_self(),p->stack_base, p->stack_size, VM_INHERIT_NONE); -} - -void -cproc_fork_child(void) -{ - register cproc_t l,p = cproc_self(); - cproc_t m; - register port_entry_t pe; - port_entry_t pet; - kern_return_t r; - - - vm_inherit(mach_task_self(),p->stack_base, p->stack_size, VM_INHERIT_NONE); - spin_lock_init(&n_kern_lock); - cthread_kernel_threads=0; -#ifdef STATISTICS - cthread_ready = 0; - cthread_running = 1; - cthread_waiting = 0; - cthread_wired = 0; - spin_lock_init(&wired_lock); - cthread_wait_stacks = 0; - cthread_waiters = 0; - cthread_wakeup = 0; - cthread_blocked = 0; - cthread_rnone = 0; - cthread_yields = 0; - cthread_none = 0; - cthread_switches = 0; - cthread_no_mutex = 0; - spin_lock_init(&mutex_count_lock); -#endif /* STATISTICS */ - - for(l=cproc_list;l!=NO_CPROC;l=m) { - m=l->next; - if (l!=p) - free(l); - } - - cproc_list = p; - p->next = NO_CPROC; - spin_lock_init(&cproc_list_lock); - cprocs_started = FALSE; - cthread_queue_init(&ready); - ready_count = 0; - spin_lock_init(&ready_lock); - - MACH_CALL(mach_port_allocate(mach_task_self(), - MACH_PORT_RIGHT_RECEIVE, - &wait_port), r); - MACH_CALL(mach_port_insert_right(mach_task_self(), - wait_port, wait_port, - MACH_MSG_TYPE_MAKE_SEND), r); - wakeup_msg.msgh_remote_port = wait_port; - wait_count = 0; - cthread_queue_init(&waiters); - spin_lock_init(&waiters_lock); - for(pe=port_list;pe!=PORT_ENTRY_NULL;pe=pet) { - pet = pe->next; - free(pe); - } - port_list = PORT_ENTRY_NULL; - spin_lock_init(&port_lock); - - if (p->wired) cthread_wire(); -} |