+
diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
index 1b22c1bb..df154f43 100644
--- a/app/CMakeLists.txt
+++ b/app/CMakeLists.txt
@@ -1,21 +1,32 @@
cmake_minimum_required(VERSION 3.8)
-project(Skyline VERSION 0.3 LANGUAGES CXX)
+project(Skyline VERSION 0.3)
set(BUILD_TESTING OFF)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(source_DIR ${CMAKE_SOURCE_DIR}/src/main/cpp)
set(CMAKE_CXX_FLAGS_RELEASE "-Ofast -flto=full -Wno-unused-command-line-argument")
+if (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
+ add_compile_definitions(NDEBUG)
+endif()
+
add_subdirectory("libraries/tinyxml2")
add_subdirectory("libraries/fmt")
-set(source_DIR ${CMAKE_SOURCE_DIR}/src/main/cpp)
-
include_directories(${source_DIR}/skyline)
add_library(skyline SHARED
${source_DIR}/main.cpp
${source_DIR}/skyline/common.cpp
${source_DIR}/skyline/nce.cpp
+ ${source_DIR}/skyline/gpu.cpp
+ ${source_DIR}/skyline/gpu/display.cpp
+ ${source_DIR}/skyline/gpu/parcel.cpp
+ ${source_DIR}/skyline/gpu/devices/nvhost_ctrl.cpp
+ ${source_DIR}/skyline/gpu/devices/nvhost_ctrl_gpu.cpp
+ ${source_DIR}/skyline/gpu/devices/nvhost_channel.cpp
+ ${source_DIR}/skyline/gpu/devices/nvmap.cpp
+ ${source_DIR}/skyline/gpu/devices/nvhost_as_gpu.cpp
${source_DIR}/skyline/os.cpp
${source_DIR}/skyline/loader/nro.cpp
${source_DIR}/skyline/kernel/ipc.cpp
@@ -26,15 +37,20 @@ add_library(skyline SHARED
${source_DIR}/skyline/kernel/types/KSharedMemory.cpp
${source_DIR}/skyline/kernel/types/KTransferMemory.cpp
${source_DIR}/skyline/kernel/types/KPrivateMemory.cpp
- ${source_DIR}/skyline/kernel/services/serviceman.cpp
- ${source_DIR}/skyline/kernel/services/sm/sm.cpp
- ${source_DIR}/skyline/kernel/services/fatal/fatal.cpp
- ${source_DIR}/skyline/kernel/services/set/sys.cpp
- ${source_DIR}/skyline/kernel/services/apm/apm.cpp
- ${source_DIR}/skyline/kernel/services/am/appletOE.cpp
- ${source_DIR}/skyline/kernel/services/hid/hid.cpp
- ${source_DIR}/skyline/kernel/services/time/time.cpp
- ${source_DIR}/skyline/kernel/services/fs/fs.cpp
+ ${source_DIR}/skyline/services/serviceman.cpp
+ ${source_DIR}/skyline/services/sm/sm.cpp
+ ${source_DIR}/skyline/services/fatal/fatal.cpp
+ ${source_DIR}/skyline/services/set/sys.cpp
+ ${source_DIR}/skyline/services/apm/apm.cpp
+ ${source_DIR}/skyline/services/am/applet.cpp
+ ${source_DIR}/skyline/services/am/appletController.cpp
+ ${source_DIR}/skyline/services/hid/hid.cpp
+ ${source_DIR}/skyline/services/time/time.cpp
+ ${source_DIR}/skyline/services/fs/fs.cpp
+ ${source_DIR}/skyline/services/nvdrv/nvdrv.cpp
+ ${source_DIR}/skyline/services/nvnflinger/dispdrv.cpp
+ ${source_DIR}/skyline/services/vi/vi_m.cpp
)
-target_link_libraries(skyline fmt tinyxml2)
+
+target_link_libraries(skyline vulkan GLESv3 EGL android fmt tinyxml2)
target_compile_options(skyline PRIVATE -Wno-c++17-extensions)
diff --git a/app/build.gradle b/app/build.gradle
index 1c2bc437..671b3cf7 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -5,7 +5,7 @@ android {
buildToolsVersion '29.0.2'
defaultConfig {
applicationId "skyline.emu"
- minSdkVersion 26
+ minSdkVersion 24
targetSdkVersion 29
versionCode 3
versionName "0.3"
@@ -16,6 +16,11 @@ android {
buildTypes {
release {
debuggable true
+ externalNativeBuild {
+ cmake {
+ arguments "-DCMAKE_BUILD_TYPE=RELEASE"
+ }
+ }
minifyEnabled true
shrinkResources true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
@@ -33,11 +38,6 @@ android {
path "CMakeLists.txt"
}
}
- sourceSets {
- main {
- jni.srcDirs = ['src/main/cpp/unicorn/lib']
- }
- }
compileOptions {
sourceCompatibility = 1.8
targetCompatibility = 1.8
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index daaa672b..b4346405 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -7,15 +7,19 @@
+ tools:ignore="GoogleAppIndexingWarning">
+
diff --git a/app/src/main/cpp/main.cpp b/app/src/main/cpp/main.cpp
index e223c6f5..2b279cc4 100644
--- a/app/src/main/cpp/main.cpp
+++ b/app/src/main/cpp/main.cpp
@@ -1,47 +1,115 @@
-#include
-#include
-#include
-#include
#include "skyline/common.h"
#include "skyline/os.h"
+#include
+#include
+#include
+#include
+#include
-std::thread *EmuThread;
-bool Halt = false;
+bool Halt{};
+uint faultCount{};
+ANativeActivity *Activity{};
+ANativeWindow *Window{};
+AInputQueue *Queue{};
+std::thread *uiThread{};
-void ThreadMain(const std::string romPath, const std::string prefPath, const std::string logPath) {
- auto logger = std::make_shared(logPath);
+void GameThread(const std::string &prefPath, const std::string &logPath, const std::string &romPath) {
+ while (!Window)
+ sched_yield();
+ setpriority(PRIO_PROCESS, static_cast(getpid()), skyline::constant::PriorityAn.second);
auto settings = std::make_shared(prefPath);
+ auto logger = std::make_shared(logPath, static_cast(std::stoi(settings->GetString("log_level"))));
//settings->List(logger); // (Uncomment when you want to print out all settings strings)
auto start = std::chrono::steady_clock::now();
try {
- skyline::kernel::OS os(logger, settings);
- logger->Write(skyline::Logger::Info, "Launching ROM {}", romPath);
+ skyline::kernel::OS os(logger, settings, Window);
+ logger->Info("Launching ROM {}", romPath);
os.Execute(romPath);
- logger->Write(skyline::Logger::Info, "Emulation has ended");
+ logger->Info("Emulation has ended");
} catch (std::exception &e) {
- logger->Write(skyline::Logger::Error, e.what());
+ logger->Error(e.what());
} catch (...) {
- logger->Write(skyline::Logger::Error, "An unknown exception has occurred");
+ logger->Error("An unknown exception has occurred");
}
auto end = std::chrono::steady_clock::now();
- logger->Write(skyline::Logger::Info, "Done in: {} ms", (std::chrono::duration_cast(end - start).count()));
+ logger->Info("Done in: {} ms", (std::chrono::duration_cast(end - start).count()));
+ Window = nullptr;
+ Halt = true;
}
-extern "C" JNIEXPORT void JNICALL Java_emu_skyline_MainActivity_loadFile(JNIEnv *env, jobject instance, jstring romPathJni, jstring prefPathJni, jstring logPathJni) {
- const char *romPath = env->GetStringUTFChars(romPathJni, nullptr);
- const char *prefPath = env->GetStringUTFChars(prefPathJni, nullptr);
- const char *logPath = env->GetStringUTFChars(logPathJni, nullptr);
-
- if (EmuThread) {
- Halt = true; // This'll cause execution to stop after the next breakpoint
- EmuThread->join();
- Halt = false; // Or the current instance will halt immediately
+void UIThread(const std::string &prefPath, const std::string &logPath, const std::string &romPath) {
+ while (!Queue)
+ sched_yield();
+ std::thread gameThread(GameThread, std::string(prefPath), std::string(logPath), std::string(romPath));
+ AInputEvent *event{};
+ while (!Halt) {
+ if (AInputQueue_getEvent(Queue, &event) >= -1) {
+ if (AKeyEvent_getKeyCode(event) == AKEYCODE_BACK)
+ Halt = true;
+ AInputQueue_finishEvent(Queue, event, true);
+ }
}
-
- // Running on UI thread is not a good idea as the UI will remain unresponsive
- EmuThread = new std::thread(ThreadMain, std::string(romPath, strlen(romPath)), std::string(prefPath, strlen(prefPath)), std::string(logPath, strlen(logPath)));
-
- env->ReleaseStringUTFChars(romPathJni, romPath);
- env->ReleaseStringUTFChars(prefPathJni, prefPath);
- env->ReleaseStringUTFChars(logPathJni, logPath);
+ Queue = nullptr;
+ gameThread.join();
+ Halt = false;
+ ANativeActivity_finish(Activity);
+}
+
+void onNativeWindowCreated(ANativeActivity *activity, ANativeWindow *window) {
+ Window = window;
+}
+
+void onInputQueueCreated(ANativeActivity *activity, AInputQueue *queue) {
+ Queue = queue;
+}
+
+void onNativeWindowDestroyed(ANativeActivity *activity, ANativeWindow *window) {
+ Halt = true;
+ while (Window)
+ sched_yield();
+}
+
+void onInputQueueDestroyed(ANativeActivity *activity, AInputQueue *queue) {
+ Halt = true;
+ while (Queue)
+ sched_yield();
+}
+
+void signalHandler(int signal) {
+ syslog(LOG_ERR, "Halting program due to signal: %s", strsignal(signal));
+ if (faultCount > 2)
+ pthread_kill(uiThread->native_handle(), SIGKILL);
+ else
+ ANativeActivity_finish(Activity);
+ faultCount++;
+}
+
+JNIEXPORT void ANativeActivity_onCreate(ANativeActivity *activity, void *savedState, size_t savedStateSize) {
+ Activity = activity;
+ Halt = false;
+ faultCount = 0;
+ JNIEnv *env = activity->env;
+ jobject intent = env->CallObjectMethod(activity->clazz, env->GetMethodID(env->GetObjectClass(activity->clazz), "getIntent", "()Landroid/content/Intent;"));
+ jclass icl = env->GetObjectClass(intent);
+ jmethodID gse = env->GetMethodID(icl, "getStringExtra", "(Ljava/lang/String;)Ljava/lang/String;");
+ auto jsRom = reinterpret_cast(env->CallObjectMethod(intent, gse, env->NewStringUTF("rom")));
+ auto jsPrefs = reinterpret_cast(env->CallObjectMethod(intent, gse, env->NewStringUTF("prefs")));
+ auto jsLog = reinterpret_cast(env->CallObjectMethod(intent, gse, env->NewStringUTF("log")));
+ const char *romPath = env->GetStringUTFChars(jsRom, nullptr);
+ const char *prefPath = env->GetStringUTFChars(jsPrefs, nullptr);
+ const char *logPath = env->GetStringUTFChars(jsLog, nullptr);
+ std::signal(SIGTERM, signalHandler);
+ std::signal(SIGSEGV, signalHandler);
+ std::signal(SIGINT, signalHandler);
+ std::signal(SIGILL, signalHandler);
+ std::signal(SIGABRT, signalHandler);
+ std::signal(SIGFPE, signalHandler);
+ activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
+ activity->callbacks->onInputQueueCreated = onInputQueueCreated;
+ activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
+ activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
+ uiThread = new std::thread(UIThread, std::string(prefPath), std::string(logPath), std::string(romPath));
+ env->ReleaseStringUTFChars(jsRom, romPath);
+ env->ReleaseStringUTFChars(jsPrefs, prefPath);
+ env->ReleaseStringUTFChars(jsLog, logPath);
}
diff --git a/app/src/main/cpp/skyline/common.cpp b/app/src/main/cpp/skyline/common.cpp
index 5388004f..96b64a1a 100644
--- a/app/src/main/cpp/skyline/common.cpp
+++ b/app/src/main/cpp/skyline/common.cpp
@@ -1,4 +1,6 @@
#include "common.h"
+#include "nce.h"
+#include "gpu.h"
#include
namespace skyline {
@@ -10,37 +12,46 @@ namespace skyline {
while (elem) {
switch (elem->Value()[0]) {
case 's':
- stringMap.insert(
- std::pair(elem->FindAttribute("name")->Value(), elem->GetText()));
+ stringMap[elem->FindAttribute("name")->Value()] = elem->GetText();
break;
case 'b':
- boolMap.insert(std::pair(elem->FindAttribute("name")->Value(), elem->FindAttribute("value")->BoolValue()));
+ boolMap[elem->FindAttribute("name")->Value()] = elem->FindAttribute("value")->BoolValue();
+ break;
+ case 'i':
+ intMap[elem->FindAttribute("name")->Value()] = elem->FindAttribute("value")->IntValue();
+ break;
default:
+ syslog(LOG_ALERT, "Settings type is missing: %s for %s", elem->Value(), elem->FindAttribute("name")->Value());
break;
};
if (elem->NextSibling())
elem = elem->NextSibling()->ToElement();
- else break;
+ else
+ break;
}
pref.Clear();
}
- std::string Settings::GetString(const std::string& key) {
+ std::string Settings::GetString(const std::string &key) {
return stringMap.at(key);
}
- bool Settings::GetBool(const std::string& key) {
+ bool Settings::GetBool(const std::string &key) {
return boolMap.at(key);
}
- void Settings::List(std::shared_ptr logger) {
- for (auto& iter : stringMap)
- logger->Write(Logger::Info, "Key: {}, Value: {}, Type: String", iter.first, GetString(iter.first));
- for (auto& iter : boolMap)
- logger->Write(Logger::Info, "Key: {}, Value: {}, Type: Bool", iter.first, GetBool(iter.first));
+ int Settings::GetInt(const std::string &key) {
+ return intMap.at(key);
}
- Logger::Logger(const std::string &logPath) {
+ void Settings::List(const std::shared_ptr &logger) {
+ for (auto &iter : stringMap)
+ logger->Info("Key: {}, Value: {}, Type: String", iter.first, GetString(iter.first));
+ for (auto &iter : boolMap)
+ logger->Info("Key: {}, Value: {}, Type: Bool", iter.first, GetBool(iter.first));
+ }
+
+ Logger::Logger(const std::string &logPath, LogLevel configLevel) : configLevel(configLevel) {
logFile.open(logPath, std::ios::app);
WriteHeader("Logging started");
}
@@ -55,12 +66,18 @@ namespace skyline {
logFile.flush();
}
- void Logger::Write(const LogLevel level, const std::string& str) {
- #ifdef NDEBUG
- if (level == Debug) return;
- #endif
- syslog(levelSyslog[level], "%s", str.c_str());
- logFile << "1|" << levelStr[level] << "|" << str << "\n";
+ void Logger::Write(const LogLevel level, std::string str) {
+ syslog(levelSyslog[static_cast(level)], "%s", str.c_str());
+ for (auto &character : str)
+ if (character == '\n')
+ character = '\\';
+ logFile << "1|" << levelStr[static_cast(level)] << "|" << str << "\n";
logFile.flush();
}
+
+ DeviceState::DeviceState(kernel::OS *os, std::shared_ptr &thisProcess, std::shared_ptr &thisThread, ANativeWindow *window, std::shared_ptr settings, std::shared_ptr logger) : os(os), settings(std::move(settings)), logger(std::move(logger)), thisProcess(thisProcess), thisThread(thisThread) {
+ // We assign these later as they may use the state in their constructor and we don't want null pointers
+ nce = std::move(std::make_shared(*this));
+ gpu = std::move(std::make_shared(*this, window));
+ }
}
diff --git a/app/src/main/cpp/skyline/common.h b/app/src/main/cpp/skyline/common.h
index 5a044242..6fa826ce 100644
--- a/app/src/main/cpp/skyline/common.h
+++ b/app/src/main/cpp/skyline/common.h
@@ -14,6 +14,7 @@
#include
#include
#include
+#include
namespace skyline {
// Global typedefs
@@ -27,13 +28,13 @@ namespace skyline {
typedef __int32_t i32;
typedef __int16_t i16;
typedef __int8_t i8;
- typedef std::runtime_error exception; //!< This is used as the default exception
typedef u32 handle_t; //!< The type of an handle
namespace constant {
// Memory
constexpr u64 BaseAddr = 0x8000000; //!< The address space base
constexpr u64 MapAddr = BaseAddr + 0x80000000; //!< The address of the map region
+ constexpr u64 HeapAddr = MapAddr + 0x1000000000; //!< The address of the heap region
constexpr u64 BaseSize = 0x7FF8000000; //!< The size of the address space
constexpr u64 BaseEnd = BaseAddr + BaseSize; //!< The end of the address space
constexpr u64 MapSize = 0x1000000000; //!< The size of the map region
@@ -54,17 +55,24 @@ namespace skyline {
// Kernel
constexpr u64 MaxSyncHandles = 0x40; //!< The total amount of handles that can be passed to WaitSynchronization
constexpr handle_t BaseHandleIndex = 0xD000; // The index of the base handle
+ constexpr handle_t ThreadSelf = 0xFFFF8000; //!< This is the handle used by threads to refer to themselves
constexpr u8 DefaultPriority = 31; //!< The default priority of a process
constexpr std::pair PriorityAn = {19, -8}; //!< The range of priority for Android, taken from https://medium.com/mindorks/exploring-android-thread-priority-5d0542eebbd1
constexpr std::pair PriorityNin = {0, 63}; //!< The range of priority for the Nintendo Switch
- constexpr u32 mtxOwnerMask = 0xBFFFFFFF; //!< The mask of values which contain the owner of a mutex
+ constexpr u32 MtxOwnerMask = 0xBFFFFFFF; //!< The mask of values which contain the owner of a mutex
// IPC
constexpr size_t TlsIpcSize = 0x100; //!< The size of the IPC command buffer in a TLS slot
constexpr u8 PortSize = 0x8; //!< The size of a port name string
constexpr u32 SfcoMagic = 0x4F434653; //!< SFCO in reverse, written to IPC messages
constexpr u32 SfciMagic = 0x49434653; //!< SFCI in reverse, present in received IPC messages
- constexpr u64 PaddingSum = 0x10; //!< The sum of the padding surrounding DataPayload
+ constexpr u64 IpcPaddingSum = 0x10; //!< The sum of the padding surrounding DataPayload
constexpr handle_t BaseVirtualHandleIndex = 0x1; // The index of the base virtual handle
+ // GPU
+ constexpr u32 HandheldResolutionW = 1280; //!< The width component of the handheld resolution
+ constexpr u32 HandheldResolutionH = 720; //!< The height component of the handheld resolution
+ constexpr u32 DockedResolutionW = 1920; //!< The width component of the docked resolution
+ constexpr u32 DockedResolutionH = 1080; //!< The height component of the docked resolution
+ constexpr u32 TokenLength = 0x50; //!< The length of the token on BufferQueue parcels
// Status codes
namespace status {
constexpr u32 Success = 0x0; //!< "Success"
@@ -75,6 +83,7 @@ namespace skyline {
constexpr u32 MaxHandles = 0xEE01; //!< "Too many handles"
constexpr u32 Timeout = 0xEA01; //!< "Timeout while svcWaitSynchronization"
constexpr u32 Unimpl = 0x177202; //!< "Unimplemented behaviour"
+ constexpr u32 NoMessages = 0x680; //!< "No message available"
}
};
@@ -175,12 +184,14 @@ namespace skyline {
static constexpr int levelSyslog[4] = {LOG_ERR, LOG_WARNING, LOG_INFO, LOG_DEBUG}; //!< This corresponds to LogLevel and provides it's equivalent for syslog
public:
- enum LogLevel { Error, Warn, Info, Debug }; //!< The level of a particular log
+ enum class LogLevel { Error, Warn, Info, Debug }; //!< The level of a particular log
+ LogLevel configLevel; //!< The level of logs to write
/**
* @param logPath The path to the log file
+ * @param configLevel The minimum level of logs to write
*/
- Logger(const std::string &logPath);
+ Logger(const std::string &logPath, LogLevel configLevel);
/**
* Writes "Logging ended" as a header
@@ -198,20 +209,54 @@ namespace skyline {
* @param level The level of the log
* @param str The value to be written
*/
- void Write(const LogLevel level, const std::string &str);
+ void Write(const LogLevel level, std::string str);
/**
- * @brief Write a log to the log file with libfmt formatting
- * @param level The level of the log
+ * @brief Write an error log with libfmt formatting
* @param formatStr The value to be written, with libfmt formatting
* @param args The arguments based on format_str
*/
template
- void Write(Logger::LogLevel level, const S &formatStr, Args &&... args) {
- #ifdef NDEBUG
- if (level == Debug) return;
- #endif
- Write(level, fmt::format(formatStr, args...));
+ inline void Error(const S &formatStr, Args &&... args) {
+ if (LogLevel::Error <= configLevel) {
+ Write(LogLevel::Error, fmt::format(formatStr, args...));
+ }
+ }
+
+ /**
+ * @brief Write a debug log with libfmt formatting
+ * @param formatStr The value to be written, with libfmt formatting
+ * @param args The arguments based on format_str
+ */
+ template
+ inline void Warn(const S &formatStr, Args &&... args) {
+ if (LogLevel::Warn <= configLevel) {
+ Write(LogLevel::Warn, fmt::format(formatStr, args...));
+ }
+ }
+
+ /**
+ * @brief Write a debug log with libfmt formatting
+ * @param formatStr The value to be written, with libfmt formatting
+ * @param args The arguments based on format_str
+ */
+ template
+ inline void Info(const S &formatStr, Args &&... args) {
+ if (LogLevel::Info <= configLevel) {
+ Write(LogLevel::Info, fmt::format(formatStr, args...));
+ }
+ }
+
+ /**
+ * @brief Write a debug log with libfmt formatting
+ * @param formatStr The value to be written, with libfmt formatting
+ * @param args The arguments based on format_str
+ */
+ template
+ inline void Debug(const S &formatStr, Args &&... args) {
+ if (LogLevel::Debug <= configLevel) {
+ Write(LogLevel::Debug, fmt::format(formatStr, args...));
+ }
}
};
@@ -222,6 +267,7 @@ namespace skyline {
private:
std::map stringMap; //!< A mapping from all keys to their corresponding string value
std::map boolMap; //!< A mapping from all keys to their corresponding boolean value
+ std::map intMap; //!< A mapping from all keys to their corresponding integer value
public:
/**
@@ -243,22 +289,45 @@ namespace skyline {
*/
bool GetBool(const std::string &key);
+ /**
+ * @brief Retrieves a particular setting as a integer
+ * @param key The key of the setting
+ * @return The integer value of the setting
+ */
+ int GetInt(const std::string &key);
+
/**
* @brief Writes all settings keys and values to syslog. This function is for development purposes.
*/
- void List(std::shared_ptr logger);
+ void List(const std::shared_ptr &logger);
+ };
+
+ /**
+ * @brief This is a std::runtime_error with libfmt formatting
+ */
+ class exception : public std::runtime_error {
+ public:
+ /**
+ * @param formatStr The exception string to be written, with libfmt formatting
+ * @param args The arguments based on format_str
+ */
+ template
+ inline exception(const S &formatStr, Args &&... args) : runtime_error(fmt::format(formatStr, args...)) {}
};
/**
* @brief Returns the current time in nanoseconds
* @return The current time in nanoseconds
*/
- inline long long int GetCurrTimeNs() {
- return std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+ inline u64 GetCurrTimeNs() {
+ return static_cast(std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
}
// Predeclare some classes here as we use them in DeviceState
class NCE;
+ namespace gpu {
+ class GPU;
+ }
namespace kernel {
namespace type {
class KProcess;
@@ -271,12 +340,13 @@ namespace skyline {
* @brief This struct is used to hold the state of a device
*/
struct DeviceState {
- DeviceState(kernel::OS *os, std::shared_ptr &thisProcess, std::shared_ptr &thisThread, std::shared_ptr nce, std::shared_ptr settings, std::shared_ptr logger) : os(os), nce(nce), settings(settings), logger(logger), thisProcess(thisProcess), thisThread(thisThread) {}
+ DeviceState(kernel::OS *os, std::shared_ptr &thisProcess, std::shared_ptr &thisThread, ANativeWindow *window, std::shared_ptr settings, std::shared_ptr logger);
kernel::OS *os; //!< This holds a reference to the OS class
std::shared_ptr &thisProcess; //!< This holds a reference to the current process object
std::shared_ptr &thisThread; //!< This holds a reference to the current thread object
std::shared_ptr nce; //!< This holds a reference to the NCE class
+ std::shared_ptr gpu; //!< This holds a reference to the GPU class
std::shared_ptr settings; //!< This holds a reference to the Settings class
std::shared_ptr logger; //!< This holds a reference to the Logger class
};
diff --git a/app/src/main/cpp/skyline/gpu.cpp b/app/src/main/cpp/skyline/gpu.cpp
new file mode 100644
index 00000000..80d3f214
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu.cpp
@@ -0,0 +1,163 @@
+#include "gpu.h"
+#include "gpu/devices/nvhost_ctrl.h"
+#include "gpu/devices/nvhost_ctrl_gpu.h"
+#include "gpu/devices/nvhost_channel.h"
+#include "gpu/devices/nvhost_as_gpu.h"
+#include
+
+extern bool Halt;
+
+namespace skyline::gpu {
+ GPU::GPU(const DeviceState &state, ANativeWindow *window) : state(state), window(window), bufferQueue(state), vsyncEvent(std::make_shared(state)), bufferEvent(std::make_shared(state)) {
+ ANativeWindow_acquire(window);
+ resolution.width = static_cast(ANativeWindow_getWidth(window));
+ resolution.height = static_cast(ANativeWindow_getHeight(window));
+ }
+
+ GPU::~GPU() {
+ ANativeWindow_release(window);
+ }
+
+ void GPU::Loop() {
+ if (!bufferQueue.displayQueue.empty()) {
+ auto &buffer = bufferQueue.displayQueue.front();
+ bufferQueue.displayQueue.pop();
+ if (resolution != buffer->resolution || buffer->gbpBuffer.format != format) {
+ if (resolution != buffer->resolution && buffer->gbpBuffer.format != format) {
+ ANativeWindow_setBuffersGeometry(window, buffer->resolution.width, buffer->resolution.height, buffer->gbpBuffer.format);
+ resolution = buffer->resolution;
+ format = buffer->gbpBuffer.format;
+ } else if (resolution != buffer->resolution) {
+ ANativeWindow_setBuffersGeometry(window, buffer->resolution.width, buffer->resolution.height, format);
+ resolution = buffer->resolution;
+ } else if (buffer->gbpBuffer.format != format) {
+ ANativeWindow_setBuffersGeometry(window, resolution.width, resolution.height, buffer->gbpBuffer.format);
+ format = buffer->gbpBuffer.format;
+ }
+ }
+ buffer->UpdateBuffer();
+ auto bufferData = buffer->dataBuffer.data();
+ //madvise(bufferData, buffer->gbpBuffer.size, MADV_SEQUENTIAL); (Uncomment this after deswizzling while reading sequentially instead of writing sequentially)
+ ANativeWindow_Buffer windowBuffer;
+ ARect rect;
+ ANativeWindow_lock(window, &windowBuffer, &rect);
+ u32 *address = reinterpret_cast(windowBuffer.bits);
+ for (u32 y = 0; y < buffer->resolution.height; y++) {
+ for (u32 x = 0; x < buffer->resolution.width; x += 4, address += 4) {
+ u32 position = (y & 0x7f) >> 4U;
+ position += (x >> 4U) << 3U;
+ position += (y >> 7U) * ((resolution.width >> 4U) << 3U);
+ position *= 1024;
+ position += ((y & 0xf) >> 3U) << 9U;
+ position += ((x & 0xf) >> 3U) << 8U;
+ position += ((y & 0x7) >> 1U) << 6U;
+ position += ((x & 0x7) >> 2U) << 5U;
+ position += (y & 0x1) << 4U;
+ position += (x & 0x3) << 2U;
+ std::memcpy(address, bufferData + position, sizeof(u32) * 4);
+ }
+ }
+ ANativeWindow_unlockAndPost(window);
+ bufferQueue.FreeBuffer(buffer->slot);
+ vsyncEvent->Signal();
+ if (prevTime != 0) {
+ auto now = std::chrono::duration_cast(std::chrono::steady_clock::now().time_since_epoch()).count();
+ state.logger->Error("{} ms, {} FPS", (now - prevTime) / 1000, 1000000 / (now - prevTime));
+ }
+ prevTime = std::chrono::duration_cast(std::chrono::steady_clock::now().time_since_epoch()).count();
+ }
+ }
+
+ u32 GPU::OpenDevice(const std::string &path) {
+ state.logger->Debug("Opening NVDRV device ({}): {}", fdIndex, path);
+ auto type = device::nvDeviceMap.at(path);
+ for (const auto &device : fdMap) {
+ if (device.second->deviceType == type) {
+ device.second->refCount++;
+ fdMap[fdIndex] = device.second;
+ return fdIndex++;
+ }
+ }
+ std::shared_ptr object;
+ switch (type) {
+ case (device::NvDeviceType::nvhost_ctrl):
+ object = std::make_shared(state);
+ break;
+ case (device::NvDeviceType::nvhost_gpu):
+ case (device::NvDeviceType::nvhost_vic):
+ case (device::NvDeviceType::nvhost_nvdec):
+ object = std::make_shared(state, type);
+ break;
+ case (device::NvDeviceType::nvhost_ctrl_gpu):
+ object = std::make_shared(state);
+ break;
+ case (device::NvDeviceType::nvmap):
+ object = std::make_shared(state);
+ break;
+ case (device::NvDeviceType::nvhost_as_gpu):
+ object = std::make_shared(state);
+ break;
+ default:
+ throw exception("Cannot find NVDRV device");
+ }
+ deviceMap[type] = object;
+ fdMap[fdIndex] = object;
+ return fdIndex++;
+ }
+
+ void GPU::CloseDevice(u32 fd) {
+ state.logger->Debug("Closing NVDRV device ({})", fd);
+ try {
+ auto device = fdMap.at(fd);
+ if (!--device->refCount)
+ deviceMap.erase(device->deviceType);
+ fdMap.erase(fd);
+ } catch (const std::out_of_range &) {
+ state.logger->Warn("Trying to close non-existent FD");
+ }
+ }
+
+ void GPU::Ioctl(u32 fd, u32 cmd, kernel::ipc::IpcRequest &request, kernel::ipc::IpcResponse &response) {
+ state.logger->Debug("IOCTL on device: 0x{:X}, cmd: 0x{:X}", fd, cmd);
+ try {
+ if (!request.vecBufA.empty() && !request.vecBufB.empty()) {
+ device::IoctlBuffers input(device::InputBuffer(request.vecBufA[0]), device::OutputBuffer(request.vecBufB[0]));
+ fdMap.at(fd)->HandleIoctl(cmd, input);
+ response.WriteValue(input.status);
+ } else if (!request.vecBufX.empty() && !request.vecBufC.empty()) {
+ device::IoctlBuffers input(device::InputBuffer(request.vecBufX[0]), device::OutputBuffer(request.vecBufC[0]));
+ fdMap.at(fd)->HandleIoctl(cmd, input);
+ response.WriteValue(input.status);
+ } else if (!request.vecBufX.empty()) {
+ device::IoctlBuffers input(device::InputBuffer(request.vecBufX[0]));
+ fdMap.at(fd)->HandleIoctl(cmd, input);
+ response.WriteValue(input.status);
+ } else if (!request.vecBufC.empty()) {
+ device::IoctlBuffers input(device::OutputBuffer(request.vecBufC[0]));
+ fdMap.at(fd)->HandleIoctl(cmd, input);
+ response.WriteValue(input.status);
+ } else
+ throw exception("Unknown IOCTL buffer configuration");
+ } catch (const std::out_of_range &) {
+ throw exception("IOCTL was requested on an invalid file descriptor");
+ }
+ }
+
+ void GPU::SetDisplay(const std::string &name) {
+ try {
+ const auto type = displayTypeMap.at(name);
+ if (displayId == DisplayId::Null)
+ displayId = type;
+ else
+ throw exception("Trying to change display type from non-null type");
+ } catch (const std::out_of_range &) {
+ throw exception("The display with name: '{}' doesn't exist", name);
+ }
+ }
+
+ void GPU::CloseDisplay() {
+ if (displayId == DisplayId::Null)
+ state.logger->Warn("Trying to close uninitiated display");
+ displayId = DisplayId::Null;
+ }
+}
diff --git a/app/src/main/cpp/skyline/gpu.h b/app/src/main/cpp/skyline/gpu.h
new file mode 100644
index 00000000..318442f9
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu.h
@@ -0,0 +1,112 @@
+#pragma once
+
+#include "kernel/ipc.h"
+#include "kernel/types/KEvent.h"
+#include "gpu/display.h"
+#include "gpu/devices/nvdevice.h"
+
+namespace skyline::gpu {
+ /**
+ * @brief This is used to converge all of the interfaces to the GPU and send the results to a GPU API
+ * @note We opted for just supporting a single layer and display as it's what basically all games use and wasting cycles on it is pointless
+ */
+ class GPU {
+ private:
+ ANativeWindow *window; //!< The ANativeWindow to render to
+ const DeviceState &state; //!< The state of the device
+ u32 fdIndex{}; //!< Holds the index of a file descriptor
+ std::unordered_map> deviceMap; //!< A map from a NvDeviceType to the NvDevice object
+ std::unordered_map> fdMap; //!< A map from an FD to a shared pointer to it's NvDevice object
+ double prevTime{};
+
+ public:
+ DisplayId displayId{DisplayId::Null}; //!< The ID of this display
+ LayerStatus layerStatus{LayerStatus::Uninitialized}; //!< This is the status of the single layer the display has
+ BufferQueue bufferQueue; //!< This holds all of the buffers to be pushed onto the display
+ Resolution resolution{}; //!< The resolution of the display window
+ i32 format{}; //!< The format of the display window
+ std::shared_ptr vsyncEvent; //!< This KEvent is triggered every time a frame is drawn
+ std::shared_ptr bufferEvent; //!< This KEvent is triggered every time a buffer is freed
+
+ /**
+ * @param window The ANativeWindow to render to
+ */
+ GPU(const DeviceState &state, ANativeWindow *window);
+
+ /**
+ * @brief The destructor for the GPU class
+ */
+ ~GPU();
+
+ /**
+ * @brief The loop that executes routine GPU functions
+ */
+ void Loop();
+
+ /**
+ * @brief Open a specific device and return a FD
+ * @param path The path of the device to open an FD to
+ * @return The file descriptor to the device
+ */
+ u32 OpenDevice(const std::string &path);
+
+ /**
+ * @brief Close the specified FD
+ * @param fd The file descriptor to close
+ */
+ void CloseDevice(u32 fd);
+
+ /**
+ * @brief Returns a particular device with a specific FD
+ * @tparam objectClass The class of the device to return
+ * @param fd The file descriptor to retrieve
+ * @return A shared pointer to the device
+ */
+ template
+ std::shared_ptr GetDevice(u32 fd) {
+ try {
+ auto item = fdMap.at(fd);
+ return std::static_pointer_cast(item);
+ } catch (std::out_of_range) {
+ throw exception("GetDevice was called with invalid file descriptor: 0x{:X}", fd);
+ }
+ }
+
+ /**
+ * @brief Returns a particular device with a specific type
+ * @tparam objectClass The class of the device to return
+ * @param type The type of the device to return
+ * @return A shared pointer to the device
+ */
+ template
+ std::shared_ptr GetDevice(device::NvDeviceType type) {
+ try {
+ auto item = deviceMap.at(type);
+ return std::static_pointer_cast(item);
+ } catch (std::out_of_range) {
+ throw exception("GetDevice was called with invalid type: 0x{:X}", type);
+ }
+ }
+
+ /**
+ * @brief Process an Ioctl request to a device
+ * @param fd The file descriptor the Ioctl was issued to
+ * @param cmd The command of the Ioctl
+ * @param request The IPC request object
+ * @param response The IPC response object
+ */
+ void Ioctl(u32 fd, u32 cmd, kernel::ipc::IpcRequest &request, kernel::ipc::IpcResponse &response);
+
+ /**
+ * @brief This sets displayId to a specific display type
+ * @param name The name of the display
+ * @note displayId has to be DisplayId::Null or this will throw an exception
+ */
+ void SetDisplay(const std::string &name);
+
+ /**
+ * @brief This closes the display by setting displayId to DisplayId::Null
+ */
+ void CloseDisplay();
+ };
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvdevice.h b/app/src/main/cpp/skyline/gpu/devices/nvdevice.h
new file mode 100644
index 00000000..e91d1dd6
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvdevice.h
@@ -0,0 +1,227 @@
+#pragma once
+
+#include
+#include
+
+#define NFUNC(function) std::bind(&function, this, std::placeholders::_1)
+
+namespace skyline::gpu::device {
+ /**
+ * @brief An enumeration of all the devices that can be opened by nvdrv
+ */
+ enum class NvDeviceType {
+ nvhost_ctrl, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhost-ctrl
+ nvhost_gpu, //!< https://switchbrew.org/wiki/NV_services#Channels
+ nvhost_nvdec, //!< https://switchbrew.org/wiki/NV_services#Channels
+ nvhost_vic, //!< https://switchbrew.org/wiki/NV_services#Channels
+ nvmap, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvmap
+ nvdisp_ctrl, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvdisp-ctrl
+ nvdisp_disp0, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvdisp-disp0.2C_.2Fdev.2Fnvdisp-disp1
+ nvdisp_disp1, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvdisp-disp0.2C_.2Fdev.2Fnvdisp-disp1
+ nvcec_ctrl, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvcec-ctrl
+ nvhdcp_up_ctrl, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhdcp_up-ctrl
+ nvdcutil_disp0, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvdcutil-disp0.2C_.2Fdev.2Fnvdcutil-disp1
+ nvdcutil_disp1, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvdcutil-disp0.2C_.2Fdev.2Fnvdcutil-disp1
+ nvsched_ctrl, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvsched-ctrl
+ nverpt_ctrl, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnverpt-ctrl
+ nvhost_as_gpu, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhost-as-gpu
+ nvhost_dbg_gpu, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhost-dbg-gpu
+ nvhost_prof_gpu, //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhost-prof-gpu
+ nvhost_ctrl_gpu //!< https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhost-ctrl-gpu
+ };
+
+ /**
+ * @brief A mapping from a device's path to it's nvDevice entry
+ */
+ const static std::unordered_map nvDeviceMap{
+ {"/dev/nvhost-ctrl", NvDeviceType::nvhost_ctrl},
+ {"/dev/nvhost-gpu", NvDeviceType::nvhost_gpu},
+ {"/dev/nvhost-nvdec", NvDeviceType::nvhost_nvdec},
+ {"/dev/nvhost-vic", NvDeviceType::nvhost_vic},
+ {"/dev/nvmap", NvDeviceType::nvmap},
+ {"/dev/nvdisp-ctrl", NvDeviceType::nvdisp_ctrl},
+ {"/dev/nvdisp-disp0", NvDeviceType::nvdisp_disp0},
+ {"/dev/nvdisp-disp1", NvDeviceType::nvdisp_disp1},
+ {"/dev/nvcec-ctrl", NvDeviceType::nvcec_ctrl},
+ {"/dev/nvhdcp_up-ctrl", NvDeviceType::nvhdcp_up_ctrl},
+ {"/dev/nvdcutil-disp0", NvDeviceType::nvdcutil_disp0},
+ {"/dev/nvdcutil-disp1", NvDeviceType::nvdcutil_disp1},
+ {"/dev/nvsched-ctrl", NvDeviceType::nvsched_ctrl},
+ {"/dev/nverpt-ctrl", NvDeviceType::nverpt_ctrl},
+ {"/dev/nvhost-as-gpu", NvDeviceType::nvhost_as_gpu},
+ {"/dev/nvhost-dbg-gpu", NvDeviceType::nvhost_dbg_gpu},
+ {"/dev/nvhost-prof-gpu", NvDeviceType::nvhost_prof_gpu},
+ {"/dev/nvhost-ctrl-gpu", NvDeviceType::nvhost_ctrl_gpu}
+ };
+
+ /**
+ * @brief Describes a buffer by holding the address and size
+ */
+ struct IoctlBuffer {
+ u64 address; //!< The address of the buffer
+ size_t size; //!< The size of the buffer
+
+ /**
+ * @param address The address of the buffer
+ * @param size The size of the buffer
+ */
+ IoctlBuffer(u64 address, size_t size) : address(address), size(size) {}
+ };
+
+ /**
+ * @brief Wrapper around IoctlBuffer that loads in the address from a A Buffer Descriptor
+ */
+ struct InputBuffer : public IoctlBuffer {
+ /**
+ * @param aBuf The A Buffer Descriptor that has contains the input data
+ */
+ InputBuffer(kernel::ipc::BufferDescriptorABW *aBuf) : IoctlBuffer(aBuf->Address(), aBuf->Size()) {}
+
+ /**
+ * @param aBuf The X Buffer Descriptor that has contains the input data
+ */
+ InputBuffer(kernel::ipc::BufferDescriptorX *xBuf) : IoctlBuffer(xBuf->Address(), xBuf->size) {}
+ };
+
+ /**
+ * @brief Wrapper around IoctlBuffer that loads in the address from a B Buffer Descriptor
+ */
+ struct OutputBuffer : public IoctlBuffer {
+ /**
+ * @param aBuf The B Buffer Descriptor that has to be outputted to
+ */
+ OutputBuffer(kernel::ipc::BufferDescriptorABW *bBuf) : IoctlBuffer(bBuf->Address(), bBuf->Size()) {}
+
+ /**
+ * @param xBuf The C Buffer Descriptor that has to be outputted to
+ */
+ OutputBuffer(kernel::ipc::BufferDescriptorC *cBuf) : IoctlBuffer(cBuf->address, cBuf->size) {}
+ };
+
+ /**
+ * @brief This enumerates all the possible error codes returned by the Nvidia driver (https://switchbrew.org/wiki/NV_services#Errors)
+ */
+ enum NvStatus : u32 {
+ Success = 0x0, //!< The operation has succeeded
+ NotImplemented = 0x1, //!< The operation is not implemented
+ NotSupported = 0x2, //!< The operation is not supported
+ NotInitialized = 0x3, //!< The operation uses an uninitialized object
+ BadParameter = 0x4, //!< The operation was provided a bad parameter
+ Timeout = 0x5, //!< The operation has timed out
+ InsufficientMemory = 0x6, //!< The device ran out of memory during the operation
+ ReadOnlyAttribute = 0x7, //!< The mutating operation was performed on a read only section
+ InvalidState = 0x8, //!< The state of the device was invalid
+ InvalidAddress = 0x9, //!< The provided address is invalid
+ InvalidSize = 0xA, //!< The provided size is invalid
+ BadValue = 0xB, //!< The operation was provided a bad value
+ AlreadyAllocated = 0xD, //!< An object was tried to be reallocated
+ Busy = 0xE, //!< The device is busy
+ ResourceError = 0xF, //!< There was an error accessing the resource
+ CountMismatch = 0x10, //!< ?
+ SharedMemoryTooSmall = 0x1000, //!< The shared memory segment is too small
+ FileOperationFailed = 0x30003, //!< The file operation has failed
+ DirOperationFailed = 0x30004, //!< The directory operation has failed
+ IoctlFailed = 0x3000F, //!< The IOCTL operation has failed
+ AccessDenied = 0x30010, //!< The access to a resource was denied
+ FileNotFound = 0x30013, //!< A file was not found
+ ModuleNotPresent = 0xA000E, //!< A module was not present
+ };
+
+ /**
+ * @brief This holds all the IoctlBuffer objects in a coherent container
+ */
+ struct IoctlBuffers {
+ std::vector input; //!< A vector of all input IOCTL buffers
+ std::vector output; //!< A vector of all output IOCTL buffers
+ NvStatus status{NvStatus::Success}; //!< The error code that is returned to the application
+
+ /**
+ * @brief This constructor takes 1 input buffer and 1 output buffer, it's used for Ioctl
+ * @param input An input buffer
+ * @param output An output buffer
+ */
+ IoctlBuffers(InputBuffer input, OutputBuffer output) : input({input}), output({output}) {}
+
+ /**
+ * @brief This constructor takes 1 input buffer, it's used for Ioctl sometimes
+ * @param output An output buffer
+ */
+ IoctlBuffers(InputBuffer input) : input({input}) {}
+
+ /**
+ * @brief This constructor takes 1 output buffer, it's used for Ioctl sometimes
+ * @param output An output buffer
+ */
+ IoctlBuffers(OutputBuffer output) : output({output}) {}
+
+ /**
+ * @brief This constructor takes 2 input buffers and 1 output buffer, it's used for Ioctl1
+ * @param input1 The first input buffer
+ * @param input2 The second input buffer
+ * @param output An output buffer
+ */
+ IoctlBuffers(InputBuffer input1, InputBuffer input2, OutputBuffer output) : input({input1, input2}), output({output}) {}
+
+ /**
+ * @brief This constructor takes 1 input buffer and 2 output buffers, it's used for Ioctl2
+ * @param input An input buffer
+ * @param output1 The first output buffer
+ * @param output2 The second output buffer
+ */
+ IoctlBuffers(InputBuffer input, OutputBuffer output1, OutputBuffer output2) : input({input}), output({output1, output2}) {}
+ };
+
+ /**
+ * @brief NvDevice is the base class all /dev/nv* devices inherit from
+ */
+ class NvDevice {
+ protected:
+ const DeviceState &state; //!< The state of the device
+ std::unordered_map> vTable; //!< This holds the mapping from an Ioctl to the actual function
+
+ public:
+ u16 refCount{1}; //!< The amount of handles to the device
+ NvDeviceType deviceType; //!< The type of the device
+
+ /**
+ * @param state The state of the device
+ * @param deviceType The type of the device
+ * @param vTable The functions in this device
+ */
+ NvDevice(const DeviceState &state, NvDeviceType deviceType, std::unordered_map> vTable) : state(state), deviceType(deviceType), vTable(vTable) {}
+
+ /**
+ * @brief This returns the name of the current service
+ * @note It may not return the exact name the service was initialized with if there are multiple entries in ServiceString
+ * @return The name of the service
+ */
+ std::string getName() {
+ std::string serviceName;
+ for (const auto&[name, type] : nvDeviceMap)
+ if (type == deviceType)
+ serviceName = name;
+ return serviceName;
+ }
+
+ /**
+ * @brief This handles IOCTL calls for devices
+ * @param cmd The IOCTL command that was called
+ * @param input The input to the IOCTL call
+ */
+ void HandleIoctl(u32 cmd, IoctlBuffers &input) {
+ std::function function;
+ try {
+ function = vTable.at(cmd);
+ } catch (std::out_of_range &) {
+ state.logger->Warn("Cannot find IOCTL for device '{}': 0x{:X}", getName(), deviceType, cmd);
+ input.status = NvStatus::NotImplemented;
+ return;
+ }
+ try {
+ function(input);
+ } catch (std::exception &e) {
+ throw exception("{} (Device: {})", e.what(), getName());
+ }
+ }
+ };
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvhost_as_gpu.cpp b/app/src/main/cpp/skyline/gpu/devices/nvhost_as_gpu.cpp
new file mode 100644
index 00000000..de427864
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvhost_as_gpu.cpp
@@ -0,0 +1,5 @@
+#include "nvhost_as_gpu.h"
+
+namespace skyline::gpu::device {
+ NvHostAsGpu::NvHostAsGpu(const DeviceState &state) : NvDevice(state, NvDeviceType::nvhost_as_gpu, {}) {}
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvhost_as_gpu.h b/app/src/main/cpp/skyline/gpu/devices/nvhost_as_gpu.h
new file mode 100644
index 00000000..8e596da1
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvhost_as_gpu.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "nvdevice.h"
+
+namespace skyline::gpu::device {
+ /**
+ * @brief NvHostAsGpu (/dev/nvhost-as-gpu) is used to access GPU virtual address spaces (https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhost-as-gpu)
+ */
+ class NvHostAsGpu : public NvDevice {
+ public:
+ NvHostAsGpu(const DeviceState &state);
+ };
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvhost_channel.cpp b/app/src/main/cpp/skyline/gpu/devices/nvhost_channel.cpp
new file mode 100644
index 00000000..66120478
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvhost_channel.cpp
@@ -0,0 +1,42 @@
+#include "nvhost_channel.h"
+#include
+
+namespace skyline::gpu::device {
+ NvHostChannel::NvHostChannel(const DeviceState &state, NvDeviceType type) : NvDevice(state, type, {
+ {0x40044801, NFUNC(NvHostChannel::SetNvmapFd)},
+ {0xC0104809, NFUNC(NvHostChannel::AllocObjCtx)},
+ {0xC010480B, NFUNC(NvHostChannel::ZcullBind)},
+ {0xC018480C, NFUNC(NvHostChannel::SetErrorNotifier)},
+ {0x4004480D, NFUNC(NvHostChannel::SetPriority)},
+ {0xC020481A, NFUNC(NvHostChannel::AllocGpfifoEx2)},
+ {0x40084714, NFUNC(NvHostChannel::SetUserData)}
+ }) {}
+
+ void NvHostChannel::SetNvmapFd(skyline::gpu::device::IoctlBuffers &buffer) {}
+
+ void NvHostChannel::AllocObjCtx(skyline::gpu::device::IoctlBuffers &buffer) {}
+
+ void NvHostChannel::ZcullBind(IoctlBuffers &buffer) {}
+
+ void NvHostChannel::SetErrorNotifier(skyline::gpu::device::IoctlBuffers &buffer) {}
+
+ void NvHostChannel::SetPriority(skyline::gpu::device::IoctlBuffers &buffer) {
+ auto priority = state.thisProcess->ReadMemory(buffer.input[0].address);
+ switch (priority) {
+ case NvChannelPriority::Low:
+ timeslice = 1300;
+ break;
+ case NvChannelPriority::Medium:
+ timeslice = 2600;
+ break;
+ case NvChannelPriority::High:
+ timeslice = 5200;
+ break;
+ }
+ }
+
+ void NvHostChannel::AllocGpfifoEx2(skyline::gpu::device::IoctlBuffers &buffer) {}
+
+ void NvHostChannel::SetUserData(skyline::gpu::device::IoctlBuffers &buffer) {}
+
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvhost_channel.h b/app/src/main/cpp/skyline/gpu/devices/nvhost_channel.h
new file mode 100644
index 00000000..a9511076
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvhost_channel.h
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "nvdevice.h"
+
+namespace skyline::gpu::device {
+ /**
+ * @brief NvHostChannel is used as a common interface for all Channel devices (https://switchbrew.org/wiki/NV_services#Channels)
+ */
+ class NvHostChannel : public NvDevice {
+ private:
+ enum class NvChannelPriority : u32 {
+ Low = 0x32,
+ Medium = 0x64,
+ High = 0x94
+ };
+
+ u32 timeslice{};
+
+ public:
+ NvHostChannel(const DeviceState &state, NvDeviceType type);
+
+ /**
+ * @brief This sets the nvmap file descriptor (https://switchbrew.org/wiki/NV_services#NVGPU_IOCTL_CHANNEL_SET_NVMAP_FD)
+ */
+ void SetNvmapFd(IoctlBuffers &buffer);
+
+ /**
+ * @brief This allocates a graphic context object (https://switchbrew.org/wiki/NV_services#NVGPU_IOCTL_CHANNEL_ALLOC_OBJ_CTX)
+ */
+ void AllocObjCtx(IoctlBuffers &buffer);
+
+ /**
+ * @brief This initializes the error notifier for this channel (https://switchbrew.org/wiki/NV_services#NVGPU_IOCTL_CHANNEL_ZCULL_BIND)
+ */
+ void ZcullBind(IoctlBuffers &buffer);
+
+ /**
+ * @brief This initializes the error notifier for this channel (https://switchbrew.org/wiki/NV_services#NVGPU_IOCTL_CHANNEL_SET_ERROR_NOTIFIER)
+ */
+ void SetErrorNotifier(IoctlBuffers &buffer);
+
+ /**
+ * @brief This sets the priority of the channel (https://switchbrew.org/wiki/NV_services#NVGPU_IOCTL_CHANNEL_SET_PRIORITY)
+ */
+ void SetPriority(IoctlBuffers &buffer);
+
+ /**
+ * @brief This allocates a GPFIFO entry (https://switchbrew.org/wiki/NV_services#NVGPU_IOCTL_CHANNEL_ALLOC_GPFIFO_EX2)
+ */
+ void AllocGpfifoEx2(IoctlBuffers &buffer);
+
+ /**
+ * @brief This sets the user specific data (https://switchbrew.org/wiki/NV_services#NVGPU_IOCTL_CHANNEL_SET_USER_DATA)
+ */
+ void SetUserData(IoctlBuffers &buffer);
+ };
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl.cpp b/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl.cpp
new file mode 100644
index 00000000..e38a04a9
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl.cpp
@@ -0,0 +1,5 @@
+#include "nvhost_ctrl.h"
+
+namespace skyline::gpu::device {
+ NvHostCtrl::NvHostCtrl(const DeviceState &state) : NvDevice(state, NvDeviceType::nvhost_ctrl, {}) {}
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl.h b/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl.h
new file mode 100644
index 00000000..e7422905
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "nvdevice.h"
+
+namespace skyline::gpu::device {
+ /**
+ * @brief NvHostCtrl (/dev/nvhost-ctrl) is used for GPU synchronization (https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhost-ctrl)
+ */
+ class NvHostCtrl : public NvDevice {
+ public:
+ NvHostCtrl(const DeviceState &state);
+ };
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl_gpu.cpp b/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl_gpu.cpp
new file mode 100644
index 00000000..0740ae14
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl_gpu.cpp
@@ -0,0 +1,138 @@
+#include "nvhost_ctrl_gpu.h"
+#include
+
+namespace skyline::gpu::device {
+ NvHostCtrlGpu::NvHostCtrlGpu(const DeviceState &state) : NvDevice(state, NvDeviceType::nvhost_ctrl_gpu, {
+ {0x80044701, NFUNC(NvHostCtrlGpu::ZCullGetCtxSize)},
+ {0x80284702, NFUNC(NvHostCtrlGpu::ZCullGetInfo)},
+ {0xC0184706, NFUNC(NvHostCtrlGpu::GetTpcMasks)},
+ {0xC0B04705, NFUNC(NvHostCtrlGpu::GetCharacteristics)},
+ {0x80084714, NFUNC(NvHostCtrlGpu::GetActiveSlotMask)}
+ }) {}
+
+ void NvHostCtrlGpu::ZCullGetCtxSize(IoctlBuffers &buffer) {
+ u32 size = 0x1;
+ state.thisProcess->WriteMemory(size, buffer.output[0].address);
+ }
+
+ void NvHostCtrlGpu::ZCullGetInfo(skyline::gpu::device::IoctlBuffers &buffer) {
+ struct {
+ u32 widthAlignPixels{0x20};
+ u32 heightAlignPixels{0x20};
+ u32 pixelSquaresByAliquots{0x400};
+ u32 aliquotTotal{0x800};
+ u32 regionByteMultiplier{0x20};
+ u32 regionHeaderSize{0x20};
+ u32 subregionHeaderSize{0xC0};
+ u32 subregionWidthAlignPixels{0x20};
+ u32 subregionHeightAlignPixels{0x40};
+ u32 subregionCount{0x10};
+ } zCullInfo;
+ state.thisProcess->WriteMemory(zCullInfo, buffer.output[0].address);
+ }
+
+ void NvHostCtrlGpu::GetCharacteristics(IoctlBuffers &buffer) {
+ struct GpuCharacteristics {
+ u32 arch; // 0x120 (NVGPU_GPU_ARCH_GM200)
+ u32 impl; // 0xB (NVGPU_GPU_IMPL_GM20B) or 0xE (NVGPU_GPU_IMPL_GM20B_B)
+ u32 rev; // 0xA1 (Revision A1)
+ u32 numGpc; // 0x1
+ u64 l2CacheSize; // 0x40000
+ u64 onBoardVideoMemorySize; // 0x0 (not used)
+ u32 numTpcPerGpc; // 0x2
+ u32 busType; // 0x20 (NVGPU_GPU_BUS_TYPE_AXI)
+ u32 bigPageSize; // 0x20000
+ u32 compressionPageSize; // 0x20000
+ u32 pdeCoverageBitCount; // 0x1B
+ u32 availableBigPageSizes; // 0x30000
+ u32 gpcMask; // 0x1
+ u32 smArchSmVersion; // 0x503 (Maxwell Generation 5.0.3)
+ u32 smArchSpaVersion; // 0x503 (Maxwell Generation 5.0.3)
+ u32 smArchWarpCount; // 0x80
+ u32 gpuVaBitCount; // 0x28
+ u32 reserved; // NULL
+ u64 flags; // 0x55 (HAS_SYNCPOINTS | SUPPORT_SPARSE_ALLOCS | SUPPORT_CYCLE_STATS | SUPPORT_CYCLE_STATS_SNAPSHOT)
+ u32 twodClass; // 0x902D (FERMI_TWOD_A)
+ u32 threedClass; // 0xB197 (MAXWELL_B)
+ u32 computeClass; // 0xB1C0 (MAXWELL_COMPUTE_B)
+ u32 gpfifoClass; // 0xB06F (MAXWELL_CHANNEL_GPFIFO_A)
+ u32 inlineToMemoryClass; // 0xA140 (KEPLER_INLINE_TO_MEMORY_B)
+ u32 dmaCopyClass; // 0xB0B5 (MAXWELL_DMA_COPY_A)
+ u32 maxFbpsCount; // 0x1
+ u32 fbpEnMask; // 0x0 (disabled)
+ u32 maxLtcPerFbp; // 0x2
+ u32 maxLtsPerLtc; // 0x1
+ u32 maxTexPerTpc; // 0x0 (not supported)
+ u32 maxGpcCount; // 0x1
+ u32 ropL2EnMask0; // 0x21D70 (fuse_status_opt_rop_l2_fbp_r)
+ u32 ropL2EnMask1; // 0x0
+ u64 chipName; // 0x6230326D67 ("gm20b")
+ u64 grCompbitStoreBaseHw; // 0x0 (not supported)
+ };
+ struct Data {
+ u64 gpuCharacteristicsBufSize; // InOut
+ u64 gpuCharacteristicsBufAddr; // In
+ GpuCharacteristics gpuCharacteristics; // Out
+ } data = state.thisProcess->ReadMemory(buffer.input[0].address);
+ data.gpuCharacteristics = {
+ .arch = 0x120,
+ .impl = 0xB,
+ .rev = 0xA1,
+ .numGpc = 0x1,
+ .l2CacheSize = 0x40000,
+ .onBoardVideoMemorySize = 0x0,
+ .numTpcPerGpc = 0x2,
+ .busType = 0x20,
+ .bigPageSize = 0x20000,
+ .compressionPageSize = 0x20000,
+ .pdeCoverageBitCount = 0x1B,
+ .availableBigPageSizes = 0x30000,
+ .gpcMask = 0x1,
+ .smArchSmVersion = 0x503,
+ .smArchSpaVersion = 0x503,
+ .smArchWarpCount = 0x80,
+ .gpuVaBitCount = 0x2,
+ .flags = 0x55,
+ .twodClass = 0x902D,
+ .threedClass = 0xB197,
+ .computeClass = 0xB1C0,
+ .gpfifoClass = 0xB06F,
+ .inlineToMemoryClass = 0xA140,
+ .dmaCopyClass = 0xB0B5,
+ .maxFbpsCount = 0x1,
+ .fbpEnMask = 0x0,
+ .maxLtcPerFbp = 0x2,
+ .maxLtsPerLtc = 0x1,
+ .maxTexPerTpc = 0x0,
+ .maxGpcCount = 0x1,
+ .ropL2EnMask0 = 0x21D70,
+ .ropL2EnMask1 = 0x0,
+ .chipName = 0x6230326D67,
+ .grCompbitStoreBaseHw = 0x0
+ };
+ data.gpuCharacteristicsBufSize = 0xA0;
+ state.thisProcess->WriteMemory(data, buffer.output[0].address);
+ }
+
+ void NvHostCtrlGpu::GetTpcMasks(IoctlBuffers &buffer) {
+ struct Data {
+ u32 maskBufSize; // In
+ u32 reserved[3]; // In
+ u64 maskBuf; // Out
+ } data = state.thisProcess->ReadMemory(buffer.input[0].address);
+ if (data.maskBufSize)
+ data.maskBuf = 0x3;
+ state.thisProcess->WriteMemory(data, buffer.output[0].address);
+ }
+
+ void NvHostCtrlGpu::GetActiveSlotMask(IoctlBuffers &buffer) {
+ struct Data {
+ u32 slot; // Out
+ u32 mask; // Out
+ } data = {
+ .slot = 0x07,
+ .mask = 0x01
+ };
+ state.thisProcess->WriteMemory(data, buffer.output[0].address);
+ }
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl_gpu.h b/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl_gpu.h
new file mode 100644
index 00000000..f3dcb9db
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvhost_ctrl_gpu.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "nvdevice.h"
+
+namespace skyline::gpu::device {
+ /**
+ * @brief NvHostCtrlGpu (/dev/nvhost-ctrl-gpu) is used for context independent operations on the underlying GPU (https://switchbrew.org/wiki/NV_services#.2Fdev.2Fnvhost-ctrl-gpu)
+ */
+ class NvHostCtrlGpu : public NvDevice {
+ public:
+ NvHostCtrlGpu(const DeviceState &state);
+
+ /**
+ * @brief This returns a u32 GPU ZCULL Context Size (https://switchbrew.org/wiki/NV_services#NVGPU_GPU_IOCTL_ZCULL_GET_CTX_SIZE)
+ */
+ void ZCullGetCtxSize(IoctlBuffers &buffer);
+
+ /**
+ * @brief This returns a the GPU ZCULL Information (https://switchbrew.org/wiki/NV_services#NVGPU_GPU_IOCTL_ZCULL_GET_INFO)
+ */
+ void ZCullGetInfo(IoctlBuffers &buffer);
+
+ /**
+ * @brief This returns a struct with certain GPU characteristics (https://switchbrew.org/wiki/NV_services#NVGPU_GPU_IOCTL_GET_CHARACTERISTICS)
+ */
+ void GetCharacteristics(IoctlBuffers &buffer);
+
+ /**
+ * @brief This returns the TPC mask value for each GPC (https://switchbrew.org/wiki/NV_services#NVGPU_GPU_IOCTL_GET_TPC_MASKS)
+ */
+ void GetTpcMasks(IoctlBuffers &buffer);
+
+ /**
+ * @brief This returns the mask value for a ZBC slot (https://switchbrew.org/wiki/NV_services#NVGPU_GPU_IOCTL_ZBC_GET_ACTIVE_SLOT_MASK)
+ */
+ void GetActiveSlotMask(IoctlBuffers &buffer);
+ };
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvmap.cpp b/app/src/main/cpp/skyline/gpu/devices/nvmap.cpp
new file mode 100644
index 00000000..50aa206d
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvmap.cpp
@@ -0,0 +1,140 @@
+#include "nvmap.h"
+#include
+
+namespace skyline::gpu::device {
+ NvMap::NvMapObject::NvMapObject(u32 id, u32 size) : id(id), size(size) {}
+
+ NvMap::NvMap(const DeviceState &state) : NvDevice(state, NvDeviceType::nvmap, {
+ {0xC0080101, NFUNC(NvMap::Create)},
+ {0xC0080103, NFUNC(NvMap::FromId)},
+ {0xC0200104, NFUNC(NvMap::Alloc)},
+ {0xC0180105, NFUNC(NvMap::Free)},
+ {0xC00C0109, NFUNC(NvMap::Param)},
+ {0xC008010E, NFUNC(NvMap::GetId)}
+ }) {}
+
+ void NvMap::Create(IoctlBuffers &buffer) {
+ struct Data {
+ u32 size; // In
+ u32 handle; // Out
+ } data = state.thisProcess->ReadMemory(buffer.input[0].address);
+ handleTable[handleIndex] = std::make_shared(idIndex++, data.size);
+ data.handle = handleIndex++;
+ state.thisProcess->WriteMemory(data, buffer.output[0].address);
+ state.logger->Info("Create: Input: Size: 0x{:X}, Output: Handle: 0x{:X}, Status: {}", data.size, data.handle, buffer.status);
+ }
+
+ void NvMap::FromId(skyline::gpu::device::IoctlBuffers &buffer) {
+ struct Data {
+ u32 id; // In
+ u32 handle; // Out
+ } data = state.thisProcess->ReadMemory(buffer.input[0].address);
+ bool found{};
+ for (const auto &object : handleTable) {
+ if (object.second->id == data.id) {
+ data.handle = object.first;
+ found = true;
+ break;
+ }
+ }
+ if (found)
+ state.thisProcess->WriteMemory(data, buffer.output[0].address);
+ else
+ buffer.status = NvStatus::BadValue;
+ state.logger->Info("FromId: Input: Handle: 0x{:X}, Output: ID: 0x{:X}, Status: {}", data.handle, data.id, buffer.status);
+ }
+
+ void NvMap::Alloc(IoctlBuffers &buffer) {
+ struct Data {
+ u32 handle; // In
+ u32 heapMask; // In
+ u32 flags; // In
+ u32 align; // In
+ u8 kind; // In
+ u8 _pad0_[7];
+ u64 address; // InOut
+ } data = state.thisProcess->ReadMemory(buffer.input[0].address);
+ auto &object = handleTable.at(data.handle);
+ object->heapMask = data.heapMask;
+ object->flags = data.flags;
+ object->align = data.align;
+ object->kind = data.kind;
+ object->address = data.address;
+ object->status = NvMapObject::Status::Allocated;
+ state.logger->Info("Alloc: Input: Handle: 0x{:X}, HeapMask: 0x{:X}, Flags: {}, Align: 0x{:X}, Kind: {}, Address: 0x{:X}, Output: Status: {}", data.handle, data.heapMask, data.flags, data.align, data.kind, data.address, buffer.status);
+ }
+
+ void NvMap::Free(skyline::gpu::device::IoctlBuffers &buffer) {
+ struct Data {
+ u32 handle; // In
+ u32 _pad0_;
+ u32 address; // Out
+ u32 size; // Out
+ u64 flags; // Out
+ } data = state.thisProcess->ReadMemory(buffer.input[0].address);
+ const auto &object = handleTable.at(data.handle);
+ if (object.use_count() > 1) {
+ data.address = static_cast(object->address);
+ data.flags = 0x0;
+ } else {
+ data.address = 0x0;
+ data.flags = 0x1; // Not free yet
+ }
+ data.size = object->size;
+ handleTable.erase(data.handle);
+ state.thisProcess->WriteMemory(data, buffer.output[0].address);
+ }
+
+ void NvMap::Param(IoctlBuffers &buffer) {
+ enum class Parameter : u32 { Size = 1, Alignment = 2, Base = 3, HeapMask = 4, Kind = 5, Compr = 6 }; // https://android.googlesource.com/kernel/tegra/+/refs/heads/android-tegra-flounder-3.10-marshmallow/include/linux/nvmap.h#102
+ struct Data {
+ u32 handle; // In
+ Parameter parameter; // In
+ u32 result; // Out
+ } data = state.thisProcess->ReadMemory(buffer.input[0].address);
+ auto &object = handleTable.at(data.handle);
+ switch (data.parameter) {
+ case Parameter::Size:
+ data.result = object->size;
+ break;
+ case Parameter::Alignment:
+ case Parameter::HeapMask:
+ case Parameter::Kind: {
+ if (object->status != NvMapObject::Status::Allocated)
+ data.result = NvStatus::BadParameter;
+ switch (data.parameter) {
+ case Parameter::Alignment:
+ data.result = object->align;
+ break;
+ case Parameter::HeapMask:
+ data.result = object->heapMask;
+ break;
+ case Parameter::Kind:
+ data.result = object->kind;
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+ case Parameter::Base:
+ buffer.status = NvStatus::NotImplemented;
+ break;
+ case Parameter::Compr:
+ buffer.status = NvStatus::NotImplemented;
+ break;
+ }
+ state.thisProcess->WriteMemory(data, buffer.output[0].address);
+ state.logger->Info("Param: Input: Handle: 0x{:X}, Parameter: {}, Output: Result: 0x{:X}, Status: {}", data.handle, data.parameter, data.result, buffer.status);
+ }
+
+ void NvMap::GetId(skyline::gpu::device::IoctlBuffers &buffer) {
+ struct Data {
+ u32 id; // Out
+ u32 handle; // In
+ } data = state.thisProcess->ReadMemory(buffer.input[0].address);
+ data.id = handleTable.at(data.handle)->id;
+ state.thisProcess->WriteMemory(data, buffer.output[0].address);
+ state.logger->Info("GetId: Input: Handle: 0x{:X}, Output: ID: 0x{:X}, Status: {}", data.handle, data.id, buffer.status);
+ }
+}
diff --git a/app/src/main/cpp/skyline/gpu/devices/nvmap.h b/app/src/main/cpp/skyline/gpu/devices/nvmap.h
new file mode 100644
index 00000000..349119a3
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/devices/nvmap.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include "nvdevice.h"
+
+namespace skyline::gpu::device {
+ /**
+ * @brief NvMap (/dev/nvmap) is used to map certain CPU memory as GPU memory (https://switchbrew.org/wiki/NV_services) (https://android.googlesource.com/kernel/tegra/+/refs/heads/android-tegra-flounder-3.10-marshmallow/include/linux/nvmap.h)
+ */
+ class NvMap : public NvDevice {
+ public:
+ /**
+ * @brief NvMapObject is used to hold the state of held objects
+ */
+ struct NvMapObject {
+ u32 id; //!< The ID of this object
+ u32 size; //!< The size of this object
+ u64 address{}; //!< The address of the allocation
+ u32 flags{}; //!< The flag of the memory (0 = Read Only, 1 = Read-Write)
+ u32 align{}; //!< The alignment of the allocation
+ u32 heapMask{}; //!< This is set during Alloc and returned during Param
+ u8 kind{}; //!< This is same as heapMask
+
+ enum class Status {
+ Created, //!< The object has been created but memory has not been allocated
+ Allocated //!< The object has been allocated
+ } status{Status::Created}; //!< This holds the status of the object
+
+ /**
+ * @param handle The ID of this object
+ * @param size The size of the object in bytes
+ */
+ NvMapObject(u32 id, u32 size);
+ };
+
+ std::unordered_map> handleTable; //!< A mapping from a handle to it's corresponding NvMapObject
+ handle_t handleIndex{1}; //!< This is used to keep track of the next handle to allocate
+ u32 idIndex{1}; //!< This is used to keep track of the next ID to allocate
+
+ NvMap(const DeviceState &state);
+
+ /**
+ * @brief This creates an NvMapObject and returns an handle to it (https://switchbrew.org/wiki/NV_services#NVMAP_IOC_CREATE)
+ */
+ void Create(IoctlBuffers &buffer);
+
+ /**
+ * @brief This returns the handle of an NvMapObject from it's ID (https://switchbrew.org/wiki/NV_services#NVMAP_IOC_FROM_ID)
+ */
+ void FromId(IoctlBuffers &buffer);
+
+ /**
+ * @brief This allocates memory for an NvMapObject (https://switchbrew.org/wiki/NV_services#NVMAP_IOC_ALLOC)
+ */
+ void Alloc(IoctlBuffers &buffer);
+
+ /**
+ * @brief This frees previously allocated memory (https://switchbrew.org/wiki/NV_services#NVMAP_IOC_FREE)
+ */
+ void Free(IoctlBuffers &buffer);
+
+ /**
+ * @brief This returns a particular parameter from an NvMapObject (https://switchbrew.org/wiki/NV_services#NVMAP_IOC_PARAM)
+ */
+ void Param(IoctlBuffers &buffer);
+
+ /**
+ * @brief This returns the ID of an NvMapObject from it's handle (https://switchbrew.org/wiki/NV_services#NVMAP_IOC_GET_ID)
+ */
+ void GetId(IoctlBuffers &buffer);
+ };
+}
diff --git a/app/src/main/cpp/skyline/gpu/display.cpp b/app/src/main/cpp/skyline/gpu/display.cpp
new file mode 100644
index 00000000..18afdec4
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/display.cpp
@@ -0,0 +1,138 @@
+#include "display.h"
+#include
+#include
+
+namespace skyline::gpu {
+ Buffer::Buffer(const DeviceState &state, u32 slot, GbpBuffer &gbpBuffer) : state(state), slot(slot), gbpBuffer(gbpBuffer), resolution{gbpBuffer.width, gbpBuffer.height}, dataBuffer(gbpBuffer.size) {
+ if (gbpBuffer.nvmapHandle)
+ nvBuffer = state.gpu->GetDevice(device::NvDeviceType::nvmap)->handleTable.at(gbpBuffer.nvmapHandle);
+ else {
+ auto nvmap = state.gpu->GetDevice(device::NvDeviceType::nvmap);
+ for (const auto &object : nvmap->handleTable) {
+ if (object.second->id == gbpBuffer.nvmapId) {
+ nvBuffer = object.second;
+ break;
+ }
+ }
+ if (!nvBuffer)
+ throw exception("A QueueBuffer request has an invalid NVMap Handle ({}) and ID ({})", gbpBuffer.nvmapHandle, gbpBuffer.nvmapId);
+ }
+ }
+
+ void Buffer::UpdateBuffer() {
+ state.thisProcess->ReadMemory(dataBuffer.data(), nvBuffer->address + gbpBuffer.offset, gbpBuffer.size);
+ }
+
+ BufferQueue::WaitContext::WaitContext(std::shared_ptr thread, DequeueIn input, u64 address, u64 size) : thread(std::move(thread)), input(input), address(address), size(size) {}
+
+ BufferQueue::DequeueOut::DequeueOut(u32 slot) : slot(slot), _unk0_(0x1), _unk1_(0x24) {}
+
+ BufferQueue::BufferQueue(const DeviceState &state) : state(state) {}
+
+ void BufferQueue::RequestBuffer(Parcel &in, Parcel &out) {
+ u32 slot = *reinterpret_cast(in.data.data() + constant::TokenLength);
+ auto buffer = queue.at(slot);
+ out.WriteData(1);
+ out.WriteData(sizeof(GbpBuffer));
+ out.WriteData(0);
+ out.WriteData(buffer->gbpBuffer);
+ state.logger->Debug("RequestBuffer: Slot: {}, Size: {}", slot, sizeof(GbpBuffer));
+ }
+
+ bool BufferQueue::DequeueBuffer(Parcel &in, Parcel &out, u64 address, u64 size) {
+ auto *data = reinterpret_cast(in.data.data() + constant::TokenLength);
+ i64 slot{-1};
+ for (auto &buffer : queue) {
+ if (buffer.second->status == BufferStatus::Free && buffer.second->resolution.width == data->width && buffer.second->resolution.height == data->height && buffer.second->gbpBuffer.format == data->format && buffer.second->gbpBuffer.usage == data->usage) {
+ slot = buffer.first;
+ buffer.second->status = BufferStatus::Dequeued;
+ }
+ }
+ if (slot == -1) {
+ state.thisThread->Sleep();
+ waitVec.emplace_back(state.thisThread, *data, address, size);
+ state.logger->Debug("DequeueBuffer: No Free Buffers");
+ return true;
+ }
+ DequeueOut output(static_cast(slot));
+ out.WriteData(output);
+ state.logger->Debug("DequeueBuffer: Width: {}, Height: {}, Format: {}, Usage: {}, Timestamps: {}, Slot: {}", data->width, data->height, data->format, data->usage, data->timestamps, slot);
+ return false;
+ }
+
+ void BufferQueue::QueueBuffer(Parcel &in, Parcel &out) {
+ struct Data {
+ u32 slot;
+ u64 timestamp;
+ u32 autoTimestamp;
+ ARect crop;
+ u32 scalingMode;
+ u32 transform;
+ u32 stickyTransform;
+ u64 _unk0_;
+ u32 swapInterval;
+ Fence fence[4];
+ } *data = reinterpret_cast(in.data.data() + constant::TokenLength);
+ auto buffer = queue.at(data->slot);
+ buffer->status = BufferStatus::Queued;
+ displayQueue.emplace(buffer);
+ state.gpu->bufferEvent->Signal();
+ struct {
+ u32 width;
+ u32 height;
+ u32 _pad0_[3];
+ } output{
+ .width = buffer->gbpBuffer.width,
+ .height = buffer->gbpBuffer.height
+ };
+ out.WriteData(output);
+ state.logger->Debug("QueueBuffer: Timestamp: {}, Auto Timestamp: {}, Crop: [T: {}, B: {}, L: {}, R: {}], Scaling Mode: {}, Transform: {}, Sticky Transform: {}, Swap Interval: {}, Slot: {}", data->timestamp, data->autoTimestamp, data->crop.top, data->crop.bottom, data->crop.left, data->crop.right, data->scalingMode, data->transform, data->stickyTransform, data->swapInterval,
+ data->slot);
+ }
+
+ void BufferQueue::CancelBuffer(Parcel &parcel) {
+ struct Data {
+ u32 slot;
+ Fence fence[4];
+ } *data = reinterpret_cast(parcel.data.data() + constant::TokenLength);
+ FreeBuffer(data->slot);
+ }
+
+ void BufferQueue::SetPreallocatedBuffer(Parcel &parcel) {
+ auto pointer = parcel.data.data() + constant::TokenLength;
+ struct Data {
+ u32 slot;
+ u32 _unk0_;
+ u32 length;
+ u32 _pad0_;
+ } *data = reinterpret_cast(pointer);
+ pointer += sizeof(Data);
+ auto gbpBuffer = reinterpret_cast(pointer);
+ queue[data->slot] = std::make_shared(state, data->slot, *gbpBuffer);
+ state.gpu->bufferEvent->Signal();
+ state.logger->Debug("SetPreallocatedBuffer: Slot: {}, Length: {}, Magic: 0x{:X}, Width: {}, Height: {}, Stride: {}, Format: {}, Usage: {}, Index: {}, ID: {}, Handle: {}, Offset: 0x{:X}, Block Height: {}", data->slot, data->length, gbpBuffer->magic, gbpBuffer->width, gbpBuffer->height, gbpBuffer->stride, gbpBuffer->format, gbpBuffer->usage, gbpBuffer->index, gbpBuffer->nvmapId,
+ gbpBuffer->nvmapHandle, gbpBuffer->offset, (1U << gbpBuffer->blockHeightLog2));
+ }
+
+ void BufferQueue::FreeBuffer(u32 slotNo) {
+ auto &slot = queue.at(slotNo);
+ if (waitVec.empty())
+ slot->status = BufferStatus::Free;
+ else {
+ auto context = waitVec.begin();
+ while (context != waitVec.end()) {
+ if (slot->resolution.width == context->input.width && slot->resolution.height == context->input.height && slot->gbpBuffer.format == context->input.format && slot->gbpBuffer.usage == context->input.usage) {
+ context->thread->WakeUp();
+ gpu::Parcel out(state);
+ DequeueOut output(slotNo);
+ out.WriteData(output);
+ out.WriteParcel(context->address, context->size, context->thread->pid);
+ slot->status = BufferStatus::Dequeued;
+ waitVec.erase(context);
+ break;
+ }
+ context++;
+ }
+ }
+ }
+}
diff --git a/app/src/main/cpp/skyline/gpu/display.h b/app/src/main/cpp/skyline/gpu/display.h
new file mode 100644
index 00000000..59e29f3c
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/display.h
@@ -0,0 +1,218 @@
+#pragma once
+
+#include
+#include
+#include
+#include "parcel.h"
+
+namespace skyline::gpu {
+ /**
+ * @brief A struct that encapsulates a resolution
+ */
+ struct Resolution {
+ u32 width; //!< The width component of the resolution
+ u32 height; //!< The height component of the resolution
+
+ bool operator==(const Resolution &r) {
+ return (width == r.width) && (height == r.height);
+ }
+
+ bool operator!=(const Resolution &r) {
+ return !operator==(r);
+ }
+ };
+
+ /**
+ * @brief An enumeration of all the possible display IDs (https://switchbrew.org/wiki/Display_services#DisplayName)
+ */
+ enum class DisplayId : u64 {
+ Default,
+ External,
+ Edid,
+ Internal,
+ Null
+ };
+
+ /**
+ * @brief A mapping from a display's name to it's displayType entry
+ */
+ static const std::unordered_map displayTypeMap{
+ {"Default", DisplayId::Default},
+ {"External", DisplayId::External},
+ {"Edid", DisplayId::Edid},
+ {"Internal", DisplayId::Internal},
+ {"Null", DisplayId::Null},
+ };
+
+ /**
+ * @brief The status of a specific layer
+ */
+ enum class LayerStatus {
+ Uninitialized,
+ Initialized
+ };
+
+ /**
+ * @brief The status of a specific buffer
+ */
+ enum class BufferStatus {
+ Free,
+ Dequeued,
+ Queued,
+ Acquired
+ };
+
+ /**
+ * @brief This struct holds information about the graphics buffer (https://github.com/reswitched/libtransistor/blob/0f0c36227842c344d163922fc98ee76229e9f0ee/lib/display/graphic_buffer_queue.c#L66)
+ */
+ struct GbpBuffer {
+ u32 magic; //!< The magic of the graphics buffer: 0x47424652
+ u32 width; //!< The width of the buffer
+ u32 height; //!< The height of the buffer
+ u32 stride; //!< The stride of the buffer
+ u32 format; //!< The format of the buffer, this corresponds to AHardwareBuffer_Format
+ u32 usage; //!< The usage flags for the buffer
+ u32 _pad0_;
+ u32 index; //!< The index of the buffer
+ u32 _pad1_[3];
+ u32 nvmapId; //!< The ID of the buffer in regards to /dev/nvmap
+ u32 _pad2_[8];
+ u32 size; //!< The size of the buffer
+ u32 _pad3_[8];
+ u32 nvmapHandle; //!< The handle of the buffer in regards to /dev/nvmap
+ u32 offset; //!< This is the offset of the pixel data in the GPU Buffer
+ u32 _pad4_;
+ u32 blockHeightLog2; //!< The log2 of the block height
+ u32 _pad5_[58];
+ };
+
+ /**
+ * @brief This represents conditions for the completion of an asynchronous graphics operation
+ */
+ struct Fence {
+ u32 syncptId;
+ u32 syncptValue;
+ };
+
+ /**
+ * @brief This holds the state and describes a single Buffer
+ */
+ class Buffer {
+ public:
+ const DeviceState &state; //!< The state of the device
+ u32 slot; //!< The slot the buffer is in
+ Resolution resolution; //!< The resolution of this buffer
+ GbpBuffer gbpBuffer; //!< The information about the underlying buffer
+ BufferStatus status{BufferStatus::Free}; //!< The status of this buffer
+ std::vector dataBuffer; //!< The vector holding the actual pixel data
+ std::shared_ptr nvBuffer{}; //!< A shared pointer to the buffer's nvmap object
+
+ /**
+ * @param state The state of the device
+ * @param slot The slot this buffer is in
+ * @param gpBuffer The GbpBuffer object for this buffer
+ */
+ Buffer(const DeviceState &state, u32 slot, GbpBuffer &gbpBuffer);
+
+ /**
+ * @brief This reads the buffer from the process into the dataBuffer vector
+ */
+ void UpdateBuffer();
+ };
+
+ /**
+ * @brief This holds the state of all the buffers used by the guest application
+ */
+ class BufferQueue {
+ private:
+ const DeviceState &state; //!< The state of the device
+
+ /**
+ * @brief This is the input struct for DequeueBuffer
+ */
+ struct DequeueIn {
+ u32 format;
+ u32 width;
+ u32 height;
+ u32 timestamps;
+ u32 usage;
+ };
+
+ /**
+ * @brief This is the output struct for DequeueBuffer
+ */
+ struct DequeueOut {
+ u32 slot; //!< The slot of the dequeued buffer
+ u32 _unk0_;
+ u32 _unk1_;
+ u32 _unk2_[11]{};
+
+ /**
+ * @param slot The slot of the dequeued buffer
+ */
+ DequeueOut(u32 slot);
+ };
+
+ /**
+ * @brief This holds the context of a thread waiting on a buffer
+ */
+ struct WaitContext {
+ std::shared_ptr thread; //!< The thread that is waiting on a buffer
+ DequeueIn input; //!< The input of DequeueBuffer
+ u64 address; //!< The address of the parcel buffer
+ u64 size; //!< The size of the parcel buffer
+
+ /**
+ * @param thread The thread that is waiting on a buffer
+ * @param input The input of DequeueBuffer
+ * @param address The address of the parcel buffer
+ * @param size The size of the parcel buffer
+ */
+ WaitContext(std::shared_ptr thread, DequeueIn input, u64 address, u64 size);
+ };
+ std::vector waitVec; //!< A vector of shared pointers to threads waiting on a buffer
+
+ public:
+ std::unordered_map> queue; //!< A vector of shared pointers to all the queued buffers
+ std::queue> displayQueue; //!< A queue of all the buffers to be posted to the display
+
+ /**
+ * @param state The state of the device
+ */
+ BufferQueue(const DeviceState &state);
+
+ /**
+ * @brief This the GbpBuffer struct of the specified buffer
+ */
+ void RequestBuffer(Parcel &in, Parcel &out);
+
+ /**
+ * @brief This returns the slot of a free buffer
+ * @param address The address of the parcel buffer
+ * @param size The size of the parcel buffer
+ * @return If the process is waiting for a buffer or not
+ */
+ bool DequeueBuffer(Parcel &in, Parcel &out, u64 address, u64 size);
+
+ /**
+ * @brief This queues a buffer to be displayed
+ */
+ void QueueBuffer(Parcel &in, Parcel &out);
+
+ /**
+ * @brief This removes a previously queued buffer
+ */
+ void CancelBuffer(Parcel &parcel);
+
+ /**
+ * @brief This adds a pre-existing buffer to the queue
+ */
+ void SetPreallocatedBuffer(Parcel &parcel);
+
+ /**
+ * @brief This frees a buffer which is currently queued
+ * @param slotNo The slot of the buffer
+ */
+ void FreeBuffer(u32 slotNo);
+ };
+}
diff --git a/app/src/main/cpp/skyline/gpu/parcel.cpp b/app/src/main/cpp/skyline/gpu/parcel.cpp
new file mode 100644
index 00000000..8a3e31e1
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/parcel.cpp
@@ -0,0 +1,50 @@
+#include "parcel.h"
+#include
+#include
+
+namespace skyline::gpu {
+ Parcel::Parcel(kernel::ipc::BufferDescriptorABW *buffer, const DeviceState &state) : Parcel(buffer->Address(), buffer->Size(), state) {}
+
+ Parcel::Parcel(kernel::ipc::BufferDescriptorX *buffer, const DeviceState &state) : Parcel(buffer->Address(), buffer->size, state) {}
+
+ Parcel::Parcel(u64 address, u64 size, const DeviceState &state) : state(state) {
+ state.thisProcess->ReadMemory(&header, address, sizeof(ParcelHeader));
+ if (size < (sizeof(ParcelHeader) + header.dataSize + header.objectsSize))
+ throw exception("The size of the parcel according to the header exceeds the specified size");
+ data.resize(header.dataSize);
+ state.thisProcess->ReadMemory(data.data(), address + header.dataOffset, header.dataSize);
+ objects.resize(header.objectsSize);
+ state.thisProcess->ReadMemory(objects.data(), address + header.objectsOffset, header.objectsSize);
+ }
+
+ Parcel::Parcel(const DeviceState &state) : state(state) {}
+
+ u64 Parcel::WriteParcel(kernel::ipc::BufferDescriptorABW *buffer, pid_t process) {
+ return WriteParcel(buffer->Address(), buffer->Size(), process);
+ }
+
+ u64 Parcel::WriteParcel(kernel::ipc::BufferDescriptorC *buffer, pid_t process) {
+ return WriteParcel(buffer->address, buffer->size, process);
+ }
+
+ u64 Parcel::WriteParcel(u64 address, u64 maxSize, pid_t process) {
+ header.dataSize = static_cast(data.size());
+ header.dataOffset = sizeof(ParcelHeader);
+ header.objectsSize = static_cast(objects.size());
+ header.objectsOffset = sizeof(ParcelHeader) + data.size();
+ u64 totalSize = sizeof(ParcelHeader) + header.dataSize + header.objectsSize;
+ if (maxSize < totalSize)
+ throw exception("The size of the parcel exceeds maxSize");
+ if (process) {
+ auto &object = state.os->processMap.at(process);
+ object->WriteMemory(header, address);
+ object->WriteMemory(data.data(), address + header.dataOffset, data.size());
+ object->WriteMemory(objects.data(), address + header.objectsOffset, objects.size());
+ } else {
+ state.thisProcess->WriteMemory(header, address);
+ state.thisProcess->WriteMemory(data.data(), address + header.dataOffset, data.size());
+ state.thisProcess->WriteMemory(objects.data(), address + header.objectsOffset, objects.size());
+ }
+ return totalSize;
+ }
+}
diff --git a/app/src/main/cpp/skyline/gpu/parcel.h b/app/src/main/cpp/skyline/gpu/parcel.h
new file mode 100644
index 00000000..687315b5
--- /dev/null
+++ b/app/src/main/cpp/skyline/gpu/parcel.h
@@ -0,0 +1,112 @@
+#pragma once
+
+#include
+#include
+
+namespace skyline::gpu {
+ /**
+ * @brief This class encapsulates a Parcel object (https://switchbrew.org/wiki/Display_services#Parcel)
+ */
+ class Parcel {
+ private:
+ /**
+ * @brief This holds the header of a parcel
+ */
+ struct ParcelHeader {
+ u32 dataSize;
+ u32 dataOffset;
+ u32 objectsSize;
+ u32 objectsOffset;
+ } header{};
+ static_assert(sizeof(ParcelHeader) == 0x10);
+
+ const DeviceState &state; //!< The state of the device
+
+ public:
+ std::vector data; //!< A vector filled with data in the parcel
+ std::vector objects; //!< A vector filled with objects in the parcel
+
+ /**
+ * @brief This constructor fills in the Parcel object with data from a IPC buffer
+ * @param buffer The buffer that contains the parcel
+ * @param state The state of the device
+ */
+ Parcel(kernel::ipc::BufferDescriptorABW *buffer, const DeviceState &state);
+
+ /**
+ * @brief This constructor fills in the Parcel object with data from a IPC buffer
+ * @param buffer The buffer that contains the parcel
+ * @param state The state of the device
+ */
+ Parcel(kernel::ipc::BufferDescriptorX *buffer, const DeviceState &state);
+
+ /**
+ * @brief This constructor fills in the Parcel object with data from a Parcel on a remote process
+ * @param address The remote address of the parcel
+ * @param size The size of the parcel
+ * @param state The state of the device
+ */
+ Parcel(u64 address, u64 size, const DeviceState &state);
+
+ /**
+ * @brief This constructor is used to create an empty parcel then write to a process
+ * @param state The state of the device
+ */
+ Parcel(const DeviceState &state);
+
+ /**
+ * @brief Writes some data to the Parcel
+ * @tparam ValueType The type of the object to write
+ * @param value The object to be written
+ */
+ template
+ void WriteData(const ValueType &value) {
+ data.reserve(data.size() + sizeof(ValueType));
+ auto item = reinterpret_cast(&value);
+ for (uint index = 0; sizeof(ValueType) > index; index++) {
+ data.push_back(*item);
+ item++;
+ }
+ }
+
+ /**
+ * @brief Writes an object to the Parcel
+ * @tparam ValueType The type of the object to write
+ * @param value The object to be written
+ */
+ template
+ void WriteObject(const ValueType &value) {
+ objects.reserve(objects.size() + sizeof(ValueType));
+ auto item = reinterpret_cast(&value);
+ for (uint index = 0; sizeof(ValueType) > index; index++) {
+ objects.push_back(*item);
+ item++;
+ }
+ }
+
+ /**
+ * @brief Writes the Parcel object into a particular B buffer on a process
+ * @param buffer The buffer to write into
+ * @param process The process to write the Parcel to
+ * @return The total size of the message
+ */
+ u64 WriteParcel(kernel::ipc::BufferDescriptorABW *buffer, pid_t process = 0);
+
+ /**
+ * @brief Writes the Parcel object into a particular C buffer on a process
+ * @param buffer The buffer to write into
+ * @param process The process to write the Parcel to
+ * @return The total size of the message
+ */
+ u64 WriteParcel(kernel::ipc::BufferDescriptorC *buffer, pid_t process = 0);
+
+ /**
+ * @brief Writes the Parcel object into the process's memory
+ * @param address The address to write the Parcel object to
+ * @param maxSize The maximum size of the Parcel
+ * @param process The process to write the Parcel to
+ * @return The total size of the message
+ */
+ u64 WriteParcel(u64 address, u64 maxSize, pid_t process = 0);
+ };
+}
diff --git a/app/src/main/cpp/skyline/kernel/ipc.cpp b/app/src/main/cpp/skyline/kernel/ipc.cpp
index 170e5021..fe0a48e7 100644
--- a/app/src/main/cpp/skyline/kernel/ipc.cpp
+++ b/app/src/main/cpp/skyline/kernel/ipc.cpp
@@ -23,26 +23,43 @@ namespace skyline::kernel::ipc {
}
for (uint index = 0; header->x_no > index; index++) {
- vecBufX.push_back(reinterpret_cast(currPtr));
+ auto bufX = reinterpret_cast(currPtr);
+ if (bufX->Address()) {
+ vecBufX.push_back(bufX);
+ state.logger->Debug("Buf X #{} AD: 0x{:X} SZ: 0x{:X} CTR: {}", index, u64(bufX->Address()), u16(bufX->size), u16(bufX->Counter()));
+ }
currPtr += sizeof(BufferDescriptorX);
}
for (uint index = 0; header->a_no > index; index++) {
- vecBufA.push_back(reinterpret_cast(currPtr));
+ auto bufA = reinterpret_cast(currPtr);
+ if (bufA->Address()) {
+ vecBufA.push_back(bufA);
+ state.logger->Debug("Buf A #{} AD: 0x{:X} SZ: 0x{:X}", index, u64(bufA->Address()), u64(bufA->Size()));
+ }
currPtr += sizeof(BufferDescriptorABW);
}
for (uint index = 0; header->b_no > index; index++) {
- vecBufB.push_back(reinterpret_cast(currPtr));
+ auto bufB = reinterpret_cast(currPtr);
+ if (bufB->Address()) {
+ vecBufB.push_back(bufB);
+ state.logger->Debug("Buf B #{} AD: 0x{:X} SZ: 0x{:X}", index, u64(bufB->Address()), u64(bufB->Size()));
+ }
currPtr += sizeof(BufferDescriptorABW);
}
for (uint index = 0; header->w_no > index; index++) {
- vecBufW.push_back(reinterpret_cast(currPtr));
+ auto bufW = reinterpret_cast(currPtr);
+ if (bufW->Address()) {
+ vecBufW.push_back(bufW);
+ state.logger->Debug("Buf W #{} AD: 0x{:X} SZ: 0x{:X}", index, u64(bufW->Address()), u16(bufW->Size()));
+ }
currPtr += sizeof(BufferDescriptorABW);
}
- currPtr = reinterpret_cast((((reinterpret_cast(currPtr) - reinterpret_cast(tls.data())) - 1U) & ~(constant::PaddingSum - 1U)) + constant::PaddingSum + reinterpret_cast(tls.data())); // Align to 16 bytes relative to start of TLS
+ u64 padding = ((((reinterpret_cast(currPtr) - reinterpret_cast(tls.data())) - 1U) & ~(constant::IpcPaddingSum - 1U)) + constant::IpcPaddingSum + (reinterpret_cast(tls.data()) - reinterpret_cast(currPtr))); // Calculate the amount of padding at the front
+ currPtr += padding;
if (isDomain) {
domain = reinterpret_cast(currPtr);
@@ -64,29 +81,36 @@ namespace skyline::kernel::ipc {
currPtr += sizeof(PayloadHeader);
cmdArg = currPtr;
- cmdArgSz = (header->raw_sz * sizeof(u32)) - (constant::PaddingSum + sizeof(PayloadHeader));
+ cmdArgSz = (header->raw_sz * sizeof(u32)) - (constant::IpcPaddingSum + sizeof(PayloadHeader));
currPtr += cmdArgSz;
}
- if (payload->magic != constant::SfciMagic)
- state.logger->Write(Logger::Debug, "Unexpected Magic in PayloadHeader: 0x{:X}", u32(payload->magic));
+ if (payload->magic != constant::SfciMagic && header->type != static_cast(CommandType::Control))
+ state.logger->Debug("Unexpected Magic in PayloadHeader: 0x{:X}", u32(payload->magic));
+
+ currPtr += constant::IpcPaddingSum - padding;
if (header->c_flag == static_cast(BufferCFlag::SingleDescriptor)) {
- vecBufC.push_back(reinterpret_cast(currPtr));
+ auto bufC = reinterpret_cast(currPtr);
+ vecBufC.push_back(bufC);
+ state.logger->Debug("Buf C: AD: 0x{:X} SZ: 0x{:X}", u64(bufC->address), u16(bufC->size));
} else if (header->c_flag > static_cast(BufferCFlag::SingleDescriptor)) {
for (uint index = 0; (header->c_flag - 2) > index; index++) { // (c_flag - 2) C descriptors are present
- vecBufC.push_back(reinterpret_cast(currPtr));
- state.logger->Write(Logger::Debug, "Buf C #{} AD: 0x{:X} SZ: 0x{:X}", index, u64(vecBufC[index]->address), u16(vecBufC[index]->size));
+ auto bufC = reinterpret_cast(currPtr);
+ if (bufC->address) {
+ vecBufC.push_back(bufC);
+ state.logger->Debug("Buf C #{} AD: 0x{:X} SZ: 0x{:X}", index, u64(bufC->address), u16(bufC->size));
+ }
currPtr += sizeof(BufferDescriptorC);
}
}
- state.logger->Write(Logger::Debug, "Header: X No: {}, A No: {}, B No: {}, W No: {}, C No: {}, Raw Size: {}", u8(header->x_no), u8(header->a_no), u8(header->b_no), u8(header->w_no), u8(vecBufC.size()), u64(cmdArgSz));
+ state.logger->Debug("Header: X No: {}, A No: {}, B No: {}, W No: {}, C No: {}, Raw Size: {}", u8(header->x_no), u8(header->a_no), u8(header->b_no), u8(header->w_no), u8(vecBufC.size()), u64(cmdArgSz));
if (header->handle_desc)
- state.logger->Write(Logger::Debug, "Handle Descriptor: Send PID: {}, Copy Count: {}, Move Count: {}", bool(handleDesc->send_pid), u32(handleDesc->copy_count), u32(handleDesc->move_count));
+ state.logger->Debug("Handle Descriptor: Send PID: {}, Copy Count: {}, Move Count: {}", bool(handleDesc->send_pid), u32(handleDesc->copy_count), u32(handleDesc->move_count));
if (isDomain)
- state.logger->Write(Logger::Debug, "Domain Header: Command: {}, Input Object Count: {}, Object ID: 0x{:X}", domain->command, domain->input_count, domain->object_id);
- state.logger->Write(Logger::Debug, "Data Payload: Command ID: 0x{:X}", u32(payload->value));
+ state.logger->Debug("Domain Header: Command: {}, Input Object Count: {}, Object ID: 0x{:X}", domain->command, domain->input_count, domain->object_id);
+ state.logger->Debug("Data Payload: Command ID: 0x{:X}", u32(payload->value));
}
IpcResponse::IpcResponse(bool isDomain, const DeviceState &state) : isDomain(isDomain), state(state) {}
@@ -95,7 +119,7 @@ namespace skyline::kernel::ipc {
std::array tls{};
u8 *currPtr = tls.data();
auto header = reinterpret_cast(currPtr);
- header->raw_sz = static_cast((sizeof(PayloadHeader) + argVec.size() + (domainObjects.size() * sizeof(handle_t)) + constant::PaddingSum + (isDomain ? sizeof(DomainHeaderRequest) : 0)) / sizeof(u32)); // Size is in 32-bit units because Nintendo
+ header->raw_sz = static_cast((sizeof(PayloadHeader) + argVec.size() + (domainObjects.size() * sizeof(handle_t)) + constant::IpcPaddingSum + (isDomain ? sizeof(DomainHeaderRequest) : 0)) / sizeof(u32)); // Size is in 32-bit units because Nintendo
header->handle_desc = (!copyHandles.empty() || !moveHandles.empty());
currPtr += sizeof(CommandHeader);
@@ -116,7 +140,7 @@ namespace skyline::kernel::ipc {
}
}
- u64 padding = ((((reinterpret_cast(currPtr) - reinterpret_cast(tls.data())) - 1U) & ~(constant::PaddingSum - 1U)) + constant::PaddingSum + (reinterpret_cast(tls.data()) - reinterpret_cast(currPtr))); // Calculate the amount of padding at the front
+ u64 padding = ((((reinterpret_cast(currPtr) - reinterpret_cast(tls.data())) - 1U) & ~(constant::IpcPaddingSum - 1U)) + constant::IpcPaddingSum + (reinterpret_cast(tls.data()) - reinterpret_cast(currPtr))); // Calculate the amount of padding at the front
currPtr += padding;
if (isDomain) {
@@ -134,15 +158,21 @@ namespace skyline::kernel::ipc {
memcpy(currPtr, argVec.data(), argVec.size());
currPtr += argVec.size();
- if(isDomain) {
- for (auto& domainObject : domainObjects) {
+ if (isDomain) {
+ for (auto &domainObject : domainObjects) {
*reinterpret_cast(currPtr) = domainObject;
currPtr += sizeof(handle_t);
}
}
- state.logger->Write(Logger::Debug, "Output: Raw Size: {}, Command ID: 0x{:X}, Copy Handles: {}, Move Handles: {}", u32(header->raw_sz), u32(payload->value), copyHandles.size(), moveHandles.size());
+ state.logger->Debug("Output: Raw Size: {}, Command ID: 0x{:X}, Copy Handles: {}, Move Handles: {}", u32(header->raw_sz), u32(payload->value), copyHandles.size(), moveHandles.size());
state.thisProcess->WriteMemory(tls.data(), state.thisThread->tls, constant::TlsIpcSize);
}
+
+ std::vector BufferDescriptorABW::Read(const DeviceState &state) {
+ std::vector vec(Size());
+ state.thisProcess->ReadMemory(vec.data(), Address(), Size());
+ return std::move(vec);
+ }
}
diff --git a/app/src/main/cpp/skyline/kernel/ipc.h b/app/src/main/cpp/skyline/kernel/ipc.h
index f3ea71f4..b0553004 100644
--- a/app/src/main/cpp/skyline/kernel/ipc.h
+++ b/app/src/main/cpp/skyline/kernel/ipc.h
@@ -144,6 +144,8 @@ namespace skyline::kernel::ipc {
size_32_35 = static_cast(size & 0x78000000);
}
+ std::vector Read(const DeviceState &state);
+
inline u64 Address() const {
return static_cast(address_0_31) | static_cast(address_32_35) << 32 | static_cast(address_36_38) << 36;
}
@@ -160,7 +162,7 @@ namespace skyline::kernel::ipc {
*/
struct BufferDescriptorC {
u64 address : 48;
- u16 size : 16;
+ u32 size : 16;
BufferDescriptorC(u64 address, u16 size) : address(address), size(size) {}
};
@@ -208,6 +210,7 @@ namespace skyline::kernel::ipc {
const DeviceState &state; //!< The state of the device
public:
+ bool nWrite{}; //!< This is to signal the IPC handler to not write this, as it will be manually written
bool isDomain{}; //!< If this is a domain request
u32 errorCode{}; //!< The error code to respond with, it is 0 (Success) by default
std::vector copyHandles; //!< A vector of handles to copy
diff --git a/app/src/main/cpp/skyline/kernel/services/am/appletOE.cpp b/app/src/main/cpp/skyline/kernel/services/am/appletOE.cpp
deleted file mode 100644
index f97f9324..00000000
--- a/app/src/main/cpp/skyline/kernel/services/am/appletOE.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#include "appletOE.h"
-
-namespace skyline::kernel::service::am {
- appletOE::appletOE(const DeviceState &state, ServiceManager& manager) : BaseService(state, manager, false, Service::am_appletOE, {
- {0x0, SFunc(appletOE::OpenApplicationProxy)}
- }) {}
-
- void appletOE::OpenApplicationProxy(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_IApplicationProxy, session, response);
- }
-
- IApplicationProxy::IApplicationProxy(const DeviceState &state, ServiceManager& manager) : BaseService(state, manager, false, Service::am_IApplicationProxy, {
- {0x0, SFunc(IApplicationProxy::GetCommonStateGetter)},
- {0x1, SFunc(IApplicationProxy::GetSelfController)},
- {0x2, SFunc(IApplicationProxy::GetWindowController)},
- {0x3, SFunc(IApplicationProxy::GetAudioController)},
- {0x4, SFunc(IApplicationProxy::GetDisplayController)},
- {0xB, SFunc(IApplicationProxy::GetLibraryAppletCreator)},
- {0x14, SFunc(IApplicationProxy::GetApplicationFunctions)},
- {0x3E8, SFunc(IApplicationProxy::GetDisplayController)}
- }) {}
-
- void IApplicationProxy::GetCommonStateGetter(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_ICommonStateGetter, session, response);
- }
-
- void IApplicationProxy::GetSelfController(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_ISelfController, session, response);
- }
-
- void IApplicationProxy::GetWindowController(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_IWindowController, session, response);
- }
-
- void IApplicationProxy::GetAudioController(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_IAudioController, session, response);
- }
-
- void IApplicationProxy::GetDisplayController(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_IDisplayController, session, response);
- }
-
- void IApplicationProxy::GetLibraryAppletCreator(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_ILibraryAppletCreator, session, response);
- }
-
- void IApplicationProxy::GetApplicationFunctions(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_IApplicationFunctions, session, response);
- }
-
- void IApplicationProxy::IDebugFunctions(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- manager.NewService(Service::am_IDebugFunctions, session, response);
- }
-
- ICommonStateGetter::ICommonStateGetter(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, false, Service::am_ICommonStateGetter, {
- {0x0, SFunc(ICommonStateGetter::GetEventHandle)},
- {0x9, SFunc(ICommonStateGetter::GetCurrentFocusState)},
- {0x5, SFunc(ICommonStateGetter::GetOperationMode)},
- {0x6, SFunc(ICommonStateGetter::GetPerformanceMode)}
- }) {
- operationMode = static_cast(state.settings->GetBool("operation_mode"));
- state.logger->Write(Logger::Info, "Switch on mode: {}", static_cast(operationMode) ? "Docked" : "Handheld");
- }
-
- void ICommonStateGetter::GetEventHandle(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- auto event = state.thisProcess->NewHandle();
- messageEvent = event.item;
- response.copyHandles.push_back(event.handle);
- }
-
- void ICommonStateGetter::GetCurrentFocusState(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- response.WriteValue(static_cast(ApplicationStatus::InFocus));
- }
-
- void ICommonStateGetter::GetOperationMode(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- response.WriteValue(static_cast(operationMode));
- }
-
- void ICommonStateGetter::GetPerformanceMode(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- response.WriteValue(static_cast(operationMode));
- }
-
- ISelfController::ISelfController(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, false, Service::am_ISelfController, {
- {0xB, SFunc(ISelfController::SetOperationModeChangedNotification)},
- {0xC, SFunc(ISelfController::SetPerformanceModeChangedNotification)},
- {0xD, SFunc(ISelfController::SetFocusHandlingMode)}
- }) {}
-
- void ISelfController::SetFocusHandlingMode(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {}
-
- void ISelfController::SetOperationModeChangedNotification(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {}
-
- void ISelfController::SetPerformanceModeChangedNotification(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {}
-
- IWindowController::IWindowController(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, false, Service::am_IWindowController, {
- {0x1, SFunc(IWindowController::GetAppletResourceUserId)},
- {0xA, SFunc(IWindowController::AcquireForegroundRights)}
- }) {}
-
- void IWindowController::GetAppletResourceUserId(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- response.WriteValue(static_cast(state.thisProcess->mainThread));
- }
-
- void IWindowController::AcquireForegroundRights(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {}
-
- IAudioController::IAudioController(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, false, Service::am_IAudioController, {
- }) {}
-
- IDisplayController::IDisplayController(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, false, Service::am_IDisplayController, {
- }) {}
-
- ILibraryAppletCreator::ILibraryAppletCreator(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, false, Service::am_ILibraryAppletCreator, {
- }) {}
-
- IApplicationFunctions::IApplicationFunctions(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, false, Service::am_IApplicationFunctions, {
- {0x28, SFunc(IApplicationFunctions::NotifyRunning)}
- }) {}
-
- void IApplicationFunctions::NotifyRunning(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- response.WriteValue(1);
- }
-
- IDebugFunctions::IDebugFunctions(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, false, Service::am_IDebugFunctions, {
- }) {}
-}
diff --git a/app/src/main/cpp/skyline/kernel/services/fatal/fatal.cpp b/app/src/main/cpp/skyline/kernel/services/fatal/fatal.cpp
deleted file mode 100644
index e5fdd6db..00000000
--- a/app/src/main/cpp/skyline/kernel/services/fatal/fatal.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "fatal.h"
-
-namespace skyline::kernel::service::fatal {
- fatalU::fatalU(const DeviceState &state, ServiceManager& manager) : BaseService(state, manager, false, Service::fatal_u, {
- {0x0, SFunc(fatalU::ThrowFatal)},
- {0x1, SFunc(fatalU::ThrowFatal)},
- {0x2, SFunc(fatalU::ThrowFatal)}
- }) {}
-
- void fatalU::ThrowFatal(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
- throw exception(fmt::format("A fatal error with code: 0x{:X} has caused emulation to stop", *reinterpret_cast(request.cmdArg)));
- }
-}
diff --git a/app/src/main/cpp/skyline/kernel/svc.cpp b/app/src/main/cpp/skyline/kernel/svc.cpp
index b09fd70f..2b2dd46e 100644
--- a/app/src/main/cpp/skyline/kernel/svc.cpp
+++ b/app/src/main/cpp/skyline/kernel/svc.cpp
@@ -1,42 +1,103 @@
#include "svc.h"
#include
+#include
namespace skyline::kernel::svc {
void SetHeapSize(DeviceState &state) {
- auto heap = state.thisProcess->MapPrivateRegion(0, state.nce->GetRegister(Wreg::W1), {true, true, false}, memory::Type::Heap, memory::Region::Heap);
+ u32 size = state.nce->GetRegister(Wreg::W1);
+ std::shared_ptr heap;
+ try {
+ heap = state.thisProcess->memoryRegionMap.at(memory::Region::Heap);
+ heap->Resize(size, true); // This can fail due to not enough space to resize
+ } catch (const exception &) {
+ state.logger->Warn("svcSetHeapSize is falling back to recreating memory");
+ state.thisProcess->UnmapPrivateRegion(memory::Region::Heap);
+ heap = state.thisProcess->MapPrivateRegion(constant::HeapAddr, size, {true, true, false}, memory::Type::Heap, memory::Region::Heap).item;
+ }
state.nce->SetRegister(Wreg::W0, constant::status::Success);
- state.nce->SetRegister(Xreg::X1, heap.item->address);
- state.logger->Write(Logger::Debug, "Heap size was set to 0x{:X}", state.nce->GetRegister(Wreg::W1));
+ state.nce->SetRegister(Xreg::X1, heap->address);
+ state.logger->Debug("svcSetHeapSize allocated at 0x{:X} for 0x{:X} bytes", heap->address, heap->size);
+ }
+
+ void SetMemoryAttribute(DeviceState &state) {
+ u64 addr = state.nce->GetRegister(Xreg::X0);
+ u64 size = state.nce->GetRegister(Xreg::X1);
+ bool isUncached = (state.nce->GetRegister(Wreg::W2) == 8) && (state.nce->GetRegister(Wreg::W3) == 8);
+ bool found = false;
+ for (const auto&[address, region] : state.thisProcess->memoryMap) {
+ if (addr >= address && addr < (address + region->size)) {
+ bool subFound = false;
+ for (auto &subregion : region->regionInfoVec) {
+ if ((address >= subregion.address) && (address < (subregion.address + subregion.size)))
+ subregion.isUncached = isUncached;
+ subFound = true;
+ break;
+ }
+ if (!subFound)
+ region->regionInfoVec.push_back(memory::RegionInfo{.address=addr, .size=size, .isUncached=isUncached});
+ found = true;
+ break;
+ }
+ }
+ state.logger->Debug("svcSetMemoryAttribute set caching to {} at 0x{:X} for 0x{:X} bytes", !isUncached, addr, size);
+ state.nce->SetRegister(Wreg::W0, found ? constant::status::Success : constant::status::InvAddress);
}
void QueryMemory(DeviceState &state) {
memory::MemoryInfo memInf;
u64 addr = state.nce->GetRegister(Xreg::X2);
- bool memFree = true;
- for(const auto& [address, region] : state.thisProcess->memoryMap) {
+ bool found = false;
+ for (const auto&[address, region] : state.thisProcess->memoryMap) {
if (addr >= address && addr < (address + region->size)) {
- memInf = region->GetInfo();
- memFree = false;
+ memInf = region->GetInfo(addr);
+ found = true;
break;
}
}
- if (memFree) {
- memInf = {
- .baseAddress = static_cast(static_cast(addr / PAGE_SIZE) * PAGE_SIZE),
- .size = static_cast(-constant::BaseSize + 1),
- .type = static_cast(memory::Type::Unmapped),
+ if (!found) {
+ for (const auto &object : state.thisProcess->handleTable) {
+ if (object.second->objectType == type::KType::KSharedMemory) {
+ const auto &mem = state.thisProcess->GetHandle(object.first);
+ if (mem->procInfMap.count(state.thisProcess->mainThread)) {
+ const auto &map = mem->procInfMap.at(state.thisProcess->mainThread);
+ if (addr >= map.address && addr < (map.address + map.size)) {
+ memInf = mem->GetInfo(state.thisProcess->mainThread);
+ found = true;
+ break;
+ }
+ }
+ } else if (object.second->objectType == type::KType::KTransferMemory) {
+ const auto &mem = state.thisProcess->GetHandle(object.first);
+ if (addr >= mem->cAddress && addr < (mem->cAddress + mem->cSize)) {
+ memInf = mem->GetInfo();
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ memInf = {
+ .baseAddress = constant::BaseEnd,
+ .size = static_cast(-constant::BaseEnd + 1),
+ .type = static_cast(memory::Type::Unmapped)
};
+ state.logger->Warn("Cannot find block of address: 0x{:X}", addr);
+ }
}
state.thisProcess->WriteMemory(memInf, state.nce->GetRegister(Xreg::X0));
state.nce->SetRegister(Wreg::W0, constant::status::Success);
}
+ void ExitProcess(DeviceState &state) {
+ state.os->KillThread(state.thisProcess->mainThread);
+ }
+
void CreateThread(DeviceState &state) {
// TODO: Support Core Mask potentially
auto thread = state.thisProcess->CreateThread(state.nce->GetRegister(Xreg::X1), state.nce->GetRegister(Xreg::X2), state.nce->GetRegister(Xreg::X3), static_cast(state.nce->GetRegister(Wreg::W4)));
state.nce->SetRegister(Wreg::W0, constant::status::Success);
state.nce->SetRegister(Wreg::W1, thread->handle);
- state.logger->Write(Logger::Info, "Creating a thread: {}", thread->handle);
+ state.logger->Info("Creating a thread: {}", thread->handle);
}
void StartThread(DeviceState &state) {
@@ -53,14 +114,14 @@ namespace skyline::kernel::svc {
void SleepThread(DeviceState &state) {
auto in = state.nce->GetRegister(Xreg::X0);
- switch(in) {
+ switch (in) {
case 0:
case 1:
case 2:
- state.thisThread->status = type::KThread::ThreadStatus::Runnable; // Will cause the application to awaken on the next iteration of the main loop
+ state.thisThread->status = type::KThread::Status::Runnable; // Will cause the application to awaken on the next iteration of the main loop
default:
state.thisThread->timeout = GetCurrTimeNs() + in;
- state.thisThread->status = type::KThread::ThreadStatus::Sleeping;
+ state.thisThread->status = type::KThread::Status::Sleeping;
}
}
@@ -82,7 +143,7 @@ namespace skyline::kernel::svc {
void CloseHandle(DeviceState &state) {
auto handle = static_cast(state.nce->GetRegister(Wreg::W0));
- state.logger->Write(Logger::Debug, "Closing handle: 0x{:X}", handle);
+ state.logger->Debug("Closing handle: 0x{:X}", handle);
auto &object = state.thisProcess->handleTable.at(handle);
switch (object->objectType) {
case (type::KType::KThread):
@@ -97,6 +158,24 @@ namespace skyline::kernel::svc {
state.nce->SetRegister(Wreg::W0, constant::status::Success);
}
+ void CreateTransferMemory(DeviceState &state) {
+ u64 address = state.nce->GetRegister(Xreg::X1);
+ u64 size = state.nce->GetRegister(Xreg::X2);
+ u32 perms = state.nce->GetRegister(Wreg::W3);
+ auto shmem = state.thisProcess->NewHandle(state.thisProcess->mainThread, address, size, *reinterpret_cast(&perms));
+ state.nce->SetRegister(Wreg::W0, constant::status::Success);
+ state.nce->SetRegister(Wreg::W1, shmem.handle);
+ }
+
+ void ResetSignal(DeviceState &state) {
+ try {
+ state.thisProcess->GetHandle(state.nce->GetRegister(Wreg::W0))->ResetSignal();
+ } catch (const exception &) {
+ state.thisProcess->GetHandle(state.nce->GetRegister(Wreg::W0))->ResetSignal();
+ }
+ state.nce->SetRegister(Wreg::W0, constant::status::Success);
+ }
+
void WaitSynchronization(DeviceState &state) {
auto numHandles = state.nce->GetRegister(Wreg::W2);
if (numHandles > constant::MaxSyncHandles) {
@@ -105,9 +184,11 @@ namespace skyline::kernel::svc {
}
std::vector waitHandles(numHandles);
state.thisProcess->ReadMemory(waitHandles.data(), state.nce->GetRegister(Xreg::X1), numHandles * sizeof(handle_t));
- for (const auto& handle : waitHandles) {
+ std::string handleStr;
+ for (const auto &handle : waitHandles) {
+ handleStr += fmt::format("* 0x{:X}\n", handle);
auto object = state.thisProcess->handleTable.at(handle);
- switch(object->objectType) {
+ switch (object->objectType) {
case type::KType::KProcess:
case type::KType::KThread:
case type::KType::KEvent:
@@ -118,15 +199,34 @@ namespace skyline::kernel::svc {
return;
}
auto syncObject = std::static_pointer_cast(object);
- if(syncObject->signalled) {
+ if (syncObject->signalled) {
+ state.logger->Debug("Found signalled handle: 0x{:X}", handle);
state.nce->SetRegister(Wreg::W0, constant::status::Success);
+ state.nce->SetRegister(Wreg::W1, handle);
return;
}
state.thisThread->waitObjects.push_back(syncObject);
- syncObject->waitThreads.push_back(state.thisThread->pid);
+ syncObject->waitThreads.emplace_back(state.thisThread->pid, handle);
}
- state.thisThread->timeout = GetCurrTimeNs() + state.nce->GetRegister(Xreg::X3);
- state.thisThread->status = type::KThread::ThreadStatus::WaitSync;
+ state.logger->Debug("Waiting on handles:\n{}Timeout: 0x{:X} ns", handleStr, state.nce->GetRegister(Xreg::X3));
+ if (state.nce->GetRegister(Xreg::X3) != std::numeric_limits::max())
+ state.thisThread->timeout = GetCurrTimeNs() + state.nce->GetRegister(Xreg::X3);
+ else
+ state.thisThread->timeout = 0;
+ state.thisThread->status = type::KThread::Status::WaitSync;
+ }
+
+ void GetSystemTick(DeviceState &state) {
+ u64 tick{};
+ asm("STR X1, [SP, #-16]!\n\t"
+ "MRS %0, CNTVCT_EL0\n\t"
+ "MOV X1, #0xF800\n\t"
+ "MOVK X1, #0x124, lsl #16\n\t"
+ "MUL %0, %0, X1\n\t"
+ "MRS X1, CNTFRQ_EL0\n\t"
+ "UDIV %0, %0, X1\n\t"
+ "LDR X1, [SP], #16" : "=r"(tick));
+ state.nce->SetRegister(Xreg::X0, tick);
}
void ArbitrateLock(DeviceState &state) {
@@ -156,7 +256,7 @@ namespace skyline::kernel::svc {
break;
}
}
- state.thisThread->status = type::KThread::ThreadStatus::WaitCondVar;
+ state.thisThread->status = type::KThread::Status::WaitCondVar;
state.thisThread->timeout = GetCurrTimeNs() + state.nce->GetRegister(Xreg::X3);
state.nce->SetRegister(Wreg::W0, constant::status::Success);
}
@@ -170,7 +270,7 @@ namespace skyline::kernel::svc {
auto &cvarVec = state.thisProcess->condVarMap[address];
count = std::min(count, static_cast(cvarVec.size()));
for (uint index = 0; index < count; index++)
- cvarVec[index]->status = type::KThread::ThreadStatus::Runnable;
+ cvarVec[index]->status = type::KThread::Status::Runnable;
cvarVec.erase(cvarVec.begin(), cvarVec.begin() + count);
if (cvarVec.empty())
state.thisProcess->condVarMap.erase(address);
@@ -182,7 +282,7 @@ namespace skyline::kernel::svc {
if (std::strcmp(port, "sm:") == 0)
state.nce->SetRegister(Wreg::W1, state.os->serviceManager.NewSession(service::Service::sm));
else
- throw exception(fmt::format("svcConnectToNamedPort tried connecting to invalid port: \"{}\"", port));
+ throw exception("svcConnectToNamedPort tried connecting to invalid port: \"{}\"", port);
state.nce->SetRegister(Wreg::W0, constant::status::Success);
}
@@ -191,18 +291,26 @@ namespace skyline::kernel::svc {
state.nce->SetRegister(Wreg::W0, constant::status::Success);
}
+ void GetThreadId(DeviceState &state) {
+ pid_t pid{};
+ if (state.nce->GetRegister(Wreg::W1) != constant::ThreadSelf) {
+ handle_t thread = state.nce->GetRegister(Wreg::W1);
+ pid = state.thisProcess->GetHandle(thread)->pid;
+ } else
+ pid = state.thisThread->pid;
+ state.nce->SetRegister(Xreg::X1, static_cast(pid));
+ state.nce->SetRegister(Wreg::W0, constant::status::Success);
+ }
+
void OutputDebugString(DeviceState &state) {
std::string debug(state.nce->GetRegister(Xreg::X1), '\0');
- state.os->thisProcess->ReadMemory((void *) debug.data(), state.nce->GetRegister(Xreg::X0), state.nce->GetRegister(Xreg::X1));
- std::string::size_type pos = 0;
- while ((pos = debug.find("\r\n", pos)) != std::string::npos)
- debug.erase(pos, 2);
- state.logger->Write(Logger::Info, "Debug Output: {}", debug);
- state.nce->SetRegister(Wreg::W0, 0);
+ state.os->thisProcess->ReadMemory(debug.data(), state.nce->GetRegister(Xreg::X0), state.nce->GetRegister(Xreg::X1));
+ state.logger->Info("Debug Output: {}", debug);
+ state.nce->SetRegister(Wreg::W0, constant::status::Success);
}
void GetInfo(DeviceState &state) {
- state.logger->Write(Logger::Debug, "svcGetInfo called with ID0: {}, ID1: {}", state.nce->GetRegister(Wreg::W1), state.nce->GetRegister(Xreg::X3));
+ state.logger->Debug("svcGetInfo called with ID0: {}, ID1: {}", state.nce->GetRegister(Wreg::W1), state.nce->GetRegister(Xreg::X3));
switch (state.nce->GetRegister(Wreg::W1)) {
case constant::infoState::AllowedCpuIdBitmask:
case constant::infoState::AllowedThreadPriorityMask:
@@ -257,14 +365,10 @@ namespace skyline::kernel::svc {
state.nce->SetRegister(Xreg::X1, state.thisProcess->tlsPages[0]->Get(0));
break;
default:
- state.logger->Write(Logger::Warn, "Unimplemented svcGetInfo with ID0: {}, ID1: {}", state.nce->GetRegister(Wreg::W1), state.nce->GetRegister(Xreg::X3));
+ state.logger->Warn("Unimplemented svcGetInfo with ID0: {}, ID1: {}", state.nce->GetRegister(Wreg::W1), state.nce->GetRegister(Xreg::X3));
state.nce->SetRegister(Wreg::W0, constant::status::Unimpl);
return;
}
state.nce->SetRegister(Wreg::W0, constant::status::Success);
}
-
- void ExitProcess(DeviceState &state) {
- state.os->KillThread(state.thisProcess->mainThread);
- }
}
diff --git a/app/src/main/cpp/skyline/kernel/svc.h b/app/src/main/cpp/skyline/kernel/svc.h
index a80c0812..b9f3ebba 100644
--- a/app/src/main/cpp/skyline/kernel/svc.h
+++ b/app/src/main/cpp/skyline/kernel/svc.h
@@ -42,7 +42,12 @@ namespace skyline {
void SetHeapSize(DeviceState &state);
/**
- * @brief Query information about an address. Will always fetch the lowest page-aligned mapping that contains the provided address (https://switchbrew.org/wiki/SVC#svcQueryMemory)
+ * @brief Change attribute of page-aligned memory region. This is used to turn on/off caching for a given memory area. (https://switchbrew.org/wiki/SVC#svcSetMemoryAttribute)
+ */
+ void SetMemoryAttribute(DeviceState &state);
+
+ /**
+ * @brief Query information about an address (https://switchbrew.org/wiki/SVC#svcQueryMemory)
*/
void QueryMemory(DeviceState &state);
@@ -91,11 +96,26 @@ namespace skyline {
*/
void CloseHandle(DeviceState &state);
+ /**
+ * @brief Returns a handle to a KSharedMemory object (https://switchbrew.org/wiki/SVC#svcCreateTransferMemory)
+ */
+ void CreateTransferMemory(DeviceState &state);
+
+ /**
+ * @brief This resets a particular KEvent or KProcess which is signalled (https://switchbrew.org/wiki/SVC#svcResetSignal)
+ */
+ void ResetSignal(DeviceState &state);
+
/**
* @brief Stalls a thread till a KSyncObject signals or the timeout has ended (https://switchbrew.org/wiki/SVC#svcWaitSynchronization)
*/
void WaitSynchronization(DeviceState &state);
+ /**
+ * @brief This returns the value of CNTPCT_EL0 on the Switch (https://switchbrew.org/wiki/SVC#svcGetSystemTick)
+ */
+ void GetSystemTick(DeviceState &state);
+
/**
* @brief Locks a specified mutex
*/
@@ -126,6 +146,11 @@ namespace skyline {
*/
void SendSyncRequest(DeviceState &state);
+ /**
+ * @brief Retrieves the PID of a specific thread
+ */
+ void GetThreadId(DeviceState &state);
+
/**
* @brief Outputs a debug string
*/
@@ -143,7 +168,7 @@ namespace skyline {
nullptr, // 0x00 (Does not exist)
SetHeapSize, // 0x01
nullptr, // 0x02
- nullptr, // 0x03
+ SetMemoryAttribute, // 0x03
nullptr, // 0x04
nullptr, // 0x05
QueryMemory, // 0x06
@@ -161,23 +186,23 @@ namespace skyline {
nullptr, // 0x12
MapSharedMemory, // 0x13
nullptr, // 0x14
- nullptr, // 0x15
+ CreateTransferMemory, // 0x15
CloseHandle, // 0x16
- nullptr, // 0x17
+ ResetSignal, // 0x17
WaitSynchronization, // 0x18
nullptr, // 0x19
ArbitrateLock, // 0x1a
ArbitrateUnlock, // 0x1b
WaitProcessWideKeyAtomic, // 0x1c
SignalProcessWideKey, // 0x1d
- nullptr, // 0x1e
+ GetSystemTick, // 0x1e
ConnectToNamedPort, // 0x1f
nullptr, // 0x20
SendSyncRequest, // 0x21
nullptr, // 0x22
nullptr, // 0x23
nullptr, // 0x24
- nullptr, // 0x25
+ GetThreadId, // 0x25
nullptr, // 0x26
OutputDebugString, // 0x27
nullptr, // 0x28
diff --git a/app/src/main/cpp/skyline/kernel/types/KEvent.h b/app/src/main/cpp/skyline/kernel/types/KEvent.h
index 9eb7cf30..eb529961 100644
--- a/app/src/main/cpp/skyline/kernel/types/KEvent.h
+++ b/app/src/main/cpp/skyline/kernel/types/KEvent.h
@@ -17,8 +17,10 @@ namespace skyline::kernel::type {
* @brief Signals all threads waiting on this object
*/
virtual inline void Signal() {
- KSyncObject::Signal();
- signalled = true;
+ if (!signalled) {
+ KSyncObject::Signal();
+ signalled = true;
+ }
}
/**
diff --git a/app/src/main/cpp/skyline/kernel/types/KPrivateMemory.cpp b/app/src/main/cpp/skyline/kernel/types/KPrivateMemory.cpp
index 7930b8b0..ecc3ab8e 100644
--- a/app/src/main/cpp/skyline/kernel/types/KPrivateMemory.cpp
+++ b/app/src/main/cpp/skyline/kernel/types/KPrivateMemory.cpp
@@ -24,41 +24,48 @@ namespace skyline::kernel::type {
this->address = fregs.regs[0];
}
- u64 RemapPrivateFunc(u64 address, size_t oldSize, size_t size) {
+ u64 RemapPrivateFunc(u64 address, size_t oldSize, size_t size, u64 perms) {
return reinterpret_cast(mremap(reinterpret_cast(address), oldSize, size, 0));
}
- void KPrivateMemory::Resize(size_t newSize) {
+ u64 KPrivateMemory::Resize(size_t newSize, bool canMove) {
user_pt_regs fregs = {0};
fregs.regs[0] = address;
fregs.regs[1] = size;
fregs.regs[2] = newSize;
+ fregs.regs[3] = static_cast(PROT_READ | PROT_WRITE);
state.nce->ExecuteFunction(reinterpret_cast(RemapPrivateFunc), fregs, owner);
if (reinterpret_cast(fregs.regs[0]) == MAP_FAILED)
throw exception("An error occurred while remapping private region in child process");
+ address = fregs.regs[0];
size = newSize;
+ return address;
}
u64 UpdatePermissionPrivateFunc(u64 address, size_t size, u64 perms) {
return static_cast(mprotect(reinterpret_cast(address), size, static_cast(perms)));
}
- void KPrivateMemory::UpdatePermission(memory::Permission newPerms) {
+ void KPrivateMemory::UpdatePermission(memory::Permission permission) {
user_pt_regs fregs = {0};
fregs.regs[0] = address;
fregs.regs[1] = size;
- fregs.regs[2] = static_cast(newPerms.Get());
+ fregs.regs[2] = static_cast(permission.Get());
state.nce->ExecuteFunction(reinterpret_cast(UpdatePermissionPrivateFunc), fregs, owner);
if (static_cast
diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
index 1b22c1bb..df154f43 100644
--- a/app/CMakeLists.txt
+++ b/app/CMakeLists.txt
@@ -1,21 +1,32 @@
cmake_minimum_required(VERSION 3.8)
-project(Skyline VERSION 0.3 LANGUAGES CXX)
+project(Skyline VERSION 0.3)
set(BUILD_TESTING OFF)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(source_DIR ${CMAKE_SOURCE_DIR}/src/main/cpp)
set(CMAKE_CXX_FLAGS_RELEASE "-Ofast -flto=full -Wno-unused-command-line-argument")
+if (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
+ add_compile_definitions(NDEBUG)
+endif()
+
add_subdirectory("libraries/tinyxml2")
add_subdirectory("libraries/fmt")
-set(source_DIR ${CMAKE_SOURCE_DIR}/src/main/cpp)
-
include_directories(${source_DIR}/skyline)
add_library(skyline SHARED
${source_DIR}/main.cpp
${source_DIR}/skyline/common.cpp
${source_DIR}/skyline/nce.cpp
+ ${source_DIR}/skyline/gpu.cpp
+ ${source_DIR}/skyline/gpu/display.cpp
+ ${source_DIR}/skyline/gpu/parcel.cpp
+ ${source_DIR}/skyline/gpu/devices/nvhost_ctrl.cpp
+ ${source_DIR}/skyline/gpu/devices/nvhost_ctrl_gpu.cpp
+ ${source_DIR}/skyline/gpu/devices/nvhost_channel.cpp
+ ${source_DIR}/skyline/gpu/devices/nvmap.cpp
+ ${source_DIR}/skyline/gpu/devices/nvhost_as_gpu.cpp
${source_DIR}/skyline/os.cpp
${source_DIR}/skyline/loader/nro.cpp
${source_DIR}/skyline/kernel/ipc.cpp
@@ -26,15 +37,20 @@ add_library(skyline SHARED
${source_DIR}/skyline/kernel/types/KSharedMemory.cpp
${source_DIR}/skyline/kernel/types/KTransferMemory.cpp
${source_DIR}/skyline/kernel/types/KPrivateMemory.cpp
- ${source_DIR}/skyline/kernel/services/serviceman.cpp
- ${source_DIR}/skyline/kernel/services/sm/sm.cpp
- ${source_DIR}/skyline/kernel/services/fatal/fatal.cpp
- ${source_DIR}/skyline/kernel/services/set/sys.cpp
- ${source_DIR}/skyline/kernel/services/apm/apm.cpp
- ${source_DIR}/skyline/kernel/services/am/appletOE.cpp
- ${source_DIR}/skyline/kernel/services/hid/hid.cpp
- ${source_DIR}/skyline/kernel/services/time/time.cpp
- ${source_DIR}/skyline/kernel/services/fs/fs.cpp
+ ${source_DIR}/skyline/services/serviceman.cpp
+ ${source_DIR}/skyline/services/sm/sm.cpp
+ ${source_DIR}/skyline/services/fatal/fatal.cpp
+ ${source_DIR}/skyline/services/set/sys.cpp
+ ${source_DIR}/skyline/services/apm/apm.cpp
+ ${source_DIR}/skyline/services/am/applet.cpp
+ ${source_DIR}/skyline/services/am/appletController.cpp
+ ${source_DIR}/skyline/services/hid/hid.cpp
+ ${source_DIR}/skyline/services/time/time.cpp
+ ${source_DIR}/skyline/services/fs/fs.cpp
+ ${source_DIR}/skyline/services/nvdrv/nvdrv.cpp
+ ${source_DIR}/skyline/services/nvnflinger/dispdrv.cpp
+ ${source_DIR}/skyline/services/vi/vi_m.cpp
)
-target_link_libraries(skyline fmt tinyxml2)
+
+target_link_libraries(skyline vulkan GLESv3 EGL android fmt tinyxml2)
target_compile_options(skyline PRIVATE -Wno-c++17-extensions)
diff --git a/app/build.gradle b/app/build.gradle
index 1c2bc437..671b3cf7 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -5,7 +5,7 @@ android {
buildToolsVersion '29.0.2'
defaultConfig {
applicationId "skyline.emu"
- minSdkVersion 26
+ minSdkVersion 24
targetSdkVersion 29
versionCode 3
versionName "0.3"
@@ -16,6 +16,11 @@ android {
buildTypes {
release {
debuggable true
+ externalNativeBuild {
+ cmake {
+ arguments "-DCMAKE_BUILD_TYPE=RELEASE"
+ }
+ }
minifyEnabled true
shrinkResources true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
@@ -33,11 +38,6 @@ android {
path "CMakeLists.txt"
}
}
- sourceSets {
- main {
- jni.srcDirs = ['src/main/cpp/unicorn/lib']
- }
- }
compileOptions {
sourceCompatibility = 1.8
targetCompatibility = 1.8
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index daaa672b..b4346405 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -7,15 +7,19 @@