![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lock.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / sys|
Return to lock.h CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / sys |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1995
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code contains ideas from software contributed to Berkeley by
31: * Avadis Tevanian, Jr., Michael Wayne Young, and the Mach Operating
32: * System project at Carnegie-Mellon University.
33: *
34: * Redistribution and use in source and binary forms, with or without
35: * modification, are permitted provided that the following conditions
36: * are met:
37: * 1. Redistributions of source code must retain the above copyright
38: * notice, this list of conditions and the following disclaimer.
39: * 2. Redistributions in binary form must reproduce the above copyright
40: * notice, this list of conditions and the following disclaimer in the
41: * documentation and/or other materials provided with the distribution.
42: * 3. All advertising materials mentioning features or use of this software
43: * must display the following acknowledgement:
44: * This product includes software developed by the University of
45: * California, Berkeley and its contributors.
46: * 4. Neither the name of the University nor the names of its contributors
47: * may be used to endorse or promote products derived from this software
48: * without specific prior written permission.
49: *
50: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60: * SUCH DAMAGE.
61: *
62: * @(#)lock.h 8.12 (Berkeley) 5/19/95
63: */
64:
65: #ifndef _SYS_LOCK_H_
66: #define _SYS_LOCK_H_
67:
68: #include <mach/machine/simple_lock.h>
69:
70: /*
71: * The general lock structure. Provides for multiple shared locks,
72: * upgrading from shared to exclusive, and sleeping until the lock
73: * can be gained. The simple locks are defined in <machine/param.h>.
74: */
75: struct lock__bsd__ {
76: simple_lock_data_t
77: lk_interlock; /* lock on remaining fields */
78: u_int lk_flags; /* see below */
79: int lk_sharecount; /* # of accepted shared locks */
80: int lk_waitcount; /* # of processes sleeping for lock */
81: short lk_exclusivecount; /* # of recursive exclusive locks */
82: short lk_prio; /* priority at which to sleep */
83: char *lk_wmesg; /* resource sleeping (for tsleep) */
84: int lk_timo; /* maximum sleep time (for tsleep) */
85: pid_t lk_lockholder; /* pid of exclusive lock holder */
86: void *lk_lockthread; /* thread which acquired excl lock */
87: };
88: /*
89: * Lock request types:
90: * LK_SHARED - get one of many possible shared locks. If a process
91: * holding an exclusive lock requests a shared lock, the exclusive
92: * lock(s) will be downgraded to shared locks.
93: * LK_EXCLUSIVE - stop further shared locks, when they are cleared,
94: * grant a pending upgrade if it exists, then grant an exclusive
95: * lock. Only one exclusive lock may exist at a time, except that
96: * a process holding an exclusive lock may get additional exclusive
97: * locks if it explicitly sets the LK_CANRECURSE flag in the lock
98: * request, or if the LK_CANRECUSE flag was set when the lock was
99: * initialized.
100: * LK_UPGRADE - the process must hold a shared lock that it wants to
101: * have upgraded to an exclusive lock. Other processes may get
102: * exclusive access to the resource between the time that the upgrade
103: * is requested and the time that it is granted.
104: * LK_EXCLUPGRADE - the process must hold a shared lock that it wants to
105: * have upgraded to an exclusive lock. If the request succeeds, no
106: * other processes will have gotten exclusive access to the resource
107: * between the time that the upgrade is requested and the time that
108: * it is granted. However, if another process has already requested
109: * an upgrade, the request will fail (see error returns below).
110: * LK_DOWNGRADE - the process must hold an exclusive lock that it wants
111: * to have downgraded to a shared lock. If the process holds multiple
112: * (recursive) exclusive locks, they will all be downgraded to shared
113: * locks.
114: * LK_RELEASE - release one instance of a lock.
115: * LK_DRAIN - wait for all activity on the lock to end, then mark it
116: * decommissioned. This feature is used before freeing a lock that
117: * is part of a piece of memory that is about to be freed.
118: *
119: * These are flags that are passed to the lockmgr routine.
120: */
121: #define LK_TYPE_MASK 0x0000000f /* type of lock sought */
122: #define LK_SHARED 0x00000001 /* shared lock */
123: #define LK_EXCLUSIVE 0x00000002 /* exclusive lock */
124: #define LK_UPGRADE 0x00000003 /* shared-to-exclusive upgrade */
125: #define LK_EXCLUPGRADE 0x00000004 /* first shared-to-exclusive upgrade */
126: #define LK_DOWNGRADE 0x00000005 /* exclusive-to-shared downgrade */
127: #define LK_RELEASE 0x00000006 /* release any type of lock */
128: #define LK_DRAIN 0x00000007 /* wait for all lock activity to end */
129: /*
130: * External lock flags.
131: *
132: * The first three flags may be set in lock_init to set their mode permanently,
133: * or passed in as arguments to the lock manager. The LK_REENABLE flag may be
134: * set only at the release of a lock obtained by drain.
135: */
136: #define LK_EXTFLG_MASK 0x00000070 /* mask of external flags */
137: #define LK_NOWAIT 0x00000010 /* do not sleep to await lock */
138: #define LK_SLEEPFAIL 0x00000020 /* sleep, then return failure */
139: #define LK_CANRECURSE 0x00000040 /* allow recursive exclusive lock */
140: #define LK_REENABLE 0x00000080 /* lock is be reenabled after drain */
141: /*
142: * Internal lock flags.
143: *
144: * These flags are used internally to the lock manager.
145: */
146: #define LK_WANT_UPGRADE 0x00000100 /* waiting for share-to-excl upgrade */
147: #define LK_WANT_EXCL 0x00000200 /* exclusive lock sought */
148: #define LK_HAVE_EXCL 0x00000400 /* exclusive lock obtained */
149: #define LK_WAITDRAIN 0x00000800 /* process waiting for lock to drain */
150: #define LK_DRAINING 0x00004000 /* lock is being drained */
151: #define LK_DRAINED 0x00008000 /* lock has been decommissioned */
152: /*
153: * Control flags
154: *
155: * Non-persistent external flags.
156: */
157: #define LK_INTERLOCK 0x00010000 /* unlock passed simple lock after
158: getting lk_interlock */
159: #define LK_RETRY 0x00020000 /* vn_lock: retry until locked */
160:
161: /*
162: * Lock return status.
163: *
164: * Successfully obtained locks return 0. Locks will always succeed
165: * unless one of the following is true:
166: * LK_FORCEUPGRADE is requested and some other process has already
167: * requested a lock upgrade (returns EBUSY).
168: * LK_WAIT is set and a sleep would be required (returns EBUSY).
169: * LK_SLEEPFAIL is set and a sleep was done (returns ENOLCK).
170: * PCATCH is set in lock priority and a signal arrives (returns
171: * either EINTR or ERESTART if system calls is to be restarted).
172: * Non-null lock timeout and timeout expires (returns EWOULDBLOCK).
173: * A failed lock attempt always returns a non-zero error value. No lock
174: * is held after an error return (in particular, a failed LK_UPGRADE
175: * or LK_FORCEUPGRADE will have released its shared access lock).
176: */
177:
178: /*
179: * Indicator that no process holds exclusive lock
180: */
181: #define LK_KERNPROC ((pid_t) -2)
182: #define LK_NOPROC ((pid_t) -1)
183:
184: struct proc;
185:
186: void lockinit __P((struct lock__bsd__ *, int prio, char *wmesg, int timo,
187: int flags));
188: int lockmgr __P((struct lock__bsd__ *, u_int flags,
189: simple_lock_t, struct proc *p));
190: int lockstatus __P((struct lock__bsd__ *));
191:
192: #endif /* _SYS_LOCK_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.