Viewing file:  spinlock.h (2.13 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#ifndef __ASM_SPINLOCK_H
#define __ASM_SPINLOCK_H
#include <asm/system.h>
/* we seem to be the only architecture that uses 0 to mean locked - but we
* have to. prumpf */
#undef SPIN_LOCK_UNLOCKED
#define SPIN_LOCK_UNLOCKED (spinlock_t) { 1 }
#define spin_lock_init(x) do { (x)->lock = 1; } while(0)
#define spin_unlock_wait(x) do { barrier(); } while(((volatile spinlock_t *)(x))->lock == 1)
#define spin_lock(x) \
do { while(__ldcw(&(x)->lock) == 0); } while(0)
#define spin_unlock(x) \
do { (x)->lock = 1; } while(0)
#define spin_trylock(x) (__ldcw(&(x)->lock) == 1)
/*
* Read-write spinlocks, allowing multiple readers
* but only one writer.
*/
typedef struct {
spinlock_t lock;
volatile int counter;
} rwlock_t;
#define RW_LOCK_UNLOCKED (rwlock_t) { SPIN_LOCK_UNLOCKED, 0 }
/* read_lock, read_unlock are pretty straightforward. Of course it somehow
* sucks we end up saving/restoring flags twice for read_lock_irqsave aso. */
static inline void read_lock(rwlock_t *rw)
{
unsigned long flags;
spin_lock_irqsave(&rw->lock, flags);
rw->counter++;
spin_unlock_irqrestore(&rw->lock, flags);
}
static inline void read_unlock(rwlock_t *rw)
{
unsigned long flags;
spin_lock_irqsave(&rw->lock, flags);
rw->counter--;
spin_unlock_irqrestore(&rw->lock, flags);
}
/* write_lock is less trivial. We optimistically grab the lock and check
* if we surprised any readers. If so we release the lock and wait till
* they're all gone before trying again
*
* Also note that we don't use the _irqsave / _irqrestore suffixes here.
* If we're called with interrupts enabled and we've got readers (or other
* writers) in interrupt handlers someone fucked up and we'd dead-lock
* sooner or later anyway. prumpf */
static inline void write_lock(rwlock_t *rw)
{
retry:
spin_lock(&rw->lock);
if(rw->counter != 0) {
/* this basically never happens */
spin_unlock(&rw->lock);
while(rw->counter != 0);
goto retry;
}
/* got it. now leave without unlocking */
}
/* write_unlock is absolutely trivial - we don't have to wait for anything */
static inline void write_unlock(rwlock_t *rw)
{
spin_unlock(&rw->lock);
}
#endif /* __ASM_SPINLOCK_H */
|