Added fallback to surface swap in case unregister fails

Port citra-emu/citra#4930: "Pause when in background"

.ci/scripts/windows/upload.ps1

@@ -5,6 +5,8 @@ $RELEASE_DIST = "yuzu-windows-msvc"
 $MSVC_BUILD_ZIP = "yuzu-windows-msvc-$GITDATE-$GITREV.zip" -replace " ", ""
 $MSVC_BUILD_PDB = "yuzu-windows-msvc-$GITDATE-$GITREV-debugsymbols.zip" -replace " ", ""
 $MSVC_SEVENZIP = "yuzu-windows-msvc-$GITDATE-$GITREV.7z" -replace " ", ""
+$MSVC_TAR = "yuzu-windows-msvc-$GITDATE-$GITREV.tar" -replace " ", ""
+$MSVC_TARXZ = "yuzu-windows-msvc-$GITDATE-$GITREV.tar.xz" -replace " ", ""
 
 $env:BUILD_ZIP = $MSVC_BUILD_ZIP
 $env:BUILD_SYMBOLS = $MSVC_BUILD_PDB
@@ -28,5 +30,9 @@ Copy-Item .\README.md -Destination $RELEASE_DIST
 7z a -tzip $MSVC_BUILD_ZIP $RELEASE_DIST\*
 7z a $MSVC_SEVENZIP $RELEASE_DIST
 
+7z a -r -ttar $MSVC_TAR $RELEASE_DIST
+7z a -r -txz $MSVC_TARXZ $MSVC_TAR
+
 Get-ChildItem . -Filter "*.zip" | Copy-Item -destination "artifacts"
-Get-ChildItem . -Filter "*.7z" | Copy-Item -destination "artifacts"
+Get-ChildItem . -Filter "*.7z" | Copy-Item -destination "artifacts"
+Get-ChildItem . -Filter "*.tar.xz" | Copy-Item -destination "artifacts"

.ci/templates/build-mock.yml

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

.ci/templates/merge-private.yml

@@ -31,17 +31,7 @@ jobs:
       needSubmodules: 'true'
   - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
     displayName: 'Apply Git Configuration'
-  - script: git tag -a $(BuildName)-$(Build.BuildId) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName)"
-    displayName: 'Tag Source'
   - script: git remote add other $(GitRepoPushChangesURL)
     displayName: 'Register Repository'
-  - script: git push --follow-tags --force other HEAD:$(GitPushBranch)
+  - script: git push --force other HEAD:$(GitPushBranch)
     displayName: 'Update Code'
-  - script: git rev-list -n 1 $(BuildName)-$(Build.BuildId) > $(Build.ArtifactStagingDirectory)/tag-commit.sha
-    displayName: 'Calculate Release Point'
-  - task: PublishPipelineArtifact@1
-    displayName: 'Upload Release Point'
-    inputs:
-      targetPath: '$(Build.ArtifactStagingDirectory)/tag-commit.sha'
-      artifact: 'yuzu-$(BuildName)-release-point'
-      replaceExistingArchive: true

.ci/templates/merge.yml

@@ -30,17 +30,7 @@ jobs:
       needSubmodules: 'true'
   - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
     displayName: 'Apply Git Configuration'
-  - script: git tag -a $(BuildName)-$(Build.BuildId) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName)"
-    displayName: 'Tag Source'
   - script: git remote add other $(GitRepoPushChangesURL)
     displayName: 'Register Repository'
-  - script: git push --follow-tags --force other HEAD:$(GitPushBranch)
+  - script: git push --force other HEAD:$(GitPushBranch)
     displayName: 'Update Code'
-  - script: git rev-list -n 1 $(BuildName)-$(Build.BuildId) > $(Build.ArtifactStagingDirectory)/tag-commit.sha
-    displayName: 'Calculate Release Point'
-  - task: PublishPipelineArtifact@1
-    displayName: 'Upload Release Point'
-    inputs:
-      targetPath: '$(Build.ArtifactStagingDirectory)/tag-commit.sha'
-      artifact: 'yuzu-$(BuildName)-release-point'
-      replaceExistingArchive: true

.ci/templates/release-github.yml

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

.ci/templates/release-private-tag.yml

@@ -0,0 +1,9 @@
+steps:
+  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
+    displayName: 'Apply Git Configuration'
+  - script: git tag -a $(BuildName)-$(DisplayPrefix)-$(DisplayVersion) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName) $(DisplayPrefix)-$(DisplayVersion)"
+    displayName: 'Tag Source'
+  - script: git remote add other $(GitRepoPushChangesURL)
+    displayName: 'Register Repository'
+  - script: git push other $(BuildName)-$(DisplayPrefix)-$(DisplayVersion)
+    displayName: 'Update Code'

.ci/yuzu-mainline-step2.yml

@@ -57,12 +57,12 @@ stages:
         cache: 'true'
         version: $(DisplayVersion)
 - stage: release
-  displayName: 'Release'
+  displayName: 'release'
   dependsOn:
   - build
   - build_win
   jobs:
   - job: github
-    displayName: 'GitHub Release'
+    displayName: 'github'
     steps:
     - template: ./templates/release-github.yml

.ci/yuzu-patreon-step2.yml

@@ -32,3 +32,11 @@ stages:
         artifactSource: 'false'
         cache: $(parameters.cache)
         version: $(DisplayVersion)
+- stage: release
+  displayName: 'release'
+  dependsOn: build
+  jobs:
+    - job: release
+      displayName: 'source'
+      steps:
+        - template: ./templates/release-private-tag.yml

CONTRIBUTING.md

@@ -1 +1 @@
-**The Contributor's Guide has moved to [the Citra wiki](https://github.com/citra-emu/citra/wiki/Contributing).**
+**The Contributor's Guide has moved to [the Yuzu wiki](https://github.com/yuzu-emu/yuzu/wiki/Contributing).**

dist/yuzu.svg

