Remove dependency chrono

Earlier chrono was included but after some code changed it was no longer needed

Forgot to remove it so I'm removing it now

src/common/CMakeLists.txt

@@ -90,7 +90,7 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC Boost::boost microprofile)
+target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
 if (ARCHITECTURE_x86_64)
     target_link_libraries(common PRIVATE xbyak)
 endif()

src/common/logging/backend.cpp

@@ -11,6 +11,7 @@
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
+#include "common/string_util.h"
 
 namespace Log {
 
@@ -102,25 +103,20 @@ const char* GetLevelName(Level log_level) {
 }
 
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                  const char* function, const char* format, va_list args) {
+                  const char* function, std::string message) {
     using std::chrono::duration_cast;
     using std::chrono::steady_clock;
 
     static steady_clock::time_point time_origin = steady_clock::now();
 
-    std::array<char, 4 * 1024> formatting_buffer;
-
     Entry entry;
     entry.timestamp = duration_cast<std::chrono::microseconds>(steady_clock::now() - time_origin);
     entry.log_class = log_class;
     entry.log_level = log_level;
-
-    snprintf(formatting_buffer.data(), formatting_buffer.size(), "%s:%s:%u", filename, function,
-             line_nr);
-    entry.location = std::string(formatting_buffer.data());
-
-    vsnprintf(formatting_buffer.data(), formatting_buffer.size(), format, args);
-    entry.message = std::string(formatting_buffer.data());
+    entry.filename = Common::TrimSourcePath(filename);
+    entry.line_num = line_nr;
+    entry.function = function;
+    entry.message = std::move(message);
 
     return entry;
 }
@@ -131,15 +127,27 @@ void SetFilter(Filter* new_filter) {
     filter = new_filter;
 }
 
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
+void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
                 const char* function, const char* format, ...) {
-    if (filter != nullptr && !filter->CheckMessage(log_class, log_level))
+    if (filter && !filter->CheckMessage(log_class, log_level))
         return;
-
+    std::array<char, 4 * 1024> formatting_buffer;
     va_list args;
     va_start(args, format);
-    Entry entry = CreateEntry(log_class, log_level, filename, line_nr, function, format, args);
+    vsnprintf(formatting_buffer.data(), formatting_buffer.size(), format, args);
     va_end(args);
+    Entry entry = CreateEntry(log_class, log_level, filename, line_num, function,
+                              std::string(formatting_buffer.data()));
+
+    PrintColoredMessage(entry);
+}
+
+void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+                   const char* function, const char* format, const fmt::ArgList& args) {
+    if (filter && !filter->CheckMessage(log_class, log_level))
+        return;
+    Entry entry =
+        CreateEntry(log_class, log_level, filename, line_num, function, fmt::format(format, args));
 
     PrintColoredMessage(entry);
 }

src/common/logging/backend.h

