[apple/xnu.git] / osfmk / kern / wait_queue.h

/*
 * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

#ifdef	KERNEL_PRIVATE

#ifndef _KERN_WAIT_QUEUE_H_
#define _KERN_WAIT_QUEUE_H_

#include <mach/mach_types.h>
#include <mach/sync_policy.h>
#include <mach/kern_return.h>		/* for kern_return_t */

#include <kern/kern_types.h>		/* for wait_queue_t */

#include <sys/cdefs.h>

#ifdef	MACH_KERNEL_PRIVATE

#include <kern/lock.h>
#include <kern/queue.h>
#include <machine/cpu_number.h>

/*
 *	wait_queue_t
 *	This is the definition of the common event wait queue
 *	that the scheduler APIs understand.  It is used
 *	internally by the gerneralized event waiting mechanism
 *	(assert_wait), and also for items that maintain their
 *	own wait queues (such as ports and semaphores).
 *
 *	It is not published to other kernel components.  They
 *	can create wait queues by calling wait_queue_alloc.
 *
 *	NOTE:  Hardware locks are used to protect event wait
 *	queues since interrupt code is free to post events to
 *	them.
 */
typedef struct wait_queue {
    unsigned int                    /* flags */
    /* boolean_t */	wq_type:16,		/* only public field */
					wq_fifo:1,		/* fifo wakeup policy? */
					wq_isprepost:1,	/* is waitq preposted? set only */
					:0;				/* force to long boundary */
    hw_lock_data_t	wq_interlock;	/* interlock */
    queue_head_t	wq_queue;		/* queue of elements */
} WaitQueue;

/*
 *	wait_queue_set_t
 *	This is the common definition for a set wait queue.
 *	These can be linked as members/elements of multiple regular
 *	wait queues.  They have an additional set of linkages to
 *	identify the linkage structures that point to them.
 */
typedef struct wait_queue_set {
	WaitQueue		wqs_wait_queue; /* our wait queue */
	queue_head_t	wqs_setlinks;	/* links from set perspective */
	unsigned int 	wqs_refcount;	/* refcount for preposting */
} WaitQueueSet;

#define wqs_type		wqs_wait_queue.wq_type
#define wqs_fifo		wqs_wait_queue.wq_fifo
#define wqs_isprepost	wqs_wait_queue.wq_isprepost
#define wqs_queue		wqs_wait_queue.wq_queue

/*
 *	wait_queue_element_t
 *	This structure describes the elements on an event wait
 *	queue.  It is the common first fields in a thread shuttle
 *	and wait_queue_link_t.  In that way, a wait queue can
 *	consist of both thread shuttle elements and links off of
 *	to other (set) wait queues.
 *
 *	WARNING: These fields correspond to fields in the thread
 *	shuttle (run queue links and run queue pointer). Any change in
 *	the layout here will have to be matched with a change there.
 */
typedef struct wait_queue_element {
	queue_chain_t	wqe_links;	/* link of elements on this queue */
	void *			wqe_type;	/* Identifies link vs. thread */
	wait_queue_t	wqe_queue;	/* queue this element is on */
} WaitQueueElement;

typedef WaitQueueElement *wait_queue_element_t;

/*
 *	wait_queue_link_t
 *	Specialized wait queue element type for linking set
 *	event waits queues onto a wait queue.  In this way, an event
 *	can be constructed so that any thread waiting on any number
 *	of associated wait queues can handle the event, while letting
 *	the thread only be linked on the single wait queue it blocked on.
 *
 *	One use: ports in multiple portsets.  Each thread is queued up
 *	on the portset that it specifically blocked on during a receive
 *	operation.  Each port's event queue links in all the portset
 *	event queues of which it is a member.  An IPC event post associated
 *	with that port may wake up any thread from any of those portsets,
 *	or one that was waiting locally on the port itself.
 */
typedef struct _wait_queue_link {
	WaitQueueElement		wql_element;	/* element on master */
	queue_chain_t			wql_setlinks;	/* element on set */
    wait_queue_set_t		wql_setqueue;	/* set queue */
} WaitQueueLink;

#define wql_links wql_element.wqe_links
#define wql_type  wql_element.wqe_type
#define wql_queue wql_element.wqe_queue

