remove sem/mutex hacks needed for old klmirqd

4 files changed, 4 insertions, 153 deletions

diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index cb47debbf24d..a940fe435aca 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -126,15 +126,6 @@ static inline int mutex_is_locked(struct mutex *lock)
         return atomic_read(&lock->count) != 1;
 }
 
-/* return non-zero to abort.  only pre-side-effects may abort */
-typedef int (*side_effect_t)(unsigned long);
-extern void mutex_lock_sfx(struct mutex *lock,
-                                                   side_effect_t pre, unsigned long pre_arg,
-                                                   side_effect_t post, unsigned long post_arg);
-extern void mutex_unlock_sfx(struct mutex *lock,
-                                                         side_effect_t pre, unsigned long pre_arg,
-                                                         side_effect_t post, unsigned long post_arg);
-
 /*
  * See kernel/mutex.c for detailed documentation of these APIs.
  * Also see Documentation/mutex-design.txt.
@@ -162,7 +153,6 @@ extern void mutex_lock(struct mutex *lock);
 extern int __must_check mutex_lock_interruptible(struct mutex *lock);
 extern int __must_check mutex_lock_killable(struct mutex *lock);
 
-
 # define mutex_lock_nested(lock, subclass) mutex_lock(lock)
 # define mutex_lock_interruptible_nested(lock, subclass) mutex_lock_interruptible(lock)
 # define mutex_lock_killable_nested(lock, subclass) mutex_lock_killable(lock)
diff --git a/include/linux/semaphore.h b/include/linux/semaphore.h
index c83fc2b65f01..39fa04966aa8 100644
--- a/include/linux/semaphore.h
+++ b/include/linux/semaphore.h
@@ -43,13 +43,4 @@ extern int __must_check down_trylock(struct semaphore *sem);
 extern int __must_check down_timeout(struct semaphore *sem, long jiffies);
 extern void up(struct semaphore *sem);
 
-extern void __down(struct semaphore *sem);
-extern void __up(struct semaphore *sem);
-
-struct semaphore_waiter {
-        struct list_head list;
-        struct task_struct *task;
-        int up;
-};
-
 #endif /* __LINUX_SEMAPHORE_H */
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 2f363b9bfc1f..d607ed5dd441 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -498,128 +498,3 @@ int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock)
         return 1;
 }
 EXPORT_SYMBOL(atomic_dec_and_mutex_lock);
