SuperMarioOdysseyOnline/include/nn/os.h

266 lines
7.6 KiB
C
Raw Normal View History

2022-06-16 21:33:18 +00:00
/**
* @file os.h
* @brief Operating System implementations.
*/
#pragma once
#include <type_traits>
#include <nn/time.h>
#include <types.h>
namespace nn {
namespace os {
namespace detail {
struct InternalCriticalSection {
u32 Image;
};
struct InternalConditionVariable {
u32 Image;
};
} // namespace detail
typedef u64 Tick;
struct LightEventType {
std::aligned_storage_t<0xc, 4> storage;
};
// https://github.com/misson20000/nn-types/blob/master/nn_os.h
struct EventType {
nn::os::EventType* _x0;
nn::os::EventType* _x8;
bool isSignaled;
bool initiallySignaled;
bool shouldAutoClear;
bool isInit;
u32 signalCounter;
u32 signalCounter2;
nn::os::detail::InternalCriticalSection crit;
nn::os::detail::InternalConditionVariable condvar;
};
typedef EventType Event;
// https://github.com/misson20000/nn-types/blob/master/nn_os.h
struct ThreadType {
u64 field_8;
u64 field_10;
u64 field_18;
char field_20[32];
uint32_t thread_status;
char field_41;
u16 field_42;
uint32_t thread_prio_shift;
uint64_t thread_stack_base_addr;
uint64_t thread_stack_base_addr_mirror;
uint64_t thread_stack_size;
uint64_t thread_param;
uint64_t thread_func;
u64 field_70;
u64 field_78;
u64 field_80;
char field_88[0x100];
char thread_name[0x20];
const char* thread_name_addr;
nn::os::detail::InternalCriticalSection crit;
nn::os::detail::InternalConditionVariable condvar;
u32 thread_handle;
};
#ifdef SWITCH
static_assert(sizeof(ThreadType) == 0x1C0, "Wrong size");
#endif
struct MessageQueueType {
u64 _x0;
u64 _x8;
u64 _x10;
u64 _x18;
void* Buffer;
u32 MaxCount;
u32 Count;
u32 Offset;
bool Initialized;
detail::InternalCriticalSection _x38;
detail::InternalConditionVariable _x3C;
detail::InternalConditionVariable _x40;
};
struct ConditionVariableType {};
struct SemaphoreType {
std::aligned_storage_t<0x28, 8> storage;
};
struct SystemEvent;
struct SystemEventType;
// ARG
void SetHostArgc(s32);
s32 GetHostArgc();
void SetHostArgv(char**);
char** GetHostArgv();
// MEMORY
void InitializeVirtualAddressMemory();
Result AllocateAddressRegion(u64*, u64);
Result AllocateMemory(u64*, u64);
Result AllocateMemoryPages(u64, u64);
void AllocateMemoryBlock(u64*, u64);
void FreeMemoryBlock(u64, u64);
void SetMemoryHeapSize(u64);
// MUTEX
struct MutexType {
u8 curState; // _0
bool isRecursiveMutex; // _1
s32 lockLevel; // _2
u8 _6[0x20 - 0xE];
};
void InitializeMutex(nn::os::MutexType*, bool, s32);
void FinalizeMutex(nn::os::MutexType*);
void LockMutex(nn::os::MutexType*);
bool TryLockMutex(nn::os::MutexType*);
void UnlockMutex(nn::os::MutexType*);
bool IsMutexLockedByCurrentThread(nn::os::MutexType const*);
// QUEUE
void InitializeMessageQueue(nn::os::MessageQueueType*, u64* buf, u64 queueCount);
void FinalizeMessageQueue(nn::os::MessageQueueType*);
bool TrySendMessageQueue(MessageQueueType*, u64);
void SendMessageQueue(MessageQueueType*, u64);
bool TimedSendMessageQueue(MessageQueueType*, u64, nn::TimeSpan);
bool TryReceiveMessageQueue(u64* out, MessageQueueType*);
void ReceiveMessageQueue(u64* out, MessageQueueType*);
bool TimedReceiveMessageQueue(u64* out, MessageQueueType*, nn::TimeSpan);
bool TryPeekMessageQueue(u64*, MessageQueueType const*);
void PeekMessageQueue(u64*, MessageQueueType const*);
bool TimedPeekMessageQueue(u64*, MessageQueueType const*);
bool TryJamMessageQueue(nn::os::MessageQueueType*, u64);
void JamMessageQueue(nn::os::MessageQueueType*, u64);
bool TimedJamMessageQueue(nn::os::MessageQueueType*, u64, nn::TimeSpan);
// CONDITION VARIABLE
void InitializeConditionVariable(ConditionVariableType*);
void FinalizeConditionVariable(ConditionVariableType*);
void SignalConditionVariable(ConditionVariableType*);
void BroadcastConditionVariable(ConditionVariableType*);
void WaitConditionVariable(ConditionVariableType*);
u8 TimedWaitConditionVariable(ConditionVariableType*, MutexType*, nn::TimeSpan);
// THREAD
Result CreateThread(nn::os::ThreadType*, void (*)(void*), void* arg, void* srcStack, u64 stackSize,
s32 priority, s32 coreNum);
Result CreateThread(nn::os::ThreadType*, void (*)(void*), void* arg, void* srcStack, u64 stackSize,
s32 priority);
void DestroyThread(nn::os::ThreadType*);
void StartThread(nn::os::ThreadType*);
void SetThreadName(nn::os::ThreadType*, char const* threadName);
void SetThreadNamePointer(nn::os::ThreadType*, char const*);
char* GetThreadNamePointer(nn::os::ThreadType const*);
nn::os::ThreadType* GetCurrentThread();
void GetCurrentStackInfo(uintptr_t* stack_addr, size_t* stack_size);
s32 ChangeThreadPriority(nn::os::ThreadType* thread, s32 priority);
s32 GetThreadPriority(nn::os::ThreadType const* thread);
u64 GetThreadId(const nn::os::ThreadType* thread);
void YieldThread();
void SuspendThread(nn::os::ThreadType*);
void ResumeThread(nn::os::ThreadType*);
void SleepThread(nn::TimeSpan);
void WaitThread(nn::os::ThreadType*);
void SetThreadCoreMask(nn::os::ThreadType*, int, u64 mask);
// EVENTS
void InitializeEvent(EventType*, bool initiallySignaled, bool autoclear);
void FinalizeEvent(EventType*);
void SignalEvent(EventType*);
void WaitEvent(EventType*);
bool TryWaitEvent(EventType*);
bool TimedWaitEvent(EventType*, nn::TimeSpan);
void ClearEvent(EventType*);
// LIGHT EVENTS
void InitializeLightEvent(LightEventType*, bool initiallySignaled, bool autoclear);
void FinalizeLightEvent(LightEventType*);
void SignalLightEvent(LightEventType*);
void WaitLightEvent(LightEventType*);
bool TimedWaitLightEvent(LightEventType*, nn::TimeSpan);
void ClearLightEvent(LightEventType*);
TimeSpan ConvertToTimeSpan(Tick ticks);
// SEMAPHORES
void InitializeSemaphore(SemaphoreType* semaphore, s32 initial_count, s32 max_count);
void FinalizeSemaphore(SemaphoreType* semaphore);
void AcquireSemaphore(SemaphoreType* semaphore);
bool TryAcquireSemaphore(SemaphoreType* semaphore);
void ReleaseSemaphore(SemaphoreType* semaphore);
// EXCEPTION HANDLING
typedef union {
u64 x; ///< 64-bit AArch64 register view.
u32 w; ///< 32-bit AArch64 register view.
u32 r; ///< AArch32 register view.
} CpuRegister;
/// Armv8 NEON register.
typedef union {
u128 v; ///< 128-bit vector view.
double d; ///< 64-bit double-precision view.
float s; ///< 32-bit single-precision view.
} FpuRegister;
struct UserExceptionInfo {
u32 ErrorDescription; ///< See \ref ThreadExceptionDesc.
u32 pad[3];
CpuRegister CpuRegisters[29]; ///< GPRs 0..28. Note: also contains AArch32 registers.
CpuRegister FP; ///< Frame pointer.
CpuRegister LR; ///< Link register.
CpuRegister SP; ///< Stack pointer.
CpuRegister PC; ///< Program counter (elr_el1).
u64 padding;
FpuRegister FpuRegisters[32]; ///< 32 general-purpose NEON registers.
u32 PState; ///< pstate & 0xFF0FFE20
u32 AFSR0;
u32 AFSR1;
u32 ESR;
CpuRegister FAR; ///< Fault Address Register.
};
void SetUserExceptionHandler(void (*)(UserExceptionInfo*), void*, ulong, UserExceptionInfo*);
// OTHER
void GenerateRandomBytes(void*, u64);
nn::os::Tick GetSystemTick();
nn::os::Tick GetSystemTickFrequency();
u64 GetThreadAvailableCoreMask();
void SetMemoryHeapSize(u64 size);
// Thread-local storage
struct TlsSlot {
u32 slot;
};
Result AllocateTlsSlot(TlsSlot* slot_out, void (*)(u64));
void FreeTlsSlot(TlsSlot slot);
u64 GetTlsValue(TlsSlot slot);
void SetTlsValue(TlsSlot slot, u64 value);
u32 GetCurrentCoreNumber();
namespace detail {
extern s32 g_CommandLineParameter;
extern char** g_CommandLineParameterArgv;
}; // namespace detail
}; // namespace os
}; // namespace nn