Refactor Logging Impl

Loop on stop_token and remove final_entry in Entry.
Move Backend thread out of Impl Constructor to its own function.
Add Start function for backend thread.
Use stop token in PopWait and check if entry filename is nullptr before logging.

src/common/CMakeLists.txt

@@ -55,7 +55,6 @@ add_library(common STATIC
     dynamic_library.h
     error.cpp
     error.h
-    expected.h
     fiber.cpp
     fiber.h
     fs/file.cpp

src/common/expected.h

@@ -1,987 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This is based on the proposed implementation of std::expected (P0323)
-// https://github.com/TartanLlama/expected/blob/master/include/tl/expected.hpp
-
-#pragma once
-
-#include <type_traits>
-#include <utility>
-
-namespace Common {
-
-template <typename T, typename E>
-class Expected;
-
-template <typename E>
-class Unexpected {
-public:
-    Unexpected() = delete;
-
-    constexpr explicit Unexpected(const E& e) : m_val{e} {}
-
-    constexpr explicit Unexpected(E&& e) : m_val{std::move(e)} {}
-
-    constexpr E& value() & {
-        return m_val;
-    }
-
-    constexpr const E& value() const& {
-        return m_val;
-    }
-
-    constexpr E&& value() && {
-        return std::move(m_val);
-    }
-
-    constexpr const E&& value() const&& {
-        return std::move(m_val);
-    }
-
-private:
-    E m_val;
-};
-
-template <typename E>
-constexpr auto operator<=>(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {
-    return lhs.value() <=> rhs.value();
-}
-
-struct unexpect_t {
-    constexpr explicit unexpect_t() = default;
-};
-
-namespace detail {
-
-struct no_init_t {
-    constexpr explicit no_init_t() = default;
-};
-
-/**
- * This specialization is for when T is not trivially destructible,
- * so the destructor must be called on destruction of `expected'
- * Additionally, this requires E to be trivially destructible
- */
-template <typename T, typename E, bool = std::is_trivially_destructible_v<T>>
-requires std::is_trivially_destructible_v<E>
-struct expected_storage_base {
-    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
-
-    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr expected_storage_base(std::in_place_t, Args&&... args)
-        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
-        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
-                                             Args&&... args)
-        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
-
-    ~expected_storage_base() {
-        if (m_has_val) {
-            m_val.~T();
-        }
-    }
-
-    union {
-        T m_val;
-        Unexpected<E> m_unexpect;
-    };
-
-    bool m_has_val;
-};
-
-/**
- * This specialization is for when T is trivially destructible,
- * so the destructor of `expected` can be trivial
- * Additionally, this requires E to be trivially destructible
- */
-template <typename T, typename E>
-requires std::is_trivially_destructible_v<E>
-struct expected_storage_base<T, E, true> {
-    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
-
-    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr expected_storage_base(std::in_place_t, Args&&... args)
-        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
-        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
-                                             Args&&... args)
-        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
-
-    ~expected_storage_base() = default;
-
-    union {
-        T m_val;
-        Unexpected<E> m_unexpect;
-    };
-
-    bool m_has_val;
-};
-
-template <typename T, typename E>
-struct expected_operations_base : expected_storage_base<T, E> {
-    using expected_storage_base<T, E>::expected_storage_base;
-
-    template <typename... Args>
-    void construct(Args&&... args) noexcept {
-        new (std::addressof(this->m_val)) T{std::forward<Args>(args)...};
-        this->m_has_val = true;
-    }
-
-    template <typename Rhs>
-    void construct_with(Rhs&& rhs) noexcept {
-        new (std::addressof(this->m_val)) T{std::forward<Rhs>(rhs).get()};
-        this->m_has_val = true;
-    }
-
-    template <typename... Args>
-    void construct_error(Args&&... args) noexcept {
-        new (std::addressof(this->m_unexpect)) Unexpected<E>{std::forward<Args>(args)...};
-        this->m_has_val = false;
-    }
-
-    void assign(const expected_operations_base& rhs) noexcept {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~Unexpected<E>();
-            construct(rhs.get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    void assign(expected_operations_base&& rhs) noexcept {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~Unexpected<E>();
-            construct(std::move(rhs).get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    template <typename Rhs>
-    void assign_common(Rhs&& rhs) {
-        if (this->m_has_val) {
-            if (rhs.m_has_val) {
-                get() = std::forward<Rhs>(rhs).get();
-            } else {
-                destroy_val();
-                construct_error(std::forward<Rhs>(rhs).geterr());
-            }
-        } else {
-            if (!rhs.m_has_val) {
-                geterr() = std::forward<Rhs>(rhs).geterr();
-            }
-        }
-    }
-
-    bool has_value() const {
-        return this->m_has_val;
-    }
-
-    constexpr T& get() & {
-        return this->m_val;
-    }
-
-    constexpr const T& get() const& {
-        return this->m_val;
-    }
-
-    constexpr T&& get() && {
-        return std::move(this->m_val);
-    }
-
-    constexpr const T&& get() const&& {
-        return std::move(this->m_val);
-    }
-
-    constexpr Unexpected<E>& geterr() & {
-        return this->m_unexpect;
-    }
-
-    constexpr const Unexpected<E>& geterr() const& {
-        return this->m_unexpect;
-    }
-
-    constexpr Unexpected<E>&& geterr() && {
-        return std::move(this->m_unexpect);
-    }
-
-    constexpr const Unexpected<E>&& geterr() const&& {
-        return std::move(this->m_unexpect);
-    }
-
-    constexpr void destroy_val() {
-        get().~T();
-    }
-};
-
-/**
- * This manages conditionally having a trivial copy constructor
- * This specialization is for when T is trivially copy constructible
- * Additionally, this requires E to be trivially copy constructible
- */
-template <typename T, typename E, bool = std::is_trivially_copy_constructible_v<T>>
-requires std::is_trivially_copy_constructible_v<E>
-struct expected_copy_base : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-};
-
-/**
- * This specialization is for when T is not trivially copy constructible
- * Additionally, this requires E to be trivially copy constructible
- */
-template <typename T, typename E>
-requires std::is_trivially_copy_constructible_v<E>
-struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-
-    expected_copy_base() = default;
-
-    expected_copy_base(const expected_copy_base& rhs)
-        : expected_operations_base<T, E>{no_init_t{}} {
-        if (rhs.has_value()) {
-            this->construct_with(rhs);
-        } else {
-            this->construct_error(rhs.geterr());
-        }
-    }
-
-    expected_copy_base(expected_copy_base&&) = default;
-
-    expected_copy_base& operator=(const expected_copy_base&) = default;
-
-    expected_copy_base& operator=(expected_copy_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial move constructor
- * This specialization is for when T is trivially move constructible
- * Additionally, this requires E to be trivially move constructible
- */
-template <typename T, typename E, bool = std::is_trivially_move_constructible_v<T>>
-requires std::is_trivially_move_constructible_v<E>
-struct expected_move_base : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-};
-
-/**
- * This specialization is for when T is not trivially move constructible
- * Additionally, this requires E to be trivially move constructible
- */
-template <typename T, typename E>
-requires std::is_trivially_move_constructible_v<E>
-struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-
-    expected_move_base() = default;
-
-    expected_move_base(const expected_move_base&) = default;
-
-    expected_move_base(expected_move_base&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
-        : expected_copy_base<T, E>{no_init_t{}} {
-        if (rhs.has_value()) {
-            this->construct_with(std::move(rhs));
-        } else {
-            this->construct_error(std::move(rhs.geterr()));
-        }
-    }
-
-    expected_move_base& operator=(const expected_move_base&) = default;
-
-    expected_move_base& operator=(expected_move_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial copy assignment operator
- * This specialization is for when T is trivially copy assignable
- * Additionally, this requires E to be trivially copy assignable
- */
-template <typename T, typename E,
-          bool = std::conjunction_v<std::is_trivially_copy_assignable<T>,
-                                    std::is_trivially_copy_constructible<T>,
-                                    std::is_trivially_destructible<T>>>
-requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
-                            std::is_trivially_copy_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_copy_assign_base : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-};
-
-/**
- * This specialization is for when T is not trivially copy assignable
- * Additionally, this requires E to be trivially copy assignable
- */
-template <typename T, typename E>
-requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
-                            std::is_trivially_copy_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-
-    expected_copy_assign_base() = default;
-
-    expected_copy_assign_base(const expected_copy_assign_base&) = default;
-
-    expected_copy_assign_base(expected_copy_assign_base&&) = default;
-
-    expected_copy_assign_base& operator=(const expected_copy_assign_base& rhs) {
-        this->assign(rhs);
-        return *this;
-    }
-
-    expected_copy_assign_base& operator=(expected_copy_assign_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial move assignment operator
- * This specialization is for when T is trivially move assignable
- * Additionally, this requires E to be trivially move assignable
- */
-template <typename T, typename E,
-          bool = std::conjunction_v<std::is_trivially_move_assignable<T>,
-                                    std::is_trivially_move_constructible<T>,
-                                    std::is_trivially_destructible<T>>>
-requires std::conjunction_v<std::is_trivially_move_assignable<E>,
-                            std::is_trivially_move_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_move_assign_base : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-};
-
-/**
- * This specialization is for when T is not trivially move assignable
- * Additionally, this requires E to be trivially move assignable
- */
-template <typename T, typename E>
-requires std::conjunction_v<std::is_trivially_move_assignable<E>,
-                            std::is_trivially_move_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_move_assign_base<T, E, false> : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-
-    expected_move_assign_base() = default;
-
-    expected_move_assign_base(const expected_move_assign_base&) = default;
-
-    expected_move_assign_base(expected_move_assign_base&&) = default;
-
-    expected_move_assign_base& operator=(const expected_move_assign_base&) = default;
-
-    expected_move_assign_base& operator=(expected_move_assign_base&& rhs) noexcept(
-        std::conjunction_v<std::is_nothrow_move_constructible<T>,
-                           std::is_nothrow_move_assignable<T>>) {
-        this->assign(std::move(rhs));
-        return *this;
-    }
-};
-
-/**
- * expected_delete_ctor_base will conditionally delete copy and move constructors
- * depending on whether T is copy/move constructible
- * Additionally, this requires E to be copy/move constructible
- */
-template <typename T, typename E, bool EnableCopy = std::is_copy_constructible_v<T>,
-          bool EnableMove = std::is_move_constructible_v<T>>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, true, false> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, false, true> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, false, false> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-/**
- * expected_delete_assign_base will conditionally delete copy and move assignment operators
- * depending on whether T is copy/move constructible + assignable
- * Additionally, this requires E to be copy/move constructible + assignable
- */
-template <
-    typename T, typename E,
-    bool EnableCopy = std::conjunction_v<std::is_copy_constructible<T>, std::is_copy_assignable<T>>,
-    bool EnableMove = std::conjunction_v<std::is_move_constructible<T>, std::is_move_assignable<T>>>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, true, false> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, false, true> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, false, false> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
-};
-
-/**
- * This is needed to be able to construct the expected_default_ctor_base which follows,
- * while still conditionally deleting the default constructor.
- */
-struct default_constructor_tag {
-    constexpr explicit default_constructor_tag() = default;
-};
-
-/**
- * expected_default_ctor_base will ensure that expected
- * has a deleted default constructor if T is not default constructible
- * This specialization is for when T is default constructible
- */
-template <typename T, typename E, bool Enable = std::is_default_constructible_v<T>>
-struct expected_default_ctor_base {
-    constexpr expected_default_ctor_base() noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-template <typename T, typename E>
-struct expected_default_ctor_base<T, E, false> {
-    constexpr expected_default_ctor_base() noexcept = delete;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-template <typename T, typename E, typename U>
-using expected_enable_forward_value =
-    std::enable_if_t<std::is_constructible_v<T, U&&> &&
-                     !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
-                     !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                     !std::is_same_v<Unexpected<E>, std::remove_cvref_t<U>>>;
-
-template <typename T, typename E, typename U, typename G, typename UR, typename GR>
-using expected_enable_from_other = std::enable_if_t<
-    std::is_constructible_v<T, UR> && std::is_constructible_v<E, GR> &&
-    !std::is_constructible_v<T, Expected<U, G>&> && !std::is_constructible_v<T, Expected<U, G>&&> &&
-    !std::is_constructible_v<T, const Expected<U, G>&> &&
-    !std::is_constructible_v<T, const Expected<U, G>&&> &&
-    !std::is_convertible_v<Expected<U, G>&, T> && !std::is_convertible_v<Expected<U, G>&&, T> &&
-    !std::is_convertible_v<const Expected<U, G>&, T> &&
-    !std::is_convertible_v<const Expected<U, G>&&, T>>;
-
-} // namespace detail
-
-template <typename T, typename E>
-class Expected : private detail::expected_move_assign_base<T, E>,
-                 private detail::expected_delete_ctor_base<T, E>,
-                 private detail::expected_delete_assign_base<T, E>,
-                 private detail::expected_default_ctor_base<T, E> {
-public:
-    using value_type = T;
-    using error_type = E;
-    using unexpected_type = Unexpected<E>;
-
-    constexpr Expected() = default;
-    constexpr Expected(const Expected&) = default;
-    constexpr Expected(Expected&&) = default;
-    Expected& operator=(const Expected&) = default;
-    Expected& operator=(Expected&&) = default;
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr Expected(std::in_place_t, Args&&... args)
-        : impl_base{std::in_place, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr Expected(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : impl_base{std::in_place, il, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
-              std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr>
-    constexpr explicit Expected(const Unexpected<G>& e)
-        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
-              std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr>
-    constexpr Expected(Unexpected<G> const& e)
-        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
-              std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
-    constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-                                                             detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
-              std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
-    constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-                                                             detail::default_constructor_tag{}} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit Expected(unexpect_t, Args&&... args)
-        : impl_base{unexpect_t{}, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit Expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
-        : impl_base{unexpect_t{}, il, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename G,
-              std::enable_if_t<!(std::is_convertible_v<U const&, T> &&
-                                 std::is_convertible_v<G const&, E>)>* = nullptr,
-              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
-    constexpr explicit Expected(const Expected<U, G>& rhs)
-        : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<(std::is_convertible_v<U const&, T> &&
-                                std::is_convertible_v<G const&, E>)>* = nullptr,
-              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
-    constexpr Expected(const Expected<U, G>& rhs) : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<!(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
-                  nullptr,
-              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
-    constexpr explicit Expected(Expected<U, G>&& rhs)
-        : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
-                  nullptr,
-              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
-    constexpr Expected(Expected<U, G>&& rhs) : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template <typename U = T, std::enable_if_t<!std::is_convertible_v<U&&, T>>* = nullptr,
-              detail::expected_enable_forward_value<T, E, U>* = nullptr>
-    constexpr explicit Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
-
-    template <typename U = T, std::enable_if_t<std::is_convertible_v<U&&, T>>* = nullptr,
-              detail::expected_enable_forward_value<T, E, U>* = nullptr>
-    constexpr Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
-
-    template <typename U = T, typename G = T,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
-              std::enable_if_t<(
-                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
-                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
-                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
-    Expected& operator=(U&& v) {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<U>(v)};
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template <typename U = T, typename G = T,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
-              std::enable_if_t<(
-                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
-                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
-                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
-    Expected& operator=(U&& v) {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<U>(v)};
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template <typename G = E, std::enable_if_t<std::is_nothrow_copy_constructible_v<G> &&
-                                               std::is_assignable_v<G&, G>>* = nullptr>
-    Expected& operator=(const Unexpected<G>& rhs) {
-        if (!has_value()) {
-            err() = rhs;
-        } else {
-            this->destroy_val();
-            new (errptr()) Unexpected<E>{rhs};
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template <typename G = E, std::enable_if_t<std::is_nothrow_move_constructible_v<G> &&
-                                               std::is_move_assignable_v<G>>* = nullptr>
-    Expected& operator=(Unexpected<G>&& rhs) noexcept {
-        if (!has_value()) {
-            err() = std::move(rhs);
-        } else {
-            this->destroy_val();
-            new (errptr()) Unexpected<E>{std::move(rhs)};
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template <typename... Args,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
-    void emplace(Args&&... args) {
-        if (has_value()) {
-            val() = T{std::forward<Args>(args)...};
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename... Args,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
-    void emplace(Args&&... args) {
-        if (has_value()) {
-            val() = T{std::forward<Args>(args)...};
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
-                                                               Args&&...>>* = nullptr>
-    void emplace(std::initializer_list<U> il, Args&&... args) {
-        if (has_value()) {
-            T t{il, std::forward<Args>(args)...};
-            val() = std::move(t);
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{il, std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename U, typename... Args,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
-                                                                Args&&...>>* = nullptr>
-    void emplace(std::initializer_list<U> il, Args&&... args) {
-        if (has_value()) {
-            T t{il, std::forward<Args>(args)...};
-            val() = std::move(t);
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{il, std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    constexpr T* operator->() {
-        return valptr();
-    }
-
-    constexpr const T* operator->() const {
-        return valptr();
-    }
-
-    template <typename U = T>
-    constexpr U& operator*() & {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr const U& operator*() const& {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr U&& operator*() && {
-        return std::move(val());
-    }
-
-    template <typename U = T>
-    constexpr const U&& operator*() const&& {
-        return std::move(val());
-    }
-
-    constexpr bool has_value() const noexcept {
-        return this->m_has_val;
-    }
-
-    constexpr explicit operator bool() const noexcept {
-        return this->m_has_val;
-    }
-
-    template <typename U = T>
-    constexpr U& value() & {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr const U& value() const& {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr U&& value() && {
-        return std::move(val());
-    }
-
-    template <typename U = T>
-    constexpr const U&& value() const&& {
-        return std::move(val());
-    }
-
-    constexpr E& error() & {
-        return err().value();
-    }
-
-    constexpr const E& error() const& {
-        return err().value();
-    }
-
-    constexpr E&& error() && {
-        return std::move(err().value());
-    }
-
-    constexpr const E&& error() const&& {
-        return std::move(err().value());
-    }
-
-    template <typename U>
-    constexpr T value_or(U&& v) const& {
-        static_assert(std::is_copy_constructible_v<T> && std::is_convertible_v<U&&, T>,
-                      "T must be copy-constructible and convertible from U&&");
-        return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
-    }
-
-    template <typename U>
-    constexpr T value_or(U&& v) && {
-        static_assert(std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>,
-                      "T must be move-constructible and convertible from U&&");
-        return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
-    }
-
-private:
-    static_assert(!std::is_reference_v<T>, "T must not be a reference");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<std::in_place_t>>,
-                  "T must not be std::in_place_t");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<unexpect_t>>, "T must not be unexpect_t");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<Unexpected<E>>>,
-                  "T must not be Unexpected<E>");
-    static_assert(!std::is_reference_v<E>, "E must not be a reference");
-
-    T* valptr() {
-        return std::addressof(this->m_val);
-    }
-
-    const T* valptr() const {
-        return std::addressof(this->m_val);
-    }
-
-    Unexpected<E>* errptr() {
-        return std::addressof(this->m_unexpect);
-    }
-
-    const Unexpected<E>* errptr() const {
-        return std::addressof(this->m_unexpect);
-    }
-
-    template <typename U = T>
-    constexpr U& val() {
-        return this->m_val;
-    }
-
-    template <typename U = T>
-    constexpr const U& val() const {
-        return this->m_val;
-    }
-
-    constexpr Unexpected<E>& err() {
-        return this->m_unexpect;
-    }
-
-    constexpr const Unexpected<E>& err() const {
-        return this->m_unexpect;
-    }
-
-    using impl_base = detail::expected_move_assign_base<T, E>;
-    using ctor_base = detail::expected_default_ctor_base<T, E>;
-};
-
-template <typename T, typename E, typename U, typename F>
-constexpr bool operator==(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
-    return (lhs.has_value() != rhs.has_value())
-               ? false
-               : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
-}
-
-template <typename T, typename E, typename U, typename F>
-constexpr bool operator!=(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
-    return !operator==(lhs, rhs);
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator==(const Expected<T, E>& x, const U& v) {
-    return x.has_value() ? *x == v : false;
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator==(const U& v, const Expected<T, E>& x) {
-    return x.has_value() ? *x == v : false;
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator!=(const Expected<T, E>& x, const U& v) {
-    return !operator==(x, v);
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator!=(const U& v, const Expected<T, E>& x) {
-    return !operator==(v, x);
-}
-
-template <typename T, typename E>
-constexpr bool operator==(const Expected<T, E>& x, const Unexpected<E>& e) {
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template <typename T, typename E>
-constexpr bool operator==(const Unexpected<E>& e, const Expected<T, E>& x) {
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template <typename T, typename E>
-constexpr bool operator!=(const Expected<T, E>& x, const Unexpected<E>& e) {
-    return !operator==(x, e);
-}
-
-template <typename T, typename E>
-constexpr bool operator!=(const Unexpected<E>& e, const Expected<T, E>& x) {
-    return !operator==(e, x);
-}
-
-} // namespace Common

src/common/logging/backend.cpp

@@ -6,6 +6,7 @@
 #include <chrono>
 #include <climits>
 #include <exception>
+#include <stop_token>
 #include <thread>
 #include <vector>
 
@@ -186,6 +187,10 @@ public:
         initialization_in_progress_suppress_logging = false;
     }
 
+    static void Start() {
+        instance->StartBackendThread();
+    }
+
     Impl(const Impl&) = delete;
     Impl& operator=(const Impl&) = delete;
 
@@ -201,7 +206,7 @@ public:
     }
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string message) {
+                   const char* function, std::string&& message) {
         if (!filter.CheckMessage(log_class, log_level))
             return;
         const Entry& entry =
@@ -211,40 +216,41 @@ public:
 
 private:
     Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
-              Common::SetCurrentThreadName("yuzu:Log");
-              Entry entry;
-              const auto write_logs = [this, &entry]() {
-                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-              };
-              while (true) {
-                  entry = message_queue.PopWait();
-                  if (entry.final_entry) {
-                      break;
-                  }
-                  write_logs();
-              }
-              // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-              // case where a system is repeatedly spamming logs even on close.
-              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-              while (max_logs_to_write-- && message_queue.Pop(entry)) {
-                  write_logs();
-              }
-          })} {}
+        : filter{filter_}, file_backend{file_backend_filename} {}
 
     ~Impl() {
         StopBackendThread();
     }
 
+    void StartBackendThread() {
+        backend_thread = std::thread([this] {
+            Common::SetCurrentThreadName("yuzu:Log");
+            Entry entry;
+            const auto write_logs = [this, &entry]() {
+                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
+            };
+            while (!stop.stop_requested()) {
+                entry = message_queue.PopWait(stop.get_token());
+                if (entry.filename != nullptr) {
+                    write_logs();
+                }
+            }
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+            // case where a system is repeatedly spamming logs even on close.
+            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
+            while (max_logs_to_write-- && message_queue.Pop(entry)) {
+                write_logs();
+            }
+        });
+    }
+
     void StopBackendThread() {
-        Entry stop_entry{};
-        stop_entry.final_entry = true;
-        message_queue.Push(stop_entry);
+        stop.request_stop();
         backend_thread.join();
     }
 
     Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, std::string message) const {
+                      const char* function, std::string&& message) const {
         using std::chrono::duration_cast;
         using std::chrono::microseconds;
         using std::chrono::steady_clock;
@@ -257,7 +263,6 @@ private:
             .line_num = line_nr,
             .function = function,
             .message = std::move(message),
-            .final_entry = false,
         };
     }
 
@@ -278,8 +283,9 @@ private:
     ColorConsoleBackend color_console_backend{};
     FileBackend file_backend;
 
+    std::stop_source stop;
     std::thread backend_thread;
-    MPSCQueue<Entry> message_queue{};
+    MPSCQueue<Entry, true> message_queue{};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 } // namespace
@@ -288,6 +294,10 @@ void Initialize() {
     Impl::Initialize();
 }
 
+void Start() {
+    Impl::Start();
+}
+
 void DisableLoggingInTests() {
     initialization_in_progress_suppress_logging = true;
 }

src/common/logging/backend.h

@@ -14,6 +14,8 @@ class Filter;
 /// Initializes the logging system. This should be the first thing called in main.
 void Initialize();
 
+void Start();
+
 void DisableLoggingInTests();
 
 /**

src/common/logging/log_entry.h

@@ -22,7 +22,6 @@ struct Entry {
     unsigned int line_num = 0;
     std::string function;
     std::string message;
-    bool final_entry = false;
 };
 
 } // namespace Common::Log

src/core/core.cpp

@@ -83,6 +83,12 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
     }
 }
 
+void KProcessDeleter(Kernel::KProcess* process) {
+    process->Destroy();
+}
+
+using KProcessPtr = std::unique_ptr<Kernel::KProcess, decltype(&KProcessDeleter)>;
+
 } // Anonymous namespace
 
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
@@ -255,10 +261,11 @@ struct System::Impl {
         }
 
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-        auto main_process = Kernel::KProcess::Create(system.Kernel());
-        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
+        main_process = KProcessPtr{Kernel::KProcess::Create(system.Kernel()), KProcessDeleter};
+        ASSERT(Kernel::KProcess::Initialize(main_process.get(), system, "main",
                                             Kernel::KProcess::ProcessType::Userland)
                    .IsSuccess());
+        main_process->Open();
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
@@ -268,7 +275,7 @@ struct System::Impl {
                 static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
         }
         AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process);
+        kernel.MakeCurrentProcess(main_process.get());
         kernel.InitializeCores();
 
         // Initialize cheat engine
@@ -333,6 +340,8 @@ struct System::Impl {
         kernel.Shutdown();
         memory.Reset();
         applet_manager.ClearAll();
+        // TODO: The main process should be freed based on KAutoObject ref counting.
+        main_process.reset();
 
         LOG_DEBUG(Core, "Shutdown OK");
     }
@@ -394,6 +403,7 @@ struct System::Impl {
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
     std::unique_ptr<Core::DeviceMemory> device_memory;
+    KProcessPtr main_process{nullptr, KProcessDeleter};
     Core::Memory::Memory memory;
     CpuManager cpu_manager;
     std::atomic_bool is_powered_on{};

src/core/file_sys/romfs_factory.cpp

@@ -39,12 +39,13 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) {
 
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
     if (!updatable) {
-        return file;
+        return MakeResult<VirtualFile>(file);
     }
 
     const PatchManager patch_manager{current_process_title_id, filesystem_controller,
                                      content_provider};
-    return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw);
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
@@ -57,7 +58,8 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor
 
     const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
 
-    return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type);
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type));
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
@@ -81,7 +83,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
         return ResultUnknown;
     }
 
-    return romfs;
+    return MakeResult<VirtualFile>(romfs);
 }
 
 std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,

src/core/file_sys/savedata_factory.cpp

@@ -94,7 +94,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
         return ResultUnknown;
     }
 
-    return out;
+    return MakeResult<VirtualDir>(std::move(out));
 }
 
 ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
@@ -115,7 +115,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
         return ResultUnknown;
     }
 
-    return out;
+    return MakeResult<VirtualDir>(std::move(out));
 }
 
 VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {

src/core/file_sys/sdmc_factory.cpp

@@ -25,7 +25,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
 SDMCFactory::~SDMCFactory() = default;
 
 ResultVal<VirtualDir> SDMCFactory::Open() const {
-    return sd_dir;
+    return MakeResult<VirtualDir>(sd_dir);
 }
 
 VirtualDir SDMCFactory::GetSDMCModificationLoadRoot(u64 title_id) const {

src/core/hle/kernel/k_handle_table.cpp

@@ -56,7 +56,6 @@ bool KHandleTable::Remove(Handle handle) {
     }
 
     // Close the object.
-    kernel.UnregisterInUseObject(obj);
     obj->Close();
     return true;
 }

src/core/hle/kernel/k_page_table.cpp

@@ -859,7 +859,7 @@ ResultVal<VAddr> KPageTable::SetHeapSize(std::size_t size) {
         current_heap_addr = heap_region_start + size;
     }
 
-    return heap_region_start;
+    return MakeResult<VAddr>(heap_region_start);
 }
 
 ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
@@ -893,7 +893,7 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages,
 
     block_manager->Update(addr, needed_num_pages, state, perm);
 
-    return addr;
+    return MakeResult<VAddr>(addr);
 }
 
 ResultCode KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {

src/core/hle/kernel/k_process.cpp

@@ -434,6 +434,11 @@ void KProcess::PrepareForTermination() {
 }
 
 void KProcess::Finalize() {
+    // Release memory to the resource limit.
+    if (resource_limit != nullptr) {
+        resource_limit->Close();
+    }
+
     // Finalize the handle table and close any open handles.
     handle_table.Finalize();
 
@@ -455,12 +460,6 @@ void KProcess::Finalize() {
         }
     }
 
-    // Release memory to the resource limit.
-    if (resource_limit != nullptr) {
-        resource_limit->Close();
-        resource_limit = nullptr;
-    }
-
     // Perform inherited finalization.
     KAutoObjectWithSlabHeapAndContainer<KProcess, KSynchronizationObject>::Finalize();
 }

src/core/hle/kernel/kernel.cpp

@@ -91,6 +91,12 @@ struct KernelCore::Impl {
     }
 
     void Shutdown() {
+        // Shutdown all processes.
+        if (current_process) {
+            current_process->Finalize();
+            current_process->Close();
+            current_process = nullptr;
+        }
         process_list.clear();
 
         // Close all open server ports.
@@ -164,24 +170,6 @@ struct KernelCore::Impl {
         // Next host thead ID to use, 0-3 IDs represent core threads, >3 represent others
         next_host_thread_id = Core::Hardware::NUM_CPU_CORES;
 
-        // Close kernel objects that were not freed on shutdown
-        {
-            std::lock_guard lk(registered_in_use_objects_lock);
-            if (registered_in_use_objects.size()) {
-                for (auto& object : registered_in_use_objects) {
-                    object->Close();
-                }
-                registered_in_use_objects.clear();
-            }
-        }
-
-        // Shutdown all processes.
-        if (current_process) {
-            current_process->Finalize();
-            current_process->Close();
-            current_process = nullptr;
-        }
-
         // Track kernel objects that were not freed on shutdown
         {
             std::lock_guard lk(registered_objects_lock);
@@ -726,11 +714,9 @@ struct KernelCore::Impl {
     std::unordered_set<KServerPort*> server_ports;
     std::unordered_set<KServerSession*> server_sessions;
     std::unordered_set<KAutoObject*> registered_objects;
-    std::unordered_set<KAutoObject*> registered_in_use_objects;
     std::mutex server_ports_lock;
     std::mutex server_sessions_lock;
     std::mutex registered_objects_lock;
-    std::mutex registered_in_use_objects_lock;
 
     std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
     std::vector<Kernel::PhysicalCore> cores;
@@ -942,16 +928,6 @@ void KernelCore::UnregisterKernelObject(KAutoObject* object) {
     impl->registered_objects.erase(object);
 }
 
-void KernelCore::RegisterInUseObject(KAutoObject* object) {
-    std::lock_guard lk(impl->registered_in_use_objects_lock);
-    impl->registered_in_use_objects.insert(object);
-}
-
-void KernelCore::UnregisterInUseObject(KAutoObject* object) {
-    std::lock_guard lk(impl->registered_in_use_objects_lock);
-    impl->registered_in_use_objects.erase(object);
-}
-
 bool KernelCore::IsValidNamedPort(NamedPortTable::const_iterator port) const {
     return port != impl->named_ports.cend();
 }

src/core/hle/kernel/kernel.h

@@ -204,14 +204,6 @@ public:
     /// destroyed during the current emulation session.
     void UnregisterKernelObject(KAutoObject* object);
 
-    /// Registers kernel objects with guest in use state, this is purely for close
-    /// after emulation has been shutdown.
-    void RegisterInUseObject(KAutoObject* object);
-
-    /// Unregisters a kernel object previously registered with RegisterInUseObject when it was
-    /// destroyed during the current emulation session.
-    void UnregisterInUseObject(KAutoObject* object);
-
     /// Determines whether or not the given port is a valid named port.
     bool IsValidNamedPort(NamedPortTable::const_iterator port) const;
 

src/core/hle/kernel/svc.cpp

@@ -427,15 +427,11 @@ static ResultCode WaitSynchronization(Core::System& system, s32* index, VAddr ha
         R_UNLESS(handle_table.GetMultipleObjects<KSynchronizationObject>(objs.data(), handles,
                                                                          num_handles),
                  ResultInvalidHandle);
-        for (const auto& obj : objs) {
-            kernel.RegisterInUseObject(obj);
-        }
     }
 
     // Ensure handles are closed when we're done.
     SCOPE_EXIT({
         for (u64 i = 0; i < num_handles; ++i) {
-            kernel.UnregisterInUseObject(objs[i]);
             objs[i]->Close();
         }
     });
@@ -1565,7 +1561,6 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
 
     // If we succeeded, persist a reference to the thread.
     thread->Open();
-    system.Kernel().RegisterInUseObject(thread.GetPointerUnsafe());
 
     return ResultSuccess;
 }
@@ -1581,7 +1576,6 @@ static void ExitThread(Core::System& system) {
     auto* const current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
     system.GlobalSchedulerContext().RemoveThread(current_thread);
     current_thread->Exit();
-    system.Kernel().UnregisterInUseObject(current_thread);
 }
 
 static void ExitThread32(Core::System& system) {

src/core/hle/result.h

@@ -4,10 +4,11 @@
 
 #pragma once
 
+#include <new>
+#include <utility>
 #include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_types.h"
-#include "common/expected.h"
 
 // All the constants in this file come from http://switchbrew.org/index.php?title=Error_codes
 
@@ -154,131 +155,204 @@ constexpr ResultCode ResultSuccess(0);
 constexpr ResultCode ResultUnknown(UINT32_MAX);
 
 /**
- * This is an optional value type. It holds a `ResultCode` and, if that code is ResultSuccess, it
- * also holds a result of type `T`. If the code is an error code (not ResultSuccess), then trying
- * to access the inner value with operator* is undefined behavior and will assert with Unwrap().
- * Users of this class must be cognizant to check the status of the ResultVal with operator bool(),
- * Code(), Succeeded() or Failed() prior to accessing the inner value.
+ * This is an optional value type. It holds a `ResultCode` and, if that code is a success code,
+ * also holds a result of type `T`. If the code is an error code then trying to access the inner
+ * value fails, thus ensuring that the ResultCode of functions is always checked properly before
+ * their return value is used.  It is similar in concept to the `std::optional` type
+ * (http://en.cppreference.com/w/cpp/experimental/optional) originally proposed for inclusion in
+ * C++14, or the `Result` type in Rust (http://doc.rust-lang.org/std/result/index.html).
  *
  * An example of how it could be used:
  * \code
  * ResultVal<int> Frobnicate(float strength) {
  *     if (strength < 0.f || strength > 1.0f) {
  *         // Can't frobnicate too weakly or too strongly
- *         return ResultCode{ErrorModule::Common, 1};
+ *         return ResultCode(ErrorDescription::OutOfRange, ErrorModule::Common,
+ *             ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
  *     } else {
  *         // Frobnicated! Give caller a cookie
- *         return 42;
+ *         return MakeResult<int>(42);
  *     }
  * }
  * \endcode
  *
  * \code
- * auto frob_result = Frobnicate(0.75f);
+ * ResultVal<int> frob_result = Frobnicate(0.75f);
  * if (frob_result) {
  *     // Frobbed ok
  *     printf("My cookie is %d\n", *frob_result);
  * } else {
- *     printf("Guess I overdid it. :( Error code: %ux\n", frob_result.Code().raw);
+ *     printf("Guess I overdid it. :( Error code: %ux\n", frob_result.code().hex);
  * }
  * \endcode
  */
 template <typename T>
 class ResultVal {
 public:
-    constexpr ResultVal() : expected{} {}
-
-    constexpr ResultVal(ResultCode code) : expected{Common::Unexpected(code)} {}
-
-    template <typename U>
-    constexpr ResultVal(U&& val) : expected{std::forward<U>(val)} {}
+    /// Constructs an empty `ResultVal` with the given error code. The code must not be a success
+    /// code.
+    ResultVal(ResultCode error_code = ResultUnknown) : result_code(error_code) {
+        ASSERT(error_code.IsError());
+    }
 
+    /**
+     * Similar to the non-member function `MakeResult`, with the exception that you can manually
+     * specify the success code. `success_code` must not be an error code.
+     */
     template <typename... Args>
-    constexpr ResultVal(Args&&... args) : expected{std::in_place, std::forward<Args>(args)...} {}
-
-    ~ResultVal() = default;
-
-    constexpr ResultVal(const ResultVal&) = default;
-    constexpr ResultVal(ResultVal&&) = default;
-
-    ResultVal& operator=(const ResultVal&) = default;
-    ResultVal& operator=(ResultVal&&) = default;
-
-    [[nodiscard]] constexpr explicit operator bool() const noexcept {
-        return expected.has_value();
+    [[nodiscard]] static ResultVal WithCode(ResultCode success_code, Args&&... args) {
+        ResultVal<T> result;
+        result.emplace(success_code, std::forward<Args>(args)...);
+        return result;
     }
 
-    [[nodiscard]] constexpr ResultCode Code() const {
-        return expected.has_value() ? ResultSuccess : expected.error();
+    ResultVal(const ResultVal& o) noexcept : result_code(o.result_code) {
+        if (!o.empty()) {
+            new (&object) T(o.object);
+        }
     }
 
-    [[nodiscard]] constexpr bool Succeeded() const {
-        return expected.has_value();
+    ResultVal(ResultVal&& o) noexcept : result_code(o.result_code) {
+        if (!o.empty()) {
+            new (&object) T(std::move(o.object));
+        }
     }
 
-    [[nodiscard]] constexpr bool Failed() const {
-        return !expected.has_value();
+    ~ResultVal() {
+        if (!empty()) {
+            object.~T();
+        }
     }
 
-    [[nodiscard]] constexpr T* operator->() {
-        return std::addressof(expected.value());
+    ResultVal& operator=(const ResultVal& o) noexcept {
+        if (this == &o) {
+            return *this;
+        }
+        if (!empty()) {
+            if (!o.empty()) {
+                object = o.object;
+            } else {
+                object.~T();
+            }
+        } else {
+            if (!o.empty()) {
+                new (&object) T(o.object);
+            }
+        }
+        result_code = o.result_code;
+
+        return *this;
     }
 
-    [[nodiscard]] constexpr const T* operator->() const {
-        return std::addressof(expected.value());
+    ResultVal& operator=(ResultVal&& o) noexcept {
+        if (this == &o) {
+            return *this;
+        }
+        if (!empty()) {
+            if (!o.empty()) {
+                object = std::move(o.object);
+            } else {
+                object.~T();
+            }
+        } else {
+            if (!o.empty()) {
+                new (&object) T(std::move(o.object));
+            }
+        }
+        result_code = o.result_code;
+
+        return *this;
     }
 
-    [[nodiscard]] constexpr T& operator*() & {
-        return *expected;
+    /**
+     * Replaces the current result with a new constructed result value in-place. The code must not
+     * be an error code.
+     */
+    template <typename... Args>
+    void emplace(ResultCode success_code, Args&&... args) {
+        ASSERT(success_code.IsSuccess());
+        if (!empty()) {
+            object.~T();
+        }
+        new (&object) T(std::forward<Args>(args)...);
+        result_code = success_code;
     }
 
-    [[nodiscard]] constexpr const T& operator*() const& {
-        return *expected;
+    /// Returns true if the `ResultVal` contains an error code and no value.
+    [[nodiscard]] bool empty() const {
+        return result_code.IsError();
     }
 
-    [[nodiscard]] constexpr T&& operator*() && {
-        return *expected;
+    /// Returns true if the `ResultVal` contains a return value.
+    [[nodiscard]] bool Succeeded() const {
+        return result_code.IsSuccess();
+    }
+    /// Returns true if the `ResultVal` contains an error code and no value.
+    [[nodiscard]] bool Failed() const {
+        return empty();
     }
 
-    [[nodiscard]] constexpr const T&& operator*() const&& {
-        return *expected;
+    [[nodiscard]] ResultCode Code() const {
+        return result_code;
     }
 
-    [[nodiscard]] constexpr T& Unwrap() & {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return expected.value();
-    }
-
-    [[nodiscard]] constexpr const T& Unwrap() const& {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return expected.value();
-    }
-
-    [[nodiscard]] constexpr T&& Unwrap() && {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return std::move(expected.value());
-    }
-
-    [[nodiscard]] constexpr const T&& Unwrap() const&& {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return std::move(expected.value());
+    [[nodiscard]] const T& operator*() const {
+        return object;
+    }
+    [[nodiscard]] T& operator*() {
+        return object;
+    }
+    [[nodiscard]] const T* operator->() const {
+        return &object;
+    }
+    [[nodiscard]] T* operator->() {
+        return &object;
     }
 
+    /// Returns the value contained in this `ResultVal`, or the supplied default if it is missing.
     template <typename U>
-    [[nodiscard]] constexpr T ValueOr(U&& v) const& {
-        return expected.value_or(v);
+    [[nodiscard]] T ValueOr(U&& value) const {
+        return !empty() ? object : std::move(value);
     }
 
-    template <typename U>
-    [[nodiscard]] constexpr T ValueOr(U&& v) && {
-        return expected.value_or(v);
+    /// Asserts that the result succeeded and returns a reference to it.
+    [[nodiscard]] T& Unwrap() & {
+        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
+        return **this;
+    }
+
+    [[nodiscard]] T&& Unwrap() && {
+        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
+        return std::move(**this);
     }
 
 private:
-    // TODO: Replace this with std::expected once it is standardized in the STL.
-    Common::Expected<T, ResultCode> expected;
+    // A union is used to allocate the storage for the value, while allowing us to construct and
+    // destruct it at will.
+    union {
+        T object;
+    };
+    ResultCode result_code;
 };
 
+/**
+ * This function is a helper used to construct `ResultVal`s. It receives the arguments to construct
+ * `T` with and creates a success `ResultVal` contained the constructed value.
+ */
+template <typename T, typename... Args>
+[[nodiscard]] ResultVal<T> MakeResult(Args&&... args) {
+    return ResultVal<T>::WithCode(ResultSuccess, std::forward<Args>(args)...);
+}
+
+/**
+ * Deducible overload of MakeResult, allowing the template parameter to be ommited if you're just
+ * copy or move constructing.
+ */
+template <typename Arg>
+[[nodiscard]] ResultVal<std::remove_cvref_t<Arg>> MakeResult(Arg&& arg) {
+    return ResultVal<std::remove_cvref_t<Arg>>::WithCode(ResultSuccess, std::forward<Arg>(arg));
+}
+
 /**
  * Check for the success of `source` (which must evaluate to a ResultVal). If it succeeds, unwraps
  * the contained value and assigns it to `target`, which can be either an l-value expression or a

src/core/hle/service/filesystem/filesystem.cpp

@@ -226,10 +226,11 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
     }
 
     if (mode == FileSys::Mode::Append) {
-        return std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize());
+        return MakeResult<FileSys::VirtualFile>(
+            std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize()));
     }
 
-    return file;
+    return MakeResult<FileSys::VirtualFile>(file);
 }
 
 ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path_) {
@@ -239,7 +240,7 @@ ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const s
         // TODO(DarkLordZach): Find a better error code for this
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
-    return dir;
+    return MakeResult(dir);
 }
 
 ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
@@ -251,12 +252,12 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
     auto filename = Common::FS::GetFilename(path);
     // TODO(Subv): Some games use the '/' path, find out what this means.
     if (filename.empty())
-        return FileSys::EntryType::Directory;
+        return MakeResult(FileSys::EntryType::Directory);
 
     if (dir->GetFile(filename) != nullptr)
-        return FileSys::EntryType::File;
+        return MakeResult(FileSys::EntryType::File);
     if (dir->GetSubdirectory(filename) != nullptr)
-        return FileSys::EntryType::Directory;
+        return MakeResult(FileSys::EntryType::Directory);
     return FileSys::ERROR_PATH_NOT_FOUND;
 }
 
@@ -269,7 +270,7 @@ ResultVal<FileSys::FileTimeStampRaw> VfsDirectoryServiceWrapper::GetFileTimeStam
     if (GetEntryType(path).Failed()) {
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
-    return dir->GetFileTimeStamp(Common::FS::GetFilename(path));
+    return MakeResult(dir->GetFileTimeStamp(Common::FS::GetFilename(path)));
 }
 
 FileSystemController::FileSystemController(Core::System& system_) : system{system_} {}
@@ -394,7 +395,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace(
         return FileSys::ERROR_ENTITY_NOT_FOUND;
     }
 
-    return save_data_factory->GetSaveDataSpaceDirectory(space);
+    return MakeResult(save_data_factory->GetSaveDataSpaceDirectory(space));
 }
 
 ResultVal<FileSys::VirtualDir> FileSystemController::OpenSDMC() const {
@@ -420,7 +421,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
         return FileSys::ERROR_INVALID_ARGUMENT;
     }
 
-    return part;
+    return MakeResult<FileSys::VirtualDir>(std::move(part));
 }
 
 ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
@@ -436,7 +437,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
         return FileSys::ERROR_INVALID_ARGUMENT;
     }
 
-    return part;
+    return MakeResult<FileSys::VirtualFile>(std::move(part));
 }
 
 u64 FileSystemController::GetFreeSpaceSize(FileSys::StorageId id) const {

src/core/hle/service/glue/glue_manager.cpp

@@ -26,7 +26,7 @@ ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id)
         return ERR_NOT_REGISTERED;
     }
 
-    return iter->second.launch;
+    return MakeResult<ApplicationLaunchProperty>(iter->second.launch);
 }
 
 ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
@@ -39,7 +39,7 @@ ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
         return ERR_NOT_REGISTERED;
     }
 
-    return iter->second.control;
+    return MakeResult<std::vector<u8>>(iter->second.control);
 }
 
 ResultCode ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,

src/core/hle/service/ldr/ldr.cpp

@@ -335,7 +335,7 @@ public:
             CASCADE_CODE(result);
 
             if (ValidateRegionForMap(page_table, addr, size)) {
-                return addr;
+                return MakeResult<VAddr>(addr);
             }
         }
 
@@ -371,7 +371,7 @@ public:
             }
 
             if (ValidateRegionForMap(page_table, addr, size)) {
-                return addr;
+                return MakeResult<VAddr>(addr);
             }
         }
 

src/core/hle/service/mii/mii_manager.cpp

@@ -443,14 +443,14 @@ ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_
     std::vector<MiiInfoElement> result;
 
     if ((source_flag & SourceFlag::Default) == SourceFlag::None) {
-        return result;
+        return MakeResult(std::move(result));
     }
 
     for (std::size_t index = BaseMiiCount; index < DefaultMiiCount; index++) {
         result.emplace_back(BuildDefault(index), Source::Default);
     }
 
-    return result;
+    return MakeResult(std::move(result));
 }
 
 ResultCode MiiManager::GetIndex([[maybe_unused]] const MiiInfo& info, u32& index) {

src/core/hle/service/ns/ns.cpp

@@ -414,7 +414,7 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
     for (const auto lang : *priority_list) {
         const auto supported_flag = GetSupportedLanguageFlag(lang);
         if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) {
-            return static_cast<u8>(lang);
+            return MakeResult(static_cast<u8>(lang));
         }
     }
 
@@ -448,7 +448,7 @@ ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguag
         return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
     }
 
-    return static_cast<u64>(*language_code);
+    return MakeResult(static_cast<u64>(*language_code));
 }
 
 IApplicationVersionInterface::IApplicationVersionInterface(Core::System& system_)

src/core/hle/service/sm/sm.cpp

@@ -87,7 +87,7 @@ ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name
     auto handler = it->second;
     port->GetServerPort().SetSessionHandler(std::move(handler));
 
-    return port;
+    return MakeResult(port);
 }
 
 /**
@@ -165,7 +165,7 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(Kernel::HLERequestContext&
 
     LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId());
 
-    return session;
+    return MakeResult(session);
 }
 
 void SM::RegisterService(Kernel::HLERequestContext& ctx) {

src/core/hle/service/spl/spl_module.cpp

@@ -120,40 +120,40 @@ ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const {
         return ResultSecureMonitorNotImplemented;
     case ConfigItem::ExosphereApiVersion:
         // Get information about the current exosphere version.
-        return (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
-               (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
-               (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
-               (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware()));
+        return MakeResult((u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
+                          (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
+                          (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
+                          (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware())));
     case ConfigItem::ExosphereNeedsReboot:
         // We are executing, so we aren't in the process of rebooting.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereNeedsShutdown:
         // We are executing, so we aren't in the process of shutting down.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereGitCommitHash:
         // Get information about the current exosphere git commit hash.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereHasRcmBugPatch:
         // Get information about whether this unit has the RCM bug patched.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereBlankProdInfo:
         // Get whether this unit should simulate a "blanked" PRODINFO.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereAllowCalWrites:
         // Get whether this unit should allow writing to the calibration partition.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereEmummcType:
         // Get what kind of emummc this unit has active.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExospherePayloadAddress:
         // Gets the physical address of the reboot payload buffer, if one exists.
         return ResultSecureMonitorNotInitialized;
     case ConfigItem::ExosphereLogConfiguration:
         // Get the log configuration.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereForceEnableUsb30:
         // Get whether usb 3.0 should be force-enabled.
-        return u64{0};
+        return MakeResult(u64{0});
     default:
         return ResultSecureMonitorInvalidArgument;
     }

src/core/hle/service/vi/vi.cpp

@@ -1284,15 +1284,15 @@ private:
     static ResultVal<ConvertedScaleMode> ConvertScalingModeImpl(NintendoScaleMode mode) {
         switch (mode) {
         case NintendoScaleMode::None:
-            return ConvertedScaleMode::None;
+            return MakeResult(ConvertedScaleMode::None);
         case NintendoScaleMode::Freeze:
-            return ConvertedScaleMode::Freeze;
+            return MakeResult(ConvertedScaleMode::Freeze);
         case NintendoScaleMode::ScaleToWindow:
-            return ConvertedScaleMode::ScaleToWindow;
+            return MakeResult(ConvertedScaleMode::ScaleToWindow);
         case NintendoScaleMode::ScaleAndCrop:
-            return ConvertedScaleMode::ScaleAndCrop;
+            return MakeResult(ConvertedScaleMode::ScaleAndCrop);
         case NintendoScaleMode::PreserveAspectRatio:
-            return ConvertedScaleMode::PreserveAspectRatio;
+            return MakeResult(ConvertedScaleMode::PreserveAspectRatio);
         default:
             LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
             return ERR_OPERATION_FAILED;

src/yuzu/main.cpp

@@ -299,6 +299,8 @@ GMainWindow::GMainWindow()
     SDL_EnableScreenSaver();
 #endif
 
+    Common::Log::Start();
+
     QStringList args = QApplication::arguments();
 
     if (args.size() < 2) {