thread.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstdint>
 
#include <rex/assert.h>
#include <rex/kernel/types/status.h>
#include <rex/kernel/types/list.h>
#include <rex/kernel/types/memory.h>
#include <rex/ppc/context.h>
#include <rex/types.h>
#include <rex/memory.h>
 
namespace rex::kernel {

enum IRQL_FLAGS : u8 {
  kIRQLPassive = 0,
  kIRQLAPC = 1,
  kIRQLDispatch = 2, 
  kIRQLDPC = 3,      
  kIRQLAudio = 68,   
  kIRQLClock = 116,  
  kIRQLHighest = 124
};

enum X_DISPATCHER_FLAGS : u8 {
  kDispatcherManualResetEvent = 0,
  kDispatcherAutoResetEvent = 1,
  kDispatcherMutant = 2,
  kDispatcherQueue = 4,
  kDispatcherSemaphore = 5,
  kDispatcherThread = 6,
  kDispatcherManualResetTimer = 8,
  kDispatcherAutoResetTimer = 9,
};

enum X_KTHREAD_STATE_FLAGS : u8 {
  kKThreadStateInitialized = 0, 
  kKThreadStateReady = 1,       
  kKThreadStateRunning = 2,
  kKThreadStateStandby = 3,    
  kKThreadStateTerminated = 4, 
  kKThreadStateWaiting = 5,    
  kKThreadStateUnknown = 6,    
};
 
constexpr u32 kXCreateSuspended = 0x00000001;
 
constexpr u32 kXTLSOutOfIndexes = UINT32_MAX; 

struct X_DISPATCH_HEADER {
  struct {
    u8 type; 
 
    union {
      u8 abandoned;
      u8 absolute;
      u8 npx_irql;   
      u8 signalling; 
    };
    union {
      u8 size; 
      u8 hand; 
      u8 process_type;
    };
    union {
      u8 inserted;     
      u8 debug_active; 
      u8 dpc_active;   
    };
  };
 
  be_u32 signal_state; 
  be_u32 wait_list_flink;
  be_u32 wait_list_blink;
};
REX_STATIC_ASSERT_SIZE(X_DISPATCH_HEADER, 0x10);
 
struct X_KSEMAPHORE {
  X_DISPATCH_HEADER header;
  be_u32 limit; 
};
REX_STATIC_ASSERT_SIZE(X_KSEMAPHORE, 0x14);
 
struct XKQueue {
  X_DISPATCH_HEADER header;
  X_LIST_ENTRY entry_list_head;  
  be_u32 current_count;          
  be_u32 maximum_count;          
  X_LIST_ENTRY thread_list_head; 
};
REX_STATIC_ASSERT_SIZE(XKQueue, 0x28);
 
struct X_KDPC;
 
struct X_KTIMER {
  X_DISPATCH_HEADER header;
  be_u64 due_time;                 
  X_LIST_ENTRY table_bucket_entry; 
  be_ptr<X_KDPC> dpc;              
  be_u32 period;                   
};
REX_STATIC_ASSERT_SIZE(X_KTIMER, 0x28);

struct X_OBJECT_HEADER {
  be_u32 pointer_count;   
  be_u32 handle_count;    
  be_u32 object_type_ptr; 
  be_u16 flags;           
  u8 hash_index;          
  u8 pad_15;
};
static_assert(offsetof(X_OBJECT_HEADER, object_type_ptr) == 0x8);
static_assert(offsetof(X_OBJECT_HEADER, flags) == 0xC);
REX_STATIC_ASSERT_SIZE(X_OBJECT_HEADER, 0x10);
 
struct X_OBJECT_TYPE {
  be_u32 constructor;
  be_u32 destructor;
  be_u32 unk_08;
  be_u32 unk_0c;
  be_u32 unk_10;
  be_u32 unk_14;
  be_u32 pool_tag; 
};
REX_STATIC_ASSERT_SIZE(X_OBJECT_TYPE, 0x1C);
 
struct X_KDPC {
  be_u16 type;             
  u8 inserted_number;      
  u8 target_number;        
  X_LIST_ENTRY list_entry; 
  be_u32 routine;
  be_u32 context; 
  be_u32 arg1;    
  be_u32 arg2;    