#define _WAIT_QUEUE_inited			0xf1d0
#define _WAIT_QUEUE_SET_inited		0xf1d1

#define wait_queue_is_queue(wq)	\
	((wq)->wq_type == _WAIT_QUEUE_inited)

#define wait_queue_is_set(wqs)	\
	((wqs)->wqs_type == _WAIT_QUEUE_SET_inited)

#define wait_queue_is_valid(wq)	\
	(((wq)->wq_type & ~1) == _WAIT_QUEUE_inited)

#define wait_queue_empty(wq)	(queue_empty(&(wq)->wq_queue))

#define wait_queue_held(wq)		(hw_lock_held(&(wq)->wq_interlock))
#define wait_queue_lock_try(wq) (hw_lock_try(&(wq)->wq_interlock))

/* For x86, the hardware timeout is in TSC units. */
#if defined(i386)
#define	hwLockTimeOut LockTimeOutTSC
#else
#define	hwLockTimeOut LockTimeOut
#endif
/*
 * Double the standard lock timeout, because wait queues tend
 * to iterate over a number of threads - locking each.  If there is
 * a problem with a thread lock, it normally times out at the wait
 * queue level first, hiding the real problem.
 */

static inline void wait_queue_lock(wait_queue_t wq) {
	if (!hw_lock_to(&(wq)->wq_interlock, hwLockTimeOut * 2))
		panic("wait queue deadlock - wq=%p, cpu=%d\n", wq, cpu_number(
));
}
 
static inline void wait_queue_unlock(wait_queue_t wq) {
	assert(wait_queue_held(wq));
#if defined(__i386__)
	/* DRK: On certain x86 systems, this spinlock is susceptible to
	 * lock starvation. Hence use an unlock variant which performs
	 * a cacheline flush to minimize cache affinity on acquisition.
	 */
	i386_lock_unlock_with_flush(&(wq)->wq_interlock);
#else
	hw_lock_unlock(&(wq)->wq_interlock);
#endif
}

#define wqs_lock(wqs)		wait_queue_lock(&(wqs)->wqs_wait_queue)
#define wqs_unlock(wqs)		wait_queue_unlock(&(wqs)->wqs_wait_queue)
#define wqs_lock_try(wqs)	wait_queue__try_lock(&(wqs)->wqs_wait_queue)

#define wait_queue_assert_possible(thread) \
			((thread)->wait_queue == WAIT_QUEUE_NULL)

/******** Decomposed interfaces (to build higher level constructs) ***********/

/* assert intent to wait on a locked wait queue */
__private_extern__ wait_result_t wait_queue_assert_wait64_locked(
			wait_queue_t wait_queue,
			event64_t wait_event,
			wait_interrupt_t interruptible,
			uint64_t deadline,
			thread_t thread);

/* pull a thread from its wait queue */
__private_extern__ void wait_queue_pull_thread_locked(
			wait_queue_t wait_queue,
			thread_t thread,
			boolean_t unlock);

/* wakeup all threads waiting for a particular event on locked queue */
__private_extern__ kern_return_t wait_queue_wakeup64_all_locked(
			wait_queue_t wait_queue,
			event64_t wake_event,
			wait_result_t result,
			boolean_t unlock);

/* wakeup one thread waiting for a particular event on locked queue */
__private_extern__ kern_return_t wait_queue_wakeup64_one_locked(
			wait_queue_t wait_queue,
			event64_t wake_event,
			wait_result_t result,
			boolean_t unlock);

/* return identity of a thread awakened for a particular <wait_queue,event> */
__private_extern__ thread_t wait_queue_wakeup64_identity_locked(
			wait_queue_t wait_queue,
			event64_t wake_event,
			wait_result_t result,
			boolean_t unlock);

/* wakeup thread iff its still waiting for a particular event on locked queue */
__private_extern__ kern_return_t wait_queue_wakeup64_thread_locked(
			wait_queue_t wait_queue,
			event64_t wake_event,
			thread_t thread,
			wait_result_t result,
			boolean_t unlock);

#endif	/* MACH_KERNEL_PRIVATE */

__BEGIN_DECLS

/******** Semi-Public interfaces (not a part of a higher construct) ************/

extern unsigned int wait_queue_set_size(void);
extern unsigned int wait_queue_link_size(void);

extern kern_return_t wait_queue_init(
			wait_queue_t wait_queue,
			int policy);

extern wait_queue_set_t wait_queue_set_alloc(
			int policy);

extern kern_return_t wait_queue_set_init(
			wait_queue_set_t set_queue,
			int policy);

extern kern_return_t wait_queue_set_free(
			wait_queue_set_t set_queue);

extern wait_queue_link_t wait_queue_link_alloc(
			int policy);

extern kern_return_t wait_queue_link_free(
			wait_queue_link_t link_element);

extern kern_return_t wait_queue_link(
			wait_queue_t wait_queue,
			wait_queue_set_t set_queue);

extern kern_return_t wait_queue_link_noalloc(
			wait_queue_t wait_queue,
			wait_queue_set_t set_queue,
			wait_queue_link_t link);

extern boolean_t wait_queue_member(
			wait_queue_t wait_queue,
			wait_queue_set_t set_queue);

extern kern_return_t wait_queue_unlink(
			wait_queue_t wait_queue,
			wait_queue_set_t set_queue);

extern kern_return_t wait_queue_unlink_all(
			wait_queue_t wait_queue);

extern kern_return_t wait_queue_unlinkall_nofree(
			wait_queue_t wait_queue);

extern kern_return_t wait_queue_set_unlink_all(
			wait_queue_set_t set_queue);

/* legacy API */
kern_return_t wait_queue_sub_init(
			wait_queue_set_t set_queue,
			int policy);

kern_return_t wait_queue_sub_clearrefs(
			wait_queue_set_t wq_set);

extern kern_return_t wait_subqueue_unlink_all(
			wait_queue_set_t set_queue);

extern wait_queue_t wait_queue_alloc(
			int policy);

extern kern_return_t wait_queue_free(
			wait_queue_t wait_queue);

/* assert intent to wait on <wait_queue,event64> pair */
extern wait_result_t wait_queue_assert_wait64(
			wait_queue_t wait_queue,
			event64_t wait_event,
			wait_interrupt_t interruptible,
			uint64_t deadline);

/* wakeup the most appropriate thread waiting on <wait_queue,event64> pair */
extern kern_return_t wait_queue_wakeup64_one(
			wait_queue_t wait_queue,
			event64_t wake_event,
			wait_result_t result);

/* wakeup all the threads waiting on <wait_queue,event64> pair */
extern kern_return_t wait_queue_wakeup64_all(
			wait_queue_t wait_queue,
			event64_t wake_event,
			wait_result_t result);

/* wakeup a specified thread waiting iff waiting on <wait_queue,event64> pair */
extern kern_return_t wait_queue_wakeup64_thread(
			wait_queue_t wait_queue,
			event64_t wake_event,
			thread_t thread,
			wait_result_t result);

/*
 * Compatibility Wait Queue APIs based on pointer events instead of 64bit
 * integer events.
 */

/* assert intent to wait on <wait_queue,event> pair */
extern wait_result_t wait_queue_assert_wait(
			wait_queue_t wait_queue,
			event_t wait_event,
			wait_interrupt_t interruptible,
			uint64_t deadline);

/* wakeup the most appropriate thread waiting on <wait_queue,event> pair */
extern kern_return_t wait_queue_wakeup_one(
			wait_queue_t wait_queue,
			event_t wake_event,
			wait_result_t result);

/* wakeup all the threads waiting on <wait_queue,event> pair */
extern kern_return_t wait_queue_wakeup_all(
			wait_queue_t wait_queue,
			event_t wake_event,
			wait_result_t result);

/* wakeup a specified thread waiting iff waiting on <wait_queue,event> pair */
extern kern_return_t wait_queue_wakeup_thread(
			wait_queue_t wait_queue,
			event_t wake_event,
			thread_t thread,
			wait_result_t result);

__END_DECLS

#endif	/* _KERN_WAIT_QUEUE_H_ */

