Source to osfmk/kern/thread_pool.c
/*
* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* The contents of this file constitute Original Code as defined in and
* are subject to the Apple Public Source License Version 1.1 (the
* "License"). You may not use this file except in compliance with the
* License. Please obtain a copy of the License at
* http://www.apple.com/publicsource and read it before using this file.
*
* This Original Code and all software distributed under the License are
* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
* License for the specific language governing rights and limitations
* under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/*
* @OSF_FREE_COPYRIGHT@
*/
/*
* HISTORY
*
* Revision 1.1.1.1 1998/09/22 21:05:32 wsanchez
* Import of Mac OS X kernel (~semeria)
*
* Revision 1.1.1.1 1998/03/07 02:25:57 wsanchez
* Import of OSF Mach kernel (~mburg)
*
* Revision 1.1.7.6 1995/08/21 20:44:57 devrcs
* Fix ri-osc CR1405: Zero act->thread_pool_next when act not on pool.
* [1995/07/25 20:19:06 bolinger]
*
* Revision 1.1.7.5 1995/01/18 18:35:00 ezf
* updated Utah CR notice
* [1995/01/18 18:30:33 ezf]
*
* Revision 1.1.7.4 1995/01/10 05:15:20 devrcs
* mk6 CR801 - merge up from nmk18b4 to nmk18b7
* Comments from merged code below, as marked
* [1994/12/09 21:10:54 dwm]
*
* mk6 CR668 - 1.3b26 merge
* event_t casts
* [1994/11/04 09:39:15 dwm]
*
* Revision 1.1.7.3 1994/11/23 16:01:15 devrcs
* BEGIN comments from merge of nmk18b4 - nmk18b7
* Cleared `handlers' field of activation when returning
* it to thread pool.
* [1994/11/23 03:48:31 burke]
*
* Added an assert to `thread_pool_put_act()' to check
* for presence of handlers when returning an activation
* to its pool.
* [1994/11/18 13:36:29 rkc]
*
* Changed `thread_pool_put_act()'s call to `act_set_thread_pool()' to
* be a call to `act_locked_act_set_thread_pool()' to obey locking
* assumptions.
* [1994/11/10 23:29:51 rkc]
*
* Cosmetic changes to thread_pool_put_act.
* [1994/11/09 21:49:57 watkins]
*
* Check out for merge.
* [1994/11/09 14:16:43 watkins]
*
* Revision 1.1.9.2 1994/11/08 15:32:42 watkins
* Add thread_pool_put_act.
* END comments from merge of nmk18b4 - nmk18b7
* [1994/11/09 14:16:33 watkins]
*
* Revision 1.1.7.2 1994/09/23 02:31:05 ezf
* change marker to not FREE
* [1994/09/22 21:38:01 ezf]
*
* Revision 1.1.7.1 1994/09/02 02:40:54 watkins
* Check for destroyed thread pool port after thread_pool_get_act
* blocks.
* [1994/09/02 02:37:46 watkins]
*
* Revision 1.1.2.8 1994/06/09 14:14:04 dswartz
* Preemption merge.
* [1994/06/09 14:08:35 dswartz]
*
* Revision 1.1.2.7 1994/06/01 19:30:10 bolinger
* mk6 CR125: Update to reflect new naming for thread_pool of
* thread_act.
* [1994/06/01 19:14:46 bolinger]
*
* Revision 1.1.2.6 1994/03/17 22:38:34 dwm
* The infamous name change: thread_activation + thread_shuttle = thread.
* [1994/03/17 21:28:15 dwm]
*
* Revision 1.1.2.5 1994/02/09 00:42:29 dwm
* Put a variety of debugging code under MACH_ASSERT,
* to enhance PROD performance a bit.
* [1994/02/09 00:35:07 dwm]
*
* Revision 1.1.2.4 1994/02/04 03:46:25 condict
* Put if MACH_ASSERT around debugging printfs.
* [1994/02/04 03:44:10 condict]
*
* Revision 1.1.2.3 1994/01/21 23:45:15 dwm
* Thread_pools now embedded directly in port/pset.
* Adjust thread_pool_create.
* [1994/01/21 23:43:18 dwm]
*
* Revision 1.1.2.2 1994/01/14 18:42:01 bolinger
* Rename thread_pool_block() to thread_pool_get_act() [sic], to
* better reflect its function. Add leading comment and assertion
* checks.
* [1994/01/14 18:18:11 bolinger]
*
* Revision 1.1.2.1 1994/01/12 17:53:17 dwm
* Coloc: initial restructuring to follow Utah model.
* [1994/01/12 17:15:21 dwm]
*
* $EndLog$
*/
/*
* Copyright (c) 1993 The University of Utah and
* the Computer Systems Laboratory (CSL). 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.
*
* THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
* IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
* ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* CSL requests users of this software to return to [email protected] any
* improvements that they make and grant CSL redistribution rights.
*
* Author: Bryan Ford, University of Utah CSL
*
* File: thread_pool.c
*
* thread_pool management routines
*
*/
#include <kern/ipc_mig.h>
#include <kern/ipc_tt.h>
#include <kern/mach_param.h>
#include <kern/machine.h>
#include <kern/misc_protos.h>
#include <kern/processor.h>
#include <kern/queue.h>
#include <kern/sched.h>
#include <kern/sched_prim.h>
#include <kern/task.h>
#include <kern/thread_act.h>
#include <mach/kern_return.h>
#include <kern/thread_pool.h>
#include <kern/thread.h>
#include <kern/zalloc.h>
#include <kern/misc_protos.h>
#include <kern/sched_prim.h>
/* Initialize a new EMPTY thread_pool. */
kern_return_t
thread_pool_init(thread_pool_t new_thread_pool)
{
assert(new_thread_pool != THREAD_POOL_NULL);
/* Start with one reference for the caller */
new_thread_pool->thr_acts = (struct thread_activation *)0;
return KERN_SUCCESS;
}
/*
* Obtain an activation from a thread pool, blocking if
* necessary. Return the activation locked, since it's
* in an inconsistent state (not in a pool, not attached
* to a thread).
*
* Called with ip_lock() held for pool_port. Returns
* the same way.
*
* If the thread pool port is destroyed while we are blocked,
* then return a null activation. Callers must check for this
* error case.
*/
thread_act_t
thread_pool_get_act(ipc_port_t pool_port)
{
thread_pool_t thread_pool = &pool_port->ip_thread_pool;
thread_act_t thr_act;
#if MACH_ASSERT
assert(thread_pool != THREAD_POOL_NULL);
if (watchacts & WA_ACT_LNK)
printf("thread_pool_block: %x, waiting=%d\n",
thread_pool, thread_pool->waiting);
#endif
while ((thr_act = thread_pool->thr_acts) == THR_ACT_NULL) {
if (!ip_active(pool_port))
return THR_ACT_NULL;
thread_pool->waiting = 1;
assert_wait((event_t)thread_pool, THREAD_INTERRUPTIBLE);
ip_unlock(pool_port);
thread_block((void (*)(void)) 0); /* block self */
ip_lock(pool_port);
}
assert(thr_act->thread == THREAD_NULL);
assert(thr_act->suspend_count == 0);
thread_pool->thr_acts = thr_act->thread_pool_next;
act_lock(thr_act);
thr_act->thread_pool_next = 0;
#if MACH_ASSERT
if (watchacts & WA_ACT_LNK)
printf("thread_pool_block: return %x, next=%x\n",
thr_act, thread_pool->thr_acts);
#endif
return thr_act;
}
/*
* thread_pool_put_act
*
* Return an activation to its pool. Assumes the activation
* and pool (if it exists) are locked.
*/
void
thread_pool_put_act( thread_act_t thr_act )
{
thread_pool_t thr_pool;
/*
* Find the thread pool for this activation.
*/
if (thr_act->pool_port)
thr_pool = &thr_act->pool_port->ip_thread_pool;
else
thr_pool = THREAD_POOL_NULL;
/*
* Return act to the thread_pool's list, if it is still
* alive. Otherwise, remove it from its thread_pool, which
* will deallocate it and destroy it.
*/
if (thr_act->active) {
assert(thr_pool);
thr_act->handlers = NULL;
thr_act->thread_pool_next = thr_pool->thr_acts;
thr_pool->thr_acts = thr_act;
if (thr_pool->waiting)
thread_pool_wakeup(thr_pool);
} else if (thr_pool) {
assert(thr_act->pool_port);
act_locked_act_set_thread_pool(thr_act, IP_NULL);
}
return;
}
/*
* Called with ip_lock() held for port containing thread_pool.
* Returns same way.
*/
void
thread_pool_wakeup(thread_pool_t thread_pool)
{
#if MACH_ASSERT
assert(thread_pool != THREAD_POOL_NULL);
if (watchacts & WA_ACT_LNK)
printf("thread_pool_wakeup: %x, waiting=%d, head=%x\n",
thread_pool, thread_pool->waiting, thread_pool->thr_acts);
#endif /* MACH_ASSERT */
if (thread_pool->waiting) {
thread_wakeup((event_t)thread_pool);
thread_pool->waiting = 0;
}
}