@@ -1,86 +1 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   version="1.1"
-   id="svg815"
-   xml:space="preserve"
-   width="72"
-   height="80"
-   viewBox="0 0 72 80"
-   sodipodi:docname="center-logo-v3.svg"
-   inkscape:version="0.92.2 (5c3e80d, 2017-08-06)"><metadata
-     id="metadata821"><rdf:RDF><cc:Work
-         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
-     id="defs819"><clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath831"><path
-         d="M 0,60 H 54 V 0 H 0 Z"
-         id="path829"
-         inkscape:connector-curvature="0" /></clipPath><clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath843"><path
-         d="M 0,60 H 54 V 0 H 0 Z"
-         id="path841"
-         inkscape:connector-curvature="0" /></clipPath><clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath855"><path
-         d="M 0,60 H 54 V 0 H 0 Z"
-         id="path853"
-         inkscape:connector-curvature="0" /></clipPath><clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath867"><path
-         d="M 0,60 H 54 V 0 H 0 Z"
-         id="path865"
-         inkscape:connector-curvature="0" /></clipPath></defs><sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1920"
-     inkscape:window-height="1017"
-     id="namedview817"
-     showgrid="false"
-     inkscape:zoom="7.4953319"
-     inkscape:cx="28.177201"
-     inkscape:cy="44.348084"
-     inkscape:window-x="-8"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="g823" /><g
-     id="g823"
-     inkscape:groupmode="layer"
-     inkscape:label="center-logo-v3"
-     transform="matrix(1.3333333,0,0,-1.3333333,0,80)"><g
-       id="right"
-       inkscape:label="#g825"><g
-         id="g827"
-         clip-path="url(#clipPath831)"><g
-           id="g833"
-           transform="translate(30,48)"><path
-             d="m 0,0 v -48 c 13.255,0 24,10.745 24,24 C 24,-10.745 13.255,0 0,0 M 3,-3.214 C 13.163,-4.674 21,-13.439 21,-24 21,-34.561 13.163,-43.326 3,-44.786 v 41.572"
-             style="fill:#ff3c28;fill-opacity:1;fill-rule:nonzero;stroke:none"
-             id="path835"
-             inkscape:connector-curvature="0" /></g></g></g><g
-       id="left"
-       inkscape:label="#g837"><g
-         id="g839"
-         clip-path="url(#clipPath843)"><g
-           id="g845"
-           transform="translate(24,60)"><path
-             d="m 0,0 c -13.255,0 -24,-10.745 -24,-24 0,-13.255 10.745,-24 24,-24 z m -3,-3.214 v -41.572 c -10.163,1.46 -18,10.225 -18,20.786 0,10.561 7.837,19.326 18,20.786"
-             style="fill:#0ab9e6;fill-opacity:1;fill-rule:nonzero;stroke:none"
-             id="path847"
-             inkscape:connector-curvature="0" /></g></g></g></g></svg>
+<svg id="svg815" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 614.4 682.67"><defs><style>.cls-1{fill:none;}.cls-2{clip-path:url(#clip-path);}.cls-3{fill:#ff3c28;}.cls-4{fill:#0ab9e6;}</style><clipPath id="clip-path"><rect class="cls-1" x="-43" y="-46.67" width="699.6" height="777.33"/></clipPath></defs><title>Artboard 1</title><g id="g823"><g id="right"><g class="cls-2"><g id="g827"><g id="g833"><path id="path835" class="cls-3" d="M340.81,138V682.08c150.26,0,272.06-121.81,272.06-272.06S491.07,138,340.81,138M394,197.55a219.06,219.06,0,0,1,0,424.94V197.55"/></g></g></g></g><g id="left"><g class="cls-2"><g id="g839"><g id="g845"><path id="path847" class="cls-4" d="M272.79,1.92C122.53,1.92.73,123.73.73,274s121.8,272.07,272.06,272.07ZM219.65,61.51v425A219,219,0,0,1,118,119.18,217.51,217.51,0,0,1,219.65,61.51"/></g></g></g></g></g></svg>

src/common/alignment.h

@@ -51,7 +51,17 @@ public:
     using reference = T&;
     using const_reference = const T&;
 
+    using propagate_on_container_copy_assignment = std::true_type;
+    using propagate_on_container_move_assignment = std::true_type;
+    using propagate_on_container_swap = std::true_type;
+    using is_always_equal = std::true_type;
+
 public:
+    constexpr AlignmentAllocator() noexcept = default;
+
+    template <typename T2>
+    constexpr AlignmentAllocator(const AlignmentAllocator<T2, Align>&) noexcept {}
+
     pointer address(reference r) noexcept {
         return std::addressof(r);
     }

src/core/CMakeLists.txt

@@ -335,6 +335,8 @@ 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,6 +35,7 @@
 #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"
