common: Rewrite logging based on cut down citra logger (#86)

* common: Rewrite logging based on cut down Citra logger

* code: Misc fixes

* core: Bring back tls handler

* linker: Cleanup

* config: Remove log level

* logging: Enable console output by default

* core: Fix windows build

src/common/assert.cpp

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/assert.h"
+#include "common/logging/backend.h"
+
+#define Crash() __asm__ __volatile__("int $3")
+
+void assert_fail_impl() {
+    Common::Log::Stop();
+    Crash();
+}
+
+[[noreturn]] void unreachable_impl() {
+    Common::Log::Stop();
+    Crash();
+    throw std::runtime_error("Unreachable code");
+}

src/common/assert.h

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/logging/log.h"
+
+// Sometimes we want to try to continue even after hitting an assert.
+// However touching this file yields a global recompilation as this header is included almost
+// everywhere. So let's just move the handling of the failed assert to a single cpp file.
+
+void assert_fail_impl();
+[[noreturn]] void unreachable_impl();
+
+#ifdef _MSC_VER
+#define SHAD_NO_INLINE __declspec(noinline)
+#else
+#define SHAD_NO_INLINE __attribute__((noinline))
+#endif
+
+#define ASSERT(_a_)                                                                                \
+    ([&]() SHAD_NO_INLINE {                                                                        \
+        if (!(_a_)) [[unlikely]] {                                                                 \
+            LOG_CRITICAL(Debug, "Assertion Failed!");                                              \
+            assert_fail_impl();                                                                    \
+        }                                                                                          \
+    }())
+
+#define ASSERT_MSG(_a_, ...)                                                                       \
+    ([&]() SHAD_NO_INLINE {                                                                        \
+        if (!(_a_)) [[unlikely]] {                                                                 \
+            LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__);                                \
+            assert_fail_impl();                                                                    \
+        }                                                                                          \
+    }())
+
+#define UNREACHABLE()                                                                              \
+    do {                                                                                           \
+        LOG_CRITICAL(Debug, "Unreachable code!");                                                  \
+        unreachable_impl();                                                                        \
+    } while (0)
+
+#define UNREACHABLE_MSG(...)                                                                       \
+    do {                                                                                           \
+        LOG_CRITICAL(Debug, "Unreachable code!\n" __VA_ARGS__);                                    \
+        unreachable_impl();                                                                        \
+    } while (0)
+
+#ifdef _DEBUG
+#define DEBUG_ASSERT(_a_) ASSERT(_a_)
+#define DEBUG_ASSERT_MSG(_a_, ...) ASSERT_MSG(_a_, __VA_ARGS__)
+#else // not debug
+#define DEBUG_ASSERT(_a_)                                                                          \
+    do {                                                                                           \
+    } while (0)
+#define DEBUG_ASSERT_MSG(_a_, _desc_, ...)                                                         \
+    do {                                                                                           \
+    } while (0)
+#endif
+
+#define UNIMPLEMENTED() ASSERT_MSG(false, "Unimplemented code!")
+#define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)
+
+#define UNIMPLEMENTED_IF(cond) ASSERT_MSG(!(cond), "Unimplemented code!")
+#define UNIMPLEMENTED_IF_MSG(cond, ...) ASSERT_MSG(!(cond), __VA_ARGS__)
+
+// If the assert is ignored, execute _b_
+#define ASSERT_OR_EXECUTE(_a_, _b_)                                                                \
+    do {                                                                                           \
+        ASSERT(_a_);                                                                               \
+        if (!(_a_)) [[unlikely]] {                                                                 \
+            _b_                                                                                    \
+        }                                                                                          \
+    } while (0)
+
+// If the assert is ignored, execute _b_
+#define ASSERT_OR_EXECUTE_MSG(_a_, _b_, ...)                                                       \
+    do {                                                                                           \
+        ASSERT_MSG(_a_, __VA_ARGS__);                                                              \
+        if (!(_a_)) [[unlikely]] {                                                                 \
+            _b_                                                                                    \
+        }                                                                                          \
+    } while (0)

src/common/bounded_threadsafe_queue.h

