![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_lock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to kern_lock.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 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: /* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
23: /*
24: * Copyright (c) 1995
25: * The Regents of the University of California. All rights reserved.
26: *
27: * This code contains ideas from software contributed to Berkeley by
28: * Avadis Tevanian, Jr., Michael Wayne Young, and the Mach Operating
29: * System project at Carnegie-Mellon University.
30: *
31: * Redistribution and use in source and binary forms, with or without
32: * modification, are permitted provided that the following conditions
33: * are met:
34: * 1. Redistributions of source code must retain the above copyright
35: * notice, this list of conditions and the following disclaimer.
36: * 2. Redistributions in binary form must reproduce the above copyright
37: * notice, this list of conditions and the following disclaimer in the
38: * documentation and/or other materials provided with the distribution.
39: * 3. All advertising materials mentioning features or use of this software
40: * must display the following acknowledgement:
41: * This product includes software developed by the University of
42: * California, Berkeley and its contributors.
43: * 4. Neither the name of the University nor the names of its contributors
44: * may be used to endorse or promote products derived from this software
45: * without specific prior written permission.
46: *
47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57: * SUCH DAMAGE.
58: *
59: * @(#)kern_lock.c 8.18 (Berkeley) 5/21/95
60: */
61:
62: #include <sys/param.h>
63: #include <sys/proc.h>
64: #include <sys/lock.h>
65: #include <kern/cpu_number.h>
66: #include <kern/thread.h>
67:
68: #include <mach/mach_types.h>
69:
70: /*
71: * Locking primitives implementation.
72: * Locks provide shared/exclusive sychronization.
73: */
74:
75: #if 0
76: #define COUNT(p, x) if (p) (p)->p_locks += (x)
77: #else
78: #define COUNT(p, x)
79: #endif
80:
81: #if NCPUS > 1
82:
83: /*
84: * For multiprocessor system, try spin lock first.
85: *
86: * This should be inline expanded below, but we cannot have #if
87: * inside a multiline define.
88: */
89: int lock_wait_time = 100;
90: #define PAUSE(lkp, wanted) \
91: if (lock_wait_time > 0) { \
92: int i; \
93: \
94: simple_unlock(&lkp->lk_interlock); \
95: for (i = lock_wait_time; i > 0; i--) \
96: if (!(wanted)) \
97: break; \
98: simple_lock(&lkp->lk_interlock); \
99: } \
100: if (!(wanted)) \
101: break;
102:
103: #else /* NCPUS == 1 */
104:
105: /*
106: * It is an error to spin on a uniprocessor as nothing will ever cause
107: * the simple lock to clear while we are executing.
108: */
109: #define PAUSE(lkp, wanted)
110:
111: #endif /* NCPUS == 1 */
112:
113: /*
114: * Acquire a resource.
115: */
116: #define ACQUIRE(lkp, error, extflags, wanted) \
117: PAUSE(lkp, wanted); \
118: for (error = 0; wanted; ) { \
119: (lkp)->lk_waitcount++; \
120: simple_unlock(&(lkp)->lk_interlock); \
121: error = tsleep((void *)lkp, (lkp)->lk_prio, \
122: (lkp)->lk_wmesg, (lkp)->lk_timo); \
123: simple_lock(&(lkp)->lk_interlock); \
124: (lkp)->lk_waitcount--; \
125: if (error) \
126: break; \
127: if ((extflags) & LK_SLEEPFAIL) { \
128: error = ENOLCK; \
129: break; \
130: } \
131: }
132:
133: /*
134: * Initialize a lock; required before use.
135: */
136: void
137: lockinit(lkp, prio, wmesg, timo, flags)
138: struct lock__bsd__ *lkp;
139: int prio;
140: char *wmesg;
141: int timo;
142: int flags;
143: {
144:
145: bzero(lkp, sizeof(struct lock__bsd__));
146: simple_lock_init(&lkp->lk_interlock);
147: lkp->lk_flags = flags & LK_EXTFLG_MASK;
148: lkp->lk_prio = prio;
149: lkp->lk_timo = timo;
150: lkp->lk_wmesg = wmesg;
151: lkp->lk_lockholder = LK_NOPROC;
152: lkp->lk_lockthread = 0;
153: }
154:
155: /*
156: * Determine the status of a lock.
157: */
158: int
159: lockstatus(lkp)
160: struct lock__bsd__ *lkp;
161: {
162: int lock_type = 0;
163:
164: simple_lock(&lkp->lk_interlock);
165: if (lkp->lk_exclusivecount != 0)
166: lock_type = LK_EXCLUSIVE;
167: else if (lkp->lk_sharecount != 0)
168: lock_type = LK_SHARED;
169: simple_unlock(&lkp->lk_interlock);
170: return (lock_type);
171: }
172:
173: /*
174: * Set, change, or release a lock.
175: *
176: * Shared requests increment the shared count. Exclusive requests set the
177: * LK_WANT_EXCL flag (preventing further shared locks), and wait for already
178: * accepted shared locks and shared-to-exclusive upgrades to go away.
179: */
180: int
181: lockmgr(lkp, flags, interlkp, p)
182: struct lock__bsd__ *lkp;
183: u_int flags;
184: simple_lock_t interlkp;
185: struct proc *p;
186: {
187: int error;
188: pid_t pid;
189: int extflags;
190: void *self;
191:
192: error = 0; self = current_thread();
193: if (p)
194: pid = p->p_pid;
195: else
196: pid = LK_KERNPROC;
197: simple_lock(&lkp->lk_interlock);
198: if (flags & LK_INTERLOCK)
199: simple_unlock(interlkp);
200: extflags = (flags | lkp->lk_flags) & LK_EXTFLG_MASK;
201: #if 0
202: /*
203: * Once a lock has drained, the LK_DRAINING flag is set and an
204: * exclusive lock is returned. The only valid operation thereafter
205: * is a single release of that exclusive lock. This final release
206: * clears the LK_DRAINING flag and sets the LK_DRAINED flag. Any
207: * further requests of any sort will result in a panic. The bits
208: * selected for these two flags are chosen so that they will be set
209: * in memory that is freed (freed memory is filled with 0xdeadbeef).
210: * The final release is permitted to give a new lease on life to
211: * the lock by specifying LK_REENABLE.
212: */
213: if (lkp->lk_flags & (LK_DRAINING|LK_DRAINED)) {
214: if (lkp->lk_flags & LK_DRAINED)
215: panic("lockmgr: using decommissioned lock");
216: if ((flags & LK_TYPE_MASK) != LK_RELEASE ||
217: (lkp->lk_lockholder != pid && lkp->lk_lockthread != self)
218: panic("lockmgr: non-release on draining lock: %d\n",
219: flags & LK_TYPE_MASK);
220: lkp->lk_flags &= ~LK_DRAINING;
221: if ((flags & LK_REENABLE) == 0)
222: lkp->lk_flags |= LK_DRAINED;
223: }
224: #endif
225:
226: switch (flags & LK_TYPE_MASK) {
227:
228: case LK_SHARED:
229: if (lkp->lk_lockholder != pid || lkp->lk_lockthread != self) {
230: /*
231: * If just polling, check to see if we will block.
232: */
233: if ((extflags & LK_NOWAIT) && (lkp->lk_flags &
234: (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE))) {
235: error = EBUSY;
236: break;
237: }
238: /*
239: * Wait for exclusive locks and upgrades to clear.
240: */
241: ACQUIRE(lkp, error, extflags, lkp->lk_flags &
242: (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE));
243: if (error)
244: break;
245: lkp->lk_sharecount++;
246: COUNT(p, 1);
247: break;
248: }
249: /*
250: * We hold an exclusive lock, so downgrade it to shared.
251: * An alternative would be to fail with EDEADLK.
252: */
253: lkp->lk_sharecount++;
254: COUNT(p, 1);
255: /* fall into downgrade */
256:
257: case LK_DOWNGRADE:
258: if (lkp->lk_lockholder != pid ||
259: lkp->lk_lockthread != self ||
260: lkp->lk_exclusivecount == 0)
261: panic("lockmgr: not holding exclusive lock");
262: lkp->lk_sharecount += lkp->lk_exclusivecount;
263: lkp->lk_exclusivecount = 0;
264: lkp->lk_flags &= ~LK_HAVE_EXCL;
265: lkp->lk_lockholder = LK_NOPROC;
266: lkp->lk_lockthread = 0;
267: if (lkp->lk_waitcount)
268: wakeup((void *)lkp);
269: break;
270:
271: case LK_EXCLUPGRADE:
272: /*
273: * If another process is ahead of us to get an upgrade,
274: * then we want to fail rather than have an intervening
275: * exclusive access.
276: */
277: if (lkp->lk_flags & LK_WANT_UPGRADE) {
278: lkp->lk_sharecount--;
279: COUNT(p, -1);
280: error = EBUSY;
281: break;
282: }
283: /* fall into normal upgrade */
284:
285: case LK_UPGRADE:
286: /*
287: * Upgrade a shared lock to an exclusive one. If another
288: * shared lock has already requested an upgrade to an
289: * exclusive lock, our shared lock is released and an
290: * exclusive lock is requested (which will be granted
291: * after the upgrade). If we return an error, the file
292: * will always be unlocked.
293: */
294: if ((lkp->lk_lockholder == pid &&
295: lkp->lk_lockthread == self) ||
296: lkp->lk_sharecount <= 0)
297: panic("lockmgr: upgrade exclusive lock");
298: lkp->lk_sharecount--;
299: COUNT(p, -1);
300: /*
301: * If we are just polling, check to see if we will block.
302: */
303: if ((extflags & LK_NOWAIT) &&
304: ((lkp->lk_flags & LK_WANT_UPGRADE) ||
305: lkp->lk_sharecount > 1)) {
306: error = EBUSY;
307: break;
308: }
309: if ((lkp->lk_flags & LK_WANT_UPGRADE) == 0) {
310: /*
311: * We are first shared lock to request an upgrade, so
312: * request upgrade and wait for the shared count to
313: * drop to zero, then take exclusive lock.
314: */
315: lkp->lk_flags |= LK_WANT_UPGRADE;
316: ACQUIRE(lkp, error, extflags, lkp->lk_sharecount);
317: lkp->lk_flags &= ~LK_WANT_UPGRADE;
318: if (error)
319: break;
320: lkp->lk_flags |= LK_HAVE_EXCL;
321: lkp->lk_lockholder = pid;
322: lkp->lk_lockthread = self;
323: if (lkp->lk_exclusivecount != 0)
324: panic("lockmgr: non-zero exclusive count");
325: lkp->lk_exclusivecount = 1;
326: COUNT(p, 1);
327: break;
328: }
329: /*
330: * Someone else has requested upgrade. Release our shared
331: * lock, awaken upgrade requestor if we are the last shared
332: * lock, then request an exclusive lock.
333: */
334: if (lkp->lk_sharecount == 0 && lkp->lk_waitcount)
335: wakeup((void *)lkp);
336: /* fall into exclusive request */
337:
338: case LK_EXCLUSIVE:
339: if (lkp->lk_lockholder == pid && lkp->lk_lockthread == self) {
340: /*
341: * Recursive lock.
342: */
343: if ((extflags & LK_CANRECURSE) == 0)
344: panic("lockmgr: locking against myself");
345: lkp->lk_exclusivecount++;
346: COUNT(p, 1);
347: break;
348: }
349: /*
350: * If we are just polling, check to see if we will sleep.
351: */
352: if ((extflags & LK_NOWAIT) && ((lkp->lk_flags &
353: (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE)) ||
354: lkp->lk_sharecount != 0)) {
355: error = EBUSY;
356: break;
357: }
358: /*
359: * Try to acquire the want_exclusive flag.
360: */
361: ACQUIRE(lkp, error, extflags, lkp->lk_flags &
362: (LK_HAVE_EXCL | LK_WANT_EXCL));
363: if (error)
364: break;
365: lkp->lk_flags |= LK_WANT_EXCL;
366: /*
367: * Wait for shared locks and upgrades to finish.
368: */
369: ACQUIRE(lkp, error, extflags, lkp->lk_sharecount != 0 ||
370: (lkp->lk_flags & LK_WANT_UPGRADE));
371: lkp->lk_flags &= ~LK_WANT_EXCL;
372: if (error)
373: break;
374: lkp->lk_flags |= LK_HAVE_EXCL;
375: lkp->lk_lockholder = pid;
376: lkp->lk_lockthread = self;
377: if (lkp->lk_exclusivecount != 0)
378: panic("lockmgr: non-zero exclusive count");
379: lkp->lk_exclusivecount = 1;
380: COUNT(p, 1);
381: break;
382:
383: case LK_RELEASE:
384: if (lkp->lk_exclusivecount != 0) {
385: if (pid != lkp->lk_lockholder ||
386: lkp->lk_lockthread != self)
387: panic("lockmgr: pid %d, not %s %d unlocking",
388: pid, "exclusive lock holder",
389: lkp->lk_lockholder);
390: lkp->lk_exclusivecount--;
391: COUNT(p, -1);
392: if (lkp->lk_exclusivecount == 0) {
393: lkp->lk_flags &= ~LK_HAVE_EXCL;
394: lkp->lk_lockholder = LK_NOPROC;
395: lkp->lk_lockthread = 0;
396: }
397: } else if (lkp->lk_sharecount != 0) {
398: lkp->lk_sharecount--;
399: COUNT(p, -1);
400: }
401: if (lkp->lk_waitcount)
402: wakeup((void *)lkp);
403: break;
404:
405: case LK_DRAIN:
406: /*
407: * Check that we do not already hold the lock, as it can
408: * never drain if we do. Unfortunately, we have no way to
409: * check for holding a shared lock, but at least we can
410: * check for an exclusive one.
411: */
412: if (lkp->lk_lockholder == pid && lkp->lk_lockthread == self)
413: panic("lockmgr: draining against myself");
414: /*
415: * If we are just polling, check to see if we will sleep.
416: */
417: if ((extflags & LK_NOWAIT) && ((lkp->lk_flags &
418: (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE)) ||
419: lkp->lk_sharecount != 0 || lkp->lk_waitcount != 0)) {
420: error = EBUSY;
421: break;
422: }
423: PAUSE(lkp, ((lkp->lk_flags &
424: (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE)) ||
425: lkp->lk_sharecount != 0 || lkp->lk_waitcount != 0));
426: for (error = 0; ((lkp->lk_flags &
427: (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE)) ||
428: lkp->lk_sharecount != 0 || lkp->lk_waitcount != 0); ) {
429: lkp->lk_flags |= LK_WAITDRAIN;
430: simple_unlock(&lkp->lk_interlock);
431: if (error = tsleep((void *)&lkp->lk_flags, lkp->lk_prio,
432: lkp->lk_wmesg, lkp->lk_timo))
433: return (error);
434: if ((extflags) & LK_SLEEPFAIL)
435: return (ENOLCK);
436: simple_lock(&lkp->lk_interlock);
437: }
438: lkp->lk_flags |= LK_DRAINING | LK_HAVE_EXCL;
439: lkp->lk_lockholder = pid;
440: lkp->lk_lockthread = self;
441: lkp->lk_exclusivecount = 1;
442: COUNT(p, 1);
443: break;
444:
445: default:
446: simple_unlock(&lkp->lk_interlock);
447: panic("lockmgr: unknown locktype request %d",
448: flags & LK_TYPE_MASK);
449: /* NOTREACHED */
450: }
451: if ((lkp->lk_flags & LK_WAITDRAIN) && ((lkp->lk_flags &
452: (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE)) == 0 &&
453: lkp->lk_sharecount == 0 && lkp->lk_waitcount == 0)) {
454: lkp->lk_flags &= ~LK_WAITDRAIN;
455: wakeup((void *)&lkp->lk_flags);
456: }
457: simple_unlock(&lkp->lk_interlock);
458: return (error);
459: }
460:
461: /*
462: * Print out information about state of a lock. Used by VOP_PRINT
463: * routines to display ststus about contained locks.
464: */
465: lockmgr_printinfo(lkp)
466: struct lock__bsd__ *lkp;
467: {
468:
469: if (lkp->lk_sharecount)
470: printf(" lock type %s: SHARED (count %d)", lkp->lk_wmesg,
471: lkp->lk_sharecount);
472: else if (lkp->lk_flags & LK_HAVE_EXCL)
473: printf(" lock type %s: EXCL (count %d) by pid %d",
474: lkp->lk_wmesg, lkp->lk_exclusivecount, lkp->lk_lockholder);
475: if (lkp->lk_waitcount > 0)
476: printf(" with %d pending", lkp->lk_waitcount);
477: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.