[unix-history] / sys / vm / lock.h

/* 
 * Copyright (c) 1991 Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * The Mach Operating System project at Carnegie-Mellon University.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	from: @(#)lock.h	7.3 (Berkeley) 4/21/91
 *	$Id
 */

/*
 * Copyright (c) 1987, 1990 Carnegie-Mellon University.
 * All rights reserved.
 *
 * Authors: Avadis Tevanian, Jr., Michael Wayne Young
 * 
 * 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 the
 * rights to redistribute these changes.
 */

/*
 *	Locking primitives definitions
 */

#ifndef	_LOCK_H_
#define	_LOCK_H_

#define	NCPUS	1		/* XXX */

/*
 *	A simple spin lock.
 */

struct slock {
	int		lock_data;	/* in general 1 bit is sufficient */
};

typedef struct slock	simple_lock_data_t;
typedef struct slock	*simple_lock_t;

/*
 *	The general lock structure.  Provides for multiple readers,
 *	upgrading from read to write, and sleeping until the lock
 *	can be gained.
 */

struct lock {
#if defined(vax)
	/*
	 *	Efficient VAX implementation -- see field description below.
	 */
	unsigned int	read_count:16,
			want_upgrade:1,
			want_write:1,
			waiting:1,
			can_sleep:1,
			:0;

	simple_lock_data_t	interlock;
#elif defined(ns32000)
	/*
	 *	Efficient ns32000 implementation --
	 *	see field description below.
	 */
	simple_lock_data_t	interlock;
	unsigned int	read_count:16,
			want_upgrade:1,
			want_write:1,
			waiting:1,
			can_sleep:1,
			:0;

#else /* neither vax nor ns32000 */
	/*	Only the "interlock" field is used for hardware exclusion;
	 *	other fields are modified with normal instructions after
	 *	acquiring the interlock bit.
	 */
	simple_lock_data_t
			interlock;	/* Interlock for remaining fields */
	boolean_t	want_write;	/* Writer is waiting, or locked for write */
	boolean_t	want_upgrade;	/* Read-to-write upgrade waiting */
	boolean_t	waiting;	/* Someone is sleeping on lock */
	boolean_t	can_sleep;	/* Can attempts to lock go to sleep */
	int		read_count;	/* Number of accepted readers */
#endif	/* vax */
	char		*thread;	/* Thread that has lock, if recursive locking allowed */
					/* (should be thread_t, but but we then have mutually
					   recursive definitions) */
	int		recursion_depth;/* Depth of recursion */
};

typedef struct lock	lock_data_t;
typedef struct lock	*lock_t;

#if	NCPUS > 1
void		simple_lock_init();
void		simple_lock();
void		simple_unlock();
boolean_t	simple_lock_try();
#else  /* NCPUS == 1 */
/*
 *	No multiprocessor locking is necessary.
 */
#define simple_lock_init(l)
#define simple_lock(l)
#define simple_unlock(l)
#define simple_lock_try(l)	(1)	/* always succeeds */
#endif	/* NCPUS > 1 */

/* Sleep locks must work even if no multiprocessing */

void		lock_init();
void		lock_sleepable();
void		lock_write();
void		lock_read();
void		lock_done();
boolean_t	lock_read_to_write();
void		lock_write_to_read();
boolean_t	lock_try_write();
boolean_t	lock_try_read();
boolean_t	lock_try_read_to_write();

#define	lock_read_done(l)	lock_done(l)
#define	lock_write_done(l)	lock_done(l)

void		lock_set_recursive();
void		lock_clear_recursive();

/*
 * Try to get semi-meaningful wait messages into thread_sleep...
 */
extern void thread_sleep_(int, simple_lock_t, const char *);
#if __GNUC__ >= 2
#define thread_sleep(a,b,c) thread_sleep_((a), (b), __FUNCTION__)
#else
#define thread_sleep(a,b,c) thread_sleep_((a), (b), "vmslp")
#endif
#define thread_sleep_new thread_sleep_
extern void thread_wakeup(int);


