| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. |
| // All files in the project carrying such notice may not be copied, modified, or distributed |
| // except according to those terms. |
| //! ApiSet Contract for api-ms-win-core-memory-l1-1-0 |
| use ctypes::c_void; |
| use shared::basetsd::{PSIZE_T, PULONG_PTR, SIZE_T, ULONG64, ULONG_PTR}; |
| use shared::minwindef::{ |
| BOOL, DWORD, LPCVOID, LPDWORD, LPVOID, PBOOL, PDWORD, PULONG, UINT, ULONG, |
| }; |
| use um::minwinbase::{LPSECURITY_ATTRIBUTES, PSECURITY_ATTRIBUTES}; |
| use um::winnt::{ |
| HANDLE, LPCWSTR, PCWSTR, PMEMORY_BASIC_INFORMATION, PVOID, SECTION_ALL_ACCESS, |
| SECTION_MAP_EXECUTE_EXPLICIT, SECTION_MAP_READ, SECTION_MAP_WRITE, |
| }; |
| pub const FILE_MAP_WRITE: DWORD = SECTION_MAP_WRITE; |
| pub const FILE_MAP_READ: DWORD = SECTION_MAP_READ; |
| pub const FILE_MAP_ALL_ACCESS: DWORD = SECTION_ALL_ACCESS; |
| pub const FILE_MAP_EXECUTE: DWORD = SECTION_MAP_EXECUTE_EXPLICIT; |
| pub const FILE_MAP_COPY: DWORD = 0x00000001; |
| pub const FILE_MAP_RESERVE: DWORD = 0x80000000; |
| pub const FILE_MAP_TARGETS_INVALID: DWORD = 0x40000000; |
| pub const FILE_MAP_LARGE_PAGES: DWORD = 0x20000000; |
| extern "system" { |
| pub fn VirtualAlloc( |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| flAllocationType: DWORD, |
| flProtect: DWORD, |
| ) -> LPVOID; |
| pub fn VirtualProtect( |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| flNewProtect: DWORD, |
| lpflOldProtect: PDWORD, |
| ) -> BOOL; |
| pub fn VirtualFree( |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| dwFreeType: DWORD, |
| ) -> BOOL; |
| pub fn VirtualQuery( |
| lpAddress: LPCVOID, |
| lpBuffer: PMEMORY_BASIC_INFORMATION, |
| dwLength: SIZE_T, |
| ) -> SIZE_T; |
| pub fn VirtualAllocEx( |
| hProcess: HANDLE, |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| flAllocationType: DWORD, |
| flProtect: DWORD, |
| ) -> LPVOID; |
| pub fn VirtualFreeEx( |
| hProcess: HANDLE, |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| dwFreeType: DWORD, |
| ) -> BOOL; |
| pub fn VirtualProtectEx( |
| hProcess: HANDLE, |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| flNewProtect: DWORD, |
| lpflOldProtect: PDWORD, |
| ) -> BOOL; |
| pub fn VirtualQueryEx( |
| hProcess: HANDLE, |
| lpAddress: LPCVOID, |
| lpBuffer: PMEMORY_BASIC_INFORMATION, |
| dwLength: SIZE_T, |
| ) -> SIZE_T; |
| pub fn ReadProcessMemory( |
| hProcess: HANDLE, |
| lpBaseAddress: LPCVOID, |
| lpBuffer: LPVOID, |
| nSize: SIZE_T, |
| lpNumberOfBytesRead: *mut SIZE_T, |
| ) -> BOOL; |
| pub fn WriteProcessMemory( |
| hProcess: HANDLE, |
| lpBaseAddress: LPVOID, |
| lpBuffer: LPCVOID, |
| nSize: SIZE_T, |
| lpNumberOfBytesWritten: *mut SIZE_T, |
| ) -> BOOL; |
| pub fn CreateFileMappingW( |
| hFile: HANDLE, |
| lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, |
| flProtect: DWORD, |
| dwMaximumSizeHigh: DWORD, |
| dwMaximumSizeLow: DWORD, |
| lpName: LPCWSTR, |
| ) -> HANDLE; |
| pub fn OpenFileMappingW( |
| dwDesiredAccess: DWORD, |
| bInheritHandle: BOOL, |
| lpName: LPCWSTR, |
| ) -> HANDLE; |
| pub fn MapViewOfFile( |
| hFileMappingObject: HANDLE, |
| dwDesiredAccess: DWORD, |
| dwFileOffsetHigh: DWORD, |
| dwFileOffsetLow: DWORD, |
| dwNumberOfBytesToMap: SIZE_T, |
| ) -> LPVOID; |
| pub fn MapViewOfFileEx( |
| hFileMappingObject: HANDLE, |
| dwDesiredAccess: DWORD, |
| dwFileOffsetHigh: DWORD, |
| dwFileOffsetLow: DWORD, |
| dwNumberOfBytesToMap: SIZE_T, |
| lpBaseAddress: LPVOID, |
| ) -> LPVOID; |
| pub fn FlushViewOfFile( |
| lpBaseAddress: LPCVOID, |
| dwNumberOfBytesToFlush: SIZE_T, |
| ) -> BOOL; |
| pub fn UnmapViewOfFile( |
| lpBaseAddress: LPCVOID, |
| ) -> BOOL; |
| pub fn GetLargePageMinimum() -> SIZE_T; |
| pub fn GetProcessWorkingSetSizeEx( |
| hProcess: HANDLE, |
| lpMinimumWorkingSetSize: PSIZE_T, |
| lpMaximumWorkingSetSize: PSIZE_T, |
| Flags: PDWORD, |
| ) -> BOOL; |
| pub fn SetProcessWorkingSetSizeEx( |
| hProcess: HANDLE, |
| dwMinimumWorkingSetSize: SIZE_T, |
| dwMaximumWorkingSetSize: SIZE_T, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn VirtualLock( |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| ) -> BOOL; |
| pub fn VirtualUnlock( |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| ) -> BOOL; |
| pub fn GetWriteWatch( |
| dwFlags: DWORD, |
| lpBaseAddress: PVOID, |
| dwRegionSize: SIZE_T, |
| lpAddresses: *mut PVOID, |
| lpdwCount: *mut ULONG_PTR, |
| lpdwGranularity: LPDWORD, |
| ) -> UINT; |
| pub fn ResetWriteWatch( |
| lpBaseAddress: LPVOID, |
| dwRegionSize: SIZE_T, |
| ) -> UINT; |
| } |
| ENUM!{enum MEMORY_RESOURCE_NOTIFICATION_TYPE { |
| LowMemoryResourceNotification, |
| HighMemoryResourceNotification, |
| }} |
| extern "system" { |
| pub fn CreateMemoryResourceNotification( |
| NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE, |
| ) -> HANDLE; |
| pub fn QueryMemoryResourceNotification( |
| ResourceNotificationHandle: HANDLE, |
| ResourceState: PBOOL, |
| ) -> BOOL; |
| } |
| pub const FILE_CACHE_MAX_HARD_ENABLE: DWORD = 0x00000001; |
| pub const FILE_CACHE_MAX_HARD_DISABLE: DWORD = 0x00000002; |
| pub const FILE_CACHE_MIN_HARD_ENABLE: DWORD = 0x00000004; |
| pub const FILE_CACHE_MIN_HARD_DISABLE: DWORD = 0x00000008; |
| extern "system" { |
| pub fn GetSystemFileCacheSize( |
| lpMinimumFileCacheSize: PSIZE_T, |
| lpMaximumFileCacheSize: PSIZE_T, |
| lpFlags: PDWORD, |
| ) -> BOOL; |
| pub fn SetSystemFileCacheSize( |
| MinimumFileCacheSize: SIZE_T, |
| MaximumFileCacheSize: SIZE_T, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn CreateFileMappingNumaW( |
| hFile: HANDLE, |
| lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, |
| flProtect: DWORD, |
| dwMaximumSizeHigh: DWORD, |
| dwMaximumSizeLow: DWORD, |
| lpName: LPCWSTR, |
| nndPreferred: DWORD, |
| ) -> HANDLE; |
| } |
| STRUCT!{struct WIN32_MEMORY_RANGE_ENTRY { |
| VirtualAddress: PVOID, |
| NumberOfBytes: SIZE_T, |
| }} |
| pub type PWIN32_MEMORY_RANGE_ENTRY = *mut WIN32_MEMORY_RANGE_ENTRY; |
| extern "system" { |
| pub fn PrefetchVirtualMemory( |
| hProcess: HANDLE, |
| NumberOfEntries: ULONG_PTR, |
| VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY, |
| Flags: ULONG, |
| ) -> BOOL; |
| pub fn CreateFileMappingFromApp( |
| hFile: HANDLE, |
| SecurityAttributes: PSECURITY_ATTRIBUTES, |
| PageProtection: ULONG, |
| MaximumSize: ULONG64, |
| Name: PCWSTR, |
| ) -> HANDLE; |
| pub fn MapViewOfFileFromApp( |
| hFileMappingObject: HANDLE, |
| DesiredAccess: ULONG, |
| FileOffset: ULONG64, |
| NumberOfBytesToMap: SIZE_T, |
| ) -> PVOID; |
| pub fn UnmapViewOfFileEx( |
| BaseAddress: PVOID, |
| UnmapFlags: ULONG, |
| ) -> BOOL; |
| pub fn AllocateUserPhysicalPages( |
| hProcess: HANDLE, |
| NumberOfPages: PULONG_PTR, |
| PageArray: PULONG_PTR, |
| ) -> BOOL; |
| pub fn FreeUserPhysicalPages( |
| hProcess: HANDLE, |
| NumberOfPages: PULONG_PTR, |
| PageArray: PULONG_PTR, |
| ) -> BOOL; |
| pub fn MapUserPhysicalPages( |
| VirtualAddress: PVOID, |
| NumberOfPages: ULONG_PTR, |
| PageArray: PULONG_PTR, |
| ) -> BOOL; |
| pub fn AllocateUserPhysicalPagesNuma( |
| hProcess: HANDLE, |
| NumberOfPages: PULONG_PTR, |
| PageArray: PULONG_PTR, |
| nndPreferred: DWORD, |
| ) -> BOOL; |
| pub fn VirtualAllocExNuma( |
| hProcess: HANDLE, |
| lpAddress: LPVOID, |
| dwSize: SIZE_T, |
| flAllocationType: DWORD, |
| flProtect: DWORD, |
| nndPreferred: DWORD, |
| ) -> LPVOID; |
| } |
| pub const MEHC_PATROL_SCRUBBER_PRESENT: ULONG = 0x1; |
| extern "system" { |
| pub fn GetMemoryErrorHandlingCapabilities( |
| Capabilities: PULONG, |
| ) -> BOOL; |
| } |
| FN!{stdcall PBAD_MEMORY_CALLBACK_ROUTINE() -> ()} |
| extern "system" { |
| pub fn RegisterBadMemoryNotification( |
| Callback: PBAD_MEMORY_CALLBACK_ROUTINE, |
| ) -> PVOID; |
| pub fn UnregisterBadMemoryNotification( |
| RegistrationHandle: PVOID, |
| ) -> BOOL; |
| } |
| ENUM!{enum OFFER_PRIORITY { |
| VmOfferPriorityVeryLow = 1, |
| VmOfferPriorityLow, |
| VmOfferPriorityBelowNormal, |
| VmOfferPriorityNormal, |
| }} |
| extern "system" { |
| pub fn OfferVirtualMemory( |
| VirtualAddress: PVOID, |
| Size: SIZE_T, |
| Priority: OFFER_PRIORITY, |
| ) -> DWORD; |
| pub fn ReclaimVirtualMemory( |
| VirtualAddress: *const c_void, |
| Size: SIZE_T, |
| ) -> DWORD; |
| pub fn DiscardVirtualMemory( |
| VirtualAddress: PVOID, |
| Size: SIZE_T, |
| ) -> DWORD; |
| // TODO: Needs winnt::PCFG_CALL_TARGET_INFO. |
| /* pub fn SetProcessValidCallTargets( |
| hProcess: HANDLE, |
| VirtualAddress: PVOID, |
| RegionSize: SIZE_T, |
| NumberOfOffsets: ULONG, |
| OffsetInformation: PCFG_CALL_TARGET_INFO, |
| ) -> BOOL; */ |
| pub fn VirtualAllocFromApp( |
| BaseAddress: PVOID, |
| Size: SIZE_T, |
| AllocationType: ULONG, |
| Protection: ULONG, |
| ) -> PVOID; |
| pub fn VirtualProtectFromApp( |
| Address: PVOID, |
| Size: SIZE_T, |
| NewProtection: ULONG, |
| OldProtection: PULONG, |
| ) -> BOOL; |
| pub fn OpenFileMappingFromApp( |
| DesiredAccess: ULONG, |
| InheritHandle: BOOL, |
| Name: PCWSTR, |
| ) -> HANDLE; |
| } |
| // TODO: Under WINAPI_PARTITION_APP, define CreateFileMappingW, MapViewOfFile, VirtualAlloc, |
| // VirtualProtect, and OpenFileMappingW as wrappers around the *FromApp functions. |
| ENUM!{enum WIN32_MEMORY_INFORMATION_CLASS { |
| MemoryRegionInfo, |
| }} |
| STRUCT!{struct WIN32_MEMORY_REGION_INFORMATION { |
| AllocationBase: PVOID, |
| AllocationProtect: ULONG, |
| u: WIN32_MEMORY_REGION_INFORMATION_u, |
| RegionSize: SIZE_T, |
| CommitSize: SIZE_T, |
| }} |
| UNION!{union WIN32_MEMORY_REGION_INFORMATION_u { |
| [u32; 1], |
| Flags Flags_mut: ULONG, |
| s s_mut: WIN32_MEMORY_REGION_INFORMATION_u_s, |
| }} |
| STRUCT!{struct WIN32_MEMORY_REGION_INFORMATION_u_s { |
| Bitfield: ULONG, |
| }} |
| BITFIELD!{WIN32_MEMORY_REGION_INFORMATION_u_s Bitfield: ULONG [ |
| Private set_Private[0..1], |
| MappedDataFile set_MappedDataFile[1..2], |
| MappedImage set_MappedImage[2..3], |
| MappedPageFile set_MappedPageFile[3..4], |
| MappedPhysical set_MappedPhysical[4..5], |
| DirectMapped set_DirectMapped[5..6], |
| Reserved set_Reserved[6..32], |
| ]} |
| // TODO: Need to resolve issue #323 first. |
| /*extern "system" { |
| pub fn QueryVirtualMemoryInformation( |
| Process: HANDLE, |
| VirtualAddress: *const VOID, |
| MemoryInformationClass: WIN32_MEMORY_INFORMATION_CLASS, |
| MemoryInformation: PVOID, |
| MemoryInformationSize: SIZE_T, |
| ReturnSize: PSIZE_T, |
| ) -> BOOL; |
| pub fn MapViewOfFileNuma2( |
| FileMappingHandle: HANDLE, |
| ProcessHandle: HANDLE, |
| Offset: ULONG64, |
| BaseAddress: PVOID, |
| ViewSize: SIZE_T, |
| AllocationType: ULONG, |
| PageProtection: ULONG, |
| PreferredNode: ULONG, |
| ) -> PVOID; |
| } |
| #[inline] |
| pub unsafe fn MapViewOfFile2( |
| FileMappingHandle: HANDLE, |
| ProcessHandle: HANDLE, |
| Offset: ULONG64, |
| BaseAddress: PVOID, |
| ViewSize: SIZE_T, |
| AllocationType: ULONG, |
| PageProtection: ULONG, |
| ) -> PVOID { |
| MapViewOfFileNuma2(FileMappingHandle, |
| ProcessHandle, |
| Offset, |
| BaseAddress, |
| ViewSize, |
| AllocationType, |
| PageProtection, |
| NUMA_NO_PREFERRED_NODE) |
| }*/ |
| extern "system" { |
| pub fn UnmapViewOfFile2( |
| ProcessHandle: HANDLE, |
| BaseAddress: PVOID, |
| UnmapFlags: ULONG, |
| ) -> BOOL; |
| } |