core/CMakeLists: Add web_types.h

Merge pull request #5935 from lat9nq/controller_access_keys
debugger: controller: Add access key
2021-02-15 09:40:30 -05:00 · 2021-02-14 22:33:59 -08:00 · 2021-02-14 20:09:15 -08:00 · 2021-02-14 16:10:12 -05:00 · 2021-02-14 02:46:01 -08:00 · 2021-02-14 00:20:41 -08:00
289 changed files with 10311 additions and 4998 deletions
@@ -42,3 +42,8 @@ done
 pip3 install pefile
 python3 .ci/scripts/windows/scan_dll.py package/*.exe "package/"
 python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"
+
+# copy FFmpeg libraries
+EXTERNALS_PATH="$(pwd)/build/externals"
+FFMPEG_DLL_PATH="$(find ${EXTERNALS_PATH} -maxdepth 1 -type d | grep ffmpeg)/bin"
+find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -v {} package/ ';'
@@ -37,3 +37,6 @@
 [submodule "opus"]
 	path = externals/opus/opus
 	url = https://github.com/xiph/opus.git
+[submodule "externals/ffmpeg"]
+	path = externals/ffmpeg
+	url = https://git.ffmpeg.org/ffmpeg.git
@@ -18,6 +18,8 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "EN

 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)

+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled yuzu" ON "WIN32" OFF)
+
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)

 option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implementation of BCAT" ON)
@@ -384,19 +386,141 @@ if (NOT LIBUSB_FOUND)
    set(LIBUSB_LIBRARIES usb)
 endif()

-# Use system installed ffmpeg.
-if (NOT MSVC)
-    find_package(FFmpeg REQUIRED)
-else()
-    set(FFMPEG_EXT_NAME "ffmpeg-4.2.1")
-    set(FFMPEG_PATH "${CMAKE_BINARY_DIR}/externals/${FFMPEG_EXT_NAME}")
-    download_bundled_external("ffmpeg/" ${FFMPEG_EXT_NAME} "")
-    set(FFMPEG_FOUND YES)
-    set(FFMPEG_INCLUDE_DIR "${FFMPEG_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
-    set(FFMPEG_LIBRARY_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg library" FORCE)
-    set(FFMPEG_DLL_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
+# List of all FFmpeg components required
+set(FFmpeg_COMPONENTS
+    avcodec
+    avutil
+    swscale)
+
+if (NOT YUZU_USE_BUNDLED_FFMPEG)
+    # Use system installed FFmpeg
+    find_package(FFmpeg REQUIRED COMPONENTS ${FFmpeg_COMPONENTS})
+
+    if (FFmpeg_FOUND)
+        # Overwrite aggregate defines from FFmpeg module to avoid over-linking libraries.
+        # Prevents shipping too many libraries with the AppImage.
+        set(FFmpeg_LIBRARIES "")
+        set(FFmpeg_INCLUDE_DIR "")
+
+        foreach(COMPONENT ${FFmpeg_COMPONENTS})
+            set(FFmpeg_LIBRARIES ${FFmpeg_LIBRARIES} ${FFmpeg_LIBRARY_${COMPONENT}} CACHE PATH "Paths to FFmpeg libraries" FORCE)
+            set(FFmpeg_INCLUDE_DIR ${FFmpeg_INCLUDE_DIR} ${FFmpeg_INCLUDE_${COMPONENT}} CACHE PATH "Path to FFmpeg headers" FORCE)
+        endforeach()
+    else()
+        message(WARNING "FFmpeg not found, falling back to externals")
+        set(YUZU_USE_BUNDLED_FFMPEG ON)
+    endif()
 endif()

+if (YUZU_USE_BUNDLED_FFMPEG)
+    if (NOT WIN32)
+        # Build FFmpeg from externals
+        message(STATUS "Using FFmpeg from externals")
+
+        # FFmpeg has source that requires one of nasm or yasm to assemble it.
+        # REQUIRED throws an error if not found here during configuration rather than during compilation.
+        find_program(ASSEMBLER NAMES nasm yasm REQUIRED)
+
+        set(FFmpeg_PREFIX ${PROJECT_SOURCE_DIR}/externals/ffmpeg)
+        set(FFmpeg_BUILD_DIR ${PROJECT_BINARY_DIR}/externals/ffmpeg)
+        set(FFmpeg_MAKEFILE ${FFmpeg_BUILD_DIR}/Makefile)
+        make_directory(${FFmpeg_BUILD_DIR})
+
+        # Read version string from external
+        file(READ ${FFmpeg_PREFIX}/RELEASE FFmpeg_VERSION)
+        set(FFmpeg_FOUND NO)
+        if (NOT FFmpeg_VERSION STREQUAL "")
+            set(FFmpeg_FOUND YES)
+        endif()
+
+        foreach(COMPONENT ${FFmpeg_COMPONENTS})
+            set(FFmpeg_${COMPONENT}_PREFIX "${FFmpeg_BUILD_DIR}/lib${COMPONENT}")
+            set(FFmpeg_${COMPONENT}_LIB_NAME "lib${COMPONENT}.a")
+            set(FFmpeg_${COMPONENT}_LIBRARY "${FFmpeg_${COMPONENT}_PREFIX}/${FFmpeg_${COMPONENT}_LIB_NAME}")
+
+            set(FFmpeg_LIBRARIES
+                ${FFmpeg_LIBRARIES}
+                ${FFmpeg_${COMPONENT}_LIBRARY}
+                CACHE PATH "Paths to FFmpeg libraries" FORCE)
+        endforeach()
+
+        set(FFmpeg_INCLUDE_DIR
+            ${FFmpeg_PREFIX}
+            CACHE PATH "Path to FFmpeg headers" FORCE)
+
+        # `configure` parameters builds only exactly what yuzu needs from FFmpeg
+        # `--disable-{vaapi,vdpau}` is needed to avoid linking issues
+        add_custom_command(
+            OUTPUT
+                ${FFmpeg_MAKEFILE}
+            COMMAND
+                /bin/bash ${FFmpeg_PREFIX}/configure
+                    --disable-avdevice
+                    --disable-avfilter
+                    --disable-avformat
+                    --disable-doc
+                    --disable-everything
+                    --disable-ffmpeg
+                    --disable-ffprobe
+                    --disable-network
+                    --disable-postproc
+                    --disable-swresample
+                    --disable-vaapi
+                    --disable-vdpau
+                    --enable-decoder=h264
+                    --enable-decoder=vp9
+            WORKING_DIRECTORY
+                ${FFmpeg_BUILD_DIR}
+        )
+
+        # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
+        # with context of the jobserver. Also helps ninja users.
+        execute_process(
+            COMMAND
+                nproc
+            OUTPUT_VARIABLE
+                SYSTEM_THREADS)
+
+        add_custom_command(
+            OUTPUT
+                ${FFmpeg_LIBRARIES}
+            COMMAND
+                make -j${SYSTEM_THREADS}
+            WORKING_DIRECTORY
+                ${FFmpeg_BUILD_DIR}
+        )
+
+        # ALL makes this custom target build every time
+        # but it won't actually build if the DEPENDS parameter is up to date
+        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_LIBRARIES})
+        add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
+
+        if (FFmpeg_FOUND)
+            message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
+
+            add_dependencies(ffmpeg-build ffmpeg-configure)
+        else()
+            message(FATAL_ERROR "FFmpeg not found")
+        endif()
+    else() # WIN32
+        # Use yuzu FFmpeg binaries
+        set(FFmpeg_EXT_NAME "ffmpeg-4.2.1")
+        set(FFmpeg_PATH "${CMAKE_BINARY_DIR}/externals/${FFmpeg_EXT_NAME}")
+        download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "")
+        set(FFmpeg_FOUND YES)
+        set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
+        set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)
+        set(FFmpeg_DLL_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
+        set(FFmpeg_LIBRARIES
+            ${FFmpeg_LIBRARY_DIR}/swscale.lib
+            ${FFmpeg_LIBRARY_DIR}/avcodec.lib
+            ${FFmpeg_LIBRARY_DIR}/avutil.lib
+            CACHE PATH "Paths to FFmpeg libraries" FORCE)
+    endif()
+endif()
+
+unset(FFmpeg_COMPONENTS)
+
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
@@ -1,7 +1,7 @@
 function(copy_yuzu_FFmpeg_deps target_dir)
    include(WindowsCopyFiles)
    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
-    windows_copy_files(${target_dir} ${FFMPEG_DLL_DIR} ${DLL_DEST}
+    windows_copy_files(${target_dir} ${FFmpeg_DLL_DIR} ${DLL_DEST}
        avcodec-58.dll
        avutil-56.dll
        swresample-3.dll
@@ -33,7 +33,7 @@ If you want to contribute to the user interface translation, please check out th


 ### Support
-We happily accept monetary donations or donated games and hardware. Please see our [donations page](https://yuzu-emu.org/donate/) for more information on how you can contribute to yuzu. Any donations received will go towards things like:
+We happily accept monetary donations, or donated games and hardware. Please see our [donations page](https://yuzu-emu.org/donate/) for more information on how you can contribute to yuzu. Any donations received will go towards things like:
 * Switch consoles to explore and reverse-engineer the hardware
 * Switch games for testing, reverse-engineering, and implementing new features
 * Web hosting and infrastructure setup
@@ -1,26 +1,5 @@
 <RCC>
  <qresource prefix="controller">
-    <file alias="dual_joycon">dual_joycon.png</file>
-    <file alias="dual_joycon_dark">dual_joycon_dark.png</file>
-    <file alias="dual_joycon_midnight">dual_joycon_midnight.png</file>
-    <file alias="handheld">handheld.png</file>
-    <file alias="handheld_dark">handheld_dark.png</file>
-    <file alias="handheld_midnight">handheld_midnight.png</file>
-    <file alias="pro_controller">pro_controller.png</file>
-    <file alias="pro_controller_dark">pro_controller_dark.png</file>
-    <file alias="pro_controller_midnight">pro_controller_midnight.png</file>
-    <file alias="single_joycon_left">single_joycon_left.png</file>
-    <file alias="single_joycon_left_dark">single_joycon_left_dark.png</file>
-    <file alias="single_joycon_left_midnight">single_joycon_left_midnight.png</file>
-    <file alias="single_joycon_right">single_joycon_right.png</file>
-    <file alias="single_joycon_right_dark">single_joycon_right_dark.png</file>
-    <file alias="single_joycon_right_midnight">single_joycon_right_midnight.png</file>
-    <file alias="single_joycon_left_vertical">single_joycon_left_vertical.png</file>
-    <file alias="single_joycon_left_vertical_dark">single_joycon_left_vertical_dark.png</file>
-    <file alias="single_joycon_left_vertical_midnight">single_joycon_left_vertical_midnight.png</file>
-    <file alias="single_joycon_right_vertical">single_joycon_right_vertical.png</file>
-    <file alias="single_joycon_right_vertical_dark">single_joycon_right_vertical_dark.png</file>
-    <file alias="single_joycon_right_vertical_midnight">single_joycon_right_vertical_midnight.png</file>
    <file alias="applet_dual_joycon">applet_dual_joycon.png</file>
    <file alias="applet_dual_joycon_dark">applet_dual_joycon_dark.png</file>	
    <file alias="applet_dual_joycon_midnight">applet_dual_joycon_midnight.png</file>	
@@ -1,7 +1,7 @@
 [Icon Theme]
 Name=colorful_dark
 Comment=Colorful theme (Dark style)
-Inherits=default
+Inherits=colorful
 Directories=16x16
 
 [16x16]
@@ -1,7 +1,7 @@
 [Icon Theme]
 Name=colorful_midnight_blue
 Comment=Colorful theme (Midnight Blue style)
-Inherits=default
+Inherits=colorful
 Directories=16x16

 [16x16]
@@ -1257,10 +1257,6 @@ QComboBox::item:alternate {
  background: #19232D;
 }

-QComboBox::item:checked {
-  font-weight: bold;
-}
-
 QComboBox::item:selected {
  border: 0px solid transparent;
 }
@@ -1,100 +1,187 @@
-# - Try to find ffmpeg libraries (libavcodec, libavformat and libavutil)
-# Once done this will define
+# FindFFmpeg
+# ----------
 #
-# FFMPEG_FOUND - system has ffmpeg or libav
-# FFMPEG_INCLUDE_DIR - the ffmpeg include directory
-# FFMPEG_LIBRARIES - Link these to use ffmpeg
-# FFMPEG_LIBAVCODEC
-# FFMPEG_LIBAVFORMAT
-# FFMPEG_LIBAVUTIL
+# Copyright 2019 Citra Emulator Project
+# Licensed under GPLv2 or any later version
 #
-# Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
-# Modified for other libraries by Lasse Kärkkäinen <tronic>
-# Modified for Hedgewars by Stepik777
-# Modified for FFmpeg-example Tuukka Pasanen 2018
-# Modified for yuzu toastUnlimted 2020
+# Find the native FFmpeg includes and libraries
 #
-# Redistribution and use is allowed according to the terms of the New
-# BSD license.
+# This module defines the following variables:
+#
+#  FFmpeg_INCLUDE_<component>: where to find <component>.h
+#  FFmpeg_LIBRARY_<component>: where to find the <component> library
+#  FFmpeg_INCLUDE_DIR: aggregate all the include paths
+#  FFmpeg_LIBRARIES: aggregate all the paths to the libraries
+#  FFmpeg_FOUND: True if all components have been found
+#
+# This module defines the following targets, which are prefered over variables:
+#
+#  FFmpeg::<component>: Target to use <component> directly, with include path,
+#    library and dependencies set up. If you are using a static build, you are
+#    responsible for adding any external dependencies (such as zlib, bzlib...).
+#
+# <component> can be one of:
+#   avcodec
+#   avdevice
+#   avfilter
+#   avformat
+#   avutil
+#   postproc
+#   swresample
+#   swscale
 #

-include(FindPackageHandleStandardArgs)
-
-find_package_handle_standard_args(FFMPEG
-  FOUND_VAR FFMPEG_FOUND
-  REQUIRED_VARS
-      FFMPEG_LIBRARY
-      FFMPEG_INCLUDE_DIR
-  VERSION_VAR FFMPEG_VERSION
+set(_FFmpeg_ALL_COMPONENTS
+    avcodec
+    avdevice
+    avfilter
+    avformat
+    avutil
+    postproc
+    swresample
+    swscale
 )

-if(FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
-  # in cache already
-  set(FFMPEG_FOUND TRUE)
-else()
-  # use pkg-config to get the directories and then use these values
-  # in the FIND_PATH() and FIND_LIBRARY() calls
-  find_package(PkgConfig)
-  if(PKG_CONFIG_FOUND)
-    pkg_check_modules(_FFMPEG_AVCODEC libavcodec)
-    pkg_check_modules(_FFMPEG_AVUTIL libavutil)
-    pkg_check_modules(_FFMPEG_SWSCALE libswscale)
+set(_FFmpeg_DEPS_avcodec avutil)
+set(_FFmpeg_DEPS_avdevice avcodec avformat avutil)
+set(_FFmpeg_DEPS_avfilter avutil)
+set(_FFmpeg_DEPS_avformat avcodec avutil)
+set(_FFmpeg_DEPS_postproc avutil)
+set(_FFmpeg_DEPS_swresample avutil)
+set(_FFmpeg_DEPS_swscale avutil)
+
+function(find_ffmpeg LIBNAME)
+  if(DEFINED ENV{FFMPEG_DIR})
+    set(FFMPEG_DIR $ENV{FFMPEG_DIR})
  endif()

-  find_path(FFMPEG_AVCODEC_INCLUDE_DIR
-    NAMES libavcodec/avcodec.h
-    PATHS ${_FFMPEG_AVCODEC_INCLUDE_DIRS}
-      /usr/include
-      /usr/local/include
-      /opt/local/include
-      /sw/include
-    PATH_SUFFIXES ffmpeg libav)
-
-  find_library(FFMPEG_LIBAVCODEC
-    NAMES avcodec
-    PATHS ${_FFMPEG_AVCODEC_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  find_library(FFMPEG_LIBAVUTIL
-    NAMES avutil
-    PATHS ${_FFMPEG_AVUTIL_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  find_library(FFMPEG_LIBSWSCALE
-    NAMES swscale
-    PATHS ${_FFMPEG_SWSCALE_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  if(FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVUTIL AND FFMPEG_LIBSWSCALE)
-    set(FFMPEG_FOUND TRUE)
-  endif()
-
-  if(FFMPEG_FOUND)
-    set(FFMPEG_INCLUDE_DIR ${FFMPEG_AVCODEC_INCLUDE_DIR})
-    set(FFMPEG_LIBRARIES
-      ${FFMPEG_LIBAVCODEC}
-      ${FFMPEG_LIBAVUTIL}
-      ${FFMPEG_LIBSWSCALE})
-  endif()
-
-  if(FFMPEG_FOUND)
-    if(NOT FFMPEG_FIND_QUIETLY)
-      message(STATUS
-      "Found FFMPEG or Libav: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}")
-    endif()
+  if(FFMPEG_DIR)
+    list(APPEND INCLUDE_PATHS
+      ${FFMPEG_DIR}
+      ${FFMPEG_DIR}/ffmpeg
+      ${FFMPEG_DIR}/lib${LIBNAME}
+      ${FFMPEG_DIR}/include/lib${LIBNAME}
+      ${FFMPEG_DIR}/include/ffmpeg
+      ${FFMPEG_DIR}/include
+      NO_DEFAULT_PATH
+      NO_CMAKE_FIND_ROOT_PATH
+    )
+    list(APPEND LIB_PATHS
+      ${FFMPEG_DIR}
+      ${FFMPEG_DIR}/lib
+      ${FFMPEG_DIR}/lib${LIBNAME}
+      NO_DEFAULT_PATH
+      NO_CMAKE_FIND_ROOT_PATH
+    )
  else()
-    if(FFMPEG_FIND_REQUIRED)
-      message(FATAL_ERROR
-      "Could not find libavcodec or libavutil or libswscale")
+    list(APPEND INCLUDE_PATHS
+      /usr/local/include/ffmpeg
+      /usr/local/include/lib${LIBNAME}
+      /usr/include/ffmpeg
+      /usr/include/lib${LIBNAME}
+      /usr/include/ffmpeg/lib${LIBNAME}
+    )
+
+    list(APPEND LIB_PATHS
+      /usr/local/lib
+      /usr/lib
+    )
+  endif()
+
+  find_path(FFmpeg_INCLUDE_${LIBNAME} lib${LIBNAME}/${LIBNAME}.h
+    HINTS ${INCLUDE_PATHS}
+  )
+
+  find_library(FFmpeg_LIBRARY_${LIBNAME} ${LIBNAME}
+    HINTS ${LIB_PATHS}
+  )
+
+  if(NOT FFMPEG_DIR AND (NOT FFmpeg_LIBRARY_${LIBNAME} OR NOT FFmpeg_INCLUDE_${LIBNAME}))
+    # Didn't find it in the usual paths, try pkg-config
+    find_package(PkgConfig QUIET)
+    pkg_check_modules(FFmpeg_PKGCONFIG_${LIBNAME} QUIET lib${LIBNAME})
+
+    find_path(FFmpeg_INCLUDE_${LIBNAME} lib${LIBNAME}/${LIBNAME}.h
+      ${FFmpeg_PKGCONFIG_${LIBNAME}_INCLUDE_DIRS}
+    )
+
+    find_library(FFmpeg_LIBRARY_${LIBNAME} ${LIBNAME}
+      ${FFmpeg_PKGCONFIG_${LIBNAME}_LIBRARY_DIRS}
+    )
+  endif()
+
+  if(FFmpeg_INCLUDE_${LIBNAME} AND FFmpeg_LIBRARY_${LIBNAME})
+    set(FFmpeg_INCLUDE_${LIBNAME} "${FFmpeg_INCLUDE_${LIBNAME}}" PARENT_SCOPE)
+    set(FFmpeg_LIBRARY_${LIBNAME} "${FFmpeg_LIBRARY_${LIBNAME}}" PARENT_SCOPE)
+
+    # Extract FFmpeg version from version.h
+    foreach(v MAJOR MINOR MICRO)
+      set(FFmpeg_${LIBNAME}_VERSION_${v} 0)
+    endforeach()
+    string(TOUPPER ${LIBNAME} LIBNAME_UPPER)
+    file(STRINGS "${FFmpeg_INCLUDE_${LIBNAME}}/lib${LIBNAME}/version.h" _FFmpeg_VERSION_H_CONTENTS REGEX "#define LIB${LIBNAME_UPPER}_VERSION_(MAJOR|MINOR|MICRO) ")
+    set(_FFmpeg_VERSION_REGEX "([0-9]+)")
+    foreach(v MAJOR MINOR MICRO)
+      if("${_FFmpeg_VERSION_H_CONTENTS}" MATCHES "#define LIB${LIBNAME_UPPER}_VERSION_${v}[\\t ]+${_FFmpeg_VERSION_REGEX}")
+        set(FFmpeg_${LIBNAME}_VERSION_${v} "${CMAKE_MATCH_1}")
+      endif()
+    endforeach()
+    set(FFmpeg_${LIBNAME}_VERSION "${FFmpeg_${LIBNAME}_VERSION_MAJOR}.${FFmpeg_${LIBNAME}_VERSION_MINOR}.${FFmpeg_${LIBNAME}_VERSION_MICRO}")
+    set(FFmpeg_${c}_VERSION "${FFmpeg_${LIBNAME}_VERSION}" PARENT_SCOPE)
+    unset(_FFmpeg_VERSION_REGEX)
+    unset(_FFmpeg_VERSION_H_CONTENTS)
+
+    set(FFmpeg_${c}_FOUND TRUE PARENT_SCOPE)
+    if(NOT FFmpeg_FIND_QUIETLY)
+      message("--  Found ${LIBNAME}: ${FFmpeg_INCLUDE_${LIBNAME}} ${FFmpeg_LIBRARY_${LIBNAME}} (version: ${FFmpeg_${LIBNAME}_VERSION})")
    endif()
  endif()
+endfunction()
+
+foreach(c ${_FFmpeg_ALL_COMPONENTS})
+  find_ffmpeg(${c})
+endforeach()
+
+foreach(c ${_FFmpeg_ALL_COMPONENTS})
+  if(FFmpeg_${c}_FOUND)
+    list(APPEND FFmpeg_INCLUDE_DIR ${FFmpeg_INCLUDE_${c}})
+    list(APPEND FFmpeg_LIBRARIES ${FFmpeg_LIBRARY_${c}})
+
+    add_library(FFmpeg::${c} IMPORTED UNKNOWN)
+    set_target_properties(FFmpeg::${c} PROPERTIES
+      IMPORTED_LOCATION ${FFmpeg_LIBRARY_${c}}
+      INTERFACE_INCLUDE_DIRECTORIES ${FFmpeg_INCLUDE_${c}}
+    )
+    if(_FFmpeg_DEPS_${c})
+      set(deps)
+      foreach(dep ${_FFmpeg_DEPS_${c}})
+        list(APPEND deps FFmpeg::${dep})
+      endforeach()
+
+      set_target_properties(FFmpeg::${c} PROPERTIES
+        INTERFACE_LINK_LIBRARIES "${deps}"
+      )
+      unset(deps)
+    endif()
+  endif()
+endforeach()
+
+if(FFmpeg_INCLUDE_DIR)
+  list(REMOVE_DUPLICATES FFmpeg_INCLUDE_DIR)
 endif()
+
+foreach(c ${FFmpeg_FIND_COMPONENTS})
+  list(APPEND _FFmpeg_REQUIRED_VARS FFmpeg_INCLUDE_${c} FFmpeg_LIBRARY_${c})
+endforeach()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(FFmpeg
+  REQUIRED_VARS ${_FFmpeg_REQUIRED_VARS}
+  HANDLE_COMPONENTS
+)
+
+foreach(c ${_FFmpeg_ALL_COMPONENTS})
+  unset(_FFmpeg_DEPS_${c})
+endforeach()
+unset(_FFmpeg_ALL_COMPONENTS)
+unset(_FFmpeg_REQUIRED_VARS)
@@ -15,6 +15,8 @@ add_library(audio_core STATIC
    command_generator.cpp
    command_generator.h
    common.h
+    delay_line.cpp
+    delay_line.h
    effect_context.cpp
    effect_context.h
    info_updater.cpp
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <cmath>
+#include <numbers>
 #include "audio_core/algorithm/interpolate.h"
 #include "audio_core/command_generator.h"
 #include "audio_core/effect_context.h"
@@ -13,6 +15,20 @@ namespace AudioCore {
 namespace {
 constexpr std::size_t MIX_BUFFER_SIZE = 0x3f00;
 constexpr std::size_t SCALED_MIX_BUFFER_SIZE = MIX_BUFFER_SIZE << 15ULL;
+using DelayLineTimes = std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT>;
+
+constexpr DelayLineTimes FDN_MIN_DELAY_LINE_TIMES{5.0f, 6.0f, 13.0f, 14.0f};
+constexpr DelayLineTimes FDN_MAX_DELAY_LINE_TIMES{45.704f, 82.782f, 149.94f, 271.58f};
+constexpr DelayLineTimes DECAY0_MAX_DELAY_LINE_TIMES{17.0f, 13.0f, 9.0f, 7.0f};
+constexpr DelayLineTimes DECAY1_MAX_DELAY_LINE_TIMES{19.0f, 11.0f, 10.0f, 6.0f};
+constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_TAP_TIMES{
+    0.017136f, 0.059154f, 0.161733f, 0.390186f, 0.425262f, 0.455411f, 0.689737f,
+    0.745910f, 0.833844f, 0.859502f, 0.000000f, 0.075024f, 0.168788f, 0.299901f,
+    0.337443f, 0.371903f, 0.599011f, 0.716741f, 0.817859f, 0.851664f};
+constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_GAIN{
+    0.67096f, 0.61027f, 1.0f,     0.35680f, 0.68361f, 0.65978f, 0.51939f,
+    0.24712f, 0.45945f, 0.45021f, 0.64196f, 0.54879f, 0.92925f, 0.38270f,
+    0.72867f, 0.69794f, 0.5464f,  0.24563f, 0.45214f, 0.44042f};

 template <std::size_t N>
 void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
@@ -65,6 +81,154 @@ s32 ApplyMixDepop(s32* output, s32 first_sample, s32 delta, s32 sample_count) {
    }
 }

+float Pow10(float x) {
+    if (x >= 0.0f) {
+        return 1.0f;
+    } else if (x <= -5.3f) {
+        return 0.0f;
+    }
+    return std::pow(10.0f, x);
+}
+
+float SinD(float degrees) {
+    return std::sin(degrees * std::numbers::pi_v<float> / 180.0f);
+}
+
+float CosD(float degrees) {
+    return std::cos(degrees * std::numbers::pi_v<float> / 180.0f);
+}
+
+float ToFloat(s32 sample) {
+    return static_cast<float>(sample) / 65536.f;
+}
+
+s32 ToS32(float sample) {
+    constexpr auto min = -8388608.0f;
+    constexpr auto max = 8388607.f;
+    float rescaled_sample = sample * 65536.0f;
+    if (rescaled_sample < min) {
+        rescaled_sample = min;
+    }
+    if (rescaled_sample > max) {
+        rescaled_sample = max;
+    }
+    return static_cast<s32>(rescaled_sample);
+}
+
+constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_1CH{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_2CH{0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
+                                                           1, 1, 1, 0, 0, 0, 0, 1, 1, 1};
+
+constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_4CH{0, 0, 0, 1, 1, 1, 1, 2, 2, 2,
+                                                           1, 1, 1, 0, 0, 0, 0, 3, 3, 3};
+
+constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_6CH{4, 0, 0, 1, 1, 1, 1, 2, 2, 2,
+                                                           1, 1, 1, 0, 0, 0, 0, 3, 3, 3};
+
+template <std::size_t CHANNEL_COUNT>
+void ApplyReverbGeneric(I3dl2ReverbState& state,
+                        const std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT>& input,
+                        const std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT>& output,
+                        s32 sample_count) {
+
+    auto GetTapLookup = []() {
+        if constexpr (CHANNEL_COUNT == 1) {
+            return REVERB_TAP_INDEX_1CH;
+        } else if constexpr (CHANNEL_COUNT == 2) {
+            return REVERB_TAP_INDEX_2CH;
+        } else if constexpr (CHANNEL_COUNT == 4) {
+            return REVERB_TAP_INDEX_4CH;
+        } else if constexpr (CHANNEL_COUNT == 6) {
+            return REVERB_TAP_INDEX_6CH;
+        }
+    };
+
+    const auto& tap_index_lut = GetTapLookup();
+    for (s32 sample = 0; sample < sample_count; sample++) {
+        std::array<f32, CHANNEL_COUNT> out_samples{};
+        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> fsamp{};
+        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> mixed{};
+        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> osamp{};
+
+        // Mix everything into a single sample
+        s32 temp_mixed_sample = 0;
+        for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
+            temp_mixed_sample += input[i][sample];
+        }
+        const auto current_sample = ToFloat(temp_mixed_sample);
+        const auto early_tap = state.early_delay_line.TapOut(state.early_to_late_taps);
+
+        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_TAPS; i++) {
+            const auto tapped_samp =
+                state.early_delay_line.TapOut(state.early_tap_steps[i]) * EARLY_GAIN[i];
+            out_samples[tap_index_lut[i]] += tapped_samp;
+
+            if constexpr (CHANNEL_COUNT == 6) {
+                // handle lfe
+                out_samples[5] += tapped_samp;
+            }
+        }
+
+        state.lowpass_0 = current_sample * state.lowpass_2 + state.lowpass_0 * state.lowpass_1;
+        state.early_delay_line.Tick(state.lowpass_0);
+
+        for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
+            out_samples[i] *= state.early_gain;
+        }
+
+        // Two channel seems to apply a latet gain, we require to save this
+        f32 filter{};
+        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
+            filter = state.fdn_delay_line[i].GetOutputSample();
+            const auto computed = filter * state.lpf_coefficients[0][i] + state.shelf_filter[i];
+            state.shelf_filter[i] =
+                filter * state.lpf_coefficients[1][i] + computed * state.lpf_coefficients[2][i];
+            fsamp[i] = computed;
+        }
+
+        // Mixing matrix
+        mixed[0] = fsamp[1] + fsamp[2];
+        mixed[1] = -fsamp[0] - fsamp[3];
+        mixed[2] = fsamp[0] - fsamp[3];
+        mixed[3] = fsamp[1] - fsamp[2];
+
+        if constexpr (CHANNEL_COUNT == 2) {
+            for (auto& mix : mixed) {
+                mix *= (filter * state.late_gain);
+            }
+        }
+
+        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
+            const auto late = early_tap * state.late_gain;
+            osamp[i] = state.decay_delay_line0[i].Tick(late + mixed[i]);
+            osamp[i] = state.decay_delay_line1[i].Tick(osamp[i]);
+            state.fdn_delay_line[i].Tick(osamp[i]);
+        }
+
+        if constexpr (CHANNEL_COUNT == 1) {
+            output[0][sample] = ToS32(state.dry_gain * ToFloat(input[0][sample]) +
+                                      (out_samples[0] + osamp[0] + osamp[1]));
+        } else if constexpr (CHANNEL_COUNT == 2 || CHANNEL_COUNT == 4) {
+            for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
+                output[i][sample] =
+                    ToS32(state.dry_gain * ToFloat(input[i][sample]) + (out_samples[i] + osamp[i]));
+            }
+        } else if constexpr (CHANNEL_COUNT == 6) {
+            const auto temp_center = state.center_delay_line.Tick(0.5f * (osamp[2] - osamp[3]));
+            for (std::size_t i = 0; i < 4; i++) {
+                output[i][sample] =
+                    ToS32(state.dry_gain * ToFloat(input[i][sample]) + (out_samples[i] + osamp[i]));
+            }
+            output[4][sample] =
+                ToS32(state.dry_gain * ToFloat(input[4][sample]) + (out_samples[4] + temp_center));
+            output[5][sample] =
+                ToS32(state.dry_gain * ToFloat(input[5][sample]) + (out_samples[5] + osamp[3]));
+        }
+    }
+}
+
 } // namespace

 CommandGenerator::CommandGenerator(AudioCommon::AudioRendererParameter& worker_params_,
@@ -271,11 +435,10 @@ void CommandGenerator::GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voic
        }

        // Generate biquad filter
-        //        GenerateBiquadFilterCommand(mix_buffer_count, biquad_filter,
-        //        dsp_state.biquad_filter_state,
-        //                                    mix_buffer_count + channel, mix_buffer_count +
-        //                                    channel, worker_params.sample_count,
-        //                                    voice_info.GetInParams().node_id);
+        // GenerateBiquadFilterCommand(mix_buffer_count, biquad_filter,
+        // dsp_state.biquad_filter_state,
+        //                            mix_buffer_count + channel, mix_buffer_count + channel,
+        //                            worker_params.sample_count, voice_info.GetInParams().node_id);
    }
 }

@@ -376,17 +539,53 @@ void CommandGenerator::GenerateEffectCommand(ServerMixInfo& mix_info) {

 void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, EffectBase* info,
                                                        bool enabled) {
-    if (!enabled) {
+    auto* reverb = dynamic_cast<EffectI3dl2Reverb*>(info);
+    const auto& params = reverb->GetParams();
+    auto& state = reverb->GetState();
+    const auto channel_count = params.channel_count;
+
+    if (channel_count != 1 && channel_count != 2 && channel_count != 4 && channel_count != 6) {
        return;
    }
-    const auto& params = dynamic_cast<EffectI3dl2Reverb*>(info)->GetParams();
-    const auto channel_count = params.channel_count;
+
+    std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT> input{};
+    std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT> output{};
+
+    const auto status = params.status;
    for (s32 i = 0; i < channel_count; i++) {
-        // TODO(ogniK): Actually implement reverb
-        if (params.input[i] != params.output[i]) {
-            const auto* input = GetMixBuffer(mix_buffer_offset + params.input[i]);
-            auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
-            ApplyMix<1>(output, input, 32768, worker_params.sample_count);
+        input[i] = GetMixBuffer(mix_buffer_offset + params.input[i]);
+        output[i] = GetMixBuffer(mix_buffer_offset + params.output[i]);
+    }
+
+    if (enabled) {
+        if (status == ParameterStatus::Initialized) {
+            InitializeI3dl2Reverb(reverb->GetParams(), state, info->GetWorkBuffer());
+        } else if (status == ParameterStatus::Updating) {
+            UpdateI3dl2Reverb(reverb->GetParams(), state, false);
+        }
+    }
+
+    if (enabled) {
+        switch (channel_count) {
+        case 1:
+            ApplyReverbGeneric<1>(state, input, output, worker_params.sample_count);
+            break;
+        case 2:
+            ApplyReverbGeneric<2>(state, input, output, worker_params.sample_count);
+            break;
+        case 4:
+            ApplyReverbGeneric<4>(state, input, output, worker_params.sample_count);
+            break;
+        case 6:
+            ApplyReverbGeneric<6>(state, input, output, worker_params.sample_count);
+            break;
+        }
+    } else {
+        for (s32 i = 0; i < channel_count; i++) {
+            // Only copy if the buffer input and output do not match!
+            if ((mix_buffer_offset + params.input[i]) != (mix_buffer_offset + params.output[i])) {
+                std::memcpy(output[i], input[i], worker_params.sample_count * sizeof(s32));
+            }
        }
    }
 }
@@ -525,6 +724,133 @@ s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u3
    return sample_count;
 }

+void CommandGenerator::InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
+                                             std::vector<u8>& work_buffer) {
+    // Reset state
+    state.lowpass_0 = 0.0f;
+    state.lowpass_1 = 0.0f;
+    state.lowpass_2 = 0.0f;
+
+    state.early_delay_line.Reset();
+    state.early_tap_steps.fill(0);
+    state.early_gain = 0.0f;
+    state.late_gain = 0.0f;
+    state.early_to_late_taps = 0;
+    for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
+        state.fdn_delay_line[i].Reset();
+        state.decay_delay_line0[i].Reset();
+        state.decay_delay_line1[i].Reset();
+    }
+    state.last_reverb_echo = 0.0f;
+    state.center_delay_line.Reset();
+    for (auto& coef : state.lpf_coefficients) {
+        coef.fill(0.0f);
+    }
+    state.shelf_filter.fill(0.0f);
+    state.dry_gain = 0.0f;
+
+    const auto sample_rate = info.sample_rate / 1000;
+    f32* work_buffer_ptr = reinterpret_cast<f32*>(work_buffer.data());
+
+    s32 delay_samples{};
+    for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
+        delay_samples =
+            AudioCommon::CalculateDelaySamples(sample_rate, FDN_MAX_DELAY_LINE_TIMES[i]);
+        state.fdn_delay_line[i].Initialize(delay_samples, work_buffer_ptr);
+        work_buffer_ptr += delay_samples + 1;
+
+        delay_samples =
+            AudioCommon::CalculateDelaySamples(sample_rate, DECAY0_MAX_DELAY_LINE_TIMES[i]);
+        state.decay_delay_line0[i].Initialize(delay_samples, 0.0f, work_buffer_ptr);
+        work_buffer_ptr += delay_samples + 1;
+
+        delay_samples =
+            AudioCommon::CalculateDelaySamples(sample_rate, DECAY1_MAX_DELAY_LINE_TIMES[i]);
+        state.decay_delay_line1[i].Initialize(delay_samples, 0.0f, work_buffer_ptr);
+        work_buffer_ptr += delay_samples + 1;
+    }
+    delay_samples = AudioCommon::CalculateDelaySamples(sample_rate, 5.0f);
+    state.center_delay_line.Initialize(delay_samples, work_buffer_ptr);
+    work_buffer_ptr += delay_samples + 1;
+
+    delay_samples = AudioCommon::CalculateDelaySamples(sample_rate, 400.0f);
+    state.early_delay_line.Initialize(delay_samples, work_buffer_ptr);
+
+    UpdateI3dl2Reverb(info, state, true);
+}
+
+void CommandGenerator::UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
+                                         bool should_clear) {
+
+    state.dry_gain = info.dry_gain;
+    state.shelf_filter.fill(0.0f);
+    state.lowpass_0 = 0.0f;
+    state.early_gain = Pow10(std::min(info.room + info.reflection, 5000.0f) / 2000.0f);
+    state.late_gain = Pow10(std::min(info.room + info.reverb, 5000.0f) / 2000.0f);
+
+    const auto sample_rate = info.sample_rate / 1000;
+    const f32 hf_gain = Pow10(info.room_hf / 2000.0f);
+    if (hf_gain >= 1.0f) {
+        state.lowpass_2 = 1.0f;
+        state.lowpass_1 = 0.0f;
+    } else {
+        const auto a = 1.0f - hf_gain;
+        const auto b = 2.0f * (1.0f - hf_gain * CosD(256.0f * info.hf_reference /
+                                                     static_cast<f32>(info.sample_rate)));
+        const auto c = std::sqrt(b * b - 4.0f * a * a);
+
+        state.lowpass_1 = (b - c) / (2.0f * a);
+        state.lowpass_2 = 1.0f - state.lowpass_1;
+    }
+    state.early_to_late_taps = AudioCommon::CalculateDelaySamples(
+        sample_rate, 1000.0f * (info.reflection_delay + info.reverb_delay));
+
+    state.last_reverb_echo = 0.6f * info.diffusion * 0.01f;
+    for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
+        const auto length =
+            FDN_MIN_DELAY_LINE_TIMES[i] +
+            (info.density / 100.0f) * (FDN_MAX_DELAY_LINE_TIMES[i] - FDN_MIN_DELAY_LINE_TIMES[i]);
+        state.fdn_delay_line[i].SetDelay(AudioCommon::CalculateDelaySamples(sample_rate, length));
+
+        const auto delay_sample_counts = state.fdn_delay_line[i].GetDelay() +
+                                         state.decay_delay_line0[i].GetDelay() +
+                                         state.decay_delay_line1[i].GetDelay();
+
+        float a = (-60.0f * static_cast<f32>(delay_sample_counts)) /
+                  (info.decay_time * static_cast<f32>(info.sample_rate));
+        float b = a / info.hf_decay_ratio;
+        float c = CosD(128.0f * 0.5f * info.hf_reference / static_cast<f32>(info.sample_rate)) /
+                  SinD(128.0f * 0.5f * info.hf_reference / static_cast<f32>(info.sample_rate));
+        float d = Pow10((b - a) / 40.0f);
+        float e = Pow10((b + a) / 40.0f) * 0.7071f;
+
+        state.lpf_coefficients[0][i] = e * ((d * c) + 1.0f) / (c + d);
+        state.lpf_coefficients[1][i] = e * (1.0f - (d * c)) / (c + d);
+        state.lpf_coefficients[2][i] = (c - d) / (c + d);
+
+        state.decay_delay_line0[i].SetCoefficient(state.last_reverb_echo);
+        state.decay_delay_line1[i].SetCoefficient(-0.9f * state.last_reverb_echo);
+    }
+
+    if (should_clear) {
+        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
+            state.fdn_delay_line[i].Clear();
+            state.decay_delay_line0[i].Clear();
+            state.decay_delay_line1[i].Clear();
+        }
+        state.early_delay_line.Clear();
+        state.center_delay_line.Clear();
+    }
+
+    const auto max_early_delay = state.early_delay_line.GetMaxDelay();
+    const auto reflection_time = 1000.0f * (0.0098f * info.reverb_delay + 0.02f);
+    for (std::size_t tap = 0; tap < AudioCommon::I3DL2REVERB_TAPS; tap++) {
+        const auto length = AudioCommon::CalculateDelaySamples(
+            sample_rate, 1000.0f * info.reflection_delay + reflection_time * EARLY_TAP_TIMES[tap]);
+        state.early_tap_steps[tap] = std::min(length, max_early_delay);
+    }
+}
+
 void CommandGenerator::GenerateVolumeRampCommand(float last_volume, float current_volume,
                                                 s32 channel, s32 node_id) {
    const auto last = static_cast<s32>(last_volume * 32768.0f);
@@ -21,6 +21,8 @@ class ServerMixInfo;
 class EffectContext;
 class EffectBase;
 struct AuxInfoDSP;
+struct I3dl2ReverbParams;
+struct I3dl2ReverbState;
 using MixVolumeBuffer = std::array<float, AudioCommon::MAX_MIX_BUFFERS>;

 class CommandGenerator {
@@ -80,6 +82,9 @@ private:
    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples, s32* out_data,
                      u32 sample_count, u32 read_offset, u32 read_count);

+    void InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
+                               std::vector<u8>& work_buffer);
+    void UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state, bool should_clear);
    // DSP Code
    s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
                    s32 channel, std::size_t mix_offset);
@@ -33,6 +33,29 @@ constexpr std::size_t TEMP_MIX_BASE_SIZE = 0x3f00; // TODO(ogniK): Work out this
 // and our const ends up being 0x3f04, the 4 bytes are most
 // likely the sample history
 constexpr std::size_t TOTAL_TEMP_MIX_SIZE = TEMP_MIX_BASE_SIZE + AudioCommon::MAX_SAMPLE_HISTORY;
+constexpr f32 I3DL2REVERB_MAX_LEVEL = 5000.0f;
+constexpr f32 I3DL2REVERB_MIN_REFLECTION_DURATION = 0.02f;
+constexpr std::size_t I3DL2REVERB_TAPS = 20;
+constexpr std::size_t I3DL2REVERB_DELAY_LINE_COUNT = 4;
+using Fractional = s32;
+
+template <typename T>
+constexpr Fractional ToFractional(T x) {
+    return static_cast<Fractional>(x * static_cast<T>(0x4000));
+}
+
+constexpr Fractional MultiplyFractional(Fractional lhs, Fractional rhs) {
+    return static_cast<Fractional>(static_cast<s64>(lhs) * rhs >> 14);
+}
+
+constexpr s32 FractionalToFixed(Fractional x) {
+    const auto s = x & (1 << 13);
+    return static_cast<s32>(x >> 14) + s;
+}
+
+constexpr s32 CalculateDelaySamples(s32 sample_rate_khz, float time) {
+    return FractionalToFixed(MultiplyFractional(ToFractional(sample_rate_khz), ToFractional(time)));
+}

 static constexpr u32 VersionFromRevision(u32_le rev) {
    // "REV7" -> 7
@@ -0,0 +1,104 @@
+#include <cstring>
+#include "audio_core/delay_line.h"
+
+namespace AudioCore {
+DelayLineBase::DelayLineBase() = default;
+DelayLineBase::~DelayLineBase() = default;
+
+void DelayLineBase::Initialize(s32 max_delay_, float* src_buffer) {
+    buffer = src_buffer;
+    buffer_end = buffer + max_delay_;
+    max_delay = max_delay_;
+    output = buffer;
+    SetDelay(max_delay_);
+    Clear();
+}
+
+void DelayLineBase::SetDelay(s32 new_delay) {
+    if (max_delay < new_delay) {
+        return;
+    }
+    delay = new_delay;
+    input = (buffer + ((output - buffer) + new_delay) % (max_delay + 1));
+}
+
+s32 DelayLineBase::GetDelay() const {
+    return delay;
+}
+
+s32 DelayLineBase::GetMaxDelay() const {
+    return max_delay;
+}
+
+f32 DelayLineBase::TapOut(s32 last_sample) {
+    const float* ptr = input - (last_sample + 1);
+    if (ptr < buffer) {
+        ptr += (max_delay + 1);
+    }
+
+    return *ptr;
+}
+
+f32 DelayLineBase::Tick(f32 sample) {
+    *(input++) = sample;
+    const auto out_sample = *(output++);
+
+    if (buffer_end < input) {
+        input = buffer;
+    }
+
+    if (buffer_end < output) {
+        output = buffer;
+    }
+
+    return out_sample;
+}
+
+float* DelayLineBase::GetInput() {
+    return input;
+}
+
+const float* DelayLineBase::GetInput() const {
+    return input;
+}
+
+f32 DelayLineBase::GetOutputSample() const {
+    return *output;
+}
+
+void DelayLineBase::Clear() {
+    std::memset(buffer, 0, sizeof(float) * max_delay);
+}
+
+void DelayLineBase::Reset() {
+    buffer = nullptr;
+    buffer_end = nullptr;
+    max_delay = 0;
+    input = nullptr;
+    output = nullptr;
+    delay = 0;
+}
+
+DelayLineAllPass::DelayLineAllPass() = default;
+DelayLineAllPass::~DelayLineAllPass() = default;
+
+void DelayLineAllPass::Initialize(u32 delay_, float coeffcient_, f32* src_buffer) {
+    DelayLineBase::Initialize(delay_, src_buffer);
+    SetCoefficient(coeffcient_);
+}
+
+void DelayLineAllPass::SetCoefficient(float coeffcient_) {
+    coefficient = coeffcient_;
+}
+
+f32 DelayLineAllPass::Tick(f32 sample) {
+    const auto temp = sample - coefficient * *output;
+    return coefficient * temp + DelayLineBase::Tick(temp);
+}
+
+void DelayLineAllPass::Reset() {
+    coefficient = 0.0f;
+    DelayLineBase::Reset();
+}
+
+} // namespace AudioCore
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "common/common_types.h"
+
+namespace AudioCore {
+
+class DelayLineBase {
+public:
+    DelayLineBase();
+    ~DelayLineBase();
+
+    void Initialize(s32 max_delay_, float* src_buffer);
+    void SetDelay(s32 new_delay);
+    s32 GetDelay() const;
+    s32 GetMaxDelay() const;
+    f32 TapOut(s32 last_sample);
+    f32 Tick(f32 sample);
+    float* GetInput();
+    const float* GetInput() const;
+    f32 GetOutputSample() const;
+    void Clear();
+    void Reset();
+
+protected:
+    float* buffer{nullptr};
+    float* buffer_end{nullptr};
+    s32 max_delay{};
+    float* input{nullptr};
+    float* output{nullptr};
+    s32 delay{};
+};
+
+class DelayLineAllPass final : public DelayLineBase {
+public:
+    DelayLineAllPass();
+    ~DelayLineAllPass();
+
+    void Initialize(u32 delay, float coeffcient_, f32* src_buffer);
+    void SetCoefficient(float coeffcient_);
+    f32 Tick(f32 sample);
+    void Reset();
+
+private:
+    float coefficient{};
+};
+} // namespace AudioCore
@@ -90,6 +90,14 @@ s32 EffectBase::GetProcessingOrder() const {
    return processing_order;
 }

+std::vector<u8>& EffectBase::GetWorkBuffer() {
+    return work_buffer;
+}
+
+const std::vector<u8>& EffectBase::GetWorkBuffer() const {
+    return work_buffer;
+}
+
 EffectI3dl2Reverb::EffectI3dl2Reverb() : EffectGeneric(EffectType::I3dl2Reverb) {}
 EffectI3dl2Reverb::~EffectI3dl2Reverb() = default;

@@ -117,6 +125,12 @@ void EffectI3dl2Reverb::Update(EffectInfo::InParams& in_params) {
        usage = UsageState::Initialized;
        params.status = ParameterStatus::Initialized;
        skipped = in_params.buffer_address == 0 || in_params.buffer_size == 0;
+        if (!skipped) {
+            auto& cur_work_buffer = GetWorkBuffer();
+            // Has two buffers internally
+            cur_work_buffer.resize(in_params.buffer_size * 2);
+            std::fill(cur_work_buffer.begin(), cur_work_buffer.end(), 0);
+        }
    }
 }

@@ -129,6 +143,14 @@ void EffectI3dl2Reverb::UpdateForCommandGeneration() {
    GetParams().status = ParameterStatus::Updated;
 }

+I3dl2ReverbState& EffectI3dl2Reverb::GetState() {
+    return state;
+}
+
+const I3dl2ReverbState& EffectI3dl2Reverb::GetState() const {
+    return state;
+}
+
 EffectBiquadFilter::EffectBiquadFilter() : EffectGeneric(EffectType::BiquadFilter) {}
 EffectBiquadFilter::~EffectBiquadFilter() = default;

@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 #include "audio_core/common.h"
+#include "audio_core/delay_line.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -194,6 +195,8 @@ public:
    [[nodiscard]] bool IsEnabled() const;
    [[nodiscard]] s32 GetMixID() const;
    [[nodiscard]] s32 GetProcessingOrder() const;
+    [[nodiscard]] std::vector<u8>& GetWorkBuffer();
+    [[nodiscard]] const std::vector<u8>& GetWorkBuffer() const;

 protected:
    UsageState usage{UsageState::Invalid};
@@ -201,6 +204,7 @@ protected:
    s32 mix_id{};
    s32 processing_order{};
    bool enabled = false;
+    std::vector<u8> work_buffer{};
 };

 template <typename T>
@@ -212,7 +216,7 @@ public:
        return internal_params;
    }

-    const I3dl2ReverbParams& GetParams() const {
+    const T& GetParams() const {
        return internal_params;
    }

@@ -229,6 +233,27 @@ public:
    void UpdateForCommandGeneration() override;
 };

+struct I3dl2ReverbState {
+    f32 lowpass_0{};
+    f32 lowpass_1{};
+    f32 lowpass_2{};
+
+    DelayLineBase early_delay_line{};
+    std::array<u32, AudioCommon::I3DL2REVERB_TAPS> early_tap_steps{};
+    f32 early_gain{};
+    f32 late_gain{};
+
+    u32 early_to_late_taps{};
+    std::array<DelayLineBase, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> fdn_delay_line{};
+    std::array<DelayLineAllPass, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> decay_delay_line0{};
+    std::array<DelayLineAllPass, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> decay_delay_line1{};
+    f32 last_reverb_echo{};
+    DelayLineBase center_delay_line{};
+    std::array<std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT>, 3> lpf_coefficients{};
+    std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> shelf_filter{};
+    f32 dry_gain{};
+};
+
 class EffectI3dl2Reverb : public EffectGeneric<I3dl2ReverbParams> {
 public:
    explicit EffectI3dl2Reverb();
@@ -237,8 +262,12 @@ public:
    void Update(EffectInfo::InParams& in_params) override;
    void UpdateForCommandGeneration() override;

+    I3dl2ReverbState& GetState();
+    const I3dl2ReverbState& GetState() const;
+
 private:
    bool skipped = false;
+    I3dl2ReverbState state{};
 };

 class EffectBiquadFilter : public EffectGeneric<BiquadFilterParams> {
@@ -111,7 +111,14 @@ void Stream::PlayNextBuffer(std::chrono::nanoseconds ns_late) {

    sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());

-    core_timing.ScheduleEvent(GetBufferReleaseNS(*active_buffer) - ns_late, release_event, {});
+    const auto buffer_release_ns = GetBufferReleaseNS(*active_buffer);
+
+    // If ns_late is higher than the update rate ignore the delay
+    if (ns_late > buffer_release_ns) {
+        ns_late = {};
+    }
+
+    core_timing.ScheduleEvent(buffer_release_ns - ns_late, release_event, {});
 }

 void Stream::ReleaseActiveBuffer(std::chrono::nanoseconds ns_late) {
@@ -206,6 +206,8 @@ if (MSVC)
 else()
  target_compile_options(common PRIVATE
    -Werror
+
+    $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
  )
 endif()

@@ -19,15 +19,14 @@ namespace Common {
 /// SPSC ring buffer
 /// @tparam T            Element type
 /// @tparam capacity     Number of slots in ring buffer
-/// @tparam granularity  Slot size in terms of number of elements
-template <typename T, std::size_t capacity, std::size_t granularity = 1>
+template <typename T, std::size_t capacity>
 class RingBuffer {
-    /// A "slot" is made of `granularity` elements of `T`.
-    static constexpr std::size_t slot_size = granularity * sizeof(T);
+    /// A "slot" is made of a single `T`.
+    static constexpr std::size_t slot_size = sizeof(T);
    // T must be safely memcpy-able and have a trivial default constructor.
    static_assert(std::is_trivial_v<T>);
    // Ensure capacity is sensible.
-    static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2 / granularity);
+    static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2);
    static_assert((capacity & (capacity - 1)) == 0, "capacity must be a power of two");
    // Ensure lock-free.
    static_assert(std::atomic_size_t::is_always_lock_free);
@@ -47,7 +46,7 @@ public:
        const std::size_t second_copy = push_count - first_copy;

        const char* in = static_cast<const char*>(new_slots);
-        std::memcpy(m_data.data() + pos * granularity, in, first_copy * slot_size);
+        std::memcpy(m_data.data() + pos, in, first_copy * slot_size);
        in += first_copy * slot_size;
        std::memcpy(m_data.data(), in, second_copy * slot_size);

@@ -74,7 +73,7 @@ public:
        const std::size_t second_copy = pop_count - first_copy;

        char* out = static_cast<char*>(output);
-        std::memcpy(out, m_data.data() + pos * granularity, first_copy * slot_size);
+        std::memcpy(out, m_data.data() + pos, first_copy * slot_size);
        out += first_copy * slot_size;
        std::memcpy(out, m_data.data(), second_copy * slot_size);

@@ -84,9 +83,9 @@ public:
    }

    std::vector<T> Pop(std::size_t max_slots = ~std::size_t(0)) {
-        std::vector<T> out(std::min(max_slots, capacity) * granularity);
-        const std::size_t count = Pop(out.data(), out.size() / granularity);
-        out.resize(count * granularity);
+        std::vector<T> out(std::min(max_slots, capacity));
+        const std::size_t count = Pop(out.data(), out.size());
+        out.resize(count);
        return out;
    }

@@ -113,7 +112,7 @@ private:
    alignas(128) std::atomic_size_t m_write_index{0};
 #endif

-    std::array<T, granularity * capacity> m_data;
+    std::array<T, capacity> m_data;
 };

 } // namespace Common
@@ -49,3 +49,9 @@ ScopeExitHelper<Func> ScopeExit(Func&& func) {
 * \endcode
 */
 #define SCOPE_EXIT(body) auto CONCAT2(scope_exit_helper_, __LINE__) = detail::ScopeExit([&]() body)
