src/um/memoryapi.rs

// Copyright © 2015-2017 winapi-rs developers
// 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;
}