card_image: Implement system update commands in XCI

ci: Properly parse Azure CI details in title bar

.ci/templates/build-mock.yml

@@ -0,0 +1,5 @@
+steps:
+  - script: mkdir artifacts || echo 'X' > artifacts/T1.txt
+  - publish: artifacts
+    artifact: 'yuzu-$(BuildName)-$(BuildSuffix)'
+    displayName: 'Upload Artifacts'

.ci/templates/build-single.yml

@@ -3,17 +3,18 @@ parameters:
   cache: 'false'
 
 steps:
+- script: export DATE=`date '+%Y.%m.%d'` && export CI=true && AZURE_REPO_NAME=yuzu-emu/yuzu-$(BuildName) && AZURE_REPO_TAG=$(BuildName)-$DATE
+  displayName: 'Determine Build Name'
 - task: DockerInstaller@0
   displayName: 'Prepare Environment'
   inputs:
     dockerVersion: '17.09.0-ce'
-- ${{ if eq(parameters.cache, 'true') }}:
-  - task: CacheBeta@0
-    displayName: 'Cache Build System'
-    inputs:
-      key: yuzu-v1-$(BuildName)-$(BuildSuffix)-$(CacheSuffix)
-      path: $(System.DefaultWorkingDirectory)/ccache
-      cacheHitVar: CACHE_RESTORED
+- task: CacheBeta@0
+  displayName: 'Cache Build System'
+  inputs:
+    key: yuzu-v1-$(BuildName)-$(BuildSuffix)-$(CacheSuffix)
+    path: $(System.DefaultWorkingDirectory)/ccache
+    cacheHitVar: CACHE_RESTORED
 - script: chmod a+x ./.ci/scripts/$(ScriptFolder)/exec.sh && ./.ci/scripts/$(ScriptFolder)/exec.sh
   displayName: 'Build'
 - script: chmod a+x ./.ci/scripts/$(ScriptFolder)/upload.sh && RELEASE_NAME=$(BuildName) ./.ci/scripts/$(ScriptFolder)/upload.sh

.ci/templates/release-download.yml

@@ -0,0 +1,13 @@
+steps:
+  - task: DownloadPipelineArtifact@2
+    displayName: 'Download Windows Release'
+    inputs:
+      artifactName: 'yuzu-$(BuildName)-windows-mingw'
+      buildType: 'current'
+      targetPath: '$(Build.ArtifactStagingDirectory)'
+  - task: DownloadPipelineArtifact@2
+    displayName: 'Download Linux Release'
+    inputs:
+      artifactName: 'yuzu-$(BuildName)-linux'
+      buildType: 'current'
+      targetPath: '$(Build.ArtifactStagingDirectory)'

.ci/templates/release-github.yml

@@ -0,0 +1,11 @@
+steps:
+  - template: ./release-download.yml
+  - task: GitHubRelease@0
+    inputs:
+      action: 'create'
+      title: 'yuzu $(BuildName) #$(Build.BuildId)'
+      assets: '$(Build.ArtifactStagingDirectory)/*'
+      gitHubConnection: $(GitHubReleaseConnectionName)
+      repositoryName: '$(Build.Repository.Name)'
+      target: '$(Build.SourceVersion)'
+      tagSource: 'auto'

.ci/templates/release-universal.yml

@@ -0,0 +1,10 @@
+steps:
+  - template: ./release-download.yml
+  - task: UniversalPackages@0
+    displayName: Publish Artifacts
+    inputs:
+      command: publish
+      publishDirectory: '$(Build.ArtifactStagingDirectory)'
+      vstsFeedPublish: 'yuzu-$(BuildName)'
+      vstsFeedPackagePublish: 'main'
+      packagePublishDescription: 'Yuzu Windows and Linux Executable Packages'

.ci/yuzu-mainline-step1.yml

@@ -0,0 +1,8 @@
+trigger:
+- master
+
+stages:
+- stage: merge
+  displayName: 'merge'
+  jobs:
+  - template: ./templates/merge.yml

.ci/yuzu-mainline-step2.yml

@@ -2,12 +2,7 @@ trigger:
 - master
 
 stages:
-- stage: merge
-  displayName: 'merge'
-  jobs:
-  - template: ./templates/merge.yml
 - stage: format
-  dependsOn: merge
   displayName: 'format'
   jobs:
   - job: format
@@ -17,9 +12,17 @@ stages:
     steps:
     - template: ./templates/format-check.yml
 - stage: build
-  displayName: 'build'
   dependsOn: format
+  displayName: 'build'
   jobs:
   - template: ./templates/build-standard.yml
     parameters:
       cache: 'true'
+- stage: release
+  displayName: 'Release'
+  dependsOn: build
+  jobs:
+  - job: github
+    displayName: 'GitHub Release'
+    steps:
+    - template: ./templates/release-github.yml