#endif	/* KERNEL_PRIVATE */
Commit	Line	Data
1c79356b	1	/*
91447636	2	* Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b	27	*/
1c79356b	28
91447636	29	#ifdef KERNEL_PRIVATE
9bccf70c	30
91447636 A	31	#ifndef _KERN_WAIT_QUEUE_H_
91447636 A	32	#define _KERN_WAIT_QUEUE_H_
9bccf70c	33
91447636	34	#include <mach/mach_types.h>
1c79356b	35	#include <mach/sync_policy.h>
0b4e3aa0	36	#include <mach/kern_return.h> /* for kern_return_t */
1c79356b	37
9bccf70c A	38	#include <kern/kern_types.h> /* for wait_queue_t */
9bccf70c A	39
91447636 A	40	#include <sys/cdefs.h>
	41
	42	#ifdef MACH_KERNEL_PRIVATE
1c79356b A	43
	44	#include <kern/lock.h>
	45	#include <kern/queue.h>
91447636	46	#include <machine/cpu_number.h>
9bccf70c	47
1c79356b A	48	/*
	49	* wait_queue_t
	50	* This is the definition of the common event wait queue
	51	* that the scheduler APIs understand. It is used
	52	* internally by the gerneralized event waiting mechanism
	53	* (assert_wait), and also for items that maintain their
	54	* own wait queues (such as ports and semaphores).
	55	*
	56	* It is not published to other kernel components. They
	57	* can create wait queues by calling wait_queue_alloc.
	58	*
	59	* NOTE: Hardware locks are used to protect event wait
	60	* queues since interrupt code is free to post events to
	61	* them.
	62	*/
	63	typedef struct wait_queue {
9bccf70c A	64	unsigned int /* flags */
	65	/* boolean_t / wq_type:16, / only public field */
	66	wq_fifo:1, /* fifo wakeup policy? */
	67	wq_isprepost:1, /* is waitq preposted? set only */
	68	:0; /* force to long boundary */
1c79356b	69	hw_lock_data_t wq_interlock; /* interlock */
9bccf70c	70	queue_head_t wq_queue; /* queue of elements */
1c79356b A	71	} WaitQueue;
	72
	73	/*
9bccf70c A	74	* wait_queue_set_t
9bccf70c A	75	* This is the common definition for a set wait queue.
1c79356b A	76	* These can be linked as members/elements of multiple regular
	77	* wait queues. They have an additional set of linkages to
	78	* identify the linkage structures that point to them.
	79	*/
9bccf70c A	80	typedef struct wait_queue_set {
	81	WaitQueue wqs_wait_queue; /* our wait queue */
	82	queue_head_t wqs_setlinks; /* links from set perspective */
0b4e3aa0	83	unsigned int wqs_refcount; /* refcount for preposting */
9bccf70c	84	} WaitQueueSet;
1c79356b	85
9bccf70c A	86	#define wqs_type wqs_wait_queue.wq_type
	87	#define wqs_fifo wqs_wait_queue.wq_fifo
	88	#define wqs_isprepost wqs_wait_queue.wq_isprepost
	89	#define wqs_queue wqs_wait_queue.wq_queue
1c79356b A	90
	91	/*
	92	* wait_queue_element_t
	93	* This structure describes the elements on an event wait
	94	* queue. It is the common first fields in a thread shuttle
	95	* and wait_queue_link_t. In that way, a wait queue can
	96	* consist of both thread shuttle elements and links off of
9bccf70c	97	* to other (set) wait queues.
1c79356b	98	*
9bccf70c A	99	* WARNING: These fields correspond to fields in the thread
9bccf70c A	100	* shuttle (run queue links and run queue pointer). Any change in
1c79356b A	101	* the layout here will have to be matched with a change there.
	102	*/
	103	typedef struct wait_queue_element {
	104	queue_chain_t wqe_links; /* link of elements on this queue */
9bccf70c	105	void * wqe_type; /* Identifies link vs. thread */
1c79356b	106	wait_queue_t wqe_queue; /* queue this element is on */
9bccf70c	107	} WaitQueueElement;
1c79356b	108
9bccf70c	109	typedef WaitQueueElement *wait_queue_element_t;
0b4e3aa0	110
1c79356b A	111	/*
1c79356b A	112	* wait_queue_link_t
9bccf70c	113	* Specialized wait queue element type for linking set
1c79356b A	114	* event waits queues onto a wait queue. In this way, an event
	115	* can be constructed so that any thread waiting on any number
	116	* of associated wait queues can handle the event, while letting
	117	* the thread only be linked on the single wait queue it blocked on.
	118	*
	119	* One use: ports in multiple portsets. Each thread is queued up
	120	* on the portset that it specifically blocked on during a receive
	121	* operation. Each port's event queue links in all the portset
	122	* event queues of which it is a member. An IPC event post associated
	123	* with that port may wake up any thread from any of those portsets,
	124	* or one that was waiting locally on the port itself.
	125	*/