@@ -0,0 +1,248 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <atomic>
+#include <condition_variable>
+#include <cstddef>
+#include <memory>
+#include <mutex>
+#include <new>
+
+namespace Common {
+
+namespace detail {
+constexpr std::size_t DefaultCapacity = 0x1000;
+} // namespace detail
+
+template <typename T, std::size_t Capacity = detail::DefaultCapacity>
+class SPSCQueue {
+    static_assert((Capacity & (Capacity - 1)) == 0, "Capacity must be a power of two.");
+
+public:
+    template <typename... Args>
+    bool TryEmplace(Args&&... args) {
+        return Emplace<PushMode::Try>(std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    void EmplaceWait(Args&&... args) {
+        Emplace<PushMode::Wait>(std::forward<Args>(args)...);
+    }
+
+    bool TryPop(T& t) {
+        return Pop<PopMode::Try>(t);
+    }
+
+    void PopWait(T& t) {
+        Pop<PopMode::Wait>(t);
+    }
+
+    void PopWait(T& t, std::stop_token stop_token) {
+        Pop<PopMode::WaitWithStopToken>(t, stop_token);
+    }
+
+    T PopWait() {
+        T t;
+        Pop<PopMode::Wait>(t);
+        return t;
+    }
+
+    T PopWait(std::stop_token stop_token) {
+        T t;
+        Pop<PopMode::WaitWithStopToken>(t, stop_token);
+        return t;
+    }
+
+private:
+    enum class PushMode {
+        Try,
+        Wait,
+        Count,
+    };
+
+    enum class PopMode {
+        Try,
+        Wait,
+        WaitWithStopToken,
+        Count,
+    };
+
+    template <PushMode Mode, typename... Args>
+    bool Emplace(Args&&... args) {
+        const std::size_t write_index = m_write_index.load(std::memory_order::relaxed);
+
+        if constexpr (Mode == PushMode::Try) {
+            // Check if we have free slots to write to.
+            if ((write_index - m_read_index.load(std::memory_order::acquire)) == Capacity) {
+                return false;
+            }
+        } else if constexpr (Mode == PushMode::Wait) {
+            // Wait until we have free slots to write to.
+            std::unique_lock lock{producer_cv_mutex};
+            producer_cv.wait(lock, [this, write_index] {
+                return (write_index - m_read_index.load(std::memory_order::acquire)) < Capacity;
+            });
+        } else {
+            static_assert(Mode < PushMode::Count, "Invalid PushMode.");
+        }
+
+        // Determine the position to write to.
+        const std::size_t pos = write_index % Capacity;
+
+        // Emplace into the queue.
+        new (std::addressof(m_data[pos])) T(std::forward<Args>(args)...);
+
+        // Increment the write index.
+        ++m_write_index;
+
+        // Notify the consumer that we have pushed into the queue.
+        std::scoped_lock lock{consumer_cv_mutex};
+        consumer_cv.notify_one();
+
+        return true;
+    }
+
+    template <PopMode Mode>
+    bool Pop(T& t, [[maybe_unused]] std::stop_token stop_token = {}) {
+        const std::size_t read_index = m_read_index.load(std::memory_order::relaxed);
+
+        if constexpr (Mode == PopMode::Try) {
+            // Check if the queue is empty.
+            if (read_index == m_write_index.load(std::memory_order::acquire)) {
+                return false;
+            }
+        } else if constexpr (Mode == PopMode::Wait) {
+            // Wait until the queue is not empty.
+            std::unique_lock lock{consumer_cv_mutex};
+            consumer_cv.wait(lock, [this, read_index] {
+                return read_index != m_write_index.load(std::memory_order::acquire);
+            });
+        } else if constexpr (Mode == PopMode::WaitWithStopToken) {
+            // Wait until the queue is not empty.
+            std::unique_lock lock{consumer_cv_mutex};
+            consumer_cv.wait(lock, stop_token, [this, read_index] {
+                return read_index != m_write_index.load(std::memory_order::acquire);
+            });
+            if (stop_token.stop_requested()) {
+                return false;
+            }
+        } else {
+            static_assert(Mode < PopMode::Count, "Invalid PopMode.");
+        }
+
+        // Determine the position to read from.
+        const std::size_t pos = read_index % Capacity;
+
+        // Pop the data off the queue, moving it.
+        t = std::move(m_data[pos]);
+
+        // Increment the read index.
+        ++m_read_index;
+
+        // Notify the producer that we have popped off the queue.
+        std::scoped_lock lock{producer_cv_mutex};
+        producer_cv.notify_one();
+
+        return true;
+    }
+
+    alignas(128) std::atomic_size_t m_read_index{0};
+    alignas(128) std::atomic_size_t m_write_index{0};
+
+    std::array<T, Capacity> m_data;
+
+    std::condition_variable_any producer_cv;
+    std::mutex producer_cv_mutex;
+    std::condition_variable_any consumer_cv;
+    std::mutex consumer_cv_mutex;
+};
+
+template <typename T, std::size_t Capacity = detail::DefaultCapacity>
+class MPSCQueue {
+public:
+    template <typename... Args>
+    bool TryEmplace(Args&&... args) {
+        std::scoped_lock lock{write_mutex};
+        return spsc_queue.TryEmplace(std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    void EmplaceWait(Args&&... args) {
+        std::scoped_lock lock{write_mutex};
+        spsc_queue.EmplaceWait(std::forward<Args>(args)...);
+    }
+
+    bool TryPop(T& t) {
+        return spsc_queue.TryPop(t);
+    }
+
+    void PopWait(T& t) {
+        spsc_queue.PopWait(t);
+    }
+
+    void PopWait(T& t, std::stop_token stop_token) {
+        spsc_queue.PopWait(t, stop_token);
+    }
+
+    T PopWait() {
+        return spsc_queue.PopWait();
+    }
+
+    T PopWait(std::stop_token stop_token) {
+        return spsc_queue.PopWait(stop_token);
+    }
+
+private:
+    SPSCQueue<T, Capacity> spsc_queue;
+    std::mutex write_mutex;
+};
+
+template <typename T, std::size_t Capacity = detail::DefaultCapacity>
+class MPMCQueue {
+public:
+    template <typename... Args>
+    bool TryEmplace(Args&&... args) {
+        std::scoped_lock lock{write_mutex};
+        return spsc_queue.TryEmplace(std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    void EmplaceWait(Args&&... args) {
+        std::scoped_lock lock{write_mutex};
+        spsc_queue.EmplaceWait(std::forward<Args>(args)...);
+    }
+
+    bool TryPop(T& t) {
+        std::scoped_lock lock{read_mutex};
+        return spsc_queue.TryPop(t);
+    }
+
+    void PopWait(T& t) {
+        std::scoped_lock lock{read_mutex};
+        spsc_queue.PopWait(t);
+    }
+
+    void PopWait(T& t, std::stop_token stop_token) {
+        std::scoped_lock lock{read_mutex};
+        spsc_queue.PopWait(t, stop_token);
+    }
+
+    T PopWait() {
+        std::scoped_lock lock{read_mutex};
+        return spsc_queue.PopWait();
+    }
+
+    T PopWait(std::stop_token stop_token) {
+        std::scoped_lock lock{read_mutex};
+        return spsc_queue.PopWait(stop_token);
+    }
+
+private:
+    SPSCQueue<T, Capacity> spsc_queue;
+    std::mutex write_mutex;
+    std::mutex read_mutex;
+};
+
+} // namespace Common

src/common/concepts.h

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <concepts>
+#include <iterator>
+#include <type_traits>
+
+namespace Common {
+
+// Check if type satisfies the ContiguousContainer named requirement.
+template <typename T>
+concept IsContiguousContainer = std::contiguous_iterator<typename T::iterator>;
+
+template <typename Derived, typename Base>
+concept DerivedFrom = std::derived_from<Derived, Base>;
+
+// TODO: Replace with std::convertible_to when libc++ implements it.
+template <typename From, typename To>
+concept ConvertibleTo = std::is_convertible_v<From, To>;
+
+// No equivalents in the stdlib
+
+template <typename T>
+concept IsArithmetic = std::is_arithmetic_v<T>;
+
+template <typename T>
+concept IsIntegral = std::is_integral_v<T>;
+
+} // namespace Common

src/common/error.cpp

@@ -0,0 +1,57 @@
+// SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cstddef>
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <cerrno>
+#include <cstring>
+#endif
+
+#include "common/error.h"
+
+namespace Common {
+
+std::string NativeErrorToString(int e) {
+#ifdef _WIN32
+    LPSTR err_str;
+
+    DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                                   FORMAT_MESSAGE_IGNORE_INSERTS,
+                               nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
+    if (!res) {
+        return "(FormatMessageA failed to format error)";
+    }
+    std::string ret(err_str);
+    LocalFree(err_str);
+    return ret;
+#else
+    char err_str[255];
+#if defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600)) ||   \
+    defined(ANDROID)
+    // Thread safe (GNU-specific)
+    const char* str = strerror_r(e, err_str, sizeof(err_str));
+    return std::string(str);
+#else
+    // Thread safe (XSI-compliant)
+    int second_err = strerror_r(e, err_str, sizeof(err_str));
+    if (second_err != 0) {
+        return "(strerror_r failed to format error)";
+    }
+    return std::string(err_str);
+#endif // GLIBC etc.
+#endif // _WIN32
+}
+
+std::string GetLastErrorMsg() {
+#ifdef _WIN32
+    return NativeErrorToString(GetLastError());
+#else
+    return NativeErrorToString(errno);
+#endif
+}
+
+} // namespace Common

src/common/error.h

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+
+namespace Common {
+
+// Generic function to get last error message.
+// Call directly after the command or use the error num.
+// This function might change the error code.
+// Defined in error.cpp.
+[[nodiscard]] std::string GetLastErrorMsg();
+
+// Like GetLastErrorMsg(), but passing an explicit error code.
+// Defined in error.cpp.
+[[nodiscard]] std::string NativeErrorToString(int e);
+
+} // namespace Common

src/common/fs_file.cpp

@@ -1,96 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/fs_file.h"
-
-namespace Common::FS {
-
-File::File() = default;
-
-File::File(const std::string& path, OpenMode mode) {
-    open(path, mode);
-}
-
-File::~File() {
-    close();
-}
-
-bool File::open(const std::string& path, OpenMode mode) {
-    close();
-#ifdef _WIN64
-    fopen_s(&m_file, path.c_str(), getOpenMode(mode));
-#else
-    m_file = std::fopen(path.c_str(), getOpenMode(mode));
-#endif
-    return isOpen();
-}
-
-bool File::close() {
-    if (!isOpen() || std::fclose(m_file) != 0) [[unlikely]] {
-        m_file = nullptr;
-        return false;
-    }
-
-    m_file = nullptr;
-    return true;
-}
-
-bool File::write(std::span<const u8> data) {
-    return isOpen() && std::fwrite(data.data(), 1, data.size(), m_file) == data.size();
-}
-
-bool File::read(void* data, u64 size) const {
-    return isOpen() && std::fread(data, 1, size, m_file) == size;
-}
-
-bool File::seek(s64 offset, SeekMode mode) {
-#ifdef _WIN64
-    if (!isOpen() || _fseeki64(m_file, offset, getSeekMode(mode)) != 0) {
-        return false;
-    }
-#else
-    if (!isOpen() || fseeko64(m_file, offset, getSeekMode(mode)) != 0) {
-        return false;
-    }
-#endif
-    return true;
-}
-
-u64 File::tell() const {
-    if (isOpen()) [[likely]] {
-#ifdef _WIN64
-        return _ftelli64(m_file);
-#else
-        return ftello64(m_file);
-#endif
-    }
-
-    return -1;
-}
-
-u64 File::getFileSize() {
-#ifdef _WIN64
-    const u64 pos = _ftelli64(m_file);
-    if (_fseeki64(m_file, 0, SEEK_END) != 0) {
-        return 0;
-    }
-
-    const u64 size = _ftelli64(m_file);
-    if (_fseeki64(m_file, pos, SEEK_SET) != 0) {
-        return 0;
-    }
-#else
-    const u64 pos = ftello64(m_file);
-    if (fseeko64(m_file, 0, SEEK_END) != 0) {
-        return 0;
-    }
-
-    const u64 size = ftello64(m_file);
-    if (fseeko64(m_file, pos, SEEK_SET) != 0) {
-        return 0;
-    }
-#endif
-    return size;
-}
-
-} // namespace Common::FS

src/common/fs_file.h

@@ -1,86 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <bit>
-#include <cstdio>
-#include <span>
-#include <string>
-#include <vector>
-
-#include "common/types.h"
-
-namespace Common::FS {
-
-enum class OpenMode : u32 { Read = 0x1, Write = 0x2, ReadWrite = Read | Write };
-
-enum class SeekMode : u32 {
-    Set,
-    Cur,
-    End,
-};
-
-class File {
-public:
-    File();
-    explicit File(const std::string& path, OpenMode mode = OpenMode::Read);
-    ~File();
-
-    bool open(const std::string& path, OpenMode mode = OpenMode::Read);
-    bool close();
-    bool read(void* data, u64 size) const;
-    bool write(std::span<const u8> data);
-    bool seek(s64 offset, SeekMode mode);
-    u64 getFileSize();
-    u64 tell() const;
-
-    template <typename T>
-    bool read(T& data) const {
-        return read(&data, sizeof(T));
-    }
-
-    template <typename T>
-    bool read(std::vector<T>& data) const {
-        return read(data.data(), data.size() * sizeof(T));
-    }
-
-    bool isOpen() const {
-        return m_file != nullptr;
-    }
-
-    const char* getOpenMode(OpenMode mode) const {
-        switch (mode) {
-        case OpenMode::Read:
-            return "rb";
-        case OpenMode::Write:
-            return "wb";
-        case OpenMode::ReadWrite:
-            return "r+b";
-        default:
-            return "r";
-        }
-    }
-
-    int getSeekMode(SeekMode mode) const {
-        switch (mode) {
-        case SeekMode::Set:
-            return SEEK_SET;
-        case SeekMode::Cur:
-            return SEEK_CUR;
-        case SeekMode::End:
-            return SEEK_END;
-        default:
-            return SEEK_SET;
-        }
-    }
-
-    [[nodiscard]] std::FILE* fileDescr() const {
-        return m_file;
-    }
-
-private:
-    std::FILE* m_file{};
-};
-
-} // namespace Common::FS

src/common/io_file.cpp

@@ -1,141 +1,335 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/io_file.h"
+#include <vector>
 
-// #include "helpers.hpp"
+#include "common/io_file.h"
+#include "common/logging/log.h"
+#include "common/path_util.h"
+
+#ifdef _WIN32
+#include <io.h>
+#include <share.h>
+#else
+#include <unistd.h>
+#endif
 
 #ifdef _MSC_VER
-// 64 bit offsets for MSVC
+#define fileno _fileno
 #define fseeko _fseeki64
 #define ftello _ftelli64
-#define fileno _fileno
-
-#pragma warning(disable : 4996)
 #endif
 
-#ifndef _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_WARNINGS
-#endif
+namespace Common::FS {
+
+namespace fs = std::filesystem;
+
+namespace {
+
+#ifdef _WIN32
+
+[[nodiscard]] constexpr const wchar_t* AccessModeToWStr(FileAccessMode mode, FileType type) {
+    switch (type) {
+    case FileType::BinaryFile:
+        switch (mode) {
+        case FileAccessMode::Read:
+            return L"rb";
+        case FileAccessMode::Write:
+            return L"wb";
+        case FileAccessMode::Append:
+            return L"ab";
+        case FileAccessMode::ReadWrite:
+            return L"r+b";
+        case FileAccessMode::ReadAppend:
+            return L"a+b";
+        }
+        break;
+    case FileType::TextFile:
+        switch (mode) {
+        case FileAccessMode::Read:
+            return L"r";
+        case FileAccessMode::Write:
+            return L"w";
+        case FileAccessMode::Append:
+            return L"a";
+        case FileAccessMode::ReadWrite:
+            return L"r+";
+        case FileAccessMode::ReadAppend:
+            return L"a+";
+        }
+        break;
+    }
+
+    return L"";
+}
+
+[[nodiscard]] constexpr int ToWindowsFileShareFlag(FileShareFlag flag) {
+    switch (flag) {
+    case FileShareFlag::ShareNone:
+    default:
+        return _SH_DENYRW;
+    case FileShareFlag::ShareReadOnly:
+        return _SH_DENYWR;
+    case FileShareFlag::ShareWriteOnly:
+        return _SH_DENYRD;
+    case FileShareFlag::ShareReadWrite:
+        return _SH_DENYNO;
+    }
+}
 
-#ifdef WIN32
-#include <io.h> // For _chsize_s
 #else
-#include <unistd.h> // For ftruncate
+
+[[nodiscard]] constexpr const char* AccessModeToStr(FileAccessMode mode, FileType type) {
+    switch (type) {
+    case FileType::BinaryFile:
+        switch (mode) {
+        case FileAccessMode::Read:
+            return "rb";
+        case FileAccessMode::Write:
+            return "wb";
+        case FileAccessMode::Append:
+            return "ab";
+        case FileAccessMode::ReadWrite:
+            return "r+b";
+        case FileAccessMode::ReadAppend:
+            return "a+b";
+        }
+        break;
+    case FileType::TextFile:
+        switch (mode) {
+        case FileAccessMode::Read:
+            return "r";
+        case FileAccessMode::Write:
+            return "w";
+        case FileAccessMode::Append:
+            return "a";
+        case FileAccessMode::ReadWrite:
+            return "r+";
+        case FileAccessMode::ReadAppend:
+            return "a+";
+        }
+        break;
+    }
+
+    return "";
+}
+
 #endif
 
-IOFile::IOFile(const std::filesystem::path& path, const char* permissions) : handle(nullptr) {
-    open(path, permissions);
-}
-
-bool IOFile::open(const std::filesystem::path& path, const char* permissions) {
-    const auto str =
-        path.string(); // For some reason converting paths directly with c_str() doesn't work
-    return open(str.c_str(), permissions);
-}
-
-bool IOFile::open(const char* filename, const char* permissions) {
-    // If this IOFile is already bound to an open file descriptor, release the file descriptor
-    // To avoid leaking it and/or erroneously locking the file
-    if (isOpen()) {
-        close();
-    }
-
-    handle = std::fopen(filename, permissions);
-    return isOpen();
-}
-
-void IOFile::close() {
-    if (isOpen()) {
-        fclose(handle);
-        handle = nullptr;
+[[nodiscard]] constexpr int ToSeekOrigin(SeekOrigin origin) {
+    switch (origin) {
+    case SeekOrigin::SetOrigin:
+    default:
+        return SEEK_SET;
+    case SeekOrigin::CurrentPosition:
+        return SEEK_CUR;
+    case SeekOrigin::End:
+        return SEEK_END;
     }
 }
 
-std::pair<bool, std::size_t> IOFile::read(void* data, std::size_t length, std::size_t dataSize) {
-    if (!isOpen()) {
-        return {false, std::numeric_limits<std::size_t>::max()};
-    }
+} // Anonymous namespace
 
-    if (length == 0)
-        return {true, 0};
-    return {true, std::fread(data, dataSize, length, handle)};
+IOFile::IOFile() = default;
+
+IOFile::IOFile(const std::string& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
+    Open(path, mode, type, flag);
 }
 
-std::pair<bool, std::size_t> IOFile::write(const void* data, std::size_t length,
-                                           std::size_t dataSize) {
-    if (!isOpen()) {
-        return {false, std::numeric_limits<std::size_t>::max()};
-    }
+IOFile::IOFile(std::string_view path, FileAccessMode mode, FileType type, FileShareFlag flag) {
+    Open(path, mode, type, flag);
+}
 
-    if (length == 0) {
-        return {true, 0};
+IOFile::IOFile(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
+    Open(path, mode, type, flag);
+}
+
+IOFile::~IOFile() {
+    Close();
+}
+
+IOFile::IOFile(IOFile&& other) noexcept {
+    std::swap(file_path, other.file_path);
+    std::swap(file_access_mode, other.file_access_mode);
+    std::swap(file_type, other.file_type);
+    std::swap(file, other.file);
+}
+
+IOFile& IOFile::operator=(IOFile&& other) noexcept {
+    std::swap(file_path, other.file_path);
+    std::swap(file_access_mode, other.file_access_mode);
+    std::swap(file_type, other.file_type);
+    std::swap(file, other.file);
+    return *this;
+}
+
+void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
+    Close();
+
+    file_path = path;
+    file_access_mode = mode;
+    file_type = type;
+
+    errno = 0;
+
+#ifdef _WIN32
+    if (flag != FileShareFlag::ShareNone) {
+        file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
     } else {
-        return {true, std::fwrite(data, dataSize, length, handle)};
+        _wfopen_s(&file, path.c_str(), AccessModeToWStr(mode, type));
     }
-}
-
-std::pair<bool, std::size_t> IOFile::readBytes(void* data, std::size_t count) {
-    return read(data, count, sizeof(std::uint8_t));
-}
-std::pair<bool, std::size_t> IOFile::writeBytes(const void* data, std::size_t count) {
-    return write(data, count, sizeof(std::uint8_t));
-}
-
-std::optional<std::uint64_t> IOFile::size() {
-    if (!isOpen())
-        return {};
-
-    std::uint64_t pos = ftello(handle);
-    if (fseeko(handle, 0, SEEK_END) != 0) {
-        return {};
-    }
-
-    std::uint64_t size = ftello(handle);
-    if ((size != pos) && (fseeko(handle, pos, SEEK_SET) != 0)) {
-        return {};
-    }
-
-    return size;
-}
-
-bool IOFile::seek(std::int64_t offset, int origin) {
-    if (!isOpen() || fseeko(handle, offset, origin) != 0)
-        return false;
-
-    return true;
-}
-
-bool IOFile::flush() {
-    if (!isOpen() || fflush(handle))
-        return false;
-
-    return true;
-}
-
-bool IOFile::rewind() {
-    return seek(0, SEEK_SET);
-}
-FILE* IOFile::getHandle() {
-    return handle;
-}
-
-void IOFile::setAppDataDir(const std::filesystem::path& dir) {
-    // if (dir == "")
-    //     Helpers::panic("Failed to set app data directory");
-    appData = dir;
-}
-
-bool IOFile::setSize(std::uint64_t size) {
-    if (!isOpen())
-        return false;
-    bool success;
-
-#ifdef WIN32
-    success = _chsize_s(_fileno(handle), size) == 0;
 #else
-    success = ftruncate(fileno(handle), size) == 0;
+    file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
 #endif
-    fflush(handle);
-    return success;
+
+    if (!IsOpen()) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+    }
 }
+
+void IOFile::Close() {
+    if (!IsOpen()) {
+        return;
+    }
+
+    errno = 0;
+
+    const auto close_result = std::fclose(file) == 0;
+
+    if (!close_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to close the file at path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+    }
+
+    file = nullptr;
+}
+
+std::string IOFile::ReadString(size_t length) const {
+    std::vector<char> string_buffer(length);
+
+    const auto chars_read = ReadSpan<char>(string_buffer);
+    const auto string_size = chars_read != length ? chars_read : length;
+
+    return std::string{string_buffer.data(), string_size};
+}
+
+bool IOFile::Flush() const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+#ifdef _WIN32
+    const auto flush_result = std::fflush(file) == 0;
+#else
+    const auto flush_result = std::fflush(file) == 0;
+#endif
+
+    if (!flush_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to flush the file at path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+    }
+
+    return flush_result;
+}
+
+bool IOFile::Commit() const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+#ifdef _WIN32
+    const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
+#else
+    const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
+#endif
+
+    if (!commit_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+    }
+
+    return commit_result;
+}
+
+bool IOFile::SetSize(u64 size) const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+#ifdef _WIN32
+    const auto set_size_result = _chsize_s(fileno(file), static_cast<s64>(size)) == 0;
+#else
+    const auto set_size_result = ftruncate(fileno(file), static_cast<s64>(size)) == 0;
+#endif
+
+    if (!set_size_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}",
+                  PathToUTF8String(file_path), size, ec.message());
+    }
+
+    return set_size_result;
+}
+
+u64 IOFile::GetSize() const {
+    if (!IsOpen()) {
+        return 0;
+    }
+
+    // Flush any unwritten buffered data into the file prior to retrieving the file size.
+    std::fflush(file);
+
+    std::error_code ec;
+
+    const auto file_size = fs::file_size(file_path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+        return 0;
+    }
+
+    return file_size;
+}
+
+bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+    const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
+
+    if (!seek_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to seek the file at path={}, offset={}, origin={}, ec_message={}",
+                  PathToUTF8String(file_path), offset, static_cast<u32>(origin), ec.message());
+    }
+
+    return seek_result;
+}
+
+s64 IOFile::Tell() const {
+    if (!IsOpen()) {
+        return 0;
+    }
+
+    errno = 0;
+
+    return ftello(file);
+}
+
+} // namespace Common::FS

src/common/io_file.h

@@ -1,45 +1,207 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
-#include <cstdint>
+
+#include <cstdio>
 #include <filesystem>
-#include <optional>
+#include <span>
+#include <type_traits>
 
-class IOFile {
-    FILE* handle = nullptr;
-    static inline std::filesystem::path appData =
-        ""; // Directory for holding app data. AppData on Windows
+#include "common/concepts.h"
+#include "common/types.h"
 
-public:
-    IOFile() : handle(nullptr) {}
-    IOFile(FILE* handle) : handle(handle) {}
-    IOFile(const std::filesystem::path& path, const char* permissions = "rb");
+namespace Common::FS {
 
-    bool isOpen() {
-        return handle != nullptr;
-    }
-    bool open(const std::filesystem::path& path, const char* permissions = "rb");
-    bool open(const char* filename, const char* permissions = "rb");
-    void close();
-
-    std::pair<bool, std::size_t> read(void* data, std::size_t length, std::size_t dataSize);
-    std::pair<bool, std::size_t> readBytes(void* data, std::size_t count);
-
-    std::pair<bool, std::size_t> write(const void* data, std::size_t length, std::size_t dataSize);
-    std::pair<bool, std::size_t> writeBytes(const void* data, std::size_t count);
-
-    std::optional<std::uint64_t> size();
-
-    bool seek(std::int64_t offset, int origin = SEEK_SET);
-    bool rewind();
-    bool flush();
-    FILE* getHandle();
-    static void setAppDataDir(const std::filesystem::path& dir);
-    static std::filesystem::path getAppData() {
-        return appData;
-    }
-
-    // Sets the size of the file to "size" and returns whether it succeeded or not
-    bool setSize(std::uint64_t size);
+enum class FileAccessMode {
+    /**
+     * If the file at path exists, it opens the file for reading.
+     * If the file at path does not exist, it fails to open the file.
+     */
+    Read = 1 << 0,
+    /**
+     * If the file at path exists, the existing contents of the file are erased.
+     * The empty file is then opened for writing.
+     * If the file at path does not exist, it creates and opens a new empty file for writing.
+     */
+    Write = 1 << 1,
+    /**
+     * If the file at path exists, it opens the file for reading and writing.
+     * If the file at path does not exist, it fails to open the file.
+     */
+    ReadWrite = Read | Write,
+    /**
+     * If the file at path exists, it opens the file for appending.
+     * If the file at path does not exist, it creates and opens a new empty file for appending.
+     */
+    Append = 1 << 2,
+    /**
+     * If the file at path exists, it opens the file for both reading and appending.
+     * If the file at path does not exist, it creates and opens a new empty file for both
+     * reading and appending.
+     */
+    ReadAppend = Read | Append,
 };
+
+enum class FileType {
+    BinaryFile,
+    TextFile,
+};
+
+enum class FileShareFlag {
+    ShareNone,      // Provides exclusive access to the file.
+    ShareReadOnly,  // Provides read only shared access to the file.
+    ShareWriteOnly, // Provides write only shared access to the file.
+    ShareReadWrite, // Provides read and write shared access to the file.
+};
+
+enum class SeekOrigin : u32 {
+    SetOrigin,       // Seeks from the start of the file.
+    CurrentPosition, // Seeks from the current file pointer position.
+    End,             // Seeks from the end of the file.
+};
+
+class IOFile final {
+public:
+    IOFile();
+
+    explicit IOFile(const std::string& path, FileAccessMode mode,
+                    FileType type = FileType::BinaryFile,
+                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
+
+    explicit IOFile(std::string_view path, FileAccessMode mode,
+                    FileType type = FileType::BinaryFile,
+                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
+    explicit IOFile(const std::filesystem::path& path, FileAccessMode mode,
+                    FileType type = FileType::BinaryFile,
+                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
+
+    ~IOFile();
+
+    IOFile(const IOFile&) = delete;
+    IOFile& operator=(const IOFile&) = delete;
+
+    IOFile(IOFile&& other) noexcept;
+    IOFile& operator=(IOFile&& other) noexcept;
+
+    std::filesystem::path GetPath() const {
+        return file_path;
+    }
+
+    FileAccessMode GetAccessMode() const {
+        return file_access_mode;
+    }
+
+    FileType GetType() const {
+        return file_type;
+    }
+
+    bool IsOpen() const {
+        return file != nullptr;
+    }
+
+    void Open(const std::filesystem::path& path, FileAccessMode mode,
+              FileType type = FileType::BinaryFile,
+              FileShareFlag flag = FileShareFlag::ShareReadOnly);
+    void Close();
+
+    bool Flush() const;
+    bool Commit() const;
+
+    bool SetSize(u64 size) const;
+    u64 GetSize() const;
+
+    bool Seek(s64 offset, SeekOrigin origin = SeekOrigin::SetOrigin) const;
+    s64 Tell() const;
+
+    template <typename T>
+    size_t Read(T& data) const {
+        if constexpr (IsContiguousContainer<T>) {
+            using ContiguousType = typename T::value_type;
+            static_assert(std::is_trivially_copyable_v<ContiguousType>,
+                          "Data type must be trivially copyable.");
+            return ReadSpan<ContiguousType>(data);
+        } else {
+            return ReadObject(data) ? 1 : 0;
+        }
+    }
+
+    template <typename T>
+    size_t Write(const T& data) const {
+        if constexpr (IsContiguousContainer<T>) {
+            using ContiguousType = typename T::value_type;
+            static_assert(std::is_trivially_copyable_v<ContiguousType>,
+                          "Data type must be trivially copyable.");
+            return WriteSpan<ContiguousType>(data);
+        } else {
+            static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+            return WriteObject(data) ? 1 : 0;
+        }
+    }
+
+    template <typename T>
+    size_t ReadSpan(std::span<T> data) const {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+
+        if (!IsOpen()) {
+            return 0;
+        }
+
+        return ReadRaw<T>(data.data(), data.size());
+    }
+
+    template <typename T>
+    size_t ReadRaw(void* data, size_t size) const {
+        return std::fread(data, sizeof(T), size, file);
+    }
+
+    template <typename T>
+    size_t WriteSpan(std::span<const T> data) const {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+
+        if (!IsOpen()) {
+            return 0;
+        }
+
+        return std::fwrite(data.data(), sizeof(T), data.size(), file);
+    }
+
+    template <typename T>
+    bool ReadObject(T& object) const {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
+
+        if (!IsOpen()) {
+            return false;
+        }
+
+        return std::fread(&object, sizeof(T), 1, file) == 1;
+    }
+
+    template <typename T>
+    bool WriteObject(const T& object) const {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
+
+        if (!IsOpen()) {
+            return false;
+        }
+
+        return std::fwrite(&object, sizeof(T), 1, file) == 1;
+    }
+
+    std::string ReadString(size_t length) const;
+
+    size_t WriteString(std::span<const char> string) const {
+        return WriteSpan(string);
+    }
+
+private:
+    std::filesystem::path file_path;
+    FileAccessMode file_access_mode{};
+    FileType file_type{};
+
+    std::FILE* file = nullptr;
+};
+
+} // namespace Common::FS

src/common/log.cpp

@@ -1,159 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <vector>
-#include <Util/config.h>
-#include <spdlog/common.h>
-#include <spdlog/pattern_formatter.h>
-#include <spdlog/sinks/basic_file_sink.h>
-#include <spdlog/sinks/stdout_color_sinks.h>
-#include <spdlog/spdlog.h>
-#include "common/log.h"
-#ifdef _WIN64
-#include <windows.h>
-#endif
-
-namespace Common::Log {
-
-std::vector<spdlog::sink_ptr> sinks;
-constexpr bool log_file_exceptions = true;
-
-void Flush() {
-    spdlog::details::registry::instance().flush_all();
-}
-
-thread_local uint8_t TLS[1024];
-
-uint64_t tls_access(int64_t tls_offset) {
-    if (tls_offset == 0) {
-        return (uint64_t)TLS;
-    }
-}
-
-#ifdef _WIN64
-static LONG WINAPI ExceptionHandler(PEXCEPTION_POINTERS pExp) noexcept {
-    auto orig_rip = pExp->ContextRecord->Rip;
-    while (*(uint8_t*)pExp->ContextRecord->Rip == 0x66)
-        pExp->ContextRecord->Rip++;
-
-    if (*(uint8_t*)pExp->ContextRecord->Rip == 0xcd) {
-        int reg = *(uint8_t*)(pExp->ContextRecord->Rip + 1) - 0x80;
-        int sizes = *(uint8_t*)(pExp->ContextRecord->Rip + 2);
-        int pattern_size = sizes & 0xF;
-        int imm_size = sizes >> 4;
-
-        int64_t tls_offset;
-        if (imm_size == 4)
-            tls_offset = *(int32_t*)(pExp->ContextRecord->Rip + pattern_size);
-        else
-            tls_offset = *(int64_t*)(pExp->ContextRecord->Rip + pattern_size);
-
-        (&pExp->ContextRecord->Rax)[reg] = tls_access(tls_offset); /* TLS_ACCESS */
-        pExp->ContextRecord->Rip += pattern_size + imm_size;
-
-        return EXCEPTION_CONTINUE_EXECUTION;
-    }
-
-    pExp->ContextRecord->Rip = orig_rip;
-    const u32 ec = pExp->ExceptionRecord->ExceptionCode;
-    switch (ec) {
-    case EXCEPTION_ACCESS_VIOLATION: {
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_ACCESS_VIOLATION ({:#x}). ", ec);
-        const auto info = pExp->ExceptionRecord->ExceptionInformation;
-        switch (info[0]) {
-        case 0:
-            LOG_CRITICAL_IF(log_file_exceptions, "Read violation at address {:#x}.", info[1]);
-            break;
-        case 1:
-            LOG_CRITICAL_IF(log_file_exceptions, "Write violation at address {:#x}.", info[1]);
-            break;
-        case 8:
-            LOG_CRITICAL_IF(log_file_exceptions, "DEP violation at address {:#x}.", info[1]);
-            break;
-        default:
-            break;
-        }
-        break;
-    }
-    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_ARRAY_BOUNDS_EXCEEDED ({:#x}). ",
-                        ec);
-        break;
-    case EXCEPTION_DATATYPE_MISALIGNMENT:
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_DATATYPE_MISALIGNMENT ({:#x}). ",
-                        ec);
-        break;
-    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_FLT_DIVIDE_BY_ZERO ({:#x}). ",
-                        ec);
-        break;
-    case EXCEPTION_ILLEGAL_INSTRUCTION:
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_ILLEGAL_INSTRUCTION ({:#x}). ",
-                        ec);
-        break;
-    case EXCEPTION_IN_PAGE_ERROR:
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_IN_PAGE_ERROR ({:#x}). ", ec);
-        break;
-    case EXCEPTION_INT_DIVIDE_BY_ZERO:
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_INT_DIVIDE_BY_ZERO ({:#x}). ",
-                        ec);
-        break;
-    case EXCEPTION_PRIV_INSTRUCTION:
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_PRIV_INSTRUCTION ({:#x}). ", ec);
-        break;
-    case EXCEPTION_STACK_OVERFLOW:
-        LOG_CRITICAL_IF(log_file_exceptions, "Exception EXCEPTION_STACK_OVERFLOW ({:#x}). ", ec);
-        break;
-    default:
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-    Flush();
-    return EXCEPTION_CONTINUE_SEARCH;
-}
-#endif
-
-int Init(bool use_stdout) {
-    sinks.clear();
-    if (use_stdout) {
-        sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
-    }
-#ifdef _WIN64
-    sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>(L"shadps4.txt", true));
-#else
-    sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>("shadps4.txt", true));
-#endif
-    spdlog::set_default_logger(
-        std::make_shared<spdlog::logger>("shadps4 logger", begin(sinks), end(sinks)));
-    auto f = std::make_unique<spdlog::pattern_formatter>(
-        "%^|%L|: %v%$", spdlog::pattern_time_type::local, std::string("")); // disable eol
-    spdlog::set_formatter(std::move(f));
-    spdlog::set_level(static_cast<spdlog::level::level_enum>(Config::getLogLevel()));
-
-#ifdef _WIN64
-    if (!AddVectoredExceptionHandler(0, ExceptionHandler)) {
-        LOG_CRITICAL_IF(log_file_exceptions, "Failed to register an exception handler");
-    }
-#endif
-
-    static std::terminate_handler old_terminate = nullptr;
-    old_terminate = std::set_terminate([]() {
-        try {
-            std::rethrow_exception(std::current_exception());
-        } catch (const std::exception& e) {
-            LOG_CRITICAL_IF(log_file_exceptions, "Unhandled C++ exception. {}", e.what());
-        } catch (...) {
-            LOG_CRITICAL_IF(log_file_exceptions, "Unhandled C++ exception. UNKNOWN");
-        }
-        Flush();
-        if (old_terminate)
-            old_terminate();
-    });
-
-    return 0;
-}
-
-void SetLevel(spdlog::level::level_enum log_level) {
-    spdlog::set_level(log_level);
-}
-
-} // namespace Common::Log

src/common/log.h

@@ -1,42 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_TRACE
-
-#include <spdlog/spdlog.h>
-
-namespace Common::Log {
-
-#define LOG_TRACE SPDLOG_TRACE
-#define LOG_DEBUG SPDLOG_DEBUG
-#define LOG_INFO SPDLOG_INFO
-#define LOG_WARN SPDLOG_WARN
-#define LOG_ERROR SPDLOG_ERROR
-#define LOG_CRITICAL SPDLOG_CRITICAL
-
-#define LOG_TRACE_IF(flag, ...)                                                                    \
-    if (flag)                                                                                      \
-    LOG_TRACE(__VA_ARGS__)
-#define LOG_DEBUG_IF(flag, ...)                                                                    \
-    if (flag)                                                                                      \
-    LOG_DEBUG(__VA_ARGS__)
-#define LOG_INFO_IF(flag, ...)                                                                     \
-    if (flag)                                                                                      \
-    LOG_INFO(__VA_ARGS__)
-#define LOG_WARN_IF(flag, ...)                                                                     \
-    if (flag)                                                                                      \
-    LOG_WARN(__VA_ARGS__)
-#define LOG_ERROR_IF(flag, ...)                                                                    \
-    if (flag)                                                                                      \
-    LOG_ERROR(__VA_ARGS__)
-#define LOG_CRITICAL_IF(flag, ...)                                                                 \
-    if (flag)                                                                                      \
-    LOG_CRITICAL(__VA_ARGS__)
-
-int Init(bool use_stdout);
-
-void SetLevel(spdlog::level::level_enum log_level);
-
-} // namespace Common::Log

src/common/logging/backend.cpp

@@ -0,0 +1,277 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+#include <filesystem>
+#include <thread>
+
+#include <fmt/format.h>
+#include "Util/config.h"
+
+#ifdef _WIN32
+#include <windows.h> // For OutputDebugStringW
+#endif
+
+#include "common/bounded_threadsafe_queue.h"
+#include "common/io_file.h"
+#include "common/logging/backend.h"
+#include "common/logging/log.h"
+#include "common/logging/log_entry.h"
+#include "common/logging/text_formatter.h"
+#include "common/path_util.h"
+#include "common/string_util.h"
+#include "common/thread.h"
+
+namespace Common::Log {
+
+using namespace Common::FS;
+
+namespace {
+
+/**
+ * Backend that writes to stderr and with color
+ */
+class ColorConsoleBackend {
+public:
+    explicit ColorConsoleBackend() = default;
+
+    ~ColorConsoleBackend() = default;
+
+    void Write(const Entry& entry) {
+        if (enabled.load(std::memory_order_relaxed)) {
+            PrintColoredMessage(entry);
+        }
+    }
+
+    void Flush() {
+        // stderr shouldn't be buffered
+    }
+
+    void SetEnabled(bool enabled_) {
+        enabled = enabled_;
+    }
+
+private:
+    std::atomic_bool enabled{true};
+};
+
+/**
+ * Backend that writes to a file passed into the constructor
+ */
+class FileBackend {
+public:
+    explicit FileBackend(const std::filesystem::path& filename)
+        : file{filename, FS::FileAccessMode::Write, FS::FileType::TextFile} {}
+
+    ~FileBackend() = default;
+
+    void Write(const Entry& entry) {
+        if (!enabled) {
+            return;
+        }
+
+        bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
+
+        // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
+        const auto write_limit = 100_MB;
+        const bool write_limit_exceeded = bytes_written > write_limit;
+        if (entry.log_level >= Level::Error || write_limit_exceeded) {
+            if (write_limit_exceeded) {
+                // Stop writing after the write limit is exceeded.
+                // Don't close the file so we can print a stacktrace if necessary
+                enabled = false;
+            }
+            file.Flush();
+        }
+    }
+
+    void Flush() {
+        file.Flush();
+    }
+
+private:
+    Common::FS::IOFile file;
+    bool enabled = true;
+    std::size_t bytes_written = 0;
+};
+
+/**
+ * Backend that writes to Visual Studio's output window
+ */
+class DebuggerBackend {
+public:
+    explicit DebuggerBackend() = default;
+
+    ~DebuggerBackend() = default;
+
+    void Write(const Entry& entry) {
+#ifdef _WIN32
+        ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
+#endif
+    }
+
+    void Flush() {}
+
+    void EnableForStacktrace() {}
+};
+
+bool initialization_in_progress_suppress_logging = true;
+
+/**
+ * Static state as a singleton.
+ */
+class Impl {
+public:
+    static Impl& Instance() {
+        if (!instance) {
+            throw std::runtime_error("Using Logging instance before its initialization");
+        }
+        return *instance;
+    }
+
+    static void Initialize(std::string_view log_file) {
+        if (instance) {
+            LOG_WARNING(Log, "Reinitializing logging backend");
+            return;
+        }
+        const auto& log_dir = GetUserPath(PathType::LogDir);
+        std::filesystem::create_directory(log_dir);
+        Filter filter;
+        filter.ParseFilterString(Config::getLogFilter());
+        instance = std::unique_ptr<Impl, decltype(&Deleter)>(new Impl(log_dir / LOG_FILE, filter),
+                                                             Deleter);
+        initialization_in_progress_suppress_logging = false;
+    }
+
+    static void Start() {
+        instance->StartBackendThread();
+    }
+
+    static void Stop() {
+        instance->StopBackendThread();
+    }
+
+    Impl(const Impl&) = delete;
+    Impl& operator=(const Impl&) = delete;
+
+    Impl(Impl&&) = delete;
+    Impl& operator=(Impl&&) = delete;
+
+    void SetGlobalFilter(const Filter& f) {
+        filter = f;
+    }
+
+    void SetColorConsoleBackendEnabled(bool enabled) {
+        color_console_backend.SetEnabled(enabled);
+    }
+
+    void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+                   const char* function, std::string message) {
+        if (!filter.CheckMessage(log_class, log_level)) {
+            return;
+        }
+
+        using std::chrono::duration_cast;
+        using std::chrono::microseconds;
+        using std::chrono::steady_clock;
+
+        message_queue.EmplaceWait(Entry{
+            .timestamp = duration_cast<microseconds>(steady_clock::now() - time_origin),
+            .log_class = log_class,
+            .log_level = log_level,
+            .filename = filename,
+            .line_num = line_num,
+            .function = function,
+            .message = std::move(message),
+        });
+    }
+
+private:
+    Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
+        : filter{filter_}, file_backend{file_backend_filename} {}
+
+    ~Impl() = default;
+
+    void StartBackendThread() {
+        backend_thread = std::jthread([this](std::stop_token stop_token) {
+            Common::SetCurrentThreadName("shadPS4:Log");
+            Entry entry;
+            const auto write_logs = [this, &entry]() {
+                ForEachBackend([&entry](auto& backend) { backend.Write(entry); });
+            };
+            while (!stop_token.stop_requested()) {
+                message_queue.PopWait(entry, stop_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() ? std::numeric_limits<s32>::max() : 100;
+            while (max_logs_to_write-- && message_queue.TryPop(entry)) {
+                write_logs();
+            }
+        });
+    }
+
+    void StopBackendThread() {
+        backend_thread.request_stop();
+        if (backend_thread.joinable()) {
+            backend_thread.join();
+        }
+
+        ForEachBackend([](auto& backend) { backend.Flush(); });
+    }
+
+    void ForEachBackend(auto lambda) {
+        lambda(debugger_backend);
+        lambda(color_console_backend);
+        lambda(file_backend);
+    }
+
+    static void Deleter(Impl* ptr) {
+        delete ptr;
+    }
+
+    static inline std::unique_ptr<Impl, decltype(&Deleter)> instance{nullptr, Deleter};
+
+    Filter filter;
+    DebuggerBackend debugger_backend{};
+    ColorConsoleBackend color_console_backend{};
+    FileBackend file_backend;
+
+    MPSCQueue<Entry> message_queue{};
+    std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
+    std::jthread backend_thread;
+};
+} // namespace
+
+void Initialize(std::string_view log_file) {
+    Impl::Initialize(log_file.empty() ? LOG_FILE : log_file);
+}
+
+void Start() {
+    Impl::Start();
+}
+
+void Stop() {
+    Impl::Stop();
+}
+
+void SetGlobalFilter(const Filter& filter) {
+    Impl::Instance().SetGlobalFilter(filter);
+}
+
+void SetColorConsoleBackendEnabled(bool enabled) {
+    Impl::Instance().SetColorConsoleBackendEnabled(enabled);
+}
+
+void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
+                       unsigned int line_num, const char* function, const char* format,
+                       const fmt::format_args& args) {
+    if (!initialization_in_progress_suppress_logging) [[likely]] {
+        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,
+                                   fmt::vformat(format, args));
+    }
+}
+} // namespace Common::Log

src/common/logging/backend.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string_view>
+#include "common/logging/filter.h"
+
+namespace Common::Log {
+
+class Filter;
+
+/// Initializes the logging system. This should be the first thing called in main.
+void Initialize(std::string_view log_file = "");
+
+/// Starts the logging threads.
+void Start();
+
+/// Explictily stops the logger thread and flushes the buffers
+void Stop();
+
+/// The global filter will prevent any messages from even being processed if they are filtered.
+void SetGlobalFilter(const Filter& filter);
+
+void SetColorConsoleBackendEnabled(bool enabled);
+
+} // namespace Common::Log

src/common/logging/filter.cpp

@@ -0,0 +1,173 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+
+#include "common/assert.h"
+#include "common/logging/filter.h"
+
+namespace Common::Log {
+namespace {
+template <typename It>
+Level GetLevelByName(const It begin, const It end) {
+    for (u8 i = 0; i < static_cast<u8>(Level::Count); ++i) {
+        const char* level_name = GetLevelName(static_cast<Level>(i));
+        if (std::string_view(begin, end).compare(level_name) == 0) {
+            return static_cast<Level>(i);
+        }
+    }
+    return Level::Count;
+}
+
+template <typename It>
+Class GetClassByName(const It begin, const It end) {
+    for (u8 i = 0; i < static_cast<u8>(Class::Count); ++i) {
+        const char* level_name = GetLogClassName(static_cast<Class>(i));
+        if (std::string_view(begin, end).compare(level_name) == 0) {
+            return static_cast<Class>(i);
+        }
+    }
+    return Class::Count;
+}
+
+template <typename Iterator>
+bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
+    auto level_separator = std::find(begin, end, ':');
+    if (level_separator == end) {
+        LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}",
+                  std::string_view(begin, end));
+        return false;
+    }
+
+    const Level level = GetLevelByName(level_separator + 1, end);
+    if (level == Level::Count) {
+        LOG_ERROR(Log, "Unknown log level in filter: {}", std::string_view(begin, end));
+        return false;
+    }
+
+    if (std::string_view(begin, level_separator).compare("*") == 0) {
+        instance.ResetAll(level);
+        return true;
+    }
+
+    const Class log_class = GetClassByName(begin, level_separator);
+    if (log_class == Class::Count) {
+        LOG_ERROR(Log, "Unknown log class in filter: {}", std::string(begin, end));
+        return false;
+    }
+
+    instance.SetClassLevel(log_class, level);
+    return true;
+}
+} // Anonymous namespace
+
+/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
+#define ALL_LOG_CLASSES()                                                                          \
+    CLS(Log)                                                                                       \
+    CLS(Common)                                                                                    \
+    SUB(Common, Filesystem)                                                                        \
+    SUB(Common, Memory)                                                                            \
+    CLS(Core)                                                                                      \
+    SUB(Core, Linker)                                                                              \
+    CLS(Config)                                                                                    \
+    CLS(Debug)                                                                                     \
+    CLS(Kernel)                                                                                    \
+    SUB(Kernel, Pthread)                                                                           \
+    SUB(Kernel, Vmm)                                                                               \
+    SUB(Kernel, Fs)                                                                                \
+    SUB(Kernel, Event)                                                                             \
+    SUB(Kernel, Sce)                                                                               \
+    CLS(Lib)                                                                                       \
+    SUB(Lib, LibC)                                                                                 \
+    SUB(Lib, Kernel)                                                                               \
+    SUB(Lib, Pad)                                                                                  \
+    SUB(Lib, GnmDriver)                                                                            \
+    SUB(Lib, SystemService)                                                                        \
+    SUB(Lib, UserService)                                                                          \
+    SUB(Lib, VideoOut)                                                                             \
+    CLS(Frontend)                                                                                  \
+    CLS(Render)                                                                                    \
+    SUB(Render, Vulkan)                                                                            \
+    CLS(Input)                                                                                     \
+    CLS(Loader)
+
+// GetClassName is a macro defined by Windows.h, grrr...
+const char* GetLogClassName(Class log_class) {
+    switch (log_class) {
+#define CLS(x)                                                                                     \
+    case Class::x:                                                                                 \
+        return #x;
+#define SUB(x, y)                                                                                  \
+    case Class::x##_##y:                                                                           \
+        return #x "." #y;
+        ALL_LOG_CLASSES()
+#undef CLS
+#undef SUB
+    case Class::Count:
+    default:
+        break;
+    }
+    UNREACHABLE();
+}
+
+const char* GetLevelName(Level log_level) {
+#define LVL(x)                                                                                     \
+    case Level::x:                                                                                 \
+        return #x
+    switch (log_level) {
+        LVL(Trace);
+        LVL(Debug);
+        LVL(Info);
+        LVL(Warning);
+        LVL(Error);
+        LVL(Critical);
+    case Level::Count:
+    default:
+        break;
+    }
+#undef LVL
+    UNREACHABLE();
+}
+
+Filter::Filter(Level default_level) {
+    ResetAll(default_level);
+}
+
+void Filter::ResetAll(Level level) {
+    class_levels.fill(level);
+}
+
+void Filter::SetClassLevel(Class log_class, Level level) {
+    class_levels[static_cast<std::size_t>(log_class)] = level;
+}
+
+void Filter::ParseFilterString(std::string_view filter_view) {
+    auto clause_begin = filter_view.cbegin();
+    while (clause_begin != filter_view.cend()) {
+        auto clause_end = std::find(clause_begin, filter_view.cend(), ' ');
+
+        // If clause isn't empty
+        if (clause_end != clause_begin) {
+            ParseFilterRule(*this, clause_begin, clause_end);
+        }
+
+        if (clause_end != filter_view.cend()) {
+            // Skip over the whitespace
+            ++clause_end;
+        }
+        clause_begin = clause_end;
+    }
+}
+
+bool Filter::CheckMessage(Class log_class, Level level) const {
+    return static_cast<u8>(level) >=
+           static_cast<u8>(class_levels[static_cast<std::size_t>(log_class)]);
+}
+
+bool Filter::IsDebug() const {
+    return std::any_of(class_levels.begin(), class_levels.end(), [](const Level& l) {
+        return static_cast<u8>(l) <= static_cast<u8>(Level::Debug);
+    });
+}
+
+} // namespace Common::Log

src/common/logging/filter.h

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <string_view>
+#include "common/logging/types.h"
+
+namespace Common::Log {
+
+/**
+ * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
+ * instead of underscores as in the enumeration.
+ */
+const char* GetLogClassName(Class log_class);
+
+/**
+ * Returns the name of the passed log level as a C-string.
+ */
+const char* GetLevelName(Level log_level);
+
+/**
+ * Implements a log message filter which allows different log classes to have different minimum
+ * severity levels. The filter can be changed at runtime and can be parsed from a string to allow
+ * editing via the interface or loading from a configuration file.
+ */
+class Filter {
+public:
+    /// Initializes the filter with all classes having `default_level` as the minimum level.
+    explicit Filter(Level default_level = Level::Info);
+
+    /// Resets the filter so that all classes have `level` as the minimum displayed level.
+    void ResetAll(Level level);
+
+    /// Sets the minimum level of `log_class` (and not of its subclasses) to `level`.
+    void SetClassLevel(Class log_class, Level level);
+
+    /**
+     * Parses a filter string and applies it to this filter.
+     *
+     * A filter string consists of a space-separated list of filter rules, each of the format
+     * `<class>:<level>`. `<class>` is a log class name, with subclasses separated using periods.
+     * `*` is allowed as a class name and will reset all filters to the specified level. `<level>`
+     * a severity level name which will be set as the minimum logging level of the matched classes.
+     * Rules are applied left to right, with each rule overriding previous ones in the sequence.
+     *
+     * A few examples of filter rules:
+     *  - `*:Info` -- Resets the level of all classes to Info.
+     *  - `Service:Info` -- Sets the level of Service to Info.
+     *  - `Service.FS:Trace` -- Sets the level of the Service.FS class to Trace.
+     */
+    void ParseFilterString(std::string_view filter_view);
+
+    /// Matches class/level combination against the filter, returning true if it passed.
+    bool CheckMessage(Class log_class, Level level) const;
+
+    /// Returns true if any logging classes are set to debug
+    bool IsDebug() const;
+
+private:
+    std::array<Level, static_cast<std::size_t>(Class::Count)> class_levels;
+};
+
+} // namespace Common::Log

src/common/logging/formatter.h

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <type_traits>
+#include <fmt/format.h>
+
+// Adapted from https://github.com/fmtlib/fmt/issues/2704
+// a generic formatter for enum classes
+#if FMT_VERSION >= 80100
+template <typename T>
+struct fmt::formatter<T, std::enable_if_t<std::is_enum_v<T>, char>>
+    : formatter<std::underlying_type_t<T>> {
+    template <typename FormatContext>
+    auto format(const T& value, FormatContext& ctx) -> decltype(ctx.out()) {
+        return fmt::formatter<std::underlying_type_t<T>>::format(
+            static_cast<std::underlying_type_t<T>>(value), ctx);
+    }
+};
+#endif

src/common/logging/log.h

@@ -0,0 +1,70 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <string_view>
+
+#include "common/logging/formatter.h"
+#include "common/logging/types.h"
+
+namespace Common::Log {
+
+constexpr const char* TrimSourcePath(std::string_view source) {
+    const auto rfind = [source](const std::string_view match) {
+        return source.rfind(match) == source.npos ? 0 : (source.rfind(match) + match.size());
+    };
+    auto idx = std::max({rfind("/"), rfind("\\")});
+    return source.data() + idx;
+}
+
+/// Logs a message to the global logger, using fmt
+void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
+                       unsigned int line_num, const char* function, const char* format,
+                       const fmt::format_args& args);
+
+template <typename... Args>
+void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+                   const char* function, const char* format, const Args&... args) {
+    FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
+                      fmt::make_format_args(args...));
+}
+
+} // namespace Common::Log
+
+// Define the fmt lib macros
+#define LOG_GENERIC(log_class, log_level, ...)                                                     \
+    Common::Log::FmtLogMessage(log_class, log_level, Common::Log::TrimSourcePath(__FILE__),        \
+                               __LINE__, __func__, __VA_ARGS__)
+
+#ifdef _DEBUG
+#define LOG_TRACE(log_class, ...)                                                                  \
+    Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Trace,           \
+                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __VA_ARGS__)
+#else
+#define LOG_TRACE(log_class, fmt, ...) (void(0))
+#endif
+
+#define LOG_DEBUG(log_class, ...)                                                                  \
+    Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Debug,           \
+                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __VA_ARGS__)
+#define LOG_INFO(log_class, ...)                                                                   \
+    Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Info,            \
+                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __VA_ARGS__)
+#define LOG_WARNING(log_class, ...)                                                                \
+    Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Warning,         \
+                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __VA_ARGS__)
+#define LOG_ERROR(log_class, ...)                                                                  \
+    Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Error,           \
+                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __VA_ARGS__)
+#define LOG_CRITICAL(log_class, ...)                                                               \
+    Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Critical,        \
+                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __VA_ARGS__)

src/common/logging/log_entry.h

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <chrono>
+
+#include "common/logging/types.h"
+
+namespace Common::Log {
+
+/**
+ * A log entry. Log entries are store in a structured format to permit more varied output
+ * formatting on different frontends, as well as facilitating filtering and aggregation.
+ */
+struct Entry {
+    std::chrono::microseconds timestamp;
+    Class log_class{};
+    Level log_level{};
+    const char* filename = nullptr;
+    u32 line_num = 0;
+    std::string function;
+    std::string message;
+};
+
+} // namespace Common::Log

src/common/logging/text_formatter.cpp

@@ -0,0 +1,109 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <array>
+#include <cstdio>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include "common/assert.h"
+#include "common/logging/filter.h"
+#include "common/logging/log.h"
+#include "common/logging/log_entry.h"
+#include "common/logging/text_formatter.h"
+
+namespace Common::Log {
+
+std::string FormatLogMessage(const Entry& entry) {
+    const u32 time_seconds = static_cast<u32>(entry.timestamp.count() / 1000000);
+    const u32 time_fractional = static_cast<u32>(entry.timestamp.count() % 1000000);
+
+    const char* class_name = GetLogClassName(entry.log_class);
+    const char* level_name = GetLevelName(entry.log_level);
+
+    return fmt::format("[{}] <{}> {}:{}:{}: {}", class_name, level_name, entry.filename,
+                       entry.function, entry.line_num, entry.message);
+}
+
+void PrintMessage(const Entry& entry) {
+    const auto str = FormatLogMessage(entry).append(1, '\n');
+    fputs(str.c_str(), stdout);
+}
+
+void PrintColoredMessage(const Entry& entry) {
+#ifdef _WIN32
+    HANDLE console_handle = GetStdHandle(STD_ERROR_HANDLE);
+    if (console_handle == INVALID_HANDLE_VALUE) {
+        return;
+    }
+
+    CONSOLE_SCREEN_BUFFER_INFO original_info{};
+    GetConsoleScreenBufferInfo(console_handle, &original_info);
+
+    WORD color = 0;
+    switch (entry.log_level) {
+    case Level::Trace: // Grey
+        color = FOREGROUND_INTENSITY;
+        break;
+    case Level::Debug: // Cyan
+        color = FOREGROUND_GREEN | FOREGROUND_BLUE;
+        break;
+    case Level::Info: // Bright gray
+        color = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+        break;
+    case Level::Warning: // Bright yellow
+        color = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
+        break;
+    case Level::Error: // Bright red
+        color = FOREGROUND_RED | FOREGROUND_INTENSITY;
+        break;
+    case Level::Critical: // Bright magenta
+        color = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
+        break;
+    case Level::Count:
+        UNREACHABLE();
+    }
+
+    SetConsoleTextAttribute(console_handle, color);
+#else
+#define ESC "\x1b"
+    const char* color = "";
+    switch (entry.log_level) {
+    case Level::Trace: // Grey
+        color = ESC "[1;30m";
+        break;
+    case Level::Debug: // Cyan
+        color = ESC "[0;36m";
+        break;
+    case Level::Info: // Bright gray
+        color = ESC "[0;37m";
+        break;
+    case Level::Warning: // Bright yellow
+        color = ESC "[1;33m";
+        break;
+    case Level::Error: // Bright red
+        color = ESC "[1;31m";
+        break;
+    case Level::Critical: // Bright magenta
+        color = ESC "[1;35m";
+        break;
+    case Level::Count:
+        UNREACHABLE();
+    }
+
+    fputs(color, stdout);
+#endif
+
+    PrintMessage(entry);
+
+#ifdef _WIN32
+    SetConsoleTextAttribute(console_handle, original_info.wAttributes);
+#else
+    fputs(ESC "[0m", stdout);
+#undef ESC
+#endif
+}
+
+} // namespace Common::Log

src/common/logging/text_formatter.h

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: Copyright 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+
+namespace Common::Log {
+
+struct Entry;
+
+/// Formats a log entry into the provided text buffer.
+std::string FormatLogMessage(const Entry& entry);
+
+/// Formats and prints a log entry to stderr.
+void PrintMessage(const Entry& entry);
+
+/// Prints the same message as `PrintMessage`, but colored according to the severity level.
+void PrintColoredMessage(const Entry& entry);
+
+} // namespace Common::Log

src/common/logging/types.h

@@ -0,0 +1,63 @@
+// SPDX-FileCopyrightText: Copyright 2023 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Common::Log {
+
+/// Specifies the severity or level of detail of the log message.
+enum class Level : u8 {
+    Trace, ///< Extremely detailed and repetitive debugging information that is likely to
+    ///< pollute logs.
+    Debug,   ///< Less detailed debugging information.
+    Info,    ///< Status information from important points during execution.
+    Warning, ///< Minor or potential problems found during execution of a task.
+    Error,   ///< Major problems found during execution of a task that prevent it from being
+    ///< completed.
+    Critical, ///< Major problems during execution that threaten the stability of the entire
+    ///< application.
+
+    Count, ///< Total number of logging levels
+};
+
+/**
+ * Specifies the sub-system that generated the log message.
+ *
+ * @note If you add a new entry here, also add a corresponding one to `ALL_LOG_CLASSES` in
+ * backend.cpp.
+ */
+enum class Class : u8 {
+    Log,               ///< Messages about the log system itself
+    Common,            ///< Library routines
+    Common_Filesystem, ///< Filesystem interface library
+    Common_Memory,     ///< Memory mapping and management functions
+    Core,              ///< LLE emulation core
+    Core_Linker,       ///< The module linker
+    Config,            ///< Emulator configuration (including commandline)
+    Debug,             ///< Debugging tools
+    Kernel,            ///< The HLE implementation of the PS4 kernel.
+    Kernel_Pthread,    ///< The pthread implementation of the kernel.
+    Kernel_Fs,         ///< The filesystem implementation of the kernel.
+    Kernel_Vmm,        ///< The virtual memory implementation of the kernel.
+    Kernel_Event,      ///< The event management implementation of the kernel.
+    Kernel_Sce,        ///< The sony specific interfaces provided by the kernel.
+    Lib,               ///< HLE implementation of system library. Each major library
+                       ///< should have its own subclass.
+    Lib_LibC,          ///< The LibC implementation.
+    Lib_Kernel,        ///< The LibKernel implementation.
+    Lib_Pad,           ///< The LibScePad implementation.
+    Lib_GnmDriver,     ///< The LibSceGnmDriver implementation.
+    Lib_SystemService, ///< The LibSceSystemService implementation.
+    Lib_UserService,   ///< The LibSceUserService implementation.
+    Lib_VideoOut,      ///< The LibSceVideoOut implementation.
+    Frontend,          ///< Emulator UI
+    Render,            ///< Video Core
+    Render_Vulkan,     ///< Vulkan backend
+    Loader,            ///< ROM loader
+    Input,             ///< Input emulation
+    Count              ///< Total number of logging classes
+};
+
+} // namespace Common::Log

src/common/path_util.cpp

@@ -0,0 +1,87 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+#include <sstream>
+#include <unordered_map>
+
+#include "common/logging/log.h"
+#include "common/path_util.h"
+
+#ifndef MAX_PATH
+#ifdef _WIN32
+// This is the maximum number of UTF-16 code units permissible in Windows file paths
+#define MAX_PATH 260
+#else
+// This is the maximum number of UTF-8 code units permissible in all other OSes' file paths
+#define MAX_PATH 1024
+#endif
+#endif
+
+namespace Common::FS {
+
+namespace fs = std::filesystem;
+
+static auto UserPaths = [] {
+    std::unordered_map<PathType, fs::path> paths;
+    const auto user_dir = std::filesystem::current_path() / PORTABLE_DIR;
+
+    const auto create_path = [&](PathType shad_path, const fs::path& new_path) {
+        std::filesystem::create_directory(new_path);
+        paths.insert_or_assign(shad_path, new_path);
+    };
+
+    create_path(PathType::UserDir, user_dir);
+    create_path(PathType::LogDir, user_dir / LOG_DIR);
+    create_path(PathType::ScreenshotsDir, user_dir / SCREENSHOTS_DIR);
+    create_path(PathType::ShaderDir, user_dir / SHADER_DIR);
+    create_path(PathType::App0, user_dir / APP0_DIR);
+
+    return paths;
+}();
+
+bool ValidatePath(const fs::path& path) {
+    if (path.empty()) {
+        LOG_ERROR(Common_Filesystem, "Input path is empty, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+#ifdef _WIN32
+    if (path.u16string().size() >= MAX_PATH) {
+        LOG_ERROR(Common_Filesystem, "Input path is too long, path={}", PathToUTF8String(path));
+        return false;
+    }
+#else
+    if (path.u8string().size() >= MAX_PATH) {
+        LOG_ERROR(Common_Filesystem, "Input path is too long, path={}", PathToUTF8String(path));
+        return false;
+    }
+#endif
+
+    return true;
+}
+
+std::string PathToUTF8String(const std::filesystem::path& path) {
+    const auto u8_string = path.u8string();
+    return std::string{u8_string.begin(), u8_string.end()};
+}
+
+const fs::path& GetUserPath(PathType shad_path) {
+    return UserPaths.at(shad_path);
+}
+
+std::string GetUserPathString(PathType shad_path) {
+    return PathToUTF8String(GetUserPath(shad_path));
+}
+
+void SetUserPath(PathType shad_path, const fs::path& new_path) {
+    if (!std::filesystem::is_directory(new_path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} is not a directory",
+                  PathToUTF8String(new_path));
+        return;
+    }
+
+    UserPaths.insert_or_assign(shad_path, new_path);
+}
+
+} // namespace Common::FS

src/common/path_util.h

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <filesystem>
+#include <vector>
+
+namespace Common::FS {
+
+enum class PathType {
+    UserDir,        // Where shadPS4 stores its data.
+    LogDir,         // Where log files are stored.
+    ScreenshotsDir, // Where screenshots are stored.
+    ShaderDir,      // Where shaders are stored.
+    App0,           // Where guest application data is stored.
+};
+
+constexpr auto PORTABLE_DIR = "user";
+
+// Sub-directories contained within a user data directory
+constexpr auto LOG_DIR = "log";
+constexpr auto SCREENSHOTS_DIR = "screenshots";
+constexpr auto SHADER_DIR = "shader";
+constexpr auto APP0_DIR = "app0";
+
+// Filenames
+constexpr auto LOG_FILE = "shad_log.txt";
+
+/**
+ * Validates a given path.
+ *
+ * A given path is valid if it meets these conditions:
+ * - The path is not empty
+ * - The path is not too long
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if the path is valid, false otherwise.
+ */
+[[nodiscard]] bool ValidatePath(const std::filesystem::path& path);
+
+/**
+ * Converts a filesystem path to a UTF-8 encoded std::string.
+ *
+ * @param path Filesystem path
+ *
+ * @returns UTF-8 encoded std::string.
+ */
+[[nodiscard]] std::string PathToUTF8String(const std::filesystem::path& path);
+
+/**
+ * Gets the filesystem path associated with the PathType enum.
+ *
+ * @param user_path PathType enum
+ *
+ * @returns The filesystem path associated with the PathType enum.
+ */
+[[nodiscard]] const std::filesystem::path& GetUserPath(PathType user_path);
+
+/**
+ * Gets the filesystem path associated with the PathType enum as a UTF-8 encoded std::string.
+ *
+ * @param user_path PathType enum
+ *
+ * @returns The filesystem path associated with the PathType enum as a UTF-8 encoded std::string.
+ */
+[[nodiscard]] std::string GetUserPathString(PathType user_path);
+
+/**
+ * Sets a new filesystem path associated with the PathType enum.
+ * If the filesystem object at new_path is not a directory, this function will not do anything.
+ *
+ * @param user_path PathType enum
+ * @param new_path New filesystem path
+ */
+void SetUserPath(PathType user_path, const std::filesystem::path& new_path);
+
+} // namespace Common::FS

src/common/string_util.cpp

@@ -6,6 +6,11 @@
 #include <sstream>
 #include <string>
 #include "common/string_util.h"
+#include "common/types.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
 
 namespace Common {
 
@@ -21,4 +26,46 @@ std::vector<std::string> SplitString(const std::string& str, char delimiter) {
     return output;
 }
 
+#ifdef _WIN32
+static std::wstring CPToUTF16(u32 code_page, std::string_view input) {
+    const auto size =
+        MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
+
+    if (size == 0) {
+        return {};
+    }
+
+    std::wstring output(size, L'\0');
+
+    if (size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size()))) {
+        output.clear();
+    }
+
+    return output;
+}
+
+std::string UTF16ToUTF8(std::wstring_view input) {
+    const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+                                          nullptr, 0, nullptr, nullptr);
+    if (size == 0) {
+        return {};
+    }
+
+    std::string output(size, '\0');
+
+    if (size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size()), nullptr,
+                                    nullptr)) {
+        output.clear();
+    }
+
+    return output;
+}
+
+std::wstring UTF8ToUTF16W(std::string_view input) {
+    return CPToUTF16(CP_UTF8, input);
+}
+#endif
+
 } // namespace Common