-
-
-
-
-void mutex_lock_sfx(struct mutex *lock,
-                                   side_effect_t pre, unsigned long pre_arg,
-                                   side_effect_t post, unsigned long post_arg)
-{
-        long state = TASK_UNINTERRUPTIBLE;
-
-        struct task_struct *task = current;
-        struct mutex_waiter waiter;
-        unsigned long flags;
-        
-        preempt_disable();
-        mutex_acquire(&lock->dep_map, subclass, 0, ip);
-
-        spin_lock_mutex(&lock->wait_lock, flags);
-        
-        if(pre)
-        {
-                if(unlikely(pre(pre_arg)))
-                {
-                        // this will fuck with lockdep's CONFIG_PROVE_LOCKING...
-                        spin_unlock_mutex(&lock->wait_lock, flags);
-                        preempt_enable();
-                        return;
-                }
-        }
-
-        debug_mutex_lock_common(lock, &waiter);
-        debug_mutex_add_waiter(lock, &waiter, task_thread_info(task));
-        
-        /* add waiting tasks to the end of the waitqueue (FIFO): */
-        list_add_tail(&waiter.list, &lock->wait_list);
-        waiter.task = task;
-        
-        if (atomic_xchg(&lock->count, -1) == 1)
-                goto done;
-        
-        lock_contended(&lock->dep_map, ip);
-        
-        for (;;) {
-                /*
-                 * Lets try to take the lock again - this is needed even if
-                 * we get here for the first time (shortly after failing to
-                 * acquire the lock), to make sure that we get a wakeup once
-                 * it's unlocked. Later on, if we sleep, this is the
-                 * operation that gives us the lock. We xchg it to -1, so
-                 * that when we release the lock, we properly wake up the
-                 * other waiters:
-                 */
-                if (atomic_xchg(&lock->count, -1) == 1)
-                        break;
-                
-                __set_task_state(task, state);
-                
-                /* didnt get the lock, go to sleep: */
-                spin_unlock_mutex(&lock->wait_lock, flags);
-                preempt_enable_no_resched();
-                schedule();
-                preempt_disable();
-                spin_lock_mutex(&lock->wait_lock, flags);
-        }
-        
-done:
-        lock_acquired(&lock->dep_map, ip);
-        /* got the lock - rejoice! */
-        mutex_remove_waiter(lock, &waiter, current_thread_info());
-        mutex_set_owner(lock);
-        
-        /* set it to 0 if there are no waiters left: */
-        if (likely(list_empty(&lock->wait_list)))
-                atomic_set(&lock->count, 0);
-        
-        if(post)
-                post(post_arg); 
-        
-        spin_unlock_mutex(&lock->wait_lock, flags);
-        
-        debug_mutex_free_waiter(&waiter);
-        preempt_enable();
-}
-EXPORT_SYMBOL(mutex_lock_sfx);
-
-void mutex_unlock_sfx(struct mutex *lock,
-                                        side_effect_t pre, unsigned long pre_arg,
-                                        side_effect_t post, unsigned long post_arg)
-{
-        unsigned long flags;
-        
-        spin_lock_mutex(&lock->wait_lock, flags);
-        
-        if(pre)
-                pre(pre_arg);
-        
-        //mutex_release(&lock->dep_map, nested, _RET_IP_);
-        mutex_release(&lock->dep_map, 1, _RET_IP_);
-        debug_mutex_unlock(lock);
-        
-        /*
-         * some architectures leave the lock unlocked in the fastpath failure
-         * case, others need to leave it locked. In the later case we have to
-         * unlock it here
-         */
-        if (__mutex_slowpath_needs_to_unlock())
-                atomic_set(&lock->count, 1);
-        
-        if (!list_empty(&lock->wait_list)) {
-                /* get the first entry from the wait-list: */
-                struct mutex_waiter *waiter =
-                list_entry(lock->wait_list.next,
-                                   struct mutex_waiter, list);
-                
-                debug_mutex_wake_waiter(lock, waiter);
-                
-                wake_up_process(waiter->task);
-        }
-        
-        if(post)
-                post(post_arg);
-        
-        spin_unlock_mutex(&lock->wait_lock, flags);     
-}
-EXPORT_SYMBOL(mutex_unlock_sfx);
diff --git a/kernel/semaphore.c b/kernel/semaphore.c
index c947a046a6d7..94a62c0d4ade 100644
--- a/kernel/semaphore.c
+++ b/kernel/semaphore.c
@@ -33,11 +33,11 @@
 #include <linux/spinlock.h>
 #include <linux/ftrace.h>
 
-noinline void __down(struct semaphore *sem);
+static noinline void __down(struct semaphore *sem);
 static noinline int __down_interruptible(struct semaphore *sem);
 static noinline int __down_killable(struct semaphore *sem);
 static noinline int __down_timeout(struct semaphore *sem, long jiffies);
-noinline void __up(struct semaphore *sem);
+static noinline void __up(struct semaphore *sem);
 
 /**
  * down - acquire the semaphore
@@ -190,13 +190,11 @@ EXPORT_SYMBOL(up);
 
 /* Functions for the contended case */
 
-/*
 struct semaphore_waiter {
         struct list_head list;
         struct task_struct *task;
         int up;
 };
- */
 
 /*
  * Because this function is inlined, the 'state' parameter will be
@@ -235,12 +233,10 @@ static inline int __sched __down_common(struct semaphore *sem, long state,
         return -EINTR;
 }
 
-noinline void __sched __down(struct semaphore *sem)
+static noinline void __sched __down(struct semaphore *sem)
 {
         __down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
 }
-EXPORT_SYMBOL(__down);
-
 
 static noinline int __sched __down_interruptible(struct semaphore *sem)
 {
@@ -257,7 +253,7 @@ static noinline int __sched __down_timeout(struct semaphore *sem, long jiffies)
         return __down_common(sem, TASK_UNINTERRUPTIBLE, jiffies);
 }
 
-noinline void __sched __up(struct semaphore *sem)
+static noinline void __sched __up(struct semaphore *sem)
 {
         struct semaphore_waiter *waiter = list_first_entry(&sem->wait_list,
                                                 struct semaphore_waiter, list);
@@ -265,4 +261,3 @@ noinline void __sched __up(struct semaphore *sem)
         waiter->up = 1;
         wake_up_process(waiter->task);
 }
-EXPORT_SYMBOL(__up);
\ No newline at end of file