5,212 → 5,64 |
|
#ifdef __KERNEL__ |
|
/* |
* SMP- and interrupt-safe semaphores.. |
* |
* (C) Copyright 1996 Linus Torvalds |
* |
* Modified 1996-12-23 by Dave Grothe <dave@gcom.com> to fix bugs in |
* the original code and to make semaphore waits |
* interruptible so that processes waiting on |
* semaphores can be killed. |
* Modified 1999-02-14 by Andrea Arcangeli, split the sched.c helper |
* functions in asm/sempahore-helper.h while fixing a |
* potential and subtle race discovered by Ulrich Schmid |
* in down_interruptible(). Since I started to play here I |
* also implemented the `trylock' semaphore operation. |
* 1999-07-02 Artur Skawina <skawina@geocities.com> |
* Optimized "0(ecx)" -> "(ecx)" (the assembler does not |
* do this). Changed calling sequences from push/jmp to |
* traditional call/ret. |
* Modified 2001-01-01 Andreas Franck <afranck@gmx.de> |
* Some hacks to ensure compatibility with recent |
* GCC snapshots, to avoid stack corruption when compiling |
* with -fomit-frame-pointer. It's not sure if this will |
* be fixed in GCC, as our previous implementation was a |
* bit dubious. |
* |
* If you would like to see an analysis of this implementation, please |
* ftp to gcom.com and download the file |
* /pub/linux/src/semaphore/semaphore-2.0.24.tar.gz. |
* |
*/ |
|
#include <asm/system.h> |
#include <asm/atomic.h> |
#include <linux/wait.h> |
#include <linux/rwsem.h> |
|
typedef int sem_t; /* sem.h */ |
int sem_wait(sem_t *sem); |
int sem_init(sem_t *sem, int pshared, unsigned int value); |
int sem_post(sem_t *sem); |
int sem_trywait(sem_t *s); |
|
struct semaphore { |
atomic_t count; |
int sleepers; |
wait_queue_head_t wait; |
#ifdef WAITQUEUE_DEBUG |
long __magic; |
#endif |
int init; |
int start_value; |
sem_t shark_sem; |
}; |
|
#ifdef WAITQUEUE_DEBUG |
# define __SEM_DEBUG_INIT(name) \ |
, (int)&(name).__magic |
#else |
# define __SEM_DEBUG_INIT(name) |
#endif |
#define DECLARE_MUTEX(name) struct semaphore name = { .init=0, .start_value=1} |
#define DECLARE_MUTEX_LOCKED(name) struct semaphore name= { .init=0, .start_value=0} |
|
#define __SEMAPHORE_INITIALIZER(name,count) \ |
{ ATOMIC_INIT(count), 0, __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \ |
__SEM_DEBUG_INIT(name) } |
static inline void down(struct semaphore * sem) |
{ |
/* if (sem->init == 0) |
{ |
sem_init(&sem->shark_sem, 0, sem->start_value); |
sem->init = 1; |
} |
sem_wait(&sem->shark_sem); |
*/ |
} |
|
#define __MUTEX_INITIALIZER(name) \ |
__SEMAPHORE_INITIALIZER(name,1) |
|
#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) |
static inline void up(struct semaphore * sem) |
{ |
/* |
* *sem = (struct semaphore)__SEMAPHORE_INITIALIZER((*sem),val); |
* |
* i'd rather use the more flexible initialization above, but sadly |
* GCC 2.7.2.3 emits a bogus warning. EGCS doesn't. Oh well. |
sem_post(&sem->shark_sem); |
*/ |
atomic_set(&sem->count, val); |
sem->sleepers = 0; |
init_waitqueue_head(&sem->wait); |
#ifdef WAITQUEUE_DEBUG |
sem->__magic = (int)&sem->__magic; |
#endif |
} |
|
static inline void init_MUTEX (struct semaphore *sem) |
{ |
sema_init(sem, 1); |
/* |
sem_init(&sem->shark_sem, 0, 1); |
*/ |
} |
|
static inline void init_MUTEX_LOCKED (struct semaphore *sem) |
{ |
sema_init(sem, 0); |
} |
|
asmlinkage void __down_failed(void /* special register calling convention */); |
asmlinkage int __down_failed_interruptible(void /* params in registers */); |
asmlinkage int __down_failed_trylock(void /* params in registers */); |
asmlinkage void __up_wakeup(void /* special register calling convention */); |
|
asmlinkage void __down(struct semaphore * sem); |
asmlinkage int __down_interruptible(struct semaphore * sem); |
asmlinkage int __down_trylock(struct semaphore * sem); |
asmlinkage void __up(struct semaphore * sem); |
|
/* |
* This is ugly, but we want the default case to fall through. |
* "__down_failed" is a special asm handler that calls the C |
* routine that actually waits. See arch/i386/kernel/semaphore.c |
sem_init(&sem->shark_sem, 0, 0); |
*/ |
static inline void down(struct semaphore * sem) |
{ |
#ifdef WAITQUEUE_DEBUG |
CHECK_MAGIC(sem->__magic); |
#endif |
might_sleep(); |
__asm__ __volatile__( |
"# atomic down operation\n\t" |
LOCK "decl %0\n\t" /* --sem->count */ |
"js 2f\n" |
"1:\n" |
LOCK_SECTION_START("") |
"2:\tcall __down_failed\n\t" |
"jmp 1b\n" |
LOCK_SECTION_END |
:"=m" (sem->count) |
:"c" (sem) |
:"memory"); |
} |
|
/* |
* Interruptible try to acquire a semaphore. If we obtained |
* it, return zero. If we were interrupted, returns -EINTR |
*/ |
static inline int down_interruptible(struct semaphore * sem) |
{ |
int result; |
|
#ifdef WAITQUEUE_DEBUG |
CHECK_MAGIC(sem->__magic); |
#endif |
might_sleep(); |
__asm__ __volatile__( |
"# atomic interruptible down operation\n\t" |
LOCK "decl %1\n\t" /* --sem->count */ |
"js 2f\n\t" |
"xorl %0,%0\n" |
"1:\n" |
LOCK_SECTION_START("") |
"2:\tcall __down_failed_interruptible\n\t" |
"jmp 1b\n" |
LOCK_SECTION_END |
:"=a" (result), "=m" (sem->count) |
:"c" (sem) |
:"memory"); |
return result; |
} |
|
/* |
* Non-blockingly attempt to down() a semaphore. |
* Returns zero if we acquired it |
*/ |
static inline int down_trylock(struct semaphore * sem) |
{ |
int result; |
|
#ifdef WAITQUEUE_DEBUG |
CHECK_MAGIC(sem->__magic); |
#endif |
|
__asm__ __volatile__( |
"# atomic interruptible down operation\n\t" |
LOCK "decl %1\n\t" /* --sem->count */ |
"js 2f\n\t" |
"xorl %0,%0\n" |
"1:\n" |
LOCK_SECTION_START("") |
"2:\tcall __down_failed_trylock\n\t" |
"jmp 1b\n" |
LOCK_SECTION_END |
:"=a" (result), "=m" (sem->count) |
:"c" (sem) |
:"memory"); |
return result; |
} |
|
return 0; |
/* |
* Note! This is subtle. We jump to wake people up only if |
* the semaphore was negative (== somebody was waiting on it). |
* The default case (no contention) will result in NO |
* jumps for both down() and up(). |
return ( sem_trywait(&sem->shark_sem) ); |
*/ |
static inline void up(struct semaphore * sem) |
{ |
#ifdef WAITQUEUE_DEBUG |
CHECK_MAGIC(sem->__magic); |
#endif |
__asm__ __volatile__( |
"# atomic up operation\n\t" |
LOCK "incl %0\n\t" /* ++sem->count */ |
"jle 2f\n" |
"1:\n" |
LOCK_SECTION_START("") |
"2:\tcall __up_wakeup\n\t" |
"jmp 1b\n" |
LOCK_SECTION_END |
".subsection 0\n" |
:"=m" (sem->count) |
:"c" (sem) |
:"memory"); |
} |
|
#endif |