@@ -22,13 +22,16 @@ struct Entry {
     std::chrono::microseconds timestamp;
     Class log_class;
     Level log_level;
-    std::string location;
+    std::string filename;
+    unsigned int line_num;
+    std::string function;
     std::string message;
 
     Entry() = default;
     Entry(Entry&& o) = default;
 
     Entry& operator=(Entry&& o) = default;
+    Entry& operator=(const Entry& o) = default;
 };
 
 /**
@@ -44,7 +47,7 @@ const char* GetLevelName(Level log_level);
 
 /// Creates a log entry by formatting the given source location, and message.
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                  const char* function, const char* format, va_list args);
+                  const char* function, std::string message);
 
 void SetFilter(Filter* filter);
 } // namespace Log

src/common/logging/filter.cpp

@@ -65,14 +65,14 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
                              const std::string::const_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 `:`: %s",
-                  std::string(begin, end).c_str());
+        NGLOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s",
+                    std::string(begin, end).c_str());
         return false;
     }
 
     const Level level = GetLevelByName(level_separator + 1, end);
     if (level == Level::Count) {
-        LOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
+        NGLOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
         return false;
     }
 
@@ -83,7 +83,7 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
 
     const Class log_class = GetClassByName(begin, level_separator);
     if (log_class == Class::Count) {
-        LOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
+        NGLOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
         return false;
     }
 

src/common/logging/filter.h

@@ -19,7 +19,7 @@ namespace Log {
 class Filter {
 public:
     /// Initializes the filter with all classes having `default_level` as the minimum level.
-    Filter(Level default_level);
+    Filter(Level default_level = Level::Info);
 
     /// Resets the filter so that all classes have `level` as the minimum displayed level.
     void ResetAll(Level level);

src/common/logging/log.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <fmt/format.h>
 #include "common/common_types.h"
 
 namespace Log {
@@ -87,7 +88,7 @@ enum class Class : ClassType {
 };
 
 /// Logs a message to the global logger.
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
+void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
                 const char* function,
 #ifdef _MSC_VER
                 _Printf_format_string_
@@ -99,6 +100,10 @@ void LogMessage(Class log_class, Level log_level, const char* filename, unsigned
 #endif
     ;
 
+void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+                   const char* function, const char* format, const fmt::ArgList& args);
+FMT_VARIADIC(void, FmtLogMessage, Class, Level, const char*, unsigned int, const char*, const char*)
+
 } // namespace Log
 
 #define LOG_GENERIC(log_class, log_level, ...)                                                     \
@@ -121,3 +126,28 @@ void LogMessage(Class log_class, Level log_level, const char* filename, unsigned
     LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Error, __VA_ARGS__)
 #define LOG_CRITICAL(log_class, ...)                                                               \
     LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Critical, __VA_ARGS__)
+
+// Define the fmt lib macros
+#ifdef _DEBUG
+#define NGLOG_TRACE(log_class, ...)                                                                \
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Trace, __FILE__, __LINE__,         \
+                         __func__, __VA_ARGS__)
+#else
+#define NGLOG_TRACE(log_class, fmt, ...) (void(0))
+#endif
+
+#define NGLOG_DEBUG(log_class, ...)                                                                \
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Debug, __FILE__, __LINE__,         \
+                         __func__, __VA_ARGS__)
+#define NGLOG_INFO(log_class, ...)                                                                 \
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Info, __FILE__, __LINE__,          \
+                         __func__, __VA_ARGS__)
+#define NGLOG_WARNING(log_class, ...)                                                              \
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Warning, __FILE__, __LINE__,       \
+                         __func__, __VA_ARGS__)
+#define NGLOG_ERROR(log_class, ...)                                                                \
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Error, __FILE__, __LINE__,         \
+                         __func__, __VA_ARGS__)
+#define NGLOG_CRITICAL(log_class, ...)                                                             \
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Critical, __FILE__, __LINE__,      \
+                         __func__, __VA_ARGS__)

src/common/logging/text_formatter.cpp

@@ -18,50 +18,29 @@
 
 namespace Log {
 
-// TODO(bunnei): This should be moved to a generic path manipulation library
-const char* TrimSourcePath(const char* path, const char* root) {
-    const char* p = path;
-
-    while (*p != '\0') {
-        const char* next_slash = p;
-        while (*next_slash != '\0' && *next_slash != '/' && *next_slash != '\\') {
-            ++next_slash;
-        }
-
-        bool is_src = Common::ComparePartialString(p, next_slash, root);
-        p = next_slash;
-
-        if (*p != '\0') {
-            ++p;
-        }
-        if (is_src) {
-            path = p;
-        }
-    }
-    return path;
-}
-
-void FormatLogMessage(const Entry& entry, char* out_text, size_t text_len) {
+std::string FormatLogMessage(const Entry& entry) {
     unsigned int time_seconds = static_cast<unsigned int>(entry.timestamp.count() / 1000000);
     unsigned int time_fractional = static_cast<unsigned int>(entry.timestamp.count() % 1000000);
 
     const char* class_name = GetLogClassName(entry.log_class);
     const char* level_name = GetLevelName(entry.log_level);
 
-    snprintf(out_text, text_len, "[%4u.%06u] %s <%s> %s: %s", time_seconds, time_fractional,
-             class_name, level_name, TrimSourcePath(entry.location.c_str()), entry.message.c_str());
+    return fmt::format("[{:4d}.{:06d}] {} <{}> {}:{}:{}: {}", time_seconds, time_fractional,
+                       class_name, level_name, entry.filename, entry.function, entry.line_num,
+                       entry.message);
 }
 
 void PrintMessage(const Entry& entry) {
-    std::array<char, 4 * 1024> format_buffer;
-    FormatLogMessage(entry, format_buffer.data(), format_buffer.size());
-    fputs(format_buffer.data(), stderr);
-    fputc('\n', stderr);
+    auto str = FormatLogMessage(entry) + '\n';
+    fputs(str.c_str(), stderr);
 }
 
 void PrintColoredMessage(const Entry& entry) {
 #ifdef _WIN32
-    static HANDLE console_handle = GetStdHandle(STD_ERROR_HANDLE);
+    HANDLE console_handle = GetStdHandle(STD_ERROR_HANDLE);
+    if (console_handle == INVALID_HANDLE_VALUE) {
+        return;
+    }
 
     CONSOLE_SCREEN_BUFFER_INFO original_info = {0};
     GetConsoleScreenBufferInfo(console_handle, &original_info);

src/common/logging/text_formatter.h

@@ -10,20 +10,8 @@ namespace Log {
 
 struct Entry;
 
-/**
- * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
- * intended to be used to strip a system-specific build directory from the `__FILE__` macro,
- * leaving only the path relative to the sources root.
- *
- * @param path The input file path as a null-terminated string
- * @param root The name of the root source directory as a null-terminated string. Path up to and
- *             including the last occurrence of this name will be stripped
- * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
- */
-const char* TrimSourcePath(const char* path, const char* root = "src");
-
 /// Formats a log entry into the provided text buffer.
