Download rtx/windows_rtx/main.c from Snapkitty/sov-kernel-monster: direct link, hf CLI and curl.
- Browser
- Download file 8.87 kB
-
https://huggingface.co/Snapkitty/sov-kernel-monster/resolve/main/rtx/windows_rtx/main.c
- Command line
-
hf download hf://Snapkitty/sov-kernel-monster/rtx/windows_rtx/main.c
-
curl -L -o main.c https://huggingface.co/Snapkitty/sov-kernel-monster/resolve/main/rtx/windows_rtx/main.c
8.87 kB
| /* | |
| * Zero-CRT diagnostic entry point. | |
| * | |
| * The CUDA driver, embedded PTX modules, and KV allocator are initialized in | |
| * dependency order. The scheduler is intentionally not entered until its C-- | |
| * bridge and the WORM/Janet implementations exist in the link graph. | |
| */ | |
| typedef unsigned long long uint64_t; | |
| typedef unsigned int uint32_t; | |
| typedef unsigned short uint16_t; | |
| typedef unsigned char uint8_t; | |
| typedef int int32_t; | |
| typedef unsigned long ULONG; | |
| typedef void* PVOID; | |
| typedef PVOID HANDLE; | |
| typedef uint32_t DWORD; | |
| typedef struct _SOV_LIST_ENTRY { | |
| struct _SOV_LIST_ENTRY* Flink; | |
| struct _SOV_LIST_ENTRY* Blink; | |
| } SOV_LIST_ENTRY; | |
| typedef struct { | |
| uint16_t Length; | |
| uint16_t MaximumLength; | |
| uint16_t* Buffer; | |
| } SOV_UNICODE_STRING; | |
| typedef struct { | |
| SOV_LIST_ENTRY InLoadOrderLinks; | |
| SOV_LIST_ENTRY InMemoryOrderLinks; | |
| SOV_LIST_ENTRY InInitializationOrderLinks; | |
| PVOID DllBase; | |
| PVOID EntryPoint; | |
| ULONG SizeOfImage; | |
| SOV_UNICODE_STRING FullDllName; | |
| SOV_UNICODE_STRING BaseDllName; | |
| } SOV_LDR_DATA_TABLE_ENTRY; | |
| typedef struct { | |
| ULONG Length; | |
| uint32_t Initialized; | |
| HANDLE SsHandle; | |
| SOV_LIST_ENTRY InLoadOrderModuleList; | |
| SOV_LIST_ENTRY InMemoryOrderModuleList; | |
| } SOV_PEB_LDR_DATA; | |
| typedef struct { | |
| uint8_t Reserved1[4]; | |
| PVOID Reserved2[2]; | |
| SOV_PEB_LDR_DATA* Ldr; | |
| } SOV_PEB; | |
| typedef struct { | |
| uint32_t Characteristics; | |
| uint32_t TimeDateStamp; | |
| uint16_t MajorVersion; | |
| uint16_t MinorVersion; | |
| uint32_t Name; | |
| uint32_t Base; | |
| uint32_t NumberOfFunctions; | |
| uint32_t NumberOfNames; | |
| uint32_t AddressOfFunctions; | |
| uint32_t AddressOfNames; | |
| uint32_t AddressOfNameOrdinals; | |
| } SOV_IMAGE_EXPORT_DIRECTORY; | |
| typedef int (*WriteConsoleA_t)(HANDLE, const void*, DWORD, DWORD*, void*); | |
| typedef HANDLE (*GetStdHandle_t)(DWORD); | |
| typedef void (*ExitProcess_t)(DWORD); | |
| static WriteConsoleA_t g_WriteConsoleA; | |
| static GetStdHandle_t g_GetStdHandle; | |
| static ExitProcess_t g_ExitProcess; | |
| extern int sov_cuda_init(void); | |
| extern void sov_cuda_shutdown(void); | |
| extern int sov_cuda_kernels_init(void); | |
| extern void sov_cuda_kernels_shutdown(void); | |
| extern int sov_kv_allocator_init(void); | |
| extern void sov_kv_allocator_shutdown(void); | |
| static const uint16_t g_kernelbase_name[] = { | |
| 'k','e','r','n','e','l','b','a','s','e','.','d','l','l', 0 | |
| }; | |
| static const uint16_t g_kernel32_name[] = { | |
| 'k','e','r','n','e','l','3','2','.','d','l','l', 0 | |
| }; | |
| static PVOID peb_find(const uint16_t* target) { | |
| PVOID peb_address; | |
| SOV_PEB_LDR_DATA* loader; | |
| SOV_LIST_ENTRY* head; | |
| SOV_LIST_ENTRY* current; | |
| __asm__ volatile("mov %%gs:0x60,%0" : "=r"(peb_address)); | |
| loader = ((SOV_PEB*)peb_address)->Ldr; | |
| if (!loader) return 0; | |
| head = &loader->InMemoryOrderModuleList; | |
| current = head->Flink; | |
| while (current && current != head) { | |
| SOV_LDR_DATA_TABLE_ENTRY* entry = | |
| (SOV_LDR_DATA_TABLE_ENTRY*)((uint8_t*)current - 16u); | |
| uint32_t length = (uint32_t)entry->BaseDllName.Length / 2u; | |
| uint32_t i; | |
| int equal = entry->BaseDllName.Buffer != 0; | |
| for (i = 0; equal && i < length; ++i) { | |
| uint16_t actual = entry->BaseDllName.Buffer[i]; | |
| uint16_t expected = target[i]; | |
| if (actual >= 'A' && actual <= 'Z') actual += ('a' - 'A'); | |
| if (expected >= 'A' && expected <= 'Z') expected += ('a' - 'A'); | |
| if (actual != expected) equal = 0; | |
| } | |
| if (equal && target[length] == 0) return entry->DllBase; | |
| current = current->Flink; | |
| } | |
| return 0; | |
| } | |
| static int ascii_compare(const char* left, const char* right) { | |
| uint32_t i = 0; | |
| while (left[i] && right[i] && left[i] == right[i]) ++i; | |
| if ((uint8_t)left[i] < (uint8_t)right[i]) return -1; | |
| if ((uint8_t)left[i] > (uint8_t)right[i]) return 1; | |
| return 0; | |
| } | |
| static PVOID pe_export(PVOID module, const char* name) { | |
| uint8_t* image = (uint8_t*)module; | |
| int32_t pe_offset; | |
| uint8_t* nt; | |
| uint8_t* optional_header; | |
| uint32_t export_rva, export_size; | |
| SOV_IMAGE_EXPORT_DIRECTORY* exports; | |
| uint32_t* names; | |
| uint32_t* functions; | |
| uint16_t* ordinals; | |
| int32_t low, high; | |
| if (!image || *(uint16_t*)image != 0x5A4Du) return 0; | |
| pe_offset = *(int32_t*)(image + 0x3cu); | |
| if (pe_offset <= 0) return 0; | |
| nt = image + (uint32_t)pe_offset; | |
| if (*(uint32_t*)nt != 0x00004550u) return 0; | |
| optional_header = nt + 24u; | |
| if (*(uint16_t*)optional_header != 0x020bu) return 0; | |
| export_rva = *(uint32_t*)(optional_header + 112u); | |
| export_size = *(uint32_t*)(optional_header + 116u); | |
| if (!export_rva || !export_size) return 0; | |
| exports = (SOV_IMAGE_EXPORT_DIRECTORY*)(image + export_rva); | |
| names = (uint32_t*)(image + exports->AddressOfNames); | |
| functions = (uint32_t*)(image + exports->AddressOfFunctions); | |
| ordinals = (uint16_t*)(image + exports->AddressOfNameOrdinals); | |
| low = 0; | |
| high = (int32_t)exports->NumberOfNames - 1; | |
| while (low <= high) { | |
| int32_t middle = low + ((high - low) / 2); | |
| const char* cand = (const char*)(image + names[middle]); | |
| int cmp = ascii_compare(cand, name); | |
| if (cmp == 0) { | |
| uint16_t ord = ordinals[middle]; | |
| uint32_t fn_rva; | |
| if ((uint32_t)ord >= exports->NumberOfFunctions) return 0; | |
| fn_rva = functions[ord]; | |
| if (fn_rva >= export_rva && fn_rva < export_rva + export_size) | |
| return 0; | |
| return (PVOID)(image + fn_rva); | |
| } | |
| if (cmp < 0) low = middle + 1; | |
| else high = middle - 1; | |
| } | |
| return 0; | |
| } | |
| static int resolve_process_apis(void) { | |
| PVOID module = peb_find(g_kernelbase_name); | |
| union { PVOID address; WriteConsoleA_t function; } wc; | |
| union { PVOID address; GetStdHandle_t function; } gs; | |
| union { PVOID address; ExitProcess_t function; } ep; | |
| if (!module) module = peb_find(g_kernel32_name); | |
| if (!module) return -1; | |
| wc.address = pe_export(module, "WriteConsoleA"); | |
| gs.address = pe_export(module, "GetStdHandle"); | |
| ep.address = pe_export(module, "ExitProcess"); | |
| g_WriteConsoleA = wc.function; | |
| g_GetStdHandle = gs.function; | |
| g_ExitProcess = ep.function; | |
| return (g_WriteConsoleA && g_GetStdHandle && g_ExitProcess) ? 0 : -1; | |
| } | |
| static void console_write(const char* text) { | |
| DWORD length = 0, written = 0; | |
| HANDLE output; | |
| if (!g_WriteConsoleA || !g_GetStdHandle || !text) return; | |
| while (text[length]) ++length; | |
| output = g_GetStdHandle((DWORD)-11); | |
| g_WriteConsoleA(output, text, length, &written, 0); | |
| } | |
| static void terminate_process(DWORD exit_code) { | |
| if (g_ExitProcess) g_ExitProcess(exit_code); | |
| for (;;) __asm__ volatile("hlt"); | |
| } | |
| void sov_main(void) { | |
| int status; | |
| if (resolve_process_apis() != 0) | |
| terminate_process(SOV_EXIT_BOOTSTRAP_API); | |
| console_write("SOV RTX DIAGNOSTIC BOOT\r\n"); | |
| status = sov_cuda_init(); | |
| if (status != 0) { | |
| console_write("CUDA INIT FAILED\r\n"); | |
| terminate_process(SOV_EXIT_CUDA_INIT); | |
| } | |
| console_write("CUDA DRIVER OK\r\n"); | |
| status = sov_cuda_kernels_init(); | |
| if (status != 0) { | |
| console_write("CUDA KERNEL INIT FAILED\r\n"); | |
| sov_cuda_kernels_shutdown(); | |
| sov_cuda_shutdown(); | |
| terminate_process(SOV_EXIT_CUDA_KERNEL_INIT); | |
| } | |
| console_write("CUDA KERNELS OK\r\n"); | |
| status = sov_kv_allocator_init(); | |
| if (status != 0) { | |
| console_write("KV ALLOCATOR INIT FAILED\r\n"); | |
| sov_kv_allocator_shutdown(); | |
| sov_cuda_kernels_shutdown(); | |
| sov_cuda_shutdown(); | |
| terminate_process(SOV_EXIT_KV_ALLOCATOR_INIT); | |
| } | |
| console_write("KV ALLOCATOR OK\r\n"); | |
| /* | |
| * Fail closed. power_handler.c cannot enter the link until its WORM and | |
| * Janet dependencies exist, and scheduler.cmm has no C ABI bridge yet. | |
| */ | |
| console_write("SCHEDULER/WORM/JANET UNWIRED - HALTING\r\n"); | |
| sov_kv_allocator_shutdown(); | |
| sov_cuda_kernels_shutdown(); | |
| sov_cuda_shutdown(); | |
| console_write("RTX SHUTDOWN OK\r\n"); | |
| terminate_process(SOV_EXIT_SCHEDULER_UNWIRED); | |
| } | |