Merge 37e3a6b8f3 into b65c096be5

.travis.yml

@@ -3,11 +3,16 @@ matrix:
   include:
     - os: linux
       env: NAME="clang-format"
-      sudo: required
       dist: trusty
-      services: docker
-      install: "./.travis/clang-format/deps.sh"
-      script: "./.travis/clang-format/build.sh"
+      addons:
+        apt:
+          sources:
+            - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-6.0 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+            - sourceline: 'deb http://ppa.launchpad.net/ubuntu-toolchain-r/test/ubuntu trusty main'
+          packages:
+            - clang-format-6.0
+      script: "./.travis/clang-format/script.sh"
     - os: linux
       env: NAME="linux build"
       sudo: required
@@ -20,6 +25,16 @@ matrix:
       install: "./.travis/linux/deps.sh"
       script: "./.travis/linux/build.sh"
       after_success: "./.travis/linux/upload.sh"
+    - os: linux
+      env: NAME="linux build (frozen versions of dependencies)"
+      sudo: required
+      dist: trusty
+      services: docker
+      before_install:
+        - chmod +x ./.travis/linux-frozen/build.sh
+        - chmod +x ./.travis/linux-frozen/docker.sh
+        - chmod +x ./.travis/linux-frozen/install_package.py
+      script: "./.travis/linux-frozen/build.sh"
     - os: osx
       env: NAME="macos build"
       sudo: false

.travis/clang-format/deps.sh

@@ -1,3 +0,0 @@
-#!/bin/sh -ex
-
-docker pull ubuntu:18.04

.travis/clang-format/docker.sh

@@ -1,8 +0,0 @@
-#!/bin/bash -ex
-
-apt-get update
-apt-get install -y clang-format-6.0
-
-# Run clang-format
-cd /yuzu
-./.travis/clang-format/script.sh

.travis/linux-frozen/build.sh

@@ -1,3 +1,4 @@
 #!/bin/bash -ex
 
-docker run -v $(pwd):/yuzu ubuntu:18.04 /bin/bash -ex /yuzu/.travis/clang-format/docker.sh
+docker pull ubuntu:18.04
+docker run -v $(pwd):/yuzu ubuntu:18.04 /bin/bash -ex /yuzu/.travis/linux-frozen/docker.sh

.travis/linux-frozen/docker.sh

@@ -0,0 +1,32 @@
+#!/bin/bash -ex
+
+cd /yuzu
+
+apt-get update
+apt-get install -y build-essential wget git python-launchpadlib libssl-dev
+
+# Install specific versions of packages with their dependencies
+# The apt repositories remove older versions regularly, so we can't use
+# apt-get and have to pull the packages directly from the archives.
+/yuzu/.travis/linux-frozen/install_package.py    \
+    libsdl2-dev 2.0.4+dfsg1-2ubuntu2 xenial    \
+    qtbase5-dev 5.9.3+dfsg-0ubuntu1 bionic    \
+    libharfbuzz0b 1.7.2-1 bionic    \
+    libqt5opengl5-dev 5.9.3+dfsg-0ubuntu1 bionic    \
+    libfontconfig1 2.12.6-0ubuntu1 bionic    \
+    libfreetype6 2.8-0.2ubuntu2 bionic    \
+    libicu-le-hb0 1.0.3+git161113-4 bionic    \
+    libdouble-conversion1 2.0.1-4ubuntu1 bionic    \
+    qtchooser 64-ga1b6736-5 bionic    \
+    libicu60 60.2-1ubuntu1 bionic
+
+# Get a recent version of CMake
+wget https://cmake.org/files/v3.9/cmake-3.9.0-Linux-x86_64.sh
+echo y | sh cmake-3.9.0-Linux-x86_64.sh --prefix=cmake
+export PATH=/yuzu/cmake/cmake-3.9.0-Linux-x86_64/bin:$PATH
+
+mkdir build && cd build
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
+make -j4
+
+ctest -VV -C Release

.travis/linux-frozen/install_package.py

@@ -0,0 +1,38 @@
+#!/usr/bin/python
+
+import sys, re, subprocess
+from launchpadlib.launchpad import Launchpad
+
+cachedir = '/.launchpadlib/cache/'
+launchpad = Launchpad.login_anonymously('grab build info', 'production', cachedir, version='devel')
+
+processed_packages = []
+deb_file_list = []
+
+def get_url(pkg, distro):
+    build_link = launchpad.archives.getByReference(reference='ubuntu').getPublishedBinaries(binary_name=pkg[0], distro_arch_series='https://api.launchpad.net/devel/ubuntu/'+distro+'/amd64', version=pkg[1], exact_match=True, order_by_date=True).entries[0]['build_link']
+    deb_name = pkg[0] + '_' + pkg[1] + '_amd64.deb'
+    deb_link = build_link + '/+files/' + deb_name
+    return [deb_link, deb_name]
+
+def list_dependencies(deb_file):
+    t=subprocess.check_output(['bash', '-c', 'dpkg -I ' + deb_file + ' | grep -oP "^ Depends\: \K.*$"'])
+    deps=[i.strip() for i in t.split(',')]
+    equals_re = re.compile(r'^(.*) \(= (.*)\)$')
+    return [equals_re.sub(r'\1=\2', i).split('=') for i in filter(equals_re.match, deps)]
+
+def get_package(pkg, distro):
+    if pkg in processed_packages:
+        return
+    print 'Getting ' + pkg[0] + '...'
+    url = get_url(pkg, distro)
+    subprocess.check_call(['wget', '--quiet', url[0], '-O', url[1]])
+    for dep in list_dependencies(url[1]):
+        get_package(dep, distro)
+    processed_packages.append(pkg)
+    deb_file_list.append('./' + url[1])
+
+for i in xrange(1, len(sys.argv), 3):
+    get_package([sys.argv[i], sys.argv[i + 1]], sys.argv[i + 2])
+
+subprocess.check_call(['apt-get', 'install', '-y'] + deb_file_list)

src/common/logging/backend.cpp

@@ -35,14 +35,11 @@ namespace Log {
     SUB(Service, ACC)                                                                              \
     SUB(Service, Audio)                                                                            \
     SUB(Service, AM)                                                                               \
-    SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
-    SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \
     SUB(Service, LM)                                                                               \
     SUB(Service, NIFM)                                                                             \
-    SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
     SUB(Service, PCTL)                                                                             \
     SUB(Service, SET)                                                                              \

src/common/logging/log.h

@@ -51,15 +51,12 @@ enum class Class : ClassType {
                        ///  should have its own subclass.
     Service_ACC,       ///< The ACC (Accounts) service
     Service_AM,        ///< The AM (Applet manager) service
-    Service_AOC,       ///< The AOC (AddOn Content) service
     Service_APM,       ///< The APM (Performance) service
     Service_Audio,     ///< The Audio (Audio control) service
-    Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service
     Service_HID,       ///< The HID (Human interface device) service
     Service_LM,        ///< The LM (Logger) service
     Service_NIFM,      ///< The NIFM (Network interface) service
-    Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
     Service_PCTL,      ///< The PCTL (Parental control) service
     Service_SET,       ///< The SET (Settings) service

src/core/CMakeLists.txt

@@ -7,21 +7,15 @@ add_library(core STATIC
     core_timing.cpp
     core_timing.h
     file_sys/directory.h
-    file_sys/disk_filesystem.cpp
-    file_sys/disk_filesystem.h
     file_sys/errors.h
     file_sys/filesystem.cpp
     file_sys/filesystem.h
     file_sys/path_parser.cpp
     file_sys/path_parser.h
-    file_sys/program_metadata.cpp
-    file_sys/program_metadata.h
     file_sys/romfs_factory.cpp
     file_sys/romfs_factory.h
     file_sys/romfs_filesystem.cpp
     file_sys/romfs_filesystem.h
-    file_sys/savedata_factory.cpp
-    file_sys/savedata_factory.h
     file_sys/storage.h
     frontend/emu_window.cpp
     frontend/emu_window.h
@@ -34,6 +28,8 @@ add_library(core STATIC
     hle/config_mem.h
     hle/ipc.h
     hle/ipc_helpers.h
+    hle/kernel/address_arbiter.cpp
+    hle/kernel/address_arbiter.h
     hle/kernel/client_port.cpp
     hle/kernel/client_port.h
     hle/kernel/client_session.cpp
@@ -59,8 +55,6 @@ add_library(core STATIC
     hle/kernel/process.h
     hle/kernel/resource_limit.cpp
     hle/kernel/resource_limit.h
-    hle/kernel/scheduler.cpp
-    hle/kernel/scheduler.h
     hle/kernel/server_port.cpp
     hle/kernel/server_port.h
     hle/kernel/server_session.cpp
@@ -118,10 +112,6 @@ add_library(core STATIC
     hle/service/filesystem/filesystem.h
     hle/service/filesystem/fsp_srv.cpp
     hle/service/filesystem/fsp_srv.h
-    hle/service/friend/friend.cpp
-    hle/service/friend/friend.h
-    hle/service/friend/friend_a.cpp
-    hle/service/friend/friend_a.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
     hle/service/lm/lm.cpp
@@ -134,10 +124,6 @@ add_library(core STATIC
     hle/service/nifm/nifm_s.h
     hle/service/nifm/nifm_u.cpp
     hle/service/nifm/nifm_u.h
-    hle/service/ns/ns.cpp
-    hle/service/ns/ns.h
-    hle/service/ns/pl_u.cpp
-    hle/service/ns/pl_u.h
     hle/service/nvdrv/devices/nvdevice.h
     hle/service/nvdrv/devices/nvdisp_disp0.cpp
     hle/service/nvdrv/devices/nvdisp_disp0.h
@@ -169,14 +155,6 @@ add_library(core STATIC
     hle/service/service.h
     hle/service/set/set.cpp
     hle/service/set/set.h
-    hle/service/set/set_cal.cpp
-    hle/service/set/set_cal.h
-    hle/service/set/set_fd.cpp
-    hle/service/set/set_fd.h
-    hle/service/set/set_sys.cpp
-    hle/service/set/set_sys.h
-    hle/service/set/settings.cpp
-    hle/service/set/settings.h
     hle/service/sm/controller.cpp
     hle/service/sm/controller.h
     hle/service/sm/sm.cpp

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -6,7 +6,6 @@
 #include <memory>
 #include <dynarmic/A64/a64.h>
 #include <dynarmic/A64/config.h>
-#include "common/logging/log.h"
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/memory.h"
@@ -54,9 +53,6 @@ public:
     }
 
     void InterpreterFallback(u64 pc, size_t num_instructions) override {
-        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x%" PRIx64 " for %zu instructions (instr = %08x)",
-                 pc, num_instructions, MemoryReadCode(pc));
-
         ARM_Interface::ThreadContext ctx;
         parent.SaveContext(ctx);
         parent.inner_unicorn.LoadContext(ctx);
@@ -67,17 +63,8 @@ public:
     }
 
     void ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) override {
-        switch (exception) {
-        case Dynarmic::A64::Exception::WaitForInterrupt:
-        case Dynarmic::A64::Exception::WaitForEvent:
-        case Dynarmic::A64::Exception::SendEvent:
-        case Dynarmic::A64::Exception::SendEventLocal:
-        case Dynarmic::A64::Exception::Yield:
-            return;
-        default:
-            ASSERT_MSG(false, "ExceptionRaised(exception = %zu, pc = %" PRIx64 ")",
-                       static_cast<size_t>(exception), pc);
-        }
+        ASSERT_MSG(false, "ExceptionRaised(exception = %zu, pc = %" PRIx64 ")",
+                   static_cast<size_t>(exception), pc);
     }
 
     void CallSVC(u32 swi) override {
@@ -94,15 +81,11 @@ public:
     u64 GetTicksRemaining() override {
         return ticks_remaining;
     }
-    u64 GetCNTPCT() override {
-        return CoreTiming::GetTicks();
-    }
 
     ARM_Dynarmic& parent;
     size_t ticks_remaining = 0;
     size_t num_interpreted_instructions = 0;
     u64 tpidrro_el0 = 0;
-    u64 tpidr_el0 = 0;
 };
 
 std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_Callbacks>& cb) {
@@ -111,13 +94,10 @@ std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_C
     Dynarmic::A64::UserConfig config;
     config.callbacks = cb.get();
     config.tpidrro_el0 = &cb->tpidrro_el0;
-    config.tpidr_el0 = &cb->tpidr_el0;
     config.dczid_el0 = 4;
-    config.ctr_el0 = 0x8444c004;
     config.page_table = reinterpret_cast<void**>(page_table);
     config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
     config.silently_mirror_page_table = false;
-
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
 

src/core/arm/unicorn/arm_unicorn.cpp

@@ -52,8 +52,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
                                void* user_data) {
     ARM_Interface::ThreadContext ctx{};
     Core::CPU().SaveContext(ctx);
-    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%llx, pc=0x%llx, lr=0x%llx", addr,
-               ctx.pc, ctx.cpu_registers[30]);
+    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%llx", addr);
     return {};
 }
 

src/core/core.cpp

@@ -133,24 +133,22 @@ void System::Reschedule() {
     }
 
     reschedule_pending = false;
-    Core::System::GetInstance().Scheduler().Reschedule();
+    Kernel::Reschedule();
 }
 
 System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
     LOG_DEBUG(HW_Memory, "initialized OK");
 
-    CoreTiming::Init();
-
     switch (Settings::values.cpu_core) {
     case Settings::CpuCore::Unicorn:
-        cpu_core = std::make_shared<ARM_Unicorn>();
+        cpu_core = std::make_unique<ARM_Unicorn>();
         break;
     case Settings::CpuCore::Dynarmic:
     default:
 #ifdef ARCHITECTURE_x86_64
-        cpu_core = std::make_shared<ARM_Dynarmic>();
+        cpu_core = std::make_unique<ARM_Dynarmic>();
 #else
-        cpu_core = std::make_shared<ARM_Unicorn>();
+        cpu_core = std::make_unique<ARM_Unicorn>();
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
         break;
@@ -160,9 +158,9 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
 
     telemetry_session = std::make_unique<Core::TelemetrySession>();
 
+    CoreTiming::Init();
     HW::Init();
     Kernel::Init(system_mode);
-    scheduler = std::make_unique<Kernel::Scheduler>(cpu_core.get());
     Service::Init();
     GDBStub::Init();
 
@@ -190,18 +188,15 @@ void System::Shutdown() {
                          perf_results.frametime * 1000.0);
 
     // Shutdown emulation session
-    VideoCore::Shutdown();
     GDBStub::Shutdown();
+    VideoCore::Shutdown();
     Service::Shutdown();
-    scheduler = nullptr;
     Kernel::Shutdown();
     HW::Shutdown();
-    telemetry_session = nullptr;
-    gpu_core = nullptr;
-    cpu_core = nullptr;
     CoreTiming::Shutdown();
-
+    cpu_core = nullptr;
     app_loader = nullptr;
+    telemetry_session = nullptr;
 
     LOG_DEBUG(Core, "Shutdown OK");
 }

src/core/core.h

@@ -7,7 +7,6 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 #include "core/perf_stats.h"
@@ -108,10 +107,6 @@ public:
         return *gpu_core;
     }
 
-    Kernel::Scheduler& Scheduler() {
-        return *scheduler;
-    }
-
     PerfStats perf_stats;
     FrameLimiter frame_limiter;
 
@@ -145,8 +140,9 @@ private:
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
 
-    std::shared_ptr<ARM_Interface> cpu_core;
-    std::unique_ptr<Kernel::Scheduler> scheduler;
+    ///< ARM11 CPU core
+    std::unique_ptr<ARM_Interface> cpu_core;
+
     std::unique_ptr<Tegra::GPU> gpu_core;
 
     /// When true, signals that a reschedule should happen

src/core/file_sys/disk_filesystem.cpp

@@ -1,147 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <memory>
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "core/file_sys/disk_filesystem.h"
-
-namespace FileSys {
-
-std::string Disk_FileSystem::GetName() const {
-    return "Disk";
-}
-
-ResultVal<std::unique_ptr<StorageBackend>> Disk_FileSystem::OpenFile(const std::string& path,
-                                                                     Mode mode) const {
-    ASSERT_MSG(mode == Mode::Read || mode == Mode::Write, "Other file modes are not supported");
-
-    std::string full_path = base_directory + path;
-    auto file = std::make_shared<FileUtil::IOFile>(full_path, mode == Mode::Read ? "rb" : "wb");
-
-    if (!file->IsOpen()) {
-        // TODO(Subv): Find out the correct error code.
-        return ResultCode(-1);
-    }
-
-    return MakeResult<std::unique_ptr<StorageBackend>>(
-        std::make_unique<Disk_Storage>(std::move(file)));
-}
-
-ResultCode Disk_FileSystem::DeleteFile(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(bunnei): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::RenameFile(const Path& src_path, const Path& dest_path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::DeleteDirectory(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::DeleteDirectoryRecursively(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::CreateFile(const std::string& path, u64 size) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-
-    std::string full_path = base_directory + path;
-    if (size == 0) {
-        FileUtil::CreateEmptyFile(full_path);
-        return RESULT_SUCCESS;
-    }
-
-    FileUtil::IOFile file(full_path, "wb");
-    // Creates a sparse file (or a normal file on filesystems without the concept of sparse files)
-    // We do this by seeking to the right size, then writing a single null byte.
-    if (file.Seek(size - 1, SEEK_SET) && file.WriteBytes("", 1) == 1) {
-        return RESULT_SUCCESS;
-    }
-
-    LOG_ERROR(Service_FS, "Too large file");
-    // TODO(Subv): Find out the correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::CreateDirectory(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::RenameDirectory(const Path& src_path, const Path& dest_path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultVal<std::unique_ptr<DirectoryBackend>> Disk_FileSystem::OpenDirectory(
-    const Path& path) const {
-    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::make_unique<Disk_Directory>());
-}
-
-u64 Disk_FileSystem::GetFreeSpaceSize() const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    return 0;
-}
-
-ResultVal<FileSys::EntryType> Disk_FileSystem::GetEntryType(const std::string& path) const {
-    std::string full_path = base_directory + path;
-    if (!FileUtil::Exists(full_path)) {
-        // TODO(Subv): Find out what this actually means
-        return ResultCode(ErrorModule::FS, 1);
-    }
-
-    // TODO(Subv): Find out the EntryType values
-    UNIMPLEMENTED_MSG("Unimplemented GetEntryType");
-}
-
-ResultVal<size_t> Disk_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
-    LOG_TRACE(Service_FS, "called offset=%llu, length=%zu", offset, length);
-    file->Seek(offset, SEEK_SET);
-    return MakeResult<size_t>(file->ReadBytes(buffer, length));
-}
-
-ResultVal<size_t> Disk_Storage::Write(const u64 offset, const size_t length, const bool flush,
-                                      const u8* buffer) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    file->Seek(offset, SEEK_SET);
-    size_t written = file->WriteBytes(buffer, length);
-    if (flush) {
-        file->Flush();
-    }
-    return MakeResult<size_t>(written);
-}
-
-u64 Disk_Storage::GetSize() const {
-    return file->GetSize();
-}
-
-bool Disk_Storage::SetSize(const u64 size) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    return false;
-}
-
-u32 Disk_Directory::Read(const u32 count, Entry* entries) {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    return 0;
-}
-
-bool Disk_Directory::Close() const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    return true;
-}
-
-} // namespace FileSys

src/core/file_sys/disk_filesystem.h

@@ -1,66 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include <memory>
-#include <string>
-#include "common/common_types.h"
-#include "common/file_util.h"
-#include "core/file_sys/directory.h"
-#include "core/file_sys/filesystem.h"
-#include "core/file_sys/storage.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class Disk_FileSystem : public FileSystemBackend {
-public:
-    explicit Disk_FileSystem(std::string base_directory)
-        : base_directory(std::move(base_directory)) {}
-
-    std::string GetName() const override;
-
-    ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                        Mode mode) const override;
-    ResultCode DeleteFile(const Path& path) const override;
-    ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
-    ResultCode DeleteDirectory(const Path& path) const override;
-    ResultCode DeleteDirectoryRecursively(const Path& path) const override;
-    ResultCode CreateFile(const std::string& path, u64 size) const override;
-    ResultCode CreateDirectory(const Path& path) const override;
-    ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
-    u64 GetFreeSpaceSize() const override;
-    ResultVal<EntryType> GetEntryType(const std::string& path) const override;
-
-protected:
-    std::string base_directory;
-};
-
-class Disk_Storage : public StorageBackend {
-public:
-    Disk_Storage(std::shared_ptr<FileUtil::IOFile> file) : file(std::move(file)) {}
-
-    ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const override;
-    ResultVal<size_t> Write(u64 offset, size_t length, bool flush, const u8* buffer) const override;
-    u64 GetSize() const override;
-    bool SetSize(u64 size) const override;
-    bool Close() const override {
-        return false;
-    }
-    void Flush() const override {}
-
-private:
-    std::shared_ptr<FileUtil::IOFile> file;
-};
-
-class Disk_Directory : public DirectoryBackend {
-public:
-    u32 Read(const u32 count, Entry* entries) override;
-    bool Close() const override;
-};
-
-} // namespace FileSys

src/core/file_sys/filesystem.h

@@ -27,14 +27,11 @@ enum LowPathType : u32 {
     Wchar = 4,
 };
 
-enum EntryType : u32 {
-    Directory = 0,
-    File = 1,
-};
-
-enum class Mode : u32 {
-    Read = 1,
-    Write = 2,
+union Mode {
+    u32 hex;
+    BitField<0, 1, u32> read_flag;
+    BitField<1, 1, u32> write_flag;
+    BitField<2, 1, u32> create_flag;
 };
 
 class Path {
@@ -89,7 +86,7 @@ public:
      * @param size The size of the new file, filled with zeroes
      * @return Result of the operation
      */
-    virtual ResultCode CreateFile(const std::string& path, u64 size) const = 0;
+    virtual ResultCode CreateFile(const Path& path, u64 size) const = 0;
 
     /**
      * Delete a file specified by its path
@@ -141,8 +138,8 @@ public:
      * @param mode Mode to open the file with
      * @return Opened file, or error code
      */
-    virtual ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                                Mode mode) const = 0;
+    virtual ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const Path& path,
+                                                                const Mode& mode) const = 0;
 
     /**
      * Open a directory specified by its path
@@ -156,12 +153,6 @@ public:
      * @return The number of free bytes in the archive
      */
     virtual u64 GetFreeSpaceSize() const = 0;
-
-    /**
-     * Get the type of the specified path
-     * @return The type of the specified path or error code
-     */
-    virtual ResultVal<EntryType> GetEntryType(const std::string& path) const = 0;
 };
 
 class FileSystemFactory : NonCopyable {

src/core/file_sys/program_metadata.cpp

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

src/core/file_sys/program_metadata.h

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

src/core/file_sys/romfs_filesystem.cpp

@@ -14,8 +14,8 @@ std::string RomFS_FileSystem::GetName() const {
     return "RomFS";
 }
 
-ResultVal<std::unique_ptr<StorageBackend>> RomFS_FileSystem::OpenFile(const std::string& path,
-                                                                      Mode mode) const {
+ResultVal<std::unique_ptr<StorageBackend>> RomFS_FileSystem::OpenFile(const Path& path,
+                                                                      const Mode& mode) const {
     return MakeResult<std::unique_ptr<StorageBackend>>(
         std::make_unique<RomFS_Storage>(romfs_file, data_offset, data_size));
 }
@@ -48,7 +48,7 @@ ResultCode RomFS_FileSystem::DeleteDirectoryRecursively(const Path& path) const
     return ResultCode(-1);
 }
 
-ResultCode RomFS_FileSystem::CreateFile(const std::string& path, u64 size) const {
+ResultCode RomFS_FileSystem::CreateFile(const Path& path, u64 size) const {
     LOG_CRITICAL(Service_FS, "Attempted to create a file in an ROMFS archive (%s).",
                  GetName().c_str());
     // TODO(bunnei): Use correct error code
@@ -79,12 +79,6 @@ u64 RomFS_FileSystem::GetFreeSpaceSize() const {
     return 0;
 }
 
-ResultVal<FileSys::EntryType> RomFS_FileSystem::GetEntryType(const std::string& path) const {
-    LOG_CRITICAL(Service_FS, "Called within an ROMFS archive (path %s).", path.c_str());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
 ResultVal<size_t> RomFS_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
     LOG_TRACE(Service_FS, "called offset=%llu, length=%zu", offset, length);
     romfs_file->Seek(data_offset + offset, SEEK_SET);

src/core/file_sys/romfs_filesystem.h

@@ -29,18 +29,17 @@ public:
 
     std::string GetName() const override;
 
-    ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                        Mode mode) const override;
+    ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const Path& path,
+                                                        const Mode& mode) const override;
     ResultCode DeleteFile(const Path& path) const override;
     ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
     ResultCode DeleteDirectory(const Path& path) const override;
     ResultCode DeleteDirectoryRecursively(const Path& path) const override;
-    ResultCode CreateFile(const std::string& path, u64 size) const override;
+    ResultCode CreateFile(const Path& path, u64 size) const override;
     ResultCode CreateDirectory(const Path& path) const override;
     ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
     ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
     u64 GetFreeSpaceSize() const override;
-    ResultVal<EntryType> GetEntryType(const std::string& path) const override;
 
 protected:
     std::shared_ptr<FileUtil::IOFile> romfs_file;

src/core/file_sys/savedata_factory.cpp

@@ -1,42 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cinttypes>
-#include <memory>
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/file_sys/disk_filesystem.h"
-#include "core/file_sys/savedata_factory.h"
-#include "core/hle/kernel/process.h"
-
-namespace FileSys {
-
-SaveData_Factory::SaveData_Factory(std::string nand_directory)
-    : nand_directory(std::move(nand_directory)) {}
-
-ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path& path) {
-    u64 title_id = Kernel::g_current_process->program_id;
-    // TODO(Subv): Somehow obtain this value.
-    u32 user = 0;
-    std::string save_directory = Common::StringFromFormat("%ssave/%016" PRIX64 "/%08X",
-                                                          nand_directory.c_str(), title_id, user);
-    auto archive = std::make_unique<Disk_FileSystem>(save_directory);
-    return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
-}
-
-ResultCode SaveData_Factory::Format(const Path& path,
-                                    const FileSys::ArchiveFormatInfo& format_info) {
-    LOG_ERROR(Service_FS, "Unimplemented Format archive %s", GetName().c_str());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
-
-ResultVal<ArchiveFormatInfo> SaveData_Factory::GetFormatInfo(const Path& path) const {
-    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive %s", GetName().c_str());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
-
-} // namespace FileSys

src/core/file_sys/savedata_factory.h

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-/// File system interface to the SaveData archive
-class SaveData_Factory final : public FileSystemFactory {
-public:
-    explicit SaveData_Factory(std::string nand_directory);
-
-    std::string GetName() const override {
-        return "SaveData_Factory";
-    }
-    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
-    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
-
-private:
-    std::string nand_directory;
-};
-
-} // namespace FileSys

src/core/hle/ipc.h

@@ -91,10 +91,6 @@ struct BufferDescriptorX {
         address |= static_cast<VAddr>(address_bits_36_38) << 36;
         return address;
     }
-
-    u64 Size() const {
-        return static_cast<u64>(size);
-    }
 };
 static_assert(sizeof(BufferDescriptorX) == 8, "BufferDescriptorX size is incorrect");
 

src/core/hle/ipc_helpers.h

@@ -118,8 +118,7 @@ public:
 
         AlignWithPadding();
 
-        const bool request_has_domain_header{context.GetDomainMessageHeader() != nullptr};
-        if (context.Session()->IsDomain() && request_has_domain_header) {
+        if (context.Session()->IsDomain()) {
             IPC::DomainMessageHeader domain_header{};
             domain_header.num_objects = num_domain_objects;
             PushRaw(domain_header);

src/core/hle/kernel/address_arbiter.cpp

@@ -0,0 +1,91 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "core/hle/kernel/address_arbiter.h"
+#include "core/hle/kernel/errors.h"
+#include "core/hle/kernel/thread.h"
+#include "core/memory.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Kernel namespace
+
+namespace Kernel {
+
+AddressArbiter::AddressArbiter() {}
+AddressArbiter::~AddressArbiter() {}
+
+SharedPtr<AddressArbiter> AddressArbiter::Create(std::string name) {
+    SharedPtr<AddressArbiter> address_arbiter(new AddressArbiter);
+
+    address_arbiter->name = std::move(name);
+
+    return address_arbiter;
+}
+
+ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address, s32 value,
+                                            u64 nanoseconds) {
+    switch (type) {
+
+    // Signal thread(s) waiting for arbitrate address...
+    case ArbitrationType::Signal:
+        // Negative value means resume all threads
+        if (value < 0) {
+            ArbitrateAllThreads(address);
+        } else {
+            // Resume first N threads
+            for (int i = 0; i < value; i++)
+                ArbitrateHighestPriorityThread(address);
+        }
+        break;
+
+    // Wait current thread (acquire the arbiter)...
+    case ArbitrationType::WaitIfLessThan:
+        if ((s32)Memory::Read32(address) < value) {
+            Kernel::WaitCurrentThread_ArbitrateAddress(address);
+        }
+        break;
+    case ArbitrationType::WaitIfLessThanWithTimeout:
+        if ((s32)Memory::Read32(address) < value) {
+            Kernel::WaitCurrentThread_ArbitrateAddress(address);
+            GetCurrentThread()->WakeAfterDelay(nanoseconds);
+        }
+        break;
+    case ArbitrationType::DecrementAndWaitIfLessThan: {
+        s32 memory_value = Memory::Read32(address);
+        if (memory_value < value) {
+            // Only change the memory value if the thread should wait
+            Memory::Write32(address, (s32)memory_value - 1);
+            Kernel::WaitCurrentThread_ArbitrateAddress(address);
+        }
+        break;
+    }
+    case ArbitrationType::DecrementAndWaitIfLessThanWithTimeout: {
+        s32 memory_value = Memory::Read32(address);
+        if (memory_value < value) {
+            // Only change the memory value if the thread should wait
+            Memory::Write32(address, (s32)memory_value - 1);
+            Kernel::WaitCurrentThread_ArbitrateAddress(address);
+            GetCurrentThread()->WakeAfterDelay(nanoseconds);
+        }
+        break;
+    }
+
+    default:
+        LOG_ERROR(Kernel, "unknown type=%d", type);
+        return ERR_INVALID_ENUM_VALUE_FND;
+    }
+
+    // The calls that use a timeout seem to always return a Timeout error even if they did not put
+    // the thread to sleep
+    if (type == ArbitrationType::WaitIfLessThanWithTimeout ||
+        type == ArbitrationType::DecrementAndWaitIfLessThanWithTimeout) {
+
+        return RESULT_TIMEOUT;
+    }
+    return RESULT_SUCCESS;
+}
+
+} // namespace Kernel

src/core/hle/kernel/address_arbiter.h

@@ -0,0 +1,60 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/result.h"
+
+// Address arbiters are an underlying kernel synchronization object that can be created/used via
+// supervisor calls (SVCs). They function as sort of a global lock. Typically, games/other CTR
+// applications use them as an underlying mechanism to implement thread-safe barriers, events, and
+// semphores.
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Kernel namespace
+
+namespace Kernel {
+
+enum class ArbitrationType : u32 {
+    Signal,
+    WaitIfLessThan,
+    DecrementAndWaitIfLessThan,
+    WaitIfLessThanWithTimeout,
+    DecrementAndWaitIfLessThanWithTimeout,
+};
+
+class AddressArbiter final : public Object {
+public:
+    /**
+     * Creates an address arbiter.
+     *
+     * @param name Optional name used for debugging.
+     * @returns The created AddressArbiter.
+     */
+    static SharedPtr<AddressArbiter> Create(std::string name = "Unknown");
+
+    std::string GetTypeName() const override {
+        return "Arbiter";
+    }
+    std::string GetName() const override {
+        return name;
+    }
+
+    static const HandleType HANDLE_TYPE = HandleType::AddressArbiter;
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
+
+    std::string name; ///< Name of address arbiter object (optional)
+
+    ResultCode ArbitrateAddress(ArbitrationType type, VAddr address, s32 value, u64 nanoseconds);
+
+private:
+    AddressArbiter();
+    ~AddressArbiter() override;
+};
+
+} // namespace Kernel

src/core/hle/kernel/hle_ipc.cpp

@@ -12,7 +12,6 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/server_session.h"
-#include "core/memory.h"
 
 namespace Kernel {
 
@@ -85,14 +84,9 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
 
     if (Session()->IsDomain() && (command_header->type == IPC::CommandType::Request || !incoming)) {
         // If this is an incoming message, only CommandType "Request" has a domain header
-        // All outgoing domain messages have the domain header, if only incoming has it
-        if (incoming || domain_message_header) {
-            domain_message_header =
-                std::make_unique<IPC::DomainMessageHeader>(rp.PopRaw<IPC::DomainMessageHeader>());
-        } else {
-            if (Session()->IsDomain())
-                LOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
-        }
+        // All outgoing domain messages have the domain header
+        domain_message_header =
+            std::make_unique<IPC::DomainMessageHeader>(rp.PopRaw<IPC::DomainMessageHeader>());
     }
 
     data_payload_header =
@@ -201,7 +195,7 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, P
 
     // TODO(Subv): Translate the X/A/B/W buffers.
 
-    if (Session()->IsDomain() && domain_message_header) {
+    if (Session()->IsDomain()) {
         ASSERT(domain_message_header->num_objects == domain_objects.size());
         // Write the domain objects to the command buffer, these go after the raw untranslated data.
         // TODO(Subv): This completely ignores C buffers.
@@ -216,98 +210,4 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, P
     return RESULT_SUCCESS;
 }
 
-std::vector<u8> HLERequestContext::ReadBuffer() const {
-    std::vector<u8> buffer;
-    const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[0].Size()};
-
-    if (is_buffer_a) {
-        buffer.resize(BufferDescriptorA()[0].Size());
-        Memory::ReadBlock(BufferDescriptorA()[0].Address(), buffer.data(), buffer.size());
-    } else {
-        buffer.resize(BufferDescriptorX()[0].Size());
-        Memory::ReadBlock(BufferDescriptorX()[0].Address(), buffer.data(), buffer.size());
-    }
-
-    return buffer;
-}
-
-size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size) const {
-    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
-
-    ASSERT_MSG(size <= GetWriteBufferSize(), "Size %d is too big", size);
-
-    if (is_buffer_b) {
-        Memory::WriteBlock(BufferDescriptorB()[0].Address(), buffer, size);
-    } else {
-        Memory::WriteBlock(BufferDescriptorC()[0].Address(), buffer, size);
-    }
-
-    return size;
-}
-
-size_t HLERequestContext::WriteBuffer(const std::vector<u8>& buffer) const {
-    return WriteBuffer(buffer.data(), buffer.size());
-}
-
-size_t HLERequestContext::GetReadBufferSize() const {
-    const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[0].Size()};
-    return is_buffer_a ? BufferDescriptorA()[0].Size() : BufferDescriptorX()[0].Size();
-}
-
-size_t HLERequestContext::GetWriteBufferSize() const {
-    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
-    return is_buffer_b ? BufferDescriptorB()[0].Size() : BufferDescriptorC()[0].Size();
-}
-
-std::string HLERequestContext::Description() const {
-    if (!command_header) {
-        return "No command header available";
-    }
-    std::ostringstream s;
-    s << "IPC::CommandHeader: Type:" << static_cast<u32>(command_header->type.Value());
-    s << ", X(Pointer):" << command_header->num_buf_x_descriptors;
-    if (command_header->num_buf_x_descriptors) {
-        s << '[';
-        for (u64 i = 0; i < command_header->num_buf_x_descriptors; ++i) {
-            s << "0x" << std::hex << BufferDescriptorX()[i].Size();
-            if (i < command_header->num_buf_x_descriptors - 1)
-                s << ", ";
-        }
-        s << ']';
-    }
-    s << ", A(Send):" << command_header->num_buf_a_descriptors;
-    if (command_header->num_buf_a_descriptors) {
-        s << '[';
-        for (u64 i = 0; i < command_header->num_buf_a_descriptors; ++i) {
-            s << "0x" << std::hex << BufferDescriptorA()[i].Size();
-            if (i < command_header->num_buf_a_descriptors - 1)
-                s << ", ";
-        }
-        s << ']';
-    }
-    s << ", B(Receive):" << command_header->num_buf_b_descriptors;
-    if (command_header->num_buf_b_descriptors) {
-        s << '[';
-        for (u64 i = 0; i < command_header->num_buf_b_descriptors; ++i) {
-            s << "0x" << std::hex << BufferDescriptorB()[i].Size();
-            if (i < command_header->num_buf_b_descriptors - 1)
-                s << ", ";
-        }
-        s << ']';
-    }
-    s << ", C(ReceiveList):" << BufferDescriptorC().size();
-    if (!BufferDescriptorC().empty()) {
-        s << '[';
-        for (u64 i = 0; i < BufferDescriptorC().size(); ++i) {
-            s << "0x" << std::hex << BufferDescriptorC()[i].Size();
-            if (i < BufferDescriptorC().size() - 1)
-                s << ", ";
-        }
-        s << ']';
-    }
-    s << ", data_size:" << command_header->data_size.Value();
-
-    return s.str();
-}
-
 } // namespace Kernel