-void FormatLogMessage(const Entry& entry, char* out_text, size_t text_len);
+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 acoording to the severity level.

src/common/string_util.cpp

@@ -462,4 +462,27 @@ std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_l
 
     return std::string(buffer, len);
 }
+
+const char* TrimSourcePath(const char* path, const char* root) {
+    const char* p = path;
+
+    while (*p != '\0') {
+        const char* next_slash = p;
+        while (*next_slash != '\0' && *next_slash != '/' && *next_slash != '\\') {
+            ++next_slash;
+        }
+
+        bool is_src = Common::ComparePartialString(p, next_slash, root);
+        p = next_slash;
+
+        if (*p != '\0') {
+            ++p;
+        }
+        if (is_src) {
+            path = p;
+        }
+    }
+    return path;
+}
+
 } // namespace Common

src/common/string_util.h

@@ -134,4 +134,17 @@ bool ComparePartialString(InIt begin, InIt end, const char* other) {
  * NUL-terminated then the string ends at max_len characters.
  */
 std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_len);
+
+/**
+ * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
+ * intended to be used to strip a system-specific build directory from the `__FILE__` macro,
+ * leaving only the path relative to the sources root.
+ *
+ * @param path The input file path as a null-terminated string
+ * @param root The name of the root source directory as a null-terminated string. Path up to and
+ *             including the last occurrence of this name will be stripped
+ * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
+ */
+const char* TrimSourcePath(const char* path, const char* root = "src");
+
 } // namespace Common

src/core/CMakeLists.txt

