git subrepo clone https://github.com/Atmosphere-NX/Atmosphere-libs libraries

subrepo:
  subdir:   "libraries"
  merged:   "07af583b"
upstream:
  origin:   "https://github.com/Atmosphere-NX/Atmosphere-libs"
  branch:   "master"
  commit:   "07af583b"
git-subrepo:
  version:  "0.4.0"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "5d6aba9"

libraries/libstratosphere/include/stratosphere/os/os_common_types.hpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::os {
+
+    enum class TriBool {
+        False     = 0,
+        True      = 1,
+        Undefined = 2,
+    };
+
+    enum class MessageQueueWaitKind {
+        ForNotEmpty,
+        ForNotFull,
+    };
+
+    struct ProcessId {
+        u64 value;
+
+        inline constexpr explicit operator u64() const {
+            return this->value;
+        }
+
+        /* Invalid Process ID. */
+        static const ProcessId Invalid;
+    };
+
+    inline constexpr const ProcessId ProcessId::Invalid = {static_cast<u64>(-1ull)};
+
+    inline constexpr const ProcessId InvalidProcessId = ProcessId::Invalid;
+
+    NX_INLINE Result TryGetProcessId(os::ProcessId *out, ::Handle process_handle) {
+        return svcGetProcessId(&out->value, process_handle);
+    }
+
+    NX_INLINE os::ProcessId GetProcessId(::Handle process_handle) {
+        os::ProcessId process_id;
+        R_ASSERT(TryGetProcessId(&process_id, process_handle));
+        return process_id;
+    }
+
+    inline constexpr bool operator==(const ProcessId &lhs, const ProcessId &rhs) {
+        return lhs.value == rhs.value;
+    }
+
+    inline constexpr bool operator!=(const ProcessId &lhs, const ProcessId &rhs) {
+        return lhs.value != rhs.value;
+    }
+
+    inline constexpr bool operator<(const ProcessId &lhs, const ProcessId &rhs) {
+        return lhs.value < rhs.value;
+    }
+
+    inline constexpr bool operator<=(const ProcessId &lhs, const ProcessId &rhs) {
+        return lhs.value <= rhs.value;
+    }
+
+    inline constexpr bool operator>(const ProcessId &lhs, const ProcessId &rhs) {
+        return lhs.value > rhs.value;
+    }
+
+    inline constexpr bool operator>=(const ProcessId &lhs, const ProcessId &rhs) {
+        return lhs.value >= rhs.value;
+    }
+
+}