src/core/hle/kernel/hle_ipc.h

@@ -143,21 +143,6 @@ public:
         return domain_message_header;
     }
 
-    /// Helper function to read a buffer using the appropriate buffer descriptor
-    std::vector<u8> ReadBuffer() const;
-
-    /// Helper function to write a buffer using the appropriate buffer descriptor
-    size_t WriteBuffer(const void* buffer, size_t size) const;
-
-    /// Helper function to write a buffer using the appropriate buffer descriptor
-    size_t WriteBuffer(const std::vector<u8>& buffer) const;
-
-    /// Helper function to get the size of the input buffer
-    size_t GetReadBufferSize() const;
-
-    /// Helper function to get the size of the output buffer
-    size_t GetWriteBufferSize() const;
-
     template <typename T>
     SharedPtr<T> GetCopyObject(size_t index) {
         ASSERT(index < copy_objects.size());
@@ -202,8 +187,6 @@ public:
         return domain_objects.size();
     }
 
-    std::string Description() const;
-
 private:
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
     SharedPtr<Kernel::ServerSession> server_session;

src/core/hle/kernel/process.cpp

@@ -20,9 +20,12 @@ namespace Kernel {
 // Lists all processes that exist in the current session.
 static std::vector<SharedPtr<Process>> process_list;
 
-SharedPtr<CodeSet> CodeSet::Create(std::string name) {
+SharedPtr<CodeSet> CodeSet::Create(std::string name, u64 program_id) {
     SharedPtr<CodeSet> codeset(new CodeSet);
+
     codeset->name = std::move(name);
+    codeset->program_id = program_id;
+
     return codeset;
 }
 
@@ -31,14 +34,13 @@ CodeSet::~CodeSet() {}
 
 u32 Process::next_process_id;
 
-SharedPtr<Process> Process::Create(std::string&& name, u64 program_id) {
+SharedPtr<Process> Process::Create(std::string&& name) {
     SharedPtr<Process> process(new Process);
 
     process->name = std::move(name);
     process->flags.raw = 0;
     process->flags.memory_region.Assign(MemoryRegion::APPLICATION);
     process->status = ProcessStatus::Created;
-    process->program_id = program_id;
 
     process_list.push_back(process);
     return process;

src/core/hle/kernel/process.h

@@ -56,7 +56,7 @@ class ResourceLimit;
 struct MemoryRegionInfo;
 
 struct CodeSet final : public Object {
-    static SharedPtr<CodeSet> Create(std::string name);
+    static SharedPtr<CodeSet> Create(std::string name, u64 program_id);
 
     std::string GetTypeName() const override {
         return "CodeSet";
@@ -72,6 +72,8 @@ struct CodeSet final : public Object {
 
     /// Name of the process
     std::string name;
+    /// Title ID corresponding to the process
+    u64 program_id;
 
     std::shared_ptr<std::vector<u8>> memory;
 
@@ -95,7 +97,7 @@ private:
 
 class Process final : public Object {
 public:
-    static SharedPtr<Process> Create(std::string&& name, u64 program_id);
+    static SharedPtr<Process> Create(std::string&& name);
 
     std::string GetTypeName() const override {
         return "Process";
@@ -111,9 +113,6 @@ public:
 
     static u32 next_process_id;
 
-    /// Title ID corresponding to the process
-    u64 program_id;
-
     /// Resource limit descriptor for this process
     SharedPtr<ResourceLimit> resource_limit;
 

src/core/hle/kernel/scheduler.cpp

@@ -1,134 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core_timing.h"
-#include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
-
-namespace Kernel {
-
-Scheduler::Scheduler(ARM_Interface* cpu_core) : cpu_core(cpu_core) {}
-
-Scheduler::~Scheduler() {
-    for (auto& thread : thread_list) {
-        thread->Stop();
-    }
-}
-
-bool Scheduler::HaveReadyThreads() {
-    return ready_queue.get_first() != nullptr;
-}
-
-Thread* Scheduler::GetCurrentThread() const {
-    return current_thread.get();
-}
-
-Thread* Scheduler::PopNextReadyThread() {
-    Thread* next = nullptr;
-    Thread* thread = GetCurrentThread();
-
-    if (thread && thread->status == THREADSTATUS_RUNNING) {
-        // We have to do better than the current thread.
-        // This call returns null when that's not possible.
-        next = ready_queue.pop_first_better(thread->current_priority);
-        if (!next) {
-            // Otherwise just keep going with the current thread
-            next = thread;
-        }
-    } else {
-        next = ready_queue.pop_first();
-    }
-
-    return next;
-}
-
-void Scheduler::SwitchContext(Thread* new_thread) {
-    Thread* previous_thread = GetCurrentThread();
-
-    // Save context for previous thread
-    if (previous_thread) {
-        previous_thread->last_running_ticks = CoreTiming::GetTicks();
-        cpu_core->SaveContext(previous_thread->context);
-
-        if (previous_thread->status == THREADSTATUS_RUNNING) {
-            // This is only the case when a reschedule is triggered without the current thread
-            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
-            ready_queue.push_front(previous_thread->current_priority, previous_thread);
-            previous_thread->status = THREADSTATUS_READY;
-        }
-    }
-
-    // Load context of new thread
-    if (new_thread) {
-        ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
-                   "Thread must be ready to become running.");
-
-        // Cancel any outstanding wakeup events for this thread
-        new_thread->CancelWakeupTimer();
-
-        auto previous_process = Kernel::g_current_process;
-
-        current_thread = new_thread;
-
-        ready_queue.remove(new_thread->current_priority, new_thread);
-        new_thread->status = THREADSTATUS_RUNNING;
-
-        if (previous_process != current_thread->owner_process) {
-            Kernel::g_current_process = current_thread->owner_process;
-            SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
-        }
-
-        cpu_core->LoadContext(new_thread->context);
-        cpu_core->SetTlsAddress(new_thread->GetTLSAddress());
-    } else {
-        current_thread = nullptr;
-        // Note: We do not reset the current process and current page table when idling because
-        // technically we haven't changed processes, our threads are just paused.
-    }
-}
-
-void Scheduler::Reschedule() {
-    Thread* cur = GetCurrentThread();
-    Thread* next = PopNextReadyThread();
-
-    if (cur && next) {
-        LOG_TRACE(Kernel, "context switch %u -> %u", cur->GetObjectId(), next->GetObjectId());
-    } else if (cur) {
-        LOG_TRACE(Kernel, "context switch %u -> idle", cur->GetObjectId());
-    } else if (next) {
-        LOG_TRACE(Kernel, "context switch idle -> %u", next->GetObjectId());
-    }
-
-    SwitchContext(next);
-}
-
-void Scheduler::AddThread(SharedPtr<Thread> thread, u32 priority) {
-    thread_list.push_back(thread);
-    ready_queue.prepare(priority);
-}
-
-void Scheduler::RemoveThread(Thread* thread) {
-    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
-                      thread_list.end());
-}
-
-void Scheduler::ScheduleThread(Thread* thread, u32 priority) {
-    ASSERT(thread->status == THREADSTATUS_READY);
-    ready_queue.push_back(priority, thread);
-}
-
-void Scheduler::UnscheduleThread(Thread* thread, u32 priority) {
-    ASSERT(thread->status == THREADSTATUS_READY);
-    ready_queue.remove(priority, thread);
-}
-
-void Scheduler::SetThreadPriority(Thread* thread, u32 priority) {
-    // If thread was ready, adjust queues
-    if (thread->status == THREADSTATUS_READY)
-        ready_queue.move(thread, thread->current_priority, priority);
-    else
-        ready_queue.prepare(priority);
-}
-
-} // namespace Kernel

src/core/hle/kernel/scheduler.h

@@ -1,73 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-#include "common/thread_queue_list.h"
-#include "core/arm/arm_interface.h"
-#include "core/hle/kernel/thread.h"
-
-namespace Kernel {
-
-class Scheduler final {
-public:
-    explicit Scheduler(ARM_Interface* cpu_core);
-    ~Scheduler();
-
-    /// Returns whether there are any threads that are ready to run.
-    bool HaveReadyThreads();
-
-    /// Reschedules to the next available thread (call after current thread is suspended)
-    void Reschedule();
-
-    /// Gets the current running thread
-    Thread* GetCurrentThread() const;
-
-    /// Adds a new thread to the scheduler
-    void AddThread(SharedPtr<Thread> thread, u32 priority);
-
-    /// Removes a thread from the scheduler
-    void RemoveThread(Thread* thread);
-
-    /// Schedules a thread that has become "ready"
-    void ScheduleThread(Thread* thread, u32 priority);
-
-    /// Unschedules a thread that was already scheduled
-    void UnscheduleThread(Thread* thread, u32 priority);
-
-    /// Sets the priority of a thread in the scheduler
-    void SetThreadPriority(Thread* thread, u32 priority);
-
-    /// Returns a list of all threads managed by the scheduler
-    const std::vector<SharedPtr<Thread>>& GetThreadList() const {
-        return thread_list;
-    }
-
-private:
-    /**
-     * Pops and returns the next thread from the thread queue
-     * @return A pointer to the next ready thread
-     */
-    Thread* PopNextReadyThread();
-
-    /**
-     * Switches the CPU's active thread context to that of the specified thread
-     * @param new_thread The thread to switch to
-     */
-    void SwitchContext(Thread* new_thread);
-
-    /// Lists all thread ids that aren't deleted/etc.
-    std::vector<SharedPtr<Thread>> thread_list;
-
-    /// Lists only ready thread ids.
-    Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
-
-    SharedPtr<Thread> current_thread = nullptr;
-
-    ARM_Interface* cpu_core;
-};
-
-} // namespace Kernel

src/core/hle/kernel/server_session.cpp

@@ -57,33 +57,6 @@ void ServerSession::Acquire(Thread* thread) {
     pending_requesting_threads.pop_back();
 }
 
-ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
-    auto& domain_message_header = context.GetDomainMessageHeader();
-    if (domain_message_header) {
-        // If there is a DomainMessageHeader, then this is CommandType "Request"
-        const u32 object_id{context.GetDomainMessageHeader()->object_id};
-        switch (domain_message_header->command) {
-        case IPC::DomainMessageHeader::CommandType::SendMessage:
-            return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
-
-        case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
-            LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x%08X", object_id);
-
-            domain_request_handlers[object_id - 1] = nullptr;
-
-            IPC::ResponseBuilder rb{context, 2};
-            rb.Push(RESULT_SUCCESS);
-            return RESULT_SUCCESS;
-        }
-        }
-
-        LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
-        ASSERT(false);
-    }
-
-    return RESULT_SUCCESS;
-}
-
 ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // The ServerSession received a sync request, this means that there's new data available
     // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or
@@ -94,39 +67,46 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     context.PopulateFromIncomingCommandBuffer(cmd_buf, *Kernel::g_current_process,
                                               Kernel::g_handle_table);
 
-    ResultCode result = RESULT_SUCCESS;
-    // If the session has been converted to a domain, handle the domain request
-    if (IsDomain() && context.GetDomainMessageHeader()) {
-        result = HandleDomainSyncRequest(context);
+    // If the session has been converted to a domain, handle the doomain request
+    if (IsDomain()) {
+        auto& domain_message_header = context.GetDomainMessageHeader();
+        if (domain_message_header) {
+            // If there is a DomainMessageHeader, then this is CommandType "Request"
+            const u32 object_id{context.GetDomainMessageHeader()->object_id};
+            switch (domain_message_header->command) {
+            case IPC::DomainMessageHeader::CommandType::SendMessage:
+                return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
+
+            case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
+                LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x%08X", object_id);
+
+                domain_request_handlers[object_id - 1] = nullptr;
+
+                IPC::ResponseBuilder rb{context, 2};
+                rb.Push(RESULT_SUCCESS);
+                return RESULT_SUCCESS;
+            }
+            }
+
+            LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
+            ASSERT(false);
+        }
         // If there is no domain header, the regular session handler is used
-    } else if (hle_handler != nullptr) {
-        // If this ServerSession has an associated HLE handler, forward the request to it.
-        result = hle_handler->HandleSyncRequest(context);
     }
 
-    if (thread->status == THREADSTATUS_RUNNING) {
-        // Put the thread to sleep until the server replies, it will be awoken in
-        // svcReplyAndReceive for LLE servers.
-        thread->status = THREADSTATUS_WAIT_IPC;
+    // If this ServerSession has an associated HLE handler, forward the request to it.
+    ResultCode result{RESULT_SUCCESS};
+    if (hle_handler != nullptr) {
+        // Attempt to translate the incoming request's command buffer.
+        ResultCode translate_result = TranslateHLERequest(this);
+        if (translate_result.IsError())
+            return translate_result;
 
-        if (hle_handler != nullptr) {
-            // For HLE services, we put the request threads to sleep for a short duration to
-            // simulate IPC overhead, but only if the HLE handler didn't put the thread to sleep for
-            // other reasons like an async callback. The IPC overhead is needed to prevent
-            // starvation when a thread only does sync requests to HLE services while a
-            // lower-priority thread is waiting to run.
-
-            // This delay was approximated in a homebrew application by measuring the average time
-            // it takes for svcSendSyncRequest to return when performing the SetLcdForceBlack IPC
-            // request to the GSP:GPU service in a n3DS with firmware 11.6. The measured values have
-            // a high variance and vary between models.
-            static constexpr u64 IPCDelayNanoseconds = 39000;
-            thread->WakeAfterDelay(IPCDelayNanoseconds);
-        } else {
-            // Add the thread to the list of threads that have issued a sync request with this
-            // server.
-            pending_requesting_threads.push_back(std::move(thread));
-        }
+        result = hle_handler->HandleSyncRequest(context);
+    } else {
+        // Add the thread to the list of threads that have issued a sync request with this
+        // server.
+        pending_requesting_threads.push_back(std::move(thread));
     }
 
     // If this ServerSession does not have an HLE implementation, just wake up the threads waiting
@@ -160,4 +140,9 @@ ServerSession::SessionPair ServerSession::CreateSessionPair(const std::string& n
 
     return std::make_tuple(std::move(server_session), std::move(client_session));
 }
+
+ResultCode TranslateHLERequest(ServerSession* server_session) {
+    // TODO(Subv): Implement this function once multiple concurrent processes are supported.
+    return RESULT_SUCCESS;
+}
 } // namespace Kernel

src/core/hle/kernel/server_session.h

@@ -21,7 +21,6 @@ class ServerSession;
 class Session;
 class SessionRequestHandler;
 class Thread;
-class HLERequestContext;
 
 /**
  * Kernel object representing the server endpoint of an IPC session. Sessions are the basic CTR-OS
@@ -117,12 +116,17 @@ private:
      */
     static ResultVal<SharedPtr<ServerSession>> Create(std::string name = "Unknown");
 
-    /// Handles a SyncRequest to a domain, forwarding the request to the proper object or closing an
-    /// object handle.
-    ResultCode HandleDomainSyncRequest(Kernel::HLERequestContext& context);
-
     /// When set to True, converts the session to a domain at the end of the command
     bool convert_to_domain{};
 };
 
+/**
+ * Performs command buffer translation for an HLE IPC request.
+ * The command buffer from the ServerSession thread's TLS is copied into a
+ * buffer and all descriptors in the buffer are processed.
+ * TODO(Subv): Implement this function, currently we do not support multiple processes running at
+ * once, but once that is implemented we'll need to properly translate all descriptors
+ * in the command buffer.
+ */
+ResultCode TranslateHLERequest(ServerSession* server_session);
 } // namespace Kernel

src/core/hle/kernel/shared_memory.cpp

@@ -111,6 +111,13 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
         return ERR_INVALID_COMBINATION;
     }
 
+    // Heap-backed memory blocks can not be mapped with other_permissions = DontCare
+    if (base_address != 0 && other_permissions == MemoryPermission::DontCare) {
+        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, permissions don't match",
+                  GetObjectId(), address, name.c_str());
+        return ERR_INVALID_COMBINATION;
+    }
+
     // Error out if the provided permissions are not compatible with what the creator process needs.
     if (other_permissions != MemoryPermission::DontCare &&
         static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
@@ -119,6 +126,12 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
         return ERR_WRONG_PERMISSION;
     }
 
+    // TODO(Subv): Check for the Shared Device Mem flag in the creator process.
+    /*if (was_created_with_shared_device_mem && address != 0) {
+        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
+    ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+    }*/
+
     // TODO(Subv): The same process that created a SharedMemory object
     // can not map it in its own address space unless it was created with addr=0, result 0xD900182C.
 

src/core/hle/kernel/svc.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <cinttypes>
 
 #include "common/logging/log.h"
 #include "common/microprofile.h"
@@ -444,16 +443,6 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
     return RESULT_SUCCESS;
 }
 
