Leahnaya/WiiUModuleSystem
1
0
Fork 0
mirror of https://github.com/wiiu-env/WiiUModuleSystem.git synced 2026-05-05 20:55:28 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Move reent logic into WUMSLoader

Browse Source
This commit is contained in:
Maschell 2026-04-09 16:42:40 +02:00
parent 9916b10c8e
commit 1025c3d2d7
9 changed files with 140 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -3,7 +3,7 @@ include $(TOPDIR)/share/wums_rules
export WUMS_MAJOR := 0
export WUMS_MINOR := 3
export WUMS_PATCH := 5
export WUMS_PATCH := 6
VERSION := $(WUMS_MAJOR).$(WUMS_MINOR).$(WUMS_PATCH)

13
include/wums/hooks.h
View File

@ -27,6 +27,7 @@
#include "common.h"
#include "defines/module_defines.h"
#include "reent_internal.h"
#ifdef __cplusplus
extern "C" {
@ -68,7 +69,9 @@ typedef enum wums_hook_type_t {
WUMS_HOOK_GET_CUSTOM_RPL_ALLOCATOR, // for internal usage only
WUMS_HOOK_CLEAR_ALLOCATED_RPL_MEMORY, // for internal usage only
// Introduced in 0.3.5
WUMS_HOOK_INIT_WUT_THREAD // for internal usage only
WUMS_HOOK_INIT_WUT_THREAD, // for internal usage only
// Introduced in 0.3.6
WUMS_HOOK_INIT_REENT_FUNCTIONS // for internal usage only
} wums_hook_type_t;
typedef uint32_t (*WUMSRPLAllocatorAllocFn)(int32_t size, int32_t align, void **outAddr);
@ -196,6 +199,14 @@ typedef struct wums_relocs_done_args_t {
} \
WUMS_HOOK_EX(WUMS_HOOK_INIT_WUT_THREAD, on_init_wut_thread);
#define WUMS_INIT_REENT_FUNCTIONS() \
__EXTERN_C_MACRO void WUMSReentAPI_InitInternal(wums_loader_init_reent_args_t_); \
void wums_init_reent_functions(wums_loader_init_reent_args_t_ args); \
WUMS_HOOK_EX(WUMS_HOOK_INIT_REENT_FUNCTIONS, wums_init_reent_functions); \
void wums_init_reent_functions(wums_loader_init_reent_args_t_ args) { \
return WUMSReentAPI_InitInternal(args); \
}
#define WUMS_USE_WUT_SOCKETS() \
__EXTERN_C_MACRO void __init_wut_socket(); \
WUMS_HOOK_EX(WUMS_HOOK_INIT_WUT_SOCKETS, __init_wut_socket); \

3
include/wums/meta.h
View File

@ -39,7 +39,7 @@
extern "C" {
#endif
#define WUMS_VERSION "0.3.5"
#define WUMS_VERSION "0.3.6"
#define WUMS_MODULE_EXPORT_NAME(__module_name) \
WUMS_META(export_name, __module_name); \
@ -50,6 +50,7 @@ extern "C" {
WUMS_USE_WUT_THREAD(); \
WUMS___INIT_WRAPPER(); \
WUMS___FINI_WRAPPER(); \
WUMS_INIT_REENT_FUNCTIONS(); \
WUMS_META(buildtimestamp, __DATE__ " " __TIME__); \
extern const char wums_meta_module_name[] WUMS_SECTION("meta"); \
const char wums_meta_module_name[] = __module_name; \

35
include/wums/reent_internal.h Normal file
View File

@ -0,0 +1,35 @@
#pragma once
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef enum wums_loader_init_reent_errors_t_ {
WUMSReent_ERROR_NONE = 0,
WUMSReent_ERROR_GLOBAL_REENT_REQUESTED = 1,
WUMSReent_ERROR_NO_THREAD = 2,
} wums_loader_init_reent_errors_t_;
typedef void *(*WUMSReent_GetReentContext)(const void *moduleId, wums_loader_init_reent_errors_t_ *outError);
typedef void *(*WUMSReent_SetSentinel)();
typedef void (*WUMSReent_RestoreHead)(void *oldHead);
typedef bool (*WUMSReent_AddReentContext)(const void *moduleId, void *reentPtr, void (*cleanupFn)(void *), void *oldHead);
typedef uint32_t WUMS_REENT_API_VERSION;
#define WUMS_REENT_CUR_API_VERSION 0x01
typedef struct wums_loader_init_reent_args_t_ {
WUMS_REENT_API_VERSION version;
WUMSReent_GetReentContext get_context_ptr;
WUMSReent_SetSentinel set_sentinel_ptr;
WUMSReent_RestoreHead restore_head_ptr;
WUMSReent_AddReentContext add_reent_context_ptr;
} wums_loader_init_reent_args_t_;
void WUMSReentAPI_InitInternal(wums_loader_init_reent_args_t_ args);
#ifdef __cplusplus
}
#endif

19
include/wums/wums_debug.h
View File

@ -1,25 +1,10 @@
#pragma once
#if defined(__GNUC__) || defined(__clang__)
#define WUMS_FORMAT_PRINTF(fmt, args) __attribute__((__format__(__printf__, fmt, args)))
#else // not __GNUC__ and not __clang__
#define WUMS_FORMAT_PRINTF(fmt, args)
#endif //__GNUC__ or __clang__
extern "C" void OSReport(const char *fmt, ...);
#ifdef __cplusplus
extern "C" {
#endif
#ifdef DEBUG
extern void OSReport(const char *fmt, ...) WUMS_FORMAT_PRINTF(1, 2);
#endif
extern const char wums_meta_info_dump[];
#ifdef __cplusplus
}
@ -31,4 +16,4 @@ extern const char wums_meta_info_dump[];
#define WUMS_DEBUG_REPORT(fmt, ...)
#endif
#define WUMS_DEBUG_WARN(fmt, ...) OSReport("[%s] " fmt, wums_meta_info_dump, ##__VA_ARGS__)
#define WUMS_DEBUG_WARN(fmt, ...) OSReport("\033[33m[%s] " fmt "\033[0m", wums_meta_info_dump, ##__VA_ARGS__)

24
libraries/libwums/crt.cpp
View File

@ -1,8 +1,10 @@
#include "wums/wums_debug.h"
#include "wums_reent.h"
#include "wums_thread_specific.h"
#include <cstdio>
#include <cstring>
extern "C" void OSFatal(const char *);
extern "C" void OSFatal(const char *);
int main(int argc, char **argv) {
@ -43,16 +45,22 @@ struct _reent *__getreent(void) {
return __wums_getreent();
}
extern "C" void __attribute__((weak)) wut_set_thread_specific(__wut_thread_specific_id id, void *value);
void wut_set_thread_specific(__wut_thread_specific_id id, void *value) {
return wums_set_thread_specific(id, value);
}
typedef enum __wut_thread_specific_id {
WUT_THREAD_SPECIFIC_0 = 0,
WUT_THREAD_SPECIFIC_1 = 1,
} __wut_thread_specific_id;
extern "C" void *__attribute__((weak)) wut_get_thread_specific(__wut_thread_specific_id id);
void *wut_get_thread_specific(__wut_thread_specific_id id) {
return wums_get_thread_specific(id);
if ((uint32_t) id == 0x13371337) { // Mechanism to detect if the function was overridden properly
return (void *) 0x42424242;
}
WUMS_DEBUG_WARN("wums_get_thread_specific: NOT SUPPORTED\n");
OSFatal("wums_get_thread_specific: NOT SUPPORTED\n");
return nullptr;
}
extern "C" const char wums_meta_module_name[];
@ -100,6 +108,8 @@ __assert_func(const char *file,
}
OSFatal(buffer);
while (true)
;
/* NOTREACHED */
}

212
libraries/libwums/wums_reent.cpp
View File

@ -1,175 +1,105 @@
#include "wums_reent.h"
#include "wums_thread_specific.h"
#include <cstring>
#include <stdint.h>
#include "wums/hooks.h"
#include "wums/reent_internal.h"
#include "wums/wums_debug.h"
extern "C" void OSFatal(const char *format, ...);
extern "C" void *OSGetCurrentThread();
#include <stdlib.h>
#include <wums/wums_debug.h>
#define __WUMS_CONTEXT_THREAD_SPECIFIC_ID WUT_THREAD_SPECIFIC_0
#define WUMS_REENT_ALLOC_SENTINEL ((__wums_reent_node *) 0xFFFFFFFF)
extern "C" __attribute__((weak)) void wut_set_thread_specific(__wut_thread_specific_id id, void *value);
extern "C" __attribute__((weak)) void *wut_get_thread_specific(__wut_thread_specific_id);
typedef uint32_t OSThread;
extern "C" void OSFatal(const char *);
extern "C" void OSReport(const char *, ...);
extern "C" OSThread *OSGetCurrentThread();
typedef void (*OSThreadCleanupCallbackFn)(OSThread *thread, void *stack);
extern "C" OSThreadCleanupCallbackFn
OSSetThreadCleanupCallback(OSThread *thread,
OSThreadCleanupCallbackFn callback);
#define WUMS_REENT_NODE_VERSION 1
#define WUMS_REENT_NODE_MAGIC 0x57554D53 // WUMS
static const int sReentModuleId = 0;
struct __wums_reent_node {
// FIXED HEADER (Never move or change these offsets!)
uint32_t magic; // Guarantees this is a __wums_reent_node
uint32_t version;
__wums_reent_node *next;
// Node Version 1 Payload
const void *moduleId;
void *reentPtr;
void (*cleanupFn)(__wums_reent_node *);
OSThreadCleanupCallbackFn savedCleanup;
struct wums_loader_init_reent_args_t {
WUMSReent_GetReentContext get_context_ptr = nullptr;
WUMSReent_SetSentinel set_sentinel_ptr = nullptr;
WUMSReent_RestoreHead restore_head_ptr = nullptr;
WUMSReent_AddReentContext add_reent_context_ptr = nullptr;
};
static void reclaim_reent_trampoline(__wums_reent_node *node) {
WUMS_DEBUG_REPORT("reclaim_reent_trampoline: Destroying node %p (reent: %p)\n", node, node->reentPtr);
static wums_loader_init_reent_args_t __internal_functions = {};
if (node->reentPtr) {
_reclaim_reent(static_cast<_reent *>(node->reentPtr));
free(node->reentPtr);
void WUMSReentAPI_InitInternal(wums_loader_init_reent_args_t_ args) {
if (args.version > WUMS_REENT_CUR_API_VERSION) {
OSFatal("Incompatible reent api version");
return;
}
free(node);
WUMS_DEBUG_REPORT("WUMSReentAPI_InitInternal: Initializing reent module\n");
__internal_functions.get_context_ptr = args.get_context_ptr;
__internal_functions.set_sentinel_ptr = args.set_sentinel_ptr;
__internal_functions.add_reent_context_ptr = args.add_reent_context_ptr;
__internal_functions.restore_head_ptr = args.restore_head_ptr;
}
static void __wums_thread_cleanup(OSThread *thread, void *stack) {
auto *head = static_cast<__wums_reent_node *>(wut_get_thread_specific(__WUMS_CONTEXT_THREAD_SPECIFIC_ID));
// use variable in the .data section as unique module id
static const int sReentModuleId = 0;
if (!head || head == WUMS_REENT_ALLOC_SENTINEL) {
return;
}
void *wums_backend_get_context(const void *id, wums_loader_init_reent_errors_t_ *outError) {
return __internal_functions.get_context_ptr(id, outError);
}
if (head->magic != WUMS_REENT_NODE_MAGIC) {
WUMS_DEBUG_WARN("__wums_thread_cleanup: Unexpected node magic word: %08X (expected %08X).\n", head->magic, WUMS_REENT_NODE_MAGIC);
return;
}
void *wums_backend_set_sentinel() {
return __internal_functions.set_sentinel_ptr();
}
WUMS_DEBUG_REPORT("__wums_thread_cleanup: Triggered for thread %p\n", thread);
void wums_backend_restore_head(void *head) {
__internal_functions.restore_head_ptr(head);
}
OSThreadCleanupCallbackFn savedCleanup = nullptr;
if (head->version >= 1) {
savedCleanup = head->savedCleanup;
}
bool wums_backend_register_context(const void *moduleId, void *reentPtr, void (*cleanupFn)(void *), void *oldHead) {
return __internal_functions.add_reent_context_ptr(moduleId, reentPtr, cleanupFn, oldHead);
}
// Set to effective global during free to prevent malloc re-entrancy loops
wut_set_thread_specific(__WUMS_CONTEXT_THREAD_SPECIFIC_ID, WUMS_REENT_ALLOC_SENTINEL);
static void reclaim_reent_trampoline(void *payload) {
WUMS_DEBUG_REPORT("reclaim_reent_trampoline: Destroying reent payload: %p\n", payload);
// Safely iterate the ABI-stable list.
auto *curr = head;
while (curr) {
// Read the "next" pointer BEFORE destroying the current node.
__wums_reent_node *next = curr->next;
// Trigger the self-destruct sequence. Frees curr
if (curr->cleanupFn) {
curr->cleanupFn(curr);
}
curr = next;
}
wut_set_thread_specific(__WUMS_CONTEXT_THREAD_SPECIFIC_ID, nullptr);
if (savedCleanup) {
WUMS_DEBUG_REPORT("__wums_thread_cleanup: Chaining to saved cleanup for thread %p\n", thread);
savedCleanup(thread, stack);
if (payload) {
auto *reentPtr = static_cast<_reent *>(payload);
_reclaim_reent(reentPtr);
free(reentPtr);
}
}
struct _reent *__wums_getreent() {
if (!wut_get_thread_specific || !wut_set_thread_specific || OSGetCurrentThread() == nullptr) {
if (!OSGetCurrentThread()) {
return _GLOBAL_REENT;
}
auto head = static_cast<__wums_reent_node *>(wut_get_thread_specific(__WUMS_CONTEXT_THREAD_SPECIFIC_ID));
if (head == WUMS_REENT_ALLOC_SENTINEL) {
return _GLOBAL_REENT;
wums_loader_init_reent_errors_t_ error = WUMSReent_ERROR_NONE;
if (void *existingCtx = wums_backend_get_context(&sReentModuleId, &error)) {
return static_cast<_reent *>(existingCtx);
}
switch (error) {
case WUMSReent_ERROR_GLOBAL_REENT_REQUESTED:
case WUMSReent_ERROR_NO_THREAD:
return _GLOBAL_REENT;
case WUMSReent_ERROR_NONE:
break;
}
if (head && head->magic != WUMS_REENT_NODE_MAGIC) {
WUMS_DEBUG_WARN("__wums_getreent: Unexpected node magic word: %08X (expected %08X).\n", head->magic, WUMS_REENT_NODE_MAGIC);
return _GLOBAL_REENT;
}
// Check for already allocated reent ptr.
// (Intentionally not logging here to prevent console spam on the fast path)
const __wums_reent_node *curr = head;
while (curr) {
// Use a memory address as a unique id
if (curr->version >= 1 && curr->moduleId == &sReentModuleId) {
return static_cast<_reent *>(curr->reentPtr);
}
curr = curr->next;
}
WUMS_DEBUG_REPORT("__wums_getreent: Allocating new context for thread %p\n", OSGetCurrentThread());
// If not found allocate a new for THIS module.
// Temporarily effectively use global reent during context allocation
wut_set_thread_specific(__WUMS_CONTEXT_THREAD_SPECIFIC_ID, WUMS_REENT_ALLOC_SENTINEL);
auto *newNode = static_cast<__wums_reent_node *>(malloc(sizeof(__wums_reent_node)));
auto *oldHead = wums_backend_set_sentinel();
auto *newReent = static_cast<struct _reent *>(malloc(sizeof(struct _reent)));
if (!newNode || !newReent) {
WUMS_DEBUG_WARN("__wums_getreent: Failed to allocate context! Falling back to _GLOBAL_REENT.\n");
if (newNode) {
free(newNode);
}
if (newReent) {
free(newReent);
}
// reset on error
wut_set_thread_specific(__WUMS_CONTEXT_THREAD_SPECIFIC_ID, head);
if (!newReent) {
wums_backend_restore_head(oldHead);
return _GLOBAL_REENT;
}
WUMS_DEBUG_REPORT("Allocated context! for thread %p: %p\n", OSGetCurrentThread(), newReent);
_REENT_INIT_PTR(newReent);
newNode->magic = WUMS_REENT_NODE_MAGIC;
newNode->version = WUMS_REENT_NODE_VERSION;
newNode->next = head;
newNode->moduleId = &sReentModuleId;
newNode->reentPtr = newReent;
newNode->cleanupFn = reclaim_reent_trampoline;
newNode->savedCleanup = nullptr;
bool result = wums_backend_register_context(
&sReentModuleId,
newReent,
reclaim_reent_trampoline,
oldHead);
auto oldHead = head;
// Hook cleanup logic
if (oldHead == nullptr) {
WUMS_DEBUG_REPORT("__wums_getreent: Hooking OSSetThreadCleanupCallback for thread %p\n", OSGetCurrentThread());
newNode->savedCleanup = OSSetThreadCleanupCallback(OSGetCurrentThread(), &__wums_thread_cleanup);
} else {
WUMS_DEBUG_REPORT("__wums_getreent: Prepending to existing list for thread %p\n", OSGetCurrentThread());
// We prepend, so we must inherit the saved cleanup from the previous head
if (oldHead->version >= 1) {
newNode->savedCleanup = oldHead->savedCleanup;
oldHead->savedCleanup = nullptr;
}
if (!result) {
WUMS_DEBUG_WARN("Failed to register context for thread %p\n", OSGetCurrentThread());
_reclaim_reent(newReent);
free(newReent);
wums_backend_restore_head(oldHead);
return _GLOBAL_REENT;
}
wut_set_thread_specific(__WUMS_CONTEXT_THREAD_SPECIFIC_ID, newNode);
return newReent;
}

57
libraries/libwums/wums_thread_specific.cpp
View File

@ -1,57 +0,0 @@
#include "wums_thread_specific.h"
#include <stddef.h>
#include <stdint.h>
extern "C" void OSFatal(const char *);
extern "C" void OSReport(const char *, ...);
typedef struct OSThread {
uint8_t other[0x68c];
void *reserved[5];
} OSThread;
static_assert(offsetof(OSThread, reserved) == 0x68c, "OSThread: \"reserved\" at wrong offset");
static_assert(sizeof(OSThread) == 0x6a0, "OSThread: wrong size");
extern "C" const char wums_meta_info_dump[];
void wums_set_thread_specific(__wut_thread_specific_id id, void *value) {
OSThread *thread;
asm volatile("lwz %0, -0x20(0)"
: "=r"(thread)); // OSGetCurrentThread()
if (thread != nullptr) {
if (id == WUT_THREAD_SPECIFIC_0) {
thread->reserved[1] = value;
} else if (id == WUT_THREAD_SPECIFIC_1) {
thread->reserved[2] = value;
} else {
OSReport("[%s] wums_set_thread_specific: invalid id\n", wums_meta_info_dump);
OSFatal("wut_set_thread_specific: invalid id");
}
} else {
OSReport("[%s] wums_set_thread_specific: invalid thread\n", wums_meta_info_dump);
OSFatal("wums_set_thread_specific: invalid thread");
}
}
void *wums_get_thread_specific(__wut_thread_specific_id id) {
OSThread *thread;
asm volatile("lwz %0, -0x20(0)"
: "=r"(thread)); // OSGetCurrentThread()
if (thread != nullptr) {
if (id == WUT_THREAD_SPECIFIC_0) {
return thread->reserved[1];
} else if (id == WUT_THREAD_SPECIFIC_1) {
return thread->reserved[2];
} else if ((uint32_t) id == 0x13371337) { // Mechanism to detect if the function was overridden properly
return (void *) 0x42424242;
} else {
OSReport("[%s] wums_get_thread_specific: invalid id\n", wums_meta_info_dump);
OSFatal("wums_get_thread_specific: invalid id");
}
} else {
OSReport("[%s] wums_get_thread_specific: invalid thread\n", wums_meta_info_dump);
OSFatal("wums_get_thread_specific: invalid thread\n");
}
return nullptr;
}

18
libraries/libwums/wums_thread_specific.h
View File

@ -1,18 +0,0 @@
#pragma once
typedef enum __wut_thread_specific_id {
WUT_THREAD_SPECIFIC_0 = 0,
WUT_THREAD_SPECIFIC_1 = 1,
} __wut_thread_specific_id;
#ifdef __cplusplus
extern "C" {
#endif
void wums_set_thread_specific(__wut_thread_specific_id id, void *value);
void *wums_get_thread_specific(__wut_thread_specific_id id);
#ifdef __cplusplus
}
#endif