  void Initialize(u32 guest_func, u32 guest_context) {
    type = 19;
    inserted_number = 0;
    target_number = 0;
    list_entry.flink_ptr = 0;
    list_entry.blink_ptr = 0;
    routine = guest_func;
    context = guest_context;
    arg1 = 0;
    arg2 = 0;
  }
};
static_assert(offsetof(X_KDPC, inserted_number) == 0x2);
static_assert(offsetof(X_KDPC, target_number) == 0x3);
REX_STATIC_ASSERT_SIZE(X_KDPC, 0x1C);
 
struct X_THREAD_NOTIFICATION {
  X_LIST_ENTRY list_entry;
  be_u32 notify_routine;
};
REX_STATIC_ASSERT_SIZE(X_THREAD_NOTIFICATION, 0xC);

struct XAPC {
  static constexpr u32 kSize = 40;
  static constexpr u32 kDummyKernelRoutine = 0xF00DFF00;
  static constexpr u32 kDummyRundownRoutine = 0xF00DFF01;
 
  u16 type;    
  u8 apc_mode; 
  u8 enqueued; 
  be_u32 thread_ptr;
  X_LIST_ENTRY list_entry; 
  be_u32 kernel_routine;
  be_u32 rundown_routine;
  be_u32 normal_routine; 
  be_u32 normal_context; 
  be_u32 arg1;           
  be_u32 arg2;           
};
REX_STATIC_ASSERT_SIZE(XAPC, 40);
 
struct X_FIBER_CONTEXT {
  be_u32 fiber_data;       
  be_u32 stack_alloc_base; 
  be_u32 stack_base;
  be_u32 stack_limit;
  rex::be_u32 cr_save;
  u8 reserved_14[0x08];
  rex::be_u32 lr_save;
  u8 reserved_20[0x10];
  be_u64 sp_save; 
  u8 register_save_area[0xA50 - 0x38];
};
REX_STATIC_ASSERT_SIZE(X_FIBER_CONTEXT, 0xA50);
static_assert(sizeof(X_FIBER_CONTEXT::register_save_area) >= ::PPCContext::kNonVolatileSaveSize,
              "fiber register save area too small for PPCContext non-volatiles");
 
struct X_KTHREAD;
struct X_KPROCESS;

struct X_KWAIT_BLOCK {
  X_LIST_ENTRY wait_list_entry; 
  be_ptr<X_KTHREAD> thread;
  be_ptr<X_DISPATCH_HEADER> object;      
  be_ptr<X_KWAIT_BLOCK> next_wait_block; 
  be_u16 wait_result_xstatus;            
  be_u16 wait_type;                      
};
REX_STATIC_ASSERT_SIZE(X_KWAIT_BLOCK, 0x18);

struct X_KPRCB {
  be_ptr<X_KTHREAD> current_thread;
  be_ptr<X_KTHREAD> next_thread;
  be_ptr<X_KTHREAD> idle_thread;
  u8 current_cpu;
  u8 pad_13[3];
  be_u32 processor_mask;  
  be_u32 dpc_clock;       
  be_u32 interrupt_clock; 
  be_u32 interrupt_count;
  be_u32 ipi_frozen;
  be_u32 ipi_args[3];            
  be_u32 targeted_ipi_cpus_mask; 
  be_u32 ipi_function; 
  be_ptr<X_KPRCB> ipi_initiator_prcb; 
  be_u32 request_summary;
  be_u32 dpc_interrupt_requested; 
  be_u32 dpc_lock;                
  X_LIST_ENTRY queued_dpcs_list_head;
  be_u32 dpc_active;           
  X_KSPINLOCK ready_list_lock; 
  be_u32 idle_thread_active;   
  X_SINGLE_LIST_ENTRY enqueued_threads_list;   
  be_u32 has_ready_thread_by_priority;         
  be_u32 ready_summary_mask;                   
  X_LIST_ENTRY dispatcher_ready_list_head[32]; 
  X_KDPC thread_exit_dpc;
  X_LIST_ENTRY terminating_threads_list;
  X_KDPC switch_thread_processor_dpc;
};
REX_STATIC_ASSERT_SIZE(X_KPRCB, 0x1A8);

struct X_KPCR {
  be_u32 tls_ptr; 
  be_u32 msr_mask;
  union {
    be_u16 software_interrupt_state; 
    struct {
      u8 dispatch_software_interrupt;  
      u8 apc_software_interrupt_state; 
    };
  };
  be_u16 unk_0a;
  u8 processtype_value_in_dpc; 
  u8 timeslice_ended;
  u8 timer_pending;
  u8 unk_0f;
  be_u32 thread_fpu_related;
  be_u32 thread_vmx_related;
  u8 current_irql; 
  u8 background_scheduling_active;
  u8 background_scheduling_1a;
  u8 background_scheduling_1b;
  be_u32 timer_related;
  u8 unk_20[0x10];
  be_u64 pcr_ptr; 
  union {
    u8 unk_38[8];   
    u64 host_stash; 
  };