-static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
-    LOG_WARNING(Kernel_SVC,
-                "called, shared_memory_handle=0x%08X, addr=0x%" PRIx64 ", size=0x%" PRIx64 "",
-                shared_memory_handle, addr, size);
-
-    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
-
-    return shared_memory->Unmap(g_current_process.get(), addr);
-}
-
 /// Query process memory
 static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
                                      Handle process_handle, u64 addr) {
@@ -494,7 +483,7 @@ static void ExitProcess() {
     g_current_process->status = ProcessStatus::Exited;
 
     // Stop all the process threads that are currently waiting for objects.
-    auto& thread_list = Core::System::GetInstance().Scheduler().GetThreadList();
+    auto& thread_list = GetThreadList();
     for (auto& thread : thread_list) {
         if (thread->owner_process != g_current_process)
             continue;
@@ -596,7 +585,7 @@ static void SleepThread(s64 nanoseconds) {
 
     // Don't attempt to yield execution if there are no available threads to run,
     // this way we avoid a useless reschedule to the idle thread.
-    if (nanoseconds == 0 && !Core::System::GetInstance().Scheduler().HaveReadyThreads())
+    if (nanoseconds == 0 && !HaveReadyThreads())
         return;
 
     // Sleep current thread and check for next thread to schedule
@@ -772,16 +761,6 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
     return RESULT_SUCCESS;
 }
 
-static ResultCode ClearEvent(Handle handle) {
-    LOG_TRACE(Kernel_SVC, "called, event=0xX", handle);
-
-    SharedPtr<Event> evt = g_handle_table.Get<Event>(handle);
-    if (evt == nullptr)
-        return ERR_INVALID_HANDLE;
-    evt->Clear();
-    return RESULT_SUCCESS;
-}
-
 namespace {
 struct FunctionDef {
     using Func = void();
@@ -811,9 +790,9 @@ static const FunctionDef SVC_Table[] = {
     {0x0F, SvcWrap<SetThreadCoreMask>, "SetThreadCoreMask"},
     {0x10, SvcWrap<GetCurrentProcessorNumber>, "GetCurrentProcessorNumber"},
     {0x11, nullptr, "SignalEvent"},
-    {0x12, SvcWrap<ClearEvent>, "ClearEvent"},
+    {0x12, nullptr, "ClearEvent"},
     {0x13, SvcWrap<MapSharedMemory>, "MapSharedMemory"},
-    {0x14, SvcWrap<UnmapSharedMemory>, "UnmapSharedMemory"},
+    {0x14, nullptr, "UnmapSharedMemory"},
     {0x15, SvcWrap<CreateTransferMemory>, "CreateTransferMemory"},
     {0x16, SvcWrap<CloseHandle>, "CloseHandle"},
     {0x17, SvcWrap<ResetSignal>, "ResetSignal"},

src/core/hle/kernel/svc_wrap.h

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

src/core/hle/kernel/thread.cpp

@@ -41,6 +41,14 @@ void Thread::Acquire(Thread* thread) {
 //               us to simply use a pool index or similar.
 static Kernel::HandleTable wakeup_callback_handle_table;
 
+// Lists all thread ids that aren't deleted/etc.
+static std::vector<SharedPtr<Thread>> thread_list;
+
+// Lists only ready thread ids.
+static Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
+
+static SharedPtr<Thread> current_thread;
+
 // The first available thread id at startup
 static u32 next_thread_id;
 
@@ -55,6 +63,10 @@ inline static u32 const NewThreadId() {
 Thread::Thread() {}
 Thread::~Thread() {}
 
+Thread* GetCurrentThread() {
+    return current_thread.get();
+}
+
 /**
  * Check if the specified thread is waiting on the specified address to be arbitrated
  * @param thread The thread to test
@@ -74,7 +86,7 @@ void Thread::Stop() {
     // Clean up thread from ready queue
     // This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
     if (status == THREADSTATUS_READY) {
-        Core::System::GetInstance().Scheduler().UnscheduleThread(this, current_priority);
+        ready_queue.remove(current_priority, this);
     }
 
     status = THREADSTATUS_DEAD;
@@ -97,6 +109,112 @@ void Thread::Stop() {
     Kernel::g_current_process->tls_slots[tls_page].reset(tls_slot);
 }
 
+Thread* ArbitrateHighestPriorityThread(u32 address) {
+    Thread* highest_priority_thread = nullptr;
+    u32 priority = THREADPRIO_LOWEST;
+
+    // Iterate through threads, find highest priority thread that is waiting to be arbitrated...
+    for (auto& thread : thread_list) {
+        if (!CheckWait_AddressArbiter(thread.get(), address))
+            continue;
+
+        if (thread == nullptr)
+            continue;
+
+        if (thread->current_priority <= priority) {
+            highest_priority_thread = thread.get();
+            priority = thread->current_priority;
+        }
+    }
+
+    // If a thread was arbitrated, resume it
+    if (nullptr != highest_priority_thread) {
+        highest_priority_thread->ResumeFromWait();
+    }
+
+    return highest_priority_thread;
+}
+
+void ArbitrateAllThreads(u32 address) {
+    // Resume all threads found to be waiting on the address
+    for (auto& thread : thread_list) {
+        if (CheckWait_AddressArbiter(thread.get(), address))
+            thread->ResumeFromWait();
+    }
+}
+
+/**
+ * Switches the CPU's active thread context to that of the specified thread
+ * @param new_thread The thread to switch to
+ */
+static void SwitchContext(Thread* new_thread) {
+    Thread* previous_thread = GetCurrentThread();
+
+    // Save context for previous thread
+    if (previous_thread) {
+        previous_thread->last_running_ticks = CoreTiming::GetTicks();
+        Core::CPU().SaveContext(previous_thread->context);
+
+        if (previous_thread->status == THREADSTATUS_RUNNING) {
+            // This is only the case when a reschedule is triggered without the current thread
+            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
+            ready_queue.push_front(previous_thread->current_priority, previous_thread);
+            previous_thread->status = THREADSTATUS_READY;
+        }
+    }
+
+    // Load context of new thread
+    if (new_thread) {
+        ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
+                   "Thread must be ready to become running.");
+
+        // Cancel any outstanding wakeup events for this thread
+        CoreTiming::UnscheduleEvent(ThreadWakeupEventType, new_thread->callback_handle);
+
+        auto previous_process = Kernel::g_current_process;
+
+        current_thread = new_thread;
+
+        ready_queue.remove(new_thread->current_priority, new_thread);
+        new_thread->status = THREADSTATUS_RUNNING;
+
+        if (previous_process != current_thread->owner_process) {
+            Kernel::g_current_process = current_thread->owner_process;
+            SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
+        }
+
+        Core::CPU().LoadContext(new_thread->context);
+        Core::CPU().SetTlsAddress(new_thread->GetTLSAddress());
+    } else {
+        current_thread = nullptr;
+        // Note: We do not reset the current process and current page table when idling because
+        // technically we haven't changed processes, our threads are just paused.
+    }
+}
+
+/**
+ * Pops and returns the next thread from the thread queue
+ * @return A pointer to the next ready thread
+ */
+static Thread* PopNextReadyThread() {
+    Thread* next;
+    Thread* thread = GetCurrentThread();
+
+    if (thread && thread->status == THREADSTATUS_RUNNING) {
+        // We have to do better than the current thread.
+        // This call returns null when that's not possible.
+        next = ready_queue.pop_first_better(thread->current_priority);
+        if (!next) {
+            // Otherwise just keep going with the current thread
+            next = thread;
+        }
+    } else {
+        next = ready_queue.pop_first();
+    }
+
+    return next;
+}
+
 void WaitCurrentThread_Sleep() {
     Thread* thread = GetCurrentThread();
     thread->status = THREADSTATUS_WAIT_SLEEP;
@@ -111,7 +229,8 @@ void WaitCurrentThread_ArbitrateAddress(VAddr wait_address) {
 void ExitCurrentThread() {
     Thread* thread = GetCurrentThread();
     thread->Stop();
-    Core::System::GetInstance().Scheduler().RemoveThread(thread);
+    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
+                      thread_list.end());
 }
 
 /**
@@ -165,7 +284,6 @@ void Thread::ResumeFromWait() {
     case THREADSTATUS_WAIT_SYNCH_ANY:
     case THREADSTATUS_WAIT_ARB:
     case THREADSTATUS_WAIT_SLEEP:
-    case THREADSTATUS_WAIT_IPC:
         break;
 
     case THREADSTATUS_READY:
@@ -189,11 +307,31 @@ void Thread::ResumeFromWait() {
 
     wakeup_callback = nullptr;
 
+    ready_queue.push_back(current_priority, this);
     status = THREADSTATUS_READY;
-    Core::System::GetInstance().Scheduler().ScheduleThread(this, current_priority);
     Core::System::GetInstance().PrepareReschedule();
 }
 
+/**
+ * Prints the thread queue for debugging purposes
+ */
+static void DebugThreadQueue() {
+    Thread* thread = GetCurrentThread();
+    if (!thread) {
+        LOG_DEBUG(Kernel, "Current: NO CURRENT THREAD");
+    } else {
+        LOG_DEBUG(Kernel, "0x%02X %u (current)", thread->current_priority,
+                  GetCurrentThread()->GetObjectId());
+    }
+
+    for (auto& t : thread_list) {
+        u32 priority = ready_queue.contains(t.get());
+        if (priority != -1) {
+            LOG_DEBUG(Kernel, "0x%02X %u", priority, t->GetObjectId());
+        }
+    }
+}
+
 /**
  * Finds a free location for the TLS section of a thread.
  * @param tls_slots The TLS page array of the thread's owner process.
@@ -261,7 +399,8 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
 
     SharedPtr<Thread> thread(new Thread);
 
-    Core::System::GetInstance().Scheduler().AddThread(thread, priority);
+    thread_list.push_back(thread);
+    ready_queue.prepare(priority);
 
     thread->thread_id = NewThreadId();
     thread->status = THREADSTATUS_DORMANT;
@@ -332,7 +471,12 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
 void Thread::SetPriority(u32 priority) {
     ASSERT_MSG(priority <= THREADPRIO_LOWEST && priority >= THREADPRIO_HIGHEST,
                "Invalid priority value.");
-    Core::System::GetInstance().Scheduler().SetThreadPriority(this, priority);
+    // If thread was ready, adjust queues
+    if (status == THREADSTATUS_READY)
+        ready_queue.move(this, current_priority, priority);
+    else
+        ready_queue.prepare(priority);
+
     nominal_priority = current_priority = priority;
 }
 
@@ -346,7 +490,11 @@ void Thread::UpdatePriority() {
 }
 
 void Thread::BoostPriority(u32 priority) {
-    Core::System::GetInstance().Scheduler().SetThreadPriority(this, priority);
+    // If thread was ready, adjust queues
+    if (status == THREADSTATUS_READY)
+        ready_queue.move(this, current_priority, priority);
+    else
+        ready_queue.prepare(priority);
     current_priority = priority;
 }
 
@@ -372,6 +520,25 @@ SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
     return thread;
 }
 
+bool HaveReadyThreads() {
+    return ready_queue.get_first() != nullptr;
+}
+
+void Reschedule() {
+    Thread* cur = GetCurrentThread();
+    Thread* next = PopNextReadyThread();
+
+    if (cur && next) {
+        LOG_TRACE(Kernel, "context switch %u -> %u", cur->GetObjectId(), next->GetObjectId());
+    } else if (cur) {
+        LOG_TRACE(Kernel, "context switch %u -> idle", cur->GetObjectId());
+    } else if (next) {
+        LOG_TRACE(Kernel, "context switch idle -> %u", next->GetObjectId());
+    }
+
+    SwitchContext(next);
+}
+
 void Thread::SetWaitSynchronizationResult(ResultCode result) {
     context.cpu_registers[0] = result.raw;
 }
@@ -394,20 +561,25 @@ VAddr Thread::GetCommandBufferAddress() const {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-/**
- * Gets the current thread
- */
-Thread* GetCurrentThread() {
-    return Core::System::GetInstance().Scheduler().GetCurrentThread();
-}
-
 void ThreadingInit() {
     ThreadWakeupEventType = CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
+
+    current_thread = nullptr;
     next_thread_id = 1;
 }
 
 void ThreadingShutdown() {
-    Kernel::ClearProcessList();
+    current_thread = nullptr;
+
+    for (auto& t : thread_list) {
+        t->Stop();
+    }
+    thread_list.clear();
+    ready_queue.clear();
+}
+
+const std::vector<SharedPtr<Thread>>& GetThreadList() {
+    return thread_list;
 }
 
 } // namespace Kernel

src/core/hle/kernel/thread.h

@@ -40,7 +40,6 @@ enum ThreadStatus {
     THREADSTATUS_READY,          ///< Ready to run
     THREADSTATUS_WAIT_ARB,       ///< Waiting on an address arbiter
     THREADSTATUS_WAIT_SLEEP,     ///< Waiting due to a SleepThread SVC
-    THREADSTATUS_WAIT_IPC,       ///< Waiting for the reply from an IPC request
     THREADSTATUS_WAIT_SYNCH_ANY, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
     THREADSTATUS_WAIT_SYNCH_ALL, ///< Waiting due to WaitSynchronizationN with wait_all = true
     THREADSTATUS_DORMANT,        ///< Created but not yet made ready
@@ -249,6 +248,28 @@ private:
 SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
                                   SharedPtr<Process> owner_process);
 
+/**
+ * Returns whether there are any threads that are ready to run.
+ */
+bool HaveReadyThreads();
+
+/**
+ * Reschedules to the next available thread (call after current thread is suspended)
+ */
+void Reschedule();
+
+/**
+ * Arbitrate the highest priority thread that is waiting
+ * @param address The address for which waiting threads should be arbitrated
+ */
+Thread* ArbitrateHighestPriorityThread(VAddr address);
+
+/**
+ * Arbitrate all threads currently waiting.
+ * @param address The address for which waiting threads should be arbitrated
+ */
+void ArbitrateAllThreads(VAddr address);
+
 /**
  * Gets the current thread
  */
@@ -280,4 +301,9 @@ void ThreadingInit();
  */
 void ThreadingShutdown();
 
+/**
+ * Get a const reference to the thread list for debug use
+ */
+const std::vector<SharedPtr<Thread>>& GetThreadList();
+
 } // namespace Kernel

src/core/hle/result.h

@@ -108,11 +108,11 @@ union ResultCode {
     }
 
     constexpr bool IsSuccess() const {
-        return raw == 0;
+        return is_error.ExtractValue(raw) == 0;
     }
 
     constexpr bool IsError() const {
-        return raw != 0;
+        return is_error.ExtractValue(raw) == 1;
     }
 };
 

src/core/hle/service/acc/acc_u0.cpp

@@ -65,19 +65,12 @@ void ACC_U0::GetUserExistence(Kernel::HLERequestContext& ctx) {
 }
 
 void ACC_U0::ListAllUsers(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
     constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids.data(), user_ids.size());
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void ACC_U0::ListOpenUsers(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids.data(), user_ids.size());
+    const auto& output_buffer = ctx.BufferDescriptorC()[0];
+    Memory::WriteBlock(output_buffer.Address(), user_ids.data(), user_ids.size());
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
+    LOG_DEBUG(Service_ACC, "called");
 }
 
 void ACC_U0::GetProfile(Kernel::HLERequestContext& ctx) {
@@ -111,7 +104,6 @@ ACC_U0::ACC_U0() : ServiceFramework("acc:u0") {
     static const FunctionInfo functions[] = {
         {1, &ACC_U0::GetUserExistence, "GetUserExistence"},
         {2, &ACC_U0::ListAllUsers, "ListAllUsers"},
-        {3, &ACC_U0::ListOpenUsers, "ListOpenUsers"},
         {4, &ACC_U0::GetLastOpenedUser, "GetLastOpenedUser"},
         {5, &ACC_U0::GetProfile, "GetProfile"},
         {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},

src/core/hle/service/acc/acc_u0.h

@@ -29,7 +29,6 @@ public:
 private:
     void GetUserExistence(Kernel::HLERequestContext& ctx);
     void ListAllUsers(Kernel::HLERequestContext& ctx);
-    void ListOpenUsers(Kernel::HLERequestContext& ctx);
     void GetLastOpenedUser(Kernel::HLERequestContext& ctx);
     void GetProfile(Kernel::HLERequestContext& ctx);
     void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);

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

@@ -34,38 +34,7 @@ void IWindowController::AcquireForegroundRights(Kernel::HLERequestContext& ctx)
     rb.Push(RESULT_SUCCESS);
 }
 
-IAudioController::IAudioController() : ServiceFramework("IAudioController") {
-    static const FunctionInfo functions[] = {
-        {0, &IAudioController::SetExpectedMasterVolume, "SetExpectedMasterVolume"},
-        {1, &IAudioController::GetMainAppletExpectedMasterVolume,
-         "GetMainAppletExpectedMasterVolume"},
-        {2, &IAudioController::GetLibraryAppletExpectedMasterVolume,
-         "GetLibraryAppletExpectedMasterVolume"},
-        {3, nullptr, "ChangeMainAppletMasterVolume"},
-        {4, nullptr, "SetTransparentVolumeRate"},
-    };
-    RegisterHandlers(functions);
-}
-
-void IAudioController::SetExpectedMasterVolume(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void IAudioController::GetMainAppletExpectedMasterVolume(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(volume);
-}
-
-void IAudioController::GetLibraryAppletExpectedMasterVolume(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(volume);
-}
+IAudioController::IAudioController() : ServiceFramework("IAudioController") {}
 
 IDisplayController::IDisplayController() : ServiceFramework("IDisplayController") {}
 
@@ -77,7 +46,6 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {1, &ISelfController::LockExit, "LockExit"},
         {2, &ISelfController::UnlockExit, "UnlockExit"},
         {9, &ISelfController::GetLibraryAppletLaunchableEvent, "GetLibraryAppletLaunchableEvent"},
-        {10, &ISelfController::SetScreenShotPermission, "SetScreenShotPermission"},
         {11, &ISelfController::SetOperationModeChangedNotification,
          "SetOperationModeChangedNotification"},
         {12, &ISelfController::SetPerformanceModeChangedNotification,
@@ -130,13 +98,6 @@ void ISelfController::SetPerformanceModeChangedNotification(Kernel::HLERequestCo
     LOG_WARNING(Service_AM, "(STUBBED) called flag=%u", static_cast<u32>(flag));
 }
 
-void ISelfController::SetScreenShotPermission(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
 void ISelfController::SetOperationModeChangedNotification(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
@@ -345,11 +306,11 @@ private:
 
         u64 offset = rp.Pop<u64>();
 
-        const size_t size{ctx.GetWriteBufferSize()};
+        const auto& output_buffer = ctx.BufferDescriptorC()[0];
 
-        ASSERT(offset + size <= buffer.size());
+        ASSERT(offset + output_buffer.Size() <= buffer.size());
 
-        ctx.WriteBuffer(buffer.data() + offset, size);
+        Memory::WriteBlock(output_buffer.Address(), buffer.data() + offset, output_buffer.Size());
 
         IPC::ResponseBuilder rb{ctx, 2};
 
@@ -417,9 +378,8 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
 
 void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 4};
+    IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0);
 }
 
 void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {

src/core/hle/service/am/am.h

@@ -36,13 +36,6 @@ private:
 class IAudioController final : public ServiceFramework<IAudioController> {
 public:
     IAudioController();
-
-private:
-    void SetExpectedMasterVolume(Kernel::HLERequestContext& ctx);
-    void GetMainAppletExpectedMasterVolume(Kernel::HLERequestContext& ctx);
-    void GetLibraryAppletExpectedMasterVolume(Kernel::HLERequestContext& ctx);
-
-    u32 volume{100};
 };
 
 class IDisplayController final : public ServiceFramework<IDisplayController> {
@@ -69,7 +62,6 @@ private:
     void UnlockExit(Kernel::HLERequestContext& ctx);
     void GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx);
     void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx);
-    void SetScreenShotPermission(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     Kernel::SharedPtr<Kernel::Event> launchable_event;

src/core/hle/service/aoc/aoc_u.cpp

@@ -2,44 +2,16 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/aoc/aoc_u.h"
 
 namespace Service {
 namespace AOC {
 
-AOC_U::AOC_U() : ServiceFramework("aoc:u") {
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "CountAddOnContentByApplicationId"},
-        {1, nullptr, "ListAddOnContentByApplicationId"},
-        {2, &AOC_U::CountAddOnContent, "CountAddOnContent"},
-        {3, &AOC_U::ListAddOnContent, "ListAddOnContent"},
-        {4, nullptr, "GetAddOnContentBaseIdByApplicationId"},
-        {5, nullptr, "GetAddOnContentBaseId"},
-        {6, nullptr, "PrepareAddOnContentByApplicationId"},
-        {7, nullptr, "PrepareAddOnContent"},
-    };
-    RegisterHandlers(functions);
-}
-
-void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0);
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-}
-
-void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0);
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-}
-
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<AOC_U>()->InstallAsService(service_manager);
 }
 
+AOC_U::AOC_U() : ServiceFramework("aoc:u") {}
+
 } // namespace AOC
 } // namespace Service