2d21ac55	126	typedef struct _wait_queue_link {
9bccf70c A	127	WaitQueueElement wql_element; /* element on master */
	128	queue_chain_t wql_setlinks; /* element on set */
	129	wait_queue_set_t wql_setqueue; /* set queue */
0b4e3aa0 A	130	} WaitQueueLink;
0b4e3aa0 A	131
1c79356b	132	#define wql_links wql_element.wqe_links
9bccf70c	133	#define wql_type wql_element.wqe_type
1c79356b	134	#define wql_queue wql_element.wqe_queue
0b4e3aa0	135
9bccf70c A	136	#define _WAIT_QUEUE_inited 0xf1d0
9bccf70c A	137	#define _WAIT_QUEUE_SET_inited 0xf1d1
0b4e3aa0	138
9bccf70c A	139	#define wait_queue_is_queue(wq) \
9bccf70c A	140	((wq)->wq_type == _WAIT_QUEUE_inited)
1c79356b	141
9bccf70c A	142	#define wait_queue_is_set(wqs) \
9bccf70c A	143	((wqs)->wqs_type == _WAIT_QUEUE_SET_inited)
1c79356b	144
9bccf70c A	145	#define wait_queue_is_valid(wq) \
9bccf70c A	146	(((wq)->wq_type & ~1) == _WAIT_QUEUE_inited)
1c79356b	147
9bccf70c	148	#define wait_queue_empty(wq) (queue_empty(&(wq)->wq_queue))
2d21ac55	149
9bccf70c A	150	#define wait_queue_held(wq) (hw_lock_held(&(wq)->wq_interlock))
9bccf70c A	151	#define wait_queue_lock_try(wq) (hw_lock_try(&(wq)->wq_interlock))
1c79356b	152
2d21ac55 A	153	/* For x86, the hardware timeout is in TSC units. */
	154	#if defined(i386)
	155	#define hwLockTimeOut LockTimeOutTSC
	156	#else
	157	#define hwLockTimeOut LockTimeOut
	158	#endif
9bccf70c A	159	/*
	160	* Double the standard lock timeout, because wait queues tend
	161	* to iterate over a number of threads - locking each. If there is
	162	* a problem with a thread lock, it normally times out at the wait
	163	* queue level first, hiding the real problem.
	164	*/
1c79356b	165
0c530ab8	166	static inline void wait_queue_lock(wait_queue_t wq) {
2d21ac55 A	167	if (!hw_lock_to(&(wq)->wq_interlock, hwLockTimeOut * 2))
	168	panic("wait queue deadlock - wq=%p, cpu=%d\n", wq, cpu_number(
	169	));
0c530ab8	170	}
2d21ac55	171
0c530ab8 A	172	static inline void wait_queue_unlock(wait_queue_t wq) {
	173	assert(wait_queue_held(wq));
	174	#if defined(__i386__)
2d21ac55	175	/* DRK: On certain x86 systems, this spinlock is susceptible to
0c530ab8 A	176	* lock starvation. Hence use an unlock variant which performs
	177	* a cacheline flush to minimize cache affinity on acquisition.
	178	*/
	179	i386_lock_unlock_with_flush(&(wq)->wq_interlock);
	180	#else
2d21ac55	181	hw_lock_unlock(&(wq)->wq_interlock);
0c530ab8 A	182	#endif
0c530ab8 A	183	}
1c79356b	184
9bccf70c A	185	#define wqs_lock(wqs) wait_queue_lock(&(wqs)->wqs_wait_queue)
	186	#define wqs_unlock(wqs) wait_queue_unlock(&(wqs)->wqs_wait_queue)
	187	#define wqs_lock_try(wqs) wait_queue__try_lock(&(wqs)->wqs_wait_queue)
