mirror of https://github.com/dahall/Vanara.git
4125 lines
240 KiB
C#
4125 lines
240 KiB
C#
using System;
|
||
using System.Runtime.InteropServices;
|
||
using Vanara.InteropServices;
|
||
|
||
namespace Vanara.PInvoke
|
||
{
|
||
public static partial class Kernel32
|
||
{
|
||
/// <summary>
|
||
/// An application-defined function registered with the RegisterBadMemoryNotification function that is called when one or more bad
|
||
/// memory pages are detected.
|
||
/// </summary>
|
||
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
|
||
public delegate void BadMemoryCallbackRoutine();
|
||
|
||
/// <summary>Flags that indicate which of the file cache limits are enabled.</summary>
|
||
[PInvokeData("MemoryApi.h")]
|
||
[Flags]
|
||
public enum FILE_CACHE_LIMITS : uint
|
||
{
|
||
/// <summary>
|
||
/// Enable the maximum size limit.
|
||
/// <para>The FILE_CACHE_MAX_HARD_DISABLE and FILE_CACHE_MAX_HARD_ENABLE flags are mutually exclusive.</para>
|
||
/// </summary>
|
||
FILE_CACHE_MAX_HARD_ENABLE = 0x00000001,
|
||
|
||
/// <summary>
|
||
/// Disable the maximum size limit.
|
||
/// <para>The FILE_CACHE_MAX_HARD_DISABLE and FILE_CACHE_MAX_HARD_ENABLE flags are mutually exclusive.</para>
|
||
/// </summary>
|
||
FILE_CACHE_MAX_HARD_DISABLE = 0x00000002,
|
||
|
||
/// <summary>
|
||
/// Enable the minimum size limit.
|
||
/// <para>The FILE_CACHE_MIN_HARD_DISABLE and FILE_CACHE_MIN_HARD_ENABLE flags are mutually exclusive.</para>
|
||
/// </summary>
|
||
FILE_CACHE_MIN_HARD_ENABLE = 0x00000004,
|
||
|
||
/// <summary>
|
||
/// Disable the minimum size limit.
|
||
/// <para>The FILE_CACHE_MIN_HARD_DISABLE and FILE_CACHE_MIN_HARD_ENABLE flags are mutually exclusive.</para>
|
||
/// </summary>
|
||
FILE_CACHE_MIN_HARD_DISABLE = 0x00000008,
|
||
}
|
||
|
||
/// <summary>The type of access to a file mapping object, which determines the page protection of the pages.</summary>
|
||
[PInvokeData("MemoryApi.h")]
|
||
[Flags]
|
||
public enum FILE_MAP : uint
|
||
{
|
||
/// <summary>
|
||
/// A read/write view of the file is mapped. The file mapping object must have been created with PAGE_READWRITE or
|
||
/// PAGE_EXECUTE_READWRITE protection.
|
||
/// <para>When used with MapViewOfFileEx, (FILE_MAP_WRITE | FILE_MAP_READ) and FILE_MAP_ALL_ACCESS are equivalent to FILE_MAP_WRITE.</para>
|
||
/// </summary>
|
||
FILE_MAP_WRITE = SECTION_MAP.SECTION_MAP_WRITE,
|
||
|
||
/// <summary>
|
||
/// A read-only view of the file is mapped. An attempt to write to the file view results in an access violation.
|
||
/// <para>
|
||
/// The file mapping object must have been created with PAGE_READONLY, PAGE_READWRITE, PAGE_EXECUTE_READ, or
|
||
/// PAGE_EXECUTE_READWRITE protection.
|
||
/// </para>
|
||
/// </summary>
|
||
FILE_MAP_READ = SECTION_MAP.SECTION_MAP_READ,
|
||
|
||
/// <summary>
|
||
/// A read/write view of the file is mapped. The file mapping object must have been created with PAGE_READWRITE or
|
||
/// PAGE_EXECUTE_READWRITE protection.
|
||
/// <para>When used with the MapViewOfFileEx function, FILE_MAP_ALL_ACCESS is equivalent to FILE_MAP_WRITE.</para>
|
||
/// </summary>
|
||
FILE_MAP_ALL_ACCESS = SECTION_MAP.SECTION_ALL_ACCESS,
|
||
|
||
/// <summary>
|
||
/// An executable view of the file is mapped (mapped memory can be run as code). The file mapping object must have been created
|
||
/// with PAGE_EXECUTE_READ, PAGE_EXECUTE_WRITECOPY, or PAGE_EXECUTE_READWRITE protection.
|
||
/// <para>
|
||
/// Windows Server 2003 and Windows XP: This value is available starting with Windows XP with SP2 and Windows Server 2003 with SP1.
|
||
/// </para>
|
||
/// </summary>
|
||
FILE_MAP_EXECUTE = SECTION_MAP.SECTION_MAP_EXECUTE_EXPLICIT,
|
||
|
||
/// <summary>
|
||
/// A copy-on-write view of the file is mapped. The file mapping object must have been created with PAGE_READONLY,
|
||
/// PAGE_READ_EXECUTE, PAGE_WRITECOPY, PAGE_EXECUTE_WRITECOPY, PAGE_READWRITE, or PAGE_EXECUTE_READWRITE protection.
|
||
/// <para>
|
||
/// When a process writes to a copy-on-write page, the system copies the original page to a new page that is private to the
|
||
/// process.The new page is backed by the paging file.The protection of the new page changes from copy-on-write to read/write.
|
||
/// </para>
|
||
/// <para>
|
||
/// When copy-on-write access is specified, the system and process commit charge taken is for the entire view because the calling
|
||
/// process can potentially write to every page in the view, making all pages private. The contents of the new page are never
|
||
/// written back to the original file and are lost when the view is unmapped.
|
||
/// </para>
|
||
/// </summary>
|
||
FILE_MAP_COPY = 0x00000001,
|
||
|
||
/// <summary></summary>
|
||
FILE_MAP_RESERVE = 0x80000000,
|
||
|
||
/// <summary>
|
||
/// Sets all the locations in the mapped file as invalid targets for CFG. This flag is similar to PAGE_TARGETS_INVALID. It is
|
||
/// used along with the execute access right FILE_MAP_EXECUTE. Any indirect call to locations in those pages will fail CFG checks
|
||
/// and the process will be terminated. The default behavior for executable pages allocated is to be marked valid call targets
|
||
/// for CFG.
|
||
/// </summary>
|
||
FILE_MAP_TARGETS_INVALID = 0x40000000,
|
||
|
||
/// <summary></summary>
|
||
FILE_MAP_LARGE_PAGES = 0x20000000,
|
||
}
|
||
|
||
/// <summary>The type of memory allocation.</summary>
|
||
[PInvokeData("WinNT.h")]
|
||
[Flags]
|
||
public enum MEM_ALLOCATION_TYPE : uint
|
||
{
|
||
/// <summary>
|
||
/// Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved memory
|
||
/// pages. The function also guarantees that when the caller later initially accesses the memory, the contents will be zero.
|
||
/// Actual physical pages are not allocated unless/until the virtual addresses are actually accessed.To reserve and commit pages
|
||
/// in one step, call VirtualAlloc with .Attempting to commit a specific address range by specifying MEM_COMMIT without
|
||
/// MEM_RESERVE and a non-NULL lpAddress fails unless the entire range has already been reserved. The resulting error code is
|
||
/// ERROR_INVALID_ADDRESS.An attempt to commit a page that is already committed does not cause the function to fail. This means
|
||
/// that you can commit pages without first determining the current commitment state of each page.If lpAddress specifies an
|
||
/// address within an enclave, flAllocationType must be MEM_COMMIT.
|
||
/// </summary>
|
||
MEM_COMMIT = 0x00001000,
|
||
|
||
/// <summary>
|
||
/// Reserves a range of the process's virtual address space without allocating any actual physical storage in memory or in the
|
||
/// paging file on disk.You can commit reserved pages in subsequent calls to the VirtualAlloc function. To reserve and commit
|
||
/// pages in one step, call VirtualAlloc with MEM_COMMIT | MEM_RESERVE.Other memory allocation functions, such as malloc and
|
||
/// LocalAlloc, cannot use a reserved range of memory until it is released.
|
||
/// </summary>
|
||
MEM_RESERVE = 0x00002000,
|
||
|
||
/// <summary>
|
||
/// Decommits the specified region of committed pages. After the operation, the pages are in the reserved state. The function
|
||
/// does not fail if you attempt to decommit an uncommitted page. This means that you can decommit a range of pages without first
|
||
/// determining the current commitment state.Do not use this value with MEM_RELEASE.The MEM_DECOMMIT value is not supported when
|
||
/// the lpAddress parameter provides the base address for an enclave.
|
||
/// </summary>
|
||
MEM_DECOMMIT = 0x00004000,
|
||
|
||
/// <summary>
|
||
/// Releases the specified region of pages. After this operation, the pages are in the free state. If you specify this value,
|
||
/// dwSize must be 0 (zero), and lpAddress must point to the base address returned by the VirtualAlloc function when the region
|
||
/// is reserved. The function fails if either of these conditions is not met. If any pages in the region are committed currently,
|
||
/// the function first decommits, and then releases them.The function does not fail if you attempt to release pages that are in
|
||
/// different states, some reserved and some committed. This means that you can release a range of pages without first
|
||
/// determining the current commitment state.Do not use this value with MEM_DECOMMIT.
|
||
/// </summary>
|
||
MEM_RELEASE = 0x00008000,
|
||
|
||
/// <summary>
|
||
/// Indicates free pages not accessible to the calling process and available to be allocated. For free pages, the information in
|
||
/// the AllocationBase, AllocationProtect, Protect, and Type members is undefined.
|
||
/// </summary>
|
||
MEM_FREE = 0x00010000,
|
||
|
||
/// <summary>Indicates that the memory pages within the region are private (that is, not shared by other processes).</summary>
|
||
MEM_PRIVATE = 0x00020000,
|
||
|
||
/// <summary>Indicates that the memory pages within the region are mapped into the view of a section.</summary>
|
||
MEM_MAPPED = 0x00040000,
|
||
|
||
/// <summary>
|
||
/// Indicates that data in the memory range specified by lpAddress and dwSize is no longer of interest. The pages should not be
|
||
/// read from or written to the paging file. However, the memory block will be used again later, so it should not be decommitted.
|
||
/// This value cannot be used with any other value.Using this value does not guarantee that the range operated on with MEM_RESET
|
||
/// will contain zeros. If you want the range to contain zeros, decommit the memory and then recommit it.When you specify
|
||
/// MEM_RESET, the VirtualAlloc function ignores the value of flProtect. However, you must still set flProtect to a valid
|
||
/// protection value, such as PAGE_NOACCESS.VirtualAlloc returns an error if you use MEM_RESET and the range of memory is mapped
|
||
/// to a file. A shared view is only acceptable if it is mapped to a paging file.
|
||
/// </summary>
|
||
MEM_RESET = 0x00080000,
|
||
|
||
/// <summary>
|
||
/// Allocates memory at the highest possible address. This can be slower than regular allocations, especially when there are many allocations.
|
||
/// </summary>
|
||
MEM_TOP_DOWN = 0x00100000,
|
||
|
||
/// <summary>
|
||
/// Causes the system to track pages that are written to in the allocated region. If you specify this value, you must also
|
||
/// specify MEM_RESERVE.To retrieve the addresses of the pages that have been written to since the region was allocated or the
|
||
/// write-tracking state was reset, call the GetWriteWatch function. To reset the write-tracking state, call GetWriteWatch or
|
||
/// ResetWriteWatch. The write-tracking feature remains enabled for the memory region until the region is freed.
|
||
/// </summary>
|
||
MEM_WRITE_WATCH = 0x00200000,
|
||
|
||
/// <summary>
|
||
/// Reserves an address range that can be used to map Address Windowing Extensions (AWE) pages.This value must be used with
|
||
/// MEM_RESERVE and no other values.
|
||
/// </summary>
|
||
MEM_PHYSICAL = 0x00400000,
|
||
|
||
/// <summary></summary>
|
||
MEM_ROTATE = 0x00800000,
|
||
|
||
/// <summary></summary>
|
||
MEM_DIFFERENT_IMAGE_BASE_OK = 0x00800000,
|
||
|
||
/// <summary>
|
||
/// MEM_RESET_UNDO should only be called on an address range to which MEM_RESET was successfully applied earlier. It indicates
|
||
/// that the data in the specified memory range specified by lpAddress and dwSize is of interest to the caller and attempts to
|
||
/// reverse the effects of MEM_RESET. If the function succeeds, that means all data in the specified address range is intact. If
|
||
/// the function fails, at least some of the data in the address range has been replaced with zeroes.This value cannot be used
|
||
/// with any other value. If MEM_RESET_UNDO is called on an address range which was not MEM_RESET earlier, the behavior is
|
||
/// undefined. When you specify MEM_RESET, the VirtualAlloc function ignores the value of flProtect. However, you must still set
|
||
/// flProtect to a valid protection value, such as PAGE_NOACCESS.Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows
|
||
/// Vista, Windows Server 2003 and Windows XP: The MEM_RESET_UNDO flag is not supported until Windows 8 and Windows Server 2012.
|
||
/// </summary>
|
||
MEM_RESET_UNDO = 0x01000000,
|
||
|
||
/// <summary>
|
||
/// Allocates memory using large page support.The size and alignment must be a multiple of the large-page minimum. To obtain this
|
||
/// value, use the GetLargePageMinimum function.If you specify this value, you must also specify MEM_RESERVE and MEM_COMMIT.
|
||
/// </summary>
|
||
MEM_LARGE_PAGES = 0x20000000,
|
||
|
||
/// <summary></summary>
|
||
MEM_4MB_PAGES = 0x80000000,
|
||
|
||
/// <summary></summary>
|
||
MEM_64K_PAGES = MEM_LARGE_PAGES | MEM_PHYSICAL
|
||
}
|
||
|
||
/// <summary>Flags used by <see cref="MEM_EXTENDED_PARAMETER"/> to specify the value type.</summary>
|
||
[PInvokeData("winnt.h", MSDNShortId = "8D189F7E-83E7-4AF3-9E25-928C66666887")]
|
||
public enum MEM_EXTENDED_PARAMETER_TYPE : ulong
|
||
{
|
||
/// <summary/>
|
||
MemExtendedParameterInvalidType,
|
||
|
||
/// <summary>
|
||
/// This extended parameter type is used to specify alignment and virtual address range restrictions for new memory allocations
|
||
/// created by VirtualAlloc2 and MapViewOfFile3.
|
||
/// </summary>
|
||
MemExtendedParameterAddressRequirements,
|
||
|
||
/// <summary>
|
||
/// This extended parameter type is used to specify the preferred NUMA node for new memory allocations created by VirtualAlloc2
|
||
/// and MapViewOfFile3.
|
||
/// </summary>
|
||
MemExtendedParameterNumaNode,
|
||
|
||
/// <summary/>
|
||
MemExtendedParameterPartitionHandle,
|
||
|
||
/// <summary/>
|
||
MemExtendedParameterUserPhysicalHandle,
|
||
|
||
/// <summary/>
|
||
MemExtendedParameterAttributeFlags,
|
||
|
||
/// <summary/>
|
||
MemExtendedParameterMax
|
||
}
|
||
|
||
/// <summary>
|
||
/// The following are the memory-protection options; you must specify one of the following values when allocating or protecting a
|
||
/// page in memory. Protection attributes cannot be assigned to a portion of a page; they can only be assigned to a whole page.
|
||
/// </summary>
|
||
[PInvokeData("WinNT.h")]
|
||
[Flags]
|
||
public enum MEM_PROTECTION : uint
|
||
{
|
||
/// <summary>
|
||
/// Disables all access to the committed region of pages. An attempt to read from, write to, or execute the committed region
|
||
/// results in an access violation.
|
||
/// <para>This flag is not supported by the CreateFileMapping function.</para>
|
||
/// </summary>
|
||
PAGE_NOACCESS = 0x01,
|
||
|
||
/// <summary>
|
||
/// Enables read-only access to the committed region of pages. An attempt to write to the committed region results in an access
|
||
/// violation. If Data Execution Prevention is enabled, an attempt to execute code in the committed region results in an access violation.
|
||
/// </summary>
|
||
PAGE_READONLY = 0x02,
|
||
|
||
/// <summary>
|
||
/// Enables read-only or read/write access to the committed region of pages. If Data Execution Prevention is enabled, attempting
|
||
/// to execute code in the committed region results in an access violation.
|
||
/// </summary>
|
||
PAGE_READWRITE = 0x04,
|
||
|
||
/// <summary>
|
||
/// Enables read-only or copy-on-write access to a mapped view of a file mapping object. An attempt to write to a committed
|
||
/// copy-on-write page results in a private copy of the page being made for the process. The private page is marked as
|
||
/// PAGE_READWRITE, and the change is written to the new page. If Data Execution Prevention is enabled, attempting to execute
|
||
/// code in the committed region results in an access violation.
|
||
/// <para>This flag is not supported by the VirtualAlloc or VirtualAllocEx functions.</para>
|
||
/// </summary>
|
||
PAGE_WRITECOPY = 0x08,
|
||
|
||
/// <summary>
|
||
/// Enables execute access to the committed region of pages. An attempt to write to the committed region results in an access violation.
|
||
/// <para>This flag is not supported by the CreateFileMapping function.</para>
|
||
/// </summary>
|
||
PAGE_EXECUTE = 0x10,
|
||
|
||
/// <summary>
|
||
/// Enables execute or read-only access to the committed region of pages. An attempt to write to the committed region results in
|
||
/// an access violation.
|
||
/// <para>
|
||
/// Windows Server 2003 and Windows XP: This attribute is not supported by the CreateFileMapping function until Windows XP with
|
||
/// SP2 and Windows Server 2003 with SP1.
|
||
/// </para>
|
||
/// </summary>
|
||
PAGE_EXECUTE_READ = 0x20,
|
||
|
||
/// <summary>
|
||
/// Enables execute, read-only, or read/write access to the committed region of pages.
|
||
/// <para>
|
||
/// Windows Server 2003 and Windows XP: This attribute is not supported by the CreateFileMapping function until Windows XP with
|
||
/// SP2 and Windows Server 2003 with SP1.
|
||
/// </para>
|
||
/// </summary>
|
||
PAGE_EXECUTE_READWRITE = 0x40,
|
||
|
||
/// <summary>
|
||
/// Enables execute, read-only, or copy-on-write access to a mapped view of a file mapping object. An attempt to write to a
|
||
/// committed copy-on-write page results in a private copy of the page being made for the process. The private page is marked as
|
||
/// PAGE_EXECUTE_READWRITE, and the change is written to the new page.
|
||
/// <para>This flag is not supported by the VirtualAlloc or VirtualAllocEx functions.</para>
|
||
/// <para>
|
||
/// Windows Vista, Windows Server 2003 and Windows XP: This attribute is not supported by the CreateFileMapping function until
|
||
/// Windows Vista with SP1 and Windows Server 2008.
|
||
/// </para>
|
||
/// </summary>
|
||
PAGE_EXECUTE_WRITECOPY = 0x80,
|
||
|
||
/// <summary>
|
||
/// Pages in the region become guard pages. Any attempt to access a guard page causes the system to raise a
|
||
/// STATUS_GUARD_PAGE_VIOLATION exception and turn off the guard page status. Guard pages thus act as a one-time access alarm.
|
||
/// For more information, see Creating Guard Pages.
|
||
/// <para>When an access attempt leads the system to turn off guard page status, the underlying page protection takes over.</para>
|
||
/// <para>If a guard page exception occurs during a system service, the service typically returns a failure status indicator.</para>
|
||
/// <para>This value cannot be used with PAGE_NOACCESS.</para>
|
||
/// <para>This flag is not supported by the CreateFileMapping function.</para>
|
||
/// </summary>
|
||
PAGE_GUARD = 0x100,
|
||
|
||
/// <summary>
|
||
/// Sets all pages to be non-cachable. Applications should not use this attribute except when explicitly required for a device.
|
||
/// Using the interlocked functions with memory that is mapped with SEC_NOCACHE can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception.
|
||
/// <para>The PAGE_NOCACHE flag cannot be used with the PAGE_GUARD, PAGE_NOACCESS, or PAGE_WRITECOMBINE flags.</para>
|
||
/// <para>
|
||
/// The PAGE_NOCACHE flag can be used only when allocating private memory with the VirtualAlloc, VirtualAllocEx, or
|
||
/// VirtualAllocExNuma functions. To enable non-cached memory access for shared memory, specify the SEC_NOCACHE flag when calling
|
||
/// the CreateFileMapping function.
|
||
/// </para>
|
||
/// </summary>
|
||
PAGE_NOCACHE = 0x200,
|
||
|
||
/// <summary>
|
||
/// Sets all pages to be write-combined.
|
||
/// <para>
|
||
/// Applications should not use this attribute except when explicitly required for a device. Using the interlocked functions with
|
||
/// memory that is mapped as write-combined can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception.
|
||
/// </para>
|
||
/// <para>The PAGE_WRITECOMBINE flag cannot be specified with the PAGE_NOACCESS, PAGE_GUARD, and PAGE_NOCACHE flags.</para>
|
||
/// <para>
|
||
/// The PAGE_WRITECOMBINE flag can be used only when allocating private memory with the VirtualAlloc, VirtualAllocEx, or
|
||
/// VirtualAllocExNuma functions. To enable write-combined memory access for shared memory, specify the SEC_WRITECOMBINE flag
|
||
/// when calling the CreateFileMapping function.
|
||
/// </para>
|
||
/// <para>Windows Server 2003 and Windows XP: This flag is not supported until Windows Server 2003 with SP1.</para>
|
||
/// </summary>
|
||
PAGE_WRITECOMBINE = 0x400,
|
||
|
||
/// <summary>
|
||
/// The page contents that you supply are excluded from measurement with the EEXTEND instruction of the Intel SGX programming model.
|
||
/// </summary>
|
||
PAGE_ENCLAVE_UNVALIDATED = 0x20000000,
|
||
|
||
/// <summary>
|
||
/// Sets all locations in the pages as invalid targets for CFG. Used along with any execute page protection like PAGE_EXECUTE,
|
||
/// PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE and PAGE_EXECUTE_WRITECOPY. Any indirect call to locations in those pages will fail
|
||
/// CFG checks and the process will be terminated. The default behavior for executable pages allocated is to be marked valid call
|
||
/// targets for CFG.
|
||
/// <para>This flag is not supported by the VirtualProtect or CreateFileMapping functions.</para>
|
||
/// </summary>
|
||
PAGE_TARGETS_INVALID = 0x40000000,
|
||
|
||
/// <summary>
|
||
/// Pages in the region will not have their CFG information updated while the protection changes for VirtualProtect. For example,
|
||
/// if the pages in the region was allocated using PAGE_TARGETS_INVALID, then the invalid information will be maintained while
|
||
/// the page protection changes. This flag is only valid when the protection changes to an executable type like PAGE_EXECUTE,
|
||
/// PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE and PAGE_EXECUTE_WRITECOPY. The default behavior for VirtualProtect protection
|
||
/// change to executable is to mark all locations as valid call targets for CFG.
|
||
/// <para>
|
||
/// The following are modifiers that can be used in addition to the options provided in the previous table, except as noted.
|
||
/// </para>
|
||
/// </summary>
|
||
PAGE_TARGETS_NO_UPDATE = 0x40000000,
|
||
|
||
/// <summary>The page contains a thread control structure (TCS).</summary>
|
||
PAGE_ENCLAVE_THREAD_CONTROL = 0x80000000,
|
||
|
||
/// <summary></summary>
|
||
PAGE_REVERT_TO_FILE_MAP = 0x80000000,
|
||
}
|
||
|
||
/// <summary>The memory condition under which the object is to be signaled.</summary>
|
||
[PInvokeData("MemoryApi.h")]
|
||
public enum MEMORY_RESOURCE_NOTIFICATION_TYPE
|
||
{
|
||
/// <summary>Available physical memory is running low.</summary>
|
||
LowMemoryResourceNotification,
|
||
|
||
/// <summary>Available physical memory is high.</summary>
|
||
HighMemoryResourceNotification,
|
||
}
|
||
|
||
/// <summary>
|
||
/// Indicates how important the offered memory is to the application. A higher priority increases the probability that the offered
|
||
/// memory can be reclaimed intact when calling ReclaimVirtualMemory.
|
||
/// </summary>
|
||
public enum OFFER_PRIORITY
|
||
{
|
||
/// <summary>The offered memory is very low priority, and should be the first discarded.</summary>
|
||
VmOfferPriorityVeryLow = 1,
|
||
|
||
/// <summary>The offered memory is low priority.</summary>
|
||
VmOfferPriorityLow,
|
||
|
||
/// <summary>The offered memory is below normal priority.</summary>
|
||
VmOfferPriorityBelowNormal,
|
||
|
||
/// <summary>The offered memory is of normal priority to the application, and should be the last discarded.</summary>
|
||
VmOfferPriorityNormal
|
||
}
|
||
|
||
/// <summary>Flags that determines the allocation attributes of the section, file, page, etc.</summary>
|
||
[PInvokeData("winbase.h", MSDNShortId = "d3302183-76a0-47ec-874f-1173db353dfe")]
|
||
public enum SEC_ALLOC : uint
|
||
{
|
||
/// <summary>
|
||
/// If the file mapping object is backed by the operating system paging file (the hfile parameter is INVALID_HANDLE_VALUE),
|
||
/// specifies that when a view of the file is mapped into a process address space, the entire range of pages is committed rather
|
||
/// than reserved. The system must have enough committable pages to hold the entire mapping. Otherwise, CreateFileMapping
|
||
/// fails.This attribute has no effect for file mapping objects that are backed by executable image files or data files (the
|
||
/// hfile parameter is a handle to a file).SEC_COMMIT cannot be combined with SEC_RESERVE.If no attribute is specified,
|
||
/// SEC_COMMIT is assumed.
|
||
/// </summary>
|
||
SEC_COMMIT = 0x8000000,
|
||
|
||
/// <summary>
|
||
/// Specifies that the file that the hFile parameter specifies is an executable image file.The SEC_IMAGE attribute must be
|
||
/// combined with a page protection value such as PAGE_READONLY. However, this page protection value has no effect on views of
|
||
/// the executable image file. Page protection for views of an executable image file is determined by the executable file
|
||
/// itself.No other attributes are valid with SEC_IMAGE.
|
||
/// </summary>
|
||
SEC_IMAGE = 0x1000000,
|
||
|
||
/// <summary>
|
||
/// Specifies that the file that the hFile parameter specifies is an executable image file that will not be executed and the
|
||
/// loaded image file will have no forced integrity checks run. Additionally, mapping a view of a file mapping object created
|
||
/// with the SEC_IMAGE_NO_EXECUTE attribute will not invoke driver callbacks registered using the PsSetLoadImageNotifyRoutine
|
||
/// kernel API.The SEC_IMAGE_NO_EXECUTE attribute must be combined with the PAGE_READONLY page protection value. No other
|
||
/// attributes are valid with SEC_IMAGE_NO_EXECUTE.Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows
|
||
/// Server 2003 and Windows XP: This value is not supported before Windows Server 2012 and Windows 8.
|
||
/// </summary>
|
||
SEC_IMAGE_NO_EXECUTE = 0x11000000,
|
||
|
||
/// <summary>
|
||
/// Enables large pages to be used for file mapping objects that are backed by the operating system paging file (the hfile
|
||
/// parameter is INVALID_HANDLE_VALUE). This attribute is not supported for file mapping objects that are backed by executable
|
||
/// image files or data files (the hFile parameter is a handle to an executable image or data file).The maximum size of the file
|
||
/// mapping object must be a multiple of the minimum size of a large page returned by the GetLargePageMinimum function. If it is
|
||
/// not, CreateFileMapping fails. When mapping a view of a file mapping object created with SEC_LARGE_PAGES, the base address and
|
||
/// view size must also be multiples of the minimum large page size.SEC_LARGE_PAGES requires the SeLockMemoryPrivilege privilege
|
||
/// to be enabled in the caller's token.If SEC_LARGE_PAGES is specified, SEC_COMMIT must also be specified.Windows Server 2003:
|
||
/// This value is not supported until Windows Server 2003 with SP1.Windows XP: This value is not supported.
|
||
/// </summary>
|
||
SEC_LARGE_PAGES = 0x80000000,
|
||
|
||
/// <summary>
|
||
/// Sets all pages to be non-cachable.Applications should not use this attribute except when explicitly required for a device.
|
||
/// Using the interlocked functions with memory that is mapped with SEC_NOCACHE can result in an EXCEPTION_ILLEGAL_INSTRUCTION
|
||
/// exception.SEC_NOCACHE requires either the SEC_RESERVE or SEC_COMMIT attribute to be set.
|
||
/// </summary>
|
||
SEC_NOCACHE = 0x10000000,
|
||
|
||
/// <summary>
|
||
/// If the file mapping object is backed by the operating system paging file (the hfile parameter is INVALID_HANDLE_VALUE),
|
||
/// specifies that when a view of the file is mapped into a process address space, the entire range of pages is reserved for
|
||
/// later use by the process rather than committed.Reserved pages can be committed in subsequent calls to the VirtualAlloc
|
||
/// function. After the pages are committed, they cannot be freed or decommitted with the VirtualFree function.This attribute has
|
||
/// no effect for file mapping objects that are backed by executable image files or data files (the hfile parameter is a handle
|
||
/// to a file).SEC_RESERVE cannot be combined with SEC_COMMIT.
|
||
/// </summary>
|
||
SEC_RESERVE = 0x4000000,
|
||
|
||
/// <summary>
|
||
/// Sets all pages to be write-combined.Applications should not use this attribute except when explicitly required for a device.
|
||
/// Using the interlocked functions with memory that is mapped with SEC_WRITECOMBINE can result in an
|
||
/// EXCEPTION_ILLEGAL_INSTRUCTION exception.SEC_WRITECOMBINE requires either the SEC_RESERVE or SEC_COMMIT attribute to be
|
||
/// set.Windows Server 2003 and Windows XP: This flag is not supported until Windows Vista.
|
||
/// </summary>
|
||
SEC_WRITECOMBINE = 0x40000000,
|
||
}
|
||
|
||
/// <summary>Used by <see cref="QueryVirtualMemoryInformation"/>.</summary>
|
||
public enum WIN32_MEMORY_INFORMATION_CLASS
|
||
{
|
||
/// <summary>This parameter must point to a <c>WIN32_MEMORY_REGION_INFORMATION</c> structure.</summary>
|
||
MemoryRegionInfo
|
||
}
|
||
|
||
/// <summary>Flags used in <see cref="GetWriteWatch"/>.</summary>
|
||
public enum WRITE_WATCH
|
||
{
|
||
/// <summary>Do not reset the write-tracking state.</summary>
|
||
WRITE_WATCH_UNSPECIFIED = 0,
|
||
|
||
/// <summary>Reset the write-tracking state.</summary>
|
||
WRITE_WATCH_FLAG_RESET = 1
|
||
}
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Allocates physical memory pages to be mapped and unmapped within any Address Windowing Extensions (AWE) region of a specified process.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>64-bit Windows on Itanium-based systems:</c> Due to the difference in page sizes, <c>AllocateUserPhysicalPages</c> is not
|
||
/// supported for 32-bit applications.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// <para>A handle to a process.</para>
|
||
/// <para>
|
||
/// The function allocates memory that can later be mapped within the virtual address space of this process. The handle must have the
|
||
/// <c>PROCESS_VM_OPERATION</c> access right. For more information, see Process Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="NumberOfPages">
|
||
/// <para>The size of the physical memory to allocate, in pages.</para>
|
||
/// <para>
|
||
/// To determine the page size of the computer, use the <c>GetSystemInfo</c> function. On output, this parameter receives the number
|
||
/// of pages that are actually allocated, which might be less than the number requested.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="UserPfnArray">
|
||
/// <para>A pointer to an array to store the page frame numbers of the allocated memory.</para>
|
||
/// <para>
|
||
/// The size of the array that is allocated should be at least the NumberOfPages times the size of the <c>ULONG_PTR</c> data type.
|
||
/// </para>
|
||
/// <para>
|
||
/// Do not attempt to modify this buffer. It contains operating system data, and corruption could be catastrophic. The information in
|
||
/// the buffer is not useful to an application.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is <c>TRUE</c>.</para>
|
||
/// <para>
|
||
/// Fewer pages than requested can be allocated. The caller must check the value of the NumberOfPages parameter on return to see how
|
||
/// many pages are allocated. All allocated page frame numbers are sequentially placed in the memory pointed to by the UserPfnArray parameter.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the function fails, the return value is <c>FALSE</c>, and no frames are allocated. To get extended error information, call <c>GetLastError</c>.
|
||
/// </para>
|
||
/// </returns>
|
||
// BOOL WINAPI AllocateUserPhysicalPages( _In_ HANDLE hProcess, _Inout_ PULONG_PTR NumberOfPages, _Out_ PULONG_PTR UserPfnArray);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366528")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool AllocateUserPhysicalPages([In] HPROCESS hProcess, ref SizeT NumberOfPages, [Out] IntPtr[] UserPfnArray);
|
||
|
||
/// <summary>
|
||
/// Allocates physical memory pages to be mapped and unmapped within any Address Windowing Extensions (AWE) region of a specified
|
||
/// process and specifies the NUMA node for the physical memory.
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// <para>A handle to a process.</para>
|
||
/// <para>
|
||
/// The function allocates memory that can later be mapped within the virtual address space of this process. The handle must have the
|
||
/// <c>PROCESS_VM_OPERATION</c> access right. For more information, see Process Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="NumberOfPages">
|
||
/// <para>The size of the physical memory to allocate, in pages.</para>
|
||
/// <para>
|
||
/// To determine the page size of the computer, use the <c>GetSystemInfo</c> function. On output, this parameter receives the number
|
||
/// of pages that are actually allocated, which might be less than the number requested.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="PageArray">
|
||
/// <para>A pointer to an array to store the page frame numbers of the allocated memory.</para>
|
||
/// <para>
|
||
/// The size of the array that is allocated should be at least the NumberOfPages times the size of the <c>ULONG_PTR</c> data type.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="nndPreferred">The NUMA node where the physical memory should reside.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is <c>TRUE</c>.</para>
|
||
/// <para>
|
||
/// Fewer pages than requested can be allocated. The caller must check the value of the NumberOfPages parameter on return to see how
|
||
/// many pages are allocated. All allocated page frame numbers are sequentially placed in the memory pointed to by the PageArray parameter.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the function fails, the return value is <c>FALSE</c> and no frames are allocated. To get extended error information, call the
|
||
/// <c>GetLastError</c> function.
|
||
/// </para>
|
||
/// </returns>
|
||
// BOOL WINAPI AllocateUserPhysicalPagesNuma( _In_ HANDLE hProcess, _Inout_ PULONG_PTR NumberOfPages, _Out_ PULONG_PTR PageArray,
|
||
// _In_ DWORD nndPreferred);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366529")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool AllocateUserPhysicalPagesNuma([In] HPROCESS hProcess, ref SizeT NumberOfPages, [Out] IntPtr[] PageArray, uint nndPreferred);
|
||
|
||
/// <summary>
|
||
/// <para>Creates or opens a named or unnamed file mapping object for a specified file.</para>
|
||
/// <para>To specify the NUMA node for the physical memory, see <c>CreateFileMappingNuma</c>.</para>
|
||
/// </summary>
|
||
/// <param name="hFile">
|
||
/// <para>A handle to the file from which to create a file mapping object.</para>
|
||
/// <para>
|
||
/// The file must be opened with access rights that are compatible with the protection flags that the flProtect parameter specifies.
|
||
/// It is not required, but it is recommended that files you intend to map be opened for exclusive access. For more information, see
|
||
/// File Security and Access Rights.
|
||
/// </para>
|
||
/// <para>
|
||
/// If hFile is <c>INVALID_HANDLE_VALUE</c>, the calling process must also specify a size for the file mapping object in the
|
||
/// dwMaximumSizeHigh and dwMaximumSizeLow parameters. In this scenario, <c>CreateFileMapping</c> creates a file mapping object of a
|
||
/// specified size that is backed by the system paging file instead of by a file in the file system.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpAttributes">
|
||
/// <para>
|
||
/// A pointer to a <c>SECURITY_ATTRIBUTES</c> structure that determines whether a returned handle can be inherited by child
|
||
/// processes. The <c>lpSecurityDescriptor</c> member of the <c>SECURITY_ATTRIBUTES</c> structure specifies a security descriptor for
|
||
/// a new file mapping object.
|
||
/// </para>
|
||
/// <para>
|
||
/// If lpAttributes is <c>NULL</c>, the handle cannot be inherited and the file mapping object gets a default security descriptor.
|
||
/// The access control lists (ACL) in the default security descriptor for a file mapping object come from the primary or
|
||
/// impersonation token of the creator. For more information, see File Mapping Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="flProtect">
|
||
/// <para>
|
||
/// Specifies the page protection of the file mapping object. All mapped views of the object must be compatible with this protection.
|
||
/// </para>
|
||
/// <para>This parameter can be one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>PAGE_EXECUTE_READ0x20</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, or execute access.The file handle specified by the hFile parameter must
|
||
/// be created with the GENERIC_READ and GENERIC_EXECUTE access rights.Windows Server 2003 and Windows XP: This value is not
|
||
/// available until Windows XP with SP2 and Windows Server 2003 with SP1.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_EXECUTE_READWRITE0x40</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, read/write, or execute access.The file handle that the hFile parameter
|
||
/// specifies must be created with the GENERIC_READ, GENERIC_WRITE, and GENERIC_EXECUTE access rights.Windows Server 2003 and Windows
|
||
/// XP: This value is not available until Windows XP with SP2 and Windows Server 2003 with SP1.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_EXECUTE_WRITECOPY0x80</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, or execute access. This value is equivalent to PAGE_EXECUTE_READ.The file
|
||
/// handle that the hFile parameter specifies must be created with the GENERIC_READ and GENERIC_EXECUTE access rights.Windows Vista:
|
||
/// This value is not available until Windows Vista with SP1.Windows Server 2003 and Windows XP: This value is not supported.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_READONLY0x02</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only or copy-on-write access. An attempt to write to a specific region results in an access
|
||
/// violation.The file handle that the hFile parameter specifies must be created with the GENERIC_READ access right.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_READWRITE0x04</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, or read/write access.The file handle that the hFile parameter specifies
|
||
/// must be created with the GENERIC_READ and GENERIC_WRITE access rights.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_WRITECOPY0x08</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only or copy-on-write access. This value is equivalent to PAGE_READONLY.The file handle that
|
||
/// the hFile parameter specifies must be created with the GENERIC_READ access right.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>
|
||
/// An application can specify one or more of the following attributes for the file mapping object by combining them with one of the
|
||
/// preceding page protection values.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>SEC_COMMIT0x8000000</term>
|
||
/// <term>
|
||
/// If the file mapping object is backed by the operating system paging file (the hfile parameter is INVALID_HANDLE_VALUE), specifies
|
||
/// that when a view of the file is mapped into a process address space, the entire range of pages is committed rather than reserved.
|
||
/// The system must have enough committable pages to hold the entire mapping. Otherwise, CreateFileMapping fails.This attribute has
|
||
/// no effect for file mapping objects that are backed by executable image files or data files (the hfile parameter is a handle to a
|
||
/// file).SEC_COMMIT cannot be combined with SEC_RESERVE.If no attribute is specified, SEC_COMMIT is assumed.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_IMAGE0x1000000</term>
|
||
/// <term>
|
||
/// Specifies that the file that the hFile parameter specifies is an executable image file.The SEC_IMAGE attribute must be combined
|
||
/// with a page protection value such as PAGE_READONLY. However, this page protection value has no effect on views of the executable
|
||
/// image file. Page protection for views of an executable image file is determined by the executable file itself.No other attributes
|
||
/// are valid with SEC_IMAGE.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_IMAGE_NO_EXECUTE0x11000000</term>
|
||
/// <term>
|
||
/// Specifies that the file that the hFile parameter specifies is an executable image file that will not be executed and the loaded
|
||
/// image file will have no forced integrity checks run. Additionally, mapping a view of a file mapping object created with the
|
||
/// SEC_IMAGE_NO_EXECUTE attribute will not invoke driver callbacks registered using the PsSetLoadImageNotifyRoutine kernel API.The
|
||
/// SEC_IMAGE_NO_EXECUTE attribute must be combined with the PAGE_READONLY page protection value. No other attributes are valid with
|
||
/// SEC_IMAGE_NO_EXECUTE.Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:
|
||
/// This value is not supported before Windows Server 2012 and Windows 8.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_LARGE_PAGES0x80000000</term>
|
||
/// <term>
|
||
/// Enables large pages to be used for file mapping objects that are backed by the operating system paging file (the hfile parameter
|
||
/// is INVALID_HANDLE_VALUE). This attribute is not supported for file mapping objects that are backed by executable image files or
|
||
/// data files (the hFile parameter is a handle to an executable image or data file).The maximum size of the file mapping object must
|
||
/// be a multiple of the minimum size of a large page returned by the GetLargePageMinimum function. If it is not, CreateFileMapping
|
||
/// fails. When mapping a view of a file mapping object created with SEC_LARGE_PAGES, the base address and view size must also be
|
||
/// multiples of the minimum large page size.SEC_LARGE_PAGES requires the SeLockMemoryPrivilege privilege to be enabled in the
|
||
/// caller's token.If SEC_LARGE_PAGES is specified, SEC_COMMIT must also be specified.Windows Server 2003: This value is not
|
||
/// supported until Windows Server 2003 with SP1.Windows XP: This value is not supported.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_NOCACHE0x10000000</term>
|
||
/// <term>
|
||
/// Sets all pages to be non-cachable.Applications should not use this attribute except when explicitly required for a device. Using
|
||
/// the interlocked functions with memory that is mapped with SEC_NOCACHE can result in an EXCEPTION_ILLEGAL_INSTRUCTION
|
||
/// exception.SEC_NOCACHE requires either the SEC_RESERVE or SEC_COMMIT attribute to be set.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_RESERVE0x4000000</term>
|
||
/// <term>
|
||
/// If the file mapping object is backed by the operating system paging file (the hfile parameter is INVALID_HANDLE_VALUE), specifies
|
||
/// that when a view of the file is mapped into a process address space, the entire range of pages is reserved for later use by the
|
||
/// process rather than committed.Reserved pages can be committed in subsequent calls to the VirtualAlloc function. After the pages
|
||
/// are committed, they cannot be freed or decommitted with the VirtualFree function.This attribute has no effect for file mapping
|
||
/// objects that are backed by executable image files or data files (the hfile parameter is a handle to a file).SEC_RESERVE cannot be
|
||
/// combined with SEC_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_WRITECOMBINE0x40000000</term>
|
||
/// <term>
|
||
/// Sets all pages to be write-combined.Applications should not use this attribute except when explicitly required for a device.
|
||
/// Using the interlocked functions with memory that is mapped with SEC_WRITECOMBINE can result in an EXCEPTION_ILLEGAL_INSTRUCTION
|
||
/// exception.SEC_WRITECOMBINE requires either the SEC_RESERVE or SEC_COMMIT attribute to be set.Windows Server 2003 and Windows XP:
|
||
/// This flag is not supported until Windows Vista.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwMaximumSizeHigh">The high-order <c>DWORD</c> of the maximum size of the file mapping object.</param>
|
||
/// <param name="dwMaximumSizeLow">
|
||
/// <para>The low-order <c>DWORD</c> of the maximum size of the file mapping object.</para>
|
||
/// <para>
|
||
/// If this parameter and dwMaximumSizeHigh are 0 (zero), the maximum size of the file mapping object is equal to the current size of
|
||
/// the file that hFile identifies.
|
||
/// </para>
|
||
/// <para>
|
||
/// An attempt to map a file with a length of 0 (zero) fails with an error code of <c>ERROR_FILE_INVALID</c>. Applications should
|
||
/// test for files with a length of 0 (zero) and reject those files.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpName">
|
||
/// <para>The name of the file mapping object.</para>
|
||
/// <para>
|
||
/// If this parameter matches the name of an existing mapping object, the function requests access to the object with the protection
|
||
/// that flProtect specifies.
|
||
/// </para>
|
||
/// <para>If this parameter is <c>NULL</c>, the file mapping object is created without a name.</para>
|
||
/// <para>
|
||
/// If lpName matches the name of an existing event, semaphore, mutex, waitable timer, or job object, the function fails, and the
|
||
/// <c>GetLastError</c> function returns <c>ERROR_INVALID_HANDLE</c>. This occurs because these objects share the same namespace.
|
||
/// </para>
|
||
/// <para>
|
||
/// The name can have a "Global\" or "Local\" prefix to explicitly create the object in the global or session namespace. The
|
||
/// remainder of the name can contain any character except the backslash character (\). Creating a file mapping object in the global
|
||
/// namespace from a session other than session zero requires the SeCreateGlobalPrivilege privilege. For more information, see Kernel
|
||
/// Object Namespaces.
|
||
/// </para>
|
||
/// <para>
|
||
/// Fast user switching is implemented by using Terminal Services sessions. The first user to log on uses session 0 (zero), the next
|
||
/// user to log on uses session 1 (one), and so on. Kernel object names must follow the guidelines that are outlined for Terminal
|
||
/// Services so that applications can support multiple users.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a handle to the newly created file mapping object.</para>
|
||
/// <para>
|
||
/// If the object exists before the function call, the function returns a handle to the existing object (with its current size, not
|
||
/// the specified size), and <c>GetLastError</c> returns <c>ERROR_ALREADY_EXISTS</c>.
|
||
/// </para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// HANDLE WINAPI CreateFileMapping( _In_ HANDLE hFile, _In_opt_ LPSECURITY_ATTRIBUTES lpAttributes, _In_ DWORD flProtect, _In_ DWORD
|
||
// dwMaximumSizeHigh, _In_ DWORD dwMaximumSizeLow, _In_opt_ LPCTSTR lpName);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366537")]
|
||
public static extern SafeHSECTION CreateFileMapping([In] HFILE hFile, [In] SECURITY_ATTRIBUTES lpAttributes, MEM_PROTECTION flProtect,
|
||
uint dwMaximumSizeHigh, uint dwMaximumSizeLow, string lpName);
|
||
|
||
/// <summary>Creates or opens a named or unnamed file mapping object for a specified file from a Windows Store app.</summary>
|
||
/// <param name="hFile">
|
||
/// <para>A handle to the file from which to create a file mapping object.</para>
|
||
/// <para>
|
||
/// The file must be opened with access rights that are compatible with the protection flags that the flProtect parameter specifies.
|
||
/// It is not required, but it is recommended that files you intend to map be opened for exclusive access. For more information, see
|
||
/// File Security and Access Rights.
|
||
/// </para>
|
||
/// <para>
|
||
/// If hFile is <c>INVALID_HANDLE_VALUE</c>, the calling process must also specify a size for the file mapping object in the
|
||
/// dwMaximumSizeHigh and dwMaximumSizeLow parameters. In this scenario, <c>CreateFileMappingFromApp</c> creates a file mapping
|
||
/// object of a specified size that is backed by the system paging file instead of by a file in the file system.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="SecurityAttributes">
|
||
/// <para>
|
||
/// A pointer to a <c>SECURITY_ATTRIBUTES</c> structure that determines whether a returned handle can be inherited by child
|
||
/// processes. The <c>lpSecurityDescriptor</c> member of the <c>SECURITY_ATTRIBUTES</c> structure specifies a security descriptor for
|
||
/// a new file mapping object.
|
||
/// </para>
|
||
/// <para>
|
||
/// If SecurityAttributes is <c>NULL</c>, the handle cannot be inherited and the file mapping object gets a default security
|
||
/// descriptor. The access control lists (ACL) in the default security descriptor for a file mapping object come from the primary or
|
||
/// impersonation token of the creator. For more information, see File Mapping Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="PageProtection">
|
||
/// <para>
|
||
/// Specifies the page protection of the file mapping object. All mapped views of the object must be compatible with this protection.
|
||
/// </para>
|
||
/// <para>This parameter can be one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>PAGE_READONLY0x02</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only or copy-on-write access. An attempt to write to a specific region results in an access
|
||
/// violation.The file handle that the hFile parameter specifies must be created with the GENERIC_READ access right.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_READWRITE0x04</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, or read/write access.The file handle that the hFile parameter specifies
|
||
/// must be created with the GENERIC_READ and GENERIC_WRITE access rights.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_WRITECOPY0x08</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only or copy-on-write access. This value is equivalent to PAGE_READONLY.The file handle that
|
||
/// the hFile parameter specifies must be created with the GENERIC_READ access right.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>
|
||
/// An application can specify one or more of the following attributes for the file mapping object by combining them with one of the
|
||
/// preceding page protection values.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>SEC_COMMIT0x8000000</term>
|
||
/// <term>
|
||
/// If the file mapping object is backed by the operating system paging file (the hfile parameter is INVALID_HANDLE_VALUE), specifies
|
||
/// that when a view of the file is mapped into a process address space, the entire range of pages is committed rather than reserved.
|
||
/// The system must have enough committable pages to hold the entire mapping. Otherwise, CreateFileMappingFromApp fails.This
|
||
/// attribute has no effect for file mapping objects that are backed by executable image files or data files (the hfile parameter is
|
||
/// a handle to a file).SEC_COMMIT cannot be combined with SEC_RESERVE.If no attribute is specified, SEC_COMMIT is assumed.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_IMAGE_NO_EXECUTE0x11000000</term>
|
||
/// <term>
|
||
/// Specifies that the file that the hFile parameter specifies is an executable image file that will not be executed and the loaded
|
||
/// image file will have no forced integrity checks run. Additionally, mapping a view of a file mapping object created with the
|
||
/// SEC_IMAGE_NO_EXECUTE attribute will not invoke driver callbacks registered using the PsSetLoadImageNotifyRoutine kernel API.The
|
||
/// SEC_IMAGE_NO_EXECUTE attribute must be combined with the PAGE_READONLY page protection value. No other attributes are valid with SEC_IMAGE_NO_EXECUTE.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_LARGE_PAGES0x80000000</term>
|
||
/// <term>
|
||
/// Enables large pages to be used for file mapping objects that are backed by the operating system paging file (the hfile parameter
|
||
/// is INVALID_HANDLE_VALUE). This attribute is not supported for file mapping objects that are backed by executable image files or
|
||
/// data files (the hFile parameter is a handle to an executable image or data file).The maximum size of the file mapping object must
|
||
/// be a multiple of the minimum size of a large page returned by the GetLargePageMinimum function. If it is not,
|
||
/// CreateFileMappingFromApp fails. When mapping a view of a file mapping object created with SEC_LARGE_PAGES, the base address and
|
||
/// view size must also be multiples of the minimum large page size.SEC_LARGE_PAGES requires the SeLockMemoryPrivilege privilege to
|
||
/// be enabled in the caller's token.If SEC_LARGE_PAGES is specified, SEC_COMMIT must also be specified.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_NOCACHE0x10000000</term>
|
||
/// <term>
|
||
/// Sets all pages to be non-cachable.Applications should not use this attribute except when explicitly required for a device. Using
|
||
/// the interlocked functions with memory that is mapped with SEC_NOCACHE can result in an EXCEPTION_ILLEGAL_INSTRUCTION
|
||
/// exception.SEC_NOCACHE requires either the SEC_RESERVE or SEC_COMMIT attribute to be set.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_RESERVE0x4000000</term>
|
||
/// <term>
|
||
/// If the file mapping object is backed by the operating system paging file (the hfile parameter is INVALID_HANDLE_VALUE), specifies
|
||
/// that when a view of the file is mapped into a process address space, the entire range of pages is reserved for later use by the
|
||
/// process rather than committed.Reserved pages can be committed in subsequent calls to the VirtualAlloc function. After the pages
|
||
/// are committed, they cannot be freed or decommitted with the VirtualFree function.This attribute has no effect for file mapping
|
||
/// objects that are backed by executable image files or data files (the hfile parameter is a handle to a file).SEC_RESERVE cannot be
|
||
/// combined with SEC_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_WRITECOMBINE0x40000000</term>
|
||
/// <term>
|
||
/// Sets all pages to be write-combined.Applications should not use this attribute except when explicitly required for a device.
|
||
/// Using the interlocked functions with memory that is mapped with SEC_WRITECOMBINE can result in an EXCEPTION_ILLEGAL_INSTRUCTION
|
||
/// exception.SEC_WRITECOMBINE requires either the SEC_RESERVE or SEC_COMMIT attribute to be set.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="MaximumSize">
|
||
/// <para>The maximum size of the file mapping object.</para>
|
||
/// <para>
|
||
/// An attempt to map a file with a length of 0 (zero) fails with an error code of <c>ERROR_FILE_INVALID</c>. Applications should
|
||
/// test for files with a length of 0 (zero) and reject those files.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="Name">
|
||
/// <para>The name of the file mapping object.</para>
|
||
/// <para>
|
||
/// If this parameter matches the name of an existing mapping object, the function requests access to the object with the protection
|
||
/// that flProtect specifies.
|
||
/// </para>
|
||
/// <para>If this parameter is <c>NULL</c>, the file mapping object is created without a name.</para>
|
||
/// <para>
|
||
/// If lpName matches the name of an existing event, semaphore, mutex, waitable timer, or job object, the function fails, and the
|
||
/// <c>GetLastError</c> function returns <c>ERROR_INVALID_HANDLE</c>. This occurs because these objects share the same namespace.
|
||
/// </para>
|
||
/// <para>
|
||
/// The name can have a "Global\" or "Local\" prefix to explicitly create the object in the global or session namespace. The
|
||
/// remainder of the name can contain any character except the backslash character (\). Creating a file mapping object in the global
|
||
/// namespace from a session other than session zero requires the SeCreateGlobalPrivilege privilege. For more information, see Kernel
|
||
/// Object Namespaces.
|
||
/// </para>
|
||
/// <para>
|
||
/// Fast user switching is implemented by using Terminal Services sessions. The first user to log on uses session 0 (zero), the next
|
||
/// user to log on uses session 1 (one), and so on. Kernel object names must follow the guidelines that are outlined for Terminal
|
||
/// Services so that applications can support multiple users.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a handle to the newly created file mapping object.</para>
|
||
/// <para>
|
||
/// If the object exists before the function call, the function returns a handle to the existing object (with its current size, not
|
||
/// the specified size), and <c>GetLastError</c> returns <c>ERROR_ALREADY_EXISTS</c>.
|
||
/// </para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// HANDLE WINAPI CreateFileMappingFromApp( _In_ HANDLE hFile, _In_opt_ PSECURITY_ATTRIBUTES SecurityAttributes, _In_ ULONG
|
||
// PageProtection, _In_ ULONG64 MaximumSize, _In_opt_ PCWSTR Name);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
|
||
[PInvokeData("MemoryApi.h", MSDNShortId = "hh994453")]
|
||
public static extern SafeHSECTION CreateFileMappingFromApp([In] HFILE hFile, [In] SECURITY_ATTRIBUTES SecurityAttributes,
|
||
MEM_PROTECTION PageProtection, ulong MaximumSize, string Name);
|
||
|
||
/// <summary>
|
||
/// Creates or opens a named or unnamed file mapping object for a specified file and specifies the NUMA node for the physical memory.
|
||
/// </summary>
|
||
/// <param name="hFile">
|
||
/// <para>A handle to the file from which to create a file mapping object.</para>
|
||
/// <para>
|
||
/// The file must be opened with access rights that are compatible with the protection flags that the flProtect parameter specifies.
|
||
/// It is not required, but it is recommended that files you intend to map be opened for exclusive access. For more information, see
|
||
/// File Security and Access Rights.
|
||
/// </para>
|
||
/// <para>
|
||
/// If hFile is <c>INVALID_HANDLE_VALUE</c>, the calling process must also specify a size for the file mapping object in the
|
||
/// dwMaximumSizeHigh and dwMaximumSizeLow parameters. In this scenario, <c>CreateFileMappingNuma</c> creates a file mapping object
|
||
/// of a specified size that is backed by the system paging file instead of by a file in the file system.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpFileMappingAttributes">
|
||
/// <para>
|
||
/// A pointer to a <c>SECURITY_ATTRIBUTES</c> structure that determines whether a returned handle can be inherited by child
|
||
/// processes. The <c>lpSecurityDescriptor</c> member of the <c>SECURITY_ATTRIBUTES</c> structure specifies a security descriptor for
|
||
/// a new file mapping object.
|
||
/// </para>
|
||
/// <para>
|
||
/// If lpFileMappingAttributes is <c>NULL</c>, the handle cannot be inherited and the file mapping object gets a default security
|
||
/// descriptor. The access control lists (ACL) in the default security descriptor for a file mapping object come from the primary or
|
||
/// impersonation token of the creator. For more information, see File Mapping Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="flProtect">
|
||
/// <para>
|
||
/// Specifies the page protection of the file mapping object. All mapped views of the object must be compatible with this protection.
|
||
/// </para>
|
||
/// <para>This parameter can be one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>PAGE_EXECUTE_READ0x20</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, or execute access.The file handle that the hFile parameter specifies must
|
||
/// be created with the GENERIC_READ and GENERIC_EXECUTE access rights.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_EXECUTE_READWRITE0x40</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, read/write or execute access.The file handle that the hFile parameter
|
||
/// specifies must be created with the GENERIC_READ, GENERIC_WRITE, and GENERIC_EXECUTE access rights.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_EXECUTE_WRITECOPY0x80</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, or execute access. This value is equivalent to PAGE_EXECUTE_READ.The file
|
||
/// handle that the hFile parameter specifies must be created with the GENERIC_READ and GENERIC_EXECUTE access rights.Windows Vista:
|
||
/// This value is not available until Windows Vista with SP1.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_READONLY0x02</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only or copy-on-write access. An attempt to write to a specific region results in an access
|
||
/// violation.The file handle that the hFile parameter specifies must be created with the GENERIC_READ access right.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_READWRITE0x04</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only, copy-on-write, or read/write access.The file handle that the hFile parameter specifies
|
||
/// must be created with the GENERIC_READ and GENERIC_WRITE access rights.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_WRITECOPY0x08</term>
|
||
/// <term>
|
||
/// Allows views to be mapped for read-only or copy-on-write access. This value is equivalent to PAGE_READONLY.The file handle that
|
||
/// the hFile parameter specifies must be created with the GENERIC_READ access right.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>
|
||
/// An application can specify one or more of the following attributes for the file mapping object by combining them with one of the
|
||
/// preceding page protection values.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>SEC_COMMIT0x8000000</term>
|
||
/// <term>Allocates physical storage in memory or the paging file for all pages. This is the default setting.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_IMAGE0x1000000</term>
|
||
/// <term>
|
||
/// Sets the file that is specified to be an executable image file.The SEC_IMAGE attribute must be combined with a page protection
|
||
/// value such as PAGE_READONLY. However, this page protection value has no effect on views of the executable image file. Page
|
||
/// protection for views of an executable image file is determined by the executable file itself.No other attributes are valid with SEC_IMAGE.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_IMAGE_NO_EXECUTE0x11000000</term>
|
||
/// <term>
|
||
/// Specifies that the file that the hFile parameter specifies is an executable image file that will not be executed and the loaded
|
||
/// image file will have no forced integrity checks run. Additionally, mapping a view of a file mapping object created with the
|
||
/// SEC_IMAGE_NO_EXECUTE attribute will not invoke driver callbacks registered using the PsSetLoadImageNotifyRoutine kernel API.The
|
||
/// SEC_IMAGE_NO_EXECUTE attribute must be combined with the PAGE_READONLY page protection value. No other attributes are valid with
|
||
/// SEC_IMAGE_NO_EXECUTE.Windows Server 2008 R2, Windows 7, Windows Server 2008 and Windows Vista: This value is not supported before
|
||
/// Windows Server 2012 and Windows 8.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_LARGE_PAGES0x80000000</term>
|
||
/// <term>
|
||
/// Enables large pages to be used when mapping images or backing from the pagefile, but not when mapping data for regular files. Be
|
||
/// sure to specify the maximum size of the file mapping object as the minimum size of a large page reported by the
|
||
/// GetLargePageMinimum function and to enable the SeLockMemoryPrivilege privilege.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_NOCACHE0x10000000</term>
|
||
/// <term>
|
||
/// Sets all pages to noncachable.Applications should not use this flag except when explicitly required for a device. Using the
|
||
/// interlocked functions with memory mapped with SEC_NOCACHE can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception.SEC_NOCACHE
|
||
/// requires either SEC_RESERVE or SEC_COMMIT to be set.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_RESERVE0x4000000</term>
|
||
/// <term>
|
||
/// Reserves all pages without allocating physical storage.The reserved range of pages cannot be used by any other allocation
|
||
/// operations until the range of pages is released.Reserved pages can be identified in subsequent calls to the VirtualAllocExNuma
|
||
/// function. This attribute is valid only if the hFile parameter is INVALID_HANDLE_VALUE (that is, a file mapping object that is
|
||
/// backed by the system paging file).
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>SEC_WRITECOMBINE0x40000000</term>
|
||
/// <term>
|
||
/// Sets all pages to be write-combined.Applications should not use this attribute except when explicitly required for a device.
|
||
/// Using the interlocked functions with memory that is mapped with SEC_WRITECOMBINE can result in an EXCEPTION_ILLEGAL_INSTRUCTION
|
||
/// exception.SEC_WRITECOMBINE requires either the SEC_RESERVE or SEC_COMMIT attribute to be set.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwMaximumSizeHigh">The high-order <c>DWORD</c> of the maximum size of the file mapping object.</param>
|
||
/// <param name="dwMaximumSizeLow">
|
||
/// <para>The low-order <c>DWORD</c> of the maximum size of the file mapping object.</para>
|
||
/// <para>
|
||
/// If this parameter and the dwMaximumSizeHigh parameter are 0 (zero), the maximum size of the file mapping object is equal to the
|
||
/// current size of the file that the hFile parameter identifies.
|
||
/// </para>
|
||
/// <para>
|
||
/// An attempt to map a file with a length of 0 (zero) fails with an error code of <c>ERROR_FILE_INVALID</c>. Applications should
|
||
/// test for files with a length of 0 (zero) and reject those files.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpName">
|
||
/// <para>The name of the file mapping object.</para>
|
||
/// <para>
|
||
/// If this parameter matches the name of an existing file mapping object, the function requests access to the object with the
|
||
/// protection that the flProtect parameter specifies.
|
||
/// </para>
|
||
/// <para>If this parameter is <c>NULL</c>, the file mapping object is created without a name.</para>
|
||
/// <para>
|
||
/// If the lpName parameter matches the name of an existing event, semaphore, mutex, waitable timer, or job object, the function
|
||
/// fails and the <c>GetLastError</c> function returns <c>ERROR_INVALID_HANDLE</c>. This occurs because these objects share the same namespace.
|
||
/// </para>
|
||
/// <para>
|
||
/// The name can have a "Global\" or "Local\" prefix to explicitly create the object in the global or session namespace. The
|
||
/// remainder of the name can contain any character except the backslash character (\). Creating a file mapping object in the global
|
||
/// namespace requires the SeCreateGlobalPrivilege privilege. For more information, see Kernel Object Namespaces.
|
||
/// </para>
|
||
/// <para>
|
||
/// Fast user switching is implemented by using Terminal Services sessions. The first user to log on uses session 0 (zero), the next
|
||
/// user to log on uses session 1 (one), and so on. Kernel object names must follow the guidelines so that applications can support
|
||
/// multiple users.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="nndPreferred">
|
||
/// <para>The NUMA node where the physical memory should reside.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>NUMA_NO_PREFERRED_NODE = 0xffffffff</term>
|
||
/// <term>No NUMA node is preferred. This is the same as calling the CreateFileMapping function.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a handle to the file mapping object.</para>
|
||
/// <para>
|
||
/// If the object exists before the function call, the function returns a handle to the existing object (with its current size, not
|
||
/// the specified size) and the <c>GetLastError</c> function returns <c>ERROR_ALREADY_EXISTS</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the function fails, the return value is <c>NULL</c>. To get extended error information, call the <c>GetLastError</c> function.
|
||
/// </para>
|
||
/// </returns>
|
||
// HANDLE WINAPI CreateFileMappingNuma( _In_ HANDLE hFile, _In_opt_ LPSECURITY_ATTRIBUTES lpFileMappingAttributes, _In_ DWORD
|
||
// flProtect, _In_ DWORD dwMaximumSizeHigh, _In_ DWORD dwMaximumSizeLow, _In_opt_ LPCTSTR lpName, _In_ DWORD nndPreferred);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366539")]
|
||
public static extern SafeHSECTION CreateFileMappingNuma([In] HFILE hFile, [In, Optional] SECURITY_ATTRIBUTES lpFileMappingAttributes, MEM_PROTECTION flProtect,
|
||
uint dwMaximumSizeHigh, uint dwMaximumSizeLow, string lpName, uint nndPreferred);
|
||
|
||
/// <summary>
|
||
/// <para>Creates a memory resource notification object.</para>
|
||
/// </summary>
|
||
/// <param name="NotificationType">
|
||
/// <para>
|
||
/// The memory condition under which the object is to be signaled. This parameter can be one of the following values from the
|
||
/// <c>MEMORY_RESOURCE_NOTIFICATION_TYPE</c> enumeration.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>LowMemoryResourceNotification0</term>
|
||
/// <term>Available physical memory is running low.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>HighMemoryResourceNotification1</term>
|
||
/// <term>Available physical memory is high.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a handle to a memory resource notification object.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// HANDLE WINAPI CreateMemoryResourceNotification( _In_ MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366541")]
|
||
public static extern SafeMemoryResourceNotification CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType);
|
||
|
||
/// <summary>
|
||
/// Discards the memory contents of a range of memory pages, without decommitting the memory. The contents of discarded memory is
|
||
/// undefined and must be rewritten by the application.
|
||
/// </summary>
|
||
/// <param name="VirtualAddress">Page-aligned starting address of the memory to discard.</param>
|
||
/// <param name="Size">Size, in bytes, of the memory region to discard. Size must be an integer multiple of the system page size.</param>
|
||
/// <returns>ERROR_SUCCESS if successful; a System Error Code otherwise.</returns>
|
||
// DWORD WINAPI DiscardVirtualMemory( _In_ PVOID VirtualAddress, _In_ SIZE_T Size);
|
||
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "dn781432")]
|
||
public static extern uint DiscardVirtualMemory(IntPtr VirtualAddress, SizeT Size);
|
||
|
||
/// <summary>Fills a block of memory with a specified value.</summary>
|
||
/// <param name="Destination">A pointer to the starting address of the block of memory to fill.</param>
|
||
/// <param name="Length">
|
||
/// The size of the block of memory to fill, in bytes. This value must be less than the size of the Destination buffer.
|
||
/// </param>
|
||
/// <param name="Fill">The byte value with which to fill the memory block.</param>
|
||
// void FillMemory( [out] PVOID Destination, [in] SIZE_T Length, [in] BYTE Fill); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366561(v=vs.85).aspx
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366561")]
|
||
[DllImport(Lib.Kernel32, EntryPoint = "RtlFillMemory", SetLastError = false)]
|
||
public static extern void FillMemory(IntPtr Destination, SizeT Length, byte Fill);
|
||
|
||
/// <summary>Writes to the disk a byte range within a mapped view of a file.</summary>
|
||
/// <param name="lpBaseAddress">
|
||
/// A pointer to the base address of the byte range to be flushed to the disk representation of the mapped file.
|
||
/// </param>
|
||
/// <param name="dwNumberOfBytesToFlush">
|
||
/// The number of bytes to be flushed. If dwNumberOfBytesToFlush is zero, the file is flushed from the base address to the end of the mapping.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI FlushViewOfFile( _In_ LPCVOID lpBaseAddress, _In_ SIZE_T dwNumberOfBytesToFlush);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366563")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool FlushViewOfFile([In] IntPtr lpBaseAddress, SizeT dwNumberOfBytesToFlush);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Frees physical memory pages that are allocated previously by using <c>AllocateUserPhysicalPages</c> or
|
||
/// <c>AllocateUserPhysicalPagesNuma</c>. If any of these pages are currently mapped in the Address Windowing Extensions (AWE)
|
||
/// region, they are automatically unmapped by this call. This does not affect the virtual address space that is occupied by a
|
||
/// specified Address Windowing Extensions (AWE) region.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>64-bit Windows on Itanium-based systems:</c> Due to the difference in page sizes, <c>FreeUserPhysicalPages</c> is not
|
||
/// supported for 32-bit applications.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// <para>The handle to a process.</para>
|
||
/// <para>The function frees memory within the virtual address space of this process.</para>
|
||
/// </param>
|
||
/// <param name="NumberOfPages">
|
||
/// <para>The size of the physical memory to free, in pages.</para>
|
||
/// <para>On return, if the function fails, this parameter indicates the number of pages that are freed.</para>
|
||
/// </param>
|
||
/// <param name="UserPfnArray">A pointer to an array of page frame numbers of the allocated memory to be freed.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is <c>TRUE</c>.</para>
|
||
/// <para>
|
||
/// If the function fails, the return value is <c>FALSE</c>. In this case, the NumberOfPages parameter reflect how many pages have
|
||
/// actually been released. To get extended error information, call <c>GetLastError</c>.
|
||
/// </para>
|
||
/// </returns>
|
||
// BOOL WINAPI FreeUserPhysicalPages( _In_ HANDLE hProcess, _Inout_ PULONG_PTR NumberOfPages, _In_ PULONG_PTR UserPfnArray);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366566")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool FreeUserPhysicalPages([In] HPROCESS hProcess, ref SizeT NumberOfPages, [In] IntPtr[] UserPfnArray);
|
||
|
||
/// <summary>Retrieves the minimum size of a large page.</summary>
|
||
/// <returns>
|
||
/// <para>If the processor supports large pages, the return value is the minimum size of a large page.</para>
|
||
/// <para>If the processor does not support large pages, the return value is zero.</para>
|
||
/// </returns>
|
||
// SIZE_T WINAPI GetLargePageMinimum(void);
|
||
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366568")]
|
||
public static extern SizeT GetLargePageMinimum();
|
||
|
||
/// <summary>Gets the memory error handling capabilities of the system.</summary>
|
||
/// <param name="Capabilities">
|
||
/// <para>A <c>PULONG</c> that receives one or more of the following flags.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEHC_PATROL_SCRUBBER_PRESENT = 1</term>
|
||
/// <term>The hardware can detect and report failed memory.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI GetMemoryErrorHandlingCapabilities( _Out_ PULONG Capabilities);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "hh691012")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool GetMemoryErrorHandlingCapabilities(out uint Capabilities);
|
||
|
||
/// <summary>Retrieves the minimum and maximum working set sizes of the specified process.</summary>
|
||
/// <param name="hProcess">
|
||
/// <para>
|
||
/// A handle to the process whose working set sizes will be obtained. The handle must have the <c>PROCESS_QUERY_INFORMATION</c> or
|
||
/// <c>PROCESS_QUERY_LIMITED_INFORMATION</c> access right. For more information, see Process Security and Access Rights.
|
||
/// </para>
|
||
/// <para><c>Windows Server 2003 and Windows XP:</c> The handle must have the <c>PROCESS_QUERY_INFORMATION</c> access right.</para>
|
||
/// </param>
|
||
/// <param name="lpMinimumWorkingSetSize">
|
||
/// A pointer to a variable that receives the minimum working set size of the specified process, in bytes. The virtual memory manager
|
||
/// attempts to keep at least this much memory resident in the process whenever the process is active.
|
||
/// </param>
|
||
/// <param name="lpMaximumWorkingSetSize">
|
||
/// A pointer to a variable that receives the maximum working set size of the specified process, in bytes. The virtual memory manager
|
||
/// attempts to keep no more than this much memory resident in the process whenever the process is active when memory is in short supply.
|
||
/// </param>
|
||
/// <param name="Flags">The flags that control the enforcement of the minimum and maximum working set sizes.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI GetProcessWorkingSetSize( _In_ HANDLE hProcess, _Out_ PSIZE_T lpMinimumWorkingSetSize, _Out_ PSIZE_T lpMaximumWorkingSetSize);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "ms683226")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool GetProcessWorkingSetSizeEx([In] HPROCESS hProcess, [Out] out SizeT lpMinimumWorkingSetSize, [Out] out SizeT lpMaximumWorkingSetSize, out QUOTA_LIMITS_HARDWS Flags);
|
||
|
||
/// <summary>Retrieves the current size limits for the working set of the system cache.</summary>
|
||
/// <param name="lpMinimumFileCacheSize">
|
||
/// A pointer to a variable that receives the minimum size of the file cache, in bytes. The virtual memory manager attempts to keep
|
||
/// at least this much memory resident in the system file cache, if there is a previous call to the <c>SetSystemFileCacheSize</c>
|
||
/// function with the <c>FILE_CACHE_MIN_HARD_ENABLE</c> flag.
|
||
/// </param>
|
||
/// <param name="lpMaximumFileCacheSize">
|
||
/// A pointer to a variable that receives the maximum size of the file cache, in bytes. The virtual memory manager enforces this
|
||
/// limit only if there is a previous call to <c>SetSystemFileCacheSize</c> with the <c>FILE_CACHE_MAX_HARD_ENABLE</c> flag.
|
||
/// </param>
|
||
/// <param name="lpFlags">
|
||
/// <para>The flags that indicate which of the file cache limits are enabled.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>FILE_CACHE_MAX_HARD_ENABLE = 0x1</term>
|
||
/// <term>The maximum size limit is enabled. If this flag is not present, this limit is disabled.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_CACHE_MIN_HARD_ENABLE = 0x4</term>
|
||
/// <term>The minimum size limit is enabled. If this flag is not present, this limit is disabled.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI GetSystemFileCacheSize( _Out_ PSIZE_T lpMinimumFileCacheSize, _Out_ PSIZE_T lpMaximumFileCacheSize, _Out_ PDWORD lpFlags);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa965224")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool GetSystemFileCacheSize(out SizeT lpMinimumFileCacheSize, out SizeT lpMaximumFileCacheSize, out FILE_CACHE_LIMITS lpFlags);
|
||
|
||
/// <summary>
|
||
/// <para>Retrieves the addresses of the pages that are written to in a region of virtual memory.</para>
|
||
/// <para>
|
||
/// <c>64-bit Windows on Itanium-based systems:</c> Due to the difference in page sizes, <c>GetWriteWatch</c> is not supported for
|
||
/// 32-bit applications.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="dwFlags">
|
||
/// <para>Indicates whether the function resets the write-tracking state.</para>
|
||
/// <para>
|
||
/// To reset the write-tracking state, set this parameter to <c>WRITE_WATCH_FLAG_RESET</c>. If this parameter is 0 (zero),
|
||
/// <c>GetWriteWatch</c> does not reset the write-tracking state. For more information, see the Remarks section of this topic.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpBaseAddress">
|
||
/// <para>The base address of the memory region for which to retrieve write-tracking information.</para>
|
||
/// <para>This address must be in a memory region that is allocated by the <c>VirtualAlloc</c> function using <c>MEM_WRITE_WATCH</c>.</para>
|
||
/// </param>
|
||
/// <param name="dwRegionSize">The size of the memory region for which to retrieve write-tracking information, in bytes.</param>
|
||
/// <param name="lpAddresses">
|
||
/// <para>A pointer to a buffer that receives an array of page addresses in the memory region.</para>
|
||
/// <para>
|
||
/// The addresses indicate the pages that have been written to since the region has been allocated or the write-tracking state has
|
||
/// been reset.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpdwCount">
|
||
/// <para>On input, this variable indicates the size of the lpAddresses array, in array elements.</para>
|
||
/// <para>On output, the variable receives the number of page addresses that are returned in the array.</para>
|
||
/// </param>
|
||
/// <param name="lpdwGranularity">A pointer to a variable that receives the page size, in bytes.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is 0 (zero).</para>
|
||
/// <para>If the function fails, the return value is a nonzero value.</para>
|
||
/// </returns>
|
||
// UINT WINAPI GetWriteWatch( _In_ DWORD dwFlags, _In_ PVOID lpBaseAddress, _In_ SIZE_T dwRegionSize, _Out_ PVOID *lpAddresses,
|
||
// _Inout_ PULONG_PTR lpdwCount, _Out_ PULONG lpdwGranularity);
|
||
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366573")]
|
||
public static extern uint GetWriteWatch(WRITE_WATCH dwFlags, [In] IntPtr lpBaseAddress, SizeT dwRegionSize, out IntPtr lpAddresses, ref UIntPtr lpdwCount, [Out] out uint lpdwGranularity);
|
||
|
||
/// <summary>
|
||
/// <para>Maps previously allocated physical memory pages at a specified address in an Address Windowing Extensions (AWE) region.</para>
|
||
/// <para>To perform batch mapping and unmapping of multiple regions, use the <c>MapUserPhysicalPagesScatter</c> function.</para>
|
||
/// <para>
|
||
/// <c>64-bit Windows on Itanium-based systems:</c> Due to the difference in page sizes, <c>MapUserPhysicalPages</c> is not supported
|
||
/// for 32-bit applications.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="lpAddress">
|
||
/// <para>A pointer to the starting address of the region of memory to remap.</para>
|
||
/// <para>
|
||
/// The value of lpAddress must be within the address range that the <c>VirtualAlloc</c> function returns when the Address Windowing
|
||
/// Extensions (AWE) region is allocated.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="NumberOfPages">
|
||
/// <para>The size of the physical memory and virtual address space for which to establish translations, in pages.</para>
|
||
/// <para>The virtual address range is contiguous starting at lpAddress. The physical frames are specified by the UserPfnArray.</para>
|
||
/// <para>The total number of pages cannot extend from the starting address beyond the end of the range that is specified in <c>AllocateUserPhysicalPages</c>.</para>
|
||
/// </param>
|
||
/// <param name="UserPfnArray">
|
||
/// <para>A pointer to an array of physical page frame numbers.</para>
|
||
/// <para>
|
||
/// These frames are mapped by the argument lpAddress on return from this function. The size of the memory that is allocated should
|
||
/// be at least the NumberOfPages times the size of the data type <c>ULONG_PTR</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// Do not attempt to modify this buffer. It contains operating system data, and corruption could be catastrophic. The information in
|
||
/// the buffer is not useful to an application.
|
||
/// </para>
|
||
/// <para>
|
||
/// If this parameter is <c>NULL</c>, the specified address range is unmapped. Also, the specified physical pages are not freed, and
|
||
/// you must call <c>FreeUserPhysicalPages</c> to free them.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is <c>TRUE</c>.</para>
|
||
/// <para>
|
||
/// If the function fails, the return value is <c>FALSE</c> and no mapping is done—partial or otherwise. To get extended error
|
||
/// information, call <c>GetLastError</c>.
|
||
/// </para>
|
||
/// </returns>
|
||
// BOOL WINAPI MapUserPhysicalPages( _In_ PVOID lpAddress, _In_ ULONG_PTR NumberOfPages, _In_ PULONG_PTR UserPfnArray);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366753")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool MapUserPhysicalPages([In] IntPtr lpAddress, SizeT NumberOfPages, [In] IntPtr[] UserPfnArray);
|
||
|
||
/// <summary>
|
||
/// <para>Maps previously allocated physical memory pages at a specified address in an Address Windowing Extensions (AWE) region.</para>
|
||
/// <para>
|
||
/// <c>64-bit Windows on Itanium-based systems:</c> Due to the difference in page sizes, <c>MapUserPhysicalPagesScatter</c> is not
|
||
/// supported for 32-bit applications.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="VirtualAddresses">
|
||
/// <para>A pointer to an array of starting addresses of the regions of memory to remap.</para>
|
||
/// <para>
|
||
/// Each entry in VirtualAddresses must be within the address range that the <c>VirtualAlloc</c> function returns when the Address
|
||
/// Windowing Extensions (AWE) region is allocated. The value in NumberOfPages indicates the size of the array. Entries can be from
|
||
/// multiple Address Windowing Extensions (AWE) regions.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="NumberOfPages">
|
||
/// <para>The size of the physical memory and virtual address space for which to establish translations, in pages.</para>
|
||
/// <para>The array at VirtualAddresses specifies the virtual address range.</para>
|
||
/// </param>
|
||
/// <param name="PageArray">
|
||
/// <para>A pointer to an array of values that indicates how each corresponding page in VirtualAddresses should be treated.</para>
|
||
/// <para>
|
||
/// A 0 (zero) indicates that the corresponding entry in VirtualAddresses should be unmapped, and any nonzero value that it has
|
||
/// should be mapped.
|
||
/// </para>
|
||
/// <para>If this parameter is <c>NULL</c>, then every address in the VirtualAddresses array is unmapped.</para>
|
||
/// <para>The value in NumberOfPages indicates the size of the array.</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is <c>TRUE</c>.</para>
|
||
/// <para>
|
||
/// If the function fails, the return value is <c>FALSE</c>, and the function does not map or unmap—partial or otherwise. To get
|
||
/// extended error information, call <c>GetLastError</c>.
|
||
/// </para>
|
||
/// </returns>
|
||
// BOOL WINAPI MapUserPhysicalPagesScatter( _In_ PVOID *VirtualAddresses, _In_ ULONG_PTR NumberOfPages, _In_ PULONG_PTR PageArray); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366755(v=vs.85).aspx
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366755")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool MapUserPhysicalPagesScatter([In] IntPtr VirtualAddresses, SizeT NumberOfPages, [In] IntPtr[] PageArray);
|
||
|
||
/// <summary>
|
||
/// <para>Maps a view of a file mapping into the address space of a calling process.</para>
|
||
/// <para>
|
||
/// To specify a suggested base address for the view, use the <c>MapViewOfFileEx</c> function. However, this practice is not recommended.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="hFileMappingObject">
|
||
/// A handle to a file mapping object. The <c>CreateFileMapping</c> and <c>OpenFileMapping</c> functions return this handle.
|
||
/// </param>
|
||
/// <param name="dwDesiredAccess">
|
||
/// <para>
|
||
/// The type of access to a file mapping object, which determines the protection of the pages. This parameter can be one of the
|
||
/// following values.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>FILE_MAP_ALL_ACCESS</term>
|
||
/// <term>
|
||
/// A read/write view of the file is mapped. The file mapping object must have been created with PAGE_READWRITE or
|
||
/// PAGE_EXECUTE_READWRITE protection.When used with the MapViewOfFile function, FILE_MAP_ALL_ACCESS is equivalent to FILE_MAP_WRITE.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_COPY</term>
|
||
/// <term>
|
||
/// A copy-on-write view of the file is mapped. The file mapping object must have been created with PAGE_READONLY, PAGE_READ_EXECUTE,
|
||
/// PAGE_WRITECOPY, PAGE_EXECUTE_WRITECOPY, PAGE_READWRITE, or PAGE_EXECUTE_READWRITE protection.When a process writes to a
|
||
/// copy-on-write page, the system copies the original page to a new page that is private to the process. The new page is backed by
|
||
/// the paging file. The protection of the new page changes from copy-on-write to read/write.When copy-on-write access is specified,
|
||
/// the system and process commit charge taken is for the entire view because the calling process can potentially write to every page
|
||
/// in the view, making all pages private. The contents of the new page are never written back to the original file and are lost when
|
||
/// the view is unmapped.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_READ</term>
|
||
/// <term>
|
||
/// A read-only view of the file is mapped. An attempt to write to the file view results in an access violation.The file mapping
|
||
/// object must have been created with PAGE_READONLY, PAGE_READWRITE, PAGE_EXECUTE_READ, or PAGE_EXECUTE_READWRITE protection.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_WRITE</term>
|
||
/// <term>
|
||
/// A read/write view of the file is mapped. The file mapping object must have been created with PAGE_READWRITE or
|
||
/// PAGE_EXECUTE_READWRITE protection.When used with MapViewOfFile, (FILE_MAP_WRITE | FILE_MAP_READ) and FILE_MAP_ALL_ACCESS are
|
||
/// equivalent to FILE_MAP_WRITE.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>Each of the preceding values can be combined with the following value.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>FILE_MAP_EXECUTE</term>
|
||
/// <term>
|
||
/// An executable view of the file is mapped (mapped memory can be run as code). The file mapping object must have been created with
|
||
/// PAGE_EXECUTE_READ, PAGE_EXECUTE_WRITECOPY, or PAGE_EXECUTE_READWRITE protection.Windows Server 2003 and Windows XP: This value is
|
||
/// available starting with Windows XP with SP2 and Windows Server 2003 with SP1.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>
|
||
/// For file mapping objects created with the <c>SEC_IMAGE</c> attribute, the dwDesiredAccess parameter has no effect and should be
|
||
/// set to any valid value such as <c>FILE_MAP_READ</c>.
|
||
/// </para>
|
||
/// <para>For more information about access to file mapping objects, see File Mapping Security and Access Rights.</para>
|
||
/// </param>
|
||
/// <param name="dwFileOffsetHigh">A high-order <c>DWORD</c> of the file offset where the view begins.</param>
|
||
/// <param name="dwFileOffsetLow">
|
||
/// A low-order <c>DWORD</c> of the file offset where the view is to begin. The combination of the high and low offsets must specify
|
||
/// an offset within the file mapping. They must also match the memory allocation granularity of the system. That is, the offset must
|
||
/// be a multiple of the allocation granularity. To obtain the memory allocation granularity of the system, use the
|
||
/// <c>GetSystemInfo</c> function, which fills in the members of a <c>SYSTEM_INFO</c> structure.
|
||
/// </param>
|
||
/// <param name="dwNumberOfBytesToMap">
|
||
/// The number of bytes of a file mapping to map to the view. All bytes must be within the maximum size specified by
|
||
/// <c>CreateFileMapping</c>. If this parameter is 0 (zero), the mapping extends from the specified offset to the end of the file mapping.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the starting address of the mapped view.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// LPVOID WINAPI MapViewOfFile( _In_ HANDLE hFileMappingObject, _In_ DWORD dwDesiredAccess, _In_ DWORD dwFileOffsetHigh, _In_ DWORD
|
||
// dwFileOffsetLow, _In_ SIZE_T dwNumberOfBytesToMap);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366761")]
|
||
public static extern IntPtr MapViewOfFile([In] HSECTION hFileMappingObject, FILE_MAP dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, uint dwNumberOfBytesToMap);
|
||
|
||
/// <summary>
|
||
/// <para>Maps a view of a file or a pagefile-backed section into the address space of the specified process.</para>
|
||
/// <para>
|
||
/// Using this function, you can: for new allocations, specify a range of virtual address space and a power-of-2 alignment
|
||
/// restriction; specify an arbitrary number of extended parameters; specify a preferred NUMA node for the physical memory as an
|
||
/// extended parameter; and specify a placeholder operation (specifically, replacement).
|
||
/// </para>
|
||
/// <para>To specify the NUMA node, see the ExtendedParameters parameter.</para>
|
||
/// </summary>
|
||
/// <param name="FileMapping">A <c>HANDLE</c> to a section that is to be mapped into the address space of the specified process.</param>
|
||
/// <param name="Process">A <c>HANDLE</c> to a process into which the section will be mapped.</param>
|
||
/// <param name="BaseAddress">
|
||
/// The desired base address of the view. The address is rounded down to the nearest 64k boundary. If this parameter is <c>NULL</c>,
|
||
/// the system picks the base address.
|
||
/// </param>
|
||
/// <param name="Offset">The offset from the beginning of the section. This must be 64k aligned.</param>
|
||
/// <param name="ViewSize">
|
||
/// <para>The number of bytes to map. A value of zero (0) specifies that the entire section is to be mapped.</para>
|
||
/// <para>The size must always be a multiple of the page size.</para>
|
||
/// </param>
|
||
/// <param name="AllocationType">
|
||
/// <para>The type of memory allocation. This parameter can be zero (0) or one of the following values.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE 0x00002000</term>
|
||
/// <term>Maps a reserved view.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_REPLACE_PLACEHOLDER 0x00004000</term>
|
||
/// <term>
|
||
/// Replaces a placeholder with a mapped view. Only data/pf-backed section views are supported (no images, physical memory, etc.).
|
||
/// When you replace a placeholder, BaseAddress and ViewSize must exactly match those of the placeholder. After you replace a
|
||
/// placeholder with a mapped view, to free that mapped view back to a placeholder, see the UnmapFlags parameter of UnmapViewOfFileEx
|
||
/// and UnmapViewOfFile2. A placeholder is a type of reserved memory region.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_LARGE_PAGES 0x20000000</term>
|
||
/// <term>Maps a large page view. See large page support.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="PageProtection">
|
||
/// <para>The desired page protection.</para>
|
||
/// <para>
|
||
/// For file-mapping objects created with the <c>SEC_IMAGE</c> attribute, the PageProtection parameter has no effect, and should be
|
||
/// set to any valid value such as <c>PAGE_READONLY</c>.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="ExtendedParameters">
|
||
/// An optional pointer to one or more extended parameters of type MEM_EXTENDED_PARAMETER. Each of those extended parameter values
|
||
/// can itself have a Type field of either <c>MemExtendedParameterAddressRequirements</c> or <c>MemExtendedParameterNumaNode</c>. If
|
||
/// no <c>MemExtendedParameterNumaNode</c> extended parameter is provided, then the behavior is the same as for the
|
||
/// VirtualAlloc/MapViewOfFile functions (that is, the preferred NUMA node for the physical pages is determined based on the ideal
|
||
/// processor of the thread that first accesses the memory).
|
||
/// </param>
|
||
/// <param name="ParameterCount">The number of extended parameters pointed to by ExtendedParameters.</param>
|
||
/// <returns>
|
||
/// Returns the base address of the mapped view, if successful. Otherwise, returns <c>NULL</c> and extended error status is available
|
||
/// using GetLastError.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This API helps support high-performance games, and server applications, which have particular requirements around managing their
|
||
/// virtual address space. For example, mapping memory on top of a previously reserved region; this is useful for implementing an
|
||
/// automatically wrapping ring buffer. And allocating memory with specific alignment; for example, to enable your application to
|
||
/// commit large/huge page-mapped regions on demand.
|
||
/// </para>
|
||
/// <para>Examples</para>
|
||
/// <para>For a code example, see Scenario 1 in Virtual2Alloc.</para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/memoryapi/nf-memoryapi-mapviewoffile3
|
||
// PVOID MapViewOfFile3( HANDLE FileMapping, HANDLE Process, PVOID BaseAddress, ULONG64 Offset, SIZE_T ViewSize, ULONG AllocationType, ULONG PageProtection, MEM_EXTENDED_PARAMETER *ExtendedParameters, ULONG ParameterCount );
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("memoryapi.h", MSDNShortId = "585D7BA1-688F-4F24-8D8D-46A2FC137193")]
|
||
public static extern IntPtr MapViewOfFile3([In] HSECTION FileMapping, [In] HPROCESS Process, [In] IntPtr BaseAddress, ulong Offset, SizeT ViewSize, MEM_ALLOCATION_TYPE AllocationType,
|
||
MEM_PROTECTION PageProtection, [In] MEM_EXTENDED_PARAMETER[] ExtendedParameters, uint ParameterCount);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Maps a view of a file mapping into the address space of a calling process. A caller can optionally specify a suggested base
|
||
/// memory address for the view.
|
||
/// </para>
|
||
/// <para>To specify the NUMA node for the physical memory, see <c>MapViewOfFileExNuma</c>.</para>
|
||
/// </summary>
|
||
/// <param name="hFileMappingObject">
|
||
/// A handle to a file mapping object. The <c>CreateFileMapping</c> and <c>OpenFileMapping</c> functions return this handle.
|
||
/// </param>
|
||
/// <param name="dwDesiredAccess">
|
||
/// <para>
|
||
/// The type of access to a file mapping object, which determines the page protection of the pages. This parameter can be one of the
|
||
/// following values.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>FILE_MAP_ALL_ACCESS</term>
|
||
/// <term>
|
||
/// A read/write view of the file is mapped. The file mapping object must have been created with PAGE_READWRITE or
|
||
/// PAGE_EXECUTE_READWRITE protection.When used with the MapViewOfFileEx function, FILE_MAP_ALL_ACCESS is equivalent to FILE_MAP_WRITE.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_COPY</term>
|
||
/// <term>
|
||
/// A copy-on-write view of the file is mapped. The file mapping object must have been created with PAGE_READONLY, PAGE_READ_EXECUTE,
|
||
/// PAGE_WRITECOPY, PAGE_EXECUTE_WRITECOPY, PAGE_READWRITE, or PAGE_EXECUTE_READWRITE protection.When a process writes to a
|
||
/// copy-on-write page, the system copies the original page to a new page that is private to the process. The new page is backed by
|
||
/// the paging file. The protection of the new page changes from copy-on-write to read/write.When copy-on-write access is specified,
|
||
/// the system and process commit charge taken is for the entire view because the calling process can potentially write to every page
|
||
/// in the view, making all pages private. The contents of the new page are never written back to the original file and are lost when
|
||
/// the view is unmapped.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_READ</term>
|
||
/// <term>
|
||
/// A read-only view of the file is mapped. An attempt to write to the file view results in an access violation.The file mapping
|
||
/// object must have been created with PAGE_READONLY, PAGE_READWRITE, PAGE_EXECUTE_READ, or PAGE_EXECUTE_READWRITE protection.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_WRITE</term>
|
||
/// <term>
|
||
/// A read/write view of the file is mapped. The file mapping object must have been created with PAGE_READWRITE or
|
||
/// PAGE_EXECUTE_READWRITE protection.When used with MapViewOfFileEx, (FILE_MAP_WRITE | FILE_MAP_READ) and FILE_MAP_ALL_ACCESS are
|
||
/// equivalent to FILE_MAP_WRITE.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>Each of the preceding values can be combined with the following value.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>FILE_MAP_EXECUTE</term>
|
||
/// <term>
|
||
/// An executable view of the file is mapped (mapped memory can be run as code). The file mapping object must have been created with
|
||
/// PAGE_EXECUTE_READ, PAGE_EXECUTE_WRITECOPY, or PAGE_EXECUTE_READWRITE protection.Windows Server 2003 and Windows XP: This value is
|
||
/// available starting with Windows XP with SP2 and Windows Server 2003 with SP1.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>
|
||
/// For file mapping objects created with the <c>SEC_IMAGE</c> attribute, the dwDesiredAccess parameter has no effect and should be
|
||
/// set to any valid value such as <c>FILE_MAP_READ</c>.
|
||
/// </para>
|
||
/// <para>For more information about access to file mapping objects, see File Mapping Security and Access Rights.</para>
|
||
/// </param>
|
||
/// <param name="dwFileOffsetHigh">The high-order <c>DWORD</c> of the file offset where the view is to begin.</param>
|
||
/// <param name="dwFileOffsetLow">
|
||
/// The low-order <c>DWORD</c> of the file offset where the view is to begin. The combination of the high and low offsets must
|
||
/// specify an offset within the file mapping. They must also match the memory allocation granularity of the system. That is, the
|
||
/// offset must be a multiple of the allocation granularity. To obtain the memory allocation granularity of the system, use the
|
||
/// <c>GetSystemInfo</c> function, which fills in the members of a <c>SYSTEM_INFO</c> structure.
|
||
/// </param>
|
||
/// <param name="dwNumberOfBytesToMap">
|
||
/// The number of bytes of a file mapping to map to a view. All bytes must be within the maximum size specified by
|
||
/// <c>CreateFileMapping</c>. If this parameter is 0 (zero), the mapping extends from the specified offset to the end of the file mapping.
|
||
/// </param>
|
||
/// <param name="lpBaseAddress">
|
||
/// <para>
|
||
/// A pointer to the memory address in the calling process address space where mapping begins. This must be a multiple of the
|
||
/// system's memory allocation granularity, or the function fails. To determine the memory allocation granularity of the system, use
|
||
/// the <c>GetSystemInfo</c> function. If there is not enough address space at the specified address, the function fails.
|
||
/// </para>
|
||
/// <para>
|
||
/// If lpBaseAddress is <c>NULL</c>, the operating system chooses the mapping address. In this scenario, the function is equivalent
|
||
/// to the <c>MapViewOfFile</c> function.
|
||
/// </para>
|
||
/// <para>
|
||
/// While it is possible to specify an address that is safe now (not used by the operating system), there is no guarantee that the
|
||
/// address will remain safe over time. Therefore, it is better to let the operating system choose the address. In this case, you
|
||
/// would not store pointers in the memory mapped file, you would store offsets from the base of the file mapping so that the mapping
|
||
/// can be used at any address.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the starting address of the mapped view.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// LPVOID WINAPI MapViewOfFileEx( _In_ HANDLE hFileMappingObject, _In_ DWORD dwDesiredAccess, _In_ DWORD dwFileOffsetHigh, _In_ DWORD
|
||
// dwFileOffsetLow, _In_ SIZE_T dwNumberOfBytesToMap, _In_opt_ LPVOID lpBaseAddress);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366763")]
|
||
public static extern IntPtr MapViewOfFileEx([In] HSECTION hFileMappingObject, FILE_MAP dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, uint dwNumberOfBytesToMap,
|
||
[In] IntPtr lpBaseAddress);
|
||
|
||
/// <summary>Maps a view of a file mapping into the address space of a calling Windows Store app.</summary>
|
||
/// <param name="hFileMappingObject">
|
||
/// A handle to a file mapping object. The <c>CreateFileMappingFromApp</c> function returns this handle.
|
||
/// </param>
|
||
/// <param name="DesiredAccess">
|
||
/// <para>
|
||
/// The type of access to a file mapping object, which determines the protection of the pages. This parameter can be one of the
|
||
/// following values.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>FILE_MAP_ALL_ACCESS</term>
|
||
/// <term>
|
||
/// A read/write view of the file is mapped. The file mapping object must have been created with PAGE_READWRITE protection.When used
|
||
/// with the MapViewOfFileFromApp function, FILE_MAP_ALL_ACCESS is equivalent to FILE_MAP_WRITE.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_COPY</term>
|
||
/// <term>
|
||
/// A copy-on-write view of the file is mapped. The file mapping object must have been created with PAGE_READONLY, PAGE_READ_EXECUTE,
|
||
/// PAGE_WRITECOPY, or PAGE_READWRITE protection.When a process writes to a copy-on-write page, the system copies the original page
|
||
/// to a new page that is private to the process. The new page is backed by the paging file. The protection of the new page changes
|
||
/// from copy-on-write to read/write.When copy-on-write access is specified, the system and process commit charge taken is for the
|
||
/// entire view because the calling process can potentially write to every page in the view, making all pages private. The contents
|
||
/// of the new page are never written back to the original file and are lost when the view is unmapped.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_READ</term>
|
||
/// <term>
|
||
/// A read-only view of the file is mapped. An attempt to write to the file view results in an access violation.The file mapping
|
||
/// object must have been created with PAGE_READONLY, PAGE_READWRITE, PAGE_EXECUTE_READ, or PAGE_EXECUTE_READWRITE protection.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_MAP_WRITE</term>
|
||
/// <term>
|
||
/// A read/write view of the file is mapped. The file mapping object must have been created with PAGE_READWRITE protection.When used
|
||
/// with MapViewOfFileFromApp, (FILE_MAP_WRITE | FILE_MAP_READ) and FILE_MAP_ALL_ACCESS are equivalent to FILE_MAP_WRITE.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>For more information about access to file mapping objects, see File Mapping Security and Access Rights.</para>
|
||
/// </param>
|
||
/// <param name="FileOffset">
|
||
/// The file offset where the view is to begin. The offset must specify an offset within the file mapping. They must also match the
|
||
/// memory allocation granularity of the system. That is, the offset must be a multiple of the allocation granularity. To obtain the
|
||
/// memory allocation granularity of the system, use the <c>GetSystemInfo</c> function, which fills in the members of a
|
||
/// <c>SYSTEM_INFO</c> structure.
|
||
/// </param>
|
||
/// <param name="NumberOfBytesToMap">
|
||
/// The number of bytes of a file mapping to map to the view. All bytes must be within the maximum size specified by
|
||
/// <c>CreateFileMappingFromApp</c>. If this parameter is 0 (zero), the mapping extends from the specified offset to the end of the
|
||
/// file mapping.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the starting address of the mapped view.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// PVOID WINAPI MapViewOfFileFromApp( _In_ HANDLE hFileMappingObject, _In_ ULONG DesiredAccess, _In_ ULONG64 FileOffset, _In_ SIZE_T NumberOfBytesToMap);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("MemoryApi.h", MSDNShortId = "hh994454")]
|
||
public static extern IntPtr MapViewOfFileFromApp([In] HSECTION hFileMappingObject, FILE_MAP DesiredAccess, ulong FileOffset, SizeT NumberOfBytesToMap);
|
||
|
||
/// <summary>
|
||
/// <para>Maps a view of a file mapping into the address space of a calling Windows Store app.</para>
|
||
/// <para>
|
||
/// Using this function, you can: for new allocations, specify a range of virtual address space and a power-of-2 alignment
|
||
/// restriction; specify an arbitrary number of extended parameters; specify a preferred NUMA node for the physical memory as an
|
||
/// extended parameter; and specify a placeholder operation (specifically, replacement).
|
||
/// </para>
|
||
/// <para>To specify the NUMA node, see the ExtendedParameters parameter.</para>
|
||
/// </summary>
|
||
/// <param name="FileMapping">A <c>HANDLE</c> to a section that is to be mapped into the address space of the specified process.</param>
|
||
/// <param name="Process">A <c>HANDLE</c> to a process into which the section will be mapped.</param>
|
||
/// <param name="BaseAddress">
|
||
/// The desired base address of the view. The address is rounded down to the nearest 64k boundary. If this parameter is <c>NULL</c>,
|
||
/// the system picks the base address.
|
||
/// </param>
|
||
/// <param name="Offset">The offset from the beginning of the section. This must be 64k aligned.</param>
|
||
/// <param name="ViewSize">
|
||
/// <para>The number of bytes to map. A value of zero (0) specifies that the entire section is to be mapped.</para>
|
||
/// <para>The size must always be a multiple of the page size.</para>
|
||
/// </param>
|
||
/// <param name="AllocationType">
|
||
/// <para>The type of memory allocation. This parameter can be zero (0) or one of the following values.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE 0x00002000</term>
|
||
/// <term>Maps a reserved view.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_REPLACE_PLACEHOLDER 0x00004000</term>
|
||
/// <term>
|
||
/// Replaces a placeholder with a mapped view. Only data/pf-backed section views are supported (no images, physical memory, etc.).
|
||
/// When you replace a placeholder, BaseAddress and ViewSize must exactly match those of the placeholder. After you replace a
|
||
/// placeholder with a mapped view, to free that mapped view back to a placeholder, see the UnmapFlags parameter of UnmapViewOfFileEx
|
||
/// and UnmapViewOfFile2. A placeholder is a type of reserved memory region.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_LARGE_PAGES 0x20000000</term>
|
||
/// <term>Maps a large page view. See large page support.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="PageProtection">
|
||
/// <para>The desired page protection.</para>
|
||
/// <para>
|
||
/// For file-mapping objects created with the <c>SEC_IMAGE</c> attribute, the PageProtection parameter has no effect, and should be
|
||
/// set to any valid value such as <c>PAGE_READONLY</c>.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="ExtendedParameters">
|
||
/// An optional pointer to one or more extended parameters of type MEM_EXTENDED_PARAMETER. Each of those extended parameter values
|
||
/// can itself have a Type field of either <c>MemExtendedParameterAddressRequirements</c> or <c>MemExtendedParameterNumaNode</c>. If
|
||
/// no <c>MemExtendedParameterNumaNode</c> extended parameter is provided, then the behavior is the same as for the
|
||
/// VirtualAlloc/MapViewOfFile functions (that is, the preferred NUMA node for the physical pages is determined based on the ideal
|
||
/// processor of the thread that first accesses the memory).
|
||
/// </param>
|
||
/// <param name="ParameterCount">The number of extended parameters pointed to by ExtendedParameters.</param>
|
||
/// <returns>
|
||
/// Returns the base address of the mapped view, if successful. Otherwise, returns <c>NULL</c> and extended error status is available
|
||
/// using GetLastError.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This API helps support high-performance games, and server applications, which have particular requirements around managing their
|
||
/// virtual address space. For example, mapping memory on top of a previously reserved region; this is useful for implementing an
|
||
/// automatically wrapping ring buffer. And allocating memory with specific alignment; for example, to enable your application to
|
||
/// commit large/huge page-mapped regions on demand.
|
||
/// </para>
|
||
/// <para>
|
||
/// With one important exception, file views derived from any file mapping object that is backed by the same file are coherent or
|
||
/// identical at a specific time. Coherency is guaranteed for views within a process and for views that are mapped by different processes.
|
||
/// </para>
|
||
/// <para>
|
||
/// The exception is related to remote files. Although <c>MapViewOfFile3FromApp</c> works with remote files, it does not keep them
|
||
/// coherent. For example, if two computers both map a file as writable, and both change the same page, each computer only sees its
|
||
/// own writes to the page. When the data gets updated on the disk, it is not merged.
|
||
/// </para>
|
||
/// <para>You can only successfully request executable protection if your app has the <c>codeGeneration</c> capability.</para>
|
||
/// <para>Examples</para>
|
||
/// <para>For a code example, see Scenario 1 in Virtual2Alloc.</para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/memoryapi/nf-memoryapi-mapviewoffile3fromapp
|
||
// PVOID MapViewOfFile3FromApp( HANDLE FileMapping, HANDLE Process, PVOID BaseAddress, ULONG64 Offset, SIZE_T ViewSize, ULONG AllocationType, ULONG PageProtection, MEM_EXTENDED_PARAMETER *ExtendedParameters, ULONG ParameterCount );
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("memoryapi.h", MSDNShortId = "5E10E1B2-69D9-4F68-8F06-D411CF7FE2ED")]
|
||
public static extern IntPtr MapViewOfFile3FromApp([In] HSECTION FileMapping, [In] HPROCESS Process, [In] IntPtr BaseAddress, ulong Offset, SizeT ViewSize, MEM_ALLOCATION_TYPE AllocationType,
|
||
MEM_PROTECTION PageProtection, [In] MEM_EXTENDED_PARAMETER[] ExtendedParameters, uint ParameterCount);
|
||
|
||
/// <summary>Maps a view of a file or a pagefile-backed section into the address space of the specified process.</summary>
|
||
/// <param name="FileMappingHandle">A <c>HANDLE</c> to a section that is to be mapped into the address space of the specified process.</param>
|
||
/// <param name="ProcessHandle">A <c>HANDLE</c> to a process into which the section will be mapped.</param>
|
||
/// <param name="Offset">The offset from the beginning of the section. This must be 64k aligned.</param>
|
||
/// <param name="BaseAddress">
|
||
/// The desired base address of the view. The address is rounded down to the nearest 64k boundary. If this parameter is <c>NULL</c>,
|
||
/// the system picks the base address.
|
||
/// </param>
|
||
/// <param name="ViewSize">The number of bytes to map. A value of zero (0) specifies that the entire section is to be mapped.</param>
|
||
/// <param name="AllocationType">The type of allocation. This parameter can be zero (0) or one of the following constant values:</param>
|
||
/// <param name="PageProtection">The desired page protection.</param>
|
||
/// <param name="PreferredNode">The preferred NUMA node for this memory.</param>
|
||
/// <returns>
|
||
/// Returns the base address of the mapped view, if successful. Otherwise, returns <c>NULL</c> and extended error status is available
|
||
/// using <c>GetLastError</c>.
|
||
/// </returns>
|
||
// PVOID WINAPI MapViewOfFileNuma2( _In_ HANDLE FileMappingHandle, _In_ HANDLE ProcessHandle, _In_ ULONG64 Offset, _In_opt_ PVOID
|
||
// BaseAddress, _In_ SIZE_T ViewSize, _In_ ULONG AllocationType, _In_ ULONG PageProtection, _In_ ULONG PreferredNode);
|
||
[DllImport("Api-ms-win-core-memory-l1-1-5.dll", SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "mt492558")]
|
||
public static extern IntPtr MapViewOfFileNuma2([In] HSECTION FileMappingHandle, [In] HPROCESS ProcessHandle, ulong Offset, IntPtr BaseAddress, SizeT ViewSize,
|
||
MEM_ALLOCATION_TYPE AllocationType, MEM_PROTECTION PageProtection, uint PreferredNode);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Indicates that the data contained in a range of memory pages is no longer needed by the application and can be discarded by the
|
||
/// system if necessary.
|
||
/// </para>
|
||
/// <para>
|
||
/// The specified pages will be marked as inaccessible, removed from the process working set, and will not be written to the paging file.
|
||
/// </para>
|
||
/// <para>To later reclaim offered pages, call <c>ReclaimVirtualMemory</c>.</para>
|
||
/// </summary>
|
||
/// <param name="VirtualAddress">Page-aligned starting address of the memory to offer.</param>
|
||
/// <param name="Size">Size, in bytes, of the memory region to offer. Size must be an integer multiple of the system page size.</param>
|
||
/// <param name="Priority">
|
||
/// <para>
|
||
/// Priority indicates how important the offered memory is to the application. A higher priority increases the probability that the
|
||
/// offered memory can be reclaimed intact when calling <c>ReclaimVirtualMemory</c>. The system typically discards lower priority
|
||
/// memory before discarding higher priority memory. Priority must be one of the following values.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>VMOfferPriorityVeryLow0x00001000</term>
|
||
/// <term>The offered memory is very low priority, and should be the first discarded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>VMOfferPriorityLow0x00002000</term>
|
||
/// <term>The offered memory is low priority.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>VMOfferPriorityBelowNormal0x00002000</term>
|
||
/// <term>The offered memory is below normal priority.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>VMOfferPriorityNormal0x00002000</term>
|
||
/// <term>The offered memory is of normal priority to the application, and should be the last discarded.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>ERROR_SUCCESS if successful; a System Error Code otherwise.</returns>
|
||
// DWORD WINAPI OfferVirtualMemory( _In_ PVOID VirtualAddress, _In_ SIZE_T Size, _In_ OFFER_PRIORITY Priority);
|
||
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "dn781436")]
|
||
public static extern uint OfferVirtualMemory(IntPtr VirtualAddress, SizeT Size, OFFER_PRIORITY Priority);
|
||
|
||
/// <summary>Opens a named file mapping object.</summary>
|
||
/// <param name="dwDesiredAccess">
|
||
/// The access to the file mapping object. This access is checked against any security descriptor on the target file mapping object.
|
||
/// For a list of values, see File Mapping Security and Access Rights.
|
||
/// </param>
|
||
/// <param name="bInheritHandle">
|
||
/// If this parameter is <c>TRUE</c>, a process created by the <c>CreateProcess</c> function can inherit the handle; otherwise, the
|
||
/// handle cannot be inherited.
|
||
/// </param>
|
||
/// <param name="lpName">
|
||
/// The name of the file mapping object to be opened. If there is an open handle to a file mapping object by this name and the
|
||
/// security descriptor on the mapping object does not conflict with the dwDesiredAccess parameter, the open operation succeeds. The
|
||
/// name can have a "Global\" or "Local\" prefix to explicitly open an object in the global or session namespace. The remainder of
|
||
/// the name can contain any character except the backslash character (\). For more information, see Kernel Object Namespaces. Fast
|
||
/// user switching is implemented using Terminal Services sessions. The first user to log on uses session 0, the next user to log on
|
||
/// uses session 1, and so on. Kernel object names must follow the guidelines outlined for Terminal Services so that applications can
|
||
/// support multiple users.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is an open handle to the specified file mapping object.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// HANDLE WINAPI OpenFileMapping( _In_ DWORD dwDesiredAccess, _In_ BOOL bInheritHandle, _In_ LPCTSTR lpName);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366791")]
|
||
public static extern SafeHSECTION OpenFileMapping(FILE_MAP dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, string lpName);
|
||
|
||
/// <summary>Opens a named file mapping object.</summary>
|
||
/// <param name="DesiredAccess">
|
||
/// The access to the file mapping object. This access is checked against any security descriptor on the target file mapping object.
|
||
/// For a list of values, see File Mapping Security and Access Rights. You can only open the file mapping object for
|
||
/// <c>FILE_MAP_EXECUTE</c> access if your app has the <c>codeGeneration</c> capability.
|
||
/// </param>
|
||
/// <param name="InheritHandle">
|
||
/// If this parameter is <c>TRUE</c>, a process created by the <c>CreateProcess</c> function can inherit the handle; otherwise, the
|
||
/// handle cannot be inherited.
|
||
/// </param>
|
||
/// <param name="Name">
|
||
/// The name of the file mapping object to be opened. If there is an open handle to a file mapping object by this name and the
|
||
/// security descriptor on the mapping object does not conflict with the DesiredAccess parameter, the open operation succeeds. The
|
||
/// name can have a "Global\" or "Local\" prefix to explicitly open an object in the global or session namespace. The remainder of
|
||
/// the name can contain any character except the backslash character (\). For more information, see Kernel Object Namespaces. Fast
|
||
/// user switching is implemented using Terminal Services sessions. The first user to log on uses session 0, the next user to log on
|
||
/// uses session 1, and so on. Kernel object names must follow the guidelines outlined for Terminal Services so that applications can
|
||
/// support multiple users.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is an open handle to the specified file mapping object.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// HANDLE WINAPI OpenFileMappingFromApp( _In_ ULONG DesiredAccess, _In_ BOOL InheritHandle, _In_ PCWSTR Name);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
|
||
[PInvokeData("MemoryApi.h", MSDNShortId = "mt169844")]
|
||
public static extern SafeHSECTION OpenFileMappingFromApp(FILE_MAP DesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool InheritHandle, string Name);
|
||
|
||
/// <summary>
|
||
/// Provides an efficient mechanism to bring into memory potentially discontiguous virtual address ranges in a process address space.
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// Handle to the process whose virtual address ranges are to be prefetched. Use the <c>GetCurrentProcess</c> function to use the
|
||
/// current process.
|
||
/// </param>
|
||
/// <param name="NumberOfEntries">Number of entries in the array pointed to by the VirtualAddresses parameter.</param>
|
||
/// <param name="VirtualAddresses">
|
||
/// Pointer to an array of <c>WIN32_MEMORY_RANGE_ENTRY</c> structures which each specify a virtual address range to be prefetched.
|
||
/// The virtual address ranges may cover any part of the process address space accessible by the target process.
|
||
/// </param>
|
||
/// <param name="Flags">Reserved. Must be 0.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI PrefetchVirtualMemory( _In_ HANDLE hProcess, _In_ ULONG_PTR NumberOfEntries, _In_ PWIN32_MEMORY_RANGE_ENTRY
|
||
// VirtualAddresses, _In_ ULONG Flags);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "hh780543")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool PrefetchVirtualMemory(HPROCESS hProcess, UIntPtr NumberOfEntries, IntPtr VirtualAddresses, uint Flags);
|
||
|
||
/// <summary>Retrieves the state of the specified memory resource object.</summary>
|
||
/// <param name="ResourceNotificationHandle">
|
||
/// A handle to a memory resource notification object. The <c>CreateMemoryResourceNotification</c> function returns this handle.
|
||
/// </param>
|
||
/// <param name="ResourceState">
|
||
/// The memory pointed to by this parameter receives the state of the memory resource notification object. The value of this
|
||
/// parameter is set to <c>TRUE</c> if the specified memory condition exists, and <c>FALSE</c> if the specified memory condition does
|
||
/// not exist.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. For more error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI QueryMemoryResourceNotification( _In_ HANDLE ResourceNotificationHandle, _Out_ PBOOL ResourceState);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366799")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool QueryMemoryResourceNotification([In] SafeMemoryResourceNotification ResourceNotificationHandle, [Out, MarshalAs(UnmanagedType.Bool)] out bool ResourceState);
|
||
|
||
/// <summary>
|
||
/// The <c>QueryVirtualMemoryInformation</c> function returns information about a page or a set of pages within the virtual address
|
||
/// space of the specified process.
|
||
/// </summary>
|
||
/// <param name="Process">A handle for the process in whose context the pages to be queried reside.</param>
|
||
/// <param name="VirtualAddress">
|
||
/// The address of the region of pages to be queried. This value is rounded down to the next host-page-address boundary.
|
||
/// </param>
|
||
/// <param name="MemoryInformationClass">
|
||
/// The memory information class about which to retrieve information. The only supported value is <c>MemoryRegionInfo</c>.
|
||
/// </param>
|
||
/// <param name="MemoryInformation">
|
||
/// <para>A pointer to a buffer that receives the specified information.</para>
|
||
/// <para>
|
||
/// If the MemoryInformationClass parameter has a value of <c>MemoryRegionInfo</c>, this parameter must point to a
|
||
/// <c>WIN32_MEMORY_REGION_INFORMATION</c> structure.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="MemoryInformationSize">Specifies the length in bytes of the memory information buffer.</param>
|
||
/// <param name="ReturnSize">
|
||
/// An optional pointer which, if specified, receives the number of bytes placed in the memory information buffer.
|
||
/// </param>
|
||
/// <returns>Returns <c>TRUE</c> on success. Returns <c>FALSE</c> for failure. To get extended error information, call <c>GetLastError</c>.</returns>
|
||
// BOOL WINAPI QueryVirtualMemoryInformation( _In_ HANDLE Process, _In_ const VOID *VirtualAddress, _In_
|
||
// WIN32_MEMORY_INFORMATION_CLASS MemoryInformationClass, _Out_ _writes_bytes_(MemoryInformationSize) PVOID MemoryInformation, _In_
|
||
// SIZE_T MemoryInformationSize, _Out_opt_ PSIZE_T ReturnSize);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("MemoryApi.h", MSDNShortId = "mt845761")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool QueryVirtualMemoryInformation([In] HPROCESS Process, IntPtr VirtualAddress, WIN32_MEMORY_INFORMATION_CLASS MemoryInformationClass, IntPtr MemoryInformation, SizeT MemoryInformationSize, out SizeT ReturnSize);
|
||
|
||
/// <summary>
|
||
/// Reads data from an area of memory in a specified process. The entire area to be read must be accessible or the operation fails.
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process.
|
||
/// </param>
|
||
/// <param name="lpBaseAddress">
|
||
/// A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies
|
||
/// that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the
|
||
/// function fails.
|
||
/// </param>
|
||
/// <param name="lpBuffer">A pointer to a buffer that receives the contents from the address space of the specified process.</param>
|
||
/// <param name="nSize">The number of bytes to be read from the specified process.</param>
|
||
/// <param name="lpNumberOfBytesRead">
|
||
/// A pointer to a variable that receives the number of bytes transferred into the specified buffer. If lpNumberOfBytesRead is
|
||
/// <c>NULL</c>, the parameter is ignored.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// <para>The function fails if the requested read operation crosses into an area of the process that is inaccessible.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI ReadProcessMemory( _In_ HANDLE hProcess, _In_ LPCVOID lpBaseAddress, _Out_ LPVOID lpBuffer, _In_ SIZE_T nSize, _Out_
|
||
// SIZE_T *lpNumberOfBytesRead);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "ms680553")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool ReadProcessMemory([In] HPROCESS hProcess, [In] IntPtr lpBaseAddress, IntPtr lpBuffer, SizeT nSize, out SizeT lpNumberOfBytesRead);
|
||
|
||
/// <summary>
|
||
/// <para>Reclaims a range of memory pages that were offered to the system with <c>OfferVirtualMemory</c>.</para>
|
||
/// <para>
|
||
/// If the offered memory has been discarded, the contents of the memory region is undefined and must be rewritten by the
|
||
/// application. If the offered memory has not been discarded, it is reclaimed intact.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="VirtualAddress">Page-aligned starting address of the memory to reclaim.</param>
|
||
/// <param name="Size">Size, in bytes, of the memory region to reclaim. Size must be an integer multiple of the system page size.</param>
|
||
/// <returns>
|
||
/// <para>Returns ERROR_SUCCESS if successful and the memory was reclaimed intact.</para>
|
||
/// <para>
|
||
/// Returns ERROR_BUSY if successful but the memory was discarded and must be rewritten by the application. In this case, the
|
||
/// contents of the memory region is undefined.
|
||
/// </para>
|
||
/// <para>Returns a System Error Code otherwise.</para>
|
||
/// </returns>
|
||
// DWORD WINAPI ReclaimVirtualMemory( _In_ PVOID VirtualAddress, _In_ SIZE_T Size);
|
||
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "dn781437")]
|
||
public static extern uint ReclaimVirtualMemory(IntPtr VirtualAddress, SizeT Size);
|
||
|
||
/// <summary>
|
||
/// Registers a bad memory notification that is called when one or more bad memory pages are detected and the system cannot remove at
|
||
/// least one of them (for example if the pages contains modified data that has not yet been written to the pagefile.)
|
||
/// </summary>
|
||
/// <param name="Callback">A pointer to the application-defined BadMemoryCallbackRoutine function to register.</param>
|
||
/// <returns>
|
||
/// Registration handle that represents the callback notification. Can be passed to the <c>UnregisterBadMemoryNotification</c>
|
||
/// function when no longer needed.
|
||
/// </returns>
|
||
// PVOID WINAPI RegisterBadMemoryNotification( _In_ PBAD_MEMORY_CALLBACK_ROUTINE Callback);
|
||
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "hh691013")]
|
||
public static extern IntPtr RegisterBadMemoryNotification(BadMemoryCallbackRoutine Callback);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Resets the write-tracking state for a region of virtual memory. Subsequent calls to the <c>GetWriteWatch</c> function only report
|
||
/// pages that are written to since the reset operation.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>64-bit Windows on Itanium-based systems:</c> Due to the difference in page sizes, <c>ResetWriteWatch</c> is not supported for
|
||
/// 32-bit applications.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="lpBaseAddress">
|
||
/// <para>A pointer to the base address of the memory region for which to reset the write-tracking state.</para>
|
||
/// <para>This address must be in a memory region that is allocated by the <c>VirtualAlloc</c> function with <c>MEM_WRITE_WATCH</c>.</para>
|
||
/// </param>
|
||
/// <param name="dwRegionSize">The size of the memory region for which to reset the write-tracking information, in bytes.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is 0 (zero).</para>
|
||
/// <para>If the function fails, the return value is a nonzero value.</para>
|
||
/// </returns>
|
||
// UINT WINAPI ResetWriteWatch( _In_ LPVOID lpBaseAddress, _In_ SIZE_T dwRegionSize);
|
||
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366874")]
|
||
public static extern uint ResetWriteWatch([In] IntPtr lpBaseAddress, SizeT dwRegionSize);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Some information relates to pre-released product which may be substantially modified before it's commercially released.
|
||
/// Microsoft makes no warranties, express or implied, with respect to the information provided here.]
|
||
/// </para>
|
||
/// <para>
|
||
/// Provides CFG with a list of valid indirect call targets and specifies whether they should be marked valid or not. The valid call
|
||
/// target information is provided as a list of offsets relative to a virtual memory range(start and size of the range). The call
|
||
/// targets specified should be 16-byte aligned and in ascendingorder.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="hProcess">The handle to the target process.</param>
|
||
/// <param name="VirtualAddress">The start of the virtual memory region whose call targets are being marked valid.</param>
|
||
/// <param name="RegionSize">The size of the virtual memory region.</param>
|
||
/// <param name="NumberOfOffsets">The number of offsets relative to the virtual memory ranges.</param>
|
||
/// <param name="OffsetInformation">A list of offsets and flags relative to the virtual memory ranges.</param>
|
||
/// <returns>
|
||
/// <c>TRUE</c> if the operation was successful; otherwise, <c>FALSE</c>. To retrieve error values for this function, call <c>GetLastError</c>.
|
||
/// </returns>
|
||
// WINAPI SetProcessValidCallTargets( _In_ HANDLE hProcess, _In_ PVOID VirtualAddress, _In_ SIZE_T RegionSize, _In_ ULONG
|
||
// NumberOfOffsets, _Inout_ PCFG_CALL_TARGET_INFO OffsetInformation);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "dn934202")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool SetProcessValidCallTargets(HPROCESS hProcess, IntPtr VirtualAddress, SizeT RegionSize, uint NumberOfOffsets, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] CFG_CALL_TARGET_INFO[] OffsetInformation);
|
||
|
||
/// <summary>Sets the minimum and maximum working set sizes for the specified process.</summary>
|
||
/// <param name="hProcess">
|
||
/// <para>A handle to the process whose working set sizes is to be set.</para>
|
||
/// <para>The handle must have <c>PROCESS_SET_QUOTA</c> access rights. For more information, see Process Security and Access Rights.</para>
|
||
/// </param>
|
||
/// <param name="dwMinimumWorkingSetSize">
|
||
/// <para>
|
||
/// The minimum working set size for the process, in bytes. The virtual memory manager attempts to keep at least this much memory
|
||
/// resident in the process whenever the process is active.
|
||
/// </para>
|
||
/// <para>
|
||
/// This parameter must be greater than zero but less than or equal to the maximum working set size. The default size is 50 pages
|
||
/// (for example, this is 204,800 bytes on systems with a 4K page size). If the value is greater than zero but less than 20 pages,
|
||
/// the minimum value is set to 20 pages.
|
||
/// </para>
|
||
/// <para>
|
||
/// If both dwMinimumWorkingSetSize and dwMaximumWorkingSetSize have the value ( <c>SIZE_T</c>)–1, the function removes as many pages
|
||
/// as possible from the working set of the specified process.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwMaximumWorkingSetSize">
|
||
/// <para>
|
||
/// The maximum working set size for the process, in bytes. The virtual memory manager attempts to keep no more than this much memory
|
||
/// resident in the process whenever the process is active and available memory is low.
|
||
/// </para>
|
||
/// <para>
|
||
/// This parameter must be greater than or equal to 13 pages (for example, 53,248 on systems with a 4K page size), and less than the
|
||
/// system-wide maximum (number of available pages minus 512 pages). The default size is 345 pages (for example, this is 1,413,120
|
||
/// bytes on systems with a 4K page size).
|
||
/// </para>
|
||
/// <para>
|
||
/// If both dwMinimumWorkingSetSize and dwMaximumWorkingSetSize have the value ( <c>SIZE_T</c>)–1, the function removes as many pages
|
||
/// as possible from the working set of the specified process. For details, see Remarks.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="Flags">
|
||
/// <para>The flags that control the enforcement of the minimum and maximum working set sizes.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>QUOTA_LIMITS_HARDWS_MIN_DISABLE0x00000002</term>
|
||
/// <term>
|
||
/// The working set may fall below the minimum working set limit if memory demands are high.This flag cannot be used with QUOTA_LIMITS_HARDWS_MIN_ENABLE.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>QUOTA_LIMITS_HARDWS_MIN_ENABLE0x00000001</term>
|
||
/// <term>The working set will not fall below the minimum working set limit.This flag cannot be used with QUOTA_LIMITS_HARDWS_MIN_DISABLE.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>QUOTA_LIMITS_HARDWS_MAX_DISABLE0x00000008</term>
|
||
/// <term>The working set may exceed the maximum working set limit if there is abundant memory.This flag cannot be used with QUOTA_LIMITS_HARDWS_MAX_ENABLE.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>QUOTA_LIMITS_HARDWS_MAX_ENABLE0x00000004</term>
|
||
/// <term>The working set will not exceed the maximum working set limit.This flag cannot be used with QUOTA_LIMITS_HARDWS_MAX_DISABLE.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function is succeeds, the return value is nonzero.</para>
|
||
/// <para>
|
||
/// If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>. If the function
|
||
/// fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.
|
||
/// </para>
|
||
/// </returns>
|
||
// BOOL WINAPI SetProcessWorkingSetSizeEx( _In_ HANDLE hProcess, _In_ SIZE_T dwMinimumWorkingSetSize, _In_ SIZE_T
|
||
// dwMaximumWorkingSetSize, _In_ DWORD Flags);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "ms686237")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool SetProcessWorkingSetSizeEx([In] HPROCESS hProcess, SizeT dwMinimumWorkingSetSize, SizeT dwMaximumWorkingSetSize, QUOTA_LIMITS_HARDWS Flags);
|
||
|
||
/// <summary>Limits the size of the working set for the file system cache.</summary>
|
||
/// <param name="MinimumFileCacheSize">
|
||
/// <para>
|
||
/// The minimum size of the file cache, in bytes. The virtual memory manager attempts to keep at least this much memory resident in
|
||
/// the system file cache.
|
||
/// </para>
|
||
/// <para>To flush the cache, specify .</para>
|
||
/// </param>
|
||
/// <param name="MaximumFileCacheSize">
|
||
/// <para>
|
||
/// The maximum size of the file cache, in bytes. The virtual memory manager enforces this limit only if this call or a previous call
|
||
/// to <c>SetSystemFileCacheSize</c> specifies <c>FILE_CACHE_MAX_HARD_ENABLE</c>.
|
||
/// </para>
|
||
/// <para>To flush the cache, specify .</para>
|
||
/// </param>
|
||
/// <param name="Flags">
|
||
/// <para>
|
||
/// The flags that enable or disable the file cache limits. If this parameter is 0 (zero), the size limits retain the current
|
||
/// setting, which is either disabled or enabled.
|
||
/// </para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>FILE_CACHE_MAX_HARD_DISABLE0x2</term>
|
||
/// <term>Disable the maximum size limit.The FILE_CACHE_MAX_HARD_DISABLE and FILE_CACHE_MAX_HARD_ENABLE flags are mutually exclusive.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_CACHE_MAX_HARD_ENABLE0x1</term>
|
||
/// <term>Enable the maximum size limit.The FILE_CACHE_MAX_HARD_DISABLE and FILE_CACHE_MAX_HARD_ENABLE flags are mutually exclusive.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_CACHE_MIN_HARD_DISABLE0x8</term>
|
||
/// <term>Disable the minimum size limit.The FILE_CACHE_MIN_HARD_DISABLE and FILE_CACHE_MIN_HARD_ENABLE flags are mutually exclusive.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>FILE_CACHE_MIN_HARD_ENABLE0x4</term>
|
||
/// <term>Enable the minimum size limit.The FILE_CACHE_MIN_HARD_DISABLE and FILE_CACHE_MIN_HARD_ENABLE flags are mutually exclusive.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI SetSystemFileCacheSize( _In_ SIZE_T MinimumFileCacheSize, _In_ SIZE_T MaximumFileCacheSize, _In_ DWORD Flags);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa965240")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool SetSystemFileCacheSize(SizeT MinimumFileCacheSize, SizeT MaximumFileCacheSize, FILE_CACHE_LIMITS Flags);
|
||
|
||
/// <summary>Unmaps a mapped view of a file from the calling process's address space.</summary>
|
||
/// <param name="lpBaseAddress">
|
||
/// A pointer to the base address of the mapped view of a file that is to be unmapped. This value must be identical to the value
|
||
/// returned by a previous call to the <c>MapViewOfFile</c> or <c>MapViewOfFileEx</c> function.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI UnmapViewOfFile( _In_ LPCVOID lpBaseAddress);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366882")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool UnmapViewOfFile([In] IntPtr lpBaseAddress);
|
||
|
||
/// <summary>Unmaps a previously mapped view of a file or a pagefile-backed section.</summary>
|
||
/// <param name="ProcessHandle">A HANDLE to the process from which the section will be unmapped.</param>
|
||
/// <param name="BaseAddress">
|
||
/// The base address of a previously mapped view that is to be unmapped. This value must be identical to the value returned by a
|
||
/// previous call to MapViewOfFile2.
|
||
/// </param>
|
||
/// <param name="UnmapFlags">
|
||
/// MEM_UNMAP_WITH_TRANSIENT_BOOST (1) or zero (0). MEM_UNMAP_WITH_TRANSIENT_BOOST should be used if the pages backing this view
|
||
/// should be temporarily boosted (with automatic short term decay) because another thread will access them shortly.
|
||
/// </param>
|
||
/// <returns></returns>
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("MemoryApi.h", MSDNShortId = "mt492559")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool UnmapViewOfFile2([In] HPROCESS ProcessHandle, IntPtr BaseAddress, uint UnmapFlags);
|
||
|
||
/// <summary>This is an extended version of UnmapViewOfFile that takes an additional flags parameter.</summary>
|
||
/// <param name="BaseAddress">
|
||
/// A pointer to the base address of the mapped view of a file that is to be unmapped. This value must be identical to the value
|
||
/// returned by a previous call to the MapViewOfFile or MapViewOfFileEx function.
|
||
/// </param>
|
||
/// <param name="UnmapFlags">
|
||
/// The only supported flag is MEM_UNMAP_WITH_TRANSIENT_BOOST (0x1), which specifies that the priority of the pages being unmapped
|
||
/// should be temporarily boosted because the caller expects that these pages will be accessed again shortly. For more information
|
||
/// about memory priorities, see the SetThreadInformation(ThreadMemoryPriority) function.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("MemoryApi.h", MSDNShortId = "mt670639")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool UnmapViewOfFileEx(IntPtr BaseAddress, uint UnmapFlags);
|
||
|
||
/// <summary>Closes the specified bad memory notification handle.</summary>
|
||
/// <param name="RegistrationHandle">Registration handle returned from the <c>RegisterBadMemoryNotification</c> function.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI UnregisterBadMemoryNotification( _In_ PVOID RegistrationHandle);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "hh691014")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool UnregisterBadMemoryNotification(IntPtr RegistrationHandle);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Reserves, commits, or changes the state of a region of pages in the virtual address space of the calling process. Memory
|
||
/// allocated by this function is automatically initialized to zero.
|
||
/// </para>
|
||
/// <para>To allocate memory in the address space of another process, use the <c>VirtualAllocEx</c> function.</para>
|
||
/// </summary>
|
||
/// <param name="lpAddress">
|
||
/// <para>
|
||
/// The starting address of the region to allocate. If the memory is being reserved, the specified address is rounded down to the
|
||
/// nearest multiple of the allocation granularity. If the memory is already reserved and is being committed, the address is rounded
|
||
/// down to the next page boundary. To determine the size of a page and the allocation granularity on the host computer, use the
|
||
/// <c>GetSystemInfo</c> function. If this parameter is <c>NULL</c>, the system determines where to allocate the region.
|
||
/// </para>
|
||
/// <para>
|
||
/// If this address is within an enclave that you have not initialized by calling <c>InitializeEnclave</c>, <c>VirtualAlloc</c>
|
||
/// allocates a page of zeros for the enclave at that address. The page must be previously uncommitted, and will not be measured with
|
||
/// the EEXTEND instruction of the Intel Software Guard Extensions programming model.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the address in within an enclave that you initialized, then the allocation operation fails with the
|
||
/// <c>ERROR_INVALID_ADDRESS</c> error.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwSize">
|
||
/// The size of the region, in bytes. If the lpAddress parameter is <c>NULL</c>, this value is rounded up to the next page boundary.
|
||
/// Otherwise, the allocated pages include all pages containing one or more bytes in the range from lpAddress to lpAddress+dwSize.
|
||
/// This means that a 2-byte range straddling a page boundary causes both pages to be included in the allocated region.
|
||
/// </param>
|
||
/// <param name="flAllocationType">
|
||
/// <para>The type of memory allocation. This parameter must contain one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_COMMIT0x00001000</term>
|
||
/// <term>
|
||
/// Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved memory pages.
|
||
/// The function also guarantees that when the caller later initially accesses the memory, the contents will be zero. Actual physical
|
||
/// pages are not allocated unless/until the virtual addresses are actually accessed.To reserve and commit pages in one step, call
|
||
/// VirtualAlloc with .Attempting to commit a specific address range by specifying MEM_COMMIT without MEM_RESERVE and a non-NULL
|
||
/// lpAddress fails unless the entire range has already been reserved. The resulting error code is ERROR_INVALID_ADDRESS.An attempt
|
||
/// to commit a page that is already committed does not cause the function to fail. This means that you can commit pages without
|
||
/// first determining the current commitment state of each page.If lpAddress specifies an address within an enclave, flAllocationType
|
||
/// must be MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE0x00002000</term>
|
||
/// <term>
|
||
/// Reserves a range of the process's virtual address space without allocating any actual physical storage in memory or in the paging
|
||
/// file on disk.You can commit reserved pages in subsequent calls to the VirtualAlloc function. To reserve and commit pages in one
|
||
/// step, call VirtualAlloc with MEM_COMMIT | MEM_RESERVE.Other memory allocation functions, such as malloc and LocalAlloc, cannot
|
||
/// use a reserved range of memory until it is released.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET0x00080000</term>
|
||
/// <term>
|
||
/// Indicates that data in the memory range specified by lpAddress and dwSize is no longer of interest. The pages should not be read
|
||
/// from or written to the paging file. However, the memory block will be used again later, so it should not be decommitted. This
|
||
/// value cannot be used with any other value.Using this value does not guarantee that the range operated on with MEM_RESET will
|
||
/// contain zeros. If you want the range to contain zeros, decommit the memory and then recommit it.When you specify MEM_RESET, the
|
||
/// VirtualAlloc function ignores the value of flProtect. However, you must still set flProtect to a valid protection value, such as
|
||
/// PAGE_NOACCESS.VirtualAlloc returns an error if you use MEM_RESET and the range of memory is mapped to a file. A shared view is
|
||
/// only acceptable if it is mapped to a paging file.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET_UNDO0x1000000</term>
|
||
/// <term>
|
||
/// MEM_RESET_UNDO should only be called on an address range to which MEM_RESET was successfully applied earlier. It indicates that
|
||
/// the data in the specified memory range specified by lpAddress and dwSize is of interest to the caller and attempts to reverse the
|
||
/// effects of MEM_RESET. If the function succeeds, that means all data in the specified address range is intact. If the function
|
||
/// fails, at least some of the data in the address range has been replaced with zeroes.This value cannot be used with any other
|
||
/// value. If MEM_RESET_UNDO is called on an address range which was not MEM_RESET earlier, the behavior is undefined. When you
|
||
/// specify MEM_RESET, the VirtualAlloc function ignores the value of flProtect. However, you must still set flProtect to a valid
|
||
/// protection value, such as PAGE_NOACCESS.Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server
|
||
/// 2003 and Windows XP: The MEM_RESET_UNDO flag is not supported until Windows 8 and Windows Server 2012.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>This parameter can also specify the following values as indicated.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_LARGE_PAGES0x20000000</term>
|
||
/// <term>
|
||
/// Allocates memory using large page support.The size and alignment must be a multiple of the large-page minimum. To obtain this
|
||
/// value, use the GetLargePageMinimum function.If you specify this value, you must also specify MEM_RESERVE and MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_PHYSICAL0x00400000</term>
|
||
/// <term>
|
||
/// Reserves an address range that can be used to map Address Windowing Extensions (AWE) pages.This value must be used with
|
||
/// MEM_RESERVE and no other values.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_TOP_DOWN0x00100000</term>
|
||
/// <term>
|
||
/// Allocates memory at the highest possible address. This can be slower than regular allocations, especially when there are many allocations.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_WRITE_WATCH0x00200000</term>
|
||
/// <term>
|
||
/// Causes the system to track pages that are written to in the allocated region. If you specify this value, you must also specify
|
||
/// MEM_RESERVE.To retrieve the addresses of the pages that have been written to since the region was allocated or the write-tracking
|
||
/// state was reset, call the GetWriteWatch function. To reset the write-tracking state, call GetWriteWatch or ResetWriteWatch. The
|
||
/// write-tracking feature remains enabled for the memory region until the region is freed.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="flProtect">
|
||
/// <para>
|
||
/// The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify any one of the
|
||
/// memory protection constants.
|
||
/// </para>
|
||
/// <para>If lpAddress specifies an address within an enclave, flProtect cannot be any of the following values:</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the base address of the allocated region of pages.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// LPVOID WINAPI VirtualAlloc( _In_opt_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD flAllocationType, _In_ DWORD flProtect);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366887")]
|
||
public static extern IntPtr VirtualAlloc([In] IntPtr lpAddress, SizeT dwSize, MEM_ALLOCATION_TYPE flAllocationType, MEM_PROTECTION flProtect);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Reserves, commits, or changes the state of a region of memory within the virtual address space of a specified process. The
|
||
/// function initializes the memory it allocates to zero.
|
||
/// </para>
|
||
/// <para>
|
||
/// Using this function, you can: for new allocations, specify a range of virtual address space and a power-of-2 alignment
|
||
/// restriction; specify an arbitrary number of extended parameters; specify a preferred NUMA node for the physical memory as an
|
||
/// extended parameter; and specify a placeholder operation (specifically, replacement).
|
||
/// </para>
|
||
/// <para>To specify the NUMA node, see the ExtendedParameters parameter.</para>
|
||
/// </summary>
|
||
/// <param name="Process">
|
||
/// <para>The handle to a process. The function allocates memory within the virtual address space of this process.</para>
|
||
/// <para>
|
||
/// The handle must have the <c>PROCESS_VM_OPERATION</c> access right. For more information, see Process Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="BaseAddress">
|
||
/// <para>The pointer that specifies a desired starting address for the region of pages that you want to allocate.</para>
|
||
/// <para>
|
||
/// If an explicit base address is specified, then it must be a multiple of the system allocation granularity. To determine the size
|
||
/// of a page and the allocation granularity on the host computer, use the GetSystemInfo function.
|
||
/// </para>
|
||
/// <para>If BaseAddress is <c>NULL</c>, the function determines where to allocate the region.</para>
|
||
/// <para>
|
||
/// If this address is within an enclave that you have not initialized by calling InitializeEnclave, <c>VirtualAlloc2</c> allocates a
|
||
/// page of zeros for the enclave at that address. The page must be previously uncommitted, and will not be measured with the EEXTEND
|
||
/// instruction of the Intel Software Guard Extensions programming model.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the address in within an enclave that you initialized, then the allocation operation fails with the
|
||
/// <c>ERROR_INVALID_ADDRESS</c> error.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="Size">
|
||
/// <para>The size of the region of memory to allocate, in bytes.</para>
|
||
/// <para>The size must always be a multiple of the page size.</para>
|
||
/// <para>
|
||
/// If BaseAddress is not <c>NULL</c>, the function allocates all pages that contain one or more bytes in the range from BaseAddress
|
||
/// to BaseAddress+Size. This means, for example, that a 2-byte range that straddles a page boundary causes the function to allocate
|
||
/// both pages.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="AllocationType">
|
||
/// <para>The type of memory allocation. This parameter must contain one of the following values.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_COMMIT 0x00001000</term>
|
||
/// <term>
|
||
/// Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved memory pages.
|
||
/// The function also guarantees that when the caller later initially accesses the memory, the contents will be zero. Actual physical
|
||
/// pages are not allocated unless/until the virtual addresses are actually accessed. To reserve and commit pages in one step, call
|
||
/// VirtualAlloc2 with . Attempting to commit a specific address range by specifying MEM_COMMIT without MEM_RESERVE and a non-NULL
|
||
/// BaseAddress fails unless the entire range has already been reserved. The resulting error code is ERROR_INVALID_ADDRESS. An
|
||
/// attempt to commit a page that is already committed does not cause the function to fail. This means that you can commit pages
|
||
/// without first determining the current commitment state of each page. If BaseAddress specifies an address within an enclave,
|
||
/// AllocationType must be MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE 0x00002000</term>
|
||
/// <term>
|
||
/// Reserves a range of the process's virtual address space without allocating any actual physical storage in memory or in the paging
|
||
/// file on disk. You commit reserved pages by calling VirtualAlloc2 again with MEM_COMMIT. To reserve and commit pages in one step,
|
||
/// call VirtualAlloc2 with . Other memory allocation functions, such as malloc and LocalAlloc, cannot use reserved memory until it
|
||
/// has been released.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_REPLACE_PLACEHOLDER 0x00004000</term>
|
||
/// <term>
|
||
/// Replaces a placeholder with a normal private allocation. Only data/pf-backed section views are supported (no images, physical
|
||
/// memory, etc.). When you replace a placeholder, BaseAddress and Size must exactly match those of the placeholder. After you
|
||
/// replace a placeholder with a private allocation, to free that allocation back to a placeholder, see the dwFreeType parameter of
|
||
/// VirtualFree and VirtualFreeEx. A placeholder is a type of reserved memory region.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE_PLACEHOLDER 0x00040000</term>
|
||
/// <term>
|
||
/// To create a placeholder, call VirtualAlloc2 with and PageProtection set to PAGE_NOACCESS. To free/split/coalesce a placeholder,
|
||
/// see the dwFreeType parameter of VirtualFree and VirtualFreeEx. A placeholder is a type of reserved memory region.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET 0x00080000</term>
|
||
/// <term>
|
||
/// Indicates that data in the memory range specified by BaseAddress and Size is no longer of interest. The pages should not be read
|
||
/// from or written to the paging file. However, the memory block will be used again later, so it should not be decommitted. This
|
||
/// value cannot be used with any other value. Using this value does not guarantee that the range operated on with MEM_RESET will
|
||
/// contain zeros. If you want the range to contain zeros, decommit the memory and then recommit it. When you use MEM_RESET, the
|
||
/// VirtualAlloc2 function ignores the value of fProtect. However, you must still set fProtect to a valid protection value, such as
|
||
/// PAGE_NOACCESS. VirtualAlloc2 returns an error if you use MEM_RESET and the range of memory is mapped to a file. A shared view is
|
||
/// only acceptable if it is mapped to a paging file.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET_UNDO 0x1000000</term>
|
||
/// <term>
|
||
/// MEM_RESET_UNDO should only be called on an address range to which MEM_RESET was successfully applied earlier. It indicates that
|
||
/// the data in the specified memory range specified by BaseAddress and Size is of interest to the caller and attempts to reverse the
|
||
/// effects of MEM_RESET. If the function succeeds, that means all data in the specified address range is intact. If the function
|
||
/// fails, at least some of the data in the address range has been replaced with zeroes. This value cannot be used with any other
|
||
/// value. If MEM_RESET_UNDO is called on an address range which was not MEM_RESET earlier, the behavior is undefined. When you
|
||
/// specify MEM_RESET, the VirtualAlloc2 function ignores the value of PageProtection. However, you must still set PageProtection to
|
||
/// a valid protection value, such as PAGE_NOACCESS. Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows
|
||
/// Server 2003 and Windows XP: The MEM_RESET_UNDO flag is not supported until Windows 8 and Windows Server 2012.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>This parameter can also specify the following values as indicated.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_LARGE_PAGES 0x20000000</term>
|
||
/// <term>
|
||
/// Allocates memory using large page support. The size and alignment must be a multiple of the large-page minimum. To obtain this
|
||
/// value, use the GetLargePageMinimum function. If you specify this value, you must also specify MEM_RESERVE and MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_PHYSICAL 0x00400000</term>
|
||
/// <term>
|
||
/// Reserves an address range that can be used to map Address Windowing Extensions (AWE) pages. This value must be used with
|
||
/// MEM_RESERVE and no other values.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_TOP_DOWN 0x00100000</term>
|
||
/// <term>
|
||
/// Allocates memory at the highest possible address. This can be slower than regular allocations, especially when there are many allocations.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="PageProtection">
|
||
/// <para>
|
||
/// The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify any one of the
|
||
/// memory protection constants.
|
||
/// </para>
|
||
/// <para>If BaseAddress specifies an address within an enclave, PageProtection cannot be any of the following values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>PAGE_NOACCESS</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_GUARD</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_NOCACHE</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAGE_WRITECOMBINE</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="ExtendedParameters">
|
||
/// <para>
|
||
/// An optional pointer to one or more extended parameters of type MEM_EXTENDED_PARAMETER. Each of those extended parameter values
|
||
/// can itself have a Type field of either <c>MemExtendedParameterAddressRequirements</c> or <c>MemExtendedParameterNumaNode</c>. If
|
||
/// no <c>MemExtendedParameterNumaNode</c> extended parameter is provided, then the behavior is the same as for the
|
||
/// VirtualAlloc/MapViewOfFile functions (that is, the preferred NUMA node for the physical pages is determined based on the ideal
|
||
/// processor of the thread that first accesses the memory).
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="ParameterCount">
|
||
/// <para>The number of extended parameters pointed to by ExtendedParameters.</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the base address of the allocated region of pages.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This API helps support high-performance games, and server applications, which have particular requirements around managing their
|
||
/// virtual address space. For example, mapping memory on top of a previously reserved region; this is useful for implementing an
|
||
/// automatically wrapping ring buffer. And allocating memory with specific alignment; for example, to enable your application to
|
||
/// commit large/huge page-mapped regions on demand.
|
||
/// </para>
|
||
/// <para>Each page has an associated page state. The <c>VirtualAlloc2</c> function can perform the following operations:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>Commit a region of reserved pages</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Reserve a region of free pages</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Simultaneously reserve and commit a region of free pages</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>
|
||
/// <c>VirtualAlloc2</c> cannot reserve a reserved page. It can commit a page that is already committed. This means you can commit a
|
||
/// range of pages, regardless of whether they have already been committed, and the function will not fail.
|
||
/// </para>
|
||
/// <para>
|
||
/// You can use <c>VirtualAlloc2</c> to reserve a block of pages and then make additional calls to <c>VirtualAlloc2</c> to commit
|
||
/// individual pages from the reserved block. This enables a process to reserve a range of its virtual address space without
|
||
/// consuming physical storage until it is needed.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the lpAddress parameter is not <c>NULL</c>, the function uses the lpAddress and dwSize parameters to compute the region of
|
||
/// pages to be allocated. The current state of the entire range of pages must be compatible with the type of allocation specified by
|
||
/// the flAllocationType parameter. Otherwise, the function fails and none of the pages is allocated. This compatibility requirement
|
||
/// does not preclude committing an already committed page; see the preceding list.
|
||
/// </para>
|
||
/// <para>
|
||
/// To execute dynamically generated code, use <c>VirtualAlloc2</c> to allocate memory, and the VirtualProtectEx function to grant
|
||
/// <c>PAGE_EXECUTE</c> access.
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>VirtualAlloc2</c> function can be used to reserve an Address Windowing Extensions (AWE) region of memory within the
|
||
/// virtual address space of a specified process. This region of memory can then be used to map physical pages into and out of
|
||
/// virtual memory as required by the application. The <c>MEM_PHYSICAL</c> and <c>MEM_RESERVE</c> values must be set in the
|
||
/// AllocationType parameter. The <c>MEM_COMMIT</c> value must not be set. The page protection must be set to <c>PAGE_READWRITE</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// The VirtualFreeEx function can decommit a committed page, releasing the page's storage, or it can simultaneously decommit and
|
||
/// release a committed page. It can also release a reserved page, making it a free page.
|
||
/// </para>
|
||
/// <para>
|
||
/// When creating a region that will be executable, the calling program bears responsibility for ensuring cache coherency via an
|
||
/// appropriate call to FlushInstructionCache once the code has been set in place. Otherwise attempts to execute code out of the
|
||
/// newly executable region may produce unpredictable results.
|
||
/// </para>
|
||
/// <para>Examples</para>
|
||
/// <para>Scenario 1. Create a circular buffer by mapping two adjacent views of the same shared memory section.</para>
|
||
/// <para>Scenario 2. Specify a preferred NUMA node when allocating memory.</para>
|
||
/// <para>Scenario 3. Allocate memory in a specific virtual address range (below 4GB, in this example) and with specific alignment.</para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/memoryapi/nf-memoryapi-virtualalloc2 PVOID VirtualAlloc2( HANDLE Process,
|
||
// PVOID BaseAddress, SIZE_T Size, ULONG AllocationType, ULONG PageProtection, MEM_EXTENDED_PARAMETER *ExtendedParameters, ULONG
|
||
// ParameterCount );
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("memoryapi.h", MSDNShortId = "5021062F-E414-49A1-8B70-BE2A57A90E54")]
|
||
public static extern IntPtr VirtualAlloc2(SafeHANDLE Process, IntPtr BaseAddress, SizeT Size, MEM_ALLOCATION_TYPE AllocationType, MEM_PROTECTION PageProtection, MEM_EXTENDED_PARAMETER[] ExtendedParameters, uint ParameterCount);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Reserves, commits, or changes the state of a region of pages in the virtual address space of the calling process. Memory
|
||
/// allocated by this function is automatically initialized to zero.
|
||
/// </para>
|
||
/// <para>
|
||
/// Using this function, you can: for new allocations, specify a range of virtual address space and a power-of-2 alignment
|
||
/// restriction; specify an arbitrary number of extended parameters; specify a preferred NUMA node for the physical memory as an
|
||
/// extended parameter; and specify a placeholder operation (specifically, replacement).
|
||
/// </para>
|
||
/// <para>To specify the NUMA node, see the ExtendedParameters parameter.</para>
|
||
/// </summary>
|
||
/// <param name="Process">
|
||
/// <para>The handle to a process. The function allocates memory within the virtual address space of this process.</para>
|
||
/// <para>
|
||
/// The handle must have the <c>PROCESS_VM_OPERATION</c> access right. For more information, see Process Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="BaseAddress">
|
||
/// <para>The pointer that specifies a desired starting address for the region of pages that you want to allocate.</para>
|
||
/// <para>
|
||
/// If an explicit base address is specified, then it must be a multiple of the system allocation granularity. To determine the size
|
||
/// of a page and the allocation granularity on the host computer, use the GetSystemInfo function.
|
||
/// </para>
|
||
/// <para>If BaseAddress is <c>NULL</c>, the function determines where to allocate the region.</para>
|
||
/// </param>
|
||
/// <param name="Size">
|
||
/// <para>The size of the region of memory to allocate, in bytes.</para>
|
||
/// <para>The size must always be a multiple of the page size.</para>
|
||
/// <para>
|
||
/// If BaseAddress is not <c>NULL</c>, the function allocates all pages that contain one or more bytes in the range from BaseAddress
|
||
/// to BaseAddress+Size. This means, for example, that a 2-byte range that straddles a page boundary causes the function to allocate
|
||
/// both pages.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="AllocationType">
|
||
/// <para>The type of memory allocation. This parameter must contain one of the following values.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_COMMIT 0x00001000</term>
|
||
/// <term>
|
||
/// Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved memory pages.
|
||
/// The function also guarantees that when the caller later initially accesses the memory, the contents will be zero. Actual physical
|
||
/// pages are not allocated unless/until the virtual addresses are actually accessed. To reserve and commit pages in one step, call
|
||
/// Virtual2AllocFromApp with . Attempting to commit a specific address range by specifying MEM_COMMIT without MEM_RESERVE and a
|
||
/// non-NULL BaseAddress fails unless the entire range has already been reserved. The resulting error code is ERROR_INVALID_ADDRESS.
|
||
/// An attempt to commit a page that is already committed does not cause the function to fail. This means that you can commit pages
|
||
/// without first determining the current commitment state of each page.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE 0x00002000</term>
|
||
/// <term>
|
||
/// Reserves a range of the process's virtual address space without allocating any actual physical storage in memory or in the paging
|
||
/// file on disk. You can commit reserved pages in subsequent calls to the Virtual2AllocFromApp function. To reserve and commit pages
|
||
/// in one step, call Virtual2AllocFromApp with MEM_COMMIT | MEM_RESERVE. Other memory allocation functions, such as malloc and
|
||
/// LocalAlloc, cannot use a reserved range of memory until it is released.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_REPLACE_PLACEHOLDER 0x00004000</term>
|
||
/// <term>
|
||
/// Replaces a placeholder with a normal private allocation. Only data/pf-backed section views are supported (no images, physical
|
||
/// memory, etc.). When you replace a placeholder, BaseAddress and Size must exactly match those of the placeholder. After you
|
||
/// replace a placeholder with a private allocation, to free that allocation back to a placeholder, see the dwFreeType parameter of
|
||
/// VirtualFree and VirtualFreeEx. A placeholder is a type of reserved memory region.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE_PLACEHOLDER 0x00040000</term>
|
||
/// <term>
|
||
/// To create a placeholder, call VirtualAlloc2 with and PageProtection set to PAGE_NOACCESS. To free/split/coalesce a placeholder,
|
||
/// see the dwFreeType parameter of VirtualFree and VirtualFreeEx. A placeholder is a type of reserved memory region.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET 0x00080000</term>
|
||
/// <term>
|
||
/// Indicates that data in the memory range specified by BaseAddress and Size is no longer of interest. The pages should not be read
|
||
/// from or written to the paging file. However, the memory block will be used again later, so it should not be decommitted. This
|
||
/// value cannot be used with any other value. Using this value does not guarantee that the range operated on with MEM_RESET will
|
||
/// contain zeros. If you want the range to contain zeros, decommit the memory and then recommit it. When you specify MEM_RESET, the
|
||
/// Virtual2AllocFromApp function ignores the value of Protection. However, you must still set Protection to a valid protection
|
||
/// value, such as PAGE_NOACCESS. Virtual2AllocFromApp returns an error if you use MEM_RESET and the range of memory is mapped to a
|
||
/// file. A shared view is only acceptable if it is mapped to a paging file.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET_UNDO 0x1000000</term>
|
||
/// <term>
|
||
/// MEM_RESET_UNDO should only be called on an address range to which MEM_RESET was successfully applied earlier. It indicates that
|
||
/// the data in the specified memory range specified by BaseAddress and Size is of interest to the caller and attempts to reverse the
|
||
/// effects of MEM_RESET. If the function succeeds, that means all data in the specified address range is intact. If the function
|
||
/// fails, at least some of the data in the address range has been replaced with zeroes. This value cannot be used with any other
|
||
/// value. If MEM_RESET_UNDO is called on an address range which was not MEM_RESET earlier, the behavior is undefined. When you
|
||
/// specify MEM_RESET, the Virtual2AllocFromApp function ignores the value of Protection. However, you must still set Protection to a
|
||
/// valid protection value, such as PAGE_NOACCESS.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>This parameter can also specify the following values as indicated.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_LARGE_PAGES 0x20000000</term>
|
||
/// <term>
|
||
/// Allocates memory using large page support. The size and alignment must be a multiple of the large-page minimum. To obtain this
|
||
/// value, use the GetLargePageMinimum function. If you specify this value, you must also specify MEM_RESERVE and MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_PHYSICAL 0x00400000</term>
|
||
/// <term>
|
||
/// Reserves an address range that can be used to map Address Windowing Extensions (AWE) pages. This value must be used with
|
||
/// MEM_RESERVE and no other values.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_TOP_DOWN 0x00100000</term>
|
||
/// <term>
|
||
/// Allocates memory at the highest possible address. This can be slower than regular allocations, especially when there are many allocations.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_WRITE_WATCH 0x00200000</term>
|
||
/// <term>
|
||
/// Causes the system to track pages that are written to in the allocated region. If you specify this value, you must also specify
|
||
/// MEM_RESERVE. To retrieve the addresses of the pages that have been written to since the region was allocated or the
|
||
/// write-tracking state was reset, call the GetWriteWatch function. To reset the write-tracking state, call GetWriteWatch or
|
||
/// ResetWriteWatch. The write-tracking feature remains enabled for the memory region until the region is freed.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="PageProtection">
|
||
/// <para>
|
||
/// The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify one of the
|
||
/// memory protection constants. The following constants generate an error:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>PAGE_EXECUTE</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PAGE_EXECUTE_READ</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PAGE_EXECUTE_READWRITE</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PAGE_EXECUTE_WRITECOPY</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="ExtendedParameters">
|
||
/// <para>
|
||
/// An optional pointer to one or more extended parameters of type MEM_EXTENDED_PARAMETER. Each of those extended parameter values
|
||
/// can itself have a Type field of either <c>MemExtendedParameterAddressRequirements</c> or <c>MemExtendedParameterNumaNode</c>. If
|
||
/// no <c>MemExtendedParameterNumaNode</c> extended parameter is provided, then the behavior is the same as for the
|
||
/// VirtualAlloc/MapViewOfFile functions (that is, the preferred NUMA node for the physical pages is determined based on the ideal
|
||
/// processor of the thread that first accesses the memory).
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="ParameterCount">
|
||
/// <para>The number of extended parameters pointed to by ExtendedParameters.</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the base address of the allocated region of pages.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This API helps support high-performance games, and server applications, which have particular requirements around managing their
|
||
/// virtual address space. For example, mapping memory on top of a previously reserved region; this is useful for implementing an
|
||
/// automatically wrapping ring buffer. And allocating memory with specific alignment; for example, to enable your application to
|
||
/// commit large/huge page-mapped regions on demand.
|
||
/// </para>
|
||
/// <para>
|
||
/// You can call <c>Virtual2AllocFromApp</c> from Windows Store apps with just-in-time (JIT) capabilities to use JIT functionality.
|
||
/// The app must include the <c>codeGeneration</c> capability in the app manifest file to use JIT capabilities.
|
||
/// </para>
|
||
/// <para>Each page has an associated page state. The <c>Virtual2AllocFromApp</c> function can perform the following operations:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>Commit a region of reserved pages</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Reserve a region of free pages</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Simultaneously reserve and commit a region of free pages</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>
|
||
/// <c>Virtual2AllocFromApp</c> cannot reserve a reserved page. It can commit a page that is already committed. This means you can
|
||
/// commit a range of pages, regardless of whether they have already been committed, and the function will not fail.
|
||
/// </para>
|
||
/// <para>
|
||
/// You can use <c>Virtual2AllocFromApp</c> to reserve a block of pages and then make additional calls to <c>Virtual2AllocFromApp</c>
|
||
/// to commit individual pages from the reserved block. This enables a process to reserve a range of its virtual address space
|
||
/// without consuming physical storage until it is needed.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the BaseAddress parameter is not <c>NULL</c>, the function uses the BaseAddress and Size parameters to compute the region of
|
||
/// pages to be allocated. The current state of the entire range of pages must be compatible with the type of allocation specified by
|
||
/// the AllocationType parameter. Otherwise, the function fails and none of the pages are allocated. This compatibility requirement
|
||
/// does not preclude committing an already committed page, as mentioned previously.
|
||
/// </para>
|
||
/// <para><c>Virtual2AllocFromApp</c> does not allow the creation of executable pages.</para>
|
||
/// <para>
|
||
/// The <c>Virtual2AllocFromApp</c> function can be used to reserve an Address Windowing Extensions (AWE) region of memory within the
|
||
/// virtual address space of a specified process. This region of memory can then be used to map physical pages into and out of
|
||
/// virtual memory as required by the application. The <c>MEM_PHYSICAL</c> and <c>MEM_RESERVE</c> values must be set in the
|
||
/// AllocationType parameter. The <c>MEM_COMMIT</c> value must not be set. The page protection must be set to <c>PAGE_READWRITE</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// The VirtualFree function can decommit a committed page, releasing the page's storage, or it can simultaneously decommit and
|
||
/// release a committed page. It can also release a reserved page, making it a free page.
|
||
/// </para>
|
||
/// <para>
|
||
/// When creating a region that will be executable, the calling program bears responsibility for ensuring cache coherency via an
|
||
/// appropriate call to FlushInstructionCache once the code has been set in place. Otherwise attempts to execute code out of the
|
||
/// newly executable region may produce unpredictable results.
|
||
/// </para>
|
||
/// <para>Examples</para>
|
||
/// <para>For code examples, see Virtual2Alloc.</para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/memoryapi/nf-memoryapi-virtualalloc2fromapp PVOID VirtualAlloc2FromApp(
|
||
// HANDLE Process, PVOID BaseAddress, SIZE_T Size, ULONG AllocationType, ULONG PageProtection, MEM_EXTENDED_PARAMETER
|
||
// *ExtendedParameters, ULONG ParameterCount );
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("memoryapi.h", MSDNShortId = "84896A75-A917-4CA1-A417-650428E1FBFD")]
|
||
public static extern IntPtr VirtualAlloc2FromApp(SafeHANDLE Process, IntPtr BaseAddress, SizeT Size, MEM_ALLOCATION_TYPE AllocationType, MEM_PROTECTION PageProtection, MEM_EXTENDED_PARAMETER[] ExtendedParameters, uint ParameterCount);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Reserves, commits, or changes the state of a region of memory within the virtual address space of a specified process. The
|
||
/// function initializes the memory it allocates to zero.
|
||
/// </para>
|
||
/// <para>To specify the NUMA node for the physical memory, see <c>VirtualAllocExNuma</c>.</para>
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// <para>The handle to a process. The function allocates memory within the virtual address space of this process.</para>
|
||
/// <para>
|
||
/// The handle must have the <c>PROCESS_VM_OPERATION</c> access right. For more information, see Process Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpAddress">
|
||
/// <para>The pointer that specifies a desired starting address for the region of pages that you want to allocate.</para>
|
||
/// <para>If you are reserving memory, the function rounds this address down to the nearest multiple of the allocation granularity.</para>
|
||
/// <para>
|
||
/// If you are committing memory that is already reserved, the function rounds this address down to the nearest page boundary. To
|
||
/// determine the size of a page and the allocation granularity on the host computer, use the <c>GetSystemInfo</c> function.
|
||
/// </para>
|
||
/// <para>If lpAddress is <c>NULL</c>, the function determines where to allocate the region.</para>
|
||
/// <para>
|
||
/// If this address is within an enclave that you have not initialized by calling <c>InitializeEnclave</c>, <c>VirtualAllocEx</c>
|
||
/// allocates a page of zeros for the enclave at that address. The page must be previously uncommitted, and will not be measured with
|
||
/// the EEXTEND instruction of the Intel Software Guard Extensions programming model.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the address in within an enclave that you initialized, then the allocation operation fails with the
|
||
/// <c>ERROR_INVALID_ADDRESS</c> error.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwSize">
|
||
/// <para>The size of the region of memory to allocate, in bytes.</para>
|
||
/// <para>If lpAddress is <c>NULL</c>, the function rounds dwSize up to the next page boundary.</para>
|
||
/// <para>
|
||
/// If lpAddress is not <c>NULL</c>, the function allocates all pages that contain one or more bytes in the range from lpAddress to
|
||
/// lpAddress+dwSize. This means, for example, that a 2-byte range that straddles a page boundary causes the function to allocate
|
||
/// both pages.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="flAllocationType">
|
||
/// <para>The type of memory allocation. This parameter must contain one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_COMMIT0x00001000</term>
|
||
/// <term>
|
||
/// Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved memory pages.
|
||
/// The function also guarantees that when the caller later initially accesses the memory, the contents will be zero. Actual physical
|
||
/// pages are not allocated unless/until the virtual addresses are actually accessed.To reserve and commit pages in one step, call
|
||
/// VirtualAllocEx with .Attempting to commit a specific address range by specifying MEM_COMMIT without MEM_RESERVE and a non-NULL
|
||
/// lpAddress fails unless the entire range has already been reserved. The resulting error code is ERROR_INVALID_ADDRESS.An attempt
|
||
/// to commit a page that is already committed does not cause the function to fail. This means that you can commit pages without
|
||
/// first determining the current commitment state of each page.If lpAddress specifies an address within an enclave, flAllocationType
|
||
/// must be MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE0x00002000</term>
|
||
/// <term>
|
||
/// Reserves a range of the process's virtual address space without allocating any actual physical storage in memory or in the paging
|
||
/// file on disk.You commit reserved pages by calling VirtualAllocEx again with MEM_COMMIT. To reserve and commit pages in one step,
|
||
/// call VirtualAllocEx with .Other memory allocation functions, such as malloc and LocalAlloc, cannot use reserved memory until it
|
||
/// has been released.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET0x00080000</term>
|
||
/// <term>
|
||
/// Indicates that data in the memory range specified by lpAddress and dwSize is no longer of interest. The pages should not be read
|
||
/// from or written to the paging file. However, the memory block will be used again later, so it should not be decommitted. This
|
||
/// value cannot be used with any other value.Using this value does not guarantee that the range operated on with MEM_RESET will
|
||
/// contain zeros. If you want the range to contain zeros, decommit the memory and then recommit it.When you use MEM_RESET, the
|
||
/// VirtualAllocEx function ignores the value of fProtect. However, you must still set fProtect to a valid protection value, such as
|
||
/// PAGE_NOACCESS.VirtualAllocEx returns an error if you use MEM_RESET and the range of memory is mapped to a file. A shared view is
|
||
/// only acceptable if it is mapped to a paging file.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET_UNDO0x1000000</term>
|
||
/// <term>
|
||
/// MEM_RESET_UNDO should only be called on an address range to which MEM_RESET was successfully applied earlier. It indicates that
|
||
/// the data in the specified memory range specified by lpAddress and dwSize is of interest to the caller and attempts to reverse the
|
||
/// effects of MEM_RESET. If the function succeeds, that means all data in the specified address range is intact. If the function
|
||
/// fails, at least some of the data in the address range has been replaced with zeroes.This value cannot be used with any other
|
||
/// value. If MEM_RESET_UNDO is called on an address range which was not MEM_RESET earlier, the behavior is undefined. When you
|
||
/// specify MEM_RESET, the VirtualAllocEx function ignores the value of flProtect. However, you must still set flProtect to a valid
|
||
/// protection value, such as PAGE_NOACCESS.Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server
|
||
/// 2003 and Windows XP: The MEM_RESET_UNDO flag is not supported until Windows 8 and Windows Server 2012.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>This parameter can also specify the following values as indicated.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_LARGE_PAGES0x20000000</term>
|
||
/// <term>
|
||
/// Allocates memory using large page support.The size and alignment must be a multiple of the large-page minimum. To obtain this
|
||
/// value, use the GetLargePageMinimum function.If you specify this value, you must also specify MEM_RESERVE and MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_PHYSICAL0x00400000</term>
|
||
/// <term>
|
||
/// Reserves an address range that can be used to map Address Windowing Extensions (AWE) pages.This value must be used with
|
||
/// MEM_RESERVE and no other values.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_TOP_DOWN0x00100000</term>
|
||
/// <term>
|
||
/// Allocates memory at the highest possible address. This can be slower than regular allocations, especially when there are many allocations.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="flProtect">
|
||
/// <para>
|
||
/// The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify any one of the
|
||
/// memory protection constants.
|
||
/// </para>
|
||
/// <para>If lpAddress specifies an address within an enclave, flProtect cannot be any of the following values:</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the base address of the allocated region of pages.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// LPVOID WINAPI VirtualAllocEx( _In_ HANDLE hProcess, _In_opt_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD flAllocationType,
|
||
// _In_ DWORD flProtect);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366890")]
|
||
public static extern IntPtr VirtualAllocEx([In] HPROCESS hProcess, [In] IntPtr lpAddress, SizeT dwSize, MEM_ALLOCATION_TYPE flAllocationType, MEM_PROTECTION flProtect);
|
||
|
||
/// <summary>
|
||
/// Reserves, commits, or changes the state of a region of memory within the virtual address space of the specified process, and
|
||
/// specifies the NUMA node for the physical memory.
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// <para>The handle to a process. The function allocates memory within the virtual address space of this process.</para>
|
||
/// <para>
|
||
/// The handle must have the <c>PROCESS_VM_OPERATION</c> access right. For more information, see Process Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpAddress">
|
||
/// <para>The pointer that specifies a desired starting address for the region of pages that you want to allocate.</para>
|
||
/// <para>If you are reserving memory, the function rounds this address down to the nearest multiple of the allocation granularity.</para>
|
||
/// <para>
|
||
/// If you are committing memory that is already reserved, the function rounds this address down to the nearest page boundary. To
|
||
/// determine the size of a page and the allocation granularity on the host computer, use the <c>GetSystemInfo</c> function.
|
||
/// </para>
|
||
/// <para>If lpAddress is <c>NULL</c>, the function determines where to allocate the region.</para>
|
||
/// </param>
|
||
/// <param name="dwSize">
|
||
/// <para>The size of the region of memory to be allocated, in bytes.</para>
|
||
/// <para>If lpAddress is <c>NULL</c>, the function rounds dwSize up to the next page boundary.</para>
|
||
/// <para>
|
||
/// If lpAddress is not <c>NULL</c>, the function allocates all pages that contain one or more bytes in the range from lpAddress to .
|
||
/// This means, for example, that a 2-byte range that straddles a page boundary causes the function to allocate both pages.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="flAllocationType">
|
||
/// <para>The type of memory allocation. This parameter must contain one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_COMMIT0x00001000</term>
|
||
/// <term>
|
||
/// Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved memory pages.
|
||
/// The function also guarantees that when the caller later initially accesses the memory, the contents will be zero. Actual physical
|
||
/// pages are not allocated unless/until the virtual addresses are actually accessed.To reserve and commit pages in one step, call
|
||
/// the function with .Attempting to commit a specific address range by specifying MEM_COMMIT without MEM_RESERVE and a non-NULL
|
||
/// lpAddress fails unless the entire range has already been reserved. The resulting error code is ERROR_INVALID_ADDRESS.An attempt
|
||
/// to commit a page that is already committed does not cause the function to fail. This means that you can commit pages without
|
||
/// first determining the current commitment state of each page.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE0x00002000</term>
|
||
/// <term>
|
||
/// Reserves a range of the process's virtual address space without allocating any actual physical storage in memory or in the paging
|
||
/// file on disk.You commit reserved pages by calling the function again with MEM_COMMIT. To reserve and commit pages in one step,
|
||
/// call the function with .Other memory allocation functions, such as malloc and LocalAlloc, cannot use reserved memory until it has
|
||
/// been released.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET0x00080000</term>
|
||
/// <term>
|
||
/// Indicates that data in the memory range specified by lpAddress and dwSize is no longer of interest. The pages should not be read
|
||
/// from or written to the paging file. However, the memory block will be used again later, so it should not be decommitted. This
|
||
/// value cannot be used with any other value.Using this value does not guarantee that the range operated on with MEM_RESET will
|
||
/// contain zeros. If you want the range to contain zeros, decommit the memory and then recommit it.When you use MEM_RESET, the
|
||
/// function ignores the value of fProtect. However, you must still set fProtect to a valid protection value, such as
|
||
/// PAGE_NOACCESS.The function returns an error if you use MEM_RESET and the range of memory is mapped to a file. A shared view is
|
||
/// only acceptable if it is mapped to a paging file.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET_UNDO0x1000000</term>
|
||
/// <term>
|
||
/// MEM_RESET_UNDO should only be called on an address range to which MEM_RESET was successfully applied earlier. It indicates that
|
||
/// the data in the specified memory range specified by lpAddress and dwSize is of interest to the caller and attempts to reverse the
|
||
/// effects of MEM_RESET. If the function succeeds, that means all data in the specified address range is intact. If the function
|
||
/// fails, at least some of the data in the address range has been replaced with zeroes.This value cannot be used with any other
|
||
/// value. If MEM_RESET_UNDO is called on an address range which was not MEM_RESET earlier, the behavior is undefined. When you
|
||
/// specify MEM_RESET, the VirtualAllocExNuma function ignores the value of flProtect. However, you must still set flProtect to a
|
||
/// valid protection value, such as PAGE_NOACCESS.Windows Server 2008 R2, Windows 7, Windows Server 2008 and Windows
|
||
/// Vista: The MEM_RESET_UNDO flag is not supported until Windows 8 and Windows Server 2012.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>This parameter can also specify the following values as indicated.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_LARGE_PAGES0x20000000</term>
|
||
/// <term>
|
||
/// Allocates memory using large page support.The size and alignment must be a multiple of the large-page minimum. To obtain this
|
||
/// value, use the GetLargePageMinimum function.If you specify this value, you must also specify MEM_RESERVE and MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_PHYSICAL0x00400000</term>
|
||
/// <term>
|
||
/// Reserves an address range that can be used to map Address Windowing Extensions (AWE) pages.This value must be used with
|
||
/// MEM_RESERVE and no other values.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_TOP_DOWN0x00100000</term>
|
||
/// <term>Allocates memory at the highest possible address.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="flProtect">
|
||
/// <para>
|
||
/// The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify any one of the
|
||
/// memory protection constants.
|
||
/// </para>
|
||
/// <para>Protection attributes specified when protecting a page cannot conflict with those specified when allocating a page.</para>
|
||
/// </param>
|
||
/// <param name="nndPreferred">
|
||
/// <para>The NUMA node where the physical memory should reside.</para>
|
||
/// <para>
|
||
/// Used only when allocating a new VA region (either committed or reserved). Otherwise this parameter is ignored when the API is
|
||
/// used to commit pages in a region that already exists
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the base address of the allocated region of pages.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// LPVOID WINAPI VirtualAllocExNuma( _In_ HANDLE hProcess, _In_opt_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD
|
||
// flAllocationType, _In_ DWORD flProtect, _In_ DWORD nndPreferred);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366891")]
|
||
public static extern IntPtr VirtualAllocExNuma([In] HPROCESS hProcess, [In] IntPtr lpAddress, SizeT dwSize, MEM_ALLOCATION_TYPE flAllocationType, MEM_PROTECTION flProtect, uint nndPreferred);
|
||
|
||
/// <summary>
|
||
/// Reserves, commits, or changes the state of a region of pages in the virtual address space of the calling process. Memory
|
||
/// allocated by this function is automatically initialized to zero.
|
||
/// </summary>
|
||
/// <param name="BaseAddress">
|
||
/// The starting address of the region to allocate. If the memory is being reserved, the specified address is rounded down to the
|
||
/// nearest multiple of the allocation granularity. If the memory is already reserved and is being committed, the address is rounded
|
||
/// down to the next page boundary. To determine the size of a page and the allocation granularity on the host computer, use the
|
||
/// <c>GetSystemInfo</c> function. If this parameter is <c>NULL</c>, the system determines where to allocate the region.
|
||
/// </param>
|
||
/// <param name="Size">
|
||
/// The size of the region, in bytes. If the BaseAddress parameter is <c>NULL</c>, this value is rounded up to the next page
|
||
/// boundary. Otherwise, the allocated pages include all pages containing one or more bytes in the range from BaseAddress to
|
||
/// BaseAddress+Size. This means that a 2-byte range straddling a page boundary causes both pages to be included in the allocated region.
|
||
/// </param>
|
||
/// <param name="AllocationType">
|
||
/// <para>The type of memory allocation. This parameter must contain one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_COMMIT0x00001000</term>
|
||
/// <term>
|
||
/// Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved memory pages.
|
||
/// The function also guarantees that when the caller later initially accesses the memory, the contents will be zero. Actual physical
|
||
/// pages are not allocated unless/until the virtual addresses are actually accessed.To reserve and commit pages in one step, call
|
||
/// VirtualAllocFromApp with .Attempting to commit a specific address range by specifying MEM_COMMIT without MEM_RESERVE and a
|
||
/// non-NULL BaseAddress fails unless the entire range has already been reserved. The resulting error code is
|
||
/// ERROR_INVALID_ADDRESS.An attempt to commit a page that is already committed does not cause the function to fail. This means that
|
||
/// you can commit pages without first determining the current commitment state of each page.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESERVE0x00002000</term>
|
||
/// <term>
|
||
/// Reserves a range of the process's virtual address space without allocating any actual physical storage in memory or in the paging
|
||
/// file on disk.You can commit reserved pages in subsequent calls to the VirtualAllocFromApp function. To reserve and commit pages
|
||
/// in one step, call VirtualAllocFromApp with MEM_COMMIT | MEM_RESERVE.Other memory allocation functions, such as malloc and
|
||
/// LocalAlloc, cannot use a reserved range of memory until it is released.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET0x00080000</term>
|
||
/// <term>
|
||
/// Indicates that data in the memory range specified by BaseAddress and Size is no longer of interest. The pages should not be read
|
||
/// from or written to the paging file. However, the memory block will be used again later, so it should not be decommitted. This
|
||
/// value cannot be used with any other value.Using this value does not guarantee that the range operated on with MEM_RESET will
|
||
/// contain zeros. If you want the range to contain zeros, decommit the memory and then recommit it.When you specify MEM_RESET, the
|
||
/// VirtualAllocFromApp function ignores the value of Protection. However, you must still set Protection to a valid protection value,
|
||
/// such as PAGE_NOACCESS.VirtualAllocFromApp returns an error if you use MEM_RESET and the range of memory is mapped to a file. A
|
||
/// shared view is only acceptable if it is mapped to a paging file.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RESET_UNDO0x1000000</term>
|
||
/// <term>
|
||
/// MEM_RESET_UNDO should only be called on an address range to which MEM_RESET was successfully applied earlier. It indicates that
|
||
/// the data in the specified memory range specified by BaseAddress and Size is of interest to the caller and attempts to reverse the
|
||
/// effects of MEM_RESET. If the function succeeds, that means all data in the specified address range is intact. If the function
|
||
/// fails, at least some of the data in the address range has been replaced with zeroes.This value cannot be used with any other
|
||
/// value. If MEM_RESET_UNDO is called on an address range which was not MEM_RESET earlier, the behavior is undefined. When you
|
||
/// specify MEM_RESET, the VirtualAllocFromApp function ignores the value of Protection. However, you must still set Protection to a
|
||
/// valid protection value, such as PAGE_NOACCESS.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>This parameter can also specify the following values as indicated.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_LARGE_PAGES0x20000000</term>
|
||
/// <term>
|
||
/// Allocates memory using large page support.The size and alignment must be a multiple of the large-page minimum. To obtain this
|
||
/// value, use the GetLargePageMinimum function.If you specify this value, you must also specify MEM_RESERVE and MEM_COMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_PHYSICAL0x00400000</term>
|
||
/// <term>
|
||
/// Reserves an address range that can be used to map Address Windowing Extensions (AWE) pages.This value must be used with
|
||
/// MEM_RESERVE and no other values.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_TOP_DOWN0x00100000</term>
|
||
/// <term>
|
||
/// Allocates memory at the highest possible address. This can be slower than regular allocations, especially when there are many allocations.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_WRITE_WATCH0x00200000</term>
|
||
/// <term>
|
||
/// Causes the system to track pages that are written to in the allocated region. If you specify this value, you must also specify
|
||
/// MEM_RESERVE.To retrieve the addresses of the pages that have been written to since the region was allocated or the write-tracking
|
||
/// state was reset, call the GetWriteWatch function. To reset the write-tracking state, call GetWriteWatch or ResetWriteWatch. The
|
||
/// write-tracking feature remains enabled for the memory region until the region is freed.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="Protection">
|
||
/// The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify one of the
|
||
/// memory protection constants. The following constants generate an error:
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is the base address of the allocated region of pages.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// PVOID WINAPI VirtualAllocFromApp( _In_opt_ PVOID BaseAddress, _In_ SIZE_T Size, _In_ ULONG AllocationType, _In_ ULONG Protection);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("MemoryApi.h", MSDNShortId = "mt169845")]
|
||
public static extern IntPtr VirtualAllocFromApp([In] IntPtr BaseAddress, SizeT Size, MEM_ALLOCATION_TYPE AllocationType, MEM_PROTECTION Protection);
|
||
|
||
/// <summary>
|
||
/// <para>Releases, decommits, or releases and decommits a region of pages within the virtual address space of the calling process.</para>
|
||
/// <para>To free memory allocated in another process by the <c>VirtualAllocEx</c> function, use the <c>VirtualFreeEx</c> function.</para>
|
||
/// </summary>
|
||
/// <param name="lpAddress">
|
||
/// <para>A pointer to the base address of the region of pages to be freed.</para>
|
||
/// <para>
|
||
/// If the dwFreeType parameter is <c>MEM_RELEASE</c>, this parameter must be the base address returned by the <c>VirtualAlloc</c>
|
||
/// function when the region of pages is reserved.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwSize">
|
||
/// <para>The size of the region of memory to be freed, in bytes.</para>
|
||
/// <para>
|
||
/// If the dwFreeType parameter is <c>MEM_RELEASE</c>, this parameter must be 0 (zero). The function frees the entire region that is
|
||
/// reserved in the initial allocation call to <c>VirtualAlloc</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the dwFreeType parameter is <c>MEM_DECOMMIT</c>, the function decommits all memory pages that contain one or more bytes in the
|
||
/// range from the lpAddress parameter to . This means, for example, that a 2-byte region of memory that straddles a page boundary
|
||
/// causes both pages to be decommitted. If lpAddress is the base address returned by <c>VirtualAlloc</c> and dwSize is 0 (zero), the
|
||
/// function decommits the entire region that is allocated by <c>VirtualAlloc</c>. After that, the entire region is in the reserved state.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwFreeType">
|
||
/// <para>The type of free operation. This parameter can be one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_DECOMMIT0x4000</term>
|
||
/// <term>
|
||
/// Decommits the specified region of committed pages. After the operation, the pages are in the reserved state. The function does
|
||
/// not fail if you attempt to decommit an uncommitted page. This means that you can decommit a range of pages without first
|
||
/// determining the current commitment state.Do not use this value with MEM_RELEASE.The MEM_DECOMMIT value is not supported when the
|
||
/// lpAddress parameter provides the base address for an enclave.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RELEASE0x8000</term>
|
||
/// <term>
|
||
/// Releases the specified region of pages. After this operation, the pages are in the free state. If you specify this value, dwSize
|
||
/// must be 0 (zero), and lpAddress must point to the base address returned by the VirtualAlloc function when the region is reserved.
|
||
/// The function fails if either of these conditions is not met.If any pages in the region are committed currently, the function
|
||
/// first decommits, and then releases them.The function does not fail if you attempt to release pages that are in different states,
|
||
/// some reserved and some committed. This means that you can release a range of pages without first determining the current
|
||
/// commitment state.Do not use this value with MEM_DECOMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI VirtualFree( _In_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD dwFreeType);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366892")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool VirtualFree([In] IntPtr lpAddress, SizeT dwSize, MEM_ALLOCATION_TYPE dwFreeType);
|
||
|
||
/// <summary>
|
||
/// Releases, decommits, or releases and decommits a region of memory within the virtual address space of a specified process.
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// <para>A handle to a process. The function frees memory within the virtual address space of the process.</para>
|
||
/// <para>
|
||
/// The handle must have the <c>PROCESS_VM_OPERATION</c> access right. For more information, see Process Security and Access Rights.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpAddress">
|
||
/// <para>A pointer to the starting address of the region of memory to be freed.</para>
|
||
/// <para>
|
||
/// If the dwFreeType parameter is <c>MEM_RELEASE</c>, lpAddress must be the base address returned by the <c>VirtualAllocEx</c>
|
||
/// function when the region is reserved.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwSize">
|
||
/// <para>The size of the region of memory to free, in bytes.</para>
|
||
/// <para>
|
||
/// If the dwFreeType parameter is <c>MEM_RELEASE</c>, dwSize must be 0 (zero). The function frees the entire region that is reserved
|
||
/// in the initial allocation call to <c>VirtualAllocEx</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// If dwFreeType is <c>MEM_DECOMMIT</c>, the function decommits all memory pages that contain one or more bytes in the range from
|
||
/// the lpAddress parameter to . This means, for example, that a 2-byte region of memory that straddles a page boundary causes both
|
||
/// pages to be decommitted. If lpAddress is the base address returned by <c>VirtualAllocEx</c> and dwSize is 0 (zero), the function
|
||
/// decommits the entire region that is allocated by <c>VirtualAllocEx</c>. After that, the entire region is in the reserved state.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwFreeType">
|
||
/// <para>The type of free operation. This parameter can be one of the following values.</para>
|
||
/// <para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>MEM_DECOMMIT0x4000</term>
|
||
/// <term>
|
||
/// Decommits the specified region of committed pages. After the operation, the pages are in the reserved state. The function does
|
||
/// not fail if you attempt to decommit an uncommitted page. This means that you can decommit a range of pages without first
|
||
/// determining their current commitment state.Do not use this value with MEM_RELEASE.The MEM_DECOMMIT value is not supported when
|
||
/// the lpAddress parameter provides the base address for an enclave.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>MEM_RELEASE0x8000</term>
|
||
/// <term>
|
||
/// Releases the specified region of pages. After the operation, the pages are in the free state. If you specify this value, dwSize
|
||
/// must be 0 (zero), and lpAddress must point to the base address returned by the VirtualAllocEx function when the region is
|
||
/// reserved. The function fails if either of these conditions is not met.If any pages in the region are committed currently, the
|
||
/// function first decommits, and then releases them.The function does not fail if you attempt to release pages that are in different
|
||
/// states, some reserved and some committed. This means that you can release a range of pages without first determining the current
|
||
/// commitment state.Do not use this value with MEM_DECOMMIT.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI VirtualFreeEx( _In_ HANDLE hProcess, _In_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD dwFreeType);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366894")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool VirtualFreeEx([In] HPROCESS hProcess, [In] IntPtr lpAddress, SizeT dwSize, MEM_ALLOCATION_TYPE dwFreeType);
|
||
|
||
/// <summary>
|
||
/// Locks the specified region of the process's virtual address space into physical memory, ensuring that subsequent access to the
|
||
/// region will not incur a page fault.
|
||
/// </summary>
|
||
/// <param name="lpAddress">A pointer to the base address of the region of pages to be locked.</param>
|
||
/// <param name="dwSize">
|
||
/// The size of the region to be locked, in bytes. The region of affected pages includes all pages that contain one or more bytes in
|
||
/// the range from the lpAddress parameter to . This means that a 2-byte range straddling a page boundary causes both pages to be locked.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI VirtualLock( _In_ LPVOID lpAddress, _In_ SIZE_T dwSize);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366895")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool VirtualLock([In] IntPtr lpAddress, SizeT dwSize);
|
||
|
||
/// <summary>
|
||
/// <para>Changes the protection on a region of committed pages in the virtual address space of the calling process.</para>
|
||
/// <para>To change the access protection of any process, use the <c>VirtualProtectEx</c> function.</para>
|
||
/// </summary>
|
||
/// <param name="lpAddress">
|
||
/// <para>
|
||
/// A pointer an address that describes the starting page of the region of pages whose access protection attributes are to be changed.
|
||
/// </para>
|
||
/// <para>
|
||
/// All pages in the specified region must be within the same reserved region allocated when calling the <c>VirtualAlloc</c> or
|
||
/// <c>VirtualAllocEx</c> function using <c>MEM_RESERVE</c>. The pages cannot span adjacent reserved regions that were allocated by
|
||
/// separate calls to <c>VirtualAlloc</c> or <c>VirtualAllocEx</c> using <c>MEM_RESERVE</c>.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwSize">
|
||
/// The size of the region whose access protection attributes are to be changed, in bytes. The region of affected pages includes all
|
||
/// pages containing one or more bytes in the range from the lpAddress parameter to . This means that a 2-byte range straddling a
|
||
/// page boundary causes the protection attributes of both pages to be changed.
|
||
/// </param>
|
||
/// <param name="flNewProtect">
|
||
/// <para>The memory protection option. This parameter can be one of the memory protection constants.</para>
|
||
/// <para>
|
||
/// For mapped views, this value must be compatible with the access protection specified when the view was mapped (see
|
||
/// <c>MapViewOfFile</c>, <c>MapViewOfFileEx</c>, and <c>MapViewOfFileExNuma</c>).
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpflOldProtect">
|
||
/// A pointer to a variable that receives the previous access protection value of the first page in the specified region of pages. If
|
||
/// this parameter is <c>NULL</c> or does not point to a valid variable, the function fails.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI VirtualProtect( _In_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD flNewProtect, _Out_ PDWORD lpflOldProtect);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366898")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool VirtualProtect([In] IntPtr lpAddress, SizeT dwSize, MEM_PROTECTION flNewProtect, [Out] out MEM_PROTECTION lpflOldProtect);
|
||
|
||
/// <summary>Changes the protection on a region of committed pages in the virtual address space of a specified process.</summary>
|
||
/// <param name="hProcess">
|
||
/// A handle to the process whose memory protection is to be changed. The handle must have the <c>PROCESS_VM_OPERATION</c> access
|
||
/// right. For more information, see Process Security and Access Rights.
|
||
/// </param>
|
||
/// <param name="lpAddress">
|
||
/// <para>A pointer to the base address of the region of pages whose access protection attributes are to be changed.</para>
|
||
/// <para>
|
||
/// All pages in the specified region must be within the same reserved region allocated when calling the <c>VirtualAlloc</c> or
|
||
/// <c>VirtualAllocEx</c> function using <c>MEM_RESERVE</c>. The pages cannot span adjacent reserved regions that were allocated by
|
||
/// separate calls to <c>VirtualAlloc</c> or <c>VirtualAllocEx</c> using <c>MEM_RESERVE</c>.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="dwSize">
|
||
/// The size of the region whose access protection attributes are changed, in bytes. The region of affected pages includes all pages
|
||
/// containing one or more bytes in the range from the lpAddress parameter to . This means that a 2-byte range straddling a page
|
||
/// boundary causes the protection attributes of both pages to be changed.
|
||
/// </param>
|
||
/// <param name="flNewProtect">
|
||
/// <para>The memory protection option. This parameter can be one of the memory protection constants.</para>
|
||
/// <para>
|
||
/// For mapped views, this value must be compatible with the access protection specified when the view was mapped (see
|
||
/// <c>MapViewOfFile</c>, <c>MapViewOfFileEx</c>, and <c>MapViewOfFileExNuma</c>).
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpflOldProtect">
|
||
/// A pointer to a variable that receives the previous access protection of the first page in the specified region of pages. If this
|
||
/// parameter is <c>NULL</c> or does not point to a valid variable, the function fails.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI VirtualProtectEx( _In_ HANDLE hProcess, _In_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD flNewProtect, _Out_
|
||
// PDWORD lpflOldProtect);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366899")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool VirtualProtectEx([In] HPROCESS hProcess, [In] IntPtr lpAddress, SizeT dwSize, MEM_PROTECTION flNewProtect, [Out] out MEM_PROTECTION lpflOldProtect);
|
||
|
||
/// <summary>Changes the protection on a region of committed pages in the virtual address space of the calling process.</summary>
|
||
/// <param name="Address">
|
||
/// <para>
|
||
/// A pointer an address that describes the starting page of the region of pages whose access protection attributes are to be changed.
|
||
/// </para>
|
||
/// <para>
|
||
/// All pages in the specified region must be within the same reserved region allocated when calling the <c>VirtualAlloc</c>,
|
||
/// <c>VirtualAllocFromApp</c>, or <c>VirtualAllocEx</c> function using <c>MEM_RESERVE</c>. The pages cannot span adjacent reserved
|
||
/// regions that were allocated by separate calls to <c>VirtualAlloc</c>, <c>VirtualAllocFromApp</c>, or <c>VirtualAllocEx</c> using <c>MEM_RESERVE</c>.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="Size">
|
||
/// The size of the region whose access protection attributes are to be changed, in bytes. The region of affected pages includes all
|
||
/// pages containing one or more bytes in the range from the Address parameter to . This means that a 2-byte range straddling a page
|
||
/// boundary causes the protection attributes of both pages to be changed.
|
||
/// </param>
|
||
/// <param name="NewProtection">
|
||
/// <para>The memory protection option. This parameter can be one of the memory protection constants.</para>
|
||
/// <para>
|
||
/// For mapped views, this value must be compatible with the access protection specified when the view was mapped (see
|
||
/// <c>MapViewOfFile</c>, <c>MapViewOfFileEx</c>, and <c>MapViewOfFileExNuma</c>).
|
||
/// </para>
|
||
/// <para>The following constants generate an error:</para>
|
||
/// <para>The following constants are allowed only for apps that have the <c>codeGeneration</c> capability:</para>
|
||
/// </param>
|
||
/// <param name="OldProtection">
|
||
/// A pointer to a variable that receives the previous access protection value of the first page in the specified region of pages. If
|
||
/// this parameter is <c>NULL</c> or does not point to a valid variable, the function fails.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI VirtualProtectFromApp( _In_ PVOID Address, _In_ SIZE_T Size, _In_ ULONG NewProtection, _Out_ PULONG OldProtection);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("MemoryApi.h", MSDNShortId = "mt169846")]
|
||
public static extern bool VirtualProtectFromApp([In] IntPtr Address, SizeT Size, MEM_PROTECTION NewProtection, [Out] out MEM_PROTECTION OldProtection);
|
||
|
||
/// <summary>
|
||
/// <para>Retrieves information about a range of pages in the virtual address space of the calling process.</para>
|
||
/// <para>
|
||
/// To retrieve information about a range of pages in the address space of another process, use the <c>VirtualQueryEx</c> function.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="lpAddress">
|
||
/// <para>
|
||
/// A pointer to the base address of the region of pages to be queried. This value is rounded down to the next page boundary. To
|
||
/// determine the size of a page on the host computer, use the <c>GetSystemInfo</c> function.
|
||
/// </para>
|
||
/// <para>
|
||
/// If lpAddress specifies an address above the highest memory address accessible to the process, the function fails with <c>ERROR_INVALID_PARAMETER</c>.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpBuffer">
|
||
/// A pointer to a <c>MEMORY_BASIC_INFORMATION</c> structure in which information about the specified page range is returned.
|
||
/// </param>
|
||
/// <param name="dwLength">The size of the buffer pointed to by the lpBuffer parameter, in bytes.</param>
|
||
/// <returns>
|
||
/// <para>The return value is the actual number of bytes returned in the information buffer.</para>
|
||
/// <para>
|
||
/// If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>. Possible error
|
||
/// values include <c>ERROR_INVALID_PARAMETER</c>.
|
||
/// </para>
|
||
/// </returns>
|
||
// SIZE_T WINAPI VirtualQuery( _In_opt_ LPCVOID lpAddress, _Out_ PMEMORY_BASIC_INFORMATION lpBuffer, _In_ SIZE_T dwLength);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366902")]
|
||
public static extern SizeT VirtualQuery([In] IntPtr lpAddress, IntPtr lpBuffer, SizeT dwLength);
|
||
|
||
/// <summary>Retrieves information about a range of pages within the virtual address space of a specified process.</summary>
|
||
/// <param name="hProcess">
|
||
/// A handle to the process whose memory information is queried. The handle must have been opened with the
|
||
/// <c>PROCESS_QUERY_INFORMATION</c> access right, which enables using the handle to read information from the process object. For
|
||
/// more information, see Process Security and Access Rights.
|
||
/// </param>
|
||
/// <param name="lpAddress">
|
||
/// <para>
|
||
/// A pointer to the base address of the region of pages to be queried. This value is rounded down to the next page boundary. To
|
||
/// determine the size of a page on the host computer, use the <c>GetSystemInfo</c> function.
|
||
/// </para>
|
||
/// <para>
|
||
/// If lpAddress specifies an address above the highest memory address accessible to the process, the function fails with <c>ERROR_INVALID_PARAMETER</c>.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="lpBuffer">
|
||
/// A pointer to a <c>MEMORY_BASIC_INFORMATION</c> structure in which information about the specified page range is returned.
|
||
/// </param>
|
||
/// <param name="dwLength">The size of the buffer pointed to by the lpBuffer parameter, in bytes.</param>
|
||
/// <returns>
|
||
/// <para>The return value is the actual number of bytes returned in the information buffer.</para>
|
||
/// <para>
|
||
/// If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>. Possible error
|
||
/// values include <c>ERROR_INVALID_PARAMETER</c>.
|
||
/// </para>
|
||
/// </returns>
|
||
// SIZE_T WINAPI VirtualQueryEx( _In_ HANDLE hProcess, _In_opt_ LPCVOID lpAddress, _Out_ PMEMORY_BASIC_INFORMATION lpBuffer, _In_
|
||
// SIZE_T dwLength);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366907")]
|
||
public static extern SizeT VirtualQueryEx([In] HPROCESS hProcess, [In] IntPtr lpAddress, IntPtr lpBuffer, SizeT dwLength);
|
||
|
||
/// <summary>
|
||
/// Unlocks a specified range of pages in the virtual address space of a process, enabling the system to swap the pages out to the
|
||
/// paging file if necessary.
|
||
/// </summary>
|
||
/// <param name="lpAddress">A pointer to the base address of the region of pages to be unlocked.</param>
|
||
/// <param name="dwSize">
|
||
/// The size of the region being unlocked, in bytes. The region of affected pages includes all pages containing one or more bytes in
|
||
/// the range from the lpAddress parameter to . This means that a 2-byte range straddling a page boundary causes both pages to be unlocked.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
|
||
/// </returns>
|
||
// BOOL WINAPI VirtualUnlock( _In_ LPVOID lpAddress, _In_ SIZE_T dwSize); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366910(v=vs.85).aspx
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "aa366910")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool VirtualUnlock(IntPtr lpAddress, SizeT dwSize);
|
||
|
||
/// <summary>
|
||
/// Writes data to an area of memory in a specified process. The entire area to be written to must be accessible or the operation fails.
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process.
|
||
/// </param>
|
||
/// <param name="lpBaseAddress">
|
||
/// A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies
|
||
/// that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible,
|
||
/// the function fails.
|
||
/// </param>
|
||
/// <param name="lpBuffer">A pointer to the buffer that contains data to be written in the address space of the specified process.</param>
|
||
/// <param name="nSize">The number of bytes to be written to the specified process.</param>
|
||
/// <param name="lpNumberOfBytesWritten">
|
||
/// A pointer to a variable that receives the number of bytes transferred into the specified process. This parameter is optional. If
|
||
/// lpNumberOfBytesWritten is <c>NULL</c>, the parameter is ignored.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>
|
||
/// If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>. The function
|
||
/// fails if the requested write operation crosses into an area of the process that is inaccessible.
|
||
/// </para>
|
||
/// </returns>
|
||
// BOOL WINAPI WriteProcessMemory( _In_ HANDLE hProcess, _In_ LPVOID lpBaseAddress, _In_ LPCVOID lpBuffer, _In_ SIZE_T nSize, _Out_
|
||
// SIZE_T *lpNumberOfBytesWritten);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "ms681674")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool WriteProcessMemory([In] HPROCESS hProcess, [In] IntPtr lpBaseAddress, [In] IntPtr lpBuffer, SizeT nSize, out SizeT lpNumberOfBytesWritten);
|
||
|
||
/// <summary>
|
||
/// Writes data to an area of memory in a specified process. The entire area to be written to must be accessible or the operation fails.
|
||
/// </summary>
|
||
/// <param name="hProcess">
|
||
/// A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process.
|
||
/// </param>
|
||
/// <param name="lpBaseAddress">
|
||
/// A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies
|
||
/// that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible,
|
||
/// the function fails.
|
||
/// </param>
|
||
/// <param name="lpBuffer">A pointer to the buffer that contains data to be written in the address space of the specified process.</param>
|
||
/// <param name="nSize">The number of bytes to be written to the specified process.</param>
|
||
/// <param name="lpNumberOfBytesWritten">
|
||
/// A pointer to a variable that receives the number of bytes transferred into the specified process. This parameter is optional. If
|
||
/// lpNumberOfBytesWritten is <c>NULL</c>, the parameter is ignored.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>
|
||
/// If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>. The function
|
||
/// fails if the requested write operation crosses into an area of the process that is inaccessible.
|
||
/// </para>
|
||
/// </returns>
|
||
// BOOL WINAPI WriteProcessMemory( _In_ HANDLE hProcess, _In_ LPVOID lpBaseAddress, _In_ LPCVOID lpBuffer, _In_ SIZE_T nSize, _Out_
|
||
// SIZE_T *lpNumberOfBytesWritten);
|
||
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("WinBase.h", MSDNShortId = "ms681674")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool WriteProcessMemory([In] HPROCESS hProcess, [In] IntPtr lpBaseAddress, [In] byte[] lpBuffer, SizeT nSize, out SizeT lpNumberOfBytesWritten);
|
||
|
||
/// <summary>Represents information about call targets for Control Flow Guard (CFG).</summary>
|
||
// typedef struct _CFG_CALL_TARGET_INFO { ULONG_PTR Offset; ULONG_PTR Flags;} CFG_CALL_TARGET_INFO, *PCFG_CALL_TARGET_INFO;
|
||
[PInvokeData("Ntmmapi.h", MSDNShortId = "mt219054")]
|
||
public struct CFG_CALL_TARGET_INFO
|
||
{
|
||
/// <summary>
|
||
/// Flags describing the operation to be performed on the address. If <c>CFG_CALL_TARGET_VALID</c> is set, then the address will
|
||
/// be marked valid for CFG. Otherwise, it will be marked an invalid call target.
|
||
/// </summary>
|
||
public UIntPtr Flags;
|
||
|
||
/// <summary>Offset relative to a provided (start) virtual address. This offset should be 16 byte aligned.</summary>
|
||
public UIntPtr Offset;
|
||
}
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Specifies a lowest and highest base address and alignment as part of an extended parameter to a function that manages virtual memory.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// <para>Specifying a <c>MEM_ADDRESS_REQUIREMENTS</c> structure with all fields set to 0 is the same as not specifying one at all.</para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_mem_address_requirements typedef struct
|
||
// _MEM_ADDRESS_REQUIREMENTS { PVOID LowestStartingAddress; PVOID HighestEndingAddress; SIZE_T Alignment; } MEM_ADDRESS_REQUIREMENTS, *PMEM_ADDRESS_REQUIREMENTS;
|
||
[PInvokeData("winnt.h", MSDNShortId = "1CAB4942-F0D2-4A60-9472-4EDF2FC9FA7A")]
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct MEM_ADDRESS_REQUIREMENTS
|
||
{
|
||
/// <summary>
|
||
/// <para>
|
||
/// Specifies the lowest acceptable address. Calling VirtualAlloc2 or MapViewOfFile3, and specifying <c>NULL</c> for
|
||
/// LowestStartingAddress, gives the same behavior as calling VirtualAlloc/MapViewOfFile.
|
||
/// </para>
|
||
/// </summary>
|
||
public IntPtr LowestStartingAddress;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Specifies the highest acceptable address (inclusive). This address must not exceed <c>lpMaximumApplicationAddress</c>
|
||
/// returned by GetSystemInfo. Calling VirtualAlloc2 or MapViewOfFile3, and specifying <c>NULL</c> for HighestEndingAddress,
|
||
/// gives the same behavior as calling VirtualAlloc/MapViewOfFile.
|
||
/// </para>
|
||
/// </summary>
|
||
public IntPtr HighestEndingAddress;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies power-of-2 alignment. Specifying 0 aligns the returned address on the system allocation granularity.</para>
|
||
/// </summary>
|
||
public SizeT Alignment;
|
||
}
|
||
|
||
/// <summary>Represents an extended parameter for a function that manages virtual memory.</summary>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-mem_extended_parameter typedef struct MEM_EXTENDED_PARAMETER {
|
||
// struct { DWORD64 Type : MEM_EXTENDED_PARAMETER_TYPE_BITS; DWORD64 Reserved : 64 - MEM_EXTENDED_PARAMETER_TYPE_BITS; }
|
||
// DUMMYSTRUCTNAME; union { DWORD64 ULong64; PVOID Pointer; SIZE_T Size; HANDLE Handle; DWORD ULong; } DUMMYUNIONNAME; }
|
||
// MEM_EXTENDED_PARAMETER, *PMEM_EXTENDED_PARAMETER;
|
||
[PInvokeData("winnt.h", MSDNShortId = "8D189F7E-83E7-4AF3-9E25-928C66666887")]
|
||
[StructLayout(LayoutKind.Explicit, Pack = 8, Size = 16)]
|
||
public struct MEM_EXTENDED_PARAMETER
|
||
{
|
||
/// <summary>
|
||
/// <para>A MEM_EXTENDED_PARAMETER_TYPE value that indicates the type of the parameter.</para>
|
||
/// <para>
|
||
/// If Type is set to <c>MemExtendedParameterAddressRequirements</c>, then Pointer must be a pointer to a caller-allocated
|
||
/// <see cref="MEM_ADDRESS_REQUIREMENTS"/> structure that specifies the lowest and highest base address and alignment.
|
||
/// </para>
|
||
/// <para>If Type is set to <c>MemExtendedParameterNumaNode</c>, then ULong must be set to the desired node number.</para>
|
||
/// </summary>
|
||
[FieldOffset(0)]
|
||
public MEM_EXTENDED_PARAMETER_TYPE Type;
|
||
|
||
/// <summary>A ULONGLONG value.</summary>
|
||
[FieldOffset(8)] public ulong ULong64;
|
||
|
||
/// <summary>
|
||
/// If Type is set to <c>MemExtendedParameterAddressRequirements</c>, then Pointer must be a pointer to a caller-allocated
|
||
/// MEM_ADDRESS_REQUIREMENTS structure that specifies the lowest and highest base address and alignment.
|
||
/// </summary>
|
||
[FieldOffset(8)] public IntPtr Pointer;
|
||
|
||
/// <summary>A SIZE_T value.</summary>
|
||
[FieldOffset(8)] public SizeT Size;
|
||
|
||
/// <summary>A HANDLE value.</summary>
|
||
[FieldOffset(8)] public IntPtr Handle;
|
||
|
||
/// <summary>If Type is set to <c>MemExtendedParameterNumaNode</c>, then ULong must be set to the desired node number.</summary>
|
||
[FieldOffset(8)] public uint ULong;
|
||
}
|
||
|
||
/// <summary>Specifies a range of memory. This structure is used by the <c>PrefetchVirtualMemory</c> function.</summary>
|
||
// typedef struct _WIN32_MEMORY_RANGE_ENTRY { PVOID VirtualAddress; SIZE_T NumberOfBytes;} WIN32_MEMORY_RANGE_ENTRY, *PWIN32_MEMORY_RANGE_ENTRY;
|
||
[PInvokeData("WinBase.h", MSDNShortId = "hh780544")]
|
||
public struct WIN32_MEMORY_RANGE_ENTRY
|
||
{
|
||
/// <summary></summary>
|
||
public SizeT NumberOfBytes;
|
||
|
||
/// <summary></summary>
|
||
public IntPtr VirtualAddress;
|
||
}
|
||
|
||
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="HSECTION"/> that is disposed using <see cref="CloseHandle"/>.</summary>
|
||
public class SafeHSECTION : SafeKernelHandle
|
||
{
|
||
/// <summary>Initializes a new instance of the <see cref="SafeHSECTION"/> class and assigns an existing handle.</summary>
|
||
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
||
/// <param name="ownsHandle"><see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).</param>
|
||
public SafeHSECTION(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
|
||
|
||
/// <summary>Initializes a new instance of the <see cref="SafeHSECTION"/> class.</summary>
|
||
private SafeHSECTION() : base() { }
|
||
|
||
/// <summary>Performs an implicit conversion from <see cref="SafeHSECTION"/> to <see cref="HSECTION"/>.</summary>
|
||
/// <param name="h">The safe handle instance.</param>
|
||
/// <returns>The result of the conversion.</returns>
|
||
public static implicit operator HSECTION(SafeHSECTION h) => h.handle;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Provides a <see cref="SafeHandle"/> to a memory resource notification object that releases its instance at disposal using CloseHandle.
|
||
/// </summary>
|
||
public class SafeMemoryResourceNotification : SafeSyncHandle
|
||
{
|
||
/// <summary>
|
||
/// Initializes a new instance of the <see cref="SafeMemoryResourceNotification"/> class and assigns an existing handle.
|
||
/// </summary>
|
||
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
||
/// <param name="ownsHandle">
|
||
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
|
||
/// </param>
|
||
public SafeMemoryResourceNotification(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
|
||
}
|
||
}
|
||
} |