#ifndef _ALPHA_SEMAPHORE_H #define _ALPHA_SEMAPHORE_H /* * SMP- and interrupt-safe semaphores.. * * (C) Copyright 1996 Linus Torvalds * (C) Copyright 1996, 2000 Richard Henderson */ #include <asm/current.h> #include <asm/system.h> #include <asm/atomic.h> #include <linux/compiler.h> #include <linux/wait.h> #include <linux/rwsem.h> struct semaphore { atomic_t count; wait_queue_head_t wait; }; #define __SEMAPHORE_INITIALIZER(name, n) \ { \ .count = ATOMIC_INIT(n), \ .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \ } #define __DECLARE_SEMAPHORE_GENERIC(name,count) \ struct semaphore name = __SEMAPHORE_INITIALIZER(name,count) #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1) #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0) static inline void sema_init(struct semaphore *sem, int val) { /* * Logically, * *sem = (struct semaphore)__SEMAPHORE_INITIALIZER((*sem),val); * except that gcc produces better initializing by parts yet. */ atomic_set(&sem->count, val); init_waitqueue_head(&sem->wait); } static inline void init_MUTEX (struct semaphore *sem) { sema_init(sem, 1); } static inline void init_MUTEX_LOCKED (struct semaphore *sem) { sema_init(sem, 0); } extern void down(struct semaphore *); extern void __down_failed(struct semaphore *); extern int down_interruptible(struct semaphore *); extern int __down_failed_interruptible(struct semaphore *); extern int down_trylock(struct semaphore *); extern void up(struct semaphore *); extern void __up_wakeup(struct semaphore *); /* * Hidden out of line code is fun, but extremely messy. Rely on newer * compilers to do a respectable job with this. The contention cases * are handled out of line in arch/alpha/kernel/semaphore.c. */ static inline void __down(struct semaphore *sem) { long count; might_sleep(); count = atomic_dec_return(&sem->count); if (unlikely(count < 0)) __down_failed(sem); } static inline int __down_interruptible(struct semaphore *sem) { long count; might_sleep(); count = atomic_dec_return(&sem->count); if (unlikely(count < 0)) return __down_failed_interruptible(sem); return 0; } /* * down_trylock returns 0 on success, 1 if we failed to get the lock. */ static inline int __down_trylock(struct semaphore *sem) { long ret; /* "Equivalent" C: do { ret = ldl_l; --ret; if (ret < 0) break; ret = stl_c = ret; } while (ret == 0); */ __asm__ __volatile__( "1: ldl_l %0,%1\n" " subl %0,1,%0\n" " blt %0,2f\n" " stl_c %0,%1\n" " beq %0,3f\n" " mb\n" "2:\n" ".subsection 2\n" "3: br 1b\n" ".previous" : "=&r" (ret), "=m" (sem->count) : "m" (sem->count)); return ret < 0; } static inline void __up(struct semaphore *sem) { if (unlikely(atomic_inc_return(&sem->count) <= 0)) __up_wakeup(sem); } #if !defined(CONFIG_DEBUG_SEMAPHORE) extern inline void down(struct semaphore *sem) { __down(sem); } extern inline int down_interruptible(struct semaphore *sem) { return __down_interruptible(sem); } extern inline int down_trylock(struct semaphore *sem) { return __down_trylock(sem); } extern inline void up(struct semaphore *sem) { __up(sem); } #endif #endif