threading.h

Go to the documentation of this file.

/*
 * Copyright 2021-present dogtopus
 * SPDX-License-Identifier: MIT
 */
 
#ifndef __MUTEKI_THREADING_H__
#define __MUTEKI_THREADING_H__
 
#include <muteki/common.h>
#include <muteki/errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum thread_wait_reason_e {
    WAIT_ON_NONE = 0x0,
    WAIT_ON_SEMAPHORE = 0x1,
    WAIT_ON_EVENT = 0x2,
    WAIT_ON_QUEUE = 0x4,
    WAIT_ON_SUSPEND = 0x8,
    WAIT_ON_CRITICAL_SECTION = 0x10,
    WAIT_ON_SLEEP = 0x20,
};
 
typedef enum wait_result_e {
    WAIT_RESULT_TIMEOUT = 0x82,
    WAIT_RESULT_RESOLVED,
    WAIT_RESULT_ERROR,
} wait_result_t;
 
typedef int (*thread_func_t)(void *user_data);
 
typedef struct {
    unsigned char active_bytes;
    unsigned char waiting_by[8];
} threading_waitable_t;
 
typedef char message_queue_message_t[16] SYS_ALIGN(4);
 
typedef struct {
    message_queue_message_t *messages;
    unsigned short size;
    short pop_idx;
    short push_idx;
    short _padding_0xa;
} message_queue_nonatomic_t;
 
typedef struct thread_s thread_t;
typedef struct semaphore_s semaphore_t;
typedef struct event_s event_t;
typedef struct critical_section_s critical_section_t;
typedef struct message_queue_s message_queue_t;
 
struct thread_s {
    int magic; // always 0x100
    uintptr_t *sp;
    void *stack;
    int exit_code; // init to 0
    kerrno_t kerrno; // init to 0
    uintptr_t unk_0x14; // init to 0x80000000
    thread_func_t thread_func;
    short unk_0x1c;
    short sleep_counter;
    short wait_reason; // 0x20
    short slot; // 0x22
    char slot_low3b;
    char slot_high3b;
    unsigned char slot_low3b_bit;
    unsigned char slot_high3b_bit;
    event_t *event;
    thread_t *prev;
    thread_t *next;
    union {
        char unk_0x34[0x20];
        uintptr_t ktls[8];
    };
};
 
struct semaphore_s {
    int magic;
    int _padding_0x4;
    short ctr;
    threading_waitable_t wait_state;
    char _padding_0x13;
};
 
struct event_s {
    int magic;
    int flag;
    short latch_on;
    threading_waitable_t wait_state;
    char _padding_0x13;
};
 
struct critical_section_s {
    int magic; // 0x00000202
    thread_t *thr;
    unsigned short refcount;
    threading_waitable_t wait_state;
    char _padding_0x13;
}; // 0x14
 
struct message_queue_s {
    int magic;
    message_queue_nonatomic_t *storage;
    short _padding_0x8;
    threading_waitable_t wait_state;
    char _padding_0x13;
};
 
extern thread_t *OSCreateThread(thread_func_t func, void *user_data, size_t stack_size, bool defer_start);
 
extern int OSTerminateThread(thread_t *thr, int exit_code);
 
 extern bool OSSetThreadPriority(thread_t *thr, short new_slot);
 
extern short OSGetThreadPriority(thread_t *thr);
 
extern bool OSSuspendThread(thread_t *thr);
 
extern bool OSResumeThread(thread_t *thr);
 
extern bool OSWakeUpThread(thread_t *thr);
 
 extern int OSExitThread(int exit_code);
 
extern void OSSleep(short millis);
 
extern semaphore_t *OSCreateSemaphore(short init_ctr);
 
extern wait_result_t OSWaitForSemaphore(semaphore_t *semaphore, short timeout);
 
extern bool OSReleaseSemaphore(semaphore_t *semaphore);
 
extern bool OSCloseSemaphore(semaphore_t *semaphore);
 
extern event_t *OSCreateEvent(short latch_on, int flag);
 
extern wait_result_t OSWaitForEvent(event_t *event, short timeout);
 
extern bool OSSetEvent(event_t *event);
 
extern bool OSResetEvent(event_t *event);
 
extern bool OSCloseEvent(event_t *event);
 
extern void OSInitCriticalSection(critical_section_t *cs);
 
extern void OSEnterCriticalSection(critical_section_t *cs);
 
extern void OSLeaveCriticalSection(critical_section_t *cs);
 
extern void OSDeleteCriticalSection(critical_section_t *cs);
 
extern message_queue_t *OSCreateMsgQue(unsigned short size);
 
extern bool OSPostMsgQue(message_queue_t *queue, const message_queue_message_t *message);
 
extern bool OSSendMsgQue(message_queue_t *queue, const message_queue_message_t *message);
 
extern bool OSPeekMsgQue(message_queue_t *queue, message_queue_message_t *message);
 
extern bool OSGetMsgQue(message_queue_t *queue, message_queue_message_t *message);
 
extern bool OSCloseMsgQue(message_queue_t *queue);
 
extern short OSGetCurrentlyRunningTCBPrio(void);
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#endif // __MUTEKI_THREADING_H__