Index: uspace/lib/cpp/include/impl/mutex.hpp
===================================================================
--- uspace/lib/cpp/include/impl/mutex.hpp	(revision da6bcc0fb6dfddd5ecd61b224a7b568bf875dbfb)
+++ uspace/lib/cpp/include/impl/mutex.hpp	(revision d3501757f8fe2b3aa0ed85c7a18d030f2e170c8f)
@@ -202,6 +202,61 @@
      */
 
-    // TODO: implement
-    class shared_timed_mutex;
+    class shared_timed_mutex
+    {
+        public:
+            shared_timed_mutex() noexcept;
+            ~shared_timed_mutex();
+
+            shared_timed_mutex(const shared_timed_mutex&) = delete;
+            shared_timed_mutex& operator=(const shared_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)
+            {
+                auto time = aux::threading::time::convert(rel_time);
+
+                return aux::threading::shared_mutex::try_lock_for(time);
+            }
+
+            template<class Clock, class Duration>
+            bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
+            {
+                auto dur = (abs_time - Clock::now());
+                auto time = aux::threading::time::convert(dur);
+
+                return aux::threading::shared_mutex::try_lock_for(time);
+            }
+
+            void lock_shared();
+            bool try_lock_shared();
+            void unlock_shared();
+
+            template<class Rep, class Period>
+            bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
+            {
+                auto time = aux::threading::time::convert(rel_time);
+
+                return aux::threading::shared_mutex::try_lock_shared_for(time);
+            }
+
+            template<class Clock, class Duration>
+            bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time)
+            {
+                auto dur = (abs_time - Clock::now());
+                auto time = aux::threading::time::convert(dur);
+
+                return aux::threading::shared_mutex::try_lock_shared_for(time);
+            }
+
+            using native_handle_type = aux::shared_mutex_t*;
+            native_handle_type native_handle();
+
+        private:
+            aux::shared_mutex_t mtx_;
+    };
 
     struct defer_lock_t
Index: uspace/lib/cpp/src/mutex.cpp
===================================================================
--- uspace/lib/cpp/src/mutex.cpp	(revision da6bcc0fb6dfddd5ecd61b224a7b568bf875dbfb)
+++ uspace/lib/cpp/src/mutex.cpp	(revision d3501757f8fe2b3aa0ed85c7a18d030f2e170c8f)
@@ -173,3 +173,47 @@
         return &mtx_;
     }
+
+    shared_timed_mutex::shared_timed_mutex() noexcept
+        : mtx_{}
+    {
+        aux::threading::shared_mutex::init(mtx_);
+    }
+
+    shared_timed_mutex::~shared_timed_mutex()
+    { /* DUMMY BODY */ }
+
+    void shared_timed_mutex::lock()
+    {
+        aux::threading::shared_mutex::lock(mtx_);
+    }
+
+    bool shared_timed_mutex::try_lock()
+    {
+        return aux::threading::shared_mutex::try_lock(mtx_);
+    }
+
+    void shared_timed_mutex::unlock()
+    {
+        aux::threading::shared_mutex::unlock(mtx_);
+    }
+
+    void shared_timed_mutex::lock_shared()
+    {
+        aux::threading::shared_mutex::lock_shared(mtx_);
+    }
+
+    bool shared_timed_mutex::try_lock_shared()
+    {
+        return aux::threading::shared_mutex::try_lock_shared(mtx_);
+    }
+
+    void shared_timed_mutex::unlock_shared()
+    {
+        aux::threading::shared_mutex::unlock_shared(mtx_);
+    }
+
+    shared_timed_mutex::native_handle_type shared_timed_mutex::native_handle()
+    {
+        return &mtx_;
+    }
 }