1c79356b A	188
	189	#define wait_queue_assert_possible(thread) \
	190	((thread)->wait_queue == WAIT_QUEUE_NULL)
	191
1c79356b A	192	/****** Decomposed interfaces (to build higher level constructs) *********/
1c79356b A	193
1c79356b	194	/* assert intent to wait on a locked wait queue */
9bccf70c	195	__private_extern__ wait_result_t wait_queue_assert_wait64_locked(
1c79356b	196	wait_queue_t wait_queue,
9bccf70c A	197	event64_t wait_event,
9bccf70c A	198	wait_interrupt_t interruptible,
91447636	199	uint64_t deadline,
55e303ae	200	thread_t thread);
1c79356b	201
2d21ac55	202	/* pull a thread from its wait queue */
9bccf70c	203	__private_extern__ void wait_queue_pull_thread_locked(
1c79356b A	204	wait_queue_t wait_queue,
	205	thread_t thread,
	206	boolean_t unlock);
	207
	208	/* wakeup all threads waiting for a particular event on locked queue */
9bccf70c	209	__private_extern__ kern_return_t wait_queue_wakeup64_all_locked(
1c79356b	210	wait_queue_t wait_queue,
9bccf70c A	211	event64_t wake_event,
9bccf70c A	212	wait_result_t result,
1c79356b A	213	boolean_t unlock);
	214
	215	/* wakeup one thread waiting for a particular event on locked queue */
9bccf70c	216	__private_extern__ kern_return_t wait_queue_wakeup64_one_locked(
1c79356b	217	wait_queue_t wait_queue,
9bccf70c A	218	event64_t wake_event,
9bccf70c A	219	wait_result_t result,
1c79356b A	220	boolean_t unlock);
1c79356b A	221
1c79356b	222	/* return identity of a thread awakened for a particular <wait_queue,event> */
9bccf70c	223	__private_extern__ thread_t wait_queue_wakeup64_identity_locked(
1c79356b	224	wait_queue_t wait_queue,
9bccf70c A	225	event64_t wake_event,
9bccf70c A	226	wait_result_t result,
1c79356b A	227	boolean_t unlock);
	228
	229	/* wakeup thread iff its still waiting for a particular event on locked queue */
9bccf70c	230	__private_extern__ kern_return_t wait_queue_wakeup64_thread_locked(
1c79356b	231	wait_queue_t wait_queue,
9bccf70c	232	event64_t wake_event,
1c79356b	233	thread_t thread,
9bccf70c	234	wait_result_t result,
1c79356b A	235	boolean_t unlock);
1c79356b A	236
91447636 A	237	#endif /* MACH_KERNEL_PRIVATE */
	238
	239	__BEGIN_DECLS
1c79356b	240
9bccf70c A	241	/****** Semi-Public interfaces (not a part of a higher construct) **********/
9bccf70c A	242
91447636 A	243	extern unsigned int wait_queue_set_size(void);
	244	extern unsigned int wait_queue_link_size(void);
	245
9bccf70c A	246	extern kern_return_t wait_queue_init(
	247	wait_queue_t wait_queue,
	248	int policy);
	249
	250	extern wait_queue_set_t wait_queue_set_alloc(
	251	int policy);
	252
91447636 A	253	extern kern_return_t wait_queue_set_init(
	254	wait_queue_set_t set_queue,
	255	int policy);
	256
9bccf70c A	257	extern kern_return_t wait_queue_set_free(
	258	wait_queue_set_t set_queue);
	259
	260	extern wait_queue_link_t wait_queue_link_alloc(
	261	int policy);
	262
	263	extern kern_return_t wait_queue_link_free(
	264	wait_queue_link_t link_element);
	265
91447636 A	266	extern kern_return_t wait_queue_link(
	267	wait_queue_t wait_queue,
	268	wait_queue_set_t set_queue);
9bccf70c	269
91447636 A	270	extern kern_return_t wait_queue_link_noalloc(
	271	wait_queue_t wait_queue,
	272	wait_queue_set_t set_queue,
	273	wait_queue_link_t link);