src/common/CMakeLists.txt

@@ -10,6 +10,9 @@ if (DEFINED ENV{CI})
   elseif(DEFINED ENV{APPVEYOR})
     set(BUILD_REPOSITORY $ENV{APPVEYOR_REPO_NAME})
     set(BUILD_TAG $ENV{APPVEYOR_REPO_TAG_NAME})
+  elseif(DEFINED ENV{AZURE})
+    set(BUILD_REPOSITORY $ENV{AZURE_REPO_NAME})
+    set(BUILD_TAG $ENV{AZURE_REPO_TAG})
   endif()
 endif()
 add_custom_command(OUTPUT scm_rev.cpp

src/core/CMakeLists.txt

@@ -324,8 +324,6 @@ add_library(core STATIC
     hle/service/ldr/ldr.h
     hle/service/lm/lm.cpp
     hle/service/lm/lm.h
-    hle/service/lm/manager.cpp
-    hle/service/lm/manager.h
     hle/service/mig/mig.cpp
     hle/service/mig/mig.h
     hle/service/mii/mii.cpp

src/core/core.cpp

@@ -35,7 +35,6 @@
 #include "core/hle/service/apm/controller.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/glue/manager.h"
-#include "core/hle/service/lm/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
@@ -250,8 +249,6 @@ struct System::Impl {
         telemetry_session->AddField(Telemetry::FieldType::Performance, "Mean_Frametime_MS",
                                     perf_stats->GetMeanFrametime());
 
-        lm_manager.Flush();
-
         is_powered_on = false;
         exit_lock = false;
 
@@ -340,7 +337,6 @@ struct System::Impl {
     bool is_powered_on = false;
     bool exit_lock = false;
 
-    Reporter reporter;
     std::unique_ptr<Memory::CheatEngine> cheat_engine;
     std::unique_ptr<Tools::Freezer> memory_freezer;
 
@@ -350,9 +346,8 @@ struct System::Impl {
     /// APM (Performance) services
     Service::APM::Controller apm_controller{core_timing};
 
-    /// Service State
+    /// Glue services
     Service::Glue::ARPManager arp_manager;
-    Service::LM::Manager lm_manager{reporter};
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -360,6 +355,8 @@ struct System::Impl {
     /// Telemetry session for this emulation session
     std::unique_ptr<Core::TelemetrySession> telemetry_session;
 
+    Reporter reporter;
+
     ResultStatus status = ResultStatus::Success;
     std::string status_details = "";
 
@@ -635,14 +632,6 @@ const Service::APM::Controller& System::GetAPMController() const {
     return impl->apm_controller;
 }
 
-Service::LM::Manager& System::GetLogManager() {
-    return impl->lm_manager;
-}
-
-const Service::LM::Manager& System::GetLogManager() const {
-    return impl->lm_manager;
-}
-
 void System::SetExitLock(bool locked) {
     impl->exit_lock = locked;
 }

src/core/core.h

@@ -58,10 +58,6 @@ namespace Glue {
 class ARPManager;
 }
 
-namespace LM {
-class Manager;
-} // namespace LM
-
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -330,10 +326,6 @@ public:
 
     const Service::APM::Controller& GetAPMController() const;
 
-    Service::LM::Manager& GetLogManager();
-
-    const Service::LM::Manager& GetLogManager() const;
-
     void SetExitLock(bool locked);
 
     bool GetExitLock() const;

src/core/file_sys/card_image.cpp

@@ -31,7 +31,7 @@ constexpr std::array partition_names{
 
 XCI::XCI(VirtualFile file_)
     : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(partition_names.size()) {
+      partitions(partition_names.size()), partitions_raw(partition_names.size()) {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
         status = Loader::ResultStatus::ErrorBadXCIHeader;
         return;
@@ -42,8 +42,10 @@ XCI::XCI(VirtualFile file_)
         return;
     }
 
-    PartitionFilesystem main_hfs(
-        std::make_shared<OffsetVfsFile>(file, header.hfs_size, header.hfs_offset));
+    PartitionFilesystem main_hfs(std::make_shared<OffsetVfsFile>(
+        file, file->GetSize() - header.hfs_offset, header.hfs_offset));
+
+    update_normal_partition_end = main_hfs.GetFileOffsets()["secure"];
 
     if (main_hfs.GetStatus() != Loader::ResultStatus::Success) {
         status = main_hfs.GetStatus();
@@ -55,9 +57,7 @@ XCI::XCI(VirtualFile file_)
         const auto partition_idx = static_cast<std::size_t>(partition);
         auto raw = main_hfs.GetFile(partition_names[partition_idx]);
 
-        if (raw != nullptr) {
-            partitions[partition_idx] = std::make_shared<PartitionFilesystem>(std::move(raw));
-        }
+        partitions_raw[static_cast<std::size_t>(partition)] = std::move(raw);
     }
 
     secure_partition = std::make_shared<NSP>(
@@ -71,13 +71,7 @@ XCI::XCI(VirtualFile file_)
         program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
     }
 
-    auto result = AddNCAFromPartition(XCIPartition::Update);
-    if (result != Loader::ResultStatus::Success) {
-        status = result;
-        return;
-    }
-
-    result = AddNCAFromPartition(XCIPartition::Normal);
+    auto result = AddNCAFromPartition(XCIPartition::Normal);
     if (result != Loader::ResultStatus::Success) {
         status = result;
         return;
@@ -104,34 +98,114 @@ Loader::ResultStatus XCI::GetProgramNCAStatus() const {
     return program_nca_status;
 }
 
-VirtualDir XCI::GetPartition(XCIPartition partition) const {
+VirtualDir XCI::GetPartition(XCIPartition partition) {
+    const auto id = static_cast<std::size_t>(partition);
+    if (partitions[id] == nullptr && partitions_raw[id] != nullptr) {
+        partitions[id] = std::make_shared<PartitionFilesystem>(partitions_raw[id]);
+    }
+
     return partitions[static_cast<std::size_t>(partition)];
 }
 
+std::vector<VirtualDir> XCI::GetPartitions() {
+    std::vector<VirtualDir> out;
+    for (const auto& id :
+         {XCIPartition::Update, XCIPartition::Normal, XCIPartition::Secure, XCIPartition::Logo}) {
+        const auto part = GetPartition(id);
+        if (part != nullptr) {
+            out.push_back(part);
+        }
+    }
+    return out;
+}
+
 std::shared_ptr<NSP> XCI::GetSecurePartitionNSP() const {
     return secure_partition;
 }
 
-VirtualDir XCI::GetSecurePartition() const {
+VirtualDir XCI::GetSecurePartition() {
     return GetPartition(XCIPartition::Secure);
 }
 
-VirtualDir XCI::GetNormalPartition() const {
+VirtualDir XCI::GetNormalPartition() {
     return GetPartition(XCIPartition::Normal);
 }
 
-VirtualDir XCI::GetUpdatePartition() const {
+VirtualDir XCI::GetUpdatePartition() {
     return GetPartition(XCIPartition::Update);
 }
 
-VirtualDir XCI::GetLogoPartition() const {
+VirtualDir XCI::GetLogoPartition() {
     return GetPartition(XCIPartition::Logo);
 }
 
+VirtualFile XCI::GetPartitionRaw(XCIPartition partition) const {
+    return partitions_raw[static_cast<std::size_t>(partition)];
+}
+
+VirtualFile XCI::GetSecurePartitionRaw() const {
+    return GetPartitionRaw(XCIPartition::Secure);
+}
+
+VirtualFile XCI::GetStoragePartition0() const {
+    return std::make_shared<OffsetVfsFile>(file, update_normal_partition_end, 0, "partition0");
+}
+
+VirtualFile XCI::GetStoragePartition1() const {
+    return std::make_shared<OffsetVfsFile>(file, file->GetSize() - update_normal_partition_end,
+                                           update_normal_partition_end, "partition1");
+}
+
+VirtualFile XCI::GetNormalPartitionRaw() const {
+    return GetPartitionRaw(XCIPartition::Normal);
+}
+
+VirtualFile XCI::GetUpdatePartitionRaw() const {
+    return GetPartitionRaw(XCIPartition::Update);
+}
+
+VirtualFile XCI::GetLogoPartitionRaw() const {
+    return GetPartitionRaw(XCIPartition::Logo);
+}
+
 u64 XCI::GetProgramTitleID() const {
     return secure_partition->GetProgramTitleID();
 }
 
+u32 XCI::GetSystemUpdateVersion() {
+    const auto update = GetPartition(XCIPartition::Update);
+    if (update == nullptr)
+        return 0;
+
+    for (const auto& file : update->GetFiles()) {
+        NCA nca{file, nullptr, 0, keys};
+
+        if (nca.GetStatus() != Loader::ResultStatus::Success)
+            continue;
+
+        if (nca.GetType() == NCAContentType::Meta && nca.GetTitleId() == 0x0100000000000816) {
+            const auto dir = nca.GetSubdirectories()[0];
+            const auto cnmt = dir->GetFile("SystemUpdate_0100000000000816.cnmt");
+            if (cnmt == nullptr)
+                continue;
+
+            CNMT cnmt_data{cnmt};
+
+            const auto metas = cnmt_data.GetMetaRecords();
+            if (metas.empty())
+                continue;
+
+            return metas[0].title_version;
+        }
+    }
+
+    return 0;
+}
+
+u64 XCI::GetSystemUpdateTitleID() const {
+    return 0x0100000000000816;
+}
+
 bool XCI::HasProgramNCA() const {
     return program != nullptr;
 }
@@ -201,7 +275,7 @@ std::array<u8, 0x200> XCI::GetCertificate() const {
 
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     const auto partition_index = static_cast<std::size_t>(part);
-    const auto& partition = partitions[partition_index];
+    const auto partition = GetPartition(part);
 
     if (partition == nullptr) {
         return Loader::ResultStatus::ErrorXCIMissingPartition;
@@ -232,7 +306,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     return Loader::ResultStatus::Success;
 }
 
-u8 XCI::GetFormatVersion() const {
+u8 XCI::GetFormatVersion() {
     return GetLogoPartition() == nullptr ? 0x1 : 0x2;
 }
 } // namespace FileSys

src/core/file_sys/card_image.h

@@ -81,14 +81,24 @@ public:
     Loader::ResultStatus GetStatus() const;
     Loader::ResultStatus GetProgramNCAStatus() const;
 
-    u8 GetFormatVersion() const;
+    u8 GetFormatVersion();
+
+    VirtualDir GetPartition(XCIPartition partition);
+    std::vector<VirtualDir> GetPartitions();
 
-    VirtualDir GetPartition(XCIPartition partition) const;
     std::shared_ptr<NSP> GetSecurePartitionNSP() const;
-    VirtualDir GetSecurePartition() const;
-    VirtualDir GetNormalPartition() const;
-    VirtualDir GetUpdatePartition() const;
-    VirtualDir GetLogoPartition() const;
+    VirtualDir GetSecurePartition();
+    VirtualDir GetNormalPartition();
+    VirtualDir GetUpdatePartition();
+    VirtualDir GetLogoPartition();
+
+    VirtualFile GetPartitionRaw(XCIPartition partition) const;
+    VirtualFile GetSecurePartitionRaw() const;
+    VirtualFile GetStoragePartition0() const;
+    VirtualFile GetStoragePartition1() const;
+    VirtualFile GetNormalPartitionRaw() const;
+    VirtualFile GetUpdatePartitionRaw() const;
+    VirtualFile GetLogoPartitionRaw() const;
 
     u64 GetProgramTitleID() const;
     u32 GetSystemUpdateVersion();
@@ -123,6 +133,7 @@ private:
     Loader::ResultStatus program_nca_status;
 
     std::vector<VirtualDir> partitions;
+    std::vector<VirtualFile> partitions_raw;
     std::shared_ptr<NSP> secure_partition;
     std::shared_ptr<NCA> program;
     std::vector<std::shared_ptr<NCA>> ncas;

src/core/file_sys/partition_filesystem.cpp

@@ -65,6 +65,9 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
         std::string name(
             reinterpret_cast<const char*>(&file_data[strtab_offset + entry.strtab_offset]));
 
+        offsets.insert_or_assign(name, content_offset + entry.offset);
+        sizes.insert_or_assign(name, entry.size);
+
         pfs_files.emplace_back(std::make_shared<OffsetVfsFile>(
             file, entry.size, content_offset + entry.offset, std::move(name)));
     }
@@ -78,6 +81,14 @@ Loader::ResultStatus PartitionFilesystem::GetStatus() const {
     return status;
 }
 
+std::map<std::string, u64> PartitionFilesystem::GetFileOffsets() const {
+    return offsets;
+}
+
+std::map<std::string, u64> PartitionFilesystem::GetFileSizes() const {
+    return sizes;
+}
+
 std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
     return pfs_files;
 }

src/core/file_sys/partition_filesystem.h

@@ -29,6 +29,9 @@ public:
 
     Loader::ResultStatus GetStatus() const;
 
+    std::map<std::string, u64> GetFileOffsets() const;
+    std::map<std::string, u64> GetFileSizes() const;
+
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
     std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
     std::string GetName() const override;
@@ -80,6 +83,9 @@ private:
     bool is_hfs = false;
     std::size_t content_offset = 0;
 
+    std::map<std::string, u64> offsets;
+    std::map<std::string, u64> sizes;
+
     std::vector<VirtualFile> pfs_files;
 };
 

src/core/hle/service/lm/lm.cpp

@@ -6,10 +6,8 @@
 #include <string>
 
 #include "common/logging/log.h"
-#include "common/scope_exit.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/lm/lm.h"
-#include "core/hle/service/lm/manager.h"
 #include "core/hle/service/service.h"
 #include "core/memory.h"
 
@@ -17,16 +15,65 @@ namespace Service::LM {
 
 class ILogger final : public ServiceFramework<ILogger> {
 public:
-    ILogger(Manager& manager) : ServiceFramework("ILogger"), manager(manager) {
+    ILogger() : ServiceFramework("ILogger") {
         static const FunctionInfo functions[] = {
-            {0, &ILogger::Log, "Log"},
-            {1, &ILogger::SetDestination, "SetDestination"},
+            {0x00000000, &ILogger::Initialize, "Initialize"},
+            {0x00000001, &ILogger::SetDestination, "SetDestination"},
         };
         RegisterHandlers(functions);
     }
 
 private:
-    void Log(Kernel::HLERequestContext& ctx) {
+    struct MessageHeader {
+        enum Flags : u32_le {
+            IsHead = 1,
+            IsTail = 2,
+        };
+        enum Severity : u32_le {
+            Trace,
+            Info,
+            Warning,
+            Error,
+            Critical,
+        };
+
+        u64_le pid;
+        u64_le threadContext;
+        union {
+            BitField<0, 16, Flags> flags;
+            BitField<16, 8, Severity> severity;
+            BitField<24, 8, u32> verbosity;
+        };
+        u32_le payload_size;
+
+        bool IsHeadLog() const {
+            return flags & Flags::IsHead;
+        }
+        bool IsTailLog() const {
+            return flags & Flags::IsTail;
+        }
+    };
+    static_assert(sizeof(MessageHeader) == 0x18, "MessageHeader is incorrect size");
+
+    /// Log field type
+    enum class Field : u8 {
+        Skip = 1,
+        Message = 2,
+        Line = 3,
+        Filename = 4,
+        Function = 5,
+        Module = 6,
+        Thread = 7,
+    };
+
+    /**
+     * ILogger::Initialize service function
+     *  Inputs:
+     *      0: 0x00000000
+     *  Outputs:
+     *      0: ResultCode
+     */
+    void Initialize(Kernel::HLERequestContext& ctx) {
         // This function only succeeds - Get that out of the way
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -38,70 +85,140 @@ private:
         Memory::ReadBlock(addr, &header, sizeof(MessageHeader));
         addr += sizeof(MessageHeader);
 
-        FieldMap fields;
+        if (header.IsHeadLog()) {
+            log_stream.str("");
+            log_stream.clear();
+        }
+
+        // Parse out log metadata
+        u32 line{};
+        std::string module;
+        std::string message;
+        std::string filename;
+        std::string function;
+        std::string thread;
         while (addr < end_addr) {
-            const auto field = static_cast<Field>(Memory::Read8(addr++));
-            const auto length = Memory::Read8(addr++);
+            const Field field{static_cast<Field>(Memory::Read8(addr++))};
+            const std::size_t length{Memory::Read8(addr++)};
 
             if (static_cast<Field>(Memory::Read8(addr)) == Field::Skip) {
                 ++addr;
             }
 
-            SCOPE_EXIT({ addr += length; });
-
-            if (field == Field::Skip) {
-                continue;
+            switch (field) {
+            case Field::Skip:
+                break;
+            case Field::Message:
+                message = Memory::ReadCString(addr, length);
+                break;
+            case Field::Line:
+                line = Memory::Read32(addr);
+                break;
+            case Field::Filename:
+                filename = Memory::ReadCString(addr, length);
+                break;
+            case Field::Function:
+                function = Memory::ReadCString(addr, length);
+                break;
+            case Field::Module:
+                module = Memory::ReadCString(addr, length);
+                break;
+            case Field::Thread:
+                thread = Memory::ReadCString(addr, length);
+                break;
             }
 
-            std::vector<u8> data(length);
-            Memory::ReadBlock(addr, data.data(), length);
-            fields.emplace(field, std::move(data));
+            addr += length;
         }
 
-        manager.Log({header, std::move(fields)});
+        // Empty log - nothing to do here
+        if (log_stream.str().empty() && message.empty()) {
+            return;
+        }
+
+        // Format a nicely printable string out of the log metadata
+        if (!filename.empty()) {
+            log_stream << filename << ':';
+        }
+        if (!module.empty()) {
+            log_stream << module << ':';
+        }
+        if (!function.empty()) {
+            log_stream << function << ':';
+        }
+        if (line) {
+            log_stream << std::to_string(line) << ':';
+        }
+        if (!thread.empty()) {
+            log_stream << thread << ':';
+        }
+        if (log_stream.str().length() > 0 && log_stream.str().back() == ':') {
+            log_stream << ' ';
+        }
+        log_stream << message;
+
+        if (header.IsTailLog()) {
+            switch (header.severity) {
+            case MessageHeader::Severity::Trace:
+                LOG_DEBUG(Debug_Emulated, "{}", log_stream.str());
+                break;
+            case MessageHeader::Severity::Info:
+                LOG_INFO(Debug_Emulated, "{}", log_stream.str());
+                break;
+            case MessageHeader::Severity::Warning:
+                LOG_WARNING(Debug_Emulated, "{}", log_stream.str());
+                break;
+            case MessageHeader::Severity::Error:
+                LOG_ERROR(Debug_Emulated, "{}", log_stream.str());
+                break;
+            case MessageHeader::Severity::Critical:
+                LOG_CRITICAL(Debug_Emulated, "{}", log_stream.str());
+                break;
+            }
+        }
     }
 
+    // This service function is intended to be used as a way to
+    // redirect logging output to different destinations, however,
+    // given we always want to see the logging output, it's sufficient
+    // to do nothing and return success here.
     void SetDestination(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto destination = rp.PopEnum<DestinationFlag>();
-
-        LOG_DEBUG(Service_LM, "called, destination={:08X}", static_cast<u32>(destination));
-
-        manager.SetDestination(destination);
+        LOG_DEBUG(Service_LM, "called");
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 
-    Manager& manager;
+    std::ostringstream log_stream;
 };
 
 class LM final : public ServiceFramework<LM> {
 public:
-    explicit LM(Manager& manager) : ServiceFramework{"lm"}, manager(manager) {
-        // clang-format off
+    explicit LM() : ServiceFramework{"lm"} {
         static const FunctionInfo functions[] = {
-            {0, &LM::OpenLogger, "OpenLogger"},
+            {0x00000000, &LM::OpenLogger, "OpenLogger"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
     }
 
-private:
+    /**
+     * LM::OpenLogger service function
+     *  Inputs:
+     *      0: 0x00000000
+     *  Outputs:
+     *      0: ResultCode
+     */
     void OpenLogger(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_LM, "called");
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILogger>(manager);
+        rb.PushIpcInterface<ILogger>();
     }
-
-    Manager& manager;
 };
 
-void InstallInterfaces(Core::System& system) {
-    std::make_shared<LM>(system.GetLogManager())->InstallAsService(system.ServiceManager());
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<LM>()->InstallAsService(service_manager);
 }
 
 } // namespace Service::LM

src/core/hle/service/lm/lm.h

@@ -4,13 +4,13 @@
 
 #pragma once
 
-namespace Core {
-class System;
+namespace Service::SM {
+class ServiceManager;
 }
 
 namespace Service::LM {
 
 /// Registers all LM services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);
 
 } // namespace Service::LM

src/core/hle/service/lm/manager.cpp

@@ -1,133 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/hle/service/lm/manager.h"
-#include "core/reporter.h"
-
-namespace Service::LM {
-
-std::ostream& operator<<(std::ostream& os, DestinationFlag dest) {
-    std::vector<std::string> array;
-    const auto check_single_flag = [dest, &array](DestinationFlag check, std::string name) {
-        if ((static_cast<u32>(check) & static_cast<u32>(dest)) != 0) {
-            array.emplace_back(std::move(name));
-        }
-    };
-
-    check_single_flag(DestinationFlag::Default, "Default");
-    check_single_flag(DestinationFlag::UART, "UART");
-    check_single_flag(DestinationFlag::UARTSleeping, "UART (Sleeping)");
-
-    os << "[";
-    for (const auto& entry : array) {
-        os << entry << ", ";
-    }
-    return os << "]";
-}
-
-std::ostream& operator<<(std::ostream& os, MessageHeader::Severity severity) {
-    switch (severity) {
-    case MessageHeader::Severity::Trace:
-        return os << "Trace";
-    case MessageHeader::Severity::Info:
-        return os << "Info";
-    case MessageHeader::Severity::Warning:
-        return os << "Warning";
-    case MessageHeader::Severity::Error:
-        return os << "Error";
-    case MessageHeader::Severity::Critical:
-        return os << "Critical";
-    default:
-        return os << fmt::format("{:08X}", static_cast<u32>(severity));
-    }
-}
-
-std::ostream& operator<<(std::ostream& os, Field field) {
-    switch (field) {
-    case Field::Skip:
-        return os << "Skip";
-    case Field::Message:
-        return os << "Message";
-    case Field::Line:
-        return os << "Line";
-    case Field::Filename:
-        return os << "Filename";
-    case Field::Function:
-        return os << "Function";
-    case Field::Module:
-        return os << "Module";
-    case Field::Thread:
-        return os << "Thread";
-    default:
-        return os << fmt::format("{:08X}", static_cast<u32>(field));
-    }
-}
-
-std::string FormatField(Field type, const std::vector<u8>& data) {
-    switch (type) {
-    case Field::Skip:
-        return "";
-    case Field::Line:
-        if (data.size() >= sizeof(u32)) {
-            u32 line;
-            std::memcpy(&line, data.data(), sizeof(u32));
-            return fmt::format("{}", line);
-        }
-        return "[ERROR DECODING LINE NUMBER]";
-    case Field::Message:
-    case Field::Filename:
-    case Field::Function:
-    case Field::Module:
-    case Field::Thread:
-        return Common::StringFromFixedZeroTerminatedBuffer(
-            reinterpret_cast<const char*>(data.data()), data.size());
-    default:
-        UNIMPLEMENTED();
-    }
-}
-
-Manager::Manager(Core::Reporter& reporter) : reporter(reporter) {}
-
-Manager::~Manager() = default;
-
-void Manager::SetEnabled(bool enabled) {
-    this->enabled = enabled;
-}
-
-void Manager::SetDestination(DestinationFlag destination) {
-    this->destination = destination;
-}
-
-void Manager::Log(LogMessage message) {
-    if (message.header.IsHeadLog()) {
-        InitializeLog();
-    }
-
-    current_log.emplace_back(std::move(message));
-
-    if (current_log.back().header.IsTailLog()) {
-        FinalizeLog();
-    }
-}
-
-void Manager::Flush() {
-    FinalizeLog();
-}
-
-void Manager::InitializeLog() {
-    current_log.clear();
-
-    LOG_INFO(Service_LM, "Initialized new log session");
-}
-
-void Manager::FinalizeLog() {
-    reporter.SaveLogReport(static_cast<u32>(destination), std::move(current_log));
-
-    LOG_INFO(Service_LM, "Finalized current log session");
-}
-
-} // namespace Service::LM

src/core/hle/service/lm/manager.h

@@ -1,106 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <map>
-#include <ostream>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-
-namespace Core {
-class Reporter;
-}
-
-namespace Service::LM {
-
-enum class DestinationFlag : u32 {
-    Default = 1,
-    UART = 2,
-    UARTSleeping = 4,
-
-    All = 0xFFFF,
-};
-
-struct MessageHeader {
-    enum Flags : u32_le {
-        IsHead = 1,
-        IsTail = 2,
-    };
-    enum Severity : u32_le {
-        Trace,
-        Info,
-        Warning,
-        Error,
-        Critical,
-    };
-
-    u64_le pid;
-    u64_le thread_context;
-    union {
-        BitField<0, 16, Flags> flags;
-        BitField<16, 8, Severity> severity;
-        BitField<24, 8, u32> verbosity;
-    };
-    u32_le payload_size;
-
-    bool IsHeadLog() const {
-        return flags & IsHead;
-    }
-    bool IsTailLog() const {
-        return flags & IsTail;
-    }
-};
-static_assert(sizeof(MessageHeader) == 0x18, "MessageHeader is incorrect size");
-
-enum class Field : u8 {
-    Skip = 1,
-    Message = 2,
-    Line = 3,
-    Filename = 4,
-    Function = 5,
-    Module = 6,
-    Thread = 7,
-};
-
-std::ostream& operator<<(std::ostream& os, DestinationFlag dest);
-std::ostream& operator<<(std::ostream& os, MessageHeader::Severity severity);
-std::ostream& operator<<(std::ostream& os, Field field);
-
-using FieldMap = std::map<Field, std::vector<u8>>;
-
-struct LogMessage {
-    MessageHeader header;
-    FieldMap fields;
-};
-
-std::string FormatField(Field type, const std::vector<u8>& data);
-
-class Manager {
-public:
-    explicit Manager(Core::Reporter& reporter);
-    ~Manager();
-
-    void SetEnabled(bool enabled);
-    void SetDestination(DestinationFlag destination);
-
-    void Log(LogMessage message);
-
-    void Flush();
-
-private:
-    void InitializeLog();
-    void FinalizeLog();
-
-    bool enabled = true;
-    DestinationFlag destination = DestinationFlag::All;
-
-    std::vector<LogMessage> current_log;
-
-    Core::Reporter& reporter;
-};
-
-} // namespace Service::LM

src/core/hle/service/service.cpp

@@ -226,7 +226,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
     LBL::InstallInterfaces(*sm);
     LDN::InstallInterfaces(*sm);
     LDR::InstallInterfaces(*sm, system);
-    LM::InstallInterfaces(system);
+    LM::InstallInterfaces(*sm);
     Migration::InstallInterfaces(*sm);
     Mii::InstallInterfaces(*sm);
     MM::InstallInterfaces(*sm);

src/core/reporter.cpp

@@ -7,7 +7,6 @@
 
 #include <fmt/chrono.h>
 #include <fmt/format.h>
-#include <fmt/ostream.h>
 #include <json.hpp>
 
 #include "common/file_util.h"
@@ -18,7 +17,6 @@
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
-#include "core/hle/service/lm/manager.h"
 #include "core/reporter.h"
 #include "core/settings.h"
 
@@ -356,55 +354,6 @@ void Reporter::SaveErrorReport(u64 title_id, ResultCode result,
     SaveToFile(std::move(out), GetPath("error_report", title_id, timestamp));
 }
 
-void Reporter::SaveLogReport(u32 destination, std::vector<Service::LM::LogMessage> messages) const {
-    if (!IsReportingEnabled()) {
-        return;
-    }
-
-    const auto timestamp = GetTimestamp();
-    json out;
-
-    out["yuzu_version"] = GetYuzuVersionData();
-    out["report_common"] =
-        GetReportCommonData(system.CurrentProcess()->GetTitleID(), RESULT_SUCCESS, timestamp);
-
-    out["log_destination"] =
-        fmt::format("{}", static_cast<Service::LM::DestinationFlag>(destination));
-
-    auto json_messages = json::array();
-    std::transform(messages.begin(), messages.end(), std::back_inserter(json_messages),
-                   [](const Service::LM::LogMessage& message) {
-                       json out;
-                       out["is_head"] = fmt::format("{}", message.header.IsHeadLog());
-                       out["is_tail"] = fmt::format("{}", message.header.IsTailLog());
-                       out["pid"] = fmt::format("{:016X}", message.header.pid);
-                       out["thread_context"] =
-                           fmt::format("{:016X}", message.header.thread_context);
-                       out["payload_size"] = fmt::format("{:016X}", message.header.payload_size);
-                       out["flags"] = fmt::format("{:04X}", message.header.flags.Value());
-                       out["severity"] = fmt::format("{}", message.header.severity.Value());
-                       out["verbosity"] = fmt::format("{:02X}", message.header.verbosity);
-
-                       auto fields = json::array();
-                       std::transform(message.fields.begin(), message.fields.end(),
-                                      std::back_inserter(fields), [](const auto& kv) {
-                                          json out;
-                                          out["type"] = fmt::format("{}", kv.first);
-                                          out["data"] =
-                                              Service::LM::FormatField(kv.first, kv.second);
-                                          return out;
-                                      });
-
-                       out["fields"] = std::move(fields);
-                       return out;
-                   });
-
-    out["log_messages"] = std::move(json_messages);
-
-    SaveToFile(std::move(out),
-               GetPath("log_report", system.CurrentProcess()->GetTitleID(), timestamp));
-}
-
 void Reporter::SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
                                           std::string log_message) const {
     if (!IsReportingEnabled())

src/core/reporter.h

@@ -20,10 +20,6 @@ namespace Service::FileSystem {
 enum class LogMode : u32;
 }
 
-namespace Service::LM {
-struct LogMessage;
-} // namespace Service::LM
-
 namespace Core {
 
 class System;
@@ -33,22 +29,18 @@ public:
     explicit Reporter(System& system);
     ~Reporter();
 
-    // Used by fatal services
     void SaveCrashReport(u64 title_id, ResultCode result, u64 set_flags, u64 entry_point, u64 sp,
                          u64 pc, u64 pstate, u64 afsr0, u64 afsr1, u64 esr, u64 far,
                          const std::array<u64, 31>& registers, const std::array<u64, 32>& backtrace,
                          u32 backtrace_size, const std::string& arch, u32 unk10) const;
 
-    // Used by syscall svcBreak
     void SaveSvcBreakReport(u32 type, bool signal_debugger, u64 info1, u64 info2,
                             std::optional<std::vector<u8>> resolved_buffer = {}) const;
 
-    // Used by HLE service handler
     void SaveUnimplementedFunctionReport(Kernel::HLERequestContext& ctx, u32 command_id,
                                          const std::string& name,
                                          const std::string& service_name) const;
 
-    // Used by stub applet implementation
     void SaveUnimplementedAppletReport(u32 applet_id, u32 common_args_version, u32 library_version,
                                        u32 theme_color, bool startup_sound, u64 system_tick,
                                        std::vector<std::vector<u8>> normal_channel,
@@ -63,7 +55,6 @@ public:
     void SavePlayReport(PlayReportType type, u64 title_id, std::vector<std::vector<u8>> data,
                         std::optional<u64> process_id = {}, std::optional<u128> user_id = {}) const;
 
-    // Used by error applet
     void SaveErrorReport(u64 title_id, ResultCode result,
                          std::optional<std::string> custom_text_main = {},
                          std::optional<std::string> custom_text_detail = {}) const;
@@ -71,11 +62,6 @@ public:
     void SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
                                     std::string log_message) const;
 
-    // Used by lm services
-    void SaveLogReport(u32 destination, std::vector<Service::LM::LogMessage> messages) const;
-
-    // Can be used anywhere to generate a backtrace and general info report at any point during
-    // execution. Not intended to be used for anything other than debugging or testing.
     void SaveUserReport() const;
 
 private: