Annotation of sys/kern/kern_rwlock.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: kern_rwlock.c,v 1.13 2007/05/13 04:52:32 tedu Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2002, 2003 Artur Grabowski <art@openbsd.org>
! 5: * All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: *
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. The name of the author may not be used to endorse or promote products
! 14: * derived from this software without specific prior written permission.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
! 17: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
! 18: * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
! 19: * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
! 20: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
! 21: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
! 22: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! 23: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
! 24: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
! 25: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 26: */
! 27:
! 28: #include <sys/param.h>
! 29: #include <sys/systm.h>
! 30: #include <sys/proc.h>
! 31: #include <sys/rwlock.h>
! 32: #include <sys/limits.h>
! 33:
! 34: #include <machine/lock.h>
! 35:
! 36: /* XXX - temporary measure until proc0 is properly aligned */
! 37: #define RW_PROC(p) (((long)p) & ~RWLOCK_MASK)
! 38:
! 39: /*
! 40: * Magic wand for lock operations. Every operation checks if certain
! 41: * flags are set and if they aren't, it increments the lock with some
! 42: * value (that might need some computing in a few cases). If the operation
! 43: * fails, we need to set certain flags while waiting for the lock.
! 44: *
! 45: * RW_WRITE The lock must be completely empty. We increment it with
! 46: * RWLOCK_WRLOCK and the proc pointer of the holder.
! 47: * Sets RWLOCK_WAIT|RWLOCK_WRWANT while waiting.
! 48: * RW_READ RWLOCK_WRLOCK|RWLOCK_WRWANT may not be set. We increment
! 49: * with RWLOCK_READ_INCR. RWLOCK_WAIT while waiting.
! 50: */
! 51: static const struct rwlock_op {
! 52: unsigned long inc;
! 53: unsigned long check;
! 54: unsigned long wait_set;
! 55: long proc_mult;
! 56: int wait_prio;
! 57: } rw_ops[] = {
! 58: { /* RW_WRITE */
! 59: RWLOCK_WRLOCK,
! 60: ULONG_MAX,
! 61: RWLOCK_WAIT | RWLOCK_WRWANT,
! 62: 1,
! 63: PLOCK - 4
! 64: },
! 65: { /* RW_READ */
! 66: RWLOCK_READ_INCR,
! 67: RWLOCK_WRLOCK,
! 68: RWLOCK_WAIT,
! 69: 0,
! 70: PLOCK
! 71: },
! 72: { /* RW_DOWNGRADE */
! 73: RWLOCK_READ_INCR - RWLOCK_WRLOCK,
! 74: 0,
! 75: 0,
! 76: -1,
! 77: PLOCK
! 78: },
! 79: };
! 80:
! 81: #ifndef __HAVE_MD_RWLOCK
! 82: /*
! 83: * Simple cases that should be in MD code and atomic.
! 84: */
! 85: void
! 86: rw_enter_read(struct rwlock *rwl)
! 87: {
! 88: unsigned long owner = rwl->rwl_owner;
! 89:
! 90: if (__predict_false((owner & RWLOCK_WRLOCK) ||
! 91: rw_cas(&rwl->rwl_owner, owner, owner + RWLOCK_READ_INCR)))
! 92: rw_enter(rwl, RW_READ);
! 93: }
! 94:
! 95: void
! 96: rw_enter_write(struct rwlock *rwl)
! 97: {
! 98: struct proc *p = curproc;
! 99:
! 100: if (__predict_false(rw_cas(&rwl->rwl_owner, 0,
! 101: RW_PROC(p) | RWLOCK_WRLOCK)))
! 102: rw_enter(rwl, RW_WRITE);
! 103: }
! 104:
! 105: void
! 106: rw_exit_read(struct rwlock *rwl)
! 107: {
! 108: unsigned long owner = rwl->rwl_owner;
! 109:
! 110: if (__predict_false((owner & RWLOCK_WAIT) ||
! 111: rw_cas(&rwl->rwl_owner, owner, owner - RWLOCK_READ_INCR)))
! 112: rw_exit(rwl);
! 113: }
! 114:
! 115: void
! 116: rw_exit_write(struct rwlock *rwl)
! 117: {
! 118: unsigned long owner = rwl->rwl_owner;
! 119:
! 120: if (__predict_false((owner & RWLOCK_WAIT) ||
! 121: rw_cas(&rwl->rwl_owner, owner, 0)))
! 122: rw_exit(rwl);
! 123: }
! 124:
! 125: #ifndef rw_cas
! 126: int
! 127: rw_cas(volatile unsigned long *p, unsigned long o, unsigned long n)
! 128: {
! 129: if (*p != o)
! 130: return (1);
! 131: *p = n;
! 132:
! 133: return (0);
! 134: }
! 135: #endif
! 136:
! 137: #endif
! 138:
! 139: #ifdef DIAGNOSTIC
! 140: /*
! 141: * Put the diagnostic functions here to keep the main code free
! 142: * from ifdef clutter.
! 143: */
! 144: static void
! 145: rw_enter_diag(struct rwlock *rwl, int flags)
! 146: {
! 147: switch (flags & RW_OPMASK) {
! 148: case RW_WRITE:
! 149: case RW_READ:
! 150: if (RW_PROC(curproc) == RW_PROC(rwl->rwl_owner))
! 151: panic("rw_enter: %s locking against myself",
! 152: rwl->rwl_name);
! 153: break;
! 154: case RW_DOWNGRADE:
! 155: /*
! 156: * If we're downgrading, we must hold the write lock.
! 157: */
! 158: if ((rwl->rwl_owner & RWLOCK_WRLOCK) == 0)
! 159: panic("rw_enter: %s downgrade of non-write lock",
! 160: rwl->rwl_name);
! 161: if (RW_PROC(curproc) != RW_PROC(rwl->rwl_owner))
! 162: panic("rw_enter: %s downgrade, not holder",
! 163: rwl->rwl_name);
! 164: break;
! 165:
! 166: default:
! 167: panic("rw_enter: unknown op 0x%x", flags);
! 168: }
! 169: }
! 170:
! 171: #else
! 172: #define rw_enter_diag(r, f)
! 173: #endif
! 174:
! 175: void
! 176: rw_init(struct rwlock *rwl, const char *name)
! 177: {
! 178: rwl->rwl_owner = 0;
! 179: rwl->rwl_name = name;
! 180: }
! 181:
! 182: int
! 183: rw_enter(struct rwlock *rwl, int flags)
! 184: {
! 185: const struct rwlock_op *op;
! 186: struct sleep_state sls;
! 187: unsigned long inc, o;
! 188: int error;
! 189:
! 190: op = &rw_ops[flags & RW_OPMASK];
! 191:
! 192: inc = op->inc + RW_PROC(curproc) * op->proc_mult;
! 193: retry:
! 194: while (__predict_false(((o = rwl->rwl_owner) & op->check) != 0)) {
! 195: unsigned long set = o | op->wait_set;
! 196: int do_sleep;
! 197:
! 198: rw_enter_diag(rwl, flags);
! 199:
! 200: if (flags & RW_NOSLEEP)
! 201: return (EBUSY);
! 202:
! 203: sleep_setup(&sls, rwl, op->wait_prio, rwl->rwl_name);
! 204: if (flags & RW_INTR)
! 205: sleep_setup_signal(&sls, op->wait_prio | PCATCH);
! 206:
! 207: do_sleep = !rw_cas(&rwl->rwl_owner, o, set);
! 208:
! 209: sleep_finish(&sls, do_sleep);
! 210: if ((flags & RW_INTR) &&
! 211: (error = sleep_finish_signal(&sls)) != 0)
! 212: return (error);
! 213: if (flags & RW_SLEEPFAIL)
! 214: return (EAGAIN);
! 215: }
! 216:
! 217: if (__predict_false(rw_cas(&rwl->rwl_owner, o, o + inc)))
! 218: goto retry;
! 219:
! 220: /*
! 221: * If old lock had RWLOCK_WAIT and RWLOCK_WRLOCK set, it means we
! 222: * downgraded a write lock and had possible read waiter, wake them
! 223: * to let them retry the lock.
! 224: */
! 225: if (__predict_false((o & (RWLOCK_WRLOCK|RWLOCK_WAIT)) ==
! 226: (RWLOCK_WRLOCK|RWLOCK_WAIT)))
! 227: wakeup(rwl);
! 228:
! 229: return (0);
! 230: }
! 231:
! 232: void
! 233: rw_exit(struct rwlock *rwl)
! 234: {
! 235: unsigned long owner = rwl->rwl_owner;
! 236: int wrlock = owner & RWLOCK_WRLOCK;
! 237: unsigned long set;
! 238:
! 239: do {
! 240: owner = rwl->rwl_owner;
! 241: if (wrlock)
! 242: set = 0;
! 243: else
! 244: set = (owner - RWLOCK_READ_INCR) &
! 245: ~(RWLOCK_WAIT|RWLOCK_WRWANT);
! 246: } while (rw_cas(&rwl->rwl_owner, owner, set));
! 247:
! 248: if (owner & RWLOCK_WAIT)
! 249: wakeup(rwl);
! 250: }
CVSweb
![[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 [local] / sys / kern