Return to simplelock.h CVS log

Up to [local] / sys / sys

Annotation of sys/sys/simplelock.h, Revision 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_ */