src/common/string_util.h

@@ -11,4 +11,9 @@ namespace Common {
 
 std::vector<std::string> SplitString(const std::string& str, char delimiter);
 
+#ifdef _WIN32
+[[nodiscard]] std::string UTF16ToUTF8(std::wstring_view input);
+[[nodiscard]] std::wstring UTF8ToUTF16W(std::string_view str);
+#endif
+
 } // namespace Common

src/common/thread.cpp

@@ -0,0 +1,123 @@
+// SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <string>
+
+#include "common/error.h"
+#include "common/logging/log.h"
+#include "common/thread.h"
+#ifdef __APPLE__
+#include <mach/mach.h>
+#elif defined(_WIN32)
+#include <windows.h>
+#include "common/string_util.h"
+#else
+#if defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+#include <pthread_np.h>
+#else
+#include <pthread.h>
+#endif
+#include <sched.h>
+#endif
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+#ifdef __FreeBSD__
+#define cpu_set_t cpuset_t
+#endif
+
+namespace Common {
+
+#ifdef _WIN32
+
+void SetCurrentThreadPriority(ThreadPriority new_priority) {
+    auto handle = GetCurrentThread();
+    int windows_priority = 0;
+    switch (new_priority) {
+    case ThreadPriority::Low:
+        windows_priority = THREAD_PRIORITY_BELOW_NORMAL;
+        break;
+    case ThreadPriority::Normal:
+        windows_priority = THREAD_PRIORITY_NORMAL;
+        break;
+    case ThreadPriority::High:
+        windows_priority = THREAD_PRIORITY_ABOVE_NORMAL;
+        break;
+    case ThreadPriority::VeryHigh:
+        windows_priority = THREAD_PRIORITY_HIGHEST;
+        break;
+    case ThreadPriority::Critical:
+        windows_priority = THREAD_PRIORITY_TIME_CRITICAL;
+        break;
+    default:
+        windows_priority = THREAD_PRIORITY_NORMAL;
+        break;
+    }
+    SetThreadPriority(handle, windows_priority);
+}
+
+#else
+
+void SetCurrentThreadPriority(ThreadPriority new_priority) {
+    pthread_t this_thread = pthread_self();
+
+    const auto scheduling_type = SCHED_OTHER;
+    s32 max_prio = sched_get_priority_max(scheduling_type);
+    s32 min_prio = sched_get_priority_min(scheduling_type);
+    u32 level = std::max(static_cast<u32>(new_priority) + 1, 4U);
+
+    struct sched_param params;
+    if (max_prio > min_prio) {
+        params.sched_priority = min_prio + ((max_prio - min_prio) * level) / 4;
+    } else {
+        params.sched_priority = min_prio - ((min_prio - max_prio) * level) / 4;
+    }
+
+    pthread_setschedparam(this_thread, scheduling_type, &params);
+}
+
+#endif
+
+#ifdef _MSC_VER
+
+// Sets the debugger-visible name of the current thread.
+void SetCurrentThreadName(const char* name) {
+    SetThreadDescription(GetCurrentThread(), UTF8ToUTF16W(name).data());
+}
+
+#else // !MSVC_VER, so must be POSIX threads
+
+// MinGW with the POSIX threading model does not support pthread_setname_np
+#if !defined(_WIN32) || defined(_MSC_VER)
+void SetCurrentThreadName(const char* name) {
+#ifdef __APPLE__
+    pthread_setname_np(name);
+#elif defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+    pthread_set_name_np(pthread_self(), name);
+#elif defined(__NetBSD__)
+    pthread_setname_np(pthread_self(), "%s", (void*)name);
+#elif defined(__linux__)
+    // Linux limits thread names to 15 characters and will outright reject any
+    // attempt to set a longer name with ERANGE.
+    std::string truncated(name, std::min(strlen(name), static_cast<std::size_t>(15)));
+    if (int e = pthread_setname_np(pthread_self(), truncated.c_str())) {
+        errno = e;
+        LOG_ERROR(Common, "Failed to set thread name to '{}': {}", truncated, GetLastErrorMsg());
+    }
+#else
+    pthread_setname_np(pthread_self(), name);
+#endif
+}
+#endif
+
+#if defined(_WIN32)
+void SetCurrentThreadName(const char*) {
+    // Do Nothing on MingW
+}
+#endif
+
+#endif
+
+} // namespace Common

src/common/thread.h

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Common {
+
+enum class ThreadPriority : u32 {
+    Low = 0,
+    Normal = 1,
+    High = 2,
+    VeryHigh = 3,
+    Critical = 4,
+};
+
+void SetCurrentThreadPriority(ThreadPriority new_priority);
+
+void SetCurrentThreadName(const char* name);
+
+} // namespace Common