@@ -111,7 +112,8 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 }
 struct System::Impl {
     explicit Impl(System& system)
-        : kernel{system}, cpu_core_manager{system}, applet_manager{system}, reporter{system} {}
+        : kernel{system}, fs_controller{system}, cpu_core_manager{system},
+          applet_manager{system}, reporter{system} {}
 
     Cpu& CurrentCpuCore() {
         return cpu_core_manager.GetCurrentCore();
@@ -249,6 +251,8 @@ 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;
 
@@ -337,6 +341,7 @@ 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;
     std::array<u8, 0x20> build_id{};
@@ -347,8 +352,9 @@ struct System::Impl {
     /// APM (Performance) services
     Service::APM::Controller apm_controller{core_timing};
 
-    /// Glue services
+    /// Service State
     Service::Glue::ARPManager arp_manager;
+    Service::LM::Manager lm_manager{reporter};
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -356,8 +362,6 @@ 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 = "";
 
@@ -633,6 +637,14 @@ 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;
 }
@@ -641,11 +653,11 @@ bool System::GetExitLock() const {
     return impl->exit_lock;
 }
 
-void System::SetCurrentProcessBuildID(std::array<u8, 32> id) {
+void System::SetCurrentProcessBuildID(const CurrentBuildProcessID& id) {
     impl->build_id = id;
 }
 
-const std::array<u8, 32>& System::GetCurrentProcessBuildID() const {
+const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
     return impl->build_id;
 }
 

src/core/core.h

@@ -8,7 +8,6 @@
 #include <memory>
 #include <string>
 
-#include <map>
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
@@ -58,6 +57,10 @@ namespace Glue {
 class ARPManager;
 }
 
+namespace LM {
+class Manager;
+} // namespace LM
+
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -98,6 +101,8 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 
 class System {
 public:
+    using CurrentBuildProcessID = std::array<u8, 0x20>;
+
     System(const System&) = delete;
     System& operator=(const System&) = delete;
 
@@ -326,13 +331,17 @@ public:
 
     const Service::APM::Controller& GetAPMController() const;
 
+    Service::LM::Manager& GetLogManager();
+
+    const Service::LM::Manager& GetLogManager() const;
+
     void SetExitLock(bool locked);
 
     bool GetExitLock() const;
 
-    void SetCurrentProcessBuildID(std::array<u8, 0x20> id);
+    void SetCurrentProcessBuildID(const CurrentBuildProcessID& id);
 
-    const std::array<u8, 0x20>& GetCurrentProcessBuildID() const;
+    const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
 
 private:
     System();
@@ -357,8 +366,4 @@ private:
     static System s_instance;
 };
 
-inline Kernel::Process* CurrentProcess() {
-    return System::GetInstance().CurrentProcess();
-}
-
 } // namespace Core

src/core/file_sys/romfs_factory.cpp

@@ -35,11 +35,11 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
     this->update_raw = std::move(update_raw);
 }
 
-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() const {
+ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
     if (!updatable)
         return MakeResult<VirtualFile>(file);
 
-    const PatchManager patch_manager(Core::CurrentProcess()->GetTitleID());
+    const PatchManager patch_manager(current_process_title_id);
     return MakeResult<VirtualFile>(
         patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }

src/core/file_sys/romfs_factory.h

@@ -33,7 +33,7 @@ public:
     ~RomFSFactory();
 
     void SetPackedUpdate(VirtualFile update_raw);
-    ResultVal<VirtualFile> OpenCurrentProcess() const;
+    ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
     ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type) const;
 
 private:

src/core/file_sys/savedata_factory.cpp

@@ -127,8 +127,9 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
                                          u128 user_id, u64 save_id) {
     // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
     // be interpreted as the title id of the current process.
-    if (type == SaveDataType::SaveData && title_id == 0)
-        title_id = Core::CurrentProcess()->GetTitleID();
+    if (type == SaveDataType::SaveData && title_id == 0) {
+        title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
+    }
 
     std::string out = GetSaveDataSpaceIdPath(space);
 

src/core/gdbstub/gdbstub.cpp

@@ -641,7 +641,8 @@ static void HandleQuery() {
                        strlen("Xfer:features:read:target.xml:")) == 0) {
         SendReply(target_xml);
     } else if (strncmp(query, "Offsets", strlen("Offsets")) == 0) {
-        const VAddr base_address = Core::CurrentProcess()->VMManager().GetCodeRegionBaseAddress();
+        const VAddr base_address =
+            Core::System::GetInstance().CurrentProcess()->VMManager().GetCodeRegionBaseAddress();
         std::string buffer = fmt::format("TextSeg={:0x}", base_address);
         SendReply(buffer.c_str());
     } else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {

src/core/hle/kernel/handle_table.cpp

@@ -103,7 +103,7 @@ SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
     if (handle == CurrentThread) {
         return GetCurrentThread();
     } else if (handle == CurrentProcess) {
-        return Core::CurrentProcess();
+        return Core::System::GetInstance().CurrentProcess();
     }
 
     if (!IsValid(handle)) {

src/core/hle/service/am/am.cpp

@@ -1142,12 +1142,12 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
     if (kind == LaunchParameterKind::ApplicationSpecific && !launch_popped_application_specific) {
         const auto backend = BCAT::CreateBackendFromSettings(
             [this](u64 tid) { return system.GetFileSystemController().GetBCATDirectory(tid); });
-        const auto build_id_full = Core::System::GetInstance().GetCurrentProcessBuildID();
+        const auto build_id_full = system.GetCurrentProcessBuildID();
         u64 build_id{};
         std::memcpy(&build_id, build_id_full.data(), sizeof(u64));
 
         const auto data =
-            backend->GetLaunchParameter({Core::CurrentProcess()->GetTitleID(), build_id});
+            backend->GetLaunchParameter({system.CurrentProcess()->GetTitleID(), build_id});
 
         if (data.has_value()) {
             IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -1200,7 +1200,7 @@ void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_AM, "called, uid={:016X}{:016X}", user_id[1], user_id[0]);
 
     FileSys::SaveDataDescriptor descriptor{};
-    descriptor.title_id = Core::CurrentProcess()->GetTitleID();
+    descriptor.title_id = system.CurrentProcess()->GetTitleID();
     descriptor.user_id = user_id;
     descriptor.type = FileSys::SaveDataType::SaveData;
     const auto res = system.GetFileSystemController().CreateSaveData(

src/core/hle/service/bcat/backend/backend.cpp

@@ -10,13 +10,14 @@
 
 namespace Service::BCAT {
 
-ProgressServiceBackend::ProgressServiceBackend(std::string event_name) : impl{} {
+ProgressServiceBackend::ProgressServiceBackend(std::string_view event_name) {
     auto& kernel{Core::System::GetInstance().Kernel()};
     event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::Automatic, "ProgressServiceBackend:UpdateEvent:" + event_name);
+        kernel, Kernel::ResetType::Automatic,
+        std::string("ProgressServiceBackend:UpdateEvent:").append(event_name));
 }
 
-Kernel::SharedPtr<Kernel::ReadableEvent> ProgressServiceBackend::GetEvent() {
+Kernel::SharedPtr<Kernel::ReadableEvent> ProgressServiceBackend::GetEvent() const {
     return event.readable;
 }
 
@@ -95,7 +96,7 @@ Backend::Backend(DirectoryGetter getter) : dir_getter(std::move(getter)) {}
 
 Backend::~Backend() = default;
 
-NullBackend::NullBackend(const DirectoryGetter& getter) : Backend(std::move(getter)) {}
+NullBackend::NullBackend(DirectoryGetter getter) : Backend(std::move(getter)) {}
 
 NullBackend::~NullBackend() = default;
 

src/core/hle/service/bcat/backend/backend.h

@@ -6,6 +6,9 @@
 
 #include <functional>
 #include <optional>
+#include <string>
+#include <string_view>
+
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/readable_event.h"
@@ -85,14 +88,14 @@ public:
     void FinishDownload(ResultCode result);
 
 private:
-    explicit ProgressServiceBackend(std::string event_name);
+    explicit ProgressServiceBackend(std::string_view event_name);
 
-    Kernel::SharedPtr<Kernel::ReadableEvent> GetEvent();
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetEvent() const;
     DeliveryCacheProgressImpl& GetImpl();
 
     void SignalUpdate() const;
 
-    DeliveryCacheProgressImpl impl;
+    DeliveryCacheProgressImpl impl{};
     Kernel::EventPair event;
     bool need_hle_lock = false;
 };
@@ -128,7 +131,7 @@ protected:
 // A backend of BCAT that provides no operation.
 class NullBackend : public Backend {
 public:
-    explicit NullBackend(const DirectoryGetter& getter);
+    explicit NullBackend(DirectoryGetter getter);
     ~NullBackend() override;
 
     bool Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) override;

src/core/hle/service/bcat/backend/boxcat.cpp

@@ -495,7 +495,8 @@ Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global,
         }
 
         return StatusResult::Success;
-    } catch (const nlohmann::json::parse_error& e) {
+    } catch (const nlohmann::json::parse_error& error) {
+        LOG_ERROR(Service_BCAT, "{}", error.what());
         return StatusResult::ParseError;
     }
 }

src/core/hle/service/bcat/bcat.cpp

@@ -6,8 +6,9 @@
 
 namespace Service::BCAT {
 
-BCAT::BCAT(std::shared_ptr<Module> module, FileSystem::FileSystemController& fsc, const char* name)
-    : Module::Interface(std::move(module), fsc, name) {
+BCAT::BCAT(Core::System& system, std::shared_ptr<Module> module,
+           FileSystem::FileSystemController& fsc, const char* name)
+    : Interface(system, std::move(module), fsc, name) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &BCAT::CreateBcatService, "CreateBcatService"},

src/core/hle/service/bcat/bcat.h

@@ -6,12 +6,16 @@
 
 #include "core/hle/service/bcat/module.h"
 
+namespace Core {
+class System;
+}
+
 namespace Service::BCAT {
 
 class BCAT final : public Module::Interface {
 public:
-    explicit BCAT(std::shared_ptr<Module> module, FileSystem::FileSystemController& fsc,
-                  const char* name);
+    explicit BCAT(Core::System& system, std::shared_ptr<Module> module,
+                  FileSystem::FileSystemController& fsc, const char* name);
     ~BCAT() override;
 };
 

src/core/hle/service/bcat/module.cpp

@@ -35,8 +35,7 @@ using BCATDigest = std::array<u8, 0x10>;
 
 namespace {
 
-u64 GetCurrentBuildID() {
-    const auto& id = Core::System::GetInstance().GetCurrentProcessBuildID();
+u64 GetCurrentBuildID(const Core::System::CurrentBuildProcessID& id) {
     u64 out{};
     std::memcpy(&out, id.data(), sizeof(u64));
     return out;
@@ -125,7 +124,8 @@ private:
 
 class IBcatService final : public ServiceFramework<IBcatService> {
 public:
-    IBcatService(Backend& backend) : ServiceFramework("IBcatService"), backend(backend) {
+    explicit IBcatService(Core::System& system_, Backend& backend_)
+        : ServiceFramework("IBcatService"), system{system_}, backend{backend_} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {10100, &IBcatService::RequestSyncDeliveryCache, "RequestSyncDeliveryCache"},
@@ -163,7 +163,8 @@ private:
     void RequestSyncDeliveryCache(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_BCAT, "called");
 
-        backend.Synchronize({Core::CurrentProcess()->GetTitleID(), GetCurrentBuildID()},
+        backend.Synchronize({system.CurrentProcess()->GetTitleID(),
+                             GetCurrentBuildID(system.GetCurrentProcessBuildID())},
                             progress.at(static_cast<std::size_t>(SyncType::Normal)));
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -179,7 +180,8 @@ private:
 
         LOG_DEBUG(Service_BCAT, "called, name={}", name);
 
-        backend.SynchronizeDirectory({Core::CurrentProcess()->GetTitleID(), GetCurrentBuildID()},
+        backend.SynchronizeDirectory({system.CurrentProcess()->GetTitleID(),
+                                      GetCurrentBuildID(system.GetCurrentProcessBuildID())},
                                      name,
                                      progress.at(static_cast<std::size_t>(SyncType::Directory)));
 
@@ -244,6 +246,7 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
+    Core::System& system;
     Backend& backend;
 
     std::array<ProgressServiceBackend, static_cast<std::size_t>(SyncType::Count)> progress{
@@ -257,7 +260,7 @@ void Module::Interface::CreateBcatService(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IBcatService>(*backend);
+    rb.PushIpcInterface<IBcatService>(system, *backend);
 }
 
 class IDeliveryCacheFileService final : public ServiceFramework<IDeliveryCacheFileService> {
@@ -451,7 +454,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(write_size * sizeof(DeliveryCacheDirectoryEntry));
+        rb.Push(static_cast<u32>(write_size * sizeof(DeliveryCacheDirectoryEntry)));
     }
 
     void GetCount(Kernel::HLERequestContext& ctx) {
@@ -468,7 +471,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(files.size());
+        rb.Push(static_cast<u32>(files.size()));
     }
 
     FileSys::VirtualDir root;
@@ -525,7 +528,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(size);
+        rb.Push(static_cast<u32>(size));
     }
 
     FileSys::VirtualDir root;
@@ -539,7 +542,7 @@ void Module::Interface::CreateDeliveryCacheStorageService(Kernel::HLERequestCont
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IDeliveryCacheStorageService>(
-        fsc.GetBCATDirectory(Core::CurrentProcess()->GetTitleID()));
+        fsc.GetBCATDirectory(system.CurrentProcess()->GetTitleID()));
 }
 
 void Module::Interface::CreateDeliveryCacheStorageServiceWithApplicationId(
@@ -565,22 +568,23 @@ std::unique_ptr<Backend> CreateBackendFromSettings(DirectoryGetter getter) {
     return std::make_unique<NullBackend>(std::move(getter));
 }
 
-Module::Interface::Interface(std::shared_ptr<Module> module, FileSystem::FileSystemController& fsc,
-                             const char* name)
-    : ServiceFramework(name), fsc(fsc), module(std::move(module)),
-      backend(CreateBackendFromSettings([&fsc](u64 tid) { return fsc.GetBCATDirectory(tid); })) {}
+Module::Interface::Interface(Core::System& system_, std::shared_ptr<Module> module_,
+                             FileSystem::FileSystemController& fsc_, const char* name)
+    : ServiceFramework(name), fsc{fsc_}, module{std::move(module_)},
+      backend{CreateBackendFromSettings([&fsc_](u64 tid) { return fsc_.GetBCATDirectory(tid); })},
+      system{system_} {}
 
 Module::Interface::~Interface() = default;
 
 void InstallInterfaces(Core::System& system) {
     auto module = std::make_shared<Module>();
-    std::make_shared<BCAT>(module, system.GetFileSystemController(), "bcat:a")
+    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:a")
         ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(module, system.GetFileSystemController(), "bcat:m")
+    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:m")
         ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(module, system.GetFileSystemController(), "bcat:u")
+    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:u")
         ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(module, system.GetFileSystemController(), "bcat:s")
+    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:s")
         ->InstallAsService(system.ServiceManager());
 }
 

src/core/hle/service/bcat/module.h

@@ -6,6 +6,10 @@
 
 #include "core/hle/service/service.h"
 
+namespace Core {
+class System;
+}
+
 namespace Service {
 
 namespace FileSystem {
@@ -20,8 +24,8 @@ class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
-        explicit Interface(std::shared_ptr<Module> module, FileSystem::FileSystemController& fsc,
-                           const char* name);
+        explicit Interface(Core::System& system_, std::shared_ptr<Module> module_,
+                           FileSystem::FileSystemController& fsc_, const char* name);
         ~Interface() override;
 
         void CreateBcatService(Kernel::HLERequestContext& ctx);
@@ -33,6 +37,9 @@ public:
 
         std::shared_ptr<Module> module;
         std::unique_ptr<Backend> backend;
+
+    private:
+        Core::System& system;
     };
 };
 

src/core/hle/service/es/es.cpp

@@ -128,7 +128,7 @@ private:
     void CountCommonTicket(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_ETicket, "called");
 
-        const auto count = keys.GetCommonTickets().size();
+        const u32 count = static_cast<u32>(keys.GetCommonTickets().size());
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
@@ -138,7 +138,7 @@ private:
     void CountPersonalizedTicket(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_ETicket, "called");
 
-        const auto count = keys.GetPersonalizedTickets().size();
+        const u32 count = static_cast<u32>(keys.GetPersonalizedTickets().size());
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
@@ -150,7 +150,7 @@ private:
         if (keys.GetCommonTickets().empty())
             out_entries = 0;
         else
-            out_entries = ctx.GetWriteBufferSize() / sizeof(u128);
+            out_entries = static_cast<u32>(ctx.GetWriteBufferSize() / sizeof(u128));
 
         LOG_DEBUG(Service_ETicket, "called, entries={:016X}", out_entries);
 
@@ -160,7 +160,7 @@ private:
         std::transform(tickets.begin(), tickets.end(), std::back_inserter(ids),
                        [](const auto& pair) { return pair.first; });
 
-        out_entries = std::min<u32>(ids.size(), out_entries);
+        out_entries = static_cast<u32>(std::min<std::size_t>(ids.size(), out_entries));
         ctx.WriteBuffer(ids.data(), out_entries * sizeof(u128));
 
         IPC::ResponseBuilder rb{ctx, 3};
@@ -173,7 +173,7 @@ private:
         if (keys.GetPersonalizedTickets().empty())
             out_entries = 0;
         else
-            out_entries = ctx.GetWriteBufferSize() / sizeof(u128);
+            out_entries = static_cast<u32>(ctx.GetWriteBufferSize() / sizeof(u128));
 
         LOG_DEBUG(Service_ETicket, "called, entries={:016X}", out_entries);
 
@@ -183,7 +183,7 @@ private:
         std::transform(tickets.begin(), tickets.end(), std::back_inserter(ids),
                        [](const auto& pair) { return pair.first; });
 
-        out_entries = std::min<u32>(ids.size(), out_entries);
+        out_entries = static_cast<u32>(std::min<std::size_t>(ids.size(), out_entries));
         ctx.WriteBuffer(ids.data(), out_entries * sizeof(u128));
 
         IPC::ResponseBuilder rb{ctx, 3};

src/core/hle/service/fatal/fatal.cpp

@@ -66,7 +66,7 @@ enum class FatalType : u32 {
 
 static void GenerateErrorReport(Core::System& system, ResultCode error_code,
                                 const FatalInfo& info) {
-    const auto title_id = Core::CurrentProcess()->GetTitleID();
+    const auto title_id = system.CurrentProcess()->GetTitleID();
     std::string crash_report = fmt::format(
         "Yuzu {}-{} crash report\n"
         "Title ID:                        {:016x}\n"

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

@@ -241,7 +241,7 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
     return FileSys::ERROR_PATH_NOT_FOUND;
 }
 
-FileSystemController::FileSystemController() = default;
+FileSystemController::FileSystemController(Core::System& system_) : system{system_} {}
 
 FileSystemController::~FileSystemController() = default;
 
@@ -290,7 +290,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess()
         return ResultCode(-1);
     }
 
-    return romfs_factory->OpenCurrentProcess();
+    return romfs_factory->OpenCurrentProcess(system.CurrentProcess()->GetTitleID());
 }
 
 ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(
@@ -447,10 +447,10 @@ FileSys::SaveDataSize FileSystemController::ReadSaveDataSize(FileSys::SaveDataTy
         FileSys::SaveDataSize new_size{SUFFICIENT_SAVE_DATA_SIZE, SUFFICIENT_SAVE_DATA_SIZE};
 
         FileSys::NACP nacp;
-        const auto res = Core::System::GetInstance().GetAppLoader().ReadControlData(nacp);
+        const auto res = system.GetAppLoader().ReadControlData(nacp);
 
         if (res != Loader::ResultStatus::Success) {
-            FileSys::PatchManager pm{Core::CurrentProcess()->GetTitleID()};
+            FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
             auto [nacp_unique, discard] = pm.GetControlMetadata();
 
             if (nacp_unique != nullptr) {
@@ -702,10 +702,10 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
     if (bis_factory == nullptr) {
         bis_factory =
             std::make_unique<FileSys::BISFactory>(nand_directory, load_directory, dump_directory);
-        Core::System::GetInstance().RegisterContentProvider(
-            FileSys::ContentProviderUnionSlot::SysNAND, bis_factory->GetSystemNANDContents());
-        Core::System::GetInstance().RegisterContentProvider(
-            FileSys::ContentProviderUnionSlot::UserNAND, bis_factory->GetUserNANDContents());
+        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::SysNAND,
+                                       bis_factory->GetSystemNANDContents());
+        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::UserNAND,
+                                       bis_factory->GetUserNANDContents());
     }
 
     if (save_data_factory == nullptr) {
@@ -714,8 +714,8 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
 
     if (sdmc_factory == nullptr) {
         sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
-        Core::System::GetInstance().RegisterContentProvider(FileSys::ContentProviderUnionSlot::SDMC,
-                                                            sdmc_factory->GetSDMCContents());
+        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::SDMC,
+                                       sdmc_factory->GetSDMCContents());
     }
 }
 

src/core/hle/service/filesystem/filesystem.h

@@ -10,6 +10,10 @@
 #include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
+namespace Core {
+class System;
+}
+
 namespace FileSys {
 class BISFactory;
 class RegisteredCache;
@@ -52,7 +56,7 @@ enum class ImageDirectoryId : u32 {
 
 class FileSystemController {
 public:
-    FileSystemController();
+    explicit FileSystemController(Core::System& system_);
     ~FileSystemController();
 
     ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory);
@@ -125,6 +129,8 @@ private:
     std::unique_ptr<FileSys::XCI> gamecard;
     std::unique_ptr<FileSys::RegisteredCache> gamecard_registered;
     std::unique_ptr<FileSys::PlaceholderCache> gamecard_placeholder;
+
+    Core::System& system;
 };
 
 void InstallInterfaces(Core::System& system);

src/core/hle/service/hid/hid.cpp

@@ -195,7 +195,7 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
         {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
         {103, &Hid::ActivateNpad, "ActivateNpad"},
-        {104, nullptr, "DeactivateNpad"},
+        {104, &Hid::DeactivateNpad, "DeactivateNpad"},
         {106, &Hid::AcquireNpadStyleSetUpdateEventHandle, "AcquireNpadStyleSetUpdateEventHandle"},
         {107, &Hid::DisconnectNpad, "DisconnectNpad"},
         {108, &Hid::GetPlayerLedPattern, "GetPlayerLedPattern"},
@@ -470,6 +470,17 @@ void Hid::ActivateNpad(Kernel::HLERequestContext& ctx) {
     applet_resource->ActivateController(HidController::NPad);
 }
 
+void Hid::DeactivateNpad(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    applet_resource->DeactivateController(HidController::NPad);
+}
+
 void Hid::AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto npad_id{rp.Pop<u32>()};

src/core/hle/service/hid/hid.h

@@ -99,6 +99,7 @@ private:
     void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx);
     void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx);
     void ActivateNpad(Kernel::HLERequestContext& ctx);
+    void DeactivateNpad(Kernel::HLERequestContext& ctx);
     void AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx);
     void DisconnectNpad(Kernel::HLERequestContext& ctx);
     void GetPlayerLedPattern(Kernel::HLERequestContext& ctx);

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

@@ -163,7 +163,7 @@ public:
             return;
         }
 
-        if (Core::CurrentProcess()->GetTitleID() != header.title_id) {
+        if (system.CurrentProcess()->GetTitleID() != header.title_id) {
             LOG_ERROR(Service_LDR,
                       "Attempting to load NRR with title ID other than current process. (actual "
                       "{:016X})!",
@@ -327,7 +327,7 @@ public:
         }
 
         // Load NRO as new executable module
-        auto* process = Core::CurrentProcess();
+        auto* process = system.CurrentProcess();
         auto& vm_manager = process->VMManager();
         auto map_address = vm_manager.FindFreeRegion(nro_size + bss_size);
 
@@ -411,7 +411,7 @@ public:
             return;
         }
 
-        auto& vm_manager = Core::CurrentProcess()->VMManager();
+        auto& vm_manager = system.CurrentProcess()->VMManager();
         const auto& nro_info = iter->second;
 
         // Unmap the mirrored memory

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

@@ -6,8 +6,10 @@
 #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"
 
@@ -15,65 +17,16 @@ namespace Service::LM {
 
 class ILogger final : public ServiceFramework<ILogger> {
 public:
-    ILogger() : ServiceFramework("ILogger") {
+    ILogger(Manager& manager) : ServiceFramework("ILogger"), manager(manager) {
         static const FunctionInfo functions[] = {
-            {0x00000000, &ILogger::Initialize, "Initialize"},
-            {0x00000001, &ILogger::SetDestination, "SetDestination"},
+            {0, &ILogger::Log, "Log"},
+            {1, &ILogger::SetDestination, "SetDestination"},
         };
         RegisterHandlers(functions);
     }
 
 private:
-    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) {
+    void Log(Kernel::HLERequestContext& ctx) {
         // This function only succeeds - Get that out of the way
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -85,140 +38,70 @@ private:
         Memory::ReadBlock(addr, &header, sizeof(MessageHeader));
         addr += sizeof(MessageHeader);
 
-        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;
+        FieldMap fields;
         while (addr < end_addr) {
-            const Field field{static_cast<Field>(Memory::Read8(addr++))};
-            const std::size_t length{Memory::Read8(addr++)};
+            const auto field = static_cast<Field>(Memory::Read8(addr++));
+            const auto length = Memory::Read8(addr++);
 
             if (static_cast<Field>(Memory::Read8(addr)) == Field::Skip) {
                 ++addr;
             }
 
-            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;
+            SCOPE_EXIT({ addr += length; });
+
+            if (field == Field::Skip) {
+                continue;
             }
 
-            addr += length;
+            std::vector<u8> data(length);
+            Memory::ReadBlock(addr, data.data(), length);
+            fields.emplace(field, std::move(data));
         }
 
-        // 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;
-            }
-        }
+        manager.Log({header, std::move(fields)});
     }
 
-    // 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) {
-        LOG_DEBUG(Service_LM, "called");
+        IPC::RequestParser rp{ctx};
+        const auto destination = rp.PopEnum<DestinationFlag>();
+
+        LOG_DEBUG(Service_LM, "called, destination={:08X}", static_cast<u32>(destination));
+
+        manager.SetDestination(destination);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 
-    std::ostringstream log_stream;
+    Manager& manager;
 };
 
 class LM final : public ServiceFramework<LM> {
 public:
-    explicit LM() : ServiceFramework{"lm"} {
+    explicit LM(Manager& manager) : ServiceFramework{"lm"}, manager(manager) {
+        // clang-format off
         static const FunctionInfo functions[] = {
-            {0x00000000, &LM::OpenLogger, "OpenLogger"},
+            {0, &LM::OpenLogger, "OpenLogger"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 
-    /**
-     * LM::OpenLogger service function
-     *  Inputs:
-     *      0: 0x00000000
-     *  Outputs:
-     *      0: ResultCode
-     */
+private:
     void OpenLogger(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_LM, "called");
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILogger>();
+        rb.PushIpcInterface<ILogger>(manager);
     }
+
+    Manager& manager;
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager) {
-    std::make_shared<LM>()->InstallAsService(service_manager);
+void InstallInterfaces(Core::System& system) {
+    std::make_shared<LM>(system.GetLogManager())->InstallAsService(system.ServiceManager());
 }
 
 } // namespace Service::LM

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

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

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

@@ -0,0 +1,133 @@
+// 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

@@ -0,0 +1,106 @@
+// 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/ns/pl_u.cpp

@@ -324,14 +324,14 @@ void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
 void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
     // Map backing memory for the font data
     LOG_DEBUG(Service_NS, "called");
-    Core::CurrentProcess()->VMManager().MapMemoryBlock(SHARED_FONT_MEM_VADDR, impl->shared_font, 0,
-                                                       SHARED_FONT_MEM_SIZE,
-                                                       Kernel::MemoryState::Shared);
+    system.CurrentProcess()->VMManager().MapMemoryBlock(SHARED_FONT_MEM_VADDR, impl->shared_font, 0,
+                                                        SHARED_FONT_MEM_SIZE,
+                                                        Kernel::MemoryState::Shared);
 
     // Create shared font memory object
     auto& kernel = system.Kernel();
     impl->shared_font_mem = Kernel::SharedMemory::Create(
-        kernel, Core::CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
+        kernel, system.CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
         Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
         "PL_U:shared_font_mem");
 

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(*sm);
+    LM::InstallInterfaces(system);
     Migration::InstallInterfaces(*sm);
     Mii::InstallInterfaces(*sm);
     MM::InstallInterfaces(*sm);

src/core/memory.cpp

@@ -146,7 +146,7 @@ static u8* GetPointerFromVMA(const Kernel::Process& process, VAddr vaddr) {
  * using a VMA from the current process.
  */
 static u8* GetPointerFromVMA(VAddr vaddr) {
-    return GetPointerFromVMA(*Core::CurrentProcess(), vaddr);
+    return GetPointerFromVMA(*Core::System::GetInstance().CurrentProcess(), vaddr);
 }
 
 template <typename T>
@@ -226,7 +226,7 @@ bool IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr) {
 }
 
 bool IsValidVirtualAddress(const VAddr vaddr) {
-    return IsValidVirtualAddress(*Core::CurrentProcess(), vaddr);
+    return IsValidVirtualAddress(*Core::System::GetInstance().CurrentProcess(), vaddr);
 }
 
 bool IsKernelVirtualAddress(const VAddr vaddr) {
@@ -387,7 +387,7 @@ void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_
 }
 
 void ReadBlock(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
-    ReadBlock(*Core::CurrentProcess(), src_addr, dest_buffer, size);
+    ReadBlock(*Core::System::GetInstance().CurrentProcess(), src_addr, dest_buffer, size);
 }
 
 void Write8(const VAddr addr, const u8 data) {
@@ -450,7 +450,7 @@ void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const voi
 }
 
 void WriteBlock(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
-    WriteBlock(*Core::CurrentProcess(), dest_addr, src_buffer, size);
+    WriteBlock(*Core::System::GetInstance().CurrentProcess(), dest_addr, src_buffer, size);
 }
 
 void ZeroBlock(const Kernel::Process& process, const VAddr dest_addr, const std::size_t size) {
@@ -539,7 +539,7 @@ void CopyBlock(const Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
 }
 
 void CopyBlock(VAddr dest_addr, VAddr src_addr, std::size_t size) {
-    CopyBlock(*Core::CurrentProcess(), dest_addr, src_addr, size);
+    CopyBlock(*Core::System::GetInstance().CurrentProcess(), dest_addr, src_addr, size);
 }
 
 } // namespace Memory

src/core/reporter.cpp

@@ -7,6 +7,7 @@
 
 #include <fmt/chrono.h>
 #include <fmt/format.h>
+#include <fmt/ostream.h>
 #include <json.hpp>
 
 #include "common/file_util.h"
@@ -17,6 +18,7 @@
 #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"
 
@@ -354,6 +356,55 @@ 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,6 +20,10 @@ namespace Service::FileSystem {
 enum class LogMode : u32;
 }
 
+namespace Service::LM {
+struct LogMessage;
+} // namespace Service::LM
+
 namespace Core {
 
 class System;
@@ -29,18 +33,22 @@ 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,
@@ -55,6 +63,7 @@ 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;
@@ -62,6 +71,11 @@ 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:

src/video_core/engines/maxwell_3d.cpp

@@ -249,6 +249,11 @@ void Maxwell3D::InitDirtySettings() {
     dirty_pointers[MAXWELL3D_REG_INDEX(polygon_offset_units)] = polygon_offset_dirty_reg;
     dirty_pointers[MAXWELL3D_REG_INDEX(polygon_offset_factor)] = polygon_offset_dirty_reg;
     dirty_pointers[MAXWELL3D_REG_INDEX(polygon_offset_clamp)] = polygon_offset_dirty_reg;
+
+    // Depth bounds
+    constexpr u32 depth_bounds_values_dirty_reg = DIRTY_REGS_POS(depth_bounds_values);
+    dirty_pointers[MAXWELL3D_REG_INDEX(depth_bounds[0])] = depth_bounds_values_dirty_reg;
+    dirty_pointers[MAXWELL3D_REG_INDEX(depth_bounds[1])] = depth_bounds_values_dirty_reg;
 }
 
 void Maxwell3D::CallMacroMethod(u32 method, std::size_t num_parameters, const u32* parameters) {

src/video_core/engines/maxwell_3d.h

@@ -687,7 +687,9 @@ public:
 
                 u32 rt_separate_frag_data;
 
-                INSERT_PADDING_WORDS(0xC);
+                f32 depth_bounds[2];
+
+                INSERT_PADDING_WORDS(0xA);
 
                 struct {
                     u32 address_high;
@@ -1201,6 +1203,7 @@ public:
                 bool transform_feedback;
                 bool color_mask;
                 bool polygon_offset;
+                bool depth_bounds_values;
 
                 // Complementary
                 bool viewport_transform;
@@ -1400,6 +1403,7 @@ ASSERT_REG_POSITION(stencil_back_mask, 0x3D6);
 ASSERT_REG_POSITION(stencil_back_func_mask, 0x3D7);
 ASSERT_REG_POSITION(color_mask_common, 0x3E4);
 ASSERT_REG_POSITION(rt_separate_frag_data, 0x3EB);
+ASSERT_REG_POSITION(depth_bounds, 0x3EC);
 ASSERT_REG_POSITION(zeta, 0x3F8);
 ASSERT_REG_POSITION(clear_flags, 0x43E);
 ASSERT_REG_POSITION(vertex_attrib_format, 0x458);

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -1340,7 +1340,9 @@ void RasterizerOpenGL::SyncPolygonOffset() {
     state.polygon_offset.fill_enable = regs.polygon_offset_fill_enable != 0;
     state.polygon_offset.line_enable = regs.polygon_offset_line_enable != 0;
     state.polygon_offset.point_enable = regs.polygon_offset_point_enable != 0;
-    state.polygon_offset.units = regs.polygon_offset_units;
+
+    // Hardware divides polygon offset units by two
+    state.polygon_offset.units = regs.polygon_offset_units / 2.0f;
     state.polygon_offset.factor = regs.polygon_offset_factor;
     state.polygon_offset.clamp = regs.polygon_offset_clamp;
 

src/video_core/renderer_opengl/gl_shader_disk_cache.cpp

@@ -112,14 +112,15 @@ std::optional<std::pair<std::vector<ShaderDiskCacheRaw>, std::vector<ShaderDiskC
 ShaderDiskCacheOpenGL::LoadTransferable() {
     // Skip games without title id
     const bool has_title_id = system.CurrentProcess()->GetTitleID() != 0;
-    if (!Settings::values.use_disk_shader_cache || !has_title_id)
+    if (!Settings::values.use_disk_shader_cache || !has_title_id) {
         return {};
-    tried_to_load = true;
+    }
 
     FileUtil::IOFile file(GetTransferablePath(), "rb");
     if (!file.IsOpen()) {
         LOG_INFO(Render_OpenGL, "No transferable shader cache found for game with title id={}",
                  GetTitleID());
+        is_usable = true;
         return {};
     }
 
@@ -135,6 +136,7 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
         LOG_INFO(Render_OpenGL, "Transferable shader cache is old - removing");
         file.Close();
         InvalidateTransferable();
+        is_usable = true;
         return {};
     }
     if (version > NativeVersion) {
@@ -180,13 +182,15 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
         }
     }
 
-    return {{raws, usages}};
+    is_usable = true;
+    return {{std::move(raws), std::move(usages)}};
 }
 
 std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>, ShaderDumpsMap>
 ShaderDiskCacheOpenGL::LoadPrecompiled() {
-    if (!IsUsable())
+    if (!is_usable) {
         return {};
+    }
 
     FileUtil::IOFile file(GetPrecompiledPath(), "rb");
     if (!file.IsOpen()) {
@@ -479,8 +483,9 @@ void ShaderDiskCacheOpenGL::InvalidatePrecompiled() {
 }
 
 void ShaderDiskCacheOpenGL::SaveRaw(const ShaderDiskCacheRaw& entry) {
-    if (!IsUsable())
+    if (!is_usable) {
         return;
+    }
 
     const u64 id = entry.GetUniqueIdentifier();
     if (transferable.find(id) != transferable.end()) {
@@ -501,8 +506,9 @@ void ShaderDiskCacheOpenGL::SaveRaw(const ShaderDiskCacheRaw& entry) {
 }
 
 void ShaderDiskCacheOpenGL::SaveUsage(const ShaderDiskCacheUsage& usage) {
-    if (!IsUsable())
+    if (!is_usable) {
         return;
+    }
 
     const auto it = transferable.find(usage.unique_identifier);
     ASSERT_MSG(it != transferable.end(), "Saving shader usage without storing raw previously");
@@ -528,8 +534,9 @@ void ShaderDiskCacheOpenGL::SaveUsage(const ShaderDiskCacheUsage& usage) {
 
 void ShaderDiskCacheOpenGL::SaveDecompiled(u64 unique_identifier, const std::string& code,
                                            const GLShader::ShaderEntries& entries) {
-    if (!IsUsable())
+    if (!is_usable) {
         return;
+    }
 
     if (precompiled_cache_virtual_file.GetSize() == 0) {
         SavePrecompiledHeaderToVirtualPrecompiledCache();
@@ -543,8 +550,9 @@ void ShaderDiskCacheOpenGL::SaveDecompiled(u64 unique_identifier, const std::str
 }
 
 void ShaderDiskCacheOpenGL::SaveDump(const ShaderDiskCacheUsage& usage, GLuint program) {
-    if (!IsUsable())
+    if (!is_usable) {
         return;
+    }
 
     GLint binary_length{};
     glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binary_length);
@@ -565,10 +573,6 @@ void ShaderDiskCacheOpenGL::SaveDump(const ShaderDiskCacheUsage& usage, GLuint p
     }
 }
 
-bool ShaderDiskCacheOpenGL::IsUsable() const {
-    return tried_to_load && Settings::values.use_disk_shader_cache;
-}
-
 FileUtil::IOFile ShaderDiskCacheOpenGL::AppendTransferableFile() const {
     if (!EnsureDirectories())
         return {};

src/video_core/renderer_opengl/gl_shader_disk_cache.h

@@ -224,9 +224,6 @@ private:
     bool SaveDecompiledFile(u64 unique_identifier, const std::string& code,
                             const GLShader::ShaderEntries& entries);
 
-    /// Returns if the cache can be used
-    bool IsUsable() const;
-
     /// Opens current game's transferable file and write it's header if it doesn't exist
     FileUtil::IOFile AppendTransferableFile() const;
 
@@ -297,7 +294,7 @@ private:
     std::unordered_map<u64, std::unordered_set<ShaderDiskCacheUsage>> transferable;
 
     // The cache has been loaded at boot
-    bool tried_to_load{};
+    bool is_usable{};
 };
 
 } // namespace OpenGL

src/video_core/shader/decode/half_set_predicate.cpp

@@ -4,6 +4,7 @@
 
 #include "common/assert.h"
 #include "common/common_types.h"
+#include "common/logging/log.h"
 #include "video_core/engines/shader_bytecode.h"
 #include "video_core/shader/node_helper.h"
 #include "video_core/shader/shader_ir.h"
@@ -18,7 +19,7 @@ u32 ShaderIR::DecodeHalfSetPredicate(NodeBlock& bb, u32 pc) {
     const Instruction instr = {program_code[pc]};
     const auto opcode = OpCode::Decode(instr);
 
-    DEBUG_ASSERT(instr.hsetp2.ftz == 0);
+    LOG_DEBUG(HW_GPU, "ftz={}", static_cast<u32>(instr.hsetp2.ftz));
 
     Node op_a = UnpackHalfFloat(GetRegister(instr.gpr8), instr.hsetp2.type_a);
     op_a = GetOperandAbsNegHalf(op_a, instr.hsetp2.abs_a, instr.hsetp2.negate_a);
@@ -32,6 +33,8 @@ u32 ShaderIR::DecodeHalfSetPredicate(NodeBlock& bb, u32 pc) {
         h_and = instr.hsetp2.cbuf_and_imm.h_and;
         op_b = GetOperandAbsNegHalf(GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset()),
                                     instr.hsetp2.cbuf.abs_b, instr.hsetp2.cbuf.negate_b);
+        // F32 is hardcoded in hardware
+        op_b = UnpackHalfFloat(std::move(op_b), Tegra::Shader::HalfType::F32);
         break;
     case OpCode::Id::HSETP2_IMM:
         cond = instr.hsetp2.cbuf_and_imm.cond;

src/video_core/texture_cache/texture_cache.h

@@ -336,6 +336,35 @@ protected:
         ReserveSurface(surface->GetSurfaceParams(), surface);
     }
 
+    void Swap(TSurface old_surface, TSurface new_surface) {
+        if (!guard_render_targets && !old_surface->IsProtected()) {
+            if (old_surface->IsRenderTarget()) {
+                ManageRenderTargetUnregister(old_surface);
+            }
+            UnregisterInnerCache(old_surface);
+            old_surface->MarkAsRegistered(false);
+            ReserveSurface(old_surface->GetSurfaceParams(), old_surface);
+            const GPUVAddr gpu_addr = new_surface->GetGpuAddr();
+            const CacheAddr cache_ptr =
+                ToCacheAddr(system.GPU().MemoryManager().GetPointer(gpu_addr));
+            const std::optional<VAddr> cpu_addr = old_surface->GetCpuAddr();
+            if (!cache_ptr || !cpu_addr) {
+                LOG_CRITICAL(HW_GPU,
+                             "Failed to register surface with unmapped gpu_address 0x{:016x}",
+                             gpu_addr);
+                return;
+            }
+            new_surface->MarkAsContinuous(system.GPU().MemoryManager().IsBlockContinuous(
+                gpu_addr, new_surface->GetSizeInBytes()));
+            new_surface->SetCacheAddr(cache_ptr);
+            new_surface->SetCpuAddr(*cpu_addr);
+            RegisterInnerCache(new_surface);
+            new_surface->MarkAsRegistered(true);
+        } else {
+            Register(new_surface);
+        }
+    }
+
     TSurface GetUncachedSurface(const GPUVAddr gpu_addr, const SurfaceParams& params) {
         if (const auto surface = TryGetReservedSurface(params); surface) {
             surface->SetGpuAddr(gpu_addr);
@@ -495,8 +524,7 @@ private:
                 ImageCopy(current_surface, new_surface, brick);
             }
         }
-        Unregister(current_surface);
-        Register(new_surface);
+        Swap(current_surface, new_surface);
         new_surface->MarkAsModified(current_surface->IsModified(), Tick());
         return {new_surface, new_surface->GetMainView()};
     }

src/yuzu/configuration/config.cpp

@@ -716,6 +716,8 @@ void Config::ReadUIValues() {
     UISettings::values.callout_flags = ReadSetting(QStringLiteral("calloutFlags"), 0).toUInt();
     UISettings::values.show_console = ReadSetting(QStringLiteral("showConsole"), false).toBool();
     UISettings::values.profile_index = ReadSetting(QStringLiteral("profileIndex"), 0).toUInt();
+    UISettings::values.pause_when_in_background =
+        ReadSetting(QStringLiteral("pauseWhenInBackground"), false).toBool();
 
     ApplyDefaultProfileIfInputInvalid();
 
@@ -1124,6 +1126,8 @@ void Config::SaveUIValues() {
     WriteSetting(QStringLiteral("calloutFlags"), UISettings::values.callout_flags, 0);
     WriteSetting(QStringLiteral("showConsole"), UISettings::values.show_console, false);
     WriteSetting(QStringLiteral("profileIndex"), UISettings::values.profile_index, 0);
+    WriteSetting(QStringLiteral("pauseWhenInBackground"),
+                 UISettings::values.pause_when_in_background, false);
 
     qt_config->endGroup();
 }

src/yuzu/configuration/configure_general.cpp

@@ -31,6 +31,7 @@ void ConfigureGeneral::SetConfiguration() {
     ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing);
     ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot);
     ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
+    ui->toggle_background_pause->setChecked(UISettings::values.pause_when_in_background);
 
     ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit);
     ui->frame_limit->setEnabled(ui->toggle_frame_limit->isChecked());
@@ -42,6 +43,7 @@ void ConfigureGeneral::ApplyConfiguration() {
     UISettings::values.select_user_on_boot = ui->toggle_user_on_boot->isChecked();
     UISettings::values.theme =
         ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString();
+    UISettings::values.pause_when_in_background = ui->toggle_background_pause->isChecked();
 
     Settings::values.use_frame_limit = ui->toggle_frame_limit->isChecked();
     Settings::values.frame_limit = ui->frame_limit->value();

src/yuzu/configuration/configure_general.ui

@@ -65,6 +65,13 @@
             </property>
            </widget>
           </item>
+           <item>
+             <widget class="QCheckBox" name="toggle_background_pause">
+               <property name="text">
+                 <string>Pause emulation when in background</string>
+               </property>
+             </widget>
+           </item>
          </layout>
         </item>
        </layout>

src/yuzu/main.cpp

@@ -675,6 +675,24 @@ void GMainWindow::RestoreUIState() {
     Debugger::ToggleConsole();
 }
 
+void GMainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
+    if (!UISettings::values.pause_when_in_background) {
+        return;
+    }
+    if (state != Qt::ApplicationHidden && state != Qt::ApplicationInactive &&
+        state != Qt::ApplicationActive) {
+        LOG_DEBUG(Frontend, "ApplicationState unusual flag: {} ", state);
+    }
+    if (ui.action_Pause->isEnabled() &&
+        (state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
+        auto_paused = true;
+        OnPauseGame();
+    } else if (ui.action_Start->isEnabled() && auto_paused && state == Qt::ApplicationActive) {
+        auto_paused = false;
+        OnStartGame();
+    }
+}
+
 void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::GameChosen, this, &GMainWindow::OnGameListLoadFile);
     connect(game_list, &GameList::OpenDirectory, this, &GMainWindow::OnGameListOpenDirectory);
@@ -2320,6 +2338,9 @@ int main(int argc, char* argv[]) {
     // After settings have been loaded by GMainWindow, apply the filter
     main_window.show();
 
+    QObject::connect(&app, &QGuiApplication::applicationStateChanged, &main_window,
+                     &GMainWindow::OnAppFocusStateChanged);
+
     Settings::LogSettings();
 
     int result = app.exec();

src/yuzu/main.h

@@ -119,6 +119,7 @@ public slots:
     void SoftwareKeyboardGetText(const Core::Frontend::SoftwareKeyboardParameters& parameters);
     void SoftwareKeyboardInvokeCheckDialog(std::u16string error_message);
     void WebBrowserOpenPage(std::string_view filename, std::string_view arguments);
+    void OnAppFocusStateChanged(Qt::ApplicationState state);
 
 private:
     void InitializeWidgets();
@@ -244,6 +245,8 @@ private:
     // The path to the game currently running
     QString game_path;
 
+    bool auto_paused = false;
+
     // FS
     std::shared_ptr<FileSys::VfsFilesystem> vfs;
     std::unique_ptr<FileSys::ManualContentProvider> provider;

src/yuzu/uisettings.h

@@ -58,6 +58,7 @@ struct Values {
 
     bool confirm_before_closing;
     bool first_start;
+    bool pause_when_in_background;
 
     bool select_user_on_boot;