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

/*
 * 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_COPYRIGHT@
 * 
 */
/*
 *	File:	kern/sync_lock.h
 *	Author:	Joseph CaraDonna
 *
 *	Contains RT distributed lock synchronization service definitions.
 */

#ifndef _KERN_SYNC_LOCK_H_
#define _KERN_SYNC_LOCK_H_

#include <mach/mach_types.h>

#include <sys/appleapiopts.h>

#ifdef	__APPLE_API_PRIVATE

#ifdef	MACH_KERNEL_PRIVATE

#include <kern/wait_queue.h>
#include <kern/macro_help.h>
#include <kern/queue.h>
#include <kern/lock.h>

typedef struct ulock {
	queue_chain_t	thread_link;	/* ulocks owned by a thread  	    */
	queue_chain_t	held_link;	/* ulocks held in the lock set	    */
	queue_chain_t	handoff_link;	/* ulocks w/ active handoffs	    */

	decl_mutex_data(,lock)		/* ulock lock			    */

	struct lock_set *lock_set;	/* the retaining lock set	    */
	thread_act_t	holder;		/* thread_act that holds the lock   */
	unsigned int			/* flags                            */
	/* boolean_t */ blocked:1,	/*     did threads block waiting?   */
	/* boolean_t */	unstable:1,	/*     unstable? (holder died)	    */
	/* boolean_t */ ho_wait:1,	/*     handoff thread waiting?	    */
	/* boolean_t */ accept_wait:1,	/*     accepting thread waiting?    */
			:0;		/*     force to long boundary       */

	struct wait_queue wait_queue;	/* queue of blocked threads	    */
} Ulock;

typedef struct ulock *ulock_t;

typedef struct lock_set {
	queue_chain_t	task_link;   /* chain of lock sets owned by a task  */
	decl_mutex_data(,lock)	     /* lock set lock			    */
	task_t		owner;	     /* task that owns the lock set	    */
	ipc_port_t	port;	     /* lock set port			    */
	int		ref_count;   /* reference count			    */

	boolean_t	active;	     /* active status			    */
	int		n_ulocks;    /* number of ulocks in the lock set    */

	struct ulock	ulock_list[1];	/* ulock group list place holder    */
} Lock_Set;

#define ULOCK_NULL	((ulock_t) 0)

#define ULOCK_FREE	0
#define ULOCK_HELD	1

/*
 *  Data structure internal lock macros
 */

#define lock_set_lock_init(ls)		mutex_init(&(ls)->lock, \
						   ETAP_THREAD_LOCK_SET)
#define lock_set_lock(ls)		mutex_lock(&(ls)->lock)
#define lock_set_unlock(ls)		mutex_unlock(&(ls)->lock)

#define ulock_lock_init(ul)		mutex_init(&(ul)->lock, \
						   ETAP_THREAD_ULOCK)
#define ulock_lock(ul)			mutex_lock(&(ul)->lock)
#define ulock_unlock(ul)		mutex_unlock(&(ul)->lock)

extern void lock_set_init(void);

extern	kern_return_t	lock_release_internal	(ulock_t ulock,
						 thread_act_t thr_act);

#endif	/* MACH_KERNEL_PRIVATE */

#endif	/* __APPLE_API_PRIVATE */


/*
 *	Forward Declarations
 */

extern	kern_return_t	lock_set_create	     	(task_t task,
						 lock_set_t *new_lock_set,
						 int n_ulocks,
						 int policy);

extern	kern_return_t	lock_set_destroy     	(task_t task,
						 lock_set_t lock_set);

extern	kern_return_t	lock_acquire   	     	(lock_set_t lock_set,
						 int lock_id);

extern	kern_return_t	lock_release	     	(lock_set_t lock_set,
						 int lock_id);

extern	kern_return_t	lock_try	     	(lock_set_t lock_set,
						 int lock_id);

extern	kern_return_t	lock_make_stable	(lock_set_t lock_set,
						 int lock_id);	       

extern  kern_return_t	lock_make_unstable	(ulock_t ulock,
						 thread_act_t thr_act);

extern	kern_return_t	lock_handoff		(lock_set_t lock_set,
						 int lock_id);

extern	kern_return_t	lock_handoff_accept	(lock_set_t lock_set,
						 int lock_id);

extern	void		lock_set_reference	(lock_set_t lock_set);
extern	void		lock_set_dereference	(lock_set_t lock_set);

#endif /* _KERN_SYNC_LOCK_H_ */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*
	25	*/
	26	/*
	27	* File: kern/sync_lock.h
	28	* Author: Joseph CaraDonna
	29	*
	30	* Contains RT distributed lock synchronization service definitions.
	31	*/
	32
	33	#ifndef _KERN_SYNC_LOCK_H_
	34	#define _KERN_SYNC_LOCK_H_
	35
	36	#include <mach/mach_types.h>
	37
