kernel: Clean up and fix some mistakes. (#2907)

src/common/va_ctx.h

@@ -8,7 +8,7 @@
 #define VA_ARGS                                                                                    \
     uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_t rcx, uint64_t r8, uint64_t r9,              \
         uint64_t overflow_arg_area, __m128 xmm0, __m128 xmm1, __m128 xmm2, __m128 xmm3,            \
-        __m128 xmm4, __m128 xmm5, __m128 xmm6, __m128 xmm7, ...
+        __m128 xmm4, __m128 xmm5, __m128 xmm6, __m128 xmm7
 
 #define VA_CTX(ctx)                                                                                \
     alignas(16)::Common::VaCtx ctx{};                                                              \

src/core/libraries/kernel/aio.cpp

@@ -19,7 +19,7 @@ namespace Libraries::Kernel {
 static s32* id_state;
 static s32 id_index;
 
-s32 sceKernelAioInitializeImpl(void* p, s32 size) {
+s32 PS4_SYSV_ABI sceKernelAioInitializeImpl(void* p, s32 size) {
 
     return 0;
 }

src/core/libraries/kernel/kernel.h

@@ -3,9 +3,6 @@
 
 #pragma once
 
-#include <algorithm>
-#include <fmt/core.h>
-#include "common/string_literal.h"
 #include "common/types.h"
 #include "core/libraries/kernel/orbis_error.h"
 
@@ -20,26 +17,21 @@ int ErrnoToSceKernelError(int e);
 void SetPosixErrno(int e);
 int* PS4_SYSV_ABI __Error();
 
-template <StringLiteral name, class F, F f>
-struct WrapperImpl;
+template <class F, F f>
+struct OrbisWrapperImpl;
 
-template <StringLiteral name, class R, class... Args, PS4_SYSV_ABI R (*f)(Args...)>
-struct WrapperImpl<name, PS4_SYSV_ABI R (*)(Args...), f> {
-    static constexpr StringLiteral Name{name};
+template <class R, class... Args, PS4_SYSV_ABI R (*f)(Args...)>
+struct OrbisWrapperImpl<PS4_SYSV_ABI R (*)(Args...), f> {
     static R PS4_SYSV_ABI wrap(Args... args) {
         u32 ret = f(args...);
         if (ret != 0) {
-            // LOG_ERROR(Lib_Kernel, "Function {} returned {}", std::string_view{name.value}, ret);
             ret += ORBIS_KERNEL_ERROR_UNKNOWN;
         }
         return ret;
     }
 };
 
-template <StringLiteral name, class F, F f>
-constexpr auto OrbisWrapper = WrapperImpl<name, F, f>::wrap;
-
-#define ORBIS(func) WrapperImpl<#func, decltype(&func), func>::wrap
+#define ORBIS(func) (Libraries::Kernel::OrbisWrapperImpl<decltype(&(func)), func>::wrap)
 
 int* PS4_SYSV_ABI __Error();
 

src/core/libraries/kernel/threads/pthread.cpp

@@ -581,12 +581,9 @@ int PS4_SYSV_ABI posix_pthread_setaffinity_np(PthreadT thread, size_t cpusetsize
     return thread->SetAffinity(cpusetp);
 }
 
-int PS4_SYSV_ABI scePthreadSetaffinity(PthreadT thread, const Cpuset mask) {
-    int result = posix_pthread_setaffinity_np(thread, 0x10, &mask);
-    if (result != 0) {
-        return ErrnoToSceKernelError(result);
-    }
-    return 0;
+int PS4_SYSV_ABI scePthreadSetaffinity(PthreadT thread, const u64 mask) {
+    const Cpuset cpuset = {.bits = mask};
+    return posix_pthread_setaffinity_np(thread, sizeof(Cpuset), &cpuset);
 }
 
 void RegisterThread(Core::Loader::SymbolsResolver* sym) {
@@ -635,7 +632,7 @@ void RegisterThread(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("W0Hpm2X0uPE", "libkernel", 1, "libkernel", 1, 1, ORBIS(posix_pthread_setprio));
     LIB_FUNCTION("rNhWz+lvOMU", "libkernel", 1, "libkernel", 1, 1, _sceKernelSetThreadDtors);
     LIB_FUNCTION("6XG4B33N09g", "libkernel", 1, "libkernel", 1, 1, sched_yield);
-    LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetaffinity)
+    LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, ORBIS(scePthreadSetaffinity));
 }
 
 } // namespace Libraries::Kernel

src/core/libraries/kernel/threads/pthread.h

@@ -159,6 +159,7 @@ enum class SchedPolicy : u32 {
 
 struct Cpuset {
     u64 bits;
+    u64 _reserved;
 };
 
 struct PthreadAttr {
@@ -269,7 +270,7 @@ struct Pthread {
     bool no_cancel;
     bool cancel_async;
     bool cancelling;
-    Cpuset sigmask;
+    u64 sigmask;
     bool unblock_sigcancel;
     bool in_sigsuspend;
     bool force_exit;

src/core/libraries/kernel/threads/pthread_attr.cpp

@@ -243,7 +243,7 @@ int PS4_SYSV_ABI posix_pthread_attr_getaffinity_np(const PthreadAttrT* pattr, si
     if (attr->cpuset != nullptr)
         memcpy(cpusetp, attr->cpuset, std::min(cpusetsize, attr->cpusetsize));
     else
-        memset(cpusetp, -1, sizeof(Cpuset));
+        memset(cpusetp, -1, cpusetsize);
     return 0;
 }
 
@@ -259,30 +259,31 @@ int PS4_SYSV_ABI posix_pthread_attr_setaffinity_np(PthreadAttrT* pattr, size_t c
     if (cpusetsize == 0 || cpusetp == nullptr) {
         if (attr->cpuset != nullptr) {
             free(attr->cpuset);
-            attr->cpuset = NULL;
+            attr->cpuset = nullptr;
             attr->cpusetsize = 0;
         }
         return 0;
     }
     if (attr->cpuset == nullptr) {
-        attr->cpuset = (Cpuset*)calloc(1, sizeof(Cpuset));
+        attr->cpuset = static_cast<Cpuset*>(calloc(1, sizeof(Cpuset)));
         attr->cpusetsize = sizeof(Cpuset);
     }
-    memcpy(attr->cpuset, cpusetp, sizeof(Cpuset));
+    memcpy(attr->cpuset, cpusetp, cpusetsize);
     return 0;
 }
 
-int PS4_SYSV_ABI scePthreadAttrGetaffinity(PthreadAttrT* param_1, Cpuset* mask) {
+int PS4_SYSV_ABI scePthreadAttrGetaffinity(PthreadAttrT* param_1, u64* mask) {
     Cpuset cpuset;
-    const int ret = posix_pthread_attr_getaffinity_np(param_1, 0x10, &cpuset);
+    const int ret = posix_pthread_attr_getaffinity_np(param_1, sizeof(Cpuset), &cpuset);
     if (ret == 0) {
-        *mask = cpuset;
+        *mask = cpuset.bits;
     }
     return ret;
 }
 
-int PS4_SYSV_ABI scePthreadAttrSetaffinity(PthreadAttrT* attr, const Cpuset mask) {
-    return posix_pthread_attr_setaffinity_np(attr, 0x10, &mask);
+int PS4_SYSV_ABI scePthreadAttrSetaffinity(PthreadAttrT* attr, const u64 mask) {
+    const Cpuset cpuset = {.bits = mask};
+    return posix_pthread_attr_setaffinity_np(attr, sizeof(Cpuset), &cpuset);
 }
 
 void RegisterThreadAttr(Core::Loader::SymbolsResolver* sym) {

src/core/libraries/libs.h

@@ -3,14 +3,9 @@
 
 #pragma once
 
-#include <functional>
-
-#include "common/logging/log.h"
 #include "core/loader/elf.h"
 #include "core/loader/symbols_resolver.h"
 
-#define W(foo) foo
-
 #define LIB_FUNCTION(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function)  \
     {                                                                                              \
         Core::Loader::SymbolResolver sr{};                                                         \
@@ -25,7 +20,7 @@
         sym->AddSymbol(sr, func);                                                                  \
     }
 
-#define LIB_OBJ(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function)       \
+#define LIB_OBJ(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, obj)            \
     {                                                                                              \
         Core::Loader::SymbolResolver sr{};                                                         \
         sr.name = nid;                                                                             \
@@ -35,8 +30,7 @@
         sr.module_version_major = moduleVersionMajor;                                              \
         sr.module_version_minor = moduleVersionMinor;                                              \
         sr.type = Core::Loader::SymbolType::Object;                                                \
-        auto func = reinterpret_cast<u64>(function);                                               \
-        sym->AddSymbol(sr, func);                                                                  \
+        sym->AddSymbol(sr, reinterpret_cast<u64>(obj));                                            \
     }
 
 namespace Libraries {

src/core/linker.cpp

@@ -127,7 +127,7 @@ void Linker::Execute(const std::vector<std::string> args) {
             }
         }
         params.entry_addr = module->GetEntryAddress();
-        RunMainEntry(&params);
+        ExecuteGuest(RunMainEntry, &params);
     });
 }
 
@@ -366,7 +366,8 @@ void* Linker::TlsGetAddr(u64 module_index, u64 offset) {
     if (!addr) {
         // Module was just loaded by above code. Allocate TLS block for it.
         const u32 init_image_size = module->tls.init_image_size;
-        u8* dest = reinterpret_cast<u8*>(heap_api->heap_malloc(module->tls.image_size));
+        u8* dest = reinterpret_cast<u8*>(
+            Core::ExecuteGuest(heap_api->heap_malloc, module->tls.image_size));
         const u8* src = reinterpret_cast<const u8*>(module->tls.image_virtual_addr);
         std::memcpy(dest, src, init_image_size);
         std::memset(dest + init_image_size, 0, module->tls.image_size - init_image_size);