src/core/hle/service/aoc/aoc_u.h

@@ -13,10 +13,6 @@ class AOC_U final : public ServiceFramework<AOC_U> {
 public:
     AOC_U();
     ~AOC_U() = default;
-
-private:
-    void CountAddOnContent(Kernel::HLERequestContext& ctx);
-    void ListAddOnContent(Kernel::HLERequestContext& ctx);
 };
 
 /// Registers all AOC services with the specified service manager.

src/core/hle/service/audio/audout_u.cpp

@@ -99,6 +99,8 @@ private:
     void GetReleasedAudioOutBuffer_1(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
+        const auto& buffer = ctx.BufferDescriptorB()[0];
+
         // TODO(st4rk): This is how libtransistor currently implements the
         // GetReleasedAudioOutBuffer, it should return the key (a VAddr) to the app and this address
         // is used to know which buffer should be filled with data and send again to the service
@@ -110,7 +112,7 @@ private:
             queue_keys.pop_back();
         }
 
-        ctx.WriteBuffer(&key, sizeof(u64));
+        Memory::WriteBlock(buffer.Address(), &key, sizeof(u64));
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
@@ -156,8 +158,10 @@ void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_Audio, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
 
+    auto& buffer = ctx.BufferDescriptorB()[0];
     const std::string audio_interface = "AudioInterface";
-    ctx.WriteBuffer(audio_interface.c_str(), audio_interface.size());
+
+    Memory::WriteBlock(buffer.Address(), &audio_interface[0], audio_interface.size());
 
     IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);
 

src/core/hle/service/audio/audren_u.cpp

@@ -53,8 +53,7 @@ private:
     }
 
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Audio, "%s", ctx.Description().c_str());
-        AudioRendererResponseData response_data{};
+        AudioRendererResponseData response_data = {0};
 
         response_data.section_0_size =
             response_data.state_entries.size() * sizeof(AudioRendererStateEntry);
@@ -70,7 +69,9 @@ private:
             response_data.state_entries[i].state = 5;
         }
 
-        ctx.WriteBuffer(&response_data, response_data.total_size);
+        auto& buffer = ctx.BufferDescriptorB()[0];
+
+        Memory::WriteBlock(buffer.Address(), &response_data, response_data.total_size);
 
         IPC::ResponseBuilder rb{ctx, 2};
 
@@ -178,10 +179,10 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
 }
 
 void AudRenU::GetAudioRenderersProcessMasterVolume(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::ResponseBuilder rb{ctx, 2};
 
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(100);
+
     LOG_WARNING(Service_Audio, "(STUBBED) called");
 }
 

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

@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <boost/container/flat_map.hpp>
-#include "common/file_util.h"
 #include "core/file_sys/filesystem.h"
-#include "core/file_sys/savedata_factory.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
 
@@ -43,17 +41,12 @@ ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenFileSystem(Type type,
     return itr->second->Open(path);
 }
 