9bccf70c A	38	#include <sys/appleapiopts.h>
	39
	40	#ifdef __APPLE_API_PRIVATE
	41
	42	#ifdef MACH_KERNEL_PRIVATE
1c79356b A	43
	44	#include <kern/wait_queue.h>
	45	#include <kern/macro_help.h>
	46	#include <kern/queue.h>
	47	#include <kern/lock.h>
	48
	49	typedef struct ulock {
	50	queue_chain_t thread_link; /* ulocks owned by a thread */
	51	queue_chain_t held_link; /* ulocks held in the lock set */
	52	queue_chain_t handoff_link; /* ulocks w/ active handoffs */
	53
	54	decl_mutex_data(,lock) /* ulock lock */
	55
	56	struct lock_set lock_set; / the retaining lock set */
	57	thread_act_t holder; /* thread_act that holds the lock */
	58	unsigned int /* flags */
	59	/* boolean_t / blocked:1, / did threads block waiting? */
	60	/* boolean_t / unstable:1, / unstable? (holder died) */
	61	/* boolean_t / ho_wait:1, / handoff thread waiting? */
	62	/* boolean_t / accept_wait:1, / accepting thread waiting? */
	63	:0; /* force to long boundary */
	64
	65	struct wait_queue wait_queue; /* queue of blocked threads */
	66	} Ulock;
	67
	68	typedef struct ulock *ulock_t;
	69
	70	typedef struct lock_set {
	71	queue_chain_t task_link; /* chain of lock sets owned by a task */
	72	decl_mutex_data(,lock) /* lock set lock */
	73	task_t owner; /* task that owns the lock set */
	74	ipc_port_t port; /* lock set port */
	75	int ref_count; /* reference count */
	76
	77	boolean_t active; /* active status */
	78	int n_ulocks; /* number of ulocks in the lock set */
	79
	80	struct ulock ulock_list[1]; /* ulock group list place holder */
	81	} Lock_Set;
	82
	83	#define ULOCK_NULL ((ulock_t) 0)
	84
	85	#define ULOCK_FREE 0
	86	#define ULOCK_HELD 1
	87
1c79356b A	88	/*
	89	* Data structure internal lock macros
	90	*/
	91
	92	#define lock_set_lock_init(ls) mutex_init(&(ls)->lock, \
	93	ETAP_THREAD_LOCK_SET)
	94	#define lock_set_lock(ls) mutex_lock(&(ls)->lock)
	95	#define lock_set_unlock(ls) mutex_unlock(&(ls)->lock)
	96
	97	#define ulock_lock_init(ul) mutex_init(&(ul)->lock, \
	98	ETAP_THREAD_ULOCK)
	99	#define ulock_lock(ul) mutex_lock(&(ul)->lock)
	100	#define ulock_unlock(ul) mutex_unlock(&(ul)->lock)
	101
	102	extern void lock_set_init(void);
	103
9bccf70c A	104	extern kern_return_t lock_release_internal (ulock_t ulock,
	105	thread_act_t thr_act);
	106
	107	#endif /* MACH_KERNEL_PRIVATE */
	108
	109	#endif /* __APPLE_API_PRIVATE */
	110
1c79356b A	111
	112	/*
	113	* Forward Declarations
	114	*/
	115
	116	extern kern_return_t lock_set_create (task_t task,
	117	lock_set_t *new_lock_set,
	118	int n_ulocks,
	119	int policy);
	120
	121	extern kern_return_t lock_set_destroy (task_t task,
	122	lock_set_t lock_set);
	123
	124	extern kern_return_t lock_acquire (lock_set_t lock_set,
	125	int lock_id);
	126
	127	extern kern_return_t lock_release (lock_set_t lock_set,
	128	int lock_id);
	129
	130	extern kern_return_t lock_try (lock_set_t lock_set,
	131	int lock_id);
	132
	133	extern kern_return_t lock_make_stable (lock_set_t lock_set,
	134	int lock_id);
	135
	136	extern kern_return_t lock_make_unstable (ulock_t ulock,
	137	thread_act_t thr_act);
	138
1c79356b A	139	extern kern_return_t lock_handoff (lock_set_t lock_set,
	140	int lock_id);
	141
	142	extern kern_return_t lock_handoff_accept (lock_set_t lock_set,
	143	int lock_id);
	144
	145	extern void lock_set_reference (lock_set_t lock_set);
	146	extern void lock_set_dereference (lock_set_t lock_set);
	147
	148	#endif /* _KERN_SYNC_LOCK_H_ */