thread.h

Go to the documentation of this file.

#pragma once
 
#include <kernel/cpu/interrupt.h>
#include <kernel/cpu/simd.h>
#include <kernel/cpu/stack_pointer.h>
#include <kernel/cpu/syscalls.h>
#include <kernel/ipc/note.h>
#include <kernel/proc/process.h>
#include <kernel/sched/sched.h>
#include <kernel/sched/wait.h>
#include <kernel/utils/ref.h>
 
#include <sys/list.h>
#include <sys/proc.h>
 
typedef enum
{
    THREAD_PARKED = 0, 
    THREAD_READY,      
    THREAD_RUNNING,    
    THREAD_PRE_BLOCK,  
    THREAD_BLOCKED,    
    THREAD_UNBLOCKING, 
} thread_state_t;
 
typedef struct thread
{
    list_entry_t entry;        
    process_t* process;        
    list_entry_t processEntry; 
    tid_t id;                  
    _Atomic(thread_state_t) state;
    errno_t error;
    stack_pointer_t kernelStack; 
    stack_pointer_t userStack;   
    sched_thread_ctx_t sched;
    wait_thread_ctx_t wait;
    simd_ctx_t simd;
    note_queue_t notes;
    syscall_ctx_t syscall;
    interrupt_frame_t frame;
} thread_t;
 
thread_t* thread_new(process_t* process);
 
void thread_free(thread_t* thread);
 
void thread_save(thread_t* thread, const interrupt_frame_t* frame);
 
void thread_load(thread_t* thread, interrupt_frame_t* frame);
 
_NORETURN extern void thread_jump(thread_t* thread);
 
void thread_get_interrupt_frame(thread_t* thread, interrupt_frame_t* frame);
 
bool thread_is_note_pending(thread_t* thread);
 
uint64_t thread_send_note(thread_t* thread, const void* buffer, uint64_t count);
 
thread_t* thread_get_boot(void);
 
uint64_t thread_handle_page_fault(const interrupt_frame_t* frame);
 
uint64_t thread_copy_from_user(thread_t* thread, void* dest, const void* userSrc, uint64_t length);
 
uint64_t thread_copy_to_user(thread_t* thread, void* dest, const void* userSrc, uint64_t length);
 
uint64_t thread_copy_from_user_terminated(thread_t* thread, const void* userArray, const void* terminator,
    uint8_t objectSize, uint64_t maxCount, void** outArray, uint64_t* outCount);
 
uint64_t thread_copy_from_user_pathname(thread_t* thread, pathname_t* pathname, const char* userPath);
 
uint64_t thread_load_atomic_from_user(thread_t* thread, atomic_uint64_t* userObj, uint64_t* outValue);