diff --git a/core/sys/windows/kernel32.odin b/core/sys/windows/kernel32.odin index b389fc9c5..85269fd6e 100644 --- a/core/sys/windows/kernel32.odin +++ b/core/sys/windows/kernel32.odin @@ -112,6 +112,7 @@ foreign kernel32 { args: rawptr, ) -> DWORD --- TlsAlloc :: proc() -> DWORD --- + TlsFree :: proc(dwTlsIndex: DWORD) -> BOOL --- TlsGetValue :: proc(dwTlsIndex: DWORD) -> LPVOID --- TlsSetValue :: proc(dwTlsIndex: DWORD, lpTlsvalue: LPVOID) -> BOOL --- GetLastError :: proc() -> DWORD --- @@ -281,3 +282,438 @@ foreign kernel32 { CreatePipe :: proc(hReadPipe, hWritePipe: ^HANDLE, lpPipeAttributes: LPSECURITY_ATTRIBUTES, nSize: DWORD) -> BOOL --- } + + +STANDARD_RIGHTS_REQUIRED :: DWORD(0x000F0000); +SECTION_QUERY :: DWORD(0x0001); +SECTION_MAP_WRITE :: DWORD(0x0002); +SECTION_MAP_READ :: DWORD(0x0004); +SECTION_MAP_EXECUTE :: DWORD(0x0008); +SECTION_EXTEND_SIZE :: DWORD(0x0010); +SECTION_ALL_ACCESS :: STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE; +SECTION_MAP_EXECUTE_EXPLICIT :: DWORD(0x0020); + +FILE_MAP_WRITE :: DWORD(SECTION_MAP_WRITE); +FILE_MAP_READ :: DWORD(SECTION_MAP_READ); +FILE_MAP_ALL_ACCESS :: DWORD(SECTION_ALL_ACCESS); +FILE_MAP_EXECUTE :: DWORD(SECTION_MAP_EXECUTE_EXPLICIT); +FILE_MAP_COPY :: DWORD(0x00000001); +FILE_MAP_RESERVE :: DWORD(0x80000000); +FILE_MAP_TARGETS_INVALID :: DWORD(0x40000000); +FILE_MAP_LARGE_PAGES :: DWORD(0x20000000); + +PAGE_NOACCESS :: 0x01; +PAGE_READONLY :: 0x02; +PAGE_READWRITE :: 0x04; +PAGE_WRITECOPY :: 0x08; +PAGE_EXECUTE :: 0x10; +PAGE_EXECUTE_READ :: 0x20; +PAGE_EXECUTE_READWRITE :: 0x40; +PAGE_EXECUTE_WRITECOPY :: 0x80; +PAGE_GUARD :: 0x100; +PAGE_NOCACHE :: 0x200; +PAGE_WRITECOMBINE :: 0x400; + +MEMORY_BASIC_INFORMATION :: struct { + BaseAddress: PVOID, + AllocationBase: PVOID, + AllocationProtect: DWORD, + PartitionId: WORD, + RegionSize: SIZE_T, + State: DWORD, + Protect: DWORD, + Type: DWORD, +} +PMEMORY_BASIC_INFORMATION :: ^MEMORY_BASIC_INFORMATION; +LPMEMORY_BASIC_INFORMATION :: ^MEMORY_BASIC_INFORMATION; + +MEM_COMMIT :: 0x1000; +MEM_RESERVE :: 0x2000; +MEM_DECOMMIT :: 0x4000; +MEM_RELEASE :: 0x8000; +MEM_FREE :: 0x10000; +MEM_PRIVATE :: 0x20000; +MEM_MAPPED :: 0x40000; +MEM_RESET :: 0x80000; +MEM_TOP_DOWN :: 0x100000; +MEM_LARGE_PAGES :: 0x20000000; +MEM_4MB_PAGES :: 0x80000000; + +foreign kernel32 { + VirtualAlloc :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + flAllocationType: DWORD, + flProtect: DWORD, + ) -> LPVOID ---; + VirtualProtect :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + flNewProtect: DWORD, + lpflOldProtect: PDWORD, + ) -> BOOL ---; + VirtualFree :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + dwFreeType: DWORD, + ) -> BOOL ---; + VirtualQuery :: proc( + lpAddress: LPCVOID, + lpBuffer: PMEMORY_BASIC_INFORMATION, + dwLength: SIZE_T, + ) -> SIZE_T ---; + VirtualAllocEx :: proc( + hProcess: HANDLE, + lpAddress: LPVOID, + dwSize: SIZE_T, + flAllocationType: DWORD, + flProtect: DWORD, + ) -> LPVOID ---; + VirtualFreeEx :: proc( + hProcess: HANDLE, + lpAddress: LPVOID, + dwSize: SIZE_T, + dwFreeType: DWORD, + ) -> BOOL ---; + VirtualProtectEx :: proc( + hProcess: HANDLE, + lpAddress: LPVOID, + dwSize: SIZE_T, + flNewProtect: DWORD, + lpflOldProtect: PDWORD, + ) -> BOOL ---; + VirtualQueryEx :: proc( + hProcess: HANDLE, + lpAddress: LPCVOID, + lpBuffer: PMEMORY_BASIC_INFORMATION, + dwLength: SIZE_T, + ) -> SIZE_T ---; + ReadProcessMemory :: proc( + hProcess: HANDLE, + lpBaseAddress: LPCVOID, + lpBuffer: LPVOID, + nSize: SIZE_T, + lpNumberOfBytesRead: ^SIZE_T, + ) -> BOOL ---; + WriteProcessMemory :: proc( + hProcess: HANDLE, + lpBaseAddress: LPVOID, + lpBuffer: LPCVOID, + nSize: SIZE_T, + lpNumberOfBytesWritten: ^SIZE_T, + ) -> BOOL ---; + CreateFileMappingW :: proc( + hFile: HANDLE, + lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, + flProtect: DWORD, + dwMaximumSizeHigh: DWORD, + dwMaximumSizeLow: DWORD, + lpName: LPCWSTR, + ) -> HANDLE ---; + OpenFileMappingW :: proc( + dwDesiredAccess: DWORD, + bInheritHandle: BOOL, + lpName: LPCWSTR, + ) -> HANDLE ---; + MapViewOfFile :: proc( + hFileMappingObject: HANDLE, + dwDesiredAccess: DWORD, + dwFileOffsetHigh: DWORD, + dwFileOffsetLow: DWORD, + dwNumberOfBytesToMap: SIZE_T, + ) -> LPVOID ---; + MapViewOfFileEx :: proc( + hFileMappingObject: HANDLE, + dwDesiredAccess: DWORD, + dwFileOffsetHigh: DWORD, + dwFileOffsetLow: DWORD, + dwNumberOfBytesToMap: SIZE_T, + lpBaseAddress: LPVOID, + ) -> LPVOID ---; + FlushViewOfFile :: proc( + lpBaseAddress: LPCVOID, + dwNumberOfBytesToFlush: SIZE_T, + ) -> BOOL ---; + UnmapViewOfFile :: proc( + lpBaseAddress: LPCVOID, + ) -> BOOL ---; + GetLargePageMinimum :: proc() -> SIZE_T ---; + GetProcessWorkingSetSizeEx :: proc( + hProcess: HANDLE, + lpMinimumWorkingSetSize: PSIZE_T, + lpMaximumWorkingSetSize: PSIZE_T, + Flags: PDWORD, + ) -> BOOL ---; + SetProcessWorkingSetSizeEx :: proc( + hProcess: HANDLE, + dwMinimumWorkingSetSize: SIZE_T, + dwMaximumWorkingSetSize: SIZE_T, + Flags: DWORD, + ) -> BOOL ---; + VirtualLock :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + ) -> BOOL ---; + VirtualUnlock :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + ) -> BOOL ---; + GetWriteWatch :: proc( + dwFlags: DWORD, + lpBaseAddress: PVOID, + dwRegionSize: SIZE_T, + lpAddresses: ^PVOID, + lpdwCount: ^ULONG_PTR, + lpdwGranularity: LPDWORD, + ) -> UINT ---; + ResetWriteWatch :: proc( + lpBaseAddress: LPVOID, + dwRegionSize: SIZE_T, + ) -> UINT ---; +} + + +using MEMORY_RESOURCE_NOTIFICATION_TYPE :: enum c_int { + LowMemoryResourceNotification, + HighMemoryResourceNotification, +} + + +foreign kernel32 { + CreateMemoryResourceNotification :: proc( + NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE, + ) -> HANDLE ---; + QueryMemoryResourceNotification :: proc( + ResourceNotificationHandle: HANDLE, + ResourceState: PBOOL, + ) -> BOOL ---; +} + +FILE_CACHE_MAX_HARD_ENABLE :: DWORD(0x00000001); +FILE_CACHE_MAX_HARD_DISABLE :: DWORD(0x00000002); +FILE_CACHE_MIN_HARD_ENABLE :: DWORD(0x00000004); +FILE_CACHE_MIN_HARD_DISABLE :: DWORD(0x00000008); + +foreign kernel32 { + GetSystemFileCacheSize :: proc( + lpMinimumFileCacheSize: PSIZE_T, + lpMaximumFileCacheSize: PSIZE_T, + lpFlags: PDWORD, + ) -> BOOL ---; + SetSystemFileCacheSize :: proc( + MinimumFileCacheSize: SIZE_T, + MaximumFileCacheSize: SIZE_T, + Flags: DWORD, + ) -> BOOL ---; + CreateFileMappingNumaW :: proc( + hFile: HANDLE, + lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, + flProtect: DWORD, + dwMaximumSizeHigh: DWORD, + dwMaximumSizeLow: DWORD, + lpName: LPCWSTR, + nndPreferred: DWORD, + ) -> HANDLE ---; +} + +WIN32_MEMORY_RANGE_ENTRY :: struct { + VirtualAddress: PVOID, + NumberOfBytes: SIZE_T, +} + +PWIN32_MEMORY_RANGE_ENTRY :: ^WIN32_MEMORY_RANGE_ENTRY; + +foreign kernel32 { + PrefetchVirtualMemory :: proc( + hProcess: HANDLE, + NumberOfEntries: ULONG_PTR, + VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY, + Flags: ULONG, + ) -> BOOL ---; + CreateFileMappingFromApp :: proc( + hFile: HANDLE, + SecurityAttributes: PSECURITY_ATTRIBUTES, + PageProtection: ULONG, + MaximumSize: ULONG64, + Name: PCWSTR, + ) -> HANDLE ---; + MapViewOfFileFromApp :: proc( + hFileMappingObject: HANDLE, + DesiredAccess: ULONG, + FileOffset: ULONG64, + NumberOfBytesToMap: SIZE_T, + ) -> PVOID ---; + UnmapViewOfFileEx :: proc( + BaseAddress: PVOID, + UnmapFlags: ULONG, + ) -> BOOL ---; + AllocateUserPhysicalPages :: proc( + hProcess: HANDLE, + NumberOfPages: PULONG_PTR, + PageArray: PULONG_PTR, + ) -> BOOL ---; + FreeUserPhysicalPages :: proc( + hProcess: HANDLE, + NumberOfPages: PULONG_PTR, + PageArray: PULONG_PTR, + ) -> BOOL ---; + MapUserPhysicalPages :: proc( + VirtualAddress: PVOID, + NumberOfPages: ULONG_PTR, + PageArray: PULONG_PTR, + ) -> BOOL ---; + AllocateUserPhysicalPagesNuma :: proc( + hProcess: HANDLE, + NumberOfPages: PULONG_PTR, + PageArray: PULONG_PTR, + nndPreferred: DWORD, + ) -> BOOL ---; + VirtualAllocExNuma :: proc( + hProcess: HANDLE, + lpAddress: LPVOID, + dwSize: SIZE_T, + flAllocationType: DWORD, + flProtect: DWORD, + nndPreferred: DWORD, + ) -> LPVOID ---; +} + +MEHC_PATROL_SCRUBBER_PRESENT :: ULONG(0x1); + +foreign kernel32 { + GetMemoryErrorHandlingCapabilities :: proc( + Capabilities: PULONG, + ) -> BOOL ---; +} + +PBAD_MEMORY_CALLBACK_ROUTINE :: #type proc "stdcall" (); + +foreign kernel32 { + RegisterBadMemoryNotification :: proc( + Callback: PBAD_MEMORY_CALLBACK_ROUTINE, + ) -> PVOID ---; + UnregisterBadMemoryNotification :: proc( + RegistrationHandle: PVOID, + ) -> BOOL ---; +} + +using OFFER_PRIORITY :: enum c_int { + VmOfferPriorityVeryLow = 1, + VmOfferPriorityLow, + VmOfferPriorityBelowNormal, + VmOfferPriorityNormal, +} + +foreign kernel32 { + OfferVirtualMemory :: proc( + VirtualAddress: PVOID, + Size: SIZE_T, + Priority: OFFER_PRIORITY, + ) -> DWORD ---; + ReclaimVirtualMemory :: proc( + VirtualAddress: PVOID, + Size: SIZE_T, + ) -> DWORD ---; + DiscardVirtualMemory :: proc( + VirtualAddress: PVOID, + Size: SIZE_T, + ) -> DWORD ---; + VirtualAllocFromApp :: proc( + BaseAddress: PVOID, + Size: SIZE_T, + AllocationType: ULONG, + Protection: ULONG, + ) -> PVOID ---; + VirtualProtectFromApp :: proc( + Address: PVOID, + Size: SIZE_T, + NewProtection: ULONG, + OldProtection: PULONG, + ) -> BOOL ---; + OpenFileMappingFromApp :: proc( + DesiredAccess: ULONG, + InheritHandle: BOOL, + Name: PCWSTR, + ) -> HANDLE ---; +} + +using WIN32_MEMORY_INFORMATION_CLASS :: enum c_int { + MemoryRegionInfo, +} +WIN32_MEMORY_REGION_INFORMATION :: struct { + AllocationBase: PVOID, + AllocationProtect: ULONG, + u: WIN32_MEMORY_REGION_INFORMATION_u, + RegionSize: SIZE_T, + CommitSize: SIZE_T, +} +WIN32_MEMORY_REGION_INFORMATION_u :: struct #raw_union { + u: [1]u32, + Flags: ULONG, + s: WIN32_MEMORY_REGION_INFORMATION_u_s, +} +WIN32_MEMORY_REGION_INFORMATION_u_s :: struct { + Bitfield: ULONG, +} +WIN32_MEMORY_REGION_INFORMATION_u_s_Bitfield :: bit_field #align align_of(ULONG) { + Private : 1-0, + MappedDataFile : 2-1, + MappedImage : 3-2, + MappedPageFile : 4-3, + MappedPhysical : 5-4, + DirectMapped : 6-5, + Reserved : 32-6, +} + +foreign kernel32 { + QueryVirtualMemoryInformation :: proc( + Process: HANDLE, + VirtualAddress: PVOID, + MemoryInformationClass: WIN32_MEMORY_INFORMATION_CLASS, + MemoryInformation: PVOID, + MemoryInformationSize: SIZE_T, + ReturnSize: PSIZE_T, + ) -> BOOL --- + MapViewOfFileNuma2 :: proc( + FileMappingHandle: HANDLE, + ProcessHandle: HANDLE, + Offset: ULONG64, + BaseAddress: PVOID, + ViewSize: SIZE_T, + AllocationType: ULONG, + PageProtection: ULONG, + PreferredNode: ULONG, + ) -> PVOID --- +} + + +NUMA_NO_PREFERRED_NODE :: 0xffffffff; + +MapViewOfFile2 :: inline proc( + FileMappingHandle: HANDLE, + ProcessHandle: HANDLE, + Offset: ULONG64, + BaseAddress: PVOID, + ViewSize: SIZE_T, + AllocationType: ULONG, + PageProtection: ULONG, +) -> PVOID { + return MapViewOfFileNuma2( + FileMappingHandle, + ProcessHandle, + Offset, + BaseAddress, + ViewSize, + AllocationType, + PageProtection, + NUMA_NO_PREFERRED_NODE, + ); +} + +foreign kernel32 { + UnmapViewOfFile2 :: proc( + ProcessHandle: HANDLE, + BaseAddress: PVOID, + UnmapFlags: ULONG, + ) -> BOOL ---; +} diff --git a/core/sys/windows/types.odin b/core/sys/windows/types.odin index 2aa99d457..5aa1d2602 100644 --- a/core/sys/windows/types.odin +++ b/core/sys/windows/types.odin @@ -33,9 +33,12 @@ SHORT :: c_short; USHORT :: c_ushort; WCHAR :: wchar_t; SIZE_T :: uint; +PSIZE_T :: ^SIZE_T; WORD :: u16; CHAR :: c_char; ULONG_PTR :: uint; +PULONG_PTR :: ^ULONG_PTR; +LPULONG_PTR :: ^ULONG_PTR; DWORD_PTR :: ULONG_PTR; LONG_PTR :: int; ULONG :: c_ulong; @@ -53,6 +56,9 @@ INT32 :: i32; INT64 :: i64; +ULONG64 :: u64; +LONG64 :: i64; + PDWORD_PTR :: ^DWORD_PTR; ATOM :: distinct WORD; @@ -65,9 +71,13 @@ LPBOOL :: ^BOOL; LPCSTR :: cstring; LPCWSTR :: wstring; LPDWORD :: ^DWORD; +PCSTR :: cstring; +PCWSTR :: wstring; +PDWORD :: ^DWORD; LPHANDLE :: ^HANDLE; LPOVERLAPPED :: ^OVERLAPPED; LPPROCESS_INFORMATION :: ^PROCESS_INFORMATION; +PSECURITY_ATTRIBUTES :: ^SECURITY_ATTRIBUTES; LPSECURITY_ATTRIBUTES :: ^SECURITY_ATTRIBUTES; LPSTARTUPINFO :: ^STARTUPINFO; PVOID :: rawptr;