+
+/**
+ * This macro is similar to SCOPE_EXIT, except the object is caller managed. This is intended to be
+ * used when the caller might want to cancel the ScopeExit.
+ */
+#define SCOPE_GUARD(body) detail::ScopeExit([&]() body)
@@ -141,27 +141,13 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 }

 std::string UTF16ToUTF8(const std::u16string& input) {
-#ifdef _MSC_VER
-    // Workaround for missing char16_t/char32_t instantiations in MSVC2017
-    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
-    std::basic_string<__int16> tmp_buffer(input.cbegin(), input.cend());
-    return convert.to_bytes(tmp_buffer);
-#else
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
    return convert.to_bytes(input);
-#endif
 }

 std::u16string UTF8ToUTF16(const std::string& input) {
-#ifdef _MSC_VER
-    // Workaround for missing char16_t/char32_t instantiations in MSVC2017
-    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
-    auto tmp_buffer = convert.from_bytes(input);
-    return std::u16string(tmp_buffer.cbegin(), tmp_buffer.cend());
-#else
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
    return convert.from_bytes(input);
-#endif
 }

 #ifdef _WIN32
@@ -148,7 +148,7 @@ add_library(core STATIC
    hle/kernel/client_session.h
    hle/kernel/code_set.cpp
    hle/kernel/code_set.h
-    hle/kernel/errors.h
+    hle/kernel/svc_results.h
    hle/kernel/global_scheduler_context.cpp
    hle/kernel/global_scheduler_context.h
    hle/kernel/handle_table.cpp
@@ -160,19 +160,29 @@ add_library(core STATIC
    hle/kernel/k_affinity_mask.h
    hle/kernel/k_condition_variable.cpp
    hle/kernel/k_condition_variable.h
+    hle/kernel/k_event.cpp
+    hle/kernel/k_event.h
+    hle/kernel/k_light_condition_variable.h
    hle/kernel/k_light_lock.cpp
    hle/kernel/k_light_lock.h
    hle/kernel/k_priority_queue.h
+    hle/kernel/k_readable_event.cpp
+    hle/kernel/k_readable_event.h
+    hle/kernel/k_resource_limit.cpp
+    hle/kernel/k_resource_limit.h
    hle/kernel/k_scheduler.cpp
    hle/kernel/k_scheduler.h
    hle/kernel/k_scheduler_lock.h
    hle/kernel/k_scoped_lock.h
+    hle/kernel/k_scoped_resource_reservation.h
    hle/kernel/k_scoped_scheduler_lock_and_sleep.h
    hle/kernel/k_synchronization_object.cpp
    hle/kernel/k_synchronization_object.h
    hle/kernel/k_thread.cpp
    hle/kernel/k_thread.h
    hle/kernel/k_thread_queue.h
+    hle/kernel/k_writable_event.cpp
+    hle/kernel/k_writable_event.h
    hle/kernel/kernel.cpp
    hle/kernel/kernel.h
    hle/kernel/memory/address_space_info.cpp
@@ -201,10 +211,6 @@ add_library(core STATIC
    hle/kernel/process.h
    hle/kernel/process_capability.cpp
    hle/kernel/process_capability.h
-    hle/kernel/readable_event.cpp
-    hle/kernel/readable_event.h
-    hle/kernel/resource_limit.cpp
-    hle/kernel/resource_limit.h
    hle/kernel/server_port.cpp
    hle/kernel/server_port.h
    hle/kernel/server_session.cpp
@@ -218,15 +224,12 @@ add_library(core STATIC
    hle/kernel/svc.cpp
    hle/kernel/svc.h
    hle/kernel/svc_common.h
-    hle/kernel/svc_results.h
    hle/kernel/svc_types.h
    hle/kernel/svc_wrap.h
    hle/kernel/time_manager.cpp
    hle/kernel/time_manager.h
    hle/kernel/transfer_memory.cpp
    hle/kernel/transfer_memory.h
-    hle/kernel/writable_event.cpp
-    hle/kernel/writable_event.h
    hle/lock.cpp
    hle/lock.h
    hle/result.h
@@ -263,6 +266,7 @@ add_library(core STATIC
    hle/service/am/applets/software_keyboard.h
    hle/service/am/applets/web_browser.cpp
    hle/service/am/applets/web_browser.h
+    hle/service/am/applets/web_types.h
    hle/service/am/idle.cpp
    hle/service/am/idle.h
    hle/service/am/omm.cpp
@@ -397,6 +401,7 @@ add_library(core STATIC
    hle/service/hid/controllers/xpad.h
    hle/service/lbl/lbl.cpp
    hle/service/lbl/lbl.h
+    hle/service/ldn/errors.h
    hle/service/ldn/ldn.cpp
    hle/service/ldn/ldn.h
    hle/service/ldr/ldr.cpp
@@ -650,6 +655,8 @@ else()
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>

+        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
+
        -Wno-sign-conversion
    )
 endif()
@@ -71,8 +71,9 @@ public:
    }

    void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
-        LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                     exception, pc, MemoryReadCode(pc));
+        LOG_CRITICAL(Core_ARM,
+                     "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X}, thumb = {})",
+                     exception, pc, MemoryReadCode(pc), parent.IsInThumbMode());
        UNIMPLEMENTED();
    }

@@ -50,6 +50,10 @@ public:
    u64 GetTPIDR_EL0() const override;
    void ChangeProcessorID(std::size_t new_core_id) override;

+    bool IsInThumbMode() const {
+        return (GetPSTATE() & 0x20) != 0;
+    }
+
    void SaveContext(ThreadContext32& ctx) override;
    void SaveContext(ThreadContext64& ctx) override {}
    void LoadContext(const ThreadContext32& ctx) override;
@@ -568,6 +568,11 @@ KeyManager::KeyManager() {
    // Initialize keys
    const std::string hactool_keys_dir = Common::FS::GetHactoolConfigurationPath();
    const std::string yuzu_keys_dir = Common::FS::GetUserPath(Common::FS::UserPath::KeysDir);
+
+    if (!Common::FS::Exists(yuzu_keys_dir)) {
+        Common::FS::CreateDir(yuzu_keys_dir);
+    }
+
    if (Settings::values.use_dev_keys) {
        dev_mode = true;
        AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "dev.keys", false);
@@ -21,6 +21,11 @@ enum class AnalogDirection : u8 {
    UP,
    DOWN,
 };
+struct AnalogProperties {
+    float deadzone;
+    float range;
+    float threshold;
+};

 /// An abstract class template for an input device (a button, an analog input, etc.).
 template <typename StatusType>
@@ -30,6 +35,12 @@ public:
    virtual StatusType GetStatus() const {
        return {};
    }
+    virtual StatusType GetRawStatus() const {
+        return GetStatus();
+    }
+    virtual AnalogProperties GetAnalogProperties() const {
+        return {};
+    }
    virtual bool GetAnalogDirectionStatus([[maybe_unused]] AnalogDirection direction) const {
        return {};
    }
@@ -4,11 +4,11 @@

 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/server_port.h"
 #include "core/hle/kernel/session.h"
+#include "core/hle/kernel/svc_results.h"

 namespace Kernel {

@@ -21,7 +21,7 @@ std::shared_ptr<ServerPort> ClientPort::GetServerPort() const {

 ResultVal<std::shared_ptr<ClientSession>> ClientPort::Connect() {
    if (active_sessions >= max_sessions) {
-        return ERR_MAX_CONNECTIONS_REACHED;
+        return ResultMaxConnectionsReached;
    }
    active_sessions++;

@@ -3,11 +3,11 @@
 // Refer to the license.txt file included.

 #include "core/hle/kernel/client_session.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/session.h"
+#include "core/hle/kernel/svc_results.h"
 #include "core/hle/result.h"

 namespace Kernel {
@@ -43,7 +43,7 @@ ResultCode ClientSession::SendSyncRequest(std::shared_ptr<KThread> thread,
                                          Core::Timing::CoreTiming& core_timing) {
    // Keep ServerSession alive until we're done working with it.
    if (!parent->Server()) {
-        return ERR_SESSION_CLOSED_BY_REMOTE;
+        return ResultSessionClosedByRemote;
    }

    // Signal the server session that new data is available
@@ -1,43 +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/result.h"
-
-namespace Kernel {
-
-// Confirmed Switch kernel error codes
-
-constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED{ErrorModule::Kernel, 7};
-constexpr ResultCode ERR_INVALID_CAPABILITY_DESCRIPTOR{ErrorModule::Kernel, 14};
-constexpr ResultCode ERR_THREAD_TERMINATING{ErrorModule::Kernel, 59};
-constexpr ResultCode ERR_TERMINATION_REQUESTED{ErrorModule::Kernel, 59};
-constexpr ResultCode ERR_INVALID_SIZE{ErrorModule::Kernel, 101};
-constexpr ResultCode ERR_INVALID_ADDRESS{ErrorModule::Kernel, 102};
-constexpr ResultCode ERR_OUT_OF_RESOURCES{ErrorModule::Kernel, 103};
-constexpr ResultCode ERR_OUT_OF_MEMORY{ErrorModule::Kernel, 104};
-constexpr ResultCode ERR_HANDLE_TABLE_FULL{ErrorModule::Kernel, 105};
-constexpr ResultCode ERR_INVALID_ADDRESS_STATE{ErrorModule::Kernel, 106};
-constexpr ResultCode ERR_INVALID_CURRENT_MEMORY{ErrorModule::Kernel, 106};
-constexpr ResultCode ERR_INVALID_MEMORY_PERMISSIONS{ErrorModule::Kernel, 108};
-constexpr ResultCode ERR_INVALID_MEMORY_RANGE{ErrorModule::Kernel, 110};
-constexpr ResultCode ERR_INVALID_PROCESSOR_ID{ErrorModule::Kernel, 113};
-constexpr ResultCode ERR_INVALID_THREAD_PRIORITY{ErrorModule::Kernel, 112};
-constexpr ResultCode ERR_INVALID_HANDLE{ErrorModule::Kernel, 114};
-constexpr ResultCode ERR_INVALID_POINTER{ErrorModule::Kernel, 115};
-constexpr ResultCode ERR_INVALID_COMBINATION{ErrorModule::Kernel, 116};
-constexpr ResultCode RESULT_TIMEOUT{ErrorModule::Kernel, 117};
-constexpr ResultCode ERR_SYNCHRONIZATION_CANCELED{ErrorModule::Kernel, 118};
-constexpr ResultCode ERR_CANCELLED{ErrorModule::Kernel, 118};
-constexpr ResultCode ERR_OUT_OF_RANGE{ErrorModule::Kernel, 119};
-constexpr ResultCode ERR_INVALID_ENUM_VALUE{ErrorModule::Kernel, 120};
-constexpr ResultCode ERR_NOT_FOUND{ErrorModule::Kernel, 121};
-constexpr ResultCode ERR_BUSY{ErrorModule::Kernel, 122};
-constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE{ErrorModule::Kernel, 123};
-constexpr ResultCode ERR_INVALID_STATE{ErrorModule::Kernel, 125};
-constexpr ResultCode ERR_RESERVED_VALUE{ErrorModule::Kernel, 126};
-constexpr ResultCode ERR_RESOURCE_LIMIT_EXCEEDED{ErrorModule::Kernel, 132};
-
-} // namespace Kernel
@@ -6,12 +6,12 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/kernel/svc_results.h"

 namespace Kernel {
 namespace {
@@ -33,7 +33,7 @@ HandleTable::~HandleTable() = default;
 ResultCode HandleTable::SetSize(s32 handle_table_size) {
    if (static_cast<u32>(handle_table_size) > MAX_COUNT) {
        LOG_ERROR(Kernel, "Handle table size {} is greater than {}", handle_table_size, MAX_COUNT);
-        return ERR_OUT_OF_MEMORY;
+        return ResultOutOfMemory;
    }

    // Values less than or equal to zero indicate to use the maximum allowable
@@ -53,7 +53,7 @@ ResultVal<Handle> HandleTable::Create(std::shared_ptr<Object> obj) {
    const u16 slot = next_free_slot;
    if (slot >= table_size) {
        LOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use.");
-        return ERR_HANDLE_TABLE_FULL;
+        return ResultHandleTableFull;
    }
    next_free_slot = generations[slot];

@@ -76,7 +76,7 @@ ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
    std::shared_ptr<Object> object = GetGeneric(handle);
    if (object == nullptr) {
        LOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle);
-        return ERR_INVALID_HANDLE;
+        return ResultInvalidHandle;
    }
    return Create(std::move(object));
 }
@@ -84,7 +84,7 @@ ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
 ResultCode HandleTable::Close(Handle handle) {
    if (!IsValid(handle)) {
        LOG_ERROR(Kernel, "Handle is not valid! handle={:08X}", handle);
-        return ERR_INVALID_HANDLE;
+        return ResultInvalidHandle;
    }

    const u16 slot = GetSlot(handle);
@@ -14,19 +14,19 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
 #include "core/hle/kernel/k_thread.h"
+#include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/server_session.h"
+#include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/time_manager.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/memory.h"

 namespace Kernel {
@@ -41,8 +41,8 @@ class KernelCore;
 class Process;
 class ServerSession;
 class KThread;
-class ReadableEvent;
-class WritableEvent;
+class KReadableEvent;
+class KWritableEvent;

 enum class ThreadWakeupReason;

@@ -118,9 +118,13 @@ ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32

        // Check the userspace value.
        s32 user_value{};
-        R_UNLESS(UpdateIfEqual(system, std::addressof(user_value), addr, value, value + 1),
-                 Svc::ResultInvalidCurrentMemory);
-        R_UNLESS(user_value == value, Svc::ResultInvalidState);
+        if (!UpdateIfEqual(system, &user_value, addr, value, value + 1)) {
+            LOG_ERROR(Kernel, "Invalid current memory!");
+            return ResultInvalidCurrentMemory;
+        }
+        if (user_value != value) {
+            return ResultInvalidState;
+        }

        auto it = thread_tree.nfind_light({addr, -1});
        while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
@@ -143,61 +147,34 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
    // Perform signaling.
    s32 num_waiters{};
    {
-        KScopedSchedulerLock sl(kernel);
+        [[maybe_unused]] const KScopedSchedulerLock sl(kernel);

        auto it = thread_tree.nfind_light({addr, -1});
        // Determine the updated value.
        s32 new_value{};
-        if (/*GetTargetFirmware() >= TargetFirmware_7_0_0*/ true) {
-            if (count <= 0) {
-                if ((it != thread_tree.end()) && (it->GetAddressArbiterKey() == addr)) {
-                    new_value = value - 2;
-                } else {
-                    new_value = value + 1;
-                }
+        if (count <= 0) {
+            if (it != thread_tree.end() && it->GetAddressArbiterKey() == addr) {
+                new_value = value - 2;
            } else {
-                if ((it != thread_tree.end()) && (it->GetAddressArbiterKey() == addr)) {
-                    auto tmp_it = it;
-                    s32 tmp_num_waiters{};
-                    while ((++tmp_it != thread_tree.end()) &&
-                           (tmp_it->GetAddressArbiterKey() == addr)) {
-                        if ((tmp_num_waiters++) >= count) {
-                            break;
-                        }
-                    }
-
-                    if (tmp_num_waiters < count) {
-                        new_value = value - 1;
-                    } else {
-                        new_value = value;
-                    }
-                } else {
-                    new_value = value + 1;
-                }
+                new_value = value + 1;
            }
        } else {
-            if (count <= 0) {
-                if ((it != thread_tree.end()) && (it->GetAddressArbiterKey() == addr)) {
-                    new_value = value - 1;
-                } else {
-                    new_value = value + 1;
-                }
-            } else {
+            if (it != thread_tree.end() && it->GetAddressArbiterKey() == addr) {
                auto tmp_it = it;
                s32 tmp_num_waiters{};
-                while ((tmp_it != thread_tree.end()) && (tmp_it->GetAddressArbiterKey() == addr) &&
-                       (tmp_num_waiters < count + 1)) {
-                    ++tmp_num_waiters;
-                    ++tmp_it;
+                while (++tmp_it != thread_tree.end() && tmp_it->GetAddressArbiterKey() == addr) {
+                    if (tmp_num_waiters++ >= count) {
+                        break;
+                    }
                }

-                if (tmp_num_waiters == 0) {
-                    new_value = value + 1;
-                } else if (tmp_num_waiters <= count) {
+                if (tmp_num_waiters < count) {
                    new_value = value - 1;
                } else {
                    new_value = value;
                }
+            } else {
+                new_value = value + 1;
            }
        }

@@ -205,13 +182,18 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
        s32 user_value{};
        bool succeeded{};
        if (value != new_value) {
-            succeeded = UpdateIfEqual(system, std::addressof(user_value), addr, value, new_value);
+            succeeded = UpdateIfEqual(system, &user_value, addr, value, new_value);
        } else {
-            succeeded = ReadFromUser(system, std::addressof(user_value), addr);
+            succeeded = ReadFromUser(system, &user_value, addr);
        }

-        R_UNLESS(succeeded, Svc::ResultInvalidCurrentMemory);
-        R_UNLESS(user_value == value, Svc::ResultInvalidState);
+        if (!succeeded) {
+            LOG_ERROR(Kernel, "Invalid current memory!");
+            return ResultInvalidCurrentMemory;
+        }
+        if (user_value != value) {
+            return ResultInvalidState;
+        }

        while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
               (it->GetAddressArbiterKey() == addr)) {
@@ -239,40 +221,40 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement
        // Check that the thread isn't terminating.
        if (cur_thread->IsTerminationRequested()) {
            slp.CancelSleep();
-            return Svc::ResultTerminationRequested;
+            return ResultTerminationRequested;
        }

        // Set the synced object.
-        cur_thread->SetSyncedObject(nullptr, Svc::ResultTimedOut);
+        cur_thread->SetSyncedObject(nullptr, ResultTimedOut);

        // Read the value from userspace.
        s32 user_value{};
        bool succeeded{};
        if (decrement) {
-            succeeded = DecrementIfLessThan(system, std::addressof(user_value), addr, value);
+            succeeded = DecrementIfLessThan(system, &user_value, addr, value);
        } else {
-            succeeded = ReadFromUser(system, std::addressof(user_value), addr);
+            succeeded = ReadFromUser(system, &user_value, addr);
        }

        if (!succeeded) {
            slp.CancelSleep();
-            return Svc::ResultInvalidCurrentMemory;
+            return ResultInvalidCurrentMemory;
        }

        // Check that the value is less than the specified one.
        if (user_value >= value) {
            slp.CancelSleep();
-            return Svc::ResultInvalidState;
+            return ResultInvalidState;
        }

        // Check that the timeout is non-zero.
        if (timeout == 0) {
            slp.CancelSleep();
-            return Svc::ResultTimedOut;
+            return ResultTimedOut;
        }

        // Set the arbiter.
-        cur_thread->SetAddressArbiter(std::addressof(thread_tree), addr);
+        cur_thread->SetAddressArbiter(&thread_tree, addr);
        thread_tree.insert(*cur_thread);
        cur_thread->SetState(ThreadState::Waiting);
        cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Arbitration);
@@ -293,7 +275,7 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement

    // Get the result.
    KSynchronizationObject* dummy{};
-    return cur_thread->GetWaitResult(std::addressof(dummy));
+    return cur_thread->GetWaitResult(&dummy);
 }

 ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
@@ -306,33 +288,33 @@ ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
        // Check that the thread isn't terminating.
        if (cur_thread->IsTerminationRequested()) {
            slp.CancelSleep();
-            return Svc::ResultTerminationRequested;
+            return ResultTerminationRequested;
        }

        // Set the synced object.
-        cur_thread->SetSyncedObject(nullptr, Svc::ResultTimedOut);
+        cur_thread->SetSyncedObject(nullptr, ResultTimedOut);

        // Read the value from userspace.
        s32 user_value{};
-        if (!ReadFromUser(system, std::addressof(user_value), addr)) {
+        if (!ReadFromUser(system, &user_value, addr)) {
            slp.CancelSleep();
-            return Svc::ResultInvalidCurrentMemory;
+            return ResultInvalidCurrentMemory;
        }

        // Check that the value is equal.
        if (value != user_value) {
            slp.CancelSleep();
-            return Svc::ResultInvalidState;
+            return ResultInvalidState;
        }

        // Check that the timeout is non-zero.
        if (timeout == 0) {
            slp.CancelSleep();
-            return Svc::ResultTimedOut;
+            return ResultTimedOut;
        }

        // Set the arbiter.
-        cur_thread->SetAddressArbiter(std::addressof(thread_tree), addr);
+        cur_thread->SetAddressArbiter(&thread_tree, addr);
        thread_tree.insert(*cur_thread);
        cur_thread->SetState(ThreadState::Waiting);
        cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Arbitration);
@@ -353,7 +335,7 @@ ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {

    // Get the result.
    KSynchronizationObject* dummy{};
-    return cur_thread->GetWaitResult(std::addressof(dummy));
+    return cur_thread->GetWaitResult(&dummy);
 }

 } // namespace Kernel
@@ -27,7 +27,7 @@ public:
    }

    [[nodiscard]] constexpr bool GetAffinity(s32 core) const {
-        return this->mask & GetCoreBit(core);
+        return (this->mask & GetCoreBit(core)) != 0;
    }

    constexpr void SetAffinity(s32 core, bool set) {
@@ -92,10 +92,10 @@ ResultCode KConditionVariable::SignalToAddress(VAddr addr) {
        // Write the value to userspace.
        if (!WriteToUser(system, addr, std::addressof(next_value))) {
            if (next_owner_thread) {
-                next_owner_thread->SetSyncedObject(nullptr, Svc::ResultInvalidCurrentMemory);
+                next_owner_thread->SetSyncedObject(nullptr, ResultInvalidCurrentMemory);
            }

-            return Svc::ResultInvalidCurrentMemory;
+            return ResultInvalidCurrentMemory;
        }
    }

@@ -114,20 +114,20 @@ ResultCode KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 val
            cur_thread->SetSyncedObject(nullptr, RESULT_SUCCESS);

            // Check if the thread should terminate.
-            R_UNLESS(!cur_thread->IsTerminationRequested(), Svc::ResultTerminationRequested);
+            R_UNLESS(!cur_thread->IsTerminationRequested(), ResultTerminationRequested);

            {
                // Read the tag from userspace.
                u32 test_tag{};
                R_UNLESS(ReadFromUser(system, std::addressof(test_tag), addr),
-                         Svc::ResultInvalidCurrentMemory);
+                         ResultInvalidCurrentMemory);

                // If the tag isn't the handle (with wait mask), we're done.
                R_UNLESS(test_tag == (handle | Svc::HandleWaitMask), RESULT_SUCCESS);

                // Get the lock owner thread.
                owner_thread = kernel.CurrentProcess()->GetHandleTable().Get<KThread>(handle);
-                R_UNLESS(owner_thread, Svc::ResultInvalidHandle);
+                R_UNLESS(owner_thread, ResultInvalidHandle);

                // Update the lock.
                cur_thread->SetAddressKey(addr, value);
@@ -191,13 +191,13 @@ KThread* KConditionVariable::SignalImpl(KThread* thread) {
                thread_to_close = owner_thread.get();
            } else {
                // The lock was tagged with a thread that doesn't exist.
-                thread->SetSyncedObject(nullptr, Svc::ResultInvalidState);
+                thread->SetSyncedObject(nullptr, ResultInvalidState);
                thread->Wakeup();
            }
        }
    } else {
        // If the address wasn't accessible, note so.
-        thread->SetSyncedObject(nullptr, Svc::ResultInvalidCurrentMemory);
+        thread->SetSyncedObject(nullptr, ResultInvalidCurrentMemory);
        thread->Wakeup();
    }

@@ -263,12 +263,12 @@ ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout)
        KScopedSchedulerLockAndSleep slp{kernel, cur_thread, timeout};

        // Set the synced object.
-        cur_thread->SetSyncedObject(nullptr, Svc::ResultTimedOut);
+        cur_thread->SetSyncedObject(nullptr, ResultTimedOut);

        // Check that the thread isn't terminating.
        if (cur_thread->IsTerminationRequested()) {
            slp.CancelSleep();
-            return Svc::ResultTerminationRequested;
+            return ResultTerminationRequested;
        }

        // Update the value and process for the next owner.
@@ -302,7 +302,7 @@ ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout)
            // Write the value to userspace.
            if (!WriteToUser(system, addr, std::addressof(next_value))) {
                slp.CancelSleep();
-                return Svc::ResultInvalidCurrentMemory;
+                return ResultInvalidCurrentMemory;
            }
        }

@@ -0,0 +1,32 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/kernel/k_writable_event.h"
+
+namespace Kernel {
+
+KEvent::KEvent(KernelCore& kernel, std::string&& name) : Object{kernel, std::move(name)} {}
+
+KEvent::~KEvent() = default;
+
+std::shared_ptr<KEvent> KEvent::Create(KernelCore& kernel, std::string&& name) {
+    return std::make_shared<KEvent>(kernel, std::move(name));
+}
+
+void KEvent::Initialize() {
+    // Create our sub events.
+    readable_event = std::make_shared<KReadableEvent>(kernel, GetName() + ":Readable");
+    writable_event = std::make_shared<KWritableEvent>(kernel, GetName() + ":Writable");
+
+    // Initialize our sub sessions.
+    readable_event->Initialize(this);
+    writable_event->Initialize(this);
+
+    // Mark initialized.
+    initialized = true;
+}
+
+} // namespace Kernel
@@ -0,0 +1,57 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/kernel/object.h"
+
+namespace Kernel {
+
+class KernelCore;
+class KReadableEvent;
+class KWritableEvent;
+
+class KEvent final : public Object {
+public:
+    explicit KEvent(KernelCore& kernel, std::string&& name);
+    ~KEvent() override;
+
+    static std::shared_ptr<KEvent> Create(KernelCore& kernel, std::string&& name);
+
+    void Initialize();
+
+    void Finalize() override {}
+
+    std::string GetTypeName() const override {
+        return "KEvent";
+    }
+
+    static constexpr HandleType HANDLE_TYPE = HandleType::Event;
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
+
+    std::shared_ptr<KReadableEvent>& GetReadableEvent() {
+        return readable_event;
+    }
+
+    std::shared_ptr<KWritableEvent>& GetWritableEvent() {
+        return writable_event;
+    }
+
+    const std::shared_ptr<KReadableEvent>& GetReadableEvent() const {
+        return readable_event;
+    }
+
+    const std::shared_ptr<KWritableEvent>& GetWritableEvent() const {
+        return writable_event;
+    }
+
+private:
+    std::shared_ptr<KReadableEvent> readable_event;
+    std::shared_ptr<KWritableEvent> writable_event;
+    bool initialized{};
+};
+
+} // namespace Kernel
@@ -0,0 +1,57 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
+#include "core/hle/kernel/k_thread_queue.h"
+#include "core/hle/kernel/time_manager.h"
+
+namespace Kernel {
+class KernelCore;
+
+class KLightConditionVariable {
+public:
+    explicit KLightConditionVariable(KernelCore& kernel) : thread_queue(kernel), kernel(kernel) {}
+
+    void Wait(KLightLock* lock, s64 timeout = -1) {
+        WaitImpl(lock, timeout);
+        lock->Lock();
+    }
+
+    void Broadcast() {
+        KScopedSchedulerLock lk{kernel};
+        while (thread_queue.WakeupFrontThread() != nullptr) {
+            // We want to signal all threads, and so should continue waking up until there's nothing
+            // to wake.
+        }
+    }
+
+private:
+    void WaitImpl(KLightLock* lock, s64 timeout) {
+        KThread* owner = GetCurrentThreadPointer(kernel);
+
+        // Sleep the thread.
+        {
+            KScopedSchedulerLockAndSleep lk(kernel, owner, timeout);
+            lock->Unlock();
+
+            if (!thread_queue.SleepThread(owner)) {
+                lk.CancelSleep();
+                return;
+            }
+        }
+
+        // Cancel the task that the sleep setup.
+        kernel.TimeManager().UnscheduleTimeEvent(owner);
+    }
+    KThreadQueue thread_queue;
+    KernelCore& kernel;
+};
+} // namespace Kernel
@@ -24,11 +24,11 @@ template <typename T>
 concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T & t) {
    { t.GetAffinityMask() }
    ->Common::ConvertibleTo<u64>;
-    {t.SetAffinityMask(std::declval<u64>())};
+    {t.SetAffinityMask(0)};

-    { t.GetAffinity(std::declval<int32_t>()) }
+    { t.GetAffinity(0) }
    ->std::same_as<bool>;
-    {t.SetAffinity(std::declval<int32_t>(), std::declval<bool>())};
+    {t.SetAffinity(0, false)};
    {t.SetAll()};
 };

@@ -42,11 +42,11 @@ concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T & t) {
    ->std::same_as<T*>;
    { (typename T::QueueEntry()).GetPrev() }
    ->std::same_as<T*>;
-    { t.GetPriorityQueueEntry(std::declval<s32>()) }
+    { t.GetPriorityQueueEntry(0) }
    ->std::same_as<typename T::QueueEntry&>;

    {t.GetAffinityMask()};
-    { typename std::remove_cvref<decltype(t.GetAffinityMask())>::type() }
+    { std::remove_cvref_t<decltype(t.GetAffinityMask())>() }
    ->KPriorityQueueAffinityMask;

    { t.GetActiveCore() }
@@ -55,17 +55,17 @@ concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T & t) {
    ->Common::ConvertibleTo<s32>;
 };

-template <typename Member, size_t _NumCores, int LowestPriority, int HighestPriority>
+template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>
 requires KPriorityQueueMember<Member> class KPriorityQueue {
 public:
-    using AffinityMaskType = typename std::remove_cv_t<
-        typename std::remove_reference<decltype(std::declval<Member>().GetAffinityMask())>::type>;
+    using AffinityMaskType = std::remove_cv_t<
+        std::remove_reference_t<decltype(std::declval<Member>().GetAffinityMask())>>;

    static_assert(LowestPriority >= 0);
    static_assert(HighestPriority >= 0);
    static_assert(LowestPriority >= HighestPriority);
    static constexpr size_t NumPriority = LowestPriority - HighestPriority + 1;
-    static constexpr size_t NumCores = _NumCores;
+    static constexpr size_t NumCores = NumCores_;

    static constexpr bool IsValidCore(s32 core) {
        return 0 <= core && core < static_cast<s32>(NumCores);
@@ -0,0 +1,56 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include "common/assert.h"
+#include "common/common_funcs.h"
+#include "common/logging/log.h"
+#include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_thread.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel {
+
+KReadableEvent::KReadableEvent(KernelCore& kernel, std::string&& name)
+    : KSynchronizationObject{kernel, std::move(name)} {}
+KReadableEvent::~KReadableEvent() = default;
+
+bool KReadableEvent::IsSignaled() const {
+    ASSERT(kernel.GlobalSchedulerContext().IsLocked());
+
+    return is_signaled;
+}
+
+ResultCode KReadableEvent::Signal() {
+    KScopedSchedulerLock lk{kernel};
+
+    if (!is_signaled) {
+        is_signaled = true;
+        NotifyAvailable();
+    }
+
+    return RESULT_SUCCESS;
+}
+
+ResultCode KReadableEvent::Clear() {
+    Reset();
+
+    return RESULT_SUCCESS;
+}
+
+ResultCode KReadableEvent::Reset() {
+    KScopedSchedulerLock lk{kernel};
+
+    if (!is_signaled) {
+        return ResultInvalidState;
+    }
+
+    is_signaled = false;
+    return RESULT_SUCCESS;
+}
+
+} // namespace Kernel
@@ -0,0 +1,51 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/kernel/k_synchronization_object.h"
+#include "core/hle/kernel/object.h"
+#include "core/hle/result.h"
+
+namespace Kernel {
+
+class KernelCore;
+class KEvent;
+
+class KReadableEvent final : public KSynchronizationObject {
+public:
+    explicit KReadableEvent(KernelCore& kernel, std::string&& name);
+    ~KReadableEvent() override;
+
+    std::string GetTypeName() const override {
+        return "KReadableEvent";
+    }
+
+    static constexpr HandleType HANDLE_TYPE = HandleType::ReadableEvent;
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
+
+    KEvent* GetParent() const {
+        return parent;
+    }
+
+    void Initialize(KEvent* parent_) {
+        is_signaled = false;
+        parent = parent_;
+    }
+
+    bool IsSignaled() const override;
+    void Finalize() override {}
+
+    ResultCode Signal();
+    ResultCode Clear();
+    ResultCode Reset();
+
+private:
+    bool is_signaled{};
+    KEvent* parent{};
+};
+
+} // namespace Kernel
@@ -0,0 +1,152 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+
+#include "common/assert.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/core_timing_util.h"
+#include "core/hle/kernel/k_resource_limit.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel {
+constexpr s64 DefaultTimeout = 10000000000; // 10 seconds
+
+KResourceLimit::KResourceLimit(KernelCore& kernel, Core::System& system)
+    : Object{kernel}, lock{kernel}, cond_var{kernel}, kernel{kernel}, system(system) {}
+KResourceLimit::~KResourceLimit() = default;
+
+s64 KResourceLimit::GetLimitValue(LimitableResource which) const {
+    const auto index = static_cast<std::size_t>(which);
+    s64 value{};
+    {
+        KScopedLightLock lk{lock};
+        value = limit_values[index];
+        ASSERT(value >= 0);
+        ASSERT(current_values[index] <= limit_values[index]);
+        ASSERT(current_hints[index] <= current_values[index]);
+    }
+    return value;
+}
+
+s64 KResourceLimit::GetCurrentValue(LimitableResource which) const {
+    const auto index = static_cast<std::size_t>(which);
+    s64 value{};
+    {
+        KScopedLightLock lk{lock};
+        value = current_values[index];
+        ASSERT(value >= 0);
+        ASSERT(current_values[index] <= limit_values[index]);
+        ASSERT(current_hints[index] <= current_values[index]);
+    }
+    return value;
+}
+
+s64 KResourceLimit::GetPeakValue(LimitableResource which) const {
+    const auto index = static_cast<std::size_t>(which);
+    s64 value{};
+    {
+        KScopedLightLock lk{lock};
+        value = peak_values[index];
+        ASSERT(value >= 0);
+        ASSERT(current_values[index] <= limit_values[index]);
+        ASSERT(current_hints[index] <= current_values[index]);
+    }
+    return value;
+}
+
+s64 KResourceLimit::GetFreeValue(LimitableResource which) const {
+    const auto index = static_cast<std::size_t>(which);
+    s64 value{};
+    {
+        KScopedLightLock lk(lock);
+        ASSERT(current_values[index] >= 0);
+        ASSERT(current_values[index] <= limit_values[index]);
+        ASSERT(current_hints[index] <= current_values[index]);
+        value = limit_values[index] - current_values[index];
+    }
+
+    return value;
+}
+
+ResultCode KResourceLimit::SetLimitValue(LimitableResource which, s64 value) {
+    const auto index = static_cast<std::size_t>(which);
+    KScopedLightLock lk(lock);
+    R_UNLESS(current_values[index] <= value, ResultInvalidState);
+
+    limit_values[index] = value;
+
+    return RESULT_SUCCESS;
+}
+
+bool KResourceLimit::Reserve(LimitableResource which, s64 value) {
+    return Reserve(which, value, system.CoreTiming().GetGlobalTimeNs().count() + DefaultTimeout);
+}
+
+bool KResourceLimit::Reserve(LimitableResource which, s64 value, s64 timeout) {
+    ASSERT(value >= 0);
+    const auto index = static_cast<std::size_t>(which);
+    KScopedLightLock lk(lock);
+
+    ASSERT(current_hints[index] <= current_values[index]);
+    if (current_hints[index] >= limit_values[index]) {
+        return false;
+    }
+
+    // Loop until we reserve or run out of time.
+    while (true) {
+        ASSERT(current_values[index] <= limit_values[index]);
+        ASSERT(current_hints[index] <= current_values[index]);
+
+        // If we would overflow, don't allow to succeed.
+        if (current_values[index] + value <= current_values[index]) {
+            break;
+        }
+
+        if (current_values[index] + value <= limit_values[index]) {
+            current_values[index] += value;
+            current_hints[index] += value;
+            peak_values[index] = std::max(peak_values[index], current_values[index]);
+            return true;
+        }
+
+        if (current_hints[index] + value <= limit_values[index] &&
+            (timeout < 0 || system.CoreTiming().GetGlobalTimeNs().count() < timeout)) {
+            waiter_count++;
+            cond_var.Wait(&lock, timeout);
+            waiter_count--;
+        } else {
+            break;
+        }
+    }
+
+    return false;
+}
+
+void KResourceLimit::Release(LimitableResource which, s64 value) {
+    Release(which, value, value);
+}
+
+void KResourceLimit::Release(LimitableResource which, s64 value, s64 hint) {
+    ASSERT(value >= 0);
+    ASSERT(hint >= 0);
+
+    const auto index = static_cast<std::size_t>(which);
+    KScopedLightLock lk(lock);
+    ASSERT(current_values[index] <= limit_values[index]);
+    ASSERT(current_hints[index] <= current_values[index]);
+    ASSERT(value <= current_values[index]);
+    ASSERT(hint <= current_hints[index]);
+
+    current_values[index] -= value;
+    current_hints[index] -= hint;
+
+    if (waiter_count != 0) {
+        cond_var.Broadcast();
+    }
+}
+
+} // namespace Kernel
@@ -0,0 +1,81 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+
+#pragma once
+
+#include <array>
+#include "common/common_types.h"
+#include "core/hle/kernel/k_light_condition_variable.h"
+#include "core/hle/kernel/k_light_lock.h"
+#include "core/hle/kernel/object.h"
+
+union ResultCode;
+
+namespace Core {
+class System;
+}
+
+namespace Kernel {
+class KernelCore;
+enum class LimitableResource : u32 {
+    PhysicalMemory = 0,
+    Threads = 1,
+    Events = 2,
+    TransferMemory = 3,
+    Sessions = 4,
+
+    Count,
+};
+
+constexpr bool IsValidResourceType(LimitableResource type) {
+    return type < LimitableResource::Count;
+}
+
+class KResourceLimit final : public Object {
+public:
+    explicit KResourceLimit(KernelCore& kernel, Core::System& system);
+    ~KResourceLimit();
+
+    s64 GetLimitValue(LimitableResource which) const;
+    s64 GetCurrentValue(LimitableResource which) const;
+    s64 GetPeakValue(LimitableResource which) const;
+    s64 GetFreeValue(LimitableResource which) const;
+
+    ResultCode SetLimitValue(LimitableResource which, s64 value);
+
+    bool Reserve(LimitableResource which, s64 value);
+    bool Reserve(LimitableResource which, s64 value, s64 timeout);
+    void Release(LimitableResource which, s64 value);
+    void Release(LimitableResource which, s64 value, s64 hint);
+
+    std::string GetTypeName() const override {
+        return "KResourceLimit";
+    }
+    std::string GetName() const override {
+        return GetTypeName();
+    }
+
+    static constexpr HandleType HANDLE_TYPE = HandleType::ResourceLimit;
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
+
+    virtual void Finalize() override {}
+
+private:
+    using ResourceArray = std::array<s64, static_cast<std::size_t>(LimitableResource::Count)>;
+    ResourceArray limit_values{};
+    ResourceArray current_values{};
+    ResourceArray current_hints{};
+    ResourceArray peak_values{};
+    mutable KLightLock lock;
+    s32 waiter_count{};
+    KLightConditionVariable cond_var;
+    KernelCore& kernel;
+    Core::System& system;
+};
+} // namespace Kernel
@@ -0,0 +1,67 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/hle/kernel/k_resource_limit.h"
+#include "core/hle/kernel/process.h"
+
+namespace Kernel {
+
+class KScopedResourceReservation {
+public:
+    explicit KScopedResourceReservation(std::shared_ptr<KResourceLimit> l, LimitableResource r,
+                                        s64 v, s64 timeout)
+        : resource_limit(std::move(l)), value(v), resource(r) {
+        if (resource_limit && value) {
+            success = resource_limit->Reserve(resource, value, timeout);
+        } else {
+            success = true;
+        }
+    }
+
+    explicit KScopedResourceReservation(std::shared_ptr<KResourceLimit> l, LimitableResource r,
+                                        s64 v = 1)
+        : resource_limit(std::move(l)), value(v), resource(r) {
+        if (resource_limit && value) {
+            success = resource_limit->Reserve(resource, value);
+        } else {
+            success = true;
+        }
+    }
+
+    explicit KScopedResourceReservation(const Process* p, LimitableResource r, s64 v, s64 t)
+        : KScopedResourceReservation(p->GetResourceLimit(), r, v, t) {}
+
+    explicit KScopedResourceReservation(const Process* p, LimitableResource r, s64 v = 1)
+        : KScopedResourceReservation(p->GetResourceLimit(), r, v) {}
+
+    ~KScopedResourceReservation() noexcept {
+        if (resource_limit && value && success) {
+            // resource was not committed, release the reservation.
+            resource_limit->Release(resource, value);
+        }
+    }
+
+    /// Commit the resource reservation, destruction of this object does not release the resource
+    void Commit() {
+        resource_limit = nullptr;
+    }
+
+    [[nodiscard]] bool Succeeded() const {
+        return success;
+    }
+
+private:
+    std::shared_ptr<KResourceLimit> resource_limit;
+    s64 value;
+    LimitableResource resource;
+    bool success;
+};
+
+} // namespace Kernel
@@ -40,20 +40,20 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,
        // Check if the timeout is zero.
        if (timeout == 0) {
            slp.CancelSleep();
-            return Svc::ResultTimedOut;
+            return ResultTimedOut;
        }

        // Check if the thread should terminate.
        if (thread->IsTerminationRequested()) {
            slp.CancelSleep();
-            return Svc::ResultTerminationRequested;
+            return ResultTerminationRequested;
        }

        // Check if waiting was canceled.
        if (thread->IsWaitCancelled()) {
            slp.CancelSleep();
            thread->ClearWaitCancelled();
-            return Svc::ResultCancelled;
+            return ResultCancelled;
        }

        // Add the waiters.
@@ -75,7 +75,7 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,

        // Mark the thread as waiting.
        thread->SetCancellable();
-        thread->SetSyncedObject(nullptr, Svc::ResultTimedOut);
+        thread->SetSyncedObject(nullptr, ResultTimedOut);
        thread->SetState(ThreadState::Waiting);
        thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Synchronization);
    }
@@ -132,6 +132,9 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,

 KSynchronizationObject::KSynchronizationObject(KernelCore& kernel) : Object{kernel} {}

+KSynchronizationObject::KSynchronizationObject(KernelCore& kernel, std::string&& name)
+    : Object{kernel, std::move(name)} {}
+
 KSynchronizationObject::~KSynchronizationObject() = default;

 void KSynchronizationObject::NotifyAvailable(ResultCode result) {
@@ -33,6 +33,7 @@ public:

 protected:
    explicit KSynchronizationObject(KernelCore& kernel);
+    explicit KSynchronizationObject(KernelCore& kernel, std::string&& name);
    virtual ~KSynchronizationObject();

    void NotifyAvailable(ResultCode result);
@@ -18,9 +18,9 @@
 #include "core/core.h"
 #include "core/cpu_manager.h"
 #include "core/hardware_properties.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/k_condition_variable.h"
+#include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
 #include "core/hle/kernel/k_thread.h"
@@ -29,7 +29,6 @@
 #include "core/hle/kernel/memory/memory_layout.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/time_manager.h"
 #include "core/hle/result.h"
@@ -127,7 +126,7 @@ ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_s

    // Set core ID and wait result.
    core_id = phys_core;
-    wait_result = Svc::ResultNoSynchronizationObject;
+    wait_result = ResultNoSynchronizationObject;

    // Set priorities.
    priority = prio;
@@ -238,7 +237,7 @@ void KThread::Finalize() {
        while (it != waiter_list.end()) {
            // The thread shouldn't be a kernel waiter.
            it->SetLockOwner(nullptr);
-            it->SetSyncedObject(nullptr, Svc::ResultInvalidState);
+            it->SetSyncedObject(nullptr, ResultInvalidState);
            it->Wakeup();
            it = waiter_list.erase(it);
        }
@@ -247,7 +246,7 @@ void KThread::Finalize() {
    // Decrement the parent process's thread count.
    if (parent != nullptr) {
        parent->DecrementThreadCount();
-        parent->GetResourceLimit()->Release(ResourceType::Threads, 1);
+        parent->GetResourceLimit()->Release(LimitableResource::Threads, 1);
    }
 }

@@ -447,7 +446,7 @@ ResultCode KThread::SetCoreMask(s32 core_id, u64 v_affinity_mask) {
        // If the core id is no-update magic, preserve the ideal core id.
        if (core_id == Svc::IdealCoreNoUpdate) {
            core_id = virtual_ideal_core_id;
-            R_UNLESS(((1ULL << core_id) & v_affinity_mask) != 0, Svc::ResultInvalidCombination);
+            R_UNLESS(((1ULL << core_id) & v_affinity_mask) != 0, ResultInvalidCombination);
        }

        // Set the virtual core/affinity mask.
@@ -526,7 +525,7 @@ ResultCode KThread::SetCoreMask(s32 core_id, u64 v_affinity_mask) {
                if (GetStackParameters().is_pinned) {
                    // Verify that the current thread isn't terminating.
                    R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),
-                             Svc::ResultTerminationRequested);
+                             ResultTerminationRequested);

                    // Note that the thread was pinned.
                    thread_is_pinned = true;
@@ -604,7 +603,7 @@ void KThread::WaitCancel() {
            sleeping_queue->WakeupThread(this);
            wait_cancelled = true;
        } else {
-            SetSyncedObject(nullptr, Svc::ResultCancelled);
+            SetSyncedObject(nullptr, ResultCancelled);
            SetState(ThreadState::Runnable);
            wait_cancelled = false;
        }
@@ -663,12 +662,12 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
        // Verify our state.
        const auto cur_state = GetState();
        R_UNLESS((cur_state == ThreadState::Waiting || cur_state == ThreadState::Runnable),
-                 Svc::ResultInvalidState);
+                 ResultInvalidState);

        // Either pause or resume.
        if (activity == Svc::ThreadActivity::Paused) {
            // Verify that we're not suspended.
-            R_UNLESS(!IsSuspendRequested(SuspendType::Thread), Svc::ResultInvalidState);
+            R_UNLESS(!IsSuspendRequested(SuspendType::Thread), ResultInvalidState);

            // Suspend.
            RequestSuspend(SuspendType::Thread);
@@ -676,7 +675,7 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
            ASSERT(activity == Svc::ThreadActivity::Runnable);

            // Verify that we're suspended.
-            R_UNLESS(IsSuspendRequested(SuspendType::Thread), Svc::ResultInvalidState);
+            R_UNLESS(IsSuspendRequested(SuspendType::Thread), ResultInvalidState);

            // Resume.
            Resume(SuspendType::Thread);
@@ -698,7 +697,7 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
            if (GetStackParameters().is_pinned) {
                // Verify that the current thread isn't terminating.
                R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),
-                         Svc::ResultTerminationRequested);
+                         ResultTerminationRequested);

                // Note that the thread was pinned and not current.
                thread_is_pinned = true;
@@ -745,7 +744,7 @@ ResultCode KThread::GetThreadContext3(std::vector<u8>& out) {
        KScopedSchedulerLock sl{kernel};

        // Verify that we're suspended.
-        R_UNLESS(IsSuspendRequested(SuspendType::Thread), Svc::ResultInvalidState);
+        R_UNLESS(IsSuspendRequested(SuspendType::Thread), ResultInvalidState);

        // If we're not terminating, get the thread's user context.
        if (!IsTerminationRequested()) {
@@ -905,12 +904,11 @@ ResultCode KThread::Run() {
        KScopedSchedulerLock lk{kernel};

        // If either this thread or the current thread are requesting termination, note it.
-        R_UNLESS(!IsTerminationRequested(), Svc::ResultTerminationRequested);
-        R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),
-                 Svc::ResultTerminationRequested);
+        R_UNLESS(!IsTerminationRequested(), ResultTerminationRequested);
+        R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(), ResultTerminationRequested);

        // Ensure our thread state is correct.
-        R_UNLESS(GetState() == ThreadState::Initialized, Svc::ResultInvalidState);
+        R_UNLESS(GetState() == ThreadState::Initialized, ResultInvalidState);

        // If the current thread has been asked to suspend, suspend it and retry.
        if (GetCurrentThread(kernel).IsSuspended()) {
@@ -962,7 +960,7 @@ ResultCode KThread::Sleep(s64 timeout) {
        // Check if the thread should terminate.
        if (IsTerminationRequested()) {
            slp.CancelSleep();
-            return Svc::ResultTerminationRequested;
+            return ResultTerminationRequested;
        }

        // Mark the thread as waiting.
@@ -0,0 +1,27 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/kernel/k_writable_event.h"
+
+namespace Kernel {
+
+KWritableEvent::KWritableEvent(KernelCore& kernel, std::string&& name)
+    : Object{kernel, std::move(name)} {}
+KWritableEvent::~KWritableEvent() = default;
+
+void KWritableEvent::Initialize(KEvent* parent_) {
+    parent = parent_;
+}
+
+ResultCode KWritableEvent::Signal() {
+    return parent->GetReadableEvent()->Signal();
+}
+
+ResultCode KWritableEvent::Clear() {
+    return parent->GetReadableEvent()->Clear();
+}
+
+} // namespace Kernel
@@ -0,0 +1,44 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/kernel/object.h"
+#include "core/hle/result.h"
+
+namespace Kernel {
+
+class KernelCore;
+class KEvent;
+
+class KWritableEvent final : public Object {
+public:
+    explicit KWritableEvent(KernelCore& kernel, std::string&& name);
+    ~KWritableEvent() override;
+
+    std::string GetTypeName() const override {
+        return "KWritableEvent";
+    }
+
+    static constexpr HandleType HANDLE_TYPE = HandleType::WritableEvent;
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
+
+    void Initialize(KEvent* parent_);
+
+    void Finalize() override {}
+
+    ResultCode Signal();
+    ResultCode Clear();
+
+    KEvent* GetParent() const {
+        return parent;
+    }
+
+private:
+    KEvent* parent{};
+};
+
+} // namespace Kernel
@@ -26,8 +26,8 @@
 #include "core/device_memory.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/client_port.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
@@ -36,9 +36,9 @@
 #include "core/hle/kernel/memory/slab_heap.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/service_thread.h"
 #include "core/hle/kernel/shared_memory.h"
+#include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/time_manager.h"
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
@@ -66,7 +66,7 @@ struct KernelCore::Impl {
        is_phantom_mode_for_singlecore = false;

        InitializePhysicalCores();
-        InitializeSystemResourceLimit(kernel);
+        InitializeSystemResourceLimit(kernel, system);
        InitializeMemoryLayout();
        InitializePreemption(kernel);
        InitializeSchedulers();
@@ -131,21 +131,27 @@ struct KernelCore::Impl {
    }

    // Creates the default system resource limit
-    void InitializeSystemResourceLimit(KernelCore& kernel) {
-        system_resource_limit = ResourceLimit::Create(kernel);
+    void InitializeSystemResourceLimit(KernelCore& kernel, Core::System& system) {
+        system_resource_limit = std::make_shared<KResourceLimit>(kernel, system);

        // If setting the default system values fails, then something seriously wrong has occurred.
-        ASSERT(system_resource_limit->SetLimitValue(ResourceType::PhysicalMemory, 0x100000000)
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::PhysicalMemory, 0x100000000)
                   .IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(ResourceType::Threads, 800).IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(ResourceType::Events, 700).IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(ResourceType::TransferMemory, 200).IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(ResourceType::Sessions, 900).IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::Threads, 800).IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::Events, 700).IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::TransferMemory, 200)
+                   .IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::Sessions, 933).IsSuccess());

-        if (!system_resource_limit->Reserve(ResourceType::PhysicalMemory, 0) ||
-            !system_resource_limit->Reserve(ResourceType::PhysicalMemory, 0x60000)) {
+        // Derived from recent software updates. The kernel reserves 27MB
+        constexpr u64 kernel_size{0x1b00000};
+        if (!system_resource_limit->Reserve(LimitableResource::PhysicalMemory, kernel_size)) {
            UNREACHABLE();
        }
+        // Reserve secure applet memory, introduced in firmware 5.0.0
+        constexpr u64 secure_applet_memory_size{0x400000};
+        ASSERT(system_resource_limit->Reserve(LimitableResource::PhysicalMemory,
+                                              secure_applet_memory_size));
    }

    void InitializePreemption(KernelCore& kernel) {
@@ -302,8 +308,11 @@ struct KernelCore::Impl {
        // Allocate slab heaps
        user_slab_heap_pages = std::make_unique<Memory::SlabHeap<Memory::Page>>();

+        constexpr u64 user_slab_heap_size{0x1ef000};
+        // Reserve slab heaps
+        ASSERT(
+            system_resource_limit->Reserve(LimitableResource::PhysicalMemory, user_slab_heap_size));
        // Initialize slab heaps
-        constexpr u64 user_slab_heap_size{0x3de000};
        user_slab_heap_pages->Initialize(
            system.DeviceMemory().GetPointer(Core::DramMemoryMap::SlabHeapBase),
            user_slab_heap_size);
@@ -320,7 +329,7 @@ struct KernelCore::Impl {
    std::unique_ptr<Kernel::GlobalSchedulerContext> global_scheduler_context;
    Kernel::TimeManager time_manager;

-    std::shared_ptr<ResourceLimit> system_resource_limit;
+    std::shared_ptr<KResourceLimit> system_resource_limit;

    std::shared_ptr<Core::Timing::EventType> preemption_event;

@@ -390,7 +399,7 @@ void KernelCore::Shutdown() {
    impl->Shutdown();
 }

-std::shared_ptr<ResourceLimit> KernelCore::GetSystemResourceLimit() const {
+std::shared_ptr<KResourceLimit> KernelCore::GetSystemResourceLimit() const {
    return impl->system_resource_limit;
 }

@@ -38,7 +38,7 @@ class GlobalSchedulerContext;
 class HandleTable;
 class PhysicalCore;
 class Process;
-class ResourceLimit;
+class KResourceLimit;
 class KScheduler;
 class SharedMemory;
 class ServiceThread;
@@ -85,7 +85,7 @@ public:
    void Shutdown();

    /// Retrieves a shared pointer to the system resource limit instance.
-    std::shared_ptr<ResourceLimit> GetSystemResourceLimit() const;
+    std::shared_ptr<KResourceLimit> GetSystemResourceLimit() const;

    /// Retrieves a shared pointer to a Thread instance within the thread wakeup handle table.
    std::shared_ptr<KThread> RetrieveThreadFromGlobalHandleTable(Handle handle) const;
@@ -8,9 +8,9 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/scope_exit.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/memory/memory_manager.h"
 #include "core/hle/kernel/memory/page_linked_list.h"
+#include "core/hle/kernel/svc_results.h"

 namespace Kernel::Memory {

@@ -95,7 +95,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
    // Choose a heap based on our page size request
    const s32 heap_index{PageHeap::GetBlockIndex(num_pages)};
    if (heap_index < 0) {
-        return ERR_OUT_OF_MEMORY;
+        return ResultOutOfMemory;
    }

    // TODO (bunnei): Support multiple managers
@@ -140,7 +140,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa

    // Only succeed if we allocated as many pages as we wanted
    if (num_pages) {
-        return ERR_OUT_OF_MEMORY;
+        return ResultOutOfMemory;
    }

    // We succeeded!
@@ -6,7 +6,7 @@
 #include "common/assert.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
-#include "core/hle/kernel/errors.h"
+#include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory/address_space_info.h"
 #include "core/hle/kernel/memory/memory_block.h"
@@ -15,7 +15,7 @@
 #include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/memory/system_control.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/resource_limit.h"
+#include "core/hle/kernel/svc_results.h"
 #include "core/memory.h"

 namespace Kernel::Memory {
@@ -141,7 +141,7 @@ ResultCode PageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_t
        (alias_region_size + heap_region_size + stack_region_size + kernel_map_region_size)};
    if (alloc_size < needed_size) {
        UNREACHABLE();
-        return ERR_OUT_OF_MEMORY;
+        return ResultOutOfMemory;
    }

    const std::size_t remaining_size{alloc_size - needed_size};
@@ -277,11 +277,11 @@ ResultCode PageTable::MapProcessCode(VAddr addr, std::size_t num_pages, MemorySt
    const u64 size{num_pages * PageSize};

    if (!CanContain(addr, size, state)) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }

    if (IsRegionMapped(addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }

    PageLinkedList page_linked_list;
@@ -307,7 +307,7 @@ ResultCode PageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::
                                  MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));

    if (IsRegionMapped(dst_addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }

    PageLinkedList page_linked_list;
@@ -409,27 +409,25 @@ ResultCode PageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
        return RESULT_SUCCESS;
    }

-    auto process{system.Kernel().CurrentProcess()};
    const std::size_t remaining_size{size - mapped_size};
    const std::size_t remaining_pages{remaining_size / PageSize};

-    if (process->GetResourceLimit() &&
-        !process->GetResourceLimit()->Reserve(ResourceType::PhysicalMemory, remaining_size)) {
-        return ERR_RESOURCE_LIMIT_EXCEEDED;
+    // Reserve the memory from the process resource limit.
+    KScopedResourceReservation memory_reservation(
+        system.Kernel().CurrentProcess()->GetResourceLimit(), LimitableResource::PhysicalMemory,
+        remaining_size);
+    if (!memory_reservation.Succeeded()) {
+        LOG_ERROR(Kernel, "Could not reserve remaining {:X} bytes", remaining_size);
+        return ResultResourceLimitedExceeded;
    }

    PageLinkedList page_linked_list;
-    {
-        auto block_guard = detail::ScopeExit([&] {
-            system.Kernel().MemoryManager().Free(page_linked_list, remaining_pages, memory_pool);
-            process->GetResourceLimit()->Release(ResourceType::PhysicalMemory, remaining_size);
-        });

-        CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_linked_list, remaining_pages,
-                                                              memory_pool));
+    CASCADE_CODE(
+        system.Kernel().MemoryManager().Allocate(page_linked_list, remaining_pages, memory_pool));

-        block_guard.Cancel();
-    }
+    // We succeeded, so commit the memory reservation.
+    memory_reservation.Commit();

    MapPhysicalMemory(page_linked_list, addr, end_addr);

@@ -454,12 +452,12 @@ ResultCode PageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
    block_manager->IterateForRange(addr, end_addr, [&](const MemoryInfo& info) {
        if (info.state == MemoryState::Normal) {
            if (info.attribute != MemoryAttribute::None) {
-                result = ERR_INVALID_ADDRESS_STATE;
+                result = ResultInvalidCurrentMemory;
                return;
            }
            mapped_size += GetSizeInRange(info, addr, end_addr);
        } else if (info.state != MemoryState::Free) {
-            result = ERR_INVALID_ADDRESS_STATE;
+            result = ResultInvalidCurrentMemory;
        }
    });

@@ -474,7 +472,7 @@ ResultCode PageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
    CASCADE_CODE(UnmapMemory(addr, size));

    auto process{system.Kernel().CurrentProcess()};
-    process->GetResourceLimit()->Release(ResourceType::PhysicalMemory, mapped_size);
+    process->GetResourceLimit()->Release(LimitableResource::PhysicalMemory, mapped_size);
    physical_memory_usage -= mapped_size;

    return RESULT_SUCCESS;
@@ -526,7 +524,7 @@ ResultCode PageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
        MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));

    if (IsRegionMapped(dst_addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }

    PageLinkedList page_linked_list;
@@ -577,7 +575,7 @@ ResultCode PageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
    AddRegionToPages(dst_addr, num_pages, dst_pages);

    if (!dst_pages.IsEqual(src_pages)) {
-        return ERR_INVALID_MEMORY_RANGE;
+        return ResultInvalidMemoryRange;
    }

    {
@@ -626,11 +624,11 @@ ResultCode PageTable::MapPages(VAddr addr, PageLinkedList& page_linked_list, Mem
    const std::size_t size{num_pages * PageSize};

    if (!CanContain(addr, size, state)) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }

    if (IsRegionMapped(addr, num_pages * PageSize)) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }

    CASCADE_CODE(MapPages(addr, page_linked_list, perm));
@@ -768,7 +766,7 @@ ResultCode PageTable::SetHeapCapacity(std::size_t new_heap_capacity) {
 ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {

    if (size > heap_region_end - heap_region_start) {
-        return ERR_OUT_OF_MEMORY;
+        return ResultOutOfMemory;
    }

    const u64 previous_heap_size{GetHeapSize()};
@@ -781,10 +779,14 @@ ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {

        const u64 delta{size - previous_heap_size};

-        auto process{system.Kernel().CurrentProcess()};
-        if (process->GetResourceLimit() && delta != 0 &&
-            !process->GetResourceLimit()->Reserve(ResourceType::PhysicalMemory, delta)) {
-            return ERR_RESOURCE_LIMIT_EXCEEDED;
+        // Reserve memory for the heap extension.
+        KScopedResourceReservation memory_reservation(
+            system.Kernel().CurrentProcess()->GetResourceLimit(), LimitableResource::PhysicalMemory,
+            delta);
+
+        if (!memory_reservation.Succeeded()) {
+            LOG_ERROR(Kernel, "Could not reserve heap extension of size {:X} bytes", delta);
+            return ResultResourceLimitedExceeded;
        }

        PageLinkedList page_linked_list;
@@ -794,12 +796,15 @@ ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {
            system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool));

        if (IsRegionMapped(current_heap_addr, delta)) {
-            return ERR_INVALID_ADDRESS_STATE;
+            return ResultInvalidCurrentMemory;
        }

        CASCADE_CODE(
            Operate(current_heap_addr, num_pages, page_linked_list, OperationType::MapGroup));

+        // Succeeded in allocation, commit the resource reservation
+        memory_reservation.Commit();
+
        block_manager->Update(current_heap_addr, num_pages, MemoryState::Normal,
                              MemoryPermission::ReadAndWrite);

@@ -816,17 +821,17 @@ ResultVal<VAddr> PageTable::AllocateAndMapMemory(std::size_t needed_num_pages, s
    std::lock_guard lock{page_table_lock};

    if (!CanContain(region_start, region_num_pages * PageSize, state)) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }

    if (region_num_pages <= needed_num_pages) {
-        return ERR_OUT_OF_MEMORY;
+        return ResultOutOfMemory;
    }

    const VAddr addr{
        AllocateVirtualMemory(region_start, region_num_pages, needed_num_pages, align)};
    if (!addr) {
-        return ERR_OUT_OF_MEMORY;
+        return ResultOutOfMemory;
    }

    if (is_map_only) {
@@ -1105,13 +1110,13 @@ constexpr ResultCode PageTable::CheckMemoryState(const MemoryInfo& info, MemoryS
                                                 MemoryAttribute attr) const {
    // Validate the states match expectation
    if ((info.state & state_mask) != state) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }
    if ((info.perm & perm_mask) != perm) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }
    if ((info.attribute & attr_mask) != attr) {
-        return ERR_INVALID_ADDRESS_STATE;
+        return ResultInvalidCurrentMemory;
    }

    return RESULT_SUCCESS;
@@ -1138,14 +1143,14 @@ ResultCode PageTable::CheckMemoryState(MemoryState* out_state, MemoryPermission*
    while (true) {
        // Validate the current block
        if (!(info.state == first_state)) {
-            return ERR_INVALID_ADDRESS_STATE;
+            return ResultInvalidCurrentMemory;
        }
        if (!(info.perm == first_perm)) {
-            return ERR_INVALID_ADDRESS_STATE;
+            return ResultInvalidCurrentMemory;
        }
        if (!((info.attribute | static_cast<MemoryAttribute>(ignore_attr)) ==
              (first_attr | static_cast<MemoryAttribute>(ignore_attr)))) {
-            return ERR_INVALID_ADDRESS_STATE;
+            return ResultInvalidCurrentMemory;
        }

        // Validate against the provided masks
@@ -8,7 +8,10 @@

 namespace Kernel {

-Object::Object(KernelCore& kernel) : kernel{kernel}, object_id{kernel.CreateNewObjectID()} {}
+Object::Object(KernelCore& kernel_)
+    : kernel{kernel_}, object_id{kernel_.CreateNewObjectID()}, name{"[UNKNOWN KERNEL OBJECT]"} {}
+Object::Object(KernelCore& kernel_, std::string&& name_)
+    : kernel{kernel_}, object_id{kernel_.CreateNewObjectID()}, name{std::move(name_)} {}
 Object::~Object() = default;

 bool Object::IsWaitable() const {
@@ -21,6 +24,7 @@ bool Object::IsWaitable() const {
        return true;

    case HandleType::Unknown:
+    case HandleType::Event:
    case HandleType::WritableEvent:
    case HandleType::SharedMemory:
    case HandleType::TransferMemory:
@@ -18,6 +18,7 @@ using Handle = u32;

 enum class HandleType : u32 {
    Unknown,
+    Event,
    WritableEvent,
    ReadableEvent,
    SharedMemory,
@@ -34,7 +35,8 @@ enum class HandleType : u32 {

 class Object : NonCopyable, public std::enable_shared_from_this<Object> {
 public:
-    explicit Object(KernelCore& kernel);
+    explicit Object(KernelCore& kernel_);
+    explicit Object(KernelCore& kernel_, std::string&& name_);
    virtual ~Object();

    /// Returns a unique identifier for the object. For debugging purposes only.
@@ -46,7 +48,7 @@ public:
        return "[BAD KERNEL OBJECT TYPE]";
    }
    virtual std::string GetName() const {
-        return "[UNKNOWN KERNEL OBJECT]";
+        return name;
    }
    virtual HandleType GetHandleType() const = 0;

@@ -69,6 +71,7 @@ protected:

 private:
    std::atomic<u32> object_id{0};
+    std::string name;
 };

 template <typename T>
@@ -14,15 +14,16 @@
 #include "core/device_memory.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/code_set.h"
-#include "core/hle/kernel/errors.h"
+#include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory/memory_block_manager.h"
 #include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/memory/slab_heap.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/resource_limit.h"
+#include "core/hle/kernel/svc_results.h"
 #include "core/hle/lock.h"
 #include "core/memory.h"
 #include "core/settings.h"
@@ -38,6 +39,7 @@ namespace {
 */
 void SetupMainThread(Core::System& system, Process& owner_process, u32 priority, VAddr stack_top) {
    const VAddr entry_point = owner_process.PageTable().GetCodeRegionStart();
+    ASSERT(owner_process.GetResourceLimit()->Reserve(LimitableResource::Threads, 1));
    auto thread_res = KThread::Create(system, ThreadType::User, "main", entry_point, priority, 0,
                                      owner_process.GetIdealCoreId(), stack_top, &owner_process);

@@ -116,7 +118,10 @@ std::shared_ptr<Process> Process::Create(Core::System& system, std::string name,

    std::shared_ptr<Process> process = std::make_shared<Process>(system);
    process->name = std::move(name);
-    process->resource_limit = ResourceLimit::Create(kernel);
+
+    // TODO: This is inaccurate
+    // The process should hold a reference to the kernel-wide resource limit.
+    process->resource_limit = std::make_shared<KResourceLimit>(kernel, system);
    process->status = ProcessStatus::Created;
    process->program_id = 0;
    process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
@@ -132,7 +137,7 @@ std::shared_ptr<Process> Process::Create(Core::System& system, std::string name,
    return process;
 }

-std::shared_ptr<ResourceLimit> Process::GetResourceLimit() const {
+std::shared_ptr<KResourceLimit> Process::GetResourceLimit() const {
    return resource_limit;
 }

@@ -154,7 +159,10 @@ void Process::DecrementThreadCount() {
 }

 u64 Process::GetTotalPhysicalMemoryAvailable() const {
-    const u64 capacity{resource_limit->GetCurrentResourceValue(ResourceType::PhysicalMemory) +
+    // TODO: This is expected to always return the application memory pool size after accurately
+    // reserving kernel resources. The current workaround uses a process-local resource limit of
+    // application memory pool size, which is inaccurate.
+    const u64 capacity{resource_limit->GetFreeValue(LimitableResource::PhysicalMemory) +
                       page_table->GetTotalHeapSize() + GetSystemResourceSize() + image_size +
                       main_thread_stack_size};

@@ -241,18 +249,16 @@ void Process::UnregisterThread(const KThread* thread) {
    thread_list.remove(thread);
 }

-ResultCode Process::ClearSignalState() {
-    KScopedSchedulerLock lock(system.Kernel());
-    if (status == ProcessStatus::Exited) {
-        LOG_ERROR(Kernel, "called on a terminated process instance.");
-        return ERR_INVALID_STATE;
-    }
+ResultCode Process::Reset() {
+    // Lock the process and the scheduler.
+    KScopedLightLock lk(state_lock);
+    KScopedSchedulerLock sl{kernel};

-    if (!is_signaled) {
-        LOG_ERROR(Kernel, "called on a process instance that isn't signaled.");
-        return ERR_INVALID_STATE;
-    }
+    // Validate that we're in a state that we can reset.
+    R_UNLESS(status != ProcessStatus::Exited, ResultInvalidState);
+    R_UNLESS(is_signaled, ResultInvalidState);

+    // Clear signaled.
    is_signaled = false;
    return RESULT_SUCCESS;
 }
@@ -265,6 +271,17 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
    system_resource_size = metadata.GetSystemResourceSize();
    image_size = code_size;

+    // Set initial resource limits
+    resource_limit->SetLimitValue(
+        LimitableResource::PhysicalMemory,
+        kernel.MemoryManager().GetSize(Memory::MemoryManager::Pool::Application));
+    KScopedResourceReservation memory_reservation(resource_limit, LimitableResource::PhysicalMemory,
+                                                  code_size + system_resource_size);
+    if (!memory_reservation.Succeeded()) {
+        LOG_ERROR(Kernel, "Could not reserve process memory requirements of size {:X} bytes",
+                  code_size + system_resource_size);
+        return ResultResourceLimitedExceeded;
+    }
    // Initialize proces address space
    if (const ResultCode result{
            page_table->InitializeForProcess(metadata.GetAddressSpaceType(), false, 0x8000000,
@@ -306,24 +323,22 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
        UNREACHABLE();
    }

-    // Set initial resource limits
-    resource_limit->SetLimitValue(
-        ResourceType::PhysicalMemory,
-        kernel.MemoryManager().GetSize(Memory::MemoryManager::Pool::Application));
-    resource_limit->SetLimitValue(ResourceType::Threads, 608);
-    resource_limit->SetLimitValue(ResourceType::Events, 700);
-    resource_limit->SetLimitValue(ResourceType::TransferMemory, 128);
-    resource_limit->SetLimitValue(ResourceType::Sessions, 894);
-    ASSERT(resource_limit->Reserve(ResourceType::PhysicalMemory, code_size));
+    resource_limit->SetLimitValue(LimitableResource::Threads, 608);
+    resource_limit->SetLimitValue(LimitableResource::Events, 700);
+    resource_limit->SetLimitValue(LimitableResource::TransferMemory, 128);
+    resource_limit->SetLimitValue(LimitableResource::Sessions, 894);

    // Create TLS region
    tls_region_address = CreateTLSRegion();
+    memory_reservation.Commit();

    return handle_table.SetSize(capabilities.GetHandleTableSize());
 }

 void Process::Run(s32 main_thread_priority, u64 stack_size) {
    AllocateMainThreadStack(stack_size);
+    resource_limit->Reserve(LimitableResource::Threads, 1);
+    resource_limit->Reserve(LimitableResource::PhysicalMemory, main_thread_stack_size);

    const std::size_t heap_capacity{memory_usage_capacity - main_thread_stack_size - image_size};
    ASSERT(!page_table->SetHeapCapacity(heap_capacity).IsError());
@@ -331,8 +346,6 @@ void Process::Run(s32 main_thread_priority, u64 stack_size) {
    ChangeStatus(ProcessStatus::Running);

    SetupMainThread(system, *this, main_thread_priority, main_thread_stack_top);
-    resource_limit->Reserve(ResourceType::Threads, 1);
-    resource_limit->Reserve(ResourceType::PhysicalMemory, main_thread_stack_size);
 }

 void Process::PrepareForTermination() {
@@ -359,6 +372,11 @@ void Process::PrepareForTermination() {
    FreeTLSRegion(tls_region_address);
    tls_region_address = 0;

+    if (resource_limit) {
+        resource_limit->Release(LimitableResource::PhysicalMemory,
+                                main_thread_stack_size + image_size);
+    }
+
    ChangeStatus(ProcessStatus::Exited);
 }

@@ -29,7 +29,7 @@ class ProgramMetadata;
 namespace Kernel {

 class KernelCore;
-class ResourceLimit;
+class KResourceLimit;
 class KThread;
 class TLSPage;

@@ -170,7 +170,7 @@ public:
    }

    /// Gets the resource limit descriptor for this process
-    std::shared_ptr<ResourceLimit> GetResourceLimit() const;
+    std::shared_ptr<KResourceLimit> GetResourceLimit() const;

    /// Gets the ideal CPU core ID for this process
    u8 GetIdealCoreId() const {
@@ -312,7 +312,7 @@ public:
    /// @pre The process must be in a signaled state. If this is called on a
    ///      process instance that is not signaled, ERR_INVALID_STATE will be
    ///      returned.
-    ResultCode ClearSignalState();
+    ResultCode Reset();

    /**
     * Loads process-specifics configuration info with metadata provided
@@ -402,7 +402,7 @@ private:
    u32 system_resource_size = 0;

    /// Resource limit descriptor for this process
-    std::shared_ptr<ResourceLimit> resource_limit;
+    std::shared_ptr<KResourceLimit> resource_limit;

    /// The ideal CPU core for this process, threads are scheduled on this core by default.
    u8 ideal_core = 0;
@@ -6,10 +6,10 @@

 #include "common/bit_util.h"
 #include "common/logging/log.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process_capability.h"
+#include "core/hle/kernel/svc_results.h"

 namespace Kernel {
 namespace {
@@ -123,13 +123,13 @@ ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
            // If there's only one, then there's a problem.
            if (i >= num_capabilities) {
                LOG_ERROR(Kernel, "Invalid combination! i={}", i);
-                return ERR_INVALID_COMBINATION;
+                return ResultInvalidCombination;
            }

            const auto size_flags = capabilities[i];
            if (GetCapabilityType(size_flags) != CapabilityType::MapPhysical) {
                LOG_ERROR(Kernel, "Invalid capability type! size_flags={}", size_flags);
-                return ERR_INVALID_COMBINATION;
+                return ResultInvalidCombination;
            }

            const auto result = HandleMapPhysicalFlags(descriptor, size_flags, page_table);
@@ -159,7 +159,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
    const auto type = GetCapabilityType(flag);

    if (type == CapabilityType::Unset) {
-        return ERR_INVALID_CAPABILITY_DESCRIPTOR;
+        return ResultInvalidCapabilityDescriptor;
    }

    // Bail early on ignorable entries, as one would expect,
@@ -176,7 +176,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
        LOG_ERROR(Kernel,
                  "Attempted to initialize flags that may only be initialized once. set_flags={}",
                  set_flags);
-        return ERR_INVALID_COMBINATION;
+        return ResultInvalidCombination;
    }
    set_flags |= set_flag;

@@ -202,7 +202,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
    }

    LOG_ERROR(Kernel, "Invalid capability type! type={}", type);
-    return ERR_INVALID_CAPABILITY_DESCRIPTOR;
+    return ResultInvalidCapabilityDescriptor;
 }

 void ProcessCapabilities::Clear() {
@@ -225,7 +225,7 @@ ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
    if (priority_mask != 0 || core_mask != 0) {
        LOG_ERROR(Kernel, "Core or priority mask are not zero! priority_mask={}, core_mask={}",
                  priority_mask, core_mask);
-        return ERR_INVALID_CAPABILITY_DESCRIPTOR;
+        return ResultInvalidCapabilityDescriptor;
    }

    const u32 core_num_min = (flags >> 16) & 0xFF;
@@ -233,7 +233,7 @@ ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
    if (core_num_min > core_num_max) {
        LOG_ERROR(Kernel, "Core min is greater than core max! core_num_min={}, core_num_max={}",
                  core_num_min, core_num_max);
-        return ERR_INVALID_COMBINATION;
+        return ResultInvalidCombination;
    }

    const u32 priority_min = (flags >> 10) & 0x3F;
@@ -242,13 +242,13 @@ ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
        LOG_ERROR(Kernel,
                  "Priority min is greater than priority max! priority_min={}, priority_max={}",
                  core_num_min, priority_max);
-        return ERR_INVALID_COMBINATION;
+        return ResultInvalidCombination;
    }

    // The switch only has 4 usable cores.
    if (core_num_max >= 4) {
        LOG_ERROR(Kernel, "Invalid max cores specified! core_num_max={}", core_num_max);
-        return ERR_INVALID_PROCESSOR_ID;
+        return ResultInvalidCoreId;
    }

    const auto make_mask = [](u64 min, u64 max) {
@@ -269,7 +269,7 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)

    // If we've already set this svc before, bail.
    if ((set_svc_bits & svc_bit) != 0) {
-        return ERR_INVALID_COMBINATION;
+        return ResultInvalidCombination;
    }
    set_svc_bits |= svc_bit;

@@ -283,7 +283,7 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)

        if (svc_number >= svc_capabilities.size()) {
            LOG_ERROR(Kernel, "Process svc capability is out of range! svc_number={}", svc_number);
-            return ERR_OUT_OF_RANGE;
+            return ResultOutOfRange;
        }

        svc_capabilities[svc_number] = true;
@@ -321,7 +321,7 @@ ResultCode ProcessCapabilities::HandleInterruptFlags(u32 flags) {
        if (interrupt >= interrupt_capabilities.size()) {
            LOG_ERROR(Kernel, "Process interrupt capability is out of range! svc_number={}",
                      interrupt);
-            return ERR_OUT_OF_RANGE;
+            return ResultOutOfRange;
        }

        interrupt_capabilities[interrupt] = true;
@@ -334,7 +334,7 @@ ResultCode ProcessCapabilities::HandleProgramTypeFlags(u32 flags) {
    const u32 reserved = flags >> 17;
    if (reserved != 0) {
        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
-        return ERR_RESERVED_VALUE;
+        return ResultReservedValue;
    }

    program_type = static_cast<ProgramType>((flags >> 14) & 0b111);
@@ -354,7 +354,7 @@ ResultCode ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
        LOG_ERROR(Kernel,
                  "Kernel version is non zero or flags are too small! major_version={}, flags={}",
                  major_version, flags);
-        return ERR_INVALID_CAPABILITY_DESCRIPTOR;
+        return ResultInvalidCapabilityDescriptor;
    }

    kernel_version = flags;
@@ -365,7 +365,7 @@ ResultCode ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
    const u32 reserved = flags >> 26;
    if (reserved != 0) {
        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
-        return ERR_RESERVED_VALUE;
+        return ResultReservedValue;
    }

    handle_table_size = static_cast<s32>((flags >> 16) & 0x3FF);
@@ -376,7 +376,7 @@ ResultCode ProcessCapabilities::HandleDebugFlags(u32 flags) {
    const u32 reserved = flags >> 19;
    if (reserved != 0) {
        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
-        return ERR_RESERVED_VALUE;
+        return ResultReservedValue;
    }

    is_debuggable = (flags & 0x20000) != 0;
@@ -1,52 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/k_scheduler.h"
-#include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/object.h"
-#include "core/hle/kernel/readable_event.h"
-
-namespace Kernel {
-
-ReadableEvent::ReadableEvent(KernelCore& kernel) : KSynchronizationObject{kernel} {}
-ReadableEvent::~ReadableEvent() = default;
-
-void ReadableEvent::Signal() {
-    if (is_signaled) {
-        return;
-    }
-
-    is_signaled = true;
-    NotifyAvailable();
-}
-
-bool ReadableEvent::IsSignaled() const {
-    ASSERT(kernel.GlobalSchedulerContext().IsLocked());
-
-    return is_signaled;
-}
-
-void ReadableEvent::Clear() {
-    is_signaled = false;
-}
-
-ResultCode ReadableEvent::Reset() {
-    KScopedSchedulerLock lock(kernel);
-    if (!is_signaled) {
-        LOG_TRACE(Kernel, "Handle is not signaled! object_id={}, object_type={}, object_name={}",
-                  GetObjectId(), GetTypeName(), GetName());
-        return ERR_INVALID_STATE;
-    }
-
-    Clear();
-
-    return RESULT_SUCCESS;
-}
-
-} // namespace Kernel
@@ -1,59 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/kernel/k_synchronization_object.h"
-#include "core/hle/kernel/object.h"
-
-union ResultCode;
-
-namespace Kernel {
-
-class KernelCore;
-class WritableEvent;
-
-class ReadableEvent final : public KSynchronizationObject {
-    friend class WritableEvent;
-
-public:
-    ~ReadableEvent() override;
-
-    std::string GetTypeName() const override {
-        return "ReadableEvent";
-    }
-    std::string GetName() const override {
-        return name;
-    }
-
-    static constexpr HandleType HANDLE_TYPE = HandleType::ReadableEvent;
-    HandleType GetHandleType() const override {
-        return HANDLE_TYPE;
-    }
-
-    /// Unconditionally clears the readable event's state.
-    void Clear();
-
-    /// Clears the readable event's state if and only if it
-    /// has already been signaled.
-    ///
-    /// @pre The event must be in a signaled state. If this event
-    ///      is in an unsignaled state and this function is called,
-    ///      then ERR_INVALID_STATE will be returned.
-    ResultCode Reset();
-
-    void Signal();
-
-    bool IsSignaled() const override;
-
-    void Finalize() override {}
-
-private:
-    explicit ReadableEvent(KernelCore& kernel);
-
-    bool is_signaled{};
-    std::string name; ///< Name of event (optional)
-};
-
-} // namespace Kernel
@@ -1,73 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/resource_limit.h"
-#include "core/hle/result.h"
-
-namespace Kernel {
-namespace {
-constexpr std::size_t ResourceTypeToIndex(ResourceType type) {
-    return static_cast<std::size_t>(type);
-}
-} // Anonymous namespace
-
-ResourceLimit::ResourceLimit(KernelCore& kernel) : Object{kernel} {}
-ResourceLimit::~ResourceLimit() = default;
-
-bool ResourceLimit::Reserve(ResourceType resource, s64 amount) {
-    return Reserve(resource, amount, 10000000000);
-}
-
-bool ResourceLimit::Reserve(ResourceType resource, s64 amount, u64 timeout) {
-    const std::size_t index{ResourceTypeToIndex(resource)};
-
-    s64 new_value = current[index] + amount;
-    if (new_value > limit[index] && available[index] + amount <= limit[index]) {
-        // TODO(bunnei): This is wrong for multicore, we should wait the calling thread for timeout
-        new_value = current[index] + amount;
-    }
-
-    if (new_value <= limit[index]) {
-        current[index] = new_value;
-        return true;
-    }
-    return false;
-}
-
-void ResourceLimit::Release(ResourceType resource, u64 amount) {
-    Release(resource, amount, amount);
-}
-
-void ResourceLimit::Release(ResourceType resource, u64 used_amount, u64 available_amount) {
-    const std::size_t index{ResourceTypeToIndex(resource)};
-
-    current[index] -= used_amount;
-    available[index] -= available_amount;
-}
-
-std::shared_ptr<ResourceLimit> ResourceLimit::Create(KernelCore& kernel) {
-    return std::make_shared<ResourceLimit>(kernel);
-}
-
-s64 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {
-    return limit.at(ResourceTypeToIndex(resource)) - current.at(ResourceTypeToIndex(resource));
-}
-
-s64 ResourceLimit::GetMaxResourceValue(ResourceType resource) const {
-    return limit.at(ResourceTypeToIndex(resource));
-}
-
-ResultCode ResourceLimit::SetLimitValue(ResourceType resource, s64 value) {
-    const std::size_t index{ResourceTypeToIndex(resource)};
-    if (current[index] <= value) {
-        limit[index] = value;
-        return RESULT_SUCCESS;
-    } else {
-        LOG_ERROR(Kernel, "Limit value is too large! resource={}, value={}, index={}", resource,
-                  value, index);
-        return ERR_INVALID_STATE;
-    }
-}
-} // namespace Kernel
@@ -1,106 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-
-#include "common/common_types.h"
-#include "core/hle/kernel/object.h"
-
-union ResultCode;
-
-namespace Kernel {
-
-class KernelCore;
-
-enum class ResourceType : u32 {
-    PhysicalMemory,
-    Threads,
-    Events,
-    TransferMemory,
-    Sessions,
-
-    // Used as a count, not an actual type.
-    ResourceTypeCount
-};
-
-constexpr bool IsValidResourceType(ResourceType type) {
-    return type < ResourceType::ResourceTypeCount;
-}
-
-class ResourceLimit final : public Object {
-public:
-    explicit ResourceLimit(KernelCore& kernel);
-    ~ResourceLimit() override;
-
-    /// Creates a resource limit object.
-    static std::shared_ptr<ResourceLimit> Create(KernelCore& kernel);
-
-    std::string GetTypeName() const override {
-        return "ResourceLimit";
-    }
-    std::string GetName() const override {
-        return GetTypeName();
-    }
-
-    static constexpr HandleType HANDLE_TYPE = HandleType::ResourceLimit;
-    HandleType GetHandleType() const override {
-        return HANDLE_TYPE;
-    }
-
-    bool Reserve(ResourceType resource, s64 amount);
-    bool Reserve(ResourceType resource, s64 amount, u64 timeout);
-    void Release(ResourceType resource, u64 amount);
-    void Release(ResourceType resource, u64 used_amount, u64 available_amount);
-
-    /**
-     * Gets the current value for the specified resource.
-     * @param resource Requested resource type
-     * @returns The current value of the resource type
-     */
-    s64 GetCurrentResourceValue(ResourceType resource) const;
-
-    /**
-     * Gets the max value for the specified resource.
-     * @param resource Requested resource type
-     * @returns The max value of the resource type
-     */
-    s64 GetMaxResourceValue(ResourceType resource) const;
-
-    /**
-     * Sets the limit value for a given resource type.
-     *
-     * @param resource The resource type to apply the limit to.
-     * @param value    The limit to apply to the given resource type.
-     *
-     * @return A result code indicating if setting the limit value
-     *         was successful or not.
-     *
-     * @note The supplied limit value *must* be greater than or equal to
-     *       the current resource value for the given resource type,
-     *       otherwise ERR_INVALID_STATE will be returned.
-     */
-    ResultCode SetLimitValue(ResourceType resource, s64 value);
-
-    void Finalize() override {}
-
-private:
-    // TODO(Subv): Increment resource limit current values in their respective Kernel::T::Create
-    // functions
-    //
-    // Currently we have no way of distinguishing if a Create was called by the running application,
-    // or by a service module. Approach this once we have separated the service modules into their
-    // own processes
-
-    using ResourceArray =
-        std::array<s64, static_cast<std::size_t>(ResourceType::ResourceTypeCount)>;
-
-    ResourceArray limit{};
-    ResourceArray current{};
-    ResourceArray available{};
-};
-
-} // namespace Kernel
@@ -5,11 +5,11 @@
 #include <tuple>
 #include "common/assert.h"
 #include "core/hle/kernel/client_port.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/server_port.h"
 #include "core/hle/kernel/server_session.h"
+#include "core/hle/kernel/svc_results.h"

 namespace Kernel {

@@ -18,7 +18,7 @@ ServerPort::~ServerPort() = default;

 ResultVal<std::shared_ptr<ServerSession>> ServerPort::Accept() {
    if (pending_sessions.empty()) {
-        return ERR_NOT_FOUND;
+        return ResultNotFound;
    }

    auto session = std::move(pending_sessions.back());
@@ -4,15 +4,23 @@

 #include "common/assert.h"
 #include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/session.h"

 namespace Kernel {

 Session::Session(KernelCore& kernel) : KSynchronizationObject{kernel} {}
-Session::~Session() = default;
+Session::~Session() {
+    // Release reserved resource when the Session pair was created.
+    kernel.GetSystemResourceLimit()->Release(LimitableResource::Sessions, 1);
+}

 Session::SessionPair Session::Create(KernelCore& kernel, std::string name) {
+    // Reserve a new session from the resource limit.
+    KScopedResourceReservation session_reservation(kernel.GetSystemResourceLimit(),
+                                                   LimitableResource::Sessions);
+    ASSERT(session_reservation.Succeeded());
    auto session{std::make_shared<Session>(kernel)};
    auto client_session{Kernel::ClientSession::Create(kernel, session, name + "_Client").Unwrap()};
    auto server_session{Kernel::ServerSession::Create(kernel, session, name + "_Server").Unwrap()};
@@ -21,6 +29,7 @@ Session::SessionPair Session::Create(KernelCore& kernel, std::string name) {
    session->client = client_session;
    session->server = server_session;

+    session_reservation.Commit();
    return std::make_pair(std::move(client_session), std::move(server_session));
 }

@@ -4,6 +4,7 @@

 #include "common/assert.h"
 #include "core/core.h"
+#include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/shared_memory.h"
@@ -13,7 +14,9 @@ namespace Kernel {
 SharedMemory::SharedMemory(KernelCore& kernel, Core::DeviceMemory& device_memory)
    : Object{kernel}, device_memory{device_memory} {}

-SharedMemory::~SharedMemory() = default;
+SharedMemory::~SharedMemory() {
+    kernel.GetSystemResourceLimit()->Release(LimitableResource::PhysicalMemory, size);
+}

 std::shared_ptr<SharedMemory> SharedMemory::Create(
    KernelCore& kernel, Core::DeviceMemory& device_memory, Process* owner_process,
@@ -21,6 +24,11 @@ std::shared_ptr<SharedMemory> SharedMemory::Create(
    Memory::MemoryPermission user_permission, PAddr physical_address, std::size_t size,
    std::string name) {

+    const auto resource_limit = kernel.GetSystemResourceLimit();
+    KScopedResourceReservation memory_reservation(resource_limit, LimitableResource::PhysicalMemory,
+                                                  size);
+    ASSERT(memory_reservation.Succeeded());
+
    std::shared_ptr<SharedMemory> shared_memory{
        std::make_shared<SharedMemory>(kernel, device_memory)};

@@ -32,6 +40,7 @@ std::shared_ptr<SharedMemory> SharedMemory::Create(
    shared_memory->size = size;
    shared_memory->name = name;

+    memory_reservation.Commit();
    return shared_memory;
 }

@@ -1,4 +1,4 @@
-// Copyright 2020 yuzu emulator team
+// Copyright 2018 yuzu emulator team
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

@@ -6,20 +6,36 @@

 #include "core/hle/result.h"

-namespace Kernel::Svc {
+namespace Kernel {

+// Confirmed Switch kernel error codes
+
+constexpr ResultCode ResultMaxConnectionsReached{ErrorModule::Kernel, 7};
+constexpr ResultCode ResultInvalidCapabilityDescriptor{ErrorModule::Kernel, 14};
 constexpr ResultCode ResultNoSynchronizationObject{ErrorModule::Kernel, 57};
 constexpr ResultCode ResultTerminationRequested{ErrorModule::Kernel, 59};
+constexpr ResultCode ResultInvalidSize{ErrorModule::Kernel, 101};
 constexpr ResultCode ResultInvalidAddress{ErrorModule::Kernel, 102};
+constexpr ResultCode ResultOutOfResource{ErrorModule::Kernel, 103};
+constexpr ResultCode ResultOutOfMemory{ErrorModule::Kernel, 104};
+constexpr ResultCode ResultHandleTableFull{ErrorModule::Kernel, 105};
 constexpr ResultCode ResultInvalidCurrentMemory{ErrorModule::Kernel, 106};
+constexpr ResultCode ResultInvalidMemoryPermissions{ErrorModule::Kernel, 108};
+constexpr ResultCode ResultInvalidMemoryRange{ErrorModule::Kernel, 110};
 constexpr ResultCode ResultInvalidPriority{ErrorModule::Kernel, 112};
 constexpr ResultCode ResultInvalidCoreId{ErrorModule::Kernel, 113};
 constexpr ResultCode ResultInvalidHandle{ErrorModule::Kernel, 114};
+constexpr ResultCode ResultInvalidPointer{ErrorModule::Kernel, 115};
 constexpr ResultCode ResultInvalidCombination{ErrorModule::Kernel, 116};
 constexpr ResultCode ResultTimedOut{ErrorModule::Kernel, 117};
 constexpr ResultCode ResultCancelled{ErrorModule::Kernel, 118};
+constexpr ResultCode ResultOutOfRange{ErrorModule::Kernel, 119};
 constexpr ResultCode ResultInvalidEnumValue{ErrorModule::Kernel, 120};
+constexpr ResultCode ResultNotFound{ErrorModule::Kernel, 121};
 constexpr ResultCode ResultBusy{ErrorModule::Kernel, 122};
+constexpr ResultCode ResultSessionClosedByRemote{ErrorModule::Kernel, 123};
 constexpr ResultCode ResultInvalidState{ErrorModule::Kernel, 125};
+constexpr ResultCode ResultReservedValue{ErrorModule::Kernel, 126};
+constexpr ResultCode ResultResourceLimitedExceeded{ErrorModule::Kernel, 132};

-} // namespace Kernel::Svc
+} // namespace Kernel
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process.h"
@@ -17,6 +18,7 @@ TransferMemory::TransferMemory(KernelCore& kernel, Core::Memory::Memory& memory)
 TransferMemory::~TransferMemory() {
    // Release memory region when transfer memory is destroyed
    Reset();
+    owner_process->GetResourceLimit()->Release(LimitableResource::TransferMemory, 1);
 }

 std::shared_ptr<TransferMemory> TransferMemory::Create(KernelCore& kernel,
@@ -1,41 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include "common/assert.h"
-#include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/object.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
-
-namespace Kernel {
-
-WritableEvent::WritableEvent(KernelCore& kernel) : Object{kernel} {}
-WritableEvent::~WritableEvent() = default;
-
-EventPair WritableEvent::CreateEventPair(KernelCore& kernel, std::string name) {
-    std::shared_ptr<WritableEvent> writable_event(new WritableEvent(kernel));
-    std::shared_ptr<ReadableEvent> readable_event(new ReadableEvent(kernel));
-
-    writable_event->name = name + ":Writable";
-    writable_event->readable = readable_event;
-    readable_event->name = name + ":Readable";
-
-    return {std::move(readable_event), std::move(writable_event)};
-}
-
-std::shared_ptr<ReadableEvent> WritableEvent::GetReadableEvent() const {
-    return readable;
-}
-
-void WritableEvent::Signal() {
-    readable->Signal();
-}
-
-void WritableEvent::Clear() {
-    readable->Clear();
-}
-
-} // namespace Kernel
@@ -1,60 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-
-#include "core/hle/kernel/object.h"
-
-namespace Kernel {
-
-class KernelCore;
-class ReadableEvent;
-class WritableEvent;
-
-struct EventPair {
-    std::shared_ptr<ReadableEvent> readable;
-    std::shared_ptr<WritableEvent> writable;
-};
-
-class WritableEvent final : public Object {
-public:
-    ~WritableEvent() override;
-
-    /**
-     * Creates an event
-     * @param kernel The kernel instance to create this event under.
-     * @param name Optional name of event
-     */
-    static EventPair CreateEventPair(KernelCore& kernel, std::string name = "Unknown");
-
-    std::string GetTypeName() const override {
-        return "WritableEvent";
-    }
-    std::string GetName() const override {
-        return name;
-    }
-
-    static constexpr HandleType HANDLE_TYPE = HandleType::WritableEvent;
-    HandleType GetHandleType() const override {
-        return HANDLE_TYPE;
-    }
-
-    std::shared_ptr<ReadableEvent> GetReadableEvent() const;
-
-    void Signal();
-    void Clear();
-
-    void Finalize() override {}
-
-private:
-    explicit WritableEvent(KernelCore& kernel);
-
-    std::shared_ptr<ReadableEvent> readable;
-
-    std::string name; ///< Name of event (optional)
-};
-
-} // namespace Kernel
@@ -41,12 +41,18 @@ constexpr char ACC_SAVE_AVATORS_BASE_PATH[] = "/system/save/8000000000000010/su/
 ProfileManager::ProfileManager() {
    ParseUserSaveFile();

-    if (user_count == 0)
+    // Create an user if none are present
+    if (user_count == 0) {
        CreateNewUser(UUID::Generate(), "yuzu");
+    }

    auto current = std::clamp<int>(Settings::values.current_user, 0, MAX_USERS - 1);
-    if (UserExistsIndex(current))
+
+    // If user index don't exist. Load the first user and change the active user
+    if (!UserExistsIndex(current)) {
        current = 0;
+        Settings::values.current_user = 0;
+    }

    OpenUser(*GetUser(current));
 }
@@ -13,11 +13,12 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/transfer_memory.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
@@ -303,17 +304,18 @@ ISelfController::ISelfController(Core::System& system_, NVFlinger::NVFlinger& nv
    RegisterHandlers(functions);

    auto& kernel = system.Kernel();
-    launchable_event =
-        Kernel::WritableEvent::CreateEventPair(kernel, "ISelfController:LaunchableEvent");
+    launchable_event = Kernel::KEvent::Create(kernel, "ISelfController:LaunchableEvent");
+    launchable_event->Initialize();

    // This event is created by AM on the first time GetAccumulatedSuspendedTickChangedEvent() is
    // called. Yuzu can just create it unconditionally, since it doesn't need to support multiple
    // ISelfControllers. The event is signaled on creation, and on transition from suspended -> not
    // suspended if the event has previously been created by a call to
    // GetAccumulatedSuspendedTickChangedEvent.
-    accumulated_suspended_tick_changed_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, "ISelfController:AccumulatedSuspendedTickChangedEvent");
-    accumulated_suspended_tick_changed_event.writable->Signal();
+    accumulated_suspended_tick_changed_event =
+        Kernel::KEvent::Create(kernel, "ISelfController:AccumulatedSuspendedTickChangedEvent");
+    accumulated_suspended_tick_changed_event->Initialize();
+    accumulated_suspended_tick_changed_event->GetWritableEvent()->Signal();
 }

 ISelfController::~ISelfController() = default;
@@ -372,11 +374,11 @@ void ISelfController::LeaveFatalSection(Kernel::HLERequestContext& ctx) {
 void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_AM, "(STUBBED) called");

-    launchable_event.writable->Signal();
+    launchable_event->GetWritableEvent()->Signal();

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(launchable_event.readable);
+    rb.PushCopyObjects(launchable_event->GetReadableEvent());
 }

 void ISelfController::SetScreenShotPermission(Kernel::HLERequestContext& ctx) {
@@ -555,41 +557,42 @@ void ISelfController::GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequest

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(accumulated_suspended_tick_changed_event.readable);
+    rb.PushCopyObjects(accumulated_suspended_tick_changed_event->GetReadableEvent());
 }

 AppletMessageQueue::AppletMessageQueue(Kernel::KernelCore& kernel) {
-    on_new_message =
-        Kernel::WritableEvent::CreateEventPair(kernel, "AMMessageQueue:OnMessageReceived");
+    on_new_message = Kernel::KEvent::Create(kernel, "AMMessageQueue:OnMessageReceived");
+    on_new_message->Initialize();
    on_operation_mode_changed =
-        Kernel::WritableEvent::CreateEventPair(kernel, "AMMessageQueue:OperationModeChanged");
+        Kernel::KEvent::Create(kernel, "AMMessageQueue:OperationModeChanged");
+    on_operation_mode_changed->Initialize();
 }

 AppletMessageQueue::~AppletMessageQueue() = default;

-const std::shared_ptr<Kernel::ReadableEvent>& AppletMessageQueue::GetMessageReceiveEvent() const {
-    return on_new_message.readable;
+const std::shared_ptr<Kernel::KReadableEvent>& AppletMessageQueue::GetMessageReceiveEvent() const {
+    return on_new_message->GetReadableEvent();
 }

-const std::shared_ptr<Kernel::ReadableEvent>& AppletMessageQueue::GetOperationModeChangedEvent()
+const std::shared_ptr<Kernel::KReadableEvent>& AppletMessageQueue::GetOperationModeChangedEvent()
    const {
-    return on_operation_mode_changed.readable;
+    return on_operation_mode_changed->GetReadableEvent();
 }

 void AppletMessageQueue::PushMessage(AppletMessage msg) {
    messages.push(msg);
-    on_new_message.writable->Signal();
+    on_new_message->GetWritableEvent()->Signal();
 }

 AppletMessageQueue::AppletMessage AppletMessageQueue::PopMessage() {
    if (messages.empty()) {
-        on_new_message.writable->Clear();
+        on_new_message->GetWritableEvent()->Clear();
        return AppletMessage::NoMessage;
    }
    auto msg = messages.front();
    messages.pop();
    if (messages.empty()) {
-        on_new_message.writable->Clear();
+        on_new_message->GetWritableEvent()->Clear();
    }
    return msg;
 }
@@ -601,7 +604,7 @@ std::size_t AppletMessageQueue::GetMessageCount() const {
 void AppletMessageQueue::OperationModeChanged() {
    PushMessage(AppletMessage::OperationModeChanged);
    PushMessage(AppletMessage::PerformanceModeChanged);
-    on_operation_mode_changed.writable->Signal();
+    on_operation_mode_changed->GetWritableEvent()->Signal();
 }

 void AppletMessageQueue::RequestExit() {
@@ -1044,20 +1047,21 @@ void IStorageAccessor::Write(Kernel::HLERequestContext& ctx) {

    const u64 offset{rp.Pop<u64>()};
    const std::vector<u8> data{ctx.ReadBuffer()};
+    const std::size_t size{std::min(data.size(), backing.GetSize() - offset)};

-    LOG_DEBUG(Service_AM, "called, offset={}, size={}", offset, data.size());
+    LOG_DEBUG(Service_AM, "called, offset={}, size={}", offset, size);

-    if (data.size() > backing.GetSize() - offset) {
+    if (offset > backing.GetSize()) {
        LOG_ERROR(Service_AM,
                  "offset is out of bounds, backing_buffer_sz={}, data_size={}, offset={}",
-                  backing.GetSize(), data.size(), offset);
+                  backing.GetSize(), size, offset);

        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ERR_SIZE_OUT_OF_BOUNDS);
        return;
    }

-    std::memcpy(backing.GetData().data() + offset, data.data(), data.size());
+    std::memcpy(backing.GetData().data() + offset, data.data(), size);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
@@ -1067,11 +1071,11 @@ void IStorageAccessor::Read(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

    const u64 offset{rp.Pop<u64>()};
-    const std::size_t size{ctx.GetWriteBufferSize()};
+    const std::size_t size{std::min(ctx.GetWriteBufferSize(), backing.GetSize() - offset)};

    LOG_DEBUG(Service_AM, "called, offset={}, size={}", offset, size);

-    if (size > backing.GetSize() - offset) {
+    if (offset > backing.GetSize()) {
        LOG_ERROR(Service_AM, "offset is out of bounds, backing_buffer_sz={}, size={}, offset={}",
                  backing.GetSize(), size, offset);

@@ -1192,7 +1196,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
        {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
        {50, &IApplicationFunctions::GetPseudoDeviceId, "GetPseudoDeviceId"},
        {60, nullptr, "SetMediaPlaybackStateForApplication"},
-        {65, nullptr, "IsGamePlayRecordingSupported"},
+        {65, &IApplicationFunctions::IsGamePlayRecordingSupported, "IsGamePlayRecordingSupported"},
        {66, &IApplicationFunctions::InitializeGamePlayRecording, "InitializeGamePlayRecording"},
        {67, &IApplicationFunctions::SetGamePlayRecordingState, "SetGamePlayRecordingState"},
        {68, nullptr, "RequestFlushGamePlayingMovieForDebug"},
@@ -1213,10 +1217,10 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
        {124, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
        {130, &IApplicationFunctions::GetGpuErrorDetectedSystemEvent, "GetGpuErrorDetectedSystemEvent"},
        {140, &IApplicationFunctions::GetFriendInvitationStorageChannelEvent, "GetFriendInvitationStorageChannelEvent"},
-        {141, nullptr, "TryPopFromFriendInvitationStorageChannel"},
+        {141, &IApplicationFunctions::TryPopFromFriendInvitationStorageChannel, "TryPopFromFriendInvitationStorageChannel"},
        {150, nullptr, "GetNotificationStorageChannelEvent"},
        {151, nullptr, "TryPopFromNotificationStorageChannel"},
-        {160, nullptr, "GetHealthWarningDisappearedSystemEvent"},
+        {160, &IApplicationFunctions::GetHealthWarningDisappearedSystemEvent, "GetHealthWarningDisappearedSystemEvent"},
        {170, nullptr, "SetHdcpAuthenticationActivated"},
        {180, nullptr, "GetLaunchRequiredVersion"},
        {181, nullptr, "UpgradeLaunchRequiredVersion"},
@@ -1229,11 +1233,15 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
    RegisterHandlers(functions);

    auto& kernel = system.Kernel();
-    gpu_error_detected_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, "IApplicationFunctions:GpuErrorDetectedSystemEvent");
-
-    friend_invitation_storage_channel_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, "IApplicationFunctions:FriendInvitationStorageChannelEvent");
+    gpu_error_detected_event =
+        Kernel::KEvent::Create(kernel, "IApplicationFunctions:GpuErrorDetectedSystemEvent");
+    gpu_error_detected_event->Initialize();
+    friend_invitation_storage_channel_event =
+        Kernel::KEvent::Create(kernel, "IApplicationFunctions:FriendInvitationStorageChannelEvent");
+    friend_invitation_storage_channel_event->Initialize();
+    health_warning_disappeared_system_event =
+        Kernel::KEvent::Create(kernel, "IApplicationFunctions:HealthWarningDisappearedSystemEvent");
+    health_warning_disappeared_system_event->Initialize();
 }

 IApplicationFunctions::~IApplicationFunctions() = default;
@@ -1480,6 +1488,16 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
    rb.Push(*res_code);
 }

+void IApplicationFunctions::IsGamePlayRecordingSupported(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    constexpr bool gameplay_recording_supported = false;
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(gameplay_recording_supported);
+}
+
 void IApplicationFunctions::InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_AM, "(STUBBED) called");

@@ -1620,7 +1638,7 @@ void IApplicationFunctions::GetGpuErrorDetectedSystemEvent(Kernel::HLERequestCon

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(gpu_error_detected_event.readable);
+    rb.PushCopyObjects(gpu_error_detected_event->GetReadableEvent());
 }

 void IApplicationFunctions::GetFriendInvitationStorageChannelEvent(Kernel::HLERequestContext& ctx) {
@@ -1628,7 +1646,23 @@ void IApplicationFunctions::GetFriendInvitationStorageChannelEvent(Kernel::HLERe

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(friend_invitation_storage_channel_event.readable);
+    rb.PushCopyObjects(friend_invitation_storage_channel_event->GetReadableEvent());
+}
+
+void IApplicationFunctions::TryPopFromFriendInvitationStorageChannel(
+    Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ERR_NO_DATA_IN_CHANNEL);
+}
+
+void IApplicationFunctions::GetHealthWarningDisappearedSystemEvent(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(health_warning_disappeared_system_event->GetReadableEvent());
 }

 void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
@@ -1664,8 +1698,9 @@ IHomeMenuFunctions::IHomeMenuFunctions(Core::System& system_)

    RegisterHandlers(functions);

-    pop_from_general_channel_event = Kernel::WritableEvent::CreateEventPair(
-        system.Kernel(), "IHomeMenuFunctions:PopFromGeneralChannelEvent");
+    pop_from_general_channel_event =
+        Kernel::KEvent::Create(system.Kernel(), "IHomeMenuFunctions:PopFromGeneralChannelEvent");
+    pop_from_general_channel_event->Initialize();
 }

 IHomeMenuFunctions::~IHomeMenuFunctions() = default;
@@ -1682,7 +1717,7 @@ void IHomeMenuFunctions::GetPopFromGeneralChannelEvent(Kernel::HLERequestContext

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(pop_from_general_channel_event.readable);
+    rb.PushCopyObjects(pop_from_general_channel_event->GetReadableEvent());
 }

 IGlobalStateController::IGlobalStateController(Core::System& system_)
@@ -7,11 +7,12 @@
 #include <chrono>
 #include <memory>
 #include <queue>
-#include "core/hle/kernel/writable_event.h"
+
 #include "core/hle/service/service.h"

 namespace Kernel {
 class KernelCore;
+class KEvent;
 class TransferMemory;
 } // namespace Kernel

@@ -55,8 +56,8 @@ public:
    explicit AppletMessageQueue(Kernel::KernelCore& kernel);
    ~AppletMessageQueue();

-    const std::shared_ptr<Kernel::ReadableEvent>& GetMessageReceiveEvent() const;
-    const std::shared_ptr<Kernel::ReadableEvent>& GetOperationModeChangedEvent() const;
+    const std::shared_ptr<Kernel::KReadableEvent>& GetMessageReceiveEvent() const;
+    const std::shared_ptr<Kernel::KReadableEvent>& GetOperationModeChangedEvent() const;
    void PushMessage(AppletMessage msg);
    AppletMessage PopMessage();
    std::size_t GetMessageCount() const;
@@ -65,8 +66,8 @@ public:

 private:
    std::queue<AppletMessage> messages;
-    Kernel::EventPair on_new_message;
-    Kernel::EventPair on_operation_mode_changed;
+    std::shared_ptr<Kernel::KEvent> on_new_message;
+    std::shared_ptr<Kernel::KEvent> on_operation_mode_changed;
 };

 class IWindowController final : public ServiceFramework<IWindowController> {
@@ -153,8 +154,8 @@ private:
    };

    NVFlinger::NVFlinger& nvflinger;
-    Kernel::EventPair launchable_event;
-    Kernel::EventPair accumulated_suspended_tick_changed_event;
+    std::shared_ptr<Kernel::KEvent> launchable_event;
+    std::shared_ptr<Kernel::KEvent> accumulated_suspended_tick_changed_event;

    u32 idle_time_detection_extension = 0;
    u64 num_fatal_sections_entered = 0;
@@ -266,6 +267,7 @@ private:
    void SetTerminateResult(Kernel::HLERequestContext& ctx);
    void GetDisplayVersion(Kernel::HLERequestContext& ctx);
    void GetDesiredLanguage(Kernel::HLERequestContext& ctx);
+    void IsGamePlayRecordingSupported(Kernel::HLERequestContext& ctx);
    void InitializeGamePlayRecording(Kernel::HLERequestContext& ctx);
    void SetGamePlayRecordingState(Kernel::HLERequestContext& ctx);
    void NotifyRunning(Kernel::HLERequestContext& ctx);
@@ -288,12 +290,15 @@ private:
    void GetPreviousProgramIndex(Kernel::HLERequestContext& ctx);
    void GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx);
    void GetFriendInvitationStorageChannelEvent(Kernel::HLERequestContext& ctx);
+    void TryPopFromFriendInvitationStorageChannel(Kernel::HLERequestContext& ctx);
+    void GetHealthWarningDisappearedSystemEvent(Kernel::HLERequestContext& ctx);

    bool launch_popped_application_specific = false;
    bool launch_popped_account_preselect = false;
    s32 previous_program_index{-1};
-    Kernel::EventPair gpu_error_detected_event;
-    Kernel::EventPair friend_invitation_storage_channel_event;
+    std::shared_ptr<Kernel::KEvent> gpu_error_detected_event;
+    std::shared_ptr<Kernel::KEvent> friend_invitation_storage_channel_event;
+    std::shared_ptr<Kernel::KEvent> health_warning_disappeared_system_event;
 };

 class IHomeMenuFunctions final : public ServiceFramework<IHomeMenuFunctions> {
@@ -305,7 +310,7 @@ private:
    void RequestToGetForeground(Kernel::HLERequestContext& ctx);
    void GetPopFromGeneralChannelEvent(Kernel::HLERequestContext& ctx);

-    Kernel::EventPair pop_from_general_channel_event;
+    std::shared_ptr<Kernel::KEvent> pop_from_general_channel_event;
 };

 class IGlobalStateController final : public ServiceFramework<IGlobalStateController> {
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.

 #include <cstring>
+
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/frontend/applets/controller.h"
@@ -11,9 +12,10 @@
 #include "core/frontend/applets/profile_select.h"
 #include "core/frontend/applets/software_keyboard.h"
 #include "core/frontend/applets/web_browser.h"
-#include "core/hle/kernel/readable_event.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/server_session.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/am/applets/controller.h"
@@ -27,11 +29,13 @@ namespace Service::AM::Applets {

 AppletDataBroker::AppletDataBroker(Kernel::KernelCore& kernel) {
    state_changed_event =
-        Kernel::WritableEvent::CreateEventPair(kernel, "ILibraryAppletAccessor:StateChangedEvent");
-    pop_out_data_event =
-        Kernel::WritableEvent::CreateEventPair(kernel, "ILibraryAppletAccessor:PopDataOutEvent");
-    pop_interactive_out_data_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");
+        Kernel::KEvent::Create(kernel, "ILibraryAppletAccessor:StateChangedEvent");
+    state_changed_event->Initialize();
+    pop_out_data_event = Kernel::KEvent::Create(kernel, "ILibraryAppletAccessor:PopDataOutEvent");
+    pop_out_data_event->Initialize();
+    pop_interactive_out_data_event =
+        Kernel::KEvent::Create(kernel, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");
+    pop_interactive_out_data_event->Initialize();
 }

 AppletDataBroker::~AppletDataBroker() = default;
@@ -58,7 +62,7 @@ std::shared_ptr<IStorage> AppletDataBroker::PopNormalDataToGame() {

    auto out = std::move(out_channel.front());
    out_channel.pop_front();
-    pop_out_data_event.writable->Clear();
+    pop_out_data_event->GetWritableEvent()->Clear();
    return out;
 }

@@ -77,7 +81,7 @@ std::shared_ptr<IStorage> AppletDataBroker::PopInteractiveDataToGame() {

    auto out = std::move(out_interactive_channel.front());
    out_interactive_channel.pop_front();
-    pop_interactive_out_data_event.writable->Clear();
+    pop_interactive_out_data_event->GetWritableEvent()->Clear();
    return out;
 }

@@ -96,7 +100,7 @@ void AppletDataBroker::PushNormalDataFromGame(std::shared_ptr<IStorage>&& storag

 void AppletDataBroker::PushNormalDataFromApplet(std::shared_ptr<IStorage>&& storage) {
    out_channel.emplace_back(std::move(storage));
-    pop_out_data_event.writable->Signal();
+    pop_out_data_event->GetWritableEvent()->Signal();
 }

 void AppletDataBroker::PushInteractiveDataFromGame(std::shared_ptr<IStorage>&& storage) {
@@ -105,23 +109,23 @@ void AppletDataBroker::PushInteractiveDataFromGame(std::shared_ptr<IStorage>&& s

 void AppletDataBroker::PushInteractiveDataFromApplet(std::shared_ptr<IStorage>&& storage) {
    out_interactive_channel.emplace_back(std::move(storage));
-    pop_interactive_out_data_event.writable->Signal();
+    pop_interactive_out_data_event->GetWritableEvent()->Signal();
 }

 void AppletDataBroker::SignalStateChanged() const {
-    state_changed_event.writable->Signal();
+    state_changed_event->GetWritableEvent()->Signal();
 }

-std::shared_ptr<Kernel::ReadableEvent> AppletDataBroker::GetNormalDataEvent() const {
-    return pop_out_data_event.readable;
+std::shared_ptr<Kernel::KReadableEvent> AppletDataBroker::GetNormalDataEvent() const {
+    return pop_out_data_event->GetReadableEvent();
 }

-std::shared_ptr<Kernel::ReadableEvent> AppletDataBroker::GetInteractiveDataEvent() const {
-    return pop_interactive_out_data_event.readable;
+std::shared_ptr<Kernel::KReadableEvent> AppletDataBroker::GetInteractiveDataEvent() const {
+    return pop_interactive_out_data_event->GetReadableEvent();
 }

-std::shared_ptr<Kernel::ReadableEvent> AppletDataBroker::GetStateChangedEvent() const {
-    return state_changed_event.readable;
+std::shared_ptr<Kernel::KReadableEvent> AppletDataBroker::GetStateChangedEvent() const {
+    return state_changed_event->GetReadableEvent();
 }

 Applet::Applet(Kernel::KernelCore& kernel_) : broker{kernel_} {}
@@ -6,9 +6,9 @@

 #include <memory>
 #include <queue>
+
 #include "common/swap.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/kernel/writable_event.h"

 union ResultCode;

@@ -29,7 +29,9 @@ class WebBrowserApplet;

 namespace Kernel {
 class KernelCore;
-}
+class KEvent;
+class KReadableEvent;
+} // namespace Kernel

 namespace Service::AM {

@@ -87,9 +89,9 @@ public:

    void SignalStateChanged() const;

-    std::shared_ptr<Kernel::ReadableEvent> GetNormalDataEvent() const;
-    std::shared_ptr<Kernel::ReadableEvent> GetInteractiveDataEvent() const;
-    std::shared_ptr<Kernel::ReadableEvent> GetStateChangedEvent() const;
+    std::shared_ptr<Kernel::KReadableEvent> GetNormalDataEvent() const;
+    std::shared_ptr<Kernel::KReadableEvent> GetInteractiveDataEvent() const;
+    std::shared_ptr<Kernel::KReadableEvent> GetStateChangedEvent() const;

 private:
    // Queues are named from applet's perspective
@@ -106,13 +108,13 @@ private:
    // PopInteractiveDataToGame and PushInteractiveDataFromApplet
    std::deque<std::shared_ptr<IStorage>> out_interactive_channel;

-    Kernel::EventPair state_changed_event;
+    std::shared_ptr<Kernel::KEvent> state_changed_event;

    // Signaled on PushNormalDataFromApplet
-    Kernel::EventPair pop_out_data_event;
+    std::shared_ptr<Kernel::KEvent> pop_out_data_event;

    // Signaled on PushInteractiveDataFromApplet
-    Kernel::EventPair pop_interactive_out_data_event;
+    std::shared_ptr<Kernel::KEvent> pop_interactive_out_data_event;
 };

 class Applet {
--- a/Show More
+++ b/Show More