![[BACK]](/icons/back.gif){kind=icon}
Return to kern_rwlock.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / kern|
Return to kern_rwlock.c CVS log | Up to [cvs.NetBSD.org] / src / sys / kern |
1.3.2.4 ! ad 1: /* $NetBSD: kern_rwlock.c,v 1.3.2.3 2007/04/15 16:03:50 yamt Exp $ */
1.2 ad 2:
3: /*-
4: * Copyright (c) 2002, 2006, 2007 The NetBSD Foundation, Inc.
5: * All rights reserved.
6: *
7: * This code is derived from software contributed to The NetBSD Foundation
8: * by Jason R. Thorpe and Andrew Doran.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by the NetBSD
21: * Foundation, Inc. and its contributors.
22: * 4. Neither the name of The NetBSD Foundation nor the names of its
23: * contributors may be used to endorse or promote products derived
24: * from this software without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36: * POSSIBILITY OF SUCH DAMAGE.
37: */
38:
39: /*
40: * Kernel reader/writer lock implementation, modeled after those
41: * found in Solaris, a description of which can be found in:
42: *
43: * Solaris Internals: Core Kernel Architecture, Jim Mauro and
44: * Richard McDougall.
45: */
46:
47: #include "opt_multiprocessor.h"
48:
49: #include <sys/cdefs.h>
1.3.2.4 ! ad 50: __KERNEL_RCSID(0, "$NetBSD: kern_rwlock.c,v 1.3.2.3 2007/04/15 16:03:50 yamt Exp $");
1.2 ad 51:
52: #define __RWLOCK_PRIVATE
53:
54: #include <sys/param.h>
55: #include <sys/proc.h>
56: #include <sys/rwlock.h>
57: #include <sys/sched.h>
58: #include <sys/sleepq.h>
59: #include <sys/systm.h>
60: #include <sys/lockdebug.h>
61:
62: #include <dev/lockstat.h>
63:
64: #define RW_ABORT(rw, msg) \
65: LOCKDEBUG_ABORT(RW_GETID(rw), rw, &rwlock_lockops, __FUNCTION__, msg)
66:
67: /*
68: * LOCKDEBUG
69: */
70:
71: #if defined(LOCKDEBUG)
72:
73: #define RW_WANTLOCK(rw, op) \
74: LOCKDEBUG_WANTLOCK(RW_GETID(rw), \
75: (uintptr_t)__builtin_return_address(0), op == RW_READER);
76: #define RW_LOCKED(rw, op) \
77: LOCKDEBUG_LOCKED(RW_GETID(rw), \
78: (uintptr_t)__builtin_return_address(0), op == RW_READER);
79: #define RW_UNLOCKED(rw, op) \
80: LOCKDEBUG_UNLOCKED(RW_GETID(rw), \
81: (uintptr_t)__builtin_return_address(0), op == RW_READER);
82: #define RW_DASSERT(rw, cond) \
83: do { \
84: if (!(cond)) \
85: RW_ABORT(rw, "assertion failed: " #cond); \
86: } while (/* CONSTCOND */ 0);
87:
88: #else /* LOCKDEBUG */
89:
90: #define RW_WANTLOCK(rw, op) /* nothing */
91: #define RW_LOCKED(rw, op) /* nothing */
92: #define RW_UNLOCKED(rw, op) /* nothing */
93: #define RW_DASSERT(rw, cond) /* nothing */
94:
95: #endif /* LOCKDEBUG */
96:
97: /*
98: * DIAGNOSTIC
99: */
100:
101: #if defined(DIAGNOSTIC)
102:
103: #define RW_ASSERT(rw, cond) \
104: do { \
105: if (!(cond)) \
106: RW_ABORT(rw, "assertion failed: " #cond); \
107: } while (/* CONSTCOND */ 0)
108:
109: #else
110:
111: #define RW_ASSERT(rw, cond) /* nothing */
112:
113: #endif /* DIAGNOSTIC */
114:
115: /*
116: * For platforms that use 'simple' RW locks.
117: */
118: #ifdef __HAVE_SIMPLE_RW_LOCKS
119: #define RW_ACQUIRE(rw, old, new) RW_CAS(&(rw)->rw_owner, old, new)
120: #define RW_RELEASE(rw, old, new) RW_CAS(&(rw)->rw_owner, old, new)
121: #define RW_SETID(rw, id) ((rw)->rw_id = id)
122: #define RW_GETID(rw) ((rw)->rw_id)
123:
124: static inline int
125: RW_SET_WAITERS(krwlock_t *rw, uintptr_t need, uintptr_t set)
126: {
127: uintptr_t old;
128:
129: if (((old = rw->rw_owner) & need) == 0)
130: return 0;
131: return RW_CAS(&rw->rw_owner, old, old | set);
132: }
133: #endif /* __HAVE_SIMPLE_RW_LOCKS */
134:
135: /*
136: * For platforms that do not provide stubs, or for the LOCKDEBUG case.
137: */
138: #ifdef LOCKDEBUG
139: #undef __HAVE_RW_STUBS
140: #endif
141:
142: #ifndef __HAVE_RW_STUBS
1.3.2.2 rmind 143: __strong_alias(rw_enter,rw_vector_enter);
144: __strong_alias(rw_exit,rw_vector_exit);
1.2 ad 145: #endif
146:
1.3.2.3 yamt 147: static void rw_dump(volatile void *);
148: static lwp_t *rw_owner(wchan_t);
1.2 ad 149:
150: lockops_t rwlock_lockops = {
151: "Reader / writer lock",
152: 1,
153: rw_dump
154: };
155:
1.3.2.1 yamt 156: syncobj_t rw_syncobj = {
157: SOBJ_SLEEPQ_SORTED,
158: turnstile_unsleep,
159: turnstile_changepri,
160: sleepq_lendpri,
161: rw_owner,
162: };
163:
1.2 ad 164: /*
165: * rw_dump:
166: *
167: * Dump the contents of a rwlock structure.
168: */
169: void
170: rw_dump(volatile void *cookie)
171: {
172: volatile krwlock_t *rw = cookie;
173:
174: printf_nolog("owner/count : %#018lx flags : %#018x\n",
175: (long)RW_OWNER(rw), (int)RW_FLAGS(rw));
176: }
177:
178: /*
179: * rw_init:
180: *
181: * Initialize a rwlock for use.
182: */
183: void
184: rw_init(krwlock_t *rw)
185: {
186: u_int id;
187:
188: memset(rw, 0, sizeof(*rw));
189:
190: id = LOCKDEBUG_ALLOC(rw, &rwlock_lockops);
191: RW_SETID(rw, id);
192: }
193:
194: /*
195: * rw_destroy:
196: *
197: * Tear down a rwlock.
198: */
199: void
200: rw_destroy(krwlock_t *rw)
201: {
202:
203: LOCKDEBUG_FREE(rw, RW_GETID(rw));
204: RW_ASSERT(rw, rw->rw_owner == 0);
205: }
206:
207: /*
208: * rw_vector_enter:
209: *
210: * Acquire a rwlock.
211: */
212: void
213: rw_vector_enter(krwlock_t *rw, const krw_t op)
214: {
215: uintptr_t owner, incr, need_wait, set_wait, curthread;
216: turnstile_t *ts;
217: int queue;
1.3.2.3 yamt 218: lwp_t *l;
1.2 ad 219: LOCKSTAT_TIMER(slptime);
220: LOCKSTAT_FLAG(lsflag);
221:
222: l = curlwp;
223: curthread = (uintptr_t)l;
224:
225: RW_ASSERT(rw, curthread != 0);
226: RW_WANTLOCK(rw, op);
227:
228: #ifdef LOCKDEBUG
229: if (panicstr == NULL) {
230: simple_lock_only_held(NULL, "rw_enter");
231: LOCKDEBUG_BARRIER(&kernel_lock, 1);
232: }
233: #endif
234:
235: /*
236: * We play a slight trick here. If we're a reader, we want
237: * increment the read count. If we're a writer, we want to
238: * set the owner field and whe WRITE_LOCKED bit.
239: *
240: * In the latter case, we expect those bits to be zero,
241: * therefore we can use an add operation to set them, which
242: * means an add operation for both cases.
243: */
244: if (__predict_true(op == RW_READER)) {
245: incr = RW_READ_INCR;
246: set_wait = RW_HAS_WAITERS;
247: need_wait = RW_WRITE_LOCKED | RW_WRITE_WANTED;
248: queue = TS_READER_Q;
249: } else {
250: RW_DASSERT(rw, op == RW_WRITER);
251: incr = curthread | RW_WRITE_LOCKED;
252: set_wait = RW_HAS_WAITERS | RW_WRITE_WANTED;
253: need_wait = RW_WRITE_LOCKED | RW_THREAD;
254: queue = TS_WRITER_Q;
255: }
256:
257: LOCKSTAT_ENTER(lsflag);
258:
259: for (;;) {
260: /*
261: * Read the lock owner field. If the need-to-wait
262: * indicator is clear, then try to acquire the lock.
263: */
264: owner = rw->rw_owner;
265: if ((owner & need_wait) == 0) {
266: if (RW_ACQUIRE(rw, owner, owner + incr)) {
267: /* Got it! */
268: break;
269: }
270:
271: /*
272: * Didn't get it -- spin around again (we'll
273: * probably sleep on the next iteration).
274: */
275: continue;
276: }
277:
278: if (panicstr != NULL)
279: return;
280: if (RW_OWNER(rw) == curthread)
281: RW_ABORT(rw, "locking against myself");
282:
283: /*
284: * Grab the turnstile chain lock. Once we have that, we
285: * can adjust the waiter bits and sleep queue.
286: */
287: ts = turnstile_lookup(rw);
288:
289: /*
290: * XXXSMP if this is a high priority LWP (interrupt handler
291: * or realtime) and acquiring a read hold, then we shouldn't
292: * wait for RW_WRITE_WANTED if our priority is >= that of
293: * the highest priority writer that is waiting.
294: */
295:
296: /*
297: * Mark the rwlock as having waiters. If the set fails,
298: * then we may not need to sleep and should spin again.
299: */
300: if (!RW_SET_WAITERS(rw, need_wait, set_wait)) {
301: turnstile_exit(rw);
302: continue;
303: }
304:
305: LOCKSTAT_START_TIMER(lsflag, slptime);
306:
1.3.2.1 yamt 307: turnstile_block(ts, queue, rw, &rw_syncobj);
1.2 ad 308:
309: /* If we wake up and arrive here, we've been handed the lock. */
310: RW_RECEIVE(rw);
311:
312: LOCKSTAT_STOP_TIMER(lsflag, slptime);
313: LOCKSTAT_EVENT(lsflag, rw,
314: LB_RWLOCK | (op == RW_WRITER ? LB_SLEEP1 : LB_SLEEP2),
315: 1, slptime);
316:
317: break;
318: }
319:
320: LOCKSTAT_EXIT(lsflag);
321:
322: RW_DASSERT(rw, (op != RW_READER && RW_OWNER(rw) == curthread) ||
323: (op == RW_READER && RW_COUNT(rw) != 0));
324: RW_LOCKED(rw, op);
325: }
326:
327: /*
328: * rw_vector_exit:
329: *
330: * Release a rwlock.
331: */
332: void
333: rw_vector_exit(krwlock_t *rw)
334: {
335: uintptr_t curthread, owner, decr, new;
336: turnstile_t *ts;
337: int rcnt, wcnt;
1.3.2.3 yamt 338: lwp_t *l;
1.2 ad 339:
340: curthread = (uintptr_t)curlwp;
341: RW_ASSERT(rw, curthread != 0);
342:
343: if (panicstr != NULL) {
344: /*
345: * XXX What's the correct thing to do here? We should at
346: * least release the lock.
347: */
348: return;
349: }
350:
351: /*
352: * Again, we use a trick. Since we used an add operation to
353: * set the required lock bits, we can use a subtract to clear
354: * them, which makes the read-release and write-release path
355: * the same.
356: */
357: owner = rw->rw_owner;
358: if (__predict_false((owner & RW_WRITE_LOCKED) != 0)) {
359: RW_UNLOCKED(rw, RW_WRITER);
360: RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) != 0);
361: RW_ASSERT(rw, RW_OWNER(rw) == curthread);
362: decr = curthread | RW_WRITE_LOCKED;
363: } else {
364: RW_UNLOCKED(rw, RW_READER);
365: RW_ASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) == 0);
366: RW_ASSERT(rw, RW_COUNT(rw) != 0);
367: decr = RW_READ_INCR;
368: }
369:
370: /*
371: * Compute what we expect the new value of the lock to be. Only
372: * proceed to do direct handoff if there are waiters, and if the
373: * lock would become unowned.
374: */
375: for (;; owner = rw->rw_owner) {
376: new = (owner - decr);
377: if ((new & (RW_THREAD | RW_HAS_WAITERS)) == RW_HAS_WAITERS)
378: break;
379: if (RW_RELEASE(rw, owner, new))
380: return;
381: }
382:
383: for (;;) {
384: /*
385: * Grab the turnstile chain lock. This gets the interlock
386: * on the sleep queue. Once we have that, we can adjust the
387: * waiter bits.
388: */
389: ts = turnstile_lookup(rw);
390: RW_DASSERT(rw, ts != NULL);
1.3 ad 391: RW_DASSERT(rw, (rw->rw_owner & RW_HAS_WAITERS) != 0);
1.2 ad 392:
393: owner = rw->rw_owner;
394: wcnt = TS_WAITERS(ts, TS_WRITER_Q);
395: rcnt = TS_WAITERS(ts, TS_READER_Q);
396:
397: /*
398: * Give the lock away.
399: *
400: * If we are releasing a write lock, then wake all
401: * outstanding readers. If we are releasing a read
402: * lock, then wake one writer.
403: */
404: if (rcnt == 0 || (decr == RW_READ_INCR && wcnt != 0)) {
405: RW_DASSERT(rw, wcnt != 0);
406: RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_WANTED) != 0);
407:
408: /*
409: * Give the lock to the longest waiting
410: * writer.
411: */
412: l = TS_FIRST(ts, TS_WRITER_Q);
413: new = (uintptr_t)l | RW_WRITE_LOCKED;
414:
415: if (wcnt > 1)
416: new |= RW_HAS_WAITERS | RW_WRITE_WANTED;
417: else if (rcnt != 0)
418: new |= RW_HAS_WAITERS;
419:
420: RW_GIVE(rw);
421: if (!RW_RELEASE(rw, owner, new)) {
422: /* Oops, try again. */
423: turnstile_exit(rw);
424: continue;
425: }
426:
427: /* Wake the writer. */
1.3.2.3 yamt 428: turnstile_wakeup(ts, TS_WRITER_Q, 1, l);
1.2 ad 429: } else {
430: RW_DASSERT(rw, rcnt != 0);
431:
432: /*
1.3 ad 433: * Give the lock to all blocked readers. If there
434: * is a writer waiting, new readers that arrive
435: * after the release will be blocked out.
1.2 ad 436: */
437: new = rcnt << RW_READ_COUNT_SHIFT;
438: if (wcnt != 0)
439: new |= RW_HAS_WAITERS | RW_WRITE_WANTED;
440:
441: RW_GIVE(rw);
442: if (!RW_RELEASE(rw, owner, new)) {
443: /* Oops, try again. */
444: turnstile_exit(rw);
445: continue;
446: }
447:
448: /* Wake up all sleeping readers. */
449: turnstile_wakeup(ts, TS_READER_Q, rcnt, NULL);
450: }
451:
452: break;
453: }
454: }
455:
456: /*
457: * rw_tryenter:
458: *
459: * Try to acquire a rwlock.
460: */
461: int
462: rw_tryenter(krwlock_t *rw, const krw_t op)
463: {
464: uintptr_t curthread, owner, incr, need_wait;
465:
466: curthread = (uintptr_t)curlwp;
467:
468: RW_ASSERT(rw, curthread != 0);
469: RW_WANTLOCK(rw, op);
470:
471: if (op == RW_READER) {
472: incr = RW_READ_INCR;
473: need_wait = RW_WRITE_LOCKED | RW_WRITE_WANTED;
474: } else {
475: RW_DASSERT(rw, op == RW_WRITER);
476: incr = curthread | RW_WRITE_LOCKED;
477: need_wait = RW_WRITE_LOCKED | RW_THREAD;
478: }
479:
480: for (;;) {
481: owner = rw->rw_owner;
482: if ((owner & need_wait) == 0) {
483: if (RW_ACQUIRE(rw, owner, owner + incr)) {
484: /* Got it! */
485: break;
486: }
487: continue;
488: }
489: return 0;
490: }
491:
492: RW_LOCKED(rw, op);
493: RW_DASSERT(rw, (op != RW_READER && RW_OWNER(rw) == curthread) ||
494: (op == RW_READER && RW_COUNT(rw) != 0));
1.3.2.3 yamt 495:
1.2 ad 496: return 1;
497: }
498:
499: /*
500: * rw_downgrade:
501: *
502: * Downgrade a write lock to a read lock.
503: */
504: void
505: rw_downgrade(krwlock_t *rw)
506: {
507: uintptr_t owner, curthread, new;
508: turnstile_t *ts;
509: int rcnt, wcnt;
510:
511: curthread = (uintptr_t)curlwp;
512: RW_ASSERT(rw, curthread != 0);
513: RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) != 0);
514: RW_ASSERT(rw, RW_OWNER(rw) == curthread);
515: RW_UNLOCKED(rw, RW_WRITER);
516:
517: owner = rw->rw_owner;
518: if ((owner & RW_HAS_WAITERS) == 0) {
519: /*
520: * There are no waiters, so we can do this the easy way.
521: * Try swapping us down to one read hold. If it fails, the
522: * lock condition has changed and we most likely now have
523: * waiters.
524: */
525: if (RW_RELEASE(rw, owner, RW_READ_INCR)) {
526: RW_LOCKED(rw, RW_READER);
527: RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) == 0);
528: RW_DASSERT(rw, RW_COUNT(rw) != 0);
529: return;
530: }
531: }
532:
533: /*
534: * Grab the turnstile chain lock. This gets the interlock
535: * on the sleep queue. Once we have that, we can adjust the
536: * waiter bits.
537: */
538: for (;;) {
539: ts = turnstile_lookup(rw);
540: RW_DASSERT(rw, ts != NULL);
541:
542: owner = rw->rw_owner;
543: rcnt = TS_WAITERS(ts, TS_READER_Q);
544: wcnt = TS_WAITERS(ts, TS_WRITER_Q);
545:
546: /*
547: * If there are no readers, just preserve the waiters
548: * bits, swap us down to one read hold and return.
549: */
550: if (rcnt == 0) {
551: RW_DASSERT(rw, wcnt != 0);
552: RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_WANTED) != 0);
553: RW_DASSERT(rw, (rw->rw_owner & RW_HAS_WAITERS) != 0);
554:
555: new = RW_READ_INCR | RW_HAS_WAITERS | RW_WRITE_WANTED;
556: if (!RW_RELEASE(rw, owner, new)) {
557: /* Oops, try again. */
558: turnstile_exit(ts);
559: continue;
560: }
561: break;
562: }
563:
564: /*
565: * Give the lock to all blocked readers. We may
566: * retain one read hold if downgrading. If there
567: * is a writer waiting, new readers will be blocked
568: * out.
569: */
570: new = (rcnt << RW_READ_COUNT_SHIFT) + RW_READ_INCR;
571: if (wcnt != 0)
572: new |= RW_HAS_WAITERS | RW_WRITE_WANTED;
573:
574: RW_GIVE(rw);
575: if (!RW_RELEASE(rw, owner, new)) {
576: /* Oops, try again. */
577: turnstile_exit(rw);
578: continue;
579: }
580:
581: /* Wake up all sleeping readers. */
582: turnstile_wakeup(ts, TS_READER_Q, rcnt, NULL);
583: break;
584: }
585:
586: RW_LOCKED(rw, RW_READER);
587: RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) == 0);
588: RW_DASSERT(rw, RW_COUNT(rw) != 0);
589: }
590:
591: /*
592: * rw_tryupgrade:
593: *
594: * Try to upgrade a read lock to a write lock. We must be the
595: * only reader.
596: */
597: int
598: rw_tryupgrade(krwlock_t *rw)
599: {
600: uintptr_t owner, curthread, new;
601:
602: curthread = (uintptr_t)curlwp;
603: RW_ASSERT(rw, curthread != 0);
604: RW_WANTLOCK(rw, RW_WRITER);
605:
606: for (;;) {
607: owner = rw->rw_owner;
608: RW_ASSERT(rw, (owner & RW_WRITE_LOCKED) == 0);
609: if ((owner & RW_THREAD) != RW_READ_INCR) {
610: RW_ASSERT(rw, (owner & RW_THREAD) != 0);
611: return 0;
612: }
613: new = curthread | RW_WRITE_LOCKED | (owner & ~RW_THREAD);
614: if (RW_ACQUIRE(rw, owner, new))
615: break;
616: }
617:
618: RW_UNLOCKED(rw, RW_READER);
619: RW_LOCKED(rw, RW_WRITER);
620: RW_DASSERT(rw, rw->rw_owner & RW_WRITE_LOCKED);
621: RW_DASSERT(rw, RW_OWNER(rw) == curthread);
622:
623: return 1;
624: }
625:
626: /*
627: * rw_read_held:
628: *
629: * Returns true if the rwlock is held for reading. Must only be
630: * used for diagnostic assertions, and never be used to make
631: * decisions about how to use a rwlock.
632: */
633: int
634: rw_read_held(krwlock_t *rw)
635: {
636: uintptr_t owner;
637:
638: if (panicstr != NULL)
639: return 1;
640:
641: owner = rw->rw_owner;
642: return (owner & RW_WRITE_LOCKED) == 0 && (owner & RW_THREAD) != 0;
643: }
644:
645: /*
646: * rw_write_held:
647: *
648: * Returns true if the rwlock is held for writing. Must only be
649: * used for diagnostic assertions, and never be used to make
650: * decisions about how to use a rwlock.
651: */
652: int
653: rw_write_held(krwlock_t *rw)
654: {
655:
656: if (panicstr != NULL)
657: return 1;
658:
659: return (rw->rw_owner & RW_WRITE_LOCKED) != 0;
660: }
661:
662: /*
663: * rw_lock_held:
664: *
665: * Returns true if the rwlock is held for reading or writing. Must
666: * only be used for diagnostic assertions, and never be used to make
667: * decisions about how to use a rwlock.
668: */
669: int
670: rw_lock_held(krwlock_t *rw)
671: {
672:
673: if (panicstr != NULL)
674: return 1;
675:
676: return (rw->rw_owner & RW_THREAD) != 0;
677: }
1.3.2.1 yamt 678:
679: /*
680: * rw_owner:
681: *
682: * Return the current owner of an RW lock, but only if it is write
683: * held. Used for priority inheritance.
684: */
1.3.2.3 yamt 685: static lwp_t *
1.3.2.1 yamt 686: rw_owner(wchan_t obj)
687: {
688: krwlock_t *rw = (void *)(uintptr_t)obj; /* discard qualifiers */
689: uintptr_t owner = rw->rw_owner;
690:
691: if ((owner & RW_WRITE_LOCKED) == 0)
692: return NULL;
693:
694: return (void *)(owner & RW_THREAD);
695: }