[PATCH] WAITQUEUE_DEBUG cleanup

While trying out compiling of reiser4 on sparc64, ppc64, alpha, and ia64, I
discovered that WAITQUEUE_DEBUG is nowhere defined in 2.6.x, and various
compiler versions spew copious warnings at #if on it.  Convert
__SEMAPHORE_INITIALIZER() to C99 initializers while in the area.

Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/include/asm-alpha/semaphore.h b/include/asm-alpha/semaphore.h
index 1f197842872c5b9b5062eb1faa1dc12bf213d84a..eb2cbd97d40434ba72ce57cdd364bac92ae49f4d 100644 (file)
--- a/include/asm-alpha/semaphore.h
+++ b/include/asm-alpha/semaphore.h
@@ -18,21 +18,13 @@
 struct semaphore {
        atomic_t count;
        wait_queue_head_t wait;
-#ifdef WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#ifdef WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name)                , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name,count)            \
-       { ATOMIC_INIT(count),                           \
-         __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
-         __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                       \
+{                                                              \
+       .count  = ATOMIC_INIT(n),                               \
+       .wait   = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait),   \
+}
 
 #define __MUTEX_INITIALIZER(name)                      \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -53,9 +45,6 @@ static inline void sema_init(struct semaphore *sem, int val)
 
        atomic_set(&sem->count, val);
        init_waitqueue_head(&sem->wait);
-#ifdef WAITQUEUE_DEBUG
-       sem->__magic = (long)&sem->__magic;
-#endif
 }
 
 static inline void init_MUTEX (struct semaphore *sem)
@@ -142,7 +131,7 @@ static inline void __up(struct semaphore *sem)
                __up_wakeup(sem);
 }
 
-#if !defined(WAITQUEUE_DEBUG) && !defined(CONFIG_DEBUG_SEMAPHORE)
+#if !defined(CONFIG_DEBUG_SEMAPHORE)
 extern inline void down(struct semaphore *sem)
 {
        __down(sem);

diff --git a/include/asm-arm/semaphore.h b/include/asm-arm/semaphore.h
index 2e47880be261821f2aca608da3116f8fc3bc0e5c..60f33e6eb800afc3d63de96dbeb269d8c43c7f57 100644 (file)
--- a/include/asm-arm/semaphore.h
+++ b/include/asm-arm/semaphore.h
@@ -16,21 +16,12 @@ 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)        .__magic = (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INIT(name,cnt) {                           \
+#define __SEMAPHORE_INIT(name, cnt)                            \
+{                                                              \
        .count  = ATOMIC_INIT(cnt),                             \
        .wait   = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait),   \
-       __SEM_DEBUG_INIT(name)                                  \
 }
 
 #define __MUTEX_INITIALIZER(name) __SEMAPHORE_INIT(name,1)
@@ -46,9 +37,6 @@ static inline void sema_init(struct semaphore *sem, int val)
        atomic_set(&sem->count, val);
        sem->sleepers = 0;
        init_waitqueue_head(&sem->wait);
-#ifdef WAITQUEUE_DEBUG
-       sem->__magic = (long)&sem->__magic;
-#endif
 }
 
 static inline void init_MUTEX(struct semaphore *sem)
@@ -85,9 +73,6 @@ extern void __up(struct semaphore * sem);
  */
 static inline void down(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        __down_op(sem, __down_failed);
 }
@@ -98,19 +83,12 @@ static inline void down(struct semaphore * sem)
  */
 static inline int down_interruptible (struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        return __down_op_ret(sem, __down_interruptible_failed);
 }
 
 static inline int down_trylock(struct semaphore *sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        return __down_op_ret(sem, __down_trylock_failed);
 }
 
@@ -122,10 +100,6 @@ static inline int down_trylock(struct semaphore *sem)
  */
 static inline void up(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        __up_op(sem, __up_wakeup);
 }
 

