Import 2.3.18pre1

[davej-history.git] / include / asm-i386 / semaphore.h

diff --git a/include/asm-i386/semaphore.hb/include/asm-i386/semaphore.h
index ccf6938..3997b2a 100644 (file)
--- a/include/asm-i386/semaphore.h
+++ b/include/asm-i386/semaphore.h
@@ -17,6+17,10 @@
  *                    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.
  *
  * If you would like to see an analysis of this implementation, please
  * ftp to gcom.com and download the file
@@ -26,16+30,63 @@
 
 #include <asm/system.h>
 #include <asm/atomic.h>
-#include <asm/spinlock.h>
+#include <linux/spinlock.h>
+#include <linux/wait.h>
 
 struct semaphore {
        atomic_t count;
-       int waking;
-       struct wait_queue * wait;
+       int sleepers;
+       wait_queue_head_t wait;
+#if WAITQUEUE_DEBUG
+       long __magic;
+#endif
 };
 
-#define MUTEX ((struct semaphore) { ATOMIC_INIT(1), 0, NULL })
-#define MUTEX_LOCKED ((struct semaphore) { ATOMIC_INIT(0), 0, NULL })
+#if 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)
+
+extern 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 doesnt. Oh well.
+ */
+       atomic_set(&sem->count, val);
+       sem->sleepers = 0;
+       init_waitqueue_head(&sem->wait);
+#if 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 */);
@@ -49,8+100,6 @@ asmlinkage void __up(struct semaphore * sem);
 
 extern spinlock_t semaphore_wake_lock;
 
-#define sema_init(sem, val)    atomic_set(&((sem)->count), (val))
-
 /*
  * This is ugly, but we want the default case to fall through.
  * "down_failed" is a special asm handler that calls the C
@@ -58,17+107,21 @@ extern spinlock_t semaphore_wake_lock;
  */
 extern inline void down(struct semaphore * sem)
 {
+#if WAITQUEUE_DEBUG
+       CHECK_MAGIC(sem->__magic);
+#endif
+
        __asm__ __volatile__(
                "# atomic down operation\n\t"
 #ifdef __SMP__
                "lock ; "
 #endif
-               "decl 0(%0)\n\t"
+               "decl (%0)\n\t"     /* --sem->count */
                "js 2f\n"
                "1:\n"
                ".section .text.lock,\"ax\"\n"
-               "2:\tpushl $1b\n\t"
-               "jmp __down_failed\n"
+               "2:\tcall __down_failed\n\t"
+               "jmp 1b\n"
                ".previous"
                :/* no outputs */
                :"c" (sem)
@@ -79,18+132,22 @@ extern inline int down_interruptible(struct semaphore * sem)
 {
        int result;
 
+#if WAITQUEUE_DEBUG
+       CHECK_MAGIC(sem->__magic);
+#endif
+
        __asm__ __volatile__(
                "# atomic interruptible down operation\n\t"
 #ifdef __SMP__
                "lock ; "
 #endif
-               "decl 0(%1)\n\t"
+               "decl (%1)\n\t"     /* --sem->count */
                "js 2f\n\t"
                "xorl %0,%0\n"
                "1:\n"
                ".section .text.lock,\"ax\"\n"
-               "2:\tpushl $1b\n\t"
-               "jmp __down_failed_interruptible\n"
+               "2:\tcall __down_failed_interruptible\n\t"
+               "jmp 1b\n"
                ".previous"
                :"=a" (result)
                :"c" (sem)
@@ -102,18+159,22 @@ extern inline int down_trylock(struct semaphore * sem)
 {
        int result;
 
+#if WAITQUEUE_DEBUG
+       CHECK_MAGIC(sem->__magic);
+#endif
+
        __asm__ __volatile__(
                "# atomic interruptible down operation\n\t"
 #ifdef __SMP__
                "lock ; "
 #endif
-               "decl 0(%1)\n\t"
+               "decl (%1)\n\t"     /* --sem->count */
                "js 2f\n\t"
                "xorl %0,%0\n"
                "1:\n"
                ".section .text.lock,\"ax\"\n"
-               "2:\tpushl $1b\n\t"
-               "jmp __down_failed_trylock\n"
+               "2:\tcall __down_failed_trylock\n\t"
+               "jmp 1b\n"
                ".previous"
                :"=a" (result)
                :"c" (sem)
@@ -129,17+190,20 @@ extern inline int down_trylock(struct semaphore * sem)
  */
 extern inline void up(struct semaphore * sem)
 {
+#if WAITQUEUE_DEBUG
+       CHECK_MAGIC(sem->__magic);
+#endif
        __asm__ __volatile__(
                "# atomic up operation\n\t"
 #ifdef __SMP__
                "lock ; "
 #endif
-               "incl 0(%0)\n\t"
+               "incl (%0)\n\t"     /* ++sem->count */
                "jle 2f\n"
                "1:\n"
                ".section .text.lock,\"ax\"\n"
-               "2:\tpushl $1b\n\t"
-               "jmp __up_wakeup\n"
+               "2:\tcall __up_wakeup\n\t"
+               "jmp 1b\n"
                ".previous"
                :/* no outputs */
                :"c" (sem)