  u8 unk_40[28];
  be_u32 unk_stack_5c;
  u8 unk_60[12];
  be_u32 use_alternative_stack;
  be_u32 stack_base_ptr; 
  be_u32 stack_end_ptr;  
  be_u32 alt_stack_base_ptr;
  be_u32 alt_stack_end_ptr;
  be_u32 interrupt_handlers[32];
  X_KPRCB prcb_data;
  be_ptr<X_KPRCB> prcb; 
  u8 unk_2ac[0x2C];     
};
static_assert(offsetof(X_KPCR, prcb_data) == 0x100);
REX_STATIC_ASSERT_SIZE(X_KPCR, 0x2D8);
 
struct X_KTHREAD {
  X_DISPATCH_HEADER header;
  be_u32 unk_10;
  be_u32 unk_14;
  X_KTIMER wait_timeout_timer;      
  X_KWAIT_BLOCK wait_timeout_block; 
  rex::be_u32 kernel_time;          
  be_u32 stack_base;                
  be_u32 stack_limit;               
  be_u32 stack_kernel;              
  be_u32 tls_address;               
  u8 thread_state;                  
  u8 alerted[2];
  u8 alertable;
  u8 priority;          
  u8 fpu_exceptions_on; 
  u8 process_type_dup;  
  u8 process_type;      
  kernel::X_TYPED_LIST<XAPC, offsetof(XAPC, list_entry)> apc_lists[2];
  be_ptr<X_KPROCESS> process; 
  u8 executing_kernel_apc;
  u8 deferred_apc_software_interrupt_state;
  u8 user_apc_pending;
  u8 may_queue_apcs;    
  X_KSPINLOCK apc_lock; 
  be_u32 num_context_switches_to;
  X_LIST_ENTRY ready_prcb_entry;
  be_u32 msr_mask; 
  rex::BE<X_STATUS> wait_result;
  u8 wait_irql;
  u8 unk_a5[0xB];
  i32 apc_disable_count;
  be_i32 quantum;
  u8 unk_b8;
  u8 unk_b9;
  u8 unk_ba;
  u8 boost_disabled; 
  u8 suspend_count;  
  u8 was_preempted;  
  u8 terminated;     
  u8 current_cpu;
  be_ptr<X_KPRCB> prcb;       
  be_ptr<X_KPRCB> prcb_alias; 
  u8 unk_c8;
  u8 unk_c9;
  u8 unk_ca;
  u8 unk_cb;
  X_KSPINLOCK timer_list_lock;
  be_u32 stack_alloc_base; 
  XAPC on_suspend;
  X_KSEMAPHORE suspend_sema;
  X_LIST_ENTRY process_threads; 
  be_u32 unk_118;
  X_LIST_ENTRY queue_related;
  be_u32 unk_124;
  be_u32 unk_128;
  be_u32 unk_12c;
  be_u64 create_time; 
  be_u64 exit_time;
  be_u32 exit_status;
  X_LIST_ENTRY timer_list; 
  be_u32 thread_id;
  be_u32 start_address;
  X_LIST_ENTRY unk_154; 
  u8 unk_15c[0x4];      
  be_u32 last_error;    
  be_u32 fiber_ptr;     
  u8 unk_168[0x4];      
  be_u32 creation_flags;
  u8 unk_170[0xC];   
  be_u32 unk_17c;    
  u8 unk_180[0x930]; 
};
REX_STATIC_ASSERT_SIZE(X_KTHREAD, 0xAB0);
 
}  // namespace rex::kernel
 
