| 1,217 → 1,69 |
|---|
| #ifndef _I386_SEMAPHORE_H |
| #define _I386_SEMAPHORE_H |
| |
| #include <linux/linkage.h> |
| |
| #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> |
| |
| struct semaphore { |
| atomic_t count; |
| int sleepers; |
| wait_queue_head_t wait; |
| #ifdef WAITQUEUE_DEBUG |
| long __magic; |
| #endif |
| }; |
| |
| #ifdef WAITQUEUE_DEBUG |
| # define __SEM_DEBUG_INIT(name) \ |
| , (int)&(name).__magic |
| #else |
| # define __SEM_DEBUG_INIT(name) |
| #endif |
| |
| #define __SEMAPHORE_INITIALIZER(name,count) \ |
| { ATOMIC_INIT(count), 0, __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \ |
| __SEM_DEBUG_INIT(name) } |
| |
| #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) |
| { |
| /* |
| * *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. |
| */ |
| 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); |
| } |
| |
| 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 |
| */ |
| 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; |
| } |
| |
| /* |
| * 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(). |
| */ |
| 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 |
| #endif |
| #ifndef _I386_SEMAPHORE_H |
| #define _I386_SEMAPHORE_H |
| |
| #include <linux/linkage.h> |
| |
| #ifdef __KERNEL__ |
| |
| #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 { |
| int init; |
| int start_value; |
| sem_t shark_sem; |
| }; |
| |
| #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} |
| |
| 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); |
| */ |
| } |
| |
| static inline void up(struct semaphore * sem) |
| { |
| /* |
| sem_post(&sem->shark_sem); |
| */ |
| } |
| |
| static inline void init_MUTEX (struct semaphore *sem) |
| { |
| /* |
| sem_init(&sem->shark_sem, 0, 1); |
| */ |
| } |
| |
| static inline void init_MUTEX_LOCKED (struct semaphore *sem) |
| { |
| /* |
| sem_init(&sem->shark_sem, 0, 0); |
| */ |
| } |
| |
| static inline int down_trylock(struct semaphore * sem) |
| { |
| return 0; |
| /* |
| return ( sem_trywait(&sem->shark_sem) ); |
| */ |
| } |
| |
| #endif |
| #endif |