libraries/libstratosphere/include/stratosphere/os/os_condvar.hpp

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_mutex.hpp"
+
+namespace ams::os {
+
+    enum class ConditionVariableStatus {
+        TimedOut = 0,
+        Success  = 1,
+    };
+
+    class ConditionVariable {
+        NON_COPYABLE(ConditionVariable);
+        NON_MOVEABLE(ConditionVariable);
+        private:
+            CondVar cv;
+        public:
+            ConditionVariable() {
+                condvarInit(&cv);
+            }
+
+            ConditionVariableStatus TimedWait(::Mutex *m, u64 timeout) {
+                if (timeout > 0) {
+                    /* Abort on any error other than timed out/success. */
+                    R_TRY_CATCH(condvarWaitTimeout(&this->cv, m, timeout)) {
+                        R_CATCH(svc::ResultTimedOut) { return ConditionVariableStatus::TimedOut; }
+                    } R_END_TRY_CATCH_WITH_ASSERT;
+
+                    return ConditionVariableStatus::Success;
+                }
+                return ConditionVariableStatus::TimedOut;
+            }
+
+            void Wait(::Mutex *m) {
+                R_ASSERT(condvarWait(&this->cv, m));
+            }
+
+            ConditionVariableStatus TimedWait(os::Mutex *m, u64 timeout) {
+                return this->TimedWait(m->GetMutex(), timeout);
+            }
+
+            void Wait(os::Mutex *m) {
+                return this->Wait(m->GetMutex());
+            }
+
+            void Signal() {
+                condvarWakeOne(&this->cv);
+            }
+
+            void Broadcast() {
+                condvarWakeAll(&this->cv);
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_event.hpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_mutex.hpp"
+#include "os_condvar.hpp"
+#include "os_timeout_helper.hpp"
+
+namespace ams::os {
+
+    namespace impl {
+
+        class WaitableObjectList;
+        class WaitableHolderOfEvent;
+
+    }
+
+    class Event {
+        friend class impl::WaitableHolderOfEvent;
+        NON_COPYABLE(Event);
+        NON_MOVEABLE(Event);
+        private:
+            util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitable_object_list_storage;
+            Mutex lock;
+            ConditionVariable cv;
+            u64 counter = 0;
+            bool auto_clear;
+            bool signaled;
+        public:
+            Event(bool a = true, bool s = false);
+            ~Event();
+
+            void Signal();
+            void Reset();
+            void Wait();
+            bool TryWait();
+            bool TimedWait(u64 ns);
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_interrupt_event.hpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_managed_handle.hpp"
+
+namespace ams::os {
+
+    namespace impl {
+
+        class WaitableHolderOfInterruptEvent;
+
+    }
+
+    class InterruptEvent {
+        friend class impl::WaitableHolderOfInterruptEvent;
+        NON_COPYABLE(InterruptEvent);
+        NON_MOVEABLE(InterruptEvent);
+        private:
+            ManagedHandle handle;
+            bool auto_clear;
+            bool is_initialized;
+        public:
+            InterruptEvent() : auto_clear(true), is_initialized(false) { }
+            InterruptEvent(u32 interrupt_id, bool autoclear = true);
+
+            Result Initialize(u32 interrupt_id, bool autoclear = true);
+            void Finalize();
+
+            void Reset();
+            void Wait();
+            bool TryWait();
+            bool TimedWait(u64 ns);
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_managed_handle.hpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_common_types.hpp"
+
+namespace ams::os {
+
+    class ManagedHandle {
+        NON_COPYABLE(ManagedHandle);
+        private:
+            Handle hnd;
+        public:
+            ManagedHandle() : hnd(INVALID_HANDLE) { /* ... */ }
+            ManagedHandle(Handle h) : hnd(h) { /* ... */ }
+            ~ManagedHandle() {
+                if (this->hnd != INVALID_HANDLE) {
+                    R_ASSERT(svcCloseHandle(this->hnd));
+                    this->hnd = INVALID_HANDLE;
+                }
+            }
+
+            ManagedHandle(ManagedHandle&& rhs) {
+                this->hnd = rhs.hnd;
+                rhs.hnd = INVALID_HANDLE;
+            }
+
+            ManagedHandle& operator=(ManagedHandle&& rhs) {
+                rhs.Swap(*this);
+                return *this;
+            }
+
+            explicit operator bool() const {
+                return this->hnd != INVALID_HANDLE;
+            }
+
+            void Swap(ManagedHandle& rhs) {
+                std::swap(this->hnd, rhs.hnd);
+            }
+
+            Handle Get() const {
+                return this->hnd;
+            }
+
+            Handle *GetPointer() {
+                return &this->hnd;
+            }
+
+            Handle *GetPointerAndClear() {
+                this->Clear();
+                return this->GetPointer();
+            }
+
+            Handle Move() {
+                const Handle h = this->hnd;
+                this->hnd = INVALID_HANDLE;
+                return h;
+            }
+
+            void Reset(Handle h) {
+                ManagedHandle(h).Swap(*this);
+            }
+
+            void Clear() {
+                this->Reset(INVALID_HANDLE);
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_memory_common.hpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::os {
+
+    constexpr inline size_t MemoryPageSize      = 0x1000;
+
+    constexpr inline size_t MemoryBlockUnitSize = 0x200000;
+
+}

libraries/libstratosphere/include/stratosphere/os/os_message_queue.hpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_mutex.hpp"
+#include "os_condvar.hpp"
+
+namespace ams::os {
+
+    namespace impl {
+
+        class WaitableObjectList;
+
+        template<MessageQueueWaitKind WaitKind>
+        class WaitableHolderOfMessageQueue;
+
+    }
+
+    class MessageQueue {
+        template<MessageQueueWaitKind WaitKind>
+        friend class impl::WaitableHolderOfMessageQueue;
+        NON_COPYABLE(MessageQueue);
+        NON_MOVEABLE(MessageQueue);
+        private:
+            util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist_not_empty;
+            util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist_not_full;
+            Mutex queue_lock;
+            ConditionVariable cv_not_full;
+            ConditionVariable cv_not_empty;
+            std::unique_ptr<uintptr_t[]> buffer;
+            size_t capacity;
+
+            size_t count;
+            size_t offset;
+        private:
+            constexpr inline bool IsFull() const {
+                return this->count >= this->capacity;
+            }
+
+            constexpr inline bool IsEmpty() const {
+                return this->count == 0;
+            }
+
+            void SendInternal(uintptr_t data);
+            void SendNextInternal(uintptr_t data);
+            uintptr_t ReceiveInternal();
+            uintptr_t PeekInternal();
+        public:
+            MessageQueue(std::unique_ptr<uintptr_t[]> buf, size_t c);
+            ~MessageQueue();
+
+            /* For convenience. */
+            MessageQueue(size_t c) : MessageQueue(std::make_unique<uintptr_t[]>(c), c) { /* ... */ }
+
+            /* Sending (FIFO functionality) */
+            void Send(uintptr_t data);
+            bool TrySend(uintptr_t data);
+            bool TimedSend(uintptr_t data, u64 timeout);
+
+            /* Sending (LIFO functionality) */
+            void SendNext(uintptr_t data);
+            bool TrySendNext(uintptr_t data);
+            bool TimedSendNext(uintptr_t data, u64 timeout);
+
+            /* Receive functionality */
+            void Receive(uintptr_t *out);
+            bool TryReceive(uintptr_t *out);
+            bool TimedReceive(uintptr_t *out, u64 timeout);
+
+            /* Peek functionality */
+            void Peek(uintptr_t *out);
+            bool TryPeek(uintptr_t *out);
+            bool TimedPeek(uintptr_t *out, u64 timeout);
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_mutex.hpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_common_types.hpp"
+
+namespace ams::os {
+
+    class ConditionVariable;
+
+    class Mutex {
+        NON_COPYABLE(Mutex);
+        NON_MOVEABLE(Mutex);
+        friend class ams::os::ConditionVariable;
+        private:
+            ::Mutex m;
+        private:
+            ::Mutex *GetMutex() {
+                return &this->m;
+            }
+        public:
+            Mutex() {
+                mutexInit(GetMutex());
+            }
+
+            void lock() {
+                mutexLock(GetMutex());
+            }
+
+            void unlock() {
+                mutexUnlock(GetMutex());
+            }
+
+            bool try_lock() {
+                return mutexTryLock(GetMutex());
+            }
+
+            void Lock() {
+                lock();
+            }
+
+            void Unlock() {
+                unlock();
+            }
+
+            bool TryLock() {
+                return try_lock();
+            }
+    };
+
+    class RecursiveMutex {
+        private:
+            ::RMutex m;
+        private:
+            ::RMutex *GetMutex() {
+                return &this->m;
+            }
+        public:
+            RecursiveMutex() {
+                rmutexInit(GetMutex());
+            }
+
+            void lock() {
+                rmutexLock(GetMutex());
+            }
+
+            void unlock() {
+                rmutexUnlock(GetMutex());
+            }
+
+            bool try_lock() {
+                return rmutexTryLock(GetMutex());
+            }
+
+            void Lock() {
+                lock();
+            }
+
+            void Unlock() {
+                unlock();
+            }
+
+            bool TryLock() {
+                return try_lock();
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_process_handle.hpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_managed_handle.hpp"
+
+namespace ams::os {
+
+    ::Handle GetCurrentProcessHandle();
+
+    NX_INLINE ProcessId GetCurrentProcessId() {
+        return GetProcessId(GetCurrentProcessHandle());
+    }
+
+}

libraries/libstratosphere/include/stratosphere/os/os_rw_lock.hpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_common_types.hpp"
+
+namespace ams::os {
+
+    class ReadWriteLock {
+        NON_COPYABLE(ReadWriteLock);
+        NON_MOVEABLE(ReadWriteLock);
+        private:
+            ::RwLock r;
+        public:
+            ReadWriteLock() {
+                rwlockInit(&this->r);
+            }
+
+            bool IsWriteLockHeldByCurrentThread() const {
+                return rwlockIsWriteLockHeldByCurrentThread(const_cast<::RwLock *>(&this->r));
+            }
+
+            bool IsLockOwner() const {
+                return rwlockIsOwnedByCurrentThread(const_cast<::RwLock *>(&this->r));
+            }
+
+            void AcquireReadLock() {
+                rwlockReadLock(&this->r);
+            }
+
+            void ReleaseReadLock() {
+                rwlockReadUnlock(&this->r);
+            }
+
+            bool TryAcquireReadLock() {
+                return rwlockTryReadLock(&this->r);
+            }
+
+            void AcquireWriteLock() {
+                rwlockWriteLock(&this->r);
+            }
+
+            void ReleaseWriteLock() {
+                rwlockWriteUnlock(&this->r);
+            }
+
+            bool TryAcquireWriteLock() {
+                return rwlockTryWriteLock(&this->r);
+            }
+
+            void lock_shared() {
+                this->AcquireReadLock();
+            }
+
+            void unlock_shared() {
+                this->ReleaseReadLock();
+            }
+
+            bool try_lock_shared() {
+                return this->TryAcquireReadLock();
+            }
+
+            void lock() {
+                this->AcquireWriteLock();
+            }
+
+            void unlock() {
+                this->ReleaseWriteLock();
+            }
+
+            bool try_lock() {
+                return this->TryAcquireWriteLock();
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_semaphore.hpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_mutex.hpp"
+#include "os_condvar.hpp"
+
+namespace ams::os {
+
+    namespace impl {
+
+        class WaitableObjectList;
+        class WaitableHolderOfSemaphore;
+
+    }
+
+    class Semaphore {
+        friend class impl::WaitableHolderOfSemaphore;
+        NON_COPYABLE(Semaphore);
+        NON_MOVEABLE(Semaphore);
+        private:
+            util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist;
+            os::Mutex mutex;
+            os::ConditionVariable condvar;
+            int count;
+            int max_count;
+        public:
+            explicit Semaphore(int c, int mc);
+            ~Semaphore();
+
+            void Acquire();
+            bool TryAcquire();
+            bool TimedAcquire(u64 timeout);
+
+            void Release();
+            void Release(int count);
+
+            constexpr inline int GetCurrentCount() const {
+                return this->count;
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_system_event.hpp

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_event.hpp"
+
+namespace ams::os {
+
+    class WaitableHolder;
+
+    namespace impl {
+
+        class InterProcessEvent;
+
+    }
+
+    enum class SystemEventState {
+        Uninitialized,
+        Event,
+        InterProcessEvent,
+    };
+
+    class SystemEvent {
+        friend class WaitableHolder;
+        NON_COPYABLE(SystemEvent);
+        NON_MOVEABLE(SystemEvent);
+        private:
+            union {
+                util::TypedStorage<Event, sizeof(Event), alignof(Event)> storage_for_event;
+                util::TypedStorage<impl::InterProcessEvent, 3 * sizeof(Handle), alignof(Handle)> storage_for_inter_process_event;
+            };
+            SystemEventState state;
+        private:
+            Event &GetEvent();
+            const Event &GetEvent() const;
+            impl::InterProcessEvent &GetInterProcessEvent();
+            const impl::InterProcessEvent &GetInterProcessEvent() const;
+        public:
+            SystemEvent() : state(SystemEventState::Uninitialized) { /* ... */ }
+            SystemEvent(bool inter_process, bool autoclear = true);
+            SystemEvent(Handle read_handle, bool manage_read_handle, Handle write_handle, bool manage_write_handle, bool autoclear = true);
+            SystemEvent(Handle read_handle, bool manage_read_handle, bool autoclear = true) : SystemEvent(read_handle, manage_read_handle, INVALID_HANDLE, false, autoclear) { /* ... */ }
+            ~SystemEvent();
+
+            Result InitializeAsEvent(bool autoclear = true);
+            Result InitializeAsInterProcessEvent(bool autoclear = true);
+            void AttachHandles(Handle read_handle, bool manage_read_handle, Handle write_handle, bool manage_write_handle, bool autoclear = true);
+            void AttachReadableHandle(Handle read_handle, bool manage_read_handle, bool autoclear = true);
+            void AttachWritableHandle(Handle write_handle, bool manage_write_handle, bool autoclear = true);
+            Handle DetachReadableHandle();
+            Handle DetachWritableHandle();
+            Handle GetReadableHandle() const;
+            Handle GetWritableHandle() const;
+            void Finalize();
+
+            SystemEventState GetState() const {
+                return this->state;
+            }
+
+            void Signal();
+            void Reset();
+            void Wait();
+            bool TryWait();
+            bool TimedWait(u64 ns);
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_thread.hpp

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "os_common_types.hpp"
+#include "os_memory_common.hpp"
+
+namespace ams::os {
+
+    class Thread {
+        NON_COPYABLE(Thread);
+        NON_MOVEABLE(Thread);
+        private:
+            ::Thread thr;
+        public:
+            constexpr Thread() : thr{} { /* ... */ }
+
+            Result Initialize(ThreadFunc entry, void *arg, void *stack_mem, size_t stack_sz, int prio, int cpuid = -2) {
+                return threadCreate(&this->thr, entry, arg, stack_mem, stack_sz, prio, cpuid);
+            }
+
+            Result Initialize(ThreadFunc entry, void *arg, size_t stack_sz, int prio, int cpuid = -2) {
+                return threadCreate(&this->thr, entry, arg, nullptr, stack_sz, prio, cpuid);
+            }
+
+            Handle GetHandle() const {
+                return this->thr.handle;
+            }
+
+            Result Start() {
+                return threadStart(&this->thr);
+            }
+
+            Result Wait() {
+                return threadWaitForExit(&this->thr);
+            }
+
+            Result Join() {
+                R_TRY(threadWaitForExit(&this->thr));
+                R_TRY(threadClose(&this->thr));
+                return ResultSuccess();
+            }
+
+            Result CancelSynchronization() {
+                return svcCancelSynchronization(this->thr.handle);
+            }
+    };
+
+    template<size_t StackSize>
+    class StaticThread {
+        NON_COPYABLE(StaticThread);
+        NON_MOVEABLE(StaticThread);
+        static_assert(util::IsAligned(StackSize, os::MemoryPageSize), "StaticThread must have aligned resource size");
+        private:
+            alignas(os::MemoryPageSize) u8 stack_mem[StackSize];
+            ::Thread thr;
+        public:
+            constexpr StaticThread() : stack_mem{}, thr{} { /* ... */ }
+
+            constexpr StaticThread(ThreadFunc entry, void *arg, int prio, int cpuid = -2) : StaticThread() {
+                R_ASSERT(this->Initialize(entry, arg, prio, cpuid));
+            }
+
+            Result Initialize(ThreadFunc entry, void *arg, int prio, int cpuid = -2) {
+                return threadCreate(&this->thr, entry, arg, this->stack_mem, StackSize, prio, cpuid);
+            }
+
+            Handle GetHandle() const {
+                return this->thr.handle;
+            }
+
+            Result Start() {
+                return threadStart(&this->thr);
+            }
+
+            Result Wait() {
+                return threadWaitForExit(&this->thr);
+            }
+
+            Result Join() {
+                R_TRY(threadWaitForExit(&this->thr));
+                R_TRY(threadClose(&this->thr));
+                return ResultSuccess();
+            }
+
+            Result CancelSynchronization() {
+                return svcCancelSynchronization(this->thr.handle);
+            }
+    };
+
+    NX_INLINE u32 GetCurrentThreadPriority() {
+        u32 prio;
+        R_ASSERT(svcGetThreadPriority(&prio, CUR_THREAD_HANDLE));
+        return prio;
+    }
+
+}

libraries/libstratosphere/include/stratosphere/os/os_timeout_helper.hpp

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include "os_common_types.hpp"
+
+namespace ams::os {
+
+    class TimeoutHelper {
+        private:
+            u64 end_tick;
+        public:
+            TimeoutHelper(u64 ns) {
+                /* Special case zero-time timeouts. */
+                if (ns == 0) {
+                    end_tick = 0;
+                    return;
+                }
+
+                u64 cur_tick = armGetSystemTick();
+                this->end_tick = cur_tick + NsToTick(ns) + 1;
+            }
+
+            static constexpr inline u64 NsToTick(u64 ns) {
+                return (ns * 12) / 625;
+            }
+
+            static constexpr inline u64 TickToNs(u64 tick) {
+                return (tick * 625) / 12;
+            }
+
+            inline bool TimedOut() const {
+                if (this->end_tick == 0) {
+                    return true;
+                }
+
+                return armGetSystemTick() >= this->end_tick;
+            }
+
+            inline u64 NsUntilTimeout() const {
+                u64 diff = TickToNs(this->end_tick - armGetSystemTick());
+
+                if (this->TimedOut()) {
+                    return 0;
+                }
+
+                return diff;
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_waitable_holder.hpp

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include "os_common_types.hpp"
+
+namespace ams::os {
+
+    class WaitableManager;
+
+    class Event;
+    class SystemEvent;
+    class InterruptEvent;
+    class Thread;
+    class MessageQueue;
+    class Semaphore;
+
+    namespace impl {
+
+        class WaitableHolderImpl;
+
+    }
+
+    class WaitableHolder {
+        friend class WaitableManager;
+        NON_COPYABLE(WaitableHolder);
+        NON_MOVEABLE(WaitableHolder);
+        private:
+            util::TypedStorage<impl::WaitableHolderImpl, 2 * sizeof(util::IntrusiveListNode) + 3 * sizeof(void *), alignof(void *)> impl_storage;
+            uintptr_t user_data;
+        public:
+            static constexpr size_t ImplStorageSize = sizeof(impl_storage);
+        public:
+            WaitableHolder(Handle handle);
+            WaitableHolder(Event *event);
+            WaitableHolder(SystemEvent *event);
+            WaitableHolder(InterruptEvent *event);
+            WaitableHolder(Thread *thread);
+            WaitableHolder(Semaphore *semaphore);
+            WaitableHolder(MessageQueue *message_queue, MessageQueueWaitKind wait_kind);
+
+            ~WaitableHolder();
+
+            void SetUserData(uintptr_t data) {
+                this->user_data = data;
+            }
+
+            uintptr_t GetUserData() const {
+                return this->user_data;
+            }
+
+            void UnlinkFromWaitableManager();
+    };
+
+}

libraries/libstratosphere/include/stratosphere/os/os_waitable_manager.hpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include "os_mutex.hpp"
+
+namespace ams::os {
+
+    class WaitableHolder;
+
+    namespace impl {
+
+        class WaitableManagerImpl;
+
+    }
+
+    class WaitableManager {
+        NON_COPYABLE(WaitableManager);
+        NON_MOVEABLE(WaitableManager);
+        private:
+            util::TypedStorage<impl::WaitableManagerImpl, sizeof(util::IntrusiveListNode) + sizeof(Mutex) + 2 * sizeof(void *) + sizeof(Handle), alignof(void *)> impl_storage;
+        public:
+            static constexpr size_t ImplStorageSize = sizeof(impl_storage);
+        public:
+            WaitableManager();
+            ~WaitableManager();
+
+            /* Wait. */
+            WaitableHolder *WaitAny();
+            WaitableHolder *TryWaitAny();
+            WaitableHolder *TimedWaitAny(u64 timeout);
+
+            /* Link. */
+            void LinkWaitableHolder(WaitableHolder *holder);
+            void UnlinkAll();
+            void MoveAllFrom(WaitableManager *other);
+    };
+
+}