Return to simplelock.h CVS log

Up to [local] / sys / sys

Annotation of sys/sys/simplelock.h, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: simplelock.h,v 1.11 2004/06/13 21:49:28 niklas Exp $  */
                      2:
                      3: #ifndef _SIMPLELOCK_H_
                      4: #define _SIMPLELOCK_H_
                      5:
                      6: #ifdef MULTIPROCESSOR
                      7: #include <machine/lock.h>
                      8: #endif
                      9:
                     10: /*
                     11:  * A simple spin lock.
                     12:  *
                     13:  * This structure only sets one bit of data, but is sized based on the
                     14:  * minimum word size that can be operated on by the hardware test-and-set
                     15:  * instruction. It is only needed for multiprocessors, as uniprocessors
                     16:  * will always run to completion or a sleep. It is an error to hold one
                     17:  * of these locks while a process is sleeping.
                     18:  */
                     19: struct simplelock {
                     20: #ifdef MULTIPROCESSOR
                     21:        __cpu_simple_lock_t lock_data;
                     22: #else
                     23:        int     lock_data;
                     24: #endif
                     25: };
                     26:
                     27: #ifdef _KERNEL
                     28:
                     29: /*
                     30:  * We can't debug locks when we use them in real life.
                     31:  */
                     32: #if defined(MULTIPROCESSOR) && defined(LOCKDEBUG)
                     33: #undef LOCKDEBUG
                     34: #endif
                     35:
                     36: #if !defined(MULTIPROCESSOR) || 1
                     37:
                     38: #define SLOCK_LOCKED 1
                     39: #define SLOCK_UNLOCKED 0
                     40:
                     41: #ifndef LOCKDEBUG
                     42:
                     43: #define        simple_lock(lkp)
                     44: #define        simple_lock_try(lkp)    (1)     /* always succeeds */
                     45: #define        simple_unlock(lkp)
                     46: #define simple_lock_assert(lkp)
                     47:
                     48: static __inline void simple_lock_init(struct simplelock *lkp)
                     49: {
                     50:
                     51:        lkp->lock_data = SLOCK_UNLOCKED;
                     52: }
                     53:
                     54: #else
                     55:
                     56: void _simple_unlock(__volatile struct simplelock *, const char *, int);
                     57: int _simple_lock_try(__volatile struct simplelock *, const char *, int);
                     58: void _simple_lock(__volatile struct simplelock *, const char *, int);
                     59: void _simple_lock_assert(__volatile struct simplelock *, int, const char *, int);
                     60:
                     61: void simple_lock_init(struct simplelock *);
                     62: #define simple_unlock(lkp) _simple_unlock(lkp, __FILE__, __LINE__)
                     63: #define simple_lock_try(lkp) _simple_lock_try(lkp, __FILE__, __LINE__)
                     64: #define simple_lock(lkp) _simple_lock(lkp, __FILE__, __LINE__)
                     65: #define simple_lock_assert(lkp, state) _simple_lock_assert(lkp, state, __FILE__, __LINE__)
                     66:
                     67: #endif /* !defined(LOCKDEBUG) */
                     68:
                     69: #else  /* MULTIPROCESSOR */
                     70:
                     71: /*
                     72:  * The simple-lock routines are the primitives out of which the lock
                     73:  * package is built. The machine-dependent code must implement an
                     74:  * atomic test_and_set operation that indivisibly sets the simple lock
                     75:  * to non-zero and returns its old value. It also assumes that the
                     76:  * setting of the lock to zero below is indivisible. Simple locks may
                     77:  * only be used for exclusive locks.
                     78:  */
                     79:
                     80: static __inline void simple_lock_init(struct simplelock *lkp)
                     81: {
                     82:        __cpu_simple_lock_init(&lkp->lock_data);
                     83: }
                     84:
                     85: static __inline void simple_lock(__volatile struct simplelock *lkp)
                     86: {
                     87:        __cpu_simple_lock(&lkp->lock_data);
                     88: }
                     89:
                     90: static __inline int simple_lock_try(__volatile struct simplelock *lkp)
                     91: {
                     92:        return (__cpu_simple_lock_try(&lkp->lock_data));
                     93: }
                     94:
                     95: static __inline void simple_unlock(__volatile struct simplelock *lkp)
                     96: {
                     97:        __cpu_simple_unlock(&lkp->lock_data);
                     98: }
                     99: #endif /* MULTIPROCESSOR */
                    100:
                    101: #endif /* _KERNEL */
                    102:
                    103: #endif /* !_SIMPLELOCK_H_ */