@@ -12,6 +12,8 @@ add_library(core STATIC
     file_sys/filesystem.h
     file_sys/path_parser.cpp
     file_sys/path_parser.h
+    file_sys/program_metadata.cpp
+    file_sys/program_metadata.h
     file_sys/romfs_factory.cpp
     file_sys/romfs_factory.h
     file_sys/romfs_filesystem.cpp

src/core/file_sys/program_metadata.cpp

@@ -0,0 +1,114 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cinttypes>
+#include "common/file_util.h"
+#include "common/logging/log.h"
+#include "core/file_sys/program_metadata.h"
+#include "core/loader/loader.h"
+
+namespace FileSys {
+
+Loader::ResultStatus ProgramMetadata::Load(const std::string& file_path) {
+    FileUtil::IOFile file(file_path, "rb");
+    if (!file.IsOpen())
+        return Loader::ResultStatus::Error;
+
+    std::vector<u8> file_data(file.GetSize());
+
+    if (!file.ReadBytes(file_data.data(), file_data.size()))
+        return Loader::ResultStatus::Error;
+
+    Loader::ResultStatus result = Load(file_data);
+    if (result != Loader::ResultStatus::Success)
+        LOG_ERROR(Service_FS, "Failed to load NPDM from file %s!", file_path.c_str());
+
+    return result;
+}
+
+Loader::ResultStatus ProgramMetadata::Load(const std::vector<u8> file_data, size_t offset) {
+    size_t total_size = static_cast<size_t>(file_data.size() - offset);
+    if (total_size < sizeof(Header))
+        return Loader::ResultStatus::Error;
+
+    size_t header_offset = offset;
+    memcpy(&npdm_header, &file_data[offset], sizeof(Header));
+
+    size_t aci_offset = header_offset + npdm_header.aci_offset;
+    size_t acid_offset = header_offset + npdm_header.acid_offset;
+    memcpy(&aci_header, &file_data[aci_offset], sizeof(AciHeader));
+    memcpy(&acid_header, &file_data[acid_offset], sizeof(AcidHeader));
+
+    size_t fac_offset = acid_offset + acid_header.fac_offset;
+    size_t fah_offset = aci_offset + aci_header.fah_offset;
+    memcpy(&acid_file_access, &file_data[fac_offset], sizeof(FileAccessControl));
+    memcpy(&aci_file_access, &file_data[fah_offset], sizeof(FileAccessHeader));
+
+    return Loader::ResultStatus::Success;
+}
+
+bool ProgramMetadata::Is64BitProgram() const {
+    return npdm_header.has_64_bit_instructions;
+}
+
+ProgramAddressSpaceType ProgramMetadata::GetAddressSpaceType() const {
+    return npdm_header.address_space_type;
+}
+
+u8 ProgramMetadata::GetMainThreadPriority() const {
+    return npdm_header.main_thread_priority;
+}
+
+u8 ProgramMetadata::GetMainThreadCore() const {
+    return npdm_header.main_thread_cpu;
+}
+
+u32 ProgramMetadata::GetMainThreadStackSize() const {
+    return npdm_header.main_stack_size;
+}
+
+u64 ProgramMetadata::GetTitleID() const {
+    return aci_header.title_id;
+}
+
+u64 ProgramMetadata::GetFilesystemPermissions() const {
+    return aci_file_access.permissions;
+}
+
+void ProgramMetadata::Print() const {
+    LOG_DEBUG(Service_FS, "Magic:                  %.4s", npdm_header.magic.data());
+    LOG_DEBUG(Service_FS, "Main thread priority:   0x%02x", npdm_header.main_thread_priority);
+    LOG_DEBUG(Service_FS, "Main thread core:       %u", npdm_header.main_thread_cpu);
+    LOG_DEBUG(Service_FS, "Main thread stack size: 0x%x bytes", npdm_header.main_stack_size);
+    LOG_DEBUG(Service_FS, "Process category:       %u", npdm_header.process_category);
+    LOG_DEBUG(Service_FS, "Flags:                  %02x", npdm_header.flags);
+    LOG_DEBUG(Service_FS, " > 64-bit instructions: %s",
+              npdm_header.has_64_bit_instructions ? "YES" : "NO");
+
+    auto address_space = "Unknown";
+    switch (npdm_header.address_space_type) {
+    case ProgramAddressSpaceType::Is64Bit:
+        address_space = "64-bit";
+        break;
+    case ProgramAddressSpaceType::Is32Bit:
+        address_space = "32-bit";
+        break;
+    }
+
+    LOG_DEBUG(Service_FS, " > Address space:       %s\n", address_space);
+
+    // Begin ACID printing (potential perms, signed)
+    LOG_DEBUG(Service_FS, "Magic:                  %.4s", acid_header.magic.data());
+    LOG_DEBUG(Service_FS, "Flags:                  %02x", acid_header.flags);
+    LOG_DEBUG(Service_FS, " > Is Retail:           %s", acid_header.is_retail ? "YES" : "NO");
+    LOG_DEBUG(Service_FS, "Title ID Min:           %016" PRIX64, acid_header.title_id_min);
+    LOG_DEBUG(Service_FS, "Title ID Max:           %016" PRIX64, acid_header.title_id_max);
+    LOG_DEBUG(Service_FS, "Filesystem Access:      %016" PRIX64 "\n", acid_file_access.permissions);
+
+    // Begin ACI0 printing (actual perms, unsigned)
+    LOG_DEBUG(Service_FS, "Magic:                  %.4s", aci_header.magic.data());
+    LOG_DEBUG(Service_FS, "Title ID:               %016" PRIX64, aci_header.title_id);
+    LOG_DEBUG(Service_FS, "Filesystem Access:      %016" PRIX64 "\n", aci_file_access.permissions);
+}
+} // namespace FileSys

src/core/file_sys/program_metadata.h

@@ -0,0 +1,154 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <string>
+#include <vector>
+#include "common/bit_field.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+
+namespace Loader {
+enum class ResultStatus;
+}
+
+namespace FileSys {
+
+enum class ProgramAddressSpaceType : u8 {
+    Is64Bit = 1,
+    Is32Bit = 2,
+};
+
+enum class ProgramFilePermission : u64 {
+    MountContent = 1ULL << 0,
+    SaveDataBackup = 1ULL << 5,
+    SdCard = 1ULL << 21,
+    Calibration = 1ULL << 34,
+    Bit62 = 1ULL << 62,
+    Everything = 1ULL << 63,
+};
+
+/**
+ * Helper which implements an interface to parse Program Description Metadata (NPDM)
+ * Data can either be loaded from a file path or with data and an offset into it.
+ */
+class ProgramMetadata {
+public:
+    Loader::ResultStatus Load(const std::string& file_path);
+    Loader::ResultStatus Load(const std::vector<u8> file_data, size_t offset = 0);
+
+    bool Is64BitProgram() const;
+    ProgramAddressSpaceType GetAddressSpaceType() const;
+    u8 GetMainThreadPriority() const;
+    u8 GetMainThreadCore() const;
+    u32 GetMainThreadStackSize() const;
+    u64 GetTitleID() const;
+    u64 GetFilesystemPermissions() const;
+
+    void Print() const;
+
+private:
+    struct Header {
+        std::array<char, 4> magic;
+        std::array<u8, 8> reserved;
+        union {
+            u8 flags;
+
+            BitField<0, 1, u8> has_64_bit_instructions;
+            BitField<1, 3, ProgramAddressSpaceType> address_space_type;
+            BitField<4, 4, u8> reserved_2;
+        };
+        u8 reserved_3;
+        u8 main_thread_priority;
+        u8 main_thread_cpu;
+        std::array<u8, 8> reserved_4;
+        u32_le process_category;
+        u32_le main_stack_size;
+        std::array<u8, 0x10> application_name;
+        std::array<u8, 0x40> reserved_5;
+        u32_le aci_offset;
+        u32_le aci_size;
+        u32_le acid_offset;
+        u32_le acid_size;
+    };
+
+    static_assert(sizeof(Header) == 0x80, "NPDM header structure size is wrong");
+
+    struct AcidHeader {
+        std::array<u8, 0x100> signature;
+        std::array<u8, 0x100> nca_modulus;
+        std::array<char, 4> magic;
+        u32_le nca_size;
+        std::array<u8, 0x4> reserved;
+        union {
+            u32 flags;
+
+            BitField<0, 1, u32> is_retail;
+            BitField<1, 31, u32> flags_unk;
+        };
+        u64_le title_id_min;
+        u64_le title_id_max;
+        u32_le fac_offset;
+        u32_le fac_size;
+        u32_le sac_offset;
+        u32_le sac_size;
+        u32_le kac_offset;
+        u32_le kac_size;
+        INSERT_PADDING_BYTES(0x8);
+    };
+
+    static_assert(sizeof(AcidHeader) == 0x240, "ACID header structure size is wrong");
+
+    struct AciHeader {
+        std::array<char, 4> magic;
+        std::array<u8, 0xC> reserved;
+        u64_le title_id;
+        INSERT_PADDING_BYTES(0x8);
+        u32_le fah_offset;
+        u32_le fah_size;
+        u32_le sac_offset;
+        u32_le sac_size;
+        u32_le kac_offset;
+        u32_le kac_size;
+        INSERT_PADDING_BYTES(0x8);
+    };
+
+    static_assert(sizeof(AciHeader) == 0x40, "ACI0 header structure size is wrong");
+
+#pragma pack(push, 1)
+
+    struct FileAccessControl {
+        u8 version;
+        INSERT_PADDING_BYTES(3);
+        u64_le permissions;
+        std::array<u8, 0x20> unknown;
+    };
+
+    static_assert(sizeof(FileAccessControl) == 0x2C, "FS access control structure size is wrong");
+
+    struct FileAccessHeader {
+        u8 version;
+        INSERT_PADDING_BYTES(3);
+        u64_le permissions;
+        u32_le unk_offset;
+        u32_le unk_size;
+        u32_le unk_offset_2;
+        u32_le unk_size_2;
+    };
+
+    static_assert(sizeof(FileAccessHeader) == 0x1C, "FS access header structure size is wrong");
+
+#pragma pack(pop)
+
+    Header npdm_header;
+    AciHeader aci_header;
+    AcidHeader acid_header;
+
+    FileAccessControl acid_file_access;
+    FileAccessHeader aci_file_access;
+};
+
+} // namespace FileSys

src/core/hle/kernel/svc.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <cinttypes>
 
 #include "common/logging/log.h"
 #include "common/microprofile.h"
@@ -443,6 +444,16 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
     return RESULT_SUCCESS;
 }
 