#endif /* !_LOCK_H_ */
Commit	Line	Data
15637ed4 RG	1	/*
	2	* Copyright (c) 1991 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* This code is derived from software contributed to Berkeley by
	6	* The Mach Operating System project at Carnegie-Mellon University.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. All advertising materials mentioning features or use of this software
	17	* must display the following acknowledgement:
	18	* This product includes software developed by the University of
	19	* California, Berkeley and its contributors.
	20	* 4. Neither the name of the University nor the names of its contributors
	21	* may be used to endorse or promote products derived from this software
	22	* without specific prior written permission.
	23	*
	24	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	25	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	30	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	31	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	32	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	33	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	34	* SUCH DAMAGE.
	35	*
1284e777 RG	36	* from: @(#)lock.h 7.3 (Berkeley) 4/21/91
	37	* $Id
	38	*/
	39
	40	/*
15637ed4 RG	41	* Copyright (c) 1987, 1990 Carnegie-Mellon University.
	42	* All rights reserved.
	43	*
	44	* Authors: Avadis Tevanian, Jr., Michael Wayne Young
	45	*
	46	* Permission to use, copy, modify and distribute this software and
	47	* its documentation is hereby granted, provided that both the copyright
	48	* notice and this permission notice appear in all copies of the
	49	* software, derivative works or modified versions, and any portions
	50	* thereof, and that both notices appear in supporting documentation.
	51	*
	52	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	53	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
	54	* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	55	*
	56	* Carnegie Mellon requests users of this software to return to
	57	*
	58	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	59	* School of Computer Science
	60	* Carnegie Mellon University
	61	* Pittsburgh PA 15213-3890
	62	*
	63	* any improvements or extensions that they make and grant Carnegie the
	64	* rights to redistribute these changes.
	65	*/
	66
	67	/*
	68	* Locking primitives definitions
	69	*/
	70
	71	#ifndef _LOCK_H_
	72	#define _LOCK_H_
	73
	74	#define NCPUS 1 /* XXX */
	75
	76	/*
	77	* A simple spin lock.
	78	*/
	79
	80	struct slock {
	81	int lock_data; /* in general 1 bit is sufficient */
	82	};
	83
	84	typedef struct slock simple_lock_data_t;
	85	typedef struct slock *simple_lock_t;
	86
	87	/*
	88	* The general lock structure. Provides for multiple readers,
	89	* upgrading from read to write, and sleeping until the lock
	90	* can be gained.
	91	*/
	92
	93	struct lock {
bbc3f849	94	#if defined(vax)
15637ed4 RG	95	/*
	96	* Efficient VAX implementation -- see field description below.
	97	*/
	98	unsigned int read_count:16,
	99	want_upgrade:1,
	100	want_write:1,
	101	waiting:1,
	102	can_sleep:1,
	103	:0;
	104
	105	simple_lock_data_t interlock;
bbc3f849	106	#elif defined(ns32000)
15637ed4 RG	107	/*
	108	* Efficient ns32000 implementation --
	109	* see field description below.
	110	*/
	111	simple_lock_data_t interlock;
	112	unsigned int read_count:16,
	113	want_upgrade:1,
	114	want_write:1,
	115	waiting:1,
	116	can_sleep:1,
	117	:0;
	118
bbc3f849	119	#else /* neither vax nor ns32000 */
15637ed4 RG	120	/* Only the "interlock" field is used for hardware exclusion;
	121	* other fields are modified with normal instructions after
	122	* acquiring the interlock bit.
	123	*/
	124	simple_lock_data_t
	125	interlock; /* Interlock for remaining fields */
	126	boolean_t want_write; /* Writer is waiting, or locked for write */
	127	boolean_t want_upgrade; /* Read-to-write upgrade waiting */
	128	boolean_t waiting; /* Someone is sleeping on lock */
	129	boolean_t can_sleep; /* Can attempts to lock go to sleep */
	130	int read_count; /* Number of accepted readers */
15637ed4 RG	131	#endif /* vax */
	132	char thread; / Thread that has lock, if recursive locking allowed */
	133	/* (should be thread_t, but but we then have mutually
	134	recursive definitions) */
	135	int recursion_depth;/* Depth of recursion */
	136	};
	137
	138	typedef struct lock lock_data_t;
	139	typedef struct lock *lock_t;
	140
	141	#if NCPUS > 1
	142	void simple_lock_init();
	143	void simple_lock();
	144	void simple_unlock();
	145	boolean_t simple_lock_try();
bbc3f849	146	#else /* NCPUS == 1 */
15637ed4 RG	147	/*
	148	* No multiprocessor locking is necessary.
	149	*/
	150	#define simple_lock_init(l)
	151	#define simple_lock(l)
	152	#define simple_unlock(l)
	153	#define simple_lock_try(l) (1) /* always succeeds */
	154	#endif /* NCPUS > 1 */
	155
	156	/* Sleep locks must work even if no multiprocessing */
	157
	158	void lock_init();
	159	void lock_sleepable();
	160	void lock_write();
	161	void lock_read();
	162	void lock_done();
	163	boolean_t lock_read_to_write();
	164	void lock_write_to_read();
	165	boolean_t lock_try_write();
	166	boolean_t lock_try_read();
	167	boolean_t lock_try_read_to_write();
	168
	169	#define lock_read_done(l) lock_done(l)
	170	#define lock_write_done(l) lock_done(l)
	171
	172	void lock_set_recursive();
	173	void lock_clear_recursive();
	174
4c45483e GW	175	/*
	176	* Try to get semi-meaningful wait messages into thread_sleep...
	177	*/
	178	extern void thread_sleep_(int, simple_lock_t, const char *);
55768178 DG	179	#if __GNUC__ >= 2
55768178 DG	180	#define thread_sleep(a,b,c) thread_sleep_((a), (b), __FUNCTION__)
4c45483e	181	#else
55768178	182	#define thread_sleep(a,b,c) thread_sleep_((a), (b), "vmslp")
4c45483e GW	183	#endif
	184	#define thread_sleep_new thread_sleep_
	185	extern void thread_wakeup(int);
	186
	187
15637ed4	188	#endif /* !_LOCK_H_ */