1c79356b	274
91447636	275	extern boolean_t wait_queue_member(
9bccf70c A	276	wait_queue_t wait_queue,
	277	wait_queue_set_t set_queue);
	278
	279	extern kern_return_t wait_queue_unlink(
	280	wait_queue_t wait_queue,
	281	wait_queue_set_t set_queue);
	282
	283	extern kern_return_t wait_queue_unlink_all(
1c79356b A	284	wait_queue_t wait_queue);
1c79356b A	285
91447636 A	286	extern kern_return_t wait_queue_unlinkall_nofree(
	287	wait_queue_t wait_queue);
	288
9bccf70c A	289	extern kern_return_t wait_queue_set_unlink_all(
	290	wait_queue_set_t set_queue);
	291
91447636 A	292	/* legacy API */
	293	kern_return_t wait_queue_sub_init(
	294	wait_queue_set_t set_queue,
	295	int policy);
	296
	297	kern_return_t wait_queue_sub_clearrefs(
	298	wait_queue_set_t wq_set);
	299
	300	extern kern_return_t wait_subqueue_unlink_all(
	301	wait_queue_set_t set_queue);
	302
	303	extern wait_queue_t wait_queue_alloc(
	304	int policy);
	305
	306	extern kern_return_t wait_queue_free(
	307	wait_queue_t wait_queue);
	308
9bccf70c A	309	/* assert intent to wait on <wait_queue,event64> pair */
	310	extern wait_result_t wait_queue_assert_wait64(
	311	wait_queue_t wait_queue,
	312	event64_t wait_event,
91447636 A	313	wait_interrupt_t interruptible,
91447636 A	314	uint64_t deadline);
9bccf70c A	315
	316	/* wakeup the most appropriate thread waiting on <wait_queue,event64> pair */
	317	extern kern_return_t wait_queue_wakeup64_one(
	318	wait_queue_t wait_queue,
	319	event64_t wake_event,
	320	wait_result_t result);
	321
	322	/* wakeup all the threads waiting on <wait_queue,event64> pair */
	323	extern kern_return_t wait_queue_wakeup64_all(
	324	wait_queue_t wait_queue,
	325	event64_t wake_event,
	326	wait_result_t result);
	327
	328	/* wakeup a specified thread waiting iff waiting on <wait_queue,event64> pair */
	329	extern kern_return_t wait_queue_wakeup64_thread(
	330	wait_queue_t wait_queue,
	331	event64_t wake_event,
	332	thread_t thread,
	333	wait_result_t result);
	334
9bccf70c A	335	/*
	336	* Compatibility Wait Queue APIs based on pointer events instead of 64bit
	337	* integer events.
	338	*/
1c79356b A	339
1c79356b A	340	/* assert intent to wait on <wait_queue,event> pair */
9bccf70c	341	extern wait_result_t wait_queue_assert_wait(
1c79356b A	342	wait_queue_t wait_queue,
1c79356b A	343	event_t wait_event,
91447636 A	344	wait_interrupt_t interruptible,
91447636 A	345	uint64_t deadline);
1c79356b A	346
1c79356b A	347	/* wakeup the most appropriate thread waiting on <wait_queue,event> pair */
9bccf70c	348	extern kern_return_t wait_queue_wakeup_one(
1c79356b A	349	wait_queue_t wait_queue,
1c79356b A	350	event_t wake_event,
9bccf70c	351	wait_result_t result);
1c79356b A	352
1c79356b A	353	/* wakeup all the threads waiting on <wait_queue,event> pair */
9bccf70c	354	extern kern_return_t wait_queue_wakeup_all(
1c79356b A	355	wait_queue_t wait_queue,
1c79356b A	356	event_t wake_event,
9bccf70c	357	wait_result_t result);
1c79356b A	358
1c79356b A	359	/* wakeup a specified thread waiting iff waiting on <wait_queue,event> pair */
9bccf70c	360	extern kern_return_t wait_queue_wakeup_thread(
1c79356b A	361	wait_queue_t wait_queue,
	362	event_t wake_event,
	363	thread_t thread,
9bccf70c A	364	wait_result_t result);
9bccf70c A	365
91447636 A	366	__END_DECLS
	367
	368	#endif /* _KERN_WAIT_QUEUE_H_ */
1c79356b	369
91447636	370	#endif /* KERNEL_PRIVATE */