-void RegisterFileSystems() {
+void UnregisterFileSystems() {
     filesystem_map.clear();
-
-    std::string nand_directory = FileUtil::GetUserPath(D_NAND_IDX);
-
-    auto savedata = std::make_unique<FileSys::SaveData_Factory>(std::move(nand_directory));
-    RegisterFileSystem(std::move(savedata), Type::SaveData);
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
-    RegisterFileSystems();
+    UnregisterFileSystems();
     std::make_shared<FSP_SRV>()->InstallAsService(service_manager);
 }
 

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

@@ -25,7 +25,6 @@ namespace FileSystem {
 /// Supported FileSystem types
 enum class Type {
     RomFS = 1,
-    SaveData = 2,
 };
 
 /**

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

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/file_sys/filesystem.h"
@@ -34,10 +33,12 @@ private:
         IPC::RequestParser rp{ctx};
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
+        const auto& descriptor = ctx.BufferDescriptorB()[0];
 
         LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
 
         // Error checking
+        ASSERT_MSG(length == descriptor.Size(), "unexpected size difference");
         if (length < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
@@ -59,193 +60,17 @@ private:
         }
 
         // Write the data to memory
-        ctx.WriteBuffer(output);
+        Memory::WriteBlock(descriptor.Address(), output.data(), descriptor.Size());
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 };
 
-class IFile final : public ServiceFramework<IFile> {
-public:
-    explicit IFile(std::unique_ptr<FileSys::StorageBackend>&& backend)
-        : ServiceFramework("IFile"), backend(std::move(backend)) {
-        static const FunctionInfo functions[] = {
-            {0, &IFile::Read, "Read"}, {1, &IFile::Write, "Write"}, {2, nullptr, "Flush"},
-            {3, nullptr, "SetSize"},   {4, nullptr, "GetSize"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    std::unique_ptr<FileSys::StorageBackend> backend;
-
-    void Read(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 unk = rp.Pop<u64>();
-        const s64 offset = rp.Pop<s64>();
-        const s64 length = rp.Pop<s64>();
-
-        LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
-
-        // Error checking
-        if (length < 0) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
-            return;
-        }
-        if (offset < 0) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
-            return;
-        }
-
-        // Read the data from the Storage backend
-        std::vector<u8> output(length);
-        ResultVal<size_t> res = backend->Read(offset, length, output.data());
-        if (res.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(res.Code());
-            return;
-        }
-
-        // Write the data to memory
-        ctx.WriteBuffer(output);
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(static_cast<u64>(*res));
-    }
-
-    void Write(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 unk = rp.Pop<u64>();
-        const s64 offset = rp.Pop<s64>();
-        const s64 length = rp.Pop<s64>();
-
-        LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
-
-        // Error checking
-        if (length < 0) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
-            return;
-        }
-        if (offset < 0) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
-            return;
-        }
-
-        // Write the data to the Storage backend
-        std::vector<u8> data = ctx.ReadBuffer();
-        ResultVal<size_t> res = backend->Write(offset, length, true, data.data());
-        if (res.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(res.Code());
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-};
-
-class IFileSystem final : public ServiceFramework<IFileSystem> {
-public:
-    explicit IFileSystem(std::unique_ptr<FileSys::FileSystemBackend>&& backend)
-        : ServiceFramework("IFileSystem"), backend(std::move(backend)) {
-        static const FunctionInfo functions[] = {
-            {0, &IFileSystem::CreateFile, "CreateFile"},
-            {7, &IFileSystem::GetEntryType, "GetEntryType"},
-            {8, &IFileSystem::OpenFile, "OpenFile"},
-            {10, &IFileSystem::Commit, "Commit"},
-        };
-        RegisterHandlers(functions);
-    }
-
-    void CreateFile(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-
-        auto file_buffer = ctx.ReadBuffer();
-        auto end = std::find(file_buffer.begin(), file_buffer.end(), '\0');
-
-        std::string name(file_buffer.begin(), end);
-
-        u64 mode = rp.Pop<u64>();
-        u32 size = rp.Pop<u32>();
-
-        LOG_DEBUG(Service_FS, "called file %s mode 0x%" PRIX64 " size 0x%08X", name.c_str(), mode,
-                  size);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(backend->CreateFile(name, size));
-    }
-
-    void OpenFile(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-
-        auto file_buffer = ctx.ReadBuffer();
-        auto end = std::find(file_buffer.begin(), file_buffer.end(), '\0');
-
-        std::string name(file_buffer.begin(), end);
-
-        auto mode = static_cast<FileSys::Mode>(rp.Pop<u32>());
-
-        LOG_DEBUG(Service_FS, "called file %s mode %u", name.c_str(), static_cast<u32>(mode));
-
-        auto result = backend->OpenFile(name, mode);
-        if (result.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
-            return;
-        }
-
-        auto file = std::move(result.Unwrap());
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IFile>(std::move(file));
-    }
-
-    void GetEntryType(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-
-        auto file_buffer = ctx.ReadBuffer();
-        auto end = std::find(file_buffer.begin(), file_buffer.end(), '\0');
-
-        std::string name(file_buffer.begin(), end);
-
-        LOG_DEBUG(Service_FS, "called file %s", name.c_str());
-
-        auto result = backend->GetEntryType(name);
-        if (result.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(static_cast<u32>(*result));
-    }
-
-    void Commit(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_FS, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-private:
-    std::unique_ptr<FileSys::FileSystemBackend> backend;
-};
-
 FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
     static const FunctionInfo functions[] = {
         {1, &FSP_SRV::Initalize, "Initalize"},
         {18, &FSP_SRV::MountSdCard, "MountSdCard"},
-        {51, &FSP_SRV::MountSaveData, "MountSaveData"},
         {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
         {202, nullptr, "OpenDataStorageByDataId"},
         {203, &FSP_SRV::OpenRomStorage, "OpenRomStorage"},
@@ -279,17 +104,6 @@ void FSP_SRV::MountSdCard(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-
-    FileSys::Path unused;
-    auto filesystem = OpenFileSystem(Type::SaveData, unused).Unwrap();
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IFileSystem>(std::move(filesystem));
-}
-
 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 

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

@@ -24,7 +24,6 @@ private:
 
     void Initalize(Kernel::HLERequestContext& ctx);
     void MountSdCard(Kernel::HLERequestContext& ctx);
-    void MountSaveData(Kernel::HLERequestContext& ctx);
     void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
     void OpenRomStorage(Kernel::HLERequestContext& ctx);

src/core/hle/service/friend/friend.cpp

@@ -1,28 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/friend/friend.h"
-#include "core/hle/service/friend/friend_a.h"
-
-namespace Service {
-namespace Friend {
-
-void Module::Interface::Unknown(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_Friend, "(STUBBED) called");
-}
-
-Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
-
-void InstallInterfaces(SM::ServiceManager& service_manager) {
-    auto module = std::make_shared<Module>();
-    std::make_shared<Friend_A>(module)->InstallAsService(service_manager);
-}
-
-} // namespace Friend
-} // namespace Service

src/core/hle/service/friend/friend.h

@@ -1,29 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace Friend {
-
-class Module final {
-public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        Interface(std::shared_ptr<Module> module, const char* name);
-
-        void Unknown(Kernel::HLERequestContext& ctx);
-
-    protected:
-        std::shared_ptr<Module> module;
-    };
-};
-
-/// Registers all Friend services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager);
-
-} // namespace Friend
-} // namespace Service

src/core/hle/service/friend/friend_a.cpp

@@ -1,19 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/friend/friend_a.h"
-
-namespace Service {
-namespace Friend {
-
-Friend_A::Friend_A(std::shared_ptr<Module> module)
-    : Module::Interface(std::move(module), "friend:a") {
-    static const FunctionInfo functions[] = {
-        {0, &Friend_A::Unknown, "Unknown"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Friend
-} // namespace Service

src/core/hle/service/friend/friend_a.h

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/friend/friend.h"
-
-namespace Service {
-namespace Friend {
-
-class Friend_A final : public Module::Interface {
-public:
-    explicit Friend_A(std::shared_ptr<Module> module);
-};
-
-} // namespace Friend
-} // namespace Service

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

@@ -176,10 +176,7 @@ public:
             {0, &Hid::CreateAppletResource, "CreateAppletResource"},
             {1, &Hid::ActivateDebugPad, "ActivateDebugPad"},
             {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
-            {21, &Hid::ActivateMouse, "ActivateMouse"},
-            {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
             {66, &Hid::StartSixAxisSensor, "StartSixAxisSensor"},
-            {79, &Hid::SetGyroscopeZeroDriftMode, "SetGyroscopeZeroDriftMode"},
             {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
             {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
             {103, &Hid::ActivateNpad, "ActivateNpad"},
@@ -187,15 +184,9 @@ public:
              "AcquireNpadStyleSetUpdateEventHandle"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
-            {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,
-             "SetNpadJoyAssignmentModeSingleByDefault"},
             {124, nullptr, "SetNpadJoyAssignmentModeDual"},
             {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
-            {200, &Hid::GetVibrationDeviceInfo, "GetVibrationDeviceInfo"},
-            {201, &Hid::SendVibrationValue, "SendVibrationValue"},
-            {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
             {203, &Hid::CreateActiveVibrationDeviceList, "CreateActiveVibrationDeviceList"},
-            {206, &Hid::SendVibrationValues, "SendVibrationValues"},
         };
         RegisterHandlers(functions);
 
@@ -231,30 +222,12 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
-    void ActivateMouse(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void ActivateKeyboard(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void StartSixAxisSensor(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
-    void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -293,49 +266,18 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
-    void SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void SendVibrationValue(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
-    void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(0);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<IActiveVibrationDeviceList>();
         LOG_DEBUG(Service_HID, "called");
     }
-
-    void SendVibrationValues(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
 };
 
 void ReloadInputDevices() {}

src/core/hle/service/nifm/nifm.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/nifm/nifm_a.h"
 #include "core/hle/service/nifm/nifm_s.h"
@@ -29,9 +28,9 @@ class IRequest final : public ServiceFramework<IRequest> {
 public:
     explicit IRequest() : ServiceFramework("IRequest") {
         static const FunctionInfo functions[] = {
-            {0, &IRequest::GetRequestState, "GetRequestState"},
-            {1, &IRequest::GetResult, "GetResult"},
-            {2, &IRequest::GetSystemEventReadableHandles, "GetSystemEventReadableHandles"},
+            {0, nullptr, "GetRequestState"},
+            {1, nullptr, "GetResult"},
+            {2, nullptr, "GetSystemEventReadableHandles"},
             {3, nullptr, "Cancel"},
             {4, nullptr, "Submit"},
             {5, nullptr, "SetRequirement"},
@@ -56,32 +55,7 @@ public:
             {25, nullptr, "UnregisterSocketDescriptor"},
         };
         RegisterHandlers(functions);
-
-        event1 = Kernel::Event::Create(Kernel::ResetType::OneShot, "IRequest:Event1");
-        event2 = Kernel::Event::Create(Kernel::ResetType::OneShot, "IRequest:Event2");
     }
-
-private:
-    void GetRequestState(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NIFM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(0);
-    }
-    void GetResult(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NIFM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(0);
-    }
-    void GetSystemEventReadableHandles(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NIFM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2, 2};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(event1, event2);
-    }
-
-    Kernel::SharedPtr<Kernel::Event> event1, event2;
 };
 
 class INetworkProfile final : public ServiceFramework<INetworkProfile> {

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

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/ns/ns.h"
-#include "core/hle/service/ns/pl_u.h"
-
-namespace Service {
-namespace NS {
-
-void InstallInterfaces(SM::ServiceManager& service_manager) {
-    std::make_shared<PL_U>()->InstallAsService(service_manager);
-}
-
-} // namespace NS
-} // namespace Service

src/core/hle/service/ns/ns.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NS {
-
-/// Registers all NS services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager);
-
-} // namespace NS
-} // namespace Service

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

@@ -1,111 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/common_paths.h"
-#include "common/file_util.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/ns/pl_u.h"
-
-namespace Service {
-namespace NS {
-
-struct FontRegion {
-    u32 offset;
-    u32 size;
-};
-
-// The below data is specific to shared font data dumped from Switch on f/w 2.2
-// Virtual address and offsets/sizes likely will vary by dump
-static constexpr VAddr SHARED_FONT_MEM_VADDR{0x00000009d3016000ULL};
-static constexpr u64 SHARED_FONT_MEM_SIZE{0x1100000};
-static constexpr std::array<FontRegion, 6> SHARED_FONT_REGIONS{
-    FontRegion{0x00000008, 0x001fe764}, FontRegion{0x001fe774, 0x00773e58},
-    FontRegion{0x009725d4, 0x0001aca8}, FontRegion{0x0098d284, 0x00369cec},
-    FontRegion{0x00cf6f78, 0x0039b858}, FontRegion{0x010927d8, 0x00019e80},
-};
-
-enum class LoadState : u32 {
-    Loading = 0,
-    Done = 1,
-};
-
-PL_U::PL_U() : ServiceFramework("pl:u") {
-    static const FunctionInfo functions[] = {
-        {1, &PL_U::GetLoadState, "GetLoadState"},
-        {2, &PL_U::GetSize, "GetSize"},
-        {3, &PL_U::GetSharedMemoryAddressOffset, "GetSharedMemoryAddressOffset"},
-        {4, &PL_U::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"}};
-    RegisterHandlers(functions);
-
-    // Attempt to load shared font data from disk
-    const std::string filepath{FileUtil::GetUserPath(D_SYSDATA_IDX) + SHARED_FONT};
-    FileUtil::CreateFullPath(filepath); // Create path if not already created
-    FileUtil::IOFile file(filepath, "rb");
-
-    if (file.IsOpen()) {
-        // Read shared font data
-        ASSERT(file.GetSize() == SHARED_FONT_MEM_SIZE);
-        shared_font = std::make_shared<std::vector<u8>>(static_cast<size_t>(file.GetSize()));
-        file.ReadBytes(shared_font->data(), shared_font->size());
-    } else {
-        LOG_WARNING(Service_NS, "Unable to load shared font: %s", filepath.c_str());
-    }
-}
-
-void PL_U::GetLoadState(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const u32 font_id{rp.Pop<u32>()};
-
-    LOG_DEBUG(Service_NS, "called, font_id=%d", font_id);
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(static_cast<u32>(LoadState::Done));
-}
-
-void PL_U::GetSize(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const u32 font_id{rp.Pop<u32>()};
-
-    LOG_DEBUG(Service_NS, "called, font_id=%d", font_id);
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].size);
-}
-
-void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const u32 font_id{rp.Pop<u32>()};
-
-    LOG_DEBUG(Service_NS, "called, font_id=%d", font_id);
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].offset);
-}
-
-void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
-    if (shared_font != nullptr) {
-        // TODO(bunnei): This is a less-than-ideal solution to load a RAM dump of the Switch shared
-        // font data. This (likely) relies on exact address, size, and offsets from the original
-        // dump. In the future, we need to replace this with a more robust solution.
-
-        // Map backing memory for the font data
-        Kernel::g_current_process->vm_manager.MapMemoryBlock(SHARED_FONT_MEM_VADDR, shared_font, 0,
-                                                             SHARED_FONT_MEM_SIZE,
-                                                             Kernel::MemoryState::Shared);
-
-        // Create shared font memory object
-        shared_font_mem = Kernel::SharedMemory::Create(
-            Kernel::g_current_process, SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
-            Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
-            "PL_U:shared_font_mem");
-    }
-
-    LOG_DEBUG(Service_NS, "called");
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(shared_font_mem);
-}
-
-} // namespace NS
-} // namespace Service

src/core/hle/service/ns/pl_u.h

@@ -1,33 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/hle/kernel/shared_memory.h"
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NS {
-
-class PL_U final : public ServiceFramework<PL_U> {
-public:
-    PL_U();
-    ~PL_U() = default;
-
-private:
-    void GetLoadState(Kernel::HLERequestContext& ctx);
-    void GetSize(Kernel::HLERequestContext& ctx);
-    void GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx);
-    void GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx);
-
-    /// Handle to shared memory region designated for a shared font
-    Kernel::SharedPtr<Kernel::SharedMemory> shared_font_mem;
-
-    /// Backing memory for the shared font data
-    std::shared_ptr<std::vector<u8>> shared_font;
-};
-
-} // namespace NS
-} // namespace Service

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

@@ -17,8 +17,6 @@ u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<
     switch (static_cast<IoctlCommand>(command.raw)) {
     case IoctlCommand::IocGetConfigCommand:
         return NvOsGetConfigU32(input, output);
-    case IoctlCommand::IocCtrlEventWaitCommand:
-        return IocCtrlEventWait(input, output);
     }
     UNIMPLEMENTED();
     return 0;
@@ -47,18 +45,6 @@ u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>&
     return 0;
 }
 
-u32 nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output) {
-    IocCtrlEventWaitParams params{};
-    std::memcpy(&params, input.data(), sizeof(params));
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, syncpt_id=%u threshold=%u timeout=%d",
-                params.syncpt_id, params.threshold, params.timeout);
-
-    // TODO(Subv): Implement actual syncpt waiting.
-    params.value = 0;
-    std::memcpy(output.data(), &params, sizeof(params));
-    return 0;
-}
-
 } // namespace Devices
 } // namespace Nvidia
 } // namespace Service

src/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -31,7 +31,6 @@ private:
         IocModuleRegRDWRCommand = 0xC008010E,
         IocSyncptWaitexCommand = 0xC0100019,
         IocSyncptReadMaxCommand = 0xC008001A,
-        IocCtrlEventWaitCommand = 0xC010001D,
         IocGetConfigCommand = 0xC183001B,
     };
 
@@ -42,17 +41,7 @@ private:
     };
     static_assert(sizeof(IocGetConfigParams) == 387, "IocGetConfigParams is incorrect size");
 
-    struct IocCtrlEventWaitParams {
-        u32_le syncpt_id;
-        u32_le threshold;
-        s32_le timeout;
-        u32_le value;
-    };
-    static_assert(sizeof(IocCtrlEventWaitParams) == 16, "IocCtrlEventWaitParams is incorrect size");
-
     u32 NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
-
-    u32 IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Devices

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

@@ -103,8 +103,11 @@ u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
                             [&](const auto& entry) { return entry.second->id == params.id; });
     ASSERT(itr != handles.end());
 
-    // Return the existing handle instead of creating a new one.
-    params.handle = itr->first;
+    // Make a new handle for the object
+    u32 handle = next_handle++;
+    handles[handle] = itr->second;
+
+    params.handle = handle;
 
     std::memcpy(output.data(), &params, sizeof(params));
     return 0;

src/core/hle/service/nvdrv/interface.cpp

@@ -15,8 +15,9 @@ namespace Nvidia {
 void NVDRV::Open(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_NVDRV, "called");
 
-    const auto& buffer = ctx.ReadBuffer();
-    std::string device_name(buffer.begin(), buffer.end());
+    auto buffer = ctx.BufferDescriptorA()[0];
+
+    std::string device_name = Memory::ReadCString(buffer.Address(), buffer.Size());
 
     u32 fd = nvdrv->Open(device_name);
     IPC::ResponseBuilder rb{ctx, 4};
@@ -32,13 +33,25 @@ void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
     u32 fd = rp.Pop<u32>();
     u32 command = rp.Pop<u32>();
 
-    std::vector<u8> output(ctx.GetWriteBufferSize());
-
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(nvdrv->Ioctl(fd, command, ctx.ReadBuffer(), output));
-
-    ctx.WriteBuffer(output);
+    if (ctx.BufferDescriptorA()[0].Size() != 0) {
+        auto input_buffer = ctx.BufferDescriptorA()[0];
+        auto output_buffer = ctx.BufferDescriptorB()[0];
+        std::vector<u8> input(input_buffer.Size());
+        std::vector<u8> output(output_buffer.Size());
+        Memory::ReadBlock(input_buffer.Address(), input.data(), input_buffer.Size());
+        rb.Push(nvdrv->Ioctl(fd, command, input, output));
+        Memory::WriteBlock(output_buffer.Address(), output.data(), output_buffer.Size());
+    } else {
+        auto input_buffer = ctx.BufferDescriptorX()[0];
+        auto output_buffer = ctx.BufferDescriptorC()[0];
+        std::vector<u8> input(input_buffer.size);
+        std::vector<u8> output(output_buffer.size);
+        Memory::ReadBlock(input_buffer.Address(), input.data(), input_buffer.size);
+        rb.Push(nvdrv->Ioctl(fd, command, input, output));
+        Memory::WriteBlock(output_buffer.Address(), output.data(), output_buffer.size);
+    }
 }
 
 void NVDRV::Close(Kernel::HLERequestContext& ctx) {

src/core/hle/service/nvdrv/nvdrv.h

@@ -17,13 +17,6 @@ namespace Devices {
 class nvdevice;
 }
 
-struct IoctlFence {
-    u32 id;
-    u32 value;
-};
-
-static_assert(sizeof(IoctlFence) == 8, "IoctlFence has wrong size");
-
 class Module final {
 public:
     Module();

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

@@ -6,7 +6,6 @@
 
 #include "common/alignment.h"
 #include "common/scope_exit.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
@@ -130,7 +129,6 @@ void NVFlinger::Compose() {
 
         if (buffer == boost::none) {
             // There was no queued buffer to draw, render previous frame
-            Core::System::GetInstance().perf_stats.EndGameFrame();
             VideoCore::g_renderer->SwapBuffers({});
             continue;
         }

src/core/hle/service/service.cpp

@@ -20,15 +20,13 @@
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/audio/audio.h"
 #include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/friend/friend.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/lm/lm.h"
 #include "core/hle/service/nifm/nifm.h"
-#include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/pctl/pctl.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/set/settings.h"
+#include "core/hle/service/set/set.h"
 #include "core/hle/service/sm/controller.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/sockets/sockets.h"
@@ -181,11 +179,9 @@ void Init() {
     APM::InstallInterfaces(*SM::g_service_manager);
     Audio::InstallInterfaces(*SM::g_service_manager);
     FileSystem::InstallInterfaces(*SM::g_service_manager);
-    Friend::InstallInterfaces(*SM::g_service_manager);
     HID::InstallInterfaces(*SM::g_service_manager);
     LM::InstallInterfaces(*SM::g_service_manager);
     NIFM::InstallInterfaces(*SM::g_service_manager);
-    NS::InstallInterfaces(*SM::g_service_manager);
     Nvidia::InstallInterfaces(*SM::g_service_manager);
     PCTL::InstallInterfaces(*SM::g_service_manager);
     Sockets::InstallInterfaces(*SM::g_service_manager);

src/core/hle/service/set/set.cpp

@@ -17,7 +17,9 @@ void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
     u32 id = rp.Pop<u32>();
     constexpr std::array<u8, 13> lang_codes{};
 
-    ctx.WriteBuffer(lang_codes.data(), lang_codes.size());
+    const auto& output_buffer = ctx.BufferDescriptorC()[0];
+
+    Memory::WriteBlock(output_buffer.Address(), lang_codes.data(), lang_codes.size());
 
     IPC::ResponseBuilder rb{ctx, 2};
 
@@ -26,19 +28,16 @@ void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_SET, "(STUBBED) called");
 }
 
-SET::SET() : ServiceFramework("set") {
+SET::SET(const char* name) : ServiceFramework(name) {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetLanguageCode"},
         {1, &SET::GetAvailableLanguageCodes, "GetAvailableLanguageCodes"},
-        {2, nullptr, "MakeLanguageCode"},
-        {3, nullptr, "GetAvailableLanguageCodeCount"},
-        {4, nullptr, "GetRegionCode"},
-        {5, nullptr, "GetAvailableLanguageCodes2"},
-        {6, nullptr, "GetAvailableLanguageCodeCount2"},
-        {7, nullptr, "GetKeyCodeMap"},
     };
     RegisterHandlers(functions);
 }
 
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<SET>("set")->InstallAsService(service_manager);
+}
+
 } // namespace Set
 } // namespace Service

src/core/hle/service/set/set.h

@@ -11,12 +11,15 @@ namespace Set {
 
 class SET final : public ServiceFramework<SET> {
 public:
-    explicit SET();
+    explicit SET(const char* name);
     ~SET() = default;
 
 private:
     void GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx);
 };
 
+/// Registers all Set services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
 } // namespace Set
 } // namespace Service

src/core/hle/service/set/set_cal.cpp

@@ -1,40 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/set/set_cal.h"
-
-namespace Service {
-namespace Set {
-
-SET_CAL::SET_CAL() : ServiceFramework("set:cal") {
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetBluetoothBdAddress"},
-        {1, nullptr, "GetConfigurationId1"},
-        {2, nullptr, "GetAccelerometerOffset"},
-        {3, nullptr, "GetAccelerometerScale"},
-        {4, nullptr, "GetGyroscopeOffset"},
-        {5, nullptr, "GetGyroscopeScale"},
-        {6, nullptr, "GetWirelessLanMacAddress"},
-        {7, nullptr, "GetWirelessLanCountryCodeCount"},
-        {8, nullptr, "GetWirelessLanCountryCodes"},
-        {9, nullptr, "GetSerialNumber"},
-        {10, nullptr, "SetInitialSystemAppletProgramId"},
-        {11, nullptr, "SetOverlayDispProgramId"},
-        {12, nullptr, "GetBatteryLot"},
-        {14, nullptr, "GetEciDeviceCertificate"},
-        {15, nullptr, "GetEticketDeviceCertificate"},
-        {16, nullptr, "GetSslKey"},
-        {17, nullptr, "GetSslCertificate"},
-        {18, nullptr, "GetGameCardKey"},
-        {19, nullptr, "GetGameCardCertificate"},
-        {20, nullptr, "GetEciDeviceKey"},
-        {21, nullptr, "GetEticketDeviceKey"},
-        {22, nullptr, "GetSpeakerParameter"},
-        {23, nullptr, "GetLcdVendorId"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Set
-} // namespace Service

src/core/hle/service/set/set_cal.h

@@ -1,19 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace Set {
-
-class SET_CAL final : public ServiceFramework<SET_CAL> {
-public:
-    explicit SET_CAL();
-    ~SET_CAL() = default;
-};
-
-} // namespace Set
-} // namespace Service

src/core/hle/service/set/set_fd.cpp

@@ -1,25 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/set/set_fd.h"
-
-namespace Service {
-namespace Set {
-
-SET_FD::SET_FD() : ServiceFramework("set:fd") {
-    static const FunctionInfo functions[] = {
-        {2, nullptr, "SetSettingsItemValue"},
-        {3, nullptr, "ResetSettingsItemValue"},
-        {4, nullptr, "CreateSettingsItemKeyIterator"},
-        {10, nullptr, "ReadSettings"},
-        {11, nullptr, "ResetSettings"},
-        {20, nullptr, "SetWebInspectorFlag"},
-        {21, nullptr, "SetAllowedSslHosts"},
-        {22, nullptr, "SetHostFsMountPoint"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Set
-} // namespace Service

src/core/hle/service/set/set_fd.h

@@ -1,19 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace Set {
-
-class SET_FD final : public ServiceFramework<SET_FD> {
-public:
-    explicit SET_FD();
-    ~SET_FD() = default;
-};
-
-} // namespace Set
-} // namespace Service

src/core/hle/service/set/set_sys.cpp

@@ -1,167 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/client_port.h"
-#include "core/hle/service/set/set_sys.h"
-
-namespace Service {
-namespace Set {
-
-void SET_SYS::GetColorSetId(Kernel::HLERequestContext& ctx) {
-
-    IPC::ResponseBuilder rb{ctx, 3};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0);
-
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-}
-
-SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "SetLanguageCode"},
-        {1, nullptr, "SetNetworkSettings"},
-        {2, nullptr, "GetNetworkSettings"},
-        {3, nullptr, "GetFirmwareVersion"},
-        {4, nullptr, "GetFirmwareVersion2"},
-        {7, nullptr, "GetLockScreenFlag"},
-        {8, nullptr, "SetLockScreenFlag"},
-        {9, nullptr, "GetBacklightSettings"},
-        {10, nullptr, "SetBacklightSettings"},
-        {11, nullptr, "SetBluetoothDevicesSettings"},
-        {12, nullptr, "GetBluetoothDevicesSettings"},
-        {13, nullptr, "GetExternalSteadyClockSourceId"},
-        {14, nullptr, "SetExternalSteadyClockSourceId"},
-        {15, nullptr, "GetUserSystemClockContext"},
-        {16, nullptr, "SetUserSystemClockContext"},
-        {17, nullptr, "GetAccountSettings"},
-        {18, nullptr, "SetAccountSettings"},
-        {19, nullptr, "GetAudioVolume"},
-        {20, nullptr, "SetAudioVolume"},
-        {21, nullptr, "GetEulaVersions"},
-        {22, nullptr, "SetEulaVersions"},
-        {23, &SET_SYS::GetColorSetId, "GetColorSetId"},
-        {24, nullptr, "SetColorSetId"},
-        {25, nullptr, "GetConsoleInformationUploadFlag"},
-        {26, nullptr, "SetConsoleInformationUploadFlag"},
-        {27, nullptr, "GetAutomaticApplicationDownloadFlag"},
-        {28, nullptr, "SetAutomaticApplicationDownloadFlag"},
-        {29, nullptr, "GetNotificationSettings"},
-        {30, nullptr, "SetNotificationSettings"},
-        {31, nullptr, "GetAccountNotificationSettings"},
-        {32, nullptr, "SetAccountNotificationSettings"},
-        {35, nullptr, "GetVibrationMasterVolume"},
-        {36, nullptr, "SetVibrationMasterVolume"},
-        {37, nullptr, "GetSettingsItemValueSize"},
-        {38, nullptr, "GetSettingsItemValue"},
-        {39, nullptr, "GetTvSettings"},
-        {40, nullptr, "SetTvSettings"},
-        {41, nullptr, "GetEdid"},
-        {42, nullptr, "SetEdid"},
-        {43, nullptr, "GetAudioOutputMode"},
-        {44, nullptr, "SetAudioOutputMode"},
-        {45, nullptr, "IsForceMuteOnHeadphoneRemoved"},
-        {46, nullptr, "SetForceMuteOnHeadphoneRemoved"},
-        {47, nullptr, "GetQuestFlag"},
-        {48, nullptr, "SetQuestFlag"},
-        {49, nullptr, "GetDataDeletionSettings"},
-        {50, nullptr, "SetDataDeletionSettings"},
-        {51, nullptr, "GetInitialSystemAppletProgramId"},
-        {52, nullptr, "GetOverlayDispProgramId"},
-        {53, nullptr, "GetDeviceTimeZoneLocationName"},
-        {54, nullptr, "SetDeviceTimeZoneLocationName"},
-        {55, nullptr, "GetWirelessCertificationFileSize"},
-        {56, nullptr, "GetWirelessCertificationFile"},
-        {57, nullptr, "SetRegionCode"},
-        {58, nullptr, "GetNetworkSystemClockContext"},
-        {59, nullptr, "SetNetworkSystemClockContext"},
-        {60, nullptr, "IsUserSystemClockAutomaticCorrectionEnabled"},
-        {61, nullptr, "SetUserSystemClockAutomaticCorrectionEnabled"},
-        {62, nullptr, "GetDebugModeFlag"},
-        {63, nullptr, "GetPrimaryAlbumStorage"},
-        {64, nullptr, "SetPrimaryAlbumStorage"},
-        {65, nullptr, "GetUsb30EnableFlag"},
-        {66, nullptr, "SetUsb30EnableFlag"},
-        {67, nullptr, "GetBatteryLot"},
-        {68, nullptr, "GetSerialNumber"},
-        {69, nullptr, "GetNfcEnableFlag"},
-        {70, nullptr, "SetNfcEnableFlag"},
-        {71, nullptr, "GetSleepSettings"},
-        {72, nullptr, "SetSleepSettings"},
-        {73, nullptr, "GetWirelessLanEnableFlag"},
-        {74, nullptr, "SetWirelessLanEnableFlag"},
-        {75, nullptr, "GetInitialLaunchSettings"},
-        {76, nullptr, "SetInitialLaunchSettings"},
-        {77, nullptr, "GetDeviceNickName"},
-        {78, nullptr, "SetDeviceNickName"},
-        {79, nullptr, "GetProductModel"},
-        {80, nullptr, "GetLdnChannel"},
-        {81, nullptr, "SetLdnChannel"},
-        {82, nullptr, "AcquireTelemetryDirtyFlagEventHandle"},
-        {83, nullptr, "GetTelemetryDirtyFlags"},
-        {84, nullptr, "GetPtmBatteryLot"},
-        {85, nullptr, "SetPtmBatteryLot"},
-        {86, nullptr, "GetPtmFuelGaugeParameter"},
-        {87, nullptr, "SetPtmFuelGaugeParameter"},
-        {88, nullptr, "GetBluetoothEnableFlag"},
-        {89, nullptr, "SetBluetoothEnableFlag"},
-        {90, nullptr, "GetMiiAuthorId"},
-        {91, nullptr, "SetShutdownRtcValue"},
-        {92, nullptr, "GetShutdownRtcValue"},
-        {93, nullptr, "AcquireFatalDirtyFlagEventHandle"},
-        {94, nullptr, "GetFatalDirtyFlags"},
-        {95, nullptr, "GetAutoUpdateEnableFlag"},
-        {96, nullptr, "SetAutoUpdateEnableFlag"},
-        {97, nullptr, "GetNxControllerSettings"},
-        {98, nullptr, "SetNxControllerSettings"},
-        {99, nullptr, "GetBatteryPercentageFlag"},
-        {100, nullptr, "SetBatteryPercentageFlag"},
-        {101, nullptr, "GetExternalRtcResetFlag"},
-        {102, nullptr, "SetExternalRtcResetFlag"},
-        {103, nullptr, "GetUsbFullKeyEnableFlag"},
-        {104, nullptr, "SetUsbFullKeyEnableFlag"},
-        {105, nullptr, "SetExternalSteadyClockInternalOffset"},
-        {106, nullptr, "GetExternalSteadyClockInternalOffset"},
-        {107, nullptr, "GetBacklightSettingsEx"},
-        {108, nullptr, "SetBacklightSettingsEx"},
-        {109, nullptr, "GetHeadphoneVolumeWarningCount"},
-        {110, nullptr, "SetHeadphoneVolumeWarningCount"},
-        {111, nullptr, "GetBluetoothAfhEnableFlag"},
-        {112, nullptr, "SetBluetoothAfhEnableFlag"},
-        {113, nullptr, "GetBluetoothBoostEnableFlag"},
-        {114, nullptr, "SetBluetoothBoostEnableFlag"},
-        {115, nullptr, "GetInRepairProcessEnableFlag"},
-        {116, nullptr, "SetInRepairProcessEnableFlag"},
-        {117, nullptr, "GetHeadphoneVolumeUpdateFlag"},
-        {118, nullptr, "SetHeadphoneVolumeUpdateFlag"},
-        {119, nullptr, "NeedsToUpdateHeadphoneVolume"},
-        {120, nullptr, "GetPushNotificationActivityModeOnSleep"},
-        {121, nullptr, "SetPushNotificationActivityModeOnSleep"},
-        {122, nullptr, "GetServiceDiscoveryControlSettings"},
-        {123, nullptr, "SetServiceDiscoveryControlSettings"},
-        {124, nullptr, "GetErrorReportSharePermission"},
-        {125, nullptr, "SetErrorReportSharePermission"},
-        {126, nullptr, "GetAppletLaunchFlags"},
-        {127, nullptr, "SetAppletLaunchFlags"},
-        {128, nullptr, "GetConsoleSixAxisSensorAccelerationBias"},
-        {129, nullptr, "SetConsoleSixAxisSensorAccelerationBias"},
-        {130, nullptr, "GetConsoleSixAxisSensorAngularVelocityBias"},
-        {131, nullptr, "SetConsoleSixAxisSensorAngularVelocityBias"},
-        {132, nullptr, "GetConsoleSixAxisSensorAccelerationGain"},
-        {133, nullptr, "SetConsoleSixAxisSensorAccelerationGain"},
-        {134, nullptr, "GetConsoleSixAxisSensorAngularVelocityGain"},
-        {135, nullptr, "SetConsoleSixAxisSensorAngularVelocityGain"},
-        {136, nullptr, "GetKeyboardLayout"},
-        {137, nullptr, "SetKeyboardLayout"},
-        {138, nullptr, "GetWebInspectorFlag"},
-        {139, nullptr, "GetAllowedSslHosts"},
-        {140, nullptr, "GetHostFsMountPoint"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Set
-} // namespace Service

src/core/hle/service/set/set_sys.h

@@ -1,22 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace Set {
-
-class SET_SYS final : public ServiceFramework<SET_SYS> {
-public:
-    explicit SET_SYS();
-    ~SET_SYS() = default;
-
-private:
-    void GetColorSetId(Kernel::HLERequestContext& ctx);
-};
-
-} // namespace Set
-} // namespace Service

src/core/hle/service/set/settings.cpp

@@ -1,22 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/set/set.h"
-#include "core/hle/service/set/set_cal.h"
-#include "core/hle/service/set/set_fd.h"
-#include "core/hle/service/set/set_sys.h"
-#include "core/hle/service/set/settings.h"
-
-namespace Service {
-namespace Set {
-
-void InstallInterfaces(SM::ServiceManager& service_manager) {
-    std::make_shared<SET>()->InstallAsService(service_manager);
-    std::make_shared<SET_CAL>()->InstallAsService(service_manager);
-    std::make_shared<SET_FD>()->InstallAsService(service_manager);
-    std::make_shared<SET_SYS>()->InstallAsService(service_manager);
-}
-
-} // namespace Set
-} // namespace Service

src/core/hle/service/set/settings.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace Set {
-
-/// Registers all Settings services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager);
-
-} // namespace Set
-} // namespace Service

src/core/hle/service/sockets/bsd_u.cpp

@@ -17,15 +17,6 @@ void BSD_U::RegisterClient(Kernel::HLERequestContext& ctx) {
     rb.Push<u32>(0); // bsd errno
 }
 
-void BSD_U::StartMonitoring(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0); // bsd errno
-}
-
 void BSD_U::Socket(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
@@ -76,7 +67,6 @@ void BSD_U::Close(Kernel::HLERequestContext& ctx) {
 
 BSD_U::BSD_U() : ServiceFramework("bsd:u") {
     static const FunctionInfo functions[] = {{0, &BSD_U::RegisterClient, "RegisterClient"},
-                                             {1, &BSD_U::StartMonitoring, "StartMonitoring"},
                                              {2, &BSD_U::Socket, "Socket"},
                                              {11, &BSD_U::SendTo, "SendTo"},
                                              {14, &BSD_U::Connect, "Connect"},

src/core/hle/service/sockets/bsd_u.h

@@ -17,7 +17,6 @@ public:
 
 private:
     void RegisterClient(Kernel::HLERequestContext& ctx);
-    void StartMonitoring(Kernel::HLERequestContext& ctx);
     void Socket(Kernel::HLERequestContext& ctx);
     void Connect(Kernel::HLERequestContext& ctx);
     void SendTo(Kernel::HLERequestContext& ctx);

src/core/hle/service/time/time.cpp

@@ -146,13 +146,6 @@ void Module::Interface::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called");
 }
 
-void Module::Interface::GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISystemClock>();
-    LOG_DEBUG(Service_Time, "called");
-}
-
 Module::Interface::Interface(std::shared_ptr<Module> time, const char* name)
     : ServiceFramework(name), time(std::move(time)) {}
 

src/core/hle/service/time/time.h

@@ -56,7 +56,6 @@ public:
         void GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx);
         void GetStandardSteadyClock(Kernel::HLERequestContext& ctx);
         void GetTimeZoneService(Kernel::HLERequestContext& ctx);
-        void GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> time;

src/core/hle/service/time/time_s.cpp

@@ -10,10 +10,6 @@ namespace Time {
 TIME_S::TIME_S(std::shared_ptr<Module> time) : Module::Interface(std::move(time), "time:s") {
     static const FunctionInfo functions[] = {
         {0, &TIME_S::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
-        {1, &TIME_S::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
-        {2, &TIME_S::GetStandardSteadyClock, "GetStandardSteadyClock"},
-        {3, &TIME_S::GetTimeZoneService, "GetTimeZoneService"},
-        {4, &TIME_S::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/time/time_u.cpp

@@ -13,7 +13,6 @@ TIME_U::TIME_U(std::shared_ptr<Module> time) : Module::Interface(std::move(time)
         {1, &TIME_U::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
         {2, &TIME_U::GetStandardSteadyClock, "GetStandardSteadyClock"},
         {3, &TIME_U::GetTimeZoneService, "GetTimeZoneService"},
-        {4, &TIME_U::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
     };
     RegisterHandlers(functions);
 }

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

@@ -8,7 +8,6 @@
 #include "common/scope_exit.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/hle/service/vi/vi_m.h"
@@ -39,7 +38,6 @@ public:
 
     template <typename T>
     T Read() {
-        ASSERT(read_index + sizeof(T) <= buffer.size());
         T val;
         std::memcpy(&val, buffer.data() + read_index, sizeof(T));
         read_index += sizeof(T);
@@ -49,7 +47,6 @@ public:
 
     template <typename T>
     T ReadUnaligned() {
-        ASSERT(read_index + sizeof(T) <= buffer.size());
         T val;
         std::memcpy(&val, buffer.data() + read_index, sizeof(T));
         read_index += sizeof(T);
@@ -57,7 +54,6 @@ public:
     }
 
     std::vector<u8> ReadBlock(size_t length) {
-        ASSERT(read_index + length <= buffer.size());
         const u8* const begin = buffer.data() + read_index;
         const u8* const end = begin + length;
         std::vector<u8> data(begin, end);
@@ -90,18 +86,7 @@ public:
         write_index = Common::AlignUp(write_index, 4);
     }
 
-    template <typename T>
-    void WriteObject(const T& val) {
-        u32_le size = static_cast<u32>(sizeof(val));
-        Write(size);
-        // TODO(Subv): Support file descriptors.
-        Write<u32_le>(0); // Fd count.
-        Write(val);
-    }
-
     void Deserialize() {
-        ASSERT(buffer.size() > sizeof(Header));
-
         Header header{};
         std::memcpy(&header, buffer.data(), sizeof(Header));
 
@@ -277,11 +262,10 @@ public:
     Data data;
 };
 
-struct BufferProducerFence {
-    u32 is_valid;
-    std::array<Nvidia::IoctlFence, 4> fences;
-};
-static_assert(sizeof(BufferProducerFence) == 36, "BufferProducerFence has wrong size");
+// TODO(bunnei): Remove this. When set to 1, games will think a fence is valid and boot further.
+// This will break libnx and potentially other apps that more stringently check this. This is here
+// purely as a convenience, and should go away once we implement fences.
+static constexpr u32 FENCE_HACK = 0;
 
 class IGBPDequeueBufferResponseParcel : public Parcel {
 public:
@@ -290,16 +274,20 @@ public:
 
 protected:
     void SerializeData() override {
-        // TODO(Subv): Find out how this Fence is used.
-        BufferProducerFence fence = {};
-        fence.is_valid = 1;
-        for (auto& fence_ : fence.fences)
-            fence_.id = -1;
-
-        Write(slot);
-        Write<u32_le>(1);
-        WriteObject(fence);
-        Write<u32_le>(0);
+        // TODO(bunnei): Find out what this all means. Writing anything non-zero here breaks libnx.
+        Write<u32>(0);
+        Write<u32>(FENCE_HACK);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
+        Write<u32>(0);
     }
 
     u32_le slot;
@@ -328,10 +316,11 @@ public:
 
 protected:
     void SerializeData() override {
-        // TODO(Subv): Figure out what this value means, writing non-zero here will make libnx try
-        // to read an IGBPBuffer object from the parcel.
-        Write<u32_le>(1);
-        WriteObject(buffer);
+        // TODO(bunnei): Find out what this all means. Writing anything non-zero here breaks libnx.
+        Write<u32_le>(0);
+        Write<u32_le>(FENCE_HACK);
+        Write<u32_le>(0);
+        Write(buffer);
         Write<u32_le>(0);
     }
 
@@ -440,7 +429,7 @@ public:
             {0, &IHOSBinderDriver::TransactParcel, "TransactParcel"},
             {1, &IHOSBinderDriver::AdjustRefcount, "AdjustRefcount"},
             {2, &IHOSBinderDriver::GetNativeHandle, "GetNativeHandle"},
-            {3, &IHOSBinderDriver::TransactParcel, "TransactParcelAuto"},
+            {3, &IHOSBinderDriver::TransactParcelAuto, "TransactParcelAuto"},
         };
         RegisterHandlers(functions);
     }
@@ -464,61 +453,95 @@ private:
         SetPreallocatedBuffer = 14
     };
 
-    void TransactParcel(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        u32 id = rp.Pop<u32>();
-        auto transaction = static_cast<TransactionId>(rp.Pop<u32>());
-        u32 flags = rp.Pop<u32>();
+    void TransactParcel(u32 id, TransactionId transaction, const std::vector<u8>& input_data,
+                        VAddr output_addr, u64 output_size) {
         auto buffer_queue = nv_flinger->GetBufferQueue(id);
 
-        LOG_DEBUG(Service_VI, "called, transaction=%x", transaction);
-
         if (transaction == TransactionId::Connect) {
-            IGBPConnectRequestParcel request{ctx.ReadBuffer()};
+            IGBPConnectRequestParcel request{input_data};
             IGBPConnectResponseParcel response{1280, 720};
-            ctx.WriteBuffer(response.Serialize());
+            std::vector<u8> response_buffer = response.Serialize();
+            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
         } else if (transaction == TransactionId::SetPreallocatedBuffer) {
-            IGBPSetPreallocatedBufferRequestParcel request{ctx.ReadBuffer()};
+            IGBPSetPreallocatedBufferRequestParcel request{input_data};
 
             buffer_queue->SetPreallocatedBuffer(request.data.slot, request.buffer);
 
             IGBPSetPreallocatedBufferResponseParcel response{};
-            ctx.WriteBuffer(response.Serialize());
+            std::vector<u8> response_buffer = response.Serialize();
+            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
         } else if (transaction == TransactionId::DequeueBuffer) {
-            IGBPDequeueBufferRequestParcel request{ctx.ReadBuffer()};
+            IGBPDequeueBufferRequestParcel request{input_data};
 
             u32 slot = buffer_queue->DequeueBuffer(request.data.pixel_format, request.data.width,
                                                    request.data.height);
 
             IGBPDequeueBufferResponseParcel response{slot};
-            ctx.WriteBuffer(response.Serialize());
+            std::vector<u8> response_buffer = response.Serialize();
+            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
         } else if (transaction == TransactionId::RequestBuffer) {
-            IGBPRequestBufferRequestParcel request{ctx.ReadBuffer()};
+            IGBPRequestBufferRequestParcel request{input_data};
 
             auto& buffer = buffer_queue->RequestBuffer(request.slot);
 
             IGBPRequestBufferResponseParcel response{buffer};
-            ctx.WriteBuffer(response.Serialize());
+            std::vector<u8> response_buffer = response.Serialize();
+            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
         } else if (transaction == TransactionId::QueueBuffer) {
-            IGBPQueueBufferRequestParcel request{ctx.ReadBuffer()};
+            IGBPQueueBufferRequestParcel request{input_data};
 
             buffer_queue->QueueBuffer(request.data.slot, request.data.transform);
 
             IGBPQueueBufferResponseParcel response{1280, 720};
-            ctx.WriteBuffer(response.Serialize());
+            std::vector<u8> response_buffer = response.Serialize();
+            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
         } else if (transaction == TransactionId::Query) {
-            IGBPQueryRequestParcel request{ctx.ReadBuffer()};
+            IGBPQueryRequestParcel request{input_data};
 
             u32 value =
                 buffer_queue->Query(static_cast<NVFlinger::BufferQueue::QueryType>(request.type));
 
             IGBPQueryResponseParcel response{value};
-            ctx.WriteBuffer(response.Serialize());
+            std::vector<u8> response_buffer = response.Serialize();
+            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
         } else if (transaction == TransactionId::CancelBuffer) {
             LOG_WARNING(Service_VI, "(STUBBED) called, transaction=CancelBuffer");
         } else {
             ASSERT_MSG(false, "Unimplemented");
         }
+    }
+
+    void TransactParcel(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        u32 id = rp.Pop<u32>();
+        auto transaction = static_cast<TransactionId>(rp.Pop<u32>());
+        u32 flags = rp.Pop<u32>();
+        LOG_DEBUG(Service_VI, "called, transaction=%x", transaction);
+
+        auto& input_buffer = ctx.BufferDescriptorA()[0];
+        auto& output_buffer = ctx.BufferDescriptorB()[0];
+        std::vector<u8> input_data(input_buffer.Size());
+        Memory::ReadBlock(input_buffer.Address(), input_data.data(), input_buffer.Size());
+
+        TransactParcel(id, transaction, input_data, output_buffer.Address(), output_buffer.Size());
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void TransactParcelAuto(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        u32 id = rp.Pop<u32>();
+        auto transaction = static_cast<TransactionId>(rp.Pop<u32>());
+        u32 flags = rp.Pop<u32>();
+        LOG_DEBUG(Service_VI, "called, transaction=%x", transaction);
+
+        auto& input_buffer = ctx.BufferDescriptorX()[0];
+        auto& output_buffer = ctx.BufferDescriptorC()[0];
+        std::vector<u8> input_data(input_buffer.size);
+        Memory::ReadBlock(input_buffer.Address(), input_data.data(), input_buffer.size);
+
+        TransactParcel(id, transaction, input_data, output_buffer.Address(), output_buffer.Size());
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -696,13 +719,18 @@ void IApplicationDisplayService::OpenLayer(Kernel::HLERequestContext& ctx) {
     u64 layer_id = rp.Pop<u64>();
     u64 aruid = rp.Pop<u64>();
 
+    auto& buffer = ctx.BufferDescriptorB()[0];
+
     u64 display_id = nv_flinger->OpenDisplay(display_name);
     u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
 
     NativeWindow native_window{buffer_queue_id};
+    auto data = native_window.Serialize();
+    Memory::WriteBlock(buffer.Address(), data.data(), data.size());
+
     IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
+    rb.Push<u64>(data.size());
 }
 
 void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx) {
@@ -713,16 +741,21 @@ void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx
     rp.Pop<u32>(); // padding
     u64 display_id = rp.Pop<u64>();
 
+    auto& buffer = ctx.BufferDescriptorB()[0];
+
     // TODO(Subv): What's the difference between a Stray and a Managed layer?
 
     u64 layer_id = nv_flinger->CreateLayer(display_id);
     u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
 
     NativeWindow native_window{buffer_queue_id};
+    auto data = native_window.Serialize();
+    Memory::WriteBlock(buffer.Address(), data.data(), data.size());
+
     IPC::ResponseBuilder rb = rp.MakeBuilder(6, 0, 0);
     rb.Push(RESULT_SUCCESS);
     rb.Push(layer_id);
-    rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
+    rb.Push<u64>(data.size());
 }
 
 void IApplicationDisplayService::DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
@@ -748,7 +781,8 @@ void IApplicationDisplayService::SetLayerScalingMode(Kernel::HLERequestContext&
 void IApplicationDisplayService::ListDisplays(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     DisplayInfo display_info;
-    ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
+    auto& buffer = ctx.BufferDescriptorB()[0];
+    Memory::WriteBlock(buffer.Address(), &display_info, sizeof(DisplayInfo));
     IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
     rb.Push(RESULT_SUCCESS);
     rb.Push<u64>(1);

src/core/loader/deconstructed_rom_directory.cpp

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

src/core/loader/deconstructed_rom_directory.h

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

src/core/loader/elf.cpp

@@ -300,7 +300,7 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
     std::vector<u8> program_image(total_image_size);
     size_t current_image_position = 0;
 
-    SharedPtr<CodeSet> codeset = CodeSet::Create("");
+    SharedPtr<CodeSet> codeset = CodeSet::Create("", 0);
 
     for (unsigned int i = 0; i < header->e_phnum; ++i) {
         Elf32_Phdr* p = &segments[i];
@@ -406,7 +406,7 @@ ResultStatus AppLoader_ELF::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     SharedPtr<CodeSet> codeset = elf_reader.LoadInto(Memory::PROCESS_IMAGE_VADDR);
     codeset->name = filename;
 
-    process = Kernel::Process::Create("main", 0);
+    process = Kernel::Process::Create("main");
     process->LoadModule(codeset, codeset->entrypoint);
     process->svc_access_mask.set();
     process->address_mappings = default_address_mappings;

src/core/loader/nro.cpp

@@ -83,7 +83,7 @@ bool AppLoader_NRO::LoadNro(const std::string& path, VAddr load_base) {
     }
 
     // Build program image
-    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("");
+    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("", 0);
     std::vector<u8> program_image;
     program_image.resize(PageAlignSize(nro_header.file_size));
     file.Seek(0, SEEK_SET);
@@ -125,7 +125,7 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
         return ResultStatus::Error;
     }
 
-    process = Kernel::Process::Create("main", 0);
+    process = Kernel::Process::Create("main");
 
     // Load NRO
     static constexpr VAddr base_addr{Memory::PROCESS_IMAGE_VADDR};

src/core/loader/nso.cpp

@@ -109,7 +109,7 @@ VAddr AppLoader_NSO::LoadModule(const std::string& path, VAddr load_base) {
     }
 
     // Build program image
-    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("");
+    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("", 0);
     std::vector<u8> program_image;
     for (int i = 0; i < nso_header.segments.size(); ++i) {
         std::vector<u8> data =
@@ -155,7 +155,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
         return ResultStatus::Error;
     }
 
-    process = Kernel::Process::Create("main", 0);
+    process = Kernel::Process::Create("main");
 
     // Load module
     LoadModule(filepath, Memory::PROCESS_IMAGE_VADDR);

src/core/memory.cpp

@@ -118,11 +118,6 @@ boost::optional<T> ReadSpecial(VAddr addr);
 
 template <typename T>
 T Read(const VAddr vaddr) {
-    if ((vaddr >> PAGE_BITS) >= PAGE_TABLE_NUM_ENTRIES) {
-        LOG_ERROR(HW_Memory, "Read%lu after page table @ 0x%016" PRIX64, sizeof(T) * 8, vaddr);
-        return 0;
-    }
-
     const PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
     switch (type) {
     case PageType::Unmapped:
@@ -151,12 +146,6 @@ bool WriteSpecial(VAddr addr, const T data);
 
 template <typename T>
 void Write(const VAddr vaddr, const T data) {
-    if ((vaddr >> PAGE_BITS) >= PAGE_TABLE_NUM_ENTRIES) {
-        LOG_ERROR(HW_Memory, "Write%lu after page table 0x%08X @ 0x%016" PRIX64, sizeof(data) * 8,
-                  (u32)data, vaddr);
-        return;
-    }
-
     const PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
     switch (type) {
     case PageType::Unmapped:

src/tests/core/arm/arm_test_common.cpp

@@ -15,7 +15,7 @@ static Memory::PageTable* page_table = nullptr;
 TestEnvironment::TestEnvironment(bool mutable_memory_)
     : mutable_memory(mutable_memory_), test_memory(std::make_shared<TestMemory>(this)) {
 
-    Kernel::g_current_process = Kernel::Process::Create("", 0);
+    Kernel::g_current_process = Kernel::Process::Create("");
     page_table = &Kernel::g_current_process->vm_manager.page_table;
 
     page_table->pointers.fill(nullptr);

src/tests/core/memory/memory.cpp

@@ -9,7 +9,7 @@
 
 TEST_CASE("Memory::IsValidVirtualAddress", "[core][memory][!hide]") {
     SECTION("these regions should not be mapped on an empty process") {
-        auto process = Kernel::Process::Create("", 0);
+        auto process = Kernel::Process::Create("");
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::PROCESS_IMAGE_VADDR) == false);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::HEAP_VADDR) == false);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::LINEAR_HEAP_VADDR) == false);
@@ -20,14 +20,14 @@ TEST_CASE("Memory::IsValidVirtualAddress", "[core][memory][!hide]") {
     }
 
     SECTION("CONFIG_MEMORY_VADDR and SHARED_PAGE_VADDR should be valid after mapping them") {
-        auto process = Kernel::Process::Create("", 0);
+        auto process = Kernel::Process::Create("");
         Kernel::MapSharedPages(process->vm_manager);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::CONFIG_MEMORY_VADDR) == true);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::SHARED_PAGE_VADDR) == true);
     }
 
     SECTION("special regions should be valid after mapping them") {
-        auto process = Kernel::Process::Create("", 0);
+        auto process = Kernel::Process::Create("");
         SECTION("VRAM") {
             Kernel::HandleSpecialMapping(process->vm_manager,
                                          {Memory::VRAM_VADDR, Memory::VRAM_SIZE, false, false});
@@ -48,7 +48,7 @@ TEST_CASE("Memory::IsValidVirtualAddress", "[core][memory][!hide]") {
     }
 
     SECTION("Unmapping a VAddr should make it invalid") {
-        auto process = Kernel::Process::Create("", 0);
+        auto process = Kernel::Process::Create("");
         Kernel::MapSharedPages(process->vm_manager);
         process->vm_manager.UnmapRange(Memory::CONFIG_MEMORY_VADDR, Memory::CONFIG_MEMORY_SIZE);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::CONFIG_MEMORY_VADDR) == false);

src/yuzu/debugger/wait_tree.cpp

@@ -5,7 +5,6 @@
 #include "yuzu/debugger/wait_tree.h"
 #include "yuzu/util/util.h"
 
-#include "core/core.h"
 #include "core/hle/kernel/condition_variable.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/mutex.h"
@@ -51,7 +50,7 @@ std::size_t WaitTreeItem::Row() const {
 }
 
 std::vector<std::unique_ptr<WaitTreeThread>> WaitTreeItem::MakeThreadItemList() {
-    const auto& threads = Core::System::GetInstance().Scheduler().GetThreadList();
+    const auto& threads = Kernel::GetThreadList();
     std::vector<std::unique_ptr<WaitTreeThread>> item_list;
     item_list.reserve(threads.size());
     for (std::size_t i = 0; i < threads.size(); ++i) {

src/yuzu/main.cpp

@@ -187,8 +187,7 @@ void GMainWindow::InitializeHotkeys() {
     RegisterHotkey("Main Window", "Load File", QKeySequence::Open);
     RegisterHotkey("Main Window", "Start Emulation");
     RegisterHotkey("Main Window", "Fullscreen", QKeySequence::FullScreen);
-    RegisterHotkey("Main Window", "Exit Fullscreen", QKeySequence(Qt::Key_Escape),
-                   Qt::ApplicationShortcut);
+    RegisterHotkey("Main Window", "Exit Fullscreen", QKeySequence::Cancel, Qt::ApplicationShortcut);
     LoadHotkeys();
 
     connect(GetHotkey("Main Window", "Load File", this), &QShortcut::activated, this,