diff --git a/include/asm-arm26/semaphore.h b/include/asm-arm26/semaphore.h
index 49946274a67b37a0f842a45339662dcaa8e906a9..c1b6a1edad92dd349a808f5837540667619fbdae 100644 (file)
--- a/include/asm-arm26/semaphore.h
+++ b/include/asm-arm26/semaphore.h
@@ -16,22 +16,14 @@ struct semaphore {
        atomic_t count;
        int sleepers;
        wait_queue_head_t wait;
-#if WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#if WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INIT(name,count)                   \
-       { ATOMIC_INIT(count), 0,                        \
-         __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
-         __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INIT(name, n)                                      \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .sleepers       = 0,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait),   \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INIT(name,1)
@@ -47,9 +39,6 @@ static inline void sema_init(struct semaphore *sem, int val)
        atomic_set(&sem->count, val);
        sem->sleepers = 0;
        init_waitqueue_head(&sem->wait);
-#if WAITQUEUE_DEBUG
-       sem->__magic = (long)&sem->__magic;
-#endif
 }
 
 static inline void init_MUTEX(struct semaphore *sem)
@@ -81,9 +70,6 @@ extern void __up(struct semaphore * sem);
  */
 static inline void down(struct semaphore * sem)
 {
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        __down_op(sem, __down_failed);
 }
@@ -94,19 +80,12 @@ static inline void down(struct semaphore * sem)
  */
 static inline int down_interruptible (struct semaphore * sem)
 {
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        return __down_op_ret(sem, __down_interruptible_failed);
 }
 
 static inline int down_trylock(struct semaphore *sem)
 {
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        return __down_op_ret(sem, __down_trylock_failed);
 }
 
@@ -118,10 +97,6 @@ static inline int down_trylock(struct semaphore *sem)
  */
 static inline void up(struct semaphore * sem)
 {
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        __up_op(sem, __up_wakeup);
 }
 

