From 7cd4495ed1791ab008627cbf38682c7f690dea5d Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Thu, 16 Jan 2025 10:09:36 +0200 Subject: [PATCH] cleanup and fixes to Aio --- CMakeLists.txt | 2 + src/core/libraries/kernel/aio.cpp | 339 +++++++++++++++++++++++++++ src/core/libraries/kernel/aio.h | 43 ++++ src/core/libraries/kernel/kernel.cpp | 263 +-------------------- 4 files changed, 386 insertions(+), 261 deletions(-) create mode 100644 src/core/libraries/kernel/aio.cpp create mode 100644 src/core/libraries/kernel/aio.h diff --git a/CMakeLists.txt b/CMakeLists.txt index be87de119..30cb033ed 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -250,6 +250,8 @@ set(KERNEL_LIB src/core/libraries/kernel/sync/mutex.cpp src/core/libraries/kernel/time.h src/core/libraries/kernel/orbis_error.h src/core/libraries/kernel/posix_error.h + src/core/libraries/kernel/aio.cpp + src/core/libraries/kernel/aio.h ) set(NETWORK_LIBS src/core/libraries/network/http.cpp diff --git a/src/core/libraries/kernel/aio.cpp b/src/core/libraries/kernel/aio.cpp new file mode 100644 index 000000000..e017010cb --- /dev/null +++ b/src/core/libraries/kernel/aio.cpp @@ -0,0 +1,339 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include + +#include "aio.h" +#include "common/assert.h" +#include "common/debug.h" +#include "common/logging/log.h" +#include "core/libraries/kernel/equeue.h" +#include "core/libraries/kernel/orbis_error.h" +#include "core/libraries/libs.h" +#include "file_system.h" + +namespace Libraries::Kernel { + +#define MAX_QUEUE 512 + +static s32* id_state; +static s32 id_index; + +s32 sceKernelAioInitializeImpl(void* p, s32 size) { + + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioDeleteRequest(OrbisKernelAioSubmitId id, s32* ret) { + if (ret == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + id_state[id] = ORBIS_KERNEL_AIO_STATE_ABORTED; + *ret = 0; + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioDeleteRequests(OrbisKernelAioSubmitId id[], s32 num, s32 ret[]) { + if (ret == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + for (s32 i = 0; i < num; i++) { + id_state[id[i]] = ORBIS_KERNEL_AIO_STATE_ABORTED; + ret[i] = 0; + } + + return 0; +} +s32 PS4_SYSV_ABI sceKernelAioPollRequest(OrbisKernelAioSubmitId id, s32* state) { + if (state == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + *state = id_state[id]; + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioPollRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[]) { + if (state == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + for (s32 i = 0; i < num; i++) { + state[i] = id_state[id[i]]; + } + + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioCancelRequest(OrbisKernelAioSubmitId id, s32* state) { + if (state == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + if (id) { + id_state[id] = ORBIS_KERNEL_AIO_STATE_ABORTED; + *state = ORBIS_KERNEL_AIO_STATE_ABORTED; + } else { + *state = ORBIS_KERNEL_AIO_STATE_PROCESSING; + } + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioCancelRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[]) { + if (state == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + for (s32 i = 0; i < num; i++) { + if (id[i]) { + id_state[id[i]] = ORBIS_KERNEL_AIO_STATE_ABORTED; + state[i] = ORBIS_KERNEL_AIO_STATE_ABORTED; + } else { + state[i] = ORBIS_KERNEL_AIO_STATE_PROCESSING; + } + } + + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioWaitRequest(OrbisKernelAioSubmitId id, s32* state, u32* usec) { + if (state == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + u32 timer = 0; + + s32 timeout = 0; + + while (id_state[id] == ORBIS_KERNEL_AIO_STATE_PROCESSING) { + sceKernelUsleep(10); + + timer += 10; + if (*usec) { + if (timer > *usec) { + timeout = 1; + break; + } + } + } + + *state = id_state[id]; + + if (timeout) + return ORBIS_KERNEL_ERROR_ETIMEDOUT; + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioWaitRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[], + u32 mode, u32* usec) { + if (state == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + u32 timer = 0; + s32 timeout = 0; + s32 completion = 0; + + for (s32 i = 0; i < num; i++) { + if (!completion && !timeout) { + while (id_state[id[i]] == ORBIS_KERNEL_AIO_STATE_PROCESSING) { + sceKernelUsleep(10); + timer += 10; + + if (*usec) { + if (timer > *usec) { + timeout = 1; + break; + } + } + } + } + + if (mode == 0x02) { + if (id_state[id[i]] == ORBIS_KERNEL_AIO_STATE_COMPLETED) + completion = 1; + } + + state[i] = id_state[id[i]]; + } + + if (timeout) + return ORBIS_KERNEL_ERROR_ETIMEDOUT; + + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioSubmitReadCommands(OrbisKernelAioRWRequest req[], s32 size, s32 prio, + OrbisKernelAioSubmitId* id) { + if (req == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + if (id == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING; + + for (s32 i = 0; i < size; i++) { + + s64 ret = sceKernelPread(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset); + + if (ret < 0) { + req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED; + req[i].result->returnValue = ret; + + } else { + req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED; + req[i].result->returnValue = ret; + } + } + + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED; + + *id = id_index; + + id_index = (id_index + 1) % MAX_QUEUE; + + if (!id_index) + id_index++; + + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioSubmitReadCommandsMultiple(OrbisKernelAioRWRequest req[], s32 size, + s32 prio, OrbisKernelAioSubmitId id[]) { + if (req == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + if (id == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + for (s32 i = 0; i < size; i++) { + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING; + + s64 ret = sceKernelPread(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset); + + if (ret < 0) { + req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED; + req[i].result->returnValue = ret; + + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED; + + } else { + req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED; + req[i].result->returnValue = ret; + + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED; + } + + id[i] = id_index; + + id_index = (id_index + 1) % MAX_QUEUE; + + if (!id_index) + id_index++; + } + + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioSubmitWriteCommands(OrbisKernelAioRWRequest req[], s32 size, s32 prio, + OrbisKernelAioSubmitId* id) { + if (req == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + if (id == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + for (s32 i = 0; i < size; i++) { + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING; + + s64 ret = sceKernelPwrite(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset); + + if (ret < 0) { + req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED; + req[i].result->returnValue = ret; + + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED; + + } else { + req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED; + req[i].result->returnValue = ret; + + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED; + } + } + + *id = id_index; + + id_index = (id_index + 1) % MAX_QUEUE; + + // skip id_index equals 0 , because sceKernelAioCancelRequest will submit id + // equal to 0 + if (!id_index) + id_index++; + + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioSubmitWriteCommandsMultiple(OrbisKernelAioRWRequest req[], s32 size, + s32 prio, OrbisKernelAioSubmitId id[]) { + if (req == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + if (id == nullptr) { + return ORBIS_KERNEL_ERROR_EFAULT; + } + for (s32 i = 0; i < size; i++) { + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING; + s64 ret = sceKernelPwrite(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset); + + if (ret < 0) { + req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED; + req[i].result->returnValue = ret; + + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED; + + } else { + req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED; + req[i].result->returnValue = ret; + id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED; + } + + id[i] = id_index; + id_index = (id_index + 1) % MAX_QUEUE; + + if (!id_index) + id_index++; + } + return 0; +} + +s32 PS4_SYSV_ABI sceKernelAioSetParam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceKernelAioInitializeParam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterAio(Core::Loader::SymbolsResolver* sym) { + id_index = 1; + id_state = (int*)malloc(sizeof(int) * MAX_QUEUE); + memset(id_state, 0, sizeof(sizeof(int) * MAX_QUEUE)); + + LIB_FUNCTION("fR521KIGgb8", "libkernel", 1, "libkernel", 1, 1, sceKernelAioCancelRequest); + LIB_FUNCTION("3Lca1XBrQdY", "libkernel", 1, "libkernel", 1, 1, sceKernelAioCancelRequests); + LIB_FUNCTION("5TgME6AYty4", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequest); + LIB_FUNCTION("Ft3EtsZzAoY", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequests); + LIB_FUNCTION("vYU8P9Td2Zo", "libkernel", 1, "libkernel", 1, 1, sceKernelAioInitializeImpl); + LIB_FUNCTION("nu4a0-arQis", "libkernel", 1, "libkernel", 1, 1, sceKernelAioInitializeParam); + LIB_FUNCTION("2pOuoWoCxdk", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequest); + LIB_FUNCTION("o7O4z3jwKzo", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequests); + LIB_FUNCTION("9WK-vhNXimw", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSetParam); + LIB_FUNCTION("HgX7+AORI58", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitReadCommands); + LIB_FUNCTION("lXT0m3P-vs4", "libkernel", 1, "libkernel", 1, 1, + sceKernelAioSubmitReadCommandsMultiple); + LIB_FUNCTION("XQ8C8y+de+E", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitWriteCommands); + LIB_FUNCTION("xT3Cpz0yh6Y", "libkernel", 1, "libkernel", 1, 1, + sceKernelAioSubmitWriteCommandsMultiple); + LIB_FUNCTION("KOF-oJbQVvc", "libkernel", 1, "libkernel", 1, 1, sceKernelAioWaitRequest); + LIB_FUNCTION("lgK+oIWkJyA", "libkernel", 1, "libkernel", 1, 1, sceKernelAioWaitRequests); +} + +} // namespace Libraries::Kernel \ No newline at end of file diff --git a/src/core/libraries/kernel/aio.h b/src/core/libraries/kernel/aio.h new file mode 100644 index 000000000..0ad21e938 --- /dev/null +++ b/src/core/libraries/kernel/aio.h @@ -0,0 +1,43 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include +#include +#include + +#include "common/types.h" + +namespace Core::Loader { +class SymbolsResolver; +} + +namespace Libraries::Kernel { + +enum AioState { + ORBIS_KERNEL_AIO_STATE_SUBMITTED = 1, + ORBIS_KERNEL_AIO_STATE_PROCESSING = 2, + ORBIS_KERNEL_AIO_STATE_COMPLETED = 3, + ORBIS_KERNEL_AIO_STATE_ABORTED = 4 +}; + +struct OrbisKernelAioResult { + s64 returnValue; + u32 state; +}; + +typedef s32 OrbisKernelAioSubmitId; + +struct OrbisKernelAioRWRequest { + s64 offset; + s64 nbyte; + void* buf; + OrbisKernelAioResult* result; + s32 fd; +}; + +void RegisterAio(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::Kernel \ No newline at end of file diff --git a/src/core/libraries/kernel/kernel.cpp b/src/core/libraries/kernel/kernel.cpp index 52449dd37..a9d04ca38 100644 --- a/src/core/libraries/kernel/kernel.cpp +++ b/src/core/libraries/kernel/kernel.cpp @@ -28,6 +28,7 @@ #include #endif #include +#include "aio.h" namespace Libraries::Kernel { @@ -207,265 +208,8 @@ int PS4_SYSV_ABI posix_getpagesize() { return 16_KB; } -#define MAX_QUEUE 512 -#define SCE_KERNEL_AIO_STATE_SUBMITTED (1) -#define SCE_KERNEL_AIO_STATE_PROCESSING (2) -#define SCE_KERNEL_AIO_STATE_COMPLETED (3) -#define SCE_KERNEL_AIO_STATE_ABORTED (4) - -typedef struct SceKernelAioResult { - s64 returnValue; - u32 state; -} SceKernelAioResult; - -typedef s32 SceKernelAioSubmitId; - -typedef struct SceKernelAioRWRequest { - s64 offset; - s64 nbyte; - void* buf; - struct SceKernelAioResult* result; - s32 fd; -} SceKernelAioRWRequest; - -static s32* id_state; -static s32 id_index; - -s32 PS4_SYSV_ABI sceKernelAioDeleteRequest(SceKernelAioSubmitId id, s32* ret) { - id_state[id] = SCE_KERNEL_AIO_STATE_ABORTED; - *ret = 0; - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioDeleteRequests(SceKernelAioSubmitId id[], s32 num, s32 ret[]) { - for (s32 i = 0; i < num; i++) { - id_state[id[i]] = SCE_KERNEL_AIO_STATE_ABORTED; - ret[i] = 0; - } - - return 0; -} -s32 PS4_SYSV_ABI sceKernelAioPollRequest(SceKernelAioSubmitId id, s32* state) { - *state = id_state[id]; - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioPollRequests(SceKernelAioSubmitId id[], s32 num, s32 state[]) { - for (s32 i = 0; i < num; i++) { - state[i] = id_state[id[i]]; - } - - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioCancelRequest(SceKernelAioSubmitId id, s32* state) { - if (id) { - id_state[id] = SCE_KERNEL_AIO_STATE_ABORTED; - *state = SCE_KERNEL_AIO_STATE_ABORTED; - } else { - *state = SCE_KERNEL_AIO_STATE_PROCESSING; - } - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioCancelRequests(SceKernelAioSubmitId id[], s32 num, s32 state[]) { - for (s32 i = 0; i < num; i++) { - if (id[i]) { - id_state[id[i]] = SCE_KERNEL_AIO_STATE_ABORTED; - state[i] = SCE_KERNEL_AIO_STATE_ABORTED; - } else { - state[i] = SCE_KERNEL_AIO_STATE_PROCESSING; - } - } - - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioWaitRequest(SceKernelAioSubmitId id, s32* state, u32* usec) { - u32 timer = 0; - - s32 timeout = 0; - - while (id_state[id] == SCE_KERNEL_AIO_STATE_PROCESSING) { - sceKernelUsleep(10); - - timer += 10; - if (*usec) { - if (timer > *usec) { - timeout = 1; - break; - } - } - } - - *state = id_state[id]; - - if (timeout) - return 0x8002003c; - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioWaitRequests(SceKernelAioSubmitId id[], s32 num, s32 state[], u32 mode, - u32* usec) { - u32 timer = 0; - s32 timeout = 0; - s32 completion = 0; - - for (s32 i = 0; i < num; i++) { - if (!completion && !timeout) { - while (id_state[id[i]] == SCE_KERNEL_AIO_STATE_PROCESSING) { - sceKernelUsleep(10); - timer += 10; - - if (*usec) { - if (timer > *usec) { - timeout = 1; - break; - } - } - } - } - - if (mode == 0x02) { - if (id_state[id[i]] == SCE_KERNEL_AIO_STATE_COMPLETED) - completion = 1; - } - - state[i] = id_state[id[i]]; - } - - if (timeout) - return 0x8002003c; - - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioSubmitReadCommands(SceKernelAioRWRequest req[], s32 size, s32 prio, - SceKernelAioSubmitId* id) { - - id_state[id_index] = SCE_KERNEL_AIO_STATE_PROCESSING; - - for (s32 i = 0; i < size; i++) { - - s64 ret = sceKernelPread(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset); - - if (ret < 0) { - req[i].result->state = SCE_KERNEL_AIO_STATE_ABORTED; - req[i].result->returnValue = ret; - - } else { - req[i].result->state = SCE_KERNEL_AIO_STATE_COMPLETED; - req[i].result->returnValue = ret; - } - } - - id_state[id_index] = SCE_KERNEL_AIO_STATE_COMPLETED; - - *id = id_index; - - id_index = (id_index + 1) % MAX_QUEUE; - - if (!id_index) - id_index++; - - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioSubmitReadCommandsMultiple(SceKernelAioRWRequest req[], s32 size, - s32 prio, SceKernelAioSubmitId id[]) { - for (s32 i = 0; i < size; i++) { - id_state[id_index] = SCE_KERNEL_AIO_STATE_PROCESSING; - - s64 ret = sceKernelPread(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset); - - if (ret < 0) { - req[i].result->state = SCE_KERNEL_AIO_STATE_ABORTED; - req[i].result->returnValue = ret; - - id_state[id_index] = SCE_KERNEL_AIO_STATE_ABORTED; - - } else { - req[i].result->state = SCE_KERNEL_AIO_STATE_COMPLETED; - req[i].result->returnValue = ret; - - id_state[id_index] = SCE_KERNEL_AIO_STATE_COMPLETED; - } - - id[i] = id_index; - - id_index = (id_index + 1) % MAX_QUEUE; - - if (!id_index) - id_index++; - } - - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioSubmitWriteCommands(SceKernelAioRWRequest req[], s32 size, s32 prio, - SceKernelAioSubmitId* id) { - for (s32 i = 0; i < size; i++) { - id_state[id_index] = SCE_KERNEL_AIO_STATE_PROCESSING; - - s64 ret = sceKernelPwrite(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset); - - if (ret < 0) { - req[i].result->state = SCE_KERNEL_AIO_STATE_ABORTED; - req[i].result->returnValue = ret; - - id_state[id_index] = SCE_KERNEL_AIO_STATE_ABORTED; - - } else { - req[i].result->state = SCE_KERNEL_AIO_STATE_COMPLETED; - req[i].result->returnValue = ret; - - id_state[id_index] = SCE_KERNEL_AIO_STATE_COMPLETED; - } - } - - *id = id_index; - - id_index = (id_index + 1) % MAX_QUEUE; - - // skip id_index equals 0 , because sceKernelAioCancelRequest will submit id - // equal to 0 - if (!id_index) - id_index++; - - return 0; -} - -s32 PS4_SYSV_ABI sceKernelAioSubmitWriteCommandsMultiple(SceKernelAioRWRequest req[], s32 size, - s32 prio, SceKernelAioSubmitId id[]) { - for (s32 i = 0; i < size; i++) { - id_state[id_index] = SCE_KERNEL_AIO_STATE_PROCESSING; - s64 ret = sceKernelPwrite(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset); - - if (ret < 0) { - req[i].result->state = SCE_KERNEL_AIO_STATE_ABORTED; - req[i].result->returnValue = ret; - - id_state[id_index] = SCE_KERNEL_AIO_STATE_ABORTED; - - } else { - req[i].result->state = SCE_KERNEL_AIO_STATE_COMPLETED; - req[i].result->returnValue = ret; - id_state[id_index] = SCE_KERNEL_AIO_STATE_COMPLETED; - } - - id[i] = id_index; - id_index = (id_index + 1) % MAX_QUEUE; - - if (!id_index) - id_index++; - } - return 0; -} void RegisterKernel(Core::Loader::SymbolsResolver* sym) { service_thread = std::jthread{KernelServiceThread}; - id_index = 1; - id_state = (int*)malloc(sizeof(int) * MAX_QUEUE); - memset(id_state, 0, sizeof(sizeof(int) * MAX_QUEUE)); Libraries::Kernel::RegisterFileSystem(sym); Libraries::Kernel::RegisterTime(sym); @@ -475,6 +219,7 @@ void RegisterKernel(Core::Loader::SymbolsResolver* sym) { Libraries::Kernel::RegisterEventQueue(sym); Libraries::Kernel::RegisterProcess(sym); Libraries::Kernel::RegisterException(sym); + Libraries::Kernel::RegisterAio(sym); LIB_OBJ("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, &g_stack_chk_guard); LIB_FUNCTION("PfccT7qURYE", "libkernel", 1, "libkernel", 1, 1, kernel_ioctl); @@ -491,10 +236,6 @@ void RegisterKernel(Core::Loader::SymbolsResolver* sym) { sceLibcHeapGetTraceInfo); LIB_FUNCTION("FxVZqBAA7ks", "libkernel", 1, "libkernel", 1, 1, ps4__write); LIB_FUNCTION("FN4gaPmuFV8", "libScePosix", 1, "libkernel", 1, 1, ps4__write); - - LIB_FUNCTION("HgX7+AORI58", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitReadCommands); - LIB_FUNCTION("2pOuoWoCxdk", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequest); - LIB_FUNCTION("5TgME6AYty4", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequest); } } // namespace Libraries::Kernel