namespace rex::kernel {
 
#pragma pack(push, 4)

struct X_EX_TITLE_TERMINATE_REGISTRATION {
  be_u32 notification_routine;
  be_u32 priority;         
  X_LIST_ENTRY list_entry; 
};
REX_STATIC_ASSERT_SIZE(X_EX_TITLE_TERMINATE_REGISTRATION, 16);
 
struct X_EXCEPTION_RECORD {
  be_u32 code;
  be_u32 exception_flags;
  be_u32 exception_record; 
  be_u32 exception_address;
  be_u32 number_parameters; 
  be_u32 exception_information[15];
};
REX_STATIC_ASSERT_SIZE(X_EXCEPTION_RECORD, 0x50);
 
#pragma pack(pop)
 
}  // namespace rex::kernel
 
namespace rex::kernel {

constexpr u32 kXProcTypeIdle = 0;
constexpr u32 kXProcTypeUser = 1;
constexpr u32 kXProcTypeSystem = 2;
 
struct X_KPROCESS {
  X_KSPINLOCK thread_list_spinlock; 
  X_LIST_ENTRY thread_list;
  be_i32 quantum;
  be_u32 clrdataa_masked_ptr; 
  be_u32 thread_count;        
  u8 unk_18;
  u8 unk_19;
  u8 unk_1a;
  u8 unk_1b;                
  be_u32 kernel_stack_size; 
  be_u32 tls_static_data_address;
  be_u32 tls_data_size;      
  be_u32 tls_raw_data_size;  
  be_u16 tls_slot_size;      
  u8 is_terminating;         
  u8 process_type;           
  be_u32 tls_slot_bitmap[8]; 
  be_u32 unk_50;             
  X_LIST_ENTRY unk_54;       
  be_u32 unk_5c;             
};
REX_STATIC_ASSERT_SIZE(X_KPROCESS, 0x60);

struct X_UNKNOWN_TYPE_REFED {
  be_u32 unk_00;          
  be_u32 unk_04;          
  be_u32 points_to_self;  
  be_u32 points_to_prior; 
};
REX_STATIC_ASSERT_SIZE(X_UNKNOWN_TYPE_REFED, 16);

struct KernelGuestGlobals {
  X_OBJECT_TYPE ExThreadObjectType;
  X_OBJECT_TYPE ExEventObjectType;
  X_OBJECT_TYPE ExMutantObjectType;
  X_OBJECT_TYPE ExSemaphoreObjectType;
  X_OBJECT_TYPE ExTimerObjectType;
  X_OBJECT_TYPE IoCompletionObjectType;
  X_OBJECT_TYPE IoDeviceObjectType;
  X_OBJECT_TYPE IoFileObjectType;
  X_OBJECT_TYPE ObDirectoryObjectType;
  X_OBJECT_TYPE ObSymbolicLinkObjectType;
  X_UNKNOWN_TYPE_REFED self_list_object;
  X_KPROCESS idle_process;
  X_KPROCESS title_process;
  X_KPROCESS system_process;   
  X_KSPINLOCK dispatcher_lock; 
  X_KSPINLOCK ob_lock;         
  X_KSPINLOCK tls_lock;        
  u8 UsbdBootEnumerationDoneEvent[0x10]; 
  be_u32 ecc_curves[15];
};
 
}  // namespace rex::kernel