diff --git a/include/asm-cris/semaphore.h b/include/asm-cris/semaphore.h
index 9ee66b9d531eec7a922c85bd470f739f70c938ef..605aa7eaaaf8d4190c767ba7920c2ddab8a9d886 100644 (file)
--- a/include/asm-cris/semaphore.h
+++ b/include/asm-cris/semaphore.h
@@ -24,21 +24,14 @@ struct semaphore {
        atomic_t count;
        atomic_t waking;
        wait_queue_head_t wait;
-#if WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#if WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name)         , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name,count)             \
-        { ATOMIC_INIT(count), ATOMIC_INIT(0),           \
-          __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
-          __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .waking         = ATOMIC_INIT(0),                               \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
         __SEMAPHORE_INITIALIZER(name,1)
@@ -76,9 +69,6 @@ extern inline void down(struct semaphore * sem)
        unsigned long flags;
        int failed;
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        /* atomically decrement the semaphores count, and if its negative, we wait */
@@ -102,9 +92,6 @@ extern inline int down_interruptible(struct semaphore * sem)
        unsigned long flags;
        int failed;
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        /* atomically decrement the semaphores count, and if its negative, we wait */
@@ -122,10 +109,6 @@ extern inline int down_trylock(struct semaphore * sem)
        unsigned long flags;
        int failed;
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        local_save_flags(flags);
        local_irq_disable();
        failed = --(sem->count.counter) < 0;
@@ -146,10 +129,6 @@ extern inline void up(struct semaphore * sem)
        unsigned long flags;
        int wakeup;
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        /* atomically increment the semaphores count, and if it was negative, we wake people */
        local_save_flags(flags);
        local_irq_disable();

diff --git a/include/asm-h8300/semaphore.h b/include/asm-h8300/semaphore.h
index 9efd009de29a4876d8399619d84160ad3a127c1c..fe6ef3774297ce03458185b2b0791fec57f78f51 100644 (file)
--- a/include/asm-h8300/semaphore.h
+++ b/include/asm-h8300/semaphore.h
@@ -26,21 +26,14 @@ struct semaphore {
        atomic_t count;
        int sleepers;
        wait_queue_head_t wait;
-#if WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#if WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(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 __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .sleepers       = 0,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -87,9 +80,6 @@ static inline void down(struct semaphore * sem)
 {
        register atomic_t *count asm("er0");
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        count = &(sem->count);
@@ -116,9 +106,6 @@ static inline int down_interruptible(struct semaphore * sem)
 {
        register atomic_t *count asm("er0");
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        count = &(sem->count);
@@ -147,10 +134,6 @@ static inline int down_trylock(struct semaphore * sem)
 {
        register atomic_t *count asm("er0");
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        count = &(sem->count);
        __asm__ __volatile__(
                "stc ccr,r3l\n\t"
@@ -187,10 +170,6 @@ static inline void up(struct semaphore * sem)
 {
        register atomic_t *count asm("er0");
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        count = &(sem->count);
        __asm__ __volatile__(
                "stc ccr,r3l\n\t"

diff --git a/include/asm-i386/semaphore.h b/include/asm-i386/semaphore.h
index 986da200e5c81eb767936299c82c79de5dc8fe2c..1db03a68622dc33954ba217e1944ac23a458c09c 100644 (file)
--- a/include/asm-i386/semaphore.h
+++ b/include/asm-i386/semaphore.h
@@ -45,21 +45,15 @@ 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 __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .sleepers       = 0,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -81,9 +75,6 @@ static inline void sema_init (struct semaphore *sem, int val)
        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)
@@ -113,9 +104,6 @@ asmlinkage void __up(struct semaphore * sem);
  */
 static inline void down(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        __asm__ __volatile__(
                "# atomic down operation\n\t"
@@ -139,9 +127,6 @@ 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"
@@ -167,10 +152,6 @@ 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 */
@@ -195,9 +176,6 @@ static inline int down_trylock(struct semaphore * 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 */

diff --git a/include/asm-ia64/semaphore.h b/include/asm-ia64/semaphore.h
index 44165a637add321e28a3e4f5051874e513341317..3a2f0f3f78f37255d15a0f364031d519fd8add66 100644 (file)
--- a/include/asm-ia64/semaphore.h
+++ b/include/asm-ia64/semaphore.h
@@ -15,21 +15,13 @@ struct semaphore {
        atomic_t count;
        int sleepers;
        wait_queue_head_t wait;
-#if WAITQUEUE_DEBUG
-       long __magic;           /* initialized by __SEM_DEBUG_INIT() */
-#endif
 };
 
-#if WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name)                , (long) &(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 __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .sleepers       = 0,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
 }
 
 #define __MUTEX_INITIALIZER(name)      __SEMAPHORE_INITIALIZER(name,1)
@@ -70,9 +62,6 @@ extern void __up (struct semaphore * sem);
 static inline void
 down (struct semaphore *sem)
 {
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        if (atomic_dec_return(&sem->count) < 0)
                __down(sem);
@@ -87,9 +76,6 @@ down_interruptible (struct semaphore * sem)
 {
        int ret = 0;
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        if (atomic_dec_return(&sem->count) < 0)
                ret = __down_interruptible(sem);
@@ -101,9 +87,6 @@ down_trylock (struct semaphore *sem)
 {
        int ret = 0;
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        if (atomic_dec_return(&sem->count) < 0)
                ret = __down_trylock(sem);
        return ret;
@@ -112,9 +95,6 @@ down_trylock (struct semaphore *sem)
 static inline void
 up (struct semaphore * sem)
 {
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        if (atomic_inc_return(&sem->count) <= 0)
                __up(sem);
 }

diff --git a/include/asm-m68k/semaphore.h b/include/asm-m68k/semaphore.h
index 213d4f79672d1d60810bb1a070bac830e094b1ce..ab94cf3ed4477b70b3f61c39b0dcec7d4cfffd04 100644 (file)
--- a/include/asm-m68k/semaphore.h
+++ b/include/asm-m68k/semaphore.h
@@ -27,21 +27,14 @@ struct semaphore {
        atomic_t count;
        atomic_t waking;
        wait_queue_head_t wait;
-#ifdef WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#ifdef WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name,count) \
-{ ATOMIC_INIT(count), ATOMIC_INIT(0), __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
-       __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .waking         = ATOMIC_INIT(0),                               \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -86,9 +79,6 @@ static inline void down(struct semaphore *sem)
 {
        register struct semaphore *sem1 __asm__ ("%a1") = sem;
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        __asm__ __volatile__(
                "| atomic down operation\n\t"
@@ -109,9 +99,6 @@ static inline int down_interruptible(struct semaphore *sem)
        register struct semaphore *sem1 __asm__ ("%a1") = sem;
        register int result __asm__ ("%d0");
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        __asm__ __volatile__(
                "| atomic interruptible down operation\n\t"
@@ -134,10 +121,6 @@ static inline int down_trylock(struct semaphore *sem)
        register struct semaphore *sem1 __asm__ ("%a1") = sem;
        register int result __asm__ ("%d0");
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        __asm__ __volatile__(
                "| atomic down trylock operation\n\t"
                "subql #1,%1@\n\t"
@@ -164,10 +147,6 @@ static inline void up(struct semaphore *sem)
 {
        register struct semaphore *sem1 __asm__ ("%a1") = sem;
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        __asm__ __volatile__(
                "| atomic up operation\n\t"
                "addql #1,%0@\n\t"

diff --git a/include/asm-m68knommu/semaphore.h b/include/asm-m68knommu/semaphore.h
index f85d311bc2d897cba4bd847cb872f054cd828b1f..febe85add5096970d392a7ecea1e5b81e1ae252b 100644 (file)
--- a/include/asm-m68knommu/semaphore.h
+++ b/include/asm-m68knommu/semaphore.h
@@ -26,21 +26,14 @@ struct semaphore {
        atomic_t count;
        atomic_t waking;
        wait_queue_head_t wait;
-#if WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#if WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name,count) \
-{ ATOMIC_INIT(count), ATOMIC_INIT(0), __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
-       __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .waking         = ATOMIC_INIT(0),                               \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -85,9 +78,6 @@ extern spinlock_t semaphore_wake_lock;
  */
 extern inline void down(struct semaphore * sem)
 {
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        __asm__ __volatile__(
                "| atomic down operation\n\t"
@@ -105,9 +95,6 @@ extern inline int down_interruptible(struct semaphore * sem)
 {
        int ret;
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        __asm__ __volatile__(
                "| atomic down operation\n\t"
@@ -128,10 +115,6 @@ extern inline int down_trylock(struct semaphore * sem)
        register struct semaphore *sem1 __asm__ ("%a1") = sem;
        register int result __asm__ ("%d0");
 
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        __asm__ __volatile__(
                "| atomic down trylock operation\n\t"
                "subql #1,%1@\n\t"
@@ -157,10 +140,6 @@ 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"
                "movel  %0, %%a1\n\t"

diff --git a/include/asm-mips/semaphore.h b/include/asm-mips/semaphore.h
index ed9a3d774c6af72acdb002547988ed40ba8c2862..c2c97dec661bb56c063eccb12a6095bf48896bba 100644 (file)
--- a/include/asm-mips/semaphore.h
+++ b/include/asm-mips/semaphore.h
@@ -37,22 +37,13 @@ struct semaphore {
         */
        atomic_t count;
        wait_queue_head_t wait;
-#ifdef WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#ifdef WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name, count) \
-       { ATOMIC_INIT(count), \
-         __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
-         __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name, 1)
@@ -67,9 +58,6 @@ static inline void sema_init (struct semaphore *sem, int val)
 {
        atomic_set(&sem->count, val);
        init_waitqueue_head(&sem->wait);
-#ifdef WAITQUEUE_DEBUG
-       sem->__magic = (long)&sem->__magic;
-#endif
 }
 
 static inline void init_MUTEX (struct semaphore *sem)
@@ -88,9 +76,6 @@ extern void __up(struct semaphore * sem);
 
 static inline void down(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        /*
@@ -104,9 +89,6 @@ static inline int down_interruptible(struct semaphore * sem)
 {
        int ret = 0;
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        if (unlikely(atomic_dec_return(&sem->count) < 0))
@@ -116,19 +98,11 @@ static inline int down_interruptible(struct semaphore * sem)
 
 static inline int down_trylock(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        return atomic_dec_if_positive(&sem->count) < 0;
 }
 
 static inline void up(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        if (unlikely(atomic_inc_return(&sem->count) <= 0))
                __up(sem);
 }

diff --git a/include/asm-parisc/semaphore.h b/include/asm-parisc/semaphore.h
index f9ab172f6984732b598c713d1e197feecbcf291f..f78bb2e3453891fc8e279de31d72c83224b2be3e 100644 (file)
--- a/include/asm-parisc/semaphore.h
+++ b/include/asm-parisc/semaphore.h
@@ -40,21 +40,14 @@ struct semaphore {
        spinlock_t      sentry;
        int             count;
        wait_queue_head_t wait;
-#if WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#if WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name,count) \
-{ SPIN_LOCK_UNLOCKED, count, __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
-       __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .sentry         = SPIN_LOCK_UNLOCKED,                           \
+       .count          = n,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -95,9 +88,6 @@ asmlinkage void __up(struct semaphore * sem);
 
 extern __inline__ void down(struct semaphore * sem)
 {
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        spin_lock_irq(&sem->sentry);
        if (sem->count > 0) {
@@ -111,9 +101,6 @@ extern __inline__ void down(struct semaphore * sem)
 extern __inline__ int down_interruptible(struct semaphore * sem)
 {
        int ret = 0;
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
        spin_lock_irq(&sem->sentry);
        if (sem->count > 0) {
@@ -132,9 +119,6 @@ extern __inline__ int down_interruptible(struct semaphore * sem)
 extern __inline__ int down_trylock(struct semaphore * sem)
 {
        int flags, count;
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
 
        spin_lock_irqsave(&sem->sentry, flags);
        count = sem->count - 1;
@@ -151,9 +135,6 @@ extern __inline__ int down_trylock(struct semaphore * sem)
 extern __inline__ void up(struct semaphore * sem)
 {
        int flags;
-#if WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        spin_lock_irqsave(&sem->sentry, flags);
        if (sem->count < 0) {
                __up(sem);

diff --git a/include/asm-ppc/semaphore.h b/include/asm-ppc/semaphore.h
index 87616e1cc59e7482b4ea58265dca1d2ed15c5df4..89e6e73be08c281e36e492d10530cec9b98e4099 100644 (file)
--- a/include/asm-ppc/semaphore.h
+++ b/include/asm-ppc/semaphore.h
@@ -29,22 +29,13 @@ struct semaphore {
         */
        atomic_t count;
        wait_queue_head_t wait;
-#ifdef WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#ifdef WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name, count) \
-       { ATOMIC_INIT(count), \
-         __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
-         __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name, 1)
@@ -59,9 +50,6 @@ static inline void sema_init (struct semaphore *sem, int val)
 {
        atomic_set(&sem->count, val);
        init_waitqueue_head(&sem->wait);
-#ifdef WAITQUEUE_DEBUG
-       sem->__magic = (long)&sem->__magic;
-#endif
 }
 
 static inline void init_MUTEX (struct semaphore *sem)
@@ -80,9 +68,6 @@ extern void __up(struct semaphore * sem);
 
 extern inline void down(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        /*
@@ -97,9 +82,6 @@ extern inline int down_interruptible(struct semaphore * sem)
 {
        int ret = 0;
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        if (atomic_dec_return(&sem->count) < 0)
@@ -112,10 +94,6 @@ extern inline int down_trylock(struct semaphore * sem)
 {
        int ret;
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        ret = atomic_dec_if_positive(&sem->count) < 0;
        smp_wmb();
        return ret;
@@ -123,10 +101,6 @@ extern inline int down_trylock(struct semaphore * sem)
 
 extern inline void up(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        smp_wmb();
        if (atomic_inc_return(&sem->count) <= 0)
                __up(sem);

diff --git a/include/asm-ppc64/semaphore.h b/include/asm-ppc64/semaphore.h
index 22dfee71d8bae58aa2161196a6259a2bc01cb182..aefe7753ea41698685912a6044112e8e13ddb991 100644 (file)
--- a/include/asm-ppc64/semaphore.h
+++ b/include/asm-ppc64/semaphore.h
@@ -23,22 +23,13 @@ struct semaphore {
         */
        atomic_t count;
        wait_queue_head_t wait;
-#ifdef WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#ifdef WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name, count) \
-       { ATOMIC_INIT(count), \
-         __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
-         __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name, 1)
@@ -53,9 +44,6 @@ static inline void sema_init (struct semaphore *sem, int val)
 {
        atomic_set(&sem->count, val);
        init_waitqueue_head(&sem->wait);
-#ifdef WAITQUEUE_DEBUG
-       sem->__magic = (long)&sem->__magic;
-#endif
 }
 
 static inline void init_MUTEX (struct semaphore *sem)
@@ -74,9 +62,6 @@ extern void __up(struct semaphore * sem);
 
 static inline void down(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        /*
@@ -90,9 +75,6 @@ static inline int down_interruptible(struct semaphore * sem)
 {
        int ret = 0;
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        if (unlikely(atomic_dec_return(&sem->count) < 0))
@@ -102,19 +84,11 @@ static inline int down_interruptible(struct semaphore * sem)
 
 static inline int down_trylock(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        return atomic_dec_if_positive(&sem->count) < 0;
 }
 
 static inline void up(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        if (unlikely(atomic_inc_return(&sem->count) <= 0))
                __up(sem);
 }

diff --git a/include/asm-sh/semaphore.h b/include/asm-sh/semaphore.h
index dc8955e3448c8236618e44349352b0b116e0eb17..b923a77a8a7e69a6150e39f3646ca0770765705f 100644 (file)
--- a/include/asm-sh/semaphore.h
+++ b/include/asm-sh/semaphore.h
@@ -24,21 +24,14 @@ 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 __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .sleepers       = 0,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -60,9 +53,6 @@ static inline void sema_init (struct semaphore *sem, int val)
        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)
@@ -91,10 +81,6 @@ extern spinlock_t semaphore_wake_lock;
 
 static inline void down(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        might_sleep();
        if (atomic_dec_return(&sem->count) < 0)
                __down(sem);
@@ -103,9 +89,6 @@ static inline void down(struct semaphore * sem)
 static inline int down_interruptible(struct semaphore * sem)
 {
        int ret = 0;
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
 
        might_sleep();
        if (atomic_dec_return(&sem->count) < 0)
@@ -116,9 +99,6 @@ static inline int down_interruptible(struct semaphore * sem)
 static inline int down_trylock(struct semaphore * sem)
 {
        int ret = 0;
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
 
        if (atomic_dec_return(&sem->count) < 0)
                ret = __down_trylock(sem);
@@ -131,9 +111,6 @@ static inline int down_trylock(struct semaphore * sem)
  */
 static inline void up(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        if (atomic_inc_return(&sem->count) <= 0)
                __up(sem);
 }

diff --git a/include/asm-sh64/semaphore.h b/include/asm-sh64/semaphore.h
index 3e97ead32d69e232f54861517dae7642feb78946..fce22bb9a5465e598b642274afbc1101448dc415 100644 (file)
--- a/include/asm-sh64/semaphore.h
+++ b/include/asm-sh64/semaphore.h
@@ -31,21 +31,14 @@ 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 __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .sleepers       = 0,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -67,9 +60,6 @@ static inline void sema_init (struct semaphore *sem, int val)
        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)
@@ -98,10 +88,6 @@ extern spinlock_t semaphore_wake_lock;
 
 static inline void down(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        if (atomic_dec_return(&sem->count) < 0)
                __down(sem);
 }
@@ -109,9 +95,6 @@ static inline void down(struct semaphore * sem)
 static inline int down_interruptible(struct semaphore * sem)
 {
        int ret = 0;
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
 
        if (atomic_dec_return(&sem->count) < 0)
                ret = __down_interruptible(sem);
@@ -121,9 +104,6 @@ static inline int down_interruptible(struct semaphore * sem)
 static inline int down_trylock(struct semaphore * sem)
 {
        int ret = 0;
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
 
        if (atomic_dec_return(&sem->count) < 0)
                ret = __down_trylock(sem);
@@ -136,9 +116,6 @@ static inline int down_trylock(struct semaphore * sem)
  */
 static inline void up(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        if (atomic_inc_return(&sem->count) <= 0)
                __up(sem);
 }

diff --git a/include/asm-sparc/semaphore.h b/include/asm-sparc/semaphore.h
index e8e9ae60180911abfb3e2499e6f954922a5b7cf6..60ac5fd9eb487c3ece110c3d4fd4793355745cc6 100644 (file)
--- a/include/asm-sparc/semaphore.h
+++ b/include/asm-sparc/semaphore.h
@@ -13,21 +13,14 @@ struct semaphore {
        atomic24_t count;
        int sleepers;
        wait_queue_head_t wait;
-#ifdef WAITQUEUE_DEBUG
-       long __magic;
-#endif
 };
 
-#ifdef WAITQUEUE_DEBUG
-# define __SEM_DEBUG_INIT(name) \
-               , (long)&(name).__magic
-#else
-# define __SEM_DEBUG_INIT(name)
-#endif
-
-#define __SEMAPHORE_INITIALIZER(name,count) \
-{ ATOMIC24_INIT(count), 0, __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
-       __SEM_DEBUG_INIT(name) }
+#define __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC24_INIT(n),                             \
+       .sleepers       = 0,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -43,9 +36,6 @@ static inline void sema_init (struct semaphore *sem, int val)
        atomic24_set(&sem->count, val);
        sem->sleepers = 0;
        init_waitqueue_head(&sem->wait);
-#ifdef WAITQUEUE_DEBUG
-       sem->__magic = (long)&sem->__magic;
-#endif
 }
 
 static inline void init_MUTEX (struct semaphore *sem)
@@ -68,9 +58,6 @@ static inline void down(struct semaphore * sem)
        register volatile int *ptr asm("g1");
        register int increment asm("g2");
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        ptr = &(sem->count.counter);
@@ -105,9 +92,6 @@ static inline int down_interruptible(struct semaphore * sem)
        register volatile int *ptr asm("g1");
        register int increment asm("g2");
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        ptr = &(sem->count.counter);
@@ -145,10 +129,6 @@ static inline int down_trylock(struct semaphore * sem)
        register volatile int *ptr asm("g1");
        register int increment asm("g2");
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        ptr = &(sem->count.counter);
        increment = 1;
 
@@ -184,10 +164,6 @@ static inline void up(struct semaphore * sem)
        register volatile int *ptr asm("g1");
        register int increment asm("g2");
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
-
        ptr = &(sem->count.counter);
        increment = 1;
 

diff --git a/include/asm-x86_64/semaphore.h b/include/asm-x86_64/semaphore.h
index 2788834229e2703117189354214f22fe497f0ae9..f325e39bf3b9d2f1db8698c61526a46a57f8b07d 100644 (file)
--- a/include/asm-x86_64/semaphore.h
+++ b/include/asm-x86_64/semaphore.h
@@ -47,21 +47,14 @@ 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 __SEMAPHORE_INITIALIZER(name, n)                               \
+{                                                                      \
+       .count          = ATOMIC_INIT(n),                               \
+       .sleepers       = 0,                                            \
+       .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
+}
 
 #define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name,1)
@@ -83,9 +76,6 @@ static inline void sema_init (struct semaphore *sem, int val)
        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)
@@ -115,9 +105,6 @@ asmlinkage void __up(struct semaphore * sem);
  */
 static inline void down(struct semaphore * sem)
 {
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        __asm__ __volatile__(
@@ -142,9 +129,6 @@ static inline int down_interruptible(struct semaphore * sem)
 {
        int result;
 
-#ifdef WAITQUEUE_DEBUG
-       CHECK_MAGIC(sem->__magic);
-#endif
        might_sleep();
 
        __asm__ __volatile__(
@@ -171,10 +155,6 @@ 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 */
@@ -199,9 +179,6 @@ static inline int down_trylock(struct semaphore * 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 */