+static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
+    LOG_WARNING(Kernel_SVC,
+                "called, shared_memory_handle=0x%08X, addr=0x%" PRIx64 ", size=0x%" PRIx64 "",
+                shared_memory_handle, addr, size);
+
+    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
+
+    return shared_memory->Unmap(g_current_process.get(), addr);
+}
+
 /// Query process memory
 static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
                                      Handle process_handle, u64 addr) {
@@ -802,7 +813,7 @@ static const FunctionDef SVC_Table[] = {
     {0x11, nullptr, "SignalEvent"},
     {0x12, SvcWrap<ClearEvent>, "ClearEvent"},
     {0x13, SvcWrap<MapSharedMemory>, "MapSharedMemory"},
-    {0x14, nullptr, "UnmapSharedMemory"},
+    {0x14, SvcWrap<UnmapSharedMemory>, "UnmapSharedMemory"},
     {0x15, SvcWrap<CreateTransferMemory>, "CreateTransferMemory"},
     {0x16, SvcWrap<CloseHandle>, "CloseHandle"},
     {0x17, SvcWrap<ResetSignal>, "ResetSignal"},

src/core/hle/kernel/svc_wrap.h

@@ -91,6 +91,11 @@ void SvcWrap() {
     FuncReturn(func((u32)PARAM(0), PARAM(1), PARAM(2), (u32)PARAM(3)).raw);
 }
 
+template <ResultCode func(u32, u64, u64)>
+void SvcWrap() {
+    FuncReturn(func((u32)PARAM(0), PARAM(1), PARAM(2)).raw);
+}
+
 template <ResultCode func(u32*, u64, u64, s64)>
 void SvcWrap() {
     u32 param_1 = 0;

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -22,9 +22,9 @@ u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, std::vector
 void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height,
                         u32 stride, NVFlinger::BufferQueue::BufferTransformFlags transform) {
     VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
-    //LOG_WARNING(Service,
-    //            "Drawing from address %llx offset %08X Width %u Height %u Stride %u Format %u",
-    //            addr, offset, width, height, stride, format);
+    LOG_WARNING(Service,
+                "Drawing from address %llx offset %08X Width %u Height %u Stride %u Format %u",
+                addr, offset, width, height, stride, format);
 
     using PixelFormat = RendererBase::FramebufferInfo::PixelFormat;
     using Flags = NVFlinger::BufferQueue::BufferTransformFlags;

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -21,10 +21,6 @@ namespace NVFlinger {
 constexpr size_t SCREEN_REFRESH_RATE = 60;
 constexpr u64 frame_ticks = static_cast<u64>(BASE_CLOCK_RATE / SCREEN_REFRESH_RATE);
 
-// libnx "GfxMode_TiledSingle" hack. libnx does not use queue/dequeue buffer
-// in GfxMode_TiledSingle mode, we maintain a pointer to the last queued buffer
-static BufferQueue::Buffer nxBuffer{};
-
 NVFlinger::NVFlinger() {
     // Add the different displays to the list of displays.
     Display default_{0, "Default"};
@@ -132,50 +128,28 @@ void NVFlinger::Compose() {
         // Search for a queued buffer and acquire it
         auto buffer = buffer_queue->AcquireBuffer();
 
-        if (buffer == boost::none && nxBuffer.status == BufferQueue::Buffer::Status::Free) {
+        if (buffer == boost::none) {
             // There was no queued buffer to draw, render previous frame
             Core::System::GetInstance().perf_stats.EndGameFrame();
             VideoCore::g_renderer->SwapBuffers({});
             continue;
-        } else if(nxBuffer.status == BufferQueue::Buffer::Status::Free) {
-            nxBuffer.slot = buffer->slot;
-            nxBuffer.status = BufferQueue::Buffer::Status::Queued;
-            memcpy(&nxBuffer.igbp_buffer, &buffer->igbp_buffer, sizeof(IGBPBuffer));
-            memcpy(&nxBuffer.transform, &buffer->transform, sizeof(BufferQueue::BufferTransformFlags));
         }
 
-        if(buffer == boost::none && nxBuffer.status != BufferQueue::Buffer::Status::Free) {
-            auto &igbp_buffer = nxBuffer.igbp_buffer;
+        auto& igbp_buffer = buffer->igbp_buffer;
 
-            // Now send the buffer to the GPU for drawing.
-            auto nvdrv = Nvidia::nvdrv.lock();
-            ASSERT(nvdrv);
+        // Now send the buffer to the GPU for drawing.
+        auto nvdrv = Nvidia::nvdrv.lock();
+        ASSERT(nvdrv);
 
-            // TODO(Subv): Support more than just disp0. The display device selection is probably based
-            // on which display we're drawing (Default, Internal, External, etc)
-            auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>("/dev/nvdisp_disp0");
-            ASSERT(nvdisp);
+        // TODO(Subv): Support more than just disp0. The display device selection is probably based
+        // on which display we're drawing (Default, Internal, External, etc)
+        auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>("/dev/nvdisp_disp0");
+        ASSERT(nvdisp);
 
-            nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.format,
-                         igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride, nxBuffer.transform);
+        nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.format,
+                     igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride, buffer->transform);
 
-        } else {
-            auto &igbp_buffer = buffer->igbp_buffer;
-
-            // Now send the buffer to the GPU for drawing.
-            auto nvdrv = Nvidia::nvdrv.lock();
-            ASSERT(nvdrv);
-
-            // TODO(Subv): Support more than just disp0. The display device selection is probably based
-            // on which display we're drawing (Default, Internal, External, etc)
-            auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>("/dev/nvdisp_disp0");
-            ASSERT(nvdisp);
-
-            nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.format,
-                         igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride, buffer->transform);
-
-            buffer_queue->ReleaseBuffer(buffer->slot);
-        }
+        buffer_queue->ReleaseBuffer(buffer->slot);
     }
 }
 

src/core/loader/deconstructed_rom_directory.cpp

@@ -53,6 +53,7 @@ AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(FileUti
 FileType AppLoader_DeconstructedRomDirectory::IdentifyType(FileUtil::IOFile& file,
                                                            const std::string& filepath) {
     bool is_main_found{};
+    bool is_npdm_found{};
     bool is_rtld_found{};
     bool is_sdk_found{};
 
@@ -67,6 +68,9 @@ FileType AppLoader_DeconstructedRomDirectory::IdentifyType(FileUtil::IOFile& fil
         // Verify filename
         if (Common::ToLower(virtual_name) == "main") {
             is_main_found = true;
+        } else if (Common::ToLower(virtual_name) == "main.npdm") {
+            is_npdm_found = true;
+            return true;
         } else if (Common::ToLower(virtual_name) == "rtld") {
             is_rtld_found = true;
         } else if (Common::ToLower(virtual_name) == "sdk") {
@@ -83,14 +87,14 @@ FileType AppLoader_DeconstructedRomDirectory::IdentifyType(FileUtil::IOFile& fil
         }
 
         // We are done if we've found and verified all required NSOs
-        return !(is_main_found && is_rtld_found && is_sdk_found);
+        return !(is_main_found && is_npdm_found && is_rtld_found && is_sdk_found);
     };
 
     // Search the directory recursively, looking for the required modules
     const std::string directory = filepath.substr(0, filepath.find_last_of("/\\")) + DIR_SEP;
     FileUtil::ForeachDirectoryEntry(nullptr, directory, callback);
 
-    if (is_main_found && is_rtld_found && is_sdk_found) {
+    if (is_main_found && is_npdm_found && is_rtld_found && is_sdk_found) {
         return FileType::DeconstructedRomDirectory;
     }
 
@@ -108,14 +112,22 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
 
     process = Kernel::Process::Create("main");
 
+    const std::string directory = filepath.substr(0, filepath.find_last_of("/\\")) + DIR_SEP;
+    const std::string npdm_path = directory + DIR_SEP + "main.npdm";
+
+    ResultStatus result = metadata.Load(npdm_path);
+    if (result != ResultStatus::Success) {
+        return result;
+    }
+    metadata.Print();
+
     // Load NSO modules
     VAddr next_load_addr{Memory::PROCESS_IMAGE_VADDR};
-    const std::string directory = filepath.substr(0, filepath.find_last_of("/\\")) + DIR_SEP;
     for (const auto& module : {"rtld", "main", "subsdk0", "subsdk1", "subsdk2", "subsdk3",
                                "subsdk4", "subsdk5", "subsdk6", "subsdk7", "sdk"}) {
         const std::string path = directory + DIR_SEP + module;
         const VAddr load_addr = next_load_addr;
-        next_load_addr = AppLoader_NSO::LoadModule(path, load_addr);
+        next_load_addr = AppLoader_NSO::LoadModule(path, load_addr, metadata.GetTitleID());
         if (next_load_addr) {
             LOG_DEBUG(Loader, "loaded module %s @ 0x%" PRIx64, module, load_addr);
         } else {
@@ -127,7 +139,8 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
     process->address_mappings = default_address_mappings;
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
-    process->Run(Memory::PROCESS_IMAGE_VADDR, 48, Kernel::DEFAULT_STACK_SIZE);
+    process->Run(Memory::PROCESS_IMAGE_VADDR, metadata.GetMainThreadPriority(),
+                 metadata.GetMainThreadStackSize());
 
     // Find the RomFS by searching for a ".romfs" file in this directory
     filepath_romfs = FindRomFS(directory);

src/core/loader/deconstructed_rom_directory.h

@@ -6,6 +6,7 @@
 
 #include <string>
 #include "common/common_types.h"
+#include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/loader/loader.h"
 
@@ -41,6 +42,7 @@ public:
 private:
     std::string filepath_romfs;
     std::string filepath;
+    FileSys::ProgramMetadata metadata;
 };
 
 } // namespace Loader

src/core/loader/nso.cpp

@@ -92,7 +92,7 @@ static constexpr u32 PageAlignSize(u32 size) {
     return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
 }
 
-VAddr AppLoader_NSO::LoadModule(const std::string& path, VAddr load_base) {
+VAddr AppLoader_NSO::LoadModule(const std::string& path, VAddr load_base, u64 tid) {
     FileUtil::IOFile file(path, "rb");
     if (!file.IsOpen()) {
         return {};
@@ -109,7 +109,7 @@ VAddr AppLoader_NSO::LoadModule(const std::string& path, VAddr load_base) {
     }
 
     // Build program image
-    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("", 0);
+    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("", tid);
     std::vector<u8> program_image;
     for (int i = 0; i < nso_header.segments.size(); ++i) {
         std::vector<u8> data =
@@ -158,7 +158,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process = Kernel::Process::Create("main");
 
     // Load module
-    LoadModule(filepath, Memory::PROCESS_IMAGE_VADDR);
+    LoadModule(filepath, Memory::PROCESS_IMAGE_VADDR, 0);
     LOG_DEBUG(Loader, "loaded module %s @ 0x%" PRIx64, filepath.c_str(),
               Memory::PROCESS_IMAGE_VADDR);
 

src/core/loader/nso.h

@@ -29,7 +29,7 @@ public:
         return IdentifyType(file, filepath);
     }
 
-    static VAddr LoadModule(const std::string& path, VAddr load_base);
+    static VAddr LoadModule(const std::string& path, VAddr load_base, u64 tid);
 
     ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
 

src/yuzu/main.cpp

@@ -387,7 +387,7 @@ bool GMainWindow::LoadROM(const QString& filename) {
 }
 
 void GMainWindow::BootGame(const QString& filename) {
-    LOG_INFO(Frontend, "yuzu starting...");
+    NGLOG_INFO(Frontend, "yuzu starting...");
     StoreRecentFile(filename); // Put the filename on top of the list
 
     if (!LoadROM(filename))