xnu-123.5.tar.gz

[apple/xnu.git] / 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 csl-dist@cs.utah.edu 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;
	}
}