Index: uspace/lib/cpp/include/impl/mutex.hpp
===================================================================
--- uspace/lib/cpp/include/impl/mutex.hpp	(revision befead8b30e3bfd4f0cade8efc20d27abcbdd008)
+++ uspace/lib/cpp/include/impl/mutex.hpp	(revision 857d4cc5a9a2387b876a7c8d0cb9a0c9679d003a)
@@ -84,5 +84,5 @@
 
             void lock();
-            bool try_lock();
+            bool try_lock() noexcept;
             void unlock();
 
@@ -141,6 +141,59 @@
      */
 
-    // TODO: implement
-    class recursive_timed_mutex;
+    class recursive_timed_mutex
+    {
+        public:
+            recursive_timed_mutex() noexcept
+                : mtx_{}, lock_level_{}, owner_{}
+            {
+                aux::threading::mutex::init(mtx_);
+            }
+
+            ~recursive_timed_mutex();
+
+            recursive_timed_mutex(const recursive_timed_mutex&) = delete;
+            recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
+
+            void lock();
+            bool try_lock();
+            void unlock();
+
+            template<class Rep, class Period>
+            bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+            {
+                if (owner_ == this_thread::get_id())
+                    return true;
+
+                auto time = aux::threading::time::convert(rel_time);
+                auto ret = aux::threading::mutex::try_lock_for(time);
+
+                if (ret)
+                    ++lock_level_;
+                return ret;
+            }
+
+            template<class Clock, class Duration>
+            bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
+            {
+                if (owner_ == this_thread::get_id())
+                    return true;
+
+                auto dur = (abs_time - Clock::now());
+                auto time = aux::threading::time::convert(dur);
+                auto ret = aux::threading::mutex::try_lock_for(time);
+
+                if (ret)
+                    ++lock_level_;
+                return ret;
+            }
+
+            using native_handle_type = aux::mutex_t*;
+            native_handle_type native_handle();
+
+        private:
+            aux::mutex_t mtx_;
+            size_t lock_level_;
+            thread::id owner_;
+    };
 
     struct defer_lock_t
Index: uspace/lib/cpp/src/mutex.cpp
===================================================================
--- uspace/lib/cpp/src/mutex.cpp	(revision befead8b30e3bfd4f0cade8efc20d27abcbdd008)
+++ uspace/lib/cpp/src/mutex.cpp	(revision 857d4cc5a9a2387b876a7c8d0cb9a0c9679d003a)
@@ -69,5 +69,5 @@
     }
 
-    bool recursive_mutex::try_lock()
+    bool recursive_mutex::try_lock() noexcept
     {
         if (owner_ != this_thread::get_id())
@@ -129,3 +129,50 @@
         return &mtx_;
     }
+
+    recursive_timed_mutex::~recursive_timed_mutex()
+    { /* DUMMY BODY */ }
+
+    void recursive_timed_mutex::lock()
+    {
+        if (owner_ != this_thread::get_id())
+        {
+            aux::threading::mutex::lock(mtx_);
+            owner_ = this_thread::get_id();
+            lock_level_ = 1;
+        }
+        else
+            ++lock_level_;
+    }
+
+    bool recursive_timed_mutex::try_lock()
+    {
+        if (owner_ != this_thread::get_id())
+        {
+            bool res = aux::threading::mutex::try_lock(mtx_);
+            if (res)
+            {
+                owner_ = this_thread::get_id();
+                lock_level_ = 1;
+            }
+
+            return res;
+        }
+        else
+            ++lock_level_;
+
+        return true;
+    }
+
+    void recursive_timed_mutex::unlock()
+    {
+        if (owner_ != this_thread::get_id())
+            return;
+        else if (--lock_level_ == 0)
+            aux::threading::mutex::unlock(mtx_);
+    }
+
+    recursive_timed_mutex::native_handle_type recursive_timed_mutex::native_handle()
+    {
+        return &mtx_;
+    }
 }