Annotation of sys/sys/mplock.h, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: mplock.h,v 1.8 2005/06/17 22:33:34 niklas Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2004 Niklas Hallqvist. All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: *
! 15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 16: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 17: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 18: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 19: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 20: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 21: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 22: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 23: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 24: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 25: */
! 26:
! 27: #ifndef _MPLOCK_H_
! 28: #define _MPLOCK_H_
! 29:
! 30: /*
! 31: * Really simple spinlock implementation with recursive capabilities.
! 32: * Correctness is paramount, no fancyness allowed.
! 33: */
! 34:
! 35: struct __mp_lock {
! 36: __cpu_simple_lock_t mpl_lock;
! 37: cpuid_t mpl_cpu;
! 38: int mpl_count;
! 39: };
! 40:
! 41: static __inline void __mp_lock_init(struct __mp_lock *);
! 42: static __inline void __mp_lock(struct __mp_lock *);
! 43: static __inline void __mp_unlock(struct __mp_lock *);
! 44: static __inline int __mp_release_all(struct __mp_lock *);
! 45: static __inline void __mp_acquire_count(struct __mp_lock *, int);
! 46: static __inline int __mp_lock_held(struct __mp_lock *);
! 47:
! 48: /*
! 49: * XXX Simplelocks macros used at "trusted" places.
! 50: */
! 51: #define SIMPLELOCK __mp_lock
! 52: #define SIMPLE_LOCK_INIT __mp_lock_init
! 53: #define SIMPLE_LOCK __mp_lock
! 54: #define SIMPLE_UNLOCK __mp_unlock
! 55:
! 56: static __inline void
! 57: __mp_lock_init(struct __mp_lock *lock)
! 58: {
! 59: __cpu_simple_lock_init(&lock->mpl_lock);
! 60: lock->mpl_cpu = LK_NOCPU;
! 61: lock->mpl_count = 0;
! 62: }
! 63:
! 64: #if defined(MP_LOCKDEBUG)
! 65: #ifndef DDB
! 66: #error "MP_LOCKDEBUG requires DDB"
! 67: #endif
! 68:
! 69: extern void Debugger(void);
! 70: extern int db_printf(const char *, ...)
! 71: __attribute__((__format__(__kprintf__,1,2)));
! 72:
! 73: /* CPU-dependent timing, needs this to be settable from ddb. */
! 74: extern int __mp_lock_spinout;
! 75: #endif
! 76:
! 77: static __inline void
! 78: __mp_lock(struct __mp_lock *lock)
! 79: {
! 80: int s = spllock();
! 81:
! 82: if (lock->mpl_cpu != cpu_number()) {
! 83: #ifndef MP_LOCKDEBUG
! 84: __cpu_simple_lock(&lock->mpl_lock);
! 85: #else
! 86: {
! 87: int got_it;
! 88: do {
! 89: int ticks = __mp_lock_spinout;
! 90:
! 91: do {
! 92: got_it = __cpu_simple_lock_try(
! 93: &lock->mpl_lock);
! 94: } while (!got_it && ticks-- > 0);
! 95: if (!got_it) {
! 96: db_printf(
! 97: "__mp_lock(0x%x): lock spun out",
! 98: lock);
! 99: Debugger();
! 100: }
! 101: } while (!got_it);
! 102: }
! 103: #endif
! 104: lock->mpl_cpu = cpu_number();
! 105: }
! 106: lock->mpl_count++;
! 107: splx(s);
! 108: }
! 109:
! 110: /*
! 111: * Try to acquire the lock, if another cpu has it, fill it in the
! 112: * call-by-reference cpu parameter. Return true if acquired.
! 113: */
! 114: static __inline int
! 115: __mp_lock_try(struct __mp_lock *lock, cpuid_t *cpu)
! 116: {
! 117: int s = spllock();
! 118:
! 119: if (lock->mpl_cpu != cpu_number()) {
! 120: if (!__cpu_simple_lock_try(&lock->mpl_lock)) {
! 121: *cpu = lock->mpl_cpu;
! 122: splx(s);
! 123: return 0;
! 124: }
! 125: lock->mpl_cpu = cpu_number();
! 126: }
! 127: lock->mpl_count++;
! 128: splx(s);
! 129: return 1;
! 130: }
! 131:
! 132: static __inline void
! 133: __mp_unlock(struct __mp_lock *lock)
! 134: {
! 135: int s = spllock();
! 136:
! 137: #ifdef MP_LOCKDEBUG
! 138: if (lock->mpl_count == 0 || lock->mpl_cpu == LK_NOCPU) {
! 139: db_printf("__mp_unlock(0x%x): releasing not locked lock\n",
! 140: lock);
! 141: Debugger();
! 142: }
! 143: #endif
! 144:
! 145: if (--lock->mpl_count == 0) {
! 146: lock->mpl_cpu = LK_NOCPU;
! 147: __cpu_simple_unlock(&lock->mpl_lock);
! 148: }
! 149: splx(s);
! 150: }
! 151:
! 152: static __inline int
! 153: __mp_release_all(struct __mp_lock *lock) {
! 154: int s = spllock();
! 155: int rv = lock->mpl_count;
! 156:
! 157: #ifdef MP_LOCKDEBUG
! 158: if (lock->mpl_count == 0 || lock->mpl_cpu == LK_NOCPU) {
! 159: db_printf(
! 160: "__mp_release_all(0x%x): releasing not locked lock\n",
! 161: lock);
! 162: Debugger();
! 163: }
! 164: #endif
! 165:
! 166: lock->mpl_cpu = LK_NOCPU;
! 167: lock->mpl_count = 0;
! 168: __cpu_simple_unlock(&lock->mpl_lock);
! 169: splx(s);
! 170: return (rv);
! 171: }
! 172:
! 173: static __inline int
! 174: __mp_release_all_but_one(struct __mp_lock *lock) {
! 175: int s = spllock();
! 176: int rv = lock->mpl_count - 1;
! 177:
! 178: #ifdef MP_LOCKDEBUG
! 179: if (lock->mpl_count == 0 || lock->mpl_cpu == LK_NOCPU) {
! 180: db_printf(
! 181: "__mp_release_all_but_one(0x%x): releasing not locked lock\n",
! 182: lock);
! 183: Debugger();
! 184: }
! 185: #endif
! 186:
! 187: lock->mpl_count = 1;
! 188: splx(s);
! 189: return (rv);
! 190: }
! 191:
! 192: static __inline void
! 193: __mp_acquire_count(struct __mp_lock *lock, int count) {
! 194: int s = spllock();
! 195:
! 196: while (count--)
! 197: __mp_lock(lock);
! 198: splx(s);
! 199: }
! 200:
! 201: static __inline int
! 202: __mp_lock_held(struct __mp_lock *lock) {
! 203: return lock->mpl_count && lock->mpl_cpu == cpu_number();
! 204: }
! 205:
! 206: extern struct __mp_lock kernel_lock;
! 207:
! 208: #endif /* !_MPLOCK_H */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to mplock.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / sys