1 files changed, 76 insertions, 7 deletions

diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index 878cab4f5fcc..f98509b26876 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -12,11 +12,85 @@
 
 #include <linux/list.h>
 #include <linux/spinlock_types.h>
+#include <linux/rt_lock.h>
 #include <linux/linkage.h>
 #include <linux/lockdep.h>
 
 #include <asm/atomic.h>
 
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+# define __DEP_MAP_MUTEX_INITIALIZER(lockname) \
+                , .dep_map = { .name = #lockname }
+#else
+# define __DEP_MAP_MUTEX_INITIALIZER(lockname)
+#endif
+
+#ifdef CONFIG_PREEMPT_RT
+
+#include <linux/rtmutex.h>
+
+struct mutex {
+        struct rt_mutex         lock;
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        struct lockdep_map      dep_map;
+#endif
+};
+
+
+#define __MUTEX_INITIALIZER(mutexname)                                  \
+        {                                                               \
+                .lock = __RT_MUTEX_INITIALIZER(mutexname.lock)          \
+                __DEP_MAP_MUTEX_INITIALIZER(mutexname)                  \
+        }
+
+#define DEFINE_MUTEX(mutexname)                                         \
+        struct mutex mutexname = __MUTEX_INITIALIZER(mutexname)
+
+extern void
+__mutex_init(struct mutex *lock, char *name, struct lock_class_key *key);
+
+extern void __lockfunc _mutex_lock(struct mutex *lock);
+extern int __lockfunc _mutex_lock_interruptible(struct mutex *lock);
+extern int __lockfunc _mutex_lock_killable(struct mutex *lock);
+extern void __lockfunc _mutex_lock_nested(struct mutex *lock, int subclass);
+extern int __lockfunc
+_mutex_lock_interruptible_nested(struct mutex *lock, int subclass);
+extern int __lockfunc
+_mutex_lock_killable_nested(struct mutex *lock, int subclass);
+extern int __lockfunc _mutex_trylock(struct mutex *lock);
+extern void __lockfunc _mutex_unlock(struct mutex *lock);
+
+#define mutex_is_locked(l)              rt_mutex_is_locked(&(l)->lock)
+#define mutex_lock(l)                   _mutex_lock(l)
+#define mutex_lock_interruptible(l)     _mutex_lock_interruptible(l)
+#define mutex_lock_killable(l)          _mutex_lock_killable(l)
+#define mutex_trylock(l)                _mutex_trylock(l)
+#define mutex_unlock(l)                 _mutex_unlock(l)
+#define mutex_destroy(l)                rt_mutex_destroy(&(l)->lock)
+
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+# define mutex_lock_nested(l, s)        _mutex_lock_nested(l, s)
+# define mutex_lock_interruptible_nested(l, s) \
+                                        _mutex_lock_interruptible_nested(l, s)
+# define mutex_lock_killable_nested(l, s) \
+                                        _mutex_lock_killable_nested(l, s)
+#else
+# define mutex_lock_nested(l, s)        _mutex_lock(l)
+# define mutex_lock_interruptible_nested(l, s) \
+                                        _mutex_lock_interruptible(l)
+# define mutex_lock_killable_nested(l, s) \
+                                        _mutex_lock_killable(l)
+#endif
+
+# define mutex_init(mutex)                              \
+do {                                                    \
+        static struct lock_class_key __key;             \
+                                                        \
+        __mutex_init((mutex), #mutex, &__key);          \
+} while (0)
+
+#else /* PREEMPT_RT */
+
 /*
  * Simple, straightforward mutexes with strict semantics:
  *
@@ -87,13 +161,6 @@ do {							\
 # define mutex_destroy(mutex)                           do { } while (0)
 #endif
 
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-# define __DEP_MAP_MUTEX_INITIALIZER(lockname) \
-                , .dep_map = { .name = #lockname }
-#else
-# define __DEP_MAP_MUTEX_INITIALIZER(lockname)
-#endif
-
 #define __MUTEX_INITIALIZER(lockname) \
                 { .count = ATOMIC_INIT(1) \
                 , .wait_lock = __SPIN_LOCK_UNLOCKED(lockname.wait_lock) \
@@ -150,6 +217,8 @@ extern int __must_check mutex_lock_killable(struct mutex *lock);
  */
 extern int mutex_trylock(struct mutex *lock);
 extern void mutex_unlock(struct mutex *lock);
+#endif /* !PREEMPT_RT */
+
 extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
 
 #endif